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         SET_MODULE_OWNER(dev);
 505
 506 #ifdef __ISAPNP__
 507         if(nopnp == 1)
 508                 goto no_pnp;
 509         for(i=0; corkscrew_isapnp_adapters[i].vendor != 0; i++) {
 510                 struct pnp_dev *idev = NULL;
 511                 int irq;
 512                 while((idev = pnp_find_dev(NULL,
 513                                            corkscrew_isapnp_adapters[i].vendor,
 514                                            corkscrew_isapnp_adapters[i].function,
 515                                            idev))) {
 516
 517                         if (pnp_device_attach(idev) < 0)
 518                                 continue;
 519                         if (pnp_activate_dev(idev) < 0) {
 520                                 printk("pnp activate failed (out of resources?)\n");
 521                                 pnp_device_detach(idev);
 522                                 continue;
 523                         }
 524                         if (!pnp_port_valid(idev, 0) || !pnp_irq_valid(idev, 0)) {
 525                                 pnp_device_detach(idev);
 526                                 continue;
 527                         }
 528                         ioaddr = pnp_port_start(idev, 0);
 529                         irq = pnp_irq(idev, 0);
 530                         if (!check_device(ioaddr)) {
 531                                 pnp_device_detach(idev);
 532                                 continue;
 533                         }
 534                         if(corkscrew_debug)
 535                                 printk ("ISAPNP reports %s at i/o 0x%x, irq %d\n",
 536                                         (char*) corkscrew_isapnp_adapters[i].driver_data, ioaddr, irq);
 537                         printk(KERN_INFO "3c515 Resource configuration register %#4.4x, DCR %4.4x.\n",
 538                                 inl(ioaddr + 0x2002), inw(ioaddr + 0x2000));
 539                         /* irq = inw(ioaddr + 0x2002) & 15; */ /* Use the irq from isapnp */
 540                         SET_NETDEV_DEV(dev, &idev->dev);
 541                         pnp_cards++;
 542                         err = corkscrew_setup(dev, ioaddr, idev, cards_found++);
 543                         if (!err)
 544                                 return dev;
 545                         cleanup_card(dev);
 546                 }
 547         }
 548 no_pnp:
 549 #endif /* __ISAPNP__ */
 550
 551         /* Check all locations on the ISA bus -- evil! */
 552         for (ioaddr = 0x100; ioaddr < 0x400; ioaddr += 0x20) {
 553                 if (!check_device(ioaddr))
 554                         continue;
 555
 556                 printk(KERN_INFO "3c515 Resource configuration register %#4.4x, DCR %4.4x.\n",
 557                      inl(ioaddr + 0x2002), inw(ioaddr + 0x2000));
 558                 err = corkscrew_setup(dev, ioaddr, NULL, cards_found++);
 559                 if (!err)
 560                         return dev;
 561                 cleanup_card(dev);
 562         }
 563         free_netdev(dev);
 564         return NULL;
 565 }
 566
 567 static int corkscrew_setup(struct net_device *dev, int ioaddr,
 568                             struct pnp_dev *idev, int card_number)
 569 {
 570         struct corkscrew_private *vp = netdev_priv(dev);
 571         unsigned int eeprom[0x40], checksum = 0;        /* EEPROM contents */
 572         int i;
 573         int irq;
 574
 575         if (idev) {
 576                 irq = pnp_irq(idev, 0);
 577                 vp->dev = &idev->dev;
 578         } else {
 579                 irq = inw(ioaddr + 0x2002) & 15;
 580         }
 581
 582         dev->base_addr = ioaddr;
 583         dev->irq = irq;
 584         dev->dma = inw(ioaddr + 0x2000) & 7;
 585         vp->product_name = "3c515";
 586         vp->options = dev->mem_start;
 587         vp->our_dev = dev;
 588
 589         if (!vp->options) {
 590                  if (card_number >= MAX_UNITS)
 591                         vp->options = -1;
 592                 else
 593                         vp->options = options[card_number];
 594         }
 595
 596         if (vp->options >= 0) {
 597                 vp->media_override = vp->options & 7;
 598                 if (vp->media_override == 2)
 599                         vp->media_override = 0;
 600                 vp->full_duplex = (vp->options & 8) ? 1 : 0;
 601                 vp->bus_master = (vp->options & 16) ? 1 : 0;
 602         } else {
 603                 vp->media_override = 7;
 604                 vp->full_duplex = 0;
 605                 vp->bus_master = 0;
 606         }
 607 #ifdef MODULE
 608         list_add(&vp->list, &root_corkscrew_dev);
 609 #endif
 610
 611         printk(KERN_INFO "%s: 3Com %s at %#3x,", dev->name, vp->product_name, ioaddr);
 612
 613         spin_lock_init(&vp->lock);
 614
 615         /* Read the station address from the EEPROM. */
 616         EL3WINDOW(0);
 617         for (i = 0; i < 0x18; i++) {
 618                 short *phys_addr = (short *) dev->dev_addr;
 619                 int timer;
 620                 outw(EEPROM_Read + i, ioaddr + Wn0EepromCmd);
 621                 /* Pause for at least 162 us. for the read to take place. */
 622                 for (timer = 4; timer >= 0; timer--) {
 623                         udelay(162);
 624                         if ((inw(ioaddr + Wn0EepromCmd) & 0x0200) == 0)
 625                                 break;
 626                 }
 627                 eeprom[i] = inw(ioaddr + Wn0EepromData);
 628                 checksum ^= eeprom[i];
 629                 if (i < 3)
 630                         phys_addr[i] = htons(eeprom[i]);
 631         }
 632         checksum = (checksum ^ (checksum >> 8)) & 0xff;
 633         if (checksum != 0x00)
 634                 printk(" ***INVALID CHECKSUM %4.4x*** ", checksum);
 635         for (i = 0; i < 6; i++)
 636                 printk("%c%2.2x", i ? ':' : ' ', dev->dev_addr[i]);
 637         if (eeprom[16] == 0x11c7) {     /* Corkscrew */
 638                 if (request_dma(dev->dma, "3c515")) {
 639                         printk(", DMA %d allocation failed", dev->dma);
 640                         dev->dma = 0;
 641                 } else
 642                         printk(", DMA %d", dev->dma);
 643         }
 644         printk(", IRQ %d\n", dev->irq);
 645         /* Tell them about an invalid IRQ. */
 646         if (corkscrew_debug && (dev->irq <= 0 || dev->irq > 15))
 647                 printk(KERN_WARNING " *** Warning: this IRQ is unlikely to work! ***\n");
 648
 649         {
 650                 char *ram_split[] = { "5:3", "3:1", "1:1", "3:5" };
 651                 union wn3_config config;
 652                 EL3WINDOW(3);
 653                 vp->available_media = inw(ioaddr + Wn3_Options);
 654                 config.i = inl(ioaddr + Wn3_Config);
 655                 if (corkscrew_debug > 1)
 656                         printk(KERN_INFO "  Internal config register is %4.4x, transceivers %#x.\n",
 657                                 config.i, inw(ioaddr + Wn3_Options));
 658                 printk(KERN_INFO "  %dK %s-wide RAM %s Rx:Tx split, %s%s interface.\n",
 659                         8 << config.u.ram_size,
 660                         config.u.ram_width ? "word" : "byte",
 661                         ram_split[config.u.ram_split],
 662                         config.u.autoselect ? "autoselect/" : "",
 663                         media_tbl[config.u.xcvr].name);
 664                 dev->if_port = config.u.xcvr;
 665                 vp->default_media = config.u.xcvr;
 666                 vp->autoselect = config.u.autoselect;
 667         }
 668         if (vp->media_override != 7) {
 669                 printk(KERN_INFO "  Media override to transceiver type %d (%s).\n",
 670                        vp->media_override,
 671                        media_tbl[vp->media_override].name);
 672                 dev->if_port = vp->media_override;
 673         }
 674
 675         vp->capabilities = eeprom[16];
 676         vp->full_bus_master_tx = (vp->capabilities & 0x20) ? 1 : 0;
 677         /* Rx is broken at 10mbps, so we always disable it. */
 678         /* vp->full_bus_master_rx = 0; */
 679         vp->full_bus_master_rx = (vp->capabilities & 0x20) ? 1 : 0;
 680
 681         /* The 3c51x-specific entries in the device structure. */
 682         dev->open = &corkscrew_open;
 683         dev->hard_start_xmit = &corkscrew_start_xmit;
 684         dev->tx_timeout = &corkscrew_timeout;
 685         dev->watchdog_timeo = (400 * HZ) / 1000;
 686         dev->stop = &corkscrew_close;
 687         dev->get_stats = &corkscrew_get_stats;
 688         dev->set_multicast_list = &set_rx_mode;
 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         union wn3_config config;
 700         int i;
 701
 702         /* Before initializing select the active media port. */
 703         EL3WINDOW(3);
 704         if (vp->full_duplex)
 705                 outb(0x20, ioaddr + Wn3_MAC_Ctrl);      /* Set the full-duplex bit. */
 706         config.i = inl(ioaddr + Wn3_Config);
 707
 708         if (vp->media_override != 7) {
 709                 if (corkscrew_debug > 1)
 710                         printk(KERN_INFO "%s: Media override to transceiver %d (%s).\n",
 711                                 dev->name, vp->media_override,
 712                                 media_tbl[vp->media_override].name);
 713                 dev->if_port = vp->media_override;
 714         } else if (vp->autoselect) {
 715                 /* Find first available media type, starting with 100baseTx. */
 716                 dev->if_port = 4;
 717                 while (!(vp->available_media & media_tbl[dev->if_port].mask))
 718                         dev->if_port = media_tbl[dev->if_port].next;
 719
 720                 if (corkscrew_debug > 1)
 721                         printk("%s: Initial media type %s.\n",
 722                                dev->name, media_tbl[dev->if_port].name);
 723
 724                 init_timer(&vp->timer);
 725                 vp->timer.expires = jiffies + media_tbl[dev->if_port].wait;
 726                 vp->timer.data = (unsigned long) dev;
 727                 vp->timer.function = &corkscrew_timer;  /* timer handler */
 728                 add_timer(&vp->timer);
 729         } else
 730                 dev->if_port = vp->default_media;
 731
 732         config.u.xcvr = dev->if_port;
 733         outl(config.i, ioaddr + Wn3_Config);
 734
 735         if (corkscrew_debug > 1) {
 736                 printk("%s: corkscrew_open() InternalConfig %8.8x.\n",
 737                        dev->name, config.i);
 738         }
 739
 740         outw(TxReset, ioaddr + EL3_CMD);
 741         for (i = 20; i >= 0; i--)
 742                 if (!(inw(ioaddr + EL3_STATUS) & CmdInProgress))
 743                         break;
 744
 745         outw(RxReset, ioaddr + EL3_CMD);
 746         /* Wait a few ticks for the RxReset command to complete. */
 747         for (i = 20; i >= 0; i--)
 748                 if (!(inw(ioaddr + EL3_STATUS) & CmdInProgress))
 749                         break;
 750
 751         outw(SetStatusEnb | 0x00, ioaddr + EL3_CMD);
 752
 753         /* Use the now-standard shared IRQ implementation. */
 754         if (vp->capabilities == 0x11c7) {
 755                 /* Corkscrew: Cannot share ISA resources. */
 756                 if (dev->irq == 0
 757                     || dev->dma == 0
 758                     || request_irq(dev->irq, &corkscrew_interrupt, 0,
 759                                    vp->product_name, dev)) return -EAGAIN;
 760                 enable_dma(dev->dma);
 761                 set_dma_mode(dev->dma, DMA_MODE_CASCADE);
 762         } else if (request_irq(dev->irq, &corkscrew_interrupt, IRQF_SHARED,
 763                                vp->product_name, dev)) {
 764                 return -EAGAIN;
 765         }
 766
 767         if (corkscrew_debug > 1) {
 768                 EL3WINDOW(4);
 769                 printk("%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                         printk("%s:  Filling in the Rx ring.\n",
 807                                dev->name);
 808                 for (i = 0; i < RX_RING_SIZE; i++) {
 809                         struct sk_buff *skb;
 810                         if (i < (RX_RING_SIZE - 1))
 811                                 vp->rx_ring[i].next =
 812                                     isa_virt_to_bus(&vp->rx_ring[i + 1]);
 813                         else
 814                                 vp->rx_ring[i].next = 0;
 815                         vp->rx_ring[i].status = 0;      /* Clear complete bit. */
 816                         vp->rx_ring[i].length = PKT_BUF_SZ | 0x80000000;
 817                         skb = dev_alloc_skb(PKT_BUF_SZ);
 818                         vp->rx_skbuff[i] = skb;
 819                         if (skb == NULL)
 820                                 break;  /* Bad news!  */
 821                         skb->dev = dev; /* Mark as being used by this device. */
 822                         skb_reserve(skb, 2);    /* Align IP on 16 byte boundaries */
 823                         vp->rx_ring[i].addr = isa_virt_to_bus(skb->data);
 824                 }
 825                 vp->rx_ring[i - 1].next = 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(unsigned long data)
 860 {
 861 #ifdef AUTOMEDIA
 862         struct net_device *dev = (struct net_device *) data;
 863         struct corkscrew_private *vp = netdev_priv(dev);
 864         int ioaddr = dev->base_addr;
 865         unsigned long flags;
 866         int ok = 0;
 867
 868         if (corkscrew_debug > 1)
 869                 printk("%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                                         printk("%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                                 printk("%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                                 printk("%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                         union wn3_config 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                                         printk("%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                                         printk("%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.i = inl(ioaddr + Wn3_Config);
 934                         config.u.xcvr = dev->if_port;
 935                         outl(config.i, 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                 printk("%s: Media selection timer finished, %s.\n",
 946                        dev->name, media_tbl[dev->if_port].name);
 947
 948 #endif                          /* AUTOMEDIA */
 949         return;
 950 }
 951
 952 static void corkscrew_timeout(struct net_device *dev)
 953 {
 954         int i;
 955         struct corkscrew_private *vp = netdev_priv(dev);
 956         int ioaddr = dev->base_addr;
 957
 958         printk(KERN_WARNING
 959                "%s: transmit timed out, tx_status %2.2x status %4.4x.\n",
 960                dev->name, inb(ioaddr + TxStatus),
 961                inw(ioaddr + EL3_STATUS));
 962         /* Slight code bloat to be user friendly. */
 963         if ((inb(ioaddr + TxStatus) & 0x88) == 0x88)
 964                 printk(KERN_WARNING
 965                        "%s: Transmitter encountered 16 collisions -- network"
 966                        " network cable problem?\n", dev->name);
 967 #ifndef final_version
 968         printk("  Flags; bus-master %d, full %d; dirty %d current %d.\n",
 969                vp->full_bus_master_tx, vp->tx_full, vp->dirty_tx,
 970                vp->cur_tx);
 971         printk("  Down list %8.8x vs. %p.\n", inl(ioaddr + DownListPtr),
 972                &vp->tx_ring[0]);
 973         for (i = 0; i < TX_RING_SIZE; i++) {
 974                 printk("  %d: %p  length %8.8x status %8.8x\n", i,
 975                        &vp->tx_ring[i],
 976                        vp->tx_ring[i].length, vp->tx_ring[i].status);
 977         }
 978 #endif
 979         /* Issue TX_RESET and TX_START commands. */
 980         outw(TxReset, ioaddr + EL3_CMD);
 981         for (i = 20; i >= 0; i--)
 982                 if (!(inw(ioaddr + EL3_STATUS) & CmdInProgress))
 983                         break;
 984         outw(TxEnable, ioaddr + EL3_CMD);
 985         dev->trans_start = jiffies;
 986         vp->stats.tx_errors++;
 987         vp->stats.tx_dropped++;
 988         netif_wake_queue(dev);
 989 }
 990
 991 static int corkscrew_start_xmit(struct sk_buff *skb,
 992                                 struct net_device *dev)
 993 {
 994         struct corkscrew_private *vp = netdev_priv(dev);
 995         int ioaddr = dev->base_addr;
 996
 997         /* Block a timer-based transmit from overlapping. */
 998
 999         netif_stop_queue(dev);
1000
1001         if (vp->full_bus_master_tx) {   /* BOOMERANG bus-master */
1002                 /* Calculate the next Tx descriptor entry. */
1003                 int entry = vp->cur_tx % TX_RING_SIZE;
1004                 struct boom_tx_desc *prev_entry;
1005                 unsigned long flags;
1006                 int i;
1007
1008                 if (vp->tx_full)        /* No room to transmit with */
1009                         return 1;
1010                 if (vp->cur_tx != 0)
1011                         prev_entry = &vp->tx_ring[(vp->cur_tx - 1) % TX_RING_SIZE];
1012                 else
1013                         prev_entry = NULL;
1014                 if (corkscrew_debug > 3)
1015                         printk("%s: Trying to send a packet, Tx index %d.\n",
1016                                 dev->name, vp->cur_tx);
1017                 /* vp->tx_full = 1; */
1018                 vp->tx_skbuff[entry] = skb;
1019                 vp->tx_ring[entry].next = 0;
1020                 vp->tx_ring[entry].addr = isa_virt_to_bus(skb->data);
1021                 vp->tx_ring[entry].length = skb->len | 0x80000000;
1022                 vp->tx_ring[entry].status = skb->len | 0x80000000;
1023
1024                 spin_lock_irqsave(&vp->lock, flags);
1025                 outw(DownStall, ioaddr + EL3_CMD);
1026                 /* Wait for the stall to complete. */
1027                 for (i = 20; i >= 0; i--)
1028                         if ((inw(ioaddr + EL3_STATUS) & CmdInProgress) == 0)
1029                                 break;
1030                 if (prev_entry)
1031                         prev_entry->next = isa_virt_to_bus(&vp->tx_ring[entry]);
1032                 if (inl(ioaddr + DownListPtr) == 0) {
1033                         outl(isa_virt_to_bus(&vp->tx_ring[entry]),
1034                              ioaddr + DownListPtr);
1035                         queued_packet++;
1036                 }
1037                 outw(DownUnstall, ioaddr + EL3_CMD);
1038                 spin_unlock_irqrestore(&vp->lock, flags);
1039
1040                 vp->cur_tx++;
1041                 if (vp->cur_tx - vp->dirty_tx > TX_RING_SIZE - 1)
1042                         vp->tx_full = 1;
1043                 else {          /* Clear previous interrupt enable. */
1044                         if (prev_entry)
1045                                 prev_entry->status &= ~0x80000000;
1046                         netif_wake_queue(dev);
1047                 }
1048                 dev->trans_start = jiffies;
1049                 return 0;
1050         }
1051         /* Put out the doubleword header... */
1052         outl(skb->len, ioaddr + TX_FIFO);
1053         vp->stats.tx_bytes += skb->len;
1054 #ifdef VORTEX_BUS_MASTER
1055         if (vp->bus_master) {
1056                 /* Set the bus-master controller to transfer the packet. */
1057                 outl((int) (skb->data), ioaddr + Wn7_MasterAddr);
1058                 outw((skb->len + 3) & ~3, ioaddr + Wn7_MasterLen);
1059                 vp->tx_skb = skb;
1060                 outw(StartDMADown, ioaddr + EL3_CMD);
1061                 /* queue will be woken at the DMADone interrupt. */
1062         } else {
1063                 /* ... and the packet rounded to a doubleword. */
1064                 outsl(ioaddr + TX_FIFO, skb->data, (skb->len + 3) >> 2);
1065                 dev_kfree_skb(skb);
1066                 if (inw(ioaddr + TxFree) > 1536) {
1067                         netif_wake_queue(dev);
1068                 } else
1069                         /* Interrupt us when the FIFO has room for max-sized packet. */
1070                         outw(SetTxThreshold + (1536 >> 2),
1071                              ioaddr + EL3_CMD);
1072         }
1073 #else
1074         /* ... and the packet rounded to a doubleword. */
1075         outsl(ioaddr + TX_FIFO, skb->data, (skb->len + 3) >> 2);
1076         dev_kfree_skb(skb);
1077         if (inw(ioaddr + TxFree) > 1536) {
1078                 netif_wake_queue(dev);
1079         } else
1080                 /* Interrupt us when the FIFO has room for max-sized packet. */
1081                 outw(SetTxThreshold + (1536 >> 2), ioaddr + EL3_CMD);
1082 #endif                          /* bus master */
1083
1084         dev->trans_start = jiffies;
1085
1086         /* Clear the Tx status stack. */
1087         {
1088                 short tx_status;
1089                 int i = 4;
1090
1091                 while (--i > 0 && (tx_status = inb(ioaddr + TxStatus)) > 0) {
1092                         if (tx_status & 0x3C) { /* A Tx-disabling error occurred.  */
1093                                 if (corkscrew_debug > 2)
1094                                         printk("%s: Tx error, status %2.2x.\n",
1095                                                 dev->name, tx_status);
1096                                 if (tx_status & 0x04)
1097                                         vp->stats.tx_fifo_errors++;
1098                                 if (tx_status & 0x38)
1099                                         vp->stats.tx_aborted_errors++;
1100                                 if (tx_status & 0x30) {
1101                                         int j;
1102                                         outw(TxReset, ioaddr + EL3_CMD);
1103                                         for (j = 20; j >= 0; j--)
1104                                                 if (!(inw(ioaddr + EL3_STATUS) & CmdInProgress))
1105                                                         break;
1106                                 }
1107                                 outw(TxEnable, ioaddr + EL3_CMD);
1108                         }
1109                         outb(0x00, ioaddr + TxStatus);  /* Pop the status stack. */
1110                 }
1111         }
1112         return 0;
1113 }
1114
1115 /* The interrupt handler does all of the Rx thread work and cleans up
1116    after the Tx thread. */
1117
1118 static irqreturn_t corkscrew_interrupt(int irq, void *dev_id)
1119 {
1120         /* Use the now-standard shared IRQ implementation. */
1121         struct net_device *dev = dev_id;
1122         struct corkscrew_private *lp = netdev_priv(dev);
1123         int ioaddr, status;
1124         int latency;
1125         int i = max_interrupt_work;
1126
1127         ioaddr = dev->base_addr;
1128         latency = inb(ioaddr + Timer);
1129
1130         spin_lock(&lp->lock);
1131
1132         status = inw(ioaddr + EL3_STATUS);
1133
1134         if (corkscrew_debug > 4)
1135                 printk("%s: interrupt, status %4.4x, timer %d.\n",
1136                         dev->name, status, latency);
1137         if ((status & 0xE000) != 0xE000) {
1138                 static int donedidthis;
1139                 /* Some interrupt controllers store a bogus interrupt from boot-time.
1140                    Ignore a single early interrupt, but don't hang the machine for
1141                    other interrupt problems. */
1142                 if (donedidthis++ > 100) {
1143                         printk(KERN_ERR "%s: Bogus interrupt, bailing. Status %4.4x, start=%d.\n",
1144                                    dev->name, status, netif_running(dev));
1145                         free_irq(dev->irq, dev);
1146                         dev->irq = -1;
1147                 }
1148         }
1149
1150         do {
1151                 if (corkscrew_debug > 5)
1152                         printk("%s: In interrupt loop, status %4.4x.\n",
1153                                dev->name, status);
1154                 if (status & RxComplete)
1155                         corkscrew_rx(dev);
1156
1157                 if (status & TxAvailable) {
1158                         if (corkscrew_debug > 5)
1159                                 printk("        TX room bit was handled.\n");
1160                         /* There's room in the FIFO for a full-sized packet. */
1161                         outw(AckIntr | TxAvailable, ioaddr + EL3_CMD);
1162                         netif_wake_queue(dev);
1163                 }
1164                 if (status & DownComplete) {
1165                         unsigned int dirty_tx = lp->dirty_tx;
1166
1167                         while (lp->cur_tx - dirty_tx > 0) {
1168                                 int entry = dirty_tx % TX_RING_SIZE;
1169                                 if (inl(ioaddr + DownListPtr) == isa_virt_to_bus(&lp->tx_ring[entry]))
1170                                         break;  /* It still hasn't been processed. */
1171                                 if (lp->tx_skbuff[entry]) {
1172                                         dev_kfree_skb_irq(lp->tx_skbuff[entry]);
1173                                         lp->tx_skbuff[entry] = NULL;
1174                                 }
1175                                 dirty_tx++;
1176                         }
1177                         lp->dirty_tx = dirty_tx;
1178                         outw(AckIntr | DownComplete, ioaddr + EL3_CMD);
1179                         if (lp->tx_full && (lp->cur_tx - dirty_tx <= TX_RING_SIZE - 1)) {
1180                                 lp->tx_full = 0;
1181                                 netif_wake_queue(dev);
1182                         }
1183                 }
1184 #ifdef VORTEX_BUS_MASTER
1185                 if (status & DMADone) {
1186                         outw(0x1000, ioaddr + Wn7_MasterStatus);        /* Ack the event. */
1187                         dev_kfree_skb_irq(lp->tx_skb);  /* Release the transferred buffer */
1188                         netif_wake_queue(dev);
1189                 }
1190 #endif
1191                 if (status & UpComplete) {
1192                         boomerang_rx(dev);
1193                         outw(AckIntr | UpComplete, ioaddr + EL3_CMD);
1194                 }
1195                 if (status & (AdapterFailure | RxEarly | StatsFull)) {
1196                         /* Handle all uncommon interrupts at once. */
1197                         if (status & RxEarly) { /* Rx early is unused. */
1198                                 corkscrew_rx(dev);
1199                                 outw(AckIntr | RxEarly, ioaddr + EL3_CMD);
1200                         }
1201                         if (status & StatsFull) {       /* Empty statistics. */
1202                                 static int DoneDidThat;
1203                                 if (corkscrew_debug > 4)
1204                                         printk("%s: Updating stats.\n", dev->name);
1205                                 update_stats(ioaddr, dev);
1206                                 /* DEBUG HACK: Disable statistics as an interrupt source. */
1207                                 /* This occurs when we have the wrong media type! */
1208                                 if (DoneDidThat == 0 && inw(ioaddr + EL3_STATUS) & StatsFull) {
1209                                         int win, reg;
1210                                         printk("%s: Updating stats failed, disabling stats as an"
1211                                              " interrupt source.\n", dev->name);
1212                                         for (win = 0; win < 8; win++) {
1213                                                 EL3WINDOW(win);
1214                                                 printk("\n Vortex window %d:", win);
1215                                                 for (reg = 0; reg < 16; reg++)
1216                                                         printk(" %2.2x", inb(ioaddr + reg));
1217                                         }
1218                                         EL3WINDOW(7);
1219                                         outw(SetIntrEnb | TxAvailable |
1220                                              RxComplete | AdapterFailure |
1221                                              UpComplete | DownComplete |
1222                                              TxComplete, ioaddr + EL3_CMD);
1223                                         DoneDidThat++;
1224                                 }
1225                         }
1226                         if (status & AdapterFailure) {
1227                                 /* Adapter failure requires Rx reset and reinit. */
1228                                 outw(RxReset, ioaddr + EL3_CMD);
1229                                 /* Set the Rx filter to the current state. */
1230                                 set_rx_mode(dev);
1231                                 outw(RxEnable, ioaddr + EL3_CMD);       /* Re-enable the receiver. */
1232                                 outw(AckIntr | AdapterFailure,
1233                                      ioaddr + EL3_CMD);
1234                         }
1235                 }
1236
1237                 if (--i < 0) {
1238                         printk(KERN_ERR "%s: Too much work in interrupt, status %4.4x.  "
1239                              "Disabling functions (%4.4x).\n", dev->name,
1240                              status, SetStatusEnb | ((~status) & 0x7FE));
1241                         /* Disable all pending interrupts. */
1242                         outw(SetStatusEnb | ((~status) & 0x7FE), ioaddr + EL3_CMD);
1243                         outw(AckIntr | 0x7FF, ioaddr + EL3_CMD);
1244                         break;
1245                 }
1246                 /* Acknowledge the IRQ. */
1247                 outw(AckIntr | IntReq | IntLatch, ioaddr + EL3_CMD);
1248
1249         } while ((status = inw(ioaddr + EL3_STATUS)) & (IntLatch | RxComplete));
1250
1251         spin_unlock(&lp->lock);
1252
1253         if (corkscrew_debug > 4)
1254                 printk("%s: exiting interrupt, status %4.4x.\n", dev->name, status);
1255         return IRQ_HANDLED;
1256 }
1257
1258 static int corkscrew_rx(struct net_device *dev)
1259 {
1260         struct corkscrew_private *vp = netdev_priv(dev);
1261         int ioaddr = dev->base_addr;
1262         int i;
1263         short rx_status;
1264
1265         if (corkscrew_debug > 5)
1266                 printk("   In rx_packet(), status %4.4x, rx_status %4.4x.\n",
1267                      inw(ioaddr + EL3_STATUS), inw(ioaddr + RxStatus));
1268         while ((rx_status = inw(ioaddr + RxStatus)) > 0) {
1269                 if (rx_status & 0x4000) {       /* Error, update stats. */
1270                         unsigned char rx_error = inb(ioaddr + RxErrors);
1271                         if (corkscrew_debug > 2)
1272                                 printk(" Rx error: status %2.2x.\n",
1273                                        rx_error);
1274                         vp->stats.rx_errors++;
1275                         if (rx_error & 0x01)
1276                                 vp->stats.rx_over_errors++;
1277                         if (rx_error & 0x02)
1278                                 vp->stats.rx_length_errors++;
1279                         if (rx_error & 0x04)
1280                                 vp->stats.rx_frame_errors++;
1281                         if (rx_error & 0x08)
1282                                 vp->stats.rx_crc_errors++;
1283                         if (rx_error & 0x10)
1284                                 vp->stats.rx_length_errors++;
1285                 } else {
1286                         /* The packet length: up to 4.5K!. */
1287                         short pkt_len = rx_status & 0x1fff;
1288                         struct sk_buff *skb;
1289
1290                         skb = dev_alloc_skb(pkt_len + 5 + 2);
1291                         if (corkscrew_debug > 4)
1292                                 printk("Receiving packet size %d status %4.4x.\n",
1293                                      pkt_len, rx_status);
1294                         if (skb != NULL) {
1295                                 skb->dev = dev;
1296                                 skb_reserve(skb, 2);    /* Align IP on 16 byte boundaries */
1297                                 /* 'skb_put()' points to the start of sk_buff data area. */
1298                                 insl(ioaddr + RX_FIFO,
1299                                      skb_put(skb, pkt_len),
1300                                      (pkt_len + 3) >> 2);
1301                                 outw(RxDiscard, ioaddr + EL3_CMD);      /* Pop top Rx packet. */
1302                                 skb->protocol = eth_type_trans(skb, dev);
1303                                 netif_rx(skb);
1304                                 dev->last_rx = jiffies;
1305                                 vp->stats.rx_packets++;
1306                                 vp->stats.rx_bytes += pkt_len;
1307                                 /* Wait a limited time to go to next packet. */
1308                                 for (i = 200; i >= 0; i--)
1309                                         if (! (inw(ioaddr + EL3_STATUS) & CmdInProgress))
1310                                                 break;
1311                                 continue;
1312                         } else if (corkscrew_debug)
1313                                 printk("%s: Couldn't allocate a sk_buff of size %d.\n", dev->name, pkt_len);
1314                 }
1315                 outw(RxDiscard, ioaddr + EL3_CMD);
1316                 vp->stats.rx_dropped++;
1317                 /* Wait a limited time to skip this packet. */
1318                 for (i = 200; i >= 0; i--)
1319                         if (!(inw(ioaddr + EL3_STATUS) & CmdInProgress))
1320                                 break;
1321         }
1322         return 0;
1323 }
1324
1325 static int boomerang_rx(struct net_device *dev)
1326 {
1327         struct corkscrew_private *vp = netdev_priv(dev);
1328         int entry = vp->cur_rx % RX_RING_SIZE;
1329         int ioaddr = dev->base_addr;
1330         int rx_status;
1331
1332         if (corkscrew_debug > 5)
1333                 printk("   In boomerang_rx(), status %4.4x, rx_status %4.4x.\n",
1334                         inw(ioaddr + EL3_STATUS), inw(ioaddr + RxStatus));
1335         while ((rx_status = vp->rx_ring[entry].status) & RxDComplete) {
1336                 if (rx_status & RxDError) {     /* Error, update stats. */
1337                         unsigned char rx_error = rx_status >> 16;
1338                         if (corkscrew_debug > 2)
1339                                 printk(" Rx error: status %2.2x.\n",
1340                                        rx_error);
1341                         vp->stats.rx_errors++;
1342                         if (rx_error & 0x01)
1343                                 vp->stats.rx_over_errors++;
1344                         if (rx_error & 0x02)
1345                                 vp->stats.rx_length_errors++;
1346                         if (rx_error & 0x04)
1347                                 vp->stats.rx_frame_errors++;
1348                         if (rx_error & 0x08)
1349                                 vp->stats.rx_crc_errors++;
1350                         if (rx_error & 0x10)
1351                                 vp->stats.rx_length_errors++;
1352                 } else {
1353                         /* The packet length: up to 4.5K!. */
1354                         short pkt_len = rx_status & 0x1fff;
1355                         struct sk_buff *skb;
1356
1357                         vp->stats.rx_bytes += pkt_len;
1358                         if (corkscrew_debug > 4)
1359                                 printk("Receiving packet size %d status %4.4x.\n",
1360                                      pkt_len, rx_status);
1361
1362                         /* Check if the packet is long enough to just accept without
1363                            copying to a properly sized skbuff. */
1364                         if (pkt_len < rx_copybreak
1365                             && (skb = dev_alloc_skb(pkt_len + 4)) != 0) {
1366                                 skb->dev = dev;
1367                                 skb_reserve(skb, 2);    /* Align IP on 16 byte boundaries */
1368                                 /* 'skb_put()' points to the start of sk_buff data area. */
1369                                 memcpy(skb_put(skb, pkt_len),
1370                                        isa_bus_to_virt(vp->rx_ring[entry].
1371                                                    addr), pkt_len);
1372                                 rx_copy++;
1373                         } else {
1374                                 void *temp;
1375                                 /* Pass up the skbuff already on the Rx ring. */
1376                                 skb = vp->rx_skbuff[entry];
1377                                 vp->rx_skbuff[entry] = NULL;
1378                                 temp = skb_put(skb, pkt_len);
1379                                 /* Remove this checking code for final release. */
1380                                 if (isa_bus_to_virt(vp->rx_ring[entry].addr) != temp)
1381                                             printk("%s: Warning -- the skbuff addresses do not match"
1382                                              " in boomerang_rx: %p vs. %p / %p.\n",
1383                                              dev->name,
1384                                              isa_bus_to_virt(vp->
1385                                                          rx_ring[entry].
1386                                                          addr), skb->head,
1387                                              temp);
1388                                 rx_nocopy++;
1389                         }
1390                         skb->protocol = eth_type_trans(skb, dev);
1391                         netif_rx(skb);
1392                         dev->last_rx = jiffies;
1393                         vp->stats.rx_packets++;
1394                 }
1395                 entry = (++vp->cur_rx) % RX_RING_SIZE;
1396         }
1397         /* Refill the Rx ring buffers. */
1398         for (; vp->cur_rx - vp->dirty_rx > 0; vp->dirty_rx++) {
1399                 struct sk_buff *skb;
1400                 entry = vp->dirty_rx % RX_RING_SIZE;
1401                 if (vp->rx_skbuff[entry] == NULL) {
1402                         skb = dev_alloc_skb(PKT_BUF_SZ);
1403                         if (skb == NULL)
1404                                 break;  /* Bad news!  */
1405                         skb->dev = dev; /* Mark as being used by this device. */
1406                         skb_reserve(skb, 2);    /* Align IP on 16 byte boundaries */
1407                         vp->rx_ring[entry].addr = isa_virt_to_bus(skb->data);
1408                         vp->rx_skbuff[entry] = skb;
1409                 }
1410                 vp->rx_ring[entry].status = 0;  /* Clear complete bit. */
1411         }
1412         return 0;
1413 }
1414
1415 static int corkscrew_close(struct net_device *dev)
1416 {
1417         struct corkscrew_private *vp = netdev_priv(dev);
1418         int ioaddr = dev->base_addr;
1419         int i;
1420
1421         netif_stop_queue(dev);
1422
1423         if (corkscrew_debug > 1) {
1424                 printk("%s: corkscrew_close() status %4.4x, Tx status %2.2x.\n",
1425                      dev->name, inw(ioaddr + EL3_STATUS),
1426                      inb(ioaddr + TxStatus));
1427                 printk("%s: corkscrew close stats: rx_nocopy %d rx_copy %d"
1428                        " tx_queued %d.\n", dev->name, rx_nocopy, rx_copy,
1429                        queued_packet);
1430         }
1431
1432         del_timer(&vp->timer);
1433
1434         /* Turn off statistics ASAP.  We update lp->stats below. */
1435         outw(StatsDisable, ioaddr + EL3_CMD);
1436
1437         /* Disable the receiver and transmitter. */
1438         outw(RxDisable, ioaddr + EL3_CMD);
1439         outw(TxDisable, ioaddr + EL3_CMD);
1440
1441         if (dev->if_port == XCVR_10base2)
1442                 /* Turn off thinnet power.  Green! */
1443                 outw(StopCoax, ioaddr + EL3_CMD);
1444
1445         free_irq(dev->irq, dev);
1446
1447         outw(SetIntrEnb | 0x0000, ioaddr + EL3_CMD);
1448
1449         update_stats(ioaddr, dev);
1450         if (vp->full_bus_master_rx) {   /* Free Boomerang bus master Rx buffers. */
1451                 outl(0, ioaddr + UpListPtr);
1452                 for (i = 0; i < RX_RING_SIZE; i++)
1453                         if (vp->rx_skbuff[i]) {
1454                                 dev_kfree_skb(vp->rx_skbuff[i]);
1455                                 vp->rx_skbuff[i] = NULL;
1456                         }
1457         }
1458         if (vp->full_bus_master_tx) {   /* Free Boomerang bus master Tx buffers. */
1459                 outl(0, ioaddr + DownListPtr);
1460                 for (i = 0; i < TX_RING_SIZE; i++)
1461                         if (vp->tx_skbuff[i]) {
1462                                 dev_kfree_skb(vp->tx_skbuff[i]);
1463                                 vp->tx_skbuff[i] = NULL;
1464                         }
1465         }
1466
1467         return 0;
1468 }
1469
1470 static struct net_device_stats *corkscrew_get_stats(struct net_device *dev)
1471 {
1472         struct corkscrew_private *vp = netdev_priv(dev);
1473         unsigned long flags;
1474
1475         if (netif_running(dev)) {
1476                 spin_lock_irqsave(&vp->lock, flags);
1477                 update_stats(dev->base_addr, dev);
1478                 spin_unlock_irqrestore(&vp->lock, flags);
1479         }
1480         return &vp->stats;
1481 }
1482
1483 /*  Update statistics.
1484         Unlike with the EL3 we need not worry about interrupts changing
1485         the window setting from underneath us, but we must still guard
1486         against a race condition with a StatsUpdate interrupt updating the
1487         table.  This is done by checking that the ASM (!) code generated uses
1488         atomic updates with '+='.
1489         */
1490 static void update_stats(int ioaddr, struct net_device *dev)
1491 {
1492         struct corkscrew_private *vp = netdev_priv(dev);
1493
1494         /* Unlike the 3c5x9 we need not turn off stats updates while reading. */
1495         /* Switch to the stats window, and read everything. */
1496         EL3WINDOW(6);
1497         vp->stats.tx_carrier_errors += inb(ioaddr + 0);
1498         vp->stats.tx_heartbeat_errors += inb(ioaddr + 1);
1499         /* Multiple collisions. */ inb(ioaddr + 2);
1500         vp->stats.collisions += inb(ioaddr + 3);
1501         vp->stats.tx_window_errors += inb(ioaddr + 4);
1502         vp->stats.rx_fifo_errors += inb(ioaddr + 5);
1503         vp->stats.tx_packets += inb(ioaddr + 6);
1504         vp->stats.tx_packets += (inb(ioaddr + 9) & 0x30) << 4;
1505                                                 /* Rx packets   */ inb(ioaddr + 7);
1506                                                 /* Must read to clear */
1507         /* Tx deferrals */ inb(ioaddr + 8);
1508         /* Don't bother with register 9, an extension of registers 6&7.
1509            If we do use the 6&7 values the atomic update assumption above
1510            is invalid. */
1511         inw(ioaddr + 10);       /* Total Rx and Tx octets. */
1512         inw(ioaddr + 12);
1513         /* New: On the Vortex we must also clear the BadSSD counter. */
1514         EL3WINDOW(4);
1515         inb(ioaddr + 12);
1516
1517         /* We change back to window 7 (not 1) with the Vortex. */
1518         EL3WINDOW(7);
1519         return;
1520 }
1521
1522 /* This new version of set_rx_mode() supports v1.4 kernels.
1523    The Vortex chip has no documented multicast filter, so the only
1524    multicast setting is to receive all multicast frames.  At least
1525    the chip has a very clean way to set the mode, unlike many others. */
1526 static void set_rx_mode(struct net_device *dev)
1527 {
1528         int ioaddr = dev->base_addr;
1529         short new_mode;
1530
1531         if (dev->flags & IFF_PROMISC) {
1532                 if (corkscrew_debug > 3)
1533                         printk("%s: Setting promiscuous mode.\n",
1534                                dev->name);
1535                 new_mode = SetRxFilter | RxStation | RxMulticast | RxBroadcast | RxProm;
1536         } else if ((dev->mc_list) || (dev->flags & IFF_ALLMULTI)) {
1537                 new_mode = SetRxFilter | RxStation | RxMulticast | RxBroadcast;
1538         } else
1539                 new_mode = SetRxFilter | RxStation | RxBroadcast;
1540
1541         outw(new_mode, ioaddr + EL3_CMD);
1542 }
1543
1544 static void netdev_get_drvinfo(struct net_device *dev,
1545                                struct ethtool_drvinfo *info)
1546 {
1547         strcpy(info->driver, DRV_NAME);
1548         strcpy(info->version, DRV_VERSION);
1549         sprintf(info->bus_info, "ISA 0x%lx", dev->base_addr);
1550 }
1551
1552 static u32 netdev_get_msglevel(struct net_device *dev)
1553 {
1554         return corkscrew_debug;
1555 }
1556
1557 static void netdev_set_msglevel(struct net_device *dev, u32 level)
1558 {
1559         corkscrew_debug = level;
1560 }
1561
1562 static const struct ethtool_ops netdev_ethtool_ops = {
1563         .get_drvinfo            = netdev_get_drvinfo,
1564         .get_msglevel           = netdev_get_msglevel,
1565         .set_msglevel           = netdev_set_msglevel,
1566 };
1567
1568
1569 #ifdef MODULE
1570 void cleanup_module(void)
1571 {
1572         while (!list_empty(&root_corkscrew_dev)) {
1573                 struct net_device *dev;
1574                 struct corkscrew_private *vp;
1575
1576                 vp = list_entry(root_corkscrew_dev.next,
1577                                 struct corkscrew_private, list);
1578                 dev = vp->our_dev;
1579                 unregister_netdev(dev);
1580                 cleanup_card(dev);
1581                 free_netdev(dev);
1582         }
1583 }
1584 #endif                          /* MODULE */
1585
1586 /*
1587  * Local variables:
1588  *  compile-command: "gcc -DMODULE -D__KERNEL__ -Wall -Wstrict-prototypes -O6 -c 3c515.c"
1589  *  c-indent-level: 4
1590  *  tab-width: 4
1591  * End:
1592  */