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

   1 /* typhoon.c: A Linux Ethernet device driver for 3Com 3CR990 family of NICs */
   2 /*
   3         Written 2002-2004 by David Dillow <dave@thedillows.org>
   4         Based on code written 1998-2000 by Donald Becker <becker@scyld.com> and
   5         Linux 2.2.x driver by David P. McLean <davidpmclean@yahoo.com>.
   6
   7         This software may be used and distributed according to the terms of
   8         the GNU General Public License (GPL), incorporated herein by reference.
   9         Drivers based on or derived from this code fall under the GPL and must
  10         retain the authorship, copyright and license notice.  This file is not
  11         a complete program and may only be used when the entire operating
  12         system is licensed under the GPL.
  13
  14         This software is available on a public web site. It may enable
  15         cryptographic capabilities of the 3Com hardware, and may be
  16         exported from the United States under License Exception "TSU"
  17         pursuant to 15 C.F.R. Section 740.13(e).
  18
  19         This work was funded by the National Library of Medicine under
  20         the Department of Energy project number 0274DD06D1 and NLM project
  21         number Y1-LM-2015-01.
  22
  23         This driver is designed for the 3Com 3CR990 Family of cards with the
  24         3XP Processor. It has been tested on x86 and sparc64.
  25
  26         KNOWN ISSUES:
  27         *) The current firmware always strips the VLAN tag off, even if
  28                 we tell it not to. You should filter VLANs at the switch
  29                 as a workaround (good practice in any event) until we can
  30                 get this fixed.
  31         *) Cannot DMA Rx packets to a 2 byte aligned address. Also firmware
  32                 issue. Hopefully 3Com will fix it.
  33         *) Waiting for a command response takes 8ms due to non-preemptable
  34                 polling. Only significant for getting stats and creating
  35                 SAs, but an ugly wart never the less.
  36
  37         TODO:
  38         *) Doesn't do IPSEC offloading. Yet. Keep yer pants on, it's coming.
  39         *) Add more support for ethtool (especially for NIC stats)
  40         *) Allow disabling of RX checksum offloading
  41         *) Fix MAC changing to work while the interface is up
  42                 (Need to put commands on the TX ring, which changes
  43                 the locking)
  44         *) Add in FCS to {rx,tx}_bytes, since the hardware doesn't. See
  45                 http://oss.sgi.com/cgi-bin/mesg.cgi?a=netdev&i=20031215152211.7003fe8e.rddunlap%40osdl.org
  46 */
  47
  48 /* Set the copy breakpoint for the copy-only-tiny-frames scheme.
  49  * Setting to > 1518 effectively disables this feature.
  50  */
  51 static int rx_copybreak = 200;
  52
  53 /* Should we use MMIO or Port IO?
  54  * 0: Port IO
  55  * 1: MMIO
  56  * 2: Try MMIO, fallback to Port IO
  57  */
  58 static unsigned int use_mmio = 2;
  59
  60 /* end user-configurable values */
  61
  62 /* Maximum number of multicast addresses to filter (vs. rx-all-multicast).
  63  */
  64 static const int multicast_filter_limit = 32;
  65
  66 /* Operational parameters that are set at compile time. */
  67
  68 /* Keep the ring sizes a power of two for compile efficiency.
  69  * The compiler will convert <unsigned>'%'<2^N> into a bit mask.
  70  * Making the Tx ring too large decreases the effectiveness of channel
  71  * bonding and packet priority.
  72  * There are no ill effects from too-large receive rings.
  73  *
  74  * We don't currently use the Hi Tx ring so, don't make it very big.
  75  *
  76  * Beware that if we start using the Hi Tx ring, we will need to change
  77  * typhoon_num_free_tx() and typhoon_tx_complete() to account for that.
  78  */
  79 #define TXHI_ENTRIES            2
  80 #define TXLO_ENTRIES            128
  81 #define RX_ENTRIES              32
  82 #define COMMAND_ENTRIES         16
  83 #define RESPONSE_ENTRIES        32
  84
  85 #define COMMAND_RING_SIZE       (COMMAND_ENTRIES * sizeof(struct cmd_desc))
  86 #define RESPONSE_RING_SIZE      (RESPONSE_ENTRIES * sizeof(struct resp_desc))
  87
  88 /* The 3XP will preload and remove 64 entries from the free buffer
  89  * list, and we need one entry to keep the ring from wrapping, so
  90  * to keep this a power of two, we use 128 entries.
  91  */
  92 #define RXFREE_ENTRIES          128
  93 #define RXENT_ENTRIES           (RXFREE_ENTRIES - 1)
  94
  95 /* Operational parameters that usually are not changed. */
  96
  97 /* Time in jiffies before concluding the transmitter is hung. */
  98 #define TX_TIMEOUT  (2*HZ)
  99
 100 #define PKT_BUF_SZ              1536
 101
 102 #define DRV_MODULE_NAME         "typhoon"
 103 #define DRV_MODULE_VERSION      "1.5.8"
 104 #define DRV_MODULE_RELDATE      "06/11/09"
 105 #define PFX                     DRV_MODULE_NAME ": "
 106 #define ERR_PFX                 KERN_ERR PFX
 107
 108 #include <linux/module.h>
 109 #include <linux/kernel.h>
 110 #include <linux/string.h>
 111 #include <linux/timer.h>
 112 #include <linux/errno.h>
 113 #include <linux/ioport.h>
 114 #include <linux/slab.h>
 115 #include <linux/interrupt.h>
 116 #include <linux/pci.h>
 117 #include <linux/netdevice.h>
 118 #include <linux/etherdevice.h>
 119 #include <linux/skbuff.h>
 120 #include <linux/mm.h>
 121 #include <linux/init.h>
 122 #include <linux/delay.h>
 123 #include <linux/ethtool.h>
 124 #include <linux/if_vlan.h>
 125 #include <linux/crc32.h>
 126 #include <linux/bitops.h>
 127 #include <asm/processor.h>
 128 #include <asm/io.h>
 129 #include <asm/uaccess.h>
 130 #include <linux/in6.h>
 131 #include <linux/dma-mapping.h>
 132
 133 #include "typhoon.h"
 134 #include "typhoon-firmware.h"
 135
 136 static char version[] __devinitdata =
 137     "typhoon.c: version " DRV_MODULE_VERSION " (" DRV_MODULE_RELDATE ")\n";
 138
 139 MODULE_AUTHOR("David Dillow <dave@thedillows.org>");
 140 MODULE_VERSION(DRV_MODULE_VERSION);
 141 MODULE_LICENSE("GPL");
 142 MODULE_DESCRIPTION("3Com Typhoon Family (3C990, 3CR990, and variants)");
 143 MODULE_PARM_DESC(rx_copybreak, "Packets smaller than this are copied and "
 144                                "the buffer given back to the NIC. Default "
 145                                "is 200.");
 146 MODULE_PARM_DESC(use_mmio, "Use MMIO (1) or PIO(0) to access the NIC. "
 147                            "Default is to try MMIO and fallback to PIO.");
 148 module_param(rx_copybreak, int, 0);
 149 module_param(use_mmio, int, 0);
 150
 151 #if defined(NETIF_F_TSO) && MAX_SKB_FRAGS > 32
 152 #warning Typhoon only supports 32 entries in its SG list for TSO, disabling TSO
 153 #undef NETIF_F_TSO
 154 #endif
 155
 156 #if TXLO_ENTRIES <= (2 * MAX_SKB_FRAGS)
 157 #error TX ring too small!
 158 #endif
 159
 160 struct typhoon_card_info {
 161         char *name;
 162         int capabilities;
 163 };
 164
 165 #define TYPHOON_CRYPTO_NONE             0x00
 166 #define TYPHOON_CRYPTO_DES              0x01
 167 #define TYPHOON_CRYPTO_3DES             0x02
 168 #define TYPHOON_CRYPTO_VARIABLE         0x04
 169 #define TYPHOON_FIBER                   0x08
 170 #define TYPHOON_WAKEUP_NEEDS_RESET      0x10
 171
 172 enum typhoon_cards {
 173         TYPHOON_TX = 0, TYPHOON_TX95, TYPHOON_TX97, TYPHOON_SVR,
 174         TYPHOON_SVR95, TYPHOON_SVR97, TYPHOON_TXM, TYPHOON_BSVR,
 175         TYPHOON_FX95, TYPHOON_FX97, TYPHOON_FX95SVR, TYPHOON_FX97SVR,
 176         TYPHOON_FXM,
 177 };
 178
 179 /* directly indexed by enum typhoon_cards, above */
 180 static struct typhoon_card_info typhoon_card_info[] __devinitdata = {
 181         { "3Com Typhoon (3C990-TX)",
 182                 TYPHOON_CRYPTO_NONE},
 183         { "3Com Typhoon (3CR990-TX-95)",
 184                 TYPHOON_CRYPTO_DES},
 185         { "3Com Typhoon (3CR990-TX-97)",
 186                 TYPHOON_CRYPTO_DES | TYPHOON_CRYPTO_3DES},
 187         { "3Com Typhoon (3C990SVR)",
 188                 TYPHOON_CRYPTO_NONE},
 189         { "3Com Typhoon (3CR990SVR95)",
 190                 TYPHOON_CRYPTO_DES},
 191         { "3Com Typhoon (3CR990SVR97)",
 192                 TYPHOON_CRYPTO_DES | TYPHOON_CRYPTO_3DES},
 193         { "3Com Typhoon2 (3C990B-TX-M)",
 194                 TYPHOON_CRYPTO_VARIABLE},
 195         { "3Com Typhoon2 (3C990BSVR)",
 196                 TYPHOON_CRYPTO_VARIABLE},
 197         { "3Com Typhoon (3CR990-FX-95)",
 198                 TYPHOON_CRYPTO_DES | TYPHOON_FIBER},
 199         { "3Com Typhoon (3CR990-FX-97)",
 200                 TYPHOON_CRYPTO_DES | TYPHOON_CRYPTO_3DES | TYPHOON_FIBER},
 201         { "3Com Typhoon (3CR990-FX-95 Server)",
 202                 TYPHOON_CRYPTO_DES | TYPHOON_FIBER},
 203         { "3Com Typhoon (3CR990-FX-97 Server)",
 204                 TYPHOON_CRYPTO_DES | TYPHOON_CRYPTO_3DES | TYPHOON_FIBER},
 205         { "3Com Typhoon2 (3C990B-FX-97)",
 206                 TYPHOON_CRYPTO_VARIABLE | TYPHOON_FIBER},
 207 };
 208
 209 /* Notes on the new subsystem numbering scheme:
 210  * bits 0-1 indicate crypto capabilities: (0) variable, (1) DES, or (2) 3DES
 211  * bit 4 indicates if this card has secured firmware (we don't support it)
 212  * bit 8 indicates if this is a (0) copper or (1) fiber card
 213  * bits 12-16 indicate card type: (0) client and (1) server
 214  */
 215 static struct pci_device_id typhoon_pci_tbl[] = {
 216         { PCI_VENDOR_ID_3COM, PCI_DEVICE_ID_3COM_3CR990,
 217           PCI_ANY_ID, PCI_ANY_ID, 0, 0,TYPHOON_TX },
 218         { PCI_VENDOR_ID_3COM, PCI_DEVICE_ID_3COM_3CR990_TX_95,
 219           PCI_ANY_ID, PCI_ANY_ID, 0, 0, TYPHOON_TX95 },
 220         { PCI_VENDOR_ID_3COM, PCI_DEVICE_ID_3COM_3CR990_TX_97,
 221           PCI_ANY_ID, PCI_ANY_ID, 0, 0, TYPHOON_TX97 },
 222         { PCI_VENDOR_ID_3COM, PCI_DEVICE_ID_3COM_3CR990B,
 223           PCI_ANY_ID, 0x1000, 0, 0, TYPHOON_TXM },
 224         { PCI_VENDOR_ID_3COM, PCI_DEVICE_ID_3COM_3CR990B,
 225           PCI_ANY_ID, 0x1102, 0, 0, TYPHOON_FXM },
 226         { PCI_VENDOR_ID_3COM, PCI_DEVICE_ID_3COM_3CR990B,
 227           PCI_ANY_ID, 0x2000, 0, 0, TYPHOON_BSVR },
 228         { PCI_VENDOR_ID_3COM, PCI_DEVICE_ID_3COM_3CR990_FX,
 229           PCI_ANY_ID, 0x1101, 0, 0, TYPHOON_FX95 },
 230         { PCI_VENDOR_ID_3COM, PCI_DEVICE_ID_3COM_3CR990_FX,
 231           PCI_ANY_ID, 0x1102, 0, 0, TYPHOON_FX97 },
 232         { PCI_VENDOR_ID_3COM, PCI_DEVICE_ID_3COM_3CR990_FX,
 233           PCI_ANY_ID, 0x2101, 0, 0, TYPHOON_FX95SVR },
 234         { PCI_VENDOR_ID_3COM, PCI_DEVICE_ID_3COM_3CR990_FX,
 235           PCI_ANY_ID, 0x2102, 0, 0, TYPHOON_FX97SVR },
 236         { PCI_VENDOR_ID_3COM, PCI_DEVICE_ID_3COM_3CR990SVR95,
 237           PCI_ANY_ID, PCI_ANY_ID, 0, 0, TYPHOON_SVR95 },
 238         { PCI_VENDOR_ID_3COM, PCI_DEVICE_ID_3COM_3CR990SVR97,
 239           PCI_ANY_ID, PCI_ANY_ID, 0, 0, TYPHOON_SVR97 },
 240         { PCI_VENDOR_ID_3COM, PCI_DEVICE_ID_3COM_3CR990SVR,
 241           PCI_ANY_ID, PCI_ANY_ID, 0, 0, TYPHOON_SVR },
 242         { 0, }
 243 };
 244 MODULE_DEVICE_TABLE(pci, typhoon_pci_tbl);
 245
 246 /* Define the shared memory area
 247  * Align everything the 3XP will normally be using.
 248  * We'll need to move/align txHi if we start using that ring.
 249  */
 250 #define __3xp_aligned   ____cacheline_aligned
 251 struct typhoon_shared {
 252         struct typhoon_interface        iface;
 253         struct typhoon_indexes          indexes                 __3xp_aligned;
 254         struct tx_desc                  txLo[TXLO_ENTRIES]      __3xp_aligned;
 255         struct rx_desc                  rxLo[RX_ENTRIES]        __3xp_aligned;
 256         struct rx_desc                  rxHi[RX_ENTRIES]        __3xp_aligned;
 257         struct cmd_desc                 cmd[COMMAND_ENTRIES]    __3xp_aligned;
 258         struct resp_desc                resp[RESPONSE_ENTRIES]  __3xp_aligned;
 259         struct rx_free                  rxBuff[RXFREE_ENTRIES]  __3xp_aligned;
 260         u32                             zeroWord;
 261         struct tx_desc                  txHi[TXHI_ENTRIES];
 262 } __attribute__ ((packed));
 263
 264 struct rxbuff_ent {
 265         struct sk_buff *skb;
 266         dma_addr_t      dma_addr;
 267 };
 268
 269 struct typhoon {
 270         /* Tx cache line section */
 271         struct transmit_ring    txLoRing        ____cacheline_aligned;
 272         struct pci_dev *        tx_pdev;
 273         void __iomem            *tx_ioaddr;
 274         u32                     txlo_dma_addr;
 275
 276         /* Irq/Rx cache line section */
 277         void __iomem            *ioaddr         ____cacheline_aligned;
 278         struct typhoon_indexes *indexes;
 279         u8                      awaiting_resp;
 280         u8                      duplex;
 281         u8                      speed;
 282         u8                      card_state;
 283         struct basic_ring       rxLoRing;
 284         struct pci_dev *        pdev;
 285         struct net_device *     dev;
 286         struct napi_struct      napi;
 287         spinlock_t              state_lock;
 288         struct vlan_group *     vlgrp;
 289         struct basic_ring       rxHiRing;
 290         struct basic_ring       rxBuffRing;
 291         struct rxbuff_ent       rxbuffers[RXENT_ENTRIES];
 292
 293         /* general section */
 294         spinlock_t              command_lock    ____cacheline_aligned;
 295         struct basic_ring       cmdRing;
 296         struct basic_ring       respRing;
 297         struct net_device_stats stats;
 298         struct net_device_stats stats_saved;
 299         const char *            name;
 300         struct typhoon_shared * shared;
 301         dma_addr_t              shared_dma;
 302         __le16                  xcvr_select;
 303         __le16                  wol_events;
 304         __le32                  offload;
 305
 306         /* unused stuff (future use) */
 307         int                     capabilities;
 308         struct transmit_ring    txHiRing;
 309 };
 310
 311 enum completion_wait_values {
 312         NoWait = 0, WaitNoSleep, WaitSleep,
 313 };
 314
 315 /* These are the values for the typhoon.card_state variable.
 316  * These determine where the statistics will come from in get_stats().
 317  * The sleep image does not support the statistics we need.
 318  */
 319 enum state_values {
 320         Sleeping = 0, Running,
 321 };
 322
 323 /* PCI writes are not guaranteed to be posted in order, but outstanding writes
 324  * cannot pass a read, so this forces current writes to post.
 325  */
 326 #define typhoon_post_pci_writes(x) \
 327         do { if(likely(use_mmio)) ioread32(x+TYPHOON_REG_HEARTBEAT); } while(0)
 328
 329 /* We'll wait up to six seconds for a reset, and half a second normally.
 330  */
 331 #define TYPHOON_UDELAY                  50
 332 #define TYPHOON_RESET_TIMEOUT_SLEEP     (6 * HZ)
 333 #define TYPHOON_RESET_TIMEOUT_NOSLEEP   ((6 * 1000000) / TYPHOON_UDELAY)
 334 #define TYPHOON_WAIT_TIMEOUT            ((1000000 / 2) / TYPHOON_UDELAY)
 335
 336 #if defined(NETIF_F_TSO)
 337 #define skb_tso_size(x)         (skb_shinfo(x)->gso_size)
 338 #define TSO_NUM_DESCRIPTORS     2
 339 #define TSO_OFFLOAD_ON          TYPHOON_OFFLOAD_TCP_SEGMENT
 340 #else
 341 #define NETIF_F_TSO             0
 342 #define skb_tso_size(x)         0
 343 #define TSO_NUM_DESCRIPTORS     0
 344 #define TSO_OFFLOAD_ON          0
 345 #endif
 346
 347 static inline void
 348 typhoon_inc_index(u32 *index, const int count, const int num_entries)
 349 {
 350         /* Increment a ring index -- we can use this for all rings execept
 351          * the Rx rings, as they use different size descriptors
 352          * otherwise, everything is the same size as a cmd_desc
 353          */
 354         *index += count * sizeof(struct cmd_desc);
 355         *index %= num_entries * sizeof(struct cmd_desc);
 356 }
 357
 358 static inline void
 359 typhoon_inc_cmd_index(u32 *index, const int count)
 360 {
 361         typhoon_inc_index(index, count, COMMAND_ENTRIES);
 362 }
 363
 364 static inline void
 365 typhoon_inc_resp_index(u32 *index, const int count)
 366 {
 367         typhoon_inc_index(index, count, RESPONSE_ENTRIES);
 368 }
 369
 370 static inline void
 371 typhoon_inc_rxfree_index(u32 *index, const int count)
 372 {
 373         typhoon_inc_index(index, count, RXFREE_ENTRIES);
 374 }
 375
 376 static inline void
 377 typhoon_inc_tx_index(u32 *index, const int count)
 378 {
 379         /* if we start using the Hi Tx ring, this needs updateing */
 380         typhoon_inc_index(index, count, TXLO_ENTRIES);
 381 }
 382
 383 static inline void
 384 typhoon_inc_rx_index(u32 *index, const int count)
 385 {
 386         /* sizeof(struct rx_desc) != sizeof(struct cmd_desc) */
 387         *index += count * sizeof(struct rx_desc);
 388         *index %= RX_ENTRIES * sizeof(struct rx_desc);
 389 }
 390
 391 static int
 392 typhoon_reset(void __iomem *ioaddr, int wait_type)
 393 {
 394         int i, err = 0;
 395         int timeout;
 396
 397         if(wait_type == WaitNoSleep)
 398                 timeout = TYPHOON_RESET_TIMEOUT_NOSLEEP;
 399         else
 400                 timeout = TYPHOON_RESET_TIMEOUT_SLEEP;
 401
 402         iowrite32(TYPHOON_INTR_ALL, ioaddr + TYPHOON_REG_INTR_MASK);
 403         iowrite32(TYPHOON_INTR_ALL, ioaddr + TYPHOON_REG_INTR_STATUS);
 404
 405         iowrite32(TYPHOON_RESET_ALL, ioaddr + TYPHOON_REG_SOFT_RESET);
 406         typhoon_post_pci_writes(ioaddr);
 407         udelay(1);
 408         iowrite32(TYPHOON_RESET_NONE, ioaddr + TYPHOON_REG_SOFT_RESET);
 409
 410         if(wait_type != NoWait) {
 411                 for(i = 0; i < timeout; i++) {
 412                         if(ioread32(ioaddr + TYPHOON_REG_STATUS) ==
 413                            TYPHOON_STATUS_WAITING_FOR_HOST)
 414                                 goto out;
 415
 416                         if(wait_type == WaitSleep)
 417                                 schedule_timeout_uninterruptible(1);
 418                         else
 419                                 udelay(TYPHOON_UDELAY);
 420                 }
 421
 422                 err = -ETIMEDOUT;
 423         }
 424
 425 out:
 426         iowrite32(TYPHOON_INTR_ALL, ioaddr + TYPHOON_REG_INTR_MASK);
 427         iowrite32(TYPHOON_INTR_ALL, ioaddr + TYPHOON_REG_INTR_STATUS);
 428
 429         /* The 3XP seems to need a little extra time to complete the load
 430          * of the sleep image before we can reliably boot it. Failure to
 431          * do this occasionally results in a hung adapter after boot in
 432          * typhoon_init_one() while trying to read the MAC address or
 433          * putting the card to sleep. 3Com's driver waits 5ms, but
 434          * that seems to be overkill. However, if we can sleep, we might
 435          * as well give it that much time. Otherwise, we'll give it 500us,
 436          * which should be enough (I've see it work well at 100us, but still
 437          * saw occasional problems.)
 438          */
 439         if(wait_type == WaitSleep)
 440                 msleep(5);
 441         else
 442                 udelay(500);
 443         return err;
 444 }
 445
 446 static int
 447 typhoon_wait_status(void __iomem *ioaddr, u32 wait_value)
 448 {
 449         int i, err = 0;
 450
 451         for(i = 0; i < TYPHOON_WAIT_TIMEOUT; i++) {
 452                 if(ioread32(ioaddr + TYPHOON_REG_STATUS) == wait_value)
 453                         goto out;
 454                 udelay(TYPHOON_UDELAY);
 455         }
 456
 457         err = -ETIMEDOUT;
 458
 459 out:
 460         return err;
 461 }
 462
 463 static inline void
 464 typhoon_media_status(struct net_device *dev, struct resp_desc *resp)
 465 {
 466         if(resp->parm1 & TYPHOON_MEDIA_STAT_NO_LINK)
 467                 netif_carrier_off(dev);
 468         else
 469                 netif_carrier_on(dev);
 470 }
 471
 472 static inline void
 473 typhoon_hello(struct typhoon *tp)
 474 {
 475         struct basic_ring *ring = &tp->cmdRing;
 476         struct cmd_desc *cmd;
 477
 478         /* We only get a hello request if we've not sent anything to the
 479          * card in a long while. If the lock is held, then we're in the
 480          * process of issuing a command, so we don't need to respond.
 481          */
 482         if(spin_trylock(&tp->command_lock)) {
 483                 cmd = (struct cmd_desc *)(ring->ringBase + ring->lastWrite);
 484                 typhoon_inc_cmd_index(&ring->lastWrite, 1);
 485
 486                 INIT_COMMAND_NO_RESPONSE(cmd, TYPHOON_CMD_HELLO_RESP);
 487                 smp_wmb();
 488                 iowrite32(ring->lastWrite, tp->ioaddr + TYPHOON_REG_CMD_READY);
 489                 spin_unlock(&tp->command_lock);
 490         }
 491 }
 492
 493 static int
 494 typhoon_process_response(struct typhoon *tp, int resp_size,
 495                                 struct resp_desc *resp_save)
 496 {
 497         struct typhoon_indexes *indexes = tp->indexes;
 498         struct resp_desc *resp;
 499         u8 *base = tp->respRing.ringBase;
 500         int count, len, wrap_len;
 501         u32 cleared;
 502         u32 ready;
 503
 504         cleared = le32_to_cpu(indexes->respCleared);
 505         ready = le32_to_cpu(indexes->respReady);
 506         while(cleared != ready) {
 507                 resp = (struct resp_desc *)(base + cleared);
 508                 count = resp->numDesc + 1;
 509                 if(resp_save && resp->seqNo) {
 510                         if(count > resp_size) {
 511                                 resp_save->flags = TYPHOON_RESP_ERROR;
 512                                 goto cleanup;
 513                         }
 514
 515                         wrap_len = 0;
 516                         len = count * sizeof(*resp);
 517                         if(unlikely(cleared + len > RESPONSE_RING_SIZE)) {
 518                                 wrap_len = cleared + len - RESPONSE_RING_SIZE;
 519                                 len = RESPONSE_RING_SIZE - cleared;
 520                         }
 521
 522                         memcpy(resp_save, resp, len);
 523                         if(unlikely(wrap_len)) {
 524                                 resp_save += len / sizeof(*resp);
 525                                 memcpy(resp_save, base, wrap_len);
 526                         }
 527
 528                         resp_save = NULL;
 529                 } else if(resp->cmd == TYPHOON_CMD_READ_MEDIA_STATUS) {
 530                         typhoon_media_status(tp->dev, resp);
 531                 } else if(resp->cmd == TYPHOON_CMD_HELLO_RESP) {
 532                         typhoon_hello(tp);
 533                 } else {
 534                         printk(KERN_ERR "%s: dumping unexpected response "
 535                                "0x%04x:%d:0x%02x:0x%04x:%08x:%08x\n",
 536                                tp->name, le16_to_cpu(resp->cmd),
 537                                resp->numDesc, resp->flags,
 538                                le16_to_cpu(resp->parm1),
 539                                le32_to_cpu(resp->parm2),
 540                                le32_to_cpu(resp->parm3));
 541                 }
 542
 543 cleanup:
 544                 typhoon_inc_resp_index(&cleared, count);
 545         }
 546
 547         indexes->respCleared = cpu_to_le32(cleared);
 548         wmb();
 549         return (resp_save == NULL);
 550 }
 551
 552 static inline int
 553 typhoon_num_free(int lastWrite, int lastRead, int ringSize)
 554 {
 555         /* this works for all descriptors but rx_desc, as they are a
 556          * different size than the cmd_desc -- everyone else is the same
 557          */
 558         lastWrite /= sizeof(struct cmd_desc);
 559         lastRead /= sizeof(struct cmd_desc);
 560         return (ringSize + lastRead - lastWrite - 1) % ringSize;
 561 }
 562
 563 static inline int
 564 typhoon_num_free_cmd(struct typhoon *tp)
 565 {
 566         int lastWrite = tp->cmdRing.lastWrite;
 567         int cmdCleared = le32_to_cpu(tp->indexes->cmdCleared);
 568
 569         return typhoon_num_free(lastWrite, cmdCleared, COMMAND_ENTRIES);
 570 }
 571
 572 static inline int
 573 typhoon_num_free_resp(struct typhoon *tp)
 574 {
 575         int respReady = le32_to_cpu(tp->indexes->respReady);
 576         int respCleared = le32_to_cpu(tp->indexes->respCleared);
 577
 578         return typhoon_num_free(respReady, respCleared, RESPONSE_ENTRIES);
 579 }
 580
 581 static inline int
 582 typhoon_num_free_tx(struct transmit_ring *ring)
 583 {
 584         /* if we start using the Hi Tx ring, this needs updating */
 585         return typhoon_num_free(ring->lastWrite, ring->lastRead, TXLO_ENTRIES);
 586 }
 587
 588 static int
 589 typhoon_issue_command(struct typhoon *tp, int num_cmd, struct cmd_desc *cmd,
 590                       int num_resp, struct resp_desc *resp)
 591 {
 592         struct typhoon_indexes *indexes = tp->indexes;
 593         struct basic_ring *ring = &tp->cmdRing;
 594         struct resp_desc local_resp;
 595         int i, err = 0;
 596         int got_resp;
 597         int freeCmd, freeResp;
 598         int len, wrap_len;
 599
 600         spin_lock(&tp->command_lock);
 601
 602         freeCmd = typhoon_num_free_cmd(tp);
 603         freeResp = typhoon_num_free_resp(tp);
 604
 605         if(freeCmd < num_cmd || freeResp < num_resp) {
 606                 printk("%s: no descs for cmd, had (needed) %d (%d) cmd, "
 607                         "%d (%d) resp\n", tp->name, freeCmd, num_cmd,
 608                         freeResp, num_resp);
 609                 err = -ENOMEM;
 610                 goto out;
 611         }
 612
 613         if(cmd->flags & TYPHOON_CMD_RESPOND) {
 614                 /* If we're expecting a response, but the caller hasn't given
 615                  * us a place to put it, we'll provide one.
 616                  */
 617                 tp->awaiting_resp = 1;
 618                 if(resp == NULL) {
 619                         resp = &local_resp;
 620                         num_resp = 1;
 621                 }
 622         }
 623
 624         wrap_len = 0;
 625         len = num_cmd * sizeof(*cmd);
 626         if(unlikely(ring->lastWrite + len > COMMAND_RING_SIZE)) {
 627                 wrap_len = ring->lastWrite + len - COMMAND_RING_SIZE;
 628                 len = COMMAND_RING_SIZE - ring->lastWrite;
 629         }
 630
 631         memcpy(ring->ringBase + ring->lastWrite, cmd, len);
 632         if(unlikely(wrap_len)) {
 633                 struct cmd_desc *wrap_ptr = cmd;
 634                 wrap_ptr += len / sizeof(*cmd);
 635                 memcpy(ring->ringBase, wrap_ptr, wrap_len);
 636         }
 637
 638         typhoon_inc_cmd_index(&ring->lastWrite, num_cmd);
 639
 640         /* "I feel a presence... another warrior is on the mesa."
 641          */
 642         wmb();
 643         iowrite32(ring->lastWrite, tp->ioaddr + TYPHOON_REG_CMD_READY);
 644         typhoon_post_pci_writes(tp->ioaddr);
 645
 646         if((cmd->flags & TYPHOON_CMD_RESPOND) == 0)
 647                 goto out;
 648
 649         /* Ugh. We'll be here about 8ms, spinning our thumbs, unable to
 650          * preempt or do anything other than take interrupts. So, don't
 651          * wait for a response unless you have to.
 652          *
 653          * I've thought about trying to sleep here, but we're called
 654          * from many contexts that don't allow that. Also, given the way
 655          * 3Com has implemented irq coalescing, we would likely timeout --
 656          * this has been observed in real life!
 657          *
 658          * The big killer is we have to wait to get stats from the card,
 659          * though we could go to a periodic refresh of those if we don't
 660          * mind them getting somewhat stale. The rest of the waiting
 661          * commands occur during open/close/suspend/resume, so they aren't
 662          * time critical. Creating SAs in the future will also have to
 663          * wait here.
 664          */
 665         got_resp = 0;
 666         for(i = 0; i < TYPHOON_WAIT_TIMEOUT && !got_resp; i++) {
 667                 if(indexes->respCleared != indexes->respReady)
 668                         got_resp = typhoon_process_response(tp, num_resp,
 669                                                                 resp);
 670                 udelay(TYPHOON_UDELAY);
 671         }
 672
 673         if(!got_resp) {
 674                 err = -ETIMEDOUT;
 675                 goto out;
 676         }
 677
 678         /* Collect the error response even if we don't care about the
 679          * rest of the response
 680          */
 681         if(resp->flags & TYPHOON_RESP_ERROR)
 682                 err = -EIO;
 683
 684 out:
 685         if(tp->awaiting_resp) {
 686                 tp->awaiting_resp = 0;
 687                 smp_wmb();
 688
 689                 /* Ugh. If a response was added to the ring between
 690                  * the call to typhoon_process_response() and the clearing
 691                  * of tp->awaiting_resp, we could have missed the interrupt
 692                  * and it could hang in the ring an indeterminate amount of
 693                  * time. So, check for it, and interrupt ourselves if this
 694                  * is the case.
 695                  */
 696                 if(indexes->respCleared != indexes->respReady)
 697                         iowrite32(1, tp->ioaddr + TYPHOON_REG_SELF_INTERRUPT);
 698         }
 699
 700         spin_unlock(&tp->command_lock);
 701         return err;
 702 }
 703
 704 static void
 705 typhoon_vlan_rx_register(struct net_device *dev, struct vlan_group *grp)
 706 {
 707         struct typhoon *tp = netdev_priv(dev);
 708         struct cmd_desc xp_cmd;
 709         int err;
 710
 711         spin_lock_bh(&tp->state_lock);
 712         if(!tp->vlgrp != !grp) {
 713                 /* We've either been turned on for the first time, or we've
 714                  * been turned off. Update the 3XP.
 715                  */
 716                 if(grp)
 717                         tp->offload |= TYPHOON_OFFLOAD_VLAN;
 718                 else
 719                         tp->offload &= ~TYPHOON_OFFLOAD_VLAN;
 720
 721                 /* If the interface is up, the runtime is running -- and we
 722                  * must be up for the vlan core to call us.
 723                  *
 724                  * Do the command outside of the spin lock, as it is slow.
 725                  */
 726                 INIT_COMMAND_WITH_RESPONSE(&xp_cmd,
 727                                         TYPHOON_CMD_SET_OFFLOAD_TASKS);
 728                 xp_cmd.parm2 = tp->offload;
 729                 xp_cmd.parm3 = tp->offload;
 730                 spin_unlock_bh(&tp->state_lock);
 731                 err = typhoon_issue_command(tp, 1, &xp_cmd, 0, NULL);
 732                 if(err < 0)
 733                         printk("%s: vlan offload error %d\n", tp->name, -err);
 734                 spin_lock_bh(&tp->state_lock);
 735         }
 736
 737         /* now make the change visible */
 738         tp->vlgrp = grp;
 739         spin_unlock_bh(&tp->state_lock);
 740 }
 741
 742 static inline void
 743 typhoon_tso_fill(struct sk_buff *skb, struct transmit_ring *txRing,
 744                         u32 ring_dma)
 745 {
 746         struct tcpopt_desc *tcpd;
 747         u32 tcpd_offset = ring_dma;
 748
 749         tcpd = (struct tcpopt_desc *) (txRing->ringBase + txRing->lastWrite);
 750         tcpd_offset += txRing->lastWrite;
 751         tcpd_offset += offsetof(struct tcpopt_desc, bytesTx);
 752         typhoon_inc_tx_index(&txRing->lastWrite, 1);
 753
 754         tcpd->flags = TYPHOON_OPT_DESC | TYPHOON_OPT_TCP_SEG;
 755         tcpd->numDesc = 1;
 756         tcpd->mss_flags = cpu_to_le16(skb_tso_size(skb));
 757         tcpd->mss_flags |= TYPHOON_TSO_FIRST | TYPHOON_TSO_LAST;
 758         tcpd->respAddrLo = cpu_to_le32(tcpd_offset);
 759         tcpd->bytesTx = cpu_to_le32(skb->len);
 760         tcpd->status = 0;
 761 }
 762
 763 static int
 764 typhoon_start_tx(struct sk_buff *skb, struct net_device *dev)
 765 {
 766         struct typhoon *tp = netdev_priv(dev);
 767         struct transmit_ring *txRing;
 768         struct tx_desc *txd, *first_txd;
 769         dma_addr_t skb_dma;
 770         int numDesc;
 771
 772         /* we have two rings to choose from, but we only use txLo for now
 773          * If we start using the Hi ring as well, we'll need to update
 774          * typhoon_stop_runtime(), typhoon_interrupt(), typhoon_num_free_tx(),
 775          * and TXHI_ENTRIES to match, as well as update the TSO code below
 776          * to get the right DMA address
 777          */
 778         txRing = &tp->txLoRing;
 779
 780         /* We need one descriptor for each fragment of the sk_buff, plus the
 781          * one for the ->data area of it.
 782          *
 783          * The docs say a maximum of 16 fragment descriptors per TCP option
 784          * descriptor, then make a new packet descriptor and option descriptor
 785          * for the next 16 fragments. The engineers say just an option
 786          * descriptor is needed. I've tested up to 26 fragments with a single
 787          * packet descriptor/option descriptor combo, so I use that for now.
 788          *
 789          * If problems develop with TSO, check this first.
 790          */
 791         numDesc = skb_shinfo(skb)->nr_frags + 1;
 792         if (skb_is_gso(skb))
 793                 numDesc++;
 794
 795         /* When checking for free space in the ring, we need to also
 796          * account for the initial Tx descriptor, and we always must leave
 797          * at least one descriptor unused in the ring so that it doesn't
 798          * wrap and look empty.
 799          *
 800          * The only time we should loop here is when we hit the race
 801          * between marking the queue awake and updating the cleared index.
 802          * Just loop and it will appear. This comes from the acenic driver.
 803          */
 804         while(unlikely(typhoon_num_free_tx(txRing) < (numDesc + 2)))
 805                 smp_rmb();
 806
 807         first_txd = (struct tx_desc *) (txRing->ringBase + txRing->lastWrite);
 808         typhoon_inc_tx_index(&txRing->lastWrite, 1);
 809
 810         first_txd->flags = TYPHOON_TX_DESC | TYPHOON_DESC_VALID;
 811         first_txd->numDesc = 0;
 812         first_txd->len = 0;
 813         first_txd->tx_addr = (u64)((unsigned long) skb);
 814         first_txd->processFlags = 0;
 815
 816         if(skb->ip_summed == CHECKSUM_PARTIAL) {
 817                 /* The 3XP will figure out if this is UDP/TCP */
 818                 first_txd->processFlags |= TYPHOON_TX_PF_TCP_CHKSUM;
 819                 first_txd->processFlags |= TYPHOON_TX_PF_UDP_CHKSUM;
 820                 first_txd->processFlags |= TYPHOON_TX_PF_IP_CHKSUM;
 821         }
 822
 823         if(vlan_tx_tag_present(skb)) {
 824                 first_txd->processFlags |=
 825                     TYPHOON_TX_PF_INSERT_VLAN | TYPHOON_TX_PF_VLAN_PRIORITY;
 826                 first_txd->processFlags |=
 827                     cpu_to_le32(ntohs(vlan_tx_tag_get(skb)) <<
 828                                 TYPHOON_TX_PF_VLAN_TAG_SHIFT);
 829         }
 830
 831         if (skb_is_gso(skb)) {
 832                 first_txd->processFlags |= TYPHOON_TX_PF_TCP_SEGMENT;
 833                 first_txd->numDesc++;
 834
 835                 typhoon_tso_fill(skb, txRing, tp->txlo_dma_addr);
 836         }
 837
 838         txd = (struct tx_desc *) (txRing->ringBase + txRing->lastWrite);
 839         typhoon_inc_tx_index(&txRing->lastWrite, 1);
 840
 841         /* No need to worry about padding packet -- the firmware pads
 842          * it with zeros to ETH_ZLEN for us.
 843          */
 844         if(skb_shinfo(skb)->nr_frags == 0) {
 845                 skb_dma = pci_map_single(tp->tx_pdev, skb->data, skb->len,
 846                                        PCI_DMA_TODEVICE);
 847                 txd->flags = TYPHOON_FRAG_DESC | TYPHOON_DESC_VALID;
 848                 txd->len = cpu_to_le16(skb->len);
 849                 txd->frag.addr = cpu_to_le32(skb_dma);
 850                 txd->frag.addrHi = 0;
 851                 first_txd->numDesc++;
 852         } else {
 853                 int i, len;
 854
 855                 len = skb_headlen(skb);
 856                 skb_dma = pci_map_single(tp->tx_pdev, skb->data, len,
 857                                          PCI_DMA_TODEVICE);
 858                 txd->flags = TYPHOON_FRAG_DESC | TYPHOON_DESC_VALID;
 859                 txd->len = cpu_to_le16(len);
 860                 txd->frag.addr = cpu_to_le32(skb_dma);
 861                 txd->frag.addrHi = 0;
 862                 first_txd->numDesc++;
 863
 864                 for(i = 0; i < skb_shinfo(skb)->nr_frags; i++) {
 865                         skb_frag_t *frag = &skb_shinfo(skb)->frags[i];
 866                         void *frag_addr;
 867
 868                         txd = (struct tx_desc *) (txRing->ringBase +
 869                                                 txRing->lastWrite);
 870                         typhoon_inc_tx_index(&txRing->lastWrite, 1);
 871
 872                         len = frag->size;
 873                         frag_addr = (void *) page_address(frag->page) +
 874                                                 frag->page_offset;
 875                         skb_dma = pci_map_single(tp->tx_pdev, frag_addr, len,
 876                                          PCI_DMA_TODEVICE);
 877                         txd->flags = TYPHOON_FRAG_DESC | TYPHOON_DESC_VALID;
 878                         txd->len = cpu_to_le16(len);
 879                         txd->frag.addr = cpu_to_le32(skb_dma);
 880                         txd->frag.addrHi = 0;
 881                         first_txd->numDesc++;
 882                 }
 883         }
 884
 885         /* Kick the 3XP
 886          */
 887         wmb();
 888         iowrite32(txRing->lastWrite, tp->tx_ioaddr + txRing->writeRegister);
 889
 890         dev->trans_start = jiffies;
 891
 892         /* If we don't have room to put the worst case packet on the
 893          * queue, then we must stop the queue. We need 2 extra
 894          * descriptors -- one to prevent ring wrap, and one for the
 895          * Tx header.
 896          */
 897         numDesc = MAX_SKB_FRAGS + TSO_NUM_DESCRIPTORS + 1;
 898
 899         if(typhoon_num_free_tx(txRing) < (numDesc + 2)) {
 900                 netif_stop_queue(dev);
 901
 902                 /* A Tx complete IRQ could have gotten inbetween, making
 903                  * the ring free again. Only need to recheck here, since
 904                  * Tx is serialized.
 905                  */
 906                 if(typhoon_num_free_tx(txRing) >= (numDesc + 2))
 907                         netif_wake_queue(dev);
 908         }
 909
 910         return 0;
 911 }
 912
 913 static void
 914 typhoon_set_rx_mode(struct net_device *dev)
 915 {
 916         struct typhoon *tp = netdev_priv(dev);
 917         struct cmd_desc xp_cmd;
 918         u32 mc_filter[2];
 919         __le16 filter;
 920
 921         filter = TYPHOON_RX_FILTER_DIRECTED | TYPHOON_RX_FILTER_BROADCAST;
 922         if(dev->flags & IFF_PROMISC) {
 923                 filter |= TYPHOON_RX_FILTER_PROMISCOUS;
 924         } else if((dev->mc_count > multicast_filter_limit) ||
 925                   (dev->flags & IFF_ALLMULTI)) {
 926                 /* Too many to match, or accept all multicasts. */
 927                 filter |= TYPHOON_RX_FILTER_ALL_MCAST;
 928         } else if(dev->mc_count) {
 929                 struct dev_mc_list *mclist;
 930                 int i;
 931
 932                 memset(mc_filter, 0, sizeof(mc_filter));
 933                 for(i = 0, mclist = dev->mc_list; mclist && i < dev->mc_count;
 934                     i++, mclist = mclist->next) {
 935                         int bit = ether_crc(ETH_ALEN, mclist->dmi_addr) & 0x3f;
 936                         mc_filter[bit >> 5] |= 1 << (bit & 0x1f);
 937                 }
 938
 939                 INIT_COMMAND_NO_RESPONSE(&xp_cmd,
 940                                          TYPHOON_CMD_SET_MULTICAST_HASH);
 941                 xp_cmd.parm1 = TYPHOON_MCAST_HASH_SET;
 942                 xp_cmd.parm2 = cpu_to_le32(mc_filter[0]);
 943                 xp_cmd.parm3 = cpu_to_le32(mc_filter[1]);
 944                 typhoon_issue_command(tp, 1, &xp_cmd, 0, NULL);
 945
 946                 filter |= TYPHOON_RX_FILTER_MCAST_HASH;
 947         }
 948
 949         INIT_COMMAND_NO_RESPONSE(&xp_cmd, TYPHOON_CMD_SET_RX_FILTER);
 950         xp_cmd.parm1 = filter;
 951         typhoon_issue_command(tp, 1, &xp_cmd, 0, NULL);
 952 }
 953
 954 static int
 955 typhoon_do_get_stats(struct typhoon *tp)
 956 {
 957         struct net_device_stats *stats = &tp->stats;
 958         struct net_device_stats *saved = &tp->stats_saved;
 959         struct cmd_desc xp_cmd;
 960         struct resp_desc xp_resp[7];
 961         struct stats_resp *s = (struct stats_resp *) xp_resp;
 962         int err;
 963
 964         INIT_COMMAND_WITH_RESPONSE(&xp_cmd, TYPHOON_CMD_READ_STATS);
 965         err = typhoon_issue_command(tp, 1, &xp_cmd, 7, xp_resp);
 966         if(err < 0)
 967                 return err;
 968
 969         /* 3Com's Linux driver uses txMultipleCollisions as it's
 970          * collisions value, but there is some other collision info as well...
 971          *
 972          * The extra status reported would be a good candidate for
 973          * ethtool_ops->get_{strings,stats}()
 974          */
 975         stats->tx_packets = le32_to_cpu(s->txPackets);
 976         stats->tx_bytes = le64_to_cpu(s->txBytes);
 977         stats->tx_errors = le32_to_cpu(s->txCarrierLost);
 978         stats->tx_carrier_errors = le32_to_cpu(s->txCarrierLost);
 979         stats->collisions = le32_to_cpu(s->txMultipleCollisions);
 980         stats->rx_packets = le32_to_cpu(s->rxPacketsGood);
 981         stats->rx_bytes = le64_to_cpu(s->rxBytesGood);
 982         stats->rx_fifo_errors = le32_to_cpu(s->rxFifoOverruns);
 983         stats->rx_errors = le32_to_cpu(s->rxFifoOverruns) +
 984                         le32_to_cpu(s->BadSSD) + le32_to_cpu(s->rxCrcErrors);
 985         stats->rx_crc_errors = le32_to_cpu(s->rxCrcErrors);
 986         stats->rx_length_errors = le32_to_cpu(s->rxOversized);
 987         tp->speed = (s->linkStatus & TYPHOON_LINK_100MBPS) ?
 988                         SPEED_100 : SPEED_10;
 989         tp->duplex = (s->linkStatus & TYPHOON_LINK_FULL_DUPLEX) ?
 990                         DUPLEX_FULL : DUPLEX_HALF;
 991
 992         /* add in the saved statistics
 993          */
 994         stats->tx_packets += saved->tx_packets;
 995         stats->tx_bytes += saved->tx_bytes;
 996         stats->tx_errors += saved->tx_errors;
 997         stats->collisions += saved->collisions;
 998         stats->rx_packets += saved->rx_packets;
 999         stats->rx_bytes += saved->rx_bytes;
1000         stats->rx_fifo_errors += saved->rx_fifo_errors;
1001         stats->rx_errors += saved->rx_errors;
1002         stats->rx_crc_errors += saved->rx_crc_errors;
1003         stats->rx_length_errors += saved->rx_length_errors;
1004
1005         return 0;
1006 }
1007
1008 static struct net_device_stats *
1009 typhoon_get_stats(struct net_device *dev)
1010 {
1011         struct typhoon *tp = netdev_priv(dev);
1012         struct net_device_stats *stats = &tp->stats;
1013         struct net_device_stats *saved = &tp->stats_saved;
1014
1015         smp_rmb();
1016         if(tp->card_state == Sleeping)
1017                 return saved;
1018
1019         if(typhoon_do_get_stats(tp) < 0) {
1020                 printk(KERN_ERR "%s: error getting stats\n", dev->name);
1021                 return saved;
1022         }
1023
1024         return stats;
1025 }
1026
1027 static int
1028 typhoon_set_mac_address(struct net_device *dev, void *addr)
1029 {
1030         struct sockaddr *saddr = (struct sockaddr *) addr;
1031
1032         if(netif_running(dev))
1033                 return -EBUSY;
1034
1035         memcpy(dev->dev_addr, saddr->sa_data, dev->addr_len);
1036         return 0;
1037 }
1038
1039 static void
1040 typhoon_get_drvinfo(struct net_device *dev, struct ethtool_drvinfo *info)
1041 {
1042         struct typhoon *tp = netdev_priv(dev);
1043         struct pci_dev *pci_dev = tp->pdev;
1044         struct cmd_desc xp_cmd;
1045         struct resp_desc xp_resp[3];
1046
1047         smp_rmb();
1048         if(tp->card_state == Sleeping) {
1049                 strcpy(info->fw_version, "Sleep image");
1050         } else {
1051                 INIT_COMMAND_WITH_RESPONSE(&xp_cmd, TYPHOON_CMD_READ_VERSIONS);
1052                 if(typhoon_issue_command(tp, 1, &xp_cmd, 3, xp_resp) < 0) {
1053                         strcpy(info->fw_version, "Unknown runtime");
1054                 } else {
1055                         u32 sleep_ver = le32_to_cpu(xp_resp[0].parm2);
1056                         snprintf(info->fw_version, 32, "%02x.%03x.%03x",
1057                                  sleep_ver >> 24, (sleep_ver >> 12) & 0xfff,
1058                                  sleep_ver & 0xfff);
1059                 }
1060         }
1061
1062         strcpy(info->driver, DRV_MODULE_NAME);
1063         strcpy(info->version, DRV_MODULE_VERSION);
1064         strcpy(info->bus_info, pci_name(pci_dev));
1065 }
1066
1067 static int
1068 typhoon_get_settings(struct net_device *dev, struct ethtool_cmd *cmd)
1069 {
1070         struct typhoon *tp = netdev_priv(dev);
1071
1072         cmd->supported = SUPPORTED_100baseT_Half | SUPPORTED_100baseT_Full |
1073                                 SUPPORTED_Autoneg;
1074
1075         switch (tp->xcvr_select) {
1076         case TYPHOON_XCVR_10HALF:
1077                 cmd->advertising = ADVERTISED_10baseT_Half;
1078                 break;
1079         case TYPHOON_XCVR_10FULL:
1080                 cmd->advertising = ADVERTISED_10baseT_Full;
1081                 break;
1082         case TYPHOON_XCVR_100HALF:
1083                 cmd->advertising = ADVERTISED_100baseT_Half;
1084                 break;
1085         case TYPHOON_XCVR_100FULL:
1086                 cmd->advertising = ADVERTISED_100baseT_Full;
1087                 break;
1088         case TYPHOON_XCVR_AUTONEG:
1089                 cmd->advertising = ADVERTISED_10baseT_Half |
1090                                             ADVERTISED_10baseT_Full |
1091                                             ADVERTISED_100baseT_Half |
1092                                             ADVERTISED_100baseT_Full |
1093                                             ADVERTISED_Autoneg;
1094                 break;
1095         }
1096
1097         if(tp->capabilities & TYPHOON_FIBER) {
1098                 cmd->supported |= SUPPORTED_FIBRE;
1099                 cmd->advertising |= ADVERTISED_FIBRE;
1100                 cmd->port = PORT_FIBRE;
1101         } else {
1102                 cmd->supported |= SUPPORTED_10baseT_Half |
1103                                         SUPPORTED_10baseT_Full |
1104                                         SUPPORTED_TP;
1105                 cmd->advertising |= ADVERTISED_TP;
1106                 cmd->port = PORT_TP;
1107         }
1108
1109         /* need to get stats to make these link speed/duplex valid */
1110         typhoon_do_get_stats(tp);
1111         cmd->speed = tp->speed;
1112         cmd->duplex = tp->duplex;
1113         cmd->phy_address = 0;
1114         cmd->transceiver = XCVR_INTERNAL;
1115         if(tp->xcvr_select == TYPHOON_XCVR_AUTONEG)
1116                 cmd->autoneg = AUTONEG_ENABLE;
1117         else
1118                 cmd->autoneg = AUTONEG_DISABLE;
1119         cmd->maxtxpkt = 1;
1120         cmd->maxrxpkt = 1;
1121
1122         return 0;
1123 }
1124
1125 static int
1126 typhoon_set_settings(struct net_device *dev, struct ethtool_cmd *cmd)
1127 {
1128         struct typhoon *tp = netdev_priv(dev);
1129         struct cmd_desc xp_cmd;
1130         __le16 xcvr;
1131         int err;
1132
1133         err = -EINVAL;
1134         if(cmd->autoneg == AUTONEG_ENABLE) {
1135                 xcvr = TYPHOON_XCVR_AUTONEG;
1136         } else {
1137                 if(cmd->duplex == DUPLEX_HALF) {
1138                         if(cmd->speed == SPEED_10)
1139                                 xcvr = TYPHOON_XCVR_10HALF;
1140                         else if(cmd->speed == SPEED_100)
1141                                 xcvr = TYPHOON_XCVR_100HALF;
1142                         else
1143                                 goto out;
1144                 } else if(cmd->duplex == DUPLEX_FULL) {
1145                         if(cmd->speed == SPEED_10)
1146                                 xcvr = TYPHOON_XCVR_10FULL;
1147                         else if(cmd->speed == SPEED_100)
1148                                 xcvr = TYPHOON_XCVR_100FULL;
1149                         else
1150                                 goto out;
1151                 } else
1152                         goto out;
1153         }
1154
1155         INIT_COMMAND_NO_RESPONSE(&xp_cmd, TYPHOON_CMD_XCVR_SELECT);
1156         xp_cmd.parm1 = xcvr;
1157         err = typhoon_issue_command(tp, 1, &xp_cmd, 0, NULL);
1158         if(err < 0)
1159                 goto out;
1160
1161         tp->xcvr_select = xcvr;
1162         if(cmd->autoneg == AUTONEG_ENABLE) {
1163                 tp->speed = 0xff;       /* invalid */
1164                 tp->duplex = 0xff;      /* invalid */
1165         } else {
1166                 tp->speed = cmd->speed;
1167                 tp->duplex = cmd->duplex;
1168         }
1169
1170 out:
1171         return err;
1172 }
1173
1174 static void
1175 typhoon_get_wol(struct net_device *dev, struct ethtool_wolinfo *wol)
1176 {
1177         struct typhoon *tp = netdev_priv(dev);
1178
1179         wol->supported = WAKE_PHY | WAKE_MAGIC;
1180         wol->wolopts = 0;
1181         if(tp->wol_events & TYPHOON_WAKE_LINK_EVENT)
1182                 wol->wolopts |= WAKE_PHY;
1183         if(tp->wol_events & TYPHOON_WAKE_MAGIC_PKT)
1184                 wol->wolopts |= WAKE_MAGIC;
1185         memset(&wol->sopass, 0, sizeof(wol->sopass));
1186 }
1187
1188 static int
1189 typhoon_set_wol(struct net_device *dev, struct ethtool_wolinfo *wol)
1190 {
1191         struct typhoon *tp = netdev_priv(dev);
1192
1193         if(wol->wolopts & ~(WAKE_PHY | WAKE_MAGIC))
1194                 return -EINVAL;
1195
1196         tp->wol_events = 0;
1197         if(wol->wolopts & WAKE_PHY)
1198                 tp->wol_events |= TYPHOON_WAKE_LINK_EVENT;
1199         if(wol->wolopts & WAKE_MAGIC)
1200                 tp->wol_events |= TYPHOON_WAKE_MAGIC_PKT;
1201
1202         return 0;
1203 }
1204
1205 static u32
1206 typhoon_get_rx_csum(struct net_device *dev)
1207 {
1208         /* For now, we don't allow turning off RX checksums.
1209          */
1210         return 1;
1211 }
1212
1213 static void
1214 typhoon_get_ringparam(struct net_device *dev, struct ethtool_ringparam *ering)
1215 {
1216         ering->rx_max_pending = RXENT_ENTRIES;
1217         ering->rx_mini_max_pending = 0;
1218         ering->rx_jumbo_max_pending = 0;
1219         ering->tx_max_pending = TXLO_ENTRIES - 1;
1220
1221         ering->rx_pending = RXENT_ENTRIES;
1222         ering->rx_mini_pending = 0;
1223         ering->rx_jumbo_pending = 0;
1224         ering->tx_pending = TXLO_ENTRIES - 1;
1225 }
1226
1227 static const struct ethtool_ops typhoon_ethtool_ops = {
1228         .get_settings           = typhoon_get_settings,
1229         .set_settings           = typhoon_set_settings,
1230         .get_drvinfo            = typhoon_get_drvinfo,
1231         .get_wol                = typhoon_get_wol,
1232         .set_wol                = typhoon_set_wol,
1233         .get_link               = ethtool_op_get_link,
1234         .get_rx_csum            = typhoon_get_rx_csum,
1235         .set_tx_csum            = ethtool_op_set_tx_csum,
1236         .set_sg                 = ethtool_op_set_sg,
1237         .set_tso                = ethtool_op_set_tso,
1238         .get_ringparam          = typhoon_get_ringparam,
1239 };
1240
1241 static int
1242 typhoon_wait_interrupt(void __iomem *ioaddr)
1243 {
1244         int i, err = 0;
1245
1246         for(i = 0; i < TYPHOON_WAIT_TIMEOUT; i++) {
1247                 if(ioread32(ioaddr + TYPHOON_REG_INTR_STATUS) &
1248                    TYPHOON_INTR_BOOTCMD)
1249                         goto out;
1250                 udelay(TYPHOON_UDELAY);
1251         }
1252
1253         err = -ETIMEDOUT;
1254
1255 out:
1256         iowrite32(TYPHOON_INTR_BOOTCMD, ioaddr + TYPHOON_REG_INTR_STATUS);
1257         return err;
1258 }
1259
1260 #define shared_offset(x)        offsetof(struct typhoon_shared, x)
1261
1262 static void
1263 typhoon_init_interface(struct typhoon *tp)
1264 {
1265         struct typhoon_interface *iface = &tp->shared->iface;
1266         dma_addr_t shared_dma;
1267
1268         memset(tp->shared, 0, sizeof(struct typhoon_shared));
1269
1270         /* The *Hi members of iface are all init'd to zero by the memset().
1271          */
1272         shared_dma = tp->shared_dma + shared_offset(indexes);
1273         iface->ringIndex = cpu_to_le32(shared_dma);
1274
1275         shared_dma = tp->shared_dma + shared_offset(txLo);
1276         iface->txLoAddr = cpu_to_le32(shared_dma);
1277         iface->txLoSize = cpu_to_le32(TXLO_ENTRIES * sizeof(struct tx_desc));
1278
1279         shared_dma = tp->shared_dma + shared_offset(txHi);
1280         iface->txHiAddr = cpu_to_le32(shared_dma);
1281         iface->txHiSize = cpu_to_le32(TXHI_ENTRIES * sizeof(struct tx_desc));
1282
1283         shared_dma = tp->shared_dma + shared_offset(rxBuff);
1284         iface->rxBuffAddr = cpu_to_le32(shared_dma);
1285         iface->rxBuffSize = cpu_to_le32(RXFREE_ENTRIES *
1286                                         sizeof(struct rx_free));
1287
1288         shared_dma = tp->shared_dma + shared_offset(rxLo);
1289         iface->rxLoAddr = cpu_to_le32(shared_dma);
1290         iface->rxLoSize = cpu_to_le32(RX_ENTRIES * sizeof(struct rx_desc));
1291
1292         shared_dma = tp->shared_dma + shared_offset(rxHi);
1293         iface->rxHiAddr = cpu_to_le32(shared_dma);
1294         iface->rxHiSize = cpu_to_le32(RX_ENTRIES * sizeof(struct rx_desc));
1295
1296         shared_dma = tp->shared_dma + shared_offset(cmd);
1297         iface->cmdAddr = cpu_to_le32(shared_dma);
1298         iface->cmdSize = cpu_to_le32(COMMAND_RING_SIZE);
1299
1300         shared_dma = tp->shared_dma + shared_offset(resp);
1301         iface->respAddr = cpu_to_le32(shared_dma);
1302         iface->respSize = cpu_to_le32(RESPONSE_RING_SIZE);
1303
1304         shared_dma = tp->shared_dma + shared_offset(zeroWord);
1305         iface->zeroAddr = cpu_to_le32(shared_dma);
1306
1307         tp->indexes = &tp->shared->indexes;
1308         tp->txLoRing.ringBase = (u8 *) tp->shared->txLo;
1309         tp->txHiRing.ringBase = (u8 *) tp->shared->txHi;
1310         tp->rxLoRing.ringBase = (u8 *) tp->shared->rxLo;
1311         tp->rxHiRing.ringBase = (u8 *) tp->shared->rxHi;
1312         tp->rxBuffRing.ringBase = (u8 *) tp->shared->rxBuff;
1313         tp->cmdRing.ringBase = (u8 *) tp->shared->cmd;
1314         tp->respRing.ringBase = (u8 *) tp->shared->resp;
1315
1316         tp->txLoRing.writeRegister = TYPHOON_REG_TX_LO_READY;
1317         tp->txHiRing.writeRegister = TYPHOON_REG_TX_HI_READY;
1318
1319         tp->txlo_dma_addr = le32_to_cpu(iface->txLoAddr);
1320         tp->card_state = Sleeping;
1321         smp_wmb();
1322
1323         tp->offload = TYPHOON_OFFLOAD_IP_CHKSUM | TYPHOON_OFFLOAD_TCP_CHKSUM;
1324         tp->offload |= TYPHOON_OFFLOAD_UDP_CHKSUM | TSO_OFFLOAD_ON;
1325
1326         spin_lock_init(&tp->command_lock);
1327         spin_lock_init(&tp->state_lock);
1328 }
1329
1330 static void
1331 typhoon_init_rings(struct typhoon *tp)
1332 {
1333         memset(tp->indexes, 0, sizeof(struct typhoon_indexes));
1334
1335         tp->txLoRing.lastWrite = 0;
1336         tp->txHiRing.lastWrite = 0;
1337         tp->rxLoRing.lastWrite = 0;
1338         tp->rxHiRing.lastWrite = 0;
1339         tp->rxBuffRing.lastWrite = 0;
1340         tp->cmdRing.lastWrite = 0;
1341         tp->cmdRing.lastWrite = 0;
1342
1343         tp->txLoRing.lastRead = 0;
1344         tp->txHiRing.lastRead = 0;
1345 }
1346
1347 static int
1348 typhoon_download_firmware(struct typhoon *tp)
1349 {
1350         void __iomem *ioaddr = tp->ioaddr;
1351         struct pci_dev *pdev = tp->pdev;
1352         struct typhoon_file_header *fHdr;
1353         struct typhoon_section_header *sHdr;
1354         u8 *image_data;
1355         void *dpage;
1356         dma_addr_t dpage_dma;
1357         __sum16 csum;
1358         u32 irqEnabled;
1359         u32 irqMasked;
1360         u32 numSections;
1361         u32 section_len;
1362         u32 len;
1363         u32 load_addr;
1364         u32 hmac;
1365         int i;
1366         int err;
1367
1368         err = -EINVAL;
1369         fHdr = (struct typhoon_file_header *) typhoon_firmware_image;
1370         image_data = (u8 *) fHdr;
1371
1372         if(memcmp(fHdr->tag, "TYPHOON", 8)) {
1373                 printk(KERN_ERR "%s: Invalid firmware image!\n", tp->name);
1374                 goto err_out;
1375         }
1376
1377         /* Cannot just map the firmware image using pci_map_single() as
1378          * the firmware is part of the kernel/module image, so we allocate
1379          * some consistent memory to copy the sections into, as it is simpler,
1380          * and short-lived. If we ever split out and require a userland
1381          * firmware loader, then we can revisit this.
1382          */
1383         err = -ENOMEM;
1384         dpage = pci_alloc_consistent(pdev, PAGE_SIZE, &dpage_dma);
1385         if(!dpage) {
1386                 printk(KERN_ERR "%s: no DMA mem for firmware\n", tp->name);
1387                 goto err_out;
1388         }
1389
1390         irqEnabled = ioread32(ioaddr + TYPHOON_REG_INTR_ENABLE);
1391         iowrite32(irqEnabled | TYPHOON_INTR_BOOTCMD,
1392                ioaddr + TYPHOON_REG_INTR_ENABLE);
1393         irqMasked = ioread32(ioaddr + TYPHOON_REG_INTR_MASK);
1394         iowrite32(irqMasked | TYPHOON_INTR_BOOTCMD,
1395                ioaddr + TYPHOON_REG_INTR_MASK);
1396
1397         err = -ETIMEDOUT;
1398         if(typhoon_wait_status(ioaddr, TYPHOON_STATUS_WAITING_FOR_HOST) < 0) {
1399                 printk(KERN_ERR "%s: card ready timeout\n", tp->name);
1400                 goto err_out_irq;
1401         }
1402
1403         numSections = le32_to_cpu(fHdr->numSections);
1404         load_addr = le32_to_cpu(fHdr->startAddr);
1405
1406         iowrite32(TYPHOON_INTR_BOOTCMD, ioaddr + TYPHOON_REG_INTR_STATUS);
1407         iowrite32(load_addr, ioaddr + TYPHOON_REG_DOWNLOAD_BOOT_ADDR);
1408         hmac = le32_to_cpu(fHdr->hmacDigest[0]);
1409         iowrite32(hmac, ioaddr + TYPHOON_REG_DOWNLOAD_HMAC_0);
1410         hmac = le32_to_cpu(fHdr->hmacDigest[1]);
1411         iowrite32(hmac, ioaddr + TYPHOON_REG_DOWNLOAD_HMAC_1);
1412         hmac = le32_to_cpu(fHdr->hmacDigest[2]);
1413         iowrite32(hmac, ioaddr + TYPHOON_REG_DOWNLOAD_HMAC_2);
1414         hmac = le32_to_cpu(fHdr->hmacDigest[3]);
1415         iowrite32(hmac, ioaddr + TYPHOON_REG_DOWNLOAD_HMAC_3);
1416         hmac = le32_to_cpu(fHdr->hmacDigest[4]);
1417         iowrite32(hmac, ioaddr + TYPHOON_REG_DOWNLOAD_HMAC_4);
1418         typhoon_post_pci_writes(ioaddr);
1419         iowrite32(TYPHOON_BOOTCMD_RUNTIME_IMAGE, ioaddr + TYPHOON_REG_COMMAND);
1420
1421         image_data += sizeof(struct typhoon_file_header);
1422
1423         /* The ioread32() in typhoon_wait_interrupt() will force the
1424          * last write to the command register to post, so
1425          * we don't need a typhoon_post_pci_writes() after it.
1426          */
1427         for(i = 0; i < numSections; i++) {
1428                 sHdr = (struct typhoon_section_header *) image_data;
1429                 image_data += sizeof(struct typhoon_section_header);
1430                 load_addr = le32_to_cpu(sHdr->startAddr);
1431                 section_len = le32_to_cpu(sHdr->len);
1432
1433                 while(section_len) {
1434                         len = min_t(u32, section_len, PAGE_SIZE);
1435
1436                         if(typhoon_wait_interrupt(ioaddr) < 0 ||
1437                            ioread32(ioaddr + TYPHOON_REG_STATUS) !=
1438                            TYPHOON_STATUS_WAITING_FOR_SEGMENT) {
1439                                 printk(KERN_ERR "%s: segment ready timeout\n",
1440                                        tp->name);
1441                                 goto err_out_irq;
1442                         }
1443
1444                         /* Do an pseudo IPv4 checksum on the data -- first
1445                          * need to convert each u16 to cpu order before
1446                          * summing. Fortunately, due to the properties of
1447                          * the checksum, we can do this once, at the end.
1448                          */
1449                         csum = csum_fold(csum_partial_copy_nocheck(image_data,
1450                                                                   dpage, len,
1451                                                                   0));
1452
1453                         iowrite32(len, ioaddr + TYPHOON_REG_BOOT_LENGTH);
1454                         iowrite32(le16_to_cpu((__force __le16)csum),
1455                                         ioaddr + TYPHOON_REG_BOOT_CHECKSUM);
1456                         iowrite32(load_addr,
1457                                         ioaddr + TYPHOON_REG_BOOT_DEST_ADDR);
1458                         iowrite32(0, ioaddr + TYPHOON_REG_BOOT_DATA_HI);
1459                         iowrite32(dpage_dma, ioaddr + TYPHOON_REG_BOOT_DATA_LO);
1460                         typhoon_post_pci_writes(ioaddr);
1461                         iowrite32(TYPHOON_BOOTCMD_SEG_AVAILABLE,
1462                                ioaddr + TYPHOON_REG_COMMAND);
1463
1464                         image_data += len;
1465                         load_addr += len;
1466                         section_len -= len;
1467                 }
1468         }
1469
1470         if(typhoon_wait_interrupt(ioaddr) < 0 ||
1471            ioread32(ioaddr + TYPHOON_REG_STATUS) !=
1472            TYPHOON_STATUS_WAITING_FOR_SEGMENT) {
1473                 printk(KERN_ERR "%s: final segment ready timeout\n", tp->name);
1474                 goto err_out_irq;
1475         }
1476
1477         iowrite32(TYPHOON_BOOTCMD_DNLD_COMPLETE, ioaddr + TYPHOON_REG_COMMAND);
1478
1479         if(typhoon_wait_status(ioaddr, TYPHOON_STATUS_WAITING_FOR_BOOT) < 0) {
1480                 printk(KERN_ERR "%s: boot ready timeout, status 0x%0x\n",
1481                        tp->name, ioread32(ioaddr + TYPHOON_REG_STATUS));
1482                 goto err_out_irq;
1483         }
1484
1485         err = 0;
1486
1487 err_out_irq:
1488         iowrite32(irqMasked, ioaddr + TYPHOON_REG_INTR_MASK);
1489         iowrite32(irqEnabled, ioaddr + TYPHOON_REG_INTR_ENABLE);
1490
1491         pci_free_consistent(pdev, PAGE_SIZE, dpage, dpage_dma);
1492
1493 err_out:
1494         return err;
1495 }
1496
1497 static int
1498 typhoon_boot_3XP(struct typhoon *tp, u32 initial_status)
1499 {
1500         void __iomem *ioaddr = tp->ioaddr;
1501
1502         if(typhoon_wait_status(ioaddr, initial_status) < 0) {
1503                 printk(KERN_ERR "%s: boot ready timeout\n", tp->name);
1504                 goto out_timeout;
1505         }
1506
1507         iowrite32(0, ioaddr + TYPHOON_REG_BOOT_RECORD_ADDR_HI);
1508         iowrite32(tp->shared_dma, ioaddr + TYPHOON_REG_BOOT_RECORD_ADDR_LO);
1509         typhoon_post_pci_writes(ioaddr);
1510         iowrite32(TYPHOON_BOOTCMD_REG_BOOT_RECORD,
1511                                 ioaddr + TYPHOON_REG_COMMAND);
1512
1513         if(typhoon_wait_status(ioaddr, TYPHOON_STATUS_RUNNING) < 0) {
1514                 printk(KERN_ERR "%s: boot finish timeout (status 0x%x)\n",
1515                        tp->name, ioread32(ioaddr + TYPHOON_REG_STATUS));
1516                 goto out_timeout;
1517         }
1518
1519         /* Clear the Transmit and Command ready registers
1520          */
1521         iowrite32(0, ioaddr + TYPHOON_REG_TX_HI_READY);
1522         iowrite32(0, ioaddr + TYPHOON_REG_CMD_READY);
1523         iowrite32(0, ioaddr + TYPHOON_REG_TX_LO_READY);
1524         typhoon_post_pci_writes(ioaddr);
1525         iowrite32(TYPHOON_BOOTCMD_BOOT, ioaddr + TYPHOON_REG_COMMAND);
1526
1527         return 0;
1528
1529 out_timeout:
1530         return -ETIMEDOUT;
1531 }
1532
1533 static u32
1534 typhoon_clean_tx(struct typhoon *tp, struct transmit_ring *txRing,
1535                         volatile __le32 * index)
1536 {
1537         u32 lastRead = txRing->lastRead;
1538         struct tx_desc *tx;
1539         dma_addr_t skb_dma;
1540         int dma_len;
1541         int type;
1542
1543         while(lastRead != le32_to_cpu(*index)) {
1544                 tx = (struct tx_desc *) (txRing->ringBase + lastRead);
1545                 type = tx->flags & TYPHOON_TYPE_MASK;
1546
1547                 if(type == TYPHOON_TX_DESC) {
1548                         /* This tx_desc describes a packet.
1549                          */
1550                         unsigned long ptr = tx->tx_addr;
1551                         struct sk_buff *skb = (struct sk_buff *) ptr;
1552                         dev_kfree_skb_irq(skb);
1553                 } else if(type == TYPHOON_FRAG_DESC) {
1554                         /* This tx_desc describes a memory mapping. Free it.
1555                          */
1556                         skb_dma = (dma_addr_t) le32_to_cpu(tx->frag.addr);
1557                         dma_len = le16_to_cpu(tx->len);
1558                         pci_unmap_single(tp->pdev, skb_dma, dma_len,
1559                                        PCI_DMA_TODEVICE);
1560                 }
1561
1562                 tx->flags = 0;
1563                 typhoon_inc_tx_index(&lastRead, 1);
1564         }
1565
1566         return lastRead;
1567 }
1568
1569 static void
1570 typhoon_tx_complete(struct typhoon *tp, struct transmit_ring *txRing,
1571                         volatile __le32 * index)
1572 {
1573         u32 lastRead;
1574         int numDesc = MAX_SKB_FRAGS + 1;
1575
1576         /* This will need changing if we start to use the Hi Tx ring. */
1577         lastRead = typhoon_clean_tx(tp, txRing, index);
1578         if(netif_queue_stopped(tp->dev) && typhoon_num_free(txRing->lastWrite,
1579                                 lastRead, TXLO_ENTRIES) > (numDesc + 2))
1580                 netif_wake_queue(tp->dev);
1581
1582         txRing->lastRead = lastRead;
1583         smp_wmb();
1584 }
1585
1586 static void
1587 typhoon_recycle_rx_skb(struct typhoon *tp, u32 idx)
1588 {
1589         struct typhoon_indexes *indexes = tp->indexes;
1590         struct rxbuff_ent *rxb = &tp->rxbuffers[idx];
1591         struct basic_ring *ring = &tp->rxBuffRing;
1592         struct rx_free *r;
1593
1594         if((ring->lastWrite + sizeof(*r)) % (RXFREE_ENTRIES * sizeof(*r)) ==
1595                                 le32_to_cpu(indexes->rxBuffCleared)) {
1596                 /* no room in ring, just drop the skb
1597                  */
1598                 dev_kfree_skb_any(rxb->skb);
1599                 rxb->skb = NULL;
1600                 return;
1601         }
1602
1603         r = (struct rx_free *) (ring->ringBase + ring->lastWrite);
1604         typhoon_inc_rxfree_index(&ring->lastWrite, 1);
1605         r->virtAddr = idx;
1606         r->physAddr = cpu_to_le32(rxb->dma_addr);
1607
1608         /* Tell the card about it */
1609         wmb();
1610         indexes->rxBuffReady = cpu_to_le32(ring->lastWrite);
1611 }
1612
1613 static int
1614 typhoon_alloc_rx_skb(struct typhoon *tp, u32 idx)
1615 {
1616         struct typhoon_indexes *indexes = tp->indexes;
1617         struct rxbuff_ent *rxb = &tp->rxbuffers[idx];
1618         struct basic_ring *ring = &tp->rxBuffRing;
1619         struct rx_free *r;
1620         struct sk_buff *skb;
1621         dma_addr_t dma_addr;
1622
1623         rxb->skb = NULL;
1624
1625         if((ring->lastWrite + sizeof(*r)) % (RXFREE_ENTRIES * sizeof(*r)) ==
1626                                 le32_to_cpu(indexes->rxBuffCleared))
1627                 return -ENOMEM;
1628
1629         skb = dev_alloc_skb(PKT_BUF_SZ);
1630         if(!skb)
1631                 return -ENOMEM;
1632
1633 #if 0
1634         /* Please, 3com, fix the firmware to allow DMA to a unaligned
1635          * address! Pretty please?
1636          */
1637         skb_reserve(skb, 2);
1638 #endif
1639
1640         skb->dev = tp->dev;
1641         dma_addr = pci_map_single(tp->pdev, skb->data,
1642                                   PKT_BUF_SZ, PCI_DMA_FROMDEVICE);
1643
1644         /* Since no card does 64 bit DAC, the high bits will never
1645          * change from zero.
1646          */
1647         r = (struct rx_free *) (ring->ringBase + ring->lastWrite);
1648         typhoon_inc_rxfree_index(&ring->lastWrite, 1);
1649         r->virtAddr = idx;
1650         r->physAddr = cpu_to_le32(dma_addr);
1651         rxb->skb = skb;
1652         rxb->dma_addr = dma_addr;
1653
1654         /* Tell the card about it */
1655         wmb();
1656         indexes->rxBuffReady = cpu_to_le32(ring->lastWrite);
1657         return 0;
1658 }
1659
1660 static int
1661 typhoon_rx(struct typhoon *tp, struct basic_ring *rxRing, volatile __le32 * ready,
1662            volatile __le32 * cleared, int budget)
1663 {
1664         struct rx_desc *rx;
1665         struct sk_buff *skb, *new_skb;
1666         struct rxbuff_ent *rxb;
1667         dma_addr_t dma_addr;
1668         u32 local_ready;
1669         u32 rxaddr;
1670         int pkt_len;
1671         u32 idx;
1672         __le32 csum_bits;
1673         int received;
1674
1675         received = 0;
1676         local_ready = le32_to_cpu(*ready);
1677         rxaddr = le32_to_cpu(*cleared);
1678         while(rxaddr != local_ready && budget > 0) {
1679                 rx = (struct rx_desc *) (rxRing->ringBase + rxaddr);
1680                 idx = rx->addr;
1681                 rxb = &tp->rxbuffers[idx];
1682                 skb = rxb->skb;
1683                 dma_addr = rxb->dma_addr;
1684
1685                 typhoon_inc_rx_index(&rxaddr, 1);
1686
1687                 if(rx->flags & TYPHOON_RX_ERROR) {
1688                         typhoon_recycle_rx_skb(tp, idx);
1689                         continue;
1690                 }
1691
1692                 pkt_len = le16_to_cpu(rx->frameLen);
1693
1694                 if(pkt_len < rx_copybreak &&
1695                    (new_skb = dev_alloc_skb(pkt_len + 2)) != NULL) {
1696                         skb_reserve(new_skb, 2);
1697                         pci_dma_sync_single_for_cpu(tp->pdev, dma_addr,
1698                                                     PKT_BUF_SZ,
1699                                                     PCI_DMA_FROMDEVICE);
1700                         skb_copy_to_linear_data(new_skb, skb->data, pkt_len);
1701                         pci_dma_sync_single_for_device(tp->pdev, dma_addr,
1702                                                        PKT_BUF_SZ,
1703                                                        PCI_DMA_FROMDEVICE);
1704                         skb_put(new_skb, pkt_len);
1705                         typhoon_recycle_rx_skb(tp, idx);
1706                 } else {
1707                         new_skb = skb;
1708                         skb_put(new_skb, pkt_len);
1709                         pci_unmap_single(tp->pdev, dma_addr, PKT_BUF_SZ,
1710                                        PCI_DMA_FROMDEVICE);
1711                         typhoon_alloc_rx_skb(tp, idx);
1712                 }
1713                 new_skb->protocol = eth_type_trans(new_skb, tp->dev);
1714                 csum_bits = rx->rxStatus & (TYPHOON_RX_IP_CHK_GOOD |
1715                         TYPHOON_RX_UDP_CHK_GOOD | TYPHOON_RX_TCP_CHK_GOOD);
1716                 if(csum_bits ==
1717                    (TYPHOON_RX_IP_CHK_GOOD | TYPHOON_RX_TCP_CHK_GOOD)
1718                    || csum_bits ==
1719                    (TYPHOON_RX_IP_CHK_GOOD | TYPHOON_RX_UDP_CHK_GOOD)) {
1720                         new_skb->ip_summed = CHECKSUM_UNNECESSARY;
1721                 } else
1722                         new_skb->ip_summed = CHECKSUM_NONE;
1723
1724                 spin_lock(&tp->state_lock);
1725                 if(tp->vlgrp != NULL && rx->rxStatus & TYPHOON_RX_VLAN)
1726                         vlan_hwaccel_receive_skb(new_skb, tp->vlgrp,
1727                                                  ntohl(rx->vlanTag) & 0xffff);
1728                 else
1729                         netif_receive_skb(new_skb);
1730                 spin_unlock(&tp->state_lock);
1731
1732                 tp->dev->last_rx = jiffies;
1733                 received++;
1734                 budget--;
1735         }
1736         *cleared = cpu_to_le32(rxaddr);
1737
1738         return received;
1739 }
1740
1741 static void
1742 typhoon_fill_free_ring(struct typhoon *tp)
1743 {
1744         u32 i;
1745
1746         for(i = 0; i < RXENT_ENTRIES; i++) {
1747                 struct rxbuff_ent *rxb = &tp->rxbuffers[i];
1748                 if(rxb->skb)
1749                         continue;
1750                 if(typhoon_alloc_rx_skb(tp, i) < 0)
1751                         break;
1752         }
1753 }
1754
1755 static int
1756 typhoon_poll(struct napi_struct *napi, int budget)
1757 {
1758         struct typhoon *tp = container_of(napi, struct typhoon, napi);
1759         struct net_device *dev = tp->dev;
1760         struct typhoon_indexes *indexes = tp->indexes;
1761         int work_done;
1762
1763         rmb();
1764         if(!tp->awaiting_resp && indexes->respReady != indexes->respCleared)
1765                         typhoon_process_response(tp, 0, NULL);
1766
1767         if(le32_to_cpu(indexes->txLoCleared) != tp->txLoRing.lastRead)
1768                 typhoon_tx_complete(tp, &tp->txLoRing, &indexes->txLoCleared);
1769
1770         work_done = 0;
1771
1772         if(indexes->rxHiCleared != indexes->rxHiReady) {
1773                 work_done += typhoon_rx(tp, &tp->rxHiRing, &indexes->rxHiReady,
1774                                         &indexes->rxHiCleared, budget);
1775         }
1776
1777         if(indexes->rxLoCleared != indexes->rxLoReady) {
1778                 work_done += typhoon_rx(tp, &tp->rxLoRing, &indexes->rxLoReady,
1779                                         &indexes->rxLoCleared, budget - work_done);
1780         }
1781
1782         if(le32_to_cpu(indexes->rxBuffCleared) == tp->rxBuffRing.lastWrite) {
1783                 /* rxBuff ring is empty, try to fill it. */
1784                 typhoon_fill_free_ring(tp);
1785         }
1786
1787         if (work_done < budget) {
1788                 netif_rx_complete(dev, napi);
1789                 iowrite32(TYPHOON_INTR_NONE,
1790                                 tp->ioaddr + TYPHOON_REG_INTR_MASK);
1791                 typhoon_post_pci_writes(tp->ioaddr);
1792         }
1793
1794         return work_done;
1795 }
1796
1797 static irqreturn_t
1798 typhoon_interrupt(int irq, void *dev_instance)
1799 {
1800         struct net_device *dev = dev_instance;
1801         struct typhoon *tp = dev->priv;
1802         void __iomem *ioaddr = tp->ioaddr;
1803         u32 intr_status;
1804
1805         intr_status = ioread32(ioaddr + TYPHOON_REG_INTR_STATUS);
1806         if(!(intr_status & TYPHOON_INTR_HOST_INT))
1807                 return IRQ_NONE;
1808
1809         iowrite32(intr_status, ioaddr + TYPHOON_REG_INTR_STATUS);
1810
1811         if (netif_rx_schedule_prep(dev, &tp->napi)) {
1812                 iowrite32(TYPHOON_INTR_ALL, ioaddr + TYPHOON_REG_INTR_MASK);
1813                 typhoon_post_pci_writes(ioaddr);
1814                 __netif_rx_schedule(dev, &tp->napi);
1815         } else {
1816                 printk(KERN_ERR "%s: Error, poll already scheduled\n",
1817                        dev->name);
1818         }
1819         return IRQ_HANDLED;
1820 }
1821
1822 static void
1823 typhoon_free_rx_rings(struct typhoon *tp)
1824 {
1825         u32 i;
1826
1827         for(i = 0; i < RXENT_ENTRIES; i++) {
1828                 struct rxbuff_ent *rxb = &tp->rxbuffers[i];
1829                 if(rxb->skb) {
1830                         pci_unmap_single(tp->pdev, rxb->dma_addr, PKT_BUF_SZ,
1831                                        PCI_DMA_FROMDEVICE);
1832                         dev_kfree_skb(rxb->skb);
1833                         rxb->skb = NULL;
1834                 }
1835         }
1836 }
1837
1838 static int
1839 typhoon_sleep(struct typhoon *tp, pci_power_t state, __le16 events)
1840 {
1841         struct pci_dev *pdev = tp->pdev;
1842         void __iomem *ioaddr = tp->ioaddr;
1843         struct cmd_desc xp_cmd;
1844         int err;
1845
1846         INIT_COMMAND_WITH_RESPONSE(&xp_cmd, TYPHOON_CMD_ENABLE_WAKE_EVENTS);
1847         xp_cmd.parm1 = events;
1848         err = typhoon_issue_command(tp, 1, &xp_cmd, 0, NULL);
1849         if(err < 0) {
1850                 printk(KERN_ERR "%s: typhoon_sleep(): wake events cmd err %d\n",
1851                                 tp->name, err);
1852                 return err;
1853         }
1854
1855         INIT_COMMAND_NO_RESPONSE(&xp_cmd, TYPHOON_CMD_GOTO_SLEEP);
1856         err = typhoon_issue_command(tp, 1, &xp_cmd, 0, NULL);
1857         if(err < 0) {
1858                 printk(KERN_ERR "%s: typhoon_sleep(): sleep cmd err %d\n",
1859                                 tp->name, err);
1860                 return err;
1861         }
1862
1863         if(typhoon_wait_status(ioaddr, TYPHOON_STATUS_SLEEPING) < 0)
1864                 return -ETIMEDOUT;
1865
1866         /* Since we cannot monitor the status of the link while sleeping,
1867          * tell the world it went away.
1868          */
1869         netif_carrier_off(tp->dev);
1870
1871         pci_enable_wake(tp->pdev, state, 1);
1872         pci_disable_device(pdev);
1873         return pci_set_power_state(pdev, state);
1874 }
1875
1876 static int
1877 typhoon_wakeup(struct typhoon *tp, int wait_type)
1878 {
1879         struct pci_dev *pdev = tp->pdev;
1880         void __iomem *ioaddr = tp->ioaddr;
1881
1882         pci_set_power_state(pdev, PCI_D0);
1883         pci_restore_state(pdev);
1884
1885         /* Post 2.x.x versions of the Sleep Image require a reset before
1886          * we can download the Runtime Image. But let's not make users of
1887          * the old firmware pay for the reset.
1888          */
1889         iowrite32(TYPHOON_BOOTCMD_WAKEUP, ioaddr + TYPHOON_REG_COMMAND);
1890         if(typhoon_wait_status(ioaddr, TYPHOON_STATUS_WAITING_FOR_HOST) < 0 ||
1891                         (tp->capabilities & TYPHOON_WAKEUP_NEEDS_RESET))
1892                 return typhoon_reset(ioaddr, wait_type);
1893
1894         return 0;
1895 }
1896
1897 static int
1898 typhoon_start_runtime(struct typhoon *tp)
1899 {
1900         struct net_device *dev = tp->dev;
1901         void __iomem *ioaddr = tp->ioaddr;
1902         struct cmd_desc xp_cmd;
1903         int err;
1904
1905         typhoon_init_rings(tp);
1906         typhoon_fill_free_ring(tp);
1907
1908         err = typhoon_download_firmware(tp);
1909         if(err < 0) {
1910                 printk("%s: cannot load runtime on 3XP\n", tp->name);
1911                 goto error_out;
1912         }
1913
1914         if(typhoon_boot_3XP(tp, TYPHOON_STATUS_WAITING_FOR_BOOT) < 0) {
1915                 printk("%s: cannot boot 3XP\n", tp->name);
1916                 err = -EIO;
1917                 goto error_out;
1918         }
1919
1920         INIT_COMMAND_NO_RESPONSE(&xp_cmd, TYPHOON_CMD_SET_MAX_PKT_SIZE);
1921         xp_cmd.parm1 = cpu_to_le16(PKT_BUF_SZ);
1922         err = typhoon_issue_command(tp, 1, &xp_cmd, 0, NULL);
1923         if(err < 0)
1924                 goto error_out;
1925
1926         INIT_COMMAND_NO_RESPONSE(&xp_cmd, TYPHOON_CMD_SET_MAC_ADDRESS);
1927         xp_cmd.parm1 = cpu_to_le16(ntohs(*(__be16 *)&dev->dev_addr[0]));
1928         xp_cmd.parm2 = cpu_to_le32(ntohl(*(__be32 *)&dev->dev_addr[2]));
1929         err = typhoon_issue_command(tp, 1, &xp_cmd, 0, NULL);
1930         if(err < 0)
1931                 goto error_out;
1932
1933         /* Disable IRQ coalescing -- we can reenable it when 3Com gives
1934          * us some more information on how to control it.
1935          */
1936         INIT_COMMAND_WITH_RESPONSE(&xp_cmd, TYPHOON_CMD_IRQ_COALESCE_CTRL);
1937         xp_cmd.parm1 = 0;
1938         err = typhoon_issue_command(tp, 1, &xp_cmd, 0, NULL);
1939         if(err < 0)
1940                 goto error_out;
1941
1942         INIT_COMMAND_NO_RESPONSE(&xp_cmd, TYPHOON_CMD_XCVR_SELECT);
1943         xp_cmd.parm1 = tp->xcvr_select;
1944         err = typhoon_issue_command(tp, 1, &xp_cmd, 0, NULL);
1945         if(err < 0)
1946                 goto error_out;
1947
1948         INIT_COMMAND_NO_RESPONSE(&xp_cmd, TYPHOON_CMD_VLAN_TYPE_WRITE);
1949         xp_cmd.parm1 = __constant_cpu_to_le16(ETH_P_8021Q);
1950         err = typhoon_issue_command(tp, 1, &xp_cmd, 0, NULL);
1951         if(err < 0)
1952                 goto error_out;
1953
1954         INIT_COMMAND_NO_RESPONSE(&xp_cmd, TYPHOON_CMD_SET_OFFLOAD_TASKS);
1955         spin_lock_bh(&tp->state_lock);
1956         xp_cmd.parm2 = tp->offload;
1957         xp_cmd.parm3 = tp->offload;
1958         err = typhoon_issue_command(tp, 1, &xp_cmd, 0, NULL);
1959         spin_unlock_bh(&tp->state_lock);
1960         if(err < 0)
1961                 goto error_out;
1962
1963         typhoon_set_rx_mode(dev);
1964
1965         INIT_COMMAND_NO_RESPONSE(&xp_cmd, TYPHOON_CMD_TX_ENABLE);
1966         err = typhoon_issue_command(tp, 1, &xp_cmd, 0, NULL);
1967         if(err < 0)
1968                 goto error_out;
1969
1970         INIT_COMMAND_WITH_RESPONSE(&xp_cmd, TYPHOON_CMD_RX_ENABLE);
1971         err = typhoon_issue_command(tp, 1, &xp_cmd, 0, NULL);
1972         if(err < 0)
1973                 goto error_out;
1974
1975         tp->card_state = Running;
1976         smp_wmb();
1977
1978         iowrite32(TYPHOON_INTR_ENABLE_ALL, ioaddr + TYPHOON_REG_INTR_ENABLE);
1979         iowrite32(TYPHOON_INTR_NONE, ioaddr + TYPHOON_REG_INTR_MASK);
1980         typhoon_post_pci_writes(ioaddr);
1981
1982         return 0;
1983
1984 error_out:
1985         typhoon_reset(ioaddr, WaitNoSleep);
1986         typhoon_free_rx_rings(tp);
1987         typhoon_init_rings(tp);
1988         return err;
1989 }
1990
1991 static int
1992 typhoon_stop_runtime(struct typhoon *tp, int wait_type)
1993 {
1994         struct typhoon_indexes *indexes = tp->indexes;
1995         struct transmit_ring *txLo = &tp->txLoRing;
1996         void __iomem *ioaddr = tp->ioaddr;
1997         struct cmd_desc xp_cmd;
1998         int i;
1999
2000         /* Disable interrupts early, since we can't schedule a poll
2001          * when called with !netif_running(). This will be posted
2002          * when we force the posting of the command.
2003          */
2004         iowrite32(TYPHOON_INTR_NONE, ioaddr + TYPHOON_REG_INTR_ENABLE);
2005
2006         INIT_COMMAND_NO_RESPONSE(&xp_cmd, TYPHOON_CMD_RX_DISABLE);
2007         typhoon_issue_command(tp, 1, &xp_cmd, 0, NULL);
2008
2009         /* Wait 1/2 sec for any outstanding transmits to occur
2010          * We'll cleanup after the reset if this times out.
2011          */
2012         for(i = 0; i < TYPHOON_WAIT_TIMEOUT; i++) {
2013                 if(indexes->txLoCleared == cpu_to_le32(txLo->lastWrite))
2014                         break;
2015                 udelay(TYPHOON_UDELAY);
2016         }
2017
2018         if(i == TYPHOON_WAIT_TIMEOUT)
2019                 printk(KERN_ERR
2020                        "%s: halt timed out waiting for Tx to complete\n",
2021                        tp->name);
2022
2023         INIT_COMMAND_NO_RESPONSE(&xp_cmd, TYPHOON_CMD_TX_DISABLE);
2024         typhoon_issue_command(tp, 1, &xp_cmd, 0, NULL);
2025
2026         /* save the statistics so when we bring the interface up again,
2027          * the values reported to userspace are correct.
2028          */
2029         tp->card_state = Sleeping;
2030         smp_wmb();
2031         typhoon_do_get_stats(tp);
2032         memcpy(&tp->stats_saved, &tp->stats, sizeof(struct net_device_stats));
2033
2034         INIT_COMMAND_NO_RESPONSE(&xp_cmd, TYPHOON_CMD_HALT);
2035         typhoon_issue_command(tp, 1, &xp_cmd, 0, NULL);
2036
2037         if(typhoon_wait_status(ioaddr, TYPHOON_STATUS_HALTED) < 0)
2038                 printk(KERN_ERR "%s: timed out waiting for 3XP to halt\n",
2039                        tp->name);
2040
2041         if(typhoon_reset(ioaddr, wait_type) < 0) {
2042                 printk(KERN_ERR "%s: unable to reset 3XP\n", tp->name);
2043                 return -ETIMEDOUT;
2044         }
2045
2046         /* cleanup any outstanding Tx packets */
2047         if(indexes->txLoCleared != cpu_to_le32(txLo->lastWrite)) {
2048                 indexes->txLoCleared = cpu_to_le32(txLo->lastWrite);
2049                 typhoon_clean_tx(tp, &tp->txLoRing, &indexes->txLoCleared);
2050         }
2051
2052         return 0;
2053 }
2054
2055 static void
2056 typhoon_tx_timeout(struct net_device *dev)
2057 {
2058         struct typhoon *tp = netdev_priv(dev);
2059
2060         if(typhoon_reset(tp->ioaddr, WaitNoSleep) < 0) {
2061                 printk(KERN_WARNING "%s: could not reset in tx timeout\n",
2062                                         dev->name);
2063                 goto truely_dead;
2064         }
2065
2066         /* If we ever start using the Hi ring, it will need cleaning too */
2067         typhoon_clean_tx(tp, &tp->txLoRing, &tp->indexes->txLoCleared);
2068         typhoon_free_rx_rings(tp);
2069
2070         if(typhoon_start_runtime(tp) < 0) {
2071                 printk(KERN_ERR "%s: could not start runtime in tx timeout\n",
2072                                         dev->name);
2073                 goto truely_dead;
2074         }
2075
2076         netif_wake_queue(dev);
2077         return;
2078
2079 truely_dead:
2080         /* Reset the hardware, and turn off carrier to avoid more timeouts */
2081         typhoon_reset(tp->ioaddr, NoWait);
2082         netif_carrier_off(dev);
2083 }
2084
2085 static int
2086 typhoon_open(struct net_device *dev)
2087 {
2088         struct typhoon *tp = netdev_priv(dev);
2089         int err;
2090
2091         err = typhoon_wakeup(tp, WaitSleep);
2092         if(err < 0) {
2093                 printk(KERN_ERR "%s: unable to wakeup device\n", dev->name);
2094                 goto out_sleep;
2095         }
2096
2097         err = request_irq(dev->irq, &typhoon_interrupt, IRQF_SHARED,
2098                                 dev->name, dev);
2099         if(err < 0)
2100                 goto out_sleep;
2101
2102         napi_enable(&tp->napi);
2103
2104         err = typhoon_start_runtime(tp);
2105         if(err < 0) {
2106                 napi_disable(&tp->napi);
2107                 goto out_irq;
2108         }
2109
2110         netif_start_queue(dev);
2111         return 0;
2112
2113 out_irq:
2114         free_irq(dev->irq, dev);
2115
2116 out_sleep:
2117         if(typhoon_boot_3XP(tp, TYPHOON_STATUS_WAITING_FOR_HOST) < 0) {
2118                 printk(KERN_ERR "%s: unable to reboot into sleep img\n",
2119                                 dev->name);
2120                 typhoon_reset(tp->ioaddr, NoWait);
2121                 goto out;
2122         }
2123
2124         if(typhoon_sleep(tp, PCI_D3hot, 0) < 0)
2125                 printk(KERN_ERR "%s: unable to go back to sleep\n", dev->name);
2126
2127 out:
2128         return err;
2129 }
2130
2131 static int
2132 typhoon_close(struct net_device *dev)
2133 {
2134         struct typhoon *tp = netdev_priv(dev);
2135
2136         netif_stop_queue(dev);
2137         napi_disable(&tp->napi);
2138
2139         if(typhoon_stop_runtime(tp, WaitSleep) < 0)
2140                 printk(KERN_ERR "%s: unable to stop runtime\n", dev->name);
2141
2142         /* Make sure there is no irq handler running on a different CPU. */
2143         free_irq(dev->irq, dev);
2144
2145         typhoon_free_rx_rings(tp);
2146         typhoon_init_rings(tp);
2147
2148         if(typhoon_boot_3XP(tp, TYPHOON_STATUS_WAITING_FOR_HOST) < 0)
2149                 printk(KERN_ERR "%s: unable to boot sleep image\n", dev->name);
2150
2151         if(typhoon_sleep(tp, PCI_D3hot, 0) < 0)
2152                 printk(KERN_ERR "%s: unable to put card to sleep\n", dev->name);
2153
2154         return 0;
2155 }
2156
2157 #ifdef CONFIG_PM
2158 static int
2159 typhoon_resume(struct pci_dev *pdev)
2160 {
2161         struct net_device *dev = pci_get_drvdata(pdev);
2162         struct typhoon *tp = netdev_priv(dev);
2163
2164         /* If we're down, resume when we are upped.
2165          */
2166         if(!netif_running(dev))
2167                 return 0;
2168
2169         if(typhoon_wakeup(tp, WaitNoSleep) < 0) {
2170                 printk(KERN_ERR "%s: critical: could not wake up in resume\n",
2171                                 dev->name);
2172                 goto reset;
2173         }
2174
2175         if(typhoon_start_runtime(tp) < 0) {
2176                 printk(KERN_ERR "%s: critical: could not start runtime in "
2177                                 "resume\n", dev->name);
2178                 goto reset;
2179         }
2180
2181         netif_device_attach(dev);
2182         return 0;
2183
2184 reset:
2185         typhoon_reset(tp->ioaddr, NoWait);
2186         return -EBUSY;
2187 }
2188
2189 static int
2190 typhoon_suspend(struct pci_dev *pdev, pm_message_t state)
2191 {
2192         struct net_device *dev = pci_get_drvdata(pdev);
2193         struct typhoon *tp = netdev_priv(dev);
2194         struct cmd_desc xp_cmd;
2195
2196         /* If we're down, we're already suspended.
2197          */
2198         if(!netif_running(dev))
2199                 return 0;
2200
2201         spin_lock_bh(&tp->state_lock);
2202         if(tp->vlgrp && tp->wol_events & TYPHOON_WAKE_MAGIC_PKT) {
2203                 spin_unlock_bh(&tp->state_lock);
2204                 printk(KERN_ERR "%s: cannot do WAKE_MAGIC with VLANS\n",
2205                                 dev->name);
2206                 return -EBUSY;
2207         }
2208         spin_unlock_bh(&tp->state_lock);
2209
2210         netif_device_detach(dev);
2211
2212         if(typhoon_stop_runtime(tp, WaitNoSleep) < 0) {
2213                 printk(KERN_ERR "%s: unable to stop runtime\n", dev->name);
2214                 goto need_resume;
2215         }
2216
2217         typhoon_free_rx_rings(tp);
2218         typhoon_init_rings(tp);
2219
2220         if(typhoon_boot_3XP(tp, TYPHOON_STATUS_WAITING_FOR_HOST) < 0) {
2221                 printk(KERN_ERR "%s: unable to boot sleep image\n", dev->name);
2222                 goto need_resume;
2223         }
2224
2225         INIT_COMMAND_NO_RESPONSE(&xp_cmd, TYPHOON_CMD_SET_MAC_ADDRESS);
2226         xp_cmd.parm1 = cpu_to_le16(ntohs(*(__be16 *)&dev->dev_addr[0]));
2227         xp_cmd.parm2 = cpu_to_le32(ntohl(*(__be32 *)&dev->dev_addr[2]));
2228         if(typhoon_issue_command(tp, 1, &xp_cmd, 0, NULL) < 0) {
2229                 printk(KERN_ERR "%s: unable to set mac address in suspend\n",
2230                                 dev->name);
2231                 goto need_resume;
2232         }
2233
2234         INIT_COMMAND_NO_RESPONSE(&xp_cmd, TYPHOON_CMD_SET_RX_FILTER);
2235         xp_cmd.parm1 = TYPHOON_RX_FILTER_DIRECTED | TYPHOON_RX_FILTER_BROADCAST;
2236         if(typhoon_issue_command(tp, 1, &xp_cmd, 0, NULL) < 0) {
2237                 printk(KERN_ERR "%s: unable to set rx filter in suspend\n",
2238                                 dev->name);
2239                 goto need_resume;
2240         }
2241
2242         if(typhoon_sleep(tp, pci_choose_state(pdev, state), tp->wol_events) < 0) {
2243                 printk(KERN_ERR "%s: unable to put card to sleep\n", dev->name);
2244                 goto need_resume;
2245         }
2246
2247         return 0;
2248
2249 need_resume:
2250         typhoon_resume(pdev);
2251         return -EBUSY;
2252 }
2253 #endif
2254
2255 static int __devinit
2256 typhoon_test_mmio(struct pci_dev *pdev)
2257 {
2258         void __iomem *ioaddr = pci_iomap(pdev, 1, 128);
2259         int mode = 0;
2260         u32 val;
2261
2262         if(!ioaddr)
2263                 goto out;
2264
2265         if(ioread32(ioaddr + TYPHOON_REG_STATUS) !=
2266                                 TYPHOON_STATUS_WAITING_FOR_HOST)
2267                 goto out_unmap;
2268
2269         iowrite32(TYPHOON_INTR_ALL, ioaddr + TYPHOON_REG_INTR_MASK);
2270         iowrite32(TYPHOON_INTR_ALL, ioaddr + TYPHOON_REG_INTR_STATUS);
2271         iowrite32(TYPHOON_INTR_ALL, ioaddr + TYPHOON_REG_INTR_ENABLE);
2272
2273         /* Ok, see if we can change our interrupt status register by
2274          * sending ourselves an interrupt. If so, then MMIO works.
2275          * The 50usec delay is arbitrary -- it could probably be smaller.
2276          */
2277         val = ioread32(ioaddr + TYPHOON_REG_INTR_STATUS);
2278         if((val & TYPHOON_INTR_SELF) == 0) {
2279                 iowrite32(1, ioaddr + TYPHOON_REG_SELF_INTERRUPT);
2280                 ioread32(ioaddr + TYPHOON_REG_INTR_STATUS);
2281                 udelay(50);
2282                 val = ioread32(ioaddr + TYPHOON_REG_INTR_STATUS);
2283                 if(val & TYPHOON_INTR_SELF)
2284                         mode = 1;
2285         }
2286
2287         iowrite32(TYPHOON_INTR_ALL, ioaddr + TYPHOON_REG_INTR_MASK);
2288         iowrite32(TYPHOON_INTR_ALL, ioaddr + TYPHOON_REG_INTR_STATUS);
2289         iowrite32(TYPHOON_INTR_NONE, ioaddr + TYPHOON_REG_INTR_ENABLE);
2290         ioread32(ioaddr + TYPHOON_REG_INTR_STATUS);
2291
2292 out_unmap:
2293         pci_iounmap(pdev, ioaddr);
2294
2295 out:
2296         if(!mode)
2297                 printk(KERN_INFO PFX "falling back to port IO\n");
2298         return mode;
2299 }
2300
2301 static int __devinit
2302 typhoon_init_one(struct pci_dev *pdev, const struct pci_device_id *ent)
2303 {
2304         static int did_version = 0;
2305         struct net_device *dev;
2306         struct typhoon *tp;
2307         int card_id = (int) ent->driver_data;
2308         void __iomem *ioaddr;
2309         void *shared;
2310         dma_addr_t shared_dma;
2311         struct cmd_desc xp_cmd;
2312         struct resp_desc xp_resp[3];
2313         int err = 0;
2314         DECLARE_MAC_BUF(mac);
2315
2316         if(!did_version++)
2317                 printk(KERN_INFO "%s", version);
2318
2319         dev = alloc_etherdev(sizeof(*tp));
2320         if(dev == NULL) {
2321                 printk(ERR_PFX "%s: unable to alloc new net device\n",
2322                        pci_name(pdev));
2323                 err = -ENOMEM;
2324                 goto error_out;
2325         }
2326         SET_NETDEV_DEV(dev, &pdev->dev);
2327
2328         err = pci_enable_device(pdev);
2329         if(err < 0) {
2330                 printk(ERR_PFX "%s: unable to enable device\n",
2331                        pci_name(pdev));
2332                 goto error_out_dev;
2333         }
2334
2335         err = pci_set_mwi(pdev);
2336         if(err < 0) {
2337                 printk(ERR_PFX "%s: unable to set MWI\n", pci_name(pdev));
2338                 goto error_out_disable;
2339         }
2340
2341         err = pci_set_dma_mask(pdev, DMA_32BIT_MASK);
2342         if(err < 0) {
2343                 printk(ERR_PFX "%s: No usable DMA configuration\n",
2344                        pci_name(pdev));
2345                 goto error_out_mwi;
2346         }
2347
2348         /* sanity checks on IO and MMIO BARs
2349          */
2350         if(!(pci_resource_flags(pdev, 0) & IORESOURCE_IO)) {
2351                 printk(ERR_PFX
2352                        "%s: region #1 not a PCI IO resource, aborting\n",
2353                        pci_name(pdev));
2354                 err = -ENODEV;
2355                 goto error_out_mwi;
2356         }
2357         if(pci_resource_len(pdev, 0) < 128) {
2358                 printk(ERR_PFX "%s: Invalid PCI IO region size, aborting\n",
2359                        pci_name(pdev));
2360                 err = -ENODEV;
2361                 goto error_out_mwi;
2362         }
2363         if(!(pci_resource_flags(pdev, 1) & IORESOURCE_MEM)) {
2364                 printk(ERR_PFX
2365                        "%s: region #1 not a PCI MMIO resource, aborting\n",
2366                        pci_name(pdev));
2367                 err = -ENODEV;
2368                 goto error_out_mwi;
2369         }
2370         if(pci_resource_len(pdev, 1) < 128) {
2371                 printk(ERR_PFX "%s: Invalid PCI MMIO region size, aborting\n",
2372                        pci_name(pdev));
2373                 err = -ENODEV;
2374                 goto error_out_mwi;
2375         }
2376
2377         err = pci_request_regions(pdev, "typhoon");
2378         if(err < 0) {
2379                 printk(ERR_PFX "%s: could not request regions\n",
2380                        pci_name(pdev));
2381                 goto error_out_mwi;
2382         }
2383
2384         /* map our registers
2385          */
2386         if(use_mmio != 0 && use_mmio != 1)
2387                 use_mmio = typhoon_test_mmio(pdev);
2388
2389         ioaddr = pci_iomap(pdev, use_mmio, 128);
2390         if (!ioaddr) {
2391                 printk(ERR_PFX "%s: cannot remap registers, aborting\n",
2392                        pci_name(pdev));
2393                 err = -EIO;
2394                 goto error_out_regions;
2395         }
2396
2397         /* allocate pci dma space for rx and tx descriptor rings
2398          */
2399         shared = pci_alloc_consistent(pdev, sizeof(struct typhoon_shared),
2400                                       &shared_dma);
2401         if(!shared) {
2402                 printk(ERR_PFX "%s: could not allocate DMA memory\n",
2403                        pci_name(pdev));
2404                 err = -ENOMEM;
2405                 goto error_out_remap;
2406         }
2407
2408         dev->irq = pdev->irq;
2409         tp = netdev_priv(dev);
2410         tp->shared = (struct typhoon_shared *) shared;
2411         tp->shared_dma = shared_dma;
2412         tp->pdev = pdev;
2413         tp->tx_pdev = pdev;
2414         tp->ioaddr = ioaddr;
2415         tp->tx_ioaddr = ioaddr;
2416         tp->dev = dev;
2417
2418         /* Init sequence:
2419          * 1) Reset the adapter to clear any bad juju
2420          * 2) Reload the sleep image
2421          * 3) Boot the sleep image
2422          * 4) Get the hardware address.
2423          * 5) Put the card to sleep.
2424          */
2425         if (typhoon_reset(ioaddr, WaitSleep) < 0) {
2426                 printk(ERR_PFX "%s: could not reset 3XP\n", pci_name(pdev));
2427                 err = -EIO;
2428                 goto error_out_dma;
2429         }
2430
2431         /* Now that we've reset the 3XP and are sure it's not going to
2432          * write all over memory, enable bus mastering, and save our
2433          * state for resuming after a suspend.
2434          */
2435         pci_set_master(pdev);
2436         pci_save_state(pdev);
2437
2438         /* dev->name is not valid until we register, but we need to
2439          * use some common routines to initialize the card. So that those
2440          * routines print the right name, we keep our oun pointer to the name
2441          */
2442         tp->name = pci_name(pdev);
2443
2444         typhoon_init_interface(tp);
2445         typhoon_init_rings(tp);
2446
2447         if(typhoon_boot_3XP(tp, TYPHOON_STATUS_WAITING_FOR_HOST) < 0) {
2448                 printk(ERR_PFX "%s: cannot boot 3XP sleep image\n",
2449                        pci_name(pdev));
2450                 err = -EIO;
2451                 goto error_out_reset;
2452         }
2453
2454         INIT_COMMAND_WITH_RESPONSE(&xp_cmd, TYPHOON_CMD_READ_MAC_ADDRESS);
2455         if(typhoon_issue_command(tp, 1, &xp_cmd, 1, xp_resp) < 0) {
2456                 printk(ERR_PFX "%s: cannot read MAC address\n",
2457                        pci_name(pdev));
2458                 err = -EIO;
2459                 goto error_out_reset;
2460         }
2461
2462         *(__be16 *)&dev->dev_addr[0] = htons(le16_to_cpu(xp_resp[0].parm1));
2463         *(__be32 *)&dev->dev_addr[2] = htonl(le32_to_cpu(xp_resp[0].parm2));
2464
2465         if(!is_valid_ether_addr(dev->dev_addr)) {
2466                 printk(ERR_PFX "%s: Could not obtain valid ethernet address, "
2467                        "aborting\n", pci_name(pdev));
2468                 goto error_out_reset;
2469         }
2470
2471         /* Read the Sleep Image version last, so the response is valid
2472          * later when we print out the version reported.
2473          */
2474         INIT_COMMAND_WITH_RESPONSE(&xp_cmd, TYPHOON_CMD_READ_VERSIONS);
2475         if(typhoon_issue_command(tp, 1, &xp_cmd, 3, xp_resp) < 0) {
2476                 printk(ERR_PFX "%s: Could not get Sleep Image version\n",
2477                         pci_name(pdev));
2478                 goto error_out_reset;
2479         }
2480
2481         tp->capabilities = typhoon_card_info[card_id].capabilities;
2482         tp->xcvr_select = TYPHOON_XCVR_AUTONEG;
2483
2484         /* Typhoon 1.0 Sleep Images return one response descriptor to the
2485          * READ_VERSIONS command. Those versions are OK after waking up
2486          * from sleep without needing a reset. Typhoon 1.1+ Sleep Images
2487          * seem to need a little extra help to get started. Since we don't
2488          * know how to nudge it along, just kick it.
2489          */
2490         if(xp_resp[0].numDesc != 0)
2491                 tp->capabilities |= TYPHOON_WAKEUP_NEEDS_RESET;
2492
2493         if(typhoon_sleep(tp, PCI_D3hot, 0) < 0) {
2494                 printk(ERR_PFX "%s: cannot put adapter to sleep\n",
2495                        pci_name(pdev));
2496                 err = -EIO;
2497                 goto error_out_reset;
2498         }
2499
2500         /* The chip-specific entries in the device structure. */
2501         dev->open               = typhoon_open;
2502         dev->hard_start_xmit    = typhoon_start_tx;
2503         dev->stop               = typhoon_close;
2504         dev->set_multicast_list = typhoon_set_rx_mode;
2505         dev->tx_timeout         = typhoon_tx_timeout;
2506         netif_napi_add(dev, &tp->napi, typhoon_poll, 16);
2507         dev->watchdog_timeo     = TX_TIMEOUT;
2508         dev->get_stats          = typhoon_get_stats;
2509         dev->set_mac_address    = typhoon_set_mac_address;
2510         dev->vlan_rx_register   = typhoon_vlan_rx_register;
2511
2512         SET_ETHTOOL_OPS(dev, &typhoon_ethtool_ops);
2513
2514         /* We can handle scatter gather, up to 16 entries, and
2515          * we can do IP checksumming (only version 4, doh...)
2516          */
2517         dev->features |= NETIF_F_SG | NETIF_F_IP_CSUM;
2518         dev->features |= NETIF_F_HW_VLAN_TX | NETIF_F_HW_VLAN_RX;
2519         dev->features |= NETIF_F_TSO;
2520
2521         if(register_netdev(dev) < 0)
2522                 goto error_out_reset;
2523
2524         /* fixup our local name */
2525         tp->name = dev->name;
2526
2527         pci_set_drvdata(pdev, dev);
2528
2529         printk(KERN_INFO "%s: %s at %s 0x%llx, %s\n",
2530                dev->name, typhoon_card_info[card_id].name,
2531                use_mmio ? "MMIO" : "IO",
2532                (unsigned long long)pci_resource_start(pdev, use_mmio),
2533                print_mac(mac, dev->dev_addr));
2534
2535         /* xp_resp still contains the response to the READ_VERSIONS command.
2536          * For debugging, let the user know what version he has.
2537          */
2538         if(xp_resp[0].numDesc == 0) {
2539                 /* This is the Typhoon 1.0 type Sleep Image, last 16 bits
2540                  * of version is Month/Day of build.
2541                  */
2542                 u16 monthday = le32_to_cpu(xp_resp[0].parm2) & 0xffff;
2543                 printk(KERN_INFO "%s: Typhoon 1.0 Sleep Image built "
2544                         "%02u/%02u/2000\n", dev->name, monthday >> 8,
2545                         monthday & 0xff);
2546         } else if(xp_resp[0].numDesc == 2) {
2547                 /* This is the Typhoon 1.1+ type Sleep Image
2548                  */
2549                 u32 sleep_ver = le32_to_cpu(xp_resp[0].parm2);
2550                 u8 *ver_string = (u8 *) &xp_resp[1];
2551                 ver_string[25] = 0;
2552                 printk(KERN_INFO "%s: Typhoon 1.1+ Sleep Image version "
2553                         "%02x.%03x.%03x %s\n", dev->name, sleep_ver >> 24,
2554                         (sleep_ver >> 12) & 0xfff, sleep_ver & 0xfff,
2555                         ver_string);
2556         } else {
2557                 printk(KERN_WARNING "%s: Unknown Sleep Image version "
2558                         "(%u:%04x)\n", dev->name, xp_resp[0].numDesc,
2559                         le32_to_cpu(xp_resp[0].parm2));
2560         }
2561
2562         return 0;
2563
2564 error_out_reset:
2565         typhoon_reset(ioaddr, NoWait);
2566
2567 error_out_dma:
2568         pci_free_consistent(pdev, sizeof(struct typhoon_shared),
2569                             shared, shared_dma);
2570 error_out_remap:
2571         pci_iounmap(pdev, ioaddr);
2572 error_out_regions:
2573         pci_release_regions(pdev);
2574 error_out_mwi:
2575         pci_clear_mwi(pdev);
2576 error_out_disable:
2577         pci_disable_device(pdev);
2578 error_out_dev:
2579         free_netdev(dev);
2580 error_out:
2581         return err;
2582 }
2583
2584 static void __devexit
2585 typhoon_remove_one(struct pci_dev *pdev)
2586 {
2587         struct net_device *dev = pci_get_drvdata(pdev);
2588         struct typhoon *tp = netdev_priv(dev);
2589
2590         unregister_netdev(dev);
2591         pci_set_power_state(pdev, PCI_D0);
2592         pci_restore_state(pdev);
2593         typhoon_reset(tp->ioaddr, NoWait);
2594         pci_iounmap(pdev, tp->ioaddr);
2595         pci_free_consistent(pdev, sizeof(struct typhoon_shared),
2596                             tp->shared, tp->shared_dma);
2597         pci_release_regions(pdev);
2598         pci_clear_mwi(pdev);
2599         pci_disable_device(pdev);
2600         pci_set_drvdata(pdev, NULL);
2601         free_netdev(dev);
2602 }
2603
2604 static struct pci_driver typhoon_driver = {
2605         .name           = DRV_MODULE_NAME,
2606         .id_table       = typhoon_pci_tbl,
2607         .probe          = typhoon_init_one,
2608         .remove         = __devexit_p(typhoon_remove_one),
2609 #ifdef CONFIG_PM
2610         .suspend        = typhoon_suspend,
2611         .resume         = typhoon_resume,
2612 #endif
2613 };
2614
2615 static int __init
2616 typhoon_init(void)
2617 {
2618         return pci_register_driver(&typhoon_driver);
2619 }
2620
2621 static void __exit
2622 typhoon_cleanup(void)
2623 {
2624         pci_unregister_driver(&typhoon_driver);
2625 }
2626
2627 module_init(typhoon_init);
2628 module_exit(typhoon_cleanup);