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