PageRenderTime 112ms CodeModel.GetById 21ms app.highlight 83ms RepoModel.GetById 1ms app.codeStats 0ms

/drivers/net/3c509.c

https://bitbucket.org/cyanogenmod/android_kernel_asus_tf300t
C | 1594 lines | 1169 code | 227 blank | 198 comment | 157 complexity | 3082d8fa5ac427ce9730cf1dcc6803b9 MD5 | raw file
Possible License(s): LGPL-2.0, AGPL-1.0, GPL-2.0
   1/* 3c509.c: A 3c509 EtherLink3 ethernet driver for linux. */
   2/*
   3	Written 1993-2000 by Donald Becker.
   4
   5	Copyright 1994-2000 by Donald Becker.
   6	Copyright 1993 United States Government as represented by the
   7	Director, National Security Agency.	 This software may be used and
   8	distributed according to the terms of the GNU General Public License,
   9	incorporated herein by reference.
  10
  11	This driver is for the 3Com EtherLinkIII series.
  12
  13	The author may be reached as becker@scyld.com, or C/O
  14	Scyld Computing Corporation
  15	410 Severn Ave., Suite 210
  16	Annapolis MD 21403
  17
  18	Known limitations:
  19	Because of the way 3c509 ISA detection works it's difficult to predict
  20	a priori which of several ISA-mode cards will be detected first.
  21
  22	This driver does not use predictive interrupt mode, resulting in higher
  23	packet latency but lower overhead.  If interrupts are disabled for an
  24	unusually long time it could also result in missed packets, but in
  25	practice this rarely happens.
  26
  27
  28	FIXES:
  29		Alan Cox:       Removed the 'Unexpected interrupt' bug.
  30		Michael Meskes:	Upgraded to Donald Becker's version 1.07.
  31		Alan Cox:	Increased the eeprom delay. Regardless of
  32				what the docs say some people definitely
  33				get problems with lower (but in card spec)
  34				delays
  35		v1.10 4/21/97 Fixed module code so that multiple cards may be detected,
  36				other cleanups.  -djb
  37		Andrea Arcangeli:	Upgraded to Donald Becker's version 1.12.
  38		Rick Payne:	Fixed SMP race condition
  39		v1.13 9/8/97 Made 'max_interrupt_work' an insmod-settable variable -djb
  40		v1.14 10/15/97 Avoided waiting..discard message for fast machines -djb
  41		v1.15 1/31/98 Faster recovery for Tx errors. -djb
  42		v1.16 2/3/98 Different ID port handling to avoid sound cards. -djb
  43		v1.18 12Mar2001 Andrew Morton
  44			- Avoid bogus detect of 3c590's (Andrzej Krzysztofowicz)
  45			- Reviewed against 1.18 from scyld.com
  46		v1.18a 17Nov2001 Jeff Garzik <jgarzik@pobox.com>
  47			- ethtool support
  48		v1.18b 1Mar2002 Zwane Mwaikambo <zwane@commfireservices.com>
  49			- Power Management support
  50		v1.18c 1Mar2002 David Ruggiero <jdr@farfalle.com>
  51			- Full duplex support
  52		v1.19  16Oct2002 Zwane Mwaikambo <zwane@linuxpower.ca>
  53			- Additional ethtool features
  54		v1.19a 28Oct2002 Davud Ruggiero <jdr@farfalle.com>
  55			- Increase *read_eeprom udelay to workaround oops with 2 cards.
  56		v1.19b 08Nov2002 Marc Zyngier <maz@wild-wind.fr.eu.org>
  57			- Introduce driver model for EISA cards.
  58		v1.20  04Feb2008 Ondrej Zary <linux@rainbow-software.org>
  59			- convert to isa_driver and pnp_driver and some cleanups
  60*/
  61
  62#define DRV_NAME	"3c509"
  63#define DRV_VERSION	"1.20"
  64#define DRV_RELDATE	"04Feb2008"
  65
  66/* A few values that may be tweaked. */
  67
  68/* Time in jiffies before concluding the transmitter is hung. */
  69#define TX_TIMEOUT  (400*HZ/1000)
  70
  71#include <linux/module.h>
  72#include <linux/mca.h>
  73#include <linux/isa.h>
  74#include <linux/pnp.h>
  75#include <linux/string.h>
  76#include <linux/interrupt.h>
  77#include <linux/errno.h>
  78#include <linux/in.h>
  79#include <linux/ioport.h>
  80#include <linux/init.h>
  81#include <linux/netdevice.h>
  82#include <linux/etherdevice.h>
  83#include <linux/pm.h>
  84#include <linux/skbuff.h>
  85#include <linux/delay.h>	/* for udelay() */
  86#include <linux/spinlock.h>
  87#include <linux/ethtool.h>
  88#include <linux/device.h>
  89#include <linux/eisa.h>
  90#include <linux/bitops.h>
  91
  92#include <asm/uaccess.h>
  93#include <asm/io.h>
  94#include <asm/irq.h>
  95
  96static char version[] __devinitdata = DRV_NAME ".c:" DRV_VERSION " " DRV_RELDATE " becker@scyld.com\n";
  97
  98#ifdef EL3_DEBUG
  99static int el3_debug = EL3_DEBUG;
 100#else
 101static int el3_debug = 2;
 102#endif
 103
 104/* Used to do a global count of all the cards in the system.  Must be
 105 * a global variable so that the mca/eisa probe routines can increment
 106 * it */
 107static int el3_cards = 0;
 108#define EL3_MAX_CARDS 8
 109
 110/* To minimize the size of the driver source I only define operating
 111   constants if they are used several times.  You'll need the manual
 112   anyway if you want to understand driver details. */
 113/* Offsets from base I/O address. */
 114#define EL3_DATA 0x00
 115#define EL3_CMD 0x0e
 116#define EL3_STATUS 0x0e
 117#define	EEPROM_READ 0x80
 118
 119#define EL3_IO_EXTENT	16
 120
 121#define EL3WINDOW(win_num) outw(SelectWindow + (win_num), ioaddr + EL3_CMD)
 122
 123
 124/* The top five bits written to EL3_CMD are a command, the lower
 125   11 bits are the parameter, if applicable. */
 126enum c509cmd {
 127	TotalReset = 0<<11, SelectWindow = 1<<11, StartCoax = 2<<11,
 128	RxDisable = 3<<11, RxEnable = 4<<11, RxReset = 5<<11, RxDiscard = 8<<11,
 129	TxEnable = 9<<11, TxDisable = 10<<11, TxReset = 11<<11,
 130	FakeIntr = 12<<11, AckIntr = 13<<11, SetIntrEnb = 14<<11,
 131	SetStatusEnb = 15<<11, SetRxFilter = 16<<11, SetRxThreshold = 17<<11,
 132	SetTxThreshold = 18<<11, SetTxStart = 19<<11, StatsEnable = 21<<11,
 133	StatsDisable = 22<<11, StopCoax = 23<<11, PowerUp = 27<<11,
 134	PowerDown = 28<<11, PowerAuto = 29<<11};
 135
 136enum c509status {
 137	IntLatch = 0x0001, AdapterFailure = 0x0002, TxComplete = 0x0004,
 138	TxAvailable = 0x0008, RxComplete = 0x0010, RxEarly = 0x0020,
 139	IntReq = 0x0040, StatsFull = 0x0080, CmdBusy = 0x1000, };
 140
 141/* The SetRxFilter command accepts the following classes: */
 142enum RxFilter {
 143	RxStation = 1, RxMulticast = 2, RxBroadcast = 4, RxProm = 8 };
 144
 145/* Register window 1 offsets, the window used in normal operation. */
 146#define TX_FIFO		0x00
 147#define RX_FIFO		0x00
 148#define RX_STATUS 	0x08
 149#define TX_STATUS 	0x0B
 150#define TX_FREE		0x0C		/* Remaining free bytes in Tx buffer. */
 151
 152#define WN0_CONF_CTRL	0x04		/* Window 0: Configuration control register */
 153#define WN0_ADDR_CONF	0x06		/* Window 0: Address configuration register */
 154#define WN0_IRQ		0x08		/* Window 0: Set IRQ line in bits 12-15. */
 155#define WN4_MEDIA	0x0A		/* Window 4: Various transcvr/media bits. */
 156#define	MEDIA_TP	0x00C0		/* Enable link beat and jabber for 10baseT. */
 157#define WN4_NETDIAG	0x06		/* Window 4: Net diagnostic */
 158#define FD_ENABLE	0x8000		/* Enable full-duplex ("external loopback") */
 159
 160/*
 161 * Must be a power of two (we use a binary and in the
 162 * circular queue)
 163 */
 164#define SKB_QUEUE_SIZE	64
 165
 166enum el3_cardtype { EL3_ISA, EL3_PNP, EL3_MCA, EL3_EISA };
 167
 168struct el3_private {
 169	spinlock_t lock;
 170	/* skb send-queue */
 171	int head, size;
 172	struct sk_buff *queue[SKB_QUEUE_SIZE];
 173	enum el3_cardtype type;
 174};
 175static int id_port;
 176static int current_tag;
 177static struct net_device *el3_devs[EL3_MAX_CARDS];
 178
 179/* Parameters that may be passed into the module. */
 180static int debug = -1;
 181static int irq[] = {-1, -1, -1, -1, -1, -1, -1, -1};
 182/* Maximum events (Rx packets, etc.) to handle at each interrupt. */
 183static int max_interrupt_work = 10;
 184#ifdef CONFIG_PNP
 185static int nopnp;
 186#endif
 187
 188static int __devinit el3_common_init(struct net_device *dev);
 189static void el3_common_remove(struct net_device *dev);
 190static ushort id_read_eeprom(int index);
 191static ushort read_eeprom(int ioaddr, int index);
 192static int el3_open(struct net_device *dev);
 193static netdev_tx_t el3_start_xmit(struct sk_buff *skb, struct net_device *dev);
 194static irqreturn_t el3_interrupt(int irq, void *dev_id);
 195static void update_stats(struct net_device *dev);
 196static struct net_device_stats *el3_get_stats(struct net_device *dev);
 197static int el3_rx(struct net_device *dev);
 198static int el3_close(struct net_device *dev);
 199static void set_multicast_list(struct net_device *dev);
 200static void el3_tx_timeout (struct net_device *dev);
 201static void el3_down(struct net_device *dev);
 202static void el3_up(struct net_device *dev);
 203static const struct ethtool_ops ethtool_ops;
 204#ifdef CONFIG_PM
 205static int el3_suspend(struct device *, pm_message_t);
 206static int el3_resume(struct device *);
 207#else
 208#define el3_suspend NULL
 209#define el3_resume NULL
 210#endif
 211
 212
 213/* generic device remove for all device types */
 214static int el3_device_remove (struct device *device);
 215#ifdef CONFIG_NET_POLL_CONTROLLER
 216static void el3_poll_controller(struct net_device *dev);
 217#endif
 218
 219/* Return 0 on success, 1 on error, 2 when found already detected PnP card */
 220static int el3_isa_id_sequence(__be16 *phys_addr)
 221{
 222	short lrs_state = 0xff;
 223	int i;
 224
 225	/* ISA boards are detected by sending the ID sequence to the
 226	   ID_PORT.  We find cards past the first by setting the 'current_tag'
 227	   on cards as they are found.  Cards with their tag set will not
 228	   respond to subsequent ID sequences. */
 229
 230	outb(0x00, id_port);
 231	outb(0x00, id_port);
 232	for (i = 0; i < 255; i++) {
 233		outb(lrs_state, id_port);
 234		lrs_state <<= 1;
 235		lrs_state = lrs_state & 0x100 ? lrs_state ^ 0xcf : lrs_state;
 236	}
 237	/* For the first probe, clear all board's tag registers. */
 238	if (current_tag == 0)
 239		outb(0xd0, id_port);
 240	else			/* Otherwise kill off already-found boards. */
 241		outb(0xd8, id_port);
 242	if (id_read_eeprom(7) != 0x6d50)
 243		return 1;
 244	/* Read in EEPROM data, which does contention-select.
 245	   Only the lowest address board will stay "on-line".
 246	   3Com got the byte order backwards. */
 247	for (i = 0; i < 3; i++)
 248		phys_addr[i] = htons(id_read_eeprom(i));
 249#ifdef CONFIG_PNP
 250	if (!nopnp) {
 251		/* The ISA PnP 3c509 cards respond to the ID sequence too.
 252		   This check is needed in order not to register them twice. */
 253		for (i = 0; i < el3_cards; i++) {
 254			struct el3_private *lp = netdev_priv(el3_devs[i]);
 255			if (lp->type == EL3_PNP &&
 256			    !memcmp(phys_addr, el3_devs[i]->dev_addr,
 257				    ETH_ALEN)) {
 258				if (el3_debug > 3)
 259					pr_debug("3c509 with address %02x %02x %02x %02x %02x %02x was found by ISAPnP\n",
 260						phys_addr[0] & 0xff, phys_addr[0] >> 8,
 261						phys_addr[1] & 0xff, phys_addr[1] >> 8,
 262						phys_addr[2] & 0xff, phys_addr[2] >> 8);
 263				/* Set the adaptor tag so that the next card can be found. */
 264				outb(0xd0 + ++current_tag, id_port);
 265				return 2;
 266			}
 267		}
 268	}
 269#endif /* CONFIG_PNP */
 270	return 0;
 271
 272}
 273
 274static void __devinit el3_dev_fill(struct net_device *dev, __be16 *phys_addr,
 275				   int ioaddr, int irq, int if_port,
 276				   enum el3_cardtype type)
 277{
 278	struct el3_private *lp = netdev_priv(dev);
 279
 280	memcpy(dev->dev_addr, phys_addr, ETH_ALEN);
 281	dev->base_addr = ioaddr;
 282	dev->irq = irq;
 283	dev->if_port = if_port;
 284	lp->type = type;
 285}
 286
 287static int __devinit el3_isa_match(struct device *pdev,
 288				   unsigned int ndev)
 289{
 290	struct net_device *dev;
 291	int ioaddr, isa_irq, if_port, err;
 292	unsigned int iobase;
 293	__be16 phys_addr[3];
 294
 295	while ((err = el3_isa_id_sequence(phys_addr)) == 2)
 296		;	/* Skip to next card when PnP card found */
 297	if (err == 1)
 298		return 0;
 299
 300	iobase = id_read_eeprom(8);
 301	if_port = iobase >> 14;
 302	ioaddr = 0x200 + ((iobase & 0x1f) << 4);
 303	if (irq[el3_cards] > 1 && irq[el3_cards] < 16)
 304		isa_irq = irq[el3_cards];
 305	else
 306		isa_irq = id_read_eeprom(9) >> 12;
 307
 308	dev = alloc_etherdev(sizeof(struct el3_private));
 309	if (!dev)
 310		return -ENOMEM;
 311
 312	netdev_boot_setup_check(dev);
 313
 314	if (!request_region(ioaddr, EL3_IO_EXTENT, "3c509-isa")) {
 315		free_netdev(dev);
 316		return 0;
 317	}
 318
 319	/* Set the adaptor tag so that the next card can be found. */
 320	outb(0xd0 + ++current_tag, id_port);
 321
 322	/* Activate the adaptor at the EEPROM location. */
 323	outb((ioaddr >> 4) | 0xe0, id_port);
 324
 325	EL3WINDOW(0);
 326	if (inw(ioaddr) != 0x6d50) {
 327		free_netdev(dev);
 328		return 0;
 329	}
 330
 331	/* Free the interrupt so that some other card can use it. */
 332	outw(0x0f00, ioaddr + WN0_IRQ);
 333
 334	el3_dev_fill(dev, phys_addr, ioaddr, isa_irq, if_port, EL3_ISA);
 335	dev_set_drvdata(pdev, dev);
 336	if (el3_common_init(dev)) {
 337		free_netdev(dev);
 338		return 0;
 339	}
 340
 341	el3_devs[el3_cards++] = dev;
 342	return 1;
 343}
 344
 345static int __devexit el3_isa_remove(struct device *pdev,
 346				    unsigned int ndev)
 347{
 348	el3_device_remove(pdev);
 349	dev_set_drvdata(pdev, NULL);
 350	return 0;
 351}
 352
 353#ifdef CONFIG_PM
 354static int el3_isa_suspend(struct device *dev, unsigned int n,
 355			   pm_message_t state)
 356{
 357	current_tag = 0;
 358	return el3_suspend(dev, state);
 359}
 360
 361static int el3_isa_resume(struct device *dev, unsigned int n)
 362{
 363	struct net_device *ndev = dev_get_drvdata(dev);
 364	int ioaddr = ndev->base_addr, err;
 365	__be16 phys_addr[3];
 366
 367	while ((err = el3_isa_id_sequence(phys_addr)) == 2)
 368		;	/* Skip to next card when PnP card found */
 369	if (err == 1)
 370		return 0;
 371	/* Set the adaptor tag so that the next card can be found. */
 372	outb(0xd0 + ++current_tag, id_port);
 373	/* Enable the card */
 374	outb((ioaddr >> 4) | 0xe0, id_port);
 375	EL3WINDOW(0);
 376	if (inw(ioaddr) != 0x6d50)
 377		return 1;
 378	/* Free the interrupt so that some other card can use it. */
 379	outw(0x0f00, ioaddr + WN0_IRQ);
 380	return el3_resume(dev);
 381}
 382#endif
 383
 384static struct isa_driver el3_isa_driver = {
 385	.match		= el3_isa_match,
 386	.remove		= __devexit_p(el3_isa_remove),
 387#ifdef CONFIG_PM
 388	.suspend	= el3_isa_suspend,
 389	.resume		= el3_isa_resume,
 390#endif
 391	.driver		= {
 392		.name	= "3c509"
 393	},
 394};
 395static int isa_registered;
 396
 397#ifdef CONFIG_PNP
 398static struct pnp_device_id el3_pnp_ids[] = {
 399	{ .id = "TCM5090" }, /* 3Com Etherlink III (TP) */
 400	{ .id = "TCM5091" }, /* 3Com Etherlink III */
 401	{ .id = "TCM5094" }, /* 3Com Etherlink III (combo) */
 402	{ .id = "TCM5095" }, /* 3Com Etherlink III (TPO) */
 403	{ .id = "TCM5098" }, /* 3Com Etherlink III (TPC) */
 404	{ .id = "PNP80f7" }, /* 3Com Etherlink III compatible */
 405	{ .id = "PNP80f8" }, /* 3Com Etherlink III compatible */
 406	{ .id = "" }
 407};
 408MODULE_DEVICE_TABLE(pnp, el3_pnp_ids);
 409
 410static int __devinit el3_pnp_probe(struct pnp_dev *pdev,
 411				    const struct pnp_device_id *id)
 412{
 413	short i;
 414	int ioaddr, irq, if_port;
 415	__be16 phys_addr[3];
 416	struct net_device *dev = NULL;
 417	int err;
 418
 419	ioaddr = pnp_port_start(pdev, 0);
 420	if (!request_region(ioaddr, EL3_IO_EXTENT, "3c509-pnp"))
 421		return -EBUSY;
 422	irq = pnp_irq(pdev, 0);
 423	EL3WINDOW(0);
 424	for (i = 0; i < 3; i++)
 425		phys_addr[i] = htons(read_eeprom(ioaddr, i));
 426	if_port = read_eeprom(ioaddr, 8) >> 14;
 427	dev = alloc_etherdev(sizeof(struct el3_private));
 428	if (!dev) {
 429		release_region(ioaddr, EL3_IO_EXTENT);
 430		return -ENOMEM;
 431	}
 432	SET_NETDEV_DEV(dev, &pdev->dev);
 433	netdev_boot_setup_check(dev);
 434
 435	el3_dev_fill(dev, phys_addr, ioaddr, irq, if_port, EL3_PNP);
 436	pnp_set_drvdata(pdev, dev);
 437	err = el3_common_init(dev);
 438
 439	if (err) {
 440		pnp_set_drvdata(pdev, NULL);
 441		free_netdev(dev);
 442		return err;
 443	}
 444
 445	el3_devs[el3_cards++] = dev;
 446	return 0;
 447}
 448
 449static void __devexit el3_pnp_remove(struct pnp_dev *pdev)
 450{
 451	el3_common_remove(pnp_get_drvdata(pdev));
 452	pnp_set_drvdata(pdev, NULL);
 453}
 454
 455#ifdef CONFIG_PM
 456static int el3_pnp_suspend(struct pnp_dev *pdev, pm_message_t state)
 457{
 458	return el3_suspend(&pdev->dev, state);
 459}
 460
 461static int el3_pnp_resume(struct pnp_dev *pdev)
 462{
 463	return el3_resume(&pdev->dev);
 464}
 465#endif
 466
 467static struct pnp_driver el3_pnp_driver = {
 468	.name		= "3c509",
 469	.id_table	= el3_pnp_ids,
 470	.probe		= el3_pnp_probe,
 471	.remove		= __devexit_p(el3_pnp_remove),
 472#ifdef CONFIG_PM
 473	.suspend	= el3_pnp_suspend,
 474	.resume		= el3_pnp_resume,
 475#endif
 476};
 477static int pnp_registered;
 478#endif /* CONFIG_PNP */
 479
 480#ifdef CONFIG_EISA
 481static struct eisa_device_id el3_eisa_ids[] = {
 482		{ "TCM5090" },
 483		{ "TCM5091" },
 484		{ "TCM5092" },
 485		{ "TCM5093" },
 486		{ "TCM5094" },
 487		{ "TCM5095" },
 488		{ "TCM5098" },
 489		{ "" }
 490};
 491MODULE_DEVICE_TABLE(eisa, el3_eisa_ids);
 492
 493static int el3_eisa_probe (struct device *device);
 494
 495static struct eisa_driver el3_eisa_driver = {
 496		.id_table = el3_eisa_ids,
 497		.driver   = {
 498				.name    = "3c579",
 499				.probe   = el3_eisa_probe,
 500				.remove  = __devexit_p (el3_device_remove),
 501				.suspend = el3_suspend,
 502				.resume  = el3_resume,
 503		}
 504};
 505static int eisa_registered;
 506#endif
 507
 508#ifdef CONFIG_MCA
 509static int el3_mca_probe(struct device *dev);
 510
 511static short el3_mca_adapter_ids[] __initdata = {
 512		0x627c,
 513		0x627d,
 514		0x62db,
 515		0x62f6,
 516		0x62f7,
 517		0x0000
 518};
 519
 520static char *el3_mca_adapter_names[] __initdata = {
 521		"3Com 3c529 EtherLink III (10base2)",
 522		"3Com 3c529 EtherLink III (10baseT)",
 523		"3Com 3c529 EtherLink III (test mode)",
 524		"3Com 3c529 EtherLink III (TP or coax)",
 525		"3Com 3c529 EtherLink III (TP)",
 526		NULL
 527};
 528
 529static struct mca_driver el3_mca_driver = {
 530		.id_table = el3_mca_adapter_ids,
 531		.driver = {
 532				.name = "3c529",
 533				.bus = &mca_bus_type,
 534				.probe = el3_mca_probe,
 535				.remove = __devexit_p(el3_device_remove),
 536				.suspend = el3_suspend,
 537				.resume  = el3_resume,
 538		},
 539};
 540static int mca_registered;
 541#endif /* CONFIG_MCA */
 542
 543static const struct net_device_ops netdev_ops = {
 544	.ndo_open 		= el3_open,
 545	.ndo_stop	 	= el3_close,
 546	.ndo_start_xmit 	= el3_start_xmit,
 547	.ndo_get_stats 		= el3_get_stats,
 548	.ndo_set_multicast_list = set_multicast_list,
 549	.ndo_tx_timeout 	= el3_tx_timeout,
 550	.ndo_change_mtu		= eth_change_mtu,
 551	.ndo_set_mac_address 	= eth_mac_addr,
 552	.ndo_validate_addr	= eth_validate_addr,
 553#ifdef CONFIG_NET_POLL_CONTROLLER
 554	.ndo_poll_controller	= el3_poll_controller,
 555#endif
 556};
 557
 558static int __devinit el3_common_init(struct net_device *dev)
 559{
 560	struct el3_private *lp = netdev_priv(dev);
 561	int err;
 562	const char *if_names[] = {"10baseT", "AUI", "undefined", "BNC"};
 563
 564	spin_lock_init(&lp->lock);
 565
 566	if (dev->mem_start & 0x05) { /* xcvr codes 1/3/4/12 */
 567		dev->if_port = (dev->mem_start & 0x0f);
 568	} else { /* xcvr codes 0/8 */
 569		/* use eeprom value, but save user's full-duplex selection */
 570		dev->if_port |= (dev->mem_start & 0x08);
 571	}
 572
 573	/* The EL3-specific entries in the device structure. */
 574	dev->netdev_ops = &netdev_ops;
 575	dev->watchdog_timeo = TX_TIMEOUT;
 576	SET_ETHTOOL_OPS(dev, &ethtool_ops);
 577
 578	err = register_netdev(dev);
 579	if (err) {
 580		pr_err("Failed to register 3c5x9 at %#3.3lx, IRQ %d.\n",
 581			dev->base_addr, dev->irq);
 582		release_region(dev->base_addr, EL3_IO_EXTENT);
 583		return err;
 584	}
 585
 586	pr_info("%s: 3c5x9 found at %#3.3lx, %s port, address %pM, IRQ %d.\n",
 587	       dev->name, dev->base_addr, if_names[(dev->if_port & 0x03)],
 588	       dev->dev_addr, dev->irq);
 589
 590	if (el3_debug > 0)
 591		pr_info("%s", version);
 592	return 0;
 593
 594}
 595
 596static void el3_common_remove (struct net_device *dev)
 597{
 598	unregister_netdev (dev);
 599	release_region(dev->base_addr, EL3_IO_EXTENT);
 600	free_netdev (dev);
 601}
 602
 603#ifdef CONFIG_MCA
 604static int __init el3_mca_probe(struct device *device)
 605{
 606	/* Based on Erik Nygren's (nygren@mit.edu) 3c529 patch,
 607	 * heavily modified by Chris Beauregard
 608	 * (cpbeaure@csclub.uwaterloo.ca) to support standard MCA
 609	 * probing.
 610	 *
 611	 * redone for multi-card detection by ZP Gu (zpg@castle.net)
 612	 * now works as a module */
 613
 614	short i;
 615	int ioaddr, irq, if_port;
 616	__be16 phys_addr[3];
 617	struct net_device *dev = NULL;
 618	u_char pos4, pos5;
 619	struct mca_device *mdev = to_mca_device(device);
 620	int slot = mdev->slot;
 621	int err;
 622
 623	pos4 = mca_device_read_stored_pos(mdev, 4);
 624	pos5 = mca_device_read_stored_pos(mdev, 5);
 625
 626	ioaddr = ((short)((pos4&0xfc)|0x02)) << 8;
 627	irq = pos5 & 0x0f;
 628
 629
 630	pr_info("3c529: found %s at slot %d\n",
 631		el3_mca_adapter_names[mdev->index], slot + 1);
 632
 633	/* claim the slot */
 634	strncpy(mdev->name, el3_mca_adapter_names[mdev->index],
 635			sizeof(mdev->name));
 636	mca_device_set_claim(mdev, 1);
 637
 638	if_port = pos4 & 0x03;
 639
 640	irq = mca_device_transform_irq(mdev, irq);
 641	ioaddr = mca_device_transform_ioport(mdev, ioaddr);
 642	if (el3_debug > 2) {
 643		pr_debug("3c529: irq %d  ioaddr 0x%x  ifport %d\n", irq, ioaddr, if_port);
 644	}
 645	EL3WINDOW(0);
 646	for (i = 0; i < 3; i++)
 647		phys_addr[i] = htons(read_eeprom(ioaddr, i));
 648
 649	dev = alloc_etherdev(sizeof (struct el3_private));
 650	if (dev == NULL) {
 651		release_region(ioaddr, EL3_IO_EXTENT);
 652		return -ENOMEM;
 653	}
 654
 655	netdev_boot_setup_check(dev);
 656
 657	el3_dev_fill(dev, phys_addr, ioaddr, irq, if_port, EL3_MCA);
 658	dev_set_drvdata(device, dev);
 659	err = el3_common_init(dev);
 660
 661	if (err) {
 662		dev_set_drvdata(device, NULL);
 663		free_netdev(dev);
 664		return -ENOMEM;
 665	}
 666
 667	el3_devs[el3_cards++] = dev;
 668	return 0;
 669}
 670
 671#endif /* CONFIG_MCA */
 672
 673#ifdef CONFIG_EISA
 674static int __init el3_eisa_probe (struct device *device)
 675{
 676	short i;
 677	int ioaddr, irq, if_port;
 678	__be16 phys_addr[3];
 679	struct net_device *dev = NULL;
 680	struct eisa_device *edev;
 681	int err;
 682
 683	/* Yeepee, The driver framework is calling us ! */
 684	edev = to_eisa_device (device);
 685	ioaddr = edev->base_addr;
 686
 687	if (!request_region(ioaddr, EL3_IO_EXTENT, "3c579-eisa"))
 688		return -EBUSY;
 689
 690	/* Change the register set to the configuration window 0. */
 691	outw(SelectWindow | 0, ioaddr + 0xC80 + EL3_CMD);
 692
 693	irq = inw(ioaddr + WN0_IRQ) >> 12;
 694	if_port = inw(ioaddr + 6)>>14;
 695	for (i = 0; i < 3; i++)
 696		phys_addr[i] = htons(read_eeprom(ioaddr, i));
 697
 698	/* Restore the "Product ID" to the EEPROM read register. */
 699	read_eeprom(ioaddr, 3);
 700
 701	dev = alloc_etherdev(sizeof (struct el3_private));
 702	if (dev == NULL) {
 703		release_region(ioaddr, EL3_IO_EXTENT);
 704		return -ENOMEM;
 705	}
 706
 707	netdev_boot_setup_check(dev);
 708
 709	el3_dev_fill(dev, phys_addr, ioaddr, irq, if_port, EL3_EISA);
 710	eisa_set_drvdata (edev, dev);
 711	err = el3_common_init(dev);
 712
 713	if (err) {
 714		eisa_set_drvdata (edev, NULL);
 715		free_netdev(dev);
 716		return err;
 717	}
 718
 719	el3_devs[el3_cards++] = dev;
 720	return 0;
 721}
 722#endif
 723
 724/* This remove works for all device types.
 725 *
 726 * The net dev must be stored in the driver data field */
 727static int __devexit el3_device_remove (struct device *device)
 728{
 729	struct net_device *dev;
 730
 731	dev = dev_get_drvdata(device);
 732
 733	el3_common_remove (dev);
 734	return 0;
 735}
 736
 737/* Read a word from the EEPROM using the regular EEPROM access register.
 738   Assume that we are in register window zero.
 739 */
 740static ushort read_eeprom(int ioaddr, int index)
 741{
 742	outw(EEPROM_READ + index, ioaddr + 10);
 743	/* Pause for at least 162 us. for the read to take place.
 744	   Some chips seem to require much longer */
 745	mdelay(2);
 746	return inw(ioaddr + 12);
 747}
 748
 749/* Read a word from the EEPROM when in the ISA ID probe state. */
 750static ushort id_read_eeprom(int index)
 751{
 752	int bit, word = 0;
 753
 754	/* Issue read command, and pause for at least 162 us. for it to complete.
 755	   Assume extra-fast 16Mhz bus. */
 756	outb(EEPROM_READ + index, id_port);
 757
 758	/* Pause for at least 162 us. for the read to take place. */
 759	/* Some chips seem to require much longer */
 760	mdelay(4);
 761
 762	for (bit = 15; bit >= 0; bit--)
 763		word = (word << 1) + (inb(id_port) & 0x01);
 764
 765	if (el3_debug > 3)
 766		pr_debug("  3c509 EEPROM word %d %#4.4x.\n", index, word);
 767
 768	return word;
 769}
 770
 771
 772static int
 773el3_open(struct net_device *dev)
 774{
 775	int ioaddr = dev->base_addr;
 776	int i;
 777
 778	outw(TxReset, ioaddr + EL3_CMD);
 779	outw(RxReset, ioaddr + EL3_CMD);
 780	outw(SetStatusEnb | 0x00, ioaddr + EL3_CMD);
 781
 782	i = request_irq(dev->irq, el3_interrupt, 0, dev->name, dev);
 783	if (i)
 784		return i;
 785
 786	EL3WINDOW(0);
 787	if (el3_debug > 3)
 788		pr_debug("%s: Opening, IRQ %d	 status@%x %4.4x.\n", dev->name,
 789			   dev->irq, ioaddr + EL3_STATUS, inw(ioaddr + EL3_STATUS));
 790
 791	el3_up(dev);
 792
 793	if (el3_debug > 3)
 794		pr_debug("%s: Opened 3c509  IRQ %d  status %4.4x.\n",
 795			   dev->name, dev->irq, inw(ioaddr + EL3_STATUS));
 796
 797	return 0;
 798}
 799
 800static void
 801el3_tx_timeout (struct net_device *dev)
 802{
 803	int ioaddr = dev->base_addr;
 804
 805	/* Transmitter timeout, serious problems. */
 806	pr_warning("%s: transmit timed out, Tx_status %2.2x status %4.4x Tx FIFO room %d.\n",
 807		   dev->name, inb(ioaddr + TX_STATUS), inw(ioaddr + EL3_STATUS),
 808		   inw(ioaddr + TX_FREE));
 809	dev->stats.tx_errors++;
 810	dev->trans_start = jiffies; /* prevent tx timeout */
 811	/* Issue TX_RESET and TX_START commands. */
 812	outw(TxReset, ioaddr + EL3_CMD);
 813	outw(TxEnable, ioaddr + EL3_CMD);
 814	netif_wake_queue(dev);
 815}
 816
 817
 818static netdev_tx_t
 819el3_start_xmit(struct sk_buff *skb, struct net_device *dev)
 820{
 821	struct el3_private *lp = netdev_priv(dev);
 822	int ioaddr = dev->base_addr;
 823	unsigned long flags;
 824
 825	netif_stop_queue (dev);
 826
 827	dev->stats.tx_bytes += skb->len;
 828
 829	if (el3_debug > 4) {
 830		pr_debug("%s: el3_start_xmit(length = %u) called, status %4.4x.\n",
 831			   dev->name, skb->len, inw(ioaddr + EL3_STATUS));
 832	}
 833#if 0
 834#ifndef final_version
 835	{	/* Error-checking code, delete someday. */
 836		ushort status = inw(ioaddr + EL3_STATUS);
 837		if (status & 0x0001 && 		/* IRQ line active, missed one. */
 838		    inw(ioaddr + EL3_STATUS) & 1) { 			/* Make sure. */
 839			pr_debug("%s: Missed interrupt, status then %04x now %04x"
 840				   "  Tx %2.2x Rx %4.4x.\n", dev->name, status,
 841				   inw(ioaddr + EL3_STATUS), inb(ioaddr + TX_STATUS),
 842				   inw(ioaddr + RX_STATUS));
 843			/* Fake interrupt trigger by masking, acknowledge interrupts. */
 844			outw(SetStatusEnb | 0x00, ioaddr + EL3_CMD);
 845			outw(AckIntr | IntLatch | TxAvailable | RxEarly | IntReq,
 846				 ioaddr + EL3_CMD);
 847			outw(SetStatusEnb | 0xff, ioaddr + EL3_CMD);
 848		}
 849	}
 850#endif
 851#endif
 852	/*
 853	 *	We lock the driver against other processors. Note
 854	 *	we don't need to lock versus the IRQ as we suspended
 855	 *	that. This means that we lose the ability to take
 856	 *	an RX during a TX upload. That sucks a bit with SMP
 857	 *	on an original 3c509 (2K buffer)
 858	 *
 859	 *	Using disable_irq stops us crapping on other
 860	 *	time sensitive devices.
 861	 */
 862
 863	spin_lock_irqsave(&lp->lock, flags);
 864
 865	/* Put out the doubleword header... */
 866	outw(skb->len, ioaddr + TX_FIFO);
 867	outw(0x00, ioaddr + TX_FIFO);
 868	/* ... and the packet rounded to a doubleword. */
 869	outsl(ioaddr + TX_FIFO, skb->data, (skb->len + 3) >> 2);
 870
 871	if (inw(ioaddr + TX_FREE) > 1536)
 872		netif_start_queue(dev);
 873	else
 874		/* Interrupt us when the FIFO has room for max-sized packet. */
 875		outw(SetTxThreshold + 1536, ioaddr + EL3_CMD);
 876
 877	spin_unlock_irqrestore(&lp->lock, flags);
 878
 879	dev_kfree_skb (skb);
 880
 881	/* Clear the Tx status stack. */
 882	{
 883		short tx_status;
 884		int i = 4;
 885
 886		while (--i > 0	&&	(tx_status = inb(ioaddr + TX_STATUS)) > 0) {
 887			if (tx_status & 0x38) dev->stats.tx_aborted_errors++;
 888			if (tx_status & 0x30) outw(TxReset, ioaddr + EL3_CMD);
 889			if (tx_status & 0x3C) outw(TxEnable, ioaddr + EL3_CMD);
 890			outb(0x00, ioaddr + TX_STATUS); /* Pop the status stack. */
 891		}
 892	}
 893	return NETDEV_TX_OK;
 894}
 895
 896/* The EL3 interrupt handler. */
 897static irqreturn_t
 898el3_interrupt(int irq, void *dev_id)
 899{
 900	struct net_device *dev = dev_id;
 901	struct el3_private *lp;
 902	int ioaddr, status;
 903	int i = max_interrupt_work;
 904
 905	lp = netdev_priv(dev);
 906	spin_lock(&lp->lock);
 907
 908	ioaddr = dev->base_addr;
 909
 910	if (el3_debug > 4) {
 911		status = inw(ioaddr + EL3_STATUS);
 912		pr_debug("%s: interrupt, status %4.4x.\n", dev->name, status);
 913	}
 914
 915	while ((status = inw(ioaddr + EL3_STATUS)) &
 916		   (IntLatch | RxComplete | StatsFull)) {
 917
 918		if (status & RxComplete)
 919			el3_rx(dev);
 920
 921		if (status & TxAvailable) {
 922			if (el3_debug > 5)
 923				pr_debug("	TX room bit was handled.\n");
 924			/* There's room in the FIFO for a full-sized packet. */
 925			outw(AckIntr | TxAvailable, ioaddr + EL3_CMD);
 926			netif_wake_queue (dev);
 927		}
 928		if (status & (AdapterFailure | RxEarly | StatsFull | TxComplete)) {
 929			/* Handle all uncommon interrupts. */
 930			if (status & StatsFull)				/* Empty statistics. */
 931				update_stats(dev);
 932			if (status & RxEarly) {				/* Rx early is unused. */
 933				el3_rx(dev);
 934				outw(AckIntr | RxEarly, ioaddr + EL3_CMD);
 935			}
 936			if (status & TxComplete) {			/* Really Tx error. */
 937				short tx_status;
 938				int i = 4;
 939
 940				while (--i>0 && (tx_status = inb(ioaddr + TX_STATUS)) > 0) {
 941					if (tx_status & 0x38) dev->stats.tx_aborted_errors++;
 942					if (tx_status & 0x30) outw(TxReset, ioaddr + EL3_CMD);
 943					if (tx_status & 0x3C) outw(TxEnable, ioaddr + EL3_CMD);
 944					outb(0x00, ioaddr + TX_STATUS); /* Pop the status stack. */
 945				}
 946			}
 947			if (status & AdapterFailure) {
 948				/* Adapter failure requires Rx reset and reinit. */
 949				outw(RxReset, ioaddr + EL3_CMD);
 950				/* Set the Rx filter to the current state. */
 951				outw(SetRxFilter | RxStation | RxBroadcast
 952					 | (dev->flags & IFF_ALLMULTI ? RxMulticast : 0)
 953					 | (dev->flags & IFF_PROMISC ? RxProm : 0),
 954					 ioaddr + EL3_CMD);
 955				outw(RxEnable, ioaddr + EL3_CMD); /* Re-enable the receiver. */
 956				outw(AckIntr | AdapterFailure, ioaddr + EL3_CMD);
 957			}
 958		}
 959
 960		if (--i < 0) {
 961			pr_err("%s: Infinite loop in interrupt, status %4.4x.\n",
 962				   dev->name, status);
 963			/* Clear all interrupts. */
 964			outw(AckIntr | 0xFF, ioaddr + EL3_CMD);
 965			break;
 966		}
 967		/* Acknowledge the IRQ. */
 968		outw(AckIntr | IntReq | IntLatch, ioaddr + EL3_CMD); /* Ack IRQ */
 969	}
 970
 971	if (el3_debug > 4) {
 972		pr_debug("%s: exiting interrupt, status %4.4x.\n", dev->name,
 973			   inw(ioaddr + EL3_STATUS));
 974	}
 975	spin_unlock(&lp->lock);
 976	return IRQ_HANDLED;
 977}
 978
 979
 980#ifdef CONFIG_NET_POLL_CONTROLLER
 981/*
 982 * Polling receive - used by netconsole and other diagnostic tools
 983 * to allow network i/o with interrupts disabled.
 984 */
 985static void el3_poll_controller(struct net_device *dev)
 986{
 987	disable_irq(dev->irq);
 988	el3_interrupt(dev->irq, dev);
 989	enable_irq(dev->irq);
 990}
 991#endif
 992
 993static struct net_device_stats *
 994el3_get_stats(struct net_device *dev)
 995{
 996	struct el3_private *lp = netdev_priv(dev);
 997	unsigned long flags;
 998
 999	/*
1000	 *	This is fast enough not to bother with disable IRQ
1001	 *	stuff.
1002	 */
1003
1004	spin_lock_irqsave(&lp->lock, flags);
1005	update_stats(dev);
1006	spin_unlock_irqrestore(&lp->lock, flags);
1007	return &dev->stats;
1008}
1009
1010/*  Update statistics.  We change to register window 6, so this should be run
1011	single-threaded if the device is active. This is expected to be a rare
1012	operation, and it's simpler for the rest of the driver to assume that
1013	window 1 is always valid rather than use a special window-state variable.
1014	*/
1015static void update_stats(struct net_device *dev)
1016{
1017	int ioaddr = dev->base_addr;
1018
1019	if (el3_debug > 5)
1020		pr_debug("   Updating the statistics.\n");
1021	/* Turn off statistics updates while reading. */
1022	outw(StatsDisable, ioaddr + EL3_CMD);
1023	/* Switch to the stats window, and read everything. */
1024	EL3WINDOW(6);
1025	dev->stats.tx_carrier_errors 	+= inb(ioaddr + 0);
1026	dev->stats.tx_heartbeat_errors	+= inb(ioaddr + 1);
1027	/* Multiple collisions. */	   inb(ioaddr + 2);
1028	dev->stats.collisions		+= inb(ioaddr + 3);
1029	dev->stats.tx_window_errors	+= inb(ioaddr + 4);
1030	dev->stats.rx_fifo_errors	+= inb(ioaddr + 5);
1031	dev->stats.tx_packets		+= inb(ioaddr + 6);
1032	/* Rx packets	*/		   inb(ioaddr + 7);
1033	/* Tx deferrals */		   inb(ioaddr + 8);
1034	inw(ioaddr + 10);	/* Total Rx and Tx octets. */
1035	inw(ioaddr + 12);
1036
1037	/* Back to window 1, and turn statistics back on. */
1038	EL3WINDOW(1);
1039	outw(StatsEnable, ioaddr + EL3_CMD);
1040}
1041
1042static int
1043el3_rx(struct net_device *dev)
1044{
1045	int ioaddr = dev->base_addr;
1046	short rx_status;
1047
1048	if (el3_debug > 5)
1049		pr_debug("   In rx_packet(), status %4.4x, rx_status %4.4x.\n",
1050			   inw(ioaddr+EL3_STATUS), inw(ioaddr+RX_STATUS));
1051	while ((rx_status = inw(ioaddr + RX_STATUS)) > 0) {
1052		if (rx_status & 0x4000) { /* Error, update stats. */
1053			short error = rx_status & 0x3800;
1054
1055			outw(RxDiscard, ioaddr + EL3_CMD);
1056			dev->stats.rx_errors++;
1057			switch (error) {
1058			case 0x0000:		dev->stats.rx_over_errors++; break;
1059			case 0x0800:		dev->stats.rx_length_errors++; break;
1060			case 0x1000:		dev->stats.rx_frame_errors++; break;
1061			case 0x1800:		dev->stats.rx_length_errors++; break;
1062			case 0x2000:		dev->stats.rx_frame_errors++; break;
1063			case 0x2800:		dev->stats.rx_crc_errors++; break;
1064			}
1065		} else {
1066			short pkt_len = rx_status & 0x7ff;
1067			struct sk_buff *skb;
1068
1069			skb = dev_alloc_skb(pkt_len+5);
1070			if (el3_debug > 4)
1071				pr_debug("Receiving packet size %d status %4.4x.\n",
1072					   pkt_len, rx_status);
1073			if (skb != NULL) {
1074				skb_reserve(skb, 2);     /* Align IP on 16 byte */
1075
1076				/* 'skb->data' points to the start of sk_buff data area. */
1077				insl(ioaddr + RX_FIFO, skb_put(skb,pkt_len),
1078					 (pkt_len + 3) >> 2);
1079
1080				outw(RxDiscard, ioaddr + EL3_CMD); /* Pop top Rx packet. */
1081				skb->protocol = eth_type_trans(skb,dev);
1082				netif_rx(skb);
1083				dev->stats.rx_bytes += pkt_len;
1084				dev->stats.rx_packets++;
1085				continue;
1086			}
1087			outw(RxDiscard, ioaddr + EL3_CMD);
1088			dev->stats.rx_dropped++;
1089			if (el3_debug)
1090				pr_debug("%s: Couldn't allocate a sk_buff of size %d.\n",
1091					   dev->name, pkt_len);
1092		}
1093		inw(ioaddr + EL3_STATUS); 				/* Delay. */
1094		while (inw(ioaddr + EL3_STATUS) & 0x1000)
1095			pr_debug("	Waiting for 3c509 to discard packet, status %x.\n",
1096				   inw(ioaddr + EL3_STATUS) );
1097	}
1098
1099	return 0;
1100}
1101
1102/*
1103 *     Set or clear the multicast filter for this adaptor.
1104 */
1105static void
1106set_multicast_list(struct net_device *dev)
1107{
1108	unsigned long flags;
1109	struct el3_private *lp = netdev_priv(dev);
1110	int ioaddr = dev->base_addr;
1111	int mc_count = netdev_mc_count(dev);
1112
1113	if (el3_debug > 1) {
1114		static int old;
1115		if (old != mc_count) {
1116			old = mc_count;
1117			pr_debug("%s: Setting Rx mode to %d addresses.\n",
1118				 dev->name, mc_count);
1119		}
1120	}
1121	spin_lock_irqsave(&lp->lock, flags);
1122	if (dev->flags&IFF_PROMISC) {
1123		outw(SetRxFilter | RxStation | RxMulticast | RxBroadcast | RxProm,
1124			 ioaddr + EL3_CMD);
1125	}
1126	else if (mc_count || (dev->flags&IFF_ALLMULTI)) {
1127		outw(SetRxFilter | RxStation | RxMulticast | RxBroadcast, ioaddr + EL3_CMD);
1128	}
1129	else
1130		outw(SetRxFilter | RxStation | RxBroadcast, ioaddr + EL3_CMD);
1131	spin_unlock_irqrestore(&lp->lock, flags);
1132}
1133
1134static int
1135el3_close(struct net_device *dev)
1136{
1137	int ioaddr = dev->base_addr;
1138	struct el3_private *lp = netdev_priv(dev);
1139
1140	if (el3_debug > 2)
1141		pr_debug("%s: Shutting down ethercard.\n", dev->name);
1142
1143	el3_down(dev);
1144
1145	free_irq(dev->irq, dev);
1146	/* Switching back to window 0 disables the IRQ. */
1147	EL3WINDOW(0);
1148	if (lp->type != EL3_EISA) {
1149		/* But we explicitly zero the IRQ line select anyway. Don't do
1150		 * it on EISA cards, it prevents the module from getting an
1151		 * IRQ after unload+reload... */
1152		outw(0x0f00, ioaddr + WN0_IRQ);
1153	}
1154
1155	return 0;
1156}
1157
1158static int
1159el3_link_ok(struct net_device *dev)
1160{
1161	int ioaddr = dev->base_addr;
1162	u16 tmp;
1163
1164	EL3WINDOW(4);
1165	tmp = inw(ioaddr + WN4_MEDIA);
1166	EL3WINDOW(1);
1167	return tmp & (1<<11);
1168}
1169
1170static int
1171el3_netdev_get_ecmd(struct net_device *dev, struct ethtool_cmd *ecmd)
1172{
1173	u16 tmp;
1174	int ioaddr = dev->base_addr;
1175
1176	EL3WINDOW(0);
1177	/* obtain current transceiver via WN4_MEDIA? */
1178	tmp = inw(ioaddr + WN0_ADDR_CONF);
1179	ecmd->transceiver = XCVR_INTERNAL;
1180	switch (tmp >> 14) {
1181	case 0:
1182		ecmd->port = PORT_TP;
1183		break;
1184	case 1:
1185		ecmd->port = PORT_AUI;
1186		ecmd->transceiver = XCVR_EXTERNAL;
1187		break;
1188	case 3:
1189		ecmd->port = PORT_BNC;
1190	default:
1191		break;
1192	}
1193
1194	ecmd->duplex = DUPLEX_HALF;
1195	ecmd->supported = 0;
1196	tmp = inw(ioaddr + WN0_CONF_CTRL);
1197	if (tmp & (1<<13))
1198		ecmd->supported |= SUPPORTED_AUI;
1199	if (tmp & (1<<12))
1200		ecmd->supported |= SUPPORTED_BNC;
1201	if (tmp & (1<<9)) {
1202		ecmd->supported |= SUPPORTED_TP | SUPPORTED_10baseT_Half |
1203				SUPPORTED_10baseT_Full;	/* hmm... */
1204		EL3WINDOW(4);
1205		tmp = inw(ioaddr + WN4_NETDIAG);
1206		if (tmp & FD_ENABLE)
1207			ecmd->duplex = DUPLEX_FULL;
1208	}
1209
1210	ethtool_cmd_speed_set(ecmd, SPEED_10);
1211	EL3WINDOW(1);
1212	return 0;
1213}
1214
1215static int
1216el3_netdev_set_ecmd(struct net_device *dev, struct ethtool_cmd *ecmd)
1217{
1218	u16 tmp;
1219	int ioaddr = dev->base_addr;
1220
1221	if (ecmd->speed != SPEED_10)
1222		return -EINVAL;
1223	if ((ecmd->duplex != DUPLEX_HALF) && (ecmd->duplex != DUPLEX_FULL))
1224		return -EINVAL;
1225	if ((ecmd->transceiver != XCVR_INTERNAL) && (ecmd->transceiver != XCVR_EXTERNAL))
1226		return -EINVAL;
1227
1228	/* change XCVR type */
1229	EL3WINDOW(0);
1230	tmp = inw(ioaddr + WN0_ADDR_CONF);
1231	switch (ecmd->port) {
1232	case PORT_TP:
1233		tmp &= ~(3<<14);
1234		dev->if_port = 0;
1235		break;
1236	case PORT_AUI:
1237		tmp |= (1<<14);
1238		dev->if_port = 1;
1239		break;
1240	case PORT_BNC:
1241		tmp |= (3<<14);
1242		dev->if_port = 3;
1243		break;
1244	default:
1245		return -EINVAL;
1246	}
1247
1248	outw(tmp, ioaddr + WN0_ADDR_CONF);
1249	if (dev->if_port == 3) {
1250		/* fire up the DC-DC convertor if BNC gets enabled */
1251		tmp = inw(ioaddr + WN0_ADDR_CONF);
1252		if (tmp & (3 << 14)) {
1253			outw(StartCoax, ioaddr + EL3_CMD);
1254			udelay(800);
1255		} else
1256			return -EIO;
1257	}
1258
1259	EL3WINDOW(4);
1260	tmp = inw(ioaddr + WN4_NETDIAG);
1261	if (ecmd->duplex == DUPLEX_FULL)
1262		tmp |= FD_ENABLE;
1263	else
1264		tmp &= ~FD_ENABLE;
1265	outw(tmp, ioaddr + WN4_NETDIAG);
1266	EL3WINDOW(1);
1267
1268	return 0;
1269}
1270
1271static void el3_get_drvinfo(struct net_device *dev, struct ethtool_drvinfo *info)
1272{
1273	strcpy(info->driver, DRV_NAME);
1274	strcpy(info->version, DRV_VERSION);
1275}
1276
1277static int el3_get_settings(struct net_device *dev, struct ethtool_cmd *ecmd)
1278{
1279	struct el3_private *lp = netdev_priv(dev);
1280	int ret;
1281
1282	spin_lock_irq(&lp->lock);
1283	ret = el3_netdev_get_ecmd(dev, ecmd);
1284	spin_unlock_irq(&lp->lock);
1285	return ret;
1286}
1287
1288static int el3_set_settings(struct net_device *dev, struct ethtool_cmd *ecmd)
1289{
1290	struct el3_private *lp = netdev_priv(dev);
1291	int ret;
1292
1293	spin_lock_irq(&lp->lock);
1294	ret = el3_netdev_set_ecmd(dev, ecmd);
1295	spin_unlock_irq(&lp->lock);
1296	return ret;
1297}
1298
1299static u32 el3_get_link(struct net_device *dev)
1300{
1301	struct el3_private *lp = netdev_priv(dev);
1302	u32 ret;
1303
1304	spin_lock_irq(&lp->lock);
1305	ret = el3_link_ok(dev);
1306	spin_unlock_irq(&lp->lock);
1307	return ret;
1308}
1309
1310static u32 el3_get_msglevel(struct net_device *dev)
1311{
1312	return el3_debug;
1313}
1314
1315static void el3_set_msglevel(struct net_device *dev, u32 v)
1316{
1317	el3_debug = v;
1318}
1319
1320static const struct ethtool_ops ethtool_ops = {
1321	.get_drvinfo = el3_get_drvinfo,
1322	.get_settings = el3_get_settings,
1323	.set_settings = el3_set_settings,
1324	.get_link = el3_get_link,
1325	.get_msglevel = el3_get_msglevel,
1326	.set_msglevel = el3_set_msglevel,
1327};
1328
1329static void
1330el3_down(struct net_device *dev)
1331{
1332	int ioaddr = dev->base_addr;
1333
1334	netif_stop_queue(dev);
1335
1336	/* Turn off statistics ASAP.  We update lp->stats below. */
1337	outw(StatsDisable, ioaddr + EL3_CMD);
1338
1339	/* Disable the receiver and transmitter. */
1340	outw(RxDisable, ioaddr + EL3_CMD);
1341	outw(TxDisable, ioaddr + EL3_CMD);
1342
1343	if (dev->if_port == 3)
1344		/* Turn off thinnet power.  Green! */
1345		outw(StopCoax, ioaddr + EL3_CMD);
1346	else if (dev->if_port == 0) {
1347		/* Disable link beat and jabber, if_port may change here next open(). */
1348		EL3WINDOW(4);
1349		outw(inw(ioaddr + WN4_MEDIA) & ~MEDIA_TP, ioaddr + WN4_MEDIA);
1350	}
1351
1352	outw(SetIntrEnb | 0x0000, ioaddr + EL3_CMD);
1353
1354	update_stats(dev);
1355}
1356
1357static void
1358el3_up(struct net_device *dev)
1359{
1360	int i, sw_info, net_diag;
1361	int ioaddr = dev->base_addr;
1362
1363	/* Activating the board required and does no harm otherwise */
1364	outw(0x0001, ioaddr + 4);
1365
1366	/* Set the IRQ line. */
1367	outw((dev->irq << 12) | 0x0f00, ioaddr + WN0_IRQ);
1368
1369	/* Set the station address in window 2 each time opened. */
1370	EL3WINDOW(2);
1371
1372	for (i = 0; i < 6; i++)
1373		outb(dev->dev_addr[i], ioaddr + i);
1374
1375	if ((dev->if_port & 0x03) == 3) /* BNC interface */
1376		/* Start the thinnet transceiver. We should really wait 50ms...*/
1377		outw(StartCoax, ioaddr + EL3_CMD);
1378	else if ((dev->if_port & 0x03) == 0) { /* 10baseT interface */
1379		/* Combine secondary sw_info word (the adapter level) and primary
1380			sw_info word (duplex setting plus other useless bits) */
1381		EL3WINDOW(0);
1382		sw_info = (read_eeprom(ioaddr, 0x14) & 0x400f) |
1383			(read_eeprom(ioaddr, 0x0d) & 0xBff0);
1384
1385		EL3WINDOW(4);
1386		net_diag = inw(ioaddr + WN4_NETDIAG);
1387		net_diag = (net_diag | FD_ENABLE); /* temporarily assume full-duplex will be set */
1388		pr_info("%s: ", dev->name);
1389		switch (dev->if_port & 0x0c) {
1390			case 12:
1391				/* force full-duplex mode if 3c5x9b */
1392				if (sw_info & 0x000f) {
1393					pr_cont("Forcing 3c5x9b full-duplex mode");
1394					break;
1395				}
1396			case 8:
1397				/* set full-duplex mode based on eeprom config setting */
1398				if ((sw_info & 0x000f) && (sw_info & 0x8000)) {
1399					pr_cont("Setting 3c5x9b full-duplex mode (from EEPROM configuration bit)");
1400					break;
1401				}
1402			default:
1403				/* xcvr=(0 || 4) OR user has an old 3c5x9 non "B" model */
1404				pr_cont("Setting 3c5x9/3c5x9B half-duplex mode");
1405				net_diag = (net_diag & ~FD_ENABLE); /* disable full duplex */
1406		}
1407
1408		outw(net_diag, ioaddr + WN4_NETDIAG);
1409		pr_cont(" if_port: %d, sw_info: %4.4x\n", dev->if_port, sw_info);
1410		if (el3_debug > 3)
1411			pr_debug("%s: 3c5x9 net diag word is now: %4.4x.\n", dev->name, net_diag);
1412		/* Enable link beat and jabber check. */
1413		outw(inw(ioaddr + WN4_MEDIA) | MEDIA_TP, ioaddr + WN4_MEDIA);
1414	}
1415
1416	/* Switch to the stats window, and clear all stats by reading. */
1417	outw(StatsDisable, ioaddr + EL3_CMD);
1418	EL3WINDOW(6);
1419	for (i = 0; i < 9; i++)
1420		inb(ioaddr + i);
1421	inw(ioaddr + 10);
1422	inw(ioaddr + 12);
1423
1424	/* Switch to register set 1 for normal use. */
1425	EL3WINDOW(1);
1426
1427	/* Accept b-case and phys addr only. */
1428	outw(SetRxFilter | RxStation | RxBroadcast, ioaddr + EL3_CMD);
1429	outw(StatsEnable, ioaddr + EL3_CMD); /* Turn on statistics. */
1430
1431	outw(RxEnable, ioaddr + EL3_CMD); /* Enable the receiver. */
1432	outw(TxEnable, ioaddr + EL3_CMD); /* Enable transmitter. */
1433	/* Allow status bits to be seen. */
1434	outw(SetStatusEnb | 0xff, ioaddr + EL3_CMD);
1435	/* Ack all pending events, and set active indicator mask. */
1436	outw(AckIntr | IntLatch | TxAvailable | RxEarly | IntReq,
1437		 ioaddr + EL3_CMD);
1438	outw(SetIntrEnb | IntLatch|TxAvailable|TxComplete|RxComplete|StatsFull,
1439		 ioaddr + EL3_CMD);
1440
1441	netif_start_queue(dev);
1442}
1443
1444/* Power Management support functions */
1445#ifdef CONFIG_PM
1446
1447static int
1448el3_suspend(struct device *pdev, pm_message_t state)
1449{
1450	unsigned long flags;
1451	struct net_device *dev;
1452	struct el3_private *lp;
1453	int ioaddr;
1454
1455	dev = dev_get_drvdata(pdev);
1456	lp = netdev_priv(dev);
1457	ioaddr = dev->base_addr;
1458
1459	spin_lock_irqsave(&lp->lock, flags);
1460
1461	if (netif_running(dev))
1462		netif_device_detach(dev);
1463
1464	el3_down(dev);
1465	outw(PowerDown, ioaddr + EL3_CMD);
1466
1467	spin_unlock_irqrestore(&lp->lock, flags);
1468	return 0;
1469}
1470
1471static int
1472el3_resume(struct device *pdev)
1473{
1474	unsigned long flags;
1475	struct net_device *dev;
1476	struct el3_private *lp;
1477	int ioaddr;
1478
1479	dev = dev_get_drvdata(pdev);
1480	lp = netdev_priv(dev);
1481	ioaddr = dev->base_addr;
1482
1483	spin_lock_irqsave(&lp->lock, flags);
1484
1485	outw(PowerUp, ioaddr + EL3_CMD);
1486	EL3WINDOW(0);
1487	el3_up(dev);
1488
1489	if (netif_running(dev))
1490		netif_device_attach(dev);
1491
1492	spin_unlock_irqrestore(&lp->lock, flags);
1493	return 0;
1494}
1495
1496#endif /* CONFIG_PM */
1497
1498module_param(debug,int, 0);
1499module_param_array(irq, int, NULL, 0);
1500module_param(max_interrupt_work, int, 0);
1501MODULE_PARM_DESC(debug, "debug level (0-6)");
1502MODULE_PARM_DESC(irq, "IRQ number(s) (assigned)");
1503MODULE_PARM_DESC(max_interrupt_work, "maximum events handled per interrupt");
1504#ifdef CONFIG_PNP
1505module_param(nopnp, int, 0);
1506MODULE_PARM_DESC(nopnp, "disable ISA PnP support (0-1)");
1507#endif	/* CONFIG_PNP */
1508MODULE_DESCRIPTION("3Com Etherlink III (3c509, 3c509B, 3c529, 3c579) ethernet driver");
1509MODULE_LICENSE("GPL");
1510
1511static int __init el3_init_module(void)
1512{
1513	int ret = 0;
1514
1515	if (debug >= 0)
1516		el3_debug = debug;
1517
1518#ifdef CONFIG_PNP
1519	if (!nopnp) {
1520		ret = pnp_register_driver(&el3_pnp_driver);
1521		if (!ret)
1522			pnp_registered = 1;
1523	}
1524#endif
1525	/* Select an open I/O location at 0x1*0 to do ISA contention select. */
1526	/* Start with 0x110 to avoid some sound cards.*/
1527	for (id_port = 0x110 ; id_port < 0x200; id_port += 0x10) {
1528		if (!request_region(id_port, 1, "3c509-control"))
1529			continue;
1530		outb(0x00, id_port);
1531		outb(0xff, id_port);
1532		if (inb(id_port) & 0x01)
1533			break;
1534		else
1535			release_region(id_port, 1);
1536	}
1537	if (id_port >= 0x200) {
1538		id_port = 0;
1539		pr_err("No I/O port available for 3c509 activation.\n");
1540	} else {
1541		ret = isa_register_driver(&el3_isa_driver, EL3_MAX_CARDS);
1542		if (!ret)
1543			isa_registered = 1;
1544	}
1545#ifdef CONFIG_EISA
1546	ret = eisa_driver_register(&el3_eisa_driver);
1547	if (!ret)
1548		eisa_registered = 1;
1549#endif
1550#ifdef CONFIG_MCA
1551	ret = mca_register_driver(&el3_mca_driver);
1552	if (!ret)
1553		mca_registered = 1;
1554#endif
1555
1556#ifdef CONFIG_PNP
1557	if (pnp_registered)
1558		ret = 0;
1559#endif
1560	if (isa_registered)
1561		ret = 0;
1562#ifdef CONFIG_EISA
1563	if (eisa_registered)
1564		ret = 0;
1565#endif
1566#ifdef CONFIG_MCA
1567	if (mca_registered)
1568		ret = 0;
1569#endif
1570	return ret;
1571}
1572
1573static void __exit el3_cleanup_module(void)
1574{
1575#ifdef CONFIG_PNP
1576	if (pnp_registered)
1577		pnp_unregister_driver(&el3_pnp_driver);
1578#endif
1579	if (isa_registered)
1580		isa_unregister_driver(&el3_isa_driver);
1581	if (id_port)
1582		release_region(id_port, 1);
1583#ifdef CONFIG_EISA
1584	if (eisa_registered)
1585		eisa_driver_unregister(&el3_eisa_driver);
1586#endif
1587#ifdef CONFIG_MCA
1588	if (mca_registered)
1589		mca_unregister_driver(&el3_mca_driver);
1590#endif
1591}
1592
1593module_init (el3_init_module);
1594module_exit (el3_cleanup_module);