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