Subversion Repositories test_project

/*

 *   olympic.c (c) 1999 Peter De Schrijver All Rights Reserved

 *                 1999/2000 Mike Phillips (mikep@linuxtr.net)

 *

 *  Linux driver for IBM PCI tokenring cards based on the Pit/Pit-Phy/Olympic

 *  chipset.

 *

 *  Base Driver Skeleton:

 *      Written 1993-94 by Donald Becker.

 *

 *      Copyright 1993 United States Government as represented by the

 *      Director, National Security Agency.

 *

 *  Thanks to Erik De Cock, Adrian Bridgett and Frank Fiene for their

 *  assistance and perserverance with the testing of this driver.

 *

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

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

 *

 *  4/27/99 - Alpha Release 0.1.0

 *            First release to the public

 *

 *  6/8/99  - Official Release 0.2.0

 *            Merged into the kernel code

 *  8/18/99 - Updated driver for 2.3.13 kernel to use new pci

 *            resource. Driver also reports the card name returned by

 *            the pci resource.

 *  1/11/00 - Added spinlocks for smp

 *  2/23/00 - Updated to dev_kfree_irq

 *  3/10/00 - Fixed FDX enable which triggered other bugs also

 *            squashed.

 *  5/20/00 - Changes to handle Olympic on LinuxPPC. Endian changes.

 *            The odd thing about the changes is that the fix for

 *            endian issues with the big-endian data in the arb, asb...

 *            was to always swab() the bytes, no matter what CPU.

 *            That's because the read[wl]() functions always swap the

 *            bytes on the way in on PPC.

 *            Fixing the hardware descriptors was another matter,

 *            because they weren't going through read[wl](), there all

 *            the results had to be in memory in le32 values. kdaaker

 *

 * 12/23/00 - Added minimal Cardbus support (Thanks Donald).

 *

 * 03/09/01 - Add new pci api, dev_base_lock, general clean up.

 *

 * 03/27/01 - Add new dma pci (Thanks to Kyle Lucke) and alloc_trdev

 *            Change proc_fs behaviour, now one entry per adapter.

 *

 * 04/09/01 - Couple of bug fixes to the dma unmaps and ejecting the

 *            adapter when live does not take the system down with it.

 *

 * 06/02/01 - Clean up, copy skb for small packets

 *

 * 06/22/01 - Add EISR error handling routines

 *

 * 07/19/01 - Improve bad LAA reporting, strip out freemem

 *            into a separate function, its called from 3

 *            different places now.

 * 02/09/02 - Replaced sleep_on.

 * 03/01/02 - Replace access to several registers from 32 bit to

 *            16 bit. Fixes alignment errors on PPC 64 bit machines.

 *            Thanks to Al Trautman for this one.

 * 03/10/02 - Fix BUG in arb_cmd. Bug was there all along but was

 *            silently ignored until the error checking code

 *            went into version 1.0.0

 * 06/04/02 - Add correct start up sequence for the cardbus adapters.

 *            Required for strict compliance with pci power mgmt specs.

 *  To Do:

 *

 *           Wake on lan

 *

 *  If Problems do Occur

 *  Most problems can be rectified by either closing and opening the interface

 *  (ifconfig down and up) or rmmod and insmod'ing the driver (a bit difficult

 *  if compiled into the kernel).

 */

/* Change OLYMPIC_DEBUG to 1 to get verbose, and I mean really verbose, messages */

#define OLYMPIC_DEBUG 0

#include <linux/module.h>

#include <linux/kernel.h>

#include <linux/errno.h>

#include <linux/timer.h>

#include <linux/in.h>

#include <linux/ioport.h>

#include <linux/string.h>

#include <linux/proc_fs.h>

#include <linux/ptrace.h>

#include <linux/skbuff.h>

#include <linux/interrupt.h>

#include <linux/delay.h>

#include <linux/netdevice.h>

#include <linux/trdevice.h>

#include <linux/stddef.h>

#include <linux/init.h>

#include <linux/pci.h>

#include <linux/spinlock.h>

#include <linux/bitops.h>

#include <linux/jiffies.h>

#include <net/checksum.h>

#include <net/net_namespace.h>

#include <asm/io.h>

#include <asm/system.h>

#include "olympic.h"

/* I've got to put some intelligence into the version number so that Peter and I know

 * which version of the code somebody has got.

 * Version Number = a.b.c.d  where a.b.c is the level of code and d is the latest author.

 * So 0.0.1.pds = Peter, 0.0.1.mlp = Mike

 *

 * Official releases will only have an a.b.c version number format.

 */

static char version[] __devinitdata =

"Olympic.c v1.0.5 6/04/02 - Peter De Schrijver & Mike Phillips" ;

static char *open_maj_error[]  = {"No error", "Lobe Media Test", "Physical Insertion",

                                   "Address Verification", "Neighbor Notification (Ring Poll)",

                                   "Request Parameters","FDX Registration Request",

                                   "FDX Duplicate Address Check", "Station registration Query Wait",

                                   "Unknown stage"};

static char *open_min_error[] = {"No error", "Function Failure", "Signal Lost", "Wire Fault",

                                   "Ring Speed Mismatch", "Timeout","Ring Failure","Ring Beaconing",

                                   "Duplicate Node Address","Request Parameters","Remove Received",

                                   "Reserved", "Reserved", "No Monitor Detected for RPL",

                                   "Monitor Contention failer for RPL", "FDX Protocol Error"};

/* Module paramters */

MODULE_AUTHOR("Mike Phillips <mikep@linuxtr.net>") ;

MODULE_DESCRIPTION("Olympic PCI/Cardbus Chipset Driver") ;

/* Ring Speed 0,4,16,100

 * 0 = Autosense

 * 4,16 = Selected speed only, no autosense

 * This allows the card to be the first on the ring

 * and become the active monitor.

 * 100 = Nothing at present, 100mbps is autodetected

 * if FDX is turned on. May be implemented in the future to

 * fail if 100mpbs is not detected.

 *

 * WARNING: Some hubs will allow you to insert

 * at the wrong speed

 */

static int ringspeed[OLYMPIC_MAX_ADAPTERS] = {0,} ;

module_param_array(ringspeed, int, NULL, 0);

/* Packet buffer size */

static int pkt_buf_sz[OLYMPIC_MAX_ADAPTERS] = {0,} ;

module_param_array(pkt_buf_sz, int, NULL, 0) ;

/* Message Level */

static int message_level[OLYMPIC_MAX_ADAPTERS] = {0,} ;

module_param_array(message_level, int, NULL, 0) ;

/* Change network_monitor to receive mac frames through the arb channel.

 * Will also create a /proc/net/olympic_tr%d entry, where %d is the tr

 * device, i.e. tr0, tr1 etc.

 * Intended to be used to create a ring-error reporting network module

 * i.e. it will give you the source address of beaconers on the ring

 */

static int network_monitor[OLYMPIC_MAX_ADAPTERS] = {0,};

module_param_array(network_monitor, int, NULL, 0);

static struct pci_device_id olympic_pci_tbl[] = {

        {PCI_VENDOR_ID_IBM,PCI_DEVICE_ID_IBM_TR_WAKE,PCI_ANY_ID,PCI_ANY_ID,},

        { }     /* Terminating Entry */

};

MODULE_DEVICE_TABLE(pci,olympic_pci_tbl) ;

static int olympic_probe(struct pci_dev *pdev, const struct pci_device_id *ent);

static int olympic_init(struct net_device *dev);

static int olympic_open(struct net_device *dev);

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

static int olympic_close(struct net_device *dev);

static void olympic_set_rx_mode(struct net_device *dev);

static void olympic_freemem(struct net_device *dev) ;

static irqreturn_t olympic_interrupt(int irq, void *dev_id);

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

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

static void olympic_arb_cmd(struct net_device *dev);

static int olympic_change_mtu(struct net_device *dev, int mtu);

static void olympic_srb_bh(struct net_device *dev) ;

static void olympic_asb_bh(struct net_device *dev) ;

static int olympic_proc_info(char *buffer, char **start, off_t offset, int length, int *eof, void *data) ;

static int __devinit olympic_probe(struct pci_dev *pdev, const struct pci_device_id *ent)

{

        struct net_device *dev ;

        struct olympic_private *olympic_priv;

        static int card_no = -1 ;

        int i ;

        card_no++ ;

        if ((i = pci_enable_device(pdev))) {

                return i ;

        }

        pci_set_master(pdev);

        if ((i = pci_request_regions(pdev,"olympic"))) {

                goto op_disable_dev;

        }

        dev = alloc_trdev(sizeof(struct olympic_private)) ;

        if (!dev) {

                i = -ENOMEM;

                goto op_release_dev;

        }

        olympic_priv = netdev_priv(dev) ;

        spin_lock_init(&olympic_priv->olympic_lock) ;

        init_waitqueue_head(&olympic_priv->srb_wait);

        init_waitqueue_head(&olympic_priv->trb_wait);

#if OLYMPIC_DEBUG  

        printk(KERN_INFO "pci_device: %p, dev:%p, dev->priv: %p\n", pdev, dev, netdev_priv(dev));

#endif

        dev->irq=pdev->irq;

        dev->base_addr=pci_resource_start(pdev, 0);

        olympic_priv->olympic_card_name = pci_name(pdev);

        olympic_priv->pdev = pdev;

        olympic_priv->olympic_mmio = ioremap(pci_resource_start(pdev,1),256);

        olympic_priv->olympic_lap = ioremap(pci_resource_start(pdev,2),2048);

        if (!olympic_priv->olympic_mmio || !olympic_priv->olympic_lap) {

                goto op_free_iomap;

        }

        if ((pkt_buf_sz[card_no] < 100) || (pkt_buf_sz[card_no] > 18000) )

                olympic_priv->pkt_buf_sz = PKT_BUF_SZ ;

        else

                olympic_priv->pkt_buf_sz = pkt_buf_sz[card_no] ;

        dev->mtu = olympic_priv->pkt_buf_sz - TR_HLEN ;

        olympic_priv->olympic_ring_speed = ringspeed[card_no] ;

        olympic_priv->olympic_message_level = message_level[card_no] ;

        olympic_priv->olympic_network_monitor = network_monitor[card_no];

        if ((i = olympic_init(dev))) {

                goto op_free_iomap;

        }

        dev->open=&olympic_open;

        dev->hard_start_xmit=&olympic_xmit;

        dev->change_mtu=&olympic_change_mtu;

        dev->stop=&olympic_close;

        dev->do_ioctl=NULL;

        dev->set_multicast_list=&olympic_set_rx_mode;

        dev->get_stats=&olympic_get_stats ;

        dev->set_mac_address=&olympic_set_mac_address ;

        SET_NETDEV_DEV(dev, &pdev->dev);

        pci_set_drvdata(pdev,dev) ;

        register_netdev(dev) ;

        printk("Olympic: %s registered as: %s\n",olympic_priv->olympic_card_name,dev->name);

        if (olympic_priv->olympic_network_monitor) { /* Must go after register_netdev as we need the device name */

                char proc_name[20] ;

                strcpy(proc_name,"olympic_") ;

                strcat(proc_name,dev->name) ;

                create_proc_read_entry(proc_name,0,init_net.proc_net,olympic_proc_info,(void *)dev) ;

                printk("Olympic: Network Monitor information: /proc/%s\n",proc_name);

        }

        return  0 ;

op_free_iomap:

        if (olympic_priv->olympic_mmio)

                iounmap(olympic_priv->olympic_mmio);

        if (olympic_priv->olympic_lap)

                iounmap(olympic_priv->olympic_lap);

        free_netdev(dev);

op_release_dev:

        pci_release_regions(pdev);

op_disable_dev:

        pci_disable_device(pdev);

        return i;

}

static int __devinit olympic_init(struct net_device *dev)

{

        struct olympic_private *olympic_priv;

        u8 __iomem *olympic_mmio, *init_srb,*adapter_addr;

        unsigned long t;

        unsigned int uaa_addr;

        olympic_priv=netdev_priv(dev);

        olympic_mmio=olympic_priv->olympic_mmio;

        printk("%s \n", version);

        printk("%s. I/O at %hx, MMIO at %p, LAP at %p, using irq %d\n", olympic_priv->olympic_card_name, (unsigned int) dev->base_addr,olympic_priv->olympic_mmio, olympic_priv->olympic_lap, dev->irq);

        writel(readl(olympic_mmio+BCTL) | BCTL_SOFTRESET,olympic_mmio+BCTL);

        t=jiffies;

        while((readl(olympic_mmio+BCTL)) & BCTL_SOFTRESET) {

                schedule();

                if(time_after(jiffies, t + 40*HZ)) {

                        printk(KERN_ERR "IBM PCI tokenring card not responding.\n");

                        return -ENODEV;

                }

        }

        /* Needed for cardbus */

        if(!(readl(olympic_mmio+BCTL) & BCTL_MODE_INDICATOR)) {

                writel(readl(olympic_priv->olympic_mmio+FERMASK)|FERMASK_INT_BIT, olympic_mmio+FERMASK);

        }

#if OLYMPIC_DEBUG

        printk("BCTL: %x\n",readl(olympic_mmio+BCTL));

        printk("GPR: %x\n",readw(olympic_mmio+GPR));

        printk("SISRMASK: %x\n",readl(olympic_mmio+SISR_MASK));

#endif

        /* Aaaahhh, You have got to be real careful setting GPR, the card

           holds the previous values from flash memory, including autosense

           and ring speed */

        writel(readl(olympic_mmio+BCTL)|BCTL_MIMREB,olympic_mmio+BCTL);

        if (olympic_priv->olympic_ring_speed  == 0) { /* Autosense */

                writew(readw(olympic_mmio+GPR)|GPR_AUTOSENSE,olympic_mmio+GPR);

                if (olympic_priv->olympic_message_level)

                        printk(KERN_INFO "%s: Ringspeed autosense mode on\n",olympic_priv->olympic_card_name);

        } else if (olympic_priv->olympic_ring_speed == 16) {

                if (olympic_priv->olympic_message_level)

                        printk(KERN_INFO "%s: Trying to open at 16 Mbps as requested\n", olympic_priv->olympic_card_name);

                writew(GPR_16MBPS, olympic_mmio+GPR);

        } else if (olympic_priv->olympic_ring_speed == 4) {

                if (olympic_priv->olympic_message_level)

                        printk(KERN_INFO "%s: Trying to open at 4 Mbps as requested\n", olympic_priv->olympic_card_name) ;

                writew(0, olympic_mmio+GPR);

        }

        writew(readw(olympic_mmio+GPR)|GPR_NEPTUNE_BF,olympic_mmio+GPR);

#if OLYMPIC_DEBUG

        printk("GPR = %x\n",readw(olympic_mmio + GPR) ) ;

#endif

        /* Solo has been paused to meet the Cardbus power

         * specs if the adapter is cardbus. Check to

         * see its been paused and then restart solo. The

         * adapter should set the pause bit within 1 second.

         */

        if(!(readl(olympic_mmio+BCTL) & BCTL_MODE_INDICATOR)) {

                t=jiffies;

                while (!readl(olympic_mmio+CLKCTL) & CLKCTL_PAUSE) {

                        schedule() ;

                        if(time_after(jiffies, t + 2*HZ)) {

                                printk(KERN_ERR "IBM Cardbus tokenring adapter not responsing.\n") ;

                                return -ENODEV;

                        }

                }

                writel(readl(olympic_mmio+CLKCTL) & ~CLKCTL_PAUSE, olympic_mmio+CLKCTL) ;

        }

        /* start solo init */

        writel((1<<15),olympic_mmio+SISR_MASK_SUM);

        t=jiffies;

        while(!((readl(olympic_mmio+SISR_RR)) & SISR_SRB_REPLY)) {

                schedule();

                if(time_after(jiffies, t + 15*HZ)) {

                        printk(KERN_ERR "IBM PCI tokenring card not responding.\n");

                        return -ENODEV;

                }

        }

        writel(readw(olympic_mmio+LAPWWO),olympic_mmio+LAPA);

#if OLYMPIC_DEBUG

        printk("LAPWWO: %x, LAPA: %x\n",readl(olympic_mmio+LAPWWO), readl(olympic_mmio+LAPA));

#endif

        init_srb=olympic_priv->olympic_lap + ((readw(olympic_mmio+LAPWWO)) & (~0xf800));

#if OLYMPIC_DEBUG               

{

        int i;

        printk("init_srb(%p): ",init_srb);

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

                printk("%x ",readb(init_srb+i));

        printk("\n");

}

#endif  

        if(readw(init_srb+6)) {

                printk(KERN_INFO "tokenring card initialization failed. errorcode : %x\n",readw(init_srb+6));

                return -ENODEV;

        }

        if (olympic_priv->olympic_message_level) {

                if ( readb(init_srb +2) & 0x40) {

                        printk(KERN_INFO "Olympic: Adapter is FDX capable.\n") ;

                } else {

                        printk(KERN_INFO "Olympic: Adapter cannot do FDX.\n");

                }

        }

        uaa_addr=swab16(readw(init_srb+8));

#if OLYMPIC_DEBUG

        printk("UAA resides at %x\n",uaa_addr);

#endif

        writel(uaa_addr,olympic_mmio+LAPA);

        adapter_addr=olympic_priv->olympic_lap + (uaa_addr & (~0xf800));

        memcpy_fromio(&dev->dev_addr[0], adapter_addr,6);

#if OLYMPIC_DEBUG

 {

        DECLARE_MAC_BUF(mac);

        printk("adapter address: %s\n", print_mac(mac, dev->dev_addr));

 }

#endif

        olympic_priv->olympic_addr_table_addr = swab16(readw(init_srb + 12));

        olympic_priv->olympic_parms_addr = swab16(readw(init_srb + 14));

        return 0;

}

static int olympic_open(struct net_device *dev)

{

        struct olympic_private *olympic_priv=netdev_priv(dev);

        u8 __iomem *olympic_mmio=olympic_priv->olympic_mmio,*init_srb;

        unsigned long flags, t;

        int i, open_finished = 1 ;

        u8 resp, err;

        DECLARE_MAC_BUF(mac);

        DECLARE_WAITQUEUE(wait,current) ;

        olympic_init(dev);

        if(request_irq(dev->irq, &olympic_interrupt, IRQF_SHARED , "olympic", dev)) {

                return -EAGAIN;

        }

#if OLYMPIC_DEBUG

        printk("BMCTL: %x\n",readl(olympic_mmio+BMCTL_SUM));

        printk("pending ints: %x\n",readl(olympic_mmio+SISR_RR));

#endif

        writel(SISR_MI,olympic_mmio+SISR_MASK_SUM);

        writel(SISR_MI | SISR_SRB_REPLY, olympic_mmio+SISR_MASK); /* more ints later, doesn't stop arb cmd interrupt */

        writel(LISR_LIE,olympic_mmio+LISR); /* more ints later */

        /* adapter is closed, so SRB is pointed to by LAPWWO */

        writel(readw(olympic_mmio+LAPWWO),olympic_mmio+LAPA);

        init_srb=olympic_priv->olympic_lap + ((readw(olympic_mmio+LAPWWO)) & (~0xf800));

#if OLYMPIC_DEBUG

        printk("LAPWWO: %x, LAPA: %x\n",readw(olympic_mmio+LAPWWO), readl(olympic_mmio+LAPA));

        printk("SISR Mask = %04x\n", readl(olympic_mmio+SISR_MASK));

        printk("Before the open command \n");

#endif  

        do {

                memset_io(init_srb,0,SRB_COMMAND_SIZE);

                writeb(SRB_OPEN_ADAPTER,init_srb) ;     /* open */

                writeb(OLYMPIC_CLEAR_RET_CODE,init_srb+2);

                /* If Network Monitor, instruct card to copy MAC frames through the ARB */

                if (olympic_priv->olympic_network_monitor)

                        writew(swab16(OPEN_ADAPTER_ENABLE_FDX | OPEN_ADAPTER_PASS_ADC_MAC | OPEN_ADAPTER_PASS_ATT_MAC | OPEN_ADAPTER_PASS_BEACON), init_srb+8);

                else

                        writew(swab16(OPEN_ADAPTER_ENABLE_FDX), init_srb+8);

                /* Test OR of first 3 bytes as its totally possible for

                 * someone to set the first 2 bytes to be zero, although this

                 * is an error, the first byte must have bit 6 set to 1  */

                if (olympic_priv->olympic_laa[0] | olympic_priv->olympic_laa[1] | olympic_priv->olympic_laa[2]) {

                        writeb(olympic_priv->olympic_laa[0],init_srb+12);

                        writeb(olympic_priv->olympic_laa[1],init_srb+13);

                        writeb(olympic_priv->olympic_laa[2],init_srb+14);

                        writeb(olympic_priv->olympic_laa[3],init_srb+15);

                        writeb(olympic_priv->olympic_laa[4],init_srb+16);

                        writeb(olympic_priv->olympic_laa[5],init_srb+17);

                        memcpy(dev->dev_addr,olympic_priv->olympic_laa,dev->addr_len) ;

                }

                writeb(1,init_srb+30);

                spin_lock_irqsave(&olympic_priv->olympic_lock,flags);

                olympic_priv->srb_queued=1;

                writel(LISR_SRB_CMD,olympic_mmio+LISR_SUM);

                spin_unlock_irqrestore(&olympic_priv->olympic_lock,flags);

                t = jiffies ;

                add_wait_queue(&olympic_priv->srb_wait,&wait) ;

                set_current_state(TASK_INTERRUPTIBLE) ;

                while(olympic_priv->srb_queued) {

                        schedule() ;

                        if(signal_pending(current))     {

                                printk(KERN_WARNING "%s: Signal received in open.\n",

                                        dev->name);

                                printk(KERN_WARNING "SISR=%x LISR=%x\n",

                                        readl(olympic_mmio+SISR),

                                        readl(olympic_mmio+LISR));

                                olympic_priv->srb_queued=0;

                                break;

                        }

                        if (time_after(jiffies, t + 10*HZ)) {

                                printk(KERN_WARNING "%s: SRB timed out. \n",dev->name) ;

                                olympic_priv->srb_queued=0;

                                break ;

                        }

                        set_current_state(TASK_INTERRUPTIBLE) ;

                }

                remove_wait_queue(&olympic_priv->srb_wait,&wait) ;

                set_current_state(TASK_RUNNING) ;

                olympic_priv->srb_queued = 0 ;

#if OLYMPIC_DEBUG

                printk("init_srb(%p): ",init_srb);

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

                        printk("%02x ",readb(init_srb+i));

                printk("\n");

#endif

                /* If we get the same return response as we set, the interrupt wasn't raised and the open

                 * timed out.

                 */

                switch (resp = readb(init_srb+2)) {

                case OLYMPIC_CLEAR_RET_CODE:

                        printk(KERN_WARNING "%s: Adapter Open time out or error.\n", dev->name) ;

                        goto out;

                case 0:

                        open_finished = 1;

                        break;

                case 0x07:

                        if (!olympic_priv->olympic_ring_speed && open_finished) { /* Autosense , first time around */

                                printk(KERN_WARNING "%s: Retrying at different ring speed \n", dev->name);

                                open_finished = 0 ;

                                continue;

                        }

                        err = readb(init_srb+7);

                        if (!olympic_priv->olympic_ring_speed && ((err & 0x0f) == 0x0d)) {

                                printk(KERN_WARNING "%s: Tried to autosense ring speed with no monitors present\n",dev->name);

                                printk(KERN_WARNING "%s: Please try again with a specified ring speed \n",dev->name);

                        } else {

                                printk(KERN_WARNING "%s: %s - %s\n", dev->name,

                                        open_maj_error[(err & 0xf0) >> 4],

                                        open_min_error[(err & 0x0f)]);

                        }

                        goto out;

                case 0x32:

                        printk(KERN_WARNING "%s: Invalid LAA: %s\n",

                               dev->name, print_mac(mac, olympic_priv->olympic_laa));

                        goto out;

                default:

                        printk(KERN_WARNING "%s: Bad OPEN response: %x\n", dev->name, resp);

                        goto out;

                }

        } while (!(open_finished)) ; /* Will only loop if ring speed mismatch re-open attempted && autosense is on */

        if (readb(init_srb+18) & (1<<3))

                if (olympic_priv->olympic_message_level)

                        printk(KERN_INFO "%s: Opened in FDX Mode\n",dev->name);

        if (readb(init_srb+18) & (1<<1))

                olympic_priv->olympic_ring_speed = 100 ;

        else if (readb(init_srb+18) & 1)

                olympic_priv->olympic_ring_speed = 16 ;

        else

                olympic_priv->olympic_ring_speed = 4 ;

        if (olympic_priv->olympic_message_level)

                printk(KERN_INFO "%s: Opened in %d Mbps mode\n",dev->name, olympic_priv->olympic_ring_speed);

        olympic_priv->asb = swab16(readw(init_srb+8));

        olympic_priv->srb = swab16(readw(init_srb+10));

        olympic_priv->arb = swab16(readw(init_srb+12));

        olympic_priv->trb = swab16(readw(init_srb+16));

        olympic_priv->olympic_receive_options = 0x01 ;

        olympic_priv->olympic_copy_all_options = 0 ;

        /* setup rx ring */

        writel((3<<16),olympic_mmio+BMCTL_RWM); /* Ensure end of frame generated interrupts */

        writel(BMCTL_RX_DIS|3,olympic_mmio+BMCTL_RWM); /* Yes, this the enables RX channel */

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

                struct sk_buff *skb;

                skb=dev_alloc_skb(olympic_priv->pkt_buf_sz);

                if(skb == NULL)

                        break;

                skb->dev = dev;

                olympic_priv->olympic_rx_ring[i].buffer = cpu_to_le32(pci_map_single(olympic_priv->pdev,

                                                          skb->data,olympic_priv->pkt_buf_sz, PCI_DMA_FROMDEVICE)) ;

                olympic_priv->olympic_rx_ring[i].res_length = cpu_to_le32(olympic_priv->pkt_buf_sz);

                olympic_priv->rx_ring_skb[i]=skb;

        }

        if (i==0) {

                printk(KERN_WARNING "%s: Not enough memory to allocate rx buffers. Adapter disabled\n",dev->name);

                goto out;

        }

        olympic_priv->rx_ring_dma_addr = pci_map_single(olympic_priv->pdev,olympic_priv->olympic_rx_ring,

                                         sizeof(struct olympic_rx_desc) * OLYMPIC_RX_RING_SIZE, PCI_DMA_TODEVICE);

        writel(olympic_priv->rx_ring_dma_addr, olympic_mmio+RXDESCQ);

        writel(olympic_priv->rx_ring_dma_addr, olympic_mmio+RXCDA);

        writew(i, olympic_mmio+RXDESCQCNT);

        olympic_priv->rx_status_ring_dma_addr = pci_map_single(olympic_priv->pdev, olympic_priv->olympic_rx_status_ring,

                                                sizeof(struct olympic_rx_status) * OLYMPIC_RX_RING_SIZE, PCI_DMA_FROMDEVICE);