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