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