1 /*======================================================================
3 A PCMCIA ethernet driver for the 3com 3c589 card.
5 Copyright (C) 1999 David A. Hinds -- dahinds@users.sourceforge.net
7 3c589_cs.c 1.162 2001/10/13 00:08:50
9 The network driver code is based on Donald Becker's 3c589 code:
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
18 Updated for 2.5.x by Alan Cox <alan@redhat.com>
20 ======================================================================*/
22 #define DRV_NAME "3c589_cs"
23 #define DRV_VERSION "1.162-ac"
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>
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>
44 #include <pcmcia/cs_types.h>
45 #include <pcmcia/cs.h>
46 #include <pcmcia/cistpl.h>
47 #include <pcmcia/cisreg.h>
48 #include <pcmcia/ciscode.h>
49 #include <pcmcia/ds.h>
51 #include <asm/uaccess.h>
53 #include <asm/system.h>
55 /* To minimize the size of the driver source I only define operating
56 constants if they are used several times. You'll need the manual
57 if you want to understand driver details. */
58 /* Offsets from base I/O address. */
60 #define EL3_TIMER 0x0a
62 #define EL3_STATUS 0x0e
64 #define EEPROM_READ 0x0080
65 #define EEPROM_BUSY 0x8000
67 #define EL3WINDOW(win_num) outw(SelectWindow + (win_num), ioaddr + EL3_CMD)
69 /* The top five bits written to EL3_CMD are a command, the lower
70 11 bits are the parameter, if applicable. */
72 TotalReset = 0<<11, SelectWindow = 1<<11, StartCoax = 2<<11,
73 RxDisable = 3<<11, RxEnable = 4<<11, RxReset = 5<<11, RxDiscard = 8<<11,
74 TxEnable = 9<<11, TxDisable = 10<<11, TxReset = 11<<11,
75 FakeIntr = 12<<11, AckIntr = 13<<11, SetIntrEnb = 14<<11,
76 SetStatusEnb = 15<<11, SetRxFilter = 16<<11, SetRxThreshold = 17<<11,
77 SetTxThreshold = 18<<11, SetTxStart = 19<<11, StatsEnable = 21<<11,
78 StatsDisable = 22<<11, StopCoax = 23<<11,
82 IntLatch = 0x0001, AdapterFailure = 0x0002, TxComplete = 0x0004,
83 TxAvailable = 0x0008, RxComplete = 0x0010, RxEarly = 0x0020,
84 IntReq = 0x0040, StatsFull = 0x0080, CmdBusy = 0x1000
87 /* The SetRxFilter command accepts the following classes: */
89 RxStation = 1, RxMulticast = 2, RxBroadcast = 4, RxProm = 8
92 /* Register window 1 offsets, the window used in normal operation. */
95 #define RX_STATUS 0x08
96 #define TX_STATUS 0x0B
97 #define TX_FREE 0x0C /* Remaining free bytes in Tx buffer. */
99 #define WN0_IRQ 0x08 /* Window 0: Set IRQ line in bits 12-15. */
100 #define WN4_MEDIA 0x0A /* Window 4: Various transcvr/media bits. */
101 #define MEDIA_TP 0x00C0 /* Enable link beat and jabber for 10baseT. */
102 #define MEDIA_LED 0x0001 /* Enable link light on 3C589E cards. */
104 /* Time in jiffies before concluding Tx hung */
105 #define TX_TIMEOUT ((400*HZ)/1000)
110 struct net_device_stats stats;
111 /* For transceiver monitoring */
112 struct timer_list media;
115 unsigned long last_irq;
119 static const char *if_names[] = { "auto", "10baseT", "10base2", "AUI" };
121 /*====================================================================*/
123 /* Module parameters */
125 MODULE_AUTHOR("David Hinds <dahinds@users.sourceforge.net>");
126 MODULE_DESCRIPTION("3Com 3c589 series PCMCIA ethernet driver");
127 MODULE_LICENSE("GPL");
129 #define INT_MODULE_PARM(n, v) static int n = v; module_param(n, int, 0)
131 /* Special hook for setting if_port when module is loaded */
132 INT_MODULE_PARM(if_port, 0);
135 INT_MODULE_PARM(pc_debug, PCMCIA_DEBUG);
136 #define DEBUG(n, args...) if (pc_debug>(n)) printk(KERN_DEBUG args)
137 static char *version =
138 DRV_NAME ".c " DRV_VERSION " 2001/10/13 00:08:50 (David Hinds)";
140 #define DEBUG(n, args...)
143 /*====================================================================*/
145 static void tc589_config(dev_link_t *link);
146 static void tc589_release(dev_link_t *link);
148 static u16 read_eeprom(kio_addr_t ioaddr, int index);
149 static void tc589_reset(struct net_device *dev);
150 static void media_check(unsigned long arg);
151 static int el3_config(struct net_device *dev, struct ifmap *map);
152 static int el3_open(struct net_device *dev);
153 static int el3_start_xmit(struct sk_buff *skb, struct net_device *dev);
154 static irqreturn_t el3_interrupt(int irq, void *dev_id, struct pt_regs *regs);
155 static void update_stats(struct net_device *dev);
156 static struct net_device_stats *el3_get_stats(struct net_device *dev);
157 static int el3_rx(struct net_device *dev);
158 static int el3_close(struct net_device *dev);
159 static void el3_tx_timeout(struct net_device *dev);
160 static void set_multicast_list(struct net_device *dev);
161 static struct ethtool_ops netdev_ethtool_ops;
163 static void tc589_detach(struct pcmcia_device *p_dev);
165 /*======================================================================
167 tc589_attach() creates an "instance" of the driver, allocating
168 local data structures for one device. The device is registered
171 ======================================================================*/
173 static int tc589_attach(struct pcmcia_device *p_dev)
175 struct el3_private *lp;
177 struct net_device *dev;
179 DEBUG(0, "3c589_attach()\n");
181 /* Create new ethernet device */
182 dev = alloc_etherdev(sizeof(struct el3_private));
185 lp = netdev_priv(dev);
189 spin_lock_init(&lp->lock);
190 link->io.NumPorts1 = 16;
191 link->io.Attributes1 = IO_DATA_PATH_WIDTH_16;
192 link->irq.Attributes = IRQ_TYPE_EXCLUSIVE | IRQ_HANDLE_PRESENT;
193 link->irq.IRQInfo1 = IRQ_LEVEL_ID;
194 link->irq.Handler = &el3_interrupt;
195 link->irq.Instance = dev;
196 link->conf.Attributes = CONF_ENABLE_IRQ;
198 link->conf.IntType = INT_MEMORY_AND_IO;
199 link->conf.ConfigIndex = 1;
200 link->conf.Present = PRESENT_OPTION;
202 /* The EL3-specific entries in the device structure. */
203 SET_MODULE_OWNER(dev);
204 dev->hard_start_xmit = &el3_start_xmit;
205 dev->set_config = &el3_config;
206 dev->get_stats = &el3_get_stats;
207 dev->set_multicast_list = &set_multicast_list;
208 dev->open = &el3_open;
209 dev->stop = &el3_close;
210 #ifdef HAVE_TX_TIMEOUT
211 dev->tx_timeout = el3_tx_timeout;
212 dev->watchdog_timeo = TX_TIMEOUT;
214 SET_ETHTOOL_OPS(dev, &netdev_ethtool_ops);
216 link->handle = p_dev;
217 p_dev->instance = link;
219 link->state |= DEV_PRESENT | DEV_CONFIG_PENDING;
225 /*======================================================================
227 This deletes a driver "instance". The device is de-registered
228 with Card Services. If it has been released, all local data
229 structures are freed. Otherwise, the structures will be freed
230 when the device is released.
232 ======================================================================*/
234 static void tc589_detach(struct pcmcia_device *p_dev)
236 dev_link_t *link = dev_to_instance(p_dev);
237 struct net_device *dev = link->priv;
239 DEBUG(0, "3c589_detach(0x%p)\n", link);
242 unregister_netdev(dev);
244 if (link->state & DEV_CONFIG)
250 /*======================================================================
252 tc589_config() is scheduled to run after a CARD_INSERTION event
253 is received, to configure the PCMCIA socket, and to make the
254 ethernet device available to the system.
256 ======================================================================*/
258 #define CS_CHECK(fn, ret) \
259 do { last_fn = (fn); if ((last_ret = (ret)) != 0) goto cs_failed; } while (0)
261 static void tc589_config(dev_link_t *link)
263 client_handle_t handle = link->handle;
264 struct net_device *dev = link->priv;
265 struct el3_private *lp = netdev_priv(dev);
268 u16 buf[32], *phys_addr;
269 int last_fn, last_ret, i, j, multi = 0, fifo;
271 char *ram_split[] = {"5:3", "3:1", "1:1", "3:5"};
273 DEBUG(0, "3c589_config(0x%p)\n", link);
275 phys_addr = (u16 *)dev->dev_addr;
276 tuple.Attributes = 0;
277 tuple.DesiredTuple = CISTPL_CONFIG;
278 CS_CHECK(GetFirstTuple, pcmcia_get_first_tuple(handle, &tuple));
279 tuple.TupleData = (cisdata_t *)buf;
280 tuple.TupleDataMax = sizeof(buf);
281 tuple.TupleOffset = 0;
282 CS_CHECK(GetTupleData, pcmcia_get_tuple_data(handle, &tuple));
283 CS_CHECK(ParseTuple, pcmcia_parse_tuple(handle, &tuple, &parse));
284 link->conf.ConfigBase = parse.config.base;
285 link->conf.Present = parse.config.rmask[0];
287 /* Is this a 3c562? */
288 tuple.DesiredTuple = CISTPL_MANFID;
289 tuple.Attributes = TUPLE_RETURN_COMMON;
290 if ((pcmcia_get_first_tuple(handle, &tuple) == CS_SUCCESS) &&
291 (pcmcia_get_tuple_data(handle, &tuple) == CS_SUCCESS)) {
292 if (le16_to_cpu(buf[0]) != MANFID_3COM)
293 printk(KERN_INFO "3c589_cs: hmmm, is this really a "
295 multi = (le16_to_cpu(buf[1]) == PRODID_3COM_3C562);
299 link->state |= DEV_CONFIG;
301 /* For the 3c562, the base address must be xx00-xx7f */
302 link->io.IOAddrLines = 16;
303 for (i = j = 0; j < 0x400; j += 0x10) {
304 if (multi && (j & 0x80)) continue;
305 link->io.BasePort1 = j ^ 0x300;
306 i = pcmcia_request_io(link->handle, &link->io);
307 if (i == CS_SUCCESS) break;
309 if (i != CS_SUCCESS) {
310 cs_error(link->handle, RequestIO, i);
313 CS_CHECK(RequestIRQ, pcmcia_request_irq(link->handle, &link->irq));
314 CS_CHECK(RequestConfiguration, pcmcia_request_configuration(link->handle, &link->conf));
316 dev->irq = link->irq.AssignedIRQ;
317 dev->base_addr = link->io.BasePort1;
318 ioaddr = dev->base_addr;
321 /* The 3c589 has an extra EEPROM for configuration info, including
322 the hardware address. The 3c562 puts the address in the CIS. */
323 tuple.DesiredTuple = 0x88;
324 if (pcmcia_get_first_tuple(handle, &tuple) == CS_SUCCESS) {
325 pcmcia_get_tuple_data(handle, &tuple);
326 for (i = 0; i < 3; i++)
327 phys_addr[i] = htons(buf[i]);
329 for (i = 0; i < 3; i++)
330 phys_addr[i] = htons(read_eeprom(ioaddr, i));
331 if (phys_addr[0] == 0x6060) {
332 printk(KERN_ERR "3c589_cs: IO port conflict at 0x%03lx"
333 "-0x%03lx\n", dev->base_addr, dev->base_addr+15);
338 /* The address and resource configuration register aren't loaded from
339 the EEPROM and *must* be set to 0 and IRQ3 for the PCMCIA version. */
340 outw(0x3f00, ioaddr + 8);
343 /* The if_port symbol can be set when the module is loaded */
344 if ((if_port >= 0) && (if_port <= 3))
345 dev->if_port = if_port;
347 printk(KERN_ERR "3c589_cs: invalid if_port requested\n");
349 link->dev = &lp->node;
350 link->state &= ~DEV_CONFIG_PENDING;
351 SET_NETDEV_DEV(dev, &handle_to_dev(handle));
353 if (register_netdev(dev) != 0) {
354 printk(KERN_ERR "3c589_cs: register_netdev() failed\n");
359 strcpy(lp->node.dev_name, dev->name);
361 printk(KERN_INFO "%s: 3Com 3c%s, io %#3lx, irq %d, hw_addr ",
362 dev->name, (multi ? "562" : "589"), dev->base_addr,
364 for (i = 0; i < 6; i++)
365 printk("%02X%s", dev->dev_addr[i], ((i<5) ? ":" : "\n"));
366 printk(KERN_INFO " %dK FIFO split %s Rx:Tx, %s xcvr\n",
367 (fifo & 7) ? 32 : 8, ram_split[(fifo >> 16) & 3],
368 if_names[dev->if_port]);
372 cs_error(link->handle, last_fn, last_ret);
379 /*======================================================================
381 After a card is removed, tc589_release() will unregister the net
382 device, and release the PCMCIA configuration. If the device is
383 still open, this will be postponed until it is closed.
385 ======================================================================*/
387 static void tc589_release(dev_link_t *link)
389 pcmcia_disable_device(link->handle);
392 static int tc589_suspend(struct pcmcia_device *p_dev)
394 dev_link_t *link = dev_to_instance(p_dev);
395 struct net_device *dev = link->priv;
397 link->state |= DEV_SUSPEND;
398 if (link->state & DEV_CONFIG) {
400 netif_device_detach(dev);
401 pcmcia_release_configuration(link->handle);
407 static int tc589_resume(struct pcmcia_device *p_dev)
409 dev_link_t *link = dev_to_instance(p_dev);
410 struct net_device *dev = link->priv;
412 link->state &= ~DEV_SUSPEND;
413 if (link->state & DEV_CONFIG) {
414 pcmcia_request_configuration(link->handle, &link->conf);
417 netif_device_attach(dev);
424 /*====================================================================*/
427 Use this for commands that may take time to finish
429 static void tc589_wait_for_completion(struct net_device *dev, int cmd)
432 outw(cmd, dev->base_addr + EL3_CMD);
434 if (!(inw(dev->base_addr + EL3_STATUS) & 0x1000)) break;
436 printk(KERN_WARNING "%s: command 0x%04x did not complete!\n",
441 Read a word from the EEPROM using the regular EEPROM access register.
442 Assume that we are in register window zero.
444 static u16 read_eeprom(kio_addr_t ioaddr, int index)
447 outw(EEPROM_READ + index, ioaddr + 10);
448 /* Reading the eeprom takes 162 us */
449 for (i = 1620; i >= 0; i--)
450 if ((inw(ioaddr + 10) & EEPROM_BUSY) == 0)
452 return inw(ioaddr + 12);
456 Set transceiver type, perhaps to something other than what the user
457 specified in dev->if_port.
459 static void tc589_set_xcvr(struct net_device *dev, int if_port)
461 struct el3_private *lp = netdev_priv(dev);
462 kio_addr_t ioaddr = dev->base_addr;
466 case 0: case 1: outw(0, ioaddr + 6); break;
467 case 2: outw(3<<14, ioaddr + 6); break;
468 case 3: outw(1<<14, ioaddr + 6); break;
470 /* On PCMCIA, this just turns on the LED */
471 outw((if_port == 2) ? StartCoax : StopCoax, ioaddr + EL3_CMD);
472 /* 10baseT interface, enable link beat and jabber check. */
474 outw(MEDIA_LED | ((if_port < 2) ? MEDIA_TP : 0), ioaddr + WN4_MEDIA);
477 lp->media_status = ((dev->if_port == 0) ? 0x8000 : 0x4000);
479 lp->media_status = ((dev->if_port == 0) ? 0x4010 : 0x8800);
482 static void dump_status(struct net_device *dev)
484 kio_addr_t ioaddr = dev->base_addr;
486 printk(KERN_INFO " irq status %04x, rx status %04x, tx status "
487 "%02x tx free %04x\n", inw(ioaddr+EL3_STATUS),
488 inw(ioaddr+RX_STATUS), inb(ioaddr+TX_STATUS),
489 inw(ioaddr+TX_FREE));
491 printk(KERN_INFO " diagnostics: fifo %04x net %04x ethernet %04x"
492 " media %04x\n", inw(ioaddr+0x04), inw(ioaddr+0x06),
493 inw(ioaddr+0x08), inw(ioaddr+0x0a));
497 /* Reset and restore all of the 3c589 registers. */
498 static void tc589_reset(struct net_device *dev)
500 kio_addr_t ioaddr = dev->base_addr;
504 outw(0x0001, ioaddr + 4); /* Activate board. */
505 outw(0x3f00, ioaddr + 8); /* Set the IRQ line. */
507 /* Set the station address in window 2. */
509 for (i = 0; i < 6; i++)
510 outb(dev->dev_addr[i], ioaddr + i);
512 tc589_set_xcvr(dev, dev->if_port);
514 /* Switch to the stats window, and clear all stats by reading. */
515 outw(StatsDisable, ioaddr + EL3_CMD);
517 for (i = 0; i < 9; i++)
522 /* Switch to register set 1 for normal use. */
525 /* Accept b-cast and phys addr only. */
526 outw(SetRxFilter | RxStation | RxBroadcast, ioaddr + EL3_CMD);
527 outw(StatsEnable, ioaddr + EL3_CMD); /* Turn on statistics. */
528 outw(RxEnable, ioaddr + EL3_CMD); /* Enable the receiver. */
529 outw(TxEnable, ioaddr + EL3_CMD); /* Enable transmitter. */
530 /* Allow status bits to be seen. */
531 outw(SetStatusEnb | 0xff, ioaddr + EL3_CMD);
532 /* Ack all pending events, and set active indicator mask. */
533 outw(AckIntr | IntLatch | TxAvailable | RxEarly | IntReq,
535 outw(SetIntrEnb | IntLatch | TxAvailable | RxComplete | StatsFull
536 | AdapterFailure, ioaddr + EL3_CMD);
539 static void netdev_get_drvinfo(struct net_device *dev,
540 struct ethtool_drvinfo *info)
542 strcpy(info->driver, DRV_NAME);
543 strcpy(info->version, DRV_VERSION);
544 sprintf(info->bus_info, "PCMCIA 0x%lx", dev->base_addr);
548 static u32 netdev_get_msglevel(struct net_device *dev)
553 static void netdev_set_msglevel(struct net_device *dev, u32 level)
557 #endif /* PCMCIA_DEBUG */
559 static struct ethtool_ops netdev_ethtool_ops = {
560 .get_drvinfo = netdev_get_drvinfo,
562 .get_msglevel = netdev_get_msglevel,
563 .set_msglevel = netdev_set_msglevel,
564 #endif /* PCMCIA_DEBUG */
567 static int el3_config(struct net_device *dev, struct ifmap *map)
569 if ((map->port != (u_char)(-1)) && (map->port != dev->if_port)) {
570 if (map->port <= 3) {
571 dev->if_port = map->port;
572 printk(KERN_INFO "%s: switched to %s port\n",
573 dev->name, if_names[dev->if_port]);
574 tc589_set_xcvr(dev, dev->if_port);
581 static int el3_open(struct net_device *dev)
583 struct el3_private *lp = netdev_priv(dev);
584 dev_link_t *link = &lp->link;
590 netif_start_queue(dev);
593 init_timer(&lp->media);
594 lp->media.function = &media_check;
595 lp->media.data = (unsigned long) dev;
596 lp->media.expires = jiffies + HZ;
597 add_timer(&lp->media);
599 DEBUG(1, "%s: opened, status %4.4x.\n",
600 dev->name, inw(dev->base_addr + EL3_STATUS));
605 static void el3_tx_timeout(struct net_device *dev)
607 struct el3_private *lp = netdev_priv(dev);
608 kio_addr_t ioaddr = dev->base_addr;
610 printk(KERN_WARNING "%s: Transmit timed out!\n", dev->name);
612 lp->stats.tx_errors++;
613 dev->trans_start = jiffies;
614 /* Issue TX_RESET and TX_START commands. */
615 tc589_wait_for_completion(dev, TxReset);
616 outw(TxEnable, ioaddr + EL3_CMD);
617 netif_wake_queue(dev);
620 static void pop_tx_status(struct net_device *dev)
622 struct el3_private *lp = netdev_priv(dev);
623 kio_addr_t ioaddr = dev->base_addr;
626 /* Clear the Tx status stack. */
627 for (i = 32; i > 0; i--) {
628 u_char tx_status = inb(ioaddr + TX_STATUS);
629 if (!(tx_status & 0x84)) break;
630 /* reset transmitter on jabber error or underrun */
631 if (tx_status & 0x30)
632 tc589_wait_for_completion(dev, TxReset);
633 if (tx_status & 0x38) {
634 DEBUG(1, "%s: transmit error: status 0x%02x\n",
635 dev->name, tx_status);
636 outw(TxEnable, ioaddr + EL3_CMD);
637 lp->stats.tx_aborted_errors++;
639 outb(0x00, ioaddr + TX_STATUS); /* Pop the status stack. */
643 static int el3_start_xmit(struct sk_buff *skb, struct net_device *dev)
645 kio_addr_t ioaddr = dev->base_addr;
646 struct el3_private *priv = netdev_priv(dev);
648 DEBUG(3, "%s: el3_start_xmit(length = %ld) called, "
649 "status %4.4x.\n", dev->name, (long)skb->len,
650 inw(ioaddr + EL3_STATUS));
652 priv->stats.tx_bytes += skb->len;
654 /* Put out the doubleword header... */
655 outw(skb->len, ioaddr + TX_FIFO);
656 outw(0x00, ioaddr + TX_FIFO);
657 /* ... and the packet rounded to a doubleword. */
658 outsl(ioaddr + TX_FIFO, skb->data, (skb->len + 3) >> 2);
660 dev->trans_start = jiffies;
661 if (inw(ioaddr + TX_FREE) <= 1536) {
662 netif_stop_queue(dev);
663 /* Interrupt us when the FIFO has room for max-sized packet. */
664 outw(SetTxThreshold + 1536, ioaddr + EL3_CMD);
673 /* The EL3 interrupt handler. */
674 static irqreturn_t el3_interrupt(int irq, void *dev_id, struct pt_regs *regs)
676 struct net_device *dev = (struct net_device *) dev_id;
677 struct el3_private *lp = netdev_priv(dev);
680 int i = 0, handled = 1;
682 if (!netif_device_present(dev))
685 ioaddr = dev->base_addr;
687 DEBUG(3, "%s: interrupt, status %4.4x.\n",
688 dev->name, inw(ioaddr + EL3_STATUS));
690 spin_lock(&lp->lock);
691 while ((status = inw(ioaddr + EL3_STATUS)) &
692 (IntLatch | RxComplete | StatsFull)) {
693 if ((status & 0xe000) != 0x2000) {
694 DEBUG(1, "%s: interrupt from dead card\n", dev->name);
699 if (status & RxComplete)
702 if (status & TxAvailable) {
703 DEBUG(3, " TX room bit was handled.\n");
704 /* There's room in the FIFO for a full-sized packet. */
705 outw(AckIntr | TxAvailable, ioaddr + EL3_CMD);
706 netif_wake_queue(dev);
709 if (status & TxComplete)
712 if (status & (AdapterFailure | RxEarly | StatsFull)) {
713 /* Handle all uncommon interrupts. */
714 if (status & StatsFull) /* Empty statistics. */
716 if (status & RxEarly) { /* Rx early is unused. */
718 outw(AckIntr | RxEarly, ioaddr + EL3_CMD);
720 if (status & AdapterFailure) {
723 fifo_diag = inw(ioaddr + 4);
725 printk(KERN_WARNING "%s: adapter failure, FIFO diagnostic"
726 " register %04x.\n", dev->name, fifo_diag);
727 if (fifo_diag & 0x0400) {
729 tc589_wait_for_completion(dev, TxReset);
730 outw(TxEnable, ioaddr + EL3_CMD);
732 if (fifo_diag & 0x2000) {
734 tc589_wait_for_completion(dev, RxReset);
735 set_multicast_list(dev);
736 outw(RxEnable, ioaddr + EL3_CMD);
738 outw(AckIntr | AdapterFailure, ioaddr + EL3_CMD);
743 printk(KERN_ERR "%s: infinite loop in interrupt, "
744 "status %4.4x.\n", dev->name, status);
745 /* Clear all interrupts */
746 outw(AckIntr | 0xFF, ioaddr + EL3_CMD);
749 /* Acknowledge the IRQ. */
750 outw(AckIntr | IntReq | IntLatch, ioaddr + EL3_CMD);
753 lp->last_irq = jiffies;
754 spin_unlock(&lp->lock);
755 DEBUG(3, "%s: exiting interrupt, status %4.4x.\n",
756 dev->name, inw(ioaddr + EL3_STATUS));
757 return IRQ_RETVAL(handled);
760 static void media_check(unsigned long arg)
762 struct net_device *dev = (struct net_device *)(arg);
763 struct el3_private *lp = netdev_priv(dev);
764 kio_addr_t ioaddr = dev->base_addr;
768 if (!netif_device_present(dev)) goto reschedule;
771 /* Check for pending interrupt with expired latency timer: with
772 this, we can limp along even if the interrupt is blocked */
773 if ((inw(ioaddr + EL3_STATUS) & IntLatch) &&
774 (inb(ioaddr + EL3_TIMER) == 0xff)) {
776 printk(KERN_WARNING "%s: interrupt(s) dropped!\n", dev->name);
777 el3_interrupt(dev->irq, lp, NULL);
782 lp->media.expires = jiffies + HZ/100;
783 add_timer(&lp->media);
787 /* lp->lock guards the EL3 window. Window should always be 1 except
788 when the lock is held */
789 spin_lock_irqsave(&lp->lock, flags);
791 media = inw(ioaddr+WN4_MEDIA) & 0xc810;
793 /* Ignore collisions unless we've had no irq's recently */
794 if (time_before(jiffies, lp->last_irq + HZ)) {
797 /* Try harder to detect carrier errors */
799 outw(StatsDisable, ioaddr + EL3_CMD);
800 errs = inb(ioaddr + 0);
801 outw(StatsEnable, ioaddr + EL3_CMD);
802 lp->stats.tx_carrier_errors += errs;
803 if (errs || (lp->media_status & 0x0010)) media |= 0x0010;
806 if (media != lp->media_status) {
807 if ((media & lp->media_status & 0x8000) &&
808 ((lp->media_status ^ media) & 0x0800))
809 printk(KERN_INFO "%s: %s link beat\n", dev->name,
810 (lp->media_status & 0x0800 ? "lost" : "found"));
811 else if ((media & lp->media_status & 0x4000) &&
812 ((lp->media_status ^ media) & 0x0010))
813 printk(KERN_INFO "%s: coax cable %s\n", dev->name,
814 (lp->media_status & 0x0010 ? "ok" : "problem"));
815 if (dev->if_port == 0) {
816 if (media & 0x8000) {
818 printk(KERN_INFO "%s: flipped to 10baseT\n",
821 tc589_set_xcvr(dev, 2);
822 } else if (media & 0x4000) {
824 tc589_set_xcvr(dev, 1);
826 printk(KERN_INFO "%s: flipped to 10base2\n",
830 lp->media_status = media;
834 spin_unlock_irqrestore(&lp->lock, flags);
837 lp->media.expires = jiffies + HZ;
838 add_timer(&lp->media);
841 static struct net_device_stats *el3_get_stats(struct net_device *dev)
843 struct el3_private *lp = netdev_priv(dev);
845 dev_link_t *link = &lp->link;
848 spin_lock_irqsave(&lp->lock, flags);
850 spin_unlock_irqrestore(&lp->lock, flags);
856 Update statistics. We change to register window 6, so this should be run
857 single-threaded if the device is active. This is expected to be a rare
858 operation, and it's simpler for the rest of the driver to assume that
859 window 1 is always valid rather than use a special window-state variable.
861 Caller must hold the lock for this
863 static void update_stats(struct net_device *dev)
865 struct el3_private *lp = netdev_priv(dev);
866 kio_addr_t ioaddr = dev->base_addr;
868 DEBUG(2, "%s: updating the statistics.\n", dev->name);
869 /* Turn off statistics updates while reading. */
870 outw(StatsDisable, ioaddr + EL3_CMD);
871 /* Switch to the stats window, and read everything. */
873 lp->stats.tx_carrier_errors += inb(ioaddr + 0);
874 lp->stats.tx_heartbeat_errors += inb(ioaddr + 1);
875 /* Multiple collisions. */ inb(ioaddr + 2);
876 lp->stats.collisions += inb(ioaddr + 3);
877 lp->stats.tx_window_errors += inb(ioaddr + 4);
878 lp->stats.rx_fifo_errors += inb(ioaddr + 5);
879 lp->stats.tx_packets += inb(ioaddr + 6);
880 /* Rx packets */ inb(ioaddr + 7);
881 /* Tx deferrals */ inb(ioaddr + 8);
882 /* Rx octets */ inw(ioaddr + 10);
883 /* Tx octets */ inw(ioaddr + 12);
885 /* Back to window 1, and turn statistics back on. */
887 outw(StatsEnable, ioaddr + EL3_CMD);
890 static int el3_rx(struct net_device *dev)
892 struct el3_private *lp = netdev_priv(dev);
893 kio_addr_t ioaddr = dev->base_addr;
897 DEBUG(3, "%s: in rx_packet(), status %4.4x, rx_status %4.4x.\n",
898 dev->name, inw(ioaddr+EL3_STATUS), inw(ioaddr+RX_STATUS));
899 while (!((rx_status = inw(ioaddr + RX_STATUS)) & 0x8000) &&
900 (--worklimit >= 0)) {
901 if (rx_status & 0x4000) { /* Error, update stats. */
902 short error = rx_status & 0x3800;
903 lp->stats.rx_errors++;
905 case 0x0000: lp->stats.rx_over_errors++; break;
906 case 0x0800: lp->stats.rx_length_errors++; break;
907 case 0x1000: lp->stats.rx_frame_errors++; break;
908 case 0x1800: lp->stats.rx_length_errors++; break;
909 case 0x2000: lp->stats.rx_frame_errors++; break;
910 case 0x2800: lp->stats.rx_crc_errors++; break;
913 short pkt_len = rx_status & 0x7ff;
916 skb = dev_alloc_skb(pkt_len+5);
918 DEBUG(3, " Receiving packet size %d status %4.4x.\n",
923 insl(ioaddr+RX_FIFO, skb_put(skb, pkt_len),
925 skb->protocol = eth_type_trans(skb, dev);
927 dev->last_rx = jiffies;
928 lp->stats.rx_packets++;
929 lp->stats.rx_bytes += pkt_len;
931 DEBUG(1, "%s: couldn't allocate a sk_buff of"
932 " size %d.\n", dev->name, pkt_len);
933 lp->stats.rx_dropped++;
936 /* Pop the top of the Rx FIFO */
937 tc589_wait_for_completion(dev, RxDiscard);
940 printk(KERN_WARNING "%s: too much work in el3_rx!\n", dev->name);
944 static void set_multicast_list(struct net_device *dev)
946 struct el3_private *lp = netdev_priv(dev);
947 dev_link_t *link = &lp->link;
948 kio_addr_t ioaddr = dev->base_addr;
949 u16 opts = SetRxFilter | RxStation | RxBroadcast;
951 if (!(DEV_OK(link))) return;
952 if (dev->flags & IFF_PROMISC)
953 opts |= RxMulticast | RxProm;
954 else if (dev->mc_count || (dev->flags & IFF_ALLMULTI))
956 outw(opts, ioaddr + EL3_CMD);
959 static int el3_close(struct net_device *dev)
961 struct el3_private *lp = netdev_priv(dev);
962 dev_link_t *link = &lp->link;
963 kio_addr_t ioaddr = dev->base_addr;
965 DEBUG(1, "%s: shutting down ethercard.\n", dev->name);
968 /* Turn off statistics ASAP. We update lp->stats below. */
969 outw(StatsDisable, ioaddr + EL3_CMD);
971 /* Disable the receiver and transmitter. */
972 outw(RxDisable, ioaddr + EL3_CMD);
973 outw(TxDisable, ioaddr + EL3_CMD);
975 if (dev->if_port == 2)
976 /* Turn off thinnet power. Green! */
977 outw(StopCoax, ioaddr + EL3_CMD);
978 else if (dev->if_port == 1) {
979 /* Disable link beat and jabber */
981 outw(0, ioaddr + WN4_MEDIA);
984 /* Switching back to window 0 disables the IRQ. */
986 /* But we explicitly zero the IRQ line select anyway. */
987 outw(0x0f00, ioaddr + WN0_IRQ);
989 /* Check if the card still exists */
990 if ((inw(ioaddr+EL3_STATUS) & 0xe000) == 0x2000)
995 netif_stop_queue(dev);
996 del_timer_sync(&lp->media);
1001 static struct pcmcia_device_id tc589_ids[] = {
1002 PCMCIA_MFC_DEVICE_MANF_CARD(0, 0x0101, 0x0562),
1003 PCMCIA_MFC_DEVICE_PROD_ID1(0, "Motorola MARQUIS", 0xf03e4e77),
1004 PCMCIA_DEVICE_MANF_CARD(0x0101, 0x0589),
1005 PCMCIA_DEVICE_PROD_ID12("Farallon", "ENet", 0x58d93fc4, 0x992c2202),
1006 PCMCIA_MFC_DEVICE_CIS_MANF_CARD(0, 0x0101, 0x0035, "3CXEM556.cis"),
1007 PCMCIA_MFC_DEVICE_CIS_MANF_CARD(0, 0x0101, 0x003d, "3CXEM556.cis"),
1010 MODULE_DEVICE_TABLE(pcmcia, tc589_ids);
1012 static struct pcmcia_driver tc589_driver = {
1013 .owner = THIS_MODULE,
1017 .probe = tc589_attach,
1018 .remove = tc589_detach,
1019 .id_table = tc589_ids,
1020 .suspend = tc589_suspend,
1021 .resume = tc589_resume,
1024 static int __init init_tc589(void)
1026 return pcmcia_register_driver(&tc589_driver);
1029 static void __exit exit_tc589(void)
1031 pcmcia_unregister_driver(&tc589_driver);
1034 module_init(init_tc589);
1035 module_exit(exit_tc589);