drivers/net/3c515.c

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