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