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