drivers/net/3c515.c

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