drivers/net/ethernet/3com/3c574

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

DEFINITIONS
