linux/drivers/net/ethernet/3com/3c515.c
<<
>>
Prefs
   1/*
   2        Written 1997-1998 by Donald Becker.
   3
   4        This software may be used and distributed according to the terms
   5        of the GNU General Public License, incorporated herein by reference.
   6
   7        This driver is for the 3Com ISA EtherLink XL "Corkscrew" 3c515 ethercard.
   8
   9        The author may be reached as becker@scyld.com, or C/O
  10        Scyld Computing Corporation
  11        410 Severn Ave., Suite 210
  12        Annapolis MD 21403
  13
  14
  15        2000/2/2- Added support for kernel-level ISAPnP
  16                by Stephen Frost <sfrost@snowman.net> and Alessandro Zummo
  17        Cleaned up for 2.3.x/softnet by Jeff Garzik and Alan Cox.
  18
  19        2001/11/17 - Added ethtool support (jgarzik)
  20
  21        2002/10/28 - Locking updates for 2.5 (alan@lxorguk.ukuu.org.uk)
  22
  23*/
  24
  25#define DRV_NAME                "3c515"
  26#define DRV_VERSION             "0.99t-ac"
  27#define DRV_RELDATE             "28-Oct-2002"
  28
  29static char *version =
  30DRV_NAME ".c:v" DRV_VERSION " " DRV_RELDATE " becker@scyld.com and others\n";
  31
  32#define CORKSCREW 1
  33
  34/* "Knobs" that adjust features and parameters. */
  35/* Set the copy breakpoint for the copy-only-tiny-frames scheme.
  36   Setting to > 1512 effectively disables this feature. */
  37static int rx_copybreak = 200;
  38
  39/* Allow setting MTU to a larger size, bypassing the normal ethernet setup. */
  40static const int mtu = 1500;
  41
  42/* Maximum events (Rx packets, etc.) to handle at each interrupt. */
  43static int max_interrupt_work = 20;
  44
  45/* Enable the automatic media selection code -- usually set. */
  46#define AUTOMEDIA 1
  47
  48/* Allow the use of fragment bus master transfers instead of only
  49   programmed-I/O for Vortex cards.  Full-bus-master transfers are always
  50   enabled by default on Boomerang cards.  If VORTEX_BUS_MASTER is defined,
  51   the feature may be turned on using 'options'. */
  52#define VORTEX_BUS_MASTER
  53
  54/* A few values that may be tweaked. */
  55/* Keep the ring sizes a power of two for efficiency. */
  56#define TX_RING_SIZE    16
  57#define RX_RING_SIZE    16
  58#define PKT_BUF_SZ              1536    /* Size of each temporary Rx buffer. */
  59
  60#include <linux/module.h>
  61#include <linux/isapnp.h>
  62#include <linux/kernel.h>
  63#include <linux/netdevice.h>
  64#include <linux/string.h>
  65#include <linux/errno.h>
  66#include <linux/in.h>
  67#include <linux/ioport.h>
  68#include <linux/skbuff.h>
  69#include <linux/etherdevice.h>
  70#include <linux/interrupt.h>
  71#include <linux/timer.h>
  72#include <linux/ethtool.h>
  73#include <linux/bitops.h>
  74
  75#include <linux/uaccess.h>
  76#include <asm/io.h>
  77#include <asm/dma.h>
  78
  79#define NEW_MULTICAST
  80#include <linux/delay.h>
  81
  82#define MAX_UNITS 8
  83
  84MODULE_AUTHOR("Donald Becker <becker@scyld.com>");
  85MODULE_DESCRIPTION("3Com 3c515 Corkscrew driver");
  86MODULE_LICENSE("GPL");
  87MODULE_VERSION(DRV_VERSION);
  88
  89/* "Knobs" for adjusting internal parameters. */
  90/* Put out somewhat more debugging messages. (0 - no msg, 1 minimal msgs). */
  91#define DRIVER_DEBUG 1
  92/* Some values here only for performance evaluation and path-coverage
  93   debugging. */
  94static int rx_nocopy, rx_copy, queued_packet;
  95
  96/* Number of times to check to see if the Tx FIFO has space, used in some
  97   limited cases. */
  98#define WAIT_TX_AVAIL 200
  99
 100/* Operational parameter that usually are not changed. */
 101#define TX_TIMEOUT  ((4*HZ)/10) /* Time in jiffies before concluding Tx hung */
 102
 103/* The size here is somewhat misleading: the Corkscrew also uses the ISA
 104   aliased registers at <base>+0x400.
 105   */
 106#define CORKSCREW_TOTAL_SIZE 0x20
 107
 108#ifdef DRIVER_DEBUG
 109static int corkscrew_debug = DRIVER_DEBUG;
 110#else
 111static int corkscrew_debug = 1;
 112#endif
 113
 114#define CORKSCREW_ID 10
 115
 116/*
 117                                Theory of Operation
 118
 119I. Board Compatibility
 120
 121This device driver is designed for the 3Com 3c515 ISA Fast EtherLink XL,
 1223Com's ISA bus adapter for Fast Ethernet.  Due to the unique I/O port layout,
 123it's not practical to integrate this driver with the other EtherLink drivers.
 124
 125II. Board-specific settings
 126
 127The Corkscrew has an EEPROM for configuration, but no special settings are
 128needed for Linux.
 129
 130III. Driver operation
 131
 132The 3c515 series use an interface that's very similar to the 3c900 "Boomerang"
 133PCI cards, with the bus master interface extensively modified to work with
 134the ISA bus.
 135
 136The card is capable of full-bus-master transfers with separate
 137lists of transmit and receive descriptors, similar to the AMD LANCE/PCnet,
 138DEC Tulip and Intel Speedo3.
 139
 140This driver uses a "RX_COPYBREAK" scheme rather than a fixed intermediate
 141receive buffer.  This scheme allocates full-sized skbuffs as receive
 142buffers.  The value RX_COPYBREAK is used as the copying breakpoint: it is
 143chosen to trade-off the memory wasted by passing the full-sized skbuff to
 144the queue layer for all frames vs. the copying cost of copying a frame to a
 145correctly-sized skbuff.
 146
 147
 148IIIC. Synchronization
 149The driver runs as two independent, single-threaded flows of control.  One
 150is the send-packet routine, which enforces single-threaded use by the netif
 151layer.  The other thread is the interrupt handler, which is single
 152threaded by the hardware and other software.
 153
 154IV. Notes
 155
 156Thanks to Terry Murphy of 3Com for providing documentation and a development
 157board.
 158
 159The names "Vortex", "Boomerang" and "Corkscrew" are the internal 3Com
 160project names.  I use these names to eliminate confusion -- 3Com product
 161numbers and names are very similar and often confused.
 162
 163The new chips support both ethernet (1.5K) and FDDI (4.5K) frame sizes!
 164This driver only supports ethernet frames because of the recent MTU limit
 165of 1.5K, but the changes to support 4.5K are minimal.
 166*/
 167
 168/* Operational definitions.
 169   These are not used by other compilation units and thus are not
 170   exported in a ".h" file.
 171
 172   First the windows.  There are eight register windows, with the command
 173   and status registers available in each.
 174   */
 175#define EL3WINDOW(win_num) outw(SelectWindow + (win_num), ioaddr + EL3_CMD)
 176#define EL3_CMD 0x0e
 177#define EL3_STATUS 0x0e
 178
 179/* The top five bits written to EL3_CMD are a command, the lower
 180   11 bits are the parameter, if applicable.
 181   Note that 11 parameters bits was fine for ethernet, but the new chips
 182   can handle FDDI length frames (~4500 octets) and now parameters count
 183   32-bit 'Dwords' rather than octets. */
 184
 185enum corkscrew_cmd {
 186        TotalReset = 0 << 11, SelectWindow = 1 << 11, StartCoax = 2 << 11,
 187        RxDisable = 3 << 11, RxEnable = 4 << 11, RxReset = 5 << 11,
 188        UpStall = 6 << 11, UpUnstall = (6 << 11) + 1, DownStall = (6 << 11) + 2,
 189        DownUnstall = (6 << 11) + 3, RxDiscard = 8 << 11, TxEnable = 9 << 11,
 190        TxDisable = 10 << 11, TxReset = 11 << 11, FakeIntr = 12 << 11,
 191        AckIntr = 13 << 11, SetIntrEnb = 14 << 11, SetStatusEnb = 15 << 11,
 192        SetRxFilter = 16 << 11, SetRxThreshold = 17 << 11,
 193        SetTxThreshold = 18 << 11, SetTxStart = 19 << 11, StartDMAUp = 20 << 11,
 194        StartDMADown = (20 << 11) + 1, StatsEnable = 21 << 11,
 195        StatsDisable = 22 << 11, StopCoax = 23 << 11,
 196};
 197
 198/* The SetRxFilter command accepts the following classes: */
 199enum RxFilter {
 200        RxStation = 1, RxMulticast = 2, RxBroadcast = 4, RxProm = 8
 201};
 202
 203/* Bits in the general status register. */
 204enum corkscrew_status {
 205        IntLatch = 0x0001, AdapterFailure = 0x0002, TxComplete = 0x0004,
 206        TxAvailable = 0x0008, RxComplete = 0x0010, RxEarly = 0x0020,
 207        IntReq = 0x0040, StatsFull = 0x0080,
 208        DMADone = 1 << 8, DownComplete = 1 << 9, UpComplete = 1 << 10,
 209        DMAInProgress = 1 << 11,        /* DMA controller is still busy. */
 210        CmdInProgress = 1 << 12,        /* EL3_CMD is still busy. */
 211};
 212
 213/* Register window 1 offsets, the window used in normal operation.
 214   On the Corkscrew this window is always mapped at offsets 0x10-0x1f. */
 215enum Window1 {
 216        TX_FIFO = 0x10, RX_FIFO = 0x10, RxErrors = 0x14,
 217        RxStatus = 0x18, Timer = 0x1A, TxStatus = 0x1B,
 218        TxFree = 0x1C,          /* Remaining free bytes in Tx buffer. */
 219};
 220enum Window0 {
 221        Wn0IRQ = 0x08,
 222#if defined(CORKSCREW)
 223        Wn0EepromCmd = 0x200A,  /* Corkscrew EEPROM command register. */
 224        Wn0EepromData = 0x200C, /* Corkscrew EEPROM results register. */
 225#else
 226        Wn0EepromCmd = 10,      /* Window 0: EEPROM command register. */
 227        Wn0EepromData = 12,     /* Window 0: EEPROM results register. */
 228#endif
 229};
 230enum Win0_EEPROM_bits {
 231        EEPROM_Read = 0x80, EEPROM_WRITE = 0x40, EEPROM_ERASE = 0xC0,
 232        EEPROM_EWENB = 0x30,    /* Enable erasing/writing for 10 msec. */
 233        EEPROM_EWDIS = 0x00,    /* Disable EWENB before 10 msec timeout. */
 234};
 235
 236/* EEPROM locations. */
 237enum eeprom_offset {
 238        PhysAddr01 = 0, PhysAddr23 = 1, PhysAddr45 = 2, ModelID = 3,
 239        EtherLink3ID = 7,
 240};
 241
 242enum Window3 {                  /* Window 3: MAC/config bits. */
 243        Wn3_Config = 0, Wn3_MAC_Ctrl = 6, Wn3_Options = 8,
 244};
 245enum wn3_config {
 246        Ram_size = 7,
 247        Ram_width = 8,
 248        Ram_speed = 0x30,
 249        Rom_size = 0xc0,
 250        Ram_split_shift = 16,
 251        Ram_split = 3 << Ram_split_shift,
 252        Xcvr_shift = 20,
 253        Xcvr = 7 << Xcvr_shift,
 254        Autoselect = 0x1000000,
 255};
 256
 257enum Window4 {
 258        Wn4_NetDiag = 6, Wn4_Media = 10,        /* Window 4: Xcvr/media bits. */
 259};
 260enum Win4_Media_bits {
 261        Media_SQE = 0x0008,     /* Enable SQE error counting for AUI. */
 262        Media_10TP = 0x00C0,    /* Enable link beat and jabber for 10baseT. */
 263        Media_Lnk = 0x0080,     /* Enable just link beat for 100TX/100FX. */
 264        Media_LnkBeat = 0x0800,
 265};
 266enum Window7 {                  /* Window 7: Bus Master control. */
 267        Wn7_MasterAddr = 0, Wn7_MasterLen = 6, Wn7_MasterStatus = 12,
 268};
 269
 270/* Boomerang-style bus master control registers.  Note ISA aliases! */
 271enum MasterCtrl {
 272        PktStatus = 0x400, DownListPtr = 0x404, FragAddr = 0x408, FragLen =
 273            0x40c,
 274        TxFreeThreshold = 0x40f, UpPktStatus = 0x410, UpListPtr = 0x418,
 275};
 276
 277/* The Rx and Tx descriptor lists.
 278   Caution Alpha hackers: these types are 32 bits!  Note also the 8 byte
 279   alignment contraint on tx_ring[] and rx_ring[]. */
 280struct boom_rx_desc {
 281        u32 next;
 282        s32 status;
 283        u32 addr;
 284        s32 length;
 285};
 286
 287/* Values for the Rx status entry. */
 288enum rx_desc_status {
 289        RxDComplete = 0x00008000, RxDError = 0x4000,
 290        /* See boomerang_rx() for actual error bits */
 291};
 292
 293struct boom_tx_desc {
 294        u32 next;
 295        s32 status;
 296        u32 addr;
 297        s32 length;
 298};
 299
 300struct corkscrew_private {
 301        const char *product_name;
 302        struct list_head list;
 303        struct net_device *our_dev;
 304        /* The Rx and Tx rings are here to keep them quad-word-aligned. */
 305        struct boom_rx_desc rx_ring[RX_RING_SIZE];
 306        struct boom_tx_desc tx_ring[TX_RING_SIZE];
 307        /* The addresses of transmit- and receive-in-place skbuffs. */
 308        struct sk_buff *rx_skbuff[RX_RING_SIZE];
 309        struct sk_buff *tx_skbuff[TX_RING_SIZE];
 310        unsigned int cur_rx, cur_tx;    /* The next free ring entry */
 311        unsigned int dirty_rx, dirty_tx;/* The ring entries to be free()ed. */
 312        struct sk_buff *tx_skb; /* Packet being eaten by bus master ctrl.  */
 313        struct timer_list timer;        /* Media selection timer. */
 314        int capabilities        ;       /* Adapter capabilities word. */
 315        int options;                    /* User-settable misc. driver options. */
 316        int last_rx_packets;            /* For media autoselection. */
 317        unsigned int available_media:8, /* From Wn3_Options */
 318                media_override:3,       /* Passed-in media type. */
 319                default_media:3,        /* Read from the EEPROM. */
 320                full_duplex:1, autoselect:1, bus_master:1,      /* Vortex can only do a fragment bus-m. */
 321                full_bus_master_tx:1, full_bus_master_rx:1,     /* Boomerang  */
 322                tx_full:1;
 323        spinlock_t lock;
 324        struct device *dev;
 325};
 326
 327/* The action to take with a media selection timer tick.
 328   Note that we deviate from the 3Com order by checking 10base2 before AUI.
 329 */
 330enum xcvr_types {
 331        XCVR_10baseT = 0, XCVR_AUI, XCVR_10baseTOnly, XCVR_10base2, XCVR_100baseTx,
 332        XCVR_100baseFx, XCVR_MII = 6, XCVR_Default = 8,
 333};
 334
 335static struct media_table {
 336        char *name;
 337        unsigned int media_bits:16,     /* Bits to set in Wn4_Media register. */
 338                mask:8,                 /* The transceiver-present bit in Wn3_Config. */
 339                next:8;                 /* The media type to try next. */
 340        short wait;                     /* Time before we check media status. */
 341} media_tbl[] = {
 342        { "10baseT", Media_10TP, 0x08, XCVR_10base2, (14 * HZ) / 10 },
 343        { "10Mbs AUI", Media_SQE, 0x20, XCVR_Default, (1 * HZ) / 10},
 344        { "undefined", 0, 0x80, XCVR_10baseT, 10000},
 345        { "10base2", 0, 0x10, XCVR_AUI, (1 * HZ) / 10},
 346        { "100baseTX", Media_Lnk, 0x02, XCVR_100baseFx, (14 * HZ) / 10},
 347        { "100baseFX", Media_Lnk, 0x04, XCVR_MII, (14 * HZ) / 10},
 348        { "MII", 0, 0x40, XCVR_10baseT, 3 * HZ},
 349        { "undefined", 0, 0x01, XCVR_10baseT, 10000},
 350        { "Default", 0, 0xFF, XCVR_10baseT, 10000},
 351};
 352
 353#ifdef __ISAPNP__
 354static struct isapnp_device_id corkscrew_isapnp_adapters[] = {
 355        {       ISAPNP_ANY_ID, ISAPNP_ANY_ID,
 356                ISAPNP_VENDOR('T', 'C', 'M'), ISAPNP_FUNCTION(0x5051),
 357                (long) "3Com Fast EtherLink ISA" },
 358        { }     /* terminate list */
 359};
 360
 361MODULE_DEVICE_TABLE(isapnp, corkscrew_isapnp_adapters);
 362
 363static int nopnp;
 364#endif /* __ISAPNP__ */
 365
 366static struct net_device *corkscrew_scan(int unit);
 367static int corkscrew_setup(struct net_device *dev, int ioaddr,
 368                            struct pnp_dev *idev, int card_number);
 369static int corkscrew_open(struct net_device *dev);
 370static void corkscrew_timer(struct timer_list *t);
 371static netdev_tx_t corkscrew_start_xmit(struct sk_buff *skb,
 372                                        struct net_device *dev);
 373static int corkscrew_rx(struct net_device *dev);
 374static void corkscrew_timeout(struct net_device *dev);
 375static int boomerang_rx(struct net_device *dev);
 376static irqreturn_t corkscrew_interrupt(int irq, void *dev_id);
 377static int corkscrew_close(struct net_device *dev);
 378static void update_stats(int addr, struct net_device *dev);
 379static struct net_device_stats *corkscrew_get_stats(struct net_device *dev);
 380static void set_rx_mode(struct net_device *dev);
 381static const struct ethtool_ops netdev_ethtool_ops;
 382
 383
 384/*
 385   Unfortunately maximizing the shared code between the integrated and
 386   module version of the driver results in a complicated set of initialization
 387   procedures.
 388   init_module() -- modules /  tc59x_init()  -- built-in
 389                The wrappers for corkscrew_scan()
 390   corkscrew_scan()              The common routine that scans for PCI and EISA cards
 391   corkscrew_found_device() Allocate a device structure when we find a card.
 392                                        Different versions exist for modules and built-in.
 393   corkscrew_probe1()           Fill in the device structure -- this is separated
 394                                        so that the modules code can put it in dev->init.
 395*/
 396/* This driver uses 'options' to pass the media type, full-duplex flag, etc. */
 397/* Note: this is the only limit on the number of cards supported!! */
 398static int options[MAX_UNITS] = { -1, -1, -1, -1, -1, -1, -1, -1, };
 399
 400#ifdef MODULE
 401static int debug = -1;
 402
 403module_param(debug, int, 0);
 404module_param_array(options, int, NULL, 0);
 405module_param(rx_copybreak, int, 0);
 406module_param(max_interrupt_work, int, 0);
 407MODULE_PARM_DESC(debug, "3c515 debug level (0-6)");
 408MODULE_PARM_DESC(options, "3c515: Bits 0-2: media type, bit 3: full duplex, bit 4: bus mastering");
 409MODULE_PARM_DESC(rx_copybreak, "3c515 copy breakpoint for copy-only-tiny-frames");
 410MODULE_PARM_DESC(max_interrupt_work, "3c515 maximum events handled per interrupt");
 411
 412/* A list of all installed Vortex devices, for removing the driver module. */
 413/* we will need locking (and refcounting) if we ever use it for more */
 414static LIST_HEAD(root_corkscrew_dev);
 415
 416int init_module(void)
 417{
 418        int found = 0;
 419        if (debug >= 0)
 420                corkscrew_debug = debug;
 421        if (corkscrew_debug)
 422                pr_debug("%s", version);
 423        while (corkscrew_scan(-1))
 424                found++;
 425        return found ? 0 : -ENODEV;
 426}
 427
 428#else
 429struct net_device *tc515_probe(int unit)
 430{
 431        struct net_device *dev = corkscrew_scan(unit);
 432        static int printed;
 433
 434        if (!dev)
 435                return ERR_PTR(-ENODEV);
 436
 437        if (corkscrew_debug > 0 && !printed) {
 438                printed = 1;
 439                pr_debug("%s", version);
 440        }
 441
 442        return dev;
 443}
 444#endif                          /* not MODULE */
 445
 446static int check_device(unsigned ioaddr)
 447{
 448        int timer;
 449
 450        if (!request_region(ioaddr, CORKSCREW_TOTAL_SIZE, "3c515"))
 451                return 0;
 452        /* Check the resource configuration for a matching ioaddr. */
 453        if ((inw(ioaddr + 0x2002) & 0x1f0) != (ioaddr & 0x1f0)) {
 454                release_region(ioaddr, CORKSCREW_TOTAL_SIZE);
 455                return 0;
 456        }
 457        /* Verify by reading the device ID from the EEPROM. */
 458        outw(EEPROM_Read + 7, ioaddr + Wn0EepromCmd);
 459        /* Pause for at least 162 us. for the read to take place. */
 460        for (timer = 4; timer >= 0; timer--) {
 461                udelay(162);
 462                if ((inw(ioaddr + Wn0EepromCmd) & 0x0200) == 0)
 463                        break;
 464        }
 465        if (inw(ioaddr + Wn0EepromData) != 0x6d50) {
 466                release_region(ioaddr, CORKSCREW_TOTAL_SIZE);
 467                return 0;
 468        }
 469        return 1;
 470}
 471
 472static void cleanup_card(struct net_device *dev)
 473{
 474        struct corkscrew_private *vp = netdev_priv(dev);
 475        list_del_init(&vp->list);
 476        if (dev->dma)
 477                free_dma(dev->dma);
 478        outw(TotalReset, dev->base_addr + EL3_CMD);
 479        release_region(dev->base_addr, CORKSCREW_TOTAL_SIZE);
 480        if (vp->dev)
 481                pnp_device_detach(to_pnp_dev(vp->dev));
 482}
 483
 484static struct net_device *corkscrew_scan(int unit)
 485{
 486        struct net_device *dev;
 487        static int cards_found = 0;
 488        static int ioaddr;
 489        int err;
 490#ifdef __ISAPNP__
 491        short i;
 492        static int pnp_cards;
 493#endif
 494
 495        dev = alloc_etherdev(sizeof(struct corkscrew_private));
 496        if (!dev)
 497                return ERR_PTR(-ENOMEM);
 498
 499        if (unit >= 0) {
 500                sprintf(dev->name, "eth%d", unit);
 501                netdev_boot_setup_check(dev);
 502        }
 503
 504#ifdef __ISAPNP__
 505        if(nopnp == 1)
 506                goto no_pnp;
 507        for(i=0; corkscrew_isapnp_adapters[i].vendor != 0; i++) {
 508                struct pnp_dev *idev = NULL;
 509                int irq;
 510                while((idev = pnp_find_dev(NULL,
 511                                           corkscrew_isapnp_adapters[i].vendor,
 512                                           corkscrew_isapnp_adapters[i].function,
 513                                           idev))) {
 514
 515                        if (pnp_device_attach(idev) < 0)
 516                                continue;
 517                        if (pnp_activate_dev(idev) < 0) {
 518                                pr_warn("pnp activate failed (out of resources?)\n");
 519                                pnp_device_detach(idev);
 520                                continue;
 521                        }
 522                        if (!pnp_port_valid(idev, 0) || !pnp_irq_valid(idev, 0)) {
 523                                pnp_device_detach(idev);
 524                                continue;
 525                        }
 526                        ioaddr = pnp_port_start(idev, 0);
 527                        irq = pnp_irq(idev, 0);
 528                        if (!check_device(ioaddr)) {
 529                                pnp_device_detach(idev);
 530                                continue;
 531                        }
 532                        if(corkscrew_debug)
 533                                pr_debug("ISAPNP reports %s at i/o 0x%x, irq %d\n",
 534                                        (char*) corkscrew_isapnp_adapters[i].driver_data, ioaddr, irq);
 535                        pr_info("3c515 Resource configuration register %#4.4x, DCR %4.4x.\n",
 536                                inl(ioaddr + 0x2002), inw(ioaddr + 0x2000));
 537                        /* irq = inw(ioaddr + 0x2002) & 15; */ /* Use the irq from isapnp */
 538                        SET_NETDEV_DEV(dev, &idev->dev);
 539                        pnp_cards++;
 540                        err = corkscrew_setup(dev, ioaddr, idev, cards_found++);
 541                        if (!err)
 542                                return dev;
 543                        cleanup_card(dev);
 544                }
 545        }
 546no_pnp:
 547#endif /* __ISAPNP__ */
 548
 549        /* Check all locations on the ISA bus -- evil! */
 550        for (ioaddr = 0x100; ioaddr < 0x400; ioaddr += 0x20) {
 551                if (!check_device(ioaddr))
 552                        continue;
 553
 554                pr_info("3c515 Resource configuration register %#4.4x, DCR %4.4x.\n",
 555                     inl(ioaddr + 0x2002), inw(ioaddr + 0x2000));
 556                err = corkscrew_setup(dev, ioaddr, NULL, cards_found++);
 557                if (!err)
 558                        return dev;
 559                cleanup_card(dev);
 560        }
 561        free_netdev(dev);
 562        return NULL;
 563}
 564
 565
 566static const struct net_device_ops netdev_ops = {
 567        .ndo_open               = corkscrew_open,
 568        .ndo_stop               = corkscrew_close,
 569        .ndo_start_xmit         = corkscrew_start_xmit,
 570        .ndo_tx_timeout         = corkscrew_timeout,
 571        .ndo_get_stats          = corkscrew_get_stats,
 572        .ndo_set_rx_mode        = set_rx_mode,
 573        .ndo_set_mac_address    = eth_mac_addr,
 574        .ndo_validate_addr      = eth_validate_addr,
 575};
 576
 577
 578static int corkscrew_setup(struct net_device *dev, int ioaddr,
 579                            struct pnp_dev *idev, int card_number)
 580{
 581        struct corkscrew_private *vp = netdev_priv(dev);
 582        unsigned int eeprom[0x40], checksum = 0;        /* EEPROM contents */
 583        int i;
 584        int irq;
 585
 586#ifdef __ISAPNP__
 587        if (idev) {
 588                irq = pnp_irq(idev, 0);
 589                vp->dev = &idev->dev;
 590        } else {
 591                irq = inw(ioaddr + 0x2002) & 15;
 592        }
 593#else
 594        irq = inw(ioaddr + 0x2002) & 15;
 595#endif
 596
 597        dev->base_addr = ioaddr;
 598        dev->irq = irq;
 599        dev->dma = inw(ioaddr + 0x2000) & 7;
 600        vp->product_name = "3c515";
 601        vp->options = dev->mem_start;
 602        vp->our_dev = dev;
 603
 604        if (!vp->options) {
 605                 if (card_number >= MAX_UNITS)
 606                        vp->options = -1;
 607                else
 608                        vp->options = options[card_number];
 609        }
 610
 611        if (vp->options >= 0) {
 612                vp->media_override = vp->options & 7;
 613                if (vp->media_override == 2)
 614                        vp->media_override = 0;
 615                vp->full_duplex = (vp->options & 8) ? 1 : 0;
 616                vp->bus_master = (vp->options & 16) ? 1 : 0;
 617        } else {
 618                vp->media_override = 7;
 619                vp->full_duplex = 0;
 620                vp->bus_master = 0;
 621        }
 622#ifdef MODULE
 623        list_add(&vp->list, &root_corkscrew_dev);
 624#endif
 625
 626        pr_info("%s: 3Com %s at %#3x,", dev->name, vp->product_name, ioaddr);
 627
 628        spin_lock_init(&vp->lock);
 629
 630        timer_setup(&vp->timer, corkscrew_timer, 0);
 631
 632        /* Read the station address from the EEPROM. */
 633        EL3WINDOW(0);
 634        for (i = 0; i < 0x18; i++) {
 635                __be16 *phys_addr = (__be16 *) dev->dev_addr;
 636                int timer;
 637                outw(EEPROM_Read + i, ioaddr + Wn0EepromCmd);
 638                /* Pause for at least 162 us. for the read to take place. */
 639                for (timer = 4; timer >= 0; timer--) {
 640                        udelay(162);
 641                        if ((inw(ioaddr + Wn0EepromCmd) & 0x0200) == 0)
 642                                break;
 643                }
 644                eeprom[i] = inw(ioaddr + Wn0EepromData);
 645                checksum ^= eeprom[i];
 646                if (i < 3)
 647                        phys_addr[i] = htons(eeprom[i]);
 648        }
 649        checksum = (checksum ^ (checksum >> 8)) & 0xff;
 650        if (checksum != 0x00)
 651                pr_cont(" ***INVALID CHECKSUM %4.4x*** ", checksum);
 652        pr_cont(" %pM", dev->dev_addr);
 653        if (eeprom[16] == 0x11c7) {     /* Corkscrew */
 654                if (request_dma(dev->dma, "3c515")) {
 655                        pr_cont(", DMA %d allocation failed", dev->dma);
 656                        dev->dma = 0;
 657                } else
 658                        pr_cont(", DMA %d", dev->dma);
 659        }
 660        pr_cont(", IRQ %d\n", dev->irq);
 661        /* Tell them about an invalid IRQ. */
 662        if (corkscrew_debug && (dev->irq <= 0 || dev->irq > 15))
 663                pr_warn(" *** Warning: this IRQ is unlikely to work! ***\n");
 664
 665        {
 666                static const char * const ram_split[] = {
 667                        "5:3", "3:1", "1:1", "3:5"
 668                };
 669                __u32 config;
 670                EL3WINDOW(3);
 671                vp->available_media = inw(ioaddr + Wn3_Options);
 672                config = inl(ioaddr + Wn3_Config);
 673                if (corkscrew_debug > 1)
 674                        pr_info("  Internal config register is %4.4x, transceivers %#x.\n",
 675                                config, inw(ioaddr + Wn3_Options));
 676                pr_info("  %dK %s-wide RAM %s Rx:Tx split, %s%s interface.\n",
 677                        8 << config & Ram_size,
 678                        config & Ram_width ? "word" : "byte",
 679                        ram_split[(config & Ram_split) >> Ram_split_shift],
 680                        config & Autoselect ? "autoselect/" : "",
 681                        media_tbl[(config & Xcvr) >> Xcvr_shift].name);
 682                vp->default_media = (config & Xcvr) >> Xcvr_shift;
 683                vp->autoselect = config & Autoselect ? 1 : 0;
 684                dev->if_port = vp->default_media;
 685        }
 686        if (vp->media_override != 7) {
 687                pr_info("  Media override to transceiver type %d (%s).\n",
 688                       vp->media_override,
 689                       media_tbl[vp->media_override].name);
 690                dev->if_port = vp->media_override;
 691        }
 692
 693        vp->capabilities = eeprom[16];
 694        vp->full_bus_master_tx = (vp->capabilities & 0x20) ? 1 : 0;
 695        /* Rx is broken at 10mbps, so we always disable it. */
 696        /* vp->full_bus_master_rx = 0; */
 697        vp->full_bus_master_rx = (vp->capabilities & 0x20) ? 1 : 0;
 698
 699        /* The 3c51x-specific entries in the device structure. */
 700        dev->netdev_ops = &netdev_ops;
 701        dev->watchdog_timeo = (400 * HZ) / 1000;
 702        dev->ethtool_ops = &netdev_ethtool_ops;
 703
 704        return register_netdev(dev);
 705}
 706
 707
 708static int corkscrew_open(struct net_device *dev)
 709{
 710        int ioaddr = dev->base_addr;
 711        struct corkscrew_private *vp = netdev_priv(dev);
 712        bool armtimer = false;
 713        __u32 config;
 714        int i;
 715
 716        /* Before initializing select the active media port. */
 717        EL3WINDOW(3);
 718        if (vp->full_duplex)
 719                outb(0x20, ioaddr + Wn3_MAC_Ctrl);      /* Set the full-duplex bit. */
 720        config = inl(ioaddr + Wn3_Config);
 721
 722        if (vp->media_override != 7) {
 723                if (corkscrew_debug > 1)
 724                        pr_info("%s: Media override to transceiver %d (%s).\n",
 725                                dev->name, vp->media_override,
 726                                media_tbl[vp->media_override].name);
 727                dev->if_port = vp->media_override;
 728        } else if (vp->autoselect) {
 729                /* Find first available media type, starting with 100baseTx. */
 730                dev->if_port = 4;
 731                while (!(vp->available_media & media_tbl[dev->if_port].mask))
 732                        dev->if_port = media_tbl[dev->if_port].next;
 733
 734                if (corkscrew_debug > 1)
 735                        pr_debug("%s: Initial media type %s.\n",
 736                               dev->name, media_tbl[dev->if_port].name);
 737                armtimer = true;
 738        } else
 739                dev->if_port = vp->default_media;
 740
 741        config = (config & ~Xcvr) | (dev->if_port << Xcvr_shift);
 742        outl(config, ioaddr + Wn3_Config);
 743
 744        if (corkscrew_debug > 1) {
 745                pr_debug("%s: corkscrew_open() InternalConfig %8.8x.\n",
 746                       dev->name, config);
 747        }
 748
 749        outw(TxReset, ioaddr + EL3_CMD);
 750        for (i = 20; i >= 0; i--)
 751                if (!(inw(ioaddr + EL3_STATUS) & CmdInProgress))
 752                        break;
 753
 754        outw(RxReset, ioaddr + EL3_CMD);
 755        /* Wait a few ticks for the RxReset command to complete. */
 756        for (i = 20; i >= 0; i--)
 757                if (!(inw(ioaddr + EL3_STATUS) & CmdInProgress))
 758                        break;
 759
 760        outw(SetStatusEnb | 0x00, ioaddr + EL3_CMD);
 761
 762        /* Use the now-standard shared IRQ implementation. */
 763        if (vp->capabilities == 0x11c7) {
 764                /* Corkscrew: Cannot share ISA resources. */
 765                if (dev->irq == 0 ||
 766                    dev->dma == 0 ||
 767                    request_irq(dev->irq, corkscrew_interrupt, 0,
 768                                vp->product_name, dev))
 769                        return -EAGAIN;
 770                enable_dma(dev->dma);
 771                set_dma_mode(dev->dma, DMA_MODE_CASCADE);
 772        } else if (request_irq(dev->irq, corkscrew_interrupt, IRQF_SHARED,
 773                               vp->product_name, dev)) {
 774                return -EAGAIN;
 775        }
 776
 777        if (armtimer)
 778                mod_timer(&vp->timer, jiffies + media_tbl[dev->if_port].wait);
 779
 780        if (corkscrew_debug > 1) {
 781                EL3WINDOW(4);
 782                pr_debug("%s: corkscrew_open() irq %d media status %4.4x.\n",
 783                       dev->name, dev->irq, inw(ioaddr + Wn4_Media));
 784        }
 785
 786        /* Set the station address and mask in window 2 each time opened. */
 787        EL3WINDOW(2);
 788        for (i = 0; i < 6; i++)
 789                outb(dev->dev_addr[i], ioaddr + i);
 790        for (; i < 12; i += 2)
 791                outw(0, ioaddr + i);
 792
 793        if (dev->if_port == 3)
 794                /* Start the thinnet transceiver. We should really wait 50ms... */
 795                outw(StartCoax, ioaddr + EL3_CMD);
 796        EL3WINDOW(4);
 797        outw((inw(ioaddr + Wn4_Media) & ~(Media_10TP | Media_SQE)) |
 798             media_tbl[dev->if_port].media_bits, ioaddr + Wn4_Media);
 799
 800        /* Switch to the stats window, and clear all stats by reading. */
 801        outw(StatsDisable, ioaddr + EL3_CMD);
 802        EL3WINDOW(6);
 803        for (i = 0; i < 10; i++)
 804                inb(ioaddr + i);
 805        inw(ioaddr + 10);
 806        inw(ioaddr + 12);
 807        /* New: On the Vortex we must also clear the BadSSD counter. */
 808        EL3WINDOW(4);
 809        inb(ioaddr + 12);
 810        /* ..and on the Boomerang we enable the extra statistics bits. */
 811        outw(0x0040, ioaddr + Wn4_NetDiag);
 812
 813        /* Switch to register set 7 for normal use. */
 814        EL3WINDOW(7);
 815
 816        if (vp->full_bus_master_rx) {   /* Boomerang bus master. */
 817                vp->cur_rx = vp->dirty_rx = 0;
 818                if (corkscrew_debug > 2)
 819                        pr_debug("%s:  Filling in the Rx ring.\n", dev->name);
 820                for (i = 0; i < RX_RING_SIZE; i++) {
 821                        struct sk_buff *skb;
 822                        if (i < (RX_RING_SIZE - 1))
 823                                vp->rx_ring[i].next =
 824                                    isa_virt_to_bus(&vp->rx_ring[i + 1]);
 825                        else
 826                                vp->rx_ring[i].next = 0;
 827                        vp->rx_ring[i].status = 0;      /* Clear complete bit. */
 828                        vp->rx_ring[i].length = PKT_BUF_SZ | 0x80000000;
 829                        skb = netdev_alloc_skb(dev, PKT_BUF_SZ);
 830                        vp->rx_skbuff[i] = skb;
 831                        if (skb == NULL)
 832                                break;  /* Bad news!  */
 833                        skb_reserve(skb, 2);    /* Align IP on 16 byte boundaries */
 834                        vp->rx_ring[i].addr = isa_virt_to_bus(skb->data);
 835                }
 836                if (i != 0)
 837                        vp->rx_ring[i - 1].next =
 838                                isa_virt_to_bus(&vp->rx_ring[0]);       /* Wrap the ring. */
 839                outl(isa_virt_to_bus(&vp->rx_ring[0]), ioaddr + UpListPtr);
 840        }
 841        if (vp->full_bus_master_tx) {   /* Boomerang bus master Tx. */
 842                vp->cur_tx = vp->dirty_tx = 0;
 843                outb(PKT_BUF_SZ >> 8, ioaddr + TxFreeThreshold);        /* Room for a packet. */
 844                /* Clear the Tx ring. */
 845                for (i = 0; i < TX_RING_SIZE; i++)
 846                        vp->tx_skbuff[i] = NULL;
 847                outl(0, ioaddr + DownListPtr);
 848        }
 849        /* Set receiver mode: presumably accept b-case and phys addr only. */
 850        set_rx_mode(dev);
 851        outw(StatsEnable, ioaddr + EL3_CMD);    /* Turn on statistics. */
 852
 853        netif_start_queue(dev);
 854
 855        outw(RxEnable, ioaddr + EL3_CMD);       /* Enable the receiver. */
 856        outw(TxEnable, ioaddr + EL3_CMD);       /* Enable transmitter. */
 857        /* Allow status bits to be seen. */
 858        outw(SetStatusEnb | AdapterFailure | IntReq | StatsFull |
 859             (vp->full_bus_master_tx ? DownComplete : TxAvailable) |
 860             (vp->full_bus_master_rx ? UpComplete : RxComplete) |
 861             (vp->bus_master ? DMADone : 0), ioaddr + EL3_CMD);
 862        /* Ack all pending events, and set active indicator mask. */
 863        outw(AckIntr | IntLatch | TxAvailable | RxEarly | IntReq,
 864             ioaddr + EL3_CMD);
 865        outw(SetIntrEnb | IntLatch | TxAvailable | RxComplete | StatsFull
 866             | (vp->bus_master ? DMADone : 0) | UpComplete | DownComplete,
 867             ioaddr + EL3_CMD);
 868
 869        return 0;
 870}
 871
 872static void corkscrew_timer(struct timer_list *t)
 873{
 874#ifdef AUTOMEDIA
 875        struct corkscrew_private *vp = from_timer(vp, t, timer);
 876        struct net_device *dev = vp->our_dev;
 877        int ioaddr = dev->base_addr;
 878        unsigned long flags;
 879        int ok = 0;
 880
 881        if (corkscrew_debug > 1)
 882                pr_debug("%s: Media selection timer tick happened, %s.\n",
 883                       dev->name, media_tbl[dev->if_port].name);
 884
 885        spin_lock_irqsave(&vp->lock, flags);
 886
 887        {
 888                int old_window = inw(ioaddr + EL3_CMD) >> 13;
 889                int media_status;
 890                EL3WINDOW(4);
 891                media_status = inw(ioaddr + Wn4_Media);
 892                switch (dev->if_port) {
 893                case 0:
 894                case 4:
 895                case 5: /* 10baseT, 100baseTX, 100baseFX  */
 896                        if (media_status & Media_LnkBeat) {
 897                                ok = 1;
 898                                if (corkscrew_debug > 1)
 899                                        pr_debug("%s: Media %s has link beat, %x.\n",
 900                                                dev->name,
 901                                                media_tbl[dev->if_port].name,
 902                                                media_status);
 903                        } else if (corkscrew_debug > 1)
 904                                pr_debug("%s: Media %s is has no link beat, %x.\n",
 905                                        dev->name,
 906                                        media_tbl[dev->if_port].name,
 907                                        media_status);
 908
 909                        break;
 910                default:        /* Other media types handled by Tx timeouts. */
 911                        if (corkscrew_debug > 1)
 912                                pr_debug("%s: Media %s is has no indication, %x.\n",
 913                                        dev->name,
 914                                        media_tbl[dev->if_port].name,
 915                                        media_status);
 916                        ok = 1;
 917                }
 918                if (!ok) {
 919                        __u32 config;
 920
 921                        do {
 922                                dev->if_port =
 923                                    media_tbl[dev->if_port].next;
 924                        }
 925                        while (!(vp->available_media & media_tbl[dev->if_port].mask));
 926
 927                        if (dev->if_port == 8) {        /* Go back to default. */
 928                                dev->if_port = vp->default_media;
 929                                if (corkscrew_debug > 1)
 930                                        pr_debug("%s: Media selection failing, using default %s port.\n",
 931                                                dev->name,
 932                                                media_tbl[dev->if_port].name);
 933                        } else {
 934                                if (corkscrew_debug > 1)
 935                                        pr_debug("%s: Media selection failed, now trying %s port.\n",
 936                                                dev->name,
 937                                                media_tbl[dev->if_port].name);
 938                                vp->timer.expires = jiffies + media_tbl[dev->if_port].wait;
 939                                add_timer(&vp->timer);
 940                        }
 941                        outw((media_status & ~(Media_10TP | Media_SQE)) |
 942                             media_tbl[dev->if_port].media_bits,
 943                             ioaddr + Wn4_Media);
 944
 945                        EL3WINDOW(3);
 946                        config = inl(ioaddr + Wn3_Config);
 947                        config = (config & ~Xcvr) | (dev->if_port << Xcvr_shift);
 948                        outl(config, ioaddr + Wn3_Config);
 949
 950                        outw(dev->if_port == 3 ? StartCoax : StopCoax,
 951                             ioaddr + EL3_CMD);
 952                }
 953                EL3WINDOW(old_window);
 954        }
 955
 956        spin_unlock_irqrestore(&vp->lock, flags);
 957        if (corkscrew_debug > 1)
 958                pr_debug("%s: Media selection timer finished, %s.\n",
 959                       dev->name, media_tbl[dev->if_port].name);
 960
 961#endif                          /* AUTOMEDIA */
 962}
 963
 964static void corkscrew_timeout(struct net_device *dev)
 965{
 966        int i;
 967        struct corkscrew_private *vp = netdev_priv(dev);
 968        int ioaddr = dev->base_addr;
 969
 970        pr_warn("%s: transmit timed out, tx_status %2.2x status %4.4x\n",
 971                dev->name, inb(ioaddr + TxStatus),
 972                inw(ioaddr + EL3_STATUS));
 973        /* Slight code bloat to be user friendly. */
 974        if ((inb(ioaddr + TxStatus) & 0x88) == 0x88)
 975                pr_warn("%s: Transmitter encountered 16 collisions -- network cable problem?\n",
 976                        dev->name);
 977#ifndef final_version
 978        pr_debug("  Flags; bus-master %d, full %d; dirty %d current %d.\n",
 979               vp->full_bus_master_tx, vp->tx_full, vp->dirty_tx,
 980               vp->cur_tx);
 981        pr_debug("  Down list %8.8x vs. %p.\n", inl(ioaddr + DownListPtr),
 982               &vp->tx_ring[0]);
 983        for (i = 0; i < TX_RING_SIZE; i++) {
 984                pr_debug("  %d: %p  length %8.8x status %8.8x\n", i,
 985                       &vp->tx_ring[i],
 986                       vp->tx_ring[i].length, vp->tx_ring[i].status);
 987        }
 988#endif
 989        /* Issue TX_RESET and TX_START commands. */
 990        outw(TxReset, ioaddr + EL3_CMD);
 991        for (i = 20; i >= 0; i--)
 992                if (!(inw(ioaddr + EL3_STATUS) & CmdInProgress))
 993                        break;
 994        outw(TxEnable, ioaddr + EL3_CMD);
 995        netif_trans_update(dev); /* prevent tx timeout */
 996        dev->stats.tx_errors++;
 997        dev->stats.tx_dropped++;
 998        netif_wake_queue(dev);
 999}
1000
1001static netdev_tx_t corkscrew_start_xmit(struct sk_buff *skb,
1002                                        struct net_device *dev)
1003{
1004        struct corkscrew_private *vp = netdev_priv(dev);
1005        int ioaddr = dev->base_addr;
1006
1007        /* Block a timer-based transmit from overlapping. */
1008
1009        netif_stop_queue(dev);
1010
1011        if (vp->full_bus_master_tx) {   /* BOOMERANG bus-master */
1012                /* Calculate the next Tx descriptor entry. */
1013                int entry = vp->cur_tx % TX_RING_SIZE;
1014                struct boom_tx_desc *prev_entry;
1015                unsigned long flags;
1016                int i;
1017
1018                if (vp->tx_full)        /* No room to transmit with */
1019                        return NETDEV_TX_BUSY;
1020                if (vp->cur_tx != 0)
1021                        prev_entry = &vp->tx_ring[(vp->cur_tx - 1) % TX_RING_SIZE];
1022                else
1023                        prev_entry = NULL;
1024                if (corkscrew_debug > 3)
1025                        pr_debug("%s: Trying to send a packet, Tx index %d.\n",
1026                                dev->name, vp->cur_tx);
1027                /* vp->tx_full = 1; */
1028                vp->tx_skbuff[entry] = skb;
1029                vp->tx_ring[entry].next = 0;
1030                vp->tx_ring[entry].addr = isa_virt_to_bus(skb->data);
1031                vp->tx_ring[entry].length = skb->len | 0x80000000;
1032                vp->tx_ring[entry].status = skb->len | 0x80000000;
1033
1034                spin_lock_irqsave(&vp->lock, flags);
1035                outw(DownStall, ioaddr + EL3_CMD);
1036                /* Wait for the stall to complete. */
1037                for (i = 20; i >= 0; i--)
1038                        if ((inw(ioaddr + EL3_STATUS) & CmdInProgress) == 0)
1039                                break;
1040                if (prev_entry)
1041                        prev_entry->next = isa_virt_to_bus(&vp->tx_ring[entry]);
1042                if (inl(ioaddr + DownListPtr) == 0) {
1043                        outl(isa_virt_to_bus(&vp->tx_ring[entry]),
1044                             ioaddr + DownListPtr);
1045                        queued_packet++;
1046                }
1047                outw(DownUnstall, ioaddr + EL3_CMD);
1048                spin_unlock_irqrestore(&vp->lock, flags);
1049
1050                vp->cur_tx++;
1051                if (vp->cur_tx - vp->dirty_tx > TX_RING_SIZE - 1)
1052                        vp->tx_full = 1;
1053                else {          /* Clear previous interrupt enable. */
1054                        if (prev_entry)
1055                                prev_entry->status &= ~0x80000000;
1056                        netif_wake_queue(dev);
1057                }
1058                return NETDEV_TX_OK;
1059        }
1060        /* Put out the doubleword header... */
1061        outl(skb->len, ioaddr + TX_FIFO);
1062        dev->stats.tx_bytes += skb->len;
1063#ifdef VORTEX_BUS_MASTER
1064        if (vp->bus_master) {
1065                /* Set the bus-master controller to transfer the packet. */
1066                outl((int) (skb->data), ioaddr + Wn7_MasterAddr);
1067                outw((skb->len + 3) & ~3, ioaddr + Wn7_MasterLen);
1068                vp->tx_skb = skb;
1069                outw(StartDMADown, ioaddr + EL3_CMD);
1070                /* queue will be woken at the DMADone interrupt. */
1071        } else {
1072                /* ... and the packet rounded to a doubleword. */
1073                outsl(ioaddr + TX_FIFO, skb->data, (skb->len + 3) >> 2);
1074                dev_kfree_skb(skb);
1075                if (inw(ioaddr + TxFree) > 1536) {
1076                        netif_wake_queue(dev);
1077                } else
1078                        /* Interrupt us when the FIFO has room for max-sized packet. */
1079                        outw(SetTxThreshold + (1536 >> 2),
1080                             ioaddr + EL3_CMD);
1081        }
1082#else
1083        /* ... and the packet rounded to a doubleword. */
1084        outsl(ioaddr + TX_FIFO, skb->data, (skb->len + 3) >> 2);
1085        dev_kfree_skb(skb);
1086        if (inw(ioaddr + TxFree) > 1536) {
1087                netif_wake_queue(dev);
1088        } else
1089                /* Interrupt us when the FIFO has room for max-sized packet. */
1090                outw(SetTxThreshold + (1536 >> 2), ioaddr + EL3_CMD);
1091#endif                          /* bus master */
1092
1093
1094        /* Clear the Tx status stack. */
1095        {
1096                short tx_status;
1097                int i = 4;
1098
1099                while (--i > 0 && (tx_status = inb(ioaddr + TxStatus)) > 0) {
1100                        if (tx_status & 0x3C) { /* A Tx-disabling error occurred.  */
1101                                if (corkscrew_debug > 2)
1102                                        pr_debug("%s: Tx error, status %2.2x.\n",
1103                                                dev->name, tx_status);
1104                                if (tx_status & 0x04)
1105                                        dev->stats.tx_fifo_errors++;
1106                                if (tx_status & 0x38)
1107                                        dev->stats.tx_aborted_errors++;
1108                                if (tx_status & 0x30) {
1109                                        int j;
1110                                        outw(TxReset, ioaddr + EL3_CMD);
1111                                        for (j = 20; j >= 0; j--)
1112                                                if (!(inw(ioaddr + EL3_STATUS) & CmdInProgress))
1113                                                        break;
1114                                }
1115                                outw(TxEnable, ioaddr + EL3_CMD);
1116                        }
1117                        outb(0x00, ioaddr + TxStatus);  /* Pop the status stack. */
1118                }
1119        }
1120        return NETDEV_TX_OK;
1121}
1122
1123/* The interrupt handler does all of the Rx thread work and cleans up
1124   after the Tx thread. */
1125
1126static irqreturn_t corkscrew_interrupt(int irq, void *dev_id)
1127{
1128        /* Use the now-standard shared IRQ implementation. */
1129        struct net_device *dev = dev_id;
1130        struct corkscrew_private *lp = netdev_priv(dev);
1131        int ioaddr, status;
1132        int latency;
1133        int i = max_interrupt_work;
1134
1135        ioaddr = dev->base_addr;
1136        latency = inb(ioaddr + Timer);
1137
1138        spin_lock(&lp->lock);
1139
1140        status = inw(ioaddr + EL3_STATUS);
1141
1142        if (corkscrew_debug > 4)
1143                pr_debug("%s: interrupt, status %4.4x, timer %d.\n",
1144                        dev->name, status, latency);
1145        if ((status & 0xE000) != 0xE000) {
1146                static int donedidthis;
1147                /* Some interrupt controllers store a bogus interrupt from boot-time.
1148                   Ignore a single early interrupt, but don't hang the machine for
1149                   other interrupt problems. */
1150                if (donedidthis++ > 100) {
1151                        pr_err("%s: Bogus interrupt, bailing. Status %4.4x, start=%d.\n",
1152                                   dev->name, status, netif_running(dev));
1153                        free_irq(dev->irq, dev);
1154                        dev->irq = -1;
1155                }
1156        }
1157
1158        do {
1159                if (corkscrew_debug > 5)
1160                        pr_debug("%s: In interrupt loop, status %4.4x.\n",
1161                               dev->name, status);
1162                if (status & RxComplete)
1163                        corkscrew_rx(dev);
1164
1165                if (status & TxAvailable) {
1166                        if (corkscrew_debug > 5)
1167                                pr_debug("      TX room bit was handled.\n");
1168                        /* There's room in the FIFO for a full-sized packet. */
1169                        outw(AckIntr | TxAvailable, ioaddr + EL3_CMD);
1170                        netif_wake_queue(dev);
1171                }
1172                if (status & DownComplete) {
1173                        unsigned int dirty_tx = lp->dirty_tx;
1174
1175                        while (lp->cur_tx - dirty_tx > 0) {
1176                                int entry = dirty_tx % TX_RING_SIZE;
1177                                if (inl(ioaddr + DownListPtr) == isa_virt_to_bus(&lp->tx_ring[entry]))
1178                                        break;  /* It still hasn't been processed. */
1179                                if (lp->tx_skbuff[entry]) {
1180                                        dev_consume_skb_irq(lp->tx_skbuff[entry]);
1181                                        lp->tx_skbuff[entry] = NULL;
1182                                }
1183                                dirty_tx++;
1184                        }
1185                        lp->dirty_tx = dirty_tx;
1186                        outw(AckIntr | DownComplete, ioaddr + EL3_CMD);
1187                        if (lp->tx_full && (lp->cur_tx - dirty_tx <= TX_RING_SIZE - 1)) {
1188                                lp->tx_full = 0;
1189                                netif_wake_queue(dev);
1190                        }
1191                }
1192#ifdef VORTEX_BUS_MASTER
1193                if (status & DMADone) {
1194                        outw(0x1000, ioaddr + Wn7_MasterStatus);        /* Ack the event. */
1195                        dev_consume_skb_irq(lp->tx_skb);        /* Release the transferred buffer */
1196                        netif_wake_queue(dev);
1197                }
1198#endif
1199                if (status & UpComplete) {
1200                        boomerang_rx(dev);
1201                        outw(AckIntr | UpComplete, ioaddr + EL3_CMD);
1202                }
1203                if (status & (AdapterFailure | RxEarly | StatsFull)) {
1204                        /* Handle all uncommon interrupts at once. */
1205                        if (status & RxEarly) { /* Rx early is unused. */
1206                                corkscrew_rx(dev);
1207                                outw(AckIntr | RxEarly, ioaddr + EL3_CMD);
1208                        }
1209                        if (status & StatsFull) {       /* Empty statistics. */
1210                                static int DoneDidThat;
1211                                if (corkscrew_debug > 4)
1212                                        pr_debug("%s: Updating stats.\n", dev->name);
1213                                update_stats(ioaddr, dev);
1214                                /* DEBUG HACK: Disable statistics as an interrupt source. */
1215                                /* This occurs when we have the wrong media type! */
1216                                if (DoneDidThat == 0 && inw(ioaddr + EL3_STATUS) & StatsFull) {
1217                                        int win, reg;
1218                                        pr_notice("%s: Updating stats failed, disabling stats as an interrupt source.\n",
1219                                                dev->name);
1220                                        for (win = 0; win < 8; win++) {
1221                                                EL3WINDOW(win);
1222                                                pr_notice("Vortex window %d:", win);
1223                                                for (reg = 0; reg < 16; reg++)
1224                                                        pr_cont(" %2.2x", inb(ioaddr + reg));
1225                                                pr_cont("\n");
1226                                        }
1227                                        EL3WINDOW(7);
1228                                        outw(SetIntrEnb | TxAvailable |
1229                                             RxComplete | AdapterFailure |
1230                                             UpComplete | DownComplete |
1231                                             TxComplete, ioaddr + EL3_CMD);
1232                                        DoneDidThat++;
1233                                }
1234                        }
1235                        if (status & AdapterFailure) {
1236                                /* Adapter failure requires Rx reset and reinit. */
1237                                outw(RxReset, ioaddr + EL3_CMD);
1238                                /* Set the Rx filter to the current state. */
1239                                set_rx_mode(dev);
1240                                outw(RxEnable, ioaddr + EL3_CMD);       /* Re-enable the receiver. */
1241                                outw(AckIntr | AdapterFailure,
1242                                     ioaddr + EL3_CMD);
1243                        }
1244                }
1245
1246                if (--i < 0) {
1247                        pr_err("%s: Too much work in interrupt, status %4.4x. Disabling functions (%4.4x).\n",
1248                                dev->name, status, SetStatusEnb | ((~status) & 0x7FE));
1249                        /* Disable all pending interrupts. */
1250                        outw(SetStatusEnb | ((~status) & 0x7FE), ioaddr + EL3_CMD);
1251                        outw(AckIntr | 0x7FF, ioaddr + EL3_CMD);
1252                        break;
1253                }
1254                /* Acknowledge the IRQ. */
1255                outw(AckIntr | IntReq | IntLatch, ioaddr + EL3_CMD);
1256
1257        } while ((status = inw(ioaddr + EL3_STATUS)) & (IntLatch | RxComplete));
1258
1259        spin_unlock(&lp->lock);
1260
1261        if (corkscrew_debug > 4)
1262                pr_debug("%s: exiting interrupt, status %4.4x.\n", dev->name, status);
1263        return IRQ_HANDLED;
1264}
1265
1266static int corkscrew_rx(struct net_device *dev)
1267{
1268        int ioaddr = dev->base_addr;
1269        int i;
1270        short rx_status;
1271
1272        if (corkscrew_debug > 5)
1273                pr_debug("   In rx_packet(), status %4.4x, rx_status %4.4x.\n",
1274                     inw(ioaddr + EL3_STATUS), inw(ioaddr + RxStatus));
1275        while ((rx_status = inw(ioaddr + RxStatus)) > 0) {
1276                if (rx_status & 0x4000) {       /* Error, update stats. */
1277                        unsigned char rx_error = inb(ioaddr + RxErrors);
1278                        if (corkscrew_debug > 2)
1279                                pr_debug(" Rx error: status %2.2x.\n",
1280                                       rx_error);
1281                        dev->stats.rx_errors++;
1282                        if (rx_error & 0x01)
1283                                dev->stats.rx_over_errors++;
1284                        if (rx_error & 0x02)
1285                                dev->stats.rx_length_errors++;
1286                        if (rx_error & 0x04)
1287                                dev->stats.rx_frame_errors++;
1288                        if (rx_error & 0x08)
1289                                dev->stats.rx_crc_errors++;
1290                        if (rx_error & 0x10)
1291                                dev->stats.rx_length_errors++;
1292                } else {
1293                        /* The packet length: up to 4.5K!. */
1294                        short pkt_len = rx_status & 0x1fff;
1295                        struct sk_buff *skb;
1296
1297                        skb = netdev_alloc_skb(dev, pkt_len + 5 + 2);
1298                        if (corkscrew_debug > 4)
1299                                pr_debug("Receiving packet size %d status %4.4x.\n",
1300                                     pkt_len, rx_status);
1301                        if (skb != NULL) {
1302                                skb_reserve(skb, 2);    /* Align IP on 16 byte boundaries */
1303                                /* 'skb_put()' points to the start of sk_buff data area. */
1304                                insl(ioaddr + RX_FIFO,
1305                                     skb_put(skb, pkt_len),
1306                                     (pkt_len + 3) >> 2);
1307                                outw(RxDiscard, ioaddr + EL3_CMD);      /* Pop top Rx packet. */
1308                                skb->protocol = eth_type_trans(skb, dev);
1309                                netif_rx(skb);
1310                                dev->stats.rx_packets++;
1311                                dev->stats.rx_bytes += pkt_len;
1312                                /* Wait a limited time to go to next packet. */
1313                                for (i = 200; i >= 0; i--)
1314                                        if (! (inw(ioaddr + EL3_STATUS) & CmdInProgress))
1315                                                break;
1316                                continue;
1317                        } else if (corkscrew_debug)
1318                                pr_debug("%s: Couldn't allocate a sk_buff of size %d.\n", dev->name, pkt_len);
1319                }
1320                outw(RxDiscard, ioaddr + EL3_CMD);
1321                dev->stats.rx_dropped++;
1322                /* Wait a limited time to skip this packet. */
1323                for (i = 200; i >= 0; i--)
1324                        if (!(inw(ioaddr + EL3_STATUS) & CmdInProgress))
1325                                break;
1326        }
1327        return 0;
1328}
1329
1330static int boomerang_rx(struct net_device *dev)
1331{
1332        struct corkscrew_private *vp = netdev_priv(dev);
1333        int entry = vp->cur_rx % RX_RING_SIZE;
1334        int ioaddr = dev->base_addr;
1335        int rx_status;
1336
1337        if (corkscrew_debug > 5)
1338                pr_debug("   In boomerang_rx(), status %4.4x, rx_status %4.4x.\n",
1339                        inw(ioaddr + EL3_STATUS), inw(ioaddr + RxStatus));
1340        while ((rx_status = vp->rx_ring[entry].status) & RxDComplete) {
1341                if (rx_status & RxDError) {     /* Error, update stats. */
1342                        unsigned char rx_error = rx_status >> 16;
1343                        if (corkscrew_debug > 2)
1344                                pr_debug(" Rx error: status %2.2x.\n",
1345                                       rx_error);
1346                        dev->stats.rx_errors++;
1347                        if (rx_error & 0x01)
1348                                dev->stats.rx_over_errors++;
1349                        if (rx_error & 0x02)
1350                                dev->stats.rx_length_errors++;
1351                        if (rx_error & 0x04)
1352                                dev->stats.rx_frame_errors++;
1353                        if (rx_error & 0x08)
1354                                dev->stats.rx_crc_errors++;
1355                        if (rx_error & 0x10)
1356                                dev->stats.rx_length_errors++;
1357                } else {
1358                        /* The packet length: up to 4.5K!. */
1359                        short pkt_len = rx_status & 0x1fff;
1360                        struct sk_buff *skb;
1361
1362                        dev->stats.rx_bytes += pkt_len;
1363                        if (corkscrew_debug > 4)
1364                                pr_debug("Receiving packet size %d status %4.4x.\n",
1365                                     pkt_len, rx_status);
1366
1367                        /* Check if the packet is long enough to just accept without
1368                           copying to a properly sized skbuff. */
1369                        if (pkt_len < rx_copybreak &&
1370                            (skb = netdev_alloc_skb(dev, pkt_len + 4)) != NULL) {
1371                                skb_reserve(skb, 2);    /* Align IP on 16 byte boundaries */
1372                                /* 'skb_put()' points to the start of sk_buff data area. */
1373                                skb_put_data(skb,
1374                                             isa_bus_to_virt(vp->rx_ring[entry].addr),
1375                                             pkt_len);
1376                                rx_copy++;
1377                        } else {
1378                                void *temp;
1379                                /* Pass up the skbuff already on the Rx ring. */
1380                                skb = vp->rx_skbuff[entry];
1381                                vp->rx_skbuff[entry] = NULL;
1382                                temp = skb_put(skb, pkt_len);
1383                                /* Remove this checking code for final release. */
1384                                if (isa_bus_to_virt(vp->rx_ring[entry].addr) != temp)
1385                                        pr_warn("%s: Warning -- the skbuff addresses do not match in boomerang_rx: %p vs. %p / %p\n",
1386                                                dev->name,
1387                                                isa_bus_to_virt(vp->rx_ring[entry].addr),
1388                                                skb->head, temp);
1389                                rx_nocopy++;
1390                        }
1391                        skb->protocol = eth_type_trans(skb, dev);
1392                        netif_rx(skb);
1393                        dev->stats.rx_packets++;
1394                }
1395                entry = (++vp->cur_rx) % RX_RING_SIZE;
1396        }
1397        /* Refill the Rx ring buffers. */
1398        for (; vp->cur_rx - vp->dirty_rx > 0; vp->dirty_rx++) {
1399                struct sk_buff *skb;
1400                entry = vp->dirty_rx % RX_RING_SIZE;
1401                if (vp->rx_skbuff[entry] == NULL) {
1402                        skb = netdev_alloc_skb(dev, PKT_BUF_SZ);
1403                        if (skb == NULL)
1404                                break;  /* Bad news!  */
1405                        skb_reserve(skb, 2);    /* Align IP on 16 byte boundaries */
1406                        vp->rx_ring[entry].addr = isa_virt_to_bus(skb->data);
1407                        vp->rx_skbuff[entry] = skb;
1408                }
1409                vp->rx_ring[entry].status = 0;  /* Clear complete bit. */
1410        }
1411        return 0;
1412}
1413
1414static int corkscrew_close(struct net_device *dev)
1415{
1416        struct corkscrew_private *vp = netdev_priv(dev);
1417        int ioaddr = dev->base_addr;
1418        int i;
1419
1420        netif_stop_queue(dev);
1421
1422        if (corkscrew_debug > 1) {
1423                pr_debug("%s: corkscrew_close() status %4.4x, Tx status %2.2x.\n",
1424                     dev->name, inw(ioaddr + EL3_STATUS),
1425                     inb(ioaddr + TxStatus));
1426                pr_debug("%s: corkscrew close stats: rx_nocopy %d rx_copy %d tx_queued %d.\n",
1427                        dev->name, rx_nocopy, rx_copy, queued_packet);
1428        }
1429
1430        del_timer_sync(&vp->timer);
1431
1432        /* Turn off statistics ASAP.  We update lp->stats below. */
1433        outw(StatsDisable, ioaddr + EL3_CMD);
1434
1435        /* Disable the receiver and transmitter. */
1436        outw(RxDisable, ioaddr + EL3_CMD);
1437        outw(TxDisable, ioaddr + EL3_CMD);
1438
1439        if (dev->if_port == XCVR_10base2)
1440                /* Turn off thinnet power.  Green! */
1441                outw(StopCoax, ioaddr + EL3_CMD);
1442
1443        free_irq(dev->irq, dev);
1444
1445        outw(SetIntrEnb | 0x0000, ioaddr + EL3_CMD);
1446
1447        update_stats(ioaddr, dev);
1448        if (vp->full_bus_master_rx) {   /* Free Boomerang bus master Rx buffers. */
1449                outl(0, ioaddr + UpListPtr);
1450                for (i = 0; i < RX_RING_SIZE; i++)
1451                        if (vp->rx_skbuff[i]) {
1452                                dev_kfree_skb(vp->rx_skbuff[i]);
1453                                vp->rx_skbuff[i] = NULL;
1454                        }
1455        }
1456        if (vp->full_bus_master_tx) {   /* Free Boomerang bus master Tx buffers. */
1457                outl(0, ioaddr + DownListPtr);
1458                for (i = 0; i < TX_RING_SIZE; i++)
1459                        if (vp->tx_skbuff[i]) {
1460                                dev_kfree_skb(vp->tx_skbuff[i]);
1461                                vp->tx_skbuff[i] = NULL;
1462                        }
1463        }
1464
1465        return 0;
1466}
1467
1468static struct net_device_stats *corkscrew_get_stats(struct net_device *dev)
1469{
1470        struct corkscrew_private *vp = netdev_priv(dev);
1471        unsigned long flags;
1472
1473        if (netif_running(dev)) {
1474                spin_lock_irqsave(&vp->lock, flags);
1475                update_stats(dev->base_addr, dev);
1476                spin_unlock_irqrestore(&vp->lock, flags);
1477        }
1478        return &dev->stats;
1479}
1480
1481/*  Update statistics.
1482        Unlike with the EL3 we need not worry about interrupts changing
1483        the window setting from underneath us, but we must still guard
1484        against a race condition with a StatsUpdate interrupt updating the
1485        table.  This is done by checking that the ASM (!) code generated uses
1486        atomic updates with '+='.
1487        */
1488static void update_stats(int ioaddr, struct net_device *dev)
1489{
1490        /* Unlike the 3c5x9 we need not turn off stats updates while reading. */
1491        /* Switch to the stats window, and read everything. */
1492        EL3WINDOW(6);
1493        dev->stats.tx_carrier_errors += inb(ioaddr + 0);
1494        dev->stats.tx_heartbeat_errors += inb(ioaddr + 1);
1495        /* Multiple collisions. */ inb(ioaddr + 2);
1496        dev->stats.collisions += inb(ioaddr + 3);
1497        dev->stats.tx_window_errors += inb(ioaddr + 4);
1498        dev->stats.rx_fifo_errors += inb(ioaddr + 5);
1499        dev->stats.tx_packets += inb(ioaddr + 6);
1500        dev->stats.tx_packets += (inb(ioaddr + 9) & 0x30) << 4;
1501                                                /* Rx packets   */ inb(ioaddr + 7);
1502                                                /* Must read to clear */
1503        /* Tx deferrals */ inb(ioaddr + 8);
1504        /* Don't bother with register 9, an extension of registers 6&7.
1505           If we do use the 6&7 values the atomic update assumption above
1506           is invalid. */
1507        inw(ioaddr + 10);       /* Total Rx and Tx octets. */
1508        inw(ioaddr + 12);
1509        /* New: On the Vortex we must also clear the BadSSD counter. */
1510        EL3WINDOW(4);
1511        inb(ioaddr + 12);
1512
1513        /* We change back to window 7 (not 1) with the Vortex. */
1514        EL3WINDOW(7);
1515}
1516
1517/* This new version of set_rx_mode() supports v1.4 kernels.
1518   The Vortex chip has no documented multicast filter, so the only
1519   multicast setting is to receive all multicast frames.  At least
1520   the chip has a very clean way to set the mode, unlike many others. */
1521static void set_rx_mode(struct net_device *dev)
1522{
1523        int ioaddr = dev->base_addr;
1524        unsigned short new_mode;
1525
1526        if (dev->flags & IFF_PROMISC) {
1527                if (corkscrew_debug > 3)
1528                        pr_debug("%s: Setting promiscuous mode.\n",
1529                               dev->name);
1530                new_mode = SetRxFilter | RxStation | RxMulticast | RxBroadcast | RxProm;
1531        } else if (!netdev_mc_empty(dev) || dev->flags & IFF_ALLMULTI) {
1532                new_mode = SetRxFilter | RxStation | RxMulticast | RxBroadcast;
1533        } else
1534                new_mode = SetRxFilter | RxStation | RxBroadcast;
1535
1536        outw(new_mode, ioaddr + EL3_CMD);
1537}
1538
1539static void netdev_get_drvinfo(struct net_device *dev,
1540                               struct ethtool_drvinfo *info)
1541{
1542        strlcpy(info->driver, DRV_NAME, sizeof(info->driver));
1543        strlcpy(info->version, DRV_VERSION, sizeof(info->version));
1544        snprintf(info->bus_info, sizeof(info->bus_info), "ISA 0x%lx",
1545                 dev->base_addr);
1546}
1547
1548static u32 netdev_get_msglevel(struct net_device *dev)
1549{
1550        return corkscrew_debug;
1551}
1552
1553static void netdev_set_msglevel(struct net_device *dev, u32 level)
1554{
1555        corkscrew_debug = level;
1556}
1557
1558static const struct ethtool_ops netdev_ethtool_ops = {
1559        .get_drvinfo            = netdev_get_drvinfo,
1560        .get_msglevel           = netdev_get_msglevel,
1561        .set_msglevel           = netdev_set_msglevel,
1562};
1563
1564
1565#ifdef MODULE
1566void cleanup_module(void)
1567{
1568        while (!list_empty(&root_corkscrew_dev)) {
1569                struct net_device *dev;
1570                struct corkscrew_private *vp;
1571
1572                vp = list_entry(root_corkscrew_dev.next,
1573                                struct corkscrew_private, list);
1574                dev = vp->our_dev;
1575                unregister_netdev(dev);
1576                cleanup_card(dev);
1577                free_netdev(dev);
1578        }
1579}
1580#endif                          /* MODULE */
1581