git.oblomov.eu Git - linux-2.6/blob - drivers/net/3c515.c

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