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@lxorguk.ukuu.org.uk>
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/cistpl.h>
45 #include <pcmcia/cisreg.h>
46 #include <pcmcia/ciscode.h>
47 #include <pcmcia/ds.h>
49 #include <asm/uaccess.h>
51 #include <asm/system.h>
53 /* To minimize the size of the driver source I only define operating
54 constants if they are used several times. You'll need the manual
55 if you want to understand driver details. */
56 /* Offsets from base I/O address. */
58 #define EL3_TIMER 0x0a
60 #define EL3_STATUS 0x0e
62 #define EEPROM_READ 0x0080
63 #define EEPROM_BUSY 0x8000
65 #define EL3WINDOW(win_num) outw(SelectWindow + (win_num), ioaddr + EL3_CMD)
67 /* The top five bits written to EL3_CMD are a command, the lower
68 11 bits are the parameter, if applicable. */
83 SetStatusEnb = 15<<11,
85 SetRxThreshold = 17<<11,
86 SetTxThreshold = 18<<11,
89 StatsDisable = 22<<11,
95 AdapterFailure = 0x0002,
105 /* The SetRxFilter command accepts the following classes: */
113 /* Register window 1 offsets, the window used in normal operation. */
116 #define RX_STATUS 0x08
117 #define TX_STATUS 0x0B
118 #define TX_FREE 0x0C /* Remaining free bytes in Tx buffer. */
120 #define WN0_IRQ 0x08 /* Window 0: Set IRQ line in bits 12-15. */
121 #define WN4_MEDIA 0x0A /* Window 4: Various transcvr/media bits. */
122 #define MEDIA_TP 0x00C0 /* Enable link beat and jabber for 10baseT. */
123 #define MEDIA_LED 0x0001 /* Enable link light on 3C589E cards. */
125 /* Time in jiffies before concluding Tx hung */
126 #define TX_TIMEOUT ((400*HZ)/1000)
129 struct pcmcia_device *p_dev;
130 /* For transceiver monitoring */
131 struct timer_list media;
134 unsigned long last_irq;
138 static const char *if_names[] = { "auto", "10baseT", "10base2", "AUI" };
140 /*====================================================================*/
142 /* Module parameters */
144 MODULE_AUTHOR("David Hinds <dahinds@users.sourceforge.net>");
145 MODULE_DESCRIPTION("3Com 3c589 series PCMCIA ethernet driver");
146 MODULE_LICENSE("GPL");
148 #define INT_MODULE_PARM(n, v) static int n = v; module_param(n, int, 0)
150 /* Special hook for setting if_port when module is loaded */
151 INT_MODULE_PARM(if_port, 0);
154 /*====================================================================*/
156 static int tc589_config(struct pcmcia_device *link);
157 static void tc589_release(struct pcmcia_device *link);
159 static u16 read_eeprom(unsigned int ioaddr, int index);
160 static void tc589_reset(struct net_device *dev);
161 static void media_check(unsigned long arg);
162 static int el3_config(struct net_device *dev, struct ifmap *map);
163 static int el3_open(struct net_device *dev);
164 static netdev_tx_t el3_start_xmit(struct sk_buff *skb,
165 struct net_device *dev);
166 static irqreturn_t el3_interrupt(int irq, void *dev_id);
167 static void update_stats(struct net_device *dev);
168 static struct net_device_stats *el3_get_stats(struct net_device *dev);
169 static int el3_rx(struct net_device *dev);
170 static int el3_close(struct net_device *dev);
171 static void el3_tx_timeout(struct net_device *dev);
172 static void set_rx_mode(struct net_device *dev);
173 static void set_multicast_list(struct net_device *dev);
174 static const struct ethtool_ops netdev_ethtool_ops;
176 static void tc589_detach(struct pcmcia_device *p_dev);
178 static const struct net_device_ops el3_netdev_ops = {
179 .ndo_open = el3_open,
180 .ndo_stop = el3_close,
181 .ndo_start_xmit = el3_start_xmit,
182 .ndo_tx_timeout = el3_tx_timeout,
183 .ndo_set_config = el3_config,
184 .ndo_get_stats = el3_get_stats,
185 .ndo_set_multicast_list = set_multicast_list,
186 .ndo_change_mtu = eth_change_mtu,
187 .ndo_set_mac_address = eth_mac_addr,
188 .ndo_validate_addr = eth_validate_addr,
191 static int tc589_probe(struct pcmcia_device *link)
193 struct el3_private *lp;
194 struct net_device *dev;
196 dev_dbg(&link->dev, "3c589_attach()\n");
198 /* Create new ethernet device */
199 dev = alloc_etherdev(sizeof(struct el3_private));
202 lp = netdev_priv(dev);
206 spin_lock_init(&lp->lock);
207 link->resource[0]->end = 16;
208 link->resource[0]->flags |= IO_DATA_PATH_WIDTH_16;
210 link->config_flags |= CONF_ENABLE_IRQ;
211 link->config_index = 1;
213 dev->netdev_ops = &el3_netdev_ops;
214 dev->watchdog_timeo = TX_TIMEOUT;
216 SET_ETHTOOL_OPS(dev, &netdev_ethtool_ops);
218 return tc589_config(link);
221 static void tc589_detach(struct pcmcia_device *link)
223 struct net_device *dev = link->priv;
225 dev_dbg(&link->dev, "3c589_detach\n");
227 unregister_netdev(dev);
234 static int tc589_config(struct pcmcia_device *link)
236 struct net_device *dev = link->priv;
238 int ret, i, j, multi = 0, fifo;
240 char *ram_split[] = {"5:3", "3:1", "1:1", "3:5"};
244 dev_dbg(&link->dev, "3c589_config\n");
246 phys_addr = (__be16 *)dev->dev_addr;
247 /* Is this a 3c562? */
248 if (link->manf_id != MANFID_3COM)
249 printk(KERN_INFO "3c589_cs: hmmm, is this really a "
251 multi = (link->card_id == PRODID_3COM_3C562);
255 /* For the 3c562, the base address must be xx00-xx7f */
256 for (i = j = 0; j < 0x400; j += 0x10) {
257 if (multi && (j & 0x80)) continue;
258 link->resource[0]->start = j ^ 0x300;
259 i = pcmcia_request_io(link);
266 ret = pcmcia_request_irq(link, el3_interrupt);
270 ret = pcmcia_enable_device(link);
274 dev->irq = link->irq;
275 dev->base_addr = link->resource[0]->start;
276 ioaddr = dev->base_addr;
279 /* The 3c589 has an extra EEPROM for configuration info, including
280 the hardware address. The 3c562 puts the address in the CIS. */
281 len = pcmcia_get_tuple(link, 0x88, &buf);
282 if (buf && len >= 6) {
283 for (i = 0; i < 3; i++)
284 phys_addr[i] = htons(le16_to_cpu(buf[i*2]));
287 kfree(buf); /* 0 < len < 6 */
288 for (i = 0; i < 3; i++)
289 phys_addr[i] = htons(read_eeprom(ioaddr, i));
290 if (phys_addr[0] == htons(0x6060)) {
291 printk(KERN_ERR "3c589_cs: IO port conflict at 0x%03lx"
292 "-0x%03lx\n", dev->base_addr, dev->base_addr+15);
297 /* The address and resource configuration register aren't loaded from
298 the EEPROM and *must* be set to 0 and IRQ3 for the PCMCIA version. */
299 outw(0x3f00, ioaddr + 8);
302 /* The if_port symbol can be set when the module is loaded */
303 if ((if_port >= 0) && (if_port <= 3))
304 dev->if_port = if_port;
306 printk(KERN_ERR "3c589_cs: invalid if_port requested\n");
308 SET_NETDEV_DEV(dev, &link->dev);
310 if (register_netdev(dev) != 0) {
311 printk(KERN_ERR "3c589_cs: register_netdev() failed\n");
315 netdev_info(dev, "3Com 3c%s, io %#3lx, irq %d, hw_addr %pM\n",
316 (multi ? "562" : "589"), dev->base_addr, dev->irq,
318 netdev_info(dev, " %dK FIFO split %s Rx:Tx, %s xcvr\n",
319 (fifo & 7) ? 32 : 8, ram_split[(fifo >> 16) & 3],
320 if_names[dev->if_port]);
328 static void tc589_release(struct pcmcia_device *link)
330 pcmcia_disable_device(link);
333 static int tc589_suspend(struct pcmcia_device *link)
335 struct net_device *dev = link->priv;
338 netif_device_detach(dev);
343 static int tc589_resume(struct pcmcia_device *link)
345 struct net_device *dev = link->priv;
349 netif_device_attach(dev);
355 /*====================================================================*/
358 Use this for commands that may take time to finish
360 static void tc589_wait_for_completion(struct net_device *dev, int cmd)
363 outw(cmd, dev->base_addr + EL3_CMD);
365 if (!(inw(dev->base_addr + EL3_STATUS) & 0x1000)) break;
367 netdev_warn(dev, "command 0x%04x did not complete!\n", cmd);
371 Read a word from the EEPROM using the regular EEPROM access register.
372 Assume that we are in register window zero.
374 static u16 read_eeprom(unsigned int ioaddr, int index)
377 outw(EEPROM_READ + index, ioaddr + 10);
378 /* Reading the eeprom takes 162 us */
379 for (i = 1620; i >= 0; i--)
380 if ((inw(ioaddr + 10) & EEPROM_BUSY) == 0)
382 return inw(ioaddr + 12);
386 Set transceiver type, perhaps to something other than what the user
387 specified in dev->if_port.
389 static void tc589_set_xcvr(struct net_device *dev, int if_port)
391 struct el3_private *lp = netdev_priv(dev);
392 unsigned int ioaddr = dev->base_addr;
396 case 0: case 1: outw(0, ioaddr + 6); break;
397 case 2: outw(3<<14, ioaddr + 6); break;
398 case 3: outw(1<<14, ioaddr + 6); break;
400 /* On PCMCIA, this just turns on the LED */
401 outw((if_port == 2) ? StartCoax : StopCoax, ioaddr + EL3_CMD);
402 /* 10baseT interface, enable link beat and jabber check. */
404 outw(MEDIA_LED | ((if_port < 2) ? MEDIA_TP : 0), ioaddr + WN4_MEDIA);
407 lp->media_status = ((dev->if_port == 0) ? 0x8000 : 0x4000);
409 lp->media_status = ((dev->if_port == 0) ? 0x4010 : 0x8800);
412 static void dump_status(struct net_device *dev)
414 unsigned int ioaddr = dev->base_addr;
416 netdev_info(dev, " irq status %04x, rx status %04x, tx status %02x tx free %04x\n",
417 inw(ioaddr+EL3_STATUS), inw(ioaddr+RX_STATUS),
418 inb(ioaddr+TX_STATUS), inw(ioaddr+TX_FREE));
420 netdev_info(dev, " diagnostics: fifo %04x net %04x ethernet %04x media %04x\n",
421 inw(ioaddr+0x04), inw(ioaddr+0x06), inw(ioaddr+0x08),
426 /* Reset and restore all of the 3c589 registers. */
427 static void tc589_reset(struct net_device *dev)
429 unsigned int ioaddr = dev->base_addr;
433 outw(0x0001, ioaddr + 4); /* Activate board. */
434 outw(0x3f00, ioaddr + 8); /* Set the IRQ line. */
436 /* Set the station address in window 2. */
438 for (i = 0; i < 6; i++)
439 outb(dev->dev_addr[i], ioaddr + i);
441 tc589_set_xcvr(dev, dev->if_port);
443 /* Switch to the stats window, and clear all stats by reading. */
444 outw(StatsDisable, ioaddr + EL3_CMD);
446 for (i = 0; i < 9; i++)
451 /* Switch to register set 1 for normal use. */
455 outw(StatsEnable, ioaddr + EL3_CMD); /* Turn on statistics. */
456 outw(RxEnable, ioaddr + EL3_CMD); /* Enable the receiver. */
457 outw(TxEnable, ioaddr + EL3_CMD); /* Enable transmitter. */
458 /* Allow status bits to be seen. */
459 outw(SetStatusEnb | 0xff, ioaddr + EL3_CMD);
460 /* Ack all pending events, and set active indicator mask. */
461 outw(AckIntr | IntLatch | TxAvailable | RxEarly | IntReq,
463 outw(SetIntrEnb | IntLatch | TxAvailable | RxComplete | StatsFull
464 | AdapterFailure, ioaddr + EL3_CMD);
467 static void netdev_get_drvinfo(struct net_device *dev,
468 struct ethtool_drvinfo *info)
470 strcpy(info->driver, DRV_NAME);
471 strcpy(info->version, DRV_VERSION);
472 sprintf(info->bus_info, "PCMCIA 0x%lx", dev->base_addr);
475 static const struct ethtool_ops netdev_ethtool_ops = {
476 .get_drvinfo = netdev_get_drvinfo,
479 static int el3_config(struct net_device *dev, struct ifmap *map)
481 if ((map->port != (u_char)(-1)) && (map->port != dev->if_port)) {
482 if (map->port <= 3) {
483 dev->if_port = map->port;
484 netdev_info(dev, "switched to %s port\n", if_names[dev->if_port]);
485 tc589_set_xcvr(dev, dev->if_port);
492 static int el3_open(struct net_device *dev)
494 struct el3_private *lp = netdev_priv(dev);
495 struct pcmcia_device *link = lp->p_dev;
497 if (!pcmcia_dev_present(link))
501 netif_start_queue(dev);
504 init_timer(&lp->media);
505 lp->media.function = &media_check;
506 lp->media.data = (unsigned long) dev;
507 lp->media.expires = jiffies + HZ;
508 add_timer(&lp->media);
510 dev_dbg(&link->dev, "%s: opened, status %4.4x.\n",
511 dev->name, inw(dev->base_addr + EL3_STATUS));
516 static void el3_tx_timeout(struct net_device *dev)
518 unsigned int ioaddr = dev->base_addr;
520 netdev_warn(dev, "Transmit timed out!\n");
522 dev->stats.tx_errors++;
523 dev->trans_start = jiffies; /* prevent tx timeout */
524 /* Issue TX_RESET and TX_START commands. */
525 tc589_wait_for_completion(dev, TxReset);
526 outw(TxEnable, ioaddr + EL3_CMD);
527 netif_wake_queue(dev);
530 static void pop_tx_status(struct net_device *dev)
532 unsigned int ioaddr = dev->base_addr;
535 /* Clear the Tx status stack. */
536 for (i = 32; i > 0; i--) {
537 u_char tx_status = inb(ioaddr + TX_STATUS);
538 if (!(tx_status & 0x84)) break;
539 /* reset transmitter on jabber error or underrun */
540 if (tx_status & 0x30)
541 tc589_wait_for_completion(dev, TxReset);
542 if (tx_status & 0x38) {
543 netdev_dbg(dev, "transmit error: status 0x%02x\n", tx_status);
544 outw(TxEnable, ioaddr + EL3_CMD);
545 dev->stats.tx_aborted_errors++;
547 outb(0x00, ioaddr + TX_STATUS); /* Pop the status stack. */
551 static netdev_tx_t el3_start_xmit(struct sk_buff *skb,
552 struct net_device *dev)
554 unsigned int ioaddr = dev->base_addr;
555 struct el3_private *priv = netdev_priv(dev);
558 netdev_dbg(dev, "el3_start_xmit(length = %ld) called, status %4.4x.\n",
559 (long)skb->len, inw(ioaddr + EL3_STATUS));
561 spin_lock_irqsave(&priv->lock, flags);
563 dev->stats.tx_bytes += skb->len;
565 /* Put out the doubleword header... */
566 outw(skb->len, ioaddr + TX_FIFO);
567 outw(0x00, ioaddr + TX_FIFO);
568 /* ... and the packet rounded to a doubleword. */
569 outsl(ioaddr + TX_FIFO, skb->data, (skb->len + 3) >> 2);
571 if (inw(ioaddr + TX_FREE) <= 1536) {
572 netif_stop_queue(dev);
573 /* Interrupt us when the FIFO has room for max-sized packet. */
574 outw(SetTxThreshold + 1536, ioaddr + EL3_CMD);
578 spin_unlock_irqrestore(&priv->lock, flags);
584 /* The EL3 interrupt handler. */
585 static irqreturn_t el3_interrupt(int irq, void *dev_id)
587 struct net_device *dev = (struct net_device *) dev_id;
588 struct el3_private *lp = netdev_priv(dev);
591 int i = 0, handled = 1;
593 if (!netif_device_present(dev))
596 ioaddr = dev->base_addr;
598 netdev_dbg(dev, "interrupt, status %4.4x.\n", inw(ioaddr + EL3_STATUS));
600 spin_lock(&lp->lock);
601 while ((status = inw(ioaddr + EL3_STATUS)) &
602 (IntLatch | RxComplete | StatsFull)) {
603 if ((status & 0xe000) != 0x2000) {
604 netdev_dbg(dev, "interrupt from dead card\n");
608 if (status & RxComplete)
610 if (status & TxAvailable) {
611 netdev_dbg(dev, " TX room bit was handled.\n");
612 /* There's room in the FIFO for a full-sized packet. */
613 outw(AckIntr | TxAvailable, ioaddr + EL3_CMD);
614 netif_wake_queue(dev);
616 if (status & TxComplete)
618 if (status & (AdapterFailure | RxEarly | StatsFull)) {
619 /* Handle all uncommon interrupts. */
620 if (status & StatsFull) /* Empty statistics. */
622 if (status & RxEarly) { /* Rx early is unused. */
624 outw(AckIntr | RxEarly, ioaddr + EL3_CMD);
626 if (status & AdapterFailure) {
629 fifo_diag = inw(ioaddr + 4);
631 netdev_warn(dev, "adapter failure, FIFO diagnostic register %04x.\n",
633 if (fifo_diag & 0x0400) {
635 tc589_wait_for_completion(dev, TxReset);
636 outw(TxEnable, ioaddr + EL3_CMD);
638 if (fifo_diag & 0x2000) {
640 tc589_wait_for_completion(dev, RxReset);
642 outw(RxEnable, ioaddr + EL3_CMD);
644 outw(AckIntr | AdapterFailure, ioaddr + EL3_CMD);
648 netdev_err(dev, "infinite loop in interrupt, status %4.4x.\n",
650 /* Clear all interrupts */
651 outw(AckIntr | 0xFF, ioaddr + EL3_CMD);
654 /* Acknowledge the IRQ. */
655 outw(AckIntr | IntReq | IntLatch, ioaddr + EL3_CMD);
657 lp->last_irq = jiffies;
658 spin_unlock(&lp->lock);
659 netdev_dbg(dev, "exiting interrupt, status %4.4x.\n",
660 inw(ioaddr + EL3_STATUS));
661 return IRQ_RETVAL(handled);
664 static void media_check(unsigned long arg)
666 struct net_device *dev = (struct net_device *)(arg);
667 struct el3_private *lp = netdev_priv(dev);
668 unsigned int ioaddr = dev->base_addr;
672 if (!netif_device_present(dev)) goto reschedule;
674 /* Check for pending interrupt with expired latency timer: with
675 this, we can limp along even if the interrupt is blocked */
676 if ((inw(ioaddr + EL3_STATUS) & IntLatch) &&
677 (inb(ioaddr + EL3_TIMER) == 0xff)) {
679 netdev_warn(dev, "interrupt(s) dropped!\n");
681 local_irq_save(flags);
682 el3_interrupt(dev->irq, dev);
683 local_irq_restore(flags);
689 lp->media.expires = jiffies + HZ/100;
690 add_timer(&lp->media);
694 /* lp->lock guards the EL3 window. Window should always be 1 except
695 when the lock is held */
696 spin_lock_irqsave(&lp->lock, flags);
698 media = inw(ioaddr+WN4_MEDIA) & 0xc810;
700 /* Ignore collisions unless we've had no irq's recently */
701 if (time_before(jiffies, lp->last_irq + HZ)) {
704 /* Try harder to detect carrier errors */
706 outw(StatsDisable, ioaddr + EL3_CMD);
707 errs = inb(ioaddr + 0);
708 outw(StatsEnable, ioaddr + EL3_CMD);
709 dev->stats.tx_carrier_errors += errs;
710 if (errs || (lp->media_status & 0x0010)) media |= 0x0010;
713 if (media != lp->media_status) {
714 if ((media & lp->media_status & 0x8000) &&
715 ((lp->media_status ^ media) & 0x0800))
716 netdev_info(dev, "%s link beat\n",
717 (lp->media_status & 0x0800 ? "lost" : "found"));
718 else if ((media & lp->media_status & 0x4000) &&
719 ((lp->media_status ^ media) & 0x0010))
720 netdev_info(dev, "coax cable %s\n",
721 (lp->media_status & 0x0010 ? "ok" : "problem"));
722 if (dev->if_port == 0) {
723 if (media & 0x8000) {
725 netdev_info(dev, "flipped to 10baseT\n");
727 tc589_set_xcvr(dev, 2);
728 } else if (media & 0x4000) {
730 tc589_set_xcvr(dev, 1);
732 netdev_info(dev, "flipped to 10base2\n");
735 lp->media_status = media;
739 spin_unlock_irqrestore(&lp->lock, flags);
742 lp->media.expires = jiffies + HZ;
743 add_timer(&lp->media);
746 static struct net_device_stats *el3_get_stats(struct net_device *dev)
748 struct el3_private *lp = netdev_priv(dev);
750 struct pcmcia_device *link = lp->p_dev;
752 if (pcmcia_dev_present(link)) {
753 spin_lock_irqsave(&lp->lock, flags);
755 spin_unlock_irqrestore(&lp->lock, flags);
761 Update statistics. We change to register window 6, so this should be run
762 single-threaded if the device is active. This is expected to be a rare
763 operation, and it's simpler for the rest of the driver to assume that
764 window 1 is always valid rather than use a special window-state variable.
766 Caller must hold the lock for this
768 static void update_stats(struct net_device *dev)
770 unsigned int ioaddr = dev->base_addr;
772 netdev_dbg(dev, "updating the statistics.\n");
773 /* Turn off statistics updates while reading. */
774 outw(StatsDisable, ioaddr + EL3_CMD);
775 /* Switch to the stats window, and read everything. */
777 dev->stats.tx_carrier_errors += inb(ioaddr + 0);
778 dev->stats.tx_heartbeat_errors += inb(ioaddr + 1);
779 /* Multiple collisions. */ inb(ioaddr + 2);
780 dev->stats.collisions += inb(ioaddr + 3);
781 dev->stats.tx_window_errors += inb(ioaddr + 4);
782 dev->stats.rx_fifo_errors += inb(ioaddr + 5);
783 dev->stats.tx_packets += inb(ioaddr + 6);
784 /* Rx packets */ inb(ioaddr + 7);
785 /* Tx deferrals */ inb(ioaddr + 8);
786 /* Rx octets */ inw(ioaddr + 10);
787 /* Tx octets */ inw(ioaddr + 12);
789 /* Back to window 1, and turn statistics back on. */
791 outw(StatsEnable, ioaddr + EL3_CMD);
794 static int el3_rx(struct net_device *dev)
796 unsigned int ioaddr = dev->base_addr;
800 netdev_dbg(dev, "in rx_packet(), status %4.4x, rx_status %4.4x.\n",
801 inw(ioaddr+EL3_STATUS), inw(ioaddr+RX_STATUS));
802 while (!((rx_status = inw(ioaddr + RX_STATUS)) & 0x8000) &&
805 if (rx_status & 0x4000) { /* Error, update stats. */
806 short error = rx_status & 0x3800;
807 dev->stats.rx_errors++;
809 case 0x0000: dev->stats.rx_over_errors++; break;
810 case 0x0800: dev->stats.rx_length_errors++; break;
811 case 0x1000: dev->stats.rx_frame_errors++; break;
812 case 0x1800: dev->stats.rx_length_errors++; break;
813 case 0x2000: dev->stats.rx_frame_errors++; break;
814 case 0x2800: dev->stats.rx_crc_errors++; break;
817 short pkt_len = rx_status & 0x7ff;
820 skb = dev_alloc_skb(pkt_len+5);
822 netdev_dbg(dev, " Receiving packet size %d status %4.4x.\n",
826 insl(ioaddr+RX_FIFO, skb_put(skb, pkt_len),
828 skb->protocol = eth_type_trans(skb, dev);
830 dev->stats.rx_packets++;
831 dev->stats.rx_bytes += pkt_len;
833 netdev_dbg(dev, "couldn't allocate a sk_buff of size %d.\n",
835 dev->stats.rx_dropped++;
838 /* Pop the top of the Rx FIFO */
839 tc589_wait_for_completion(dev, RxDiscard);
842 netdev_warn(dev, "too much work in el3_rx!\n");
846 static void set_rx_mode(struct net_device *dev)
848 unsigned int ioaddr = dev->base_addr;
849 u16 opts = SetRxFilter | RxStation | RxBroadcast;
851 if (dev->flags & IFF_PROMISC)
852 opts |= RxMulticast | RxProm;
853 else if (!netdev_mc_empty(dev) || (dev->flags & IFF_ALLMULTI))
855 outw(opts, ioaddr + EL3_CMD);
858 static void set_multicast_list(struct net_device *dev)
860 struct el3_private *priv = netdev_priv(dev);
863 spin_lock_irqsave(&priv->lock, flags);
865 spin_unlock_irqrestore(&priv->lock, flags);
868 static int el3_close(struct net_device *dev)
870 struct el3_private *lp = netdev_priv(dev);
871 struct pcmcia_device *link = lp->p_dev;
872 unsigned int ioaddr = dev->base_addr;
874 dev_dbg(&link->dev, "%s: shutting down ethercard.\n", dev->name);
876 if (pcmcia_dev_present(link)) {
877 /* Turn off statistics ASAP. We update dev->stats below. */
878 outw(StatsDisable, ioaddr + EL3_CMD);
880 /* Disable the receiver and transmitter. */
881 outw(RxDisable, ioaddr + EL3_CMD);
882 outw(TxDisable, ioaddr + EL3_CMD);
884 if (dev->if_port == 2)
885 /* Turn off thinnet power. Green! */
886 outw(StopCoax, ioaddr + EL3_CMD);
887 else if (dev->if_port == 1) {
888 /* Disable link beat and jabber */
890 outw(0, ioaddr + WN4_MEDIA);
893 /* Switching back to window 0 disables the IRQ. */
895 /* But we explicitly zero the IRQ line select anyway. */
896 outw(0x0f00, ioaddr + WN0_IRQ);
898 /* Check if the card still exists */
899 if ((inw(ioaddr+EL3_STATUS) & 0xe000) == 0x2000)
904 netif_stop_queue(dev);
905 del_timer_sync(&lp->media);
910 static struct pcmcia_device_id tc589_ids[] = {
911 PCMCIA_MFC_DEVICE_MANF_CARD(0, 0x0101, 0x0562),
912 PCMCIA_MFC_DEVICE_PROD_ID1(0, "Motorola MARQUIS", 0xf03e4e77),
913 PCMCIA_DEVICE_MANF_CARD(0x0101, 0x0589),
914 PCMCIA_DEVICE_PROD_ID12("Farallon", "ENet", 0x58d93fc4, 0x992c2202),
915 PCMCIA_MFC_DEVICE_CIS_MANF_CARD(0, 0x0101, 0x0035, "cis/3CXEM556.cis"),
916 PCMCIA_MFC_DEVICE_CIS_MANF_CARD(0, 0x0101, 0x003d, "cis/3CXEM556.cis"),
919 MODULE_DEVICE_TABLE(pcmcia, tc589_ids);
921 static struct pcmcia_driver tc589_driver = {
922 .owner = THIS_MODULE,
924 .probe = tc589_probe,
925 .remove = tc589_detach,
926 .id_table = tc589_ids,
927 .suspend = tc589_suspend,
928 .resume = tc589_resume,
931 static int __init init_tc589(void)
933 return pcmcia_register_driver(&tc589_driver);
936 static void __exit exit_tc589(void)
938 pcmcia_unregister_driver(&tc589_driver);
941 module_init(init_tc589);
942 module_exit(exit_tc589);