Subversion Repositories test_project

/* via-rhine.c: A Linux Ethernet device driver for VIA Rhine family chips. */

/*

        Written 1998-2001 by Donald Becker.

        Current Maintainer: Roger Luethi <rl@hellgate.ch>

        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.

        This driver is designed for the VIA VT86C100A Rhine-I.

        It also works with the Rhine-II (6102) and Rhine-III (6105/6105L/6105LOM

        and management NIC 6105M).

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

        Scyld Computing Corporation

        410 Severn Ave., Suite 210

        Annapolis MD 21403

        This driver contains some changes from the original Donald Becker

        version. He may or may not be interested in bug reports on this

        code. You can find his versions at:

        http://www.scyld.com/network/via-rhine.html

        [link no longer provides useful info -jgarzik]

*/

#define DRV_NAME        "via-rhine"

#define DRV_VERSION     "1.4.3"

#define DRV_RELDATE     "2007-03-06"

/* A few user-configurable values.

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

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

static int max_interrupt_work = 20;

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

   Setting to > 1518 effectively disables this feature. */

#if defined(__alpha__) || defined(__arm__) || defined(__hppa__) \

       || defined(CONFIG_SPARC) || defined(__ia64__) \

       || defined(__sh__) || defined(__mips__)

static int rx_copybreak = 1518;

#else

static int rx_copybreak;

#endif

/* Work-around for broken BIOSes: they are unable to get the chip back out of

   power state D3 so PXE booting fails. bootparam(7): via-rhine.avoid_D3=1 */

static int avoid_D3;

/*

 * In case you are looking for 'options[]' or 'full_duplex[]', they

 * are gone. Use ethtool(8) instead.

 */

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

   The Rhine has a 64 element 8390-like hash table. */

static const int multicast_filter_limit = 32;

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

/* Keep the ring sizes a power of two for compile efficiency.

   The compiler will convert <unsigned>'%'<2^N> into a bit mask.

   Making the Tx ring too large decreases the effectiveness of channel

   bonding and packet priority.

   There are no ill effects from too-large receive rings. */

#define TX_RING_SIZE    16

#define TX_QUEUE_LEN    10      /* Limit ring entries actually used. */

#ifdef CONFIG_VIA_RHINE_NAPI

#define RX_RING_SIZE    64

#else

#define RX_RING_SIZE    16

#endif

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

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

#define TX_TIMEOUT      (2*HZ)

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

#include <linux/module.h>

#include <linux/moduleparam.h>

#include <linux/kernel.h>

#include <linux/string.h>

#include <linux/timer.h>

#include <linux/errno.h>

#include <linux/ioport.h>

#include <linux/slab.h>

#include <linux/interrupt.h>

#include <linux/pci.h>

#include <linux/dma-mapping.h>

#include <linux/netdevice.h>

#include <linux/etherdevice.h>

#include <linux/skbuff.h>

#include <linux/init.h>

#include <linux/delay.h>

#include <linux/mii.h>

#include <linux/ethtool.h>

#include <linux/crc32.h>

#include <linux/bitops.h>

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

#include <asm/io.h>

#include <asm/irq.h>

#include <asm/uaccess.h>

#include <linux/dmi.h>

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

static char version[] __devinitdata =

KERN_INFO DRV_NAME ".c:v1.10-LK" DRV_VERSION " " DRV_RELDATE " Written by Donald Becker\n";

/* This driver was written to use PCI memory space. Some early versions

   of the Rhine may only work correctly with I/O space accesses. */

#ifdef CONFIG_VIA_RHINE_MMIO

#define USE_MMIO

#else

#endif

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

MODULE_DESCRIPTION("VIA Rhine PCI Fast Ethernet driver");

MODULE_LICENSE("GPL");

module_param(max_interrupt_work, int, 0);

module_param(debug, int, 0);

module_param(rx_copybreak, int, 0);

module_param(avoid_D3, bool, 0);

MODULE_PARM_DESC(max_interrupt_work, "VIA Rhine maximum events handled per interrupt");

MODULE_PARM_DESC(debug, "VIA Rhine debug level (0-7)");

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

MODULE_PARM_DESC(avoid_D3, "Avoid power state D3 (work-around for broken BIOSes)");

/*

                Theory of Operation

I. Board Compatibility

This driver is designed for the VIA 86c100A Rhine-II PCI Fast Ethernet

controller.

II. Board-specific settings

Boards with this chip are functional only in a bus-master PCI slot.

Many operational settings are loaded from the EEPROM to the Config word at

offset 0x78. For most of these settings, this driver assumes that they are

correct.

If this driver is compiled to use PCI memory space operations the EEPROM

must be configured to enable memory ops.

III. Driver operation

IIIa. Ring buffers

This driver uses two statically allocated fixed-size descriptor lists

formed into rings by a branch from the final descriptor to the beginning of

the list. The ring sizes are set at compile time by RX/TX_RING_SIZE.

IIIb/c. Transmit/Receive Structure

This driver attempts to use a zero-copy receive and transmit scheme.

Alas, all data buffers are required to start on a 32 bit boundary, so

the driver must often copy transmit packets into bounce buffers.

The driver allocates full frame size skbuffs for the Rx ring buffers at

open() time and passes the skb->data field to the chip as receive data

buffers. 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 the last phase of rhine_rx().

The RX_COPYBREAK value is chosen to trade-off the memory wasted by

using a full-sized skbuff for small frames vs. the copying costs of larger

frames. New boards are typically used in generously configured machines

and the underfilled buffers have negligible impact compared to the benefit of

a single allocation size, so the default value of zero results in never

copying packets. When copying is done, the cost is usually mitigated by using

a combined copy/checksum routine. Copying also preloads the cache, which is

most useful with small frames.

Since the VIA chips are only able to transfer data to buffers on 32 bit

boundaries, the IP header at offset 14 in an ethernet frame isn't

longword aligned for further processing. Copying these unaligned buffers

has the beneficial effect of 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->priv->lock spinlock. 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. It locks the

dev->priv->lock whenever it's queuing a Tx packet. If the next slot in the ring

is not available it stops the transmit queue by calling netif_stop_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. If at least half of the entries in

the Rx ring are available the transmit queue is woken up if it was stopped.

IV. Notes

IVb. References

Preliminary VT86C100A manual from http://www.via.com.tw/

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

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

ftp://ftp.via.com.tw/public/lan/Products/NIC/VT86C100A/Datasheet/VT86C100A03.pdf

ftp://ftp.via.com.tw/public/lan/Products/NIC/VT6102/Datasheet/VT6102_021.PDF

IVc. Errata

The VT86C100A manual is not reliable information.

The 3043 chip does not handle unaligned transmit or receive buffers, resulting

in significant performance degradation for bounce buffer copies on transmit

and unaligned IP headers on receive.

The chip does not pad to minimum transmit length.

*/

/* This table drives the PCI probe routines. It's mostly boilerplate in all

   of the drivers, and will likely be provided by some future kernel.

   Note the matching code -- the first table entry matchs all 56** cards but

   second only the 1234 card.

*/

enum rhine_revs {

        VT86C100A       = 0x00,

        VTunknown0      = 0x20,

        VT6102          = 0x40,

        VT8231          = 0x50, /* Integrated MAC */

        VT8233          = 0x60, /* Integrated MAC */

        VT8235          = 0x74, /* Integrated MAC */

        VT8237          = 0x78, /* Integrated MAC */

        VTunknown1      = 0x7C,

        VT6105          = 0x80,

        VT6105_B0       = 0x83,

        VT6105L         = 0x8A,

        VT6107          = 0x8C,

        VTunknown2      = 0x8E,

        VT6105M         = 0x90, /* Management adapter */

};

enum rhine_quirks {

        rqWOL           = 0x0001,       /* Wake-On-LAN support */

        rqForceReset    = 0x0002,

        rq6patterns     = 0x0040,       /* 6 instead of 4 patterns for WOL */

        rqStatusWBRace  = 0x0080,       /* Tx Status Writeback Error possible */

        rqRhineI        = 0x0100,       /* See comment below */

};

/*

 * rqRhineI: VT86C100A (aka Rhine-I) uses different bits to enable

 * MMIO as well as for the collision counter and the Tx FIFO underflow

 * indicator. In addition, Tx and Rx buffers need to 4 byte aligned.

 */

/* Beware of PCI posted writes */

#define IOSYNC  do { ioread8(ioaddr + StationAddr); } while (0)

static const struct pci_device_id rhine_pci_tbl[] = {

        { 0x1106, 0x3043, PCI_ANY_ID, PCI_ANY_ID, },    /* VT86C100A */

        { 0x1106, 0x3065, PCI_ANY_ID, PCI_ANY_ID, },    /* VT6102 */

        { 0x1106, 0x3106, PCI_ANY_ID, PCI_ANY_ID, },    /* 6105{,L,LOM} */

        { 0x1106, 0x3053, PCI_ANY_ID, PCI_ANY_ID, },    /* VT6105M */

        { }     /* terminate list */

};

MODULE_DEVICE_TABLE(pci, rhine_pci_tbl);

/* Offsets to the device registers. */

enum register_offsets {

        StationAddr=0x00, RxConfig=0x06, TxConfig=0x07, ChipCmd=0x08,

        ChipCmd1=0x09,

        IntrStatus=0x0C, IntrEnable=0x0E,

        MulticastFilter0=0x10, MulticastFilter1=0x14,

        RxRingPtr=0x18, TxRingPtr=0x1C, GFIFOTest=0x54,

        MIIPhyAddr=0x6C, MIIStatus=0x6D, PCIBusConfig=0x6E,

        MIICmd=0x70, MIIRegAddr=0x71, MIIData=0x72, MACRegEEcsr=0x74,

        ConfigA=0x78, ConfigB=0x79, ConfigC=0x7A, ConfigD=0x7B,

        RxMissed=0x7C, RxCRCErrs=0x7E, MiscCmd=0x81,

        StickyHW=0x83, IntrStatus2=0x84,

        WOLcrSet=0xA0, PwcfgSet=0xA1, WOLcgSet=0xA3, WOLcrClr=0xA4,

        WOLcrClr1=0xA6, WOLcgClr=0xA7,

        PwrcsrSet=0xA8, PwrcsrSet1=0xA9, PwrcsrClr=0xAC, PwrcsrClr1=0xAD,

};

/* Bits in ConfigD */

enum backoff_bits {

        BackOptional=0x01, BackModify=0x02,

        BackCaptureEffect=0x04, BackRandom=0x08

};

#ifdef USE_MMIO

/* Registers we check that mmio and reg are the same. */

static const int mmio_verify_registers[] = {

        RxConfig, TxConfig, IntrEnable, ConfigA, ConfigB, ConfigC, ConfigD,

};

#endif

/* Bits in the interrupt status/mask registers. */

enum intr_status_bits {

        IntrRxDone=0x0001, IntrRxErr=0x0004, IntrRxEmpty=0x0020,

        IntrTxDone=0x0002, IntrTxError=0x0008, IntrTxUnderrun=0x0210,

        IntrPCIErr=0x0040,

        IntrStatsMax=0x0080, IntrRxEarly=0x0100,

        IntrRxOverflow=0x0400, IntrRxDropped=0x0800, IntrRxNoBuf=0x1000,

        IntrTxAborted=0x2000, IntrLinkChange=0x4000,

        IntrRxWakeUp=0x8000,

        IntrNormalSummary=0x0003, IntrAbnormalSummary=0xC260,

        IntrTxDescRace=0x080000,        /* mapped from IntrStatus2 */

        IntrTxErrSummary=0x082218,

};

/* Bits in WOLcrSet/WOLcrClr and PwrcsrSet/PwrcsrClr */

enum wol_bits {

        WOLucast        = 0x10,

        WOLmagic        = 0x20,

        WOLbmcast       = 0x30,

        WOLlnkon        = 0x40,

        WOLlnkoff       = 0x80,

};

/* The Rx and Tx buffer descriptors. */

struct rx_desc {

        __le32 rx_status;

        __le32 desc_length; /* Chain flag, Buffer/frame length */

        __le32 addr;

        __le32 next_desc;

};

struct tx_desc {

        __le32 tx_status;

        __le32 desc_length; /* Chain flag, Tx Config, Frame length */

        __le32 addr;

        __le32 next_desc;

};

/* Initial value for tx_desc.desc_length, Buffer size goes to bits 0-10 */

#define TXDESC          0x00e08000

enum rx_status_bits {

        RxOK=0x8000, RxWholePkt=0x0300, RxErr=0x008F

};

/* Bits in *_desc.*_status */

enum desc_status_bits {

        DescOwn=0x80000000

};

/* Bits in ChipCmd. */

enum chip_cmd_bits {

        CmdInit=0x01, CmdStart=0x02, CmdStop=0x04, CmdRxOn=0x08,

        CmdTxOn=0x10, Cmd1TxDemand=0x20, CmdRxDemand=0x40,

        Cmd1EarlyRx=0x01, Cmd1EarlyTx=0x02, Cmd1FDuplex=0x04,

        Cmd1NoTxPoll=0x08, Cmd1Reset=0x80,

};

struct rhine_private {

        /* Descriptor rings */

        struct rx_desc *rx_ring;

        struct tx_desc *tx_ring;

        dma_addr_t rx_ring_dma;

        dma_addr_t tx_ring_dma;

        /* The addresses of receive-in-place skbuffs. */

        struct sk_buff *rx_skbuff[RX_RING_SIZE];

        dma_addr_t rx_skbuff_dma[RX_RING_SIZE];

        /* The saved address of a sent-in-place packet/buffer, for later free(). */

        struct sk_buff *tx_skbuff[TX_RING_SIZE];

        dma_addr_t tx_skbuff_dma[TX_RING_SIZE];

        /* Tx bounce buffers (Rhine-I only) */

        unsigned char *tx_buf[TX_RING_SIZE];

        unsigned char *tx_bufs;

        dma_addr_t tx_bufs_dma;

        struct pci_dev *pdev;

        long pioaddr;

        struct net_device *dev;

        struct napi_struct napi;

        struct net_device_stats stats;

        spinlock_t lock;

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

        u32 quirks;

        struct rx_desc *rx_head_desc;

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

        unsigned int cur_tx, dirty_tx;

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

        u8 wolopts;

        u8 tx_thresh, rx_thresh;

        struct mii_if_info mii_if;

        void __iomem *base;

};

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  rhine_open(struct net_device *dev);

static void rhine_tx_timeout(struct net_device *dev);

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

static irqreturn_t rhine_interrupt(int irq, void *dev_instance);

static void rhine_tx(struct net_device *dev);

static int rhine_rx(struct net_device *dev, int limit);

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

static void rhine_set_rx_mode(struct net_device *dev);

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

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

static const struct ethtool_ops netdev_ethtool_ops;

static int  rhine_close(struct net_device *dev);

static void rhine_shutdown (struct pci_dev *pdev);

#define RHINE_WAIT_FOR(condition) do {                                  \

        int i=1024;                                                     \

        while (!(condition) && --i)                                     \

                ;                                                       \

        if (debug > 1 && i < 512)                                       \

                printk(KERN_INFO "%s: %4d cycles used @ %s:%d\n",       \

                                DRV_NAME, 1024-i, __func__, __LINE__);  \

} while(0)

static inline u32 get_intr_status(struct net_device *dev)

{

        struct rhine_private *rp = netdev_priv(dev);

        void __iomem *ioaddr = rp->base;

        u32 intr_status;

        intr_status = ioread16(ioaddr + IntrStatus);

        /* On Rhine-II, Bit 3 indicates Tx descriptor write-back race. */

        if (rp->quirks & rqStatusWBRace)

                intr_status |= ioread8(ioaddr + IntrStatus2) << 16;

        return intr_status;

}

/*

 * Get power related registers into sane state.

 * Notify user about past WOL event.

 */

static void rhine_power_init(struct net_device *dev)

{

        struct rhine_private *rp = netdev_priv(dev);

        void __iomem *ioaddr = rp->base;

        u16 wolstat;

        if (rp->quirks & rqWOL) {

                /* Make sure chip is in power state D0 */

                iowrite8(ioread8(ioaddr + StickyHW) & 0xFC, ioaddr + StickyHW);

                /* Disable "force PME-enable" */

                iowrite8(0x80, ioaddr + WOLcgClr);

                /* Clear power-event config bits (WOL) */

                iowrite8(0xFF, ioaddr + WOLcrClr);

                /* More recent cards can manage two additional patterns */

                if (rp->quirks & rq6patterns)

                        iowrite8(0x03, ioaddr + WOLcrClr1);

                /* Save power-event status bits */

                wolstat = ioread8(ioaddr + PwrcsrSet);

                if (rp->quirks & rq6patterns)

                        wolstat |= (ioread8(ioaddr + PwrcsrSet1) & 0x03) << 8;

                /* Clear power-event status bits */

                iowrite8(0xFF, ioaddr + PwrcsrClr);

                if (rp->quirks & rq6patterns)

                        iowrite8(0x03, ioaddr + PwrcsrClr1);

                if (wolstat) {

                        char *reason;

                        switch (wolstat) {

                        case WOLmagic:

                                reason = "Magic packet";

                                break;

                        case WOLlnkon:

                                reason = "Link went up";

                                break;

                        case WOLlnkoff:

                                reason = "Link went down";

                                break;

                        case WOLucast:

                                reason = "Unicast packet";

                                break;

                        case WOLbmcast:

                                reason = "Multicast/broadcast packet";

                                break;

                        default:

                                reason = "Unknown";

                        }

                        printk(KERN_INFO "%s: Woke system up. Reason: %s.\n",

                               DRV_NAME, reason);

                }

        }

}

static void rhine_chip_reset(struct net_device *dev)

{

        struct rhine_private *rp = netdev_priv(dev);

        void __iomem *ioaddr = rp->base;

        iowrite8(Cmd1Reset, ioaddr + ChipCmd1);

        IOSYNC;

        if (ioread8(ioaddr + ChipCmd1) & Cmd1Reset) {

                printk(KERN_INFO "%s: Reset not complete yet. "

                        "Trying harder.\n", DRV_NAME);

                /* Force reset */

                if (rp->quirks & rqForceReset)

                        iowrite8(0x40, ioaddr + MiscCmd);

                /* Reset can take somewhat longer (rare) */

                RHINE_WAIT_FOR(!(ioread8(ioaddr + ChipCmd1) & Cmd1Reset));

        }

        if (debug > 1)

                printk(KERN_INFO "%s: Reset %s.\n", dev->name,

                        (ioread8(ioaddr + ChipCmd1) & Cmd1Reset) ?

                        "failed" : "succeeded");

}

#ifdef USE_MMIO

static void enable_mmio(long pioaddr, u32 quirks)

{

        int n;

        if (quirks & rqRhineI) {

                /* More recent docs say that this bit is reserved ... */

                n = inb(pioaddr + ConfigA) | 0x20;

                outb(n, pioaddr + ConfigA);

        } else {

                n = inb(pioaddr + ConfigD) | 0x80;

                outb(n, pioaddr + ConfigD);

        }

}

#endif

/*

 * Loads bytes 0x00-0x05, 0x6E-0x6F, 0x78-0x7B from EEPROM

 * (plus 0x6C for Rhine-I/II)

 */

static void __devinit rhine_reload_eeprom(long pioaddr, struct net_device *dev)

{

        struct rhine_private *rp = netdev_priv(dev);

        void __iomem *ioaddr = rp->base;

        outb(0x20, pioaddr + MACRegEEcsr);

        RHINE_WAIT_FOR(!(inb(pioaddr + MACRegEEcsr) & 0x20));

#ifdef USE_MMIO

        /*

         * Reloading from EEPROM overwrites ConfigA-D, so we must re-enable

         * MMIO. If reloading EEPROM was done first this could be avoided, but

         * it is not known if that still works with the "win98-reboot" problem.

         */

        enable_mmio(pioaddr, rp->quirks);

#endif

        /* Turn off EEPROM-controlled wake-up (magic packet) */

        if (rp->quirks & rqWOL)

                iowrite8(ioread8(ioaddr + ConfigA) & 0xFC, ioaddr + ConfigA);

}

#ifdef CONFIG_NET_POLL_CONTROLLER

static void rhine_poll(struct net_device *dev)

{

        disable_irq(dev->irq);

        rhine_interrupt(dev->irq, (void *)dev);

        enable_irq(dev->irq);

}

#endif

#ifdef CONFIG_VIA_RHINE_NAPI

static int rhine_napipoll(struct napi_struct *napi, int budget)

{

        struct rhine_private *rp = container_of(napi, struct rhine_private, napi);

        struct net_device *dev = rp->dev;

        void __iomem *ioaddr = rp->base;

        int work_done;

        work_done = rhine_rx(dev, budget);

        if (work_done < budget) {

                netif_rx_complete(dev, napi);

                iowrite16(IntrRxDone | IntrRxErr | IntrRxEmpty| IntrRxOverflow |

                          IntrRxDropped | IntrRxNoBuf | IntrTxAborted |

                          IntrTxDone | IntrTxError | IntrTxUnderrun |

                          IntrPCIErr | IntrStatsMax | IntrLinkChange,

                          ioaddr + IntrEnable);

        }

        return work_done;

}

#endif

static void rhine_hw_init(struct net_device *dev, long pioaddr)

{

        struct rhine_private *rp = netdev_priv(dev);

        /* Reset the chip to erase previous misconfiguration. */

        rhine_chip_reset(dev);

        /* Rhine-I needs extra time to recuperate before EEPROM reload */

        if (rp->quirks & rqRhineI)

                msleep(5);

        /* Reload EEPROM controlled bytes cleared by soft reset */

        rhine_reload_eeprom(pioaddr, dev);

}

static int __devinit rhine_init_one(struct pci_dev *pdev,

                                    const struct pci_device_id *ent)

{

        struct net_device *dev;

        struct rhine_private *rp;

        int i, rc;

        u32 quirks;

        long pioaddr;

        long memaddr;

        void __iomem *ioaddr;

        int io_size, phy_id;

        const char *name;

#ifdef USE_MMIO

        int bar = 1;

#else

        int bar = 0;

#endif

        DECLARE_MAC_BUF(mac);

/* when built into the kernel, we only print version if device is found */

#ifndef MODULE

        static int printed_version;

        if (!printed_version++)

                printk(version);

#endif

        io_size = 256;

        phy_id = 0;

        quirks = 0;

        name = "Rhine";

        if (pdev->revision < VTunknown0) {

                quirks = rqRhineI;

                io_size = 128;

        }

        else if (pdev->revision >= VT6102) {

                quirks = rqWOL | rqForceReset;

                if (pdev->revision < VT6105) {

                        name = "Rhine II";

                        quirks |= rqStatusWBRace;       /* Rhine-II exclusive */

                }

                else {

                        phy_id = 1;     /* Integrated PHY, phy_id fixed to 1 */

                        if (pdev->revision >= VT6105_B0)

                                quirks |= rq6patterns;

                        if (pdev->revision < VT6105M)

                                name = "Rhine III";

                        else

                                name = "Rhine III (Management Adapter)";

                }

        }

        rc = pci_enable_device(pdev);

        if (rc)

                goto err_out;

        /* this should always be supported */

        rc = pci_set_dma_mask(pdev, DMA_32BIT_MASK);

        if (rc) {

                printk(KERN_ERR "32-bit PCI DMA addresses not supported by "

                       "the card!?\n");

                goto err_out;

        }

        /* sanity check */

        if ((pci_resource_len(pdev, 0) < io_size) ||

            (pci_resource_len(pdev, 1) < io_size)) {

                rc = -EIO;

                printk(KERN_ERR "Insufficient PCI resources, aborting\n");

                goto err_out;

        }

        pioaddr = pci_resource_start(pdev, 0);

        memaddr = pci_resource_start(pdev, 1);

        pci_set_master(pdev);

        dev = alloc_etherdev(sizeof(struct rhine_private));

        if (!dev) {

                rc = -ENOMEM;

                printk(KERN_ERR "alloc_etherdev failed\n");

                goto err_out;

        }