← Back to branch summary

~ubuntu-branches/ubuntu/precise/linux-lowlatency/precise

« back to all changes in this revision

Viewing changes to drivers/net/ethernet/8390/ne3210.c

  • Committer: Package Import Robot
  • Author(s): Alessio Igor Bogani
  • Date: 2011-10-26 11:13:05 UTC
  • Revision ID: package-import@ubuntu.com-20111026111305-tz023xykf0i6eosh
Tags: upstream-3.2.0
Import upstream version 3.2.0

Show diffs side-by-side

added added

removed removed

Lines of Context:
drivers/net/ethernet/8390/ne3210.c
 
1
/*
 
2
        ne3210.c
 
3
 
 
4
        Linux driver for Novell NE3210 EISA Network Adapter
 
5
 
 
6
        Copyright (C) 1998, Paul Gortmaker.
 
7
 
 
8
        This software may be used and distributed according to the terms
 
9
        of the GNU General Public License, incorporated herein by reference.
 
10
 
 
11
        Information and Code Sources:
 
12
 
 
13
        1) Based upon my other EISA 8390 drivers (lne390, es3210, smc-ultra32)
 
14
        2) The existing myriad of other Linux 8390 drivers by Donald Becker.
 
15
        3) Info for getting IRQ and sh-mem gleaned from the EISA cfg file
 
16
 
 
17
        The NE3210 is an EISA shared memory NS8390 implementation.  Shared
 
18
        memory address > 1MB should work with this driver.
 
19
 
 
20
        Note that the .cfg file (3/11/93, v1.0) has AUI and BNC switched
 
21
        around (or perhaps there are some defective/backwards cards ???)
 
22
 
 
23
        This driver WILL NOT WORK FOR THE NE3200 - it is completely different
 
24
        and does not use an 8390 at all.
 
25
 
 
26
        Updated to EISA probing API 5/2003 by Marc Zyngier.
 
27
*/
 
28
 
 
29
#include <linux/module.h>
 
30
#include <linux/eisa.h>
 
31
#include <linux/kernel.h>
 
32
#include <linux/errno.h>
 
33
#include <linux/string.h>
 
34
#include <linux/delay.h>
 
35
#include <linux/init.h>
 
36
#include <linux/interrupt.h>
 
37
#include <linux/netdevice.h>
 
38
#include <linux/etherdevice.h>
 
39
#include <linux/mm.h>
 
40
 
 
41
#include <asm/io.h>
 
42
#include <asm/system.h>
 
43
 
 
44
#include "8390.h"
 
45
 
 
46
#define DRV_NAME "ne3210"
 
47
 
 
48
static void ne3210_reset_8390(struct net_device *dev);
 
49
 
 
50
static void ne3210_get_8390_hdr(struct net_device *dev, struct e8390_pkt_hdr *hdr, int ring_page);
 
51
static void ne3210_block_input(struct net_device *dev, int count, struct sk_buff *skb, int ring_offset);
 
52
static void ne3210_block_output(struct net_device *dev, int count, const unsigned char *buf, const int start_page);
 
53
 
 
54
#define NE3210_START_PG         0x00    /* First page of TX buffer      */
 
55
#define NE3210_STOP_PG          0x80    /* Last page +1 of RX ring      */
 
56
 
 
57
#define NE3210_IO_EXTENT        0x20
 
58
#define NE3210_SA_PROM          0x16    /* Start of e'net addr.         */
 
59
#define NE3210_RESET_PORT       0xc84
 
60
#define NE3210_NIC_OFFSET       0x00    /* Hello, the 8390 is *here*    */
 
61
 
 
62
#define NE3210_ADDR0            0x00    /* 3 byte vendor prefix         */
 
63
#define NE3210_ADDR1            0x00
 
64
#define NE3210_ADDR2            0x1b
 
65
 
 
66
#define NE3210_CFG1             0xc84   /* NB: 0xc84 is also "reset" port. */
 
67
#define NE3210_CFG2             0xc90
 
68
#define NE3210_CFG_EXTENT       (NE3210_CFG2 - NE3210_CFG1 + 1)
 
69
 
 
70
/*
 
71
 *      You can OR any of the following bits together and assign it
 
72
 *      to NE3210_DEBUG to get verbose driver info during operation.
 
73
 *      Currently only the probe one is implemented.
 
74
 */
 
75
 
 
76
#define NE3210_D_PROBE  0x01
 
77
#define NE3210_D_RX_PKT 0x02
 
78
#define NE3210_D_TX_PKT 0x04
 
79
#define NE3210_D_IRQ    0x08
 
80
 
 
81
#define NE3210_DEBUG    0x0
 
82
 
 
83
static unsigned char irq_map[] __initdata = {15, 12, 11, 10, 9, 7, 5, 3};
 
84
static unsigned int shmem_map[] __initdata = {0xff0, 0xfe0, 0xfff0, 0xd8, 0xffe0, 0xffc0, 0xd0, 0x0};
 
85
static const char *ifmap[] __initdata = {"UTP", "?", "BNC", "AUI"};
 
86
static int ifmap_val[] __initdata = {
 
87
                IF_PORT_10BASET,
 
88
                IF_PORT_UNKNOWN,
 
89
                IF_PORT_10BASE2,
 
90
                IF_PORT_AUI,
 
91
};
 
92
 
 
93
static int __init ne3210_eisa_probe (struct device *device)
 
94
{
 
95
        unsigned long ioaddr, phys_mem;
 
96
        int i, retval, port_index;
 
97
        struct eisa_device *edev = to_eisa_device (device);
 
98
        struct net_device *dev;
 
99
 
 
100
        /* Allocate dev->priv and fill in 8390 specific dev fields. */
 
101
        if (!(dev = alloc_ei_netdev ())) {
 
102
                printk ("ne3210.c: unable to allocate memory for dev!\n");
 
103
                return -ENOMEM;
 
104
        }
 
105
 
 
106
        SET_NETDEV_DEV(dev, device);
 
107
        dev_set_drvdata(device, dev);
 
108
        ioaddr = edev->base_addr;
 
109
 
 
110
        if (!request_region(ioaddr, NE3210_IO_EXTENT, DRV_NAME)) {
 
111
                retval = -EBUSY;
 
112
                goto out;
 
113
        }
 
114
 
 
115
        if (!request_region(ioaddr + NE3210_CFG1,
 
116
                            NE3210_CFG_EXTENT, DRV_NAME)) {
 
117
                retval = -EBUSY;
 
118
                goto out1;
 
119
        }
 
120
 
 
121
#if NE3210_DEBUG & NE3210_D_PROBE
 
122
        printk("ne3210-debug: probe at %#x, ID %s\n", ioaddr, edev->id.sig);
 
123
        printk("ne3210-debug: config regs: %#x %#x\n",
 
124
                inb(ioaddr + NE3210_CFG1), inb(ioaddr + NE3210_CFG2));
 
125
#endif
 
126
 
 
127
        port_index = inb(ioaddr + NE3210_CFG2) >> 6;
 
128
        for(i = 0; i < ETHER_ADDR_LEN; i++)
 
129
                dev->dev_addr[i] = inb(ioaddr + NE3210_SA_PROM + i);
 
130
        printk("ne3210.c: NE3210 in EISA slot %d, media: %s, addr: %pM.\n",
 
131
                edev->slot, ifmap[port_index], dev->dev_addr);
 
132
 
 
133
        /* Snarf the interrupt now. CFG file has them all listed as `edge' with share=NO */
 
134
        dev->irq = irq_map[(inb(ioaddr + NE3210_CFG2) >> 3) & 0x07];
 
135
        printk("ne3210.c: using IRQ %d, ", dev->irq);
 
136
 
 
137
        retval = request_irq(dev->irq, ei_interrupt, 0, DRV_NAME, dev);
 
138
        if (retval) {
 
139
                printk (" unable to get IRQ %d.\n", dev->irq);
 
140
                goto out2;
 
141
        }
 
142
 
 
143
        phys_mem = shmem_map[inb(ioaddr + NE3210_CFG2) & 0x07] * 0x1000;
 
144
 
 
145
        /*
 
146
           BEWARE!! Some dain-bramaged EISA SCUs will allow you to put
 
147
           the card mem within the region covered by `normal' RAM  !!!
 
148
        */
 
149
        if (phys_mem > 1024*1024) {     /* phys addr > 1MB */
 
150
                if (phys_mem < virt_to_phys(high_memory)) {
 
151
                        printk(KERN_CRIT "ne3210.c: Card RAM overlaps with normal memory!!!\n");
 
152
                        printk(KERN_CRIT "ne3210.c: Use EISA SCU to set card memory below 1MB,\n");
 
153
                        printk(KERN_CRIT "ne3210.c: or to an address above 0x%llx.\n",
 
154
                                (u64)virt_to_phys(high_memory));
 
155
                        printk(KERN_CRIT "ne3210.c: Driver NOT installed.\n");
 
156
                        retval = -EINVAL;
 
157
                        goto out3;
 
158
                }
 
159
        }
 
160
 
 
161
        if (!request_mem_region (phys_mem, NE3210_STOP_PG*0x100, DRV_NAME)) {
 
162
                printk ("ne3210.c: Unable to request shared memory at physical address %#lx\n",
 
163
                        phys_mem);
 
164
                goto out3;
 
165
        }
 
166
 
 
167
        printk("%dkB memory at physical address %#lx\n",
 
168
               NE3210_STOP_PG/4, phys_mem);
 
169
 
 
170
        ei_status.mem = ioremap(phys_mem, NE3210_STOP_PG*0x100);
 
171
        if (!ei_status.mem) {
 
172
                printk(KERN_ERR "ne3210.c: Unable to remap card memory !!\n");
 
173
                printk(KERN_ERR "ne3210.c: Driver NOT installed.\n");
 
174
                retval = -EAGAIN;
 
175
                goto out4;
 
176
        }
 
177
        printk("ne3210.c: remapped %dkB card memory to virtual address %p\n",
 
178
               NE3210_STOP_PG/4, ei_status.mem);
 
179
        dev->mem_start = (unsigned long)ei_status.mem;
 
180
        dev->mem_end = dev->mem_start + (NE3210_STOP_PG - NE3210_START_PG)*256;
 
181
 
 
182
        /* The 8390 offset is zero for the NE3210 */
 
183
        dev->base_addr = ioaddr;
 
184
 
 
185
        ei_status.name = "NE3210";
 
186
        ei_status.tx_start_page = NE3210_START_PG;
 
187
        ei_status.rx_start_page = NE3210_START_PG + TX_PAGES;
 
188
        ei_status.stop_page = NE3210_STOP_PG;
 
189
        ei_status.word16 = 1;
 
190
        ei_status.priv = phys_mem;
 
191
 
 
192
        if (ei_debug > 0)
 
193
                printk("ne3210 loaded.\n");
 
194
 
 
195
        ei_status.reset_8390 = &ne3210_reset_8390;
 
196
        ei_status.block_input = &ne3210_block_input;
 
197
        ei_status.block_output = &ne3210_block_output;
 
198
        ei_status.get_8390_hdr = &ne3210_get_8390_hdr;
 
199
 
 
200
        dev->netdev_ops = &ei_netdev_ops;
 
201
 
 
202
        dev->if_port = ifmap_val[port_index];
 
203
 
 
204
        if ((retval = register_netdev (dev)))
 
205
                goto out5;
 
206
 
 
207
        NS8390_init(dev, 0);
 
208
        return 0;
 
209
 
 
210
 out5:
 
211
        iounmap(ei_status.mem);
 
212
 out4:
 
213
        release_mem_region (phys_mem, NE3210_STOP_PG*0x100);
 
214
 out3:
 
215
        free_irq (dev->irq, dev);
 
216
 out2:
 
217
        release_region (ioaddr + NE3210_CFG1, NE3210_CFG_EXTENT);
 
218
 out1:
 
219
        release_region (ioaddr, NE3210_IO_EXTENT);
 
220
 out:
 
221
        free_netdev (dev);
 
222
 
 
223
        return retval;
 
224
}
 
225
 
 
226
static int __devexit ne3210_eisa_remove (struct device *device)
 
227
{
 
228
        struct net_device  *dev    = dev_get_drvdata(device);
 
229
        unsigned long       ioaddr = to_eisa_device (device)->base_addr;
 
230
 
 
231
        unregister_netdev (dev);
 
232
        iounmap(ei_status.mem);
 
233
        release_mem_region (ei_status.priv, NE3210_STOP_PG*0x100);
 
234
        free_irq (dev->irq, dev);
 
235
        release_region (ioaddr + NE3210_CFG1, NE3210_CFG_EXTENT);
 
236
        release_region (ioaddr, NE3210_IO_EXTENT);
 
237
        free_netdev (dev);
 
238
 
 
239
        return 0;
 
240
}
 
241
 
 
242
/*
 
243
 *      Reset by toggling the "Board Enable" bits (bit 2 and 0).
 
244
 */
 
245
 
 
246
static void ne3210_reset_8390(struct net_device *dev)
 
247
{
 
248
        unsigned short ioaddr = dev->base_addr;
 
249
 
 
250
        outb(0x04, ioaddr + NE3210_RESET_PORT);
 
251
        if (ei_debug > 1) printk("%s: resetting the NE3210...", dev->name);
 
252
 
 
253
        mdelay(2);
 
254
 
 
255
        ei_status.txing = 0;
 
256
        outb(0x01, ioaddr + NE3210_RESET_PORT);
 
257
        if (ei_debug > 1) printk("reset done\n");
 
258
}
 
259
 
 
260
/*
 
261
 *      Note: In the following three functions is the implicit assumption
 
262
 *      that the associated memcpy will only use "rep; movsl" as long as
 
263
 *      we keep the counts as some multiple of doublewords. This is a
 
264
 *      requirement of the hardware, and also prevents us from using
 
265
 *      eth_io_copy_and_sum() since we can't guarantee it will limit
 
266
 *      itself to doubleword access.
 
267
 */
 
268
 
 
269
/*
 
270
 *      Grab the 8390 specific header. Similar to the block_input routine, but
 
271
 *      we don't need to be concerned with ring wrap as the header will be at
 
272
 *      the start of a page, so we optimize accordingly. (A single doubleword.)
 
273
 */
 
274
 
 
275
static void
 
276
ne3210_get_8390_hdr(struct net_device *dev, struct e8390_pkt_hdr *hdr, int ring_page)
 
277
{
 
278
        void __iomem *hdr_start = ei_status.mem + ((ring_page - NE3210_START_PG)<<8);
 
279
        memcpy_fromio(hdr, hdr_start, sizeof(struct e8390_pkt_hdr));
 
280
        hdr->count = (hdr->count + 3) & ~3;     /* Round up allocation. */
 
281
}
 
282
 
 
283
/*
 
284
 *      Block input and output are easy on shared memory ethercards, the only
 
285
 *      complication is when the ring buffer wraps. The count will already
 
286
 *      be rounded up to a doubleword value via ne3210_get_8390_hdr() above.
 
287
 */
 
288
 
 
289
static void ne3210_block_input(struct net_device *dev, int count, struct sk_buff *skb,
 
290
                                                  int ring_offset)
 
291
{
 
292
        void __iomem *start = ei_status.mem + ring_offset - NE3210_START_PG*256;
 
293
 
 
294
        if (ring_offset + count > NE3210_STOP_PG*256) {
 
295
                /* Packet wraps over end of ring buffer. */
 
296
                int semi_count = NE3210_STOP_PG*256 - ring_offset;
 
297
                memcpy_fromio(skb->data, start, semi_count);
 
298
                count -= semi_count;
 
299
                memcpy_fromio(skb->data + semi_count,
 
300
                                ei_status.mem + TX_PAGES*256, count);
 
301
        } else {
 
302
                /* Packet is in one chunk. */
 
303
                memcpy_fromio(skb->data, start, count);
 
304
        }
 
305
}
 
306
 
 
307
static void ne3210_block_output(struct net_device *dev, int count,
 
308
                                const unsigned char *buf, int start_page)
 
309
{
 
310
        void __iomem *shmem = ei_status.mem + ((start_page - NE3210_START_PG)<<8);
 
311
 
 
312
        count = (count + 3) & ~3;     /* Round up to doubleword */
 
313
        memcpy_toio(shmem, buf, count);
 
314
}
 
315
 
 
316
static struct eisa_device_id ne3210_ids[] = {
 
317
        { "EGL0101" },
 
318
        { "NVL1801" },
 
319
        { "" },
 
320
};
 
321
MODULE_DEVICE_TABLE(eisa, ne3210_ids);
 
322
 
 
323
static struct eisa_driver ne3210_eisa_driver = {
 
324
        .id_table = ne3210_ids,
 
325
        .driver   = {
 
326
                .name   = "ne3210",
 
327
                .probe  = ne3210_eisa_probe,
 
328
                .remove = __devexit_p (ne3210_eisa_remove),
 
329
        },
 
330
};
 
331
 
 
332
MODULE_DESCRIPTION("NE3210 EISA Ethernet driver");
 
333
MODULE_LICENSE("GPL");
 
334
MODULE_DEVICE_TABLE(eisa, ne3210_ids);
 
335
 
 
336
static int ne3210_init(void)
 
337
{
 
338
        return eisa_driver_register (&ne3210_eisa_driver);
 
339
}
 
340
 
 
341
static void ne3210_cleanup(void)
 
342
{
 
343
        eisa_driver_unregister (&ne3210_eisa_driver);
 
344
}
 
345
 
 
346
module_init (ne3210_init);
 
347
module_exit (ne3210_cleanup);