Subversion Repositories or1k

/* starfire.c: Linux device driver for the Adaptec Starfire network adapter. */

/*

        Written 1998-2000 by Donald Becker.

        Current maintainer is Ion Badulescu <ionut@cs.columbia.edu>. Please

        send all bug reports to me, and not to Donald Becker, as this code

        has been modified quite a bit from Donald's original version.

        This software may be used and distributed according to the terms of

        the GNU General Public License (GPL), incorporated herein by reference.

        Drivers based on or derived from this code fall under the GPL and must

        retain the authorship, copyright and license notice.  This file is not

        a complete program and may only be used when the entire operating

        system is licensed under the GPL.

        The author may be reached as becker@scyld.com, or C/O

        Scyld Computing Corporation

        410 Severn Ave., Suite 210

        Annapolis MD 21403

        Support and updates available at

        http://www.scyld.com/network/starfire.html

        -----------------------------------------------------------

        Linux kernel-specific changes:

        LK1.1.1 (jgarzik):

        - Use PCI driver interface

        - Fix MOD_xxx races

        - softnet fixups

        LK1.1.2 (jgarzik):

        - Merge Becker version 0.15

        LK1.1.3 (Andrew Morton)

        - Timer cleanups

        LK1.1.4 (jgarzik):

        - Merge Becker version 1.03

        LK1.2.1 (Ion Badulescu <ionut@cs.columbia.edu>)

        - Support hardware Rx/Tx checksumming

        - Use the GFP firmware taken from Adaptec's Netware driver

        LK1.2.2 (Ion Badulescu)

        - Backported to 2.2.x

        LK1.2.3 (Ion Badulescu)

        - Fix the flaky mdio interface

        - More compat clean-ups

        LK1.2.4 (Ion Badulescu)

        - More 2.2.x initialization fixes

        LK1.2.5 (Ion Badulescu)

        - Several fixes from Manfred Spraul

        LK1.2.6 (Ion Badulescu)

        - Fixed ifup/ifdown/ifup problem in 2.4.x

        LK1.2.7 (Ion Badulescu)

        - Removed unused code

        - Made more functions static and __init

        LK1.2.8 (Ion Badulescu)

        - Quell bogus error messages, inform about the Tx threshold

        - Removed #ifdef CONFIG_PCI, this driver is PCI only

        LK1.2.9 (Ion Badulescu)

        - Merged Jeff Garzik's changes from 2.4.4-pre5

        - Added 2.2.x compatibility stuff required by the above changes

        LK1.2.9a (Ion Badulescu)

        - More updates from Jeff Garzik

        LK1.3.0 (Ion Badulescu)

        - Merged zerocopy support

        LK1.3.1 (Ion Badulescu)

        - Added ethtool support

        - Added GPIO (media change) interrupt support

        LK1.3.2 (Ion Badulescu)

        - Fixed 2.2.x compatibility issues introduced in 1.3.1

        - Fixed ethtool ioctl returning uninitialized memory

        LK1.3.3 (Ion Badulescu)

        - Initialize the TxMode register properly

        - Don't dereference dev->priv after freeing it

        LK1.3.4 (Ion Badulescu)

        - Fixed initialization timing problems

        - Fixed interrupt mask definitions

        LK1.3.5 (jgarzik)

        - ethtool NWAY_RST, GLINK, [GS]MSGLVL support

        LK1.3.6:

        - Sparc64 support and fixes (Ion Badulescu)

        - Better stats and error handling (Ion Badulescu)

        - Use new pci_set_mwi() PCI API function (jgarzik)

        LK1.3.7 (Ion Badulescu)

        - minimal implementation of tx_timeout()

        - correctly shutdown the Rx/Tx engines in netdev_close()

        - added calls to netif_carrier_on/off

        (patch from Stefan Rompf <srompf@isg.de>)

        - VLAN support

        LK1.3.8 (Ion Badulescu)

        - adjust DMA burst size on sparc64

        - 64-bit support

        - reworked zerocopy support for 64-bit buffers

        - working and usable interrupt mitigation/latency

        - reduced Tx interrupt frequency for lower interrupt overhead

        LK1.3.9 (Ion Badulescu)

        - bugfix for mcast filter

        - enable the right kind of Tx interrupts (TxDMADone, not TxDone)

TODO:

        - full NAPI support

*/

#define DRV_NAME        "starfire"

#define DRV_VERSION     "1.03+LK1.3.9"

#define DRV_RELDATE     "December 13, 2002"

#include <linux/config.h>

#include <linux/version.h>

#include <linux/module.h>

#include <linux/kernel.h>

#include <linux/pci.h>

#include <linux/netdevice.h>

#include <linux/etherdevice.h>

#include <linux/init.h>

#include <linux/delay.h>

#include <asm/processor.h>              /* Processor type for cache alignment. */

#include <asm/uaccess.h>

#include <asm/io.h>

/*

 * Adaptec's license for their Novell drivers (which is where I got the

 * firmware files) does not allow one to redistribute them. Thus, we can't

 * include the firmware with this driver.

 *

 * However, should a legal-to-use firmware become available,

 * the driver developer would need only to obtain the firmware in the

 * form of a C header file.

 * Once that's done, the #undef below must be changed into a #define

 * for this driver to really use the firmware. Note that Rx/Tx

 * hardware TCP checksumming is not possible without the firmware.

 *

 * WANTED: legal firmware to include with this GPL'd driver.

 */

#undef HAS_FIRMWARE

/*

 * The current frame processor firmware fails to checksum a fragment

 * of length 1. If and when this is fixed, the #define below can be removed.

 */

#define HAS_BROKEN_FIRMWARE

/*

 * Define this if using the driver with the zero-copy patch

 */

#if defined(HAS_FIRMWARE) && defined(MAX_SKB_FRAGS)

#define ZEROCOPY

#endif

#ifdef HAS_FIRMWARE

#include "starfire_firmware.h"

#endif /* HAS_FIRMWARE */

#if defined(CONFIG_VLAN_8021Q) || defined(CONFIG_VLAN_8021Q_MODULE)

#define VLAN_SUPPORT

#endif

/* The user-configurable values.

   These may be modified when a driver module is loaded.*/

/* Used for tuning interrupt latency vs. overhead. */

static int intr_latency;

static int small_frames;

static int debug = 1;                   /* 1 normal messages, 0 quiet .. 7 verbose. */

static int max_interrupt_work = 20;

static int mtu;

/* Maximum number of multicast addresses to filter (vs. rx-all-multicast).

   The Starfire has a 512 element hash table based on the Ethernet CRC. */

static int multicast_filter_limit = 512;

/* Whether to do TCP/UDP checksums in hardware */

#ifdef HAS_FIRMWARE

static int enable_hw_cksum = 1;

#else

static int enable_hw_cksum = 0;

#endif

#define PKT_BUF_SZ      1536            /* Size of each temporary Rx buffer.*/

/*

 * Set the copy breakpoint for the copy-only-tiny-frames scheme.

 * Setting to > 1518 effectively disables this feature.

 *

 * NOTE:

 * The ia64 doesn't allow for unaligned loads even of integers being

 * misaligned on a 2 byte boundary. Thus always force copying of

 * packets as the starfire doesn't allow for misaligned DMAs ;-(

 * 23/10/2000 - Jes

 *

 * The Alpha and the Sparc don't like unaligned loads, either. On Sparc64,

 * at least, having unaligned frames leads to a rather serious performance

 * penalty. -Ion

 */

#if defined(__ia64__) || defined(__alpha__) || defined(__sparc__)

static int rx_copybreak = PKT_BUF_SZ;

#else

static int rx_copybreak /* = 0 */;

#endif

/* PCI DMA burst size -- on sparc64 we want to force it to 64 bytes, on the others the default of 128 is fine. */

#ifdef __sparc__

#define DMA_BURST_SIZE 64

#else

#define DMA_BURST_SIZE 128

#endif

/* Used to pass the media type, etc.

   Both 'options[]' and 'full_duplex[]' exist for driver interoperability.

   The media type is usually passed in 'options[]'.

   These variables are deprecated, use ethtool instead. -Ion

*/

#define MAX_UNITS 8             /* More are supported, limit only on options */

static int options[MAX_UNITS] = {0, };

static int full_duplex[MAX_UNITS] = {0, };

/* Operational parameters that are set at compile time. */

/* The "native" ring sizes are either 256 or 2048.

   However in some modes a descriptor may be marked to wrap the ring earlier.

*/

#define RX_RING_SIZE    256

#define TX_RING_SIZE    32

/* The completion queues are fixed at 1024 entries i.e. 4K or 8KB. */

#define DONE_Q_SIZE     1024

/* All queues must be aligned on a 256-byte boundary */

#define QUEUE_ALIGN     256

#if RX_RING_SIZE > 256

#define RX_Q_ENTRIES Rx2048QEntries

#else

#define RX_Q_ENTRIES Rx256QEntries

#endif

/* Operational parameters that usually are not changed. */

/* Time in jiffies before concluding the transmitter is hung. */

#define TX_TIMEOUT      (2 * HZ)

/*

 * This SUCKS.

 * We need a much better method to determine if dma_addr_t is 64-bit.

 */

#if (defined(__i386__) && defined(CONFIG_HIGHMEM) && (LINUX_VERSION_CODE > 0x20500 || defined(CONFIG_HIGHMEM64G))) || defined(__x86_64__) || defined (__ia64__) || defined(__mips64__) || (defined(__mips__) && defined(CONFIG_HIGHMEM) && defined(CONFIG_64BIT_PHYS_ADDR))

/* 64-bit dma_addr_t */

#define ADDR_64BITS     /* This chip uses 64 bit addresses. */

#define cpu_to_dma(x) cpu_to_le64(x)

#define dma_to_cpu(x) le64_to_cpu(x)

#define RX_DESC_Q_ADDR_SIZE RxDescQAddr64bit

#define TX_DESC_Q_ADDR_SIZE TxDescQAddr64bit

#define RX_COMPL_Q_ADDR_SIZE RxComplQAddr64bit

#define TX_COMPL_Q_ADDR_SIZE TxComplQAddr64bit

#define RX_DESC_ADDR_SIZE RxDescAddr64bit

#else  /* 32-bit dma_addr_t */

#define cpu_to_dma(x) cpu_to_le32(x)

#define dma_to_cpu(x) le32_to_cpu(x)

#define RX_DESC_Q_ADDR_SIZE RxDescQAddr32bit

#define TX_DESC_Q_ADDR_SIZE TxDescQAddr32bit

#define RX_COMPL_Q_ADDR_SIZE RxComplQAddr32bit

#define TX_COMPL_Q_ADDR_SIZE TxComplQAddr32bit

#define RX_DESC_ADDR_SIZE RxDescAddr32bit

#endif

#ifdef MAX_SKB_FRAGS

#define skb_first_frag_len(skb) skb_headlen(skb)

#define skb_num_frags(skb) (skb_shinfo(skb)->nr_frags + 1)

#else  /* not MAX_SKB_FRAGS */

#define skb_first_frag_len(skb) (skb->len)

#define skb_num_frags(skb) 1

#endif /* not MAX_SKB_FRAGS */

/* 2.2.x compatibility code */

#if LINUX_VERSION_CODE < 0x20300

#include "starfire-kcomp22.h"

#else  /* LINUX_VERSION_CODE > 0x20300 */

#include <linux/crc32.h>

#include <linux/ethtool.h>

#include <linux/mii.h>

#include <linux/if_vlan.h>

#define COMPAT_MOD_INC_USE_COUNT

#define COMPAT_MOD_DEC_USE_COUNT

#define init_tx_timer(dev, func, timeout) \

        dev->tx_timeout = func; \

        dev->watchdog_timeo = timeout;

#define kick_tx_timer(dev, func, timeout)

#define netif_start_if(dev)

#define netif_stop_if(dev)

#define PCI_SLOT_NAME(pci_dev)  (pci_dev)->slot_name

#endif /* LINUX_VERSION_CODE > 0x20300 */

/* end of compatibility code */

/* These identify the driver base version and may not be removed. */

static char version[] __devinitdata =

KERN_INFO "starfire.c:v1.03 7/26/2000  Written by Donald Becker <becker@scyld.com>\n"

KERN_INFO " (unofficial 2.2/2.4 kernel port, version " DRV_VERSION ", " DRV_RELDATE ")\n";

MODULE_AUTHOR("Donald Becker <becker@scyld.com>");

MODULE_DESCRIPTION("Adaptec Starfire Ethernet driver");

MODULE_LICENSE("GPL");

MODULE_PARM(max_interrupt_work, "i");

MODULE_PARM(mtu, "i");

MODULE_PARM(debug, "i");

MODULE_PARM(rx_copybreak, "i");

MODULE_PARM(intr_latency, "i");

MODULE_PARM(small_frames, "i");

MODULE_PARM(options, "1-" __MODULE_STRING(MAX_UNITS) "i");

MODULE_PARM(full_duplex, "1-" __MODULE_STRING(MAX_UNITS) "i");

MODULE_PARM(enable_hw_cksum, "i");

MODULE_PARM_DESC(max_interrupt_work, "Maximum events handled per interrupt");

MODULE_PARM_DESC(mtu, "MTU (all boards)");

MODULE_PARM_DESC(debug, "Debug level (0-6)");

MODULE_PARM_DESC(rx_copybreak, "Copy breakpoint for copy-only-tiny-frames");

MODULE_PARM_DESC(intr_latency, "Maximum interrupt latency, in microseconds");

MODULE_PARM_DESC(small_frames, "Maximum size of receive frames that bypass interrupt latency (0,64,128,256,512)");

MODULE_PARM_DESC(options, "Deprecated: Bits 0-3: media type, bit 17: full duplex");

MODULE_PARM_DESC(full_duplex, "Deprecated: Forced full-duplex setting (0/1)");

MODULE_PARM_DESC(enable_hw_cksum, "Enable/disable hardware cksum support (0/1)");

/*

                                Theory of Operation

I. Board Compatibility

This driver is for the Adaptec 6915 "Starfire" 64 bit PCI Ethernet adapter.

II. Board-specific settings

III. Driver operation

IIIa. Ring buffers

The Starfire hardware uses multiple fixed-size descriptor queues/rings.  The

ring sizes are set fixed by the hardware, but may optionally be wrapped

earlier by the END bit in the descriptor.

This driver uses that hardware queue size for the Rx ring, where a large

number of entries has no ill effect beyond increases the potential backlog.

The Tx ring is wrapped with the END bit, since a large hardware Tx queue

disables the queue layer priority ordering and we have no mechanism to

utilize the hardware two-level priority queue.  When modifying the

RX/TX_RING_SIZE pay close attention to page sizes and the ring-empty warning

levels.

IIIb/c. Transmit/Receive Structure

See the Adaptec manual for the many possible structures, and options for

each structure.  There are far too many to document all of them here.

For transmit this driver uses type 0/1 transmit descriptors (depending

on the 32/64 bitness of the architecture), and relies on automatic

minimum-length padding.  It does not use the completion queue

consumer index, but instead checks for non-zero status entries.

For receive this driver uses type 0/1/2/3 receive descriptors.  The driver

allocates full frame size skbuffs for the Rx ring buffers, so all frames

should fit in a single descriptor.  The driver does not use the completion

queue consumer index, but instead checks for non-zero status entries.

When an incoming frame is less than RX_COPYBREAK bytes long, a fresh skbuff

is allocated and the frame is copied to the new skbuff.  When the incoming

frame is larger, the skbuff is passed directly up the protocol stack.

Buffers consumed this way are replaced by newly allocated skbuffs in a later

phase of receive.

A notable aspect of operation is that unaligned buffers are not permitted by

the Starfire hardware.  Thus the IP header at offset 14 in an ethernet frame

isn't longword aligned, which may cause problems on some machine

e.g. Alphas and IA64. For these architectures, the driver is forced to copy

the frame into a new skbuff unconditionally. Copied frames are put into the

skbuff at an offset of "+2", thus 16-byte aligning the IP header.

IIId. Synchronization

The driver runs as two independent, single-threaded flows of control.  One

is the send-packet routine, which enforces single-threaded use by the

dev->tbusy flag.  The other thread is the interrupt handler, which is single

threaded by the hardware and interrupt handling software.

The send packet thread has partial control over the Tx ring and the netif_queue

status. If the number of free Tx slots in the ring falls below a certain number

(currently hardcoded to 4), it signals the upper layer to stop the queue.

The interrupt handler has exclusive control over the Rx ring and records stats

from the Tx ring.  After reaping the stats, it marks the Tx queue entry as

empty by incrementing the dirty_tx mark. Iff the netif_queue is stopped and the

number of free Tx slow is above the threshold, it signals the upper layer to

restart the queue.

IV. Notes

IVb. References

The Adaptec Starfire manuals, available only from Adaptec.

http://www.scyld.com/expert/100mbps.html

http://www.scyld.com/expert/NWay.html

IVc. Errata

- StopOnPerr is broken, don't enable

- Hardware ethernet padding exposes random data, perform software padding

  instead (unverified -- works correctly for all the hardware I have)

*/

enum chip_capability_flags {CanHaveMII=1, };

enum chipset {

        CH_6915 = 0,

};

static struct pci_device_id starfire_pci_tbl[] __devinitdata = {

        { 0x9004, 0x6915, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CH_6915 },

        { 0, }

};

MODULE_DEVICE_TABLE(pci, starfire_pci_tbl);

/* A chip capabilities table, matching the CH_xxx entries in xxx_pci_tbl[] above. */

static struct chip_info {

        const char *name;

        int drv_flags;

} netdrv_tbl[] __devinitdata = {

        { "Adaptec Starfire 6915", CanHaveMII },

};

/* Offsets to the device registers.

   Unlike software-only systems, device drivers interact with complex hardware.

   It's not useful to define symbolic names for every register bit in the

   device.  The name can only partially document the semantics and make

   the driver longer and more difficult to read.

   In general, only the important configuration values or bits changed

   multiple times should be defined symbolically.

*/

enum register_offsets {

        PCIDeviceConfig=0x50040, GenCtrl=0x50070, IntrTimerCtrl=0x50074,

        IntrClear=0x50080, IntrStatus=0x50084, IntrEnable=0x50088,

        MIICtrl=0x52000, TxStationAddr=0x50120, EEPROMCtrl=0x51000,

        GPIOCtrl=0x5008C, TxDescCtrl=0x50090,

        TxRingPtr=0x50098, HiPriTxRingPtr=0x50094, /* Low and High priority. */

        TxRingHiAddr=0x5009C,           /* 64 bit address extension. */

        TxProducerIdx=0x500A0, TxConsumerIdx=0x500A4,

        TxThreshold=0x500B0,

        CompletionHiAddr=0x500B4, TxCompletionAddr=0x500B8,

        RxCompletionAddr=0x500BC, RxCompletionQ2Addr=0x500C0,

        CompletionQConsumerIdx=0x500C4, RxDMACtrl=0x500D0,

        RxDescQCtrl=0x500D4, RxDescQHiAddr=0x500DC, RxDescQAddr=0x500E0,

        RxDescQIdx=0x500E8, RxDMAStatus=0x500F0, RxFilterMode=0x500F4,

        TxMode=0x55000, VlanType=0x55064,

        PerfFilterTable=0x56000, HashTable=0x56100,

        TxGfpMem=0x58000, RxGfpMem=0x5a000,

};

/*

 * Bits in the interrupt status/mask registers.

 * Warning: setting Intr[Ab]NormalSummary in the IntrEnable register

 * enables all the interrupt sources that are or'ed into those status bits.

 */

enum intr_status_bits {

        IntrLinkChange=0xf0000000, IntrStatsMax=0x08000000,

        IntrAbnormalSummary=0x02000000, IntrGeneralTimer=0x01000000,

        IntrSoftware=0x800000, IntrRxComplQ1Low=0x400000,

        IntrTxComplQLow=0x200000, IntrPCI=0x100000,

        IntrDMAErr=0x080000, IntrTxDataLow=0x040000,

        IntrRxComplQ2Low=0x020000, IntrRxDescQ1Low=0x010000,

        IntrNormalSummary=0x8000, IntrTxDone=0x4000,

        IntrTxDMADone=0x2000, IntrTxEmpty=0x1000,

        IntrEarlyRxQ2=0x0800, IntrEarlyRxQ1=0x0400,

        IntrRxQ2Done=0x0200, IntrRxQ1Done=0x0100,

        IntrRxGFPDead=0x80, IntrRxDescQ2Low=0x40,

        IntrNoTxCsum=0x20, IntrTxBadID=0x10,

        IntrHiPriTxBadID=0x08, IntrRxGfp=0x04,

        IntrTxGfp=0x02, IntrPCIPad=0x01,

        /* not quite bits */

        IntrRxDone=IntrRxQ2Done | IntrRxQ1Done,

        IntrRxEmpty=IntrRxDescQ1Low | IntrRxDescQ2Low,

        IntrNormalMask=0xff00, IntrAbnormalMask=0x3ff00fe,

};

/* Bits in the RxFilterMode register. */

enum rx_mode_bits {

        AcceptBroadcast=0x04, AcceptAllMulticast=0x02, AcceptAll=0x01,

        AcceptMulticast=0x10, PerfectFilter=0x40, HashFilter=0x30,

        PerfectFilterVlan=0x80, MinVLANPrio=0xE000, VlanMode=0x0200,

        WakeupOnGFP=0x0800,

};

/* Bits in the TxMode register */

enum tx_mode_bits {

        MiiSoftReset=0x8000, MIILoopback=0x4000,

        TxFlowEnable=0x0800, RxFlowEnable=0x0400,

        PadEnable=0x04, FullDuplex=0x02, HugeFrame=0x01,

};

/* Bits in the TxDescCtrl register. */

enum tx_ctrl_bits {

        TxDescSpaceUnlim=0x00, TxDescSpace32=0x10, TxDescSpace64=0x20,

        TxDescSpace128=0x30, TxDescSpace256=0x40,

        TxDescType0=0x00, TxDescType1=0x01, TxDescType2=0x02,

        TxDescType3=0x03, TxDescType4=0x04,

        TxNoDMACompletion=0x08,

        TxDescQAddr64bit=0x80, TxDescQAddr32bit=0,

        TxHiPriFIFOThreshShift=24, TxPadLenShift=16,

        TxDMABurstSizeShift=8,

};

/* Bits in the RxDescQCtrl register. */

enum rx_ctrl_bits {

        RxBufferLenShift=16, RxMinDescrThreshShift=0,

        RxPrefetchMode=0x8000, RxVariableQ=0x2000,

        Rx2048QEntries=0x4000, Rx256QEntries=0,

        RxDescAddr64bit=0x1000, RxDescAddr32bit=0,

        RxDescQAddr64bit=0x0100, RxDescQAddr32bit=0,

        RxDescSpace4=0x000, RxDescSpace8=0x100,

        RxDescSpace16=0x200, RxDescSpace32=0x300,

        RxDescSpace64=0x400, RxDescSpace128=0x500,

        RxConsumerWrEn=0x80,

};

/* Bits in the RxDMACtrl register. */

enum rx_dmactrl_bits {

        RxReportBadFrames=0x80000000, RxDMAShortFrames=0x40000000,

        RxDMABadFrames=0x20000000, RxDMACrcErrorFrames=0x10000000,

        RxDMAControlFrame=0x08000000, RxDMAPauseFrame=0x04000000,

        RxChecksumIgnore=0, RxChecksumRejectTCPUDP=0x02000000,

        RxChecksumRejectTCPOnly=0x01000000,

        RxCompletionQ2Enable=0x800000,

        RxDMAQ2Disable=0, RxDMAQ2FPOnly=0x100000,

        RxDMAQ2SmallPkt=0x200000, RxDMAQ2HighPrio=0x300000,

        RxDMAQ2NonIP=0x400000,

        RxUseBackupQueue=0x080000, RxDMACRC=0x040000,

        RxEarlyIntThreshShift=12, RxHighPrioThreshShift=8,

        RxBurstSizeShift=0,

};

/* Bits in the RxCompletionAddr register */

enum rx_compl_bits {

        RxComplQAddr64bit=0x80, RxComplQAddr32bit=0,

        RxComplProducerWrEn=0x40,

        RxComplType0=0x00, RxComplType1=0x10,

        RxComplType2=0x20, RxComplType3=0x30,

        RxComplThreshShift=0,

};

/* Bits in the TxCompletionAddr register */

enum tx_compl_bits {

        TxComplQAddr64bit=0x80, TxComplQAddr32bit=0,

        TxComplProducerWrEn=0x40,

        TxComplIntrStatus=0x20,

        CommonQueueMode=0x10,

        TxComplThreshShift=0,

};

/* Bits in the GenCtrl register */

enum gen_ctrl_bits {

        RxEnable=0x05, TxEnable=0x0a,

        RxGFPEnable=0x10, TxGFPEnable=0x20,

};

/* Bits in the IntrTimerCtrl register */

enum intr_ctrl_bits {

        Timer10X=0x800, EnableIntrMasking=0x60, SmallFrameBypass=0x100,

        SmallFrame64=0, SmallFrame128=0x200, SmallFrame256=0x400, SmallFrame512=0x600,

        IntrLatencyMask=0x1f,

};

/* The Rx and Tx buffer descriptors. */

struct starfire_rx_desc {

        dma_addr_t rxaddr;

};

enum rx_desc_bits {

        RxDescValid=1, RxDescEndRing=2,

};

/* Completion queue entry. */

struct short_rx_done_desc {

        u32 status;                     /* Low 16 bits is length. */

};

struct basic_rx_done_desc {

        u32 status;                     /* Low 16 bits is length. */

        u16 vlanid;

        u16 status2;

};

struct csum_rx_done_desc {

        u32 status;                     /* Low 16 bits is length. */

        u16 csum;                       /* Partial checksum */

        u16 status2;

};

struct full_rx_done_desc {

        u32 status;                     /* Low 16 bits is length. */

        u16 status3;

        u16 status2;

        u16 vlanid;

        u16 csum;                       /* partial checksum */

        u32 timestamp;

};

/* XXX: this is ugly and I'm not sure it's worth the trouble -Ion */

#ifdef HAS_FIRMWARE

#ifdef VLAN_SUPPORT

typedef struct full_rx_done_desc rx_done_desc;

#define RxComplType RxComplType3

#else  /* not VLAN_SUPPORT */

typedef struct csum_rx_done_desc rx_done_desc;

#define RxComplType RxComplType2

#endif /* not VLAN_SUPPORT */

#else  /* not HAS_FIRMWARE */

#ifdef VLAN_SUPPORT

typedef struct basic_rx_done_desc rx_done_desc;

#define RxComplType RxComplType1

#else  /* not VLAN_SUPPORT */

typedef struct short_rx_done_desc rx_done_desc;

#define RxComplType RxComplType0

#endif /* not VLAN_SUPPORT */

#endif /* not HAS_FIRMWARE */

enum rx_done_bits {

        RxOK=0x20000000, RxFIFOErr=0x10000000, RxBufQ2=0x08000000,

};

/* Type 1 Tx descriptor. */

struct starfire_tx_desc_1 {

        u32 status;                     /* Upper bits are status, lower 16 length. */

        u32 addr;

};

/* Type 2 Tx descriptor. */

struct starfire_tx_desc_2 {

        u32 status;                     /* Upper bits are status, lower 16 length. */

        u32 reserved;

        u64 addr;

};

#ifdef ADDR_64BITS

typedef struct starfire_tx_desc_2 starfire_tx_desc;

#define TX_DESC_TYPE TxDescType2

#else  /* not ADDR_64BITS */

typedef struct starfire_tx_desc_1 starfire_tx_desc;

#define TX_DESC_TYPE TxDescType1

#endif /* not ADDR_64BITS */

#define TX_DESC_SPACING TxDescSpaceUnlim

enum tx_desc_bits {

        TxDescID=0xB0000000,

        TxCRCEn=0x01000000, TxDescIntr=0x08000000,

        TxRingWrap=0x04000000, TxCalTCP=0x02000000,

};

struct tx_done_desc {

        u32 status;                     /* timestamp, index. */

#if 0

        u32 intrstatus;                 /* interrupt status */

#endif

};

struct rx_ring_info {

        struct sk_buff *skb;

        dma_addr_t mapping;

};

struct tx_ring_info {

        struct sk_buff *skb;

        dma_addr_t mapping;

        unsigned int used_slots;

};

#define PHY_CNT         2

struct netdev_private {

        /* Descriptor rings first for alignment. */

        struct starfire_rx_desc *rx_ring;

        starfire_tx_desc *tx_ring;

        dma_addr_t rx_ring_dma;

        dma_addr_t tx_ring_dma;

        /* The addresses of rx/tx-in-place skbuffs. */

        struct rx_ring_info rx_info[RX_RING_SIZE];

        struct tx_ring_info tx_info[TX_RING_SIZE];

        /* Pointers to completion queues (full pages). */

        rx_done_desc *rx_done_q;

        dma_addr_t rx_done_q_dma;

        unsigned int rx_done;

        struct tx_done_desc *tx_done_q;

        dma_addr_t tx_done_q_dma;

        unsigned int tx_done;

        struct net_device_stats stats;

        struct pci_dev *pci_dev;

#ifdef VLAN_SUPPORT

        struct vlan_group *vlgrp;

#endif

        void *queue_mem;

        dma_addr_t queue_mem_dma;

        size_t queue_mem_size;

        /* Frequently used values: keep some adjacent for cache effect. */

        spinlock_t lock;

        unsigned int cur_rx, dirty_rx;  /* Producer/consumer ring indices */

        unsigned int cur_tx, dirty_tx, reap_tx;

        unsigned int rx_buf_sz;         /* Based on MTU+slack. */

        /* These values keep track of the transceiver/media in use. */

        int speed100;                   /* Set if speed == 100MBit. */

        u32 tx_mode;

        u32 intr_timer_ctrl;

        u8 tx_threshold;

        /* MII transceiver section. */

        struct mii_if_info mii_if;              /* MII lib hooks/info */

        int phy_cnt;                    /* MII device addresses. */

        unsigned char phys[PHY_CNT];    /* MII device addresses. */

};

static int      mdio_read(struct net_device *dev, int phy_id, int location);

static void     mdio_write(struct net_device *dev, int phy_id, int location, int value);

static int      netdev_open(struct net_device *dev);

static void     check_duplex(struct net_device *dev);

static void     tx_timeout(struct net_device *dev);

static void     init_ring(struct net_device *dev);

static int      start_tx(struct sk_buff *skb, struct net_device *dev);

static void     intr_handler(int irq, void *dev_instance, struct pt_regs *regs);

static void     netdev_error(struct net_device *dev, int intr_status);

static int      netdev_rx(struct net_device *dev);

static void     netdev_error(struct net_device *dev, int intr_status);

static void     set_rx_mode(struct net_device *dev);

static struct net_device_stats *get_stats(struct net_device *dev);

static int      netdev_ioctl(struct net_device *dev, struct ifreq *rq, int cmd);

static int      netdev_close(struct net_device *dev);

static void     netdev_media_change(struct net_device *dev);

#ifdef VLAN_SUPPORT