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/config.h>
  61 #include <linux/module.h>
  62 #include <linux/isapnp.h>
  63 #include <linux/kernel.h>
  64 #include <linux/netdevice.h>
  65 #include <linux/string.h>
  66 #include <linux/errno.h>
  67 #include <linux/in.h>
  68 #include <linux/ioport.h>
  69 #include <linux/slab.h>
  70 #include <linux/skbuff.h>
  71 #include <linux/etherdevice.h>
  72 #include <linux/interrupt.h>
  73 #include <linux/timer.h>
  74 #include <linux/ethtool.h>
  75 #include <linux/bitops.h>
  76
  77 #include <asm/uaccess.h>
  78 #include <asm/io.h>
  79 #include <asm/dma.h>
  80
  81 #define NEW_MULTICAST
  82 #include <linux/delay.h>
  83
  84 #define MAX_UNITS 8
  85
  86 MODULE_AUTHOR("Donald Becker <becker@scyld.com>");
  87 MODULE_DESCRIPTION("3Com 3c515 Corkscrew driver");
  88 MODULE_LICENSE("GPL");
  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 void 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 = (struct corkscrew_private *) dev->priv;
 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                         corkscrew_setup(dev, ioaddr, idev, cards_found++);
 542                         SET_NETDEV_DEV(dev, &idev->dev);
 543                         pnp_cards++;
 544                         err = register_netdev(dev);
 545                         if (!err)
 546                                 return dev;
 547                         cleanup_card(dev);
 548                 }
 549         }
 550 no_pnp:
 551 #endif /* __ISAPNP__ */
 552
 553         /* Check all locations on the ISA bus -- evil! */
 554         for (ioaddr = 0x100; ioaddr < 0x400; ioaddr += 0x20) {
 555                 if (!check_device(ioaddr))
 556                         continue;
 557
 558                 printk(KERN_INFO "3c515 Resource configuration register %#4.4x, DCR %4.4x.\n",
 559                      inl(ioaddr + 0x2002), inw(ioaddr + 0x2000));
 560                 corkscrew_setup(dev, ioaddr, NULL, cards_found++);
 561                 err = register_netdev(dev);
 562                 if (!err)
 563                         return dev;
 564                 cleanup_card(dev);
 565         }
 566         free_netdev(dev);
 567         return NULL;
 568 }
 569
 570 static void corkscrew_setup(struct net_device *dev, int ioaddr,
 571                             struct pnp_dev *idev, int card_number)
 572 {
 573         struct corkscrew_private *vp = (struct corkscrew_private *) dev->priv;
 574         unsigned int eeprom[0x40], checksum = 0;        /* EEPROM contents */
 575         int i;
 576         int irq;
 577
 578         if (idev) {
 579                 irq = pnp_irq(idev, 0);
 580                 vp->dev = &idev->dev;
 581         } else {
 582                 irq = inw(ioaddr + 0x2002) & 15;
 583         }
 584
 585         dev->base_addr = ioaddr;
 586         dev->irq = irq;
 587         dev->dma = inw(ioaddr + 0x2000) & 7;
 588         vp->product_name = "3c515";
 589         vp->options = dev->mem_start;
 590         vp->our_dev = dev;
 591
 592         if (!vp->options) {
 593                  if (card_number >= MAX_UNITS)
 594                         vp->options = -1;
 595                 else
 596                         vp->options = options[card_number];
 597         }
 598
 599         if (vp->options >= 0) {
 600                 vp->media_override = vp->options & 7;
 601                 if (vp->media_override == 2)
 602                         vp->media_override = 0;
 603                 vp->full_duplex = (vp->options & 8) ? 1 : 0;
 604                 vp->bus_master = (vp->options & 16) ? 1 : 0;
 605         } else {
 606                 vp->media_override = 7;
 607                 vp->full_duplex = 0;
 608                 vp->bus_master = 0;
 609         }
 610 #ifdef MODULE
 611         list_add(&vp->list, &root_corkscrew_dev);
 612 #endif
 613
 614         printk(KERN_INFO "%s: 3Com %s at %#3x,", dev->name, vp->product_name, ioaddr);
 615
 616         spin_lock_init(&vp->lock);
 617
 618         /* Read the station address from the EEPROM. */
 619         EL3WINDOW(0);
 620         for (i = 0; i < 0x18; i++) {
 621                 short *phys_addr = (short *) dev->dev_addr;
 622                 int timer;
 623                 outw(EEPROM_Read + i, ioaddr + Wn0EepromCmd);
 624                 /* Pause for at least 162 us. for the read to take place. */
 625                 for (timer = 4; timer >= 0; timer--) {
 626                         udelay(162);
 627                         if ((inw(ioaddr + Wn0EepromCmd) & 0x0200) == 0)
 628                                 break;
 629                 }
 630                 eeprom[i] = inw(ioaddr + Wn0EepromData);
 631                 checksum ^= eeprom[i];
 632                 if (i < 3)
 633                         phys_addr[i] = htons(eeprom[i]);
 634         }
 635         checksum = (checksum ^ (checksum >> 8)) & 0xff;
 636         if (checksum != 0x00)
 637                 printk(" ***INVALID CHECKSUM %4.4x*** ", checksum);
 638         for (i = 0; i < 6; i++)
 639                 printk("%c%2.2x", i ? ':' : ' ', dev->dev_addr[i]);
 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                 union wn3_config config;
 655                 EL3WINDOW(3);
 656                 vp->available_media = inw(ioaddr + Wn3_Options);
 657                 config.i = inl(ioaddr + Wn3_Config);
 658                 if (corkscrew_debug > 1)
 659                         printk(KERN_INFO "  Internal config register is %4.4x, transceivers %#x.\n",
 660                                 config.i, inw(ioaddr + Wn3_Options));
 661                 printk(KERN_INFO "  %dK %s-wide RAM %s Rx:Tx split, %s%s interface.\n",
 662                         8 << config.u.ram_size,
 663                         config.u.ram_width ? "word" : "byte",
 664                         ram_split[config.u.ram_split],
 665                         config.u.autoselect ? "autoselect/" : "",
 666                         media_tbl[config.u.xcvr].name);
 667                 dev->if_port = config.u.xcvr;
 668                 vp->default_media = config.u.xcvr;
 669                 vp->autoselect = config.u.autoselect;
 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 \f
 695
 696 static int corkscrew_open(struct net_device *dev)
 697 {
 698         int ioaddr = dev->base_addr;
 699         struct corkscrew_private *vp =
 700             (struct corkscrew_private *) dev->priv;
 701         union wn3_config config;
 702         int i;
 703
 704         /* Before initializing select the active media port. */
 705         EL3WINDOW(3);
 706         if (vp->full_duplex)
 707                 outb(0x20, ioaddr + Wn3_MAC_Ctrl);      /* Set the full-duplex bit. */
 708         config.i = inl(ioaddr + Wn3_Config);
 709
 710         if (vp->media_override != 7) {
 711                 if (corkscrew_debug > 1)
 712                         printk(KERN_INFO "%s: Media override to transceiver %d (%s).\n",
 713                                 dev->name, vp->media_override,
 714                                 media_tbl[vp->media_override].name);
 715                 dev->if_port = vp->media_override;
 716         } else if (vp->autoselect) {
 717                 /* Find first available media type, starting with 100baseTx. */
 718                 dev->if_port = 4;
 719                 while (!(vp->available_media & media_tbl[dev->if_port].mask))
 720                         dev->if_port = media_tbl[dev->if_port].next;
 721
 722                 if (corkscrew_debug > 1)
 723                         printk("%s: Initial media type %s.\n",
 724                                dev->name, media_tbl[dev->if_port].name);
 725
 726                 init_timer(&vp->timer);
 727                 vp->timer.expires = jiffies + media_tbl[dev->if_port].wait;
 728                 vp->timer.data = (unsigned long) dev;
 729                 vp->timer.function = &corkscrew_timer;  /* timer handler */
 730                 add_timer(&vp->timer);
 731         } else
 732                 dev->if_port = vp->default_media;
 733
 734         config.u.xcvr = dev->if_port;
 735         outl(config.i, ioaddr + Wn3_Config);
 736
 737         if (corkscrew_debug > 1) {
 738                 printk("%s: corkscrew_open() InternalConfig %8.8x.\n",
 739                        dev->name, config.i);
 740         }
 741
 742         outw(TxReset, ioaddr + EL3_CMD);
 743         for (i = 20; i >= 0; i--)
 744                 if (!(inw(ioaddr + EL3_STATUS) & CmdInProgress))
 745                         break;
 746
 747         outw(RxReset, ioaddr + EL3_CMD);
 748         /* Wait a few ticks for the RxReset command to complete. */
 749         for (i = 20; i >= 0; i--)
 750                 if (!(inw(ioaddr + EL3_STATUS) & CmdInProgress))
 751                         break;
 752
 753         outw(SetStatusEnb | 0x00, ioaddr + EL3_CMD);
 754
 755         /* Use the now-standard shared IRQ implementation. */
 756         if (vp->capabilities == 0x11c7) {
 757                 /* Corkscrew: Cannot share ISA resources. */
 758                 if (dev->irq == 0
 759                     || dev->dma == 0
 760                     || request_irq(dev->irq, &corkscrew_interrupt, 0,
 761                                    vp->product_name, dev)) return -EAGAIN;
 762                 enable_dma(dev->dma);
 763                 set_dma_mode(dev->dma, DMA_MODE_CASCADE);
 764         } else if (request_irq(dev->irq, &corkscrew_interrupt, SA_SHIRQ,
 765                                vp->product_name, dev)) {
 766                 return -EAGAIN;
 767         }
 768
 769         if (corkscrew_debug > 1) {
 770                 EL3WINDOW(4);
 771                 printk("%s: corkscrew_open() irq %d media status %4.4x.\n",
 772                        dev->name, dev->irq, inw(ioaddr + Wn4_Media));
 773         }
 774
 775         /* Set the station address and mask in window 2 each time opened. */
 776         EL3WINDOW(2);
 777         for (i = 0; i < 6; i++)
 778                 outb(dev->dev_addr[i], ioaddr + i);
 779         for (; i < 12; i += 2)
 780                 outw(0, ioaddr + i);
 781
 782         if (dev->if_port == 3)
 783                 /* Start the thinnet transceiver. We should really wait 50ms... */
 784                 outw(StartCoax, ioaddr + EL3_CMD);
 785         EL3WINDOW(4);
 786         outw((inw(ioaddr + Wn4_Media) & ~(Media_10TP | Media_SQE)) |
 787              media_tbl[dev->if_port].media_bits, ioaddr + Wn4_Media);
 788
 789         /* Switch to the stats window, and clear all stats by reading. */
 790         outw(StatsDisable, ioaddr + EL3_CMD);
 791         EL3WINDOW(6);
 792         for (i = 0; i < 10; i++)
 793                 inb(ioaddr + i);
 794         inw(ioaddr + 10);
 795         inw(ioaddr + 12);
 796         /* New: On the Vortex we must also clear the BadSSD counter. */
 797         EL3WINDOW(4);
 798         inb(ioaddr + 12);
 799         /* ..and on the Boomerang we enable the extra statistics bits. */
 800         outw(0x0040, ioaddr + Wn4_NetDiag);
 801
 802         /* Switch to register set 7 for normal use. */
 803         EL3WINDOW(7);
 804
 805         if (vp->full_bus_master_rx) {   /* Boomerang bus master. */
 806                 vp->cur_rx = vp->dirty_rx = 0;
 807                 if (corkscrew_debug > 2)
 808                         printk("%s:  Filling in the Rx ring.\n",
 809                                dev->name);
 810                 for (i = 0; i < RX_RING_SIZE; i++) {
 811                         struct sk_buff *skb;
 812                         if (i < (RX_RING_SIZE - 1))
 813                                 vp->rx_ring[i].next =
 814                                     isa_virt_to_bus(&vp->rx_ring[i + 1]);
 815                         else
 816                                 vp->rx_ring[i].next = 0;
 817                         vp->rx_ring[i].status = 0;      /* Clear complete bit. */
 818                         vp->rx_ring[i].length = PKT_BUF_SZ | 0x80000000;
 819                         skb = dev_alloc_skb(PKT_BUF_SZ);
 820                         vp->rx_skbuff[i] = skb;
 821                         if (skb == NULL)
 822                                 break;  /* Bad news!  */
 823                         skb->dev = dev; /* Mark as being used by this device. */
 824                         skb_reserve(skb, 2);    /* Align IP on 16 byte boundaries */
 825                         vp->rx_ring[i].addr = isa_virt_to_bus(skb->tail);
 826                 }
 827                 vp->rx_ring[i - 1].next = isa_virt_to_bus(&vp->rx_ring[0]);     /* Wrap the ring. */
 828                 outl(isa_virt_to_bus(&vp->rx_ring[0]), ioaddr + UpListPtr);
 829         }
 830         if (vp->full_bus_master_tx) {   /* Boomerang bus master Tx. */
 831                 vp->cur_tx = vp->dirty_tx = 0;
 832                 outb(PKT_BUF_SZ >> 8, ioaddr + TxFreeThreshold);        /* Room for a packet. */
 833                 /* Clear the Tx ring. */
 834                 for (i = 0; i < TX_RING_SIZE; i++)
 835                         vp->tx_skbuff[i] = NULL;
 836                 outl(0, ioaddr + DownListPtr);
 837         }
 838         /* Set receiver mode: presumably accept b-case and phys addr only. */
 839         set_rx_mode(dev);
 840         outw(StatsEnable, ioaddr + EL3_CMD);    /* Turn on statistics. */
 841
 842         netif_start_queue(dev);
 843
 844         outw(RxEnable, ioaddr + EL3_CMD);       /* Enable the receiver. */
 845         outw(TxEnable, ioaddr + EL3_CMD);       /* Enable transmitter. */
 846         /* Allow status bits to be seen. */
 847         outw(SetStatusEnb | AdapterFailure | IntReq | StatsFull |
 848              (vp->full_bus_master_tx ? DownComplete : TxAvailable) |
 849              (vp->full_bus_master_rx ? UpComplete : RxComplete) |
 850              (vp->bus_master ? DMADone : 0), ioaddr + EL3_CMD);
 851         /* Ack all pending events, and set active indicator mask. */
 852         outw(AckIntr | IntLatch | TxAvailable | RxEarly | IntReq,
 853              ioaddr + EL3_CMD);
 854         outw(SetIntrEnb | IntLatch | TxAvailable | RxComplete | StatsFull
 855              | (vp->bus_master ? DMADone : 0) | UpComplete | DownComplete,
 856              ioaddr + EL3_CMD);
 857
 858         return 0;
 859 }
 860
 861 static void corkscrew_timer(unsigned long data)
 862 {
 863 #ifdef AUTOMEDIA
 864         struct net_device *dev = (struct net_device *) data;
 865         struct corkscrew_private *vp = (struct corkscrew_private *) dev->priv;
 866         int ioaddr = dev->base_addr;
 867         unsigned long flags;
 868         int ok = 0;
 869
 870         if (corkscrew_debug > 1)
 871                 printk("%s: Media selection timer tick happened, %s.\n",
 872                        dev->name, media_tbl[dev->if_port].name);
 873
 874         spin_lock_irqsave(&vp->lock, flags);
 875
 876         {
 877                 int old_window = inw(ioaddr + EL3_CMD) >> 13;
 878                 int media_status;
 879                 EL3WINDOW(4);
 880                 media_status = inw(ioaddr + Wn4_Media);
 881                 switch (dev->if_port) {
 882                 case 0:
 883                 case 4:
 884                 case 5: /* 10baseT, 100baseTX, 100baseFX  */
 885                         if (media_status & Media_LnkBeat) {
 886                                 ok = 1;
 887                                 if (corkscrew_debug > 1)
 888                                         printk("%s: Media %s has link beat, %x.\n",
 889                                                 dev->name,
 890                                                 media_tbl[dev->if_port].name,
 891                                                 media_status);
 892                         } else if (corkscrew_debug > 1)
 893                                 printk("%s: Media %s is has no link beat, %x.\n",
 894                                         dev->name,
 895                                         media_tbl[dev->if_port].name,
 896                                         media_status);
 897
 898                         break;
 899                 default:        /* Other media types handled by Tx timeouts. */
 900                         if (corkscrew_debug > 1)
 901                                 printk("%s: Media %s is has no indication, %x.\n",
 902                                         dev->name,
 903                                         media_tbl[dev->if_port].name,
 904                                         media_status);
 905                         ok = 1;
 906                 }
 907                 if (!ok) {
 908                         union wn3_config config;
 909
 910                         do {
 911                                 dev->if_port =
 912                                     media_tbl[dev->if_port].next;
 913                         }
 914                         while (!(vp->available_media & media_tbl[dev->if_port].mask));
 915
 916                         if (dev->if_port == 8) {        /* Go back to default. */
 917                                 dev->if_port = vp->default_media;
 918                                 if (corkscrew_debug > 1)
 919                                         printk("%s: Media selection failing, using default %s port.\n",
 920                                                 dev->name,
 921                                                 media_tbl[dev->if_port].name);
 922                         } else {
 923                                 if (corkscrew_debug > 1)
 924                                         printk("%s: Media selection failed, now trying %s port.\n",
 925                                                 dev->name,
 926                                                 media_tbl[dev->if_port].name);
 927                                 vp->timer.expires = jiffies + media_tbl[dev->if_port].wait;
 928                                 add_timer(&vp->timer);
 929                         }
 930                         outw((media_status & ~(Media_10TP | Media_SQE)) |
 931                              media_tbl[dev->if_port].media_bits,
 932                              ioaddr + Wn4_Media);
 933
 934                         EL3WINDOW(3);
 935                         config.i = inl(ioaddr + Wn3_Config);
 936                         config.u.xcvr = dev->if_port;
 937                         outl(config.i, ioaddr + Wn3_Config);
 938
 939                         outw(dev->if_port == 3 ? StartCoax : StopCoax,
 940                              ioaddr + EL3_CMD);
 941                 }
 942                 EL3WINDOW(old_window);
 943         }
 944
 945         spin_unlock_irqrestore(&vp->lock, flags);
 946         if (corkscrew_debug > 1)
 947                 printk("%s: Media selection timer finished, %s.\n",
 948                        dev->name, media_tbl[dev->if_port].name);
 949
 950 #endif                          /* AUTOMEDIA */
 951         return;
 952 }
 953
 954 static void corkscrew_timeout(struct net_device *dev)
 955 {
 956         int i;
 957         struct corkscrew_private *vp =
 958             (struct corkscrew_private *) dev->priv;
 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         vp->stats.tx_errors++;
 990         vp->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 =
 998             (struct corkscrew_private *) dev->priv;
 999         int ioaddr = dev->base_addr;
1000
1001         /* Block a timer-based transmit from overlapping. */
1002
1003         netif_stop_queue(dev);
1004
1005         if (vp->full_bus_master_tx) {   /* BOOMERANG bus-master */
1006                 /* Calculate the next Tx descriptor entry. */
1007                 int entry = vp->cur_tx % TX_RING_SIZE;
1008                 struct boom_tx_desc *prev_entry;
1009                 unsigned long flags, 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         vp->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                                         vp->stats.tx_fifo_errors++;
1101                                 if (tx_status & 0x38)
1102                                         vp->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                                     struct pt_regs *regs)
1123 {
1124         /* Use the now-standard shared IRQ implementation. */
1125         struct net_device *dev = dev_id;
1126         struct corkscrew_private *lp;
1127         int ioaddr, status;
1128         int latency;
1129         int i = max_interrupt_work;
1130
1131         ioaddr = dev->base_addr;
1132         latency = inb(ioaddr + Timer);
1133         lp = (struct corkscrew_private *) dev->priv;
1134
1135         spin_lock(&lp->lock);
1136
1137         status = inw(ioaddr + EL3_STATUS);
1138
1139         if (corkscrew_debug > 4)
1140                 printk("%s: interrupt, status %4.4x, timer %d.\n",
1141                         dev->name, status, latency);
1142         if ((status & 0xE000) != 0xE000) {
1143                 static int donedidthis;
1144                 /* Some interrupt controllers store a bogus interrupt from boot-time.
1145                    Ignore a single early interrupt, but don't hang the machine for
1146                    other interrupt problems. */
1147                 if (donedidthis++ > 100) {
1148                         printk(KERN_ERR "%s: Bogus interrupt, bailing. Status %4.4x, start=%d.\n",
1149                                    dev->name, status, netif_running(dev));
1150                         free_irq(dev->irq, dev);
1151                         dev->irq = -1;
1152                 }
1153         }
1154
1155         do {
1156                 if (corkscrew_debug > 5)
1157                         printk("%s: In interrupt loop, status %4.4x.\n",
1158                                dev->name, status);
1159                 if (status & RxComplete)
1160                         corkscrew_rx(dev);
1161
1162                 if (status & TxAvailable) {
1163                         if (corkscrew_debug > 5)
1164                                 printk("        TX room bit was handled.\n");
1165                         /* There's room in the FIFO for a full-sized packet. */
1166                         outw(AckIntr | TxAvailable, ioaddr + EL3_CMD);
1167                         netif_wake_queue(dev);
1168                 }
1169                 if (status & DownComplete) {
1170                         unsigned int dirty_tx = lp->dirty_tx;
1171
1172                         while (lp->cur_tx - dirty_tx > 0) {
1173                                 int entry = dirty_tx % TX_RING_SIZE;
1174                                 if (inl(ioaddr + DownListPtr) == isa_virt_to_bus(&lp->tx_ring[entry]))
1175                                         break;  /* It still hasn't been processed. */
1176                                 if (lp->tx_skbuff[entry]) {
1177                                         dev_kfree_skb_irq(lp->tx_skbuff[entry]);
1178                                         lp->tx_skbuff[entry] = NULL;
1179                                 }
1180                                 dirty_tx++;
1181                         }
1182                         lp->dirty_tx = dirty_tx;
1183                         outw(AckIntr | DownComplete, ioaddr + EL3_CMD);
1184                         if (lp->tx_full && (lp->cur_tx - dirty_tx <= TX_RING_SIZE - 1)) {
1185                                 lp->tx_full = 0;
1186                                 netif_wake_queue(dev);
1187                         }
1188                 }
1189 #ifdef VORTEX_BUS_MASTER
1190                 if (status & DMADone) {
1191                         outw(0x1000, ioaddr + Wn7_MasterStatus);        /* Ack the event. */
1192                         dev_kfree_skb_irq(lp->tx_skb);  /* Release the transferred buffer */
1193                         netif_wake_queue(dev);
1194                 }
1195 #endif
1196                 if (status & UpComplete) {
1197                         boomerang_rx(dev);
1198                         outw(AckIntr | UpComplete, ioaddr + EL3_CMD);
1199                 }
1200                 if (status & (AdapterFailure | RxEarly | StatsFull)) {
1201                         /* Handle all uncommon interrupts at once. */
1202                         if (status & RxEarly) { /* Rx early is unused. */
1203                                 corkscrew_rx(dev);
1204                                 outw(AckIntr | RxEarly, ioaddr + EL3_CMD);
1205                         }
1206                         if (status & StatsFull) {       /* Empty statistics. */
1207                                 static int DoneDidThat;
1208                                 if (corkscrew_debug > 4)
1209                                         printk("%s: Updating stats.\n", dev->name);
1210                                 update_stats(ioaddr, dev);
1211                                 /* DEBUG HACK: Disable statistics as an interrupt source. */
1212                                 /* This occurs when we have the wrong media type! */
1213                                 if (DoneDidThat == 0 && inw(ioaddr + EL3_STATUS) & StatsFull) {
1214                                         int win, reg;
1215                                         printk("%s: Updating stats failed, disabling stats as an"
1216                                              " interrupt source.\n", dev->name);
1217                                         for (win = 0; win < 8; win++) {
1218                                                 EL3WINDOW(win);
1219                                                 printk("\n Vortex window %d:", win);
1220                                                 for (reg = 0; reg < 16; reg++)
1221                                                         printk(" %2.2x", inb(ioaddr + reg));
1222                                         }
1223                                         EL3WINDOW(7);
1224                                         outw(SetIntrEnb | TxAvailable |
1225                                              RxComplete | AdapterFailure |
1226                                              UpComplete | DownComplete |
1227                                              TxComplete, ioaddr + EL3_CMD);
1228                                         DoneDidThat++;
1229                                 }
1230                         }
1231                         if (status & AdapterFailure) {
1232                                 /* Adapter failure requires Rx reset and reinit. */
1233                                 outw(RxReset, ioaddr + EL3_CMD);
1234                                 /* Set the Rx filter to the current state. */
1235                                 set_rx_mode(dev);
1236                                 outw(RxEnable, ioaddr + EL3_CMD);       /* Re-enable the receiver. */
1237                                 outw(AckIntr | AdapterFailure,
1238                                      ioaddr + EL3_CMD);
1239                         }
1240                 }
1241
1242                 if (--i < 0) {
1243                         printk(KERN_ERR "%s: Too much work in interrupt, status %4.4x.  "
1244                              "Disabling functions (%4.4x).\n", dev->name,
1245                              status, SetStatusEnb | ((~status) & 0x7FE));
1246                         /* Disable all pending interrupts. */
1247                         outw(SetStatusEnb | ((~status) & 0x7FE), ioaddr + EL3_CMD);
1248                         outw(AckIntr | 0x7FF, ioaddr + EL3_CMD);
1249                         break;
1250                 }
1251                 /* Acknowledge the IRQ. */
1252                 outw(AckIntr | IntReq | IntLatch, ioaddr + EL3_CMD);
1253
1254         } while ((status = inw(ioaddr + EL3_STATUS)) & (IntLatch | RxComplete));
1255
1256         spin_unlock(&lp->lock);
1257
1258         if (corkscrew_debug > 4)
1259                 printk("%s: exiting interrupt, status %4.4x.\n", dev->name, status);
1260         return IRQ_HANDLED;
1261 }
1262
1263 static int corkscrew_rx(struct net_device *dev)
1264 {
1265         struct corkscrew_private *vp = (struct corkscrew_private *) dev->priv;
1266         int ioaddr = dev->base_addr;
1267         int i;
1268         short rx_status;
1269
1270         if (corkscrew_debug > 5)
1271                 printk("   In rx_packet(), status %4.4x, rx_status %4.4x.\n",
1272                      inw(ioaddr + EL3_STATUS), inw(ioaddr + RxStatus));
1273         while ((rx_status = inw(ioaddr + RxStatus)) > 0) {
1274                 if (rx_status & 0x4000) {       /* Error, update stats. */
1275                         unsigned char rx_error = inb(ioaddr + RxErrors);
1276                         if (corkscrew_debug > 2)
1277                                 printk(" Rx error: status %2.2x.\n",
1278                                        rx_error);
1279                         vp->stats.rx_errors++;
1280                         if (rx_error & 0x01)
1281                                 vp->stats.rx_over_errors++;
1282                         if (rx_error & 0x02)
1283                                 vp->stats.rx_length_errors++;
1284                         if (rx_error & 0x04)
1285                                 vp->stats.rx_frame_errors++;
1286                         if (rx_error & 0x08)
1287                                 vp->stats.rx_crc_errors++;
1288                         if (rx_error & 0x10)
1289                                 vp->stats.rx_length_errors++;
1290                 } else {
1291                         /* The packet length: up to 4.5K!. */
1292                         short pkt_len = rx_status & 0x1fff;
1293                         struct sk_buff *skb;
1294
1295                         skb = dev_alloc_skb(pkt_len + 5 + 2);
1296                         if (corkscrew_debug > 4)
1297                                 printk("Receiving packet size %d status %4.4x.\n",
1298                                      pkt_len, rx_status);
1299                         if (skb != NULL) {
1300                                 skb->dev = dev;
1301                                 skb_reserve(skb, 2);    /* Align IP on 16 byte boundaries */
1302                                 /* 'skb_put()' points to the start of sk_buff data area. */
1303                                 insl(ioaddr + RX_FIFO,
1304                                      skb_put(skb, pkt_len),
1305                                      (pkt_len + 3) >> 2);
1306                                 outw(RxDiscard, ioaddr + EL3_CMD);      /* Pop top Rx packet. */
1307                                 skb->protocol = eth_type_trans(skb, dev);
1308                                 netif_rx(skb);
1309                                 dev->last_rx = jiffies;
1310                                 vp->stats.rx_packets++;
1311                                 vp->stats.rx_bytes += pkt_len;
1312                                 /* Wait a limited time to go to next packet. */
1313                                 for (i = 200; i >= 0; i--)
1314                                         if (! (inw(ioaddr + EL3_STATUS) & CmdInProgress))
1315                                                 break;
1316                                 continue;
1317                         } else if (corkscrew_debug)
1318                                 printk("%s: Couldn't allocate a sk_buff of size %d.\n", dev->name, pkt_len);
1319                 }
1320                 outw(RxDiscard, ioaddr + EL3_CMD);
1321                 vp->stats.rx_dropped++;
1322                 /* Wait a limited time to skip this packet. */
1323                 for (i = 200; i >= 0; i--)
1324                         if (!(inw(ioaddr + EL3_STATUS) & CmdInProgress))
1325                                 break;
1326         }
1327         return 0;
1328 }
1329
1330 static int boomerang_rx(struct net_device *dev)
1331 {
1332         struct corkscrew_private *vp =
1333             (struct corkscrew_private *) dev->priv;
1334         int entry = vp->cur_rx % RX_RING_SIZE;
1335         int ioaddr = dev->base_addr;
1336         int rx_status;
1337
1338         if (corkscrew_debug > 5)
1339                 printk("   In boomerang_rx(), status %4.4x, rx_status %4.4x.\n",
1340                         inw(ioaddr + EL3_STATUS), inw(ioaddr + RxStatus));
1341         while ((rx_status = vp->rx_ring[entry].status) & RxDComplete) {
1342                 if (rx_status & RxDError) {     /* Error, update stats. */
1343                         unsigned char rx_error = rx_status >> 16;
1344                         if (corkscrew_debug > 2)
1345                                 printk(" Rx error: status %2.2x.\n",
1346                                        rx_error);
1347                         vp->stats.rx_errors++;
1348                         if (rx_error & 0x01)
1349                                 vp->stats.rx_over_errors++;
1350                         if (rx_error & 0x02)
1351                                 vp->stats.rx_length_errors++;
1352                         if (rx_error & 0x04)
1353                                 vp->stats.rx_frame_errors++;
1354                         if (rx_error & 0x08)
1355                                 vp->stats.rx_crc_errors++;
1356                         if (rx_error & 0x10)
1357                                 vp->stats.rx_length_errors++;
1358                 } else {
1359                         /* The packet length: up to 4.5K!. */
1360                         short pkt_len = rx_status & 0x1fff;
1361                         struct sk_buff *skb;
1362
1363                         vp->stats.rx_bytes += pkt_len;
1364                         if (corkscrew_debug > 4)
1365                                 printk("Receiving packet size %d status %4.4x.\n",
1366                                      pkt_len, rx_status);
1367
1368                         /* Check if the packet is long enough to just accept without
1369                            copying to a properly sized skbuff. */
1370                         if (pkt_len < rx_copybreak
1371                             && (skb = dev_alloc_skb(pkt_len + 4)) != 0) {
1372                                 skb->dev = dev;
1373                                 skb_reserve(skb, 2);    /* Align IP on 16 byte boundaries */
1374                                 /* 'skb_put()' points to the start of sk_buff data area. */
1375                                 memcpy(skb_put(skb, pkt_len),
1376                                        isa_bus_to_virt(vp->rx_ring[entry].
1377                                                    addr), pkt_len);
1378                                 rx_copy++;
1379                         } else {
1380                                 void *temp;
1381                                 /* Pass up the skbuff already on the Rx ring. */
1382                                 skb = vp->rx_skbuff[entry];
1383                                 vp->rx_skbuff[entry] = NULL;
1384                                 temp = skb_put(skb, pkt_len);
1385                                 /* Remove this checking code for final release. */
1386                                 if (isa_bus_to_virt(vp->rx_ring[entry].addr) != temp)
1387                                             printk("%s: Warning -- the skbuff addresses do not match"
1388                                              " in boomerang_rx: %p vs. %p / %p.\n",
1389                                              dev->name,
1390                                              isa_bus_to_virt(vp->
1391                                                          rx_ring[entry].
1392                                                          addr), skb->head,
1393                                              temp);
1394                                 rx_nocopy++;
1395                         }
1396                         skb->protocol = eth_type_trans(skb, dev);
1397                         netif_rx(skb);
1398                         dev->last_rx = jiffies;
1399                         vp->stats.rx_packets++;
1400                 }
1401                 entry = (++vp->cur_rx) % RX_RING_SIZE;
1402         }
1403         /* Refill the Rx ring buffers. */
1404         for (; vp->cur_rx - vp->dirty_rx > 0; vp->dirty_rx++) {
1405                 struct sk_buff *skb;
1406                 entry = vp->dirty_rx % RX_RING_SIZE;
1407                 if (vp->rx_skbuff[entry] == NULL) {
1408                         skb = dev_alloc_skb(PKT_BUF_SZ);
1409                         if (skb == NULL)
1410                                 break;  /* Bad news!  */
1411                         skb->dev = dev; /* Mark as being used by this device. */
1412                         skb_reserve(skb, 2);    /* Align IP on 16 byte boundaries */
1413                         vp->rx_ring[entry].addr = isa_virt_to_bus(skb->tail);
1414                         vp->rx_skbuff[entry] = skb;
1415                 }
1416                 vp->rx_ring[entry].status = 0;  /* Clear complete bit. */
1417         }
1418         return 0;
1419 }
1420
1421 static int corkscrew_close(struct net_device *dev)
1422 {
1423         struct corkscrew_private *vp =
1424             (struct corkscrew_private *) dev->priv;
1425         int ioaddr = dev->base_addr;
1426         int i;
1427
1428         netif_stop_queue(dev);
1429
1430         if (corkscrew_debug > 1) {
1431                 printk("%s: corkscrew_close() status %4.4x, Tx status %2.2x.\n",
1432                      dev->name, inw(ioaddr + EL3_STATUS),
1433                      inb(ioaddr + TxStatus));
1434                 printk("%s: corkscrew close stats: rx_nocopy %d rx_copy %d"
1435                        " tx_queued %d.\n", dev->name, rx_nocopy, rx_copy,
1436                        queued_packet);
1437         }
1438
1439         del_timer(&vp->timer);
1440
1441         /* Turn off statistics ASAP.  We update lp->stats below. */
1442         outw(StatsDisable, ioaddr + EL3_CMD);
1443
1444         /* Disable the receiver and transmitter. */
1445         outw(RxDisable, ioaddr + EL3_CMD);
1446         outw(TxDisable, ioaddr + EL3_CMD);
1447
1448         if (dev->if_port == XCVR_10base2)
1449                 /* Turn off thinnet power.  Green! */
1450                 outw(StopCoax, ioaddr + EL3_CMD);
1451
1452         free_irq(dev->irq, dev);
1453
1454         outw(SetIntrEnb | 0x0000, ioaddr + EL3_CMD);
1455
1456         update_stats(ioaddr, dev);
1457         if (vp->full_bus_master_rx) {   /* Free Boomerang bus master Rx buffers. */
1458                 outl(0, ioaddr + UpListPtr);
1459                 for (i = 0; i < RX_RING_SIZE; i++)
1460                         if (vp->rx_skbuff[i]) {
1461                                 dev_kfree_skb(vp->rx_skbuff[i]);
1462                                 vp->rx_skbuff[i] = NULL;
1463                         }
1464         }
1465         if (vp->full_bus_master_tx) {   /* Free Boomerang bus master Tx buffers. */
1466                 outl(0, ioaddr + DownListPtr);
1467                 for (i = 0; i < TX_RING_SIZE; i++)
1468                         if (vp->tx_skbuff[i]) {
1469                                 dev_kfree_skb(vp->tx_skbuff[i]);
1470                                 vp->tx_skbuff[i] = NULL;
1471                         }
1472         }
1473
1474         return 0;
1475 }
1476
1477 static struct net_device_stats *corkscrew_get_stats(struct net_device *dev)
1478 {
1479         struct corkscrew_private *vp = (struct corkscrew_private *) dev->priv;
1480         unsigned long flags;
1481
1482         if (netif_running(dev)) {
1483                 spin_lock_irqsave(&vp->lock, flags);
1484                 update_stats(dev->base_addr, dev);
1485                 spin_unlock_irqrestore(&vp->lock, flags);
1486         }
1487         return &vp->stats;
1488 }
1489
1490 /*  Update statistics.
1491         Unlike with the EL3 we need not worry about interrupts changing
1492         the window setting from underneath us, but we must still guard
1493         against a race condition with a StatsUpdate interrupt updating the
1494         table.  This is done by checking that the ASM (!) code generated uses
1495         atomic updates with '+='.
1496         */
1497 static void update_stats(int ioaddr, struct net_device *dev)
1498 {
1499         struct corkscrew_private *vp =
1500             (struct corkscrew_private *) dev->priv;
1501
1502         /* Unlike the 3c5x9 we need not turn off stats updates while reading. */
1503         /* Switch to the stats window, and read everything. */
1504         EL3WINDOW(6);
1505         vp->stats.tx_carrier_errors += inb(ioaddr + 0);
1506         vp->stats.tx_heartbeat_errors += inb(ioaddr + 1);
1507         /* Multiple collisions. */ inb(ioaddr + 2);
1508         vp->stats.collisions += inb(ioaddr + 3);
1509         vp->stats.tx_window_errors += inb(ioaddr + 4);
1510         vp->stats.rx_fifo_errors += inb(ioaddr + 5);
1511         vp->stats.tx_packets += inb(ioaddr + 6);
1512         vp->stats.tx_packets += (inb(ioaddr + 9) & 0x30) << 4;
1513                                                 /* Rx packets   */ inb(ioaddr + 7);
1514                                                 /* Must read to clear */
1515         /* Tx deferrals */ inb(ioaddr + 8);
1516         /* Don't bother with register 9, an extension of registers 6&7.
1517            If we do use the 6&7 values the atomic update assumption above
1518            is invalid. */
1519         inw(ioaddr + 10);       /* Total Rx and Tx octets. */
1520         inw(ioaddr + 12);
1521         /* New: On the Vortex we must also clear the BadSSD counter. */
1522         EL3WINDOW(4);
1523         inb(ioaddr + 12);
1524
1525         /* We change back to window 7 (not 1) with the Vortex. */
1526         EL3WINDOW(7);
1527         return;
1528 }
1529
1530 /* This new version of set_rx_mode() supports v1.4 kernels.
1531    The Vortex chip has no documented multicast filter, so the only
1532    multicast setting is to receive all multicast frames.  At least
1533    the chip has a very clean way to set the mode, unlike many others. */
1534 static void set_rx_mode(struct net_device *dev)
1535 {
1536         int ioaddr = dev->base_addr;
1537         short new_mode;
1538
1539         if (dev->flags & IFF_PROMISC) {
1540                 if (corkscrew_debug > 3)
1541                         printk("%s: Setting promiscuous mode.\n",
1542                                dev->name);
1543                 new_mode = SetRxFilter | RxStation | RxMulticast | RxBroadcast | RxProm;
1544         } else if ((dev->mc_list) || (dev->flags & IFF_ALLMULTI)) {
1545                 new_mode = SetRxFilter | RxStation | RxMulticast | RxBroadcast;
1546         } else
1547                 new_mode = SetRxFilter | RxStation | RxBroadcast;
1548
1549         outw(new_mode, ioaddr + EL3_CMD);
1550 }
1551
1552 static void netdev_get_drvinfo(struct net_device *dev,
1553                                struct ethtool_drvinfo *info)
1554 {
1555         strcpy(info->driver, DRV_NAME);
1556         strcpy(info->version, DRV_VERSION);
1557         sprintf(info->bus_info, "ISA 0x%lx", dev->base_addr);
1558 }
1559
1560 static u32 netdev_get_msglevel(struct net_device *dev)
1561 {
1562         return corkscrew_debug;
1563 }
1564
1565 static void netdev_set_msglevel(struct net_device *dev, u32 level)
1566 {
1567         corkscrew_debug = level;
1568 }
1569
1570 static struct ethtool_ops netdev_ethtool_ops = {
1571         .get_drvinfo            = netdev_get_drvinfo,
1572         .get_msglevel           = netdev_get_msglevel,
1573         .set_msglevel           = netdev_set_msglevel,
1574 };
1575
1576 \f
1577 #ifdef MODULE
1578 void cleanup_module(void)
1579 {
1580         while (!list_empty(&root_corkscrew_dev)) {
1581                 struct net_device *dev;
1582                 struct corkscrew_private *vp;
1583
1584                 vp = list_entry(root_corkscrew_dev.next,
1585                                 struct corkscrew_private, list);
1586                 dev = vp->our_dev;
1587                 unregister_netdev(dev);
1588                 cleanup_card(dev);
1589                 free_netdev(dev);
1590         }
1591 }
1592 #endif                          /* MODULE */
1593 \f
1594 /*
1595  * Local variables:
1596  *  compile-command: "gcc -DMODULE -D__KERNEL__ -Wall -Wstrict-prototypes -O6 -c 3c515.c"
1597  *  c-indent-level: 4
1598  *  tab-width: 4
1599  * End:
1600  */