Subversion Repositories or1k

/* cs89x0.c: A Crystal Semiconductor (Now Cirrus Logic) CS89[02]0

 *  driver for linux.

 */

/*

        Written 1996 by Russell Nelson, with reference to skeleton.c

        written 1993-1994 by Donald Becker.

        This software may be used and distributed according to the terms

        of the GNU General Public License, incorporated herein by reference.

        The author may be reached at nelson@crynwr.com, Crynwr

        Software, 521 Pleasant Valley Rd., Potsdam, NY 13676

  Changelog:

  Mike Cruse        : mcruse@cti-ltd.com

                    : Changes for Linux 2.0 compatibility.

                    : Added dev_id parameter in net_interrupt(),

                    : request_irq() and free_irq(). Just NULL for now.

  Mike Cruse        : Added MOD_INC_USE_COUNT and MOD_DEC_USE_COUNT macros

                    : in net_open() and net_close() so kerneld would know

                    : that the module is in use and wouldn't eject the

                    : driver prematurely.

  Mike Cruse        : Rewrote init_module() and cleanup_module using 8390.c

                    : as an example. Disabled autoprobing in init_module(),

                    : not a good thing to do to other devices while Linux

                    : is running from all accounts.

  Russ Nelson       : Jul 13 1998.  Added RxOnly DMA support.

  Melody Lee        : Aug 10 1999.  Changes for Linux 2.2.5 compatibility.

                    : email: ethernet@crystal.cirrus.com

  Alan Cox          : Removed 1.2 support, added 2.1 extra counters.

  Andrew Morton     : andrewm@uow.edu.au

                    : Kernel 2.3.48

                    : Handle kmalloc() failures

                    : Other resource allocation fixes

                    : Add SMP locks

                    : Integrate Russ Nelson's ALLOW_DMA functionality back in.

                    : If ALLOW_DMA is true, make DMA runtime selectable

                    : Folded in changes from Cirrus (Melody Lee

                    : <klee@crystal.cirrus.com>)

                    : Don't call netif_wake_queue() in net_send_packet()

                    : Fixed an out-of-mem bug in dma_rx()

                    : Updated Documentation/cs89x0.txt

  Andrew Morton     : andrewm@uow.edu.au / Kernel 2.3.99-pre1

                    : Use skb_reserve to longword align IP header (two places)

                    : Remove a delay loop from dma_rx()

                    : Replace '100' with HZ

                    : Clean up a couple of skb API abuses

                    : Added 'cs89x0_dma=N' kernel boot option

                    : Correctly initialise lp->lock in non-module compile

  Andrew Morton     : andrewm@uow.edu.au / Kernel 2.3.99-pre4-1

                    : MOD_INC/DEC race fix (see

                    : http://www.uwsg.indiana.edu/hypermail/linux/kernel/0003.3/1532.html)

  Andrew Morton     : andrewm@uow.edu.au / Kernel 2.4.0-test7-pre2

                    : Enhanced EEPROM support to cover more devices,

                    :   abstracted IRQ mapping to support CONFIG_ARCH_CLPS7500 arch

                    :   (Jason Gunthorpe <jgg@ualberta.ca>)

  Andrew Morton     : Kernel 2.4.0-test11-pre4

                    : Use dev->name in request_*() (Andrey Panin)

                    : Fix an error-path memleak in init_module()

                    : Preserve return value from request_irq()

                    : Fix type of `media' module parm (Keith Owens)

                    : Use SET_MODULE_OWNER()

                    : Tidied up strange request_irq() abuse in net_open().

  Andrew Morton     : Kernel 2.4.3-pre1

                    : Request correct number of pages for DMA (Hugh Dickens)

                    : Select PP_ChipID _after_ unregister_netdev in cleanup_module()

                    :  because unregister_netdev() calls get_stats.

                    : Make `version[]' __initdata

                    : Uninlined the read/write reg/word functions.

  Oskar Schirmer    : oskar@scara.com

                    : HiCO.SH4 (superh) support added (irq#1, cs89x0_media=)

*/

/* Always include 'config.h' first in case the user wants to turn on

   or override something. */

#include <linux/config.h>

#include <linux/module.h>

#include <linux/version.h>

/*

 * Set this to zero to disable DMA code

 *

 * Note that even if DMA is turned off we still support the 'dma' and  'use_dma'

 * module options so we don't break any startup scripts.

 */

#define ALLOW_DMA       1

/*

 * Set this to zero to remove all the debug statements via

 * dead code elimination

 */

#define DEBUGGING       1

/*

  Sources:

        Crynwr packet driver epktisa.

        Crystal Semiconductor data sheets.

*/

#include <linux/kernel.h>

#include <linux/sched.h>

#include <linux/types.h>

#include <linux/fcntl.h>

#include <linux/interrupt.h>

#include <linux/ptrace.h>

#include <linux/ioport.h>

#include <linux/in.h>

#include <linux/slab.h>

#include <linux/string.h>

#include <linux/init.h>

#include <asm/system.h>

#include <asm/bitops.h>

#include <asm/io.h>

#if ALLOW_DMA

#include <asm/dma.h>

#endif

#include <linux/errno.h>

#include <linux/spinlock.h>

#include <linux/netdevice.h>

#include <linux/etherdevice.h>

#include <linux/skbuff.h>

#include "cs89x0.h"

static char version[] __initdata =

"cs89x0.c: v2.4.3-pre1 Russell Nelson <nelson@crynwr.com>, Andrew Morton <andrewm@uow.edu.au>\n";

/* First, a few definitions that the brave might change.

   A zero-terminated list of I/O addresses to be probed. Some special flags..

      Addr & 1 = Read back the address port, look for signature and reset

                 the page window before probing

      Addr & 3 = Reset the page window and probe

   The CLPS eval board has the Cirrus chip at 0x80090300, in ARM IO space,

   but it is possible that a Cirrus board could be plugged into the ISA

   slots. */

/* The cs8900 has 4 IRQ pins, software selectable. cs8900_irq_map maps

   them to system IRQ numbers. This mapping is card specific and is set to

   the configuration of the Cirrus Eval board for this chip. */

#ifdef CONFIG_ARCH_CLPS7500

static unsigned int netcard_portlist[] __initdata =

   { 0x80090303, 0x300, 0x320, 0x340, 0x360, 0x200, 0x220, 0x240, 0x260, 0x280, 0x2a0, 0x2c0, 0x2e0, 0};

static unsigned int cs8900_irq_map[] = {12,0,0,0};

#elif defined(CONFIG_SH_HICOSH4)

static unsigned int netcard_portlist[] __initdata =

   { 0x0300, 0};

static unsigned int cs8900_irq_map[] = {1,0,0,0};

#else

static unsigned int netcard_portlist[] __initdata =

   { 0x300, 0x320, 0x340, 0x360, 0x200, 0x220, 0x240, 0x260, 0x280, 0x2a0, 0x2c0, 0x2e0, 0};

static unsigned int cs8900_irq_map[] = {10,11,12,5};

#endif

#if DEBUGGING

static unsigned int net_debug = DEBUGGING;

#else

#define net_debug 0     /* gcc will remove all the debug code for us */

#endif

/* The number of low I/O ports used by the ethercard. */

#define NETCARD_IO_EXTENT       16

/* we allow the user to override various values normally set in the EEPROM */

#define FORCE_RJ45      0x0001    /* pick one of these three */

#define FORCE_AUI       0x0002

#define FORCE_BNC       0x0004

#define FORCE_AUTO      0x0010    /* pick one of these three */

#define FORCE_HALF      0x0020

#define FORCE_FULL      0x0030

/* Information that need to be kept for each board. */

struct net_local {

        struct net_device_stats stats;

        int chip_type;          /* one of: CS8900, CS8920, CS8920M */

        char chip_revision;     /* revision letter of the chip ('A'...) */

        int send_cmd;           /* the proper send command: TX_NOW, TX_AFTER_381, or TX_AFTER_ALL */

        int auto_neg_cnf;       /* auto-negotiation word from EEPROM */

        int adapter_cnf;        /* adapter configuration from EEPROM */

        int isa_config;         /* ISA configuration from EEPROM */

        int irq_map;            /* IRQ map from EEPROM */

        int rx_mode;            /* what mode are we in? 0, RX_MULTCAST_ACCEPT, or RX_ALL_ACCEPT */

        int curr_rx_cfg;        /* a copy of PP_RxCFG */

        int linectl;            /* either 0 or LOW_RX_SQUELCH, depending on configuration. */

        int send_underrun;      /* keep track of how many underruns in a row we get */

        int force;              /* force various values; see FORCE* above. */

        spinlock_t lock;

#if ALLOW_DMA

        int use_dma;            /* Flag: we're using dma */

        int dma;                /* DMA channel */

        int dmasize;            /* 16 or 64 */

        unsigned char *dma_buff;        /* points to the beginning of the buffer */

        unsigned char *end_dma_buff;    /* points to the end of the buffer */

        unsigned char *rx_dma_ptr;      /* points to the next packet  */

#endif

};

/* Index to functions, as function prototypes. */

extern int cs89x0_probe(struct net_device *dev);

static int cs89x0_probe1(struct net_device *dev, int ioaddr);

static int net_open(struct net_device *dev);

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

static void net_interrupt(int irq, void *dev_id, struct pt_regs *regs);

static void set_multicast_list(struct net_device *dev);

static void net_timeout(struct net_device *dev);

static void net_rx(struct net_device *dev);

static int net_close(struct net_device *dev);

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

static void reset_chip(struct net_device *dev);

static int get_eeprom_data(struct net_device *dev, int off, int len, int *buffer);

static int get_eeprom_cksum(int off, int len, int *buffer);

static int set_mac_address(struct net_device *dev, void *addr);

static void count_rx_errors(int status, struct net_local *lp);

#if ALLOW_DMA

static void get_dma_channel(struct net_device *dev);

static void release_dma_buff(struct net_local *lp);

#endif

/* Example routines you must write ;->. */

#define tx_done(dev) 1

/*

 * Permit 'cs89x0_dma=N' in the kernel boot environment

 */

#if !defined(MODULE) && (ALLOW_DMA != 0)

static int g_cs89x0_dma;

static int __init dma_fn(char *str)

{

        g_cs89x0_dma = simple_strtol(str,NULL,0);

        return 1;

}

__setup("cs89x0_dma=", dma_fn);

#endif  /* !defined(MODULE) && (ALLOW_DMA != 0) */

#ifndef MODULE

static int g_cs89x0_media__force;

static int __init media_fn(char *str)

{

        if (!strcmp(str, "rj45")) g_cs89x0_media__force = FORCE_RJ45;

        else if (!strcmp(str, "aui")) g_cs89x0_media__force = FORCE_AUI;

        else if (!strcmp(str, "bnc")) g_cs89x0_media__force = FORCE_BNC;

        return 1;

}

__setup("cs89x0_media=", media_fn);

#endif

/* Check for a network adaptor of this type, and return '0' iff one exists.

   If dev->base_addr == 0, probe all likely locations.

   If dev->base_addr == 1, always return failure.

   If dev->base_addr == 2, allocate space for the device and return success

   (detachable devices only).

   Return 0 on success.

   */

int __init cs89x0_probe(struct net_device *dev)

{

        int i;

        int base_addr = dev ? dev->base_addr : 0;

        SET_MODULE_OWNER(dev);

        if (net_debug)

                printk("cs89x0:cs89x0_probe(0x%x)\n", base_addr);

        if (base_addr > 0x1ff)          /* Check a single specified location. */

                return cs89x0_probe1(dev, base_addr);

        else if (base_addr != 0) /* Don't probe at all. */

                return -ENXIO;

        for (i = 0; netcard_portlist[i]; i++) {

                if (cs89x0_probe1(dev, netcard_portlist[i]) == 0)

                        return 0;

        }

        printk(KERN_WARNING "cs89x0: no cs8900 or cs8920 detected.  Be sure to disable PnP with SETUP\n");

        return -ENODEV;

}

static int

readreg(struct net_device *dev, int portno)

{

        outw(portno, dev->base_addr + ADD_PORT);

        return inw(dev->base_addr + DATA_PORT);

}

static void

writereg(struct net_device *dev, int portno, int value)

{

        outw(portno, dev->base_addr + ADD_PORT);

        outw(value, dev->base_addr + DATA_PORT);

}

static int

readword(struct net_device *dev, int portno)

{

        return inw(dev->base_addr + portno);

}

static void

writeword(struct net_device *dev, int portno, int value)

{

        outw(value, dev->base_addr + portno);

}

static int __init

wait_eeprom_ready(struct net_device *dev)

{

        int timeout = jiffies;

        /* check to see if the EEPROM is ready, a timeout is used -

           just in case EEPROM is ready when SI_BUSY in the

           PP_SelfST is clear */

        while(readreg(dev, PP_SelfST) & SI_BUSY)

                if (jiffies - timeout >= 40)

                        return -1;

        return 0;

}

static int __init

get_eeprom_data(struct net_device *dev, int off, int len, int *buffer)

{

        int i;

        if (net_debug > 3) printk("EEPROM data from %x for %x:\n",off,len);

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

                if (wait_eeprom_ready(dev) < 0) return -1;

                /* Now send the EEPROM read command and EEPROM location to read */

                writereg(dev, PP_EECMD, (off + i) | EEPROM_READ_CMD);

                if (wait_eeprom_ready(dev) < 0) return -1;

                buffer[i] = readreg(dev, PP_EEData);

                if (net_debug > 3) printk("%04x ", buffer[i]);

        }

        if (net_debug > 3) printk("\n");

        return 0;

}

static int  __init

get_eeprom_cksum(int off, int len, int *buffer)

{

        int i, cksum;

        cksum = 0;

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

                cksum += buffer[i];

        cksum &= 0xffff;

        if (cksum == 0)

                return 0;

        return -1;

}

/* This is the real probe routine.  Linux has a history of friendly device

   probes on the ISA bus.  A good device probes avoids doing writes, and

   verifies that the correct device exists and functions.

   Return 0 on success.

 */

static int __init

cs89x0_probe1(struct net_device *dev, int ioaddr)

{

        struct net_local *lp;

        static unsigned version_printed;

        int i;

        unsigned rev_type = 0;

        int eeprom_buff[CHKSUM_LEN];

        int retval;

        /* Initialize the device structure. */

        if (dev->priv == NULL) {

                dev->priv = kmalloc(sizeof(struct net_local), GFP_KERNEL);

                if (dev->priv == 0) {

                        retval = -ENOMEM;

                        goto out;

                }

                lp = (struct net_local *)dev->priv;

                memset(lp, 0, sizeof(*lp));

                spin_lock_init(&lp->lock);

#if !defined(MODULE) && (ALLOW_DMA != 0)

                if (g_cs89x0_dma) {

                        lp->use_dma = 1;

                        lp->dma = g_cs89x0_dma;

                        lp->dmasize = 16;       /* Could make this an option... */

                }

#endif

#ifndef MODULE

                lp->force = g_cs89x0_media__force;

#endif

        }

        lp = (struct net_local *)dev->priv;

        /* Grab the region so we can find another board if autoIRQ fails. */

        if (!request_region(ioaddr & ~3, NETCARD_IO_EXTENT, dev->name)) {

                printk(KERN_ERR "%s: request_region(0x%x, 0x%x) failed\n",

                                dev->name, ioaddr, NETCARD_IO_EXTENT);

                retval = -EBUSY;

                goto out1;

        }

#ifdef CONFIG_SH_HICOSH4

        /* truely reset the chip */

        outw(0x0114, ioaddr + ADD_PORT);

        outw(0x0040, ioaddr + DATA_PORT);

#endif

        /* if they give us an odd I/O address, then do ONE write to

           the address port, to get it back to address zero, where we

           expect to find the EISA signature word. An IO with a base of 0x3

           will skip the test for the ADD_PORT. */

        if (ioaddr & 1) {

                if (net_debug > 1)

                        printk(KERN_INFO "%s: odd ioaddr 0x%x\n", dev->name, ioaddr);

                if ((ioaddr & 2) != 2)

                        if ((inw((ioaddr & ~3)+ ADD_PORT) & ADD_MASK) != ADD_SIG) {

                                printk(KERN_ERR "%s: bad signature 0x%x\n",

                                        dev->name, inw((ioaddr & ~3)+ ADD_PORT));

                                retval = -ENODEV;

                                goto out2;

                        }

                ioaddr &= ~3;

                outw(PP_ChipID, ioaddr + ADD_PORT);

        }

printk("PP_addr=0x%x\n", inw(ioaddr + ADD_PORT));

        if (inw(ioaddr + DATA_PORT) != CHIP_EISA_ID_SIG) {

                printk(KERN_ERR "%s: incorrect signature 0x%x\n",

                        dev->name, inw(ioaddr + DATA_PORT));

                retval = -ENODEV;

                goto out2;

        }

        /* Fill in the 'dev' fields. */

        dev->base_addr = ioaddr;

        /* get the chip type */

        rev_type = readreg(dev, PRODUCT_ID_ADD);

        lp->chip_type = rev_type &~ REVISON_BITS;

        lp->chip_revision = ((rev_type & REVISON_BITS) >> 8) + 'A';

        /* Check the chip type and revision in order to set the correct send command

        CS8920 revision C and CS8900 revision F can use the faster send. */

        lp->send_cmd = TX_AFTER_381;

        if (lp->chip_type == CS8900 && lp->chip_revision >= 'F')

                lp->send_cmd = TX_NOW;

        if (lp->chip_type != CS8900 && lp->chip_revision >= 'C')

                lp->send_cmd = TX_NOW;

        if (net_debug  &&  version_printed++ == 0)

                printk(version);

        printk(KERN_INFO "%s: cs89%c0%s rev %c found at %#3lx ",

               dev->name,

               lp->chip_type==CS8900?'0':'2',

               lp->chip_type==CS8920M?"M":"",

               lp->chip_revision,

               dev->base_addr);

        reset_chip(dev);

        /* Here we read the current configuration of the chip. If there

           is no Extended EEPROM then the idea is to not disturb the chip

           configuration, it should have been correctly setup by automatic

           EEPROM read on reset. So, if the chip says it read the EEPROM

           the driver will always do *something* instead of complain that

           adapter_cnf is 0. */

#ifdef CONFIG_SH_HICOSH4

        if (1) {

                /* For the HiCO.SH4 board, things are different: we don't

                   have EEPROM, but there is some data in flash, so we go

                   get it there directly (MAC). */

                __u16 *confd;

                short cnt;

                if (((* (volatile __u32 *) 0xa0013ff0) & 0x00ffffff)

                        == 0x006c3000) {

                        confd = (__u16*) 0xa0013fc0;

                } else {

                        confd = (__u16*) 0xa001ffc0;

                }

                cnt = (*confd++ & 0x00ff) >> 1;

                while (--cnt > 0) {

                        __u16 j = *confd++;

                        switch (j & 0x0fff) {

                        case PP_IA:

                                for (i = 0; i < ETH_ALEN/2; i++) {

                                        dev->dev_addr[i*2] = confd[i] & 0xFF;

                                        dev->dev_addr[i*2+1] = confd[i] >> 8;

                                }

                                break;

                        }

                        j = (j >> 12) + 1;

                        confd += j;

                        cnt -= j;

                }

        } else

#endif

        if ((readreg(dev, PP_SelfST) & (EEPROM_OK | EEPROM_PRESENT)) ==

              (EEPROM_OK|EEPROM_PRESENT)) {

                /* Load the MAC. */

                for (i=0; i < ETH_ALEN/2; i++) {

                        unsigned int Addr;

                        Addr = readreg(dev, PP_IA+i*2);

                        dev->dev_addr[i*2] = Addr & 0xFF;

                        dev->dev_addr[i*2+1] = Addr >> 8;

                }

                /* Load the Adapter Configuration.

                   Note:  Barring any more specific information from some

                   other source (ie EEPROM+Schematics), we would not know

                   how to operate a 10Base2 interface on the AUI port.

                   However, since we  do read the status of HCB1 and use

                   settings that always result in calls to control_dc_dc(dev,0)

                   a BNC interface should work if the enable pin

                   (dc/dc converter) is on HCB1. It will be called AUI

                   however. */

                lp->adapter_cnf = 0;

                i = readreg(dev, PP_LineCTL);

                /* Preserve the setting of the HCB1 pin. */

                if ((i & (HCB1 | HCB1_ENBL)) ==  (HCB1 | HCB1_ENBL))

                        lp->adapter_cnf |= A_CNF_DC_DC_POLARITY;

                /* Save the sqelch bit */

                if ((i & LOW_RX_SQUELCH) == LOW_RX_SQUELCH)

                        lp->adapter_cnf |= A_CNF_EXTND_10B_2 | A_CNF_LOW_RX_SQUELCH;

                /* Check if the card is in 10Base-t only mode */

                if ((i & (AUI_ONLY | AUTO_AUI_10BASET)) == 0)

                        lp->adapter_cnf |=  A_CNF_10B_T | A_CNF_MEDIA_10B_T;

                /* Check if the card is in AUI only mode */

                if ((i & (AUI_ONLY | AUTO_AUI_10BASET)) == AUI_ONLY)

                        lp->adapter_cnf |=  A_CNF_AUI | A_CNF_MEDIA_AUI;

                /* Check if the card is in Auto mode. */

                if ((i & (AUI_ONLY | AUTO_AUI_10BASET)) == AUTO_AUI_10BASET)

                        lp->adapter_cnf |=  A_CNF_AUI | A_CNF_10B_T |

                        A_CNF_MEDIA_AUI | A_CNF_MEDIA_10B_T | A_CNF_MEDIA_AUTO;

                if (net_debug > 1)

                        printk(KERN_INFO "%s: PP_LineCTL=0x%x, adapter_cnf=0x%x\n",

                                        dev->name, i, lp->adapter_cnf);

                /* IRQ. Other chips already probe, see below. */

                if (lp->chip_type == CS8900)

                        lp->isa_config = readreg(dev, PP_CS8900_ISAINT) & INT_NO_MASK;

                printk( "[Cirrus EEPROM] ");

        }

        printk("\n");

        /* First check to see if an EEPROM is attached. */

#ifdef CONFIG_SH_HICOSH4 /* no EEPROM on HiCO, don't hazzle with it here */

        if (1) {

                printk(KERN_NOTICE "cs89x0: No EEPROM on HiCO.SH4\n");

        } else

#endif

        if ((readreg(dev, PP_SelfST) & EEPROM_PRESENT) == 0)

                printk(KERN_WARNING "cs89x0: No EEPROM, relying on command line....\n");

        else if (get_eeprom_data(dev, START_EEPROM_DATA,CHKSUM_LEN,eeprom_buff) < 0) {

                printk(KERN_WARNING "\ncs89x0: EEPROM read failed, relying on command line.\n");

        } else if (get_eeprom_cksum(START_EEPROM_DATA,CHKSUM_LEN,eeprom_buff) < 0) {

                /* Check if the chip was able to read its own configuration starting

                   at 0 in the EEPROM*/

                if ((readreg(dev, PP_SelfST) & (EEPROM_OK | EEPROM_PRESENT)) !=

                    (EEPROM_OK|EEPROM_PRESENT))

                        printk(KERN_WARNING "cs89x0: Extended EEPROM checksum bad and no Cirrus EEPROM, relying on command line\n");

        } else {

                /* This reads an extended EEPROM that is not documented

                   in the CS8900 datasheet. */

                /* get transmission control word  but keep the autonegotiation bits */

                if (!lp->auto_neg_cnf) lp->auto_neg_cnf = eeprom_buff[AUTO_NEG_CNF_OFFSET/2];

                /* Store adapter configuration */

                if (!lp->adapter_cnf) lp->adapter_cnf = eeprom_buff[ADAPTER_CNF_OFFSET/2];

                /* Store ISA configuration */

                lp->isa_config = eeprom_buff[ISA_CNF_OFFSET/2];

                dev->mem_start = eeprom_buff[PACKET_PAGE_OFFSET/2] << 8;

                /* eeprom_buff has 32-bit ints, so we can't just memcpy it */

                /* store the initial memory base address */

                for (i = 0; i < ETH_ALEN/2; i++) {

                        dev->dev_addr[i*2] = eeprom_buff[i];

                        dev->dev_addr[i*2+1] = eeprom_buff[i] >> 8;

                }

                if (net_debug > 1)

                        printk(KERN_DEBUG "%s: new adapter_cnf: 0x%x\n",

                                dev->name, lp->adapter_cnf);

        }

        /* allow them to force multiple transceivers.  If they force multiple, autosense */

        {

                int count = 0;

                if (lp->force & FORCE_RJ45)     {lp->adapter_cnf |= A_CNF_10B_T; count++; }

                if (lp->force & FORCE_AUI)      {lp->adapter_cnf |= A_CNF_AUI; count++; }

                if (lp->force & FORCE_BNC)      {lp->adapter_cnf |= A_CNF_10B_2; count++; }

                if (count > 1)                  {lp->adapter_cnf |= A_CNF_MEDIA_AUTO; }

                else if (lp->force & FORCE_RJ45){lp->adapter_cnf |= A_CNF_MEDIA_10B_T; }

                else if (lp->force & FORCE_AUI) {lp->adapter_cnf |= A_CNF_MEDIA_AUI; }

                else if (lp->force & FORCE_BNC) {lp->adapter_cnf |= A_CNF_MEDIA_10B_2; }

        }

        if (net_debug > 1)

                printk(KERN_DEBUG "%s: after force 0x%x, adapter_cnf=0x%x\n",

                        dev->name, lp->force, lp->adapter_cnf);

        /* FIXME: We don't let you set dc-dc polarity or low RX squelch from the command line: add it here */

        /* FIXME: We don't let you set the IMM bit from the command line: add it to lp->auto_neg_cnf here */

        /* FIXME: we don't set the Ethernet address on the command line.  Use

           ifconfig IFACE hw ether AABBCCDDEEFF */

        printk(KERN_INFO "cs89x0 media %s%s%s",

               (lp->adapter_cnf & A_CNF_10B_T)?"RJ-45,":"",

               (lp->adapter_cnf & A_CNF_AUI)?"AUI,":"",

               (lp->adapter_cnf & A_CNF_10B_2)?"BNC,":"");

        lp->irq_map = 0xffff;

        /* If this is a CS8900 then no pnp soft */

        if (lp->chip_type != CS8900 &&

            /* Check if the ISA IRQ has been set  */

                (i = readreg(dev, PP_CS8920_ISAINT) & 0xff,

                 (i != 0 && i < CS8920_NO_INTS))) {

                if (!dev->irq)

                        dev->irq = i;

        } else {

                i = lp->isa_config & INT_NO_MASK;

                if (lp->chip_type == CS8900) {

                        /* Translate the IRQ using the IRQ mapping table. */

                        if (i >= sizeof(cs8900_irq_map)/sizeof(cs8900_irq_map[0]))

                                printk("\ncs89x0: invalid ISA interrupt number %d\n", i);

                        else

                                i = cs8900_irq_map[i];

                        lp->irq_map = CS8900_IRQ_MAP; /* fixed IRQ map for CS8900 */

                } else {

                        int irq_map_buff[IRQ_MAP_LEN/2];

                        if (get_eeprom_data(dev, IRQ_MAP_EEPROM_DATA,

                                            IRQ_MAP_LEN/2,

                                            irq_map_buff) >= 0) {