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