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