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