Subversion Repositories or1k

/* esp.c:  EnhancedScsiProcessor Sun SCSI driver code.

 *

 * Copyright (C) 1995 David S. Miller (davem@caip.rutgers.edu)

 */

#include <linux/kernel.h>

#include <linux/delay.h>

#include <linux/types.h>

#include <linux/string.h>

#include <linux/malloc.h>

#include <linux/blk.h>

#include <linux/proc_fs.h>

#include <linux/stat.h>

#include "scsi.h"

#include "hosts.h"

#include "esp.h"

#include <asm/sbus.h>

#include <asm/dma.h>

#include <asm/system.h>

#include <asm/idprom.h>

#include <asm/machines.h>

#include <asm/ptrace.h>

#include <asm/pgtable.h>

#include <asm/oplib.h>

#include <asm/vaddrs.h>

#include <asm/io.h>

#define DEBUG_ESP

/* #define DEBUG_ESP_SG */

#if defined(DEBUG_ESP)

#define ESPLOG(foo)  printk foo

#else

#define ESPLOG(foo)

#endif /* (DEBUG_ESP) */

#define INTERNAL_ESP_ERROR \

        (panic ("Internal ESP driver error in file %s, line %d\n", \

                __FILE__, __LINE__))

#define INTERNAL_ESP_ERROR_NOPANIC \

        (printk ("Internal ESP driver error in file %s, line %d\n", \

                 __FILE__, __LINE__))

/* This enum will be expanded when we have sync code written. */

enum {

        not_issued   = 0x01,  /* Still in the issue_SC queue.          */

        in_selection = 0x02,  /* ESP is arbitrating, awaiting IRQ      */

        in_datain    = 0x04,  /* Data is transferring over the bus     */

        in_dataout   = 0x08,  /* Data is transferring over the bus     */

        in_status    = 0x10,  /* Awaiting status/msg bytes from target */

        in_finale    = 0x11,  /* Sent Msg ack, awaiting disconnect     */

};

struct proc_dir_entry proc_scsi_esp = {

        PROC_SCSI_ESP, 3, "esp",

        S_IFDIR | S_IRUGO | S_IXUGO, 2

};

struct Sparc_ESP *espchain;

static void esp_intr(int irq, void *dev_id, struct pt_regs *pregs);

static void esp_done(struct Sparc_ESP *esp, int error);

/* Debugging routines */

struct esp_cmdstrings {

        unchar cmdchar;

        char *text;

} esp_cmd_strings[] = {

        /* Miscellaneous */

        { ESP_CMD_NULL, "ESP_NOP", },

        { ESP_CMD_FLUSH, "FIFO_FLUSH", },

        { ESP_CMD_RC, "RSTESP", },

        { ESP_CMD_RS, "RSTSCSI", },

        /* Disconnected State Group */

        { ESP_CMD_RSEL, "RESLCTSEQ", },

        { ESP_CMD_SEL, "SLCTNATN", },

        { ESP_CMD_SELA, "SLCTATN", },

        { ESP_CMD_SELAS, "SLCTATNSTOP", },

        { ESP_CMD_ESEL, "ENSLCTRESEL", },

        { ESP_CMD_DSEL, "DISSELRESEL", },

        { ESP_CMD_SA3, "SLCTATN3", },

        { ESP_CMD_RSEL3, "RESLCTSEQ", },

        /* Target State Group */

        { ESP_CMD_SMSG, "SNDMSG", },

        { ESP_CMD_SSTAT, "SNDSTATUS", },

        { ESP_CMD_SDATA, "SNDDATA", },

        { ESP_CMD_DSEQ, "DISCSEQ", },

        { ESP_CMD_TSEQ, "TERMSEQ", },

        { ESP_CMD_TCCSEQ, "TRGTCMDCOMPSEQ", },

        { ESP_CMD_DCNCT, "DISC", },

        { ESP_CMD_RMSG, "RCVMSG", },

        { ESP_CMD_RCMD, "RCVCMD", },

        { ESP_CMD_RDATA, "RCVDATA", },

        { ESP_CMD_RCSEQ, "RCVCMDSEQ", },

        /* Initiator State Group */

        { ESP_CMD_TI, "TRANSINFO", },

        { ESP_CMD_ICCSEQ, "INICMDSEQCOMP", },

        { ESP_CMD_MOK, "MSGACCEPTED", },

        { ESP_CMD_TPAD, "TPAD", },

        { ESP_CMD_SATN, "SATN", },

        { ESP_CMD_RATN, "RATN", },

};

#define NUM_ESP_COMMANDS  ((sizeof(esp_cmd_strings)) / (sizeof(struct esp_cmdstrings)))

/* Print textual representation of an ESP command */

static inline void esp_print_cmd(unchar espcmd)

{

        unchar dma_bit = espcmd & ESP_CMD_DMA;

        int i;

        espcmd &= ~dma_bit;

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

                if(esp_cmd_strings[i].cmdchar == espcmd)

                        break;

        if(i==NUM_ESP_COMMANDS)

                printk("ESP_Unknown");

        else

                printk("%s%s", esp_cmd_strings[i].text,

                       ((dma_bit) ? "+DMA" : ""));

}

/* Print the status register's value */

static inline void esp_print_statreg(unchar statreg)

{

        unchar phase;

        printk("STATUS<");

        phase = statreg & ESP_STAT_PMASK;

        printk("%s,", (phase == ESP_DOP ? "DATA-OUT" :

                       (phase == ESP_DIP ? "DATA-IN" :

                        (phase == ESP_CMDP ? "COMMAND" :

                         (phase == ESP_STATP ? "STATUS" :

                          (phase == ESP_MOP ? "MSG-OUT" :

                           (phase == ESP_MIP ? "MSG_IN" :

                            "unknown")))))));

        if(statreg & ESP_STAT_TDONE)

                printk("TRANS_DONE,");

        if(statreg & ESP_STAT_TCNT)

                printk("TCOUNT_ZERO,");

        if(statreg & ESP_STAT_PERR)

                printk("P_ERROR,");

        if(statreg & ESP_STAT_SPAM)

                printk("SPAM,");

        if(statreg & ESP_STAT_INTR)

                printk("IRQ,");

        printk(">");

}

/* Print the interrupt register's value */

static inline void esp_print_ireg(unchar intreg)

{

        printk("INTREG< ");

        if(intreg & ESP_INTR_S)

                printk("SLCT_NATN ");

        if(intreg & ESP_INTR_SATN)

                printk("SLCT_ATN ");

        if(intreg & ESP_INTR_RSEL)

                printk("RSLCT ");

        if(intreg & ESP_INTR_FDONE)

                printk("FDONE ");

        if(intreg & ESP_INTR_BSERV)

                printk("BSERV ");

        if(intreg & ESP_INTR_DC)

                printk("DISCNCT ");

        if(intreg & ESP_INTR_IC)

                printk("ILL_CMD ");

        if(intreg & ESP_INTR_SR)

                printk("SCSI_BUS_RESET ");

        printk(">");

}

/* Print the sequence step registers contents */

static inline void esp_print_seqreg(unchar stepreg)

{

        stepreg &= ESP_STEP_VBITS;

        printk("STEP<%s>",

               (stepreg == ESP_STEP_ASEL ? "SLCT_ARB_CMPLT" :

                (stepreg == ESP_STEP_SID ? "1BYTE_MSG_SENT" :

                 (stepreg == ESP_STEP_NCMD ? "NOT_IN_CMD_PHASE" :

                  (stepreg == ESP_STEP_PPC ? "CMD_BYTES_LOST" :

                   (stepreg == ESP_STEP_FINI ? "CMD_SENT_OK" :

                    "UNKNOWN"))))));

}

/* Manipulation of the ESP command queues.  Thanks to the aha152x driver

 * and its author, Juergen E. Fischer, for the methods used here.

 * Note that these are per-ESP queues, not global queues like

 * the aha152x driver uses.

 */

static inline void append_SC(Scsi_Cmnd **SC, Scsi_Cmnd *new_SC)

{

        Scsi_Cmnd *end;

        unsigned long flags;

        save_flags(flags); cli();

        new_SC->host_scribble = (unsigned char *) NULL;

        if(!*SC)

                *SC = new_SC;

        else {

                for(end=*SC;end->host_scribble;end=(Scsi_Cmnd *)end->host_scribble)

                        ;

                end->host_scribble = (unsigned char *) new_SC;

        }

        restore_flags(flags);

}

static inline Scsi_Cmnd *remove_first_SC(Scsi_Cmnd **SC)

{

        Scsi_Cmnd *ptr;

        unsigned long flags;

        save_flags(flags); cli();

        ptr = *SC;

        if(ptr)

                *SC = (Scsi_Cmnd *) (*SC)->host_scribble;

        restore_flags(flags);

        return ptr;

}

static inline Scsi_Cmnd *remove_SC(Scsi_Cmnd **SC, int target, int lun)

{

        Scsi_Cmnd *ptr, *prev;

        unsigned long flags;

        save_flags(flags); cli();

        for(ptr = *SC, prev = NULL;

            ptr && ((ptr->target != target) || (ptr->lun != lun));

            prev = ptr, ptr = (Scsi_Cmnd *) ptr->host_scribble)

                ;

        if(ptr) {

                if(prev)

                        prev->host_scribble=ptr->host_scribble;

                else

                        *SC=(Scsi_Cmnd *)ptr->host_scribble;

        }

        restore_flags(flags);

        return ptr;

}

static inline void do_pause(unsigned amount)

{

        unsigned long the_time = jiffies + amount;

        while(jiffies < the_time)

                barrier(); /* Not really needed, but... */

}

/* This places the ESP into a known state at boot time. */

static inline void esp_bootup_reset(struct Sparc_ESP *esp, struct Sparc_ESP_regs *eregs)

{

        struct sparc_dma_registers *dregs = esp->dregs;

        volatile unchar trash;

        /* Punt the DVMA into a known state. */

        dregs->cond_reg |= DMA_RST_SCSI;

        do_pause(100);

        dregs->cond_reg &= ~(DMA_RST_SCSI);

        if(esp->dma->revision == dvmarev2)

                if(esp->erev != esp100)

                        dregs->cond_reg |= DMA_3CLKS;

        else if(esp->dma->revision == dvmarev3)

                if(esp->erev == fas236 || esp->erev == fas100a) {

                        dregs->cond_reg &= ~(DMA_3CLKS);

                        dregs->cond_reg |= DMA_2CLKS;

                }

        else if(esp->dma->revision == dvmaesc1)

                dregs->cond_reg |= DMA_ADD_ENABLE;

        DMA_INTSON(dregs);

        /* Now reset the ESP chip */

        eregs->esp_cmd = ESP_CMD_RC;

        eregs->esp_cmd = (ESP_CMD_NULL | ESP_CMD_DMA);

        eregs->esp_cmd = (ESP_CMD_NULL | ESP_CMD_DMA); /* borken hardware... */

        /* Reload the configuration registers */

        eregs->esp_cfg1  = esp->config1;

        eregs->esp_cfact = esp->cfact;

        eregs->esp_stp   = 0;

        eregs->esp_soff  = 0;

        eregs->esp_timeo = esp->sync_defp;

        if(esp->erev == esp100a || esp->erev == esp236)

                eregs->esp_cfg2 = esp->config2;

        if(esp->erev == esp236)

                eregs->esp_cfg3 = esp->config3[0];

        /* Eat any bitrot in the chip */

        trash = eregs->esp_intrpt;

        /* Reset the SCSI bus, but tell ESP not to generate an irq */

        eregs->esp_cfg1 |= ESP_CONFIG1_SRRDISAB;

        eregs->esp_cmd = ESP_CMD_RS;

        do_pause(200);

        eregs->esp_cfg1 = esp->config1;

        /* Eat any bitrot in the chip and we are done... */

        trash = eregs->esp_intrpt;

}

/* Detecting ESP chips on the machine.  This is the simple and easy

 * version.

 */

int esp_detect(Scsi_Host_Template *tpnt)

{

        struct Sparc_ESP *esp, *elink;

        struct Scsi_Host *esp_host;

        struct linux_sbus *sbus;

        struct linux_sbus_device *esp_dev, *sbdev_iter;

        struct Sparc_ESP_regs *eregs;

        struct sparc_dma_registers *dregs;

        struct Linux_SBus_DMA *dma, *dlink;

        unsigned int fmhz;

        unchar ccf, bsizes, bsizes_more;

        int nesps = 0;

        int esp_node;

        espchain = 0;

        if(!SBus_chain)

                panic("No SBUS in esp_detect()");

        for_each_sbus(sbus) {

                for_each_sbusdev(sbdev_iter, sbus) {

                        /* Is it an esp sbus device? */

                        esp_dev = sbdev_iter;

                        if(strcmp(esp_dev->prom_name, "esp") &&

                           strcmp(esp_dev->prom_name, "SUNW,esp")) {

                                if(!esp_dev->child ||

                                   strcmp(esp_dev->prom_name, "espdma"))

                                        continue; /* nope... */

                                esp_dev = esp_dev->child;

                                if(strcmp(esp_dev->prom_name, "esp") &&

                                   strcmp(esp_dev->prom_name, "SUNW,esp"))

                                        continue; /* how can this happen? */

                        }

                        esp_host = scsi_register(tpnt, sizeof(struct Sparc_ESP));

                        if(!esp_host)

                                panic("Cannot register ESP SCSI host");

                        esp = (struct Sparc_ESP *) esp_host->hostdata;

                        if(!esp)

                                panic("No esp in hostdata");

                        esp->ehost = esp_host;

                        esp->edev = esp_dev;

                        /* Put into the chain of esp chips detected */

                        if(espchain) {

                                elink = espchain;

                                while(elink->next) elink = elink->next;

                                elink->next = esp;

                        } else {

                                espchain = esp;

                        }

                        esp->next = 0;

                        /* Get misc. prom information */

#define ESP_IS_MY_DVMA(esp, dma)  \

        ((esp->edev->my_bus == dma->SBus_dev->my_bus) && \

         (esp->edev->slot == dma->SBus_dev->slot) && \

         (!strcmp(dma->SBus_dev->prom_name, "dma") || \

          !strcmp(dma->SBus_dev->prom_name, "espdma")))

                        esp_node = esp_dev->prom_node;

                        prom_getstring(esp_node, "name", esp->prom_name,

                                       sizeof(esp->prom_name));

                        esp->prom_node = esp_node;

                        for_each_dvma(dlink) {

                                if(ESP_IS_MY_DVMA(esp, dlink) && !dlink->allocated)

                                        break;

                        }

#undef ESP_IS_MY_DVMA

                        /* If we don't know how to handle the dvma, do not use this device */

                        if(!dlink){

                                printk ("Cannot find dvma for ESP SCSI\n");

                                scsi_unregister (esp_host);

                                continue;

                        }

                        if (dlink->allocated){

                                printk ("esp: can't use my espdma\n");

                                scsi_unregister (esp_host);

                                continue;

                        }

                        dlink->allocated = 1;

                        dma = dlink;

                        esp->dma = dma;

                        esp->dregs = dregs = dma->regs;

                        /* Map in the ESP registers from I/O space */

                        prom_apply_sbus_ranges(esp->edev->reg_addrs, 1);

                        esp->eregs = eregs = (struct Sparc_ESP_regs *)

                                sparc_alloc_io(esp->edev->reg_addrs[0].phys_addr, 0,

                                               PAGE_SIZE, "ESP Registers",

                                               esp->edev->reg_addrs[0].which_io, 0x0);

                        if(!eregs)

                                panic("ESP registers unmappable");

                        esp->esp_command =

                                sparc_dvma_malloc(16, "ESP DVMA Cmd Block");

                        if(!esp->esp_command)

                                panic("ESP DVMA transport area unmappable");

                        /* Set up the irq's etc. */

                        esp->ehost->base = (unsigned char *) esp->eregs;

                        esp->ehost->io_port = (unsigned int) esp->eregs;

                        esp->ehost->n_io_port = (unsigned char)

                                esp->edev->reg_addrs[0].reg_size;

                        /* XXX The following may be different on sun4ms XXX */

                        esp->ehost->irq = esp->irq = esp->edev->irqs[0].pri;

                        /* Allocate the irq only if necessary */

                        for_each_esp(elink) {

                                if((elink != esp) && (esp->irq == elink->irq)) {

                                        goto esp_irq_acquired; /* BASIC rulez */

                                }

                        }

                        /* XXX We have shared interrupts per level now, maybe

                         * XXX use them, maybe not...

                         */

                        if(request_irq(esp->ehost->irq, esp_intr, SA_INTERRUPT,

                                       "Sparc ESP SCSI", NULL))

                                panic("Cannot acquire ESP irq line");

esp_irq_acquired:

                        printk("esp%d: IRQ %d ", nesps, esp->ehost->irq);

                        /* Figure out our scsi ID on the bus */

                        esp->scsi_id = prom_getintdefault(esp->prom_node,

                                                          "initiator-id", -1);

                        if(esp->scsi_id == -1)

                                esp->scsi_id = prom_getintdefault(esp->prom_node,

                                                                  "scsi-initiator-id", -1);

                        if(esp->scsi_id == -1)

                                esp->scsi_id =

                                        prom_getintdefault(esp->edev->my_bus->prom_node,

                                                           "scsi-initiator-id", 7);

                        esp->ehost->this_id = esp->scsi_id;

                        esp->scsi_id_mask = (1 << esp->scsi_id);

                        /* Check for differential bus */

                        esp->diff = prom_getintdefault(esp->prom_node, "differential", -1);

                        esp->diff = (esp->diff == -1) ? 0 : 1;

                        /* Check out the clock properties of the chip */

                        fmhz = prom_getintdefault(esp->prom_node, "clock-frequency", -1);

                        if(fmhz==-1)

                                fmhz = prom_getintdefault(esp->edev->my_bus->prom_node,

                                                          "clock-frequency", -1);

                        if(fmhz <= (5000))

                                ccf = 0;

                        else

                                ccf = (((5000 - 1) + (fmhz))/(5000));

                        if(!ccf || ccf > 8) {

                                ccf = ESP_CCF_F4;

                                fmhz = (5000 * 4);

                        }

                        if(ccf==(ESP_CCF_F7+1))

                                esp->cfact = ESP_CCF_F0;

                        else if(ccf == ESP_CCF_NEVER)

                                esp->cfact = ESP_CCF_F2;

                        else

                                esp->cfact = ccf;

                        esp->cfreq = fmhz;

                        esp->ccycle = ((1000000000) / ((fmhz)/1000));

                        esp->ctick = ((7682 * esp->cfact * esp->ccycle)/1000);

                        esp->sync_defp = ((7682 + esp->ctick - 1) / esp->ctick);

                        /* XXX HACK HACK HACK XXX */

                        if (esp->sync_defp < 153)

                                esp->sync_defp = 153;

                        printk("SCSI ID %d  Clock %d MHz Period %2x ", esp->scsi_id,

                               (fmhz / 1000), esp->sync_defp);

                        /* Find the burst sizes this dma supports. */

                        bsizes = prom_getintdefault(esp->prom_node, "burst-sizes", 0xff);

                        bsizes_more = prom_getintdefault(esp->edev->my_bus->prom_node,

                                                         "burst-sizes", 0xff);

                        if(bsizes_more != 0xff) bsizes &= bsizes_more;

                        if(bsizes == 0xff || (bsizes & DMA_BURST16)==0 ||

                           (bsizes & DMA_BURST32)==0)

                                bsizes = (DMA_BURST32 - 1);

                        esp->bursts = bsizes;

                        /* Probe the revision of this esp */

                        esp->config1 = (ESP_CONFIG1_PENABLE | (esp->scsi_id & 7));

                        esp->config2 = (ESP_CONFIG2_SCSI2ENAB | ESP_CONFIG2_REGPARITY);

                        esp->config3[0] = ESP_CONFIG3_TENB;

                        eregs->esp_cfg2 = esp->config2;

                        if((eregs->esp_cfg2 & ~(ESP_CONFIG2_MAGIC)) !=

                           (ESP_CONFIG2_SCSI2ENAB | ESP_CONFIG2_REGPARITY)) {

                                printk("NCR53C90(esp100) detected\n");

                                esp->erev = esp100;

                        } else {

                                eregs->esp_cfg2 = esp->config2 = 0;

                                eregs->esp_cfg3 = 0;

                                eregs->esp_cfg3 = esp->config3[0] = 5;

                                if(eregs->esp_cfg3 != 5) {

                                        printk("NCR53C90A(esp100a) detected\n");

                                        esp->erev = esp100a;

                                } else {

                                        int target;

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

                                                esp->config3[target] = 0;

                                        eregs->esp_cfg3 = 0;

                                        if(esp->cfact > ESP_CCF_F5) {

                                                printk("NCR53C9XF(espfast) detected\n");

                                                esp->erev = fast;

                                                esp->config2 |= ESP_CONFIG2_FENAB;

                                                eregs->esp_cfg2 = esp->config2;

                                        } else {

                                                printk("NCR53C9x(esp236) detected\n");

                                                esp->erev = esp236;

                                                eregs->esp_cfg2 = esp->config2 = 0;

                                        }

                                }

                        }

                        /* Initialize the command queues */

                        esp->current_SC = 0;

                        esp->disconnected_SC = 0;

                        esp->issue_SC = 0;

                        /* Reset the thing before we try anything... */

                        esp_bootup_reset(esp, eregs);

                        nesps++;

#ifdef THREADED_ESP_DRIVER

                        kernel_thread(esp_kernel_thread, esp, 0);

#endif

                } /* for each sbusdev */

        } /* for each sbus */

        return nesps;

}

/*

 * The info function will return whatever useful

 * information the developer sees fit.  If not provided, then

 * the name field will be used instead.

 */

const char *esp_info(struct Scsi_Host *host)

{

        struct Sparc_ESP *esp;

        esp = (struct Sparc_ESP *) host->hostdata;

        switch(esp->erev) {

        case esp100:

                return "Sparc ESP100 (NCR53C90)";

        case esp100a:

                return "Sparc ESP100A (NCR53C90A)";

        case esp236:

                return "Sparc ESP236";

        case fast:

                return "Sparc ESP-FAST (236 or 100A)";

        case fas236:

                return "Sparc ESP236-FAST";

        case fas100a:

                return "Sparc ESP100A-FAST";

        default:

                panic("Bogon ESP revision");

        };

}

/* Execute a SCSI command when the bus is free.   All callers

 * turn off all interrupts, so we don't need to explicitly do

 * it here.

 */

static inline void esp_exec_cmd(struct Sparc_ESP *esp)

{

        struct sparc_dma_registers *dregs;

        struct Sparc_ESP_regs *eregs;

        Scsi_Cmnd *SCptr;

        int i;

        eregs = esp->eregs;

        dregs = esp->dregs;

        /* Grab first member of the issue queue. */

        SCptr = esp->current_SC = remove_first_SC(&esp->issue_SC);

        if(!SCptr)

                goto bad;

        SCptr->SCp.phase = in_selection;

        /* NCR docs say:

         * 1) Load select/reselect Bus ID register with target ID

         * 2) Load select/reselect Timeout Reg with desired value

         * 3) Load Synchronous offset register with zero (for

         *    asynchronous transfers).

         * 4) Load Synchronous Transfer Period register (if

         *    synchronous)

         * 5) Load FIFO with 6, 10, or 12 byte SCSI command

         * 6) Issue SELECTION_WITHOUT_ATTENTION command

         *

         * They also mention that a DMA NOP command must be issued

         * to the SCSI chip under many circumstances, plus it's

         * also a good idea to flush out the fifo just in case.

         */

        /* Load zeros into COUNTER via 2 DMA NOP chip commands

         * due to flaky implementations of the 53C9x which don't

         * get the idea the first time around.

         */

        dregs->cond_reg = (DMA_INT_ENAB | DMA_FIFO_INV);

        eregs->esp_tclow = 0;

        eregs->esp_tcmed = 0;

        eregs->esp_cmd   = (ESP_CMD_NULL | ESP_CMD_DMA);

        /* Flush the fifo of excess garbage. */

        eregs->esp_cmd   = ESP_CMD_FLUSH;

        /* Load bus-id and timeout values. */

        eregs->esp_busid = (SCptr->target & 7);

        eregs->esp_timeo = esp->sync_defp;

        eregs->esp_soff  = 0; /* This means async transfer... */

        eregs->esp_stp   = 0;

        /* Load FIFO with the actual SCSI command. */

        for(i=0; i < SCptr->cmd_len; i++)

                eregs->esp_fdata = SCptr->cmnd[i];

        /* Make sure the dvma forwards the ESP interrupt. */

        dregs->cond_reg = DMA_INT_ENAB;

        /* Tell ESP to SELECT without asserting ATN. */

        eregs->esp_cmd = ESP_CMD_SEL;

        return;

bad:

        panic("esp: daaarrrkk starrr crashesss....");

}

/* Queue a SCSI command delivered from the mid-level Linux SCSI code. */

int esp_queue(Scsi_Cmnd *SCpnt, void (*done)(Scsi_Cmnd *))

{

        struct Sparc_ESP *esp;

        unsigned long flags;

        save_flags(flags); cli();

        /* Set up func ptr and initial driver cmd-phase. */