drivers/net/pcmcia/3c574_cs.c

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