drivers/net/ethernet/3com/3c515.c

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