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/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
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 */
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
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. */
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
105/* A zero-terminated list of I/O addresses to be probed at boot. */
106#ifdef NEEDS_PORTLIST
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 */
144#ifdef CONFIG_MACH_TX49XX
145    {"RBHMA4X00-RTL8019", "RBHMA4X00-RTL8019", {0x00, 0x60, 0x0a}},  /* Toshiba built-in */
146#endif
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
165#if defined(CONFIG_PLAT_MAPPI)
166#  define DCR_VAL 0x4b
167#elif defined(CONFIG_PLAT_OAKS32R)  || \
168   defined(CONFIG_MACH_TX49XX)
169#  define DCR_VAL 0x48		/* 8-bit mode */
170#else
171#  define DCR_VAL 0x49
172#endif
173
174static int ne_probe1(struct net_device *dev, unsigned long ioaddr);
175static int ne_probe_isapnp(struct net_device *dev);
176
177static void ne_reset_8390(struct net_device *dev);
178static void ne_get_8390_hdr(struct net_device *dev, struct e8390_pkt_hdr *hdr,
179			  int ring_page);
180static void ne_block_input(struct net_device *dev, int count,
181			  struct sk_buff *skb, int ring_offset);
182static 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
207static 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			printk(KERN_WARNING "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
242static 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			printk(KERN_INFO "ne.c: ISAPnP reports %s at i/o %#lx, irq %d.\n",
269				(char *) isapnp_clone_list[i].driver_data,
270				dev->base_addr, dev->irq);
271			if (ne_probe1(dev, dev->base_addr) != 0) {	/* Shouldn't happen. */
272				printk(KERN_ERR "ne.c: Probe of ISAPnP card at %#lx failed.\n", dev->base_addr);
273				pnp_device_detach(idev);
274				return -ENXIO;
275			}
276			ei_status.priv = (unsigned long)idev;
277			break;
278		}
279		if (!idev)
280			continue;
281		return 0;
282	}
283
284	return -ENODEV;
285}
286
287static int __init ne_probe1(struct net_device *dev, unsigned long ioaddr)
288{
289	int i;
290	unsigned char SA_prom[32];
291	int wordlength = 2;
292	const char *name = NULL;
293	int start_page, stop_page;
294	int neX000, ctron, copam, bad_card;
295	int reg0, ret;
296	static unsigned version_printed;
297
298	if (!request_region(ioaddr, NE_IO_EXTENT, DRV_NAME))
299		return -EBUSY;
300
301	reg0 = inb_p(ioaddr);
302	if (reg0 == 0xFF) {
303		ret = -ENODEV;
304		goto err_out;
305	}
306
307	/* Do a preliminary verification that we have a 8390. */
308	{
309		int regd;
310		outb_p(E8390_NODMA+E8390_PAGE1+E8390_STOP, ioaddr + E8390_CMD);
311		regd = inb_p(ioaddr + 0x0d);
312		outb_p(0xff, ioaddr + 0x0d);
313		outb_p(E8390_NODMA+E8390_PAGE0, ioaddr + E8390_CMD);
314		inb_p(ioaddr + EN0_COUNTER0); /* Clear the counter by reading. */
315		if (inb_p(ioaddr + EN0_COUNTER0) != 0) {
316			outb_p(reg0, ioaddr);
317			outb_p(regd, ioaddr + 0x0d);	/* Restore the old values. */
318			ret = -ENODEV;
319			goto err_out;
320		}
321	}
322
323	if (ei_debug  &&  version_printed++ == 0)
324		printk(KERN_INFO "%s%s", version1, version2);
325
326	printk(KERN_INFO "NE*000 ethercard probe at %#3lx:", ioaddr);
327
328	/* A user with a poor card that fails to ack the reset, or that
329	   does not have a valid 0x57,0x57 signature can still use this
330	   without having to recompile. Specifying an i/o address along
331	   with an otherwise unused dev->mem_end value of "0xBAD" will
332	   cause the driver to skip these parts of the probe. */
333
334	bad_card = ((dev->base_addr != 0) && (dev->mem_end == BAD));
335
336	/* Reset card. Who knows what dain-bramaged state it was left in. */
337
338	{
339		unsigned long reset_start_time = jiffies;
340
341		/* DON'T change these to inb_p/outb_p or reset will fail on clones. */
342		outb(inb(ioaddr + NE_RESET), ioaddr + NE_RESET);
343
344		while ((inb_p(ioaddr + EN0_ISR) & ENISR_RESET) == 0)
345		if (time_after(jiffies, reset_start_time + 2*HZ/100)) {
346			if (bad_card) {
347				printk(" (warning: no reset ack)");
348				break;
349			} else {
350				printk(" not found (no reset ack).\n");
351				ret = -ENODEV;
352				goto err_out;
353			}
354		}
355
356		outb_p(0xff, ioaddr + EN0_ISR);		/* Ack all intr. */
357	}
358
359	/* Read the 16 bytes of station address PROM.
360	   We must first initialize registers, similar to NS8390p_init(eifdev, 0).
361	   We can't reliably read the SAPROM address without this.
362	   (I learned the hard way!). */
363	{
364		struct {unsigned char value, offset; } program_seq[] =
365		{
366			{E8390_NODMA+E8390_PAGE0+E8390_STOP, E8390_CMD}, /* Select page 0*/
367			{0x48,	EN0_DCFG},	/* Set byte-wide (0x48) access. */
368			{0x00,	EN0_RCNTLO},	/* Clear the count regs. */
369			{0x00,	EN0_RCNTHI},
370			{0x00,	EN0_IMR},	/* Mask completion irq. */
371			{0xFF,	EN0_ISR},
372			{E8390_RXOFF, EN0_RXCR},	/* 0x20  Set to monitor */
373			{E8390_TXOFF, EN0_TXCR},	/* 0x02  and loopback mode. */
374			{32,	EN0_RCNTLO},
375			{0x00,	EN0_RCNTHI},
376			{0x00,	EN0_RSARLO},	/* DMA starting at 0x0000. */
377			{0x00,	EN0_RSARHI},
378			{E8390_RREAD+E8390_START, E8390_CMD},
379		};
380
381		for (i = 0; i < ARRAY_SIZE(program_seq); i++)
382			outb_p(program_seq[i].value, ioaddr + program_seq[i].offset);
383
384	}
385	for(i = 0; i < 32 /*sizeof(SA_prom)*/; i+=2) {
386		SA_prom[i] = inb(ioaddr + NE_DATAPORT);
387		SA_prom[i+1] = inb(ioaddr + NE_DATAPORT);
388		if (SA_prom[i] != SA_prom[i+1])
389			wordlength = 1;
390	}
391
392	if (wordlength == 2)
393	{
394		for (i = 0; i < 16; i++)
395			SA_prom[i] = SA_prom[i+i];
396		/* We must set the 8390 for word mode. */
397		outb_p(DCR_VAL, ioaddr + EN0_DCFG);
398		start_page = NESM_START_PG;
399
400		/*
401		 * Realtek RTL8019AS datasheet says that the PSTOP register
402		 * shouldn't exceed 0x60 in 8-bit mode.
403		 * This chip can be identified by reading the signature from
404		 * the  remote byte count registers (otherwise write-only)...
405		 */
406		if ((DCR_VAL & 0x01) == 0 &&		/* 8-bit mode */
407		    inb(ioaddr + EN0_RCNTLO) == 0x50 &&
408		    inb(ioaddr + EN0_RCNTHI) == 0x70)
409			stop_page = 0x60;
410		else
411			stop_page = NESM_STOP_PG;
412	} else {
413		start_page = NE1SM_START_PG;
414		stop_page  = NE1SM_STOP_PG;
415	}
416
417#if  defined(CONFIG_PLAT_MAPPI) || defined(CONFIG_PLAT_OAKS32R)
418	neX000 = ((SA_prom[14] == 0x57  &&  SA_prom[15] == 0x57)
419		|| (SA_prom[14] == 0x42 && SA_prom[15] == 0x42));
420#else
421	neX000 = (SA_prom[14] == 0x57  &&  SA_prom[15] == 0x57);
422#endif
423	ctron =  (SA_prom[0] == 0x00 && SA_prom[1] == 0x00 && SA_prom[2] == 0x1d);
424	copam =  (SA_prom[14] == 0x49 && SA_prom[15] == 0x00);
425
426	/* Set up the rest of the parameters. */
427	if (neX000 || bad_card || copam) {
428		name = (wordlength == 2) ? "NE2000" : "NE1000";
429	}
430	else if (ctron)
431	{
432		name = (wordlength == 2) ? "Ctron-8" : "Ctron-16";
433		start_page = 0x01;
434		stop_page = (wordlength == 2) ? 0x40 : 0x20;
435	}
436	else
437	{
438#ifdef SUPPORT_NE_BAD_CLONES
439		/* Ack!  Well, there might be a *bad* NE*000 clone there.
440		   Check for total bogus addresses. */
441		for (i = 0; bad_clone_list[i].name8; i++)
442		{
443			if (SA_prom[0] == bad_clone_list[i].SAprefix[0] &&
444				SA_prom[1] == bad_clone_list[i].SAprefix[1] &&
445				SA_prom[2] == bad_clone_list[i].SAprefix[2])
446			{
447				if (wordlength == 2)
448				{
449					name = bad_clone_list[i].name16;
450				} else {
451					name = bad_clone_list[i].name8;
452				}
453				break;
454			}
455		}
456		if (bad_clone_list[i].name8 == NULL)
457		{
458			printk(" not found (invalid signature %2.2x %2.2x).\n",
459				SA_prom[14], SA_prom[15]);
460			ret = -ENXIO;
461			goto err_out;
462		}
463#else
464		printk(" not found.\n");
465		ret = -ENXIO;
466		goto err_out;
467#endif
468	}
469
470	if (dev->irq < 2)
471	{
472		unsigned long cookie = probe_irq_on();
473		outb_p(0x50, ioaddr + EN0_IMR);	/* Enable one interrupt. */
474		outb_p(0x00, ioaddr + EN0_RCNTLO);
475		outb_p(0x00, ioaddr + EN0_RCNTHI);
476		outb_p(E8390_RREAD+E8390_START, ioaddr); /* Trigger it... */
477		mdelay(10);		/* wait 10ms for interrupt to propagate */
478		outb_p(0x00, ioaddr + EN0_IMR); 		/* Mask it again. */
479		dev->irq = probe_irq_off(cookie);
480		if (ei_debug > 2)
481			printk(" autoirq is %d\n", dev->irq);
482	} else if (dev->irq == 2)
483		/* Fixup for users that don't know that IRQ 2 is really IRQ 9,
484		   or don't know which one to set. */
485		dev->irq = 9;
486
487	if (! dev->irq) {
488		printk(" failed to detect IRQ line.\n");
489		ret = -EAGAIN;
490		goto err_out;
491	}
492
493	/* Snarf the interrupt now.  There's no point in waiting since we cannot
494	   share and the board will usually be enabled. */
495	ret = request_irq(dev->irq, eip_interrupt, 0, name, dev);
496	if (ret) {
497		printk (" unable to get IRQ %d (errno=%d).\n", dev->irq, ret);
498		goto err_out;
499	}
500
501	dev->base_addr = ioaddr;
502
503#ifdef CONFIG_PLAT_MAPPI
504	outb_p(E8390_NODMA + E8390_PAGE1 + E8390_STOP,
505		ioaddr + E8390_CMD); /* 0x61 */
506	for (i = 0; i < ETH_ALEN; i++) {
507		dev->dev_addr[i] = SA_prom[i]
508			= inb_p(ioaddr + EN1_PHYS_SHIFT(i));
509	}
510#else
511	for (i = 0; i < ETH_ALEN; i++) {
512		dev->dev_addr[i] = SA_prom[i];
513	}
514#endif
515
516	printk("%pM\n", dev->dev_addr);
517
518	ei_status.name = name;
519	ei_status.tx_start_page = start_page;
520	ei_status.stop_page = stop_page;
521
522	/* Use 16-bit mode only if this wasn't overridden by DCR_VAL */
523	ei_status.word16 = (wordlength == 2 && (DCR_VAL & 0x01));
524
525	ei_status.rx_start_page = start_page + TX_PAGES;
526#ifdef PACKETBUF_MEMSIZE
527	 /* Allow the packet buffer size to be overridden by know-it-alls. */
528	ei_status.stop_page = ei_status.tx_start_page + PACKETBUF_MEMSIZE;
529#endif
530
531	ei_status.reset_8390 = &ne_reset_8390;
532	ei_status.block_input = &ne_block_input;
533	ei_status.block_output = &ne_block_output;
534	ei_status.get_8390_hdr = &ne_get_8390_hdr;
535	ei_status.priv = 0;
536
537	dev->netdev_ops = &eip_netdev_ops;
538	NS8390p_init(dev, 0);
539
540	ret = register_netdev(dev);
541	if (ret)
542		goto out_irq;
543	printk(KERN_INFO "%s: %s found at %#lx, using IRQ %d.\n",
544	       dev->name, name, ioaddr, dev->irq);
545	return 0;
546
547out_irq:
548	free_irq(dev->irq, dev);
549err_out:
550	release_region(ioaddr, NE_IO_EXTENT);
551	return ret;
552}
553
554/* Hard reset the card.  This used to pause for the same period that a
555   8390 reset command required, but that shouldn't be necessary. */
556
557static void ne_reset_8390(struct net_device *dev)
558{
559	unsigned long reset_start_time = jiffies;
560
561	if (ei_debug > 1)
562		printk(KERN_DEBUG "resetting the 8390 t=%ld...", jiffies);
563
564	/* DON'T change these to inb_p/outb_p or reset will fail on clones. */
565	outb(inb(NE_BASE + NE_RESET), NE_BASE + NE_RESET);
566
567	ei_status.txing = 0;
568	ei_status.dmaing = 0;
569
570	/* This check _should_not_ be necessary, omit eventually. */
571	while ((inb_p(NE_BASE+EN0_ISR) & ENISR_RESET) == 0)
572		if (time_after(jiffies, reset_start_time + 2*HZ/100)) {
573			printk(KERN_WARNING "%s: ne_reset_8390() did not complete.\n", dev->name);
574			break;
575		}
576	outb_p(ENISR_RESET, NE_BASE + EN0_ISR);	/* Ack intr. */
577}
578
579/* Grab the 8390 specific header. Similar to the block_input routine, but
580   we don't need to be concerned with ring wrap as the header will be at
581   the start of a page, so we optimize accordingly. */
582
583static void ne_get_8390_hdr(struct net_device *dev, struct e8390_pkt_hdr *hdr, int ring_page)
584{
585	int nic_base = dev->base_addr;
586
587	/* This *shouldn't* happen. If it does, it's the last thing you'll see */
588
589	if (ei_status.dmaing)
590	{
591		printk(KERN_EMERG "%s: DMAing conflict in ne_get_8390_hdr "
592			"[DMAstat:%d][irqlock:%d].\n",
593			dev->name, ei_status.dmaing, ei_status.irqlock);
594		return;
595	}
596
597	ei_status.dmaing |= 0x01;
598	outb_p(E8390_NODMA+E8390_PAGE0+E8390_START, nic_base+ NE_CMD);
599	outb_p(sizeof(struct e8390_pkt_hdr), nic_base + EN0_RCNTLO);
600	outb_p(0, nic_base + EN0_RCNTHI);
601	outb_p(0, nic_base + EN0_RSARLO);		/* On page boundary */
602	outb_p(ring_page, nic_base + EN0_RSARHI);
603	outb_p(E8390_RREAD+E8390_START, nic_base + NE_CMD);
604
605	if (ei_status.word16)
606		insw(NE_BASE + NE_DATAPORT, hdr, sizeof(struct e8390_pkt_hdr)>>1);
607	else
608		insb(NE_BASE + NE_DATAPORT, hdr, sizeof(struct e8390_pkt_hdr));
609
610	outb_p(ENISR_RDC, nic_base + EN0_ISR);	/* Ack intr. */
611	ei_status.dmaing &= ~0x01;
612
613	le16_to_cpus(&hdr->count);
614}
615
616/* Block input and output, similar to the Crynwr packet driver.  If you
617   are porting to a new ethercard, look at the packet driver source for hints.
618   The NEx000 doesn't share the on-board packet memory -- you have to put
619   the packet out through the "remote DMA" dataport using outb. */
620
621static void ne_block_input(struct net_device *dev, int count, struct sk_buff *skb, int ring_offset)
622{
623#ifdef NE_SANITY_CHECK
624	int xfer_count = count;
625#endif
626	int nic_base = dev->base_addr;
627	char *buf = skb->data;
628
629	/* This *shouldn't* happen. If it does, it's the last thing you'll see */
630	if (ei_status.dmaing)
631	{
632		printk(KERN_EMERG "%s: DMAing conflict in ne_block_input "
633			"[DMAstat:%d][irqlock:%d].\n",
634			dev->name, ei_status.dmaing, ei_status.irqlock);
635		return;
636	}
637	ei_status.dmaing |= 0x01;
638	outb_p(E8390_NODMA+E8390_PAGE0+E8390_START, nic_base+ NE_CMD);
639	outb_p(count & 0xff, nic_base + EN0_RCNTLO);
640	outb_p(count >> 8, nic_base + EN0_RCNTHI);
641	outb_p(ring_offset & 0xff, nic_base + EN0_RSARLO);
642	outb_p(ring_offset >> 8, nic_base + EN0_RSARHI);
643	outb_p(E8390_RREAD+E8390_START, nic_base + NE_CMD);
644	if (ei_status.word16)
645	{
646		insw(NE_BASE + NE_DATAPORT,buf,count>>1);
647		if (count & 0x01)
648		{
649			buf[count-1] = inb(NE_BASE + NE_DATAPORT);
650#ifdef NE_SANITY_CHECK
651			xfer_count++;
652#endif
653		}
654	} else {
655		insb(NE_BASE + NE_DATAPORT, buf, count);
656	}
657
658#ifdef NE_SANITY_CHECK
659	/* This was for the ALPHA version only, but enough people have
660	   been encountering problems so it is still here.  If you see
661	   this message you either 1) have a slightly incompatible clone
662	   or 2) have noise/speed problems with your bus. */
663
664	if (ei_debug > 1)
665	{
666		/* DMA termination address check... */
667		int addr, tries = 20;
668		do {
669			/* DON'T check for 'inb_p(EN0_ISR) & ENISR_RDC' here
670			   -- it's broken for Rx on some cards! */
671			int high = inb_p(nic_base + EN0_RSARHI);
672			int low = inb_p(nic_base + EN0_RSARLO);
673			addr = (high << 8) + low;
674			if (((ring_offset + xfer_count) & 0xff) == low)
675				break;
676		} while (--tries > 0);
677	 	if (tries <= 0)
678			printk(KERN_WARNING "%s: RX transfer address mismatch,"
679				"%#4.4x (expected) vs. %#4.4x (actual).\n",
680				dev->name, ring_offset + xfer_count, addr);
681	}
682#endif
683	outb_p(ENISR_RDC, nic_base + EN0_ISR);	/* Ack intr. */
684	ei_status.dmaing &= ~0x01;
685}
686
687static void ne_block_output(struct net_device *dev, int count,
688		const unsigned char *buf, const int start_page)
689{
690	int nic_base = NE_BASE;
691	unsigned long dma_start;
692#ifdef NE_SANITY_CHECK
693	int retries = 0;
694#endif
695
696	/* Round the count up for word writes.  Do we need to do this?
697	   What effect will an odd byte count have on the 8390?
698	   I should check someday. */
699
700	if (ei_status.word16 && (count & 0x01))
701		count++;
702
703	/* This *shouldn't* happen. If it does, it's the last thing you'll see */
704	if (ei_status.dmaing)
705	{
706		printk(KERN_EMERG "%s: DMAing conflict in ne_block_output."
707			"[DMAstat:%d][irqlock:%d]\n",
708			dev->name, ei_status.dmaing, ei_status.irqlock);
709		return;
710	}
711	ei_status.dmaing |= 0x01;
712	/* We should already be in page 0, but to be safe... */
713	outb_p(E8390_PAGE0+E8390_START+E8390_NODMA, nic_base + NE_CMD);
714
715#ifdef NE_SANITY_CHECK
716retry:
717#endif
718
719#ifdef NE8390_RW_BUGFIX
720	/* Handle the read-before-write bug the same way as the
721	   Crynwr packet driver -- the NatSemi method doesn't work.
722	   Actually this doesn't always work either, but if you have
723	   problems with your NEx000 this is better than nothing! */
724
725	outb_p(0x42, nic_base + EN0_RCNTLO);
726	outb_p(0x00,   nic_base + EN0_RCNTHI);
727	outb_p(0x42, nic_base + EN0_RSARLO);
728	outb_p(0x00, nic_base + EN0_RSARHI);
729	outb_p(E8390_RREAD+E8390_START, nic_base + NE_CMD);
730	/* Make certain that the dummy read has occurred. */
731	udelay(6);
732#endif
733
734	outb_p(ENISR_RDC, nic_base + EN0_ISR);
735
736	/* Now the normal output. */
737	outb_p(count & 0xff, nic_base + EN0_RCNTLO);
738	outb_p(count >> 8,   nic_base + EN0_RCNTHI);
739	outb_p(0x00, nic_base + EN0_RSARLO);
740	outb_p(start_page, nic_base + EN0_RSARHI);
741
742	outb_p(E8390_RWRITE+E8390_START, nic_base + NE_CMD);
743	if (ei_status.word16) {
744		outsw(NE_BASE + NE_DATAPORT, buf, count>>1);
745	} else {
746		outsb(NE_BASE + NE_DATAPORT, buf, count);
747	}
748
749	dma_start = jiffies;
750
751#ifdef NE_SANITY_CHECK
752	/* This was for the ALPHA version only, but enough people have
753	   been encountering problems so it is still here. */
754
755	if (ei_debug > 1)
756	{
757		/* DMA termination address check... */
758		int addr, tries = 20;
759		do {
760			int high = inb_p(nic_base + EN0_RSARHI);
761			int low = inb_p(nic_base + EN0_RSARLO);
762			addr = (high << 8) + low;
763			if ((start_page << 8) + count == addr)
764				break;
765		} while (--tries > 0);
766
767		if (tries <= 0)
768		{
769			printk(KERN_WARNING "%s: Tx packet transfer address mismatch,"
770				"%#4.4x (expected) vs. %#4.4x (actual).\n",
771				dev->name, (start_page << 8) + count, addr);
772			if (retries++ == 0)
773				goto retry;
774		}
775	}
776#endif
777
778	while ((inb_p(nic_base + EN0_ISR) & ENISR_RDC) == 0)
779		if (time_after(jiffies, dma_start + 2*HZ/100)) {		/* 20ms */
780			printk(KERN_WARNING "%s: timeout waiting for Tx RDC.\n", dev->name);
781			ne_reset_8390(dev);
782			NS8390p_init(dev, 1);
783			break;
784		}
785
786	outb_p(ENISR_RDC, nic_base + EN0_ISR);	/* Ack intr. */
787	ei_status.dmaing &= ~0x01;
788}
789
790static int __init ne_drv_probe(struct platform_device *pdev)
791{
792	struct net_device *dev;
793	int err, this_dev = pdev->id;
794	struct resource *res;
795
796	dev = alloc_eip_netdev();
797	if (!dev)
798		return -ENOMEM;
799
800	/* ne.c doesn't populate resources in platform_device, but
801	 * rbtx4927_ne_init and rbtx4938_ne_init do register devices
802	 * with resources.
803	 */
804	res = platform_get_resource(pdev, IORESOURCE_IO, 0);
805	if (res) {
806		dev->base_addr = res->start;
807		dev->irq = platform_get_irq(pdev, 0);
808	} else {
809		if (this_dev < 0 || this_dev >= MAX_NE_CARDS) {
810			free_netdev(dev);
811			return -EINVAL;
812		}
813		dev->base_addr = io[this_dev];
814		dev->irq = irq[this_dev];
815		dev->mem_end = bad[this_dev];
816	}
817	err = do_ne_probe(dev);
818	if (err) {
819		free_netdev(dev);
820		return err;
821	}
822	platform_set_drvdata(pdev, dev);
823
824	/* Update with any values found by probing, don't update if
825	 * resources were specified.
826	 */
827	if (!res) {
828		io[this_dev] = dev->base_addr;
829		irq[this_dev] = dev->irq;
830	}
831	return 0;
832}
833
834static int ne_drv_remove(struct platform_device *pdev)
835{
836	struct net_device *dev = platform_get_drvdata(pdev);
837
838	if (dev) {
839		struct pnp_dev *idev = (struct pnp_dev *)ei_status.priv;
840		netif_device_detach(dev);
841		unregister_netdev(dev);
842		if (idev)
843			pnp_device_detach(idev);
844		/* Careful ne_drv_remove can be called twice, once from
845		 * the platform_driver.remove and again when the
846		 * platform_device is being removed.
847		 */
848		ei_status.priv = 0;
849		free_irq(dev->irq, dev);
850		release_region(dev->base_addr, NE_IO_EXTENT);
851		free_netdev(dev);
852		platform_set_drvdata(pdev, NULL);
853	}
854	return 0;
855}
856
857/* Remove unused devices or all if true. */
858static void ne_loop_rm_unreg(int all)
859{
860	int this_dev;
861	struct platform_device *pdev;
862	for (this_dev = 0; this_dev < MAX_NE_CARDS; this_dev++) {
863		pdev = pdev_ne[this_dev];
864		/* No network device == unused */
865		if (pdev && (!platform_get_drvdata(pdev) || all)) {
866			ne_drv_remove(pdev);
867			platform_device_unregister(pdev);
868			pdev_ne[this_dev] = NULL;
869		}
870	}
871}
872
873#ifdef CONFIG_PM
874static int ne_drv_suspend(struct platform_device *pdev, pm_message_t state)
875{
876	struct net_device *dev = platform_get_drvdata(pdev);
877
878	if (netif_running(dev)) {
879		struct pnp_dev *idev = (struct pnp_dev *)ei_status.priv;
880		netif_device_detach(dev);
881		if (idev)
882			pnp_stop_dev(idev);
883	}
884	return 0;
885}
886
887static int ne_drv_resume(struct platform_device *pdev)
888{
889	struct net_device *dev = platform_get_drvdata(pdev);
890
891	if (netif_running(dev)) {
892		struct pnp_dev *idev = (struct pnp_dev *)ei_status.priv;
893		if (idev)
894			pnp_start_dev(idev);
895		ne_reset_8390(dev);
896		NS8390p_init(dev, 1);
897		netif_device_attach(dev);
898	}
899	return 0;
900}
901#else
902#define ne_drv_suspend NULL
903#define ne_drv_resume NULL
904#endif
905
906static struct platform_driver ne_driver = {
907	.remove		= ne_drv_remove,
908	.suspend	= ne_drv_suspend,
909	.resume		= ne_drv_resume,
910	.driver		= {
911		.name	= DRV_NAME,
912		.owner	= THIS_MODULE,
913	},
914};
915
916static void __init ne_add_devices(void)
917{
918	int this_dev;
919	struct platform_device *pdev;
920
921	for (this_dev = 0; this_dev < MAX_NE_CARDS; this_dev++) {
922		if (pdev_ne[this_dev])
923			continue;
924		pdev = platform_device_register_simple(
925			DRV_NAME, this_dev, NULL, 0);
926		if (IS_ERR(pdev))
927			continue;
928		pdev_ne[this_dev] = pdev;
929	}
930}
931
932#ifdef MODULE
933int __init init_module(void)
934{
935	int retval;
936	ne_add_devices();
937	retval = platform_driver_probe(&ne_driver, ne_drv_probe);
938	if (retval) {
939		if (io[0] == 0)
940			printk(KERN_NOTICE "ne.c: You must supply \"io=0xNNN\""
941				" value(s) for ISA cards.\n");
942		ne_loop_rm_unreg(1);
943		return retval;
944	}
945
946	/* Unregister unused platform_devices. */
947	ne_loop_rm_unreg(0);
948	return retval;
949}
950#else /* MODULE */
951static int __init ne_init(void)
952{
953	int retval = platform_driver_probe(&ne_driver, ne_drv_probe);
954
955	/* Unregister unused platform_devices. */
956	ne_loop_rm_unreg(0);
957	return retval;
958}
959module_init(ne_init);
960
961struct net_device * __init ne_probe(int unit)
962{
963	int this_dev;
964	struct net_device *dev;
965
966	/* Find an empty slot, that is no net_device and zero io port. */
967	this_dev = 0;
968	while ((pdev_ne[this_dev] && platform_get_drvdata(pdev_ne[this_dev])) ||
969		io[this_dev]) {
970		if (++this_dev == MAX_NE_CARDS)
971			return ERR_PTR(-ENOMEM);
972	}
973
974	/* Get irq, io from kernel command line */
975	dev = alloc_eip_netdev();
976	if (!dev)
977		return ERR_PTR(-ENOMEM);
978
979	sprintf(dev->name, "eth%d", unit);
980	netdev_boot_setup_check(dev);
981
982	io[this_dev] = dev->base_addr;
983	irq[this_dev] = dev->irq;
984	bad[this_dev] = dev->mem_end;
985
986	free_netdev(dev);
987
988	ne_add_devices();
989
990	/* return the first device found */
991	for (this_dev = 0; this_dev < MAX_NE_CARDS; this_dev++) {
992		if (pdev_ne[this_dev]) {
993			dev = platform_get_drvdata(pdev_ne[this_dev]);
994			if (dev)
995				return dev;
996		}
997	}
998
999	return ERR_PTR(-ENODEV);
1000}
1001#endif /* MODULE */
1002
1003static void __exit ne_exit(void)
1004{
1005	platform_driver_unregister(&ne_driver);
1006	ne_loop_rm_unreg(1);
1007}
1008module_exit(ne_exit);
1009