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

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