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