xref: /openbmc/linux/drivers/net/ethernet/8390/ne.c (revision 067dee65)
1 // SPDX-License-Identifier: GPL-1.0+
2 /* ne.c: A general non-shared-memory NS8390 ethernet driver for linux. */
3 /*
4     Written 1992-94 by Donald Becker.
5 
6     Copyright 1993 United States Government as represented by the
7     Director, National Security Agency.
8 
9     The author may be reached as becker@scyld.com, or C/O
10     Scyld Computing Corporation, 410 Severn Ave., Suite 210, Annapolis MD 21403
11 
12     This driver should work with many programmed-I/O 8390-based ethernet
13     boards.  Currently it supports the NE1000, NE2000, many clones,
14     and some Cabletron products.
15 
16     Changelog:
17 
18     Paul Gortmaker	: use ENISR_RDC to monitor Tx PIO uploads, made
19 			  sanity checks and bad clone support optional.
20     Paul Gortmaker	: new reset code, reset card after probe at boot.
21     Paul Gortmaker	: multiple card support for module users.
22     Paul Gortmaker	: Support for PCI ne2k clones, similar to lance.c
23     Paul Gortmaker	: Allow users with bad cards to avoid full probe.
24     Paul Gortmaker	: PCI probe changes, more PCI cards supported.
25     rjohnson@analogic.com : Changed init order so an interrupt will only
26     occur after memory is allocated for dev->priv. Deallocated memory
27     last in cleanup_modue()
28     Richard Guenther    : Added support for ISAPnP cards
29     Paul Gortmaker	: Discontinued PCI support - use ne2k-pci.c instead.
30     Hayato Fujiwara	: Add m32r support.
31 
32 */
33 
34 /* Routines for the NatSemi-based designs (NE[12]000). */
35 
36 static const char version1[] =
37 "ne.c:v1.10 9/23/94 Donald Becker (becker@scyld.com)\n";
38 static const char version2[] =
39 "Last modified Nov 1, 2000 by Paul Gortmaker\n";
40 
41 
42 #include <linux/module.h>
43 #include <linux/kernel.h>
44 #include <linux/errno.h>
45 #include <linux/isapnp.h>
46 #include <linux/init.h>
47 #include <linux/interrupt.h>
48 #include <linux/delay.h>
49 #include <linux/netdevice.h>
50 #include <linux/etherdevice.h>
51 #include <linux/jiffies.h>
52 #include <linux/platform_device.h>
53 #include <net/Space.h>
54 
55 #include <asm/io.h>
56 
57 #include "8390.h"
58 
59 #define DRV_NAME "ne"
60 
61 /* Some defines that people can play with if so inclined. */
62 
63 /* Do we support clones that don't adhere to 14,15 of the SAprom ? */
64 #define SUPPORT_NE_BAD_CLONES
65 /* 0xbad = bad sig or no reset ack */
66 #define BAD 0xbad
67 
68 #define MAX_NE_CARDS	4	/* Max number of NE cards per module */
69 static struct platform_device *pdev_ne[MAX_NE_CARDS];
70 static int io[MAX_NE_CARDS];
71 static int irq[MAX_NE_CARDS];
72 static int bad[MAX_NE_CARDS];
73 static u32 ne_msg_enable;
74 
75 #ifdef MODULE
76 module_param_hw_array(io, int, ioport, NULL, 0);
77 module_param_hw_array(irq, int, irq, NULL, 0);
78 module_param_array(bad, int, NULL, 0);
79 module_param_named(msg_enable, ne_msg_enable, uint, 0444);
80 MODULE_PARM_DESC(io, "I/O base address(es),required");
81 MODULE_PARM_DESC(irq, "IRQ number(s)");
82 MODULE_PARM_DESC(bad, "Accept card(s) with bad signatures");
83 MODULE_PARM_DESC(msg_enable, "Debug message level (see linux/netdevice.h for bitmap)");
84 MODULE_DESCRIPTION("NE1000/NE2000 ISA/PnP Ethernet driver");
85 MODULE_LICENSE("GPL");
86 #endif /* MODULE */
87 
88 /* Do we perform extra sanity checks on stuff ? */
89 /* #define NE_SANITY_CHECK */
90 
91 /* Do we implement the read before write bugfix ? */
92 /* #define NE_RW_BUGFIX */
93 
94 /* Do we have a non std. amount of memory? (in units of 256 byte pages) */
95 /* #define PACKETBUF_MEMSIZE	0x40 */
96 
97 /* This is set up so that no ISA autoprobe takes place. We can't guarantee
98 that the ne2k probe is the last 8390 based probe to take place (as it
99 is at boot) and so the probe will get confused by any other 8390 cards.
100 ISA device autoprobes on a running machine are not recommended anyway. */
101 #if !defined(MODULE) && defined(CONFIG_ISA)
102 /* Do we need a portlist for the ISA auto-probe ? */
103 #define NEEDS_PORTLIST
104 #endif
105 
106 /* A zero-terminated list of I/O addresses to be probed at boot. */
107 #ifdef NEEDS_PORTLIST
108 static unsigned int netcard_portlist[] __initdata = {
109 	0x300, 0x280, 0x320, 0x340, 0x360, 0x380, 0
110 };
111 #endif
112 
113 static struct isapnp_device_id isapnp_clone_list[] __initdata = {
114 	{	ISAPNP_CARD_ID('A','X','E',0x2011),
115 		ISAPNP_VENDOR('A','X','E'), ISAPNP_FUNCTION(0x2011),
116 		(long) "NetGear EA201" },
117 	{	ISAPNP_ANY_ID, ISAPNP_ANY_ID,
118 		ISAPNP_VENDOR('E','D','I'), ISAPNP_FUNCTION(0x0216),
119 		(long) "NN NE2000" },
120 	{	ISAPNP_ANY_ID, ISAPNP_ANY_ID,
121 		ISAPNP_VENDOR('P','N','P'), ISAPNP_FUNCTION(0x80d6),
122 		(long) "Generic PNP" },
123 	{ }	/* terminate list */
124 };
125 
126 MODULE_DEVICE_TABLE(isapnp, isapnp_clone_list);
127 
128 #ifdef SUPPORT_NE_BAD_CLONES
129 /* A list of bad clones that we none-the-less recognize. */
130 static struct { const char *name8, *name16; unsigned char SAprefix[4];}
131 bad_clone_list[] __initdata = {
132     {"DE100", "DE200", {0x00, 0xDE, 0x01,}},
133     {"DE120", "DE220", {0x00, 0x80, 0xc8,}},
134     {"DFI1000", "DFI2000", {'D', 'F', 'I',}}, /* Original, eh?  */
135     {"EtherNext UTP8", "EtherNext UTP16", {0x00, 0x00, 0x79}},
136     {"NE1000","NE2000-invalid", {0x00, 0x00, 0xd8}}, /* Ancient real NE1000. */
137     {"NN1000", "NN2000",  {0x08, 0x03, 0x08}}, /* Outlaw no-name clone. */
138     {"4-DIM8","4-DIM16", {0x00,0x00,0x4d,}},  /* Outlaw 4-Dimension cards. */
139     {"Con-Intl_8", "Con-Intl_16", {0x00, 0x00, 0x24}}, /* Connect Int'nl */
140     {"ET-100","ET-200", {0x00, 0x45, 0x54}}, /* YANG and YA clone */
141     {"COMPEX","COMPEX16",{0x00,0x80,0x48}}, /* Broken ISA Compex cards */
142     {"E-LAN100", "E-LAN200", {0x00, 0x00, 0x5d}}, /* Broken ne1000 clones */
143     {"PCM-4823", "PCM-4823", {0x00, 0xc0, 0x6c}}, /* Broken Advantech MoBo */
144     {"REALTEK", "RTL8019", {0x00, 0x00, 0xe8}}, /* no-name with Realtek chip */
145 #ifdef CONFIG_MACH_TX49XX
146     {"RBHMA4X00-RTL8019", "RBHMA4X00-RTL8019", {0x00, 0x60, 0x0a}},  /* Toshiba built-in */
147 #endif
148     {"LCS-8834", "LCS-8836", {0x04, 0x04, 0x37}}, /* ShinyNet (SET) */
149     {NULL,}
150 };
151 #endif
152 
153 /* ---- No user-serviceable parts below ---- */
154 
155 #define NE_BASE	 (dev->base_addr)
156 #define NE_CMD	 	0x00
157 #define NE_DATAPORT	0x10	/* NatSemi-defined port window offset. */
158 #define NE_RESET	0x1f	/* Issue a read to reset, a write to clear. */
159 #define NE_IO_EXTENT	0x20
160 
161 #define NE1SM_START_PG	0x20	/* First page of TX buffer */
162 #define NE1SM_STOP_PG 	0x40	/* Last page +1 of RX ring */
163 #define NESM_START_PG	0x40	/* First page of TX buffer */
164 #define NESM_STOP_PG	0x80	/* Last page +1 of RX ring */
165 
166 #if defined(CONFIG_MACH_TX49XX)
167 #  define DCR_VAL 0x48		/* 8-bit mode */
168 #elif defined(CONFIG_ATARI)	/* 8-bit mode on Atari, normal on Q40 */
169 #  define DCR_VAL (MACH_IS_ATARI ? 0x48 : 0x49)
170 #else
171 #  define DCR_VAL 0x49
172 #endif
173 
174 static int ne_probe1(struct net_device *dev, unsigned long ioaddr);
175 static int ne_probe_isapnp(struct net_device *dev);
176 
177 static void ne_reset_8390(struct net_device *dev);
178 static void ne_get_8390_hdr(struct net_device *dev, struct e8390_pkt_hdr *hdr,
179 			  int ring_page);
180 static void ne_block_input(struct net_device *dev, int count,
181 			  struct sk_buff *skb, int ring_offset);
182 static void ne_block_output(struct net_device *dev, const int count,
183 		const unsigned char *buf, const int start_page);
184 
185 
186 /*  Probe for various non-shared-memory ethercards.
187 
188    NEx000-clone boards have a Station Address PROM (SAPROM) in the packet
189    buffer memory space.  NE2000 clones have 0x57,0x57 in bytes 0x0e,0x0f of
190    the SAPROM, while other supposed NE2000 clones must be detected by their
191    SA prefix.
192 
193    Reading the SAPROM from a word-wide card with the 8390 set in byte-wide
194    mode results in doubled values, which can be detected and compensated for.
195 
196    The probe is also responsible for initializing the card and filling
197    in the 'dev' and 'ei_status' structures.
198 
199    We use the minimum memory size for some ethercard product lines, iff we can't
200    distinguish models.  You can increase the packet buffer size by setting
201    PACKETBUF_MEMSIZE.  Reported Cabletron packet buffer locations are:
202 	E1010   starts at 0x100 and ends at 0x2000.
203 	E1010-x starts at 0x100 and ends at 0x8000. ("-x" means "more memory")
204 	E2010	 starts at 0x100 and ends at 0x4000.
205 	E2010-x starts at 0x100 and ends at 0xffff.  */
206 
do_ne_probe(struct net_device * dev)207 static int __init do_ne_probe(struct net_device *dev)
208 {
209 	unsigned long base_addr = dev->base_addr;
210 #ifdef NEEDS_PORTLIST
211 	int orig_irq = dev->irq;
212 #endif
213 
214 	/* First check any supplied i/o locations. User knows best. <cough> */
215 	if (base_addr > 0x1ff) {	/* Check a single specified location. */
216 		int ret = ne_probe1(dev, base_addr);
217 		if (ret)
218 			netdev_warn(dev, "ne.c: No NE*000 card found at "
219 				    "i/o = %#lx\n", base_addr);
220 		return ret;
221 	}
222 	else if (base_addr != 0)	/* Don't probe at all. */
223 		return -ENXIO;
224 
225 	/* Then look for any installed ISAPnP clones */
226 	if (isapnp_present() && (ne_probe_isapnp(dev) == 0))
227 		return 0;
228 
229 #ifdef NEEDS_PORTLIST
230 	/* Last resort. The semi-risky ISA auto-probe. */
231 	for (base_addr = 0; netcard_portlist[base_addr] != 0; base_addr++) {
232 		int ioaddr = netcard_portlist[base_addr];
233 		dev->irq = orig_irq;
234 		if (ne_probe1(dev, ioaddr) == 0)
235 			return 0;
236 	}
237 #endif
238 
239 	return -ENODEV;
240 }
241 
ne_probe_isapnp(struct net_device * dev)242 static int __init ne_probe_isapnp(struct net_device *dev)
243 {
244 	int i;
245 
246 	for (i = 0; isapnp_clone_list[i].vendor != 0; i++) {
247 		struct pnp_dev *idev = NULL;
248 
249 		while ((idev = pnp_find_dev(NULL,
250 					    isapnp_clone_list[i].vendor,
251 					    isapnp_clone_list[i].function,
252 					    idev))) {
253 			/* Avoid already found cards from previous calls */
254 			if (pnp_device_attach(idev) < 0)
255 				continue;
256 			if (pnp_activate_dev(idev) < 0) {
257 			      	pnp_device_detach(idev);
258 			      	continue;
259 			}
260 			/* if no io and irq, search for next */
261 			if (!pnp_port_valid(idev, 0) || !pnp_irq_valid(idev, 0)) {
262 				pnp_device_detach(idev);
263 				continue;
264 			}
265 			/* found it */
266 			dev->base_addr = pnp_port_start(idev, 0);
267 			dev->irq = pnp_irq(idev, 0);
268 			netdev_info(dev,
269 				    "ne.c: ISAPnP reports %s at i/o %#lx, irq %d.\n",
270 				    (char *) isapnp_clone_list[i].driver_data,
271 				    dev->base_addr, dev->irq);
272 			if (ne_probe1(dev, dev->base_addr) != 0) {	/* Shouldn't happen. */
273 				netdev_err(dev,
274 					   "ne.c: Probe of ISAPnP card at %#lx failed.\n",
275 					   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 
ne_probe1(struct net_device * dev,unsigned long ioaddr)290 static int __init ne_probe1(struct net_device *dev, unsigned long ioaddr)
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;
300 	struct ei_device *ei_local = netdev_priv(dev);
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 ((ne_msg_enable & NETIF_MSG_DRV) && (version_printed++ == 0))
328 		netdev_info(dev, "%s%s", version1, version2);
329 
330 	netdev_info(dev, "NE*000 ethercard probe at %#3lx:", ioaddr);
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 
338 	bad_card = ((dev->base_addr != 0) && (dev->mem_end == BAD));
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)
349 		if (time_after(jiffies, reset_start_time + 2*HZ/100)) {
350 			if (bad_card) {
351 				pr_cont(" (warning: no reset ack)");
352 				break;
353 			} else {
354 				pr_cont(" 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.
364 	   We must first initialize registers, similar to NS8390p_init(eifdev, 0).
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 
385 		for (i = 0; i < ARRAY_SIZE(program_seq); i++)
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;
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;
416 	} else {
417 		start_page = NE1SM_START_PG;
418 		stop_page  = NE1SM_STOP_PG;
419 	}
420 
421 	neX000 = (SA_prom[14] == 0x57  &&  SA_prom[15] == 0x57);
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 			pr_cont(" 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 		pr_cont(" 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 (ne_msg_enable & NETIF_MSG_PROBE)
480 			pr_cont(" autoirq is %d", 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 		pr_cont(" 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 		pr_cont(" unable to get IRQ %d (errno=%d).\n", dev->irq, ret);
497 		goto err_out;
498 	}
499 
500 	dev->base_addr = ioaddr;
501 
502 	eth_hw_addr_set(dev, SA_prom);
503 
504 	pr_cont("%pM\n", dev->dev_addr);
505 
506 	ei_status.name = name;
507 	ei_status.tx_start_page = start_page;
508 	ei_status.stop_page = stop_page;
509 
510 	/* Use 16-bit mode only if this wasn't overridden by DCR_VAL */
511 	ei_status.word16 = (wordlength == 2 && (DCR_VAL & 0x01));
512 
513 	ei_status.rx_start_page = start_page + TX_PAGES;
514 #ifdef PACKETBUF_MEMSIZE
515 	 /* Allow the packet buffer size to be overridden by know-it-alls. */
516 	ei_status.stop_page = ei_status.tx_start_page + PACKETBUF_MEMSIZE;
517 #endif
518 
519 	ei_status.reset_8390 = &ne_reset_8390;
520 	ei_status.block_input = &ne_block_input;
521 	ei_status.block_output = &ne_block_output;
522 	ei_status.get_8390_hdr = &ne_get_8390_hdr;
523 	ei_status.priv = 0;
524 
525 	dev->netdev_ops = &eip_netdev_ops;
526 	NS8390p_init(dev, 0);
527 
528 	ei_local->msg_enable = ne_msg_enable;
529 	ret = register_netdev(dev);
530 	if (ret)
531 		goto out_irq;
532 	netdev_info(dev, "%s found at %#lx, using IRQ %d.\n",
533 		    name, ioaddr, dev->irq);
534 	return 0;
535 
536 out_irq:
537 	free_irq(dev->irq, dev);
538 err_out:
539 	release_region(ioaddr, NE_IO_EXTENT);
540 	return ret;
541 }
542 
543 /* Hard reset the card.  This used to pause for the same period that a
544    8390 reset command required, but that shouldn't be necessary. */
545 
ne_reset_8390(struct net_device * dev)546 static void ne_reset_8390(struct net_device *dev)
547 {
548 	unsigned long reset_start_time = jiffies;
549 	struct ei_device *ei_local = netdev_priv(dev);
550 
551 	netif_dbg(ei_local, hw, dev, "resetting the 8390 t=%ld...\n", jiffies);
552 
553 	/* DON'T change these to inb_p/outb_p or reset will fail on clones. */
554 	outb(inb(NE_BASE + NE_RESET), NE_BASE + NE_RESET);
555 
556 	ei_status.txing = 0;
557 	ei_status.dmaing = 0;
558 
559 	/* This check _should_not_ be necessary, omit eventually. */
560 	while ((inb_p(NE_BASE+EN0_ISR) & ENISR_RESET) == 0)
561 		if (time_after(jiffies, reset_start_time + 2*HZ/100)) {
562 			netdev_err(dev, "ne_reset_8390() did not complete.\n");
563 			break;
564 		}
565 	outb_p(ENISR_RESET, NE_BASE + EN0_ISR);	/* Ack intr. */
566 }
567 
568 /* Grab the 8390 specific header. Similar to the block_input routine, but
569    we don't need to be concerned with ring wrap as the header will be at
570    the start of a page, so we optimize accordingly. */
571 
ne_get_8390_hdr(struct net_device * dev,struct e8390_pkt_hdr * hdr,int ring_page)572 static void ne_get_8390_hdr(struct net_device *dev, struct e8390_pkt_hdr *hdr, int ring_page)
573 {
574 	int nic_base = dev->base_addr;
575 
576 	/* This *shouldn't* happen. If it does, it's the last thing you'll see */
577 
578 	if (ei_status.dmaing)
579 	{
580 		netdev_err(dev, "DMAing conflict in ne_get_8390_hdr "
581 			   "[DMAstat:%d][irqlock:%d].\n",
582 			   ei_status.dmaing, ei_status.irqlock);
583 		return;
584 	}
585 
586 	ei_status.dmaing |= 0x01;
587 	outb_p(E8390_NODMA+E8390_PAGE0+E8390_START, nic_base+ NE_CMD);
588 	outb_p(sizeof(struct e8390_pkt_hdr), nic_base + EN0_RCNTLO);
589 	outb_p(0, nic_base + EN0_RCNTHI);
590 	outb_p(0, nic_base + EN0_RSARLO);		/* On page boundary */
591 	outb_p(ring_page, nic_base + EN0_RSARHI);
592 	outb_p(E8390_RREAD+E8390_START, nic_base + NE_CMD);
593 
594 	if (ei_status.word16)
595 		insw(NE_BASE + NE_DATAPORT, hdr, sizeof(struct e8390_pkt_hdr)>>1);
596 	else
597 		insb(NE_BASE + NE_DATAPORT, hdr, sizeof(struct e8390_pkt_hdr));
598 
599 	outb_p(ENISR_RDC, nic_base + EN0_ISR);	/* Ack intr. */
600 	ei_status.dmaing &= ~0x01;
601 
602 	le16_to_cpus(&hdr->count);
603 }
604 
605 /* Block input and output, similar to the Crynwr packet driver.  If you
606    are porting to a new ethercard, look at the packet driver source for hints.
607    The NEx000 doesn't share the on-board packet memory -- you have to put
608    the packet out through the "remote DMA" dataport using outb. */
609 
ne_block_input(struct net_device * dev,int count,struct sk_buff * skb,int ring_offset)610 static void ne_block_input(struct net_device *dev, int count, struct sk_buff *skb, int ring_offset)
611 {
612 #ifdef NE_SANITY_CHECK
613 	int xfer_count = count;
614 	struct ei_device *ei_local = netdev_priv(dev);
615 #endif
616 	int nic_base = dev->base_addr;
617 	char *buf = skb->data;
618 
619 	/* This *shouldn't* happen. If it does, it's the last thing you'll see */
620 	if (ei_status.dmaing)
621 	{
622 		netdev_err(dev, "DMAing conflict in ne_block_input "
623 			   "[DMAstat:%d][irqlock:%d].\n",
624 			   ei_status.dmaing, ei_status.irqlock);
625 		return;
626 	}
627 	ei_status.dmaing |= 0x01;
628 	outb_p(E8390_NODMA+E8390_PAGE0+E8390_START, nic_base+ NE_CMD);
629 	outb_p(count & 0xff, nic_base + EN0_RCNTLO);
630 	outb_p(count >> 8, nic_base + EN0_RCNTHI);
631 	outb_p(ring_offset & 0xff, nic_base + EN0_RSARLO);
632 	outb_p(ring_offset >> 8, nic_base + EN0_RSARHI);
633 	outb_p(E8390_RREAD+E8390_START, nic_base + NE_CMD);
634 	if (ei_status.word16)
635 	{
636 		insw(NE_BASE + NE_DATAPORT,buf,count>>1);
637 		if (count & 0x01)
638 		{
639 			buf[count-1] = inb(NE_BASE + NE_DATAPORT);
640 #ifdef NE_SANITY_CHECK
641 			xfer_count++;
642 #endif
643 		}
644 	} else {
645 		insb(NE_BASE + NE_DATAPORT, buf, count);
646 	}
647 
648 #ifdef NE_SANITY_CHECK
649 	/* This was for the ALPHA version only, but enough people have
650 	   been encountering problems so it is still here.  If you see
651 	   this message you either 1) have a slightly incompatible clone
652 	   or 2) have noise/speed problems with your bus. */
653 
654 	if (netif_msg_rx_status(ei_local))
655 	{
656 		/* DMA termination address check... */
657 		int addr, tries = 20;
658 		do {
659 			/* DON'T check for 'inb_p(EN0_ISR) & ENISR_RDC' here
660 			   -- it's broken for Rx on some cards! */
661 			int high = inb_p(nic_base + EN0_RSARHI);
662 			int low = inb_p(nic_base + EN0_RSARLO);
663 			addr = (high << 8) + low;
664 			if (((ring_offset + xfer_count) & 0xff) == low)
665 				break;
666 		} while (--tries > 0);
667 	 	if (tries <= 0)
668 			netdev_warn(dev, "RX transfer address mismatch,"
669 				    "%#4.4x (expected) vs. %#4.4x (actual).\n",
670 				    ring_offset + xfer_count, addr);
671 	}
672 #endif
673 	outb_p(ENISR_RDC, nic_base + EN0_ISR);	/* Ack intr. */
674 	ei_status.dmaing &= ~0x01;
675 }
676 
ne_block_output(struct net_device * dev,int count,const unsigned char * buf,const int start_page)677 static void ne_block_output(struct net_device *dev, int count,
678 		const unsigned char *buf, const int start_page)
679 {
680 	int nic_base = NE_BASE;
681 	unsigned long dma_start;
682 #ifdef NE_SANITY_CHECK
683 	int retries = 0;
684 	struct ei_device *ei_local = netdev_priv(dev);
685 #endif
686 
687 	/* Round the count up for word writes.  Do we need to do this?
688 	   What effect will an odd byte count have on the 8390?
689 	   I should check someday. */
690 
691 	if (ei_status.word16 && (count & 0x01))
692 		count++;
693 
694 	/* This *shouldn't* happen. If it does, it's the last thing you'll see */
695 	if (ei_status.dmaing)
696 	{
697 		netdev_err(dev, "DMAing conflict in ne_block_output."
698 			   "[DMAstat:%d][irqlock:%d]\n",
699 			   ei_status.dmaing, ei_status.irqlock);
700 		return;
701 	}
702 	ei_status.dmaing |= 0x01;
703 	/* We should already be in page 0, but to be safe... */
704 	outb_p(E8390_PAGE0+E8390_START+E8390_NODMA, nic_base + NE_CMD);
705 
706 #ifdef NE_SANITY_CHECK
707 retry:
708 #endif
709 
710 #ifdef NE_RW_BUGFIX
711 	/* Handle the read-before-write bug the same way as the
712 	   Crynwr packet driver -- the NatSemi method doesn't work.
713 	   Actually this doesn't always work either, but if you have
714 	   problems with your NEx000 this is better than nothing! */
715 
716 	outb_p(0x42, nic_base + EN0_RCNTLO);
717 	outb_p(0x00,   nic_base + EN0_RCNTHI);
718 	outb_p(0x42, nic_base + EN0_RSARLO);
719 	outb_p(0x00, nic_base + EN0_RSARHI);
720 	outb_p(E8390_RREAD+E8390_START, nic_base + NE_CMD);
721 	/* Make certain that the dummy read has occurred. */
722 	udelay(6);
723 #endif
724 
725 	outb_p(ENISR_RDC, nic_base + EN0_ISR);
726 
727 	/* Now the normal output. */
728 	outb_p(count & 0xff, nic_base + EN0_RCNTLO);
729 	outb_p(count >> 8,   nic_base + EN0_RCNTHI);
730 	outb_p(0x00, nic_base + EN0_RSARLO);
731 	outb_p(start_page, nic_base + EN0_RSARHI);
732 
733 	outb_p(E8390_RWRITE+E8390_START, nic_base + NE_CMD);
734 	if (ei_status.word16) {
735 		outsw(NE_BASE + NE_DATAPORT, buf, count>>1);
736 	} else {
737 		outsb(NE_BASE + NE_DATAPORT, buf, count);
738 	}
739 
740 	dma_start = jiffies;
741 
742 #ifdef NE_SANITY_CHECK
743 	/* This was for the ALPHA version only, but enough people have
744 	   been encountering problems so it is still here. */
745 
746 	if (netif_msg_tx_queued(ei_local))
747 	{
748 		/* DMA termination address check... */
749 		int addr, tries = 20;
750 		do {
751 			int high = inb_p(nic_base + EN0_RSARHI);
752 			int low = inb_p(nic_base + EN0_RSARLO);
753 			addr = (high << 8) + low;
754 			if ((start_page << 8) + count == addr)
755 				break;
756 		} while (--tries > 0);
757 
758 		if (tries <= 0)
759 		{
760 			netdev_warn(dev, "Tx packet transfer address mismatch,"
761 				    "%#4.4x (expected) vs. %#4.4x (actual).\n",
762 				    (start_page << 8) + count, addr);
763 			if (retries++ == 0)
764 				goto retry;
765 		}
766 	}
767 #endif
768 
769 	while ((inb_p(nic_base + EN0_ISR) & ENISR_RDC) == 0)
770 		if (time_after(jiffies, dma_start + 2*HZ/100)) {		/* 20ms */
771 			netdev_warn(dev, "timeout waiting for Tx RDC.\n");
772 			ne_reset_8390(dev);
773 			NS8390p_init(dev, 1);
774 			break;
775 		}
776 
777 	outb_p(ENISR_RDC, nic_base + EN0_ISR);	/* Ack intr. */
778 	ei_status.dmaing &= ~0x01;
779 }
780 
ne_drv_probe(struct platform_device * pdev)781 static int __init ne_drv_probe(struct platform_device *pdev)
782 {
783 	struct net_device *dev;
784 	int err, this_dev = pdev->id;
785 	struct resource *res;
786 
787 	dev = alloc_eip_netdev();
788 	if (!dev)
789 		return -ENOMEM;
790 
791 	/* ne.c doesn't populate resources in platform_device, but
792 	 * rbtx4927_ne_init and rbtx4938_ne_init do register devices
793 	 * with resources.
794 	 */
795 	res = platform_get_resource(pdev, IORESOURCE_IO, 0);
796 	if (res) {
797 		dev->base_addr = res->start;
798 		dev->irq = platform_get_irq(pdev, 0);
799 	} else {
800 		if (this_dev < 0 || this_dev >= MAX_NE_CARDS) {
801 			free_netdev(dev);
802 			return -EINVAL;
803 		}
804 		dev->base_addr = io[this_dev];
805 		dev->irq = irq[this_dev];
806 		dev->mem_end = bad[this_dev];
807 	}
808 	SET_NETDEV_DEV(dev, &pdev->dev);
809 	err = do_ne_probe(dev);
810 	if (err) {
811 		free_netdev(dev);
812 		return err;
813 	}
814 	platform_set_drvdata(pdev, dev);
815 
816 	/* Update with any values found by probing, don't update if
817 	 * resources were specified.
818 	 */
819 	if (!res) {
820 		io[this_dev] = dev->base_addr;
821 		irq[this_dev] = dev->irq;
822 	}
823 	return 0;
824 }
825 
ne_drv_remove(struct platform_device * pdev)826 static int ne_drv_remove(struct platform_device *pdev)
827 {
828 	struct net_device *dev = platform_get_drvdata(pdev);
829 
830 	if (dev) {
831 		struct pnp_dev *idev = (struct pnp_dev *)ei_status.priv;
832 		netif_device_detach(dev);
833 		unregister_netdev(dev);
834 		if (idev)
835 			pnp_device_detach(idev);
836 		/* Careful ne_drv_remove can be called twice, once from
837 		 * the platform_driver.remove and again when the
838 		 * platform_device is being removed.
839 		 */
840 		ei_status.priv = 0;
841 		free_irq(dev->irq, dev);
842 		release_region(dev->base_addr, NE_IO_EXTENT);
843 		free_netdev(dev);
844 	}
845 	return 0;
846 }
847 
848 /* Remove unused devices or all if true. */
ne_loop_rm_unreg(int all)849 static void ne_loop_rm_unreg(int all)
850 {
851 	int this_dev;
852 	struct platform_device *pdev;
853 	for (this_dev = 0; this_dev < MAX_NE_CARDS; this_dev++) {
854 		pdev = pdev_ne[this_dev];
855 		/* No network device == unused */
856 		if (pdev && (!platform_get_drvdata(pdev) || all)) {
857 			ne_drv_remove(pdev);
858 			platform_device_unregister(pdev);
859 			pdev_ne[this_dev] = NULL;
860 		}
861 	}
862 }
863 
864 #ifdef CONFIG_PM
ne_drv_suspend(struct platform_device * pdev,pm_message_t state)865 static int ne_drv_suspend(struct platform_device *pdev, pm_message_t state)
866 {
867 	struct net_device *dev = platform_get_drvdata(pdev);
868 
869 	if (netif_running(dev)) {
870 		struct pnp_dev *idev = (struct pnp_dev *)ei_status.priv;
871 		netif_device_detach(dev);
872 		if (idev)
873 			pnp_stop_dev(idev);
874 	}
875 	return 0;
876 }
877 
ne_drv_resume(struct platform_device * pdev)878 static int ne_drv_resume(struct platform_device *pdev)
879 {
880 	struct net_device *dev = platform_get_drvdata(pdev);
881 
882 	if (netif_running(dev)) {
883 		struct pnp_dev *idev = (struct pnp_dev *)ei_status.priv;
884 		if (idev)
885 			pnp_start_dev(idev);
886 		ne_reset_8390(dev);
887 		NS8390p_init(dev, 1);
888 		netif_device_attach(dev);
889 	}
890 	return 0;
891 }
892 #else
893 #define ne_drv_suspend NULL
894 #define ne_drv_resume NULL
895 #endif
896 
897 static struct platform_driver ne_driver = {
898 	.remove		= ne_drv_remove,
899 	.suspend	= ne_drv_suspend,
900 	.resume		= ne_drv_resume,
901 	.driver		= {
902 		.name	= DRV_NAME,
903 	},
904 };
905 
ne_add_devices(void)906 static void __init ne_add_devices(void)
907 {
908 	int this_dev;
909 	struct platform_device *pdev;
910 
911 	for (this_dev = 0; this_dev < MAX_NE_CARDS; this_dev++) {
912 		if (pdev_ne[this_dev])
913 			continue;
914 		pdev = platform_device_register_simple(
915 			DRV_NAME, this_dev, NULL, 0);
916 		if (IS_ERR(pdev))
917 			continue;
918 		pdev_ne[this_dev] = pdev;
919 	}
920 }
921 
ne_init(void)922 static int __init ne_init(void)
923 {
924 	int retval;
925 
926 	if (IS_MODULE(CONFIG_NE2000))
927 		ne_add_devices();
928 
929 	retval = platform_driver_probe(&ne_driver, ne_drv_probe);
930 
931 	if (IS_MODULE(CONFIG_NE2000) && retval) {
932 		if (io[0] == 0)
933 			pr_notice("ne.c: You must supply \"io=0xNNN\""
934 			       " value(s) for ISA cards.\n");
935 		ne_loop_rm_unreg(1);
936 		return retval;
937 	}
938 
939 	/* Unregister unused platform_devices. */
940 	ne_loop_rm_unreg(0);
941 	return retval;
942 }
943 module_init(ne_init);
944 
945 #if !defined(MODULE) && defined(CONFIG_NETDEV_LEGACY_INIT)
ne_probe(int unit)946 struct net_device * __init ne_probe(int unit)
947 {
948 	int this_dev;
949 	struct net_device *dev;
950 
951 	/* Find an empty slot, that is no net_device and zero io port. */
952 	this_dev = 0;
953 	while ((pdev_ne[this_dev] && platform_get_drvdata(pdev_ne[this_dev])) ||
954 		io[this_dev]) {
955 		if (++this_dev == MAX_NE_CARDS)
956 			return ERR_PTR(-ENOMEM);
957 	}
958 
959 	/* Get irq, io from kernel command line */
960 	dev = alloc_eip_netdev();
961 	if (!dev)
962 		return ERR_PTR(-ENOMEM);
963 
964 	sprintf(dev->name, "eth%d", unit);
965 	netdev_boot_setup_check(dev);
966 
967 	io[this_dev] = dev->base_addr;
968 	irq[this_dev] = dev->irq;
969 	bad[this_dev] = dev->mem_end;
970 
971 	free_netdev(dev);
972 
973 	ne_add_devices();
974 
975 	/* return the first device found */
976 	for (this_dev = 0; this_dev < MAX_NE_CARDS; this_dev++) {
977 		if (pdev_ne[this_dev]) {
978 			dev = platform_get_drvdata(pdev_ne[this_dev]);
979 			if (dev)
980 				return dev;
981 		}
982 	}
983 
984 	return ERR_PTR(-ENODEV);
985 }
986 #endif
987 
ne_exit(void)988 static void __exit ne_exit(void)
989 {
990 	platform_driver_unregister(&ne_driver);
991 	ne_loop_rm_unreg(1);
992 }
993 module_exit(ne_exit);
994