Pileus Git - ~andy/linux/blob - 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 #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_rx_mode        = 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         strlcpy(info->driver, DRV_NAME, sizeof(info->driver));
 472         strlcpy(info->version, DRV_VERSION, sizeof(info->version));
 473         snprintf(info->bus_info, sizeof(info->bus_info),
 474                 "PCMCIA 0x%lx", dev->base_addr);
 475 }
 476
 477 static const struct ethtool_ops netdev_ethtool_ops = {
 478         .get_drvinfo            = netdev_get_drvinfo,
 479 };
 480
 481 static int el3_config(struct net_device *dev, struct ifmap *map)
 482 {
 483     if ((map->port != (u_char)(-1)) && (map->port != dev->if_port)) {
 484         if (map->port <= 3) {
 485             dev->if_port = map->port;
 486             netdev_info(dev, "switched to %s port\n", if_names[dev->if_port]);
 487             tc589_set_xcvr(dev, dev->if_port);
 488         } else
 489             return -EINVAL;
 490     }
 491     return 0;
 492 }
 493
 494 static int el3_open(struct net_device *dev)
 495 {
 496     struct el3_private *lp = netdev_priv(dev);
 497     struct pcmcia_device *link = lp->p_dev;
 498
 499     if (!pcmcia_dev_present(link))
 500         return -ENODEV;
 501
 502     link->open++;
 503     netif_start_queue(dev);
 504
 505     tc589_reset(dev);
 506     init_timer(&lp->media);
 507     lp->media.function = media_check;
 508     lp->media.data = (unsigned long) dev;
 509     lp->media.expires = jiffies + HZ;
 510     add_timer(&lp->media);
 511
 512     dev_dbg(&link->dev, "%s: opened, status %4.4x.\n",
 513           dev->name, inw(dev->base_addr + EL3_STATUS));
 514
 515     return 0;
 516 }
 517
 518 static void el3_tx_timeout(struct net_device *dev)
 519 {
 520     unsigned int ioaddr = dev->base_addr;
 521
 522     netdev_warn(dev, "Transmit timed out!\n");
 523     dump_status(dev);
 524     dev->stats.tx_errors++;
 525     dev->trans_start = jiffies; /* prevent tx timeout */
 526     /* Issue TX_RESET and TX_START commands. */
 527     tc589_wait_for_completion(dev, TxReset);
 528     outw(TxEnable, ioaddr + EL3_CMD);
 529     netif_wake_queue(dev);
 530 }
 531
 532 static void pop_tx_status(struct net_device *dev)
 533 {
 534     unsigned int ioaddr = dev->base_addr;
 535     int i;
 536
 537     /* Clear the Tx status stack. */
 538     for (i = 32; i > 0; i--) {
 539         u_char tx_status = inb(ioaddr + TX_STATUS);
 540         if (!(tx_status & 0x84)) break;
 541         /* reset transmitter on jabber error or underrun */
 542         if (tx_status & 0x30)
 543                 tc589_wait_for_completion(dev, TxReset);
 544         if (tx_status & 0x38) {
 545                 netdev_dbg(dev, "transmit error: status 0x%02x\n", tx_status);
 546                 outw(TxEnable, ioaddr + EL3_CMD);
 547                 dev->stats.tx_aborted_errors++;
 548         }
 549         outb(0x00, ioaddr + TX_STATUS); /* Pop the status stack. */
 550     }
 551 }
 552
 553 static netdev_tx_t el3_start_xmit(struct sk_buff *skb,
 554                                         struct net_device *dev)
 555 {
 556     unsigned int ioaddr = dev->base_addr;
 557     struct el3_private *priv = netdev_priv(dev);
 558     unsigned long flags;
 559
 560     netdev_dbg(dev, "el3_start_xmit(length = %ld) called, status %4.4x.\n",
 561                (long)skb->len, inw(ioaddr + EL3_STATUS));
 562
 563     spin_lock_irqsave(&priv->lock, flags);
 564
 565     dev->stats.tx_bytes += skb->len;
 566
 567     /* Put out the doubleword header... */
 568     outw(skb->len, ioaddr + TX_FIFO);
 569     outw(0x00, ioaddr + TX_FIFO);
 570     /* ... and the packet rounded to a doubleword. */
 571     outsl(ioaddr + TX_FIFO, skb->data, (skb->len + 3) >> 2);
 572
 573     if (inw(ioaddr + TX_FREE) <= 1536) {
 574         netif_stop_queue(dev);
 575         /* Interrupt us when the FIFO has room for max-sized packet. */
 576         outw(SetTxThreshold + 1536, ioaddr + EL3_CMD);
 577     }
 578
 579     pop_tx_status(dev);
 580     spin_unlock_irqrestore(&priv->lock, flags);
 581     dev_kfree_skb(skb);
 582
 583     return NETDEV_TX_OK;
 584 }
 585
 586 /* The EL3 interrupt handler. */
 587 static irqreturn_t el3_interrupt(int irq, void *dev_id)
 588 {
 589     struct net_device *dev = (struct net_device *) dev_id;
 590     struct el3_private *lp = netdev_priv(dev);
 591     unsigned int ioaddr;
 592     __u16 status;
 593     int i = 0, handled = 1;
 594
 595     if (!netif_device_present(dev))
 596         return IRQ_NONE;
 597
 598     ioaddr = dev->base_addr;
 599
 600     netdev_dbg(dev, "interrupt, status %4.4x.\n", inw(ioaddr + EL3_STATUS));
 601
 602     spin_lock(&lp->lock);
 603     while ((status = inw(ioaddr + EL3_STATUS)) &
 604         (IntLatch | RxComplete | StatsFull)) {
 605         if ((status & 0xe000) != 0x2000) {
 606                 netdev_dbg(dev, "interrupt from dead card\n");
 607                 handled = 0;
 608                 break;
 609         }
 610         if (status & RxComplete)
 611                 el3_rx(dev);
 612         if (status & TxAvailable) {
 613                 netdev_dbg(dev, "    TX room bit was handled.\n");
 614                 /* There's room in the FIFO for a full-sized packet. */
 615                 outw(AckIntr | TxAvailable, ioaddr + EL3_CMD);
 616                 netif_wake_queue(dev);
 617         }
 618         if (status & TxComplete)
 619                 pop_tx_status(dev);
 620         if (status & (AdapterFailure | RxEarly | StatsFull)) {
 621             /* Handle all uncommon interrupts. */
 622             if (status & StatsFull)             /* Empty statistics. */
 623                 update_stats(dev);
 624             if (status & RxEarly) {             /* Rx early is unused. */
 625                 el3_rx(dev);
 626                 outw(AckIntr | RxEarly, ioaddr + EL3_CMD);
 627             }
 628             if (status & AdapterFailure) {
 629                 u16 fifo_diag;
 630                 EL3WINDOW(4);
 631                 fifo_diag = inw(ioaddr + 4);
 632                 EL3WINDOW(1);
 633                 netdev_warn(dev, "adapter failure, FIFO diagnostic register %04x.\n",
 634                             fifo_diag);
 635                 if (fifo_diag & 0x0400) {
 636                     /* Tx overrun */
 637                     tc589_wait_for_completion(dev, TxReset);
 638                     outw(TxEnable, ioaddr + EL3_CMD);
 639                 }
 640                 if (fifo_diag & 0x2000) {
 641                     /* Rx underrun */
 642                     tc589_wait_for_completion(dev, RxReset);
 643                     set_rx_mode(dev);
 644                     outw(RxEnable, ioaddr + EL3_CMD);
 645                 }
 646                 outw(AckIntr | AdapterFailure, ioaddr + EL3_CMD);
 647             }
 648         }
 649         if (++i > 10) {
 650                 netdev_err(dev, "infinite loop in interrupt, status %4.4x.\n",
 651                            status);
 652                 /* Clear all interrupts */
 653                 outw(AckIntr | 0xFF, ioaddr + EL3_CMD);
 654                 break;
 655         }
 656         /* Acknowledge the IRQ. */
 657         outw(AckIntr | IntReq | IntLatch, ioaddr + EL3_CMD);
 658     }
 659     lp->last_irq = jiffies;
 660     spin_unlock(&lp->lock);
 661     netdev_dbg(dev, "exiting interrupt, status %4.4x.\n",
 662                inw(ioaddr + EL3_STATUS));
 663     return IRQ_RETVAL(handled);
 664 }
 665
 666 static void media_check(unsigned long arg)
 667 {
 668     struct net_device *dev = (struct net_device *)(arg);
 669     struct el3_private *lp = netdev_priv(dev);
 670     unsigned int ioaddr = dev->base_addr;
 671     u16 media, errs;
 672     unsigned long flags;
 673
 674     if (!netif_device_present(dev)) goto reschedule;
 675
 676     /* Check for pending interrupt with expired latency timer: with
 677        this, we can limp along even if the interrupt is blocked */
 678     if ((inw(ioaddr + EL3_STATUS) & IntLatch) &&
 679         (inb(ioaddr + EL3_TIMER) == 0xff)) {
 680         if (!lp->fast_poll)
 681                 netdev_warn(dev, "interrupt(s) dropped!\n");
 682
 683         local_irq_save(flags);
 684         el3_interrupt(dev->irq, dev);
 685         local_irq_restore(flags);
 686
 687         lp->fast_poll = HZ;
 688     }
 689     if (lp->fast_poll) {
 690         lp->fast_poll--;
 691         lp->media.expires = jiffies + HZ/100;
 692         add_timer(&lp->media);
 693         return;
 694     }
 695
 696     /* lp->lock guards the EL3 window. Window should always be 1 except
 697        when the lock is held */
 698     spin_lock_irqsave(&lp->lock, flags);
 699     EL3WINDOW(4);
 700     media = inw(ioaddr+WN4_MEDIA) & 0xc810;
 701
 702     /* Ignore collisions unless we've had no irq's recently */
 703     if (time_before(jiffies, lp->last_irq + HZ)) {
 704         media &= ~0x0010;
 705     } else {
 706         /* Try harder to detect carrier errors */
 707         EL3WINDOW(6);
 708         outw(StatsDisable, ioaddr + EL3_CMD);
 709         errs = inb(ioaddr + 0);
 710         outw(StatsEnable, ioaddr + EL3_CMD);
 711         dev->stats.tx_carrier_errors += errs;
 712         if (errs || (lp->media_status & 0x0010)) media |= 0x0010;
 713     }
 714
 715     if (media != lp->media_status) {
 716         if ((media & lp->media_status & 0x8000) &&
 717             ((lp->media_status ^ media) & 0x0800))
 718                 netdev_info(dev, "%s link beat\n",
 719                             (lp->media_status & 0x0800 ? "lost" : "found"));
 720         else if ((media & lp->media_status & 0x4000) &&
 721                  ((lp->media_status ^ media) & 0x0010))
 722                 netdev_info(dev, "coax cable %s\n",
 723                             (lp->media_status & 0x0010 ? "ok" : "problem"));
 724         if (dev->if_port == 0) {
 725             if (media & 0x8000) {
 726                 if (media & 0x0800)
 727                         netdev_info(dev, "flipped to 10baseT\n");
 728                 else
 729                         tc589_set_xcvr(dev, 2);
 730             } else if (media & 0x4000) {
 731                 if (media & 0x0010)
 732                     tc589_set_xcvr(dev, 1);
 733                 else
 734                     netdev_info(dev, "flipped to 10base2\n");
 735             }
 736         }
 737         lp->media_status = media;
 738     }
 739
 740     EL3WINDOW(1);
 741     spin_unlock_irqrestore(&lp->lock, flags);
 742
 743 reschedule:
 744     lp->media.expires = jiffies + HZ;
 745     add_timer(&lp->media);
 746 }
 747
 748 static struct net_device_stats *el3_get_stats(struct net_device *dev)
 749 {
 750     struct el3_private *lp = netdev_priv(dev);
 751     unsigned long flags;
 752     struct pcmcia_device *link = lp->p_dev;
 753
 754     if (pcmcia_dev_present(link)) {
 755         spin_lock_irqsave(&lp->lock, flags);
 756         update_stats(dev);
 757         spin_unlock_irqrestore(&lp->lock, flags);
 758     }
 759     return &dev->stats;
 760 }
 761
 762 /*
 763   Update statistics.  We change to register window 6, so this should be run
 764   single-threaded if the device is active. This is expected to be a rare
 765   operation, and it's simpler for the rest of the driver to assume that
 766   window 1 is always valid rather than use a special window-state variable.
 767
 768   Caller must hold the lock for this
 769 */
 770 static void update_stats(struct net_device *dev)
 771 {
 772     unsigned int ioaddr = dev->base_addr;
 773
 774     netdev_dbg(dev, "updating the statistics.\n");
 775     /* Turn off statistics updates while reading. */
 776     outw(StatsDisable, ioaddr + EL3_CMD);
 777     /* Switch to the stats window, and read everything. */
 778     EL3WINDOW(6);
 779     dev->stats.tx_carrier_errors        += inb(ioaddr + 0);
 780     dev->stats.tx_heartbeat_errors      += inb(ioaddr + 1);
 781     /* Multiple collisions. */          inb(ioaddr + 2);
 782     dev->stats.collisions               += inb(ioaddr + 3);
 783     dev->stats.tx_window_errors         += inb(ioaddr + 4);
 784     dev->stats.rx_fifo_errors           += inb(ioaddr + 5);
 785     dev->stats.tx_packets               += inb(ioaddr + 6);
 786     /* Rx packets   */                  inb(ioaddr + 7);
 787     /* Tx deferrals */                  inb(ioaddr + 8);
 788     /* Rx octets */                     inw(ioaddr + 10);
 789     /* Tx octets */                     inw(ioaddr + 12);
 790
 791     /* Back to window 1, and turn statistics back on. */
 792     EL3WINDOW(1);
 793     outw(StatsEnable, ioaddr + EL3_CMD);
 794 }
 795
 796 static int el3_rx(struct net_device *dev)
 797 {
 798     unsigned int ioaddr = dev->base_addr;
 799     int worklimit = 32;
 800     short rx_status;
 801
 802     netdev_dbg(dev, "in rx_packet(), status %4.4x, rx_status %4.4x.\n",
 803                inw(ioaddr+EL3_STATUS), inw(ioaddr+RX_STATUS));
 804     while (!((rx_status = inw(ioaddr + RX_STATUS)) & 0x8000) &&
 805                     worklimit > 0) {
 806         worklimit--;
 807         if (rx_status & 0x4000) { /* Error, update stats. */
 808             short error = rx_status & 0x3800;
 809             dev->stats.rx_errors++;
 810             switch (error) {
 811             case 0x0000:        dev->stats.rx_over_errors++; break;
 812             case 0x0800:        dev->stats.rx_length_errors++; break;
 813             case 0x1000:        dev->stats.rx_frame_errors++; break;
 814             case 0x1800:        dev->stats.rx_length_errors++; break;
 815             case 0x2000:        dev->stats.rx_frame_errors++; break;
 816             case 0x2800:        dev->stats.rx_crc_errors++; break;
 817             }
 818         } else {
 819             short pkt_len = rx_status & 0x7ff;
 820             struct sk_buff *skb;
 821
 822             skb = netdev_alloc_skb(dev, pkt_len + 5);
 823
 824             netdev_dbg(dev, "    Receiving packet size %d status %4.4x.\n",
 825                        pkt_len, rx_status);
 826             if (skb != NULL) {
 827                 skb_reserve(skb, 2);
 828                 insl(ioaddr+RX_FIFO, skb_put(skb, pkt_len),
 829                         (pkt_len+3)>>2);
 830                 skb->protocol = eth_type_trans(skb, dev);
 831                 netif_rx(skb);
 832                 dev->stats.rx_packets++;
 833                 dev->stats.rx_bytes += pkt_len;
 834             } else {
 835                 netdev_dbg(dev, "couldn't allocate a sk_buff of size %d.\n",
 836                            pkt_len);
 837                 dev->stats.rx_dropped++;
 838             }
 839         }
 840         /* Pop the top of the Rx FIFO */
 841         tc589_wait_for_completion(dev, RxDiscard);
 842     }
 843     if (worklimit == 0)
 844         netdev_warn(dev, "too much work in el3_rx!\n");
 845     return 0;
 846 }
 847
 848 static void set_rx_mode(struct net_device *dev)
 849 {
 850     unsigned int ioaddr = dev->base_addr;
 851     u16 opts = SetRxFilter | RxStation | RxBroadcast;
 852
 853     if (dev->flags & IFF_PROMISC)
 854         opts |= RxMulticast | RxProm;
 855     else if (!netdev_mc_empty(dev) || (dev->flags & IFF_ALLMULTI))
 856         opts |= RxMulticast;
 857     outw(opts, ioaddr + EL3_CMD);
 858 }
 859
 860 static void set_multicast_list(struct net_device *dev)
 861 {
 862         struct el3_private *priv = netdev_priv(dev);
 863         unsigned long flags;
 864
 865         spin_lock_irqsave(&priv->lock, flags);
 866         set_rx_mode(dev);
 867         spin_unlock_irqrestore(&priv->lock, flags);
 868 }
 869
 870 static int el3_close(struct net_device *dev)
 871 {
 872     struct el3_private *lp = netdev_priv(dev);
 873     struct pcmcia_device *link = lp->p_dev;
 874     unsigned int ioaddr = dev->base_addr;
 875
 876     dev_dbg(&link->dev, "%s: shutting down ethercard.\n", dev->name);
 877
 878     if (pcmcia_dev_present(link)) {
 879         /* Turn off statistics ASAP.  We update dev->stats below. */
 880         outw(StatsDisable, ioaddr + EL3_CMD);
 881
 882         /* Disable the receiver and transmitter. */
 883         outw(RxDisable, ioaddr + EL3_CMD);
 884         outw(TxDisable, ioaddr + EL3_CMD);
 885
 886         if (dev->if_port == 2)
 887             /* Turn off thinnet power.  Green! */
 888             outw(StopCoax, ioaddr + EL3_CMD);
 889         else if (dev->if_port == 1) {
 890             /* Disable link beat and jabber */
 891             EL3WINDOW(4);
 892             outw(0, ioaddr + WN4_MEDIA);
 893         }
 894
 895         /* Switching back to window 0 disables the IRQ. */
 896         EL3WINDOW(0);
 897         /* But we explicitly zero the IRQ line select anyway. */
 898         outw(0x0f00, ioaddr + WN0_IRQ);
 899
 900         /* Check if the card still exists */
 901         if ((inw(ioaddr+EL3_STATUS) & 0xe000) == 0x2000)
 902             update_stats(dev);
 903     }
 904
 905     link->open--;
 906     netif_stop_queue(dev);
 907     del_timer_sync(&lp->media);
 908
 909     return 0;
 910 }
 911
 912 static const struct pcmcia_device_id tc589_ids[] = {
 913         PCMCIA_MFC_DEVICE_MANF_CARD(0, 0x0101, 0x0562),
 914         PCMCIA_MFC_DEVICE_PROD_ID1(0, "Motorola MARQUIS", 0xf03e4e77),
 915         PCMCIA_DEVICE_MANF_CARD(0x0101, 0x0589),
 916         PCMCIA_DEVICE_PROD_ID12("Farallon", "ENet", 0x58d93fc4, 0x992c2202),
 917         PCMCIA_MFC_DEVICE_CIS_MANF_CARD(0, 0x0101, 0x0035, "cis/3CXEM556.cis"),
 918         PCMCIA_MFC_DEVICE_CIS_MANF_CARD(0, 0x0101, 0x003d, "cis/3CXEM556.cis"),
 919         PCMCIA_DEVICE_NULL,
 920 };
 921 MODULE_DEVICE_TABLE(pcmcia, tc589_ids);
 922
 923 static struct pcmcia_driver tc589_driver = {
 924         .owner          = THIS_MODULE,
 925         .name           = "3c589_cs",
 926         .probe          = tc589_probe,
 927         .remove         = tc589_detach,
 928         .id_table       = tc589_ids,
 929         .suspend        = tc589_suspend,
 930         .resume         = tc589_resume,
 931 };
 932
 933 static int __init init_tc589(void)
 934 {
 935         return pcmcia_register_driver(&tc589_driver);
 936 }
 937
 938 static void __exit exit_tc589(void)
 939 {
 940         pcmcia_unregister_driver(&tc589_driver);
 941 }
 942
 943 module_init(init_tc589);
 944 module_exit(exit_tc589);