1/*
   2	Written 1997-1998 by Donald Becker.
   3
   4	This software may be used and distributed according to the terms
   5	of the GNU General Public License, incorporated herein by reference.
   6
   7	This driver is for the 3Com ISA EtherLink XL "Corkscrew" 3c515 ethercard.
   8
   9	The author may be reached as becker@scyld.com, or C/O
  10	Scyld Computing Corporation
  11	410 Severn Ave., Suite 210
  12	Annapolis MD 21403
  13
  14
  15	2000/2/2- Added support for kernel-level ISAPnP
  16		by Stephen Frost <sfrost@snowman.net> and Alessandro Zummo
  17	Cleaned up for 2.3.x/softnet by Jeff Garzik and Alan Cox.
  18
  19	2001/11/17 - Added ethtool support (jgarzik)
  20
  21	2002/10/28 - Locking updates for 2.5 (alan@lxorguk.ukuu.org.uk)
  22
  23*/
  24
  25#define DRV_NAME		"3c515"
 
 
 
 
 
  26
  27#define CORKSCREW 1
  28
  29/* "Knobs" that adjust features and parameters. */
  30/* Set the copy breakpoint for the copy-only-tiny-frames scheme.
  31   Setting to > 1512 effectively disables this feature. */
  32static int rx_copybreak = 200;
  33
  34/* Allow setting MTU to a larger size, bypassing the normal ethernet setup. */
  35static const int mtu = 1500;
  36
  37/* Maximum events (Rx packets, etc.) to handle at each interrupt. */
  38static int max_interrupt_work = 20;
  39
  40/* Enable the automatic media selection code -- usually set. */
  41#define AUTOMEDIA 1
  42
  43/* Allow the use of fragment bus master transfers instead of only
  44   programmed-I/O for Vortex cards.  Full-bus-master transfers are always
  45   enabled by default on Boomerang cards.  If VORTEX_BUS_MASTER is defined,
  46   the feature may be turned on using 'options'. */
  47#define VORTEX_BUS_MASTER
  48
  49/* A few values that may be tweaked. */
  50/* Keep the ring sizes a power of two for efficiency. */
  51#define TX_RING_SIZE	16
  52#define RX_RING_SIZE	16
  53#define PKT_BUF_SZ		1536	/* Size of each temporary Rx buffer. */
  54
  55#include <linux/module.h>
  56#include <linux/isapnp.h>
  57#include <linux/kernel.h>
  58#include <linux/netdevice.h>
  59#include <linux/string.h>
  60#include <linux/errno.h>
  61#include <linux/in.h>
  62#include <linux/ioport.h>
  63#include <linux/skbuff.h>
  64#include <linux/etherdevice.h>
  65#include <linux/interrupt.h>
  66#include <linux/timer.h>
  67#include <linux/ethtool.h>
  68#include <linux/bitops.h>
  69#include <linux/uaccess.h>
  70
  71#include <net/Space.h>
  72
 
  73#include <asm/io.h>
  74#include <asm/dma.h>
  75
  76#define NEW_MULTICAST
  77#include <linux/delay.h>
  78
  79#define MAX_UNITS 8
  80
  81MODULE_AUTHOR("Donald Becker <becker@scyld.com>");
  82MODULE_DESCRIPTION("3Com 3c515 Corkscrew driver");
  83MODULE_LICENSE("GPL");
 
  84
  85/* "Knobs" for adjusting internal parameters. */
  86/* Put out somewhat more debugging messages. (0 - no msg, 1 minimal msgs). */
  87#define DRIVER_DEBUG 1
  88/* Some values here only for performance evaluation and path-coverage
  89   debugging. */
  90static int rx_nocopy, rx_copy, queued_packet;
  91
  92/* Number of times to check to see if the Tx FIFO has space, used in some
  93   limited cases. */
  94#define WAIT_TX_AVAIL 200
  95
  96/* Operational parameter that usually are not changed. */
  97#define TX_TIMEOUT  ((4*HZ)/10)	/* Time in jiffies before concluding Tx hung */
  98
  99/* The size here is somewhat misleading: the Corkscrew also uses the ISA
 100   aliased registers at <base>+0x400.
 101   */
 102#define CORKSCREW_TOTAL_SIZE 0x20
 103
 104#ifdef DRIVER_DEBUG
 105static int corkscrew_debug = DRIVER_DEBUG;
 106#else
 107static int corkscrew_debug = 1;
 108#endif
 109
 110#define CORKSCREW_ID 10
 111
 112/*
 113				Theory of Operation
 114
 115I. Board Compatibility
 116
 117This device driver is designed for the 3Com 3c515 ISA Fast EtherLink XL,
 1183Com's ISA bus adapter for Fast Ethernet.  Due to the unique I/O port layout,
 119it's not practical to integrate this driver with the other EtherLink drivers.
 120
 121II. Board-specific settings
 122
 123The Corkscrew has an EEPROM for configuration, but no special settings are
 124needed for Linux.
 125
 126III. Driver operation
 127
 128The 3c515 series use an interface that's very similar to the 3c900 "Boomerang"
 129PCI cards, with the bus master interface extensively modified to work with
 130the ISA bus.
 131
 132The card is capable of full-bus-master transfers with separate
 133lists of transmit and receive descriptors, similar to the AMD LANCE/PCnet,
 134DEC Tulip and Intel Speedo3.
 135
 136This driver uses a "RX_COPYBREAK" scheme rather than a fixed intermediate
 137receive buffer.  This scheme allocates full-sized skbuffs as receive
 138buffers.  The value RX_COPYBREAK is used as the copying breakpoint: it is
 139chosen to trade-off the memory wasted by passing the full-sized skbuff to
 140the queue layer for all frames vs. the copying cost of copying a frame to a
 141correctly-sized skbuff.
 142
 143
 144IIIC. Synchronization
 145The driver runs as two independent, single-threaded flows of control.  One
 146is the send-packet routine, which enforces single-threaded use by the netif
 147layer.  The other thread is the interrupt handler, which is single
 148threaded by the hardware and other software.
 149
 150IV. Notes
 151
 152Thanks to Terry Murphy of 3Com for providing documentation and a development
 153board.
 154
 155The names "Vortex", "Boomerang" and "Corkscrew" are the internal 3Com
 156project names.  I use these names to eliminate confusion -- 3Com product
 157numbers and names are very similar and often confused.
 158
 159The new chips support both ethernet (1.5K) and FDDI (4.5K) frame sizes!
 160This driver only supports ethernet frames because of the recent MTU limit
 161of 1.5K, but the changes to support 4.5K are minimal.
 162*/
 163
 164/* Operational definitions.
 165   These are not used by other compilation units and thus are not
 166   exported in a ".h" file.
 167
 168   First the windows.  There are eight register windows, with the command
 169   and status registers available in each.
 170   */
 171#define EL3WINDOW(win_num) outw(SelectWindow + (win_num), ioaddr + EL3_CMD)
 172#define EL3_CMD 0x0e
 173#define EL3_STATUS 0x0e
 174
 175/* The top five bits written to EL3_CMD are a command, the lower
 176   11 bits are the parameter, if applicable.
 177   Note that 11 parameters bits was fine for ethernet, but the new chips
 178   can handle FDDI length frames (~4500 octets) and now parameters count
 179   32-bit 'Dwords' rather than octets. */
 180
 181enum corkscrew_cmd {
 182	TotalReset = 0 << 11, SelectWindow = 1 << 11, StartCoax = 2 << 11,
 183	RxDisable = 3 << 11, RxEnable = 4 << 11, RxReset = 5 << 11,
 184	UpStall = 6 << 11, UpUnstall = (6 << 11) + 1, DownStall = (6 << 11) + 2,
 185	DownUnstall = (6 << 11) + 3, RxDiscard = 8 << 11, TxEnable = 9 << 11,
 186	TxDisable = 10 << 11, TxReset = 11 << 11, FakeIntr = 12 << 11,
 187	AckIntr = 13 << 11, SetIntrEnb = 14 << 11, SetStatusEnb = 15 << 11,
 188	SetRxFilter = 16 << 11, SetRxThreshold = 17 << 11,
 189	SetTxThreshold = 18 << 11, SetTxStart = 19 << 11, StartDMAUp = 20 << 11,
 190	StartDMADown = (20 << 11) + 1, StatsEnable = 21 << 11,
 191	StatsDisable = 22 << 11, StopCoax = 23 << 11,
 192};
 193
 194/* The SetRxFilter command accepts the following classes: */
 195enum RxFilter {
 196	RxStation = 1, RxMulticast = 2, RxBroadcast = 4, RxProm = 8
 197};
 198
 199/* Bits in the general status register. */
 200enum corkscrew_status {
 201	IntLatch = 0x0001, AdapterFailure = 0x0002, TxComplete = 0x0004,
 202	TxAvailable = 0x0008, RxComplete = 0x0010, RxEarly = 0x0020,
 203	IntReq = 0x0040, StatsFull = 0x0080,
 204	DMADone = 1 << 8, DownComplete = 1 << 9, UpComplete = 1 << 10,
 205	DMAInProgress = 1 << 11,	/* DMA controller is still busy. */
 206	CmdInProgress = 1 << 12,	/* EL3_CMD is still busy. */
 207};
 208
 209/* Register window 1 offsets, the window used in normal operation.
 210   On the Corkscrew this window is always mapped at offsets 0x10-0x1f. */
 211enum Window1 {
 212	TX_FIFO = 0x10, RX_FIFO = 0x10, RxErrors = 0x14,
 213	RxStatus = 0x18, Timer = 0x1A, TxStatus = 0x1B,
 214	TxFree = 0x1C,		/* Remaining free bytes in Tx buffer. */
 215};
 216enum Window0 {
 217	Wn0IRQ = 0x08,
 218#if defined(CORKSCREW)
 219	Wn0EepromCmd = 0x200A,	/* Corkscrew EEPROM command register. */
 220	Wn0EepromData = 0x200C,	/* Corkscrew EEPROM results register. */
 221#else
 222	Wn0EepromCmd = 10,	/* Window 0: EEPROM command register. */
 223	Wn0EepromData = 12,	/* Window 0: EEPROM results register. */
 224#endif
 225};
 226enum Win0_EEPROM_bits {
 227	EEPROM_Read = 0x80, EEPROM_WRITE = 0x40, EEPROM_ERASE = 0xC0,
 228	EEPROM_EWENB = 0x30,	/* Enable erasing/writing for 10 msec. */
 229	EEPROM_EWDIS = 0x00,	/* Disable EWENB before 10 msec timeout. */
 230};
 231
 232/* EEPROM locations. */
 233enum eeprom_offset {
 234	PhysAddr01 = 0, PhysAddr23 = 1, PhysAddr45 = 2, ModelID = 3,
 235	EtherLink3ID = 7,
 236};
 237
 238enum Window3 {			/* Window 3: MAC/config bits. */
 239	Wn3_Config = 0, Wn3_MAC_Ctrl = 6, Wn3_Options = 8,
 240};
 241enum wn3_config {
 242	Ram_size = 7,
 243	Ram_width = 8,
 244	Ram_speed = 0x30,
 245	Rom_size = 0xc0,
 246	Ram_split_shift = 16,
 247	Ram_split = 3 << Ram_split_shift,
 248	Xcvr_shift = 20,
 249	Xcvr = 7 << Xcvr_shift,
 250	Autoselect = 0x1000000,
 251};
 252
 253enum Window4 {
 254	Wn4_NetDiag = 6, Wn4_Media = 10,	/* Window 4: Xcvr/media bits. */
 255};
 256enum Win4_Media_bits {
 257	Media_SQE = 0x0008,	/* Enable SQE error counting for AUI. */
 258	Media_10TP = 0x00C0,	/* Enable link beat and jabber for 10baseT. */
 259	Media_Lnk = 0x0080,	/* Enable just link beat for 100TX/100FX. */
 260	Media_LnkBeat = 0x0800,
 261};
 262enum Window7 {			/* Window 7: Bus Master control. */
 263	Wn7_MasterAddr = 0, Wn7_MasterLen = 6, Wn7_MasterStatus = 12,
 264};
 265
 266/* Boomerang-style bus master control registers.  Note ISA aliases! */
 267enum MasterCtrl {
 268	PktStatus = 0x400, DownListPtr = 0x404, FragAddr = 0x408, FragLen =
 269	    0x40c,
 270	TxFreeThreshold = 0x40f, UpPktStatus = 0x410, UpListPtr = 0x418,
 271};
 272
 273/* The Rx and Tx descriptor lists.
 274   Caution Alpha hackers: these types are 32 bits!  Note also the 8 byte
 275   alignment contraint on tx_ring[] and rx_ring[]. */
 276struct boom_rx_desc {
 277	u32 next;
 278	s32 status;
 279	u32 addr;
 280	s32 length;
 281};
 282
 283/* Values for the Rx status entry. */
 284enum rx_desc_status {
 285	RxDComplete = 0x00008000, RxDError = 0x4000,
 286	/* See boomerang_rx() for actual error bits */
 287};
 288
 289struct boom_tx_desc {
 290	u32 next;
 291	s32 status;
 292	u32 addr;
 293	s32 length;
 294};
 295
 296struct corkscrew_private {
 297	const char *product_name;
 298	struct list_head list;
 299	struct net_device *our_dev;
 300	/* The Rx and Tx rings are here to keep them quad-word-aligned. */
 301	struct boom_rx_desc rx_ring[RX_RING_SIZE];
 302	struct boom_tx_desc tx_ring[TX_RING_SIZE];
 303	/* The addresses of transmit- and receive-in-place skbuffs. */
 304	struct sk_buff *rx_skbuff[RX_RING_SIZE];
 305	struct sk_buff *tx_skbuff[TX_RING_SIZE];
 306	unsigned int cur_rx, cur_tx;	/* The next free ring entry */
 307	unsigned int dirty_rx, dirty_tx;/* The ring entries to be free()ed. */
 308	struct sk_buff *tx_skb;	/* Packet being eaten by bus master ctrl.  */
 309	struct timer_list timer;	/* Media selection timer. */
 310	int capabilities	;	/* Adapter capabilities word. */
 311	int options;			/* User-settable misc. driver options. */
 312	int last_rx_packets;		/* For media autoselection. */
 313	unsigned int available_media:8,	/* From Wn3_Options */
 314		media_override:3,	/* Passed-in media type. */
 315		default_media:3,	/* Read from the EEPROM. */
 316		full_duplex:1, autoselect:1, bus_master:1,	/* Vortex can only do a fragment bus-m. */
 317		full_bus_master_tx:1, full_bus_master_rx:1,	/* Boomerang  */
 318		tx_full:1;
 319	spinlock_t lock;
 320	struct device *dev;
 321};
 322
 323/* The action to take with a media selection timer tick.
 324   Note that we deviate from the 3Com order by checking 10base2 before AUI.
 325 */
 326enum xcvr_types {
 327	XCVR_10baseT = 0, XCVR_AUI, XCVR_10baseTOnly, XCVR_10base2, XCVR_100baseTx,
 328	XCVR_100baseFx, XCVR_MII = 6, XCVR_Default = 8,
 329};
 330
 331static struct media_table {
 332	char *name;
 333	unsigned int media_bits:16,	/* Bits to set in Wn4_Media register. */
 334		mask:8,			/* The transceiver-present bit in Wn3_Config. */
 335		next:8;			/* The media type to try next. */
 336	short wait;			/* Time before we check media status. */
 337} media_tbl[] = {
 338	{ "10baseT", Media_10TP, 0x08, XCVR_10base2, (14 * HZ) / 10 },
 339	{ "10Mbs AUI", Media_SQE, 0x20, XCVR_Default, (1 * HZ) / 10},
 340	{ "undefined", 0, 0x80, XCVR_10baseT, 10000},
 341	{ "10base2", 0, 0x10, XCVR_AUI, (1 * HZ) / 10},
 342	{ "100baseTX", Media_Lnk, 0x02, XCVR_100baseFx, (14 * HZ) / 10},
 343	{ "100baseFX", Media_Lnk, 0x04, XCVR_MII, (14 * HZ) / 10},
 344	{ "MII", 0, 0x40, XCVR_10baseT, 3 * HZ},
 345	{ "undefined", 0, 0x01, XCVR_10baseT, 10000},
 346	{ "Default", 0, 0xFF, XCVR_10baseT, 10000},
 347};
 348
 349#ifdef __ISAPNP__
 350static struct isapnp_device_id corkscrew_isapnp_adapters[] = {
 351	{	ISAPNP_ANY_ID, ISAPNP_ANY_ID,
 352		ISAPNP_VENDOR('T', 'C', 'M'), ISAPNP_FUNCTION(0x5051),
 353		(long) "3Com Fast EtherLink ISA" },
 354	{ }	/* terminate list */
 355};
 356
 357MODULE_DEVICE_TABLE(isapnp, corkscrew_isapnp_adapters);
 358
 359static int nopnp;
 360#endif /* __ISAPNP__ */
 361
 362static struct net_device *corkscrew_scan(int unit);
 363static int corkscrew_setup(struct net_device *dev, int ioaddr,
 364			    struct pnp_dev *idev, int card_number);
 365static int corkscrew_open(struct net_device *dev);
 366static void corkscrew_timer(struct timer_list *t);
 367static netdev_tx_t corkscrew_start_xmit(struct sk_buff *skb,
 368					struct net_device *dev);
 369static int corkscrew_rx(struct net_device *dev);
 370static void corkscrew_timeout(struct net_device *dev, unsigned int txqueue);
 371static int boomerang_rx(struct net_device *dev);
 372static irqreturn_t corkscrew_interrupt(int irq, void *dev_id);
 373static int corkscrew_close(struct net_device *dev);
 374static void update_stats(int addr, struct net_device *dev);
 375static struct net_device_stats *corkscrew_get_stats(struct net_device *dev);
 376static void set_rx_mode(struct net_device *dev);
 377static const struct ethtool_ops netdev_ethtool_ops;
 378
 379
 380/*
 381   Unfortunately maximizing the shared code between the integrated and
 382   module version of the driver results in a complicated set of initialization
 383   procedures.
 384   init_module() -- modules /  tc59x_init()  -- built-in
 385		The wrappers for corkscrew_scan()
 386   corkscrew_scan()  		 The common routine that scans for PCI and EISA cards
 387   corkscrew_found_device() Allocate a device structure when we find a card.
 388					Different versions exist for modules and built-in.
 389   corkscrew_probe1()		Fill in the device structure -- this is separated
 390					so that the modules code can put it in dev->init.
 391*/
 392/* This driver uses 'options' to pass the media type, full-duplex flag, etc. */
 393/* Note: this is the only limit on the number of cards supported!! */
 394static int options[MAX_UNITS] = { -1, -1, -1, -1, -1, -1, -1, -1, };
 395
 396#ifdef MODULE
 397static int debug = -1;
 398
 399module_param(debug, int, 0);
 400module_param_array(options, int, NULL, 0);
 401module_param(rx_copybreak, int, 0);
 402module_param(max_interrupt_work, int, 0);
 403MODULE_PARM_DESC(debug, "3c515 debug level (0-6)");
 404MODULE_PARM_DESC(options, "3c515: Bits 0-2: media type, bit 3: full duplex, bit 4: bus mastering");
 405MODULE_PARM_DESC(rx_copybreak, "3c515 copy breakpoint for copy-only-tiny-frames");
 406MODULE_PARM_DESC(max_interrupt_work, "3c515 maximum events handled per interrupt");
 407
 408/* A list of all installed Vortex devices, for removing the driver module. */
 409/* we will need locking (and refcounting) if we ever use it for more */
 410static LIST_HEAD(root_corkscrew_dev);
 411
 412static int corkscrew_init_module(void)
 413{
 414	int found = 0;
 415	if (debug >= 0)
 416		corkscrew_debug = debug;
 
 
 417	while (corkscrew_scan(-1))
 418		found++;
 419	return found ? 0 : -ENODEV;
 420}
 421module_init(corkscrew_init_module);
 422
 423#else
 424struct net_device *tc515_probe(int unit)
 425{
 426	struct net_device *dev = corkscrew_scan(unit);
 
 427
 428	if (!dev)
 429		return ERR_PTR(-ENODEV);
 430
 
 
 
 
 
 431	return dev;
 432}
 433#endif				/* not MODULE */
 434
 435static int check_device(unsigned ioaddr)
 436{
 437	int timer;
 438
 439	if (!request_region(ioaddr, CORKSCREW_TOTAL_SIZE, "3c515"))
 440		return 0;
 441	/* Check the resource configuration for a matching ioaddr. */
 442	if ((inw(ioaddr + 0x2002) & 0x1f0) != (ioaddr & 0x1f0)) {
 443		release_region(ioaddr, CORKSCREW_TOTAL_SIZE);
 444		return 0;
 445	}
 446	/* Verify by reading the device ID from the EEPROM. */
 447	outw(EEPROM_Read + 7, ioaddr + Wn0EepromCmd);
 448	/* Pause for at least 162 us. for the read to take place. */
 449	for (timer = 4; timer >= 0; timer--) {
 450		udelay(162);
 451		if ((inw(ioaddr + Wn0EepromCmd) & 0x0200) == 0)
 452			break;
 453	}
 454	if (inw(ioaddr + Wn0EepromData) != 0x6d50) {
 455		release_region(ioaddr, CORKSCREW_TOTAL_SIZE);
 456		return 0;
 457	}
 458	return 1;
 459}
 460
 461static void cleanup_card(struct net_device *dev)
 462{
 463	struct corkscrew_private *vp = netdev_priv(dev);
 464	list_del_init(&vp->list);
 465	if (dev->dma)
 466		free_dma(dev->dma);
 467	outw(TotalReset, dev->base_addr + EL3_CMD);
 468	release_region(dev->base_addr, CORKSCREW_TOTAL_SIZE);
 469	if (vp->dev)
 470		pnp_device_detach(to_pnp_dev(vp->dev));
 471}
 472
 473static struct net_device *corkscrew_scan(int unit)
 474{
 475	struct net_device *dev;
 476	static int cards_found = 0;
 477	static int ioaddr;
 478	int err;
 479#ifdef __ISAPNP__
 480	short i;
 481	static int pnp_cards;
 482#endif
 483
 484	dev = alloc_etherdev(sizeof(struct corkscrew_private));
 485	if (!dev)
 486		return ERR_PTR(-ENOMEM);
 487
 488	if (unit >= 0) {
 489		sprintf(dev->name, "eth%d", unit);
 490		netdev_boot_setup_check(dev);
 491	}
 492
 493#ifdef __ISAPNP__
 494	if(nopnp == 1)
 495		goto no_pnp;
 496	for(i=0; corkscrew_isapnp_adapters[i].vendor != 0; i++) {
 497		struct pnp_dev *idev = NULL;
 498		int irq;
 499		while((idev = pnp_find_dev(NULL,
 500					   corkscrew_isapnp_adapters[i].vendor,
 501					   corkscrew_isapnp_adapters[i].function,
 502					   idev))) {
 503
 504			if (pnp_device_attach(idev) < 0)
 505				continue;
 506			if (pnp_activate_dev(idev) < 0) {
 507				pr_warn("pnp activate failed (out of resources?)\n");
 508				pnp_device_detach(idev);
 509				continue;
 510			}
 511			if (!pnp_port_valid(idev, 0) || !pnp_irq_valid(idev, 0)) {
 512				pnp_device_detach(idev);
 513				continue;
 514			}
 515			ioaddr = pnp_port_start(idev, 0);
 516			irq = pnp_irq(idev, 0);
 517			if (!check_device(ioaddr)) {
 518				pnp_device_detach(idev);
 519				continue;
 520			}
 521			if(corkscrew_debug)
 522				pr_debug("ISAPNP reports %s at i/o 0x%x, irq %d\n",
 523					(char*) corkscrew_isapnp_adapters[i].driver_data, ioaddr, irq);
 524			pr_info("3c515 Resource configuration register %#4.4x, DCR %4.4x.\n",
 525		     		inl(ioaddr + 0x2002), inw(ioaddr + 0x2000));
 526			/* irq = inw(ioaddr + 0x2002) & 15; */ /* Use the irq from isapnp */
 527			SET_NETDEV_DEV(dev, &idev->dev);
 528			pnp_cards++;
 529			err = corkscrew_setup(dev, ioaddr, idev, cards_found++);
 530			if (!err)
 531				return dev;
 532			cleanup_card(dev);
 533		}
 534	}
 535no_pnp:
 536#endif /* __ISAPNP__ */
 537
 538	/* Check all locations on the ISA bus -- evil! */
 539	for (ioaddr = 0x100; ioaddr < 0x400; ioaddr += 0x20) {
 540		if (!check_device(ioaddr))
 541			continue;
 542
 543		pr_info("3c515 Resource configuration register %#4.4x, DCR %4.4x.\n",
 544		     inl(ioaddr + 0x2002), inw(ioaddr + 0x2000));
 545		err = corkscrew_setup(dev, ioaddr, NULL, cards_found++);
 546		if (!err)
 547			return dev;
 548		cleanup_card(dev);
 549	}
 550	free_netdev(dev);
 551	return NULL;
 552}
 553
 554
 555static const struct net_device_ops netdev_ops = {
 556	.ndo_open		= corkscrew_open,
 557	.ndo_stop		= corkscrew_close,
 558	.ndo_start_xmit		= corkscrew_start_xmit,
 559	.ndo_tx_timeout		= corkscrew_timeout,
 560	.ndo_get_stats		= corkscrew_get_stats,
 561	.ndo_set_rx_mode	= set_rx_mode,
 562	.ndo_set_mac_address 	= eth_mac_addr,
 563	.ndo_validate_addr	= eth_validate_addr,
 564};
 565
 566
 567static int corkscrew_setup(struct net_device *dev, int ioaddr,
 568			    struct pnp_dev *idev, int card_number)
 569{
 570	struct corkscrew_private *vp = netdev_priv(dev);
 571	unsigned int eeprom[0x40], checksum = 0;	/* EEPROM contents */
 572	__be16 addr[ETH_ALEN / 2];
 573	int i;
 574	int irq;
 575
 576#ifdef __ISAPNP__
 577	if (idev) {
 578		irq = pnp_irq(idev, 0);
 579		vp->dev = &idev->dev;
 580	} else {
 581		irq = inw(ioaddr + 0x2002) & 15;
 582	}
 583#else
 584	irq = inw(ioaddr + 0x2002) & 15;
 585#endif
 586
 587	dev->base_addr = ioaddr;
 588	dev->irq = irq;
 589	dev->dma = inw(ioaddr + 0x2000) & 7;
 590	vp->product_name = "3c515";
 591	vp->options = dev->mem_start;
 592	vp->our_dev = dev;
 593
 594	if (!vp->options) {
 595		 if (card_number >= MAX_UNITS)
 596			vp->options = -1;
 597		else
 598			vp->options = options[card_number];
 599	}
 600
 601	if (vp->options >= 0) {
 602		vp->media_override = vp->options & 7;
 603		if (vp->media_override == 2)
 604			vp->media_override = 0;
 605		vp->full_duplex = (vp->options & 8) ? 1 : 0;
 606		vp->bus_master = (vp->options & 16) ? 1 : 0;
 607	} else {
 608		vp->media_override = 7;
 609		vp->full_duplex = 0;
 610		vp->bus_master = 0;
 611	}
 612#ifdef MODULE
 613	list_add(&vp->list, &root_corkscrew_dev);
 614#endif
 615
 616	pr_info("%s: 3Com %s at %#3x,", dev->name, vp->product_name, ioaddr);
 617
 618	spin_lock_init(&vp->lock);
 619
 620	timer_setup(&vp->timer, corkscrew_timer, 0);
 621
 622	/* Read the station address from the EEPROM. */
 623	EL3WINDOW(0);
 624	for (i = 0; i < 0x18; i++) {
 
 625		int timer;
 626		outw(EEPROM_Read + i, ioaddr + Wn0EepromCmd);
 627		/* Pause for at least 162 us. for the read to take place. */
 628		for (timer = 4; timer >= 0; timer--) {
 629			udelay(162);
 630			if ((inw(ioaddr + Wn0EepromCmd) & 0x0200) == 0)
 631				break;
 632		}
 633		eeprom[i] = inw(ioaddr + Wn0EepromData);
 634		checksum ^= eeprom[i];
 635		if (i < 3)
 636			addr[i] = htons(eeprom[i]);
 637	}
 638	eth_hw_addr_set(dev, (u8 *)addr);
 639	checksum = (checksum ^ (checksum >> 8)) & 0xff;
 640	if (checksum != 0x00)
 641		pr_cont(" ***INVALID CHECKSUM %4.4x*** ", checksum);
 642	pr_cont(" %pM", dev->dev_addr);
 643	if (eeprom[16] == 0x11c7) {	/* Corkscrew */
 644		if (request_dma(dev->dma, "3c515")) {
 645			pr_cont(", DMA %d allocation failed", dev->dma);
 646			dev->dma = 0;
 647		} else
 648			pr_cont(", DMA %d", dev->dma);
 649	}
 650	pr_cont(", IRQ %d\n", dev->irq);
 651	/* Tell them about an invalid IRQ. */
 652	if (corkscrew_debug && (dev->irq <= 0 || dev->irq > 15))
 653		pr_warn(" *** Warning: this IRQ is unlikely to work! ***\n");
 654
 655	{
 656		static const char * const ram_split[] = {
 657			"5:3", "3:1", "1:1", "3:5"
 658		};
 659		__u32 config;
 660		EL3WINDOW(3);
 661		vp->available_media = inw(ioaddr + Wn3_Options);
 662		config = inl(ioaddr + Wn3_Config);
 663		if (corkscrew_debug > 1)
 664			pr_info("  Internal config register is %4.4x, transceivers %#x.\n",
 665				config, inw(ioaddr + Wn3_Options));
 666		pr_info("  %dK %s-wide RAM %s Rx:Tx split, %s%s interface.\n",
 667			8 << config & Ram_size,
 668			config & Ram_width ? "word" : "byte",
 669			ram_split[(config & Ram_split) >> Ram_split_shift],
 670			config & Autoselect ? "autoselect/" : "",
 671			media_tbl[(config & Xcvr) >> Xcvr_shift].name);
 672		vp->default_media = (config & Xcvr) >> Xcvr_shift;
 673		vp->autoselect = config & Autoselect ? 1 : 0;
 674		dev->if_port = vp->default_media;
 675	}
 676	if (vp->media_override != 7) {
 677		pr_info("  Media override to transceiver type %d (%s).\n",
 678		       vp->media_override,
 679		       media_tbl[vp->media_override].name);
 680		dev->if_port = vp->media_override;
 681	}
 682
 683	vp->capabilities = eeprom[16];
 684	vp->full_bus_master_tx = (vp->capabilities & 0x20) ? 1 : 0;
 685	/* Rx is broken at 10mbps, so we always disable it. */
 686	/* vp->full_bus_master_rx = 0; */
 687	vp->full_bus_master_rx = (vp->capabilities & 0x20) ? 1 : 0;
 688
 689	/* The 3c51x-specific entries in the device structure. */
 690	dev->netdev_ops = &netdev_ops;
 691	dev->watchdog_timeo = (400 * HZ) / 1000;
 692	dev->ethtool_ops = &netdev_ethtool_ops;
 693
 694	return register_netdev(dev);
 695}
 696
 697
 698static int corkscrew_open(struct net_device *dev)
 699{
 700	int ioaddr = dev->base_addr;
 701	struct corkscrew_private *vp = netdev_priv(dev);
 702	bool armtimer = false;
 703	__u32 config;
 704	int i;
 705
 706	/* Before initializing select the active media port. */
 707	EL3WINDOW(3);
 708	if (vp->full_duplex)
 709		outb(0x20, ioaddr + Wn3_MAC_Ctrl);	/* Set the full-duplex bit. */
 710	config = inl(ioaddr + Wn3_Config);
 711
 712	if (vp->media_override != 7) {
 713		if (corkscrew_debug > 1)
 714			pr_info("%s: Media override to transceiver %d (%s).\n",
 715				dev->name, vp->media_override,
 716				media_tbl[vp->media_override].name);
 717		dev->if_port = vp->media_override;
 718	} else if (vp->autoselect) {
 719		/* Find first available media type, starting with 100baseTx. */
 720		dev->if_port = 4;
 721		while (!(vp->available_media & media_tbl[dev->if_port].mask))
 722			dev->if_port = media_tbl[dev->if_port].next;
 723
 724		if (corkscrew_debug > 1)
 725			pr_debug("%s: Initial media type %s.\n",
 726			       dev->name, media_tbl[dev->if_port].name);
 727		armtimer = true;
 728	} else
 729		dev->if_port = vp->default_media;
 730
 731	config = (config & ~Xcvr) | (dev->if_port << Xcvr_shift);
 732	outl(config, ioaddr + Wn3_Config);
 733
 734	if (corkscrew_debug > 1) {
 735		pr_debug("%s: corkscrew_open() InternalConfig %8.8x.\n",
 736		       dev->name, config);
 737	}
 738
 739	outw(TxReset, ioaddr + EL3_CMD);
 740	for (i = 20; i >= 0; i--)
 741		if (!(inw(ioaddr + EL3_STATUS) & CmdInProgress))
 742			break;
 743
 744	outw(RxReset, ioaddr + EL3_CMD);
 745	/* Wait a few ticks for the RxReset command to complete. */
 746	for (i = 20; i >= 0; i--)
 747		if (!(inw(ioaddr + EL3_STATUS) & CmdInProgress))
 748			break;
 749
 750	outw(SetStatusEnb | 0x00, ioaddr + EL3_CMD);
 751
 752	/* Use the now-standard shared IRQ implementation. */
 753	if (vp->capabilities == 0x11c7) {
 754		/* Corkscrew: Cannot share ISA resources. */
 755		if (dev->irq == 0 ||
 756		    dev->dma == 0 ||
 757		    request_irq(dev->irq, corkscrew_interrupt, 0,
 758				vp->product_name, dev))
 759			return -EAGAIN;
 760		enable_dma(dev->dma);
 761		set_dma_mode(dev->dma, DMA_MODE_CASCADE);
 762	} else if (request_irq(dev->irq, corkscrew_interrupt, IRQF_SHARED,
 763			       vp->product_name, dev)) {
 764		return -EAGAIN;
 765	}
 766
 767	if (armtimer)
 768		mod_timer(&vp->timer, jiffies + media_tbl[dev->if_port].wait);
 769
 770	if (corkscrew_debug > 1) {
 771		EL3WINDOW(4);
 772		pr_debug("%s: corkscrew_open() irq %d media status %4.4x.\n",
 773		       dev->name, dev->irq, inw(ioaddr + Wn4_Media));
 774	}
 775
 776	/* Set the station address and mask in window 2 each time opened. */
 777	EL3WINDOW(2);
 778	for (i = 0; i < 6; i++)
 779		outb(dev->dev_addr[i], ioaddr + i);
 780	for (; i < 12; i += 2)
 781		outw(0, ioaddr + i);
 782
 783	if (dev->if_port == 3)
 784		/* Start the thinnet transceiver. We should really wait 50ms... */
 785		outw(StartCoax, ioaddr + EL3_CMD);
 786	EL3WINDOW(4);
 787	outw((inw(ioaddr + Wn4_Media) & ~(Media_10TP | Media_SQE)) |
 788	     media_tbl[dev->if_port].media_bits, ioaddr + Wn4_Media);
 789
 790	/* Switch to the stats window, and clear all stats by reading. */
 791	outw(StatsDisable, ioaddr + EL3_CMD);
 792	EL3WINDOW(6);
 793	for (i = 0; i < 10; i++)
 794		inb(ioaddr + i);
 795	inw(ioaddr + 10);
 796	inw(ioaddr + 12);
 797	/* New: On the Vortex we must also clear the BadSSD counter. */
 798	EL3WINDOW(4);
 799	inb(ioaddr + 12);
 800	/* ..and on the Boomerang we enable the extra statistics bits. */
 801	outw(0x0040, ioaddr + Wn4_NetDiag);
 802
 803	/* Switch to register set 7 for normal use. */
 804	EL3WINDOW(7);
 805
 806	if (vp->full_bus_master_rx) {	/* Boomerang bus master. */
 807		vp->cur_rx = vp->dirty_rx = 0;
 808		if (corkscrew_debug > 2)
 809			pr_debug("%s:  Filling in the Rx ring.\n", dev->name);
 810		for (i = 0; i < RX_RING_SIZE; i++) {
 811			struct sk_buff *skb;
 812			if (i < (RX_RING_SIZE - 1))
 813				vp->rx_ring[i].next =
 814				    isa_virt_to_bus(&vp->rx_ring[i + 1]);
 815			else
 816				vp->rx_ring[i].next = 0;
 817			vp->rx_ring[i].status = 0;	/* Clear complete bit. */
 818			vp->rx_ring[i].length = PKT_BUF_SZ | 0x80000000;
 819			skb = netdev_alloc_skb(dev, PKT_BUF_SZ);
 820			vp->rx_skbuff[i] = skb;
 821			if (skb == NULL)
 822				break;	/* Bad news!  */
 823			skb_reserve(skb, 2);	/* Align IP on 16 byte boundaries */
 824			vp->rx_ring[i].addr = isa_virt_to_bus(skb->data);
 825		}
 826		if (i != 0)
 827			vp->rx_ring[i - 1].next =
 828				isa_virt_to_bus(&vp->rx_ring[0]);	/* Wrap the ring. */
 829		outl(isa_virt_to_bus(&vp->rx_ring[0]), ioaddr + UpListPtr);
 830	}
 831	if (vp->full_bus_master_tx) {	/* Boomerang bus master Tx. */
 832		vp->cur_tx = vp->dirty_tx = 0;
 833		outb(PKT_BUF_SZ >> 8, ioaddr + TxFreeThreshold);	/* Room for a packet. */
 834		/* Clear the Tx ring. */
 835		for (i = 0; i < TX_RING_SIZE; i++)
 836			vp->tx_skbuff[i] = NULL;
 837		outl(0, ioaddr + DownListPtr);
 838	}
 839	/* Set receiver mode: presumably accept b-case and phys addr only. */
 840	set_rx_mode(dev);
 841	outw(StatsEnable, ioaddr + EL3_CMD);	/* Turn on statistics. */
 842
 843	netif_start_queue(dev);
 844
 845	outw(RxEnable, ioaddr + EL3_CMD);	/* Enable the receiver. */
 846	outw(TxEnable, ioaddr + EL3_CMD);	/* Enable transmitter. */
 847	/* Allow status bits to be seen. */
 848	outw(SetStatusEnb | AdapterFailure | IntReq | StatsFull |
 849	     (vp->full_bus_master_tx ? DownComplete : TxAvailable) |
 850	     (vp->full_bus_master_rx ? UpComplete : RxComplete) |
 851	     (vp->bus_master ? DMADone : 0), ioaddr + EL3_CMD);
 852	/* Ack all pending events, and set active indicator mask. */
 853	outw(AckIntr | IntLatch | TxAvailable | RxEarly | IntReq,
 854	     ioaddr + EL3_CMD);
 855	outw(SetIntrEnb | IntLatch | TxAvailable | RxComplete | StatsFull
 856	     | (vp->bus_master ? DMADone : 0) | UpComplete | DownComplete,
 857	     ioaddr + EL3_CMD);
 858
 859	return 0;
 860}
 861
 862static void corkscrew_timer(struct timer_list *t)
 863{
 864#ifdef AUTOMEDIA
 865	struct corkscrew_private *vp = from_timer(vp, t, timer);
 866	struct net_device *dev = vp->our_dev;
 867	int ioaddr = dev->base_addr;
 868	unsigned long flags;
 869	int ok = 0;
 870
 871	if (corkscrew_debug > 1)
 872		pr_debug("%s: Media selection timer tick happened, %s.\n",
 873		       dev->name, media_tbl[dev->if_port].name);
 874
 875	spin_lock_irqsave(&vp->lock, flags);
 876
 877	{
 878		int old_window = inw(ioaddr + EL3_CMD) >> 13;
 879		int media_status;
 880		EL3WINDOW(4);
 881		media_status = inw(ioaddr + Wn4_Media);
 882		switch (dev->if_port) {
 883		case 0:
 884		case 4:
 885		case 5:	/* 10baseT, 100baseTX, 100baseFX  */
 886			if (media_status & Media_LnkBeat) {
 887				ok = 1;
 888				if (corkscrew_debug > 1)
 889					pr_debug("%s: Media %s has link beat, %x.\n",
 890						dev->name,
 891						media_tbl[dev->if_port].name,
 892						media_status);
 893			} else if (corkscrew_debug > 1)
 894				pr_debug("%s: Media %s is has no link beat, %x.\n",
 895					dev->name,
 896					media_tbl[dev->if_port].name,
 897					media_status);
 898
 899			break;
 900		default:	/* Other media types handled by Tx timeouts. */
 901			if (corkscrew_debug > 1)
 902				pr_debug("%s: Media %s is has no indication, %x.\n",
 903					dev->name,
 904					media_tbl[dev->if_port].name,
 905					media_status);
 906			ok = 1;
 907		}
 908		if (!ok) {
 909			__u32 config;
 910
 911			do {
 912				dev->if_port =
 913				    media_tbl[dev->if_port].next;
 914			}
 915			while (!(vp->available_media & media_tbl[dev->if_port].mask));
 916
 917			if (dev->if_port == 8) {	/* Go back to default. */
 918				dev->if_port = vp->default_media;
 919				if (corkscrew_debug > 1)
 920					pr_debug("%s: Media selection failing, using default %s port.\n",
 921						dev->name,
 922						media_tbl[dev->if_port].name);
 923			} else {
 924				if (corkscrew_debug > 1)
 925					pr_debug("%s: Media selection failed, now trying %s port.\n",
 926						dev->name,
 927						media_tbl[dev->if_port].name);
 928				vp->timer.expires = jiffies + media_tbl[dev->if_port].wait;
 929				add_timer(&vp->timer);
 930			}
 931			outw((media_status & ~(Media_10TP | Media_SQE)) |
 932			     media_tbl[dev->if_port].media_bits,
 933			     ioaddr + Wn4_Media);
 934
 935			EL3WINDOW(3);
 936			config = inl(ioaddr + Wn3_Config);
 937			config = (config & ~Xcvr) | (dev->if_port << Xcvr_shift);
 938			outl(config, ioaddr + Wn3_Config);
 939
 940			outw(dev->if_port == 3 ? StartCoax : StopCoax,
 941			     ioaddr + EL3_CMD);
 942		}
 943		EL3WINDOW(old_window);
 944	}
 945
 946	spin_unlock_irqrestore(&vp->lock, flags);
 947	if (corkscrew_debug > 1)
 948		pr_debug("%s: Media selection timer finished, %s.\n",
 949		       dev->name, media_tbl[dev->if_port].name);
 950
 951#endif				/* AUTOMEDIA */
 952}
 953
 954static void corkscrew_timeout(struct net_device *dev, unsigned int txqueue)
 955{
 956	int i;
 957	struct corkscrew_private *vp = netdev_priv(dev);
 958	int ioaddr = dev->base_addr;
 959
 960	pr_warn("%s: transmit timed out, tx_status %2.2x status %4.4x\n",
 961		dev->name, inb(ioaddr + TxStatus),
 962		inw(ioaddr + EL3_STATUS));
 963	/* Slight code bloat to be user friendly. */
 964	if ((inb(ioaddr + TxStatus) & 0x88) == 0x88)
 965		pr_warn("%s: Transmitter encountered 16 collisions -- network cable problem?\n",
 966			dev->name);
 967#ifndef final_version
 968	pr_debug("  Flags; bus-master %d, full %d; dirty %d current %d.\n",
 969	       vp->full_bus_master_tx, vp->tx_full, vp->dirty_tx,
 970	       vp->cur_tx);
 971	pr_debug("  Down list %8.8x vs. %p.\n", inl(ioaddr + DownListPtr),
 972	       &vp->tx_ring[0]);
 973	for (i = 0; i < TX_RING_SIZE; i++) {
 974		pr_debug("  %d: %p  length %8.8x status %8.8x\n", i,
 975		       &vp->tx_ring[i],
 976		       vp->tx_ring[i].length, vp->tx_ring[i].status);
 977	}
 978#endif
 979	/* Issue TX_RESET and TX_START commands. */
 980	outw(TxReset, ioaddr + EL3_CMD);
 981	for (i = 20; i >= 0; i--)
 982		if (!(inw(ioaddr + EL3_STATUS) & CmdInProgress))
 983			break;
 984	outw(TxEnable, ioaddr + EL3_CMD);
 985	netif_trans_update(dev); /* prevent tx timeout */
 986	dev->stats.tx_errors++;
 987	dev->stats.tx_dropped++;
 988	netif_wake_queue(dev);
 989}
 990
 991static netdev_tx_t corkscrew_start_xmit(struct sk_buff *skb,
 992					struct net_device *dev)
 993{
 994	struct corkscrew_private *vp = netdev_priv(dev);
 995	int ioaddr = dev->base_addr;
 996
 997	/* Block a timer-based transmit from overlapping. */
 998
 999	netif_stop_queue(dev);
1000
1001	if (vp->full_bus_master_tx) {	/* BOOMERANG bus-master */
1002		/* Calculate the next Tx descriptor entry. */
1003		int entry = vp->cur_tx % TX_RING_SIZE;
1004		struct boom_tx_desc *prev_entry;
1005		unsigned long flags;
1006		int i;
1007
1008		if (vp->tx_full)	/* No room to transmit with */
1009			return NETDEV_TX_BUSY;
1010		if (vp->cur_tx != 0)
1011			prev_entry = &vp->tx_ring[(vp->cur_tx - 1) % TX_RING_SIZE];
1012		else
1013			prev_entry = NULL;
1014		if (corkscrew_debug > 3)
1015			pr_debug("%s: Trying to send a packet, Tx index %d.\n",
1016				dev->name, vp->cur_tx);
1017		/* vp->tx_full = 1; */
1018		vp->tx_skbuff[entry] = skb;
1019		vp->tx_ring[entry].next = 0;
1020		vp->tx_ring[entry].addr = isa_virt_to_bus(skb->data);
1021		vp->tx_ring[entry].length = skb->len | 0x80000000;
1022		vp->tx_ring[entry].status = skb->len | 0x80000000;
1023
1024		spin_lock_irqsave(&vp->lock, flags);
1025		outw(DownStall, ioaddr + EL3_CMD);
1026		/* Wait for the stall to complete. */
1027		for (i = 20; i >= 0; i--)
1028			if ((inw(ioaddr + EL3_STATUS) & CmdInProgress) == 0)
1029				break;
1030		if (prev_entry)
1031			prev_entry->next = isa_virt_to_bus(&vp->tx_ring[entry]);
1032		if (inl(ioaddr + DownListPtr) == 0) {
1033			outl(isa_virt_to_bus(&vp->tx_ring[entry]),
1034			     ioaddr + DownListPtr);
1035			queued_packet++;
1036		}
1037		outw(DownUnstall, ioaddr + EL3_CMD);
1038		spin_unlock_irqrestore(&vp->lock, flags);
1039
1040		vp->cur_tx++;
1041		if (vp->cur_tx - vp->dirty_tx > TX_RING_SIZE - 1)
1042			vp->tx_full = 1;
1043		else {		/* Clear previous interrupt enable. */
1044			if (prev_entry)
1045				prev_entry->status &= ~0x80000000;
1046			netif_wake_queue(dev);
1047		}
1048		return NETDEV_TX_OK;
1049	}
1050	/* Put out the doubleword header... */
1051	outl(skb->len, ioaddr + TX_FIFO);
1052	dev->stats.tx_bytes += skb->len;
1053#ifdef VORTEX_BUS_MASTER
1054	if (vp->bus_master) {
1055		/* Set the bus-master controller to transfer the packet. */
1056		outl(isa_virt_to_bus(skb->data), ioaddr + Wn7_MasterAddr);
1057		outw((skb->len + 3) & ~3, ioaddr + Wn7_MasterLen);
1058		vp->tx_skb = skb;
1059		outw(StartDMADown, ioaddr + EL3_CMD);
1060		/* queue will be woken at the DMADone interrupt. */
1061	} else {
1062		/* ... and the packet rounded to a doubleword. */
1063		outsl(ioaddr + TX_FIFO, skb->data, (skb->len + 3) >> 2);
1064		dev_kfree_skb(skb);
1065		if (inw(ioaddr + TxFree) > 1536) {
1066			netif_wake_queue(dev);
1067		} else
1068			/* Interrupt us when the FIFO has room for max-sized packet. */
1069			outw(SetTxThreshold + (1536 >> 2),
1070			     ioaddr + EL3_CMD);
1071	}
1072#else
1073	/* ... and the packet rounded to a doubleword. */
1074	outsl(ioaddr + TX_FIFO, skb->data, (skb->len + 3) >> 2);
1075	dev_kfree_skb(skb);
1076	if (inw(ioaddr + TxFree) > 1536) {
1077		netif_wake_queue(dev);
1078	} else
1079		/* Interrupt us when the FIFO has room for max-sized packet. */
1080		outw(SetTxThreshold + (1536 >> 2), ioaddr + EL3_CMD);
1081#endif				/* bus master */
1082
1083
1084	/* Clear the Tx status stack. */
1085	{
1086		short tx_status;
1087		int i = 4;
1088
1089		while (--i > 0 && (tx_status = inb(ioaddr + TxStatus)) > 0) {
1090			if (tx_status & 0x3C) {	/* A Tx-disabling error occurred.  */
1091				if (corkscrew_debug > 2)
1092					pr_debug("%s: Tx error, status %2.2x.\n",
1093						dev->name, tx_status);
1094				if (tx_status & 0x04)
1095					dev->stats.tx_fifo_errors++;
1096				if (tx_status & 0x38)
1097					dev->stats.tx_aborted_errors++;
1098				if (tx_status & 0x30) {
1099					int j;
1100					outw(TxReset, ioaddr + EL3_CMD);
1101					for (j = 20; j >= 0; j--)
1102						if (!(inw(ioaddr + EL3_STATUS) & CmdInProgress))
1103							break;
1104				}
1105				outw(TxEnable, ioaddr + EL3_CMD);
1106			}
1107			outb(0x00, ioaddr + TxStatus);	/* Pop the status stack. */
1108		}
1109	}
1110	return NETDEV_TX_OK;
1111}
1112
1113/* The interrupt handler does all of the Rx thread work and cleans up
1114   after the Tx thread. */
1115
1116static irqreturn_t corkscrew_interrupt(int irq, void *dev_id)
1117{
1118	/* Use the now-standard shared IRQ implementation. */
1119	struct net_device *dev = dev_id;
1120	struct corkscrew_private *lp = netdev_priv(dev);
1121	int ioaddr, status;
1122	int latency;
1123	int i = max_interrupt_work;
1124
1125	ioaddr = dev->base_addr;
1126	latency = inb(ioaddr + Timer);
1127
1128	spin_lock(&lp->lock);
1129
1130	status = inw(ioaddr + EL3_STATUS);
1131
1132	if (corkscrew_debug > 4)
1133		pr_debug("%s: interrupt, status %4.4x, timer %d.\n",
1134			dev->name, status, latency);
1135	if ((status & 0xE000) != 0xE000) {
1136		static int donedidthis;
1137		/* Some interrupt controllers store a bogus interrupt from boot-time.
1138		   Ignore a single early interrupt, but don't hang the machine for
1139		   other interrupt problems. */
1140		if (donedidthis++ > 100) {
1141			pr_err("%s: Bogus interrupt, bailing. Status %4.4x, start=%d.\n",
1142				   dev->name, status, netif_running(dev));
1143			free_irq(dev->irq, dev);
1144			dev->irq = -1;
1145		}
1146	}
1147
1148	do {
1149		if (corkscrew_debug > 5)
1150			pr_debug("%s: In interrupt loop, status %4.4x.\n",
1151			       dev->name, status);
1152		if (status & RxComplete)
1153			corkscrew_rx(dev);
1154
1155		if (status & TxAvailable) {
1156			if (corkscrew_debug > 5)
1157				pr_debug("	TX room bit was handled.\n");
1158			/* There's room in the FIFO for a full-sized packet. */
1159			outw(AckIntr | TxAvailable, ioaddr + EL3_CMD);
1160			netif_wake_queue(dev);
1161		}
1162		if (status & DownComplete) {
1163			unsigned int dirty_tx = lp->dirty_tx;
1164
1165			while (lp->cur_tx - dirty_tx > 0) {
1166				int entry = dirty_tx % TX_RING_SIZE;
1167				if (inl(ioaddr + DownListPtr) == isa_virt_to_bus(&lp->tx_ring[entry]))
1168					break;	/* It still hasn't been processed. */
1169				if (lp->tx_skbuff[entry]) {
1170					dev_consume_skb_irq(lp->tx_skbuff[entry]);
1171					lp->tx_skbuff[entry] = NULL;
1172				}
1173				dirty_tx++;
1174			}
1175			lp->dirty_tx = dirty_tx;
1176			outw(AckIntr | DownComplete, ioaddr + EL3_CMD);
1177			if (lp->tx_full && (lp->cur_tx - dirty_tx <= TX_RING_SIZE - 1)) {
1178				lp->tx_full = 0;
1179				netif_wake_queue(dev);
1180			}
1181		}
1182#ifdef VORTEX_BUS_MASTER
1183		if (status & DMADone) {
1184			outw(0x1000, ioaddr + Wn7_MasterStatus);	/* Ack the event. */
1185			dev_consume_skb_irq(lp->tx_skb);	/* Release the transferred buffer */
1186			netif_wake_queue(dev);
1187		}
1188#endif
1189		if (status & UpComplete) {
1190			boomerang_rx(dev);
1191			outw(AckIntr | UpComplete, ioaddr + EL3_CMD);
1192		}
1193		if (status & (AdapterFailure | RxEarly | StatsFull)) {
1194			/* Handle all uncommon interrupts at once. */
1195			if (status & RxEarly) {	/* Rx early is unused. */
1196				corkscrew_rx(dev);
1197				outw(AckIntr | RxEarly, ioaddr + EL3_CMD);
1198			}
1199			if (status & StatsFull) {	/* Empty statistics. */
1200				static int DoneDidThat;
1201				if (corkscrew_debug > 4)
1202					pr_debug("%s: Updating stats.\n", dev->name);
1203				update_stats(ioaddr, dev);
1204				/* DEBUG HACK: Disable statistics as an interrupt source. */
1205				/* This occurs when we have the wrong media type! */
1206				if (DoneDidThat == 0 && inw(ioaddr + EL3_STATUS) & StatsFull) {
1207					int win, reg;
1208					pr_notice("%s: Updating stats failed, disabling stats as an interrupt source.\n",
1209						dev->name);
1210					for (win = 0; win < 8; win++) {
1211						EL3WINDOW(win);
1212						pr_notice("Vortex window %d:", win);
1213						for (reg = 0; reg < 16; reg++)
1214							pr_cont(" %2.2x", inb(ioaddr + reg));
1215						pr_cont("\n");
1216					}
1217					EL3WINDOW(7);
1218					outw(SetIntrEnb | TxAvailable |
1219					     RxComplete | AdapterFailure |
1220					     UpComplete | DownComplete |
1221					     TxComplete, ioaddr + EL3_CMD);
1222					DoneDidThat++;
1223				}
1224			}
1225			if (status & AdapterFailure) {
1226				/* Adapter failure requires Rx reset and reinit. */
1227				outw(RxReset, ioaddr + EL3_CMD);
1228				/* Set the Rx filter to the current state. */
1229				set_rx_mode(dev);
1230				outw(RxEnable, ioaddr + EL3_CMD);	/* Re-enable the receiver. */
1231				outw(AckIntr | AdapterFailure,
1232				     ioaddr + EL3_CMD);
1233			}
1234		}
1235
1236		if (--i < 0) {
1237			pr_err("%s: Too much work in interrupt, status %4.4x. Disabling functions (%4.4x).\n",
1238				dev->name, status, SetStatusEnb | ((~status) & 0x7FE));
1239			/* Disable all pending interrupts. */
1240			outw(SetStatusEnb | ((~status) & 0x7FE), ioaddr + EL3_CMD);
1241			outw(AckIntr | 0x7FF, ioaddr + EL3_CMD);
1242			break;
1243		}
1244		/* Acknowledge the IRQ. */
1245		outw(AckIntr | IntReq | IntLatch, ioaddr + EL3_CMD);
1246
1247	} while ((status = inw(ioaddr + EL3_STATUS)) & (IntLatch | RxComplete));
1248
1249	spin_unlock(&lp->lock);
1250
1251	if (corkscrew_debug > 4)
1252		pr_debug("%s: exiting interrupt, status %4.4x.\n", dev->name, status);
1253	return IRQ_HANDLED;
1254}
1255
1256static int corkscrew_rx(struct net_device *dev)
1257{
1258	int ioaddr = dev->base_addr;
1259	int i;
1260	short rx_status;
1261
1262	if (corkscrew_debug > 5)
1263		pr_debug("   In rx_packet(), status %4.4x, rx_status %4.4x.\n",
1264		     inw(ioaddr + EL3_STATUS), inw(ioaddr + RxStatus));
1265	while ((rx_status = inw(ioaddr + RxStatus)) > 0) {
1266		if (rx_status & 0x4000) {	/* Error, update stats. */
1267			unsigned char rx_error = inb(ioaddr + RxErrors);
1268			if (corkscrew_debug > 2)
1269				pr_debug(" Rx error: status %2.2x.\n",
1270				       rx_error);
1271			dev->stats.rx_errors++;
1272			if (rx_error & 0x01)
1273				dev->stats.rx_over_errors++;
1274			if (rx_error & 0x02)
1275				dev->stats.rx_length_errors++;
1276			if (rx_error & 0x04)
1277				dev->stats.rx_frame_errors++;
1278			if (rx_error & 0x08)
1279				dev->stats.rx_crc_errors++;
1280			if (rx_error & 0x10)
1281				dev->stats.rx_length_errors++;
1282		} else {
1283			/* The packet length: up to 4.5K!. */
1284			short pkt_len = rx_status & 0x1fff;
1285			struct sk_buff *skb;
1286
1287			skb = netdev_alloc_skb(dev, pkt_len + 5 + 2);
1288			if (corkscrew_debug > 4)
1289				pr_debug("Receiving packet size %d status %4.4x.\n",
1290				     pkt_len, rx_status);
1291			if (skb != NULL) {
1292				skb_reserve(skb, 2);	/* Align IP on 16 byte boundaries */
1293				/* 'skb_put()' points to the start of sk_buff data area. */
1294				insl(ioaddr + RX_FIFO,
1295				     skb_put(skb, pkt_len),
1296				     (pkt_len + 3) >> 2);
1297				outw(RxDiscard, ioaddr + EL3_CMD);	/* Pop top Rx packet. */
1298				skb->protocol = eth_type_trans(skb, dev);
1299				netif_rx(skb);
1300				dev->stats.rx_packets++;
1301				dev->stats.rx_bytes += pkt_len;
1302				/* Wait a limited time to go to next packet. */
1303				for (i = 200; i >= 0; i--)
1304					if (! (inw(ioaddr + EL3_STATUS) & CmdInProgress))
1305						break;
1306				continue;
1307			} else if (corkscrew_debug)
1308				pr_debug("%s: Couldn't allocate a sk_buff of size %d.\n", dev->name, pkt_len);
1309		}
1310		outw(RxDiscard, ioaddr + EL3_CMD);
1311		dev->stats.rx_dropped++;
1312		/* Wait a limited time to skip this packet. */
1313		for (i = 200; i >= 0; i--)
1314			if (!(inw(ioaddr + EL3_STATUS) & CmdInProgress))
1315				break;
1316	}
1317	return 0;
1318}
1319
1320static int boomerang_rx(struct net_device *dev)
1321{
1322	struct corkscrew_private *vp = netdev_priv(dev);
1323	int entry = vp->cur_rx % RX_RING_SIZE;
1324	int ioaddr = dev->base_addr;
1325	int rx_status;
1326
1327	if (corkscrew_debug > 5)
1328		pr_debug("   In boomerang_rx(), status %4.4x, rx_status %4.4x.\n",
1329			inw(ioaddr + EL3_STATUS), inw(ioaddr + RxStatus));
1330	while ((rx_status = vp->rx_ring[entry].status) & RxDComplete) {
1331		if (rx_status & RxDError) {	/* Error, update stats. */
1332			unsigned char rx_error = rx_status >> 16;
1333			if (corkscrew_debug > 2)
1334				pr_debug(" Rx error: status %2.2x.\n",
1335				       rx_error);
1336			dev->stats.rx_errors++;
1337			if (rx_error & 0x01)
1338				dev->stats.rx_over_errors++;
1339			if (rx_error & 0x02)
1340				dev->stats.rx_length_errors++;
1341			if (rx_error & 0x04)
1342				dev->stats.rx_frame_errors++;
1343			if (rx_error & 0x08)
1344				dev->stats.rx_crc_errors++;
1345			if (rx_error & 0x10)
1346				dev->stats.rx_length_errors++;
1347		} else {
1348			/* The packet length: up to 4.5K!. */
1349			short pkt_len = rx_status & 0x1fff;
1350			struct sk_buff *skb;
1351
1352			dev->stats.rx_bytes += pkt_len;
1353			if (corkscrew_debug > 4)
1354				pr_debug("Receiving packet size %d status %4.4x.\n",
1355				     pkt_len, rx_status);
1356
1357			/* Check if the packet is long enough to just accept without
1358			   copying to a properly sized skbuff. */
1359			if (pkt_len < rx_copybreak &&
1360			    (skb = netdev_alloc_skb(dev, pkt_len + 4)) != NULL) {
1361				skb_reserve(skb, 2);	/* Align IP on 16 byte boundaries */
1362				/* 'skb_put()' points to the start of sk_buff data area. */
1363				skb_put_data(skb,
1364					     isa_bus_to_virt(vp->rx_ring[entry].addr),
1365					     pkt_len);
1366				rx_copy++;
1367			} else {
1368				void *temp;
1369				/* Pass up the skbuff already on the Rx ring. */
1370				skb = vp->rx_skbuff[entry];
1371				vp->rx_skbuff[entry] = NULL;
1372				temp = skb_put(skb, pkt_len);
1373				/* Remove this checking code for final release. */
1374				if (isa_bus_to_virt(vp->rx_ring[entry].addr) != temp)
1375					pr_warn("%s: Warning -- the skbuff addresses do not match in boomerang_rx: %p vs. %p / %p\n",
1376						dev->name,
1377						isa_bus_to_virt(vp->rx_ring[entry].addr),
1378						skb->head, temp);
1379				rx_nocopy++;
1380			}
1381			skb->protocol = eth_type_trans(skb, dev);
1382			netif_rx(skb);
1383			dev->stats.rx_packets++;
1384		}
1385		entry = (++vp->cur_rx) % RX_RING_SIZE;
1386	}
1387	/* Refill the Rx ring buffers. */
1388	for (; vp->cur_rx - vp->dirty_rx > 0; vp->dirty_rx++) {
1389		struct sk_buff *skb;
1390		entry = vp->dirty_rx % RX_RING_SIZE;
1391		if (vp->rx_skbuff[entry] == NULL) {
1392			skb = netdev_alloc_skb(dev, PKT_BUF_SZ);
1393			if (skb == NULL)
1394				break;	/* Bad news!  */
1395			skb_reserve(skb, 2);	/* Align IP on 16 byte boundaries */
1396			vp->rx_ring[entry].addr = isa_virt_to_bus(skb->data);
1397			vp->rx_skbuff[entry] = skb;
1398		}
1399		vp->rx_ring[entry].status = 0;	/* Clear complete bit. */
1400	}
1401	return 0;
1402}
1403
1404static int corkscrew_close(struct net_device *dev)
1405{
1406	struct corkscrew_private *vp = netdev_priv(dev);
1407	int ioaddr = dev->base_addr;
1408	int i;
1409
1410	netif_stop_queue(dev);
1411
1412	if (corkscrew_debug > 1) {
1413		pr_debug("%s: corkscrew_close() status %4.4x, Tx status %2.2x.\n",
1414		     dev->name, inw(ioaddr + EL3_STATUS),
1415		     inb(ioaddr + TxStatus));
1416		pr_debug("%s: corkscrew close stats: rx_nocopy %d rx_copy %d tx_queued %d.\n",
1417			dev->name, rx_nocopy, rx_copy, queued_packet);
1418	}
1419
1420	del_timer_sync(&vp->timer);
1421
1422	/* Turn off statistics ASAP.  We update lp->stats below. */
1423	outw(StatsDisable, ioaddr + EL3_CMD);
1424
1425	/* Disable the receiver and transmitter. */
1426	outw(RxDisable, ioaddr + EL3_CMD);
1427	outw(TxDisable, ioaddr + EL3_CMD);
1428
1429	if (dev->if_port == XCVR_10base2)
1430		/* Turn off thinnet power.  Green! */
1431		outw(StopCoax, ioaddr + EL3_CMD);
1432
1433	free_irq(dev->irq, dev);
1434
1435	outw(SetIntrEnb | 0x0000, ioaddr + EL3_CMD);
1436
1437	update_stats(ioaddr, dev);
1438	if (vp->full_bus_master_rx) {	/* Free Boomerang bus master Rx buffers. */
1439		outl(0, ioaddr + UpListPtr);
1440		for (i = 0; i < RX_RING_SIZE; i++)
1441			if (vp->rx_skbuff[i]) {
1442				dev_kfree_skb(vp->rx_skbuff[i]);
1443				vp->rx_skbuff[i] = NULL;
1444			}
1445	}
1446	if (vp->full_bus_master_tx) {	/* Free Boomerang bus master Tx buffers. */
1447		outl(0, ioaddr + DownListPtr);
1448		for (i = 0; i < TX_RING_SIZE; i++)
1449			if (vp->tx_skbuff[i]) {
1450				dev_kfree_skb(vp->tx_skbuff[i]);
1451				vp->tx_skbuff[i] = NULL;
1452			}
1453	}
1454
1455	return 0;
1456}
1457
1458static struct net_device_stats *corkscrew_get_stats(struct net_device *dev)
1459{
1460	struct corkscrew_private *vp = netdev_priv(dev);
1461	unsigned long flags;
1462
1463	if (netif_running(dev)) {
1464		spin_lock_irqsave(&vp->lock, flags);
1465		update_stats(dev->base_addr, dev);
1466		spin_unlock_irqrestore(&vp->lock, flags);
1467	}
1468	return &dev->stats;
1469}
1470
1471/*  Update statistics.
1472	Unlike with the EL3 we need not worry about interrupts changing
1473	the window setting from underneath us, but we must still guard
1474	against a race condition with a StatsUpdate interrupt updating the
1475	table.  This is done by checking that the ASM (!) code generated uses
1476	atomic updates with '+='.
1477	*/
1478static void update_stats(int ioaddr, struct net_device *dev)
1479{
1480	/* Unlike the 3c5x9 we need not turn off stats updates while reading. */
1481	/* Switch to the stats window, and read everything. */
1482	EL3WINDOW(6);
1483	dev->stats.tx_carrier_errors += inb(ioaddr + 0);
1484	dev->stats.tx_heartbeat_errors += inb(ioaddr + 1);
1485	/* Multiple collisions. */ inb(ioaddr + 2);
1486	dev->stats.collisions += inb(ioaddr + 3);
1487	dev->stats.tx_window_errors += inb(ioaddr + 4);
1488	dev->stats.rx_fifo_errors += inb(ioaddr + 5);
1489	dev->stats.tx_packets += inb(ioaddr + 6);
1490	dev->stats.tx_packets += (inb(ioaddr + 9) & 0x30) << 4;
1491						/* Rx packets   */ inb(ioaddr + 7);
1492						/* Must read to clear */
1493	/* Tx deferrals */ inb(ioaddr + 8);
1494	/* Don't bother with register 9, an extension of registers 6&7.
1495	   If we do use the 6&7 values the atomic update assumption above
1496	   is invalid. */
1497	inw(ioaddr + 10);	/* Total Rx and Tx octets. */
1498	inw(ioaddr + 12);
1499	/* New: On the Vortex we must also clear the BadSSD counter. */
1500	EL3WINDOW(4);
1501	inb(ioaddr + 12);
1502
1503	/* We change back to window 7 (not 1) with the Vortex. */
1504	EL3WINDOW(7);
1505}
1506
1507/* This new version of set_rx_mode() supports v1.4 kernels.
1508   The Vortex chip has no documented multicast filter, so the only
1509   multicast setting is to receive all multicast frames.  At least
1510   the chip has a very clean way to set the mode, unlike many others. */
1511static void set_rx_mode(struct net_device *dev)
1512{
1513	int ioaddr = dev->base_addr;
1514	unsigned short new_mode;
1515
1516	if (dev->flags & IFF_PROMISC) {
1517		if (corkscrew_debug > 3)
1518			pr_debug("%s: Setting promiscuous mode.\n",
1519			       dev->name);
1520		new_mode = SetRxFilter | RxStation | RxMulticast | RxBroadcast | RxProm;
1521	} else if (!netdev_mc_empty(dev) || dev->flags & IFF_ALLMULTI) {
1522		new_mode = SetRxFilter | RxStation | RxMulticast | RxBroadcast;
1523	} else
1524		new_mode = SetRxFilter | RxStation | RxBroadcast;
1525
1526	outw(new_mode, ioaddr + EL3_CMD);
1527}
1528
1529static void netdev_get_drvinfo(struct net_device *dev,
1530			       struct ethtool_drvinfo *info)
1531{
1532	strscpy(info->driver, DRV_NAME, sizeof(info->driver));
 
1533	snprintf(info->bus_info, sizeof(info->bus_info), "ISA 0x%lx",
1534		 dev->base_addr);
1535}
1536
1537static u32 netdev_get_msglevel(struct net_device *dev)
1538{
1539	return corkscrew_debug;
1540}
1541
1542static void netdev_set_msglevel(struct net_device *dev, u32 level)
1543{
1544	corkscrew_debug = level;
1545}
1546
1547static const struct ethtool_ops netdev_ethtool_ops = {
1548	.get_drvinfo		= netdev_get_drvinfo,
1549	.get_msglevel		= netdev_get_msglevel,
1550	.set_msglevel		= netdev_set_msglevel,
1551};
1552
1553
1554#ifdef MODULE
1555void cleanup_module(void)
1556{
1557	while (!list_empty(&root_corkscrew_dev)) {
1558		struct net_device *dev;
1559		struct corkscrew_private *vp;
1560
1561		vp = list_entry(root_corkscrew_dev.next,
1562				struct corkscrew_private, list);
1563		dev = vp->our_dev;
1564		unregister_netdev(dev);
1565		cleanup_card(dev);
1566		free_netdev(dev);
1567	}
1568}
1569#endif				/* MODULE */