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(dev_link_t *);
 257
 258 static dev_link_t *dev_list;
 259
 260 /*
 261         tc574_attach() creates an "instance" of the driver, allocating
 262         local data structures for one device.  The device is registered
 263         with Card Services.
 264 */
 265
 266 static dev_link_t *tc574_attach(void)
 267 {
 268         struct el3_private *lp;
 269         client_reg_t client_reg;
 270         dev_link_t *link;
 271         struct net_device *dev;
 272         int ret;
 273
 274         DEBUG(0, "3c574_attach()\n");
 275
 276         /* Create the PC card device object. */
 277         dev = alloc_etherdev(sizeof(struct el3_private));
 278         if (!dev)
 279                 return NULL;
 280         lp = netdev_priv(dev);
 281         link = &lp->link;
 282         link->priv = dev;
 283
 284         spin_lock_init(&lp->window_lock);
 285         link->io.NumPorts1 = 32;
 286         link->io.Attributes1 = IO_DATA_PATH_WIDTH_16;
 287         link->irq.Attributes = IRQ_TYPE_EXCLUSIVE | IRQ_HANDLE_PRESENT;
 288         link->irq.IRQInfo1 = IRQ_LEVEL_ID;
 289         link->irq.Handler = &el3_interrupt;
 290         link->irq.Instance = dev;
 291         link->conf.Attributes = CONF_ENABLE_IRQ;
 292         link->conf.Vcc = 50;
 293         link->conf.IntType = INT_MEMORY_AND_IO;
 294         link->conf.ConfigIndex = 1;
 295         link->conf.Present = PRESENT_OPTION;
 296
 297         /* The EL3-specific entries in the device structure. */
 298         dev->hard_start_xmit = &el3_start_xmit;
 299         dev->get_stats = &el3_get_stats;
 300         dev->do_ioctl = &el3_ioctl;
 301         SET_ETHTOOL_OPS(dev, &netdev_ethtool_ops);
 302         dev->set_multicast_list = &set_rx_mode;
 303         dev->open = &el3_open;
 304         dev->stop = &el3_close;
 305 #ifdef HAVE_TX_TIMEOUT
 306         dev->tx_timeout = el3_tx_timeout;
 307         dev->watchdog_timeo = TX_TIMEOUT;
 308 #endif
 309
 310         /* Register with Card Services */
 311         link->next = dev_list;
 312         dev_list = link;
 313         client_reg.dev_info = &dev_info;
 314         client_reg.Version = 0x0210;
 315         client_reg.event_callback_args.client_data = link;
 316         ret = pcmcia_register_client(&link->handle, &client_reg);
 317         if (ret != 0) {
 318                 cs_error(link->handle, RegisterClient, ret);
 319                 tc574_detach(link);
 320                 return NULL;
 321         }
 322
 323         return link;
 324 } /* tc574_attach */
 325
 326 /*
 327
 328         This deletes a driver "instance".  The device is de-registered
 329         with Card Services.  If it has been released, all local data
 330         structures are freed.  Otherwise, the structures will be freed
 331         when the device is released.
 332
 333 */
 334
 335 static void tc574_detach(dev_link_t *link)
 336 {
 337         struct net_device *dev = link->priv;
 338         dev_link_t **linkp;
 339
 340         DEBUG(0, "3c574_detach(0x%p)\n", link);
 341
 342         /* Locate device structure */
 343         for (linkp = &dev_list; *linkp; linkp = &(*linkp)->next)
 344                 if (*linkp == link) break;
 345         if (*linkp == NULL)
 346                 return;
 347
 348         if (link->dev)
 349                 unregister_netdev(dev);
 350
 351         if (link->state & DEV_CONFIG)
 352                 tc574_release(link);
 353
 354         if (link->handle)
 355                 pcmcia_deregister_client(link->handle);
 356
 357         /* Unlink device structure, free bits */
 358         *linkp = link->next;
 359         free_netdev(dev);
 360 } /* tc574_detach */
 361
 362 /*
 363         tc574_config() is scheduled to run after a CARD_INSERTION event
 364         is received, to configure the PCMCIA socket, and to make the
 365         ethernet device available to the system.
 366 */
 367
 368 #define CS_CHECK(fn, ret) \
 369   do { last_fn = (fn); if ((last_ret = (ret)) != 0) goto cs_failed; } while (0)
 370
 371 static char *ram_split[] = {"5:3", "3:1", "1:1", "3:5"};
 372
 373 static void tc574_config(dev_link_t *link)
 374 {
 375         client_handle_t handle = link->handle;
 376         struct net_device *dev = link->priv;
 377         struct el3_private *lp = netdev_priv(dev);
 378         tuple_t tuple;
 379         cisparse_t parse;
 380         unsigned short buf[32];
 381         int last_fn, last_ret, i, j;
 382         kio_addr_t ioaddr;
 383         u16 *phys_addr;
 384         char *cardname;
 385         union wn3_config config;
 386
 387         phys_addr = (u16 *)dev->dev_addr;
 388
 389         DEBUG(0, "3c574_config(0x%p)\n", link);
 390
 391         tuple.Attributes = 0;
 392         tuple.DesiredTuple = CISTPL_CONFIG;
 393         CS_CHECK(GetFirstTuple, pcmcia_get_first_tuple(handle, &tuple));
 394         tuple.TupleData = (cisdata_t *)buf;
 395         tuple.TupleDataMax = 64;
 396         tuple.TupleOffset = 0;
 397         CS_CHECK(GetTupleData, pcmcia_get_tuple_data(handle, &tuple));
 398         CS_CHECK(ParseTuple, pcmcia_parse_tuple(handle, &tuple, &parse));
 399         link->conf.ConfigBase = parse.config.base;
 400         link->conf.Present = parse.config.rmask[0];
 401
 402         /* Configure card */
 403         link->state |= DEV_CONFIG;
 404
 405         link->io.IOAddrLines = 16;
 406         for (i = j = 0; j < 0x400; j += 0x20) {
 407                 link->io.BasePort1 = j ^ 0x300;
 408                 i = pcmcia_request_io(link->handle, &link->io);
 409                 if (i == CS_SUCCESS) break;
 410         }
 411         if (i != CS_SUCCESS) {
 412                 cs_error(link->handle, RequestIO, i);
 413                 goto failed;
 414         }
 415         CS_CHECK(RequestIRQ, pcmcia_request_irq(link->handle, &link->irq));
 416         CS_CHECK(RequestConfiguration, pcmcia_request_configuration(link->handle, &link->conf));
 417
 418         dev->irq = link->irq.AssignedIRQ;
 419         dev->base_addr = link->io.BasePort1;
 420
 421         ioaddr = dev->base_addr;
 422
 423         /* The 3c574 normally uses an EEPROM for configuration info, including
 424            the hardware address.  The future products may include a modem chip
 425            and put the address in the CIS. */
 426         tuple.DesiredTuple = 0x88;
 427         if (pcmcia_get_first_tuple(handle, &tuple) == CS_SUCCESS) {
 428                 pcmcia_get_tuple_data(handle, &tuple);
 429                 for (i = 0; i < 3; i++)
 430                         phys_addr[i] = htons(buf[i]);
 431         } else {
 432                 EL3WINDOW(0);
 433                 for (i = 0; i < 3; i++)
 434                         phys_addr[i] = htons(read_eeprom(ioaddr, i + 10));
 435                 if (phys_addr[0] == 0x6060) {
 436                         printk(KERN_NOTICE "3c574_cs: IO port conflict at 0x%03lx"
 437                                    "-0x%03lx\n", dev->base_addr, dev->base_addr+15);
 438                         goto failed;
 439                 }
 440         }
 441         tuple.DesiredTuple = CISTPL_VERS_1;
 442         if (pcmcia_get_first_tuple(handle, &tuple) == CS_SUCCESS &&
 443                 pcmcia_get_tuple_data(handle, &tuple) == CS_SUCCESS &&
 444                 pcmcia_parse_tuple(handle, &tuple, &parse) == CS_SUCCESS) {
 445                 cardname = parse.version_1.str + parse.version_1.ofs[1];
 446         } else
 447                 cardname = "3Com 3c574";
 448
 449         {
 450                 u_char mcr;
 451                 outw(2<<11, ioaddr + RunnerRdCtrl);
 452                 mcr = inb(ioaddr + 2);
 453                 outw(0<<11, ioaddr + RunnerRdCtrl);
 454                 printk(KERN_INFO "  ASIC rev %d,", mcr>>3);
 455                 EL3WINDOW(3);
 456                 config.i = inl(ioaddr + Wn3_Config);
 457                 lp->default_media = config.u.xcvr;
 458                 lp->autoselect = config.u.autoselect;
 459         }
 460
 461         init_timer(&lp->media);
 462
 463         {
 464                 int phy;
 465
 466                 /* Roadrunner only: Turn on the MII transceiver */
 467                 outw(0x8040, ioaddr + Wn3_Options);
 468                 mdelay(1);
 469                 outw(0xc040, ioaddr + Wn3_Options);
 470                 tc574_wait_for_completion(dev, TxReset);
 471                 tc574_wait_for_completion(dev, RxReset);
 472                 mdelay(1);
 473                 outw(0x8040, ioaddr + Wn3_Options);
 474
 475                 EL3WINDOW(4);
 476                 for (phy = 1; phy <= 32; phy++) {
 477                         int mii_status;
 478                         mdio_sync(ioaddr, 32);
 479                         mii_status = mdio_read(ioaddr, phy & 0x1f, 1);
 480                         if (mii_status != 0xffff) {
 481                                 lp->phys = phy & 0x1f;
 482                                 DEBUG(0, "  MII transceiver at index %d, status %x.\n",
 483                                           phy, mii_status);
 484                                 if ((mii_status & 0x0040) == 0)
 485                                         mii_preamble_required = 1;
 486                                 break;
 487                         }
 488                 }
 489                 if (phy > 32) {
 490                         printk(KERN_NOTICE "  No MII transceivers found!\n");
 491                         goto failed;
 492                 }
 493                 i = mdio_read(ioaddr, lp->phys, 16) | 0x40;
 494                 mdio_write(ioaddr, lp->phys, 16, i);
 495                 lp->advertising = mdio_read(ioaddr, lp->phys, 4);
 496                 if (full_duplex) {
 497                         /* Only advertise the FD media types. */
 498                         lp->advertising &= ~0x02a0;
 499                         mdio_write(ioaddr, lp->phys, 4, lp->advertising);
 500                 }
 501         }
 502
 503         link->state &= ~DEV_CONFIG_PENDING;
 504         link->dev = &lp->node;
 505         SET_NETDEV_DEV(dev, &handle_to_dev(handle));
 506
 507         if (register_netdev(dev) != 0) {
 508                 printk(KERN_NOTICE "3c574_cs: register_netdev() failed\n");
 509                 link->dev = NULL;
 510                 goto failed;
 511         }
 512
 513         strcpy(lp->node.dev_name, dev->name);
 514
 515         printk(KERN_INFO "%s: %s at io %#3lx, irq %d, hw_addr ",
 516                    dev->name, cardname, dev->base_addr, dev->irq);
 517         for (i = 0; i < 6; i++)
 518                 printk("%02X%s", dev->dev_addr[i], ((i<5) ? ":" : ".\n"));
 519         printk(" %dK FIFO split %s Rx:Tx, %sMII interface.\n",
 520                    8 << config.u.ram_size, ram_split[config.u.ram_split],
 521                    config.u.autoselect ? "autoselect " : "");
 522
 523         return;
 524
 525 cs_failed:
 526         cs_error(link->handle, last_fn, last_ret);
 527 failed:
 528         tc574_release(link);
 529         return;
 530
 531 } /* tc574_config */
 532
 533 /*
 534         After a card is removed, tc574_release() will unregister the net
 535         device, and release the PCMCIA configuration.  If the device is
 536         still open, this will be postponed until it is closed.
 537 */
 538
 539 static void tc574_release(dev_link_t *link)
 540 {
 541         DEBUG(0, "3c574_release(0x%p)\n", link);
 542
 543         pcmcia_release_configuration(link->handle);
 544         pcmcia_release_io(link->handle, &link->io);
 545         pcmcia_release_irq(link->handle, &link->irq);
 546
 547         link->state &= ~DEV_CONFIG;
 548 }
 549
 550 /*
 551         The card status event handler.  Mostly, this schedules other
 552         stuff to run after an event is received.  A CARD_REMOVAL event
 553         also sets some flags to discourage the net drivers from trying
 554         to talk to the card any more.
 555 */
 556
 557 static int tc574_event(event_t event, int priority,
 558                                            event_callback_args_t *args)
 559 {
 560         dev_link_t *link = args->client_data;
 561         struct net_device *dev = link->priv;
 562
 563         DEBUG(1, "3c574_event(0x%06x)\n", event);
 564
 565         switch (event) {
 566         case CS_EVENT_CARD_REMOVAL:
 567                 link->state &= ~DEV_PRESENT;
 568                 if (link->state & DEV_CONFIG)
 569                         netif_device_detach(dev);
 570                 break;
 571         case CS_EVENT_CARD_INSERTION:
 572                 link->state |= DEV_PRESENT | DEV_CONFIG_PENDING;
 573                 tc574_config(link);
 574                 break;
 575         case CS_EVENT_PM_SUSPEND:
 576                 link->state |= DEV_SUSPEND;
 577                 /* Fall through... */
 578         case CS_EVENT_RESET_PHYSICAL:
 579                 if (link->state & DEV_CONFIG) {
 580                         if (link->open)
 581                                 netif_device_detach(dev);
 582                         pcmcia_release_configuration(link->handle);
 583                 }
 584                 break;
 585         case CS_EVENT_PM_RESUME:
 586                 link->state &= ~DEV_SUSPEND;
 587                 /* Fall through... */
 588         case CS_EVENT_CARD_RESET:
 589                 if (link->state & DEV_CONFIG) {
 590                         pcmcia_request_configuration(link->handle, &link->conf);
 591                         if (link->open) {
 592                                 tc574_reset(dev);
 593                                 netif_device_attach(dev);
 594                         }
 595                 }
 596                 break;
 597         }
 598         return 0;
 599 } /* tc574_event */
 600
 601 static void dump_status(struct net_device *dev)
 602 {
 603         kio_addr_t ioaddr = dev->base_addr;
 604         EL3WINDOW(1);
 605         printk(KERN_INFO "  irq status %04x, rx status %04x, tx status "
 606                    "%02x, tx free %04x\n", inw(ioaddr+EL3_STATUS),
 607                    inw(ioaddr+RxStatus), inb(ioaddr+TxStatus),
 608                    inw(ioaddr+TxFree));
 609         EL3WINDOW(4);
 610         printk(KERN_INFO "  diagnostics: fifo %04x net %04x ethernet %04x"
 611                    " media %04x\n", inw(ioaddr+0x04), inw(ioaddr+0x06),
 612                    inw(ioaddr+0x08), inw(ioaddr+0x0a));
 613         EL3WINDOW(1);
 614 }
 615
 616 /*
 617   Use this for commands that may take time to finish
 618 */
 619 static void tc574_wait_for_completion(struct net_device *dev, int cmd)
 620 {
 621         int i = 1500;
 622         outw(cmd, dev->base_addr + EL3_CMD);
 623         while (--i > 0)
 624                 if (!(inw(dev->base_addr + EL3_STATUS) & 0x1000)) break;
 625         if (i == 0)
 626                 printk(KERN_NOTICE "%s: command 0x%04x did not complete!\n", dev->name, cmd);
 627 }
 628
 629 /* Read a word from the EEPROM using the regular EEPROM access register.
 630    Assume that we are in register window zero.
 631  */
 632 static unsigned short read_eeprom(kio_addr_t ioaddr, int index)
 633 {
 634         int timer;
 635         outw(EEPROM_Read + index, ioaddr + Wn0EepromCmd);
 636         /* Pause for at least 162 usec for the read to take place. */
 637         for (timer = 1620; timer >= 0; timer--) {
 638                 if ((inw(ioaddr + Wn0EepromCmd) & 0x8000) == 0)
 639                         break;
 640         }
 641         return inw(ioaddr + Wn0EepromData);
 642 }
 643
 644 /* MII transceiver control section.
 645    Read and write the MII registers using software-generated serial
 646    MDIO protocol.  See the MII specifications or DP83840A data sheet
 647    for details.
 648    The maxium data clock rate is 2.5 Mhz.  The timing is easily met by the
 649    slow PC card interface. */
 650
 651 #define MDIO_SHIFT_CLK  0x01
 652 #define MDIO_DIR_WRITE  0x04
 653 #define MDIO_DATA_WRITE0 (0x00 | MDIO_DIR_WRITE)
 654 #define MDIO_DATA_WRITE1 (0x02 | MDIO_DIR_WRITE)
 655 #define MDIO_DATA_READ  0x02
 656 #define MDIO_ENB_IN             0x00
 657
 658 /* Generate the preamble required for initial synchronization and
 659    a few older transceivers. */
 660 static void mdio_sync(kio_addr_t ioaddr, int bits)
 661 {
 662         kio_addr_t mdio_addr = ioaddr + Wn4_PhysicalMgmt;
 663
 664         /* Establish sync by sending at least 32 logic ones. */
 665         while (-- bits >= 0) {
 666                 outw(MDIO_DATA_WRITE1, mdio_addr);
 667                 outw(MDIO_DATA_WRITE1 | MDIO_SHIFT_CLK, mdio_addr);
 668         }
 669 }
 670
 671 static int mdio_read(kio_addr_t ioaddr, int phy_id, int location)
 672 {
 673         int i;
 674         int read_cmd = (0xf6 << 10) | (phy_id << 5) | location;
 675         unsigned int retval = 0;
 676         kio_addr_t mdio_addr = ioaddr + Wn4_PhysicalMgmt;
 677
 678         if (mii_preamble_required)
 679                 mdio_sync(ioaddr, 32);
 680
 681         /* Shift the read command bits out. */
 682         for (i = 14; i >= 0; i--) {
 683                 int dataval = (read_cmd&(1<<i)) ? MDIO_DATA_WRITE1 : MDIO_DATA_WRITE0;
 684                 outw(dataval, mdio_addr);
 685                 outw(dataval | MDIO_SHIFT_CLK, mdio_addr);
 686         }
 687         /* Read the two transition, 16 data, and wire-idle bits. */
 688         for (i = 19; i > 0; i--) {
 689                 outw(MDIO_ENB_IN, mdio_addr);
 690                 retval = (retval << 1) | ((inw(mdio_addr) & MDIO_DATA_READ) ? 1 : 0);
 691                 outw(MDIO_ENB_IN | MDIO_SHIFT_CLK, mdio_addr);
 692         }
 693         return (retval>>1) & 0xffff;
 694 }
 695
 696 static void mdio_write(kio_addr_t ioaddr, int phy_id, int location, int value)
 697 {
 698         int write_cmd = 0x50020000 | (phy_id << 23) | (location << 18) | value;
 699         kio_addr_t mdio_addr = ioaddr + Wn4_PhysicalMgmt;
 700         int i;
 701
 702         if (mii_preamble_required)
 703                 mdio_sync(ioaddr, 32);
 704
 705         /* Shift the command bits out. */
 706         for (i = 31; i >= 0; i--) {
 707                 int dataval = (write_cmd&(1<<i)) ? MDIO_DATA_WRITE1 : MDIO_DATA_WRITE0;
 708                 outw(dataval, mdio_addr);
 709                 outw(dataval | MDIO_SHIFT_CLK, mdio_addr);
 710         }
 711         /* Leave the interface idle. */
 712         for (i = 1; i >= 0; i--) {
 713                 outw(MDIO_ENB_IN, mdio_addr);
 714                 outw(MDIO_ENB_IN | MDIO_SHIFT_CLK, mdio_addr);
 715         }
 716
 717         return;
 718 }
 719
 720 /* Reset and restore all of the 3c574 registers. */
 721 static void tc574_reset(struct net_device *dev)
 722 {
 723         struct el3_private *lp = netdev_priv(dev);
 724         int i;
 725         kio_addr_t ioaddr = dev->base_addr;
 726         unsigned long flags;
 727
 728         tc574_wait_for_completion(dev, TotalReset|0x10);
 729
 730         spin_lock_irqsave(&lp->window_lock, flags);
 731         /* Clear any transactions in progress. */
 732         outw(0, ioaddr + RunnerWrCtrl);
 733         outw(0, ioaddr + RunnerRdCtrl);
 734
 735         /* Set the station address and mask. */
 736         EL3WINDOW(2);
 737         for (i = 0; i < 6; i++)
 738                 outb(dev->dev_addr[i], ioaddr + i);
 739         for (; i < 12; i+=2)
 740                 outw(0, ioaddr + i);
 741
 742         /* Reset config options */
 743         EL3WINDOW(3);
 744         outb((dev->mtu > 1500 ? 0x40 : 0), ioaddr + Wn3_MAC_Ctrl);
 745         outl((lp->autoselect ? 0x01000000 : 0) | 0x0062001b,
 746                  ioaddr + Wn3_Config);
 747         /* Roadrunner only: Turn on the MII transceiver. */
 748         outw(0x8040, ioaddr + Wn3_Options);
 749         mdelay(1);
 750         outw(0xc040, ioaddr + Wn3_Options);
 751         EL3WINDOW(1);
 752         spin_unlock_irqrestore(&lp->window_lock, flags);
 753
 754         tc574_wait_for_completion(dev, TxReset);
 755         tc574_wait_for_completion(dev, RxReset);
 756         mdelay(1);
 757         spin_lock_irqsave(&lp->window_lock, flags);
 758         EL3WINDOW(3);
 759         outw(0x8040, ioaddr + Wn3_Options);
 760
 761         /* Switch to the stats window, and clear all stats by reading. */
 762         outw(StatsDisable, ioaddr + EL3_CMD);
 763         EL3WINDOW(6);
 764         for (i = 0; i < 10; i++)
 765                 inb(ioaddr + i);
 766         inw(ioaddr + 10);
 767         inw(ioaddr + 12);
 768         EL3WINDOW(4);
 769         inb(ioaddr + 12);
 770         inb(ioaddr + 13);
 771
 772         /* .. enable any extra statistics bits.. */
 773         outw(0x0040, ioaddr + Wn4_NetDiag);
 774
 775         EL3WINDOW(1);
 776         spin_unlock_irqrestore(&lp->window_lock, flags);
 777
 778         /* .. re-sync MII and re-fill what NWay is advertising. */
 779         mdio_sync(ioaddr, 32);
 780         mdio_write(ioaddr, lp->phys, 4, lp->advertising);
 781         if (!auto_polarity) {
 782                 /* works for TDK 78Q2120 series MII's */
 783                 int i = mdio_read(ioaddr, lp->phys, 16) | 0x20;
 784                 mdio_write(ioaddr, lp->phys, 16, i);
 785         }
 786
 787         spin_lock_irqsave(&lp->window_lock, flags);
 788         /* Switch to register set 1 for normal use, just for TxFree. */
 789         set_rx_mode(dev);
 790         spin_unlock_irqrestore(&lp->window_lock, flags);
 791         outw(StatsEnable, ioaddr + EL3_CMD); /* Turn on statistics. */
 792         outw(RxEnable, ioaddr + EL3_CMD); /* Enable the receiver. */
 793         outw(TxEnable, ioaddr + EL3_CMD); /* Enable transmitter. */
 794         /* Allow status bits to be seen. */
 795         outw(SetStatusEnb | 0xff, ioaddr + EL3_CMD);
 796         /* Ack all pending events, and set active indicator mask. */
 797         outw(AckIntr | IntLatch | TxAvailable | RxEarly | IntReq,
 798                  ioaddr + EL3_CMD);
 799         outw(SetIntrEnb | IntLatch | TxAvailable | RxComplete | StatsFull
 800                  | AdapterFailure | RxEarly, ioaddr + EL3_CMD);
 801 }
 802
 803 static int el3_open(struct net_device *dev)
 804 {
 805         struct el3_private *lp = netdev_priv(dev);
 806         dev_link_t *link = &lp->link;
 807
 808         if (!DEV_OK(link))
 809                 return -ENODEV;
 810
 811         link->open++;
 812         netif_start_queue(dev);
 813
 814         tc574_reset(dev);
 815         lp->media.function = &media_check;
 816         lp->media.data = (unsigned long) dev;
 817         lp->media.expires = jiffies + HZ;
 818         add_timer(&lp->media);
 819
 820         DEBUG(2, "%s: opened, status %4.4x.\n",
 821                   dev->name, inw(dev->base_addr + EL3_STATUS));
 822
 823         return 0;
 824 }
 825
 826 static void el3_tx_timeout(struct net_device *dev)
 827 {
 828         struct el3_private *lp = netdev_priv(dev);
 829         kio_addr_t ioaddr = dev->base_addr;
 830
 831         printk(KERN_NOTICE "%s: Transmit timed out!\n", dev->name);
 832         dump_status(dev);
 833         lp->stats.tx_errors++;
 834         dev->trans_start = jiffies;
 835         /* Issue TX_RESET and TX_START commands. */
 836         tc574_wait_for_completion(dev, TxReset);
 837         outw(TxEnable, ioaddr + EL3_CMD);
 838         netif_wake_queue(dev);
 839 }
 840
 841 static void pop_tx_status(struct net_device *dev)
 842 {
 843         struct el3_private *lp = netdev_priv(dev);
 844         kio_addr_t ioaddr = dev->base_addr;
 845         int i;
 846
 847         /* Clear the Tx status stack. */
 848         for (i = 32; i > 0; i--) {
 849                 u_char tx_status = inb(ioaddr + TxStatus);
 850                 if (!(tx_status & 0x84))
 851                         break;
 852                 /* reset transmitter on jabber error or underrun */
 853                 if (tx_status & 0x30)
 854                         tc574_wait_for_completion(dev, TxReset);
 855                 if (tx_status & 0x38) {
 856                         DEBUG(1, "%s: transmit error: status 0x%02x\n",
 857                                   dev->name, tx_status);
 858                         outw(TxEnable, ioaddr + EL3_CMD);
 859                         lp->stats.tx_aborted_errors++;
 860                 }
 861                 outb(0x00, ioaddr + TxStatus); /* Pop the status stack. */
 862         }
 863 }
 864
 865 static int el3_start_xmit(struct sk_buff *skb, struct net_device *dev)
 866 {
 867         kio_addr_t ioaddr = dev->base_addr;
 868         struct el3_private *lp = netdev_priv(dev);
 869         unsigned long flags;
 870
 871         DEBUG(3, "%s: el3_start_xmit(length = %ld) called, "
 872                   "status %4.4x.\n", dev->name, (long)skb->len,
 873                   inw(ioaddr + EL3_STATUS));
 874
 875         spin_lock_irqsave(&lp->window_lock, flags);
 876         outw(skb->len, ioaddr + TX_FIFO);
 877         outw(0, ioaddr + TX_FIFO);
 878         outsl(ioaddr + TX_FIFO, skb->data, (skb->len+3)>>2);
 879
 880         dev->trans_start = jiffies;
 881
 882         /* TxFree appears only in Window 1, not offset 0x1c. */
 883         if (inw(ioaddr + TxFree) <= 1536) {
 884                 netif_stop_queue(dev);
 885                 /* Interrupt us when the FIFO has room for max-sized packet.
 886                    The threshold is in units of dwords. */
 887                 outw(SetTxThreshold + (1536>>2), ioaddr + EL3_CMD);
 888         }
 889
 890         pop_tx_status(dev);
 891         spin_unlock_irqrestore(&lp->window_lock, flags);
 892         dev_kfree_skb(skb);
 893         return 0;
 894 }
 895
 896 /* The EL3 interrupt handler. */
 897 static irqreturn_t el3_interrupt(int irq, void *dev_id, struct pt_regs *regs)
 898 {
 899         struct net_device *dev = (struct net_device *) dev_id;
 900         struct el3_private *lp = netdev_priv(dev);
 901         kio_addr_t ioaddr;
 902         unsigned status;
 903         int work_budget = max_interrupt_work;
 904         int handled = 0;
 905
 906         if (!netif_device_present(dev))
 907                 return IRQ_NONE;
 908         ioaddr = dev->base_addr;
 909
 910         DEBUG(3, "%s: interrupt, status %4.4x.\n",
 911                   dev->name, inw(ioaddr + EL3_STATUS));
 912
 913         spin_lock(&lp->window_lock);
 914
 915         while ((status = inw(ioaddr + EL3_STATUS)) &
 916                    (IntLatch | RxComplete | RxEarly | StatsFull)) {
 917                 if (!netif_device_present(dev) ||
 918                         ((status & 0xe000) != 0x2000)) {
 919                         DEBUG(1, "%s: Interrupt from dead card\n", dev->name);
 920                         break;
 921                 }
 922
 923                 handled = 1;
 924
 925                 if (status & RxComplete)
 926                         work_budget = el3_rx(dev, work_budget);
 927
 928                 if (status & TxAvailable) {
 929                         DEBUG(3, "  TX room bit was handled.\n");
 930                         /* There's room in the FIFO for a full-sized packet. */
 931                         outw(AckIntr | TxAvailable, ioaddr + EL3_CMD);
 932                         netif_wake_queue(dev);
 933                 }
 934
 935                 if (status & TxComplete)
 936                         pop_tx_status(dev);
 937
 938                 if (status & (AdapterFailure | RxEarly | StatsFull)) {
 939                         /* Handle all uncommon interrupts. */
 940                         if (status & StatsFull)
 941                                 update_stats(dev);
 942                         if (status & RxEarly) {
 943                                 work_budget = el3_rx(dev, work_budget);
 944                                 outw(AckIntr | RxEarly, ioaddr + EL3_CMD);
 945                         }
 946                         if (status & AdapterFailure) {
 947                                 u16 fifo_diag;
 948                                 EL3WINDOW(4);
 949                                 fifo_diag = inw(ioaddr + Wn4_FIFODiag);
 950                                 EL3WINDOW(1);
 951                                 printk(KERN_NOTICE "%s: adapter failure, FIFO diagnostic"
 952                                            " register %04x.\n", dev->name, fifo_diag);
 953                                 if (fifo_diag & 0x0400) {
 954                                         /* Tx overrun */
 955                                         tc574_wait_for_completion(dev, TxReset);
 956                                         outw(TxEnable, ioaddr + EL3_CMD);
 957                                 }
 958                                 if (fifo_diag & 0x2000) {
 959                                         /* Rx underrun */
 960                                         tc574_wait_for_completion(dev, RxReset);
 961                                         set_rx_mode(dev);
 962                                         outw(RxEnable, ioaddr + EL3_CMD);
 963                                 }
 964                                 outw(AckIntr | AdapterFailure, ioaddr + EL3_CMD);
 965                         }
 966                 }
 967
 968                 if (--work_budget < 0) {
 969                         DEBUG(0, "%s: Too much work in interrupt, "
 970                                   "status %4.4x.\n", dev->name, status);
 971                         /* Clear all interrupts */
 972                         outw(AckIntr | 0xFF, ioaddr + EL3_CMD);
 973                         break;
 974                 }
 975                 /* Acknowledge the IRQ. */
 976                 outw(AckIntr | IntReq | IntLatch, ioaddr + EL3_CMD);
 977         }
 978
 979         DEBUG(3, "%s: exiting interrupt, status %4.4x.\n",
 980                   dev->name, inw(ioaddr + EL3_STATUS));
 981
 982         spin_unlock(&lp->window_lock);
 983         return IRQ_RETVAL(handled);
 984 }
 985
 986 /*
 987     This timer serves two purposes: to check for missed interrupts
 988         (and as a last resort, poll the NIC for events), and to monitor
 989         the MII, reporting changes in cable status.
 990 */
 991 static void media_check(unsigned long arg)
 992 {
 993         struct net_device *dev = (struct net_device *) arg;
 994         struct el3_private *lp = netdev_priv(dev);
 995         kio_addr_t ioaddr = dev->base_addr;
 996         unsigned long flags;
 997         unsigned short /* cable, */ media, partner;
 998
 999         if (!netif_device_present(dev))
1000                 goto reschedule;
1001
1002         /* Check for pending interrupt with expired latency timer: with
1003            this, we can limp along even if the interrupt is blocked */
1004         if ((inw(ioaddr + EL3_STATUS) & IntLatch) && (inb(ioaddr + Timer) == 0xff)) {
1005                 if (!lp->fast_poll)
1006                         printk(KERN_INFO "%s: interrupt(s) dropped!\n", dev->name);
1007                 el3_interrupt(dev->irq, lp, NULL);
1008                 lp->fast_poll = HZ;
1009         }
1010         if (lp->fast_poll) {
1011                 lp->fast_poll--;
1012                 lp->media.expires = jiffies + 2*HZ/100;
1013                 add_timer(&lp->media);
1014                 return;
1015         }
1016
1017         spin_lock_irqsave(&lp->window_lock, flags);
1018         EL3WINDOW(4);
1019         media = mdio_read(ioaddr, lp->phys, 1);
1020         partner = mdio_read(ioaddr, lp->phys, 5);
1021         EL3WINDOW(1);
1022
1023         if (media != lp->media_status) {
1024                 if ((media ^ lp->media_status) & 0x0004)
1025                         printk(KERN_INFO "%s: %s link beat\n", dev->name,
1026                                    (lp->media_status & 0x0004) ? "lost" : "found");
1027                 if ((media ^ lp->media_status) & 0x0020) {
1028                         lp->partner = 0;
1029                         if (lp->media_status & 0x0020) {
1030                                 printk(KERN_INFO "%s: autonegotiation restarted\n",
1031                                            dev->name);
1032                         } else if (partner) {
1033                                 partner &= lp->advertising;
1034                                 lp->partner = partner;
1035                                 printk(KERN_INFO "%s: autonegotiation complete: "
1036                                            "%sbaseT-%cD selected\n", dev->name,
1037                                            ((partner & 0x0180) ? "100" : "10"),
1038                                            ((partner & 0x0140) ? 'F' : 'H'));
1039                         } else {
1040                                 printk(KERN_INFO "%s: link partner did not autonegotiate\n",
1041                                            dev->name);
1042                         }
1043
1044                         EL3WINDOW(3);
1045                         outb((partner & 0x0140 ? 0x20 : 0) |
1046                                  (dev->mtu > 1500 ? 0x40 : 0), ioaddr + Wn3_MAC_Ctrl);
1047                         EL3WINDOW(1);
1048
1049                 }
1050                 if (media & 0x0010)
1051                         printk(KERN_INFO "%s: remote fault detected\n",
1052                                    dev->name);
1053                 if (media & 0x0002)
1054                         printk(KERN_INFO "%s: jabber detected\n", dev->name);
1055                 lp->media_status = media;
1056         }
1057         spin_unlock_irqrestore(&lp->window_lock, flags);
1058
1059 reschedule:
1060         lp->media.expires = jiffies + HZ;
1061         add_timer(&lp->media);
1062 }
1063
1064 static struct net_device_stats *el3_get_stats(struct net_device *dev)
1065 {
1066         struct el3_private *lp = netdev_priv(dev);
1067
1068         if (netif_device_present(dev)) {
1069                 unsigned long flags;
1070                 spin_lock_irqsave(&lp->window_lock, flags);
1071                 update_stats(dev);
1072                 spin_unlock_irqrestore(&lp->window_lock, flags);
1073         }
1074         return &lp->stats;
1075 }
1076
1077 /*  Update statistics.
1078         Suprisingly this need not be run single-threaded, but it effectively is.
1079         The counters clear when read, so the adds must merely be atomic.
1080  */
1081 static void update_stats(struct net_device *dev)
1082 {
1083         struct el3_private *lp = netdev_priv(dev);
1084         kio_addr_t ioaddr = dev->base_addr;
1085         u8 rx, tx, up;
1086
1087         DEBUG(2, "%s: updating the statistics.\n", dev->name);
1088
1089         if (inw(ioaddr+EL3_STATUS) == 0xffff) /* No card. */
1090                 return;
1091
1092         /* Unlike the 3c509 we need not turn off stats updates while reading. */
1093         /* Switch to the stats window, and read everything. */
1094         EL3WINDOW(6);
1095         lp->stats.tx_carrier_errors             += inb(ioaddr + 0);
1096         lp->stats.tx_heartbeat_errors           += inb(ioaddr + 1);
1097         /* Multiple collisions. */              inb(ioaddr + 2);
1098         lp->stats.collisions                    += inb(ioaddr + 3);
1099         lp->stats.tx_window_errors              += inb(ioaddr + 4);
1100         lp->stats.rx_fifo_errors                += inb(ioaddr + 5);
1101         lp->stats.tx_packets                    += inb(ioaddr + 6);
1102         up                                       = inb(ioaddr + 9);
1103         lp->stats.tx_packets                    += (up&0x30) << 4;
1104         /* Rx packets   */                         inb(ioaddr + 7);
1105         /* Tx deferrals */                         inb(ioaddr + 8);
1106         rx                                       = inw(ioaddr + 10);
1107         tx                                       = inw(ioaddr + 12);
1108
1109         EL3WINDOW(4);
1110         /* BadSSD */                               inb(ioaddr + 12);
1111         up                                       = inb(ioaddr + 13);
1112
1113         lp->stats.tx_bytes                      += tx + ((up & 0xf0) << 12);
1114
1115         EL3WINDOW(1);
1116 }
1117
1118 static int el3_rx(struct net_device *dev, int worklimit)
1119 {
1120         struct el3_private *lp = netdev_priv(dev);
1121         kio_addr_t ioaddr = dev->base_addr;
1122         short rx_status;
1123
1124         DEBUG(3, "%s: in rx_packet(), status %4.4x, rx_status %4.4x.\n",
1125                   dev->name, inw(ioaddr+EL3_STATUS), inw(ioaddr+RxStatus));
1126         while (!((rx_status = inw(ioaddr + RxStatus)) & 0x8000) &&
1127                    (--worklimit >= 0)) {
1128                 if (rx_status & 0x4000) { /* Error, update stats. */
1129                         short error = rx_status & 0x3800;
1130                         lp->stats.rx_errors++;
1131                         switch (error) {
1132                         case 0x0000:    lp->stats.rx_over_errors++; break;
1133                         case 0x0800:    lp->stats.rx_length_errors++; break;
1134                         case 0x1000:    lp->stats.rx_frame_errors++; break;
1135                         case 0x1800:    lp->stats.rx_length_errors++; break;
1136                         case 0x2000:    lp->stats.rx_frame_errors++; break;
1137                         case 0x2800:    lp->stats.rx_crc_errors++; break;
1138                         }
1139                 } else {
1140                         short pkt_len = rx_status & 0x7ff;
1141                         struct sk_buff *skb;
1142
1143                         skb = dev_alloc_skb(pkt_len+5);
1144
1145                         DEBUG(3, "  Receiving packet size %d status %4.4x.\n",
1146                                   pkt_len, rx_status);
1147                         if (skb != NULL) {
1148                                 skb->dev = dev;
1149                                 skb_reserve(skb, 2);
1150                                 insl(ioaddr+RX_FIFO, skb_put(skb, pkt_len),
1151                                                 ((pkt_len+3)>>2));
1152                                 skb->protocol = eth_type_trans(skb, dev);
1153                                 netif_rx(skb);
1154                                 dev->last_rx = jiffies;
1155                                 lp->stats.rx_packets++;
1156                                 lp->stats.rx_bytes += pkt_len;
1157                         } else {
1158                                 DEBUG(1, "%s: couldn't allocate a sk_buff of"
1159                                           " size %d.\n", dev->name, pkt_len);
1160                                 lp->stats.rx_dropped++;
1161                         }
1162                 }
1163                 tc574_wait_for_completion(dev, RxDiscard);
1164         }
1165
1166         return worklimit;
1167 }
1168
1169 static void netdev_get_drvinfo(struct net_device *dev,
1170                                struct ethtool_drvinfo *info)
1171 {
1172         strcpy(info->driver, "3c574_cs");
1173 }
1174
1175 static struct ethtool_ops netdev_ethtool_ops = {
1176         .get_drvinfo            = netdev_get_drvinfo,
1177 };
1178
1179 /* Provide ioctl() calls to examine the MII xcvr state. */
1180 static int el3_ioctl(struct net_device *dev, struct ifreq *rq, int cmd)
1181 {
1182         struct el3_private *lp = netdev_priv(dev);
1183         kio_addr_t ioaddr = dev->base_addr;
1184         u16 *data = (u16 *)&rq->ifr_ifru;
1185         int phy = lp->phys & 0x1f;
1186
1187         DEBUG(2, "%s: In ioct(%-.6s, %#4.4x) %4.4x %4.4x %4.4x %4.4x.\n",
1188                   dev->name, rq->ifr_ifrn.ifrn_name, cmd,
1189                   data[0], data[1], data[2], data[3]);
1190
1191         switch(cmd) {
1192         case SIOCGMIIPHY:               /* Get the address of the PHY in use. */
1193                 data[0] = phy;
1194         case SIOCGMIIREG:               /* Read the specified MII register. */
1195                 {
1196                         int saved_window;
1197                         unsigned long flags;
1198
1199                         spin_lock_irqsave(&lp->window_lock, flags);
1200                         saved_window = inw(ioaddr + EL3_CMD) >> 13;
1201                         EL3WINDOW(4);
1202                         data[3] = mdio_read(ioaddr, data[0] & 0x1f, data[1] & 0x1f);
1203                         EL3WINDOW(saved_window);
1204                         spin_unlock_irqrestore(&lp->window_lock, flags);
1205                         return 0;
1206                 }
1207         case SIOCSMIIREG:               /* Write the specified MII register */
1208                 {
1209                         int saved_window;
1210                        unsigned long flags;
1211
1212                         if (!capable(CAP_NET_ADMIN))
1213                                 return -EPERM;
1214                         spin_lock_irqsave(&lp->window_lock, flags);
1215                         saved_window = inw(ioaddr + EL3_CMD) >> 13;
1216                         EL3WINDOW(4);
1217                         mdio_write(ioaddr, data[0] & 0x1f, data[1] & 0x1f, data[2]);
1218                         EL3WINDOW(saved_window);
1219                         spin_unlock_irqrestore(&lp->window_lock, flags);
1220                         return 0;
1221                 }
1222         default:
1223                 return -EOPNOTSUPP;
1224         }
1225 }
1226
1227 /* The Odie chip has a 64 bin multicast filter, but the bit layout is not
1228    documented.  Until it is we revert to receiving all multicast frames when
1229    any multicast reception is desired.
1230    Note: My other drivers emit a log message whenever promiscuous mode is
1231    entered to help detect password sniffers.  This is less desirable on
1232    typical PC card machines, so we omit the message.
1233    */
1234
1235 static void set_rx_mode(struct net_device *dev)
1236 {
1237         kio_addr_t ioaddr = dev->base_addr;
1238
1239         if (dev->flags & IFF_PROMISC)
1240                 outw(SetRxFilter | RxStation | RxMulticast | RxBroadcast | RxProm,
1241                          ioaddr + EL3_CMD);
1242         else if (dev->mc_count || (dev->flags & IFF_ALLMULTI))
1243                 outw(SetRxFilter|RxStation|RxMulticast|RxBroadcast, ioaddr + EL3_CMD);
1244         else
1245                 outw(SetRxFilter | RxStation | RxBroadcast, ioaddr + EL3_CMD);
1246 }
1247
1248 static int el3_close(struct net_device *dev)
1249 {
1250         kio_addr_t ioaddr = dev->base_addr;
1251         struct el3_private *lp = netdev_priv(dev);
1252         dev_link_t *link = &lp->link;
1253
1254         DEBUG(2, "%s: shutting down ethercard.\n", dev->name);
1255
1256         if (DEV_OK(link)) {
1257                 unsigned long flags;
1258
1259                 /* Turn off statistics ASAP.  We update lp->stats below. */
1260                 outw(StatsDisable, ioaddr + EL3_CMD);
1261
1262                 /* Disable the receiver and transmitter. */
1263                 outw(RxDisable, ioaddr + EL3_CMD);
1264                 outw(TxDisable, ioaddr + EL3_CMD);
1265
1266                 /* Note: Switching to window 0 may disable the IRQ. */
1267                 EL3WINDOW(0);
1268                 spin_lock_irqsave(&lp->window_lock, flags);
1269                 update_stats(dev);
1270                 spin_unlock_irqrestore(&lp->window_lock, flags);
1271
1272                 /* force interrupts off */
1273                 outw(SetIntrEnb | 0x0000, ioaddr + EL3_CMD);
1274         }
1275
1276         link->open--;
1277         netif_stop_queue(dev);
1278         del_timer_sync(&lp->media);
1279
1280         return 0;
1281 }
1282
1283 static struct pcmcia_device_id tc574_ids[] = {
1284         PCMCIA_DEVICE_MANF_CARD(0x0101, 0x0574),
1285         PCMCIA_MFC_DEVICE_CIS_MANF_CARD(0, 0x0101, 0x0556, "3CCFEM556.cis"),
1286         PCMCIA_DEVICE_NULL,
1287 };
1288 MODULE_DEVICE_TABLE(pcmcia, tc574_ids);
1289
1290 static struct pcmcia_driver tc574_driver = {
1291         .owner          = THIS_MODULE,
1292         .drv            = {
1293                 .name   = "3c574_cs",
1294         },
1295         .attach         = tc574_attach,
1296         .event          = tc574_event,
1297         .detach         = tc574_detach,
1298         .id_table       = tc574_ids,
1299 };
1300
1301 static int __init init_tc574(void)
1302 {
1303         return pcmcia_register_driver(&tc574_driver);
1304 }
1305
1306 static void __exit exit_tc574(void)
1307 {
1308         pcmcia_unregister_driver(&tc574_driver);
1309         BUG_ON(dev_list != NULL);
1310 }
1311
1312 module_init(init_tc574);
1313 module_exit(exit_tc574);