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