1 /* 3c574.c: A PCMCIA ethernet driver for the 3com 3c574 "RoadRunner".
2 
3 	Written 1993-1998 by
4 	Donald Becker, becker@scyld.com, (driver core) and
5 	David Hinds, dahinds@users.sourceforge.net (from his PC card code).
6 	Locking fixes (C) Copyright 2003 Red Hat Inc
7 
8 	This software may be used and distributed according to the terms of
9 	the GNU General Public License, incorporated herein by reference.
10 
11 	This driver derives from Donald Becker's 3c509 core, which has the
12 	following copyright:
13 	Copyright 1993 United States Government as represented by the
14 	Director, National Security Agency.
15 
16 
17 */
18 
19 /*
20 				Theory of Operation
21 
22 I. Board Compatibility
23 
24 This device driver is designed for the 3Com 3c574 PC card Fast Ethernet
25 Adapter.
26 
27 II. Board-specific settings
28 
29 None -- PC cards are autoconfigured.
30 
31 III. Driver operation
32 
33 The 3c574 uses a Boomerang-style interface, without the bus-master capability.
34 See the Boomerang driver and documentation for most details.
35 
36 IV. Notes and chip documentation.
37 
38 Two added registers are used to enhance PIO performance, RunnerRdCtrl and
39 RunnerWrCtrl.  These are 11 bit down-counters that are preloaded with the
40 count of word (16 bits) reads or writes the driver is about to do to the Rx
41 or Tx FIFO.  The chip is then able to hide the internal-PCI-bus to PC-card
42 translation latency by buffering the I/O operations with an 8 word FIFO.
43 Note: No other chip accesses are permitted when this buffer is used.
44 
45 A second enhancement is that both attribute and common memory space
46 0x0800-0x0fff can translated to the PIO FIFO.  Thus memory operations (faster
47 with *some* PCcard bridges) may be used instead of I/O operations.
48 This is enabled by setting the 0x10 bit in the PCMCIA LAN COR.
49 
50 Some slow PC card bridges work better if they never see a WAIT signal.
51 This is configured by setting the 0x20 bit in the PCMCIA LAN COR.
52 Only do this after testing that it is reliable and improves performance.
53 
54 The upper five bits of RunnerRdCtrl are used to window into PCcard
55 configuration space registers.  Window 0 is the regular Boomerang/Odie
56 register set, 1-5 are various PC card control registers, and 16-31 are
57 the (reversed!) CIS table.
58 
59 A final note: writing the InternalConfig register in window 3 with an
60 invalid ramWidth is Very Bad.
61 
62 V. References
63 
64 http://www.scyld.com/expert/NWay.html
65 http://www.national.com/opf/DP/DP83840A.html
66 
67 Thanks to Terry Murphy of 3Com for providing development information for
68 earlier 3Com products.
69 
70 */
71 
72 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
73 
74 #include <linux/module.h>
75 #include <linux/kernel.h>
76 #include <linux/slab.h>
77 #include <linux/string.h>
78 #include <linux/timer.h>
79 #include <linux/interrupt.h>
80 #include <linux/in.h>
81 #include <linux/delay.h>
82 #include <linux/netdevice.h>
83 #include <linux/etherdevice.h>
84 #include <linux/skbuff.h>
85 #include <linux/if_arp.h>
86 #include <linux/ioport.h>
87 #include <linux/bitops.h>
88 #include <linux/mii.h>
89 
90 #include <pcmcia/cistpl.h>
91 #include <pcmcia/cisreg.h>
92 #include <pcmcia/ciscode.h>
93 #include <pcmcia/ds.h>
94 
95 #include <linux/uaccess.h>
96 #include <asm/io.h>
97 
98 /*====================================================================*/
99 
100 /* Module parameters */
101 
102 MODULE_AUTHOR("David Hinds <dahinds@users.sourceforge.net>");
103 MODULE_DESCRIPTION("3Com 3c574 series PCMCIA ethernet driver");
104 MODULE_LICENSE("GPL");
105 
106 #define INT_MODULE_PARM(n, v) static int n = v; module_param(n, int, 0)
107 
108 /* Maximum events (Rx packets, etc.) to handle at each interrupt. */
109 INT_MODULE_PARM(max_interrupt_work, 32);
110 
111 /* Force full duplex modes? */
112 INT_MODULE_PARM(full_duplex, 0);
113 
114 /* Autodetect link polarity reversal? */
115 INT_MODULE_PARM(auto_polarity, 1);
116 
117 
118 /*====================================================================*/
119 
120 /* Time in jiffies before concluding the transmitter is hung. */
121 #define TX_TIMEOUT  ((800*HZ)/1000)
122 
123 /* To minimize the size of the driver source and make the driver more
124    readable not all constants are symbolically defined.
125    You'll need the manual if you want to understand driver details anyway. */
126 /* Offsets from base I/O address. */
127 #define EL3_DATA	0x00
128 #define EL3_CMD		0x0e
129 #define EL3_STATUS	0x0e
130 
131 #define EL3WINDOW(win_num) outw(SelectWindow + (win_num), ioaddr + EL3_CMD)
132 
133 /* The top five bits written to EL3_CMD are a command, the lower
134    11 bits are the parameter, if applicable. */
135 enum el3_cmds {
136 	TotalReset = 0<<11, SelectWindow = 1<<11, StartCoax = 2<<11,
137 	RxDisable = 3<<11, RxEnable = 4<<11, RxReset = 5<<11, RxDiscard = 8<<11,
138 	TxEnable = 9<<11, TxDisable = 10<<11, TxReset = 11<<11,
139 	FakeIntr = 12<<11, AckIntr = 13<<11, SetIntrEnb = 14<<11,
140 	SetStatusEnb = 15<<11, SetRxFilter = 16<<11, SetRxThreshold = 17<<11,
141 	SetTxThreshold = 18<<11, SetTxStart = 19<<11, StatsEnable = 21<<11,
142 	StatsDisable = 22<<11, StopCoax = 23<<11,
143 };
144 
145 enum elxl_status {
146 	IntLatch = 0x0001, AdapterFailure = 0x0002, TxComplete = 0x0004,
147 	TxAvailable = 0x0008, RxComplete = 0x0010, RxEarly = 0x0020,
148 	IntReq = 0x0040, StatsFull = 0x0080, CmdBusy = 0x1000 };
149 
150 /* The SetRxFilter command accepts the following classes: */
151 enum RxFilter {
152 	RxStation = 1, RxMulticast = 2, RxBroadcast = 4, RxProm = 8
153 };
154 
155 enum Window0 {
156 	Wn0EepromCmd = 10, Wn0EepromData = 12, /* EEPROM command/address, data. */
157 	IntrStatus=0x0E,		/* Valid in all windows. */
158 };
159 /* These assumes the larger EEPROM. */
160 enum Win0_EEPROM_cmds {
161 	EEPROM_Read = 0x200, EEPROM_WRITE = 0x100, EEPROM_ERASE = 0x300,
162 	EEPROM_EWENB = 0x30,		/* Enable erasing/writing for 10 msec. */
163 	EEPROM_EWDIS = 0x00,		/* Disable EWENB before 10 msec timeout. */
164 };
165 
166 /* Register window 1 offsets, the window used in normal operation.
167    On the "Odie" this window is always mapped at offsets 0x10-0x1f.
168    Except for TxFree, which is overlapped by RunnerWrCtrl. */
169 enum Window1 {
170 	TX_FIFO = 0x10,  RX_FIFO = 0x10,  RxErrors = 0x14,
171 	RxStatus = 0x18,  Timer=0x1A, TxStatus = 0x1B,
172 	TxFree = 0x0C, /* Remaining free bytes in Tx buffer. */
173 	RunnerRdCtrl = 0x16, RunnerWrCtrl = 0x1c,
174 };
175 
176 enum Window3 {			/* Window 3: MAC/config bits. */
177 	Wn3_Config=0, Wn3_MAC_Ctrl=6, Wn3_Options=8,
178 };
179 enum wn3_config {
180 	Ram_size = 7,
181 	Ram_width = 8,
182 	Ram_speed = 0x30,
183 	Rom_size = 0xc0,
184 	Ram_split_shift = 16,
185 	Ram_split = 3 << Ram_split_shift,
186 	Xcvr_shift = 20,
187 	Xcvr = 7 << Xcvr_shift,
188 	Autoselect = 0x1000000,
189 };
190 
191 enum Window4 {		/* Window 4: Xcvr/media bits. */
192 	Wn4_FIFODiag = 4, Wn4_NetDiag = 6, Wn4_PhysicalMgmt=8, Wn4_Media = 10,
193 };
194 
195 #define MEDIA_TP	0x00C0	/* Enable link beat and jabber for 10baseT. */
196 
197 struct el3_private {
198 	struct pcmcia_device	*p_dev;
199 	u16 advertising, partner;		/* NWay media advertisement */
200 	unsigned char phys;			/* MII device address */
201 	unsigned int autoselect:1, default_media:3;	/* Read from the EEPROM/Wn3_Config. */
202 	/* for transceiver monitoring */
203 	struct timer_list media;
204 	unsigned short media_status;
205 	unsigned short fast_poll;
206 	unsigned long last_irq;
207 	spinlock_t window_lock;			/* Guards the Window selection */
208 };
209 
210 /* Set iff a MII transceiver on any interface requires mdio preamble.
211    This only set with the original DP83840 on older 3c905 boards, so the extra
212    code size of a per-interface flag is not worthwhile. */
213 static char mii_preamble_required = 0;
214 
215 /* Index of functions. */
216 
217 static int tc574_config(struct pcmcia_device *link);
218 static void tc574_release(struct pcmcia_device *link);
219 
220 static void mdio_sync(unsigned int ioaddr, int bits);
221 static int mdio_read(unsigned int ioaddr, int phy_id, int location);
222 static void mdio_write(unsigned int ioaddr, int phy_id, int location,
223 		       int value);
224 static unsigned short read_eeprom(unsigned int ioaddr, int index);
225 static void tc574_wait_for_completion(struct net_device *dev, int cmd);
226 
227 static void tc574_reset(struct net_device *dev);
228 static void media_check(struct timer_list *t);
229 static int el3_open(struct net_device *dev);
230 static netdev_tx_t el3_start_xmit(struct sk_buff *skb,
231 					struct net_device *dev);
232 static irqreturn_t el3_interrupt(int irq, void *dev_id);
233 static void update_stats(struct net_device *dev);
234 static struct net_device_stats *el3_get_stats(struct net_device *dev);
235 static int el3_rx(struct net_device *dev, int worklimit);
236 static int el3_close(struct net_device *dev);
237 static void el3_tx_timeout(struct net_device *dev, unsigned int txqueue);
238 static int el3_ioctl(struct net_device *dev, struct ifreq *rq, int cmd);
239 static void set_rx_mode(struct net_device *dev);
240 static void set_multicast_list(struct net_device *dev);
241 
242 static void tc574_detach(struct pcmcia_device *p_dev);
243 
244 /*
245 	tc574_attach() creates an "instance" of the driver, allocating
246 	local data structures for one device.  The device is registered
247 	with Card Services.
248 */
249 static const struct net_device_ops el3_netdev_ops = {
250 	.ndo_open 		= el3_open,
251 	.ndo_stop 		= el3_close,
252 	.ndo_start_xmit		= el3_start_xmit,
253 	.ndo_tx_timeout 	= el3_tx_timeout,
254 	.ndo_get_stats		= el3_get_stats,
255 	.ndo_eth_ioctl		= el3_ioctl,
256 	.ndo_set_rx_mode	= set_multicast_list,
257 	.ndo_set_mac_address 	= eth_mac_addr,
258 	.ndo_validate_addr	= eth_validate_addr,
259 };
260 
261 static int tc574_probe(struct pcmcia_device *link)
262 {
263 	struct el3_private *lp;
264 	struct net_device *dev;
265 
266 	dev_dbg(&link->dev, "3c574_attach()\n");
267 
268 	/* Create the PC card device object. */
269 	dev = alloc_etherdev(sizeof(struct el3_private));
270 	if (!dev)
271 		return -ENOMEM;
272 	lp = netdev_priv(dev);
273 	link->priv = dev;
274 	lp->p_dev = link;
275 
276 	spin_lock_init(&lp->window_lock);
277 	link->resource[0]->end = 32;
278 	link->resource[0]->flags |= IO_DATA_PATH_WIDTH_16;
279 	link->config_flags |= CONF_ENABLE_IRQ;
280 	link->config_index = 1;
281 
282 	dev->netdev_ops = &el3_netdev_ops;
283 	dev->watchdog_timeo = TX_TIMEOUT;
284 
285 	return tc574_config(link);
286 }
287 
288 static void tc574_detach(struct pcmcia_device *link)
289 {
290 	struct net_device *dev = link->priv;
291 
292 	dev_dbg(&link->dev, "3c574_detach()\n");
293 
294 	unregister_netdev(dev);
295 
296 	tc574_release(link);
297 
298 	free_netdev(dev);
299 } /* tc574_detach */
300 
301 static const char *ram_split[] = {"5:3", "3:1", "1:1", "3:5"};
302 
303 static int tc574_config(struct pcmcia_device *link)
304 {
305 	struct net_device *dev = link->priv;
306 	struct el3_private *lp = netdev_priv(dev);
307 	int ret, i, j;
308 	__be16 addr[ETH_ALEN / 2];
309 	unsigned int ioaddr;
310 	char *cardname;
311 	__u32 config;
312 	u8 *buf;
313 	size_t len;
314 
315 	dev_dbg(&link->dev, "3c574_config()\n");
316 
317 	link->io_lines = 16;
318 
319 	for (i = j = 0; j < 0x400; j += 0x20) {
320 		link->resource[0]->start = j ^ 0x300;
321 		i = pcmcia_request_io(link);
322 		if (i == 0)
323 			break;
324 	}
325 	if (i != 0)
326 		goto failed;
327 
328 	ret = pcmcia_request_irq(link, el3_interrupt);
329 	if (ret)
330 		goto failed;
331 
332 	ret = pcmcia_enable_device(link);
333 	if (ret)
334 		goto failed;
335 
336 	dev->irq = link->irq;
337 	dev->base_addr = link->resource[0]->start;
338 
339 	ioaddr = dev->base_addr;
340 
341 	/* The 3c574 normally uses an EEPROM for configuration info, including
342 	   the hardware address.  The future products may include a modem chip
343 	   and put the address in the CIS. */
344 
345 	len = pcmcia_get_tuple(link, 0x88, &buf);
346 	if (buf && len >= 6) {
347 		for (i = 0; i < 3; i++)
348 			addr[i] = htons(le16_to_cpu(buf[i * 2]));
349 		kfree(buf);
350 	} else {
351 		kfree(buf); /* 0 < len < 6 */
352 		EL3WINDOW(0);
353 		for (i = 0; i < 3; i++)
354 			addr[i] = htons(read_eeprom(ioaddr, i + 10));
355 		if (addr[0] == htons(0x6060)) {
356 			pr_notice("IO port conflict at 0x%03lx-0x%03lx\n",
357 				  dev->base_addr, dev->base_addr+15);
358 			goto failed;
359 		}
360 	}
361 	eth_hw_addr_set(dev, (u8 *)addr);
362 	if (link->prod_id[1])
363 		cardname = link->prod_id[1];
364 	else
365 		cardname = "3Com 3c574";
366 
367 	{
368 		u_char mcr;
369 		outw(2<<11, ioaddr + RunnerRdCtrl);
370 		mcr = inb(ioaddr + 2);
371 		outw(0<<11, ioaddr + RunnerRdCtrl);
372 		pr_info("  ASIC rev %d,", mcr>>3);
373 		EL3WINDOW(3);
374 		config = inl(ioaddr + Wn3_Config);
375 		lp->default_media = (config & Xcvr) >> Xcvr_shift;
376 		lp->autoselect = config & Autoselect ? 1 : 0;
377 	}
378 
379 	timer_setup(&lp->media, media_check, 0);
380 
381 	{
382 		int phy;
383 
384 		/* Roadrunner only: Turn on the MII transceiver */
385 		outw(0x8040, ioaddr + Wn3_Options);
386 		mdelay(1);
387 		outw(0xc040, ioaddr + Wn3_Options);
388 		tc574_wait_for_completion(dev, TxReset);
389 		tc574_wait_for_completion(dev, RxReset);
390 		mdelay(1);
391 		outw(0x8040, ioaddr + Wn3_Options);
392 
393 		EL3WINDOW(4);
394 		for (phy = 1; phy <= 32; phy++) {
395 			int mii_status;
396 			mdio_sync(ioaddr, 32);
397 			mii_status = mdio_read(ioaddr, phy & 0x1f, 1);
398 			if (mii_status != 0xffff) {
399 				lp->phys = phy & 0x1f;
400 				dev_dbg(&link->dev, "  MII transceiver at "
401 					"index %d, status %x.\n",
402 					  phy, mii_status);
403 				if ((mii_status & 0x0040) == 0)
404 					mii_preamble_required = 1;
405 				break;
406 			}
407 		}
408 		if (phy > 32) {
409 			pr_notice("  No MII transceivers found!\n");
410 			goto failed;
411 		}
412 		i = mdio_read(ioaddr, lp->phys, 16) | 0x40;
413 		mdio_write(ioaddr, lp->phys, 16, i);
414 		lp->advertising = mdio_read(ioaddr, lp->phys, 4);
415 		if (full_duplex) {
416 			/* Only advertise the FD media types. */
417 			lp->advertising &= ~0x02a0;
418 			mdio_write(ioaddr, lp->phys, 4, lp->advertising);
419 		}
420 	}
421 
422 	SET_NETDEV_DEV(dev, &link->dev);
423 
424 	if (register_netdev(dev) != 0) {
425 		pr_notice("register_netdev() failed\n");
426 		goto failed;
427 	}
428 
429 	netdev_info(dev, "%s at io %#3lx, irq %d, hw_addr %pM\n",
430 		    cardname, dev->base_addr, dev->irq, dev->dev_addr);
431 	netdev_info(dev, " %dK FIFO split %s Rx:Tx, %sMII interface.\n",
432 		    8 << (config & Ram_size),
433 		    ram_split[(config & Ram_split) >> Ram_split_shift],
434 		    config & Autoselect ? "autoselect " : "");
435 
436 	return 0;
437 
438 failed:
439 	tc574_release(link);
440 	return -ENODEV;
441 
442 } /* tc574_config */
443 
444 static void tc574_release(struct pcmcia_device *link)
445 {
446 	pcmcia_disable_device(link);
447 }
448 
449 static int tc574_suspend(struct pcmcia_device *link)
450 {
451 	struct net_device *dev = link->priv;
452 
453 	if (link->open)
454 		netif_device_detach(dev);
455 
456 	return 0;
457 }
458 
459 static int tc574_resume(struct pcmcia_device *link)
460 {
461 	struct net_device *dev = link->priv;
462 
463 	if (link->open) {
464 		tc574_reset(dev);
465 		netif_device_attach(dev);
466 	}
467 
468 	return 0;
469 }
470 
471 static void dump_status(struct net_device *dev)
472 {
473 	unsigned int ioaddr = dev->base_addr;
474 	EL3WINDOW(1);
475 	netdev_info(dev, "  irq status %04x, rx status %04x, tx status %02x, tx free %04x\n",
476 		    inw(ioaddr+EL3_STATUS),
477 		    inw(ioaddr+RxStatus), inb(ioaddr+TxStatus),
478 		    inw(ioaddr+TxFree));
479 	EL3WINDOW(4);
480 	netdev_info(dev, "  diagnostics: fifo %04x net %04x ethernet %04x media %04x\n",
481 		    inw(ioaddr+0x04), inw(ioaddr+0x06),
482 		    inw(ioaddr+0x08), inw(ioaddr+0x0a));
483 	EL3WINDOW(1);
484 }
485 
486 /*
487   Use this for commands that may take time to finish
488 */
489 static void tc574_wait_for_completion(struct net_device *dev, int cmd)
490 {
491 	int i = 1500;
492 	outw(cmd, dev->base_addr + EL3_CMD);
493 	while (--i > 0)
494 		if (!(inw(dev->base_addr + EL3_STATUS) & 0x1000)) break;
495 	if (i == 0)
496 		netdev_notice(dev, "command 0x%04x did not complete!\n", cmd);
497 }
498 
499 /* Read a word from the EEPROM using the regular EEPROM access register.
500    Assume that we are in register window zero.
501  */
502 static unsigned short read_eeprom(unsigned int ioaddr, int index)
503 {
504 	int timer;
505 	outw(EEPROM_Read + index, ioaddr + Wn0EepromCmd);
506 	/* Pause for at least 162 usec for the read to take place. */
507 	for (timer = 1620; timer >= 0; timer--) {
508 		if ((inw(ioaddr + Wn0EepromCmd) & 0x8000) == 0)
509 			break;
510 	}
511 	return inw(ioaddr + Wn0EepromData);
512 }
513 
514 /* MII transceiver control section.
515    Read and write the MII registers using software-generated serial
516    MDIO protocol.  See the MII specifications or DP83840A data sheet
517    for details.
518    The maxium data clock rate is 2.5 Mhz.  The timing is easily met by the
519    slow PC card interface. */
520 
521 #define MDIO_SHIFT_CLK	0x01
522 #define MDIO_DIR_WRITE	0x04
523 #define MDIO_DATA_WRITE0 (0x00 | MDIO_DIR_WRITE)
524 #define MDIO_DATA_WRITE1 (0x02 | MDIO_DIR_WRITE)
525 #define MDIO_DATA_READ	0x02
526 #define MDIO_ENB_IN		0x00
527 
528 /* Generate the preamble required for initial synchronization and
529    a few older transceivers. */
530 static void mdio_sync(unsigned int ioaddr, int bits)
531 {
532 	unsigned int mdio_addr = ioaddr + Wn4_PhysicalMgmt;
533 
534 	/* Establish sync by sending at least 32 logic ones. */
535 	while (-- bits >= 0) {
536 		outw(MDIO_DATA_WRITE1, mdio_addr);
537 		outw(MDIO_DATA_WRITE1 | MDIO_SHIFT_CLK, mdio_addr);
538 	}
539 }
540 
541 static int mdio_read(unsigned int ioaddr, int phy_id, int location)
542 {
543 	int i;
544 	int read_cmd = (0xf6 << 10) | (phy_id << 5) | location;
545 	unsigned int retval = 0;
546 	unsigned int mdio_addr = ioaddr + Wn4_PhysicalMgmt;
547 
548 	if (mii_preamble_required)
549 		mdio_sync(ioaddr, 32);
550 
551 	/* Shift the read command bits out. */
552 	for (i = 14; i >= 0; i--) {
553 		int dataval = (read_cmd&(1<<i)) ? MDIO_DATA_WRITE1 : MDIO_DATA_WRITE0;
554 		outw(dataval, mdio_addr);
555 		outw(dataval | MDIO_SHIFT_CLK, mdio_addr);
556 	}
557 	/* Read the two transition, 16 data, and wire-idle bits. */
558 	for (i = 19; i > 0; i--) {
559 		outw(MDIO_ENB_IN, mdio_addr);
560 		retval = (retval << 1) | ((inw(mdio_addr) & MDIO_DATA_READ) ? 1 : 0);
561 		outw(MDIO_ENB_IN | MDIO_SHIFT_CLK, mdio_addr);
562 	}
563 	return (retval>>1) & 0xffff;
564 }
565 
566 static void mdio_write(unsigned int ioaddr, int phy_id, int location, int value)
567 {
568 	int write_cmd = 0x50020000 | (phy_id << 23) | (location << 18) | value;
569 	unsigned int mdio_addr = ioaddr + Wn4_PhysicalMgmt;
570 	int i;
571 
572 	if (mii_preamble_required)
573 		mdio_sync(ioaddr, 32);
574 
575 	/* Shift the command bits out. */
576 	for (i = 31; i >= 0; i--) {
577 		int dataval = (write_cmd&(1<<i)) ? MDIO_DATA_WRITE1 : MDIO_DATA_WRITE0;
578 		outw(dataval, mdio_addr);
579 		outw(dataval | MDIO_SHIFT_CLK, mdio_addr);
580 	}
581 	/* Leave the interface idle. */
582 	for (i = 1; i >= 0; i--) {
583 		outw(MDIO_ENB_IN, mdio_addr);
584 		outw(MDIO_ENB_IN | MDIO_SHIFT_CLK, mdio_addr);
585 	}
586 }
587 
588 /* Reset and restore all of the 3c574 registers. */
589 static void tc574_reset(struct net_device *dev)
590 {
591 	struct el3_private *lp = netdev_priv(dev);
592 	int i;
593 	unsigned int ioaddr = dev->base_addr;
594 	unsigned long flags;
595 
596 	tc574_wait_for_completion(dev, TotalReset|0x10);
597 
598 	spin_lock_irqsave(&lp->window_lock, flags);
599 	/* Clear any transactions in progress. */
600 	outw(0, ioaddr + RunnerWrCtrl);
601 	outw(0, ioaddr + RunnerRdCtrl);
602 
603 	/* Set the station address and mask. */
604 	EL3WINDOW(2);
605 	for (i = 0; i < 6; i++)
606 		outb(dev->dev_addr[i], ioaddr + i);
607 	for (; i < 12; i+=2)
608 		outw(0, ioaddr + i);
609 
610 	/* Reset config options */
611 	EL3WINDOW(3);
612 	outb((dev->mtu > 1500 ? 0x40 : 0), ioaddr + Wn3_MAC_Ctrl);
613 	outl((lp->autoselect ? 0x01000000 : 0) | 0x0062001b,
614 		 ioaddr + Wn3_Config);
615 	/* Roadrunner only: Turn on the MII transceiver. */
616 	outw(0x8040, ioaddr + Wn3_Options);
617 	mdelay(1);
618 	outw(0xc040, ioaddr + Wn3_Options);
619 	EL3WINDOW(1);
620 	spin_unlock_irqrestore(&lp->window_lock, flags);
621 
622 	tc574_wait_for_completion(dev, TxReset);
623 	tc574_wait_for_completion(dev, RxReset);
624 	mdelay(1);
625 	spin_lock_irqsave(&lp->window_lock, flags);
626 	EL3WINDOW(3);
627 	outw(0x8040, ioaddr + Wn3_Options);
628 
629 	/* Switch to the stats window, and clear all stats by reading. */
630 	outw(StatsDisable, ioaddr + EL3_CMD);
631 	EL3WINDOW(6);
632 	for (i = 0; i < 10; i++)
633 		inb(ioaddr + i);
634 	inw(ioaddr + 10);
635 	inw(ioaddr + 12);
636 	EL3WINDOW(4);
637 	inb(ioaddr + 12);
638 	inb(ioaddr + 13);
639 
640 	/* .. enable any extra statistics bits.. */
641 	outw(0x0040, ioaddr + Wn4_NetDiag);
642 
643 	EL3WINDOW(1);
644 	spin_unlock_irqrestore(&lp->window_lock, flags);
645 
646 	/* .. re-sync MII and re-fill what NWay is advertising. */
647 	mdio_sync(ioaddr, 32);
648 	mdio_write(ioaddr, lp->phys, 4, lp->advertising);
649 	if (!auto_polarity) {
650 		/* works for TDK 78Q2120 series MII's */
651 		i = mdio_read(ioaddr, lp->phys, 16) | 0x20;
652 		mdio_write(ioaddr, lp->phys, 16, i);
653 	}
654 
655 	spin_lock_irqsave(&lp->window_lock, flags);
656 	/* Switch to register set 1 for normal use, just for TxFree. */
657 	set_rx_mode(dev);
658 	spin_unlock_irqrestore(&lp->window_lock, flags);
659 	outw(StatsEnable, ioaddr + EL3_CMD); /* Turn on statistics. */
660 	outw(RxEnable, ioaddr + EL3_CMD); /* Enable the receiver. */
661 	outw(TxEnable, ioaddr + EL3_CMD); /* Enable transmitter. */
662 	/* Allow status bits to be seen. */
663 	outw(SetStatusEnb | 0xff, ioaddr + EL3_CMD);
664 	/* Ack all pending events, and set active indicator mask. */
665 	outw(AckIntr | IntLatch | TxAvailable | RxEarly | IntReq,
666 		 ioaddr + EL3_CMD);
667 	outw(SetIntrEnb | IntLatch | TxAvailable | RxComplete | StatsFull
668 		 | AdapterFailure | RxEarly, ioaddr + EL3_CMD);
669 }
670 
671 static int el3_open(struct net_device *dev)
672 {
673 	struct el3_private *lp = netdev_priv(dev);
674 	struct pcmcia_device *link = lp->p_dev;
675 
676 	if (!pcmcia_dev_present(link))
677 		return -ENODEV;
678 
679 	link->open++;
680 	netif_start_queue(dev);
681 
682 	tc574_reset(dev);
683 	lp->media.expires = jiffies + HZ;
684 	add_timer(&lp->media);
685 
686 	dev_dbg(&link->dev, "%s: opened, status %4.4x.\n",
687 		  dev->name, inw(dev->base_addr + EL3_STATUS));
688 
689 	return 0;
690 }
691 
692 static void el3_tx_timeout(struct net_device *dev, unsigned int txqueue)
693 {
694 	unsigned int ioaddr = dev->base_addr;
695 
696 	netdev_notice(dev, "Transmit timed out!\n");
697 	dump_status(dev);
698 	dev->stats.tx_errors++;
699 	netif_trans_update(dev); /* prevent tx timeout */
700 	/* Issue TX_RESET and TX_START commands. */
701 	tc574_wait_for_completion(dev, TxReset);
702 	outw(TxEnable, ioaddr + EL3_CMD);
703 	netif_wake_queue(dev);
704 }
705 
706 static void pop_tx_status(struct net_device *dev)
707 {
708 	unsigned int ioaddr = dev->base_addr;
709 	int i;
710 
711 	/* Clear the Tx status stack. */
712 	for (i = 32; i > 0; i--) {
713 		u_char tx_status = inb(ioaddr + TxStatus);
714 		if (!(tx_status & 0x84))
715 			break;
716 		/* reset transmitter on jabber error or underrun */
717 		if (tx_status & 0x30)
718 			tc574_wait_for_completion(dev, TxReset);
719 		if (tx_status & 0x38) {
720 			pr_debug("%s: transmit error: status 0x%02x\n",
721 				  dev->name, tx_status);
722 			outw(TxEnable, ioaddr + EL3_CMD);
723 			dev->stats.tx_aborted_errors++;
724 		}
725 		outb(0x00, ioaddr + TxStatus); /* Pop the status stack. */
726 	}
727 }
728 
729 static netdev_tx_t el3_start_xmit(struct sk_buff *skb,
730 					struct net_device *dev)
731 {
732 	unsigned int ioaddr = dev->base_addr;
733 	struct el3_private *lp = netdev_priv(dev);
734 	unsigned long flags;
735 
736 	pr_debug("%s: el3_start_xmit(length = %ld) called, "
737 		  "status %4.4x.\n", dev->name, (long)skb->len,
738 		  inw(ioaddr + EL3_STATUS));
739 
740 	spin_lock_irqsave(&lp->window_lock, flags);
741 
742 	dev->stats.tx_bytes += skb->len;
743 
744 	/* Put out the doubleword header... */
745 	outw(skb->len, ioaddr + TX_FIFO);
746 	outw(0, ioaddr + TX_FIFO);
747 	/* ... and the packet rounded to a doubleword. */
748 	outsl(ioaddr + TX_FIFO, skb->data, (skb->len+3)>>2);
749 
750 	/* TxFree appears only in Window 1, not offset 0x1c. */
751 	if (inw(ioaddr + TxFree) <= 1536) {
752 		netif_stop_queue(dev);
753 		/* Interrupt us when the FIFO has room for max-sized packet.
754 		   The threshold is in units of dwords. */
755 		outw(SetTxThreshold + (1536>>2), ioaddr + EL3_CMD);
756 	}
757 
758 	pop_tx_status(dev);
759 	spin_unlock_irqrestore(&lp->window_lock, flags);
760 	dev_kfree_skb(skb);
761 	return NETDEV_TX_OK;
762 }
763 
764 /* The EL3 interrupt handler. */
765 static irqreturn_t el3_interrupt(int irq, void *dev_id)
766 {
767 	struct net_device *dev = (struct net_device *) dev_id;
768 	struct el3_private *lp = netdev_priv(dev);
769 	unsigned int ioaddr;
770 	unsigned status;
771 	int work_budget = max_interrupt_work;
772 	int handled = 0;
773 
774 	if (!netif_device_present(dev))
775 		return IRQ_NONE;
776 	ioaddr = dev->base_addr;
777 
778 	pr_debug("%s: interrupt, status %4.4x.\n",
779 		  dev->name, inw(ioaddr + EL3_STATUS));
780 
781 	spin_lock(&lp->window_lock);
782 
783 	while ((status = inw(ioaddr + EL3_STATUS)) &
784 		   (IntLatch | RxComplete | RxEarly | StatsFull)) {
785 		if (!netif_device_present(dev) ||
786 			((status & 0xe000) != 0x2000)) {
787 			pr_debug("%s: Interrupt from dead card\n", dev->name);
788 			break;
789 		}
790 
791 		handled = 1;
792 
793 		if (status & RxComplete)
794 			work_budget = el3_rx(dev, work_budget);
795 
796 		if (status & TxAvailable) {
797 			pr_debug("  TX room bit was handled.\n");
798 			/* There's room in the FIFO for a full-sized packet. */
799 			outw(AckIntr | TxAvailable, ioaddr + EL3_CMD);
800 			netif_wake_queue(dev);
801 		}
802 
803 		if (status & TxComplete)
804 			pop_tx_status(dev);
805 
806 		if (status & (AdapterFailure | RxEarly | StatsFull)) {
807 			/* Handle all uncommon interrupts. */
808 			if (status & StatsFull)
809 				update_stats(dev);
810 			if (status & RxEarly) {
811 				work_budget = el3_rx(dev, work_budget);
812 				outw(AckIntr | RxEarly, ioaddr + EL3_CMD);
813 			}
814 			if (status & AdapterFailure) {
815 				u16 fifo_diag;
816 				EL3WINDOW(4);
817 				fifo_diag = inw(ioaddr + Wn4_FIFODiag);
818 				EL3WINDOW(1);
819 				netdev_notice(dev, "adapter failure, FIFO diagnostic register %04x\n",
820 					      fifo_diag);
821 				if (fifo_diag & 0x0400) {
822 					/* Tx overrun */
823 					tc574_wait_for_completion(dev, TxReset);
824 					outw(TxEnable, ioaddr + EL3_CMD);
825 				}
826 				if (fifo_diag & 0x2000) {
827 					/* Rx underrun */
828 					tc574_wait_for_completion(dev, RxReset);
829 					set_rx_mode(dev);
830 					outw(RxEnable, ioaddr + EL3_CMD);
831 				}
832 				outw(AckIntr | AdapterFailure, ioaddr + EL3_CMD);
833 			}
834 		}
835 
836 		if (--work_budget < 0) {
837 			pr_debug("%s: Too much work in interrupt, "
838 				  "status %4.4x.\n", dev->name, status);
839 			/* Clear all interrupts */
840 			outw(AckIntr | 0xFF, ioaddr + EL3_CMD);
841 			break;
842 		}
843 		/* Acknowledge the IRQ. */
844 		outw(AckIntr | IntReq | IntLatch, ioaddr + EL3_CMD);
845 	}
846 
847 	pr_debug("%s: exiting interrupt, status %4.4x.\n",
848 		  dev->name, inw(ioaddr + EL3_STATUS));
849 
850 	spin_unlock(&lp->window_lock);
851 	return IRQ_RETVAL(handled);
852 }
853 
854 /*
855     This timer serves two purposes: to check for missed interrupts
856 	(and as a last resort, poll the NIC for events), and to monitor
857 	the MII, reporting changes in cable status.
858 */
859 static void media_check(struct timer_list *t)
860 {
861 	struct el3_private *lp = from_timer(lp, t, media);
862 	struct net_device *dev = lp->p_dev->priv;
863 	unsigned int ioaddr = dev->base_addr;
864 	unsigned long flags;
865 	unsigned short /* cable, */ media, partner;
866 
867 	if (!netif_device_present(dev))
868 		goto reschedule;
869 
870 	/* Check for pending interrupt with expired latency timer: with
871 	   this, we can limp along even if the interrupt is blocked */
872 	if ((inw(ioaddr + EL3_STATUS) & IntLatch) && (inb(ioaddr + Timer) == 0xff)) {
873 		if (!lp->fast_poll)
874 			netdev_info(dev, "interrupt(s) dropped!\n");
875 
876 		local_irq_save(flags);
877 		el3_interrupt(dev->irq, dev);
878 		local_irq_restore(flags);
879 
880 		lp->fast_poll = HZ;
881 	}
882 	if (lp->fast_poll) {
883 		lp->fast_poll--;
884 		lp->media.expires = jiffies + 2*HZ/100;
885 		add_timer(&lp->media);
886 		return;
887 	}
888 
889 	spin_lock_irqsave(&lp->window_lock, flags);
890 	EL3WINDOW(4);
891 	media = mdio_read(ioaddr, lp->phys, 1);
892 	partner = mdio_read(ioaddr, lp->phys, 5);
893 	EL3WINDOW(1);
894 
895 	if (media != lp->media_status) {
896 		if ((media ^ lp->media_status) & 0x0004)
897 			netdev_info(dev, "%s link beat\n",
898 				    (lp->media_status & 0x0004) ? "lost" : "found");
899 		if ((media ^ lp->media_status) & 0x0020) {
900 			lp->partner = 0;
901 			if (lp->media_status & 0x0020) {
902 				netdev_info(dev, "autonegotiation restarted\n");
903 			} else if (partner) {
904 				partner &= lp->advertising;
905 				lp->partner = partner;
906 				netdev_info(dev, "autonegotiation complete: "
907 					    "%dbaseT-%cD selected\n",
908 					    (partner & 0x0180) ? 100 : 10,
909 					    (partner & 0x0140) ? 'F' : 'H');
910 			} else {
911 				netdev_info(dev, "link partner did not autonegotiate\n");
912 			}
913 
914 			EL3WINDOW(3);
915 			outb((partner & 0x0140 ? 0x20 : 0) |
916 				 (dev->mtu > 1500 ? 0x40 : 0), ioaddr + Wn3_MAC_Ctrl);
917 			EL3WINDOW(1);
918 
919 		}
920 		if (media & 0x0010)
921 			netdev_info(dev, "remote fault detected\n");
922 		if (media & 0x0002)
923 			netdev_info(dev, "jabber detected\n");
924 		lp->media_status = media;
925 	}
926 	spin_unlock_irqrestore(&lp->window_lock, flags);
927 
928 reschedule:
929 	lp->media.expires = jiffies + HZ;
930 	add_timer(&lp->media);
931 }
932 
933 static struct net_device_stats *el3_get_stats(struct net_device *dev)
934 {
935 	struct el3_private *lp = netdev_priv(dev);
936 
937 	if (netif_device_present(dev)) {
938 		unsigned long flags;
939 		spin_lock_irqsave(&lp->window_lock, flags);
940 		update_stats(dev);
941 		spin_unlock_irqrestore(&lp->window_lock, flags);
942 	}
943 	return &dev->stats;
944 }
945 
946 /*  Update statistics.
947 	Surprisingly this need not be run single-threaded, but it effectively is.
948 	The counters clear when read, so the adds must merely be atomic.
949  */
950 static void update_stats(struct net_device *dev)
951 {
952 	unsigned int ioaddr = dev->base_addr;
953 	u8 up;
954 
955 	pr_debug("%s: updating the statistics.\n", dev->name);
956 
957 	if (inw(ioaddr+EL3_STATUS) == 0xffff) /* No card. */
958 		return;
959 
960 	/* Unlike the 3c509 we need not turn off stats updates while reading. */
961 	/* Switch to the stats window, and read everything. */
962 	EL3WINDOW(6);
963 	dev->stats.tx_carrier_errors 		+= inb(ioaddr + 0);
964 	dev->stats.tx_heartbeat_errors		+= inb(ioaddr + 1);
965 	/* Multiple collisions. */	   	inb(ioaddr + 2);
966 	dev->stats.collisions			+= inb(ioaddr + 3);
967 	dev->stats.tx_window_errors		+= inb(ioaddr + 4);
968 	dev->stats.rx_fifo_errors		+= inb(ioaddr + 5);
969 	dev->stats.tx_packets			+= inb(ioaddr + 6);
970 	up		 			 = inb(ioaddr + 9);
971 	dev->stats.tx_packets			+= (up&0x30) << 4;
972 	/* Rx packets   */			   inb(ioaddr + 7);
973 	/* Tx deferrals */			   inb(ioaddr + 8);
974 	/* rx */				   inw(ioaddr + 10);
975 	/* tx */				   inw(ioaddr + 12);
976 
977 	EL3WINDOW(4);
978 	/* BadSSD */				   inb(ioaddr + 12);
979 	up					 = inb(ioaddr + 13);
980 
981 	EL3WINDOW(1);
982 }
983 
984 static int el3_rx(struct net_device *dev, int worklimit)
985 {
986 	unsigned int ioaddr = dev->base_addr;
987 	short rx_status;
988 
989 	pr_debug("%s: in rx_packet(), status %4.4x, rx_status %4.4x.\n",
990 		  dev->name, inw(ioaddr+EL3_STATUS), inw(ioaddr+RxStatus));
991 	while (!((rx_status = inw(ioaddr + RxStatus)) & 0x8000) &&
992 			worklimit > 0) {
993 		worklimit--;
994 		if (rx_status & 0x4000) { /* Error, update stats. */
995 			short error = rx_status & 0x3800;
996 			dev->stats.rx_errors++;
997 			switch (error) {
998 			case 0x0000:	dev->stats.rx_over_errors++; break;
999 			case 0x0800:	dev->stats.rx_length_errors++; break;
1000 			case 0x1000:	dev->stats.rx_frame_errors++; break;
1001 			case 0x1800:	dev->stats.rx_length_errors++; break;
1002 			case 0x2000:	dev->stats.rx_frame_errors++; break;
1003 			case 0x2800:	dev->stats.rx_crc_errors++; break;
1004 			}
1005 		} else {
1006 			short pkt_len = rx_status & 0x7ff;
1007 			struct sk_buff *skb;
1008 
1009 			skb = netdev_alloc_skb(dev, pkt_len + 5);
1010 
1011 			pr_debug("  Receiving packet size %d status %4.4x.\n",
1012 				  pkt_len, rx_status);
1013 			if (skb != NULL) {
1014 				skb_reserve(skb, 2);
1015 				insl(ioaddr+RX_FIFO, skb_put(skb, pkt_len),
1016 						((pkt_len+3)>>2));
1017 				skb->protocol = eth_type_trans(skb, dev);
1018 				netif_rx(skb);
1019 				dev->stats.rx_packets++;
1020 				dev->stats.rx_bytes += pkt_len;
1021 			} else {
1022 				pr_debug("%s: couldn't allocate a sk_buff of"
1023 					  " size %d.\n", dev->name, pkt_len);
1024 				dev->stats.rx_dropped++;
1025 			}
1026 		}
1027 		tc574_wait_for_completion(dev, RxDiscard);
1028 	}
1029 
1030 	return worklimit;
1031 }
1032 
1033 /* Provide ioctl() calls to examine the MII xcvr state. */
1034 static int el3_ioctl(struct net_device *dev, struct ifreq *rq, int cmd)
1035 {
1036 	struct el3_private *lp = netdev_priv(dev);
1037 	unsigned int ioaddr = dev->base_addr;
1038 	struct mii_ioctl_data *data = if_mii(rq);
1039 	int phy = lp->phys & 0x1f;
1040 
1041 	pr_debug("%s: In ioct(%-.6s, %#4.4x) %4.4x %4.4x %4.4x %4.4x.\n",
1042 		  dev->name, rq->ifr_ifrn.ifrn_name, cmd,
1043 		  data->phy_id, data->reg_num, data->val_in, data->val_out);
1044 
1045 	switch(cmd) {
1046 	case SIOCGMIIPHY:		/* Get the address of the PHY in use. */
1047 		data->phy_id = phy;
1048 		fallthrough;
1049 	case SIOCGMIIREG:		/* Read the specified MII register. */
1050 		{
1051 			int saved_window;
1052 			unsigned long flags;
1053 
1054 			spin_lock_irqsave(&lp->window_lock, flags);
1055 			saved_window = inw(ioaddr + EL3_CMD) >> 13;
1056 			EL3WINDOW(4);
1057 			data->val_out = mdio_read(ioaddr, data->phy_id & 0x1f,
1058 						  data->reg_num & 0x1f);
1059 			EL3WINDOW(saved_window);
1060 			spin_unlock_irqrestore(&lp->window_lock, flags);
1061 			return 0;
1062 		}
1063 	case SIOCSMIIREG:		/* Write the specified MII register */
1064 		{
1065 			int saved_window;
1066                        unsigned long flags;
1067 
1068 			spin_lock_irqsave(&lp->window_lock, flags);
1069 			saved_window = inw(ioaddr + EL3_CMD) >> 13;
1070 			EL3WINDOW(4);
1071 			mdio_write(ioaddr, data->phy_id & 0x1f,
1072 				   data->reg_num & 0x1f, data->val_in);
1073 			EL3WINDOW(saved_window);
1074 			spin_unlock_irqrestore(&lp->window_lock, flags);
1075 			return 0;
1076 		}
1077 	default:
1078 		return -EOPNOTSUPP;
1079 	}
1080 }
1081 
1082 /* The Odie chip has a 64 bin multicast filter, but the bit layout is not
1083    documented.  Until it is we revert to receiving all multicast frames when
1084    any multicast reception is desired.
1085    Note: My other drivers emit a log message whenever promiscuous mode is
1086    entered to help detect password sniffers.  This is less desirable on
1087    typical PC card machines, so we omit the message.
1088    */
1089 
1090 static void set_rx_mode(struct net_device *dev)
1091 {
1092 	unsigned int ioaddr = dev->base_addr;
1093 
1094 	if (dev->flags & IFF_PROMISC)
1095 		outw(SetRxFilter | RxStation | RxMulticast | RxBroadcast | RxProm,
1096 			 ioaddr + EL3_CMD);
1097 	else if (!netdev_mc_empty(dev) || (dev->flags & IFF_ALLMULTI))
1098 		outw(SetRxFilter|RxStation|RxMulticast|RxBroadcast, ioaddr + EL3_CMD);
1099 	else
1100 		outw(SetRxFilter | RxStation | RxBroadcast, ioaddr + EL3_CMD);
1101 }
1102 
1103 static void set_multicast_list(struct net_device *dev)
1104 {
1105 	struct el3_private *lp = netdev_priv(dev);
1106 	unsigned long flags;
1107 
1108 	spin_lock_irqsave(&lp->window_lock, flags);
1109 	set_rx_mode(dev);
1110 	spin_unlock_irqrestore(&lp->window_lock, flags);
1111 }
1112 
1113 static int el3_close(struct net_device *dev)
1114 {
1115 	unsigned int ioaddr = dev->base_addr;
1116 	struct el3_private *lp = netdev_priv(dev);
1117 	struct pcmcia_device *link = lp->p_dev;
1118 
1119 	dev_dbg(&link->dev, "%s: shutting down ethercard.\n", dev->name);
1120 
1121 	if (pcmcia_dev_present(link)) {
1122 		unsigned long flags;
1123 
1124 		/* Turn off statistics ASAP.  We update lp->stats below. */
1125 		outw(StatsDisable, ioaddr + EL3_CMD);
1126 
1127 		/* Disable the receiver and transmitter. */
1128 		outw(RxDisable, ioaddr + EL3_CMD);
1129 		outw(TxDisable, ioaddr + EL3_CMD);
1130 
1131 		/* Note: Switching to window 0 may disable the IRQ. */
1132 		EL3WINDOW(0);
1133 		spin_lock_irqsave(&lp->window_lock, flags);
1134 		update_stats(dev);
1135 		spin_unlock_irqrestore(&lp->window_lock, flags);
1136 
1137 		/* force interrupts off */
1138 		outw(SetIntrEnb | 0x0000, ioaddr + EL3_CMD);
1139 	}
1140 
1141 	link->open--;
1142 	netif_stop_queue(dev);
1143 	del_timer_sync(&lp->media);
1144 
1145 	return 0;
1146 }
1147 
1148 static const struct pcmcia_device_id tc574_ids[] = {
1149 	PCMCIA_DEVICE_MANF_CARD(0x0101, 0x0574),
1150 	PCMCIA_MFC_DEVICE_CIS_MANF_CARD(0, 0x0101, 0x0556, "cis/3CCFEM556.cis"),
1151 	PCMCIA_DEVICE_NULL,
1152 };
1153 MODULE_DEVICE_TABLE(pcmcia, tc574_ids);
1154 
1155 static struct pcmcia_driver tc574_driver = {
1156 	.owner		= THIS_MODULE,
1157 	.name		= "3c574_cs",
1158 	.probe		= tc574_probe,
1159 	.remove		= tc574_detach,
1160 	.id_table       = tc574_ids,
1161 	.suspend	= tc574_suspend,
1162 	.resume		= tc574_resume,
1163 };
1164 module_pcmcia_driver(tc574_driver);
1165