drivers/net/ethernet/3com/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
  54 /* To minimize the size of the driver source I only define operating
  55    constants if they are used several times.  You'll need the manual
  56    if you want to understand driver details. */
  57 /* Offsets from base I/O address. */
  58 #define EL3_DATA        0x00
  59 #define EL3_TIMER       0x0a
  60 #define EL3_CMD         0x0e
  61 #define EL3_STATUS      0x0e
  62
  63 #define EEPROM_READ     0x0080
  64 #define EEPROM_BUSY     0x8000
  65
  66 #define EL3WINDOW(win_num) outw(SelectWindow + (win_num), ioaddr + EL3_CMD)
  67
  68 /* The top five bits written to EL3_CMD are a command, the lower
  69    11 bits are the parameter, if applicable. */
  70 enum c509cmd {
  71         TotalReset      = 0<<11,
  72         SelectWindow    = 1<<11,
  73         StartCoax       = 2<<11,
  74         RxDisable       = 3<<11,
  75         RxEnable        = 4<<11,
  76         RxReset         = 5<<11,
  77         RxDiscard       = 8<<11,
  78         TxEnable        = 9<<11,
  79         TxDisable       = 10<<11,
  80         TxReset         = 11<<11,
  81         FakeIntr        = 12<<11,
  82         AckIntr         = 13<<11,
  83         SetIntrEnb      = 14<<11,
  84         SetStatusEnb    = 15<<11,
  85         SetRxFilter     = 16<<11,
  86         SetRxThreshold  = 17<<11,
  87         SetTxThreshold  = 18<<11,
  88         SetTxStart      = 19<<11,
  89         StatsEnable     = 21<<11,
  90         StatsDisable    = 22<<11,
  91         StopCoax        = 23<<11
  92 };
  93
  94 enum c509status {
  95         IntLatch        = 0x0001,
  96         AdapterFailure  = 0x0002,
  97         TxComplete      = 0x0004,
  98         TxAvailable     = 0x0008,
  99         RxComplete      = 0x0010,
 100         RxEarly         = 0x0020,
 101         IntReq          = 0x0040,
 102         StatsFull       = 0x0080,
 103         CmdBusy         = 0x1000
 104 };
 105
 106 /* The SetRxFilter command accepts the following classes: */
 107 enum RxFilter {
 108         RxStation       = 1,
 109         RxMulticast     = 2,
 110         RxBroadcast     = 4,
 111         RxProm          = 8
 112 };
 113
 114 /* Register window 1 offsets, the window used in normal operation. */
 115 #define TX_FIFO         0x00
 116 #define RX_FIFO         0x00
 117 #define RX_STATUS       0x08
 118 #define TX_STATUS       0x0B
 119 #define TX_FREE         0x0C    /* Remaining free bytes in Tx buffer. */
 120
 121 #define WN0_IRQ         0x08    /* Window 0: Set IRQ line in bits 12-15. */
 122 #define WN4_MEDIA       0x0A    /* Window 4: Various transcvr/media bits. */
 123 #define MEDIA_TP        0x00C0  /* Enable link beat and jabber for 10baseT. */
 124 #define MEDIA_LED       0x0001  /* Enable link light on 3C589E cards. */
 125
 126 /* Time in jiffies before concluding Tx hung */
 127 #define TX_TIMEOUT      ((400*HZ)/1000)
 128
 129 struct el3_private {
 130         struct pcmcia_device    *p_dev;
 131         /* For transceiver monitoring */
 132         struct timer_list       media;
 133         u16                     media_status;
 134         u16                     fast_poll;
 135         unsigned long           last_irq;
 136         spinlock_t              lock;
 137 };
 138
 139 static const char *if_names[] = { "auto", "10baseT", "10base2", "AUI" };
 140
 141 /*====================================================================*/
 142
 143 /* Module parameters */
 144
 145 MODULE_AUTHOR("David Hinds <dahinds@users.sourceforge.net>");
 146 MODULE_DESCRIPTION("3Com 3c589 series PCMCIA ethernet driver");
 147 MODULE_LICENSE("GPL");
 148
 149 #define INT_MODULE_PARM(n, v) static int n = v; module_param(n, int, 0)
 150
 151 /* Special hook for setting if_port when module is loaded */
 152 INT_MODULE_PARM(if_port, 0);
 153
 154
 155 /*====================================================================*/
 156
 157 static int tc589_config(struct pcmcia_device *link);
 158 static void tc589_release(struct pcmcia_device *link);
 159
 160 static u16 read_eeprom(unsigned int ioaddr, int index);
 161 static void tc589_reset(struct net_device *dev);
 162 static void media_check(unsigned long arg);
 163 static int el3_config(struct net_device *dev, struct ifmap *map);
 164 static int el3_open(struct net_device *dev);
 165 static netdev_tx_t el3_start_xmit(struct sk_buff *skb,
 166                                         struct net_device *dev);
 167 static irqreturn_t el3_interrupt(int irq, void *dev_id);
 168 static void update_stats(struct net_device *dev);
 169 static struct net_device_stats *el3_get_stats(struct net_device *dev);
 170 static int el3_rx(struct net_device *dev);
 171 static int el3_close(struct net_device *dev);
 172 static void el3_tx_timeout(struct net_device *dev);
 173 static void set_rx_mode(struct net_device *dev);
 174 static void set_multicast_list(struct net_device *dev);
 175 static const struct ethtool_ops netdev_ethtool_ops;
 176
 177 static void tc589_detach(struct pcmcia_device *p_dev);
 178
 179 static const struct net_device_ops el3_netdev_ops = {
 180         .ndo_open               = el3_open,
 181         .ndo_stop               = el3_close,
 182         .ndo_start_xmit         = el3_start_xmit,
 183         .ndo_tx_timeout         = el3_tx_timeout,
 184         .ndo_set_config         = el3_config,
 185         .ndo_get_stats          = el3_get_stats,
 186         .ndo_set_rx_mode        = set_multicast_list,
 187         .ndo_change_mtu         = eth_change_mtu,
 188         .ndo_set_mac_address    = eth_mac_addr,
 189         .ndo_validate_addr      = eth_validate_addr,
 190 };
 191
 192 static int tc589_probe(struct pcmcia_device *link)
 193 {
 194     struct el3_private *lp;
 195     struct net_device *dev;
 196
 197     dev_dbg(&link->dev, "3c589_attach()\n");
 198
 199     /* Create new ethernet device */
 200     dev = alloc_etherdev(sizeof(struct el3_private));
 201     if (!dev)
 202          return -ENOMEM;
 203     lp = netdev_priv(dev);
 204     link->priv = dev;
 205     lp->p_dev = link;
 206
 207     spin_lock_init(&lp->lock);
 208     link->resource[0]->end = 16;
 209     link->resource[0]->flags |= IO_DATA_PATH_WIDTH_16;
 210
 211     link->config_flags |= CONF_ENABLE_IRQ;
 212     link->config_index = 1;
 213
 214     dev->netdev_ops = &el3_netdev_ops;
 215     dev->watchdog_timeo = TX_TIMEOUT;
 216
 217     SET_ETHTOOL_OPS(dev, &netdev_ethtool_ops);
 218
 219     return tc589_config(link);
 220 }
 221
 222 static void tc589_detach(struct pcmcia_device *link)
 223 {
 224     struct net_device *dev = link->priv;
 225
 226     dev_dbg(&link->dev, "3c589_detach\n");
 227
 228     unregister_netdev(dev);
 229
 230     tc589_release(link);
 231
 232     free_netdev(dev);
 233 } /* tc589_detach */
 234
 235 static int tc589_config(struct pcmcia_device *link)
 236 {
 237     struct net_device *dev = link->priv;
 238     __be16 *phys_addr;
 239     int ret, i, j, multi = 0, fifo;
 240     unsigned int ioaddr;
 241     static const char * const ram_split[] = {"5:3", "3:1", "1:1", "3:5"};
 242     u8 *buf;
 243     size_t len;
 244
 245     dev_dbg(&link->dev, "3c589_config\n");
 246
 247     phys_addr = (__be16 *)dev->dev_addr;
 248     /* Is this a 3c562? */
 249     if (link->manf_id != MANFID_3COM)
 250             dev_info(&link->dev, "hmmm, is this really a 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             dev_err(&link->dev, "IO port conflict at 0x%03lx-0x%03lx\n",
 292                     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         dev_err(&link->dev, "invalid if_port requested\n");
 307
 308     SET_NETDEV_DEV(dev, &link->dev);
 309
 310     if (register_netdev(dev) != 0) {
 311             dev_err(&link->dev, "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         strlcpy(info->driver, DRV_NAME, sizeof(info->driver));
 471         strlcpy(info->version, DRV_VERSION, sizeof(info->version));
 472         snprintf(info->bus_info, sizeof(info->bus_info),
 473                 "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 = netdev_alloc_skb(dev, 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);