drivers/net/pcmcia/3c589_cs.c

   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/cistpl.h>
  45 #include <pcmcia/cisreg.h>
  46 #include <pcmcia/ciscode.h>
  47 #include <pcmcia/ds.h>
  48
  49 #include <asm/uaccess.h>
  50 #include <asm/io.h>
  51 #include <asm/system.h>
  52
  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. */
  57 #define EL3_DATA        0x00
  58 #define EL3_TIMER       0x0a
  59 #define EL3_CMD         0x0e
  60 #define EL3_STATUS      0x0e
  61
  62 #define EEPROM_READ     0x0080
  63 #define EEPROM_BUSY     0x8000
  64
  65 #define EL3WINDOW(win_num) outw(SelectWindow + (win_num), ioaddr + EL3_CMD)
  66
  67 /* The top five bits written to EL3_CMD are a command, the lower
  68    11 bits are the parameter, if applicable. */
  69 enum c509cmd {
  70         TotalReset      = 0<<11,
  71         SelectWindow    = 1<<11,
  72         StartCoax       = 2<<11,
  73         RxDisable       = 3<<11,
  74         RxEnable        = 4<<11,
  75         RxReset         = 5<<11,
  76         RxDiscard       = 8<<11,
  77         TxEnable        = 9<<11,
  78         TxDisable       = 10<<11,
  79         TxReset         = 11<<11,
  80         FakeIntr        = 12<<11,
  81         AckIntr         = 13<<11,
  82         SetIntrEnb      = 14<<11,
  83         SetStatusEnb    = 15<<11,
  84         SetRxFilter     = 16<<11,
  85         SetRxThreshold  = 17<<11,
  86         SetTxThreshold  = 18<<11,
  87         SetTxStart      = 19<<11,
  88         StatsEnable     = 21<<11,
  89         StatsDisable    = 22<<11,
  90         StopCoax        = 23<<11
  91 };
  92
  93 enum c509status {
  94         IntLatch        = 0x0001,
  95         AdapterFailure  = 0x0002,
  96         TxComplete      = 0x0004,
  97         TxAvailable     = 0x0008,
  98         RxComplete      = 0x0010,
  99         RxEarly         = 0x0020,
 100         IntReq          = 0x0040,
 101         StatsFull       = 0x0080,
 102         CmdBusy         = 0x1000
 103 };
 104
 105 /* The SetRxFilter command accepts the following classes: */
 106 enum RxFilter {
 107         RxStation       = 1,
 108         RxMulticast     = 2,
 109         RxBroadcast     = 4,
 110         RxProm          = 8
 111 };
 112
 113 /* Register window 1 offsets, the window used in normal operation. */
 114 #define TX_FIFO         0x00
 115 #define RX_FIFO         0x00
 116 #define RX_STATUS       0x08
 117 #define TX_STATUS       0x0B
 118 #define TX_FREE         0x0C    /* Remaining free bytes in Tx buffer. */
 119
 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. */
 124
 125 /* Time in jiffies before concluding Tx hung */
 126 #define TX_TIMEOUT      ((400*HZ)/1000)
 127
 128 struct el3_private {
 129         struct pcmcia_device    *p_dev;
 130         /* For transceiver monitoring */
 131         struct timer_list       media;
 132         u16                     media_status;
 133         u16                     fast_poll;
 134         unsigned long           last_irq;
 135         spinlock_t              lock;
 136 };
 137
 138 static const char *if_names[] = { "auto", "10baseT", "10base2", "AUI" };
 139
 140 /*====================================================================*/
 141
 142 /* Module parameters */
 143
 144 MODULE_AUTHOR("David Hinds <dahinds@users.sourceforge.net>");
 145 MODULE_DESCRIPTION("3Com 3c589 series PCMCIA ethernet driver");
 146 MODULE_LICENSE("GPL");
 147
 148 #define INT_MODULE_PARM(n, v) static int n = v; module_param(n, int, 0)
 149
 150 /* Special hook for setting if_port when module is loaded */
 151 INT_MODULE_PARM(if_port, 0);
 152
 153
 154 /*====================================================================*/
 155
 156 static int tc589_config(struct pcmcia_device *link);
 157 static void tc589_release(struct pcmcia_device *link);
 158
 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;
 175
 176 static void tc589_detach(struct pcmcia_device *p_dev);
 177
 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,
 189 };
 190
 191 static int tc589_probe(struct pcmcia_device *link)
 192 {
 193     struct el3_private *lp;
 194     struct net_device *dev;
 195
 196     dev_dbg(&link->dev, "3c589_attach()\n");
 197
 198     /* Create new ethernet device */
 199     dev = alloc_etherdev(sizeof(struct el3_private));
 200     if (!dev)
 201          return -ENOMEM;
 202     lp = netdev_priv(dev);
 203     link->priv = dev;
 204     lp->p_dev = link;
 205
 206     spin_lock_init(&lp->lock);
 207     link->resource[0]->end = 16;
 208     link->resource[0]->flags |= IO_DATA_PATH_WIDTH_16;
 209
 210     link->config_flags |= CONF_ENABLE_IRQ;
 211     link->config_index = 1;
 212
 213     dev->netdev_ops = &el3_netdev_ops;
 214     dev->watchdog_timeo = TX_TIMEOUT;
 215
 216     SET_ETHTOOL_OPS(dev, &netdev_ethtool_ops);
 217
 218     return tc589_config(link);
 219 }
 220
 221 static void tc589_detach(struct pcmcia_device *link)
 222 {
 223     struct net_device *dev = link->priv;
 224
 225     dev_dbg(&link->dev, "3c589_detach\n");
 226
 227     unregister_netdev(dev);
 228
 229     tc589_release(link);
 230
 231     free_netdev(dev);
 232 } /* tc589_detach */
 233
 234 static int tc589_config(struct pcmcia_device *link)
 235 {
 236     struct net_device *dev = link->priv;
 237     __be16 *phys_addr;
 238     int ret, i, j, multi = 0, fifo;
 239     unsigned int ioaddr;
 240     char *ram_split[] = {"5:3", "3:1", "1:1", "3:5"};
 241     u8 *buf;
 242     size_t len;
 243
 244     dev_dbg(&link->dev, "3c589_config\n");
 245
 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 "
 250                    "3Com card??\n");
 251     multi = (link->card_id == PRODID_3COM_3C562);
 252
 253     link->io_lines = 16;
 254
 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);
 260         if (i == 0)
 261                 break;
 262     }
 263     if (i != 0)
 264         goto failed;
 265
 266     ret = pcmcia_request_irq(link, el3_interrupt);
 267     if (ret)
 268             goto failed;
 269
 270     ret = pcmcia_enable_device(link);
 271     if (ret)
 272             goto failed;
 273
 274     dev->irq = link->irq;
 275     dev->base_addr = link->resource[0]->start;
 276     ioaddr = dev->base_addr;
 277     EL3WINDOW(0);
 278
 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]));
 285             kfree(buf);
 286     } else {
 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);
 293             goto failed;
 294         }
 295     }
 296
 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);
 300     fifo = inl(ioaddr);
 301
 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;
 305     else
 306         printk(KERN_ERR "3c589_cs: invalid if_port requested\n");
 307
 308     SET_NETDEV_DEV(dev, &link->dev);
 309
 310     if (register_netdev(dev) != 0) {
 311         printk(KERN_ERR "3c589_cs: register_netdev() failed\n");
 312         goto failed;
 313     }
 314
 315     netdev_info(dev, "3Com 3c%s, io %#3lx, irq %d, hw_addr %pM\n",
 316                 (multi ? "562" : "589"), dev->base_addr, dev->irq,
 317                 dev->dev_addr);
 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]);
 321     return 0;
 322
 323 failed:
 324     tc589_release(link);
 325     return -ENODEV;
 326 } /* tc589_config */
 327
 328 static void tc589_release(struct pcmcia_device *link)
 329 {
 330         pcmcia_disable_device(link);
 331 }
 332
 333 static int tc589_suspend(struct pcmcia_device *link)
 334 {
 335         struct net_device *dev = link->priv;
 336
 337         if (link->open)
 338                 netif_device_detach(dev);
 339
 340         return 0;
 341 }
 342
 343 static int tc589_resume(struct pcmcia_device *link)
 344 {
 345         struct net_device *dev = link->priv;
 346
 347         if (link->open) {
 348                 tc589_reset(dev);
 349                 netif_device_attach(dev);
 350         }
 351
 352         return 0;
 353 }
 354
 355 /*====================================================================*/
 356
 357 /*
 358   Use this for commands that may take time to finish
 359 */
 360 static void tc589_wait_for_completion(struct net_device *dev, int cmd)
 361 {
 362     int i = 100;
 363     outw(cmd, dev->base_addr + EL3_CMD);
 364     while (--i > 0)
 365         if (!(inw(dev->base_addr + EL3_STATUS) & 0x1000)) break;
 366     if (i == 0)
 367         netdev_warn(dev, "command 0x%04x did not complete!\n", cmd);
 368 }
 369
 370 /*
 371   Read a word from the EEPROM using the regular EEPROM access register.
 372   Assume that we are in register window zero.
 373 */
 374 static u16 read_eeprom(unsigned int ioaddr, int index)
 375 {
 376     int i;
 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)
 381             break;
 382     return inw(ioaddr + 12);
 383 }
 384
 385 /*
 386   Set transceiver type, perhaps to something other than what the user
 387   specified in dev->if_port.
 388 */
 389 static void tc589_set_xcvr(struct net_device *dev, int if_port)
 390 {
 391     struct el3_private *lp = netdev_priv(dev);
 392     unsigned int ioaddr = dev->base_addr;
 393
 394     EL3WINDOW(0);
 395     switch (if_port) {
 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;
 399     }
 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. */
 403     EL3WINDOW(4);
 404     outw(MEDIA_LED | ((if_port < 2) ? MEDIA_TP : 0), ioaddr + WN4_MEDIA);
 405     EL3WINDOW(1);
 406     if (if_port == 2)
 407         lp->media_status = ((dev->if_port == 0) ? 0x8000 : 0x4000);
 408     else
 409         lp->media_status = ((dev->if_port == 0) ? 0x4010 : 0x8800);
 410 }
 411
 412 static void dump_status(struct net_device *dev)
 413 {
 414     unsigned int ioaddr = dev->base_addr;
 415     EL3WINDOW(1);
 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));
 419     EL3WINDOW(4);
 420     netdev_info(dev, "  diagnostics: fifo %04x net %04x ethernet %04x media %04x\n",
 421                 inw(ioaddr+0x04), inw(ioaddr+0x06), inw(ioaddr+0x08),
 422                 inw(ioaddr+0x0a));
 423     EL3WINDOW(1);
 424 }
 425
 426 /* Reset and restore all of the 3c589 registers. */
 427 static void tc589_reset(struct net_device *dev)
 428 {
 429     unsigned int ioaddr = dev->base_addr;
 430     int i;
 431
 432     EL3WINDOW(0);
 433     outw(0x0001, ioaddr + 4);                   /* Activate board. */
 434     outw(0x3f00, ioaddr + 8);                   /* Set the IRQ line. */
 435
 436     /* Set the station address in window 2. */
 437     EL3WINDOW(2);
 438     for (i = 0; i < 6; i++)
 439         outb(dev->dev_addr[i], ioaddr + i);
 440
 441     tc589_set_xcvr(dev, dev->if_port);
 442
 443     /* Switch to the stats window, and clear all stats by reading. */
 444     outw(StatsDisable, ioaddr + EL3_CMD);
 445     EL3WINDOW(6);
 446     for (i = 0; i < 9; i++)
 447         inb(ioaddr+i);
 448     inw(ioaddr + 10);
 449     inw(ioaddr + 12);
 450
 451     /* Switch to register set 1 for normal use. */
 452     EL3WINDOW(1);
 453
 454     set_rx_mode(dev);
 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,
 462          ioaddr + EL3_CMD);
 463     outw(SetIntrEnb | IntLatch | TxAvailable | RxComplete | StatsFull
 464          | AdapterFailure, ioaddr + EL3_CMD);
 465 }
 466
 467 static void netdev_get_drvinfo(struct net_device *dev,
 468                                struct ethtool_drvinfo *info)
 469 {
 470         strcpy(info->driver, DRV_NAME);
 471         strcpy(info->version, DRV_VERSION);
 472         sprintf(info->bus_info, "PCMCIA 0x%lx", dev->base_addr);
 473 }
 474
 475 static const struct ethtool_ops netdev_ethtool_ops = {
 476         .get_drvinfo            = netdev_get_drvinfo,
 477 };
 478
 479 static int el3_config(struct net_device *dev, struct ifmap *map)
 480 {
 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);
 486         } else
 487             return -EINVAL;
 488     }
 489     return 0;
 490 }
 491
 492 static int el3_open(struct net_device *dev)
 493 {
 494     struct el3_private *lp = netdev_priv(dev);
 495     struct pcmcia_device *link = lp->p_dev;
 496
 497     if (!pcmcia_dev_present(link))
 498         return -ENODEV;
 499
 500     link->open++;
 501     netif_start_queue(dev);
 502
 503     tc589_reset(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);
 509
 510     dev_dbg(&link->dev, "%s: opened, status %4.4x.\n",
 511           dev->name, inw(dev->base_addr + EL3_STATUS));
 512
 513     return 0;
 514 }
 515
 516 static void el3_tx_timeout(struct net_device *dev)
 517 {
 518     unsigned int ioaddr = dev->base_addr;
 519
 520     netdev_warn(dev, "Transmit timed out!\n");
 521     dump_status(dev);
 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);
 528 }
 529
 530 static void pop_tx_status(struct net_device *dev)
 531 {
 532     unsigned int ioaddr = dev->base_addr;
 533     int i;
 534
 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++;
 546         }
 547         outb(0x00, ioaddr + TX_STATUS); /* Pop the status stack. */
 548     }
 549 }
 550
 551 static netdev_tx_t el3_start_xmit(struct sk_buff *skb,
 552                                         struct net_device *dev)
 553 {
 554     unsigned int ioaddr = dev->base_addr;
 555     struct el3_private *priv = netdev_priv(dev);
 556     unsigned long flags;
 557
 558     netdev_dbg(dev, "el3_start_xmit(length = %ld) called, status %4.4x.\n",
 559                (long)skb->len, inw(ioaddr + EL3_STATUS));
 560
 561     spin_lock_irqsave(&priv->lock, flags);
 562
 563     dev->stats.tx_bytes += skb->len;
 564
 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);
 570
 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);
 575     }
 576
 577     pop_tx_status(dev);
 578     spin_unlock_irqrestore(&priv->lock, flags);
 579     dev_kfree_skb(skb);
 580
 581     return NETDEV_TX_OK;
 582 }
 583
 584 /* The EL3 interrupt handler. */
 585 static irqreturn_t el3_interrupt(int irq, void *dev_id)
 586 {
 587     struct net_device *dev = (struct net_device *) dev_id;
 588     struct el3_private *lp = netdev_priv(dev);
 589     unsigned int ioaddr;
 590     __u16 status;
 591     int i = 0, handled = 1;
 592
 593     if (!netif_device_present(dev))
 594         return IRQ_NONE;
 595
 596     ioaddr = dev->base_addr;
 597
 598     netdev_dbg(dev, "interrupt, status %4.4x.\n", inw(ioaddr + EL3_STATUS));
 599
 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");
 605                 handled = 0;
 606                 break;
 607         }
 608         if (status & RxComplete)
 609                 el3_rx(dev);
 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);
 615         }
 616         if (status & TxComplete)
 617                 pop_tx_status(dev);
 618         if (status & (AdapterFailure | RxEarly | StatsFull)) {
 619             /* Handle all uncommon interrupts. */
 620             if (status & StatsFull)             /* Empty statistics. */
 621                 update_stats(dev);
 622             if (status & RxEarly) {             /* Rx early is unused. */
 623                 el3_rx(dev);
 624                 outw(AckIntr | RxEarly, ioaddr + EL3_CMD);
 625             }
 626             if (status & AdapterFailure) {
 627                 u16 fifo_diag;
 628                 EL3WINDOW(4);
 629                 fifo_diag = inw(ioaddr + 4);
 630                 EL3WINDOW(1);
 631                 netdev_warn(dev, "adapter failure, FIFO diagnostic register %04x.\n",
 632                             fifo_diag);
 633                 if (fifo_diag & 0x0400) {
 634                     /* Tx overrun */
 635                     tc589_wait_for_completion(dev, TxReset);
 636                     outw(TxEnable, ioaddr + EL3_CMD);
 637                 }
 638                 if (fifo_diag & 0x2000) {
 639                     /* Rx underrun */
 640                     tc589_wait_for_completion(dev, RxReset);
 641                     set_rx_mode(dev);
 642                     outw(RxEnable, ioaddr + EL3_CMD);
 643                 }
 644                 outw(AckIntr | AdapterFailure, ioaddr + EL3_CMD);
 645             }
 646         }
 647         if (++i > 10) {
 648                 netdev_err(dev, "infinite loop in interrupt, status %4.4x.\n",
 649                            status);
 650                 /* Clear all interrupts */
 651                 outw(AckIntr | 0xFF, ioaddr + EL3_CMD);
 652                 break;
 653         }
 654         /* Acknowledge the IRQ. */
 655         outw(AckIntr | IntReq | IntLatch, ioaddr + EL3_CMD);
 656     }
 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);
 662 }
 663
 664 static void media_check(unsigned long arg)
 665 {
 666     struct net_device *dev = (struct net_device *)(arg);
 667     struct el3_private *lp = netdev_priv(dev);
 668     unsigned int ioaddr = dev->base_addr;
 669     u16 media, errs;
 670     unsigned long flags;
 671
 672     if (!netif_device_present(dev)) goto reschedule;
 673
 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)) {
 678         if (!lp->fast_poll)
 679                 netdev_warn(dev, "interrupt(s) dropped!\n");
 680
 681         local_irq_save(flags);
 682         el3_interrupt(dev->irq, dev);
 683         local_irq_restore(flags);
 684
 685         lp->fast_poll = HZ;
 686     }
 687     if (lp->fast_poll) {
 688         lp->fast_poll--;
 689         lp->media.expires = jiffies + HZ/100;
 690         add_timer(&lp->media);
 691         return;
 692     }
 693
 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);
 697     EL3WINDOW(4);
 698     media = inw(ioaddr+WN4_MEDIA) & 0xc810;
 699
 700     /* Ignore collisions unless we've had no irq's recently */
 701     if (time_before(jiffies, lp->last_irq + HZ)) {
 702         media &= ~0x0010;
 703     } else {
 704         /* Try harder to detect carrier errors */
 705         EL3WINDOW(6);
 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;
 711     }
 712
 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) {
 724                 if (media & 0x0800)
 725                         netdev_info(dev, "flipped to 10baseT\n");
 726                 else
 727                         tc589_set_xcvr(dev, 2);
 728             } else if (media & 0x4000) {
 729                 if (media & 0x0010)
 730                     tc589_set_xcvr(dev, 1);
 731                 else
 732                     netdev_info(dev, "flipped to 10base2\n");
 733             }
 734         }
 735         lp->media_status = media;
 736     }
 737
 738     EL3WINDOW(1);
 739     spin_unlock_irqrestore(&lp->lock, flags);
 740
 741 reschedule:
 742     lp->media.expires = jiffies + HZ;
 743     add_timer(&lp->media);
 744 }
 745
 746 static struct net_device_stats *el3_get_stats(struct net_device *dev)
 747 {
 748     struct el3_private *lp = netdev_priv(dev);
 749     unsigned long flags;
 750     struct pcmcia_device *link = lp->p_dev;
 751
 752     if (pcmcia_dev_present(link)) {
 753         spin_lock_irqsave(&lp->lock, flags);
 754         update_stats(dev);
 755         spin_unlock_irqrestore(&lp->lock, flags);
 756     }
 757     return &dev->stats;
 758 }
 759
 760 /*
 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.
 765
 766   Caller must hold the lock for this
 767 */
 768 static void update_stats(struct net_device *dev)
 769 {
 770     unsigned int ioaddr = dev->base_addr;
 771
 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. */
 776     EL3WINDOW(6);
 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);
 788
 789     /* Back to window 1, and turn statistics back on. */
 790     EL3WINDOW(1);
 791     outw(StatsEnable, ioaddr + EL3_CMD);
 792 }
 793
 794 static int el3_rx(struct net_device *dev)
 795 {
 796     unsigned int ioaddr = dev->base_addr;
 797     int worklimit = 32;
 798     short rx_status;
 799
 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) &&
 803                     worklimit > 0) {
 804         worklimit--;
 805         if (rx_status & 0x4000) { /* Error, update stats. */
 806             short error = rx_status & 0x3800;
 807             dev->stats.rx_errors++;
 808             switch (error) {
 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;
 815             }
 816         } else {
 817             short pkt_len = rx_status & 0x7ff;
 818             struct sk_buff *skb;
 819
 820             skb = dev_alloc_skb(pkt_len+5);
 821
 822             netdev_dbg(dev, "    Receiving packet size %d status %4.4x.\n",
 823                        pkt_len, rx_status);
 824             if (skb != NULL) {
 825                 skb_reserve(skb, 2);
 826                 insl(ioaddr+RX_FIFO, skb_put(skb, pkt_len),
 827                         (pkt_len+3)>>2);
 828                 skb->protocol = eth_type_trans(skb, dev);
 829                 netif_rx(skb);
 830                 dev->stats.rx_packets++;
 831                 dev->stats.rx_bytes += pkt_len;
 832             } else {
 833                 netdev_dbg(dev, "couldn't allocate a sk_buff of size %d.\n",
 834                            pkt_len);
 835                 dev->stats.rx_dropped++;
 836             }
 837         }
 838         /* Pop the top of the Rx FIFO */
 839         tc589_wait_for_completion(dev, RxDiscard);
 840     }
 841     if (worklimit == 0)
 842         netdev_warn(dev, "too much work in el3_rx!\n");
 843     return 0;
 844 }
 845
 846 static void set_rx_mode(struct net_device *dev)
 847 {
 848     unsigned int ioaddr = dev->base_addr;
 849     u16 opts = SetRxFilter | RxStation | RxBroadcast;
 850
 851     if (dev->flags & IFF_PROMISC)
 852         opts |= RxMulticast | RxProm;
 853     else if (!netdev_mc_empty(dev) || (dev->flags & IFF_ALLMULTI))
 854         opts |= RxMulticast;
 855     outw(opts, ioaddr + EL3_CMD);
 856 }
 857
 858 static void set_multicast_list(struct net_device *dev)
 859 {
 860         struct el3_private *priv = netdev_priv(dev);
 861         unsigned long flags;
 862
 863         spin_lock_irqsave(&priv->lock, flags);
 864         set_rx_mode(dev);
 865         spin_unlock_irqrestore(&priv->lock, flags);
 866 }
 867
 868 static int el3_close(struct net_device *dev)
 869 {
 870     struct el3_private *lp = netdev_priv(dev);
 871     struct pcmcia_device *link = lp->p_dev;
 872     unsigned int ioaddr = dev->base_addr;
 873
 874     dev_dbg(&link->dev, "%s: shutting down ethercard.\n", dev->name);
 875
 876     if (pcmcia_dev_present(link)) {
 877         /* Turn off statistics ASAP.  We update dev->stats below. */
 878         outw(StatsDisable, ioaddr + EL3_CMD);
 879
 880         /* Disable the receiver and transmitter. */
 881         outw(RxDisable, ioaddr + EL3_CMD);
 882         outw(TxDisable, ioaddr + EL3_CMD);
 883
 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 */
 889             EL3WINDOW(4);
 890             outw(0, ioaddr + WN4_MEDIA);
 891         }
 892
 893         /* Switching back to window 0 disables the IRQ. */
 894         EL3WINDOW(0);
 895         /* But we explicitly zero the IRQ line select anyway. */
 896         outw(0x0f00, ioaddr + WN0_IRQ);
 897
 898         /* Check if the card still exists */
 899         if ((inw(ioaddr+EL3_STATUS) & 0xe000) == 0x2000)
 900             update_stats(dev);
 901     }
 902
 903     link->open--;
 904     netif_stop_queue(dev);
 905     del_timer_sync(&lp->media);
 906
 907     return 0;
 908 }
 909
 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"),
 917         PCMCIA_DEVICE_NULL,
 918 };
 919 MODULE_DEVICE_TABLE(pcmcia, tc589_ids);
 920
 921 static struct pcmcia_driver tc589_driver = {
 922         .owner          = THIS_MODULE,
 923         .name           = "3c589_cs",
 924         .probe          = tc589_probe,
 925         .remove         = tc589_detach,
 926         .id_table       = tc589_ids,
 927         .suspend        = tc589_suspend,
 928         .resume         = tc589_resume,
 929 };
 930
 931 static int __init init_tc589(void)
 932 {
 933         return pcmcia_register_driver(&tc589_driver);
 934 }
 935
 936 static void __exit exit_tc589(void)
 937 {
 938         pcmcia_unregister_driver(&tc589_driver);
 939 }
 940
 941 module_init(init_tc589);
 942 module_exit(exit_tc589);