Subversion Repositories or1k

/* tulip.c: A DEC 21040-family ethernet driver for Linux. */

/*

        Written 1994-1998 by Donald Becker.

        This software may be used and distributed according to the terms

        of the GNU Public License, incorporated herein by reference.

        This driver is for the Digital "Tulip" Ethernet adapter interface.

        It should work with most DEC 21*4*-based chips/ethercards, as well as

        with work-alike chips from Lite-On (PNIC) and Macronix (MXIC) and ASIX.

        The author may be reached as becker@CESDIS.gsfc.nasa.gov, or C/O

        Center of Excellence in Space Data and Information Sciences

           Code 930.5, Goddard Space Flight Center, Greenbelt MD 20771

        Support and updates available at

        http://cesdis.gsfc.nasa.gov/linux/drivers/tulip.html

*/

#define SMP_CHECK

static const char version[] = "tulip.c:v0.90 10/20/98 becker@cesdis.gsfc.nasa.gov\n";

/* A few user-configurable values. */

/* Maximum events (Rx packets, etc.) to handle at each interrupt. */

static int max_interrupt_work = 25;

#define MAX_UNITS 8

/* Used to pass the full-duplex flag, etc. */

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

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

static int mtu[MAX_UNITS] = {0, };                       /* Jumbo MTU for interfaces. */

/*  The possible media types that can be set in options[] are: */

static const char * const medianame[] = {

        "10baseT", "10base2", "AUI", "100baseTx",

        "10baseT-FD", "100baseTx-FD", "100baseT4", "100baseFx",

        "100baseFx-FD", "MII 10baseT", "MII 10baseT-FD", "MII",

        "10baseT(forced)", "MII 100baseTx", "MII 100baseTx-FD", "MII 100baseT4",

};

/* Set if the PCI BIOS detects the chips on a multiport board backwards. */

#ifdef REVERSE_PROBE_ORDER

static int reverse_probe = 1;

#else

static int reverse_probe = 0;

#endif

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

   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 RX_RING_SIZE    32

/* Set the copy breakpoint for the copy-only-tiny-buffer Rx structure. */

#ifdef __alpha__

static int rx_copybreak = 1518;

#else

static int rx_copybreak = 100;

#endif

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

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

#define TX_TIMEOUT  (4*HZ)

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

/* This is a mysterious value that can be written to CSR11 in the 21040 (only)

   to support a pre-NWay full-duplex signaling mechanism using short frames.

   No one knows what it should be, but if left at its default value some

   10base2(!) packets trigger a full-duplex-request interrupt. */

#define FULL_DUPLEX_MAGIC       0x6969

#include <linux/config.h>

#include <linux/version.h>

#ifdef MODULE

#ifdef MODVERSIONS

#include <linux/modversions.h>

#endif

#include <linux/module.h>

#else

#define MOD_INC_USE_COUNT

#define MOD_DEC_USE_COUNT

#endif

#include <linux/kernel.h>

#include <linux/sched.h>

#include <linux/string.h>

#include <linux/timer.h>

#include <linux/errno.h>

#include <linux/ioport.h>

#include <linux/malloc.h>

#include <linux/interrupt.h>

#include <linux/pci.h>

#include <linux/netdevice.h>

#include <linux/etherdevice.h>

#include <linux/skbuff.h>

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

#include <asm/bitops.h>

#include <asm/io.h>

/* Kernel compatibility defines, some common to David Hind's PCMCIA package.

   This is only in the support-all-kernels source code. */

#if defined(MODULE) && LINUX_VERSION_CODE > 0x20115

MODULE_AUTHOR("Donald Becker <becker@cesdis.gsfc.nasa.gov>");

MODULE_DESCRIPTION("Digital 21*4* Tulip ethernet driver");

MODULE_PARM(debug, "i");

MODULE_PARM(max_interrupt_work, "i");

MODULE_PARM(reverse_probe, "i");

MODULE_PARM(rx_copybreak, "i");

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

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

#endif

#define RUN_AT(x) (jiffies + (x))

#if (LINUX_VERSION_CODE >= 0x20100)

char kernel_version[] = UTS_RELEASE;

#endif

#if LINUX_VERSION_CODE < 0x20123

#define hard_smp_processor_id() smp_processor_id()

#define test_and_set_bit(val, addr) set_bit(val, addr)

#endif

#if LINUX_VERSION_CODE <= 0x20139

#define net_device_stats enet_statistics

#else

#define NETSTATS_VER2

#endif

#if LINUX_VERSION_CODE < 0x20155  ||  defined(CARDBUS)

/* Grrrr, the PCI code changed, but did not consider CardBus... */

#include <linux/bios32.h>

#define PCI_SUPPORT_VER1

#else

#define PCI_SUPPORT_VER2

#endif

#if LINUX_VERSION_CODE < 0x20159

#define dev_free_skb(skb) dev_kfree_skb(skb, FREE_WRITE);

#else

#define dev_free_skb(skb) dev_kfree_skb(skb);

#endif

#define tulip_debug debug

#ifdef TULIP_DEBUG

static int tulip_debug = TULIP_DEBUG;

#else

static int tulip_debug = 1;

#endif

/*

                                Theory of Operation

I. Board Compatibility

This device driver is designed for the DECchip "Tulip", Digital's

single-chip ethernet controllers for PCI.  Supported members of the family

are the 21040, 21041, 21140, 21140A, 21142, and 21143.  Similar work-alike

chips from Lite-On, Macronics, ASIX, Compex and other listed below are also

supported.

These chips are used on at least 140 unique PCI board designs.  The great

number of chips and board designs supported is the reason for the

driver size and complexity.  Almost of the increasing complexity is in the

board configuration and media selection code.  There is very little

increasing in the operational critical path length.

II. Board-specific settings

PCI bus devices are configured by the system at boot time, so no jumpers

need to be set on the board.  The system BIOS preferably should assign the

PCI INTA signal to an otherwise unused system IRQ line.

Some boards have EEPROMs tables with default media entry.  The factory default

is usually "autoselect".  This should only be overridden when using

transceiver connections without link beat e.g. 10base2 or AUI, or (rarely!)

for forcing full-duplex when used with old link partners that do not do

autonegotiation.

III. Driver operation

IIIa. Ring buffers

The Tulip can use either ring buffers or lists of Tx and Rx descriptors.

This driver uses statically allocated rings of Rx and Tx descriptors, set at

compile time by RX/TX_RING_SIZE.  This version of the driver allocates skbuffs

for the Rx ring buffers at open() time and passes the skb->data field to the

Tulip 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 and replaced by a newly allocated

skbuff.

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.  For small frames the copying cost is negligible (esp. considering

that we are pre-loading the cache with immediately useful header

information).  For large frames the copying cost is non-trivial, and the

larger copy might flush the cache of useful data.  A subtle aspect of this

choice is that the Tulip only receives into longword aligned buffers, thus

the IP header at offset 14 isn't longword aligned for further processing.

Copied frames are put into the new skbuff at an offset of "+2", thus copying

has the beneficial effect of aligning the IP header and preloading the

cache.

IIIC. 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 other software.

The send packet thread has partial control over the Tx ring and 'dev->tbusy'

flag.  It sets the tbusy flag whenever it's queuing a Tx packet. If the next

queue slot is empty, it clears the tbusy flag when finished otherwise it sets

the 'tp->tx_full' flag.

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

from the Tx ring.  (The Tx-done interrupt can't be selectively turned off, so

we can't avoid the interrupt overhead by having the Tx routine reap the Tx

stats.)  After reaping the stats, it marks the queue entry as empty by setting

the 'base' to zero.      Iff the 'tp->tx_full' flag is set, it clears both the

tx_full and tbusy flags.

IV. Notes

Thanks to Duke Kamstra of SMC for long ago providing an EtherPower board.

Greg LaPolla at Linksys provided PNIC and other Linksys boards.

Znyx provided a four-port card for testing.

IVb. References

http://cesdis.gsfc.nasa.gov/linux/misc/NWay.html

http://www.digital.com  (search for current 21*4* datasheets and "21X4 SROM")

http://www.national.com/pf/DP/DP83840.html

IVc. Errata

The old DEC databooks were light on details.

The 21040 databook claims that CSR13, CSR14, and CSR15 should each be the last

register of the set CSR12-15 written.  Hmmm, now how is that possible?

The DEC SROM format is very badly designed not precisely defined, leading to

part of the media selection junkheap below.  Some boards do not have EEPROM

media tables and need to be patched up.  Worse, other boards use the DEC

design kit media table when it isn't correct for their board.

We cannot use MII interrupts because there is no defined GPIO pin to attach

them.

*/

#ifndef PCI_VENDOR_ID_DEC               /* Now defined in linux/pci.h */

#define PCI_VENDOR_ID_DEC                       0x1011

#endif

static struct device *

tulip_probe1(int pci_bus, int pci_devfn, struct device *dev, long ioaddr,

                         int irq, int chip_idx, int board_idx);

/* 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 pci_flags_bit {

        PCI_USES_IO=1, PCI_USES_MEM=2, PCI_USES_MASTER=4,

        PCI_ADDR0=0x10<<0, PCI_ADDR1=0x10<<1, PCI_ADDR2=0x10<<2, PCI_ADDR3=0x10<<3,

};

#define PCI_ADDR0_IO (PCI_USES_IO|PCI_ADDR0)

struct pci_id_info {

        const char *name;

        u16     vendor_id, device_id, device_id_mask, flags;

        int io_size, min_latency;

        struct device *(*probe1)(int pci_bus, int pci_devfn, struct device *dev,

                                                         long ioaddr, int irq, int chip_idx, int fnd_cnt);

};

#ifndef CARDBUS

static struct pci_id_info pci_tbl[] = {

  { "Digital DC21040 Tulip",

        0x1011, 0x0002, 0xffff, PCI_ADDR0_IO, 128, 32, tulip_probe1 },

  { "Digital DC21041 Tulip",

        0x1011, 0x0014, 0xffff, PCI_ADDR0_IO, 128, 32, tulip_probe1 },

  { "Digital DS21140 Tulip",

        0x1011, 0x0009, 0xffff, PCI_ADDR0_IO, 128, 32, tulip_probe1 },

  { "Digital DS21143 Tulip",

        0x1011, 0x0019, 0xffff, PCI_ADDR0_IO, 128, 32, tulip_probe1 },

  { "Lite-On 82c168 PNIC",

        0x11AD, 0x0002, 0xffff, PCI_ADDR0_IO, 256, 32, tulip_probe1 },

  { "Macronix 98713 PMAC",

        0x10d9, 0x0512, 0xffff, PCI_ADDR0_IO, 256, 32, tulip_probe1 },

  { "Macronix 98715 PMAC",

        0x10d9, 0x0531, 0xffff, PCI_ADDR0_IO, 256, 32, tulip_probe1 },

  { "Macronix 98725 PMAC",

        0x10d9, 0x0531, 0xffff, PCI_ADDR0_IO, 256, 32, tulip_probe1 },

  { "ASIX AX88140",

        0x125B, 0x1400, 0xffff, PCI_ADDR0_IO, 128, 32, tulip_probe1 },

  {0},

};

#endif CARD_BUS

/* This table use during operation for capabilities and media timer. */

static void tulip_timer(unsigned long data);

static void t21142_timer(unsigned long data);

static void mxic_timer(unsigned long data);

static void pnic_timer(unsigned long data);

enum tbl_flag {

        HAS_MII=1, HAS_MEDIA_TABLE=2, CSR12_IN_SROM=4, ALWAYS_CHECK_MII=8,

        HAS_ACPI=0x10,

};

static struct tulip_chip_table {

        char *chip_name;

        int io_size;

        int valid_intrs;                        /* CSR7 interrupt enable settings */

        int flags;

        void (*media_timer)(unsigned long data);

} tulip_tbl[] = {

  { "Digital DC21040 Tulip", 128, 0x0001ebef, 0, tulip_timer },

  { "Digital DC21041 Tulip", 128, 0x0001ebef, HAS_MEDIA_TABLE, tulip_timer },

  { "Digital DS21140 Tulip", 128, 0x0001ebef,

        HAS_MII | HAS_MEDIA_TABLE | CSR12_IN_SROM, tulip_timer },

  { "Digital DS21143 Tulip", 128, 0x0801fbff,

        HAS_MII | HAS_MEDIA_TABLE | ALWAYS_CHECK_MII | HAS_ACPI, t21142_timer },

  { "Lite-On 82c168 PNIC", 256, 0x0001ebef,

        HAS_MII, pnic_timer },

  { "Macronix 98713 PMAC", 128, 0x0001ebef,

        HAS_MII | HAS_MEDIA_TABLE | CSR12_IN_SROM, mxic_timer },

  { "Macronix 98715 PMAC", 256, 0x0001ebef,

        HAS_MEDIA_TABLE, mxic_timer },

  { "Macronix 98725 PMAC", 256, 0x0001ebef,

        HAS_MEDIA_TABLE, mxic_timer },

  { "ASIX AX88140", 128, 0x0001fbff,

        HAS_MII | HAS_MEDIA_TABLE | CSR12_IN_SROM, tulip_timer },

  {0},

};

/* This matches the table above. */

enum chips { DC21040=0, DC21041=1, DC21140=2, DC21142=3, DC21143=3,

                         LC82C168, MX98713, MX98715, MX98725};

/* A full-duplex map for media types. */

enum MediaIs {MediaIsFD = 1, MediaAlwaysFD=2, MediaIsMII=4, MediaIsFx=8,

                  MediaIs100=16};

static const char media_cap[] =

{0,0,0,16,  3,19,16,24,  27,4,7,5, 0,20,23,20 };

/* 21041 transceiver register settings: 10-T, 10-2, AUI, 10-T, 10T-FD*/

static u16 t21041_csr13[] = { 0xEF05, 0xEF09, 0xEF09, 0xEF01, 0xEF09, };

static u16 t21041_csr14[] = { 0x7F3F, 0xF7FD, 0xF7FD, 0x7F3F, 0x7F3D, };

static u16 t21041_csr15[] = { 0x0008, 0x0006, 0x000E, 0x0008, 0x0008, };

static u16 t21142_csr13[] = { 0x0001, 0x0009, 0x0009, 0x0000, 0x0001, };

static u16 t21142_csr14[] = { 0xFFFF, 0x0705, 0x0705, 0x0000, 0x7F3D, };

static u16 t21142_csr15[] = { 0x0008, 0x0006, 0x000E, 0x0008, 0x0008, };

/* Offsets to the Command and Status Registers, "CSRs".  All accesses

   must be longword instructions and quadword aligned. */

enum tulip_offsets {

        CSR0=0,    CSR1=0x08, CSR2=0x10, CSR3=0x18, CSR4=0x20, CSR5=0x28,

        CSR6=0x30, CSR7=0x38, CSR8=0x40, CSR9=0x48, CSR10=0x50, CSR11=0x58,

        CSR12=0x60, CSR13=0x68, CSR14=0x70, CSR15=0x78 };

/* The bits in the CSR5 status registers, mostly interrupt sources. */

enum status_bits {

        TimerInt=0x800, TPLnkFail=0x1000, TPLnkPass=0x10,

        NormalIntr=0x10000, AbnormalIntr=0x8000,

        RxJabber=0x200, RxDied=0x100, RxNoBuf=0x80, RxIntr=0x40,

        TxFIFOUnderflow=0x20, TxJabber=0x08, TxNoBuf=0x04, TxDied=0x02, TxIntr=0x01,

};

/* The Tulip Rx and Tx buffer descriptors. */

struct tulip_rx_desc {

        s32 status;

        s32 length;

        u32 buffer1, buffer2;

};

struct tulip_tx_desc {

        s32 status;

        s32 length;

        u32 buffer1, buffer2;                           /* We use only buffer 1.  */

};

/* Ring-wrap flag in length field, use for last ring entry.

        0x01000000 means chain on buffer2 address,

        0x02000000 means use the ring start address in CSR2/3.

   Note: Some work-alike chips do not function correctly in chained mode.

*/

#define DESC_RING_WRAP 0x02000000

struct medialeaf {

        u8 type;

        u8 media;

        unsigned char *leafdata;

};

struct mediatable {

        u16 defaultmedia;

        u8 leafcount, csr12dir;                         /* General purpose pin directions. */

        unsigned has_mii:1, has_nonmii:1;

        struct medialeaf mleaf[0];

};

struct mediainfo {

        struct mediainfo *next;

        int info_type;

        int index;

        unsigned char *info;

};

struct tulip_private {

        char devname[8];                        /* Used only for kernel debugging. */

        const char *product_name;

        struct device *next_module;

        struct tulip_rx_desc rx_ring[RX_RING_SIZE];

        struct tulip_tx_desc tx_ring[TX_RING_SIZE];

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

        struct sk_buff* tx_skbuff[TX_RING_SIZE];

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

        struct sk_buff* rx_skbuff[RX_RING_SIZE];

        char *rx_buffs;                         /* Address of temporary Rx buffers. */

        u32 setup_frame[48];            /* Pseudo-Tx frame to init address table. */

        int chip_id;

        int revision;

        struct net_device_stats stats;

        struct timer_list timer;        /* Media selection timer. */

        int interrupt;                          /* In-interrupt flag. */

#ifdef SMP_CHECK

        int smp_proc_id;                        /* Which processor in IRQ handler. */

#endif

        unsigned int cur_rx, cur_tx;            /* The next free ring entry */

        unsigned int dirty_rx, dirty_tx;        /* The ring entries to be free()ed. */

        unsigned int tx_full:1;                         /* The Tx queue is full. */

        unsigned int full_duplex:1;                     /* Full-duplex operation requested. */

        unsigned int full_duplex_lock:1;

        unsigned int fake_addr:1;                       /* Multiport board faked address. */

        unsigned int default_port:4;            /* Last dev->if_port value. */

        unsigned int media2:4;                          /* Secondary monitored media port. */

        unsigned int medialock:1;                       /* Don't sense media type. */

        unsigned int mediasense:1;                      /* Media sensing in progress. */

        unsigned int csr6;                                      /* Current CSR6 control settings. */

        unsigned char eeprom[128];                      /* Serial EEPROM contents. */

        u16 to_advertise;                                       /* NWay capabilities advertised.  */

        u16 advertising[4];

        signed char phys[4], mii_cnt;           /* MII device addresses. */

        struct mediatable *mtable;

        int cur_index;                                          /* Current media index. */

        int saved_if_port;

        unsigned char pci_bus, pci_devfn;

        int pad0, pad1;                                         /* Used for 8-byte alignment */

};

static void parse_eeprom(struct device *dev);

static int read_eeprom(long ioaddr, int location);

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

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

static void select_media(struct device *dev, int startup);

static int tulip_open(struct device *dev);

static void tulip_timer(unsigned long data);

static void tulip_tx_timeout(struct device *dev);

static void tulip_init_ring(struct device *dev);

static int tulip_start_xmit(struct sk_buff *skb, struct device *dev);

static int tulip_rx(struct device *dev);

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

static int tulip_close(struct device *dev);

static struct net_device_stats *tulip_get_stats(struct device *dev);

#ifdef HAVE_PRIVATE_IOCTL

static int private_ioctl(struct device *dev, struct ifreq *rq, int cmd);

#endif

static void set_rx_mode(struct device *dev);

/* A list of all installed Tulip devices. */

static struct device *root_tulip_dev = NULL;

#ifndef CARDBUS

int tulip_probe(struct device *dev)

{

        int cards_found = 0;

        int pci_index = 0;

        unsigned char pci_bus, pci_device_fn;

        if ( ! pcibios_present())

                return -ENODEV;

        for (;pci_index < 0xff; pci_index++) {

                u16 vendor, device, pci_command, new_command;

                int chip_idx;

                int irq;

                long ioaddr;

                if (pcibios_find_class

                        (PCI_CLASS_NETWORK_ETHERNET << 8,

                         reverse_probe ? 0xfe - pci_index : pci_index,

                         &pci_bus, &pci_device_fn) != PCIBIOS_SUCCESSFUL)

                        if (reverse_probe)

                                continue;

                        else

                                break;

                pcibios_read_config_word(pci_bus, pci_device_fn,

                                                                 PCI_VENDOR_ID, &vendor);

                pcibios_read_config_word(pci_bus, pci_device_fn,

                                                                 PCI_DEVICE_ID, &device);

                for (chip_idx = 0; pci_tbl[chip_idx].vendor_id; chip_idx++)

                        if (vendor == pci_tbl[chip_idx].vendor_id

                                && (device & pci_tbl[chip_idx].device_id_mask) ==

                                pci_tbl[chip_idx].device_id)

                                break;

                if (pci_tbl[chip_idx].vendor_id == 0)

                        continue;

                {

#if defined(PCI_SUPPORT_VER2)

                        struct pci_dev *pdev = pci_find_slot(pci_bus, pci_device_fn);

                        ioaddr = pdev->base_address[0] & ~3;

                        irq = pdev->irq;

#else

                        u32 pci_ioaddr;

                        u8 pci_irq_line;

                        pcibios_read_config_dword(pci_bus, pci_device_fn,

                                                                          PCI_BASE_ADDRESS_0, &pci_ioaddr);

                        pcibios_read_config_byte(pci_bus, pci_device_fn,

                                                                         PCI_INTERRUPT_LINE, &pci_irq_line);

                        ioaddr = pci_ioaddr & ~3;

                        irq = pci_irq_line;

#endif

                }

                if (debug > 2)

                        printk(KERN_INFO "Found %s at PCI I/O address %#lx.\n",

                                   pci_tbl[chip_idx].name, ioaddr);

                if (check_region(ioaddr, pci_tbl[chip_idx].io_size))

                        continue;

                pcibios_read_config_word(pci_bus, pci_device_fn,

                                                                 PCI_COMMAND, &pci_command);

                new_command = pci_command | PCI_COMMAND_MASTER|PCI_COMMAND_IO;

                if (pci_command != new_command) {

                        printk(KERN_INFO "  The PCI BIOS has not enabled the"

                                   " device at %d/%d!  Updating PCI command %4.4x->%4.4x.\n",

                                   pci_bus, pci_device_fn, pci_command, new_command);

                        pcibios_write_config_word(pci_bus, pci_device_fn,

                                                                          PCI_COMMAND, new_command);

                }

                dev = pci_tbl[chip_idx].probe1(pci_bus, pci_device_fn, dev, ioaddr,

                                                                           irq, chip_idx, cards_found);

                /* Get and check the bus-master and latency values. */

                if (dev) {

                        u8 pci_latency;

                        pcibios_read_config_byte(pci_bus, pci_device_fn,

                                                                         PCI_LATENCY_TIMER, &pci_latency);

                        if (pci_latency < 10) {

                                printk(KERN_INFO "  PCI latency timer (CFLT) is "

                                           "unreasonably low at %d.  Setting to 64 clocks.\n",

                                           pci_latency);

                                pcibios_write_config_byte(pci_bus, pci_device_fn,

                                                                                  PCI_LATENCY_TIMER, 64);

                        }

                }

                dev = 0;

                cards_found++;

        }

        return cards_found ? 0 : -ENODEV;

}

#endif  /* not CARDBUS */

static struct device *tulip_probe1(int pci_bus, int pci_devfn,

                                                                   struct device *dev, long ioaddr, int irq,

                                                                   int chip_idx, int board_idx)

{

        static int did_version = 0;                      /* Already printed version info. */

        struct tulip_private *tp;

        /* See note below on the multiport cards. */

        static unsigned char last_phys_addr[6] = {0x00, 'L', 'i', 'n', 'u', 'x'};

        static int last_irq = 0;

        static int multiport_cnt = 0;            /* For four-port boards w/one EEPROM */

        int i;

        unsigned short sum;

        if (tulip_debug > 0  &&  did_version++ == 0)

                printk(KERN_INFO "%s", version);

        dev = init_etherdev(dev, 0);

        /* Bring the 21143 out of sleep mode.

           Caution: Snooze mode does not work with some boards! */

        if (tulip_tbl[chip_idx].flags & HAS_ACPI)

                pcibios_write_config_dword(pci_bus, pci_devfn, 0x40, 0x00000000);

        printk(KERN_INFO "%s: %s at %#3lx,",

                   dev->name, tulip_tbl[chip_idx].chip_name, ioaddr);

        /* Stop the chip's Tx and Rx processes. */

        outl(inl(ioaddr + CSR6) & ~0x2002, ioaddr + CSR6);

        /* Clear the missed-packet counter. */

        (volatile int)inl(ioaddr + CSR8);

        if (chip_idx == DC21041) {

                if (inl(ioaddr + CSR9) & 0x8000) {

                        printk(" 21040 compatible mode,");

                        chip_idx = DC21040;

                } else {

                        printk(" 21041 mode,");

                }

        }

        /* The station address ROM is read byte serially.  The register must

           be polled, waiting for the value to be read bit serially from the

           EEPROM.

           */

        sum = 0;

        if (chip_idx == DC21040) {

                outl(0, ioaddr + CSR9);          /* Reset the pointer with a dummy write. */

                for (i = 0; i < 6; i++) {

                        int value, boguscnt = 100000;

                        do

                                value = inl(ioaddr + CSR9);

                        while (value < 0  && --boguscnt > 0);

                        dev->dev_addr[i] = value;

                        sum += value & 0xff;

                }

        } else if (chip_idx == LC82C168) {

                for (i = 0; i < 3; i++) {

                        int value, boguscnt = 100000;

                        outl(0x600 | i, ioaddr + 0x98);

                        do

                                value = inl(ioaddr + CSR9);

                        while (value < 0  && --boguscnt > 0);

                        ((u16*)dev->dev_addr)[i] = value;

                        sum += value & 0xffff;

                }

        } else {        /* Must be a new chip, with a serial EEPROM interface. */

                /* We read the whole EEPROM, and sort it out later.  DEC has a

                   specification _Digital Semiconductor 21X4 Serial ROM Format_

                   but early vendor boards just put the address in the first six

                   EEPROM locations. */

                unsigned char ee_data[128];

                int sa_offset = 0;

                for (i = 0; i < sizeof(ee_data)/2; i++)

                        ((u16 *)ee_data)[i] = read_eeprom(ioaddr, i);

                /* Detect the simple EEPROM format by the duplicated station addr. */

                for (i = 0; i < 8; i ++)

                        if (ee_data[i] != ee_data[16+i])

                                sa_offset = 20;

                if (ee_data[0] == 0xff  &&  ee_data[1] == 0xff &&  ee_data[2] == 0) {