SAFE public projects git trees. - safe/jmp/linux-2.6/blob - drivers/net/pcmcia/3c589_cs.c

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