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