PageRenderTime 92ms CodeModel.GetById 37ms app.highlight 46ms RepoModel.GetById 1ms app.codeStats 1ms

/drivers/net/ne.c

https://gitlab.com/TeamCarbonXtreme/android_kernel_samsung_bcm21553-common
C | 1008 lines | 719 code | 131 blank | 158 comment | 163 complexity | 7ffb674faf38085d2cede4b84086239c MD5 | raw file
   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 < ETHER_ADDR_LEN ; 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 < ETHER_ADDR_LEN; 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);