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