usbnet: fix skb traversing races during unlink(v2)
[linux-2.6.git] / drivers / net / es3210.c
1 /*
2         es3210.c
3
4         Linux driver for Racal-Interlan ES3210 EISA Network Adapter
5
6         Copyright (C) 1996, 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) The existing myriad of Linux 8390 drivers written by Donald Becker.
14
15         2) Once again Russ Nelson's asm packet driver provided additional info.
16
17         3) Info for getting IRQ and sh-mem gleaned from the EISA cfg files.
18            Too bad it doesn't work -- see below.
19
20         The ES3210 is an EISA shared memory NS8390 implementation. Note
21         that all memory copies to/from the board must be 32bit transfers.
22         Which rules out using eth_io_copy_and_sum() in this driver.
23
24         Apparently there are two slightly different revisions of the
25         card, since there are two distinct EISA cfg files (!rii0101.cfg
26         and !rii0102.cfg) One has media select in the cfg file and the
27         other doesn't. Hopefully this will work with either.
28
29         That is about all I can tell you about it, having never actually
30         even seen one of these cards. :)  Try http://www.interlan.com
31         if you want more info.
32
33         Thanks go to Mark Salazar for testing v0.02 of this driver.
34
35         Bugs, to-fix, etc:
36
37         1) The EISA cfg ports that are *supposed* to have the IRQ and shared
38            mem values just read 0xff all the time. Hrrmpf. Apparently the
39            same happens with the packet driver as the code for reading
40            these registers is disabled there. In the meantime, boot with:
41            ether=<IRQ>,0,0x<shared_mem_addr>,eth0 to override the IRQ and
42            shared memory detection. (The i/o port detection is okay.)
43
44         2) Module support currently untested. Probably works though.
45
46 */
47
48 static const char version[] =
49         "es3210.c: Driver revision v0.03, 14/09/96\n";
50
51 #include <linux/module.h>
52 #include <linux/eisa.h>
53 #include <linux/kernel.h>
54 #include <linux/errno.h>
55 #include <linux/string.h>
56 #include <linux/init.h>
57 #include <linux/interrupt.h>
58 #include <linux/netdevice.h>
59 #include <linux/etherdevice.h>
60
61 #include <asm/io.h>
62 #include <asm/system.h>
63
64 #include "8390.h"
65
66 static int es_probe1(struct net_device *dev, int ioaddr);
67
68 static void es_reset_8390(struct net_device *dev);
69
70 static void es_get_8390_hdr(struct net_device *dev, struct e8390_pkt_hdr *hdr, int ring_page);
71 static void es_block_input(struct net_device *dev, int count, struct sk_buff *skb, int ring_offset);
72 static void es_block_output(struct net_device *dev, int count, const unsigned char *buf, int start_page);
73
74 #define ES_START_PG     0x00    /* First page of TX buffer              */
75 #define ES_STOP_PG      0x40    /* Last page +1 of RX ring              */
76
77 #define ES_IO_EXTENT    0x37    /* The cfg file says 0xc90 -> 0xcc7     */
78 #define ES_ID_PORT      0xc80   /* Same for all EISA cards              */
79 #define ES_SA_PROM      0xc90   /* Start of e'net addr.                 */
80 #define ES_RESET_PORT   0xc84   /* From the packet driver source        */
81 #define ES_NIC_OFFSET   0xca0   /* Hello, the 8390 is *here*            */
82
83 #define ES_ADDR0        0x02    /* 3 byte vendor prefix                 */
84 #define ES_ADDR1        0x07
85 #define ES_ADDR2        0x01
86
87 /*
88  * Two card revisions. EISA ID's are always rev. minor, rev. major,, and
89  * then the three vendor letters stored in 5 bits each, with an "a" = 1.
90  * For eg: "rii" = 10010 01001 01001 = 0x4929, which is how the EISA
91  * config utility determines automagically what config file(s) to use.
92  */
93 #define ES_EISA_ID1     0x01012949      /* !rii0101.cfg                 */
94 #define ES_EISA_ID2     0x02012949      /* !rii0102.cfg                 */
95
96 #define ES_CFG1         0xcc0   /* IOPORT(1) --> IOPORT(6) in cfg file  */
97 #define ES_CFG2         0xcc1
98 #define ES_CFG3         0xcc2
99 #define ES_CFG4         0xcc3
100 #define ES_CFG5         0xcc4
101 #define ES_CFG6         0xc84   /* NB: 0xc84 is also "reset" port.      */
102
103 /*
104  *      You can OR any of the following bits together and assign it
105  *      to ES_DEBUG to get verbose driver info during operation.
106  *      Some of these don't do anything yet.
107  */
108
109 #define ES_D_PROBE      0x01
110 #define ES_D_RX_PKT     0x02
111 #define ES_D_TX_PKT     0x04
112 #define ED_D_IRQ        0x08
113
114 #define ES_DEBUG        0
115
116 static unsigned char lo_irq_map[] __initdata = {3, 4, 5, 6, 7, 9, 10};
117 static unsigned char hi_irq_map[] __initdata = {11, 12, 0, 14, 0, 0, 0, 15};
118
119 /*
120  *      Probe for the card. The best way is to read the EISA ID if it
121  *      is known. Then we check the prefix of the station address
122  *      PROM for a match against the Racal-Interlan assigned value.
123  */
124
125 static int __init do_es_probe(struct net_device *dev)
126 {
127         unsigned short ioaddr = dev->base_addr;
128         int irq = dev->irq;
129         int mem_start = dev->mem_start;
130
131         if (ioaddr > 0x1ff)             /* Check a single specified location. */
132                 return es_probe1(dev, ioaddr);
133         else if (ioaddr > 0)            /* Don't probe at all. */
134                 return -ENXIO;
135
136         if (!EISA_bus) {
137 #if ES_DEBUG & ES_D_PROBE
138                 printk("es3210.c: Not EISA bus. Not probing high ports.\n");
139 #endif
140                 return -ENXIO;
141         }
142
143         /* EISA spec allows for up to 16 slots, but 8 is typical. */
144         for (ioaddr = 0x1000; ioaddr < 0x9000; ioaddr += 0x1000) {
145                 if (es_probe1(dev, ioaddr) == 0)
146                         return 0;
147                 dev->irq = irq;
148                 dev->mem_start = mem_start;
149         }
150
151         return -ENODEV;
152 }
153
154 #ifndef MODULE
155 struct net_device * __init es_probe(int unit)
156 {
157         struct net_device *dev = alloc_ei_netdev();
158         int err;
159
160         if (!dev)
161                 return ERR_PTR(-ENOMEM);
162
163         sprintf(dev->name, "eth%d", unit);
164         netdev_boot_setup_check(dev);
165
166         err = do_es_probe(dev);
167         if (err)
168                 goto out;
169         return dev;
170 out:
171         free_netdev(dev);
172         return ERR_PTR(err);
173 }
174 #endif
175
176 static int __init es_probe1(struct net_device *dev, int ioaddr)
177 {
178         int i, retval;
179         unsigned long eisa_id;
180
181         if (!request_region(ioaddr + ES_SA_PROM, ES_IO_EXTENT, "es3210"))
182                 return -ENODEV;
183
184 #if ES_DEBUG & ES_D_PROBE
185         printk("es3210.c: probe at %#x, ID %#8x\n", ioaddr, inl(ioaddr + ES_ID_PORT));
186         printk("es3210.c: config regs: %#x %#x %#x %#x %#x %#x\n",
187                 inb(ioaddr + ES_CFG1), inb(ioaddr + ES_CFG2), inb(ioaddr + ES_CFG3),
188                 inb(ioaddr + ES_CFG4), inb(ioaddr + ES_CFG5), inb(ioaddr + ES_CFG6));
189 #endif
190
191 /*      Check the EISA ID of the card. */
192         eisa_id = inl(ioaddr + ES_ID_PORT);
193         if ((eisa_id != ES_EISA_ID1) && (eisa_id != ES_EISA_ID2)) {
194                 retval = -ENODEV;
195                 goto out;
196         }
197
198         for (i = 0; i < ETHER_ADDR_LEN ; i++)
199                 dev->dev_addr[i] = inb(ioaddr + ES_SA_PROM + i);
200
201 /*      Check the Racal vendor ID as well. */
202         if (dev->dev_addr[0] != ES_ADDR0 ||
203             dev->dev_addr[1] != ES_ADDR1 ||
204             dev->dev_addr[2] != ES_ADDR2) {
205                 printk("es3210.c: card not found %pM (invalid_prefix).\n",
206                        dev->dev_addr);
207                 retval = -ENODEV;
208                 goto out;
209         }
210
211         printk("es3210.c: ES3210 rev. %ld at %#x, node %pM",
212                eisa_id>>24, ioaddr, dev->dev_addr);
213
214         /* Snarf the interrupt now. */
215         if (dev->irq == 0) {
216                 unsigned char hi_irq = inb(ioaddr + ES_CFG2) & 0x07;
217                 unsigned char lo_irq = inb(ioaddr + ES_CFG1) & 0xfe;
218
219                 if (hi_irq != 0) {
220                         dev->irq = hi_irq_map[hi_irq - 1];
221                 } else {
222                         int i = 0;
223                         while (lo_irq > (1<<i)) i++;
224                         dev->irq = lo_irq_map[i];
225                 }
226                 printk(" using IRQ %d", dev->irq);
227 #if ES_DEBUG & ES_D_PROBE
228                 printk("es3210.c: hi_irq %#x, lo_irq %#x, dev->irq = %d\n",
229                                         hi_irq, lo_irq, dev->irq);
230 #endif
231         } else {
232                 if (dev->irq == 2)
233                         dev->irq = 9;                   /* Doh! */
234                 printk(" assigning IRQ %d", dev->irq);
235         }
236
237         if (request_irq(dev->irq, ei_interrupt, 0, "es3210", dev)) {
238                 printk (" unable to get IRQ %d.\n", dev->irq);
239                 retval = -EAGAIN;
240                 goto out;
241         }
242
243         if (dev->mem_start == 0) {
244                 unsigned char mem_enabled = inb(ioaddr + ES_CFG2) & 0xc0;
245                 unsigned char mem_bits = inb(ioaddr + ES_CFG3) & 0x07;
246
247                 if (mem_enabled != 0x80) {
248                         printk(" shared mem disabled - giving up\n");
249                         retval = -ENXIO;
250                         goto out1;
251                 }
252                 dev->mem_start = 0xC0000 + mem_bits*0x4000;
253                 printk(" using ");
254         } else {
255                 printk(" assigning ");
256         }
257
258         ei_status.mem = ioremap(dev->mem_start, (ES_STOP_PG - ES_START_PG)*256);
259         if (!ei_status.mem) {
260                 printk("ioremap failed - giving up\n");
261                 retval = -ENXIO;
262                 goto out1;
263         }
264
265         dev->mem_end = dev->mem_start + (ES_STOP_PG - ES_START_PG)*256;
266
267         printk("mem %#lx-%#lx\n", dev->mem_start, dev->mem_end-1);
268
269 #if ES_DEBUG & ES_D_PROBE
270         if (inb(ioaddr + ES_CFG5))
271                 printk("es3210: Warning - DMA channel enabled, but not used here.\n");
272 #endif
273         /* Note, point at the 8390, and not the card... */
274         dev->base_addr = ioaddr + ES_NIC_OFFSET;
275
276         ei_status.name = "ES3210";
277         ei_status.tx_start_page = ES_START_PG;
278         ei_status.rx_start_page = ES_START_PG + TX_PAGES;
279         ei_status.stop_page = ES_STOP_PG;
280         ei_status.word16 = 1;
281
282         if (ei_debug > 0)
283                 printk(version);
284
285         ei_status.reset_8390 = &es_reset_8390;
286         ei_status.block_input = &es_block_input;
287         ei_status.block_output = &es_block_output;
288         ei_status.get_8390_hdr = &es_get_8390_hdr;
289
290         dev->netdev_ops = &ei_netdev_ops;
291         NS8390_init(dev, 0);
292
293         retval = register_netdev(dev);
294         if (retval)
295                 goto out1;
296         return 0;
297 out1:
298         free_irq(dev->irq, dev);
299 out:
300         release_region(ioaddr + ES_SA_PROM, ES_IO_EXTENT);
301         return retval;
302 }
303
304 /*
305  *      Reset as per the packet driver method. Judging by the EISA cfg
306  *      file, this just toggles the "Board Enable" bits (bit 2 and 0).
307  */
308
309 static void es_reset_8390(struct net_device *dev)
310 {
311         unsigned short ioaddr = dev->base_addr;
312         unsigned long end;
313
314         outb(0x04, ioaddr + ES_RESET_PORT);
315         if (ei_debug > 1) printk("%s: resetting the ES3210...", dev->name);
316
317         end = jiffies + 2*HZ/100;
318         while ((signed)(end - jiffies) > 0) continue;
319
320         ei_status.txing = 0;
321         outb(0x01, ioaddr + ES_RESET_PORT);
322         if (ei_debug > 1) printk("reset done\n");
323 }
324
325 /*
326  *      Note: In the following three functions is the implicit assumption
327  *      that the associated memcpy will only use "rep; movsl" as long as
328  *      we keep the counts as some multiple of doublewords. This is a
329  *      requirement of the hardware, and also prevents us from using
330  *      eth_io_copy_and_sum() since we can't guarantee it will limit
331  *      itself to doubleword access.
332  */
333
334 /*
335  *      Grab the 8390 specific header. Similar to the block_input routine, but
336  *      we don't need to be concerned with ring wrap as the header will be at
337  *      the start of a page, so we optimize accordingly. (A single doubleword.)
338  */
339
340 static void
341 es_get_8390_hdr(struct net_device *dev, struct e8390_pkt_hdr *hdr, int ring_page)
342 {
343         void __iomem *hdr_start = ei_status.mem + ((ring_page - ES_START_PG)<<8);
344         memcpy_fromio(hdr, hdr_start, sizeof(struct e8390_pkt_hdr));
345         hdr->count = (hdr->count + 3) & ~3;     /* Round up allocation. */
346 }
347
348 /*
349  *      Block input and output are easy on shared memory ethercards, the only
350  *      complication is when the ring buffer wraps. The count will already
351  *      be rounded up to a doubleword value via es_get_8390_hdr() above.
352  */
353
354 static void es_block_input(struct net_device *dev, int count, struct sk_buff *skb,
355                                                   int ring_offset)
356 {
357         void __iomem *xfer_start = ei_status.mem + ring_offset - ES_START_PG*256;
358
359         if (ring_offset + count > ES_STOP_PG*256) {
360                 /* Packet wraps over end of ring buffer. */
361                 int semi_count = ES_STOP_PG*256 - ring_offset;
362                 memcpy_fromio(skb->data, xfer_start, semi_count);
363                 count -= semi_count;
364                 memcpy_fromio(skb->data + semi_count, ei_status.mem, count);
365         } else {
366                 /* Packet is in one chunk. */
367                 memcpy_fromio(skb->data, xfer_start, count);
368         }
369 }
370
371 static void es_block_output(struct net_device *dev, int count,
372                                 const unsigned char *buf, int start_page)
373 {
374         void __iomem *shmem = ei_status.mem + ((start_page - ES_START_PG)<<8);
375
376         count = (count + 3) & ~3;     /* Round up to doubleword */
377         memcpy_toio(shmem, buf, count);
378 }
379
380 #ifdef MODULE
381 #define MAX_ES_CARDS    4       /* Max number of ES3210 cards per module */
382 #define NAMELEN         8       /* # of chars for storing dev->name */
383 static struct net_device *dev_es3210[MAX_ES_CARDS];
384 static int io[MAX_ES_CARDS];
385 static int irq[MAX_ES_CARDS];
386 static int mem[MAX_ES_CARDS];
387
388 module_param_array(io, int, NULL, 0);
389 module_param_array(irq, int, NULL, 0);
390 module_param_array(mem, int, NULL, 0);
391 MODULE_PARM_DESC(io, "I/O base address(es)");
392 MODULE_PARM_DESC(irq, "IRQ number(s)");
393 MODULE_PARM_DESC(mem, "memory base address(es)");
394 MODULE_DESCRIPTION("Racal-Interlan ES3210 EISA ethernet driver");
395 MODULE_LICENSE("GPL");
396
397 int __init init_module(void)
398 {
399         struct net_device *dev;
400         int this_dev, found = 0;
401
402         for (this_dev = 0; this_dev < MAX_ES_CARDS; this_dev++) {
403                 if (io[this_dev] == 0 && this_dev != 0)
404                         break;
405                 dev = alloc_ei_netdev();
406                 if (!dev)
407                         break;
408                 dev->irq = irq[this_dev];
409                 dev->base_addr = io[this_dev];
410                 dev->mem_start = mem[this_dev];
411                 if (do_es_probe(dev) == 0) {
412                         dev_es3210[found++] = dev;
413                         continue;
414                 }
415                 free_netdev(dev);
416                 printk(KERN_WARNING "es3210.c: No es3210 card found (i/o = 0x%x).\n", io[this_dev]);
417                 break;
418         }
419         if (found)
420                 return 0;
421         return -ENXIO;
422 }
423
424 static void cleanup_card(struct net_device *dev)
425 {
426         free_irq(dev->irq, dev);
427         release_region(dev->base_addr, ES_IO_EXTENT);
428         iounmap(ei_status.mem);
429 }
430
431 void __exit
432 cleanup_module(void)
433 {
434         int this_dev;
435
436         for (this_dev = 0; this_dev < MAX_ES_CARDS; this_dev++) {
437                 struct net_device *dev = dev_es3210[this_dev];
438                 if (dev) {
439                         unregister_netdev(dev);
440                         cleanup_card(dev);
441                         free_netdev(dev);
442                 }
443         }
444 }
445 #endif /* MODULE */
446