git.oblomov.eu Git - linux-2.6/blob - drivers/net/pcmcia/3c574_cs.c

   1 /* 3c574.c: A PCMCIA ethernet driver for the 3com 3c574 "RoadRunner".
   2
   3         Written 1993-1998 by
   4         Donald Becker, becker@scyld.com, (driver core) and
   5         David Hinds, dahinds@users.sourceforge.net (from his PC card code).
   6         Locking fixes (C) Copyright 2003 Red Hat Inc
   7
   8         This software may be used and distributed according to the terms of
   9         the GNU General Public License, incorporated herein by reference.
  10
  11         This driver derives from Donald Becker's 3c509 core, which has the
  12         following copyright:
  13         Copyright 1993 United States Government as represented by the
  14         Director, National Security Agency.
  15
  16
  17 */
  18
  19 /*
  20                                 Theory of Operation
  21
  22 I. Board Compatibility
  23
  24 This device driver is designed for the 3Com 3c574 PC card Fast Ethernet
  25 Adapter.
  26
  27 II. Board-specific settings
  28
  29 None -- PC cards are autoconfigured.
  30
  31 III. Driver operation
  32
  33 The 3c574 uses a Boomerang-style interface, without the bus-master capability.
  34 See the Boomerang driver and documentation for most details.
  35
  36 IV. Notes and chip documentation.
  37
  38 Two added registers are used to enhance PIO performance, RunnerRdCtrl and
  39 RunnerWrCtrl.  These are 11 bit down-counters that are preloaded with the
  40 count of word (16 bits) reads or writes the driver is about to do to the Rx
  41 or Tx FIFO.  The chip is then able to hide the internal-PCI-bus to PC-card
  42 translation latency by buffering the I/O operations with an 8 word FIFO.
  43 Note: No other chip accesses are permitted when this buffer is used.
  44
  45 A second enhancement is that both attribute and common memory space
  46 0x0800-0x0fff can translated to the PIO FIFO.  Thus memory operations (faster
  47 with *some* PCcard bridges) may be used instead of I/O operations.
  48 This is enabled by setting the 0x10 bit in the PCMCIA LAN COR.
  49
  50 Some slow PC card bridges work better if they never see a WAIT signal.
  51 This is configured by setting the 0x20 bit in the PCMCIA LAN COR.
  52 Only do this after testing that it is reliable and improves performance.
  53
  54 The upper five bits of RunnerRdCtrl are used to window into PCcard
  55 configuration space registers.  Window 0 is the regular Boomerang/Odie
  56 register set, 1-5 are various PC card control registers, and 16-31 are
  57 the (reversed!) CIS table.
  58
  59 A final note: writing the InternalConfig register in window 3 with an
  60 invalid ramWidth is Very Bad.
  61
  62 V. References
  63
  64 http://www.scyld.com/expert/NWay.html
  65 http://www.national.com/pf/DP/DP83840.html
  66
  67 Thanks to Terry Murphy of 3Com for providing development information for
  68 earlier 3Com products.
  69
  70 */
  71
  72 #include <linux/module.h>
  73 #include <linux/kernel.h>
  74 #include <linux/init.h>
  75 #include <linux/slab.h>
  76 #include <linux/string.h>
  77 #include <linux/timer.h>
  78 #include <linux/interrupt.h>
  79 #include <linux/in.h>
  80 #include <linux/delay.h>
  81 #include <linux/netdevice.h>
  82 #include <linux/etherdevice.h>
  83 #include <linux/skbuff.h>
  84 #include <linux/if_arp.h>
  85 #include <linux/ioport.h>
  86 #include <linux/ethtool.h>
  87 #include <linux/bitops.h>
  88
  89 #include <pcmcia/cs_types.h>
  90 #include <pcmcia/cs.h>
  91 #include <pcmcia/cistpl.h>
  92 #include <pcmcia/cisreg.h>
  93 #include <pcmcia/ciscode.h>
  94 #include <pcmcia/ds.h>
  95 #include <pcmcia/mem_op.h>
  96
  97 #include <asm/uaccess.h>
  98 #include <asm/io.h>
  99 #include <asm/system.h>
 100
 101 /*====================================================================*/
 102
 103 /* Module parameters */
 104
 105 MODULE_AUTHOR("David Hinds <dahinds@users.sourceforge.net>");
 106 MODULE_DESCRIPTION("3Com 3c574 series PCMCIA ethernet driver");
 107 MODULE_LICENSE("GPL");
 108
 109 #define INT_MODULE_PARM(n, v) static int n = v; module_param(n, int, 0)
 110
 111 /* Maximum events (Rx packets, etc.) to handle at each interrupt. */
 112 INT_MODULE_PARM(max_interrupt_work, 32);
 113
 114 /* Force full duplex modes? */
 115 INT_MODULE_PARM(full_duplex, 0);
 116
 117 /* Autodetect link polarity reversal? */
 118 INT_MODULE_PARM(auto_polarity, 1);
 119
 120 #ifdef PCMCIA_DEBUG
 121 INT_MODULE_PARM(pc_debug, PCMCIA_DEBUG);
 122 #define DEBUG(n, args...) if (pc_debug>(n)) printk(KERN_DEBUG args)
 123 static char *version =
 124 "3c574_cs.c 1.65ac1 2003/04/07 Donald Becker/David Hinds, becker@scyld.com.\n";
 125 #else
 126 #define DEBUG(n, args...)
 127 #endif
 128
 129 /*====================================================================*/
 130
 131 /* Time in jiffies before concluding the transmitter is hung. */
 132 #define TX_TIMEOUT  ((800*HZ)/1000)
 133
 134 /* To minimize the size of the driver source and make the driver more
 135    readable not all constants are symbolically defined.
 136    You'll need the manual if you want to understand driver details anyway. */
 137 /* Offsets from base I/O address. */
 138 #define EL3_DATA        0x00
 139 #define EL3_CMD         0x0e
 140 #define EL3_STATUS      0x0e
 141
 142 #define EL3WINDOW(win_num) outw(SelectWindow + (win_num), ioaddr + EL3_CMD)
 143
 144 /* The top five bits written to EL3_CMD are a command, the lower
 145    11 bits are the parameter, if applicable. */
 146 enum el3_cmds {
 147         TotalReset = 0<<11, SelectWindow = 1<<11, StartCoax = 2<<11,
 148         RxDisable = 3<<11, RxEnable = 4<<11, RxReset = 5<<11, RxDiscard = 8<<11,
 149         TxEnable = 9<<11, TxDisable = 10<<11, TxReset = 11<<11,
 150         FakeIntr = 12<<11, AckIntr = 13<<11, SetIntrEnb = 14<<11,
 151         SetStatusEnb = 15<<11, SetRxFilter = 16<<11, SetRxThreshold = 17<<11,
 152         SetTxThreshold = 18<<11, SetTxStart = 19<<11, StatsEnable = 21<<11,
 153         StatsDisable = 22<<11, StopCoax = 23<<11,
 154 };
 155
 156 enum elxl_status {
 157         IntLatch = 0x0001, AdapterFailure = 0x0002, TxComplete = 0x0004,
 158         TxAvailable = 0x0008, RxComplete = 0x0010, RxEarly = 0x0020,
 159         IntReq = 0x0040, StatsFull = 0x0080, CmdBusy = 0x1000 };
 160
 161 /* The SetRxFilter command accepts the following classes: */
 162 enum RxFilter {
 163         RxStation = 1, RxMulticast = 2, RxBroadcast = 4, RxProm = 8
 164 };
 165
 166 enum Window0 {
 167         Wn0EepromCmd = 10, Wn0EepromData = 12, /* EEPROM command/address, data. */
 168         IntrStatus=0x0E,                /* Valid in all windows. */
 169 };
 170 /* These assumes the larger EEPROM. */
 171 enum Win0_EEPROM_cmds {
 172         EEPROM_Read = 0x200, EEPROM_WRITE = 0x100, EEPROM_ERASE = 0x300,
 173         EEPROM_EWENB = 0x30,            /* Enable erasing/writing for 10 msec. */
 174         EEPROM_EWDIS = 0x00,            /* Disable EWENB before 10 msec timeout. */
 175 };
 176
 177 /* Register window 1 offsets, the window used in normal operation.
 178    On the "Odie" this window is always mapped at offsets 0x10-0x1f.
 179    Except for TxFree, which is overlapped by RunnerWrCtrl. */
 180 enum Window1 {
 181         TX_FIFO = 0x10,  RX_FIFO = 0x10,  RxErrors = 0x14,
 182         RxStatus = 0x18,  Timer=0x1A, TxStatus = 0x1B,
 183         TxFree = 0x0C, /* Remaining free bytes in Tx buffer. */
 184         RunnerRdCtrl = 0x16, RunnerWrCtrl = 0x1c,
 185 };
 186
 187 enum Window3 {                  /* Window 3: MAC/config bits. */
 188         Wn3_Config=0, Wn3_MAC_Ctrl=6, Wn3_Options=8,
 189 };
 190 union wn3_config {
 191         int i;
 192         struct w3_config_fields {
 193                 unsigned int ram_size:3, ram_width:1, ram_speed:2, rom_size:2;
 194                 int pad8:8;
 195                 unsigned int ram_split:2, pad18:2, xcvr:3, pad21:1, autoselect:1;
 196                 int pad24:7;
 197         } u;
 198 };
 199
 200 enum Window4 {          /* Window 4: Xcvr/media bits. */
 201         Wn4_FIFODiag = 4, Wn4_NetDiag = 6, Wn4_PhysicalMgmt=8, Wn4_Media = 10,
 202 };
 203
 204 #define MEDIA_TP        0x00C0  /* Enable link beat and jabber for 10baseT. */
 205
 206 struct el3_private {
 207         dev_link_t link;
 208         dev_node_t node;
 209         struct net_device_stats stats;
 210         u16 advertising, partner;               /* NWay media advertisement */
 211         unsigned char phys;                     /* MII device address */
 212         unsigned int autoselect:1, default_media:3;     /* Read from the EEPROM/Wn3_Config. */
 213         /* for transceiver monitoring */
 214         struct timer_list media;
 215         unsigned short media_status;
 216         unsigned short fast_poll;
 217         unsigned long last_irq;
 218         spinlock_t window_lock;                 /* Guards the Window selection */
 219 };
 220
 221 /* Set iff a MII transceiver on any interface requires mdio preamble.
 222    This only set with the original DP83840 on older 3c905 boards, so the extra
 223    code size of a per-interface flag is not worthwhile. */
 224 static char mii_preamble_required = 0;
 225
 226 /* Index of functions. */
 227
 228 static void tc574_config(dev_link_t *link);
 229 static void tc574_release(dev_link_t *link);
 230 static int tc574_event(event_t event, int priority,
 231                                            event_callback_args_t *args);
 232
 233 static void mdio_sync(kio_addr_t ioaddr, int bits);
 234 static int mdio_read(kio_addr_t ioaddr, int phy_id, int location);
 235 static void mdio_write(kio_addr_t ioaddr, int phy_id, int location, int value);
 236 static unsigned short read_eeprom(kio_addr_t ioaddr, int index);
 237 static void tc574_wait_for_completion(struct net_device *dev, int cmd);
 238
 239 static void tc574_reset(struct net_device *dev);
 240 static void media_check(unsigned long arg);
 241 static int el3_open(struct net_device *dev);
 242 static int el3_start_xmit(struct sk_buff *skb, struct net_device *dev);
 243 static irqreturn_t el3_interrupt(int irq, void *dev_id, struct pt_regs *regs);
 244 static void update_stats(struct net_device *dev);
 245 static struct net_device_stats *el3_get_stats(struct net_device *dev);
 246 static int el3_rx(struct net_device *dev, int worklimit);
 247 static int el3_close(struct net_device *dev);
 248 static void el3_tx_timeout(struct net_device *dev);
 249 static int el3_ioctl(struct net_device *dev, struct ifreq *rq, int cmd);
 250 static struct ethtool_ops netdev_ethtool_ops;
 251 static void set_rx_mode(struct net_device *dev);
 252
 253 static dev_info_t dev_info = "3c574_cs";
 254
 255 static dev_link_t *tc574_attach(void);
 256 static void tc574_detach(struct pcmcia_device *p_dev);
 257
 258 /*
 259         tc574_attach() creates an "instance" of the driver, allocating
 260         local data structures for one device.  The device is registered
 261         with Card Services.
 262 */
 263
 264 static dev_link_t *tc574_attach(void)
 265 {
 266         struct el3_private *lp;
 267         client_reg_t client_reg;
 268         dev_link_t *link;
 269         struct net_device *dev;
 270         int ret;
 271
 272         DEBUG(0, "3c574_attach()\n");
 273
 274         /* Create the PC card device object. */
 275         dev = alloc_etherdev(sizeof(struct el3_private));
 276         if (!dev)
 277                 return NULL;
 278         lp = netdev_priv(dev);
 279         link = &lp->link;
 280         link->priv = dev;
 281
 282         spin_lock_init(&lp->window_lock);
 283         link->io.NumPorts1 = 32;
 284         link->io.Attributes1 = IO_DATA_PATH_WIDTH_16;
 285         link->irq.Attributes = IRQ_TYPE_EXCLUSIVE | IRQ_HANDLE_PRESENT;
 286         link->irq.IRQInfo1 = IRQ_LEVEL_ID;
 287         link->irq.Handler = &el3_interrupt;
 288         link->irq.Instance = dev;
 289         link->conf.Attributes = CONF_ENABLE_IRQ;
 290         link->conf.Vcc = 50;
 291         link->conf.IntType = INT_MEMORY_AND_IO;
 292         link->conf.ConfigIndex = 1;
 293         link->conf.Present = PRESENT_OPTION;
 294
 295         /* The EL3-specific entries in the device structure. */
 296         dev->hard_start_xmit = &el3_start_xmit;
 297         dev->get_stats = &el3_get_stats;
 298         dev->do_ioctl = &el3_ioctl;
 299         SET_ETHTOOL_OPS(dev, &netdev_ethtool_ops);
 300         dev->set_multicast_list = &set_rx_mode;
 301         dev->open = &el3_open;
 302         dev->stop = &el3_close;
 303 #ifdef HAVE_TX_TIMEOUT
 304         dev->tx_timeout = el3_tx_timeout;
 305         dev->watchdog_timeo = TX_TIMEOUT;
 306 #endif
 307
 308         /* Register with Card Services */
 309         link->next = NULL;
 310         client_reg.dev_info = &dev_info;
 311         client_reg.Version = 0x0210;
 312         client_reg.event_callback_args.client_data = link;
 313         ret = pcmcia_register_client(&link->handle, &client_reg);
 314         if (ret != 0) {
 315                 cs_error(link->handle, RegisterClient, ret);
 316                 tc574_detach(link->handle);
 317                 return NULL;
 318         }
 319
 320         return link;
 321 } /* tc574_attach */
 322
 323 /*
 324
 325         This deletes a driver "instance".  The device is de-registered
 326         with Card Services.  If it has been released, all local data
 327         structures are freed.  Otherwise, the structures will be freed
 328         when the device is released.
 329
 330 */
 331
 332 static void tc574_detach(struct pcmcia_device *p_dev)
 333 {
 334         dev_link_t *link = dev_to_instance(p_dev);
 335         struct net_device *dev = link->priv;
 336
 337         DEBUG(0, "3c574_detach(0x%p)\n", link);
 338
 339         if (link->dev)
 340                 unregister_netdev(dev);
 341
 342         if (link->state & DEV_CONFIG)
 343                 tc574_release(link);
 344
 345         free_netdev(dev);
 346 } /* tc574_detach */
 347
 348 /*
 349         tc574_config() is scheduled to run after a CARD_INSERTION event
 350         is received, to configure the PCMCIA socket, and to make the
 351         ethernet device available to the system.
 352 */
 353
 354 #define CS_CHECK(fn, ret) \
 355   do { last_fn = (fn); if ((last_ret = (ret)) != 0) goto cs_failed; } while (0)
 356
 357 static char *ram_split[] = {"5:3", "3:1", "1:1", "3:5"};
 358
 359 static void tc574_config(dev_link_t *link)
 360 {
 361         client_handle_t handle = link->handle;
 362         struct net_device *dev = link->priv;
 363         struct el3_private *lp = netdev_priv(dev);
 364         tuple_t tuple;
 365         cisparse_t parse;
 366         unsigned short buf[32];
 367         int last_fn, last_ret, i, j;
 368         kio_addr_t ioaddr;
 369         u16 *phys_addr;
 370         char *cardname;
 371         union wn3_config config;
 372
 373         phys_addr = (u16 *)dev->dev_addr;
 374
 375         DEBUG(0, "3c574_config(0x%p)\n", link);
 376
 377         tuple.Attributes = 0;
 378         tuple.DesiredTuple = CISTPL_CONFIG;
 379         CS_CHECK(GetFirstTuple, pcmcia_get_first_tuple(handle, &tuple));
 380         tuple.TupleData = (cisdata_t *)buf;
 381         tuple.TupleDataMax = 64;
 382         tuple.TupleOffset = 0;
 383         CS_CHECK(GetTupleData, pcmcia_get_tuple_data(handle, &tuple));
 384         CS_CHECK(ParseTuple, pcmcia_parse_tuple(handle, &tuple, &parse));
 385         link->conf.ConfigBase = parse.config.base;
 386         link->conf.Present = parse.config.rmask[0];
 387
 388         /* Configure card */
 389         link->state |= DEV_CONFIG;
 390
 391         link->io.IOAddrLines = 16;
 392         for (i = j = 0; j < 0x400; j += 0x20) {
 393                 link->io.BasePort1 = j ^ 0x300;
 394                 i = pcmcia_request_io(link->handle, &link->io);
 395                 if (i == CS_SUCCESS) break;
 396         }
 397         if (i != CS_SUCCESS) {
 398                 cs_error(link->handle, RequestIO, i);
 399                 goto failed;
 400         }
 401         CS_CHECK(RequestIRQ, pcmcia_request_irq(link->handle, &link->irq));
 402         CS_CHECK(RequestConfiguration, pcmcia_request_configuration(link->handle, &link->conf));
 403
 404         dev->irq = link->irq.AssignedIRQ;
 405         dev->base_addr = link->io.BasePort1;
 406
 407         ioaddr = dev->base_addr;
 408
 409         /* The 3c574 normally uses an EEPROM for configuration info, including
 410            the hardware address.  The future products may include a modem chip
 411            and put the address in the CIS. */
 412         tuple.DesiredTuple = 0x88;
 413         if (pcmcia_get_first_tuple(handle, &tuple) == CS_SUCCESS) {
 414                 pcmcia_get_tuple_data(handle, &tuple);
 415                 for (i = 0; i < 3; i++)
 416                         phys_addr[i] = htons(buf[i]);
 417         } else {
 418                 EL3WINDOW(0);
 419                 for (i = 0; i < 3; i++)
 420                         phys_addr[i] = htons(read_eeprom(ioaddr, i + 10));
 421                 if (phys_addr[0] == 0x6060) {
 422                         printk(KERN_NOTICE "3c574_cs: IO port conflict at 0x%03lx"
 423                                    "-0x%03lx\n", dev->base_addr, dev->base_addr+15);
 424                         goto failed;
 425                 }
 426         }
 427         tuple.DesiredTuple = CISTPL_VERS_1;
 428         if (pcmcia_get_first_tuple(handle, &tuple) == CS_SUCCESS &&
 429                 pcmcia_get_tuple_data(handle, &tuple) == CS_SUCCESS &&
 430                 pcmcia_parse_tuple(handle, &tuple, &parse) == CS_SUCCESS) {
 431                 cardname = parse.version_1.str + parse.version_1.ofs[1];
 432         } else
 433                 cardname = "3Com 3c574";
 434
 435         {
 436                 u_char mcr;
 437                 outw(2<<11, ioaddr + RunnerRdCtrl);
 438                 mcr = inb(ioaddr + 2);
 439                 outw(0<<11, ioaddr + RunnerRdCtrl);
 440                 printk(KERN_INFO "  ASIC rev %d,", mcr>>3);
 441                 EL3WINDOW(3);
 442                 config.i = inl(ioaddr + Wn3_Config);
 443                 lp->default_media = config.u.xcvr;
 444                 lp->autoselect = config.u.autoselect;
 445         }
 446
 447         init_timer(&lp->media);
 448
 449         {
 450                 int phy;
 451
 452                 /* Roadrunner only: Turn on the MII transceiver */
 453                 outw(0x8040, ioaddr + Wn3_Options);
 454                 mdelay(1);
 455                 outw(0xc040, ioaddr + Wn3_Options);
 456                 tc574_wait_for_completion(dev, TxReset);
 457                 tc574_wait_for_completion(dev, RxReset);
 458                 mdelay(1);
 459                 outw(0x8040, ioaddr + Wn3_Options);
 460
 461                 EL3WINDOW(4);
 462                 for (phy = 1; phy <= 32; phy++) {
 463                         int mii_status;
 464                         mdio_sync(ioaddr, 32);
 465                         mii_status = mdio_read(ioaddr, phy & 0x1f, 1);
 466                         if (mii_status != 0xffff) {
 467                                 lp->phys = phy & 0x1f;
 468                                 DEBUG(0, "  MII transceiver at index %d, status %x.\n",
 469                                           phy, mii_status);
 470                                 if ((mii_status & 0x0040) == 0)
 471                                         mii_preamble_required = 1;
 472                                 break;
 473                         }
 474                 }
 475                 if (phy > 32) {
 476                         printk(KERN_NOTICE "  No MII transceivers found!\n");
 477                         goto failed;
 478                 }
 479                 i = mdio_read(ioaddr, lp->phys, 16) | 0x40;
 480                 mdio_write(ioaddr, lp->phys, 16, i);
 481                 lp->advertising = mdio_read(ioaddr, lp->phys, 4);
 482                 if (full_duplex) {
 483                         /* Only advertise the FD media types. */
 484                         lp->advertising &= ~0x02a0;
 485                         mdio_write(ioaddr, lp->phys, 4, lp->advertising);
 486                 }
 487         }
 488
 489         link->state &= ~DEV_CONFIG_PENDING;
 490         link->dev = &lp->node;
 491         SET_NETDEV_DEV(dev, &handle_to_dev(handle));
 492
 493         if (register_netdev(dev) != 0) {
 494                 printk(KERN_NOTICE "3c574_cs: register_netdev() failed\n");
 495                 link->dev = NULL;
 496                 goto failed;
 497         }
 498
 499         strcpy(lp->node.dev_name, dev->name);
 500
 501         printk(KERN_INFO "%s: %s at io %#3lx, irq %d, hw_addr ",
 502                    dev->name, cardname, dev->base_addr, dev->irq);
 503         for (i = 0; i < 6; i++)
 504                 printk("%02X%s", dev->dev_addr[i], ((i<5) ? ":" : ".\n"));
 505         printk(" %dK FIFO split %s Rx:Tx, %sMII interface.\n",
 506                    8 << config.u.ram_size, ram_split[config.u.ram_split],
 507                    config.u.autoselect ? "autoselect " : "");
 508
 509         return;
 510
 511 cs_failed:
 512         cs_error(link->handle, last_fn, last_ret);
 513 failed:
 514         tc574_release(link);
 515         return;
 516
 517 } /* tc574_config */
 518
 519 /*
 520         After a card is removed, tc574_release() will unregister the net
 521         device, and release the PCMCIA configuration.  If the device is
 522         still open, this will be postponed until it is closed.
 523 */
 524
 525 static void tc574_release(dev_link_t *link)
 526 {
 527         DEBUG(0, "3c574_release(0x%p)\n", link);
 528
 529         pcmcia_release_configuration(link->handle);
 530         pcmcia_release_io(link->handle, &link->io);
 531         pcmcia_release_irq(link->handle, &link->irq);
 532
 533         link->state &= ~DEV_CONFIG;
 534 }
 535
 536 static int tc574_suspend(struct pcmcia_device *p_dev)
 537 {
 538         dev_link_t *link = dev_to_instance(p_dev);
 539         struct net_device *dev = link->priv;
 540
 541         link->state |= DEV_SUSPEND;
 542         if (link->state & DEV_CONFIG) {
 543                 if (link->open)
 544                         netif_device_detach(dev);
 545                 pcmcia_release_configuration(link->handle);
 546         }
 547
 548         return 0;
 549 }
 550
 551 static int tc574_resume(struct pcmcia_device *p_dev)
 552 {
 553         dev_link_t *link = dev_to_instance(p_dev);
 554         struct net_device *dev = link->priv;
 555
 556         link->state &= ~DEV_SUSPEND;
 557         if (link->state & DEV_CONFIG) {
 558                 pcmcia_request_configuration(link->handle, &link->conf);
 559                 if (link->open) {
 560                         tc574_reset(dev);
 561                         netif_device_attach(dev);
 562                 }
 563         }
 564
 565         return 0;
 566 }
 567
 568 /*
 569         The card status event handler.  Mostly, this schedules other
 570         stuff to run after an event is received.  A CARD_REMOVAL event
 571         also sets some flags to discourage the net drivers from trying
 572         to talk to the card any more.
 573 */
 574
 575 static int tc574_event(event_t event, int priority,
 576                                            event_callback_args_t *args)
 577 {
 578         dev_link_t *link = args->client_data;
 579
 580         DEBUG(1, "3c574_event(0x%06x)\n", event);
 581
 582         switch (event) {
 583         case CS_EVENT_CARD_INSERTION:
 584                 link->state |= DEV_PRESENT | DEV_CONFIG_PENDING;
 585                 tc574_config(link);
 586                 break;
 587         }
 588         return 0;
 589 } /* tc574_event */
 590
 591 static void dump_status(struct net_device *dev)
 592 {
 593         kio_addr_t ioaddr = dev->base_addr;
 594         EL3WINDOW(1);
 595         printk(KERN_INFO "  irq status %04x, rx status %04x, tx status "
 596                    "%02x, tx free %04x\n", inw(ioaddr+EL3_STATUS),
 597                    inw(ioaddr+RxStatus), inb(ioaddr+TxStatus),
 598                    inw(ioaddr+TxFree));
 599         EL3WINDOW(4);
 600         printk(KERN_INFO "  diagnostics: fifo %04x net %04x ethernet %04x"
 601                    " media %04x\n", inw(ioaddr+0x04), inw(ioaddr+0x06),
 602                    inw(ioaddr+0x08), inw(ioaddr+0x0a));
 603         EL3WINDOW(1);
 604 }
 605
 606 /*
 607   Use this for commands that may take time to finish
 608 */
 609 static void tc574_wait_for_completion(struct net_device *dev, int cmd)
 610 {
 611         int i = 1500;
 612         outw(cmd, dev->base_addr + EL3_CMD);
 613         while (--i > 0)
 614                 if (!(inw(dev->base_addr + EL3_STATUS) & 0x1000)) break;
 615         if (i == 0)
 616                 printk(KERN_NOTICE "%s: command 0x%04x did not complete!\n", dev->name, cmd);
 617 }
 618
 619 /* Read a word from the EEPROM using the regular EEPROM access register.
 620    Assume that we are in register window zero.
 621  */
 622 static unsigned short read_eeprom(kio_addr_t ioaddr, int index)
 623 {
 624         int timer;
 625         outw(EEPROM_Read + index, ioaddr + Wn0EepromCmd);
 626         /* Pause for at least 162 usec for the read to take place. */
 627         for (timer = 1620; timer >= 0; timer--) {
 628                 if ((inw(ioaddr + Wn0EepromCmd) & 0x8000) == 0)
 629                         break;
 630         }
 631         return inw(ioaddr + Wn0EepromData);
 632 }
 633
 634 /* MII transceiver control section.
 635    Read and write the MII registers using software-generated serial
 636    MDIO protocol.  See the MII specifications or DP83840A data sheet
 637    for details.
 638    The maxium data clock rate is 2.5 Mhz.  The timing is easily met by the
 639    slow PC card interface. */
 640
 641 #define MDIO_SHIFT_CLK  0x01
 642 #define MDIO_DIR_WRITE  0x04
 643 #define MDIO_DATA_WRITE0 (0x00 | MDIO_DIR_WRITE)
 644 #define MDIO_DATA_WRITE1 (0x02 | MDIO_DIR_WRITE)
 645 #define MDIO_DATA_READ  0x02
 646 #define MDIO_ENB_IN             0x00
 647
 648 /* Generate the preamble required for initial synchronization and
 649    a few older transceivers. */
 650 static void mdio_sync(kio_addr_t ioaddr, int bits)
 651 {
 652         kio_addr_t mdio_addr = ioaddr + Wn4_PhysicalMgmt;
 653
 654         /* Establish sync by sending at least 32 logic ones. */
 655         while (-- bits >= 0) {
 656                 outw(MDIO_DATA_WRITE1, mdio_addr);
 657                 outw(MDIO_DATA_WRITE1 | MDIO_SHIFT_CLK, mdio_addr);
 658         }
 659 }
 660
 661 static int mdio_read(kio_addr_t ioaddr, int phy_id, int location)
 662 {
 663         int i;
 664         int read_cmd = (0xf6 << 10) | (phy_id << 5) | location;
 665         unsigned int retval = 0;
 666         kio_addr_t mdio_addr = ioaddr + Wn4_PhysicalMgmt;
 667
 668         if (mii_preamble_required)
 669                 mdio_sync(ioaddr, 32);
 670
 671         /* Shift the read command bits out. */
 672         for (i = 14; i >= 0; i--) {
 673                 int dataval = (read_cmd&(1<<i)) ? MDIO_DATA_WRITE1 : MDIO_DATA_WRITE0;
 674                 outw(dataval, mdio_addr);
 675                 outw(dataval | MDIO_SHIFT_CLK, mdio_addr);
 676         }
 677         /* Read the two transition, 16 data, and wire-idle bits. */
 678         for (i = 19; i > 0; i--) {
 679                 outw(MDIO_ENB_IN, mdio_addr);
 680                 retval = (retval << 1) | ((inw(mdio_addr) & MDIO_DATA_READ) ? 1 : 0);
 681                 outw(MDIO_ENB_IN | MDIO_SHIFT_CLK, mdio_addr);
 682         }
 683         return (retval>>1) & 0xffff;
 684 }
 685
 686 static void mdio_write(kio_addr_t ioaddr, int phy_id, int location, int value)
 687 {
 688         int write_cmd = 0x50020000 | (phy_id << 23) | (location << 18) | value;
 689         kio_addr_t mdio_addr = ioaddr + Wn4_PhysicalMgmt;
 690         int i;
 691
 692         if (mii_preamble_required)
 693                 mdio_sync(ioaddr, 32);
 694
 695         /* Shift the command bits out. */
 696         for (i = 31; i >= 0; i--) {
 697                 int dataval = (write_cmd&(1<<i)) ? MDIO_DATA_WRITE1 : MDIO_DATA_WRITE0;
 698                 outw(dataval, mdio_addr);
 699                 outw(dataval | MDIO_SHIFT_CLK, mdio_addr);
 700         }
 701         /* Leave the interface idle. */
 702         for (i = 1; i >= 0; i--) {
 703                 outw(MDIO_ENB_IN, mdio_addr);
 704                 outw(MDIO_ENB_IN | MDIO_SHIFT_CLK, mdio_addr);
 705         }
 706
 707         return;
 708 }
 709
 710 /* Reset and restore all of the 3c574 registers. */
 711 static void tc574_reset(struct net_device *dev)
 712 {
 713         struct el3_private *lp = netdev_priv(dev);
 714         int i;
 715         kio_addr_t ioaddr = dev->base_addr;
 716         unsigned long flags;
 717
 718         tc574_wait_for_completion(dev, TotalReset|0x10);
 719
 720         spin_lock_irqsave(&lp->window_lock, flags);
 721         /* Clear any transactions in progress. */
 722         outw(0, ioaddr + RunnerWrCtrl);
 723         outw(0, ioaddr + RunnerRdCtrl);
 724
 725         /* Set the station address and mask. */
 726         EL3WINDOW(2);
 727         for (i = 0; i < 6; i++)
 728                 outb(dev->dev_addr[i], ioaddr + i);
 729         for (; i < 12; i+=2)
 730                 outw(0, ioaddr + i);
 731
 732         /* Reset config options */
 733         EL3WINDOW(3);
 734         outb((dev->mtu > 1500 ? 0x40 : 0), ioaddr + Wn3_MAC_Ctrl);
 735         outl((lp->autoselect ? 0x01000000 : 0) | 0x0062001b,
 736                  ioaddr + Wn3_Config);
 737         /* Roadrunner only: Turn on the MII transceiver. */
 738         outw(0x8040, ioaddr + Wn3_Options);
 739         mdelay(1);
 740         outw(0xc040, ioaddr + Wn3_Options);
 741         EL3WINDOW(1);
 742         spin_unlock_irqrestore(&lp->window_lock, flags);
 743
 744         tc574_wait_for_completion(dev, TxReset);
 745         tc574_wait_for_completion(dev, RxReset);
 746         mdelay(1);
 747         spin_lock_irqsave(&lp->window_lock, flags);
 748         EL3WINDOW(3);
 749         outw(0x8040, ioaddr + Wn3_Options);
 750
 751         /* Switch to the stats window, and clear all stats by reading. */
 752         outw(StatsDisable, ioaddr + EL3_CMD);
 753         EL3WINDOW(6);
 754         for (i = 0; i < 10; i++)
 755                 inb(ioaddr + i);
 756         inw(ioaddr + 10);
 757         inw(ioaddr + 12);
 758         EL3WINDOW(4);
 759         inb(ioaddr + 12);
 760         inb(ioaddr + 13);
 761
 762         /* .. enable any extra statistics bits.. */
 763         outw(0x0040, ioaddr + Wn4_NetDiag);
 764
 765         EL3WINDOW(1);
 766         spin_unlock_irqrestore(&lp->window_lock, flags);
 767
 768         /* .. re-sync MII and re-fill what NWay is advertising. */
 769         mdio_sync(ioaddr, 32);
 770         mdio_write(ioaddr, lp->phys, 4, lp->advertising);
 771         if (!auto_polarity) {
 772                 /* works for TDK 78Q2120 series MII's */
 773                 int i = mdio_read(ioaddr, lp->phys, 16) | 0x20;
 774                 mdio_write(ioaddr, lp->phys, 16, i);
 775         }
 776
 777         spin_lock_irqsave(&lp->window_lock, flags);
 778         /* Switch to register set 1 for normal use, just for TxFree. */
 779         set_rx_mode(dev);
 780         spin_unlock_irqrestore(&lp->window_lock, flags);
 781         outw(StatsEnable, ioaddr + EL3_CMD); /* Turn on statistics. */
 782         outw(RxEnable, ioaddr + EL3_CMD); /* Enable the receiver. */
 783         outw(TxEnable, ioaddr + EL3_CMD); /* Enable transmitter. */
 784         /* Allow status bits to be seen. */
 785         outw(SetStatusEnb | 0xff, ioaddr + EL3_CMD);
 786         /* Ack all pending events, and set active indicator mask. */
 787         outw(AckIntr | IntLatch | TxAvailable | RxEarly | IntReq,
 788                  ioaddr + EL3_CMD);
 789         outw(SetIntrEnb | IntLatch | TxAvailable | RxComplete | StatsFull
 790                  | AdapterFailure | RxEarly, ioaddr + EL3_CMD);
 791 }
 792
 793 static int el3_open(struct net_device *dev)
 794 {
 795         struct el3_private *lp = netdev_priv(dev);
 796         dev_link_t *link = &lp->link;
 797
 798         if (!DEV_OK(link))
 799                 return -ENODEV;
 800
 801         link->open++;
 802         netif_start_queue(dev);
 803
 804         tc574_reset(dev);
 805         lp->media.function = &media_check;
 806         lp->media.data = (unsigned long) dev;
 807         lp->media.expires = jiffies + HZ;
 808         add_timer(&lp->media);
 809
 810         DEBUG(2, "%s: opened, status %4.4x.\n",
 811                   dev->name, inw(dev->base_addr + EL3_STATUS));
 812
 813         return 0;
 814 }
 815
 816 static void el3_tx_timeout(struct net_device *dev)
 817 {
 818         struct el3_private *lp = netdev_priv(dev);
 819         kio_addr_t ioaddr = dev->base_addr;
 820
 821         printk(KERN_NOTICE "%s: Transmit timed out!\n", dev->name);
 822         dump_status(dev);
 823         lp->stats.tx_errors++;
 824         dev->trans_start = jiffies;
 825         /* Issue TX_RESET and TX_START commands. */
 826         tc574_wait_for_completion(dev, TxReset);
 827         outw(TxEnable, ioaddr + EL3_CMD);
 828         netif_wake_queue(dev);
 829 }
 830
 831 static void pop_tx_status(struct net_device *dev)
 832 {
 833         struct el3_private *lp = netdev_priv(dev);
 834         kio_addr_t ioaddr = dev->base_addr;
 835         int i;
 836
 837         /* Clear the Tx status stack. */
 838         for (i = 32; i > 0; i--) {
 839                 u_char tx_status = inb(ioaddr + TxStatus);
 840                 if (!(tx_status & 0x84))
 841                         break;
 842                 /* reset transmitter on jabber error or underrun */
 843                 if (tx_status & 0x30)
 844                         tc574_wait_for_completion(dev, TxReset);
 845                 if (tx_status & 0x38) {
 846                         DEBUG(1, "%s: transmit error: status 0x%02x\n",
 847                                   dev->name, tx_status);
 848                         outw(TxEnable, ioaddr + EL3_CMD);
 849                         lp->stats.tx_aborted_errors++;
 850                 }
 851                 outb(0x00, ioaddr + TxStatus); /* Pop the status stack. */
 852         }
 853 }
 854
 855 static int el3_start_xmit(struct sk_buff *skb, struct net_device *dev)
 856 {
 857         kio_addr_t ioaddr = dev->base_addr;
 858         struct el3_private *lp = netdev_priv(dev);
 859         unsigned long flags;
 860
 861         DEBUG(3, "%s: el3_start_xmit(length = %ld) called, "
 862                   "status %4.4x.\n", dev->name, (long)skb->len,
 863                   inw(ioaddr + EL3_STATUS));
 864
 865         spin_lock_irqsave(&lp->window_lock, flags);
 866         outw(skb->len, ioaddr + TX_FIFO);
 867         outw(0, ioaddr + TX_FIFO);
 868         outsl(ioaddr + TX_FIFO, skb->data, (skb->len+3)>>2);
 869
 870         dev->trans_start = jiffies;
 871
 872         /* TxFree appears only in Window 1, not offset 0x1c. */
 873         if (inw(ioaddr + TxFree) <= 1536) {
 874                 netif_stop_queue(dev);
 875                 /* Interrupt us when the FIFO has room for max-sized packet.
 876                    The threshold is in units of dwords. */
 877                 outw(SetTxThreshold + (1536>>2), ioaddr + EL3_CMD);
 878         }
 879
 880         pop_tx_status(dev);
 881         spin_unlock_irqrestore(&lp->window_lock, flags);
 882         dev_kfree_skb(skb);
 883         return 0;
 884 }
 885
 886 /* The EL3 interrupt handler. */
 887 static irqreturn_t el3_interrupt(int irq, void *dev_id, struct pt_regs *regs)
 888 {
 889         struct net_device *dev = (struct net_device *) dev_id;
 890         struct el3_private *lp = netdev_priv(dev);
 891         kio_addr_t ioaddr;
 892         unsigned status;
 893         int work_budget = max_interrupt_work;
 894         int handled = 0;
 895
 896         if (!netif_device_present(dev))
 897                 return IRQ_NONE;
 898         ioaddr = dev->base_addr;
 899
 900         DEBUG(3, "%s: interrupt, status %4.4x.\n",
 901                   dev->name, inw(ioaddr + EL3_STATUS));
 902
 903         spin_lock(&lp->window_lock);
 904
 905         while ((status = inw(ioaddr + EL3_STATUS)) &
 906                    (IntLatch | RxComplete | RxEarly | StatsFull)) {
 907                 if (!netif_device_present(dev) ||
 908                         ((status & 0xe000) != 0x2000)) {
 909                         DEBUG(1, "%s: Interrupt from dead card\n", dev->name);
 910                         break;
 911                 }
 912
 913                 handled = 1;
 914
 915                 if (status & RxComplete)
 916                         work_budget = el3_rx(dev, work_budget);
 917
 918                 if (status & TxAvailable) {
 919                         DEBUG(3, "  TX room bit was handled.\n");
 920                         /* There's room in the FIFO for a full-sized packet. */
 921                         outw(AckIntr | TxAvailable, ioaddr + EL3_CMD);
 922                         netif_wake_queue(dev);
 923                 }
 924
 925                 if (status & TxComplete)
 926                         pop_tx_status(dev);
 927
 928                 if (status & (AdapterFailure | RxEarly | StatsFull)) {
 929                         /* Handle all uncommon interrupts. */
 930                         if (status & StatsFull)
 931                                 update_stats(dev);
 932                         if (status & RxEarly) {
 933                                 work_budget = el3_rx(dev, work_budget);
 934                                 outw(AckIntr | RxEarly, ioaddr + EL3_CMD);
 935                         }
 936                         if (status & AdapterFailure) {
 937                                 u16 fifo_diag;
 938                                 EL3WINDOW(4);
 939                                 fifo_diag = inw(ioaddr + Wn4_FIFODiag);
 940                                 EL3WINDOW(1);
 941                                 printk(KERN_NOTICE "%s: adapter failure, FIFO diagnostic"
 942                                            " register %04x.\n", dev->name, fifo_diag);
 943                                 if (fifo_diag & 0x0400) {
 944                                         /* Tx overrun */
 945                                         tc574_wait_for_completion(dev, TxReset);
 946                                         outw(TxEnable, ioaddr + EL3_CMD);
 947                                 }
 948                                 if (fifo_diag & 0x2000) {
 949                                         /* Rx underrun */
 950                                         tc574_wait_for_completion(dev, RxReset);
 951                                         set_rx_mode(dev);
 952                                         outw(RxEnable, ioaddr + EL3_CMD);
 953                                 }
 954                                 outw(AckIntr | AdapterFailure, ioaddr + EL3_CMD);
 955                         }
 956                 }
 957
 958                 if (--work_budget < 0) {
 959                         DEBUG(0, "%s: Too much work in interrupt, "
 960                                   "status %4.4x.\n", dev->name, status);
 961                         /* Clear all interrupts */
 962                         outw(AckIntr | 0xFF, ioaddr + EL3_CMD);
 963                         break;
 964                 }
 965                 /* Acknowledge the IRQ. */
 966                 outw(AckIntr | IntReq | IntLatch, ioaddr + EL3_CMD);
 967         }
 968
 969         DEBUG(3, "%s: exiting interrupt, status %4.4x.\n",
 970                   dev->name, inw(ioaddr + EL3_STATUS));
 971
 972         spin_unlock(&lp->window_lock);
 973         return IRQ_RETVAL(handled);
 974 }
 975
 976 /*
 977     This timer serves two purposes: to check for missed interrupts
 978         (and as a last resort, poll the NIC for events), and to monitor
 979         the MII, reporting changes in cable status.
 980 */
 981 static void media_check(unsigned long arg)
 982 {
 983         struct net_device *dev = (struct net_device *) arg;
 984         struct el3_private *lp = netdev_priv(dev);
 985         kio_addr_t ioaddr = dev->base_addr;
 986         unsigned long flags;
 987         unsigned short /* cable, */ media, partner;
 988
 989         if (!netif_device_present(dev))
 990                 goto reschedule;
 991
 992         /* Check for pending interrupt with expired latency timer: with
 993            this, we can limp along even if the interrupt is blocked */
 994         if ((inw(ioaddr + EL3_STATUS) & IntLatch) && (inb(ioaddr + Timer) == 0xff)) {
 995                 if (!lp->fast_poll)
 996                         printk(KERN_INFO "%s: interrupt(s) dropped!\n", dev->name);
 997                 el3_interrupt(dev->irq, lp, NULL);
 998                 lp->fast_poll = HZ;
 999         }
1000         if (lp->fast_poll) {
1001                 lp->fast_poll--;
1002                 lp->media.expires = jiffies + 2*HZ/100;
1003                 add_timer(&lp->media);
1004                 return;
1005         }
1006
1007         spin_lock_irqsave(&lp->window_lock, flags);
1008         EL3WINDOW(4);
1009         media = mdio_read(ioaddr, lp->phys, 1);
1010         partner = mdio_read(ioaddr, lp->phys, 5);
1011         EL3WINDOW(1);
1012
1013         if (media != lp->media_status) {
1014                 if ((media ^ lp->media_status) & 0x0004)
1015                         printk(KERN_INFO "%s: %s link beat\n", dev->name,
1016                                    (lp->media_status & 0x0004) ? "lost" : "found");
1017                 if ((media ^ lp->media_status) & 0x0020) {
1018                         lp->partner = 0;
1019                         if (lp->media_status & 0x0020) {
1020                                 printk(KERN_INFO "%s: autonegotiation restarted\n",
1021                                            dev->name);
1022                         } else if (partner) {
1023                                 partner &= lp->advertising;
1024                                 lp->partner = partner;
1025                                 printk(KERN_INFO "%s: autonegotiation complete: "
1026                                            "%sbaseT-%cD selected\n", dev->name,
1027                                            ((partner & 0x0180) ? "100" : "10"),
1028                                            ((partner & 0x0140) ? 'F' : 'H'));
1029                         } else {
1030                                 printk(KERN_INFO "%s: link partner did not autonegotiate\n",
1031                                            dev->name);
1032                         }
1033
1034                         EL3WINDOW(3);
1035                         outb((partner & 0x0140 ? 0x20 : 0) |
1036                                  (dev->mtu > 1500 ? 0x40 : 0), ioaddr + Wn3_MAC_Ctrl);
1037                         EL3WINDOW(1);
1038
1039                 }
1040                 if (media & 0x0010)
1041                         printk(KERN_INFO "%s: remote fault detected\n",
1042                                    dev->name);
1043                 if (media & 0x0002)
1044                         printk(KERN_INFO "%s: jabber detected\n", dev->name);
1045                 lp->media_status = media;
1046         }
1047         spin_unlock_irqrestore(&lp->window_lock, flags);
1048
1049 reschedule:
1050         lp->media.expires = jiffies + HZ;
1051         add_timer(&lp->media);
1052 }
1053
1054 static struct net_device_stats *el3_get_stats(struct net_device *dev)
1055 {
1056         struct el3_private *lp = netdev_priv(dev);
1057
1058         if (netif_device_present(dev)) {
1059                 unsigned long flags;
1060                 spin_lock_irqsave(&lp->window_lock, flags);
1061                 update_stats(dev);
1062                 spin_unlock_irqrestore(&lp->window_lock, flags);
1063         }
1064         return &lp->stats;
1065 }
1066
1067 /*  Update statistics.
1068         Suprisingly this need not be run single-threaded, but it effectively is.
1069         The counters clear when read, so the adds must merely be atomic.
1070  */
1071 static void update_stats(struct net_device *dev)
1072 {
1073         struct el3_private *lp = netdev_priv(dev);
1074         kio_addr_t ioaddr = dev->base_addr;
1075         u8 rx, tx, up;
1076
1077         DEBUG(2, "%s: updating the statistics.\n", dev->name);
1078
1079         if (inw(ioaddr+EL3_STATUS) == 0xffff) /* No card. */
1080                 return;
1081
1082         /* Unlike the 3c509 we need not turn off stats updates while reading. */
1083         /* Switch to the stats window, and read everything. */
1084         EL3WINDOW(6);
1085         lp->stats.tx_carrier_errors             += inb(ioaddr + 0);
1086         lp->stats.tx_heartbeat_errors           += inb(ioaddr + 1);
1087         /* Multiple collisions. */              inb(ioaddr + 2);
1088         lp->stats.collisions                    += inb(ioaddr + 3);
1089         lp->stats.tx_window_errors              += inb(ioaddr + 4);
1090         lp->stats.rx_fifo_errors                += inb(ioaddr + 5);
1091         lp->stats.tx_packets                    += inb(ioaddr + 6);
1092         up                                       = inb(ioaddr + 9);
1093         lp->stats.tx_packets                    += (up&0x30) << 4;
1094         /* Rx packets   */                         inb(ioaddr + 7);
1095         /* Tx deferrals */                         inb(ioaddr + 8);
1096         rx                                       = inw(ioaddr + 10);
1097         tx                                       = inw(ioaddr + 12);
1098
1099         EL3WINDOW(4);
1100         /* BadSSD */                               inb(ioaddr + 12);
1101         up                                       = inb(ioaddr + 13);
1102
1103         lp->stats.tx_bytes                      += tx + ((up & 0xf0) << 12);
1104
1105         EL3WINDOW(1);
1106 }
1107
1108 static int el3_rx(struct net_device *dev, int worklimit)
1109 {
1110         struct el3_private *lp = netdev_priv(dev);
1111         kio_addr_t ioaddr = dev->base_addr;
1112         short rx_status;
1113
1114         DEBUG(3, "%s: in rx_packet(), status %4.4x, rx_status %4.4x.\n",
1115                   dev->name, inw(ioaddr+EL3_STATUS), inw(ioaddr+RxStatus));
1116         while (!((rx_status = inw(ioaddr + RxStatus)) & 0x8000) &&
1117                    (--worklimit >= 0)) {
1118                 if (rx_status & 0x4000) { /* Error, update stats. */
1119                         short error = rx_status & 0x3800;
1120                         lp->stats.rx_errors++;
1121                         switch (error) {
1122                         case 0x0000:    lp->stats.rx_over_errors++; break;
1123                         case 0x0800:    lp->stats.rx_length_errors++; break;
1124                         case 0x1000:    lp->stats.rx_frame_errors++; break;
1125                         case 0x1800:    lp->stats.rx_length_errors++; break;
1126                         case 0x2000:    lp->stats.rx_frame_errors++; break;
1127                         case 0x2800:    lp->stats.rx_crc_errors++; break;
1128                         }
1129                 } else {
1130                         short pkt_len = rx_status & 0x7ff;
1131                         struct sk_buff *skb;
1132
1133                         skb = dev_alloc_skb(pkt_len+5);
1134
1135                         DEBUG(3, "  Receiving packet size %d status %4.4x.\n",
1136                                   pkt_len, rx_status);
1137                         if (skb != NULL) {
1138                                 skb->dev = dev;
1139                                 skb_reserve(skb, 2);
1140                                 insl(ioaddr+RX_FIFO, skb_put(skb, pkt_len),
1141                                                 ((pkt_len+3)>>2));
1142                                 skb->protocol = eth_type_trans(skb, dev);
1143                                 netif_rx(skb);
1144                                 dev->last_rx = jiffies;
1145                                 lp->stats.rx_packets++;
1146                                 lp->stats.rx_bytes += pkt_len;
1147                         } else {
1148                                 DEBUG(1, "%s: couldn't allocate a sk_buff of"
1149                                           " size %d.\n", dev->name, pkt_len);
1150                                 lp->stats.rx_dropped++;
1151                         }
1152                 }
1153                 tc574_wait_for_completion(dev, RxDiscard);
1154         }
1155
1156         return worklimit;
1157 }
1158
1159 static void netdev_get_drvinfo(struct net_device *dev,
1160                                struct ethtool_drvinfo *info)
1161 {
1162         strcpy(info->driver, "3c574_cs");
1163 }
1164
1165 static struct ethtool_ops netdev_ethtool_ops = {
1166         .get_drvinfo            = netdev_get_drvinfo,
1167 };
1168
1169 /* Provide ioctl() calls to examine the MII xcvr state. */
1170 static int el3_ioctl(struct net_device *dev, struct ifreq *rq, int cmd)
1171 {
1172         struct el3_private *lp = netdev_priv(dev);
1173         kio_addr_t ioaddr = dev->base_addr;
1174         u16 *data = (u16 *)&rq->ifr_ifru;
1175         int phy = lp->phys & 0x1f;
1176
1177         DEBUG(2, "%s: In ioct(%-.6s, %#4.4x) %4.4x %4.4x %4.4x %4.4x.\n",
1178                   dev->name, rq->ifr_ifrn.ifrn_name, cmd,
1179                   data[0], data[1], data[2], data[3]);
1180
1181         switch(cmd) {
1182         case SIOCGMIIPHY:               /* Get the address of the PHY in use. */
1183                 data[0] = phy;
1184         case SIOCGMIIREG:               /* Read the specified MII register. */
1185                 {
1186                         int saved_window;
1187                         unsigned long flags;
1188
1189                         spin_lock_irqsave(&lp->window_lock, flags);
1190                         saved_window = inw(ioaddr + EL3_CMD) >> 13;
1191                         EL3WINDOW(4);
1192                         data[3] = mdio_read(ioaddr, data[0] & 0x1f, data[1] & 0x1f);
1193                         EL3WINDOW(saved_window);
1194                         spin_unlock_irqrestore(&lp->window_lock, flags);
1195                         return 0;
1196                 }
1197         case SIOCSMIIREG:               /* Write the specified MII register */
1198                 {
1199                         int saved_window;
1200                        unsigned long flags;
1201
1202                         if (!capable(CAP_NET_ADMIN))
1203                                 return -EPERM;
1204                         spin_lock_irqsave(&lp->window_lock, flags);
1205                         saved_window = inw(ioaddr + EL3_CMD) >> 13;
1206                         EL3WINDOW(4);
1207                         mdio_write(ioaddr, data[0] & 0x1f, data[1] & 0x1f, data[2]);
1208                         EL3WINDOW(saved_window);
1209                         spin_unlock_irqrestore(&lp->window_lock, flags);
1210                         return 0;
1211                 }
1212         default:
1213                 return -EOPNOTSUPP;
1214         }
1215 }
1216
1217 /* The Odie chip has a 64 bin multicast filter, but the bit layout is not
1218    documented.  Until it is we revert to receiving all multicast frames when
1219    any multicast reception is desired.
1220    Note: My other drivers emit a log message whenever promiscuous mode is
1221    entered to help detect password sniffers.  This is less desirable on
1222    typical PC card machines, so we omit the message.
1223    */
1224
1225 static void set_rx_mode(struct net_device *dev)
1226 {
1227         kio_addr_t ioaddr = dev->base_addr;
1228
1229         if (dev->flags & IFF_PROMISC)
1230                 outw(SetRxFilter | RxStation | RxMulticast | RxBroadcast | RxProm,
1231                          ioaddr + EL3_CMD);
1232         else if (dev->mc_count || (dev->flags & IFF_ALLMULTI))
1233                 outw(SetRxFilter|RxStation|RxMulticast|RxBroadcast, ioaddr + EL3_CMD);
1234         else
1235                 outw(SetRxFilter | RxStation | RxBroadcast, ioaddr + EL3_CMD);
1236 }
1237
1238 static int el3_close(struct net_device *dev)
1239 {
1240         kio_addr_t ioaddr = dev->base_addr;
1241         struct el3_private *lp = netdev_priv(dev);
1242         dev_link_t *link = &lp->link;
1243
1244         DEBUG(2, "%s: shutting down ethercard.\n", dev->name);
1245
1246         if (DEV_OK(link)) {
1247                 unsigned long flags;
1248
1249                 /* Turn off statistics ASAP.  We update lp->stats below. */
1250                 outw(StatsDisable, ioaddr + EL3_CMD);
1251
1252                 /* Disable the receiver and transmitter. */
1253                 outw(RxDisable, ioaddr + EL3_CMD);
1254                 outw(TxDisable, ioaddr + EL3_CMD);
1255
1256                 /* Note: Switching to window 0 may disable the IRQ. */
1257                 EL3WINDOW(0);
1258                 spin_lock_irqsave(&lp->window_lock, flags);
1259                 update_stats(dev);
1260                 spin_unlock_irqrestore(&lp->window_lock, flags);
1261
1262                 /* force interrupts off */
1263                 outw(SetIntrEnb | 0x0000, ioaddr + EL3_CMD);
1264         }
1265
1266         link->open--;
1267         netif_stop_queue(dev);
1268         del_timer_sync(&lp->media);
1269
1270         return 0;
1271 }
1272
1273 static struct pcmcia_device_id tc574_ids[] = {
1274         PCMCIA_DEVICE_MANF_CARD(0x0101, 0x0574),
1275         PCMCIA_MFC_DEVICE_CIS_MANF_CARD(0, 0x0101, 0x0556, "3CCFEM556.cis"),
1276         PCMCIA_DEVICE_NULL,
1277 };
1278 MODULE_DEVICE_TABLE(pcmcia, tc574_ids);
1279
1280 static struct pcmcia_driver tc574_driver = {
1281         .owner          = THIS_MODULE,
1282         .drv            = {
1283                 .name   = "3c574_cs",
1284         },
1285         .attach         = tc574_attach,
1286         .event          = tc574_event,
1287         .remove         = tc574_detach,
1288         .id_table       = tc574_ids,
1289         .suspend        = tc574_suspend,
1290         .resume         = tc574_resume,
1291 };
1292
1293 static int __init init_tc574(void)
1294 {
1295         return pcmcia_register_driver(&tc574_driver);
1296 }
1297
1298 static void __exit exit_tc574(void)
1299 {
1300         pcmcia_unregister_driver(&tc574_driver);
1301 }
1302
1303 module_init(init_tc574);
1304 module_exit(exit_tc574);