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);
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_do_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 	unsigned int ioaddr;
309 	__be16 *phys_addr;
310 	char *cardname;
311 	__u32 config;
312 	u8 *buf;
313 	size_t len;
314 
315 	phys_addr = (__be16 *)dev->dev_addr;
316 
317 	dev_dbg(&link->dev, "3c574_config()\n");
318 
319 	link->io_lines = 16;
320 
321 	for (i = j = 0; j < 0x400; j += 0x20) {
322 		link->resource[0]->start = j ^ 0x300;
323 		i = pcmcia_request_io(link);
324 		if (i == 0)
325 			break;
326 	}
327 	if (i != 0)
328 		goto failed;
329 
330 	ret = pcmcia_request_irq(link, el3_interrupt);
331 	if (ret)
332 		goto failed;
333 
334 	ret = pcmcia_enable_device(link);
335 	if (ret)
336 		goto failed;
337 
338 	dev->irq = link->irq;
339 	dev->base_addr = link->resource[0]->start;
340 
341 	ioaddr = dev->base_addr;
342 
343 	/* The 3c574 normally uses an EEPROM for configuration info, including
344 	   the hardware address.  The future products may include a modem chip
345 	   and put the address in the CIS. */
346 
347 	len = pcmcia_get_tuple(link, 0x88, &buf);
348 	if (buf && len >= 6) {
349 		for (i = 0; i < 3; i++)
350 			phys_addr[i] = htons(le16_to_cpu(buf[i * 2]));
351 		kfree(buf);
352 	} else {
353 		kfree(buf); /* 0 < len < 6 */
354 		EL3WINDOW(0);
355 		for (i = 0; i < 3; i++)
356 			phys_addr[i] = htons(read_eeprom(ioaddr, i + 10));
357 		if (phys_addr[0] == htons(0x6060)) {
358 			pr_notice("IO port conflict at 0x%03lx-0x%03lx\n",
359 				  dev->base_addr, dev->base_addr+15);
360 			goto failed;
361 		}
362 	}
363 	if (link->prod_id[1])
364 		cardname = link->prod_id[1];
365 	else
366 		cardname = "3Com 3c574";
367 
368 	{
369 		u_char mcr;
370 		outw(2<<11, ioaddr + RunnerRdCtrl);
371 		mcr = inb(ioaddr + 2);
372 		outw(0<<11, ioaddr + RunnerRdCtrl);
373 		pr_info("  ASIC rev %d,", mcr>>3);
374 		EL3WINDOW(3);
375 		config = inl(ioaddr + Wn3_Config);
376 		lp->default_media = (config & Xcvr) >> Xcvr_shift;
377 		lp->autoselect = config & Autoselect ? 1 : 0;
378 	}
379 
380 	timer_setup(&lp->media, media_check, 0);
381 
382 	{
383 		int phy;
384 
385 		/* Roadrunner only: Turn on the MII transceiver */
386 		outw(0x8040, ioaddr + Wn3_Options);
387 		mdelay(1);
388 		outw(0xc040, ioaddr + Wn3_Options);
389 		tc574_wait_for_completion(dev, TxReset);
390 		tc574_wait_for_completion(dev, RxReset);
391 		mdelay(1);
392 		outw(0x8040, ioaddr + Wn3_Options);
393 
394 		EL3WINDOW(4);
395 		for (phy = 1; phy <= 32; phy++) {
396 			int mii_status;
397 			mdio_sync(ioaddr, 32);
398 			mii_status = mdio_read(ioaddr, phy & 0x1f, 1);
399 			if (mii_status != 0xffff) {
400 				lp->phys = phy & 0x1f;
401 				dev_dbg(&link->dev, "  MII transceiver at "
402 					"index %d, status %x.\n",
403 					  phy, mii_status);
404 				if ((mii_status & 0x0040) == 0)
405 					mii_preamble_required = 1;
406 				break;
407 			}
408 		}
409 		if (phy > 32) {
410 			pr_notice("  No MII transceivers found!\n");
411 			goto failed;
412 		}
413 		i = mdio_read(ioaddr, lp->phys, 16) | 0x40;
414 		mdio_write(ioaddr, lp->phys, 16, i);
415 		lp->advertising = mdio_read(ioaddr, lp->phys, 4);
416 		if (full_duplex) {
417 			/* Only advertise the FD media types. */
418 			lp->advertising &= ~0x02a0;
419 			mdio_write(ioaddr, lp->phys, 4, lp->advertising);
420 		}
421 	}
422 
423 	SET_NETDEV_DEV(dev, &link->dev);
424 
425 	if (register_netdev(dev) != 0) {
426 		pr_notice("register_netdev() failed\n");
427 		goto failed;
428 	}
429 
430 	netdev_info(dev, "%s at io %#3lx, irq %d, hw_addr %pM\n",
431 		    cardname, dev->base_addr, dev->irq, dev->dev_addr);
432 	netdev_info(dev, " %dK FIFO split %s Rx:Tx, %sMII interface.\n",
433 		    8 << (config & Ram_size),
434 		    ram_split[(config & Ram_split) >> Ram_split_shift],
435 		    config & Autoselect ? "autoselect " : "");
436 
437 	return 0;
438 
439 failed:
440 	tc574_release(link);
441 	return -ENODEV;
442 
443 } /* tc574_config */
444 
445 static void tc574_release(struct pcmcia_device *link)
446 {
447 	pcmcia_disable_device(link);
448 }
449 
450 static int tc574_suspend(struct pcmcia_device *link)
451 {
452 	struct net_device *dev = link->priv;
453 
454 	if (link->open)
455 		netif_device_detach(dev);
456 
457 	return 0;
458 }
459 
460 static int tc574_resume(struct pcmcia_device *link)
461 {
462 	struct net_device *dev = link->priv;
463 
464 	if (link->open) {
465 		tc574_reset(dev);
466 		netif_device_attach(dev);
467 	}
468 
469 	return 0;
470 }
471 
472 static void dump_status(struct net_device *dev)
473 {
474 	unsigned int ioaddr = dev->base_addr;
475 	EL3WINDOW(1);
476 	netdev_info(dev, "  irq status %04x, rx status %04x, tx status %02x, tx free %04x\n",
477 		    inw(ioaddr+EL3_STATUS),
478 		    inw(ioaddr+RxStatus), inb(ioaddr+TxStatus),
479 		    inw(ioaddr+TxFree));
480 	EL3WINDOW(4);
481 	netdev_info(dev, "  diagnostics: fifo %04x net %04x ethernet %04x media %04x\n",
482 		    inw(ioaddr+0x04), inw(ioaddr+0x06),
483 		    inw(ioaddr+0x08), inw(ioaddr+0x0a));
484 	EL3WINDOW(1);
485 }
486 
487 /*
488   Use this for commands that may take time to finish
489 */
490 static void tc574_wait_for_completion(struct net_device *dev, int cmd)
491 {
492 	int i = 1500;
493 	outw(cmd, dev->base_addr + EL3_CMD);
494 	while (--i > 0)
495 		if (!(inw(dev->base_addr + EL3_STATUS) & 0x1000)) break;
496 	if (i == 0)
497 		netdev_notice(dev, "command 0x%04x did not complete!\n", cmd);
498 }
499 
500 /* Read a word from the EEPROM using the regular EEPROM access register.
501    Assume that we are in register window zero.
502  */
503 static unsigned short read_eeprom(unsigned int ioaddr, int index)
504 {
505 	int timer;
506 	outw(EEPROM_Read + index, ioaddr + Wn0EepromCmd);
507 	/* Pause for at least 162 usec for the read to take place. */
508 	for (timer = 1620; timer >= 0; timer--) {
509 		if ((inw(ioaddr + Wn0EepromCmd) & 0x8000) == 0)
510 			break;
511 	}
512 	return inw(ioaddr + Wn0EepromData);
513 }
514 
515 /* MII transceiver control section.
516    Read and write the MII registers using software-generated serial
517    MDIO protocol.  See the MII specifications or DP83840A data sheet
518    for details.
519    The maxium data clock rate is 2.5 Mhz.  The timing is easily met by the
520    slow PC card interface. */
521 
522 #define MDIO_SHIFT_CLK	0x01
523 #define MDIO_DIR_WRITE	0x04
524 #define MDIO_DATA_WRITE0 (0x00 | MDIO_DIR_WRITE)
525 #define MDIO_DATA_WRITE1 (0x02 | MDIO_DIR_WRITE)
526 #define MDIO_DATA_READ	0x02
527 #define MDIO_ENB_IN		0x00
528 
529 /* Generate the preamble required for initial synchronization and
530    a few older transceivers. */
531 static void mdio_sync(unsigned int ioaddr, int bits)
532 {
533 	unsigned int mdio_addr = ioaddr + Wn4_PhysicalMgmt;
534 
535 	/* Establish sync by sending at least 32 logic ones. */
536 	while (-- bits >= 0) {
537 		outw(MDIO_DATA_WRITE1, mdio_addr);
538 		outw(MDIO_DATA_WRITE1 | MDIO_SHIFT_CLK, mdio_addr);
539 	}
540 }
541 
542 static int mdio_read(unsigned int ioaddr, int phy_id, int location)
543 {
544 	int i;
545 	int read_cmd = (0xf6 << 10) | (phy_id << 5) | location;
546 	unsigned int retval = 0;
547 	unsigned int mdio_addr = ioaddr + Wn4_PhysicalMgmt;
548 
549 	if (mii_preamble_required)
550 		mdio_sync(ioaddr, 32);
551 
552 	/* Shift the read command bits out. */
553 	for (i = 14; i >= 0; i--) {
554 		int dataval = (read_cmd&(1<<i)) ? MDIO_DATA_WRITE1 : MDIO_DATA_WRITE0;
555 		outw(dataval, mdio_addr);
556 		outw(dataval | MDIO_SHIFT_CLK, mdio_addr);
557 	}
558 	/* Read the two transition, 16 data, and wire-idle bits. */
559 	for (i = 19; i > 0; i--) {
560 		outw(MDIO_ENB_IN, mdio_addr);
561 		retval = (retval << 1) | ((inw(mdio_addr) & MDIO_DATA_READ) ? 1 : 0);
562 		outw(MDIO_ENB_IN | MDIO_SHIFT_CLK, mdio_addr);
563 	}
564 	return (retval>>1) & 0xffff;
565 }
566 
567 static void mdio_write(unsigned int ioaddr, int phy_id, int location, int value)
568 {
569 	int write_cmd = 0x50020000 | (phy_id << 23) | (location << 18) | value;
570 	unsigned int mdio_addr = ioaddr + Wn4_PhysicalMgmt;
571 	int i;
572 
573 	if (mii_preamble_required)
574 		mdio_sync(ioaddr, 32);
575 
576 	/* Shift the command bits out. */
577 	for (i = 31; i >= 0; i--) {
578 		int dataval = (write_cmd&(1<<i)) ? MDIO_DATA_WRITE1 : MDIO_DATA_WRITE0;
579 		outw(dataval, mdio_addr);
580 		outw(dataval | MDIO_SHIFT_CLK, mdio_addr);
581 	}
582 	/* Leave the interface idle. */
583 	for (i = 1; i >= 0; i--) {
584 		outw(MDIO_ENB_IN, mdio_addr);
585 		outw(MDIO_ENB_IN | MDIO_SHIFT_CLK, mdio_addr);
586 	}
587 }
588 
589 /* Reset and restore all of the 3c574 registers. */
590 static void tc574_reset(struct net_device *dev)
591 {
592 	struct el3_private *lp = netdev_priv(dev);
593 	int i;
594 	unsigned int ioaddr = dev->base_addr;
595 	unsigned long flags;
596 
597 	tc574_wait_for_completion(dev, TotalReset|0x10);
598 
599 	spin_lock_irqsave(&lp->window_lock, flags);
600 	/* Clear any transactions in progress. */
601 	outw(0, ioaddr + RunnerWrCtrl);
602 	outw(0, ioaddr + RunnerRdCtrl);
603 
604 	/* Set the station address and mask. */
605 	EL3WINDOW(2);
606 	for (i = 0; i < 6; i++)
607 		outb(dev->dev_addr[i], ioaddr + i);
608 	for (; i < 12; i+=2)
609 		outw(0, ioaddr + i);
610 
611 	/* Reset config options */
612 	EL3WINDOW(3);
613 	outb((dev->mtu > 1500 ? 0x40 : 0), ioaddr + Wn3_MAC_Ctrl);
614 	outl((lp->autoselect ? 0x01000000 : 0) | 0x0062001b,
615 		 ioaddr + Wn3_Config);
616 	/* Roadrunner only: Turn on the MII transceiver. */
617 	outw(0x8040, ioaddr + Wn3_Options);
618 	mdelay(1);
619 	outw(0xc040, ioaddr + Wn3_Options);
620 	EL3WINDOW(1);
621 	spin_unlock_irqrestore(&lp->window_lock, flags);
622 
623 	tc574_wait_for_completion(dev, TxReset);
624 	tc574_wait_for_completion(dev, RxReset);
625 	mdelay(1);
626 	spin_lock_irqsave(&lp->window_lock, flags);
627 	EL3WINDOW(3);
628 	outw(0x8040, ioaddr + Wn3_Options);
629 
630 	/* Switch to the stats window, and clear all stats by reading. */
631 	outw(StatsDisable, ioaddr + EL3_CMD);
632 	EL3WINDOW(6);
633 	for (i = 0; i < 10; i++)
634 		inb(ioaddr + i);
635 	inw(ioaddr + 10);
636 	inw(ioaddr + 12);
637 	EL3WINDOW(4);
638 	inb(ioaddr + 12);
639 	inb(ioaddr + 13);
640 
641 	/* .. enable any extra statistics bits.. */
642 	outw(0x0040, ioaddr + Wn4_NetDiag);
643 
644 	EL3WINDOW(1);
645 	spin_unlock_irqrestore(&lp->window_lock, flags);
646 
647 	/* .. re-sync MII and re-fill what NWay is advertising. */
648 	mdio_sync(ioaddr, 32);
649 	mdio_write(ioaddr, lp->phys, 4, lp->advertising);
650 	if (!auto_polarity) {
651 		/* works for TDK 78Q2120 series MII's */
652 		i = mdio_read(ioaddr, lp->phys, 16) | 0x20;
653 		mdio_write(ioaddr, lp->phys, 16, i);
654 	}
655 
656 	spin_lock_irqsave(&lp->window_lock, flags);
657 	/* Switch to register set 1 for normal use, just for TxFree. */
658 	set_rx_mode(dev);
659 	spin_unlock_irqrestore(&lp->window_lock, flags);
660 	outw(StatsEnable, ioaddr + EL3_CMD); /* Turn on statistics. */
661 	outw(RxEnable, ioaddr + EL3_CMD); /* Enable the receiver. */
662 	outw(TxEnable, ioaddr + EL3_CMD); /* Enable transmitter. */
663 	/* Allow status bits to be seen. */
664 	outw(SetStatusEnb | 0xff, ioaddr + EL3_CMD);
665 	/* Ack all pending events, and set active indicator mask. */
666 	outw(AckIntr | IntLatch | TxAvailable | RxEarly | IntReq,
667 		 ioaddr + EL3_CMD);
668 	outw(SetIntrEnb | IntLatch | TxAvailable | RxComplete | StatsFull
669 		 | AdapterFailure | RxEarly, ioaddr + EL3_CMD);
670 }
671 
672 static int el3_open(struct net_device *dev)
673 {
674 	struct el3_private *lp = netdev_priv(dev);
675 	struct pcmcia_device *link = lp->p_dev;
676 
677 	if (!pcmcia_dev_present(link))
678 		return -ENODEV;
679 
680 	link->open++;
681 	netif_start_queue(dev);
682 
683 	tc574_reset(dev);
684 	lp->media.expires = jiffies + HZ;
685 	add_timer(&lp->media);
686 
687 	dev_dbg(&link->dev, "%s: opened, status %4.4x.\n",
688 		  dev->name, inw(dev->base_addr + EL3_STATUS));
689 
690 	return 0;
691 }
692 
693 static void el3_tx_timeout(struct net_device *dev)
694 {
695 	unsigned int ioaddr = dev->base_addr;
696 
697 	netdev_notice(dev, "Transmit timed out!\n");
698 	dump_status(dev);
699 	dev->stats.tx_errors++;
700 	netif_trans_update(dev); /* prevent tx timeout */
701 	/* Issue TX_RESET and TX_START commands. */
702 	tc574_wait_for_completion(dev, TxReset);
703 	outw(TxEnable, ioaddr + EL3_CMD);
704 	netif_wake_queue(dev);
705 }
706 
707 static void pop_tx_status(struct net_device *dev)
708 {
709 	unsigned int ioaddr = dev->base_addr;
710 	int i;
711 
712 	/* Clear the Tx status stack. */
713 	for (i = 32; i > 0; i--) {
714 		u_char tx_status = inb(ioaddr + TxStatus);
715 		if (!(tx_status & 0x84))
716 			break;
717 		/* reset transmitter on jabber error or underrun */
718 		if (tx_status & 0x30)
719 			tc574_wait_for_completion(dev, TxReset);
720 		if (tx_status & 0x38) {
721 			pr_debug("%s: transmit error: status 0x%02x\n",
722 				  dev->name, tx_status);
723 			outw(TxEnable, ioaddr + EL3_CMD);
724 			dev->stats.tx_aborted_errors++;
725 		}
726 		outb(0x00, ioaddr + TxStatus); /* Pop the status stack. */
727 	}
728 }
729 
730 static netdev_tx_t el3_start_xmit(struct sk_buff *skb,
731 					struct net_device *dev)
732 {
733 	unsigned int ioaddr = dev->base_addr;
734 	struct el3_private *lp = netdev_priv(dev);
735 	unsigned long flags;
736 
737 	pr_debug("%s: el3_start_xmit(length = %ld) called, "
738 		  "status %4.4x.\n", dev->name, (long)skb->len,
739 		  inw(ioaddr + EL3_STATUS));
740 
741 	spin_lock_irqsave(&lp->window_lock, flags);
742 
743 	dev->stats.tx_bytes += skb->len;
744 
745 	/* Put out the doubleword header... */
746 	outw(skb->len, ioaddr + TX_FIFO);
747 	outw(0, ioaddr + TX_FIFO);
748 	/* ... and the packet rounded to a doubleword. */
749 	outsl(ioaddr + TX_FIFO, skb->data, (skb->len+3)>>2);
750 
751 	/* TxFree appears only in Window 1, not offset 0x1c. */
752 	if (inw(ioaddr + TxFree) <= 1536) {
753 		netif_stop_queue(dev);
754 		/* Interrupt us when the FIFO has room for max-sized packet.
755 		   The threshold is in units of dwords. */
756 		outw(SetTxThreshold + (1536>>2), ioaddr + EL3_CMD);
757 	}
758 
759 	pop_tx_status(dev);
760 	spin_unlock_irqrestore(&lp->window_lock, flags);
761 	dev_kfree_skb(skb);
762 	return NETDEV_TX_OK;
763 }
764 
765 /* The EL3 interrupt handler. */
766 static irqreturn_t el3_interrupt(int irq, void *dev_id)
767 {
768 	struct net_device *dev = (struct net_device *) dev_id;
769 	struct el3_private *lp = netdev_priv(dev);
770 	unsigned int ioaddr;
771 	unsigned status;
772 	int work_budget = max_interrupt_work;
773 	int handled = 0;
774 
775 	if (!netif_device_present(dev))
776 		return IRQ_NONE;
777 	ioaddr = dev->base_addr;
778 
779 	pr_debug("%s: interrupt, status %4.4x.\n",
780 		  dev->name, inw(ioaddr + EL3_STATUS));
781 
782 	spin_lock(&lp->window_lock);
783 
784 	while ((status = inw(ioaddr + EL3_STATUS)) &
785 		   (IntLatch | RxComplete | RxEarly | StatsFull)) {
786 		if (!netif_device_present(dev) ||
787 			((status & 0xe000) != 0x2000)) {
788 			pr_debug("%s: Interrupt from dead card\n", dev->name);
789 			break;
790 		}
791 
792 		handled = 1;
793 
794 		if (status & RxComplete)
795 			work_budget = el3_rx(dev, work_budget);
796 
797 		if (status & TxAvailable) {
798 			pr_debug("  TX room bit was handled.\n");
799 			/* There's room in the FIFO for a full-sized packet. */
800 			outw(AckIntr | TxAvailable, ioaddr + EL3_CMD);
801 			netif_wake_queue(dev);
802 		}
803 
804 		if (status & TxComplete)
805 			pop_tx_status(dev);
806 
807 		if (status & (AdapterFailure | RxEarly | StatsFull)) {
808 			/* Handle all uncommon interrupts. */
809 			if (status & StatsFull)
810 				update_stats(dev);
811 			if (status & RxEarly) {
812 				work_budget = el3_rx(dev, work_budget);
813 				outw(AckIntr | RxEarly, ioaddr + EL3_CMD);
814 			}
815 			if (status & AdapterFailure) {
816 				u16 fifo_diag;
817 				EL3WINDOW(4);
818 				fifo_diag = inw(ioaddr + Wn4_FIFODiag);
819 				EL3WINDOW(1);
820 				netdev_notice(dev, "adapter failure, FIFO diagnostic register %04x\n",
821 					      fifo_diag);
822 				if (fifo_diag & 0x0400) {
823 					/* Tx overrun */
824 					tc574_wait_for_completion(dev, TxReset);
825 					outw(TxEnable, ioaddr + EL3_CMD);
826 				}
827 				if (fifo_diag & 0x2000) {
828 					/* Rx underrun */
829 					tc574_wait_for_completion(dev, RxReset);
830 					set_rx_mode(dev);
831 					outw(RxEnable, ioaddr + EL3_CMD);
832 				}
833 				outw(AckIntr | AdapterFailure, ioaddr + EL3_CMD);
834 			}
835 		}
836 
837 		if (--work_budget < 0) {
838 			pr_debug("%s: Too much work in interrupt, "
839 				  "status %4.4x.\n", dev->name, status);
840 			/* Clear all interrupts */
841 			outw(AckIntr | 0xFF, ioaddr + EL3_CMD);
842 			break;
843 		}
844 		/* Acknowledge the IRQ. */
845 		outw(AckIntr | IntReq | IntLatch, ioaddr + EL3_CMD);
846 	}
847 
848 	pr_debug("%s: exiting interrupt, status %4.4x.\n",
849 		  dev->name, inw(ioaddr + EL3_STATUS));
850 
851 	spin_unlock(&lp->window_lock);
852 	return IRQ_RETVAL(handled);
853 }
854 
855 /*
856     This timer serves two purposes: to check for missed interrupts
857 	(and as a last resort, poll the NIC for events), and to monitor
858 	the MII, reporting changes in cable status.
859 */
860 static void media_check(struct timer_list *t)
861 {
862 	struct el3_private *lp = from_timer(lp, t, media);
863 	struct net_device *dev = lp->p_dev->priv;
864 	unsigned int ioaddr = dev->base_addr;
865 	unsigned long flags;
866 	unsigned short /* cable, */ media, partner;
867 
868 	if (!netif_device_present(dev))
869 		goto reschedule;
870 
871 	/* Check for pending interrupt with expired latency timer: with
872 	   this, we can limp along even if the interrupt is blocked */
873 	if ((inw(ioaddr + EL3_STATUS) & IntLatch) && (inb(ioaddr + Timer) == 0xff)) {
874 		if (!lp->fast_poll)
875 			netdev_info(dev, "interrupt(s) dropped!\n");
876 
877 		local_irq_save(flags);
878 		el3_interrupt(dev->irq, dev);
879 		local_irq_restore(flags);
880 
881 		lp->fast_poll = HZ;
882 	}
883 	if (lp->fast_poll) {
884 		lp->fast_poll--;
885 		lp->media.expires = jiffies + 2*HZ/100;
886 		add_timer(&lp->media);
887 		return;
888 	}
889 
890 	spin_lock_irqsave(&lp->window_lock, flags);
891 	EL3WINDOW(4);
892 	media = mdio_read(ioaddr, lp->phys, 1);
893 	partner = mdio_read(ioaddr, lp->phys, 5);
894 	EL3WINDOW(1);
895 
896 	if (media != lp->media_status) {
897 		if ((media ^ lp->media_status) & 0x0004)
898 			netdev_info(dev, "%s link beat\n",
899 				    (lp->media_status & 0x0004) ? "lost" : "found");
900 		if ((media ^ lp->media_status) & 0x0020) {
901 			lp->partner = 0;
902 			if (lp->media_status & 0x0020) {
903 				netdev_info(dev, "autonegotiation restarted\n");
904 			} else if (partner) {
905 				partner &= lp->advertising;
906 				lp->partner = partner;
907 				netdev_info(dev, "autonegotiation complete: "
908 					    "%dbaseT-%cD selected\n",
909 					    (partner & 0x0180) ? 100 : 10,
910 					    (partner & 0x0140) ? 'F' : 'H');
911 			} else {
912 				netdev_info(dev, "link partner did not autonegotiate\n");
913 			}
914 
915 			EL3WINDOW(3);
916 			outb((partner & 0x0140 ? 0x20 : 0) |
917 				 (dev->mtu > 1500 ? 0x40 : 0), ioaddr + Wn3_MAC_Ctrl);
918 			EL3WINDOW(1);
919 
920 		}
921 		if (media & 0x0010)
922 			netdev_info(dev, "remote fault detected\n");
923 		if (media & 0x0002)
924 			netdev_info(dev, "jabber detected\n");
925 		lp->media_status = media;
926 	}
927 	spin_unlock_irqrestore(&lp->window_lock, flags);
928 
929 reschedule:
930 	lp->media.expires = jiffies + HZ;
931 	add_timer(&lp->media);
932 }
933 
934 static struct net_device_stats *el3_get_stats(struct net_device *dev)
935 {
936 	struct el3_private *lp = netdev_priv(dev);
937 
938 	if (netif_device_present(dev)) {
939 		unsigned long flags;
940 		spin_lock_irqsave(&lp->window_lock, flags);
941 		update_stats(dev);
942 		spin_unlock_irqrestore(&lp->window_lock, flags);
943 	}
944 	return &dev->stats;
945 }
946 
947 /*  Update statistics.
948 	Surprisingly this need not be run single-threaded, but it effectively is.
949 	The counters clear when read, so the adds must merely be atomic.
950  */
951 static void update_stats(struct net_device *dev)
952 {
953 	unsigned int ioaddr = dev->base_addr;
954 	u8 rx, tx, up;
955 
956 	pr_debug("%s: updating the statistics.\n", dev->name);
957 
958 	if (inw(ioaddr+EL3_STATUS) == 0xffff) /* No card. */
959 		return;
960 
961 	/* Unlike the 3c509 we need not turn off stats updates while reading. */
962 	/* Switch to the stats window, and read everything. */
963 	EL3WINDOW(6);
964 	dev->stats.tx_carrier_errors 		+= inb(ioaddr + 0);
965 	dev->stats.tx_heartbeat_errors		+= inb(ioaddr + 1);
966 	/* Multiple collisions. */	   	inb(ioaddr + 2);
967 	dev->stats.collisions			+= inb(ioaddr + 3);
968 	dev->stats.tx_window_errors		+= inb(ioaddr + 4);
969 	dev->stats.rx_fifo_errors		+= inb(ioaddr + 5);
970 	dev->stats.tx_packets			+= inb(ioaddr + 6);
971 	up		 			 = inb(ioaddr + 9);
972 	dev->stats.tx_packets			+= (up&0x30) << 4;
973 	/* Rx packets   */			   inb(ioaddr + 7);
974 	/* Tx deferrals */			   inb(ioaddr + 8);
975 	rx		 			 = inw(ioaddr + 10);
976 	tx					 = inw(ioaddr + 12);
977 
978 	EL3WINDOW(4);
979 	/* BadSSD */				   inb(ioaddr + 12);
980 	up					 = inb(ioaddr + 13);
981 
982 	EL3WINDOW(1);
983 }
984 
985 static int el3_rx(struct net_device *dev, int worklimit)
986 {
987 	unsigned int ioaddr = dev->base_addr;
988 	short rx_status;
989 
990 	pr_debug("%s: in rx_packet(), status %4.4x, rx_status %4.4x.\n",
991 		  dev->name, inw(ioaddr+EL3_STATUS), inw(ioaddr+RxStatus));
992 	while (!((rx_status = inw(ioaddr + RxStatus)) & 0x8000) &&
993 			worklimit > 0) {
994 		worklimit--;
995 		if (rx_status & 0x4000) { /* Error, update stats. */
996 			short error = rx_status & 0x3800;
997 			dev->stats.rx_errors++;
998 			switch (error) {
999 			case 0x0000:	dev->stats.rx_over_errors++; break;
1000 			case 0x0800:	dev->stats.rx_length_errors++; break;
1001 			case 0x1000:	dev->stats.rx_frame_errors++; break;
1002 			case 0x1800:	dev->stats.rx_length_errors++; break;
1003 			case 0x2000:	dev->stats.rx_frame_errors++; break;
1004 			case 0x2800:	dev->stats.rx_crc_errors++; break;
1005 			}
1006 		} else {
1007 			short pkt_len = rx_status & 0x7ff;
1008 			struct sk_buff *skb;
1009 
1010 			skb = netdev_alloc_skb(dev, pkt_len + 5);
1011 
1012 			pr_debug("  Receiving packet size %d status %4.4x.\n",
1013 				  pkt_len, rx_status);
1014 			if (skb != NULL) {
1015 				skb_reserve(skb, 2);
1016 				insl(ioaddr+RX_FIFO, skb_put(skb, pkt_len),
1017 						((pkt_len+3)>>2));
1018 				skb->protocol = eth_type_trans(skb, dev);
1019 				netif_rx(skb);
1020 				dev->stats.rx_packets++;
1021 				dev->stats.rx_bytes += pkt_len;
1022 			} else {
1023 				pr_debug("%s: couldn't allocate a sk_buff of"
1024 					  " size %d.\n", dev->name, pkt_len);
1025 				dev->stats.rx_dropped++;
1026 			}
1027 		}
1028 		tc574_wait_for_completion(dev, RxDiscard);
1029 	}
1030 
1031 	return worklimit;
1032 }
1033 
1034 /* Provide ioctl() calls to examine the MII xcvr state. */
1035 static int el3_ioctl(struct net_device *dev, struct ifreq *rq, int cmd)
1036 {
1037 	struct el3_private *lp = netdev_priv(dev);
1038 	unsigned int ioaddr = dev->base_addr;
1039 	struct mii_ioctl_data *data = if_mii(rq);
1040 	int phy = lp->phys & 0x1f;
1041 
1042 	pr_debug("%s: In ioct(%-.6s, %#4.4x) %4.4x %4.4x %4.4x %4.4x.\n",
1043 		  dev->name, rq->ifr_ifrn.ifrn_name, cmd,
1044 		  data->phy_id, data->reg_num, data->val_in, data->val_out);
1045 
1046 	switch(cmd) {
1047 	case SIOCGMIIPHY:		/* Get the address of the PHY in use. */
1048 		data->phy_id = phy;
1049 		/* fall through */
1050 	case SIOCGMIIREG:		/* Read the specified MII register. */
1051 		{
1052 			int saved_window;
1053 			unsigned long flags;
1054 
1055 			spin_lock_irqsave(&lp->window_lock, flags);
1056 			saved_window = inw(ioaddr + EL3_CMD) >> 13;
1057 			EL3WINDOW(4);
1058 			data->val_out = mdio_read(ioaddr, data->phy_id & 0x1f,
1059 						  data->reg_num & 0x1f);
1060 			EL3WINDOW(saved_window);
1061 			spin_unlock_irqrestore(&lp->window_lock, flags);
1062 			return 0;
1063 		}
1064 	case SIOCSMIIREG:		/* Write the specified MII register */
1065 		{
1066 			int saved_window;
1067                        unsigned long flags;
1068 
1069 			spin_lock_irqsave(&lp->window_lock, flags);
1070 			saved_window = inw(ioaddr + EL3_CMD) >> 13;
1071 			EL3WINDOW(4);
1072 			mdio_write(ioaddr, data->phy_id & 0x1f,
1073 				   data->reg_num & 0x1f, data->val_in);
1074 			EL3WINDOW(saved_window);
1075 			spin_unlock_irqrestore(&lp->window_lock, flags);
1076 			return 0;
1077 		}
1078 	default:
1079 		return -EOPNOTSUPP;
1080 	}
1081 }
1082 
1083 /* The Odie chip has a 64 bin multicast filter, but the bit layout is not
1084    documented.  Until it is we revert to receiving all multicast frames when
1085    any multicast reception is desired.
1086    Note: My other drivers emit a log message whenever promiscuous mode is
1087    entered to help detect password sniffers.  This is less desirable on
1088    typical PC card machines, so we omit the message.
1089    */
1090 
1091 static void set_rx_mode(struct net_device *dev)
1092 {
1093 	unsigned int ioaddr = dev->base_addr;
1094 
1095 	if (dev->flags & IFF_PROMISC)
1096 		outw(SetRxFilter | RxStation | RxMulticast | RxBroadcast | RxProm,
1097 			 ioaddr + EL3_CMD);
1098 	else if (!netdev_mc_empty(dev) || (dev->flags & IFF_ALLMULTI))
1099 		outw(SetRxFilter|RxStation|RxMulticast|RxBroadcast, ioaddr + EL3_CMD);
1100 	else
1101 		outw(SetRxFilter | RxStation | RxBroadcast, ioaddr + EL3_CMD);
1102 }
1103 
1104 static void set_multicast_list(struct net_device *dev)
1105 {
1106 	struct el3_private *lp = netdev_priv(dev);
1107 	unsigned long flags;
1108 
1109 	spin_lock_irqsave(&lp->window_lock, flags);
1110 	set_rx_mode(dev);
1111 	spin_unlock_irqrestore(&lp->window_lock, flags);
1112 }
1113 
1114 static int el3_close(struct net_device *dev)
1115 {
1116 	unsigned int ioaddr = dev->base_addr;
1117 	struct el3_private *lp = netdev_priv(dev);
1118 	struct pcmcia_device *link = lp->p_dev;
1119 
1120 	dev_dbg(&link->dev, "%s: shutting down ethercard.\n", dev->name);
1121 
1122 	if (pcmcia_dev_present(link)) {
1123 		unsigned long flags;
1124 
1125 		/* Turn off statistics ASAP.  We update lp->stats below. */
1126 		outw(StatsDisable, ioaddr + EL3_CMD);
1127 
1128 		/* Disable the receiver and transmitter. */
1129 		outw(RxDisable, ioaddr + EL3_CMD);
1130 		outw(TxDisable, ioaddr + EL3_CMD);
1131 
1132 		/* Note: Switching to window 0 may disable the IRQ. */
1133 		EL3WINDOW(0);
1134 		spin_lock_irqsave(&lp->window_lock, flags);
1135 		update_stats(dev);
1136 		spin_unlock_irqrestore(&lp->window_lock, flags);
1137 
1138 		/* force interrupts off */
1139 		outw(SetIntrEnb | 0x0000, ioaddr + EL3_CMD);
1140 	}
1141 
1142 	link->open--;
1143 	netif_stop_queue(dev);
1144 	del_timer_sync(&lp->media);
1145 
1146 	return 0;
1147 }
1148 
1149 static const struct pcmcia_device_id tc574_ids[] = {
1150 	PCMCIA_DEVICE_MANF_CARD(0x0101, 0x0574),
1151 	PCMCIA_MFC_DEVICE_CIS_MANF_CARD(0, 0x0101, 0x0556, "cis/3CCFEM556.cis"),
1152 	PCMCIA_DEVICE_NULL,
1153 };
1154 MODULE_DEVICE_TABLE(pcmcia, tc574_ids);
1155 
1156 static struct pcmcia_driver tc574_driver = {
1157 	.owner		= THIS_MODULE,
1158 	.name		= "3c574_cs",
1159 	.probe		= tc574_probe,
1160 	.remove		= tc574_detach,
1161 	.id_table       = tc574_ids,
1162 	.suspend	= tc574_suspend,
1163 	.resume		= tc574_resume,
1164 };
1165 module_pcmcia_driver(tc574_driver);
1166