drivers/net/ethernet/3com/3c515.c

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