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