Subversion Repositories or1k

/* ibmtr.c:  A shared-memory IBM Token Ring 16/4 driver for linux */

/*

  Written 1993 by Mark Swanson and Peter De Schrijver.

  This software may be used and distributed according to the terms

  of the GNU Public License, incorporated herein by reference.

  This device driver should work with Any IBM Token Ring Card that does

  not use DMA.

  I used Donald Becker's (becker@super.org) device driver work

  as a base for most of my initial work.

*/

/*

   Changes by Peter De Schrijver (Peter.Deschrijver@linux.cc.kuleuven.ac.be) :

        + changed name to ibmtr.c in anticipation of other tr boards.

        + changed reset code and adapter open code.

        + added SAP open code.

        + a first attempt to write interrupt, transmit and receive routines.

   Changes by David W. Morris (dwm@shell.portal.com) :

     941003 dwm: - Restructure tok_probe for multiple adapters, devices

                 - Add comments, misc reorg for clarity

                 - Flatten interrupt handler levels

   Changes by Farzad Farid (farzy@zen.via.ecp.fr)

   and Pascal Andre (andre@chimay.via.ecp.fr) (March 9 1995) :

        - multi ring support clean up

        - RFC1042 compliance enhanced

   Changes by Pascal Andre (andre@chimay.via.ecp.fr) (September 7 1995) :

        - bug correction in tr_tx

        - removed redundant information display

        - some code reworking

   Changes by Michel Lespinasse (walken@via.ecp.fr),

     Yann Doussot (doussot@via.ecp.fr) and Pascal Andre (andre@via.ecp.fr)

     (February 18, 1996) :

        - modified shared memory and mmio access port the driver to

          alpha platform (structure access -> readb/writeb)

   Changes by Steve Kipisz (bungy@ibm.net or kipisz@vnet.ibm.com)

                           (January 18 1996):

        - swapped WWOR and WWCR in ibmtr.h

        - moved some init code from tok_probe into trdev_init.  The

          PCMCIA code can call trdev_init to complete initializing

          the driver.

        - added -DPCMCIA to support PCMCIA

        - detecting PCMCIA Card Removal in interrupt handler.  if

          ISRP is FF, then a PCMCIA card has been removed

   Changes by Paul Norton (pnorton@cts.com) :

        - restructured the READ.LOG logic to prevent the transmit SRB

          from being rudely overwritten before the transmit cycle is

          complete. (August 15 1996)

   Warnings !!!!!!!!!!!!!!

      This driver is only partially sanitized for support of multiple

      adapters.  It will almost definitely fail if more than one

      active adapter is identified.

*/

#ifdef PCMCIA

#define MODULE

#endif

#include <linux/module.h>

#ifdef PCMCIA

#undef MODULE

#endif

#define NO_AUTODETECT 1

#undef NO_AUTODETECT

#undef ENABLE_PAGING

#define FALSE 0

#define TRUE (!FALSE)

/* changes the output format of driver initialisation */

#define TR_NEWFORMAT    1

#define TR_VERBOSE      0

/* some 95 OS send many non UI frame; this allow removing the warning */

#define TR_FILTERNONUI  1

/* version and credits */

static const char *version =

"ibmtr.c: v1.3.57 8/7/94 Peter De Schrijver and Mark Swanson\n"

"  modified 10/3/94 DW Morris, modified at VIA, ECP, France\n"

"  (3/9/95 F Farid and P Andre, 9/7/95 PA and 2/20/95 ML/PA/YD)\n";

static char pcchannelid[]={0x05, 0x00, 0x04, 0x09,

                           0x04, 0x03, 0x04, 0x0f,

                           0x03, 0x06, 0x03, 0x01,

                           0x03, 0x01, 0x03, 0x00,

                           0x03, 0x09, 0x03, 0x09,

                           0x03, 0x00, 0x02, 0x00};

static char mcchannelid[]={0x04, 0x0d, 0x04, 0x01,

                           0x05, 0x02, 0x05, 0x03,

                           0x03, 0x06, 0x03, 0x03,

                           0x05, 0x08, 0x03, 0x04,

                           0x03, 0x05, 0x03, 0x01,

                           0x03, 0x08, 0x02, 0x00};

#include <linux/kernel.h>

#include <linux/sched.h>

#include <linux/errno.h>

#include <linux/sched.h>

#include <linux/timer.h>

#include <linux/in.h>

#include <asm/io.h>

#include <asm/system.h>

#include <asm/bitops.h>

#include <linux/ioport.h>

#include <linux/errno.h>

#include <linux/string.h>

#include <linux/skbuff.h>

#include <linux/interrupt.h>

#include <linux/delay.h>

#include <linux/netdevice.h>

#include <linux/trdevice.h>

#include <stddef.h>

#include "ibmtr.h"

#define DPRINTK(format, args...) printk("%s: " format, dev->name , ## args)

#define DPRINTD(format, args...) DummyCall("%s: " format, dev->name , ## args)

#if TR_NEWFORMAT

/* this allows displaying full adapter information */

const char *channel_def[] = { "ISA", "MCA", "ISA P&P" };

char *adapter_def(char type)

{

        switch (type) {

              case 0xF : return "Adapter/A";

              case 0xE : return "16/4 Adapter/II";

              default : return "adapter";

        };

};

#endif

#if !TR_NEWFORMAT

unsigned char ibmtr_debug_trace=1;  /*  Patch or otherwise alter to

                                         control tokenring tracing.  */

#else

unsigned char ibmtr_debug_trace=0;

#endif

#define TRC_INIT 0x01              /*  Trace initialization & PROBEs */

#define TRC_INITV 0x02             /*  verbose init trace points     */

/* addresses to scan */

static short TokBaseAddrs[] = { MMIOStartLocP, MMIOStartLocA };

int tok_probe(struct device *dev);

unsigned char get_sram_size(struct tok_info *adapt_info);

static int tok_init_card(struct device *dev);

int trdev_init(struct device *dev);

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

static void initial_tok_int(struct device *dev);

static void open_sap(unsigned char type,struct device *dev);

void tok_open_adapter(unsigned long dev_addr);

static void tr_rx(struct device *dev);

static void tr_tx(struct device *dev);

static int tok_open(struct device *dev);

static int tok_close(struct device *dev);

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

static struct enet_statistics * tok_get_stats(struct device *dev);

void tr_readlog(struct device *dev);

static struct timer_list tr_timer={NULL,NULL,0,0L,tok_open_adapter};

#if 0

int DummyCallCount=0;

/*  This routine combined with the #DEFINE DPRINTD serves

    to workaround the gcc apparent bug.   in tr_tx() */

static void DummyCall(const char * fmt,...)

{ DummyCallCount++; return; }

#endif

static void PrtChanID(char *pcid, short stride) {

        short i, j;

        for (i=0, j=0; i<24; i++, j+=stride)

                printk("%1x", ((int) pcid[j]) & 0x0f);

        printk("\n");

}

static void HWPrtChanID (__u32 pcid, short stride)

{

        short i, j;

        for (i=0, j=0; i<24; i++, j+=stride)

                printk("%1x", ((int)readb(pcid + j)) & 0x0f);

        printk("\n");

}

/* tok_probe():  Routine specified in the network device structure

          to probe for an IBM Token Ring Adapter.  Routine outline:

          I.  Interrogate hardware to determine if an adapter exists

              and what the speeds and feeds are

         II.  Setup data structures to control execution based upon

              adapter characteristics.

         III. Initialize adapter operation

     We expect tok_probe to be called once for each device entry

     which references it.

 */

int tok_probe(struct device *dev)

{

        unsigned char segment=0, intr=0, irq=0, i=0, j=0, cardpresent=NOTOK,temp=0;

        __u32 t_mmio=0;

        short PIOaddr=0, iAddr;

        struct tok_info *ti=0;

        static struct tok_info *badti=0;  /* if fail after kmalloc, reuse */

        static unsigned char Shared_Ram_Base = IBMTR_SHARED_RAM_BASE;

        /* this is the major adapter probe loop.  For each call to tok_probe,

           we try each remaining entry in TokBaseAddrs[] as a possible

           adapter.  Once an entry is rejected or assigned, we zero it to

           avoid duplicate use or worthless trial for the tok probe call*/

        for (iAddr=0;

             iAddr < (sizeof(TokBaseAddrs)/sizeof(short))&&PIOaddr==0; iAddr++) {

                __u32 cd_chanid;

                unsigned char *tchanid, ctemp;

                PIOaddr=TokBaseAddrs[iAddr];  /* address to try           */

                TokBaseAddrs[iAddr] = 0;      /* (and marked already used */

                if (PIOaddr == 0) continue;   /* already tried this addr */

                /* Make sure PIO address not already assigned

                   elsewhere before we muck with IO address */

                if (check_region(PIOaddr,TR_IO_EXTENT)) {

                        if (ibmtr_debug_trace & TRC_INIT)

                                DPRINTK("check_region(%4hx,%d) failed.\n", PIOaddr, TR_IO_EXTENT);

                        PIOaddr = 0;

                        continue; /* clear to flag fail and try next */

                }

                /* Query the adapter PIO base port which will return

                   indication of where MMIO was placed (per tech ref

                   this assignment is done by BIOS - what is rational for

                   where it is?).  We also have a coded interrupt address. */

                segment = inb(PIOaddr);

                /* out of range values so we'll assume non-existent IO device */

                if (segment < 0x40 || segment > 0xe0) {

                        PIOaddr = 0;

                        continue; /* clear to flag fail and try next */

                }

                /* Compute the linear base address of the MMIO area

                   as LINUX doesn't care about segments          */

                t_mmio=(((__u32)(segment & 0xfc) << 11) + 0x80000);

                intr = segment & 0x03;   /* low bits is coded interrupt # */

                if (ibmtr_debug_trace & TRC_INIT)

                        DPRINTK("PIOaddr: %4hx seg/intr: %2x mmio base: %08X intr: %d\n", PIOaddr, (int)segment, t_mmio, (int)intr);

                /* Now we will compare expected 'channelid' strings with

                   what we is there to learn of ISA/MCA or not TR card */

                /* !!!WARNING:!!!! It seems pretty silly to blunder ahead

                   w/o verification that the mmio address we have found

                   is valid storage -- perhaps this is tolerable for current

                   hardware state??? */

                cd_chanid = (CHANNEL_ID + t_mmio);  /* for efficiency */

                tchanid=pcchannelid;

                cardpresent=TR_ISA;  /* try ISA */

                /* suboptimize knowing first byte different */

                ctemp = readb(cd_chanid) & 0x0f;

                if (ctemp != *tchanid) { /* NOT ISA card, try MCA */

                        tchanid=mcchannelid;

                        cardpresent=TR_MCA;

                        if (ctemp != *tchanid)  /* Neither ISA nor MCA */

                                cardpresent=NOTOK;

                }

                if (cardpresent != NOTOK) { /* know presumed type, try rest of ID */

                        for (i=2,j=1; i<=46; i=i+2,j++) {

                                if ((readb(cd_chanid+i) & 0x0f) != tchanid[j]) {

                                        cardpresent=NOTOK;   /* match failed, not TR card */

                                        break;

                                }

                        }

                }

                /* If we have an ISA board check for the ISA P&P version,

                   as it has different IRQ settings */

                if (cardpresent == TR_ISA && (readb(AIPFID + t_mmio)==0x0e))

                        cardpresent=TR_ISAPNP;

                if (cardpresent == NOTOK) { /* "channel_id" did not match, report */

                        if (ibmtr_debug_trace & TRC_INIT) {

                                DPRINTK("Channel ID string not found for PIOaddr: %4hx\n", PIOaddr);

                                DPRINTK("Expected for ISA: ");  PrtChanID(pcchannelid,1);

                                DPRINTK("           found: ");  HWPrtChanID(cd_chanid,2);

                                DPRINTK("Expected for MCA: ");  PrtChanID(mcchannelid,1);

                        }

                        PIOaddr = 0;  /* all to know not found yet */

                        continue;

                }

        /* !!!! we could tighten validation by checking the HW Address

           against the 1-s complement..  Move the get HW logic to here */

        }

        /* The search loop has either completed with a presumed TR adapter

           or none found.  Check situation ... march on if possible */

        if (PIOaddr == 0) { /* failed to find a valid TR adapter */

                if (ibmtr_debug_trace & TRC_INIT)

                        DPRINTK("Unable to assign adapter to device.\n");

                return ENODEV;

        }

        /*?? Now, allocate some of the pl0 buffers for this driver.. */

        if (!badti) {

                ti = (struct tok_info *)kmalloc(sizeof(struct tok_info), GFP_KERNEL);

                if (ti == NULL) return -ENOMEM;

        } else {

                ti = badti;

                badti = NULL;

        } /*?? dev->priv = kmalloc(sizeof(struct net_local), GFP_KERNEL); */

        memset(ti, 0, sizeof(struct tok_info));

        ti->mmio= t_mmio;

        ti->readlog_pending = 0;

        dev->priv = ti;     /* this seems like the logical use of the

                         field ... let's try some empirical tests

                         using the token-info structure -- that

                         should fit with out future hope of multiple

                         adapter support as well /dwm   */

        switch (cardpresent) {

              case TR_ISA:

                if (intr==0) irq=9; /* irq2 really is irq9 */

                if (intr==1) irq=3;

                if (intr==2) irq=6;

                if (intr==3) irq=7;

                ti->global_int_enable=GLOBAL_INT_ENABLE+((irq==9) ? 2 : irq);

                ti->sram=0;

#if !TR_NEWFORMAT

                DPRINTK("ti->global_int_enable: %04X\n",ti->global_int_enable);

#endif

                break;

              case TR_MCA:

                if (intr==0) irq=9;

                if (intr==1) irq=3;

                if (intr==2) irq=10;

                if (intr==3) irq=11;

                ti->global_int_enable=0;

                ti->sram=((__u32)(inb(PIOaddr+ADAPTRESETREL) & 0xfe) << 12);

                break;

              case TR_ISAPNP:

                if (intr==0) irq=9;

                if (intr==1) irq=3;

                if (intr==2) irq=10;

                if (intr==3) irq=11;

                while(!readb(ti->mmio + ACA_OFFSET + ACA_RW + RRR_EVEN));

                ti->sram=((__u32)readb(ti->mmio + ACA_OFFSET + ACA_RW + RRR_EVEN)<<12);

                ti->global_int_enable=PIOaddr+ADAPTINTREL;

                break;

        }

        if (ibmtr_debug_trace & TRC_INIT) { /* just report int */

                DPRINTK("irq=%d",irq);

                if (ibmtr_debug_trace & TRC_INITV) { /* full chat in verbose only */

                        DPRINTK(", ti->mmio=%08X",ti->mmio);

                        printk(", segment=%02X",segment);

                }

                printk(".\n");

        }

        /* Get hw address of token ring card */

#if !TR_NEWFORMAT 

        DPRINTK("hw address: ");

#endif

        j=0;

        for (i=0; i<0x18; i=i+2) {

                /* technical reference states to do this */

                temp = readb(ti->mmio + AIP + i) & 0x0f;

#if !TR_NEWFORMAT

                printk("%1X",ti->hw_address[j]=temp);

#else

                ti->hw_address[j]=temp;

#endif

                if(j&1)

                        dev->dev_addr[(j/2)]=ti->hw_address[j]+(ti->hw_address[j-1]<<4);

                ++j;

        }

#ifndef TR_NEWFORMAT

        printk("\n");

#endif

        /* get Adapter type:  'F' = Adapter/A, 'E' = 16/4 Adapter II,...*/

        ti->adapter_type = readb(ti->mmio + AIPADAPTYPE);

        /* get Data Rate:  F=4Mb, E=16Mb, D=4Mb & 16Mb ?? */

        ti->data_rate = readb(ti->mmio + AIPDATARATE);

        /* Get Early Token Release support?: F=no, E=4Mb, D=16Mb, C=4&16Mb */

        ti->token_release = readb(ti->mmio + AIPEARLYTOKEN);

        /* How much shared RAM is on adapter ? */

        ti->avail_shared_ram = get_sram_size(ti);

        /* We need to set or do a bunch of work here based on previous results.. */

        /* Support paging?  What sizes?:  F=no, E=16k, D=32k, C=16 & 32k */

        ti->shared_ram_paging = readb(ti->mmio + AIPSHRAMPAGE);

  /* Available DHB  4Mb size:   F=2048, E=4096, D=4464 */

        ti->dhb_size4mb = readb(ti->mmio + AIP4MBDHB);

        /* Available DHB 16Mb size:  F=2048, E=4096, D=8192, C=16384, B=17960 */

        ti->dhb_size16mb = readb(ti->mmio + AIP16MBDHB);

#if !TR_NEWFORMAT

        DPRINTK("atype=%x, drate=%x, trel=%x, asram=%dK, srp=%x, "

                "dhb(4mb=%x, 16mb=%x)\n",ti->adapter_type,

                ti->data_rate, ti->token_release, ti->avail_shared_ram/2,

                ti->shared_ram_paging, ti->dhb_size4mb, ti->dhb_size16mb);

#endif

        /* We must figure out how much shared memory space this adapter

           will occupy so that if there are two adapters we can fit both

           in.  Given a choice, we will limit this adapter to 32K.  The

           maximum space will use for two adapters is 64K so if the adapter

           we are working on demands 64K (it also doesn't support paging),

           then only one adapter can be supported.  */

        /* determine how much of total RAM is mapped into PC space */

        ti->mapped_ram_size=1<<((((readb(ti->mmio+ ACA_OFFSET + ACA_RW + RRR_ODD)) >>2) & 0x03) + 4);

        ti->page_mask=0;

        if (ti->shared_ram_paging == 0xf) { /* No paging in adapter */

                ti->mapped_ram_size = ti->avail_shared_ram;

        } else {

#ifdef ENABLE_PAGING

                unsigned char pg_size;

#endif

#if !TR_NEWFORMAT

                DPRINTK("shared ram page size: %dK\n",ti->mapped_ram_size/2);

#endif

#ifdef ENABLE_PAGING

        switch(ti->shared_ram_paging) {

              case 0xf:

                break;

              case 0xe:

                ti->page_mask=(ti->mapped_ram_size==32) ? 0xc0 : 0;

                pg_size=32;   /* 16KB page size */

                break;

              case 0xd:

                ti->page_mask=(ti->mapped_ram_size==64) ? 0x80 : 0;

                pg_size=64;   /* 32KB page size */

                break;

              case 0xc:

                ti->page_mask=(ti->mapped_ram_size==32) ? 0xc0 : 0;

                ti->page_mask=(ti->mapped_ram_size==64) ? 0x80 : 0;

                DPRINTK("Dual size shared RAM page (code=0xC), don't support it!\n");

                /* nb/dwm: I did this because RRR (3,2) bits are documented as

                   R/O and I can't find how to select which page size

                   Also, the above conditional statement sequence is invalid

                   as page_mask will always be set by the second stmt */

                badti=ti;

                break;

              default:

                DPRINTK("Unknown shared ram paging info %01X\n",ti->shared_ram_paging);

                badti=ti;    /* bail out if bad code */

                break;

        }

        if (ti->page_mask) {

                if (pg_size > ti->mapped_ram_size) {

                        DPRINTK("Page size (%d) > mapped ram window (%d), can't page.\n",

                                pg_size, ti->mapped_ram_size);

                                ti->page_mask = 0;    /* reset paging */

                } else {

                        ti->mapped_ram_size=ti->avail_shared_ram;

                        DPRINTK("Shared RAM paging enabled. Page size : %uK\n",

                                ((ti->page_mask^ 0xff)+1)>>2);

                }

#endif

        }

        /* finish figuring the shared RAM address */

        if (cardpresent==TR_ISA) {

                static unsigned char ram_bndry_mask[]={0xfe, 0xfc, 0xf8, 0xf0};

                unsigned char new_base, rrr_32, chk_base, rbm;

                rrr_32 = ((readb(ti->mmio+ ACA_OFFSET + ACA_RW + RRR_ODD))>>2) & 0x03;

                rbm = ram_bndry_mask[rrr_32];

                new_base = (Shared_Ram_Base + (~rbm)) & rbm; /* up to boundary */

                chk_base = new_base + (ti->mapped_ram_size>>3);

                if (chk_base > (IBMTR_SHARED_RAM_BASE+IBMTR_SHARED_RAM_SIZE)) {

                        DPRINTK("Shared RAM for this adapter (%05x) exceeds driver"

                                " limit (%05x), adapter not started.\n",

                                chk_base<<12, (IBMTR_SHARED_RAM_BASE+

                                               IBMTR_SHARED_RAM_SIZE)<<12);

                        badti=ti;

                } else {  /* seems cool, record what we have figured out */

                        ti->sram_base = new_base;

                        Shared_Ram_Base = new_base;

                }

        }

        /* dwm: irq and other final setup moved here so if we find other

           unrecognized values OR shared ram conflicts, we can still

           bail out in a rather benign fashion.    */

        if (badti) return ENODEV;

#if !TR_NEWFORMAT

        DPRINTK("Using %dK shared RAM\n",ti->mapped_ram_size/2);

#endif

        if (request_irq (dev->irq = irq, &tok_interrupt,0,"IBM TR", NULL) != 0) {

                DPRINTK("Could not grab irq %d.  Halting Token Ring driver.\n",irq);

                badti = ti;    /*  keep track of unused tok_info */

                return ENODEV;

        }

        irq2dev_map[irq]=dev;

 /*?? Now, allocate some of the PIO PORTs for this driver.. */

        request_region(PIOaddr,TR_IO_EXTENT,"ibmtr");  /* record PIOaddr range

                                                                  as busy */

#if !TR_NEWFORMAT

        DPRINTK("%s",version); /* As we have passed card identification,

                                  let the world know we're here! */

#else

        printk("%s",version);

        DPRINTK("%s %s found using irq %d, PIOaddr %4hx, %dK shared RAM.\n",

                channel_def[cardpresent-1], adapter_def(ti->adapter_type), irq,

                PIOaddr, ti->mapped_ram_size/2);

        DPRINTK("Hardware address : %02X:%02X:%02X:%02X:%02X:%02X\n",

                dev->dev_addr[0], dev->dev_addr[1], dev->dev_addr[2],

                dev->dev_addr[3], dev->dev_addr[4], dev->dev_addr[5]);

#endif

        dev->base_addr=PIOaddr; /* set the value for device */

        trdev_init(dev);

        tok_init_card(dev);

        return 0;  /* Return 0 to indicate we have found a Token Ring card. */

}

/* query the adapter for the size of shared RAM  */

unsigned char get_sram_size(struct tok_info *adapt_info)

{

        unsigned char avail_sram_code;

        static unsigned char size_code[]={ 0,16,32,64,127,128 };

        /* Adapter gives

           'F' -- use RRR bits 3,2

           'E' -- 8kb   'D' -- 16kb

           'C' -- 32kb  'A' -- 64KB

           'B' - 64KB less 512 bytes at top

           (WARNING ... must zero top bytes in INIT */

        avail_sram_code=0xf-readb(adapt_info->mmio + AIPAVAILSHRAM);

        if (avail_sram_code)

                return size_code[avail_sram_code];

        else  /* for code 'F', must compute size from RRR(3,2) bits */

                return 1<<((readb(adapt_info->mmio+ ACA_OFFSET + ACA_RW + RRR_ODD)>>2)+4);

}

int trdev_init(struct device *dev)

{

  struct tok_info *ti=(struct tok_info *)dev->priv;

  ti->open_status=CLOSED;

  dev->init=tok_init_card;

  dev->open=tok_open;

  dev->stop=tok_close;

  dev->hard_start_xmit=tok_send_packet;

  dev->get_stats = NULL;

  dev->get_stats = tok_get_stats;

  dev->set_multicast_list = NULL;

  tr_setup(dev);

  return 0;

}

static int tok_open(struct device *dev)

{

        struct tok_info *ti=(struct tok_info *)dev->priv;

        if (ti->open_status==CLOSED) tok_init_card(dev);

        if (ti->open_status==IN_PROGRESS) sleep_on(&ti->wait_for_reset);

        if (ti->open_status==SUCCESS) {

                dev->tbusy=0;

                dev->interrupt=0;

                dev->start=1;

                /* NEED to see smem size *AND* reset high 512 bytes if needed */

                MOD_INC_USE_COUNT;

                return 0;

        } else return -EAGAIN;

}

static int tok_close(struct device *dev)

{

        struct tok_info *ti=(struct tok_info *) dev->priv;

        writeb(DIR_CLOSE_ADAPTER,

               ti->srb + offsetof(struct srb_close_adapter, command));

        writeb(CMD_IN_SRB, ti->mmio + ACA_OFFSET + ACA_SET + ISRA_ODD);

        ti->open_status=CLOSED;

        sleep_on(&ti->wait_for_tok_int);

        if (readb(ti->srb + offsetof(struct srb_close_adapter, ret_code)))

                DPRINTK("close adapter failed: %02X\n",

                        (int)readb(ti->srb + offsetof(struct srb_close_adapter, ret_code)));

        MOD_DEC_USE_COUNT;

        return 0;

}

void tok_interrupt (int irq, void *dev_id, struct pt_regs *regs)

{

        unsigned char status;

        struct tok_info *ti;

        struct device *dev = (struct device *)(irq2dev_map[irq]);