drivers/net/pcmcia/3c589_cs.c

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