git.oblomov.eu Git - linux-2.6/blob - 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@redhat.com)
  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 static int corkscrew_setup(struct net_device *dev, int ioaddr,
 567                             struct pnp_dev *idev, int card_number)
 568 {
 569         struct corkscrew_private *vp = netdev_priv(dev);
 570         unsigned int eeprom[0x40], checksum = 0;        /* EEPROM contents */
 571         int i;
 572         int irq;
 573         DECLARE_MAC_BUF(mac);
 574
 575 #ifdef __ISAPNP__
 576         if (idev) {
 577                 irq = pnp_irq(idev, 0);
 578                 vp->dev = &idev->dev;
 579         } else {
 580                 irq = inw(ioaddr + 0x2002) & 15;
 581         }
 582 #else
 583         irq = inw(ioaddr + 0x2002) & 15;
 584 #endif
 585
 586         dev->base_addr = ioaddr;
 587         dev->irq = irq;
 588         dev->dma = inw(ioaddr + 0x2000) & 7;
 589         vp->product_name = "3c515";
 590         vp->options = dev->mem_start;
 591         vp->our_dev = dev;
 592
 593         if (!vp->options) {
 594                  if (card_number >= MAX_UNITS)
 595                         vp->options = -1;
 596                 else
 597                         vp->options = options[card_number];
 598         }
 599
 600         if (vp->options >= 0) {
 601                 vp->media_override = vp->options & 7;
 602                 if (vp->media_override == 2)
 603                         vp->media_override = 0;
 604                 vp->full_duplex = (vp->options & 8) ? 1 : 0;
 605                 vp->bus_master = (vp->options & 16) ? 1 : 0;
 606         } else {
 607                 vp->media_override = 7;
 608                 vp->full_duplex = 0;
 609                 vp->bus_master = 0;
 610         }
 611 #ifdef MODULE
 612         list_add(&vp->list, &root_corkscrew_dev);
 613 #endif
 614
 615         printk(KERN_INFO "%s: 3Com %s at %#3x,", dev->name, vp->product_name, ioaddr);
 616
 617         spin_lock_init(&vp->lock);
 618
 619         /* Read the station address from the EEPROM. */
 620         EL3WINDOW(0);
 621         for (i = 0; i < 0x18; i++) {
 622                 __be16 *phys_addr = (__be16 *) dev->dev_addr;
 623                 int timer;
 624                 outw(EEPROM_Read + i, ioaddr + Wn0EepromCmd);
 625                 /* Pause for at least 162 us. for the read to take place. */
 626                 for (timer = 4; timer >= 0; timer--) {
 627                         udelay(162);
 628                         if ((inw(ioaddr + Wn0EepromCmd) & 0x0200) == 0)
 629                                 break;
 630                 }
 631                 eeprom[i] = inw(ioaddr + Wn0EepromData);
 632                 checksum ^= eeprom[i];
 633                 if (i < 3)
 634                         phys_addr[i] = htons(eeprom[i]);
 635         }
 636         checksum = (checksum ^ (checksum >> 8)) & 0xff;
 637         if (checksum != 0x00)
 638                 printk(" ***INVALID CHECKSUM %4.4x*** ", checksum);
 639         printk(" %s", print_mac(mac, dev->dev_addr));
 640         if (eeprom[16] == 0x11c7) {     /* Corkscrew */
 641                 if (request_dma(dev->dma, "3c515")) {
 642                         printk(", DMA %d allocation failed", dev->dma);
 643                         dev->dma = 0;
 644                 } else
 645                         printk(", DMA %d", dev->dma);
 646         }
 647         printk(", IRQ %d\n", dev->irq);
 648         /* Tell them about an invalid IRQ. */
 649         if (corkscrew_debug && (dev->irq <= 0 || dev->irq > 15))
 650                 printk(KERN_WARNING " *** Warning: this IRQ is unlikely to work! ***\n");
 651
 652         {
 653                 char *ram_split[] = { "5:3", "3:1", "1:1", "3:5" };
 654                 __u32 config;
 655                 EL3WINDOW(3);
 656                 vp->available_media = inw(ioaddr + Wn3_Options);
 657                 config = inl(ioaddr + Wn3_Config);
 658                 if (corkscrew_debug > 1)
 659                         printk(KERN_INFO "  Internal config register is %4.4x, transceivers %#x.\n",
 660                                 config, inw(ioaddr + Wn3_Options));
 661                 printk(KERN_INFO "  %dK %s-wide RAM %s Rx:Tx split, %s%s interface.\n",
 662                         8 << config & Ram_size,
 663                         config & Ram_width ? "word" : "byte",
 664                         ram_split[(config & Ram_split) >> Ram_split_shift],
 665                         config & Autoselect ? "autoselect/" : "",
 666                         media_tbl[(config & Xcvr) >> Xcvr_shift].name);
 667                 vp->default_media = (config & Xcvr) >> Xcvr_shift;
 668                 vp->autoselect = config & Autoselect ? 1 : 0;
 669                 dev->if_port = vp->default_media;
 670         }
 671         if (vp->media_override != 7) {
 672                 printk(KERN_INFO "  Media override to transceiver type %d (%s).\n",
 673                        vp->media_override,
 674                        media_tbl[vp->media_override].name);
 675                 dev->if_port = vp->media_override;
 676         }
 677
 678         vp->capabilities = eeprom[16];
 679         vp->full_bus_master_tx = (vp->capabilities & 0x20) ? 1 : 0;
 680         /* Rx is broken at 10mbps, so we always disable it. */
 681         /* vp->full_bus_master_rx = 0; */
 682         vp->full_bus_master_rx = (vp->capabilities & 0x20) ? 1 : 0;
 683
 684         /* The 3c51x-specific entries in the device structure. */
 685         dev->open = &corkscrew_open;
 686         dev->hard_start_xmit = &corkscrew_start_xmit;
 687         dev->tx_timeout = &corkscrew_timeout;
 688         dev->watchdog_timeo = (400 * HZ) / 1000;
 689         dev->stop = &corkscrew_close;
 690         dev->get_stats = &corkscrew_get_stats;
 691         dev->set_multicast_list = &set_rx_mode;
 692         dev->ethtool_ops = &netdev_ethtool_ops;
 693
 694         return register_netdev(dev);
 695 }
 696
 697
 698 static int corkscrew_open(struct net_device *dev)
 699 {
 700         int ioaddr = dev->base_addr;
 701         struct corkscrew_private *vp = netdev_priv(dev);
 702         __u32 config;
 703         int i;
 704
 705         /* Before initializing select the active media port. */
 706         EL3WINDOW(3);
 707         if (vp->full_duplex)
 708                 outb(0x20, ioaddr + Wn3_MAC_Ctrl);      /* Set the full-duplex bit. */
 709         config = inl(ioaddr + Wn3_Config);
 710
 711         if (vp->media_override != 7) {
 712                 if (corkscrew_debug > 1)
 713                         printk(KERN_INFO "%s: Media override to transceiver %d (%s).\n",
 714                                 dev->name, vp->media_override,
 715                                 media_tbl[vp->media_override].name);
 716                 dev->if_port = vp->media_override;
 717         } else if (vp->autoselect) {
 718                 /* Find first available media type, starting with 100baseTx. */
 719                 dev->if_port = 4;
 720                 while (!(vp->available_media & media_tbl[dev->if_port].mask))
 721                         dev->if_port = media_tbl[dev->if_port].next;
 722
 723                 if (corkscrew_debug > 1)
 724                         printk("%s: Initial media type %s.\n",
 725                                dev->name, media_tbl[dev->if_port].name);
 726
 727                 init_timer(&vp->timer);
 728                 vp->timer.expires = jiffies + media_tbl[dev->if_port].wait;
 729                 vp->timer.data = (unsigned long) dev;
 730                 vp->timer.function = &corkscrew_timer;  /* timer handler */
 731                 add_timer(&vp->timer);
 732         } else
 733                 dev->if_port = vp->default_media;
 734
 735         config = (config & ~Xcvr) | (dev->if_port << Xcvr_shift);
 736         outl(config, ioaddr + Wn3_Config);
 737
 738         if (corkscrew_debug > 1) {
 739                 printk("%s: corkscrew_open() InternalConfig %8.8x.\n",
 740                        dev->name, config);
 741         }
 742
 743         outw(TxReset, ioaddr + EL3_CMD);
 744         for (i = 20; i >= 0; i--)
 745                 if (!(inw(ioaddr + EL3_STATUS) & CmdInProgress))
 746                         break;
 747
 748         outw(RxReset, ioaddr + EL3_CMD);
 749         /* Wait a few ticks for the RxReset command to complete. */
 750         for (i = 20; i >= 0; i--)
 751                 if (!(inw(ioaddr + EL3_STATUS) & CmdInProgress))
 752                         break;
 753
 754         outw(SetStatusEnb | 0x00, ioaddr + EL3_CMD);
 755
 756         /* Use the now-standard shared IRQ implementation. */
 757         if (vp->capabilities == 0x11c7) {
 758                 /* Corkscrew: Cannot share ISA resources. */
 759                 if (dev->irq == 0
 760                     || dev->dma == 0
 761                     || request_irq(dev->irq, &corkscrew_interrupt, 0,
 762                                    vp->product_name, dev)) return -EAGAIN;
 763                 enable_dma(dev->dma);
 764                 set_dma_mode(dev->dma, DMA_MODE_CASCADE);
 765         } else if (request_irq(dev->irq, &corkscrew_interrupt, IRQF_SHARED,
 766                                vp->product_name, dev)) {
 767                 return -EAGAIN;
 768         }
 769
 770         if (corkscrew_debug > 1) {
 771                 EL3WINDOW(4);
 772                 printk("%s: corkscrew_open() irq %d media status %4.4x.\n",
 773                        dev->name, dev->irq, inw(ioaddr + Wn4_Media));
 774         }
 775
 776         /* Set the station address and mask in window 2 each time opened. */
 777         EL3WINDOW(2);
 778         for (i = 0; i < 6; i++)
 779                 outb(dev->dev_addr[i], ioaddr + i);
 780         for (; i < 12; i += 2)
 781                 outw(0, ioaddr + i);
 782
 783         if (dev->if_port == 3)
 784                 /* Start the thinnet transceiver. We should really wait 50ms... */
 785                 outw(StartCoax, ioaddr + EL3_CMD);
 786         EL3WINDOW(4);
 787         outw((inw(ioaddr + Wn4_Media) & ~(Media_10TP | Media_SQE)) |
 788              media_tbl[dev->if_port].media_bits, ioaddr + Wn4_Media);
 789
 790         /* Switch to the stats window, and clear all stats by reading. */
 791         outw(StatsDisable, ioaddr + EL3_CMD);
 792         EL3WINDOW(6);
 793         for (i = 0; i < 10; i++)
 794                 inb(ioaddr + i);
 795         inw(ioaddr + 10);
 796         inw(ioaddr + 12);
 797         /* New: On the Vortex we must also clear the BadSSD counter. */
 798         EL3WINDOW(4);
 799         inb(ioaddr + 12);
 800         /* ..and on the Boomerang we enable the extra statistics bits. */
 801         outw(0x0040, ioaddr + Wn4_NetDiag);
 802
 803         /* Switch to register set 7 for normal use. */
 804         EL3WINDOW(7);
 805
 806         if (vp->full_bus_master_rx) {   /* Boomerang bus master. */
 807                 vp->cur_rx = vp->dirty_rx = 0;
 808                 if (corkscrew_debug > 2)
 809                         printk("%s:  Filling in the Rx ring.\n",
 810                                dev->name);
 811                 for (i = 0; i < RX_RING_SIZE; i++) {
 812                         struct sk_buff *skb;
 813                         if (i < (RX_RING_SIZE - 1))
 814                                 vp->rx_ring[i].next =
 815                                     isa_virt_to_bus(&vp->rx_ring[i + 1]);
 816                         else
 817                                 vp->rx_ring[i].next = 0;
 818                         vp->rx_ring[i].status = 0;      /* Clear complete bit. */
 819                         vp->rx_ring[i].length = PKT_BUF_SZ | 0x80000000;
 820                         skb = dev_alloc_skb(PKT_BUF_SZ);
 821                         vp->rx_skbuff[i] = skb;
 822                         if (skb == NULL)
 823                                 break;  /* Bad news!  */
 824                         skb->dev = dev; /* Mark as being used by this device. */
 825                         skb_reserve(skb, 2);    /* Align IP on 16 byte boundaries */
 826                         vp->rx_ring[i].addr = isa_virt_to_bus(skb->data);
 827                 }
 828                 vp->rx_ring[i - 1].next = isa_virt_to_bus(&vp->rx_ring[0]);     /* Wrap the ring. */
 829                 outl(isa_virt_to_bus(&vp->rx_ring[0]), ioaddr + UpListPtr);
 830         }
 831         if (vp->full_bus_master_tx) {   /* Boomerang bus master Tx. */
 832                 vp->cur_tx = vp->dirty_tx = 0;
 833                 outb(PKT_BUF_SZ >> 8, ioaddr + TxFreeThreshold);        /* Room for a packet. */
 834                 /* Clear the Tx ring. */
 835                 for (i = 0; i < TX_RING_SIZE; i++)
 836                         vp->tx_skbuff[i] = NULL;
 837                 outl(0, ioaddr + DownListPtr);
 838         }
 839         /* Set receiver mode: presumably accept b-case and phys addr only. */
 840         set_rx_mode(dev);
 841         outw(StatsEnable, ioaddr + EL3_CMD);    /* Turn on statistics. */
 842
 843         netif_start_queue(dev);
 844
 845         outw(RxEnable, ioaddr + EL3_CMD);       /* Enable the receiver. */
 846         outw(TxEnable, ioaddr + EL3_CMD);       /* Enable transmitter. */
 847         /* Allow status bits to be seen. */
 848         outw(SetStatusEnb | AdapterFailure | IntReq | StatsFull |
 849              (vp->full_bus_master_tx ? DownComplete : TxAvailable) |
 850              (vp->full_bus_master_rx ? UpComplete : RxComplete) |
 851              (vp->bus_master ? DMADone : 0), ioaddr + EL3_CMD);
 852         /* Ack all pending events, and set active indicator mask. */
 853         outw(AckIntr | IntLatch | TxAvailable | RxEarly | IntReq,
 854              ioaddr + EL3_CMD);
 855         outw(SetIntrEnb | IntLatch | TxAvailable | RxComplete | StatsFull
 856              | (vp->bus_master ? DMADone : 0) | UpComplete | DownComplete,
 857              ioaddr + EL3_CMD);
 858
 859         return 0;
 860 }
 861
 862 static void corkscrew_timer(unsigned long data)
 863 {
 864 #ifdef AUTOMEDIA
 865         struct net_device *dev = (struct net_device *) data;
 866         struct corkscrew_private *vp = netdev_priv(dev);
 867         int ioaddr = dev->base_addr;
 868         unsigned long flags;
 869         int ok = 0;
 870
 871         if (corkscrew_debug > 1)
 872                 printk("%s: Media selection timer tick happened, %s.\n",
 873                        dev->name, media_tbl[dev->if_port].name);
 874
 875         spin_lock_irqsave(&vp->lock, flags);
 876
 877         {
 878                 int old_window = inw(ioaddr + EL3_CMD) >> 13;
 879                 int media_status;
 880                 EL3WINDOW(4);
 881                 media_status = inw(ioaddr + Wn4_Media);
 882                 switch (dev->if_port) {
 883                 case 0:
 884                 case 4:
 885                 case 5: /* 10baseT, 100baseTX, 100baseFX  */
 886                         if (media_status & Media_LnkBeat) {
 887                                 ok = 1;
 888                                 if (corkscrew_debug > 1)
 889                                         printk("%s: Media %s has link beat, %x.\n",
 890                                                 dev->name,
 891                                                 media_tbl[dev->if_port].name,
 892                                                 media_status);
 893                         } else if (corkscrew_debug > 1)
 894                                 printk("%s: Media %s is has no link beat, %x.\n",
 895                                         dev->name,
 896                                         media_tbl[dev->if_port].name,
 897                                         media_status);
 898
 899                         break;
 900                 default:        /* Other media types handled by Tx timeouts. */
 901                         if (corkscrew_debug > 1)
 902                                 printk("%s: Media %s is has no indication, %x.\n",
 903                                         dev->name,
 904                                         media_tbl[dev->if_port].name,
 905                                         media_status);
 906                         ok = 1;
 907                 }
 908                 if (!ok) {
 909                         __u32 config;
 910
 911                         do {
 912                                 dev->if_port =
 913                                     media_tbl[dev->if_port].next;
 914                         }
 915                         while (!(vp->available_media & media_tbl[dev->if_port].mask));
 916
 917                         if (dev->if_port == 8) {        /* Go back to default. */
 918                                 dev->if_port = vp->default_media;
 919                                 if (corkscrew_debug > 1)
 920                                         printk("%s: Media selection failing, using default %s port.\n",
 921                                                 dev->name,
 922                                                 media_tbl[dev->if_port].name);
 923                         } else {
 924                                 if (corkscrew_debug > 1)
 925                                         printk("%s: Media selection failed, now trying %s port.\n",
 926                                                 dev->name,
 927                                                 media_tbl[dev->if_port].name);
 928                                 vp->timer.expires = jiffies + media_tbl[dev->if_port].wait;
 929                                 add_timer(&vp->timer);
 930                         }
 931                         outw((media_status & ~(Media_10TP | Media_SQE)) |
 932                              media_tbl[dev->if_port].media_bits,
 933                              ioaddr + Wn4_Media);
 934
 935                         EL3WINDOW(3);
 936                         config = inl(ioaddr + Wn3_Config);
 937                         config = (config & ~Xcvr) | (dev->if_port << Xcvr_shift);
 938                         outl(config, ioaddr + Wn3_Config);
 939
 940                         outw(dev->if_port == 3 ? StartCoax : StopCoax,
 941                              ioaddr + EL3_CMD);
 942                 }
 943                 EL3WINDOW(old_window);
 944         }
 945
 946         spin_unlock_irqrestore(&vp->lock, flags);
 947         if (corkscrew_debug > 1)
 948                 printk("%s: Media selection timer finished, %s.\n",
 949                        dev->name, media_tbl[dev->if_port].name);
 950
 951 #endif                          /* AUTOMEDIA */
 952         return;
 953 }
 954
 955 static void corkscrew_timeout(struct net_device *dev)
 956 {
 957         int i;
 958         struct corkscrew_private *vp = netdev_priv(dev);
 959         int ioaddr = dev->base_addr;
 960
 961         printk(KERN_WARNING
 962                "%s: transmit timed out, tx_status %2.2x status %4.4x.\n",
 963                dev->name, inb(ioaddr + TxStatus),
 964                inw(ioaddr + EL3_STATUS));
 965         /* Slight code bloat to be user friendly. */
 966         if ((inb(ioaddr + TxStatus) & 0x88) == 0x88)
 967                 printk(KERN_WARNING
 968                        "%s: Transmitter encountered 16 collisions -- network"
 969                        " network cable problem?\n", dev->name);
 970 #ifndef final_version
 971         printk("  Flags; bus-master %d, full %d; dirty %d current %d.\n",
 972                vp->full_bus_master_tx, vp->tx_full, vp->dirty_tx,
 973                vp->cur_tx);
 974         printk("  Down list %8.8x vs. %p.\n", inl(ioaddr + DownListPtr),
 975                &vp->tx_ring[0]);
 976         for (i = 0; i < TX_RING_SIZE; i++) {
 977                 printk("  %d: %p  length %8.8x status %8.8x\n", i,
 978                        &vp->tx_ring[i],
 979                        vp->tx_ring[i].length, vp->tx_ring[i].status);
 980         }
 981 #endif
 982         /* Issue TX_RESET and TX_START commands. */
 983         outw(TxReset, ioaddr + EL3_CMD);
 984         for (i = 20; i >= 0; i--)
 985                 if (!(inw(ioaddr + EL3_STATUS) & CmdInProgress))
 986                         break;
 987         outw(TxEnable, ioaddr + EL3_CMD);
 988         dev->trans_start = jiffies;
 989         dev->stats.tx_errors++;
 990         dev->stats.tx_dropped++;
 991         netif_wake_queue(dev);
 992 }
 993
 994 static int corkscrew_start_xmit(struct sk_buff *skb,
 995                                 struct net_device *dev)
 996 {
 997         struct corkscrew_private *vp = netdev_priv(dev);
 998         int ioaddr = dev->base_addr;
 999
1000         /* Block a timer-based transmit from overlapping. */
1001
1002         netif_stop_queue(dev);
1003
1004         if (vp->full_bus_master_tx) {   /* BOOMERANG bus-master */
1005                 /* Calculate the next Tx descriptor entry. */
1006                 int entry = vp->cur_tx % TX_RING_SIZE;
1007                 struct boom_tx_desc *prev_entry;
1008                 unsigned long flags;
1009                 int i;
1010
1011                 if (vp->tx_full)        /* No room to transmit with */
1012                         return 1;
1013                 if (vp->cur_tx != 0)
1014                         prev_entry = &vp->tx_ring[(vp->cur_tx - 1) % TX_RING_SIZE];
1015                 else
1016                         prev_entry = NULL;
1017                 if (corkscrew_debug > 3)
1018                         printk("%s: Trying to send a packet, Tx index %d.\n",
1019                                 dev->name, vp->cur_tx);
1020                 /* vp->tx_full = 1; */
1021                 vp->tx_skbuff[entry] = skb;
1022                 vp->tx_ring[entry].next = 0;
1023                 vp->tx_ring[entry].addr = isa_virt_to_bus(skb->data);
1024                 vp->tx_ring[entry].length = skb->len | 0x80000000;
1025                 vp->tx_ring[entry].status = skb->len | 0x80000000;
1026
1027                 spin_lock_irqsave(&vp->lock, flags);
1028                 outw(DownStall, ioaddr + EL3_CMD);
1029                 /* Wait for the stall to complete. */
1030                 for (i = 20; i >= 0; i--)
1031                         if ((inw(ioaddr + EL3_STATUS) & CmdInProgress) == 0)
1032                                 break;
1033                 if (prev_entry)
1034                         prev_entry->next = isa_virt_to_bus(&vp->tx_ring[entry]);
1035                 if (inl(ioaddr + DownListPtr) == 0) {
1036                         outl(isa_virt_to_bus(&vp->tx_ring[entry]),
1037                              ioaddr + DownListPtr);
1038                         queued_packet++;
1039                 }
1040                 outw(DownUnstall, ioaddr + EL3_CMD);
1041                 spin_unlock_irqrestore(&vp->lock, flags);
1042
1043                 vp->cur_tx++;
1044                 if (vp->cur_tx - vp->dirty_tx > TX_RING_SIZE - 1)
1045                         vp->tx_full = 1;
1046                 else {          /* Clear previous interrupt enable. */
1047                         if (prev_entry)
1048                                 prev_entry->status &= ~0x80000000;
1049                         netif_wake_queue(dev);
1050                 }
1051                 dev->trans_start = jiffies;
1052                 return 0;
1053         }
1054         /* Put out the doubleword header... */
1055         outl(skb->len, ioaddr + TX_FIFO);
1056         dev->stats.tx_bytes += skb->len;
1057 #ifdef VORTEX_BUS_MASTER
1058         if (vp->bus_master) {
1059                 /* Set the bus-master controller to transfer the packet. */
1060                 outl((int) (skb->data), ioaddr + Wn7_MasterAddr);
1061                 outw((skb->len + 3) & ~3, ioaddr + Wn7_MasterLen);
1062                 vp->tx_skb = skb;
1063                 outw(StartDMADown, ioaddr + EL3_CMD);
1064                 /* queue will be woken at the DMADone interrupt. */
1065         } else {
1066                 /* ... and the packet rounded to a doubleword. */
1067                 outsl(ioaddr + TX_FIFO, skb->data, (skb->len + 3) >> 2);
1068                 dev_kfree_skb(skb);
1069                 if (inw(ioaddr + TxFree) > 1536) {
1070                         netif_wake_queue(dev);
1071                 } else
1072                         /* Interrupt us when the FIFO has room for max-sized packet. */
1073                         outw(SetTxThreshold + (1536 >> 2),
1074                              ioaddr + EL3_CMD);
1075         }
1076 #else
1077         /* ... and the packet rounded to a doubleword. */
1078         outsl(ioaddr + TX_FIFO, skb->data, (skb->len + 3) >> 2);
1079         dev_kfree_skb(skb);
1080         if (inw(ioaddr + TxFree) > 1536) {
1081                 netif_wake_queue(dev);
1082         } else
1083                 /* Interrupt us when the FIFO has room for max-sized packet. */
1084                 outw(SetTxThreshold + (1536 >> 2), ioaddr + EL3_CMD);
1085 #endif                          /* bus master */
1086
1087         dev->trans_start = jiffies;
1088
1089         /* Clear the Tx status stack. */
1090         {
1091                 short tx_status;
1092                 int i = 4;
1093
1094                 while (--i > 0 && (tx_status = inb(ioaddr + TxStatus)) > 0) {
1095                         if (tx_status & 0x3C) { /* A Tx-disabling error occurred.  */
1096                                 if (corkscrew_debug > 2)
1097                                         printk("%s: Tx error, status %2.2x.\n",
1098                                                 dev->name, tx_status);
1099                                 if (tx_status & 0x04)
1100                                         dev->stats.tx_fifo_errors++;
1101                                 if (tx_status & 0x38)
1102                                         dev->stats.tx_aborted_errors++;
1103                                 if (tx_status & 0x30) {
1104                                         int j;
1105                                         outw(TxReset, ioaddr + EL3_CMD);
1106                                         for (j = 20; j >= 0; j--)
1107                                                 if (!(inw(ioaddr + EL3_STATUS) & CmdInProgress))
1108                                                         break;
1109                                 }
1110                                 outw(TxEnable, ioaddr + EL3_CMD);
1111                         }
1112                         outb(0x00, ioaddr + TxStatus);  /* Pop the status stack. */
1113                 }
1114         }
1115         return 0;
1116 }
1117
1118 /* The interrupt handler does all of the Rx thread work and cleans up
1119    after the Tx thread. */
1120
1121 static irqreturn_t corkscrew_interrupt(int irq, void *dev_id)
1122 {
1123         /* Use the now-standard shared IRQ implementation. */
1124         struct net_device *dev = dev_id;
1125         struct corkscrew_private *lp = netdev_priv(dev);
1126         int ioaddr, status;
1127         int latency;
1128         int i = max_interrupt_work;
1129
1130         ioaddr = dev->base_addr;
1131         latency = inb(ioaddr + Timer);
1132
1133         spin_lock(&lp->lock);
1134
1135         status = inw(ioaddr + EL3_STATUS);
1136
1137         if (corkscrew_debug > 4)
1138                 printk("%s: interrupt, status %4.4x, timer %d.\n",
1139                         dev->name, status, latency);
1140         if ((status & 0xE000) != 0xE000) {
1141                 static int donedidthis;
1142                 /* Some interrupt controllers store a bogus interrupt from boot-time.
1143                    Ignore a single early interrupt, but don't hang the machine for
1144                    other interrupt problems. */
1145                 if (donedidthis++ > 100) {
1146                         printk(KERN_ERR "%s: Bogus interrupt, bailing. Status %4.4x, start=%d.\n",
1147                                    dev->name, status, netif_running(dev));
1148                         free_irq(dev->irq, dev);
1149                         dev->irq = -1;
1150                 }
1151         }
1152
1153         do {
1154                 if (corkscrew_debug > 5)
1155                         printk("%s: In interrupt loop, status %4.4x.\n",
1156                                dev->name, status);
1157                 if (status & RxComplete)
1158                         corkscrew_rx(dev);
1159
1160                 if (status & TxAvailable) {
1161                         if (corkscrew_debug > 5)
1162                                 printk("        TX room bit was handled.\n");
1163                         /* There's room in the FIFO for a full-sized packet. */
1164                         outw(AckIntr | TxAvailable, ioaddr + EL3_CMD);
1165                         netif_wake_queue(dev);
1166                 }
1167                 if (status & DownComplete) {
1168                         unsigned int dirty_tx = lp->dirty_tx;
1169
1170                         while (lp->cur_tx - dirty_tx > 0) {
1171                                 int entry = dirty_tx % TX_RING_SIZE;
1172                                 if (inl(ioaddr + DownListPtr) == isa_virt_to_bus(&lp->tx_ring[entry]))
1173                                         break;  /* It still hasn't been processed. */
1174                                 if (lp->tx_skbuff[entry]) {
1175                                         dev_kfree_skb_irq(lp->tx_skbuff[entry]);
1176                                         lp->tx_skbuff[entry] = NULL;
1177                                 }
1178                                 dirty_tx++;
1179                         }
1180                         lp->dirty_tx = dirty_tx;
1181                         outw(AckIntr | DownComplete, ioaddr + EL3_CMD);
1182                         if (lp->tx_full && (lp->cur_tx - dirty_tx <= TX_RING_SIZE - 1)) {
1183                                 lp->tx_full = 0;
1184                                 netif_wake_queue(dev);
1185                         }
1186                 }
1187 #ifdef VORTEX_BUS_MASTER
1188                 if (status & DMADone) {
1189                         outw(0x1000, ioaddr + Wn7_MasterStatus);        /* Ack the event. */
1190                         dev_kfree_skb_irq(lp->tx_skb);  /* Release the transferred buffer */
1191                         netif_wake_queue(dev);
1192                 }
1193 #endif
1194                 if (status & UpComplete) {
1195                         boomerang_rx(dev);
1196                         outw(AckIntr | UpComplete, ioaddr + EL3_CMD);
1197                 }
1198                 if (status & (AdapterFailure | RxEarly | StatsFull)) {
1199                         /* Handle all uncommon interrupts at once. */
1200                         if (status & RxEarly) { /* Rx early is unused. */
1201                                 corkscrew_rx(dev);
1202                                 outw(AckIntr | RxEarly, ioaddr + EL3_CMD);
1203                         }
1204                         if (status & StatsFull) {       /* Empty statistics. */
1205                                 static int DoneDidThat;
1206                                 if (corkscrew_debug > 4)
1207                                         printk("%s: Updating stats.\n", dev->name);
1208                                 update_stats(ioaddr, dev);
1209                                 /* DEBUG HACK: Disable statistics as an interrupt source. */
1210                                 /* This occurs when we have the wrong media type! */
1211                                 if (DoneDidThat == 0 && inw(ioaddr + EL3_STATUS) & StatsFull) {
1212                                         int win, reg;
1213                                         printk("%s: Updating stats failed, disabling stats as an"
1214                                              " interrupt source.\n", dev->name);
1215                                         for (win = 0; win < 8; win++) {
1216                                                 EL3WINDOW(win);
1217                                                 printk("\n Vortex window %d:", win);
1218                                                 for (reg = 0; reg < 16; reg++)
1219                                                         printk(" %2.2x", inb(ioaddr + reg));
1220                                         }
1221                                         EL3WINDOW(7);
1222                                         outw(SetIntrEnb | TxAvailable |
1223                                              RxComplete | AdapterFailure |
1224                                              UpComplete | DownComplete |
1225                                              TxComplete, ioaddr + EL3_CMD);
1226                                         DoneDidThat++;
1227                                 }
1228                         }
1229                         if (status & AdapterFailure) {
1230                                 /* Adapter failure requires Rx reset and reinit. */
1231                                 outw(RxReset, ioaddr + EL3_CMD);
1232                                 /* Set the Rx filter to the current state. */
1233                                 set_rx_mode(dev);
1234                                 outw(RxEnable, ioaddr + EL3_CMD);       /* Re-enable the receiver. */
1235                                 outw(AckIntr | AdapterFailure,
1236                                      ioaddr + EL3_CMD);
1237                         }
1238                 }
1239
1240                 if (--i < 0) {
1241                         printk(KERN_ERR "%s: Too much work in interrupt, status %4.4x.  "
1242                              "Disabling functions (%4.4x).\n", dev->name,
1243                              status, SetStatusEnb | ((~status) & 0x7FE));
1244                         /* Disable all pending interrupts. */
1245                         outw(SetStatusEnb | ((~status) & 0x7FE), ioaddr + EL3_CMD);
1246                         outw(AckIntr | 0x7FF, ioaddr + EL3_CMD);
1247                         break;
1248                 }
1249                 /* Acknowledge the IRQ. */
1250                 outw(AckIntr | IntReq | IntLatch, ioaddr + EL3_CMD);
1251
1252         } while ((status = inw(ioaddr + EL3_STATUS)) & (IntLatch | RxComplete));
1253
1254         spin_unlock(&lp->lock);
1255
1256         if (corkscrew_debug > 4)
1257                 printk("%s: exiting interrupt, status %4.4x.\n", dev->name, status);
1258         return IRQ_HANDLED;
1259 }
1260
1261 static int corkscrew_rx(struct net_device *dev)
1262 {
1263         int ioaddr = dev->base_addr;
1264         int i;
1265         short rx_status;
1266
1267         if (corkscrew_debug > 5)
1268                 printk("   In rx_packet(), status %4.4x, rx_status %4.4x.\n",
1269                      inw(ioaddr + EL3_STATUS), inw(ioaddr + RxStatus));
1270         while ((rx_status = inw(ioaddr + RxStatus)) > 0) {
1271                 if (rx_status & 0x4000) {       /* Error, update stats. */
1272                         unsigned char rx_error = inb(ioaddr + RxErrors);
1273                         if (corkscrew_debug > 2)
1274                                 printk(" Rx error: status %2.2x.\n",
1275                                        rx_error);
1276                         dev->stats.rx_errors++;
1277                         if (rx_error & 0x01)
1278                                 dev->stats.rx_over_errors++;
1279                         if (rx_error & 0x02)
1280                                 dev->stats.rx_length_errors++;
1281                         if (rx_error & 0x04)
1282                                 dev->stats.rx_frame_errors++;
1283                         if (rx_error & 0x08)
1284                                 dev->stats.rx_crc_errors++;
1285                         if (rx_error & 0x10)
1286                                 dev->stats.rx_length_errors++;
1287                 } else {
1288                         /* The packet length: up to 4.5K!. */
1289                         short pkt_len = rx_status & 0x1fff;
1290                         struct sk_buff *skb;
1291
1292                         skb = dev_alloc_skb(pkt_len + 5 + 2);
1293                         if (corkscrew_debug > 4)
1294                                 printk("Receiving packet size %d status %4.4x.\n",
1295                                      pkt_len, rx_status);
1296                         if (skb != NULL) {
1297                                 skb_reserve(skb, 2);    /* Align IP on 16 byte boundaries */
1298                                 /* 'skb_put()' points to the start of sk_buff data area. */
1299                                 insl(ioaddr + RX_FIFO,
1300                                      skb_put(skb, pkt_len),
1301                                      (pkt_len + 3) >> 2);
1302                                 outw(RxDiscard, ioaddr + EL3_CMD);      /* Pop top Rx packet. */
1303                                 skb->protocol = eth_type_trans(skb, dev);
1304                                 netif_rx(skb);
1305                                 dev->last_rx = jiffies;
1306                                 dev->stats.rx_packets++;
1307                                 dev->stats.rx_bytes += pkt_len;
1308                                 /* Wait a limited time to go to next packet. */
1309                                 for (i = 200; i >= 0; i--)
1310                                         if (! (inw(ioaddr + EL3_STATUS) & CmdInProgress))
1311                                                 break;
1312                                 continue;
1313                         } else if (corkscrew_debug)
1314                                 printk("%s: Couldn't allocate a sk_buff of size %d.\n", dev->name, pkt_len);
1315                 }
1316                 outw(RxDiscard, ioaddr + EL3_CMD);
1317                 dev->stats.rx_dropped++;
1318                 /* Wait a limited time to skip this packet. */
1319                 for (i = 200; i >= 0; i--)
1320                         if (!(inw(ioaddr + EL3_STATUS) & CmdInProgress))
1321                                 break;
1322         }
1323         return 0;
1324 }
1325
1326 static int boomerang_rx(struct net_device *dev)
1327 {
1328         struct corkscrew_private *vp = netdev_priv(dev);
1329         int entry = vp->cur_rx % RX_RING_SIZE;
1330         int ioaddr = dev->base_addr;
1331         int rx_status;
1332
1333         if (corkscrew_debug > 5)
1334                 printk("   In boomerang_rx(), status %4.4x, rx_status %4.4x.\n",
1335                         inw(ioaddr + EL3_STATUS), inw(ioaddr + RxStatus));
1336         while ((rx_status = vp->rx_ring[entry].status) & RxDComplete) {
1337                 if (rx_status & RxDError) {     /* Error, update stats. */
1338                         unsigned char rx_error = rx_status >> 16;
1339                         if (corkscrew_debug > 2)
1340                                 printk(" Rx error: status %2.2x.\n",
1341                                        rx_error);
1342                         dev->stats.rx_errors++;
1343                         if (rx_error & 0x01)
1344                                 dev->stats.rx_over_errors++;
1345                         if (rx_error & 0x02)
1346                                 dev->stats.rx_length_errors++;
1347                         if (rx_error & 0x04)
1348                                 dev->stats.rx_frame_errors++;
1349                         if (rx_error & 0x08)
1350                                 dev->stats.rx_crc_errors++;
1351                         if (rx_error & 0x10)
1352                                 dev->stats.rx_length_errors++;
1353                 } else {
1354                         /* The packet length: up to 4.5K!. */
1355                         short pkt_len = rx_status & 0x1fff;
1356                         struct sk_buff *skb;
1357
1358                         dev->stats.rx_bytes += pkt_len;
1359                         if (corkscrew_debug > 4)
1360                                 printk("Receiving packet size %d status %4.4x.\n",
1361                                      pkt_len, rx_status);
1362
1363                         /* Check if the packet is long enough to just accept without
1364                            copying to a properly sized skbuff. */
1365                         if (pkt_len < rx_copybreak
1366                             && (skb = dev_alloc_skb(pkt_len + 4)) != NULL) {
1367                                 skb_reserve(skb, 2);    /* Align IP on 16 byte boundaries */
1368                                 /* 'skb_put()' points to the start of sk_buff data area. */
1369                                 memcpy(skb_put(skb, pkt_len),
1370                                        isa_bus_to_virt(vp->rx_ring[entry].
1371                                                    addr), pkt_len);
1372                                 rx_copy++;
1373                         } else {
1374                                 void *temp;
1375                                 /* Pass up the skbuff already on the Rx ring. */
1376                                 skb = vp->rx_skbuff[entry];
1377                                 vp->rx_skbuff[entry] = NULL;
1378                                 temp = skb_put(skb, pkt_len);
1379                                 /* Remove this checking code for final release. */
1380                                 if (isa_bus_to_virt(vp->rx_ring[entry].addr) != temp)
1381                                             printk("%s: Warning -- the skbuff addresses do not match"
1382                                              " in boomerang_rx: %p vs. %p / %p.\n",
1383                                              dev->name,
1384                                              isa_bus_to_virt(vp->
1385                                                          rx_ring[entry].
1386                                                          addr), skb->head,
1387                                              temp);
1388                                 rx_nocopy++;
1389                         }
1390                         skb->protocol = eth_type_trans(skb, dev);
1391                         netif_rx(skb);
1392                         dev->last_rx = jiffies;
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 = dev_alloc_skb(PKT_BUF_SZ);
1403                         if (skb == NULL)
1404                                 break;  /* Bad news!  */
1405                         skb->dev = dev; /* Mark as being used by this device. */
1406                         skb_reserve(skb, 2);    /* Align IP on 16 byte boundaries */
1407                         vp->rx_ring[entry].addr = isa_virt_to_bus(skb->data);
1408                         vp->rx_skbuff[entry] = skb;
1409                 }
1410                 vp->rx_ring[entry].status = 0;  /* Clear complete bit. */
1411         }
1412         return 0;
1413 }
1414
1415 static int corkscrew_close(struct net_device *dev)
1416 {
1417         struct corkscrew_private *vp = netdev_priv(dev);
1418         int ioaddr = dev->base_addr;
1419         int i;
1420
1421         netif_stop_queue(dev);
1422
1423         if (corkscrew_debug > 1) {
1424                 printk("%s: corkscrew_close() status %4.4x, Tx status %2.2x.\n",
1425                      dev->name, inw(ioaddr + EL3_STATUS),
1426                      inb(ioaddr + TxStatus));
1427                 printk("%s: corkscrew close stats: rx_nocopy %d rx_copy %d"
1428                        " tx_queued %d.\n", dev->name, rx_nocopy, rx_copy,
1429                        queued_packet);
1430         }
1431
1432         del_timer(&vp->timer);
1433
1434         /* Turn off statistics ASAP.  We update lp->stats below. */
1435         outw(StatsDisable, ioaddr + EL3_CMD);
1436
1437         /* Disable the receiver and transmitter. */
1438         outw(RxDisable, ioaddr + EL3_CMD);
1439         outw(TxDisable, ioaddr + EL3_CMD);
1440
1441         if (dev->if_port == XCVR_10base2)
1442                 /* Turn off thinnet power.  Green! */
1443                 outw(StopCoax, ioaddr + EL3_CMD);
1444
1445         free_irq(dev->irq, dev);
1446
1447         outw(SetIntrEnb | 0x0000, ioaddr + EL3_CMD);
1448
1449         update_stats(ioaddr, dev);
1450         if (vp->full_bus_master_rx) {   /* Free Boomerang bus master Rx buffers. */
1451                 outl(0, ioaddr + UpListPtr);
1452                 for (i = 0; i < RX_RING_SIZE; i++)
1453                         if (vp->rx_skbuff[i]) {
1454                                 dev_kfree_skb(vp->rx_skbuff[i]);
1455                                 vp->rx_skbuff[i] = NULL;
1456                         }
1457         }
1458         if (vp->full_bus_master_tx) {   /* Free Boomerang bus master Tx buffers. */
1459                 outl(0, ioaddr + DownListPtr);
1460                 for (i = 0; i < TX_RING_SIZE; i++)
1461                         if (vp->tx_skbuff[i]) {
1462                                 dev_kfree_skb(vp->tx_skbuff[i]);
1463                                 vp->tx_skbuff[i] = NULL;
1464                         }
1465         }
1466
1467         return 0;
1468 }
1469
1470 static struct net_device_stats *corkscrew_get_stats(struct net_device *dev)
1471 {
1472         struct corkscrew_private *vp = netdev_priv(dev);
1473         unsigned long flags;
1474
1475         if (netif_running(dev)) {
1476                 spin_lock_irqsave(&vp->lock, flags);
1477                 update_stats(dev->base_addr, dev);
1478                 spin_unlock_irqrestore(&vp->lock, flags);
1479         }
1480         return &dev->stats;
1481 }
1482
1483 /*  Update statistics.
1484         Unlike with the EL3 we need not worry about interrupts changing
1485         the window setting from underneath us, but we must still guard
1486         against a race condition with a StatsUpdate interrupt updating the
1487         table.  This is done by checking that the ASM (!) code generated uses
1488         atomic updates with '+='.
1489         */
1490 static void update_stats(int ioaddr, struct net_device *dev)
1491 {
1492         /* Unlike the 3c5x9 we need not turn off stats updates while reading. */
1493         /* Switch to the stats window, and read everything. */
1494         EL3WINDOW(6);
1495         dev->stats.tx_carrier_errors += inb(ioaddr + 0);
1496         dev->stats.tx_heartbeat_errors += inb(ioaddr + 1);
1497         /* Multiple collisions. */ inb(ioaddr + 2);
1498         dev->stats.collisions += inb(ioaddr + 3);
1499         dev->stats.tx_window_errors += inb(ioaddr + 4);
1500         dev->stats.rx_fifo_errors += inb(ioaddr + 5);
1501         dev->stats.tx_packets += inb(ioaddr + 6);
1502         dev->stats.tx_packets += (inb(ioaddr + 9) & 0x30) << 4;
1503                                                 /* Rx packets   */ inb(ioaddr + 7);
1504                                                 /* Must read to clear */
1505         /* Tx deferrals */ inb(ioaddr + 8);
1506         /* Don't bother with register 9, an extension of registers 6&7.
1507            If we do use the 6&7 values the atomic update assumption above
1508            is invalid. */
1509         inw(ioaddr + 10);       /* Total Rx and Tx octets. */
1510         inw(ioaddr + 12);
1511         /* New: On the Vortex we must also clear the BadSSD counter. */
1512         EL3WINDOW(4);
1513         inb(ioaddr + 12);
1514
1515         /* We change back to window 7 (not 1) with the Vortex. */
1516         EL3WINDOW(7);
1517         return;
1518 }
1519
1520 /* This new version of set_rx_mode() supports v1.4 kernels.
1521    The Vortex chip has no documented multicast filter, so the only
1522    multicast setting is to receive all multicast frames.  At least
1523    the chip has a very clean way to set the mode, unlike many others. */
1524 static void set_rx_mode(struct net_device *dev)
1525 {
1526         int ioaddr = dev->base_addr;
1527         short new_mode;
1528
1529         if (dev->flags & IFF_PROMISC) {
1530                 if (corkscrew_debug > 3)
1531                         printk("%s: Setting promiscuous mode.\n",
1532                                dev->name);
1533                 new_mode = SetRxFilter | RxStation | RxMulticast | RxBroadcast | RxProm;
1534         } else if ((dev->mc_list) || (dev->flags & IFF_ALLMULTI)) {
1535                 new_mode = SetRxFilter | RxStation | RxMulticast | RxBroadcast;
1536         } else
1537                 new_mode = SetRxFilter | RxStation | RxBroadcast;
1538
1539         outw(new_mode, ioaddr + EL3_CMD);
1540 }
1541
1542 static void netdev_get_drvinfo(struct net_device *dev,
1543                                struct ethtool_drvinfo *info)
1544 {
1545         strcpy(info->driver, DRV_NAME);
1546         strcpy(info->version, DRV_VERSION);
1547         sprintf(info->bus_info, "ISA 0x%lx", dev->base_addr);
1548 }
1549
1550 static u32 netdev_get_msglevel(struct net_device *dev)
1551 {
1552         return corkscrew_debug;
1553 }
1554
1555 static void netdev_set_msglevel(struct net_device *dev, u32 level)
1556 {
1557         corkscrew_debug = level;
1558 }
1559
1560 static const struct ethtool_ops netdev_ethtool_ops = {
1561         .get_drvinfo            = netdev_get_drvinfo,
1562         .get_msglevel           = netdev_get_msglevel,
1563         .set_msglevel           = netdev_set_msglevel,
1564 };
1565
1566
1567 #ifdef MODULE
1568 void cleanup_module(void)
1569 {
1570         while (!list_empty(&root_corkscrew_dev)) {
1571                 struct net_device *dev;
1572                 struct corkscrew_private *vp;
1573
1574                 vp = list_entry(root_corkscrew_dev.next,
1575                                 struct corkscrew_private, list);
1576                 dev = vp->our_dev;
1577                 unregister_netdev(dev);
1578                 cleanup_card(dev);
1579                 free_netdev(dev);
1580         }
1581 }
1582 #endif                          /* MODULE */
1583
1584 /*
1585  * Local variables:
1586  *  compile-command: "gcc -DMODULE -D__KERNEL__ -Wall -Wstrict-prototypes -O6 -c 3c515.c"
1587  *  c-indent-level: 4
1588  *  tab-width: 4
1589  * End:
1590  */