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