Merge branch 'upstream' of master.kernel.org:/pub/scm/linux/kernel/git/jgarzik/libata-dev
[linux-2.6] / drivers / net / ne.c
1 /* ne.c: A general non-shared-memory NS8390 ethernet driver for linux. */
2 /*
3     Written 1992-94 by Donald Becker.
4
5     Copyright 1993 United States Government as represented by the
6     Director, National Security Agency.
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     The author may be reached as becker@scyld.com, or C/O
12     Scyld Computing Corporation, 410 Severn Ave., Suite 210, Annapolis MD 21403
13
14     This driver should work with many programmed-I/O 8390-based ethernet
15     boards.  Currently it supports the NE1000, NE2000, many clones,
16     and some Cabletron products.
17
18     Changelog:
19
20     Paul Gortmaker      : use ENISR_RDC to monitor Tx PIO uploads, made
21                           sanity checks and bad clone support optional.
22     Paul Gortmaker      : new reset code, reset card after probe at boot.
23     Paul Gortmaker      : multiple card support for module users.
24     Paul Gortmaker      : Support for PCI ne2k clones, similar to lance.c
25     Paul Gortmaker      : Allow users with bad cards to avoid full probe.
26     Paul Gortmaker      : PCI probe changes, more PCI cards supported.
27     rjohnson@analogic.com : Changed init order so an interrupt will only
28     occur after memory is allocated for dev->priv. Deallocated memory
29     last in cleanup_modue()
30     Richard Guenther    : Added support for ISAPnP cards
31     Paul Gortmaker      : Discontinued PCI support - use ne2k-pci.c instead.
32     Hayato Fujiwara     : Add m32r support.
33
34 */
35
36 /* Routines for the NatSemi-based designs (NE[12]000). */
37
38 static const char version1[] =
39 "ne.c:v1.10 9/23/94 Donald Becker (becker@scyld.com)\n";
40 static const char version2[] =
41 "Last modified Nov 1, 2000 by Paul Gortmaker\n";
42
43
44 #include <linux/module.h>
45 #include <linux/kernel.h>
46 #include <linux/errno.h>
47 #include <linux/isapnp.h>
48 #include <linux/init.h>
49 #include <linux/interrupt.h>
50 #include <linux/delay.h>
51 #include <linux/netdevice.h>
52 #include <linux/etherdevice.h>
53
54 #include <asm/system.h>
55 #include <asm/io.h>
56
57 #if defined(CONFIG_TOSHIBA_RBTX4927) || defined(CONFIG_TOSHIBA_RBTX4938)
58 #include <asm/tx4938/rbtx4938.h>
59 #endif
60
61 #include "8390.h"
62
63 #define DRV_NAME "ne"
64
65 /* Some defines that people can play with if so inclined. */
66
67 /* Do we support clones that don't adhere to 14,15 of the SAprom ? */
68 #define SUPPORT_NE_BAD_CLONES
69
70 /* Do we perform extra sanity checks on stuff ? */
71 /* #define NE_SANITY_CHECK */
72
73 /* Do we implement the read before write bugfix ? */
74 /* #define NE_RW_BUGFIX */
75
76 /* Do we have a non std. amount of memory? (in units of 256 byte pages) */
77 /* #define PACKETBUF_MEMSIZE    0x40 */
78
79 /* A zero-terminated list of I/O addresses to be probed at boot. */
80 #ifndef MODULE
81 static unsigned int netcard_portlist[] __initdata = {
82         0x300, 0x280, 0x320, 0x340, 0x360, 0x380, 0
83 };
84 #endif
85
86 static struct isapnp_device_id isapnp_clone_list[] __initdata = {
87         {       ISAPNP_CARD_ID('A','X','E',0x2011),
88                 ISAPNP_VENDOR('A','X','E'), ISAPNP_FUNCTION(0x2011),
89                 (long) "NetGear EA201" },
90         {       ISAPNP_ANY_ID, ISAPNP_ANY_ID,
91                 ISAPNP_VENDOR('E','D','I'), ISAPNP_FUNCTION(0x0216),
92                 (long) "NN NE2000" },
93         {       ISAPNP_ANY_ID, ISAPNP_ANY_ID,
94                 ISAPNP_VENDOR('P','N','P'), ISAPNP_FUNCTION(0x80d6),
95                 (long) "Generic PNP" },
96         { }     /* terminate list */
97 };
98
99 MODULE_DEVICE_TABLE(isapnp, isapnp_clone_list);
100
101 #ifdef SUPPORT_NE_BAD_CLONES
102 /* A list of bad clones that we none-the-less recognize. */
103 static struct { const char *name8, *name16; unsigned char SAprefix[4];}
104 bad_clone_list[] __initdata = {
105     {"DE100", "DE200", {0x00, 0xDE, 0x01,}},
106     {"DE120", "DE220", {0x00, 0x80, 0xc8,}},
107     {"DFI1000", "DFI2000", {'D', 'F', 'I',}}, /* Original, eh?  */
108     {"EtherNext UTP8", "EtherNext UTP16", {0x00, 0x00, 0x79}},
109     {"NE1000","NE2000-invalid", {0x00, 0x00, 0xd8}}, /* Ancient real NE1000. */
110     {"NN1000", "NN2000",  {0x08, 0x03, 0x08}}, /* Outlaw no-name clone. */
111     {"4-DIM8","4-DIM16", {0x00,0x00,0x4d,}},  /* Outlaw 4-Dimension cards. */
112     {"Con-Intl_8", "Con-Intl_16", {0x00, 0x00, 0x24}}, /* Connect Int'nl */
113     {"ET-100","ET-200", {0x00, 0x45, 0x54}}, /* YANG and YA clone */
114     {"COMPEX","COMPEX16",{0x00,0x80,0x48}}, /* Broken ISA Compex cards */
115     {"E-LAN100", "E-LAN200", {0x00, 0x00, 0x5d}}, /* Broken ne1000 clones */
116     {"PCM-4823", "PCM-4823", {0x00, 0xc0, 0x6c}}, /* Broken Advantech MoBo */
117     {"REALTEK", "RTL8019", {0x00, 0x00, 0xe8}}, /* no-name with Realtek chip */
118 #if defined(CONFIG_TOSHIBA_RBTX4927) || defined(CONFIG_TOSHIBA_RBTX4938)
119     {"RBHMA4X00-RTL8019", "RBHMA4X00/RTL8019", {0x00, 0x60, 0x0a}},  /* Toshiba built-in */
120 #endif
121     {"LCS-8834", "LCS-8836", {0x04, 0x04, 0x37}}, /* ShinyNet (SET) */
122     {NULL,}
123 };
124 #endif
125
126 /* ---- No user-serviceable parts below ---- */
127
128 #define NE_BASE  (dev->base_addr)
129 #define NE_CMD          0x00
130 #define NE_DATAPORT     0x10    /* NatSemi-defined port window offset. */
131 #define NE_RESET        0x1f    /* Issue a read to reset, a write to clear. */
132 #define NE_IO_EXTENT    0x20
133
134 #define NE1SM_START_PG  0x20    /* First page of TX buffer */
135 #define NE1SM_STOP_PG   0x40    /* Last page +1 of RX ring */
136 #define NESM_START_PG   0x40    /* First page of TX buffer */
137 #define NESM_STOP_PG    0x80    /* Last page +1 of RX ring */
138
139 #if defined(CONFIG_PLAT_MAPPI)
140 #  define DCR_VAL 0x4b
141 #elif defined(CONFIG_PLAT_OAKS32R)
142 #  define DCR_VAL 0x48
143 #else
144 #  define DCR_VAL 0x49
145 #endif
146
147 static int ne_probe1(struct net_device *dev, int ioaddr);
148 static int ne_probe_isapnp(struct net_device *dev);
149
150 static int ne_open(struct net_device *dev);
151 static int ne_close(struct net_device *dev);
152
153 static void ne_reset_8390(struct net_device *dev);
154 static void ne_get_8390_hdr(struct net_device *dev, struct e8390_pkt_hdr *hdr,
155                           int ring_page);
156 static void ne_block_input(struct net_device *dev, int count,
157                           struct sk_buff *skb, int ring_offset);
158 static void ne_block_output(struct net_device *dev, const int count,
159                 const unsigned char *buf, const int start_page);
160
161 \f
162 /*  Probe for various non-shared-memory ethercards.
163
164    NEx000-clone boards have a Station Address PROM (SAPROM) in the packet
165    buffer memory space.  NE2000 clones have 0x57,0x57 in bytes 0x0e,0x0f of
166    the SAPROM, while other supposed NE2000 clones must be detected by their
167    SA prefix.
168
169    Reading the SAPROM from a word-wide card with the 8390 set in byte-wide
170    mode results in doubled values, which can be detected and compensated for.
171
172    The probe is also responsible for initializing the card and filling
173    in the 'dev' and 'ei_status' structures.
174
175    We use the minimum memory size for some ethercard product lines, iff we can't
176    distinguish models.  You can increase the packet buffer size by setting
177    PACKETBUF_MEMSIZE.  Reported Cabletron packet buffer locations are:
178         E1010   starts at 0x100 and ends at 0x2000.
179         E1010-x starts at 0x100 and ends at 0x8000. ("-x" means "more memory")
180         E2010    starts at 0x100 and ends at 0x4000.
181         E2010-x starts at 0x100 and ends at 0xffff.  */
182
183 static int __init do_ne_probe(struct net_device *dev)
184 {
185         unsigned int base_addr = dev->base_addr;
186 #ifndef MODULE
187         int orig_irq = dev->irq;
188 #endif
189
190         SET_MODULE_OWNER(dev);
191
192         /* First check any supplied i/o locations. User knows best. <cough> */
193         if (base_addr > 0x1ff)  /* Check a single specified location. */
194                 return ne_probe1(dev, base_addr);
195         else if (base_addr != 0)        /* Don't probe at all. */
196                 return -ENXIO;
197
198         /* Then look for any installed ISAPnP clones */
199         if (isapnp_present() && (ne_probe_isapnp(dev) == 0))
200                 return 0;
201
202 #ifndef MODULE
203         /* Last resort. The semi-risky ISA auto-probe. */
204         for (base_addr = 0; netcard_portlist[base_addr] != 0; base_addr++) {
205                 int ioaddr = netcard_portlist[base_addr];
206                 dev->irq = orig_irq;
207                 if (ne_probe1(dev, ioaddr) == 0)
208                         return 0;
209         }
210 #endif
211
212         return -ENODEV;
213 }
214
215 static void cleanup_card(struct net_device *dev)
216 {
217         struct pnp_dev *idev = (struct pnp_dev *)ei_status.priv;
218         if (idev)
219                 pnp_device_detach(idev);
220         free_irq(dev->irq, dev);
221         release_region(dev->base_addr, NE_IO_EXTENT);
222 }
223
224 #ifndef MODULE
225 struct net_device * __init ne_probe(int unit)
226 {
227         struct net_device *dev = alloc_ei_netdev();
228         int err;
229
230         if (!dev)
231                 return ERR_PTR(-ENOMEM);
232
233         sprintf(dev->name, "eth%d", unit);
234         netdev_boot_setup_check(dev);
235
236 #ifdef CONFIG_TOSHIBA_RBTX4938
237         dev->base_addr = 0x07f20280;
238         dev->irq = RBTX4938_RTL_8019_IRQ;
239 #endif
240         err = do_ne_probe(dev);
241         if (err)
242                 goto out;
243         return dev;
244 out:
245         free_netdev(dev);
246         return ERR_PTR(err);
247 }
248 #endif
249
250 static int __init ne_probe_isapnp(struct net_device *dev)
251 {
252         int i;
253
254         for (i = 0; isapnp_clone_list[i].vendor != 0; i++) {
255                 struct pnp_dev *idev = NULL;
256
257                 while ((idev = pnp_find_dev(NULL,
258                                             isapnp_clone_list[i].vendor,
259                                             isapnp_clone_list[i].function,
260                                             idev))) {
261                         /* Avoid already found cards from previous calls */
262                         if (pnp_device_attach(idev) < 0)
263                                 continue;
264                         if (pnp_activate_dev(idev) < 0) {
265                                 pnp_device_detach(idev);
266                                 continue;
267                         }
268                         /* if no io and irq, search for next */
269                         if (!pnp_port_valid(idev, 0) || !pnp_irq_valid(idev, 0)) {
270                                 pnp_device_detach(idev);
271                                 continue;
272                         }
273                         /* found it */
274                         dev->base_addr = pnp_port_start(idev, 0);
275                         dev->irq = pnp_irq(idev, 0);
276                         printk(KERN_INFO "ne.c: ISAPnP reports %s at i/o %#lx, irq %d.\n",
277                                 (char *) isapnp_clone_list[i].driver_data,
278                                 dev->base_addr, dev->irq);
279                         if (ne_probe1(dev, dev->base_addr) != 0) {      /* Shouldn't happen. */
280                                 printk(KERN_ERR "ne.c: Probe of ISAPnP card at %#lx failed.\n", dev->base_addr);
281                                 pnp_device_detach(idev);
282                                 return -ENXIO;
283                         }
284                         ei_status.priv = (unsigned long)idev;
285                         break;
286                 }
287                 if (!idev)
288                         continue;
289                 return 0;
290         }
291
292         return -ENODEV;
293 }
294
295 static int __init ne_probe1(struct net_device *dev, int ioaddr)
296 {
297         int i;
298         unsigned char SA_prom[32];
299         int wordlength = 2;
300         const char *name = NULL;
301         int start_page, stop_page;
302         int neX000, ctron, copam, bad_card;
303         int reg0, ret;
304         static unsigned version_printed;
305
306         if (!request_region(ioaddr, NE_IO_EXTENT, DRV_NAME))
307                 return -EBUSY;
308
309         reg0 = inb_p(ioaddr);
310         if (reg0 == 0xFF) {
311                 ret = -ENODEV;
312                 goto err_out;
313         }
314
315         /* Do a preliminary verification that we have a 8390. */
316         {
317                 int regd;
318                 outb_p(E8390_NODMA+E8390_PAGE1+E8390_STOP, ioaddr + E8390_CMD);
319                 regd = inb_p(ioaddr + 0x0d);
320                 outb_p(0xff, ioaddr + 0x0d);
321                 outb_p(E8390_NODMA+E8390_PAGE0, ioaddr + E8390_CMD);
322                 inb_p(ioaddr + EN0_COUNTER0); /* Clear the counter by reading. */
323                 if (inb_p(ioaddr + EN0_COUNTER0) != 0) {
324                         outb_p(reg0, ioaddr);
325                         outb_p(regd, ioaddr + 0x0d);    /* Restore the old values. */
326                         ret = -ENODEV;
327                         goto err_out;
328                 }
329         }
330
331         if (ei_debug  &&  version_printed++ == 0)
332                 printk(KERN_INFO "%s" KERN_INFO "%s", version1, version2);
333
334         printk(KERN_INFO "NE*000 ethercard probe at %#3x:", ioaddr);
335
336         /* A user with a poor card that fails to ack the reset, or that
337            does not have a valid 0x57,0x57 signature can still use this
338            without having to recompile. Specifying an i/o address along
339            with an otherwise unused dev->mem_end value of "0xBAD" will
340            cause the driver to skip these parts of the probe. */
341
342         bad_card = ((dev->base_addr != 0) && (dev->mem_end == 0xbad));
343
344         /* Reset card. Who knows what dain-bramaged state it was left in. */
345
346         {
347                 unsigned long reset_start_time = jiffies;
348
349                 /* DON'T change these to inb_p/outb_p or reset will fail on clones. */
350                 outb(inb(ioaddr + NE_RESET), ioaddr + NE_RESET);
351
352                 while ((inb_p(ioaddr + EN0_ISR) & ENISR_RESET) == 0)
353                 if (jiffies - reset_start_time > 2*HZ/100) {
354                         if (bad_card) {
355                                 printk(" (warning: no reset ack)");
356                                 break;
357                         } else {
358                                 printk(" not found (no reset ack).\n");
359                                 ret = -ENODEV;
360                                 goto err_out;
361                         }
362                 }
363
364                 outb_p(0xff, ioaddr + EN0_ISR);         /* Ack all intr. */
365         }
366
367         /* Read the 16 bytes of station address PROM.
368            We must first initialize registers, similar to NS8390_init(eifdev, 0).
369            We can't reliably read the SAPROM address without this.
370            (I learned the hard way!). */
371         {
372                 struct {unsigned char value, offset; } program_seq[] =
373                 {
374                         {E8390_NODMA+E8390_PAGE0+E8390_STOP, E8390_CMD}, /* Select page 0*/
375                         {0x48,  EN0_DCFG},      /* Set byte-wide (0x48) access. */
376                         {0x00,  EN0_RCNTLO},    /* Clear the count regs. */
377                         {0x00,  EN0_RCNTHI},
378                         {0x00,  EN0_IMR},       /* Mask completion irq. */
379                         {0xFF,  EN0_ISR},
380                         {E8390_RXOFF, EN0_RXCR},        /* 0x20  Set to monitor */
381                         {E8390_TXOFF, EN0_TXCR},        /* 0x02  and loopback mode. */
382                         {32,    EN0_RCNTLO},
383                         {0x00,  EN0_RCNTHI},
384                         {0x00,  EN0_RSARLO},    /* DMA starting at 0x0000. */
385                         {0x00,  EN0_RSARHI},
386                         {E8390_RREAD+E8390_START, E8390_CMD},
387                 };
388
389                 for (i = 0; i < sizeof(program_seq)/sizeof(program_seq[0]); i++)
390                         outb_p(program_seq[i].value, ioaddr + program_seq[i].offset);
391
392         }
393         for(i = 0; i < 32 /*sizeof(SA_prom)*/; i+=2) {
394                 SA_prom[i] = inb(ioaddr + NE_DATAPORT);
395                 SA_prom[i+1] = inb(ioaddr + NE_DATAPORT);
396                 if (SA_prom[i] != SA_prom[i+1])
397                         wordlength = 1;
398         }
399
400         if (wordlength == 2)
401         {
402                 for (i = 0; i < 16; i++)
403                         SA_prom[i] = SA_prom[i+i];
404                 /* We must set the 8390 for word mode. */
405                 outb_p(DCR_VAL, ioaddr + EN0_DCFG);
406                 start_page = NESM_START_PG;
407                 stop_page = NESM_STOP_PG;
408         } else {
409                 start_page = NE1SM_START_PG;
410                 stop_page = NE1SM_STOP_PG;
411         }
412
413 #if  defined(CONFIG_PLAT_MAPPI) || defined(CONFIG_PLAT_OAKS32R)
414         neX000 = ((SA_prom[14] == 0x57  &&  SA_prom[15] == 0x57)
415                 || (SA_prom[14] == 0x42 && SA_prom[15] == 0x42));
416 #else
417         neX000 = (SA_prom[14] == 0x57  &&  SA_prom[15] == 0x57);
418 #endif
419         ctron =  (SA_prom[0] == 0x00 && SA_prom[1] == 0x00 && SA_prom[2] == 0x1d);
420         copam =  (SA_prom[14] == 0x49 && SA_prom[15] == 0x00);
421
422         /* Set up the rest of the parameters. */
423         if (neX000 || bad_card || copam) {
424                 name = (wordlength == 2) ? "NE2000" : "NE1000";
425         }
426         else if (ctron)
427         {
428                 name = (wordlength == 2) ? "Ctron-8" : "Ctron-16";
429                 start_page = 0x01;
430                 stop_page = (wordlength == 2) ? 0x40 : 0x20;
431         }
432         else
433         {
434 #ifdef SUPPORT_NE_BAD_CLONES
435                 /* Ack!  Well, there might be a *bad* NE*000 clone there.
436                    Check for total bogus addresses. */
437                 for (i = 0; bad_clone_list[i].name8; i++)
438                 {
439                         if (SA_prom[0] == bad_clone_list[i].SAprefix[0] &&
440                                 SA_prom[1] == bad_clone_list[i].SAprefix[1] &&
441                                 SA_prom[2] == bad_clone_list[i].SAprefix[2])
442                         {
443                                 if (wordlength == 2)
444                                 {
445                                         name = bad_clone_list[i].name16;
446                                 } else {
447                                         name = bad_clone_list[i].name8;
448                                 }
449                                 break;
450                         }
451                 }
452                 if (bad_clone_list[i].name8 == NULL)
453                 {
454                         printk(" not found (invalid signature %2.2x %2.2x).\n",
455                                 SA_prom[14], SA_prom[15]);
456                         ret = -ENXIO;
457                         goto err_out;
458                 }
459 #else
460                 printk(" not found.\n");
461                 ret = -ENXIO;
462                 goto err_out;
463 #endif
464         }
465
466         if (dev->irq < 2)
467         {
468                 unsigned long cookie = probe_irq_on();
469                 outb_p(0x50, ioaddr + EN0_IMR); /* Enable one interrupt. */
470                 outb_p(0x00, ioaddr + EN0_RCNTLO);
471                 outb_p(0x00, ioaddr + EN0_RCNTHI);
472                 outb_p(E8390_RREAD+E8390_START, ioaddr); /* Trigger it... */
473                 mdelay(10);             /* wait 10ms for interrupt to propagate */
474                 outb_p(0x00, ioaddr + EN0_IMR);                 /* Mask it again. */
475                 dev->irq = probe_irq_off(cookie);
476                 if (ei_debug > 2)
477                         printk(" autoirq is %d\n", dev->irq);
478         } else if (dev->irq == 2)
479                 /* Fixup for users that don't know that IRQ 2 is really IRQ 9,
480                    or don't know which one to set. */
481                 dev->irq = 9;
482
483         if (! dev->irq) {
484                 printk(" failed to detect IRQ line.\n");
485                 ret = -EAGAIN;
486                 goto err_out;
487         }
488
489         /* Snarf the interrupt now.  There's no point in waiting since we cannot
490            share and the board will usually be enabled. */
491         ret = request_irq(dev->irq, ei_interrupt, 0, name, dev);
492         if (ret) {
493                 printk (" unable to get IRQ %d (errno=%d).\n", dev->irq, ret);
494                 goto err_out;
495         }
496
497         dev->base_addr = ioaddr;
498
499 #ifdef CONFIG_PLAT_MAPPI
500         outb_p(E8390_NODMA + E8390_PAGE1 + E8390_STOP,
501                 ioaddr + E8390_CMD); /* 0x61 */
502         for (i = 0 ; i < ETHER_ADDR_LEN ; i++) {
503                 dev->dev_addr[i] = SA_prom[i]
504                         = inb_p(ioaddr + EN1_PHYS_SHIFT(i));
505                 printk(" %2.2x", SA_prom[i]);
506         }
507 #else
508         for(i = 0; i < ETHER_ADDR_LEN; i++) {
509                 printk(" %2.2x", SA_prom[i]);
510                 dev->dev_addr[i] = SA_prom[i];
511         }
512 #endif
513
514         printk("\n%s: %s found at %#x, using IRQ %d.\n",
515                 dev->name, name, ioaddr, dev->irq);
516
517         ei_status.name = name;
518         ei_status.tx_start_page = start_page;
519         ei_status.stop_page = stop_page;
520 #if defined(CONFIG_TOSHIBA_RBTX4927) || defined(CONFIG_TOSHIBA_RBTX4938)
521         wordlength = 1;
522 #endif
523
524 #ifdef CONFIG_PLAT_OAKS32R
525         ei_status.word16 = 0;
526 #else
527         ei_status.word16 = (wordlength == 2);
528 #endif
529
530         ei_status.rx_start_page = start_page + TX_PAGES;
531 #ifdef PACKETBUF_MEMSIZE
532          /* Allow the packet buffer size to be overridden by know-it-alls. */
533         ei_status.stop_page = ei_status.tx_start_page + PACKETBUF_MEMSIZE;
534 #endif
535
536         ei_status.reset_8390 = &ne_reset_8390;
537         ei_status.block_input = &ne_block_input;
538         ei_status.block_output = &ne_block_output;
539         ei_status.get_8390_hdr = &ne_get_8390_hdr;
540         ei_status.priv = 0;
541         dev->open = &ne_open;
542         dev->stop = &ne_close;
543 #ifdef CONFIG_NET_POLL_CONTROLLER
544         dev->poll_controller = ei_poll;
545 #endif
546         NS8390_init(dev, 0);
547
548         ret = register_netdev(dev);
549         if (ret)
550                 goto out_irq;
551         return 0;
552
553 out_irq:
554         free_irq(dev->irq, dev);
555 err_out:
556         release_region(ioaddr, NE_IO_EXTENT);
557         return ret;
558 }
559
560 static int ne_open(struct net_device *dev)
561 {
562         ei_open(dev);
563         return 0;
564 }
565
566 static int ne_close(struct net_device *dev)
567 {
568         if (ei_debug > 1)
569                 printk(KERN_DEBUG "%s: Shutting down ethercard.\n", dev->name);
570         ei_close(dev);
571         return 0;
572 }
573
574 /* Hard reset the card.  This used to pause for the same period that a
575    8390 reset command required, but that shouldn't be necessary. */
576
577 static void ne_reset_8390(struct net_device *dev)
578 {
579         unsigned long reset_start_time = jiffies;
580
581         if (ei_debug > 1)
582                 printk(KERN_DEBUG "resetting the 8390 t=%ld...", jiffies);
583
584         /* DON'T change these to inb_p/outb_p or reset will fail on clones. */
585         outb(inb(NE_BASE + NE_RESET), NE_BASE + NE_RESET);
586
587         ei_status.txing = 0;
588         ei_status.dmaing = 0;
589
590         /* This check _should_not_ be necessary, omit eventually. */
591         while ((inb_p(NE_BASE+EN0_ISR) & ENISR_RESET) == 0)
592                 if (jiffies - reset_start_time > 2*HZ/100) {
593                         printk(KERN_WARNING "%s: ne_reset_8390() did not complete.\n", dev->name);
594                         break;
595                 }
596         outb_p(ENISR_RESET, NE_BASE + EN0_ISR); /* Ack intr. */
597 }
598
599 /* Grab the 8390 specific header. Similar to the block_input routine, but
600    we don't need to be concerned with ring wrap as the header will be at
601    the start of a page, so we optimize accordingly. */
602
603 static void ne_get_8390_hdr(struct net_device *dev, struct e8390_pkt_hdr *hdr, int ring_page)
604 {
605         int nic_base = dev->base_addr;
606
607         /* This *shouldn't* happen. If it does, it's the last thing you'll see */
608
609         if (ei_status.dmaing)
610         {
611                 printk(KERN_EMERG "%s: DMAing conflict in ne_get_8390_hdr "
612                         "[DMAstat:%d][irqlock:%d].\n",
613                         dev->name, ei_status.dmaing, ei_status.irqlock);
614                 return;
615         }
616
617         ei_status.dmaing |= 0x01;
618         outb_p(E8390_NODMA+E8390_PAGE0+E8390_START, nic_base+ NE_CMD);
619         outb_p(sizeof(struct e8390_pkt_hdr), nic_base + EN0_RCNTLO);
620         outb_p(0, nic_base + EN0_RCNTHI);
621         outb_p(0, nic_base + EN0_RSARLO);               /* On page boundary */
622         outb_p(ring_page, nic_base + EN0_RSARHI);
623         outb_p(E8390_RREAD+E8390_START, nic_base + NE_CMD);
624
625         if (ei_status.word16)
626                 insw(NE_BASE + NE_DATAPORT, hdr, sizeof(struct e8390_pkt_hdr)>>1);
627         else
628                 insb(NE_BASE + NE_DATAPORT, hdr, sizeof(struct e8390_pkt_hdr));
629
630         outb_p(ENISR_RDC, nic_base + EN0_ISR);  /* Ack intr. */
631         ei_status.dmaing &= ~0x01;
632
633         le16_to_cpus(&hdr->count);
634 }
635
636 /* Block input and output, similar to the Crynwr packet driver.  If you
637    are porting to a new ethercard, look at the packet driver source for hints.
638    The NEx000 doesn't share the on-board packet memory -- you have to put
639    the packet out through the "remote DMA" dataport using outb. */
640
641 static void ne_block_input(struct net_device *dev, int count, struct sk_buff *skb, int ring_offset)
642 {
643 #ifdef NE_SANITY_CHECK
644         int xfer_count = count;
645 #endif
646         int nic_base = dev->base_addr;
647         char *buf = skb->data;
648
649         /* This *shouldn't* happen. If it does, it's the last thing you'll see */
650         if (ei_status.dmaing)
651         {
652                 printk(KERN_EMERG "%s: DMAing conflict in ne_block_input "
653                         "[DMAstat:%d][irqlock:%d].\n",
654                         dev->name, ei_status.dmaing, ei_status.irqlock);
655                 return;
656         }
657         ei_status.dmaing |= 0x01;
658         outb_p(E8390_NODMA+E8390_PAGE0+E8390_START, nic_base+ NE_CMD);
659         outb_p(count & 0xff, nic_base + EN0_RCNTLO);
660         outb_p(count >> 8, nic_base + EN0_RCNTHI);
661         outb_p(ring_offset & 0xff, nic_base + EN0_RSARLO);
662         outb_p(ring_offset >> 8, nic_base + EN0_RSARHI);
663         outb_p(E8390_RREAD+E8390_START, nic_base + NE_CMD);
664         if (ei_status.word16)
665         {
666                 insw(NE_BASE + NE_DATAPORT,buf,count>>1);
667                 if (count & 0x01)
668                 {
669                         buf[count-1] = inb(NE_BASE + NE_DATAPORT);
670 #ifdef NE_SANITY_CHECK
671                         xfer_count++;
672 #endif
673                 }
674         } else {
675                 insb(NE_BASE + NE_DATAPORT, buf, count);
676         }
677
678 #ifdef NE_SANITY_CHECK
679         /* This was for the ALPHA version only, but enough people have
680            been encountering problems so it is still here.  If you see
681            this message you either 1) have a slightly incompatible clone
682            or 2) have noise/speed problems with your bus. */
683
684         if (ei_debug > 1)
685         {
686                 /* DMA termination address check... */
687                 int addr, tries = 20;
688                 do {
689                         /* DON'T check for 'inb_p(EN0_ISR) & ENISR_RDC' here
690                            -- it's broken for Rx on some cards! */
691                         int high = inb_p(nic_base + EN0_RSARHI);
692                         int low = inb_p(nic_base + EN0_RSARLO);
693                         addr = (high << 8) + low;
694                         if (((ring_offset + xfer_count) & 0xff) == low)
695                                 break;
696                 } while (--tries > 0);
697                 if (tries <= 0)
698                         printk(KERN_WARNING "%s: RX transfer address mismatch,"
699                                 "%#4.4x (expected) vs. %#4.4x (actual).\n",
700                                 dev->name, ring_offset + xfer_count, addr);
701         }
702 #endif
703         outb_p(ENISR_RDC, nic_base + EN0_ISR);  /* Ack intr. */
704         ei_status.dmaing &= ~0x01;
705 }
706
707 static void ne_block_output(struct net_device *dev, int count,
708                 const unsigned char *buf, const int start_page)
709 {
710         int nic_base = NE_BASE;
711         unsigned long dma_start;
712 #ifdef NE_SANITY_CHECK
713         int retries = 0;
714 #endif
715
716         /* Round the count up for word writes.  Do we need to do this?
717            What effect will an odd byte count have on the 8390?
718            I should check someday. */
719
720         if (ei_status.word16 && (count & 0x01))
721                 count++;
722
723         /* This *shouldn't* happen. If it does, it's the last thing you'll see */
724         if (ei_status.dmaing)
725         {
726                 printk(KERN_EMERG "%s: DMAing conflict in ne_block_output."
727                         "[DMAstat:%d][irqlock:%d]\n",
728                         dev->name, ei_status.dmaing, ei_status.irqlock);
729                 return;
730         }
731         ei_status.dmaing |= 0x01;
732         /* We should already be in page 0, but to be safe... */
733         outb_p(E8390_PAGE0+E8390_START+E8390_NODMA, nic_base + NE_CMD);
734
735 #ifdef NE_SANITY_CHECK
736 retry:
737 #endif
738
739 #ifdef NE8390_RW_BUGFIX
740         /* Handle the read-before-write bug the same way as the
741            Crynwr packet driver -- the NatSemi method doesn't work.
742            Actually this doesn't always work either, but if you have
743            problems with your NEx000 this is better than nothing! */
744
745         outb_p(0x42, nic_base + EN0_RCNTLO);
746         outb_p(0x00,   nic_base + EN0_RCNTHI);
747         outb_p(0x42, nic_base + EN0_RSARLO);
748         outb_p(0x00, nic_base + EN0_RSARHI);
749         outb_p(E8390_RREAD+E8390_START, nic_base + NE_CMD);
750         /* Make certain that the dummy read has occurred. */
751         udelay(6);
752 #endif
753
754         outb_p(ENISR_RDC, nic_base + EN0_ISR);
755
756         /* Now the normal output. */
757         outb_p(count & 0xff, nic_base + EN0_RCNTLO);
758         outb_p(count >> 8,   nic_base + EN0_RCNTHI);
759         outb_p(0x00, nic_base + EN0_RSARLO);
760         outb_p(start_page, nic_base + EN0_RSARHI);
761
762         outb_p(E8390_RWRITE+E8390_START, nic_base + NE_CMD);
763         if (ei_status.word16) {
764                 outsw(NE_BASE + NE_DATAPORT, buf, count>>1);
765         } else {
766                 outsb(NE_BASE + NE_DATAPORT, buf, count);
767         }
768
769         dma_start = jiffies;
770
771 #ifdef NE_SANITY_CHECK
772         /* This was for the ALPHA version only, but enough people have
773            been encountering problems so it is still here. */
774
775         if (ei_debug > 1)
776         {
777                 /* DMA termination address check... */
778                 int addr, tries = 20;
779                 do {
780                         int high = inb_p(nic_base + EN0_RSARHI);
781                         int low = inb_p(nic_base + EN0_RSARLO);
782                         addr = (high << 8) + low;
783                         if ((start_page << 8) + count == addr)
784                                 break;
785                 } while (--tries > 0);
786
787                 if (tries <= 0)
788                 {
789                         printk(KERN_WARNING "%s: Tx packet transfer address mismatch,"
790                                 "%#4.4x (expected) vs. %#4.4x (actual).\n",
791                                 dev->name, (start_page << 8) + count, addr);
792                         if (retries++ == 0)
793                                 goto retry;
794                 }
795         }
796 #endif
797
798         while ((inb_p(nic_base + EN0_ISR) & ENISR_RDC) == 0)
799                 if (jiffies - dma_start > 2*HZ/100) {           /* 20ms */
800                         printk(KERN_WARNING "%s: timeout waiting for Tx RDC.\n", dev->name);
801                         ne_reset_8390(dev);
802                         NS8390_init(dev,1);
803                         break;
804                 }
805
806         outb_p(ENISR_RDC, nic_base + EN0_ISR);  /* Ack intr. */
807         ei_status.dmaing &= ~0x01;
808         return;
809 }
810
811 \f
812 #ifdef MODULE
813 #define MAX_NE_CARDS    4       /* Max number of NE cards per module */
814 static struct net_device *dev_ne[MAX_NE_CARDS];
815 static int io[MAX_NE_CARDS];
816 static int irq[MAX_NE_CARDS];
817 static int bad[MAX_NE_CARDS];   /* 0xbad = bad sig or no reset ack */
818
819 module_param_array(io, int, NULL, 0);
820 module_param_array(irq, int, NULL, 0);
821 module_param_array(bad, int, NULL, 0);
822 MODULE_PARM_DESC(io, "I/O base address(es),required");
823 MODULE_PARM_DESC(irq, "IRQ number(s)");
824 MODULE_PARM_DESC(bad, "Accept card(s) with bad signatures");
825 MODULE_DESCRIPTION("NE1000/NE2000 ISA/PnP Ethernet driver");
826 MODULE_LICENSE("GPL");
827
828 /* This is set up so that no ISA autoprobe takes place. We can't guarantee
829 that the ne2k probe is the last 8390 based probe to take place (as it
830 is at boot) and so the probe will get confused by any other 8390 cards.
831 ISA device autoprobes on a running machine are not recommended anyway. */
832
833 int init_module(void)
834 {
835         int this_dev, found = 0;
836
837         for (this_dev = 0; this_dev < MAX_NE_CARDS; this_dev++) {
838                 struct net_device *dev = alloc_ei_netdev();
839                 if (!dev)
840                         break;
841                 dev->irq = irq[this_dev];
842                 dev->mem_end = bad[this_dev];
843                 dev->base_addr = io[this_dev];
844                 if (do_ne_probe(dev) == 0) {
845                         dev_ne[found++] = dev;
846                         continue;
847                 }
848                 free_netdev(dev);
849                 if (found)
850                         break;
851                 if (io[this_dev] != 0)
852                         printk(KERN_WARNING "ne.c: No NE*000 card found at i/o = %#x\n", io[this_dev]);
853                 else
854                         printk(KERN_NOTICE "ne.c: You must supply \"io=0xNNN\" value(s) for ISA cards.\n");
855                 return -ENXIO;
856         }
857         if (found)
858                 return 0;
859         return -ENODEV;
860 }
861
862 void cleanup_module(void)
863 {
864         int this_dev;
865
866         for (this_dev = 0; this_dev < MAX_NE_CARDS; this_dev++) {
867                 struct net_device *dev = dev_ne[this_dev];
868                 if (dev) {
869                         unregister_netdev(dev);
870                         cleanup_card(dev);
871                         free_netdev(dev);
872                 }
873         }
874 }
875 #endif /* MODULE */