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