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 union wn3_config {
 247         int i;
 248         struct w3_config_fields {
 249                 unsigned int ram_size:3, ram_width:1, ram_speed:2, rom_size:2;
 250                 int pad8:8;
 251                 unsigned int ram_split:2, pad18:2, xcvr:3, pad21:1, autoselect:1;
 252                 int pad24:7;
 253         } u;
 254 };
 255
 256 enum Window4 {
 257         Wn4_NetDiag = 6, Wn4_Media = 10,        /* Window 4: Xcvr/media bits. */
 258 };
 259 enum Win4_Media_bits {
 260         Media_SQE = 0x0008,     /* Enable SQE error counting for AUI. */
 261         Media_10TP = 0x00C0,    /* Enable link beat and jabber for 10baseT. */
 262         Media_Lnk = 0x0080,     /* Enable just link beat for 100TX/100FX. */
 263         Media_LnkBeat = 0x0800,
 264 };
 265 enum Window7 {                  /* Window 7: Bus Master control. */
 266         Wn7_MasterAddr = 0, Wn7_MasterLen = 6, Wn7_MasterStatus = 12,
 267 };
 268
 269 /* Boomerang-style bus master control registers.  Note ISA aliases! */
 270 enum MasterCtrl {
 271         PktStatus = 0x400, DownListPtr = 0x404, FragAddr = 0x408, FragLen =
 272             0x40c,
 273         TxFreeThreshold = 0x40f, UpPktStatus = 0x410, UpListPtr = 0x418,
 274 };
 275
 276 /* The Rx and Tx descriptor lists.
 277    Caution Alpha hackers: these types are 32 bits!  Note also the 8 byte
 278    alignment contraint on tx_ring[] and rx_ring[]. */
 279 struct boom_rx_desc {
 280         u32 next;
 281         s32 status;
 282         u32 addr;
 283         s32 length;
 284 };
 285
 286 /* Values for the Rx status entry. */
 287 enum rx_desc_status {
 288         RxDComplete = 0x00008000, RxDError = 0x4000,
 289         /* See boomerang_rx() for actual error bits */
 290 };
 291
 292 struct boom_tx_desc {
 293         u32 next;
 294         s32 status;
 295         u32 addr;
 296         s32 length;
 297 };
 298
 299 struct corkscrew_private {
 300         const char *product_name;
 301         struct list_head list;
 302         struct net_device *our_dev;
 303         /* The Rx and Tx rings are here to keep them quad-word-aligned. */
 304         struct boom_rx_desc rx_ring[RX_RING_SIZE];
 305         struct boom_tx_desc tx_ring[TX_RING_SIZE];
 306         /* The addresses of transmit- and receive-in-place skbuffs. */
 307         struct sk_buff *rx_skbuff[RX_RING_SIZE];
 308         struct sk_buff *tx_skbuff[TX_RING_SIZE];
 309         unsigned int cur_rx, cur_tx;    /* The next free ring entry */
 310         unsigned int dirty_rx, dirty_tx;/* The ring entries to be free()ed. */
 311         struct net_device_stats stats;
 312         struct sk_buff *tx_skb; /* Packet being eaten by bus master ctrl.  */
 313         struct timer_list timer;        /* Media selection timer. */
 314         int capabilities        ;       /* Adapter capabilities word. */
 315         int options;                    /* User-settable misc. driver options. */
 316         int last_rx_packets;            /* For media autoselection. */
 317         unsigned int available_media:8, /* From Wn3_Options */
 318                 media_override:3,       /* Passed-in media type. */
 319                 default_media:3,        /* Read from the EEPROM. */
 320                 full_duplex:1, autoselect:1, bus_master:1,      /* Vortex can only do a fragment bus-m. */
 321                 full_bus_master_tx:1, full_bus_master_rx:1,     /* Boomerang  */
 322                 tx_full:1;
 323         spinlock_t lock;
 324         struct device *dev;
 325 };
 326
 327 /* The action to take with a media selection timer tick.
 328    Note that we deviate from the 3Com order by checking 10base2 before AUI.
 329  */
 330 enum xcvr_types {
 331         XCVR_10baseT = 0, XCVR_AUI, XCVR_10baseTOnly, XCVR_10base2, XCVR_100baseTx,
 332         XCVR_100baseFx, XCVR_MII = 6, XCVR_Default = 8,
 333 };
 334
 335 static struct media_table {
 336         char *name;
 337         unsigned int media_bits:16,     /* Bits to set in Wn4_Media register. */
 338                 mask:8,                 /* The transceiver-present bit in Wn3_Config. */
 339                 next:8;                 /* The media type to try next. */
 340         short wait;                     /* Time before we check media status. */
 341 } media_tbl[] = {
 342         { "10baseT", Media_10TP, 0x08, XCVR_10base2, (14 * HZ) / 10 },
 343         { "10Mbs AUI", Media_SQE, 0x20, XCVR_Default, (1 * HZ) / 10},
 344         { "undefined", 0, 0x80, XCVR_10baseT, 10000},
 345         { "10base2", 0, 0x10, XCVR_AUI, (1 * HZ) / 10},
 346         { "100baseTX", Media_Lnk, 0x02, XCVR_100baseFx, (14 * HZ) / 10},
 347         { "100baseFX", Media_Lnk, 0x04, XCVR_MII, (14 * HZ) / 10},
 348         { "MII", 0, 0x40, XCVR_10baseT, 3 * HZ},
 349         { "undefined", 0, 0x01, XCVR_10baseT, 10000},
 350         { "Default", 0, 0xFF, XCVR_10baseT, 10000},
 351 };
 352
 353 #ifdef __ISAPNP__
 354 static struct isapnp_device_id corkscrew_isapnp_adapters[] = {
 355         {       ISAPNP_ANY_ID, ISAPNP_ANY_ID,
 356                 ISAPNP_VENDOR('T', 'C', 'M'), ISAPNP_FUNCTION(0x5051),
 357                 (long) "3Com Fast EtherLink ISA" },
 358         { }     /* terminate list */
 359 };
 360
 361 MODULE_DEVICE_TABLE(isapnp, corkscrew_isapnp_adapters);
 362
 363 static int nopnp;
 364 #endif /* __ISAPNP__ */
 365
 366 static struct net_device *corkscrew_scan(int unit);
 367 static int corkscrew_setup(struct net_device *dev, int ioaddr,
 368                             struct pnp_dev *idev, int card_number);
 369 static int corkscrew_open(struct net_device *dev);
 370 static void corkscrew_timer(unsigned long arg);
 371 static int corkscrew_start_xmit(struct sk_buff *skb,
 372                                 struct net_device *dev);
 373 static int corkscrew_rx(struct net_device *dev);
 374 static void corkscrew_timeout(struct net_device *dev);
 375 static int boomerang_rx(struct net_device *dev);
 376 static irqreturn_t corkscrew_interrupt(int irq, void *dev_id,
 377                                     struct pt_regs *regs);
 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 struct ethtool_ops netdev_ethtool_ops;
 383 \f
 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         SET_MODULE_OWNER(dev);
 506
 507 #ifdef __ISAPNP__
 508         if(nopnp == 1)
 509                 goto no_pnp;
 510         for(i=0; corkscrew_isapnp_adapters[i].vendor != 0; i++) {
 511                 struct pnp_dev *idev = NULL;
 512                 int irq;
 513                 while((idev = pnp_find_dev(NULL,
 514                                            corkscrew_isapnp_adapters[i].vendor,
 515                                            corkscrew_isapnp_adapters[i].function,
 516                                            idev))) {
 517
 518                         if (pnp_device_attach(idev) < 0)
 519                                 continue;
 520                         if (pnp_activate_dev(idev) < 0) {
 521                                 printk("pnp activate failed (out of resources?)\n");
 522                                 pnp_device_detach(idev);
 523                                 continue;
 524                         }
 525                         if (!pnp_port_valid(idev, 0) || !pnp_irq_valid(idev, 0)) {
 526                                 pnp_device_detach(idev);
 527                                 continue;
 528                         }
 529                         ioaddr = pnp_port_start(idev, 0);
 530                         irq = pnp_irq(idev, 0);
 531                         if (!check_device(ioaddr)) {
 532                                 pnp_device_detach(idev);
 533                                 continue;
 534                         }
 535                         if(corkscrew_debug)
 536                                 printk ("ISAPNP reports %s at i/o 0x%x, irq %d\n",
 537                                         (char*) corkscrew_isapnp_adapters[i].driver_data, ioaddr, irq);
 538                         printk(KERN_INFO "3c515 Resource configuration register %#4.4x, DCR %4.4x.\n",
 539                                 inl(ioaddr + 0x2002), inw(ioaddr + 0x2000));
 540                         /* irq = inw(ioaddr + 0x2002) & 15; */ /* Use the irq from isapnp */
 541                         SET_NETDEV_DEV(dev, &idev->dev);
 542                         pnp_cards++;
 543                         err = corkscrew_setup(dev, ioaddr, idev, cards_found++);
 544                         if (!err)
 545                                 return dev;
 546                         cleanup_card(dev);
 547                 }
 548         }
 549 no_pnp:
 550 #endif /* __ISAPNP__ */
 551
 552         /* Check all locations on the ISA bus -- evil! */
 553         for (ioaddr = 0x100; ioaddr < 0x400; ioaddr += 0x20) {
 554                 if (!check_device(ioaddr))
 555                         continue;
 556
 557                 printk(KERN_INFO "3c515 Resource configuration register %#4.4x, DCR %4.4x.\n",
 558                      inl(ioaddr + 0x2002), inw(ioaddr + 0x2000));
 559                 err = corkscrew_setup(dev, ioaddr, NULL, cards_found++);
 560                 if (!err)
 561                         return dev;
 562                 cleanup_card(dev);
 563         }
 564         free_netdev(dev);
 565         return NULL;
 566 }
 567
 568 static int corkscrew_setup(struct net_device *dev, int ioaddr,
 569                             struct pnp_dev *idev, int card_number)
 570 {
 571         struct corkscrew_private *vp = netdev_priv(dev);
 572         unsigned int eeprom[0x40], checksum = 0;        /* EEPROM contents */
 573         int i;
 574         int irq;
 575
 576         if (idev) {
 577                 irq = pnp_irq(idev, 0);
 578                 vp->dev = &idev->dev;
 579         } else {
 580                 irq = inw(ioaddr + 0x2002) & 15;
 581         }
 582
 583         dev->base_addr = ioaddr;
 584         dev->irq = irq;
 585         dev->dma = inw(ioaddr + 0x2000) & 7;
 586         vp->product_name = "3c515";
 587         vp->options = dev->mem_start;
 588         vp->our_dev = dev;
 589
 590         if (!vp->options) {
 591                  if (card_number >= MAX_UNITS)
 592                         vp->options = -1;
 593                 else
 594                         vp->options = options[card_number];
 595         }
 596
 597         if (vp->options >= 0) {
 598                 vp->media_override = vp->options & 7;
 599                 if (vp->media_override == 2)
 600                         vp->media_override = 0;
 601                 vp->full_duplex = (vp->options & 8) ? 1 : 0;
 602                 vp->bus_master = (vp->options & 16) ? 1 : 0;
 603         } else {
 604                 vp->media_override = 7;
 605                 vp->full_duplex = 0;
 606                 vp->bus_master = 0;
 607         }
 608 #ifdef MODULE
 609         list_add(&vp->list, &root_corkscrew_dev);
 610 #endif
 611
 612         printk(KERN_INFO "%s: 3Com %s at %#3x,", dev->name, vp->product_name, ioaddr);
 613
 614         spin_lock_init(&vp->lock);
 615
 616         /* Read the station address from the EEPROM. */
 617         EL3WINDOW(0);
 618         for (i = 0; i < 0x18; i++) {
 619                 short *phys_addr = (short *) dev->dev_addr;
 620                 int timer;
 621                 outw(EEPROM_Read + i, ioaddr + Wn0EepromCmd);
 622                 /* Pause for at least 162 us. for the read to take place. */
 623                 for (timer = 4; timer >= 0; timer--) {
 624                         udelay(162);
 625                         if ((inw(ioaddr + Wn0EepromCmd) & 0x0200) == 0)
 626                                 break;
 627                 }
 628                 eeprom[i] = inw(ioaddr + Wn0EepromData);
 629                 checksum ^= eeprom[i];
 630                 if (i < 3)
 631                         phys_addr[i] = htons(eeprom[i]);
 632         }
 633         checksum = (checksum ^ (checksum >> 8)) & 0xff;
 634         if (checksum != 0x00)
 635                 printk(" ***INVALID CHECKSUM %4.4x*** ", checksum);
 636         for (i = 0; i < 6; i++)
 637                 printk("%c%2.2x", i ? ':' : ' ', dev->dev_addr[i]);
 638         if (eeprom[16] == 0x11c7) {     /* Corkscrew */
 639                 if (request_dma(dev->dma, "3c515")) {
 640                         printk(", DMA %d allocation failed", dev->dma);
 641                         dev->dma = 0;
 642                 } else
 643                         printk(", DMA %d", dev->dma);
 644         }
 645         printk(", IRQ %d\n", dev->irq);
 646         /* Tell them about an invalid IRQ. */
 647         if (corkscrew_debug && (dev->irq <= 0 || dev->irq > 15))
 648                 printk(KERN_WARNING " *** Warning: this IRQ is unlikely to work! ***\n");
 649
 650         {
 651                 char *ram_split[] = { "5:3", "3:1", "1:1", "3:5" };
 652                 union wn3_config config;
 653                 EL3WINDOW(3);
 654                 vp->available_media = inw(ioaddr + Wn3_Options);
 655                 config.i = inl(ioaddr + Wn3_Config);
 656                 if (corkscrew_debug > 1)
 657                         printk(KERN_INFO "  Internal config register is %4.4x, transceivers %#x.\n",
 658                                 config.i, inw(ioaddr + Wn3_Options));
 659                 printk(KERN_INFO "  %dK %s-wide RAM %s Rx:Tx split, %s%s interface.\n",
 660                         8 << config.u.ram_size,
 661                         config.u.ram_width ? "word" : "byte",
 662                         ram_split[config.u.ram_split],
 663                         config.u.autoselect ? "autoselect/" : "",
 664                         media_tbl[config.u.xcvr].name);
 665                 dev->if_port = config.u.xcvr;
 666                 vp->default_media = config.u.xcvr;
 667                 vp->autoselect = config.u.autoselect;
 668         }
 669         if (vp->media_override != 7) {
 670                 printk(KERN_INFO "  Media override to transceiver type %d (%s).\n",
 671                        vp->media_override,
 672                        media_tbl[vp->media_override].name);
 673                 dev->if_port = vp->media_override;
 674         }
 675
 676         vp->capabilities = eeprom[16];
 677         vp->full_bus_master_tx = (vp->capabilities & 0x20) ? 1 : 0;
 678         /* Rx is broken at 10mbps, so we always disable it. */
 679         /* vp->full_bus_master_rx = 0; */
 680         vp->full_bus_master_rx = (vp->capabilities & 0x20) ? 1 : 0;
 681
 682         /* The 3c51x-specific entries in the device structure. */
 683         dev->open = &corkscrew_open;
 684         dev->hard_start_xmit = &corkscrew_start_xmit;
 685         dev->tx_timeout = &corkscrew_timeout;
 686         dev->watchdog_timeo = (400 * HZ) / 1000;
 687         dev->stop = &corkscrew_close;
 688         dev->get_stats = &corkscrew_get_stats;
 689         dev->set_multicast_list = &set_rx_mode;
 690         dev->ethtool_ops = &netdev_ethtool_ops;
 691
 692         return register_netdev(dev);
 693 }
 694 \f
 695
 696 static int corkscrew_open(struct net_device *dev)
 697 {
 698         int ioaddr = dev->base_addr;
 699         struct corkscrew_private *vp = netdev_priv(dev);
 700         union wn3_config config;
 701         int i;
 702
 703         /* Before initializing select the active media port. */
 704         EL3WINDOW(3);
 705         if (vp->full_duplex)
 706                 outb(0x20, ioaddr + Wn3_MAC_Ctrl);      /* Set the full-duplex bit. */
 707         config.i = inl(ioaddr + Wn3_Config);
 708
 709         if (vp->media_override != 7) {
 710                 if (corkscrew_debug > 1)
 711                         printk(KERN_INFO "%s: Media override to transceiver %d (%s).\n",
 712                                 dev->name, vp->media_override,
 713                                 media_tbl[vp->media_override].name);
 714                 dev->if_port = vp->media_override;
 715         } else if (vp->autoselect) {
 716                 /* Find first available media type, starting with 100baseTx. */
 717                 dev->if_port = 4;
 718                 while (!(vp->available_media & media_tbl[dev->if_port].mask))
 719                         dev->if_port = media_tbl[dev->if_port].next;
 720
 721                 if (corkscrew_debug > 1)
 722                         printk("%s: Initial media type %s.\n",
 723                                dev->name, media_tbl[dev->if_port].name);
 724
 725                 init_timer(&vp->timer);
 726                 vp->timer.expires = jiffies + media_tbl[dev->if_port].wait;
 727                 vp->timer.data = (unsigned long) dev;
 728                 vp->timer.function = &corkscrew_timer;  /* timer handler */
 729                 add_timer(&vp->timer);
 730         } else
 731                 dev->if_port = vp->default_media;
 732
 733         config.u.xcvr = dev->if_port;
 734         outl(config.i, ioaddr + Wn3_Config);
 735
 736         if (corkscrew_debug > 1) {
 737                 printk("%s: corkscrew_open() InternalConfig %8.8x.\n",
 738                        dev->name, config.i);
 739         }
 740
 741         outw(TxReset, ioaddr + EL3_CMD);
 742         for (i = 20; i >= 0; i--)
 743                 if (!(inw(ioaddr + EL3_STATUS) & CmdInProgress))
 744                         break;
 745
 746         outw(RxReset, ioaddr + EL3_CMD);
 747         /* Wait a few ticks for the RxReset command to complete. */
 748         for (i = 20; i >= 0; i--)
 749                 if (!(inw(ioaddr + EL3_STATUS) & CmdInProgress))
 750                         break;
 751
 752         outw(SetStatusEnb | 0x00, ioaddr + EL3_CMD);
 753
 754         /* Use the now-standard shared IRQ implementation. */
 755         if (vp->capabilities == 0x11c7) {
 756                 /* Corkscrew: Cannot share ISA resources. */
 757                 if (dev->irq == 0
 758                     || dev->dma == 0
 759                     || request_irq(dev->irq, &corkscrew_interrupt, 0,
 760                                    vp->product_name, dev)) return -EAGAIN;
 761                 enable_dma(dev->dma);
 762                 set_dma_mode(dev->dma, DMA_MODE_CASCADE);
 763         } else if (request_irq(dev->irq, &corkscrew_interrupt, IRQF_SHARED,
 764                                vp->product_name, dev)) {
 765                 return -EAGAIN;
 766         }
 767
 768         if (corkscrew_debug > 1) {
 769                 EL3WINDOW(4);
 770                 printk("%s: corkscrew_open() irq %d media status %4.4x.\n",
 771                        dev->name, dev->irq, inw(ioaddr + Wn4_Media));
 772         }
 773
 774         /* Set the station address and mask in window 2 each time opened. */
 775         EL3WINDOW(2);
 776         for (i = 0; i < 6; i++)
 777                 outb(dev->dev_addr[i], ioaddr + i);
 778         for (; i < 12; i += 2)
 779                 outw(0, ioaddr + i);
 780
 781         if (dev->if_port == 3)
 782                 /* Start the thinnet transceiver. We should really wait 50ms... */
 783                 outw(StartCoax, ioaddr + EL3_CMD);
 784         EL3WINDOW(4);
 785         outw((inw(ioaddr + Wn4_Media) & ~(Media_10TP | Media_SQE)) |
 786              media_tbl[dev->if_port].media_bits, ioaddr + Wn4_Media);
 787
 788         /* Switch to the stats window, and clear all stats by reading. */
 789         outw(StatsDisable, ioaddr + EL3_CMD);
 790         EL3WINDOW(6);
 791         for (i = 0; i < 10; i++)
 792                 inb(ioaddr + i);
 793         inw(ioaddr + 10);
 794         inw(ioaddr + 12);
 795         /* New: On the Vortex we must also clear the BadSSD counter. */
 796         EL3WINDOW(4);
 797         inb(ioaddr + 12);
 798         /* ..and on the Boomerang we enable the extra statistics bits. */
 799         outw(0x0040, ioaddr + Wn4_NetDiag);
 800
 801         /* Switch to register set 7 for normal use. */
 802         EL3WINDOW(7);
 803
 804         if (vp->full_bus_master_rx) {   /* Boomerang bus master. */
 805                 vp->cur_rx = vp->dirty_rx = 0;
 806                 if (corkscrew_debug > 2)
 807                         printk("%s:  Filling in the Rx ring.\n",
 808                                dev->name);
 809                 for (i = 0; i < RX_RING_SIZE; i++) {
 810                         struct sk_buff *skb;
 811                         if (i < (RX_RING_SIZE - 1))
 812                                 vp->rx_ring[i].next =
 813                                     isa_virt_to_bus(&vp->rx_ring[i + 1]);
 814                         else
 815                                 vp->rx_ring[i].next = 0;
 816                         vp->rx_ring[i].status = 0;      /* Clear complete bit. */
 817                         vp->rx_ring[i].length = PKT_BUF_SZ | 0x80000000;
 818                         skb = dev_alloc_skb(PKT_BUF_SZ);
 819                         vp->rx_skbuff[i] = skb;
 820                         if (skb == NULL)
 821                                 break;  /* Bad news!  */
 822                         skb->dev = dev; /* Mark as being used by this device. */
 823                         skb_reserve(skb, 2);    /* Align IP on 16 byte boundaries */
 824                         vp->rx_ring[i].addr = isa_virt_to_bus(skb->data);
 825                 }
 826                 vp->rx_ring[i - 1].next = isa_virt_to_bus(&vp->rx_ring[0]);     /* Wrap the ring. */
 827                 outl(isa_virt_to_bus(&vp->rx_ring[0]), ioaddr + UpListPtr);
 828         }
 829         if (vp->full_bus_master_tx) {   /* Boomerang bus master Tx. */
 830                 vp->cur_tx = vp->dirty_tx = 0;
 831                 outb(PKT_BUF_SZ >> 8, ioaddr + TxFreeThreshold);        /* Room for a packet. */
 832                 /* Clear the Tx ring. */
 833                 for (i = 0; i < TX_RING_SIZE; i++)
 834                         vp->tx_skbuff[i] = NULL;
 835                 outl(0, ioaddr + DownListPtr);
 836         }
 837         /* Set receiver mode: presumably accept b-case and phys addr only. */
 838         set_rx_mode(dev);
 839         outw(StatsEnable, ioaddr + EL3_CMD);    /* Turn on statistics. */
 840
 841         netif_start_queue(dev);
 842
 843         outw(RxEnable, ioaddr + EL3_CMD);       /* Enable the receiver. */
 844         outw(TxEnable, ioaddr + EL3_CMD);       /* Enable transmitter. */
 845         /* Allow status bits to be seen. */
 846         outw(SetStatusEnb | AdapterFailure | IntReq | StatsFull |
 847              (vp->full_bus_master_tx ? DownComplete : TxAvailable) |
 848              (vp->full_bus_master_rx ? UpComplete : RxComplete) |
 849              (vp->bus_master ? DMADone : 0), ioaddr + EL3_CMD);
 850         /* Ack all pending events, and set active indicator mask. */
 851         outw(AckIntr | IntLatch | TxAvailable | RxEarly | IntReq,
 852              ioaddr + EL3_CMD);
 853         outw(SetIntrEnb | IntLatch | TxAvailable | RxComplete | StatsFull
 854              | (vp->bus_master ? DMADone : 0) | UpComplete | DownComplete,
 855              ioaddr + EL3_CMD);
 856
 857         return 0;
 858 }
 859
 860 static void corkscrew_timer(unsigned long data)
 861 {
 862 #ifdef AUTOMEDIA
 863         struct net_device *dev = (struct net_device *) data;
 864         struct corkscrew_private *vp = netdev_priv(dev);
 865         int ioaddr = dev->base_addr;
 866         unsigned long flags;
 867         int ok = 0;
 868
 869         if (corkscrew_debug > 1)
 870                 printk("%s: Media selection timer tick happened, %s.\n",
 871                        dev->name, media_tbl[dev->if_port].name);
 872
 873         spin_lock_irqsave(&vp->lock, flags);
 874
 875         {
 876                 int old_window = inw(ioaddr + EL3_CMD) >> 13;
 877                 int media_status;
 878                 EL3WINDOW(4);
 879                 media_status = inw(ioaddr + Wn4_Media);
 880                 switch (dev->if_port) {
 881                 case 0:
 882                 case 4:
 883                 case 5: /* 10baseT, 100baseTX, 100baseFX  */
 884                         if (media_status & Media_LnkBeat) {
 885                                 ok = 1;
 886                                 if (corkscrew_debug > 1)
 887                                         printk("%s: Media %s has link beat, %x.\n",
 888                                                 dev->name,
 889                                                 media_tbl[dev->if_port].name,
 890                                                 media_status);
 891                         } else if (corkscrew_debug > 1)
 892                                 printk("%s: Media %s is has no link beat, %x.\n",
 893                                         dev->name,
 894                                         media_tbl[dev->if_port].name,
 895                                         media_status);
 896
 897                         break;
 898                 default:        /* Other media types handled by Tx timeouts. */
 899                         if (corkscrew_debug > 1)
 900                                 printk("%s: Media %s is has no indication, %x.\n",
 901                                         dev->name,
 902                                         media_tbl[dev->if_port].name,
 903                                         media_status);
 904                         ok = 1;
 905                 }
 906                 if (!ok) {
 907                         union wn3_config config;
 908
 909                         do {
 910                                 dev->if_port =
 911                                     media_tbl[dev->if_port].next;
 912                         }
 913                         while (!(vp->available_media & media_tbl[dev->if_port].mask));
 914
 915                         if (dev->if_port == 8) {        /* Go back to default. */
 916                                 dev->if_port = vp->default_media;
 917                                 if (corkscrew_debug > 1)
 918                                         printk("%s: Media selection failing, using default %s port.\n",
 919                                                 dev->name,
 920                                                 media_tbl[dev->if_port].name);
 921                         } else {
 922                                 if (corkscrew_debug > 1)
 923                                         printk("%s: Media selection failed, now trying %s port.\n",
 924                                                 dev->name,
 925                                                 media_tbl[dev->if_port].name);
 926                                 vp->timer.expires = jiffies + media_tbl[dev->if_port].wait;
 927                                 add_timer(&vp->timer);
 928                         }
 929                         outw((media_status & ~(Media_10TP | Media_SQE)) |
 930                              media_tbl[dev->if_port].media_bits,
 931                              ioaddr + Wn4_Media);
 932
 933                         EL3WINDOW(3);
 934                         config.i = inl(ioaddr + Wn3_Config);
 935                         config.u.xcvr = dev->if_port;
 936                         outl(config.i, ioaddr + Wn3_Config);
 937
 938                         outw(dev->if_port == 3 ? StartCoax : StopCoax,
 939                              ioaddr + EL3_CMD);
 940                 }
 941                 EL3WINDOW(old_window);
 942         }
 943
 944         spin_unlock_irqrestore(&vp->lock, flags);
 945         if (corkscrew_debug > 1)
 946                 printk("%s: Media selection timer finished, %s.\n",
 947                        dev->name, media_tbl[dev->if_port].name);
 948
 949 #endif                          /* AUTOMEDIA */
 950         return;
 951 }
 952
 953 static void corkscrew_timeout(struct net_device *dev)
 954 {
 955         int i;
 956         struct corkscrew_private *vp = netdev_priv(dev);
 957         int ioaddr = dev->base_addr;
 958
 959         printk(KERN_WARNING
 960                "%s: transmit timed out, tx_status %2.2x status %4.4x.\n",
 961                dev->name, inb(ioaddr + TxStatus),
 962                inw(ioaddr + EL3_STATUS));
 963         /* Slight code bloat to be user friendly. */
 964         if ((inb(ioaddr + TxStatus) & 0x88) == 0x88)
 965                 printk(KERN_WARNING
 966                        "%s: Transmitter encountered 16 collisions -- network"
 967                        " network cable problem?\n", dev->name);
 968 #ifndef final_version
 969         printk("  Flags; bus-master %d, full %d; dirty %d current %d.\n",
 970                vp->full_bus_master_tx, vp->tx_full, vp->dirty_tx,
 971                vp->cur_tx);
 972         printk("  Down list %8.8x vs. %p.\n", inl(ioaddr + DownListPtr),
 973                &vp->tx_ring[0]);
 974         for (i = 0; i < TX_RING_SIZE; i++) {
 975                 printk("  %d: %p  length %8.8x status %8.8x\n", i,
 976                        &vp->tx_ring[i],
 977                        vp->tx_ring[i].length, vp->tx_ring[i].status);
 978         }
 979 #endif
 980         /* Issue TX_RESET and TX_START commands. */
 981         outw(TxReset, ioaddr + EL3_CMD);
 982         for (i = 20; i >= 0; i--)
 983                 if (!(inw(ioaddr + EL3_STATUS) & CmdInProgress))
 984                         break;
 985         outw(TxEnable, ioaddr + EL3_CMD);
 986         dev->trans_start = jiffies;
 987         vp->stats.tx_errors++;
 988         vp->stats.tx_dropped++;
 989         netif_wake_queue(dev);
 990 }
 991
 992 static int corkscrew_start_xmit(struct sk_buff *skb,
 993                                 struct net_device *dev)
 994 {
 995         struct corkscrew_private *vp = netdev_priv(dev);
 996         int ioaddr = dev->base_addr;
 997
 998         /* Block a timer-based transmit from overlapping. */
 999
1000         netif_stop_queue(dev);
1001
1002         if (vp->full_bus_master_tx) {   /* BOOMERANG bus-master */
1003                 /* Calculate the next Tx descriptor entry. */
1004                 int entry = vp->cur_tx % TX_RING_SIZE;
1005                 struct boom_tx_desc *prev_entry;
1006                 unsigned long flags, i;
1007
1008                 if (vp->tx_full)        /* No room to transmit with */
1009                         return 1;
1010                 if (vp->cur_tx != 0)
1011                         prev_entry = &vp->tx_ring[(vp->cur_tx - 1) % TX_RING_SIZE];
1012                 else
1013                         prev_entry = NULL;
1014                 if (corkscrew_debug > 3)
1015                         printk("%s: Trying to send a packet, Tx index %d.\n",
1016                                 dev->name, vp->cur_tx);
1017                 /* vp->tx_full = 1; */
1018                 vp->tx_skbuff[entry] = skb;
1019                 vp->tx_ring[entry].next = 0;
1020                 vp->tx_ring[entry].addr = isa_virt_to_bus(skb->data);
1021                 vp->tx_ring[entry].length = skb->len | 0x80000000;
1022                 vp->tx_ring[entry].status = skb->len | 0x80000000;
1023
1024                 spin_lock_irqsave(&vp->lock, flags);
1025                 outw(DownStall, ioaddr + EL3_CMD);
1026                 /* Wait for the stall to complete. */
1027                 for (i = 20; i >= 0; i--)
1028                         if ((inw(ioaddr + EL3_STATUS) & CmdInProgress) == 0)
1029                                 break;
1030                 if (prev_entry)
1031                         prev_entry->next = isa_virt_to_bus(&vp->tx_ring[entry]);
1032                 if (inl(ioaddr + DownListPtr) == 0) {
1033                         outl(isa_virt_to_bus(&vp->tx_ring[entry]),
1034                              ioaddr + DownListPtr);
1035                         queued_packet++;
1036                 }
1037                 outw(DownUnstall, ioaddr + EL3_CMD);
1038                 spin_unlock_irqrestore(&vp->lock, flags);
1039
1040                 vp->cur_tx++;
1041                 if (vp->cur_tx - vp->dirty_tx > TX_RING_SIZE - 1)
1042                         vp->tx_full = 1;
1043                 else {          /* Clear previous interrupt enable. */
1044                         if (prev_entry)
1045                                 prev_entry->status &= ~0x80000000;
1046                         netif_wake_queue(dev);
1047                 }
1048                 dev->trans_start = jiffies;
1049                 return 0;
1050         }
1051         /* Put out the doubleword header... */
1052         outl(skb->len, ioaddr + TX_FIFO);
1053         vp->stats.tx_bytes += skb->len;
1054 #ifdef VORTEX_BUS_MASTER
1055         if (vp->bus_master) {
1056                 /* Set the bus-master controller to transfer the packet. */
1057                 outl((int) (skb->data), ioaddr + Wn7_MasterAddr);
1058                 outw((skb->len + 3) & ~3, ioaddr + Wn7_MasterLen);
1059                 vp->tx_skb = skb;
1060                 outw(StartDMADown, ioaddr + EL3_CMD);
1061                 /* queue will be woken at the DMADone interrupt. */
1062         } else {
1063                 /* ... and the packet rounded to a doubleword. */
1064                 outsl(ioaddr + TX_FIFO, skb->data, (skb->len + 3) >> 2);
1065                 dev_kfree_skb(skb);
1066                 if (inw(ioaddr + TxFree) > 1536) {
1067                         netif_wake_queue(dev);
1068                 } else
1069                         /* Interrupt us when the FIFO has room for max-sized packet. */
1070                         outw(SetTxThreshold + (1536 >> 2),
1071                              ioaddr + EL3_CMD);
1072         }
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), ioaddr + EL3_CMD);
1082 #endif                          /* bus master */
1083
1084         dev->trans_start = jiffies;
1085
1086         /* Clear the Tx status stack. */
1087         {
1088                 short tx_status;
1089                 int i = 4;
1090
1091                 while (--i > 0 && (tx_status = inb(ioaddr + TxStatus)) > 0) {
1092                         if (tx_status & 0x3C) { /* A Tx-disabling error occurred.  */
1093                                 if (corkscrew_debug > 2)
1094                                         printk("%s: Tx error, status %2.2x.\n",
1095                                                 dev->name, tx_status);
1096                                 if (tx_status & 0x04)
1097                                         vp->stats.tx_fifo_errors++;
1098                                 if (tx_status & 0x38)
1099                                         vp->stats.tx_aborted_errors++;
1100                                 if (tx_status & 0x30) {
1101                                         int j;
1102                                         outw(TxReset, ioaddr + EL3_CMD);
1103                                         for (j = 20; j >= 0; j--)
1104                                                 if (!(inw(ioaddr + EL3_STATUS) & CmdInProgress))
1105                                                         break;
1106                                 }
1107                                 outw(TxEnable, ioaddr + EL3_CMD);
1108                         }
1109                         outb(0x00, ioaddr + TxStatus);  /* Pop the status stack. */
1110                 }
1111         }
1112         return 0;
1113 }
1114
1115 /* The interrupt handler does all of the Rx thread work and cleans up
1116    after the Tx thread. */
1117
1118 static irqreturn_t corkscrew_interrupt(int irq, void *dev_id,
1119                                     struct pt_regs *regs)
1120 {
1121         /* Use the now-standard shared IRQ implementation. */
1122         struct net_device *dev = dev_id;
1123         struct corkscrew_private *lp = netdev_priv(dev);
1124         int ioaddr, status;
1125         int latency;
1126         int i = max_interrupt_work;
1127
1128         ioaddr = dev->base_addr;
1129         latency = inb(ioaddr + Timer);
1130
1131         spin_lock(&lp->lock);
1132
1133         status = inw(ioaddr + EL3_STATUS);
1134
1135         if (corkscrew_debug > 4)
1136                 printk("%s: interrupt, status %4.4x, timer %d.\n",
1137                         dev->name, status, latency);
1138         if ((status & 0xE000) != 0xE000) {
1139                 static int donedidthis;
1140                 /* Some interrupt controllers store a bogus interrupt from boot-time.
1141                    Ignore a single early interrupt, but don't hang the machine for
1142                    other interrupt problems. */
1143                 if (donedidthis++ > 100) {
1144                         printk(KERN_ERR "%s: Bogus interrupt, bailing. Status %4.4x, start=%d.\n",
1145                                    dev->name, status, netif_running(dev));
1146                         free_irq(dev->irq, dev);
1147                         dev->irq = -1;
1148                 }
1149         }
1150
1151         do {
1152                 if (corkscrew_debug > 5)
1153                         printk("%s: In interrupt loop, status %4.4x.\n",
1154                                dev->name, status);
1155                 if (status & RxComplete)
1156                         corkscrew_rx(dev);
1157
1158                 if (status & TxAvailable) {
1159                         if (corkscrew_debug > 5)
1160                                 printk("        TX room bit was handled.\n");
1161                         /* There's room in the FIFO for a full-sized packet. */
1162                         outw(AckIntr | TxAvailable, ioaddr + EL3_CMD);
1163                         netif_wake_queue(dev);
1164                 }
1165                 if (status & DownComplete) {
1166                         unsigned int dirty_tx = lp->dirty_tx;
1167
1168                         while (lp->cur_tx - dirty_tx > 0) {
1169                                 int entry = dirty_tx % TX_RING_SIZE;
1170                                 if (inl(ioaddr + DownListPtr) == isa_virt_to_bus(&lp->tx_ring[entry]))
1171                                         break;  /* It still hasn't been processed. */
1172                                 if (lp->tx_skbuff[entry]) {
1173                                         dev_kfree_skb_irq(lp->tx_skbuff[entry]);
1174                                         lp->tx_skbuff[entry] = NULL;
1175                                 }
1176                                 dirty_tx++;
1177                         }
1178                         lp->dirty_tx = dirty_tx;
1179                         outw(AckIntr | DownComplete, ioaddr + EL3_CMD);
1180                         if (lp->tx_full && (lp->cur_tx - dirty_tx <= TX_RING_SIZE - 1)) {
1181                                 lp->tx_full = 0;
1182                                 netif_wake_queue(dev);
1183                         }
1184                 }
1185 #ifdef VORTEX_BUS_MASTER
1186                 if (status & DMADone) {
1187                         outw(0x1000, ioaddr + Wn7_MasterStatus);        /* Ack the event. */
1188                         dev_kfree_skb_irq(lp->tx_skb);  /* Release the transferred buffer */
1189                         netif_wake_queue(dev);
1190                 }
1191 #endif
1192                 if (status & UpComplete) {
1193                         boomerang_rx(dev);
1194                         outw(AckIntr | UpComplete, ioaddr + EL3_CMD);
1195                 }
1196                 if (status & (AdapterFailure | RxEarly | StatsFull)) {
1197                         /* Handle all uncommon interrupts at once. */
1198                         if (status & RxEarly) { /* Rx early is unused. */
1199                                 corkscrew_rx(dev);
1200                                 outw(AckIntr | RxEarly, ioaddr + EL3_CMD);
1201                         }
1202                         if (status & StatsFull) {       /* Empty statistics. */
1203                                 static int DoneDidThat;
1204                                 if (corkscrew_debug > 4)
1205                                         printk("%s: Updating stats.\n", dev->name);
1206                                 update_stats(ioaddr, dev);
1207                                 /* DEBUG HACK: Disable statistics as an interrupt source. */
1208                                 /* This occurs when we have the wrong media type! */
1209                                 if (DoneDidThat == 0 && inw(ioaddr + EL3_STATUS) & StatsFull) {
1210                                         int win, reg;
1211                                         printk("%s: Updating stats failed, disabling stats as an"
1212                                              " interrupt source.\n", dev->name);
1213                                         for (win = 0; win < 8; win++) {
1214                                                 EL3WINDOW(win);
1215                                                 printk("\n Vortex window %d:", win);
1216                                                 for (reg = 0; reg < 16; reg++)
1217                                                         printk(" %2.2x", inb(ioaddr + reg));
1218                                         }
1219                                         EL3WINDOW(7);
1220                                         outw(SetIntrEnb | TxAvailable |
1221                                              RxComplete | AdapterFailure |
1222                                              UpComplete | DownComplete |
1223                                              TxComplete, ioaddr + EL3_CMD);
1224                                         DoneDidThat++;
1225                                 }
1226                         }
1227                         if (status & AdapterFailure) {
1228                                 /* Adapter failure requires Rx reset and reinit. */
1229                                 outw(RxReset, ioaddr + EL3_CMD);
1230                                 /* Set the Rx filter to the current state. */
1231                                 set_rx_mode(dev);
1232                                 outw(RxEnable, ioaddr + EL3_CMD);       /* Re-enable the receiver. */
1233                                 outw(AckIntr | AdapterFailure,
1234                                      ioaddr + EL3_CMD);
1235                         }
1236                 }
1237
1238                 if (--i < 0) {
1239                         printk(KERN_ERR "%s: Too much work in interrupt, status %4.4x.  "
1240                              "Disabling functions (%4.4x).\n", dev->name,
1241                              status, SetStatusEnb | ((~status) & 0x7FE));
1242                         /* Disable all pending interrupts. */
1243                         outw(SetStatusEnb | ((~status) & 0x7FE), ioaddr + EL3_CMD);
1244                         outw(AckIntr | 0x7FF, ioaddr + EL3_CMD);
1245                         break;
1246                 }
1247                 /* Acknowledge the IRQ. */
1248                 outw(AckIntr | IntReq | IntLatch, ioaddr + EL3_CMD);
1249
1250         } while ((status = inw(ioaddr + EL3_STATUS)) & (IntLatch | RxComplete));
1251
1252         spin_unlock(&lp->lock);
1253
1254         if (corkscrew_debug > 4)
1255                 printk("%s: exiting interrupt, status %4.4x.\n", dev->name, status);
1256         return IRQ_HANDLED;
1257 }
1258
1259 static int corkscrew_rx(struct net_device *dev)
1260 {
1261         struct corkscrew_private *vp = netdev_priv(dev);
1262         int ioaddr = dev->base_addr;
1263         int i;
1264         short rx_status;
1265
1266         if (corkscrew_debug > 5)
1267                 printk("   In rx_packet(), status %4.4x, rx_status %4.4x.\n",
1268                      inw(ioaddr + EL3_STATUS), inw(ioaddr + RxStatus));
1269         while ((rx_status = inw(ioaddr + RxStatus)) > 0) {
1270                 if (rx_status & 0x4000) {       /* Error, update stats. */
1271                         unsigned char rx_error = inb(ioaddr + RxErrors);
1272                         if (corkscrew_debug > 2)
1273                                 printk(" Rx error: status %2.2x.\n",
1274                                        rx_error);
1275                         vp->stats.rx_errors++;
1276                         if (rx_error & 0x01)
1277                                 vp->stats.rx_over_errors++;
1278                         if (rx_error & 0x02)
1279                                 vp->stats.rx_length_errors++;
1280                         if (rx_error & 0x04)
1281                                 vp->stats.rx_frame_errors++;
1282                         if (rx_error & 0x08)
1283                                 vp->stats.rx_crc_errors++;
1284                         if (rx_error & 0x10)
1285                                 vp->stats.rx_length_errors++;
1286                 } else {
1287                         /* The packet length: up to 4.5K!. */
1288                         short pkt_len = rx_status & 0x1fff;
1289                         struct sk_buff *skb;
1290
1291                         skb = dev_alloc_skb(pkt_len + 5 + 2);
1292                         if (corkscrew_debug > 4)
1293                                 printk("Receiving packet size %d status %4.4x.\n",
1294                                      pkt_len, rx_status);
1295                         if (skb != NULL) {
1296                                 skb->dev = dev;
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                                 vp->stats.rx_packets++;
1307                                 vp->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                 vp->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                         vp->stats.rx_errors++;
1343                         if (rx_error & 0x01)
1344                                 vp->stats.rx_over_errors++;
1345                         if (rx_error & 0x02)
1346                                 vp->stats.rx_length_errors++;
1347                         if (rx_error & 0x04)
1348                                 vp->stats.rx_frame_errors++;
1349                         if (rx_error & 0x08)
1350                                 vp->stats.rx_crc_errors++;
1351                         if (rx_error & 0x10)
1352                                 vp->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                         vp->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)) != 0) {
1367                                 skb->dev = dev;
1368                                 skb_reserve(skb, 2);    /* Align IP on 16 byte boundaries */
1369                                 /* 'skb_put()' points to the start of sk_buff data area. */
1370                                 memcpy(skb_put(skb, pkt_len),
1371                                        isa_bus_to_virt(vp->rx_ring[entry].
1372                                                    addr), pkt_len);
1373                                 rx_copy++;
1374                         } else {
1375                                 void *temp;
1376                                 /* Pass up the skbuff already on the Rx ring. */
1377                                 skb = vp->rx_skbuff[entry];
1378                                 vp->rx_skbuff[entry] = NULL;
1379                                 temp = skb_put(skb, pkt_len);
1380                                 /* Remove this checking code for final release. */
1381                                 if (isa_bus_to_virt(vp->rx_ring[entry].addr) != temp)
1382                                             printk("%s: Warning -- the skbuff addresses do not match"
1383                                              " in boomerang_rx: %p vs. %p / %p.\n",
1384                                              dev->name,
1385                                              isa_bus_to_virt(vp->
1386                                                          rx_ring[entry].
1387                                                          addr), skb->head,
1388                                              temp);
1389                                 rx_nocopy++;
1390                         }
1391                         skb->protocol = eth_type_trans(skb, dev);
1392                         netif_rx(skb);
1393                         dev->last_rx = jiffies;
1394                         vp->stats.rx_packets++;
1395                 }
1396                 entry = (++vp->cur_rx) % RX_RING_SIZE;
1397         }
1398         /* Refill the Rx ring buffers. */
1399         for (; vp->cur_rx - vp->dirty_rx > 0; vp->dirty_rx++) {
1400                 struct sk_buff *skb;
1401                 entry = vp->dirty_rx % RX_RING_SIZE;
1402                 if (vp->rx_skbuff[entry] == NULL) {
1403                         skb = dev_alloc_skb(PKT_BUF_SZ);
1404                         if (skb == NULL)
1405                                 break;  /* Bad news!  */
1406                         skb->dev = dev; /* Mark as being used by this device. */
1407                         skb_reserve(skb, 2);    /* Align IP on 16 byte boundaries */
1408                         vp->rx_ring[entry].addr = isa_virt_to_bus(skb->data);
1409                         vp->rx_skbuff[entry] = skb;
1410                 }
1411                 vp->rx_ring[entry].status = 0;  /* Clear complete bit. */
1412         }
1413         return 0;
1414 }
1415
1416 static int corkscrew_close(struct net_device *dev)
1417 {
1418         struct corkscrew_private *vp = netdev_priv(dev);
1419         int ioaddr = dev->base_addr;
1420         int i;
1421
1422         netif_stop_queue(dev);
1423
1424         if (corkscrew_debug > 1) {
1425                 printk("%s: corkscrew_close() status %4.4x, Tx status %2.2x.\n",
1426                      dev->name, inw(ioaddr + EL3_STATUS),
1427                      inb(ioaddr + TxStatus));
1428                 printk("%s: corkscrew close stats: rx_nocopy %d rx_copy %d"
1429                        " tx_queued %d.\n", dev->name, rx_nocopy, rx_copy,
1430                        queued_packet);
1431         }
1432
1433         del_timer(&vp->timer);
1434
1435         /* Turn off statistics ASAP.  We update lp->stats below. */
1436         outw(StatsDisable, ioaddr + EL3_CMD);
1437
1438         /* Disable the receiver and transmitter. */
1439         outw(RxDisable, ioaddr + EL3_CMD);
1440         outw(TxDisable, ioaddr + EL3_CMD);
1441
1442         if (dev->if_port == XCVR_10base2)
1443                 /* Turn off thinnet power.  Green! */
1444                 outw(StopCoax, ioaddr + EL3_CMD);
1445
1446         free_irq(dev->irq, dev);
1447
1448         outw(SetIntrEnb | 0x0000, ioaddr + EL3_CMD);
1449
1450         update_stats(ioaddr, dev);
1451         if (vp->full_bus_master_rx) {   /* Free Boomerang bus master Rx buffers. */
1452                 outl(0, ioaddr + UpListPtr);
1453                 for (i = 0; i < RX_RING_SIZE; i++)
1454                         if (vp->rx_skbuff[i]) {
1455                                 dev_kfree_skb(vp->rx_skbuff[i]);
1456                                 vp->rx_skbuff[i] = NULL;
1457                         }
1458         }
1459         if (vp->full_bus_master_tx) {   /* Free Boomerang bus master Tx buffers. */
1460                 outl(0, ioaddr + DownListPtr);
1461                 for (i = 0; i < TX_RING_SIZE; i++)
1462                         if (vp->tx_skbuff[i]) {
1463                                 dev_kfree_skb(vp->tx_skbuff[i]);
1464                                 vp->tx_skbuff[i] = NULL;
1465                         }
1466         }
1467
1468         return 0;
1469 }
1470
1471 static struct net_device_stats *corkscrew_get_stats(struct net_device *dev)
1472 {
1473         struct corkscrew_private *vp = netdev_priv(dev);
1474         unsigned long flags;
1475
1476         if (netif_running(dev)) {
1477                 spin_lock_irqsave(&vp->lock, flags);
1478                 update_stats(dev->base_addr, dev);
1479                 spin_unlock_irqrestore(&vp->lock, flags);
1480         }
1481         return &vp->stats;
1482 }
1483
1484 /*  Update statistics.
1485         Unlike with the EL3 we need not worry about interrupts changing
1486         the window setting from underneath us, but we must still guard
1487         against a race condition with a StatsUpdate interrupt updating the
1488         table.  This is done by checking that the ASM (!) code generated uses
1489         atomic updates with '+='.
1490         */
1491 static void update_stats(int ioaddr, struct net_device *dev)
1492 {
1493         struct corkscrew_private *vp = netdev_priv(dev);
1494
1495         /* Unlike the 3c5x9 we need not turn off stats updates while reading. */
1496         /* Switch to the stats window, and read everything. */
1497         EL3WINDOW(6);
1498         vp->stats.tx_carrier_errors += inb(ioaddr + 0);
1499         vp->stats.tx_heartbeat_errors += inb(ioaddr + 1);
1500         /* Multiple collisions. */ inb(ioaddr + 2);
1501         vp->stats.collisions += inb(ioaddr + 3);
1502         vp->stats.tx_window_errors += inb(ioaddr + 4);
1503         vp->stats.rx_fifo_errors += inb(ioaddr + 5);
1504         vp->stats.tx_packets += inb(ioaddr + 6);
1505         vp->stats.tx_packets += (inb(ioaddr + 9) & 0x30) << 4;
1506                                                 /* Rx packets   */ inb(ioaddr + 7);
1507                                                 /* Must read to clear */
1508         /* Tx deferrals */ inb(ioaddr + 8);
1509         /* Don't bother with register 9, an extension of registers 6&7.
1510            If we do use the 6&7 values the atomic update assumption above
1511            is invalid. */
1512         inw(ioaddr + 10);       /* Total Rx and Tx octets. */
1513         inw(ioaddr + 12);
1514         /* New: On the Vortex we must also clear the BadSSD counter. */
1515         EL3WINDOW(4);
1516         inb(ioaddr + 12);
1517
1518         /* We change back to window 7 (not 1) with the Vortex. */
1519         EL3WINDOW(7);
1520         return;
1521 }
1522
1523 /* This new version of set_rx_mode() supports v1.4 kernels.
1524    The Vortex chip has no documented multicast filter, so the only
1525    multicast setting is to receive all multicast frames.  At least
1526    the chip has a very clean way to set the mode, unlike many others. */
1527 static void set_rx_mode(struct net_device *dev)
1528 {
1529         int ioaddr = dev->base_addr;
1530         short new_mode;
1531
1532         if (dev->flags & IFF_PROMISC) {
1533                 if (corkscrew_debug > 3)
1534                         printk("%s: Setting promiscuous mode.\n",
1535                                dev->name);
1536                 new_mode = SetRxFilter | RxStation | RxMulticast | RxBroadcast | RxProm;
1537         } else if ((dev->mc_list) || (dev->flags & IFF_ALLMULTI)) {
1538                 new_mode = SetRxFilter | RxStation | RxMulticast | RxBroadcast;
1539         } else
1540                 new_mode = SetRxFilter | RxStation | RxBroadcast;
1541
1542         outw(new_mode, ioaddr + EL3_CMD);
1543 }
1544
1545 static void netdev_get_drvinfo(struct net_device *dev,
1546                                struct ethtool_drvinfo *info)
1547 {
1548         strcpy(info->driver, DRV_NAME);
1549         strcpy(info->version, DRV_VERSION);
1550         sprintf(info->bus_info, "ISA 0x%lx", dev->base_addr);
1551 }
1552
1553 static u32 netdev_get_msglevel(struct net_device *dev)
1554 {
1555         return corkscrew_debug;
1556 }
1557
1558 static void netdev_set_msglevel(struct net_device *dev, u32 level)
1559 {
1560         corkscrew_debug = level;
1561 }
1562
1563 static struct ethtool_ops netdev_ethtool_ops = {
1564         .get_drvinfo            = netdev_get_drvinfo,
1565         .get_msglevel           = netdev_get_msglevel,
1566         .set_msglevel           = netdev_set_msglevel,
1567 };
1568
1569 \f
1570 #ifdef MODULE
1571 void cleanup_module(void)
1572 {
1573         while (!list_empty(&root_corkscrew_dev)) {
1574                 struct net_device *dev;
1575                 struct corkscrew_private *vp;
1576
1577                 vp = list_entry(root_corkscrew_dev.next,
1578                                 struct corkscrew_private, list);
1579                 dev = vp->our_dev;
1580                 unregister_netdev(dev);
1581                 cleanup_card(dev);
1582                 free_netdev(dev);
1583         }
1584 }
1585 #endif                          /* MODULE */
1586 \f
1587 /*
1588  * Local variables:
1589  *  compile-command: "gcc -DMODULE -D__KERNEL__ -Wall -Wstrict-prototypes -O6 -c 3c515.c"
1590  *  c-indent-level: 4
1591  *  tab-width: 4
1592  * End:
1593  */