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