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