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