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 static int corkscrew_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 module_init(corkscrew_init_module);
 420
 421 #else
 422 struct net_device *tc515_probe(int unit)
 423 {
 424         struct net_device *dev = corkscrew_scan(unit);
 425
 426         if (!dev)
 427                 return ERR_PTR(-ENODEV);
 428
 429         return dev;
 430 }
 431 #endif                          /* not MODULE */
 432
 433 static int check_device(unsigned ioaddr)
 434 {
 435         int timer;
 436
 437         if (!request_region(ioaddr, CORKSCREW_TOTAL_SIZE, "3c515"))
 438                 return 0;
 439         /* Check the resource configuration for a matching ioaddr. */
 440         if ((inw(ioaddr + 0x2002) & 0x1f0) != (ioaddr & 0x1f0)) {
 441                 release_region(ioaddr, CORKSCREW_TOTAL_SIZE);
 442                 return 0;
 443         }
 444         /* Verify by reading the device ID from the EEPROM. */
 445         outw(EEPROM_Read + 7, ioaddr + Wn0EepromCmd);
 446         /* Pause for at least 162 us. for the read to take place. */
 447         for (timer = 4; timer >= 0; timer--) {
 448                 udelay(162);
 449                 if ((inw(ioaddr + Wn0EepromCmd) & 0x0200) == 0)
 450                         break;
 451         }
 452         if (inw(ioaddr + Wn0EepromData) != 0x6d50) {
 453                 release_region(ioaddr, CORKSCREW_TOTAL_SIZE);
 454                 return 0;
 455         }
 456         return 1;
 457 }
 458
 459 static void cleanup_card(struct net_device *dev)
 460 {
 461         struct corkscrew_private *vp = netdev_priv(dev);
 462         list_del_init(&vp->list);
 463         if (dev->dma)
 464                 free_dma(dev->dma);
 465         outw(TotalReset, dev->base_addr + EL3_CMD);
 466         release_region(dev->base_addr, CORKSCREW_TOTAL_SIZE);
 467         if (vp->dev)
 468                 pnp_device_detach(to_pnp_dev(vp->dev));
 469 }
 470
 471 static struct net_device *corkscrew_scan(int unit)
 472 {
 473         struct net_device *dev;
 474         static int cards_found = 0;
 475         static int ioaddr;
 476         int err;
 477 #ifdef __ISAPNP__
 478         short i;
 479         static int pnp_cards;
 480 #endif
 481
 482         dev = alloc_etherdev(sizeof(struct corkscrew_private));
 483         if (!dev)
 484                 return ERR_PTR(-ENOMEM);
 485
 486         if (unit >= 0) {
 487                 sprintf(dev->name, "eth%d", unit);
 488                 netdev_boot_setup_check(dev);
 489         }
 490
 491 #ifdef __ISAPNP__
 492         if(nopnp == 1)
 493                 goto no_pnp;
 494         for(i=0; corkscrew_isapnp_adapters[i].vendor != 0; i++) {
 495                 struct pnp_dev *idev = NULL;
 496                 int irq;
 497                 while((idev = pnp_find_dev(NULL,
 498                                            corkscrew_isapnp_adapters[i].vendor,
 499                                            corkscrew_isapnp_adapters[i].function,
 500                                            idev))) {
 501
 502                         if (pnp_device_attach(idev) < 0)
 503                                 continue;
 504                         if (pnp_activate_dev(idev) < 0) {
 505                                 pr_warn("pnp activate failed (out of resources?)\n");
 506                                 pnp_device_detach(idev);
 507                                 continue;
 508                         }
 509                         if (!pnp_port_valid(idev, 0) || !pnp_irq_valid(idev, 0)) {
 510                                 pnp_device_detach(idev);
 511                                 continue;
 512                         }
 513                         ioaddr = pnp_port_start(idev, 0);
 514                         irq = pnp_irq(idev, 0);
 515                         if (!check_device(ioaddr)) {
 516                                 pnp_device_detach(idev);
 517                                 continue;
 518                         }
 519                         if(corkscrew_debug)
 520                                 pr_debug("ISAPNP reports %s at i/o 0x%x, irq %d\n",
 521                                         (char*) corkscrew_isapnp_adapters[i].driver_data, ioaddr, irq);
 522                         pr_info("3c515 Resource configuration register %#4.4x, DCR %4.4x.\n",
 523                                 inl(ioaddr + 0x2002), inw(ioaddr + 0x2000));
 524                         /* irq = inw(ioaddr + 0x2002) & 15; */ /* Use the irq from isapnp */
 525                         SET_NETDEV_DEV(dev, &idev->dev);
 526                         pnp_cards++;
 527                         err = corkscrew_setup(dev, ioaddr, idev, cards_found++);
 528                         if (!err)
 529                                 return dev;
 530                         cleanup_card(dev);
 531                 }
 532         }
 533 no_pnp:
 534 #endif /* __ISAPNP__ */
 535
 536         /* Check all locations on the ISA bus -- evil! */
 537         for (ioaddr = 0x100; ioaddr < 0x400; ioaddr += 0x20) {
 538                 if (!check_device(ioaddr))
 539                         continue;
 540
 541                 pr_info("3c515 Resource configuration register %#4.4x, DCR %4.4x.\n",
 542                      inl(ioaddr + 0x2002), inw(ioaddr + 0x2000));
 543                 err = corkscrew_setup(dev, ioaddr, NULL, cards_found++);
 544                 if (!err)
 545                         return dev;
 546                 cleanup_card(dev);
 547         }
 548         free_netdev(dev);
 549         return NULL;
 550 }
 551
 552
 553 static const struct net_device_ops netdev_ops = {
 554         .ndo_open               = corkscrew_open,
 555         .ndo_stop               = corkscrew_close,
 556         .ndo_start_xmit         = corkscrew_start_xmit,
 557         .ndo_tx_timeout         = corkscrew_timeout,
 558         .ndo_get_stats          = corkscrew_get_stats,
 559         .ndo_set_rx_mode        = set_rx_mode,
 560         .ndo_set_mac_address    = eth_mac_addr,
 561         .ndo_validate_addr      = eth_validate_addr,
 562 };
 563
 564
 565 static int corkscrew_setup(struct net_device *dev, int ioaddr,
 566                             struct pnp_dev *idev, int card_number)
 567 {
 568         struct corkscrew_private *vp = netdev_priv(dev);
 569         unsigned int eeprom[0x40], checksum = 0;        /* EEPROM contents */
 570         __be16 addr[ETH_ALEN / 2];
 571         int i;
 572         int irq;
 573
 574 #ifdef __ISAPNP__
 575         if (idev) {
 576                 irq = pnp_irq(idev, 0);
 577                 vp->dev = &idev->dev;
 578         } else {
 579                 irq = inw(ioaddr + 0x2002) & 15;
 580         }
 581 #else
 582         irq = inw(ioaddr + 0x2002) & 15;
 583 #endif
 584
 585         dev->base_addr = ioaddr;
 586         dev->irq = irq;
 587         dev->dma = inw(ioaddr + 0x2000) & 7;
 588         vp->product_name = "3c515";
 589         vp->options = dev->mem_start;
 590         vp->our_dev = dev;
 591
 592         if (!vp->options) {
 593                  if (card_number >= MAX_UNITS)
 594                         vp->options = -1;
 595                 else
 596                         vp->options = options[card_number];
 597         }
 598
 599         if (vp->options >= 0) {
 600                 vp->media_override = vp->options & 7;
 601                 if (vp->media_override == 2)
 602                         vp->media_override = 0;
 603                 vp->full_duplex = (vp->options & 8) ? 1 : 0;
 604                 vp->bus_master = (vp->options & 16) ? 1 : 0;
 605         } else {
 606                 vp->media_override = 7;
 607                 vp->full_duplex = 0;
 608                 vp->bus_master = 0;
 609         }
 610 #ifdef MODULE
 611         list_add(&vp->list, &root_corkscrew_dev);
 612 #endif
 613
 614         pr_info("%s: 3Com %s at %#3x,", dev->name, vp->product_name, ioaddr);
 615
 616         spin_lock_init(&vp->lock);
 617
 618         timer_setup(&vp->timer, corkscrew_timer, 0);
 619
 620         /* Read the station address from the EEPROM. */
 621         EL3WINDOW(0);
 622         for (i = 0; i < 0x18; i++) {
 623                 int timer;
 624                 outw(EEPROM_Read + i, ioaddr + Wn0EepromCmd);
 625                 /* Pause for at least 162 us. for the read to take place. */
 626                 for (timer = 4; timer >= 0; timer--) {
 627                         udelay(162);
 628                         if ((inw(ioaddr + Wn0EepromCmd) & 0x0200) == 0)
 629                                 break;
 630                 }
 631                 eeprom[i] = inw(ioaddr + Wn0EepromData);
 632                 checksum ^= eeprom[i];
 633                 if (i < 3)
 634                         addr[i] = htons(eeprom[i]);
 635         }
 636         eth_hw_addr_set(dev, (u8 *)addr);
 637         checksum = (checksum ^ (checksum >> 8)) & 0xff;
 638         if (checksum != 0x00)
 639                 pr_cont(" ***INVALID CHECKSUM %4.4x*** ", checksum);
 640         pr_cont(" %pM", dev->dev_addr);
 641         if (eeprom[16] == 0x11c7) {     /* Corkscrew */
 642                 if (request_dma(dev->dma, "3c515")) {
 643                         pr_cont(", DMA %d allocation failed", dev->dma);
 644                         dev->dma = 0;
 645                 } else
 646                         pr_cont(", DMA %d", dev->dma);
 647         }
 648         pr_cont(", IRQ %d\n", dev->irq);
 649         /* Tell them about an invalid IRQ. */
 650         if (corkscrew_debug && (dev->irq <= 0 || dev->irq > 15))
 651                 pr_warn(" *** Warning: this IRQ is unlikely to work! ***\n");
 652
 653         {
 654                 static const char * const ram_split[] = {
 655                         "5:3", "3:1", "1:1", "3:5"
 656                 };
 657                 __u32 config;
 658                 EL3WINDOW(3);
 659                 vp->available_media = inw(ioaddr + Wn3_Options);
 660                 config = inl(ioaddr + Wn3_Config);
 661                 if (corkscrew_debug > 1)
 662                         pr_info("  Internal config register is %4.4x, transceivers %#x.\n",
 663                                 config, inw(ioaddr + Wn3_Options));
 664                 pr_info("  %dK %s-wide RAM %s Rx:Tx split, %s%s interface.\n",
 665                         8 << config & Ram_size,
 666                         config & Ram_width ? "word" : "byte",
 667                         ram_split[(config & Ram_split) >> Ram_split_shift],
 668                         config & Autoselect ? "autoselect/" : "",
 669                         media_tbl[(config & Xcvr) >> Xcvr_shift].name);
 670                 vp->default_media = (config & Xcvr) >> Xcvr_shift;
 671                 vp->autoselect = config & Autoselect ? 1 : 0;
 672                 dev->if_port = vp->default_media;
 673         }
 674         if (vp->media_override != 7) {
 675                 pr_info("  Media override to transceiver type %d (%s).\n",
 676                        vp->media_override,
 677                        media_tbl[vp->media_override].name);
 678                 dev->if_port = vp->media_override;
 679         }
 680
 681         vp->capabilities = eeprom[16];
 682         vp->full_bus_master_tx = (vp->capabilities & 0x20) ? 1 : 0;
 683         /* Rx is broken at 10mbps, so we always disable it. */
 684         /* vp->full_bus_master_rx = 0; */
 685         vp->full_bus_master_rx = (vp->capabilities & 0x20) ? 1 : 0;
 686
 687         /* The 3c51x-specific entries in the device structure. */
 688         dev->netdev_ops = &netdev_ops;
 689         dev->watchdog_timeo = (400 * HZ) / 1000;
 690         dev->ethtool_ops = &netdev_ethtool_ops;
 691
 692         return register_netdev(dev);
 693 }
 694
 695
 696 static int corkscrew_open(struct net_device *dev)
 697 {
 698         int ioaddr = dev->base_addr;
 699         struct corkscrew_private *vp = netdev_priv(dev);
 700         bool armtimer = false;
 701         __u32 config;
 702         int i;
 703
 704         /* Before initializing select the active media port. */
 705         EL3WINDOW(3);
 706         if (vp->full_duplex)
 707                 outb(0x20, ioaddr + Wn3_MAC_Ctrl);      /* Set the full-duplex bit. */
 708         config = inl(ioaddr + Wn3_Config);
 709
 710         if (vp->media_override != 7) {
 711                 if (corkscrew_debug > 1)
 712                         pr_info("%s: Media override to transceiver %d (%s).\n",
 713                                 dev->name, vp->media_override,
 714                                 media_tbl[vp->media_override].name);
 715                 dev->if_port = vp->media_override;
 716         } else if (vp->autoselect) {
 717                 /* Find first available media type, starting with 100baseTx. */
 718                 dev->if_port = 4;
 719                 while (!(vp->available_media & media_tbl[dev->if_port].mask))
 720                         dev->if_port = media_tbl[dev->if_port].next;
 721
 722                 if (corkscrew_debug > 1)
 723                         pr_debug("%s: Initial media type %s.\n",
 724                                dev->name, media_tbl[dev->if_port].name);
 725                 armtimer = true;
 726         } else
 727                 dev->if_port = vp->default_media;
 728
 729         config = (config & ~Xcvr) | (dev->if_port << Xcvr_shift);
 730         outl(config, ioaddr + Wn3_Config);
 731
 732         if (corkscrew_debug > 1) {
 733                 pr_debug("%s: corkscrew_open() InternalConfig %8.8x.\n",
 734                        dev->name, config);
 735         }
 736
 737         outw(TxReset, ioaddr + EL3_CMD);
 738         for (i = 20; i >= 0; i--)
 739                 if (!(inw(ioaddr + EL3_STATUS) & CmdInProgress))
 740                         break;
 741
 742         outw(RxReset, ioaddr + EL3_CMD);
 743         /* Wait a few ticks for the RxReset command to complete. */
 744         for (i = 20; i >= 0; i--)
 745                 if (!(inw(ioaddr + EL3_STATUS) & CmdInProgress))
 746                         break;
 747
 748         outw(SetStatusEnb | 0x00, ioaddr + EL3_CMD);
 749
 750         /* Use the now-standard shared IRQ implementation. */
 751         if (vp->capabilities == 0x11c7) {
 752                 /* Corkscrew: Cannot share ISA resources. */
 753                 if (dev->irq == 0 ||
 754                     dev->dma == 0 ||
 755                     request_irq(dev->irq, corkscrew_interrupt, 0,
 756                                 vp->product_name, dev))
 757                         return -EAGAIN;
 758                 enable_dma(dev->dma);
 759                 set_dma_mode(dev->dma, DMA_MODE_CASCADE);
 760         } else if (request_irq(dev->irq, corkscrew_interrupt, IRQF_SHARED,
 761                                vp->product_name, dev)) {
 762                 return -EAGAIN;
 763         }
 764
 765         if (armtimer)
 766                 mod_timer(&vp->timer, jiffies + media_tbl[dev->if_port].wait);
 767
 768         if (corkscrew_debug > 1) {
 769                 EL3WINDOW(4);
 770                 pr_debug("%s: corkscrew_open() irq %d media status %4.4x.\n",
 771                        dev->name, dev->irq, inw(ioaddr + Wn4_Media));
 772         }
 773
 774         /* Set the station address and mask in window 2 each time opened. */
 775         EL3WINDOW(2);
 776         for (i = 0; i < 6; i++)
 777                 outb(dev->dev_addr[i], ioaddr + i);
 778         for (; i < 12; i += 2)
 779                 outw(0, ioaddr + i);
 780
 781         if (dev->if_port == 3)
 782                 /* Start the thinnet transceiver. We should really wait 50ms... */
 783                 outw(StartCoax, ioaddr + EL3_CMD);
 784         EL3WINDOW(4);
 785         outw((inw(ioaddr + Wn4_Media) & ~(Media_10TP | Media_SQE)) |
 786              media_tbl[dev->if_port].media_bits, ioaddr + Wn4_Media);
 787
 788         /* Switch to the stats window, and clear all stats by reading. */
 789         outw(StatsDisable, ioaddr + EL3_CMD);
 790         EL3WINDOW(6);
 791         for (i = 0; i < 10; i++)
 792                 inb(ioaddr + i);
 793         inw(ioaddr + 10);
 794         inw(ioaddr + 12);
 795         /* New: On the Vortex we must also clear the BadSSD counter. */
 796         EL3WINDOW(4);
 797         inb(ioaddr + 12);
 798         /* ..and on the Boomerang we enable the extra statistics bits. */
 799         outw(0x0040, ioaddr + Wn4_NetDiag);
 800
 801         /* Switch to register set 7 for normal use. */
 802         EL3WINDOW(7);
 803
 804         if (vp->full_bus_master_rx) {   /* Boomerang bus master. */
 805                 vp->cur_rx = vp->dirty_rx = 0;
 806                 if (corkscrew_debug > 2)
 807                         pr_debug("%s:  Filling in the Rx ring.\n", dev->name);
 808                 for (i = 0; i < RX_RING_SIZE; i++) {
 809                         struct sk_buff *skb;
 810                         if (i < (RX_RING_SIZE - 1))
 811                                 vp->rx_ring[i].next =
 812                                     isa_virt_to_bus(&vp->rx_ring[i + 1]);
 813                         else
 814                                 vp->rx_ring[i].next = 0;
 815                         vp->rx_ring[i].status = 0;      /* Clear complete bit. */
 816                         vp->rx_ring[i].length = PKT_BUF_SZ | 0x80000000;
 817                         skb = netdev_alloc_skb(dev, PKT_BUF_SZ);
 818                         vp->rx_skbuff[i] = skb;
 819                         if (skb == NULL)
 820                                 break;  /* Bad news!  */
 821                         skb_reserve(skb, 2);    /* Align IP on 16 byte boundaries */
 822                         vp->rx_ring[i].addr = isa_virt_to_bus(skb->data);
 823                 }
 824                 if (i != 0)
 825                         vp->rx_ring[i - 1].next =
 826                                 isa_virt_to_bus(&vp->rx_ring[0]);       /* Wrap the ring. */
 827                 outl(isa_virt_to_bus(&vp->rx_ring[0]), ioaddr + UpListPtr);
 828         }
 829         if (vp->full_bus_master_tx) {   /* Boomerang bus master Tx. */
 830                 vp->cur_tx = vp->dirty_tx = 0;
 831                 outb(PKT_BUF_SZ >> 8, ioaddr + TxFreeThreshold);        /* Room for a packet. */
 832                 /* Clear the Tx ring. */
 833                 for (i = 0; i < TX_RING_SIZE; i++)
 834                         vp->tx_skbuff[i] = NULL;
 835                 outl(0, ioaddr + DownListPtr);
 836         }
 837         /* Set receiver mode: presumably accept b-case and phys addr only. */
 838         set_rx_mode(dev);
 839         outw(StatsEnable, ioaddr + EL3_CMD);    /* Turn on statistics. */
 840
 841         netif_start_queue(dev);
 842
 843         outw(RxEnable, ioaddr + EL3_CMD);       /* Enable the receiver. */
 844         outw(TxEnable, ioaddr + EL3_CMD);       /* Enable transmitter. */
 845         /* Allow status bits to be seen. */
 846         outw(SetStatusEnb | AdapterFailure | IntReq | StatsFull |
 847              (vp->full_bus_master_tx ? DownComplete : TxAvailable) |
 848              (vp->full_bus_master_rx ? UpComplete : RxComplete) |
 849              (vp->bus_master ? DMADone : 0), ioaddr + EL3_CMD);
 850         /* Ack all pending events, and set active indicator mask. */
 851         outw(AckIntr | IntLatch | TxAvailable | RxEarly | IntReq,
 852              ioaddr + EL3_CMD);
 853         outw(SetIntrEnb | IntLatch | TxAvailable | RxComplete | StatsFull
 854              | (vp->bus_master ? DMADone : 0) | UpComplete | DownComplete,
 855              ioaddr + EL3_CMD);
 856
 857         return 0;
 858 }
 859
 860 static void corkscrew_timer(struct timer_list *t)
 861 {
 862 #ifdef AUTOMEDIA
 863         struct corkscrew_private *vp = from_timer(vp, t, timer);
 864         struct net_device *dev = vp->our_dev;
 865         int ioaddr = dev->base_addr;
 866         unsigned long flags;
 867         int ok = 0;
 868
 869         if (corkscrew_debug > 1)
 870                 pr_debug("%s: Media selection timer tick happened, %s.\n",
 871                        dev->name, media_tbl[dev->if_port].name);
 872
 873         spin_lock_irqsave(&vp->lock, flags);
 874
 875         {
 876                 int old_window = inw(ioaddr + EL3_CMD) >> 13;
 877                 int media_status;
 878                 EL3WINDOW(4);
 879                 media_status = inw(ioaddr + Wn4_Media);
 880                 switch (dev->if_port) {
 881                 case 0:
 882                 case 4:
 883                 case 5: /* 10baseT, 100baseTX, 100baseFX  */
 884                         if (media_status & Media_LnkBeat) {
 885                                 ok = 1;
 886                                 if (corkscrew_debug > 1)
 887                                         pr_debug("%s: Media %s has link beat, %x.\n",
 888                                                 dev->name,
 889                                                 media_tbl[dev->if_port].name,
 890                                                 media_status);
 891                         } else if (corkscrew_debug > 1)
 892                                 pr_debug("%s: Media %s is has no link beat, %x.\n",
 893                                         dev->name,
 894                                         media_tbl[dev->if_port].name,
 895                                         media_status);
 896
 897                         break;
 898                 default:        /* Other media types handled by Tx timeouts. */
 899                         if (corkscrew_debug > 1)
 900                                 pr_debug("%s: Media %s is has no indication, %x.\n",
 901                                         dev->name,
 902                                         media_tbl[dev->if_port].name,
 903                                         media_status);
 904                         ok = 1;
 905                 }
 906                 if (!ok) {
 907                         __u32 config;
 908
 909                         do {
 910                                 dev->if_port =
 911                                     media_tbl[dev->if_port].next;
 912                         }
 913                         while (!(vp->available_media & media_tbl[dev->if_port].mask));
 914
 915                         if (dev->if_port == 8) {        /* Go back to default. */
 916                                 dev->if_port = vp->default_media;
 917                                 if (corkscrew_debug > 1)
 918                                         pr_debug("%s: Media selection failing, using default %s port.\n",
 919                                                 dev->name,
 920                                                 media_tbl[dev->if_port].name);
 921                         } else {
 922                                 if (corkscrew_debug > 1)
 923                                         pr_debug("%s: Media selection failed, now trying %s port.\n",
 924                                                 dev->name,
 925                                                 media_tbl[dev->if_port].name);
 926                                 vp->timer.expires = jiffies + media_tbl[dev->if_port].wait;
 927                                 add_timer(&vp->timer);
 928                         }
 929                         outw((media_status & ~(Media_10TP | Media_SQE)) |
 930                              media_tbl[dev->if_port].media_bits,
 931                              ioaddr + Wn4_Media);
 932
 933                         EL3WINDOW(3);
 934                         config = inl(ioaddr + Wn3_Config);
 935                         config = (config & ~Xcvr) | (dev->if_port << Xcvr_shift);
 936                         outl(config, ioaddr + Wn3_Config);
 937
 938                         outw(dev->if_port == 3 ? StartCoax : StopCoax,
 939                              ioaddr + EL3_CMD);
 940                 }
 941                 EL3WINDOW(old_window);
 942         }
 943
 944         spin_unlock_irqrestore(&vp->lock, flags);
 945         if (corkscrew_debug > 1)
 946                 pr_debug("%s: Media selection timer finished, %s.\n",
 947                        dev->name, media_tbl[dev->if_port].name);
 948
 949 #endif                          /* AUTOMEDIA */
 950 }
 951
 952 static void corkscrew_timeout(struct net_device *dev, unsigned int txqueue)
 953 {
 954         int i;
 955         struct corkscrew_private *vp = netdev_priv(dev);
 956         int ioaddr = dev->base_addr;
 957
 958         pr_warn("%s: transmit timed out, tx_status %2.2x status %4.4x\n",
 959                 dev->name, inb(ioaddr + TxStatus),
 960                 inw(ioaddr + EL3_STATUS));
 961         /* Slight code bloat to be user friendly. */
 962         if ((inb(ioaddr + TxStatus) & 0x88) == 0x88)
 963                 pr_warn("%s: Transmitter encountered 16 collisions -- network cable problem?\n",
 964                         dev->name);
 965 #ifndef final_version
 966         pr_debug("  Flags; bus-master %d, full %d; dirty %d current %d.\n",
 967                vp->full_bus_master_tx, vp->tx_full, vp->dirty_tx,
 968                vp->cur_tx);
 969         pr_debug("  Down list %8.8x vs. %p.\n", inl(ioaddr + DownListPtr),
 970                &vp->tx_ring[0]);
 971         for (i = 0; i < TX_RING_SIZE; i++) {
 972                 pr_debug("  %d: %p  length %8.8x status %8.8x\n", i,
 973                        &vp->tx_ring[i],
 974                        vp->tx_ring[i].length, vp->tx_ring[i].status);
 975         }
 976 #endif
 977         /* Issue TX_RESET and TX_START commands. */
 978         outw(TxReset, ioaddr + EL3_CMD);
 979         for (i = 20; i >= 0; i--)
 980                 if (!(inw(ioaddr + EL3_STATUS) & CmdInProgress))
 981                         break;
 982         outw(TxEnable, ioaddr + EL3_CMD);
 983         netif_trans_update(dev); /* prevent tx timeout */
 984         dev->stats.tx_errors++;
 985         dev->stats.tx_dropped++;
 986         netif_wake_queue(dev);
 987 }
 988
 989 static netdev_tx_t corkscrew_start_xmit(struct sk_buff *skb,
 990                                         struct net_device *dev)
 991 {
 992         struct corkscrew_private *vp = netdev_priv(dev);
 993         int ioaddr = dev->base_addr;
 994
 995         /* Block a timer-based transmit from overlapping. */
 996
 997         netif_stop_queue(dev);
 998
 999         if (vp->full_bus_master_tx) {   /* BOOMERANG bus-master */
1000                 /* Calculate the next Tx descriptor entry. */
1001                 int entry = vp->cur_tx % TX_RING_SIZE;
1002                 struct boom_tx_desc *prev_entry;
1003                 unsigned long flags;
1004                 int i;
1005
1006                 if (vp->tx_full)        /* No room to transmit with */
1007                         return NETDEV_TX_BUSY;
1008                 if (vp->cur_tx != 0)
1009                         prev_entry = &vp->tx_ring[(vp->cur_tx - 1) % TX_RING_SIZE];
1010                 else
1011                         prev_entry = NULL;
1012                 if (corkscrew_debug > 3)
1013                         pr_debug("%s: Trying to send a packet, Tx index %d.\n",
1014                                 dev->name, vp->cur_tx);
1015                 /* vp->tx_full = 1; */
1016                 vp->tx_skbuff[entry] = skb;
1017                 vp->tx_ring[entry].next = 0;
1018                 vp->tx_ring[entry].addr = isa_virt_to_bus(skb->data);
1019                 vp->tx_ring[entry].length = skb->len | 0x80000000;
1020                 vp->tx_ring[entry].status = skb->len | 0x80000000;
1021
1022                 spin_lock_irqsave(&vp->lock, flags);
1023                 outw(DownStall, ioaddr + EL3_CMD);
1024                 /* Wait for the stall to complete. */
1025                 for (i = 20; i >= 0; i--)
1026                         if ((inw(ioaddr + EL3_STATUS) & CmdInProgress) == 0)
1027                                 break;
1028                 if (prev_entry)
1029                         prev_entry->next = isa_virt_to_bus(&vp->tx_ring[entry]);
1030                 if (inl(ioaddr + DownListPtr) == 0) {
1031                         outl(isa_virt_to_bus(&vp->tx_ring[entry]),
1032                              ioaddr + DownListPtr);
1033                         queued_packet++;
1034                 }
1035                 outw(DownUnstall, ioaddr + EL3_CMD);
1036                 spin_unlock_irqrestore(&vp->lock, flags);
1037
1038                 vp->cur_tx++;
1039                 if (vp->cur_tx - vp->dirty_tx > TX_RING_SIZE - 1)
1040                         vp->tx_full = 1;
1041                 else {          /* Clear previous interrupt enable. */
1042                         if (prev_entry)
1043                                 prev_entry->status &= ~0x80000000;
1044                         netif_wake_queue(dev);
1045                 }
1046                 return NETDEV_TX_OK;
1047         }
1048         /* Put out the doubleword header... */
1049         outl(skb->len, ioaddr + TX_FIFO);
1050         dev->stats.tx_bytes += skb->len;
1051 #ifdef VORTEX_BUS_MASTER
1052         if (vp->bus_master) {
1053                 /* Set the bus-master controller to transfer the packet. */
1054                 outl(isa_virt_to_bus(skb->data), ioaddr + Wn7_MasterAddr);
1055                 outw((skb->len + 3) & ~3, ioaddr + Wn7_MasterLen);
1056                 vp->tx_skb = skb;
1057                 outw(StartDMADown, ioaddr + EL3_CMD);
1058                 /* queue will be woken at the DMADone interrupt. */
1059         } else {
1060                 /* ... and the packet rounded to a doubleword. */
1061                 outsl(ioaddr + TX_FIFO, skb->data, (skb->len + 3) >> 2);
1062                 dev_kfree_skb(skb);
1063                 if (inw(ioaddr + TxFree) > 1536) {
1064                         netif_wake_queue(dev);
1065                 } else
1066                         /* Interrupt us when the FIFO has room for max-sized packet. */
1067                         outw(SetTxThreshold + (1536 >> 2),
1068                              ioaddr + EL3_CMD);
1069         }
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), ioaddr + EL3_CMD);
1079 #endif                          /* bus master */
1080
1081
1082         /* Clear the Tx status stack. */
1083         {
1084                 short tx_status;
1085                 int i = 4;
1086
1087                 while (--i > 0 && (tx_status = inb(ioaddr + TxStatus)) > 0) {
1088                         if (tx_status & 0x3C) { /* A Tx-disabling error occurred.  */
1089                                 if (corkscrew_debug > 2)
1090                                         pr_debug("%s: Tx error, status %2.2x.\n",
1091                                                 dev->name, tx_status);
1092                                 if (tx_status & 0x04)
1093                                         dev->stats.tx_fifo_errors++;
1094                                 if (tx_status & 0x38)
1095                                         dev->stats.tx_aborted_errors++;
1096                                 if (tx_status & 0x30) {
1097                                         int j;
1098                                         outw(TxReset, ioaddr + EL3_CMD);
1099                                         for (j = 20; j >= 0; j--)
1100                                                 if (!(inw(ioaddr + EL3_STATUS) & CmdInProgress))
1101                                                         break;
1102                                 }
1103                                 outw(TxEnable, ioaddr + EL3_CMD);
1104                         }
1105                         outb(0x00, ioaddr + TxStatus);  /* Pop the status stack. */
1106                 }
1107         }
1108         return NETDEV_TX_OK;
1109 }
1110
1111 /* The interrupt handler does all of the Rx thread work and cleans up
1112    after the Tx thread. */
1113
1114 static irqreturn_t corkscrew_interrupt(int irq, void *dev_id)
1115 {
1116         /* Use the now-standard shared IRQ implementation. */
1117         struct net_device *dev = dev_id;
1118         struct corkscrew_private *lp = netdev_priv(dev);
1119         int ioaddr, status;
1120         int latency;
1121         int i = max_interrupt_work;
1122
1123         ioaddr = dev->base_addr;
1124         latency = inb(ioaddr + Timer);
1125
1126         spin_lock(&lp->lock);
1127
1128         status = inw(ioaddr + EL3_STATUS);
1129
1130         if (corkscrew_debug > 4)
1131                 pr_debug("%s: interrupt, status %4.4x, timer %d.\n",
1132                         dev->name, status, latency);
1133         if ((status & 0xE000) != 0xE000) {
1134                 static int donedidthis;
1135                 /* Some interrupt controllers store a bogus interrupt from boot-time.
1136                    Ignore a single early interrupt, but don't hang the machine for
1137                    other interrupt problems. */
1138                 if (donedidthis++ > 100) {
1139                         pr_err("%s: Bogus interrupt, bailing. Status %4.4x, start=%d.\n",
1140                                    dev->name, status, netif_running(dev));
1141                         free_irq(dev->irq, dev);
1142                         dev->irq = -1;
1143                 }
1144         }
1145
1146         do {
1147                 if (corkscrew_debug > 5)
1148                         pr_debug("%s: In interrupt loop, status %4.4x.\n",
1149                                dev->name, status);
1150                 if (status & RxComplete)
1151                         corkscrew_rx(dev);
1152
1153                 if (status & TxAvailable) {
1154                         if (corkscrew_debug > 5)
1155                                 pr_debug("      TX room bit was handled.\n");
1156                         /* There's room in the FIFO for a full-sized packet. */
1157                         outw(AckIntr | TxAvailable, ioaddr + EL3_CMD);
1158                         netif_wake_queue(dev);
1159                 }
1160                 if (status & DownComplete) {
1161                         unsigned int dirty_tx = lp->dirty_tx;
1162
1163                         while (lp->cur_tx - dirty_tx > 0) {
1164                                 int entry = dirty_tx % TX_RING_SIZE;
1165                                 if (inl(ioaddr + DownListPtr) == isa_virt_to_bus(&lp->tx_ring[entry]))
1166                                         break;  /* It still hasn't been processed. */
1167                                 if (lp->tx_skbuff[entry]) {
1168                                         dev_consume_skb_irq(lp->tx_skbuff[entry]);
1169                                         lp->tx_skbuff[entry] = NULL;
1170                                 }
1171                                 dirty_tx++;
1172                         }
1173                         lp->dirty_tx = dirty_tx;
1174                         outw(AckIntr | DownComplete, ioaddr + EL3_CMD);
1175                         if (lp->tx_full && (lp->cur_tx - dirty_tx <= TX_RING_SIZE - 1)) {
1176                                 lp->tx_full = 0;
1177                                 netif_wake_queue(dev);
1178                         }
1179                 }
1180 #ifdef VORTEX_BUS_MASTER
1181                 if (status & DMADone) {
1182                         outw(0x1000, ioaddr + Wn7_MasterStatus);        /* Ack the event. */
1183                         dev_consume_skb_irq(lp->tx_skb);        /* Release the transferred buffer */
1184                         netif_wake_queue(dev);
1185                 }
1186 #endif
1187                 if (status & UpComplete) {
1188                         boomerang_rx(dev);
1189                         outw(AckIntr | UpComplete, ioaddr + EL3_CMD);
1190                 }
1191                 if (status & (AdapterFailure | RxEarly | StatsFull)) {
1192                         /* Handle all uncommon interrupts at once. */
1193                         if (status & RxEarly) { /* Rx early is unused. */
1194                                 corkscrew_rx(dev);
1195                                 outw(AckIntr | RxEarly, ioaddr + EL3_CMD);
1196                         }
1197                         if (status & StatsFull) {       /* Empty statistics. */
1198                                 static int DoneDidThat;
1199                                 if (corkscrew_debug > 4)
1200                                         pr_debug("%s: Updating stats.\n", dev->name);
1201                                 update_stats(ioaddr, dev);
1202                                 /* DEBUG HACK: Disable statistics as an interrupt source. */
1203                                 /* This occurs when we have the wrong media type! */
1204                                 if (DoneDidThat == 0 && inw(ioaddr + EL3_STATUS) & StatsFull) {
1205                                         int win, reg;
1206                                         pr_notice("%s: Updating stats failed, disabling stats as an interrupt source.\n",
1207                                                 dev->name);
1208                                         for (win = 0; win < 8; win++) {
1209                                                 EL3WINDOW(win);
1210                                                 pr_notice("Vortex window %d:", win);
1211                                                 for (reg = 0; reg < 16; reg++)
1212                                                         pr_cont(" %2.2x", inb(ioaddr + reg));
1213                                                 pr_cont("\n");
1214                                         }
1215                                         EL3WINDOW(7);
1216                                         outw(SetIntrEnb | TxAvailable |
1217                                              RxComplete | AdapterFailure |
1218                                              UpComplete | DownComplete |
1219                                              TxComplete, ioaddr + EL3_CMD);
1220                                         DoneDidThat++;
1221                                 }
1222                         }
1223                         if (status & AdapterFailure) {
1224                                 /* Adapter failure requires Rx reset and reinit. */
1225                                 outw(RxReset, ioaddr + EL3_CMD);
1226                                 /* Set the Rx filter to the current state. */
1227                                 set_rx_mode(dev);
1228                                 outw(RxEnable, ioaddr + EL3_CMD);       /* Re-enable the receiver. */
1229                                 outw(AckIntr | AdapterFailure,
1230                                      ioaddr + EL3_CMD);
1231                         }
1232                 }
1233
1234                 if (--i < 0) {
1235                         pr_err("%s: Too much work in interrupt, status %4.4x. Disabling functions (%4.4x).\n",
1236                                 dev->name, status, SetStatusEnb | ((~status) & 0x7FE));
1237                         /* Disable all pending interrupts. */
1238                         outw(SetStatusEnb | ((~status) & 0x7FE), ioaddr + EL3_CMD);
1239                         outw(AckIntr | 0x7FF, ioaddr + EL3_CMD);
1240                         break;
1241                 }
1242                 /* Acknowledge the IRQ. */
1243                 outw(AckIntr | IntReq | IntLatch, ioaddr + EL3_CMD);
1244
1245         } while ((status = inw(ioaddr + EL3_STATUS)) & (IntLatch | RxComplete));
1246
1247         spin_unlock(&lp->lock);
1248
1249         if (corkscrew_debug > 4)
1250                 pr_debug("%s: exiting interrupt, status %4.4x.\n", dev->name, status);
1251         return IRQ_HANDLED;
1252 }
1253
1254 static int corkscrew_rx(struct net_device *dev)
1255 {
1256         int ioaddr = dev->base_addr;
1257         int i;
1258         short rx_status;
1259
1260         if (corkscrew_debug > 5)
1261                 pr_debug("   In rx_packet(), status %4.4x, rx_status %4.4x.\n",
1262                      inw(ioaddr + EL3_STATUS), inw(ioaddr + RxStatus));
1263         while ((rx_status = inw(ioaddr + RxStatus)) > 0) {
1264                 if (rx_status & 0x4000) {       /* Error, update stats. */
1265                         unsigned char rx_error = inb(ioaddr + RxErrors);
1266                         if (corkscrew_debug > 2)
1267                                 pr_debug(" Rx error: status %2.2x.\n",
1268                                        rx_error);
1269                         dev->stats.rx_errors++;
1270                         if (rx_error & 0x01)
1271                                 dev->stats.rx_over_errors++;
1272                         if (rx_error & 0x02)
1273                                 dev->stats.rx_length_errors++;
1274                         if (rx_error & 0x04)
1275                                 dev->stats.rx_frame_errors++;
1276                         if (rx_error & 0x08)
1277                                 dev->stats.rx_crc_errors++;
1278                         if (rx_error & 0x10)
1279                                 dev->stats.rx_length_errors++;
1280                 } else {
1281                         /* The packet length: up to 4.5K!. */
1282                         short pkt_len = rx_status & 0x1fff;
1283                         struct sk_buff *skb;
1284
1285                         skb = netdev_alloc_skb(dev, pkt_len + 5 + 2);
1286                         if (corkscrew_debug > 4)
1287                                 pr_debug("Receiving packet size %d status %4.4x.\n",
1288                                      pkt_len, rx_status);
1289                         if (skb != NULL) {
1290                                 skb_reserve(skb, 2);    /* Align IP on 16 byte boundaries */
1291                                 /* 'skb_put()' points to the start of sk_buff data area. */
1292                                 insl(ioaddr + RX_FIFO,
1293                                      skb_put(skb, pkt_len),
1294                                      (pkt_len + 3) >> 2);
1295                                 outw(RxDiscard, ioaddr + EL3_CMD);      /* Pop top Rx packet. */
1296                                 skb->protocol = eth_type_trans(skb, dev);
1297                                 netif_rx(skb);
1298                                 dev->stats.rx_packets++;
1299                                 dev->stats.rx_bytes += pkt_len;
1300                                 /* Wait a limited time to go to next packet. */
1301                                 for (i = 200; i >= 0; i--)
1302                                         if (! (inw(ioaddr + EL3_STATUS) & CmdInProgress))
1303                                                 break;
1304                                 continue;
1305                         } else if (corkscrew_debug)
1306                                 pr_debug("%s: Couldn't allocate a sk_buff of size %d.\n", dev->name, pkt_len);
1307                 }
1308                 outw(RxDiscard, ioaddr + EL3_CMD);
1309                 dev->stats.rx_dropped++;
1310                 /* Wait a limited time to skip this packet. */
1311                 for (i = 200; i >= 0; i--)
1312                         if (!(inw(ioaddr + EL3_STATUS) & CmdInProgress))
1313                                 break;
1314         }
1315         return 0;
1316 }
1317
1318 static int boomerang_rx(struct net_device *dev)
1319 {
1320         struct corkscrew_private *vp = netdev_priv(dev);
1321         int entry = vp->cur_rx % RX_RING_SIZE;
1322         int ioaddr = dev->base_addr;
1323         int rx_status;
1324
1325         if (corkscrew_debug > 5)
1326                 pr_debug("   In boomerang_rx(), status %4.4x, rx_status %4.4x.\n",
1327                         inw(ioaddr + EL3_STATUS), inw(ioaddr + RxStatus));
1328         while ((rx_status = vp->rx_ring[entry].status) & RxDComplete) {
1329                 if (rx_status & RxDError) {     /* Error, update stats. */
1330                         unsigned char rx_error = rx_status >> 16;
1331                         if (corkscrew_debug > 2)
1332                                 pr_debug(" Rx error: status %2.2x.\n",
1333                                        rx_error);
1334                         dev->stats.rx_errors++;
1335                         if (rx_error & 0x01)
1336                                 dev->stats.rx_over_errors++;
1337                         if (rx_error & 0x02)
1338                                 dev->stats.rx_length_errors++;
1339                         if (rx_error & 0x04)
1340                                 dev->stats.rx_frame_errors++;
1341                         if (rx_error & 0x08)
1342                                 dev->stats.rx_crc_errors++;
1343                         if (rx_error & 0x10)
1344                                 dev->stats.rx_length_errors++;
1345                 } else {
1346                         /* The packet length: up to 4.5K!. */
1347                         short pkt_len = rx_status & 0x1fff;
1348                         struct sk_buff *skb;
1349
1350                         dev->stats.rx_bytes += pkt_len;
1351                         if (corkscrew_debug > 4)
1352                                 pr_debug("Receiving packet size %d status %4.4x.\n",
1353                                      pkt_len, rx_status);
1354
1355                         /* Check if the packet is long enough to just accept without
1356                            copying to a properly sized skbuff. */
1357                         if (pkt_len < rx_copybreak &&
1358                             (skb = netdev_alloc_skb(dev, pkt_len + 4)) != NULL) {
1359                                 skb_reserve(skb, 2);    /* Align IP on 16 byte boundaries */
1360                                 /* 'skb_put()' points to the start of sk_buff data area. */
1361                                 skb_put_data(skb,
1362                                              isa_bus_to_virt(vp->rx_ring[entry].addr),
1363                                              pkt_len);
1364                                 rx_copy++;
1365                         } else {
1366                                 void *temp;
1367                                 /* Pass up the skbuff already on the Rx ring. */
1368                                 skb = vp->rx_skbuff[entry];
1369                                 vp->rx_skbuff[entry] = NULL;
1370                                 temp = skb_put(skb, pkt_len);
1371                                 /* Remove this checking code for final release. */
1372                                 if (isa_bus_to_virt(vp->rx_ring[entry].addr) != temp)
1373                                         pr_warn("%s: Warning -- the skbuff addresses do not match in boomerang_rx: %p vs. %p / %p\n",
1374                                                 dev->name,
1375                                                 isa_bus_to_virt(vp->rx_ring[entry].addr),
1376                                                 skb->head, temp);
1377                                 rx_nocopy++;
1378                         }
1379                         skb->protocol = eth_type_trans(skb, dev);
1380                         netif_rx(skb);
1381                         dev->stats.rx_packets++;
1382                 }
1383                 entry = (++vp->cur_rx) % RX_RING_SIZE;
1384         }
1385         /* Refill the Rx ring buffers. */
1386         for (; vp->cur_rx - vp->dirty_rx > 0; vp->dirty_rx++) {
1387                 struct sk_buff *skb;
1388                 entry = vp->dirty_rx % RX_RING_SIZE;
1389                 if (vp->rx_skbuff[entry] == NULL) {
1390                         skb = netdev_alloc_skb(dev, PKT_BUF_SZ);
1391                         if (skb == NULL)
1392                                 break;  /* Bad news!  */
1393                         skb_reserve(skb, 2);    /* Align IP on 16 byte boundaries */
1394                         vp->rx_ring[entry].addr = isa_virt_to_bus(skb->data);
1395                         vp->rx_skbuff[entry] = skb;
1396                 }
1397                 vp->rx_ring[entry].status = 0;  /* Clear complete bit. */
1398         }
1399         return 0;
1400 }
1401
1402 static int corkscrew_close(struct net_device *dev)
1403 {
1404         struct corkscrew_private *vp = netdev_priv(dev);
1405         int ioaddr = dev->base_addr;
1406         int i;
1407
1408         netif_stop_queue(dev);
1409
1410         if (corkscrew_debug > 1) {
1411                 pr_debug("%s: corkscrew_close() status %4.4x, Tx status %2.2x.\n",
1412                      dev->name, inw(ioaddr + EL3_STATUS),
1413                      inb(ioaddr + TxStatus));
1414                 pr_debug("%s: corkscrew close stats: rx_nocopy %d rx_copy %d tx_queued %d.\n",
1415                         dev->name, rx_nocopy, rx_copy, queued_packet);
1416         }
1417
1418         del_timer_sync(&vp->timer);
1419
1420         /* Turn off statistics ASAP.  We update lp->stats below. */
1421         outw(StatsDisable, ioaddr + EL3_CMD);
1422
1423         /* Disable the receiver and transmitter. */
1424         outw(RxDisable, ioaddr + EL3_CMD);
1425         outw(TxDisable, ioaddr + EL3_CMD);
1426
1427         if (dev->if_port == XCVR_10base2)
1428                 /* Turn off thinnet power.  Green! */
1429                 outw(StopCoax, ioaddr + EL3_CMD);
1430
1431         free_irq(dev->irq, dev);
1432
1433         outw(SetIntrEnb | 0x0000, ioaddr + EL3_CMD);
1434
1435         update_stats(ioaddr, dev);
1436         if (vp->full_bus_master_rx) {   /* Free Boomerang bus master Rx buffers. */
1437                 outl(0, ioaddr + UpListPtr);
1438                 for (i = 0; i < RX_RING_SIZE; i++)
1439                         if (vp->rx_skbuff[i]) {
1440                                 dev_kfree_skb(vp->rx_skbuff[i]);
1441                                 vp->rx_skbuff[i] = NULL;
1442                         }
1443         }
1444         if (vp->full_bus_master_tx) {   /* Free Boomerang bus master Tx buffers. */
1445                 outl(0, ioaddr + DownListPtr);
1446                 for (i = 0; i < TX_RING_SIZE; i++)
1447                         if (vp->tx_skbuff[i]) {
1448                                 dev_kfree_skb(vp->tx_skbuff[i]);
1449                                 vp->tx_skbuff[i] = NULL;
1450                         }
1451         }
1452
1453         return 0;
1454 }
1455
1456 static struct net_device_stats *corkscrew_get_stats(struct net_device *dev)
1457 {
1458         struct corkscrew_private *vp = netdev_priv(dev);
1459         unsigned long flags;
1460
1461         if (netif_running(dev)) {
1462                 spin_lock_irqsave(&vp->lock, flags);
1463                 update_stats(dev->base_addr, dev);
1464                 spin_unlock_irqrestore(&vp->lock, flags);
1465         }
1466         return &dev->stats;
1467 }
1468
1469 /*  Update statistics.
1470         Unlike with the EL3 we need not worry about interrupts changing
1471         the window setting from underneath us, but we must still guard
1472         against a race condition with a StatsUpdate interrupt updating the
1473         table.  This is done by checking that the ASM (!) code generated uses
1474         atomic updates with '+='.
1475         */
1476 static void update_stats(int ioaddr, struct net_device *dev)
1477 {
1478         /* Unlike the 3c5x9 we need not turn off stats updates while reading. */
1479         /* Switch to the stats window, and read everything. */
1480         EL3WINDOW(6);
1481         dev->stats.tx_carrier_errors += inb(ioaddr + 0);
1482         dev->stats.tx_heartbeat_errors += inb(ioaddr + 1);
1483         /* Multiple collisions. */ inb(ioaddr + 2);
1484         dev->stats.collisions += inb(ioaddr + 3);
1485         dev->stats.tx_window_errors += inb(ioaddr + 4);
1486         dev->stats.rx_fifo_errors += inb(ioaddr + 5);
1487         dev->stats.tx_packets += inb(ioaddr + 6);
1488         dev->stats.tx_packets += (inb(ioaddr + 9) & 0x30) << 4;
1489                                                 /* Rx packets   */ inb(ioaddr + 7);
1490                                                 /* Must read to clear */
1491         /* Tx deferrals */ inb(ioaddr + 8);
1492         /* Don't bother with register 9, an extension of registers 6&7.
1493            If we do use the 6&7 values the atomic update assumption above
1494            is invalid. */
1495         inw(ioaddr + 10);       /* Total Rx and Tx octets. */
1496         inw(ioaddr + 12);
1497         /* New: On the Vortex we must also clear the BadSSD counter. */
1498         EL3WINDOW(4);
1499         inb(ioaddr + 12);
1500
1501         /* We change back to window 7 (not 1) with the Vortex. */
1502         EL3WINDOW(7);
1503 }
1504
1505 /* This new version of set_rx_mode() supports v1.4 kernels.
1506    The Vortex chip has no documented multicast filter, so the only
1507    multicast setting is to receive all multicast frames.  At least
1508    the chip has a very clean way to set the mode, unlike many others. */
1509 static void set_rx_mode(struct net_device *dev)
1510 {
1511         int ioaddr = dev->base_addr;
1512         unsigned short new_mode;
1513
1514         if (dev->flags & IFF_PROMISC) {
1515                 if (corkscrew_debug > 3)
1516                         pr_debug("%s: Setting promiscuous mode.\n",
1517                                dev->name);
1518                 new_mode = SetRxFilter | RxStation | RxMulticast | RxBroadcast | RxProm;
1519         } else if (!netdev_mc_empty(dev) || dev->flags & IFF_ALLMULTI) {
1520                 new_mode = SetRxFilter | RxStation | RxMulticast | RxBroadcast;
1521         } else
1522                 new_mode = SetRxFilter | RxStation | RxBroadcast;
1523
1524         outw(new_mode, ioaddr + EL3_CMD);
1525 }
1526
1527 static void netdev_get_drvinfo(struct net_device *dev,
1528                                struct ethtool_drvinfo *info)
1529 {
1530         strscpy(info->driver, DRV_NAME, sizeof(info->driver));
1531         snprintf(info->bus_info, sizeof(info->bus_info), "ISA 0x%lx",
1532                  dev->base_addr);
1533 }
1534
1535 static u32 netdev_get_msglevel(struct net_device *dev)
1536 {
1537         return corkscrew_debug;
1538 }
1539
1540 static void netdev_set_msglevel(struct net_device *dev, u32 level)
1541 {
1542         corkscrew_debug = level;
1543 }
1544
1545 static const struct ethtool_ops netdev_ethtool_ops = {
1546         .get_drvinfo            = netdev_get_drvinfo,
1547         .get_msglevel           = netdev_get_msglevel,
1548         .set_msglevel           = netdev_set_msglevel,
1549 };
1550
1551
1552 #ifdef MODULE
1553 void cleanup_module(void)
1554 {
1555         while (!list_empty(&root_corkscrew_dev)) {
1556                 struct net_device *dev;
1557                 struct corkscrew_private *vp;
1558
1559                 vp = list_entry(root_corkscrew_dev.next,
1560                                 struct corkscrew_private, list);
1561                 dev = vp->our_dev;
1562                 unregister_netdev(dev);
1563                 cleanup_card(dev);
1564                 free_netdev(dev);
1565         }
1566 }
1567 #endif                          /* MODULE */