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