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