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