linux/drivers/net/ethernet/3com/3c574_cs.c
<<
>>
Prefs
   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
  22I. Board Compatibility
  23
  24This device driver is designed for the 3Com 3c574 PC card Fast Ethernet
  25Adapter.
  26
  27II. Board-specific settings
  28
  29None -- PC cards are autoconfigured.
  30
  31III. Driver operation
  32
  33The 3c574 uses a Boomerang-style interface, without the bus-master capability.
  34See the Boomerang driver and documentation for most details.
  35
  36IV. Notes and chip documentation.
  37
  38Two added registers are used to enhance PIO performance, RunnerRdCtrl and
  39RunnerWrCtrl.  These are 11 bit down-counters that are preloaded with the
  40count of word (16 bits) reads or writes the driver is about to do to the Rx
  41or Tx FIFO.  The chip is then able to hide the internal-PCI-bus to PC-card
  42translation latency by buffering the I/O operations with an 8 word FIFO.
  43Note: No other chip accesses are permitted when this buffer is used.
  44
  45A second enhancement is that both attribute and common memory space
  460x0800-0x0fff can translated to the PIO FIFO.  Thus memory operations (faster
  47with *some* PCcard bridges) may be used instead of I/O operations.
  48This is enabled by setting the 0x10 bit in the PCMCIA LAN COR.
  49
  50Some slow PC card bridges work better if they never see a WAIT signal.
  51This is configured by setting the 0x20 bit in the PCMCIA LAN COR.
  52Only do this after testing that it is reliable and improves performance.
  53
  54The upper five bits of RunnerRdCtrl are used to window into PCcard
  55configuration space registers.  Window 0 is the regular Boomerang/Odie
  56register set, 1-5 are various PC card control registers, and 16-31 are
  57the (reversed!) CIS table.
  58
  59A final note: writing the InternalConfig register in window 3 with an
  60invalid ramWidth is Very Bad.
  61
  62V. References
  63
  64http://www.scyld.com/expert/NWay.html
  65http://www.national.com/opf/DP/DP83840A.html
  66
  67Thanks to Terry Murphy of 3Com for providing development information for
  68earlier 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
 102MODULE_AUTHOR("David Hinds <dahinds@users.sourceforge.net>");
 103MODULE_DESCRIPTION("3Com 3c574 series PCMCIA ethernet driver");
 104MODULE_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. */
 109INT_MODULE_PARM(max_interrupt_work, 32);
 110
 111/* Force full duplex modes? */
 112INT_MODULE_PARM(full_duplex, 0);
 113
 114/* Autodetect link polarity reversal? */
 115INT_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. */
 135enum 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
 145enum 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: */
 151enum RxFilter {
 152        RxStation = 1, RxMulticast = 2, RxBroadcast = 4, RxProm = 8
 153};
 154
 155enum Window0 {
 156        Wn0EepromCmd = 10, Wn0EepromData = 12, /* EEPROM command/address, data. */
 157        IntrStatus=0x0E,                /* Valid in all windows. */
 158};
 159/* These assumes the larger EEPROM. */
 160enum 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. */
 169enum 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
 176enum Window3 {                  /* Window 3: MAC/config bits. */
 177        Wn3_Config=0, Wn3_MAC_Ctrl=6, Wn3_Options=8,
 178};
 179enum 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
 191enum 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
 197struct 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. */
 213static char mii_preamble_required = 0;
 214
 215/* Index of functions. */
 216
 217static int tc574_config(struct pcmcia_device *link);
 218static void tc574_release(struct pcmcia_device *link);
 219
 220static void mdio_sync(unsigned int ioaddr, int bits);
 221static int mdio_read(unsigned int ioaddr, int phy_id, int location);
 222static void mdio_write(unsigned int ioaddr, int phy_id, int location,
 223                       int value);
 224static unsigned short read_eeprom(unsigned int ioaddr, int index);
 225static void tc574_wait_for_completion(struct net_device *dev, int cmd);
 226
 227static void tc574_reset(struct net_device *dev);
 228static void media_check(struct timer_list *t);
 229static int el3_open(struct net_device *dev);
 230static netdev_tx_t el3_start_xmit(struct sk_buff *skb,
 231                                        struct net_device *dev);
 232static irqreturn_t el3_interrupt(int irq, void *dev_id);
 233static void update_stats(struct net_device *dev);
 234static struct net_device_stats *el3_get_stats(struct net_device *dev);
 235static int el3_rx(struct net_device *dev, int worklimit);
 236static int el3_close(struct net_device *dev);
 237static void el3_tx_timeout(struct net_device *dev, unsigned int txqueue);
 238static int el3_ioctl(struct net_device *dev, struct ifreq *rq, int cmd);
 239static void set_rx_mode(struct net_device *dev);
 240static void set_multicast_list(struct net_device *dev);
 241
 242static 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*/
 249static 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
 261static 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
 288static 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
 301static const char *ram_split[] = {"5:3", "3:1", "1:1", "3:5"};
 302
 303static 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
 439failed:
 440        tc574_release(link);
 441        return -ENODEV;
 442
 443} /* tc574_config */
 444
 445static void tc574_release(struct pcmcia_device *link)
 446{
 447        pcmcia_disable_device(link);
 448}
 449
 450static 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
 460static 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
 472static 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*/
 490static 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 */
 503static 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. */
 531static 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
 542static 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
 567static 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. */
 590static 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
 672static 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
 693static void el3_tx_timeout(struct net_device *dev, unsigned int txqueue)
 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
 707static 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
 730static 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. */
 766static 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*/
 860static 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
 929reschedule:
 930        lp->media.expires = jiffies + HZ;
 931        add_timer(&lp->media);
 932}
 933
 934static 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 */
 951static 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
 985static 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. */
1035static 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
1091static 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
1104static 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
1114static 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
1149static 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};
1154MODULE_DEVICE_TABLE(pcmcia, tc574_ids);
1155
1156static 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};
1165module_pcmcia_driver(tc574_driver);
1166