1 /* ======================================================================
2  *
3  * A PCMCIA ethernet driver for the 3com 3c589 card.
4  *
5  * Copyright (C) 1999 David A. Hinds -- dahinds@users.sourceforge.net
6  *
7  * 3c589_cs.c 1.162 2001/10/13 00:08:50
8  *
9  * The network driver code is based on Donald Becker's 3c589 code:
10  *
11  * Written 1994 by Donald Becker.
12  * Copyright 1993 United States Government as represented by the
13  * Director, National Security Agency.  This software may be used and
14  * distributed according to the terms of the GNU General Public License,
15  * incorporated herein by reference.
16  * Donald Becker may be reached at becker@scyld.com
17  *
18  * Updated for 2.5.x by Alan Cox <alan@lxorguk.ukuu.org.uk>
19  *
20  * ======================================================================
21  */
22 
23 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
24 
25 #define DRV_NAME	"3c589_cs"
26 #define DRV_VERSION	"1.162-ac"
27 
28 #include <linux/module.h>
29 #include <linux/kernel.h>
30 #include <linux/ptrace.h>
31 #include <linux/slab.h>
32 #include <linux/string.h>
33 #include <linux/timer.h>
34 #include <linux/interrupt.h>
35 #include <linux/in.h>
36 #include <linux/delay.h>
37 #include <linux/ethtool.h>
38 #include <linux/netdevice.h>
39 #include <linux/etherdevice.h>
40 #include <linux/skbuff.h>
41 #include <linux/if_arp.h>
42 #include <linux/ioport.h>
43 #include <linux/bitops.h>
44 #include <linux/jiffies.h>
45 #include <linux/uaccess.h>
46 #include <linux/io.h>
47 
48 #include <pcmcia/cistpl.h>
49 #include <pcmcia/cisreg.h>
50 #include <pcmcia/ciscode.h>
51 #include <pcmcia/ds.h>
52 
53 
54 /* To minimize the size of the driver source I only define operating
55  * constants if they are used several times. You'll need the manual
56  * if you want to understand driver details.
57  */
58 
59 /* Offsets from base I/O address. */
60 #define EL3_DATA	0x00
61 #define EL3_TIMER	0x0a
62 #define EL3_CMD		0x0e
63 #define EL3_STATUS	0x0e
64 
65 #define EEPROM_READ	0x0080
66 #define EEPROM_BUSY	0x8000
67 
68 #define EL3WINDOW(win_num) outw(SelectWindow + (win_num), ioaddr + EL3_CMD)
69 
70 /* The top five bits written to EL3_CMD are a command, the lower
71  * 11 bits are the parameter, if applicable.
72  */
73 
74 enum c509cmd {
75 	TotalReset	= 0<<11,
76 	SelectWindow	= 1<<11,
77 	StartCoax	= 2<<11,
78 	RxDisable	= 3<<11,
79 	RxEnable	= 4<<11,
80 	RxReset		= 5<<11,
81 	RxDiscard	= 8<<11,
82 	TxEnable	= 9<<11,
83 	TxDisable	= 10<<11,
84 	TxReset		= 11<<11,
85 	FakeIntr	= 12<<11,
86 	AckIntr		= 13<<11,
87 	SetIntrEnb	= 14<<11,
88 	SetStatusEnb	= 15<<11,
89 	SetRxFilter	= 16<<11,
90 	SetRxThreshold	= 17<<11,
91 	SetTxThreshold	= 18<<11,
92 	SetTxStart	= 19<<11,
93 	StatsEnable	= 21<<11,
94 	StatsDisable	= 22<<11,
95 	StopCoax	= 23<<11
96 };
97 
98 enum c509status {
99 	IntLatch	= 0x0001,
100 	AdapterFailure	= 0x0002,
101 	TxComplete	= 0x0004,
102 	TxAvailable	= 0x0008,
103 	RxComplete	= 0x0010,
104 	RxEarly		= 0x0020,
105 	IntReq		= 0x0040,
106 	StatsFull	= 0x0080,
107 	CmdBusy		= 0x1000
108 };
109 
110 /* The SetRxFilter command accepts the following classes: */
111 enum RxFilter {
112 	RxStation	= 1,
113 	RxMulticast	= 2,
114 	RxBroadcast	= 4,
115 	RxProm		= 8
116 };
117 
118 /* Register window 1 offsets, the window used in normal operation. */
119 #define TX_FIFO		0x00
120 #define RX_FIFO		0x00
121 #define RX_STATUS	0x08
122 #define TX_STATUS	0x0B
123 #define TX_FREE		0x0C	/* Remaining free bytes in Tx buffer. */
124 
125 #define WN0_IRQ		0x08	/* Window 0: Set IRQ line in bits 12-15. */
126 #define WN4_MEDIA	0x0A	/* Window 4: Various transcvr/media bits. */
127 #define MEDIA_TP	0x00C0	/* Enable link beat and jabber for 10baseT. */
128 #define MEDIA_LED	0x0001	/* Enable link light on 3C589E cards. */
129 
130 /* Time in jiffies before concluding Tx hung */
131 #define TX_TIMEOUT	((400*HZ)/1000)
132 
133 struct el3_private {
134 	struct pcmcia_device	*p_dev;
135 	/* For transceiver monitoring */
136 	struct timer_list	media;
137 	u16			media_status;
138 	u16			fast_poll;
139 	unsigned long		last_irq;
140 	spinlock_t		lock;
141 };
142 
143 static const char *if_names[] = { "auto", "10baseT", "10base2", "AUI" };
144 
145 /*====================================================================*/
146 
147 /* Module parameters */
148 
149 MODULE_AUTHOR("David Hinds <dahinds@users.sourceforge.net>");
150 MODULE_DESCRIPTION("3Com 3c589 series PCMCIA ethernet driver");
151 MODULE_LICENSE("GPL");
152 
153 #define INT_MODULE_PARM(n, v) static int n = v; module_param(n, int, 0)
154 
155 /* Special hook for setting if_port when module is loaded */
156 INT_MODULE_PARM(if_port, 0);
157 
158 
159 /*====================================================================*/
160 
161 static int tc589_config(struct pcmcia_device *link);
162 static void tc589_release(struct pcmcia_device *link);
163 
164 static u16 read_eeprom(unsigned int ioaddr, int index);
165 static void tc589_reset(struct net_device *dev);
166 static void media_check(unsigned long arg);
167 static int el3_config(struct net_device *dev, struct ifmap *map);
168 static int el3_open(struct net_device *dev);
169 static netdev_tx_t el3_start_xmit(struct sk_buff *skb,
170 					struct net_device *dev);
171 static irqreturn_t el3_interrupt(int irq, void *dev_id);
172 static void update_stats(struct net_device *dev);
173 static struct net_device_stats *el3_get_stats(struct net_device *dev);
174 static int el3_rx(struct net_device *dev);
175 static int el3_close(struct net_device *dev);
176 static void el3_tx_timeout(struct net_device *dev);
177 static void set_rx_mode(struct net_device *dev);
178 static void set_multicast_list(struct net_device *dev);
179 static const struct ethtool_ops netdev_ethtool_ops;
180 
181 static void tc589_detach(struct pcmcia_device *p_dev);
182 
183 static const struct net_device_ops el3_netdev_ops = {
184 	.ndo_open		= el3_open,
185 	.ndo_stop		= el3_close,
186 	.ndo_start_xmit		= el3_start_xmit,
187 	.ndo_tx_timeout		= el3_tx_timeout,
188 	.ndo_set_config		= el3_config,
189 	.ndo_get_stats		= el3_get_stats,
190 	.ndo_set_rx_mode	= set_multicast_list,
191 	.ndo_set_mac_address	= eth_mac_addr,
192 	.ndo_validate_addr	= eth_validate_addr,
193 };
194 
195 static int tc589_probe(struct pcmcia_device *link)
196 {
197 	struct el3_private *lp;
198 	struct net_device *dev;
199 
200 	dev_dbg(&link->dev, "3c589_attach()\n");
201 
202 	/* Create new ethernet device */
203 	dev = alloc_etherdev(sizeof(struct el3_private));
204 	if (!dev)
205 		return -ENOMEM;
206 	lp = netdev_priv(dev);
207 	link->priv = dev;
208 	lp->p_dev = link;
209 
210 	spin_lock_init(&lp->lock);
211 	link->resource[0]->end = 16;
212 	link->resource[0]->flags |= IO_DATA_PATH_WIDTH_16;
213 
214 	link->config_flags |= CONF_ENABLE_IRQ;
215 	link->config_index = 1;
216 
217 	dev->netdev_ops = &el3_netdev_ops;
218 	dev->watchdog_timeo = TX_TIMEOUT;
219 
220 	dev->ethtool_ops = &netdev_ethtool_ops;
221 
222 	return tc589_config(link);
223 }
224 
225 static void tc589_detach(struct pcmcia_device *link)
226 {
227 	struct net_device *dev = link->priv;
228 
229 	dev_dbg(&link->dev, "3c589_detach\n");
230 
231 	unregister_netdev(dev);
232 
233 	tc589_release(link);
234 
235 	free_netdev(dev);
236 } /* tc589_detach */
237 
238 static int tc589_config(struct pcmcia_device *link)
239 {
240 	struct net_device *dev = link->priv;
241 	__be16 *phys_addr;
242 	int ret, i, j, multi = 0, fifo;
243 	unsigned int ioaddr;
244 	static const char * const ram_split[] = {"5:3", "3:1", "1:1", "3:5"};
245 	u8 *buf;
246 	size_t len;
247 
248 	dev_dbg(&link->dev, "3c589_config\n");
249 
250 	phys_addr = (__be16 *)dev->dev_addr;
251 	/* Is this a 3c562? */
252 	if (link->manf_id != MANFID_3COM)
253 		dev_info(&link->dev, "hmmm, is this really a 3Com card??\n");
254 	multi = (link->card_id == PRODID_3COM_3C562);
255 
256 	link->io_lines = 16;
257 
258 	/* For the 3c562, the base address must be xx00-xx7f */
259 	for (i = j = 0; j < 0x400; j += 0x10) {
260 		if (multi && (j & 0x80))
261 			continue;
262 		link->resource[0]->start = j ^ 0x300;
263 		i = pcmcia_request_io(link);
264 		if (i == 0)
265 			break;
266 	}
267 	if (i != 0)
268 		goto failed;
269 
270 	ret = pcmcia_request_irq(link, el3_interrupt);
271 	if (ret)
272 		goto failed;
273 
274 	ret = pcmcia_enable_device(link);
275 	if (ret)
276 		goto failed;
277 
278 	dev->irq = link->irq;
279 	dev->base_addr = link->resource[0]->start;
280 	ioaddr = dev->base_addr;
281 	EL3WINDOW(0);
282 
283 	/* The 3c589 has an extra EEPROM for configuration info, including
284 	 * the hardware address.  The 3c562 puts the address in the CIS.
285 	 */
286 	len = pcmcia_get_tuple(link, 0x88, &buf);
287 	if (buf && len >= 6) {
288 		for (i = 0; i < 3; i++)
289 			phys_addr[i] = htons(le16_to_cpu(buf[i*2]));
290 		kfree(buf);
291 	} else {
292 		kfree(buf); /* 0 < len < 6 */
293 		for (i = 0; i < 3; i++)
294 			phys_addr[i] = htons(read_eeprom(ioaddr, i));
295 		if (phys_addr[0] == htons(0x6060)) {
296 			dev_err(&link->dev, "IO port conflict at 0x%03lx-0x%03lx\n",
297 					dev->base_addr, dev->base_addr+15);
298 			goto failed;
299 		}
300 	}
301 
302 	/* The address and resource configuration register aren't loaded from
303 	 * the EEPROM and *must* be set to 0 and IRQ3 for the PCMCIA version.
304 	 */
305 
306 	outw(0x3f00, ioaddr + 8);
307 	fifo = inl(ioaddr);
308 
309 	/* The if_port symbol can be set when the module is loaded */
310 	if ((if_port >= 0) && (if_port <= 3))
311 		dev->if_port = if_port;
312 	else
313 		dev_err(&link->dev, "invalid if_port requested\n");
314 
315 	SET_NETDEV_DEV(dev, &link->dev);
316 
317 	if (register_netdev(dev) != 0) {
318 		dev_err(&link->dev, "register_netdev() failed\n");
319 		goto failed;
320 	}
321 
322 	netdev_info(dev, "3Com 3c%s, io %#3lx, irq %d, hw_addr %pM\n",
323 			(multi ? "562" : "589"), dev->base_addr, dev->irq,
324 			dev->dev_addr);
325 	netdev_info(dev, "  %dK FIFO split %s Rx:Tx, %s xcvr\n",
326 			(fifo & 7) ? 32 : 8, ram_split[(fifo >> 16) & 3],
327 			if_names[dev->if_port]);
328 	return 0;
329 
330 failed:
331 	tc589_release(link);
332 	return -ENODEV;
333 } /* tc589_config */
334 
335 static void tc589_release(struct pcmcia_device *link)
336 {
337 	pcmcia_disable_device(link);
338 }
339 
340 static int tc589_suspend(struct pcmcia_device *link)
341 {
342 	struct net_device *dev = link->priv;
343 
344 	if (link->open)
345 		netif_device_detach(dev);
346 
347 	return 0;
348 }
349 
350 static int tc589_resume(struct pcmcia_device *link)
351 {
352 	struct net_device *dev = link->priv;
353 
354 	if (link->open) {
355 		tc589_reset(dev);
356 		netif_device_attach(dev);
357 	}
358 
359 	return 0;
360 }
361 
362 /*====================================================================*/
363 
364 /* Use this for commands that may take time to finish */
365 
366 static void tc589_wait_for_completion(struct net_device *dev, int cmd)
367 {
368 	int i = 100;
369 	outw(cmd, dev->base_addr + EL3_CMD);
370 	while (--i > 0)
371 		if (!(inw(dev->base_addr + EL3_STATUS) & 0x1000))
372 			break;
373 	if (i == 0)
374 		netdev_warn(dev, "command 0x%04x did not complete!\n", cmd);
375 }
376 
377 /* Read a word from the EEPROM using the regular EEPROM access register.
378  * Assume that we are in register window zero.
379  */
380 
381 static u16 read_eeprom(unsigned int ioaddr, int index)
382 {
383 	int i;
384 	outw(EEPROM_READ + index, ioaddr + 10);
385 	/* Reading the eeprom takes 162 us */
386 	for (i = 1620; i >= 0; i--)
387 		if ((inw(ioaddr + 10) & EEPROM_BUSY) == 0)
388 			break;
389 	return inw(ioaddr + 12);
390 }
391 
392 /* Set transceiver type, perhaps to something other than what the user
393  * specified in dev->if_port.
394  */
395 
396 static void tc589_set_xcvr(struct net_device *dev, int if_port)
397 {
398 	struct el3_private *lp = netdev_priv(dev);
399 	unsigned int ioaddr = dev->base_addr;
400 
401 	EL3WINDOW(0);
402 	switch (if_port) {
403 	case 0:
404 	case 1:
405 		outw(0, ioaddr + 6);
406 		break;
407 	case 2:
408 		outw(3<<14, ioaddr + 6);
409 		break;
410 	case 3:
411 		outw(1<<14, ioaddr + 6);
412 		break;
413 	}
414 	/* On PCMCIA, this just turns on the LED */
415 	outw((if_port == 2) ? StartCoax : StopCoax, ioaddr + EL3_CMD);
416 	/* 10baseT interface, enable link beat and jabber check. */
417 	EL3WINDOW(4);
418 	outw(MEDIA_LED | ((if_port < 2) ? MEDIA_TP : 0), ioaddr + WN4_MEDIA);
419 	EL3WINDOW(1);
420 	if (if_port == 2)
421 		lp->media_status = ((dev->if_port == 0) ? 0x8000 : 0x4000);
422 	else
423 		lp->media_status = ((dev->if_port == 0) ? 0x4010 : 0x8800);
424 }
425 
426 static void dump_status(struct net_device *dev)
427 {
428 	unsigned int ioaddr = dev->base_addr;
429 	EL3WINDOW(1);
430 	netdev_info(dev, "  irq status %04x, rx status %04x, tx status %02x  tx free %04x\n",
431 			inw(ioaddr+EL3_STATUS), inw(ioaddr+RX_STATUS),
432 			inb(ioaddr+TX_STATUS), inw(ioaddr+TX_FREE));
433 	EL3WINDOW(4);
434 	netdev_info(dev, "  diagnostics: fifo %04x net %04x ethernet %04x media %04x\n",
435 			inw(ioaddr+0x04), inw(ioaddr+0x06), inw(ioaddr+0x08),
436 			inw(ioaddr+0x0a));
437 	EL3WINDOW(1);
438 }
439 
440 /* Reset and restore all of the 3c589 registers. */
441 static void tc589_reset(struct net_device *dev)
442 {
443 	unsigned int ioaddr = dev->base_addr;
444 	int i;
445 
446 	EL3WINDOW(0);
447 	outw(0x0001, ioaddr + 4);			/* Activate board. */
448 	outw(0x3f00, ioaddr + 8);			/* Set the IRQ line. */
449 
450 	/* Set the station address in window 2. */
451 	EL3WINDOW(2);
452 	for (i = 0; i < 6; i++)
453 		outb(dev->dev_addr[i], ioaddr + i);
454 
455 	tc589_set_xcvr(dev, dev->if_port);
456 
457 	/* Switch to the stats window, and clear all stats by reading. */
458 	outw(StatsDisable, ioaddr + EL3_CMD);
459 	EL3WINDOW(6);
460 	for (i = 0; i < 9; i++)
461 		inb(ioaddr+i);
462 	inw(ioaddr + 10);
463 	inw(ioaddr + 12);
464 
465 	/* Switch to register set 1 for normal use. */
466 	EL3WINDOW(1);
467 
468 	set_rx_mode(dev);
469 	outw(StatsEnable, ioaddr + EL3_CMD); /* Turn on statistics. */
470 	outw(RxEnable, ioaddr + EL3_CMD); /* Enable the receiver. */
471 	outw(TxEnable, ioaddr + EL3_CMD); /* Enable transmitter. */
472 	/* Allow status bits to be seen. */
473 	outw(SetStatusEnb | 0xff, ioaddr + EL3_CMD);
474 	/* Ack all pending events, and set active indicator mask. */
475 	outw(AckIntr | IntLatch | TxAvailable | RxEarly | IntReq,
476 	 ioaddr + EL3_CMD);
477 	outw(SetIntrEnb | IntLatch | TxAvailable | RxComplete | StatsFull
478 	 | AdapterFailure, ioaddr + EL3_CMD);
479 }
480 
481 static void netdev_get_drvinfo(struct net_device *dev,
482 			       struct ethtool_drvinfo *info)
483 {
484 	strlcpy(info->driver, DRV_NAME, sizeof(info->driver));
485 	strlcpy(info->version, DRV_VERSION, sizeof(info->version));
486 	snprintf(info->bus_info, sizeof(info->bus_info),
487 		"PCMCIA 0x%lx", dev->base_addr);
488 }
489 
490 static const struct ethtool_ops netdev_ethtool_ops = {
491 	.get_drvinfo		= netdev_get_drvinfo,
492 };
493 
494 static int el3_config(struct net_device *dev, struct ifmap *map)
495 {
496 	if ((map->port != (u_char)(-1)) && (map->port != dev->if_port)) {
497 		if (map->port <= 3) {
498 			dev->if_port = map->port;
499 			netdev_info(dev, "switched to %s port\n", if_names[dev->if_port]);
500 			tc589_set_xcvr(dev, dev->if_port);
501 		} else {
502 			return -EINVAL;
503 		}
504 	}
505 	return 0;
506 }
507 
508 static int el3_open(struct net_device *dev)
509 {
510 	struct el3_private *lp = netdev_priv(dev);
511 	struct pcmcia_device *link = lp->p_dev;
512 
513 	if (!pcmcia_dev_present(link))
514 		return -ENODEV;
515 
516 	link->open++;
517 	netif_start_queue(dev);
518 
519 	tc589_reset(dev);
520 	setup_timer(&lp->media, media_check, (unsigned long)dev);
521 	mod_timer(&lp->media, jiffies + HZ);
522 
523 	dev_dbg(&link->dev, "%s: opened, status %4.4x.\n",
524 	  dev->name, inw(dev->base_addr + EL3_STATUS));
525 
526 	return 0;
527 }
528 
529 static void el3_tx_timeout(struct net_device *dev)
530 {
531 	unsigned int ioaddr = dev->base_addr;
532 
533 	netdev_warn(dev, "Transmit timed out!\n");
534 	dump_status(dev);
535 	dev->stats.tx_errors++;
536 	netif_trans_update(dev); /* prevent tx timeout */
537 	/* Issue TX_RESET and TX_START commands. */
538 	tc589_wait_for_completion(dev, TxReset);
539 	outw(TxEnable, ioaddr + EL3_CMD);
540 	netif_wake_queue(dev);
541 }
542 
543 static void pop_tx_status(struct net_device *dev)
544 {
545 	unsigned int ioaddr = dev->base_addr;
546 	int i;
547 
548 	/* Clear the Tx status stack. */
549 	for (i = 32; i > 0; i--) {
550 		u_char tx_status = inb(ioaddr + TX_STATUS);
551 		if (!(tx_status & 0x84))
552 			break;
553 		/* reset transmitter on jabber error or underrun */
554 		if (tx_status & 0x30)
555 			tc589_wait_for_completion(dev, TxReset);
556 		if (tx_status & 0x38) {
557 			netdev_dbg(dev, "transmit error: status 0x%02x\n", tx_status);
558 			outw(TxEnable, ioaddr + EL3_CMD);
559 			dev->stats.tx_aborted_errors++;
560 		}
561 		outb(0x00, ioaddr + TX_STATUS); /* Pop the status stack. */
562 	}
563 }
564 
565 static netdev_tx_t el3_start_xmit(struct sk_buff *skb,
566 					struct net_device *dev)
567 {
568 	unsigned int ioaddr = dev->base_addr;
569 	struct el3_private *priv = netdev_priv(dev);
570 	unsigned long flags;
571 
572 	netdev_dbg(dev, "el3_start_xmit(length = %ld) called, status %4.4x.\n",
573 	       (long)skb->len, inw(ioaddr + EL3_STATUS));
574 
575 	spin_lock_irqsave(&priv->lock, flags);
576 
577 	dev->stats.tx_bytes += skb->len;
578 
579 	/* Put out the doubleword header... */
580 	outw(skb->len, ioaddr + TX_FIFO);
581 	outw(0x00, ioaddr + TX_FIFO);
582 	/* ... and the packet rounded to a doubleword. */
583 	outsl(ioaddr + TX_FIFO, skb->data, (skb->len + 3) >> 2);
584 
585 	if (inw(ioaddr + TX_FREE) <= 1536) {
586 		netif_stop_queue(dev);
587 		/* Interrupt us when the FIFO has room for max-sized packet. */
588 		outw(SetTxThreshold + 1536, ioaddr + EL3_CMD);
589 	}
590 
591 	pop_tx_status(dev);
592 	spin_unlock_irqrestore(&priv->lock, flags);
593 	dev_kfree_skb(skb);
594 
595 	return NETDEV_TX_OK;
596 }
597 
598 /* The EL3 interrupt handler. */
599 static irqreturn_t el3_interrupt(int irq, void *dev_id)
600 {
601 	struct net_device *dev = (struct net_device *) dev_id;
602 	struct el3_private *lp = netdev_priv(dev);
603 	unsigned int ioaddr;
604 	__u16 status;
605 	int i = 0, handled = 1;
606 
607 	if (!netif_device_present(dev))
608 		return IRQ_NONE;
609 
610 	ioaddr = dev->base_addr;
611 
612 	netdev_dbg(dev, "interrupt, status %4.4x.\n", inw(ioaddr + EL3_STATUS));
613 
614 	spin_lock(&lp->lock);
615 	while ((status = inw(ioaddr + EL3_STATUS)) &
616 	(IntLatch | RxComplete | StatsFull)) {
617 		if ((status & 0xe000) != 0x2000) {
618 			netdev_dbg(dev, "interrupt from dead card\n");
619 			handled = 0;
620 			break;
621 		}
622 		if (status & RxComplete)
623 			el3_rx(dev);
624 		if (status & TxAvailable) {
625 			netdev_dbg(dev, "    TX room bit was handled.\n");
626 			/* There's room in the FIFO for a full-sized packet. */
627 			outw(AckIntr | TxAvailable, ioaddr + EL3_CMD);
628 			netif_wake_queue(dev);
629 		}
630 		if (status & TxComplete)
631 			pop_tx_status(dev);
632 		if (status & (AdapterFailure | RxEarly | StatsFull)) {
633 			/* Handle all uncommon interrupts. */
634 			if (status & StatsFull)		/* Empty statistics. */
635 				update_stats(dev);
636 			if (status & RxEarly) {
637 				/* Rx early is unused. */
638 				el3_rx(dev);
639 				outw(AckIntr | RxEarly, ioaddr + EL3_CMD);
640 			}
641 			if (status & AdapterFailure) {
642 				u16 fifo_diag;
643 				EL3WINDOW(4);
644 				fifo_diag = inw(ioaddr + 4);
645 				EL3WINDOW(1);
646 				netdev_warn(dev, "adapter failure, FIFO diagnostic register %04x.\n",
647 			    fifo_diag);
648 				if (fifo_diag & 0x0400) {
649 					/* Tx overrun */
650 					tc589_wait_for_completion(dev, TxReset);
651 					outw(TxEnable, ioaddr + EL3_CMD);
652 				}
653 				if (fifo_diag & 0x2000) {
654 					/* Rx underrun */
655 					tc589_wait_for_completion(dev, RxReset);
656 					set_rx_mode(dev);
657 					outw(RxEnable, ioaddr + EL3_CMD);
658 				}
659 				outw(AckIntr | AdapterFailure, ioaddr + EL3_CMD);
660 			}
661 		}
662 		if (++i > 10) {
663 			netdev_err(dev, "infinite loop in interrupt, status %4.4x.\n",
664 					status);
665 			/* Clear all interrupts */
666 			outw(AckIntr | 0xFF, ioaddr + EL3_CMD);
667 			break;
668 		}
669 		/* Acknowledge the IRQ. */
670 		outw(AckIntr | IntReq | IntLatch, ioaddr + EL3_CMD);
671 	}
672 	lp->last_irq = jiffies;
673 	spin_unlock(&lp->lock);
674 	netdev_dbg(dev, "exiting interrupt, status %4.4x.\n",
675 			inw(ioaddr + EL3_STATUS));
676 	return IRQ_RETVAL(handled);
677 }
678 
679 static void media_check(unsigned long arg)
680 {
681 	struct net_device *dev = (struct net_device *)(arg);
682 	struct el3_private *lp = netdev_priv(dev);
683 	unsigned int ioaddr = dev->base_addr;
684 	u16 media, errs;
685 	unsigned long flags;
686 
687 	if (!netif_device_present(dev))
688 		goto reschedule;
689 
690 	/* Check for pending interrupt with expired latency timer: with
691 	 * this, we can limp along even if the interrupt is blocked
692 	 */
693 	if ((inw(ioaddr + EL3_STATUS) & IntLatch) &&
694 	(inb(ioaddr + EL3_TIMER) == 0xff)) {
695 		if (!lp->fast_poll)
696 			netdev_warn(dev, "interrupt(s) dropped!\n");
697 
698 		local_irq_save(flags);
699 		el3_interrupt(dev->irq, dev);
700 		local_irq_restore(flags);
701 
702 		lp->fast_poll = HZ;
703 	}
704 	if (lp->fast_poll) {
705 		lp->fast_poll--;
706 		lp->media.expires = jiffies + HZ/100;
707 		add_timer(&lp->media);
708 		return;
709 	}
710 
711 	/* lp->lock guards the EL3 window. Window should always be 1 except
712 	 * when the lock is held
713 	 */
714 
715 	spin_lock_irqsave(&lp->lock, flags);
716 	EL3WINDOW(4);
717 	media = inw(ioaddr+WN4_MEDIA) & 0xc810;
718 
719 	/* Ignore collisions unless we've had no irq's recently */
720 	if (time_before(jiffies, lp->last_irq + HZ)) {
721 		media &= ~0x0010;
722 	} else {
723 		/* Try harder to detect carrier errors */
724 		EL3WINDOW(6);
725 		outw(StatsDisable, ioaddr + EL3_CMD);
726 		errs = inb(ioaddr + 0);
727 		outw(StatsEnable, ioaddr + EL3_CMD);
728 		dev->stats.tx_carrier_errors += errs;
729 		if (errs || (lp->media_status & 0x0010))
730 			media |= 0x0010;
731 	}
732 
733 	if (media != lp->media_status) {
734 		if ((media & lp->media_status & 0x8000) &&
735 				((lp->media_status ^ media) & 0x0800))
736 		netdev_info(dev, "%s link beat\n",
737 				(lp->media_status & 0x0800 ? "lost" : "found"));
738 		else if ((media & lp->media_status & 0x4000) &&
739 		 ((lp->media_status ^ media) & 0x0010))
740 		netdev_info(dev, "coax cable %s\n",
741 				(lp->media_status & 0x0010 ? "ok" : "problem"));
742 		if (dev->if_port == 0) {
743 			if (media & 0x8000) {
744 				if (media & 0x0800)
745 					netdev_info(dev, "flipped to 10baseT\n");
746 				else
747 			tc589_set_xcvr(dev, 2);
748 			} else if (media & 0x4000) {
749 				if (media & 0x0010)
750 					tc589_set_xcvr(dev, 1);
751 				else
752 					netdev_info(dev, "flipped to 10base2\n");
753 			}
754 		}
755 		lp->media_status = media;
756 	}
757 
758 	EL3WINDOW(1);
759 	spin_unlock_irqrestore(&lp->lock, flags);
760 
761 reschedule:
762 	lp->media.expires = jiffies + HZ;
763 	add_timer(&lp->media);
764 }
765 
766 static struct net_device_stats *el3_get_stats(struct net_device *dev)
767 {
768 	struct el3_private *lp = netdev_priv(dev);
769 	unsigned long flags;
770 	struct pcmcia_device *link = lp->p_dev;
771 
772 	if (pcmcia_dev_present(link)) {
773 		spin_lock_irqsave(&lp->lock, flags);
774 		update_stats(dev);
775 		spin_unlock_irqrestore(&lp->lock, flags);
776 	}
777 	return &dev->stats;
778 }
779 
780 /* Update statistics.  We change to register window 6, so this should be run
781 * single-threaded if the device is active. This is expected to be a rare
782 * operation, and it's simpler for the rest of the driver to assume that
783 * window 1 is always valid rather than use a special window-state variable.
784 *
785 * Caller must hold the lock for this
786 */
787 
788 static void update_stats(struct net_device *dev)
789 {
790 	unsigned int ioaddr = dev->base_addr;
791 
792 	netdev_dbg(dev, "updating the statistics.\n");
793 	/* Turn off statistics updates while reading. */
794 	outw(StatsDisable, ioaddr + EL3_CMD);
795 	/* Switch to the stats window, and read everything. */
796 	EL3WINDOW(6);
797 	dev->stats.tx_carrier_errors	+= inb(ioaddr + 0);
798 	dev->stats.tx_heartbeat_errors	+= inb(ioaddr + 1);
799 	/* Multiple collisions. */
800 	inb(ioaddr + 2);
801 	dev->stats.collisions		+= inb(ioaddr + 3);
802 	dev->stats.tx_window_errors		+= inb(ioaddr + 4);
803 	dev->stats.rx_fifo_errors		+= inb(ioaddr + 5);
804 	dev->stats.tx_packets		+= inb(ioaddr + 6);
805 	/* Rx packets   */
806 	inb(ioaddr + 7);
807 	/* Tx deferrals */
808 	inb(ioaddr + 8);
809 	/* Rx octets */
810 	inw(ioaddr + 10);
811 	/* Tx octets */
812 	inw(ioaddr + 12);
813 
814 	/* Back to window 1, and turn statistics back on. */
815 	EL3WINDOW(1);
816 	outw(StatsEnable, ioaddr + EL3_CMD);
817 }
818 
819 static int el3_rx(struct net_device *dev)
820 {
821 	unsigned int ioaddr = dev->base_addr;
822 	int worklimit = 32;
823 	short rx_status;
824 
825 	netdev_dbg(dev, "in rx_packet(), status %4.4x, rx_status %4.4x.\n",
826 	       inw(ioaddr+EL3_STATUS), inw(ioaddr+RX_STATUS));
827 	while (!((rx_status = inw(ioaddr + RX_STATUS)) & 0x8000) &&
828 		    worklimit > 0) {
829 		worklimit--;
830 		if (rx_status & 0x4000) { /* Error, update stats. */
831 			short error = rx_status & 0x3800;
832 			dev->stats.rx_errors++;
833 			switch (error) {
834 			case 0x0000:
835 				dev->stats.rx_over_errors++;
836 				break;
837 			case 0x0800:
838 				dev->stats.rx_length_errors++;
839 				break;
840 			case 0x1000:
841 				dev->stats.rx_frame_errors++;
842 				break;
843 			case 0x1800:
844 				dev->stats.rx_length_errors++;
845 				break;
846 			case 0x2000:
847 				dev->stats.rx_frame_errors++;
848 				break;
849 			case 0x2800:
850 				dev->stats.rx_crc_errors++;
851 				break;
852 			}
853 		} else {
854 			short pkt_len = rx_status & 0x7ff;
855 			struct sk_buff *skb;
856 
857 			skb = netdev_alloc_skb(dev, pkt_len + 5);
858 
859 			netdev_dbg(dev, "    Receiving packet size %d status %4.4x.\n",
860 		       pkt_len, rx_status);
861 			if (skb != NULL) {
862 				skb_reserve(skb, 2);
863 				insl(ioaddr+RX_FIFO, skb_put(skb, pkt_len),
864 			(pkt_len+3)>>2);
865 				skb->protocol = eth_type_trans(skb, dev);
866 				netif_rx(skb);
867 				dev->stats.rx_packets++;
868 				dev->stats.rx_bytes += pkt_len;
869 			} else {
870 				netdev_dbg(dev, "couldn't allocate a sk_buff of size %d.\n",
871 			   pkt_len);
872 				dev->stats.rx_dropped++;
873 			}
874 		}
875 		/* Pop the top of the Rx FIFO */
876 		tc589_wait_for_completion(dev, RxDiscard);
877 	}
878 	if (worklimit == 0)
879 		netdev_warn(dev, "too much work in el3_rx!\n");
880 	return 0;
881 }
882 
883 static void set_rx_mode(struct net_device *dev)
884 {
885 	unsigned int ioaddr = dev->base_addr;
886 	u16 opts = SetRxFilter | RxStation | RxBroadcast;
887 
888 	if (dev->flags & IFF_PROMISC)
889 		opts |= RxMulticast | RxProm;
890 	else if (!netdev_mc_empty(dev) || (dev->flags & IFF_ALLMULTI))
891 		opts |= RxMulticast;
892 	outw(opts, ioaddr + EL3_CMD);
893 }
894 
895 static void set_multicast_list(struct net_device *dev)
896 {
897 	struct el3_private *priv = netdev_priv(dev);
898 	unsigned long flags;
899 
900 	spin_lock_irqsave(&priv->lock, flags);
901 	set_rx_mode(dev);
902 	spin_unlock_irqrestore(&priv->lock, flags);
903 }
904 
905 static int el3_close(struct net_device *dev)
906 {
907 	struct el3_private *lp = netdev_priv(dev);
908 	struct pcmcia_device *link = lp->p_dev;
909 	unsigned int ioaddr = dev->base_addr;
910 
911 	dev_dbg(&link->dev, "%s: shutting down ethercard.\n", dev->name);
912 
913 	if (pcmcia_dev_present(link)) {
914 		/* Turn off statistics ASAP.  We update dev->stats below. */
915 		outw(StatsDisable, ioaddr + EL3_CMD);
916 
917 		/* Disable the receiver and transmitter. */
918 		outw(RxDisable, ioaddr + EL3_CMD);
919 		outw(TxDisable, ioaddr + EL3_CMD);
920 
921 		if (dev->if_port == 2)
922 			/* Turn off thinnet power.  Green! */
923 			outw(StopCoax, ioaddr + EL3_CMD);
924 		else if (dev->if_port == 1) {
925 			/* Disable link beat and jabber */
926 			EL3WINDOW(4);
927 			outw(0, ioaddr + WN4_MEDIA);
928 		}
929 
930 		/* Switching back to window 0 disables the IRQ. */
931 		EL3WINDOW(0);
932 		/* But we explicitly zero the IRQ line select anyway. */
933 		outw(0x0f00, ioaddr + WN0_IRQ);
934 
935 		/* Check if the card still exists */
936 		if ((inw(ioaddr+EL3_STATUS) & 0xe000) == 0x2000)
937 			update_stats(dev);
938 	}
939 
940 	link->open--;
941 	netif_stop_queue(dev);
942 	del_timer_sync(&lp->media);
943 
944 	return 0;
945 }
946 
947 static const struct pcmcia_device_id tc589_ids[] = {
948 	PCMCIA_MFC_DEVICE_MANF_CARD(0, 0x0101, 0x0562),
949 	PCMCIA_MFC_DEVICE_PROD_ID1(0, "Motorola MARQUIS", 0xf03e4e77),
950 	PCMCIA_DEVICE_MANF_CARD(0x0101, 0x0589),
951 	PCMCIA_DEVICE_PROD_ID12("Farallon", "ENet", 0x58d93fc4, 0x992c2202),
952 	PCMCIA_MFC_DEVICE_CIS_MANF_CARD(0, 0x0101, 0x0035, "cis/3CXEM556.cis"),
953 	PCMCIA_MFC_DEVICE_CIS_MANF_CARD(0, 0x0101, 0x003d, "cis/3CXEM556.cis"),
954 	PCMCIA_DEVICE_NULL,
955 };
956 MODULE_DEVICE_TABLE(pcmcia, tc589_ids);
957 
958 static struct pcmcia_driver tc589_driver = {
959 	.owner		= THIS_MODULE,
960 	.name		= "3c589_cs",
961 	.probe		= tc589_probe,
962 	.remove		= tc589_detach,
963 	.id_table	= tc589_ids,
964 	.suspend	= tc589_suspend,
965 	.resume		= tc589_resume,
966 };
967 module_pcmcia_driver(tc589_driver);
968