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