BSD 4_4 release

[unix-history] / usr / src / sys / dev / scsi / scsi_subr.c

/*
* Copyright (c) 1992, 1993
*      The Regents of the University of California.  All rights reserved.
*
* This software was developed by the Computer Systems Engineering group
* at Lawrence Berkeley Laboratory under DARPA contract BG 91-66 and
* contributed to Berkeley.
*
* All advertising materials mentioning features or use of this software
* must display the following acknowledgement:
*      This product includes software developed by the University of
*      California, Lawrence Berkeley Laboratories.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
*    notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
*    notice, this list of conditions and the following disclaimer in the
*    documentation and/or other materials provided with the distribution.
* 3. All advertising materials mentioning features or use of this software
*    must display the following acknowledgement:
*      This product includes software developed by the University of
*      California, Berkeley and its contributors.
* 4. Neither the name of the University nor the names of its contributors
*    may be used to endorse or promote products derived from this software
*    without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
* SUCH DAMAGE.
*
*      @(#)scsi_subr.c 8.1 (Berkeley) 6/16/93
*
* from: $Header: scsi_subr.c,v 1.10 93/02/01 19:21:58 torek Exp $ (LBL)
*/

/*
* Generic SCSI host adapter driver.
* Does almost nothing (most work is relegated to per-hba drivers).
*/

#include <sys/param.h>
#include <sys/buf.h>
#include <sys/device.h>

#include <dev/scsi/scsi.h>
#include <dev/scsi/scsivar.h>

/*
* General subroutines, and scsi data.
*/

/* table of lengths of scsi commands */
const char scsicmdlen[8] = { 6, 10, 0, 0, 0, 12, 0, 0 };

/* table of lengths of scsi messages */
const signed char scsimsglen[0x24] = {
       SMLEN_DONE,             /* MSG_CMD_COMPLETE */
       SMLEN_EXTENDED,         /* MSG_EXT_MESSAGE */
       1,                      /* MSG_SAVE_DATA_PTR */
       1,                      /* MSG_RESTORE_PTR */
       1,                      /* MSG_DISCONNECT */
       1,                      /* MSG_INIT_DETECT_ERROR */
       1,                      /* MSG_ABORT */
       1,                      /* MSG_REJECT */
       1,                      /* MSG_NOOP */
       1,                      /* MSG_PARITY_ERROR */
       1,                      /* MSG_LCC */
       1,                      /* MSG_LCCF */
       1,                      /* MSG_BUS_DEVICE_RESET */
       1,                      /* MSG_ABORT_TAG */
       1,                      /* MSG_CLEAR_QUEUE */
       1,                      /* MSG_INITIATE_RECOVERY */
       1,                      /* MSG_RELEASE_RECOVERY */
       1,                      /* MSG_TERMINATE_PROCESS */
       SMLEN_UNDEF,            /* 0x12 */
       SMLEN_UNDEF,            /* 0x13 */
       SMLEN_UNDEF,            /* 0x14 */
       SMLEN_UNDEF,            /* 0x15 */
       SMLEN_UNDEF,            /* 0x16 */
       SMLEN_UNDEF,            /* 0x17 */
       SMLEN_UNDEF,            /* 0x18 */
       SMLEN_UNDEF,            /* 0x19 */
       SMLEN_UNDEF,            /* 0x1a */
       SMLEN_UNDEF,            /* 0x1b */
       SMLEN_UNDEF,            /* 0x1c */
       SMLEN_UNDEF,            /* 0x1d */
       SMLEN_UNDEF,            /* 0x1e */
       SMLEN_UNDEF,            /* 0x1f */
       2,                      /* MSG_SIMPLE_QTAG */
       2,                      /* MSG_HEAD_QTAG */
       2,                      /* MSG_ORDERED_QTAG */
       2,                      /* MSG_IGNORE_WIDE_RESID */
};

/* definition of `tg' target driver for autoconfig */
static int scsi_targmatch __P((struct device *, struct cfdata *, void *));
static void scsi_targattach __P((struct device *, struct device *, void *));
struct cfdriver tgcd =
   { NULL, "tg", scsi_targmatch, scsi_targattach,
     DV_DULL, sizeof(struct targ) };

void    scsi_targstart __P((struct device *, struct sq *, struct buf *,
                       scdgo_fn, struct device *));
int     scsi_targgo __P((struct device *, int targ,
                       scintr_fn, struct device *, struct buf *, int));
void    scsi_targintr __P((struct device *, int, int));
void    scsi_targrel __P((struct device *));

#define NOBUF   ((caddr_t)0)

/*
* Perform a TEST UNIT READY immediate (polled) command
* on the given <target,unit> pair.  Return the status byte
* returned, or -1 for none.
*/
int
scsi_test_unit_ready(hba, targ, unit)
       struct hba_softc *hba;
       int targ, unit;
{
       struct scsi_cdb cdb;

       CDB6(&cdb)->cdb_cmd = CMD_TEST_UNIT_READY;
       CDB6(&cdb)->cdb_lun_lbah = unit << 5;
       *(short *)&CDB6(&cdb)->cdb_lbam = 0;
       *(short *)&CDB6(&cdb)->cdb_len = 0;
       return (hba->hba_driver->hd_icmd(hba, targ, &cdb, NOBUF, 0, 0));
}

/*
* Request sense.  The sense is to be written into the given buffer.
* The given length must be < 256.
*/
int
scsi_request_sense(hba, targ, unit, buf, len)
       struct hba_softc *hba;
       int targ, unit;
       caddr_t buf;
       int len;
{
       struct scsi_cdb cdb;

       CDB6(&cdb)->cdb_cmd = CMD_REQUEST_SENSE;
       CDB6(&cdb)->cdb_lun_lbah = unit << 5;
       *(short *)&CDB6(&cdb)->cdb_lbam = 0;
       CDB6(&cdb)->cdb_len = len;
       CDB6(&cdb)->cdb_ctrl = 0;
       return (hba->hba_driver->hd_icmd(hba, targ, &cdb, buf, len, B_READ));
}

/*
* Called (indirectly, via config_found) from scsi_hbaattach.
* Print target number, and if no device was configured there,
* the hba as well.
*/
int
scsi_targprint(aux, hba)
       void *aux;
       char *hba;
{

       if (hba) {
               printf("target %d on %s", *(int *)aux, hba);
               return (UNCONF);
       }
       printf(" target %d", *(int *)aux);
       return (QUIET);
}

/*
* Print information about a unit found on some target.
* If the unit was not configured, `targ' is the name of the target
* on which the unit was found.  If it was, targ is NULL and we
* let the unit's attach routine print the INQUIRE result if
* appropriate.
*/
static int
scsi_unitprint(aux, targ)
       void *aux;
       char *targ;
{
       register struct scsi_attach_args *sa = aux;

       if (targ) {
               printf("unit %d at %s", sa->sa_unit, targ);
               if ((sa->sa_inq_status & STS_MASK) == STS_GOOD) {
                       printf(" (");
                       scsi_printinq(&sa->sa_si);
                       printf(")");
               }
               return (UNCONF);
       }
       printf(" unit %d", sa->sa_unit);
       return (QUIET);
}

/*
* Generic target-match.
*/
static int
scsi_targmatch(parent, cf, aux)
       struct device *parent;
       register struct cfdata *cf;
       void *aux;
{
       int targ = *(int *)aux;

       return (cf->cf_loc[0] == targ || cf->cf_loc[0] == -1);
}

/*
* And now, a generic `target attach' routine.
* We assume that INQUIRY works.
*/
static void
scsi_targattach(parent, self, aux)
       struct device *parent, *self;
       void *aux;
{
       register struct targ *t = (struct targ *)self;
       register struct hba_softc *hba;
       register struct hbadriver *hd;
       register int targ, unit;
       struct scsi_attach_args sa;
       struct scsi_cdb si;

       printf("\n");
       t->t_targ = targ = *(int *)aux;
       hba = (struct hba_softc *)parent;
       hba->hba_targets[targ] = t;

       /*
        * Probe each of the 8 units using the sequence
        *      TEST UNIT READY
        *      REQUEST SENSE
        *      INQUIRY
        * The first should not be necessary, but some SCSI devices
        * refuse to speak until it is done.  The second is only necessary
        * if the first returns a CHECK CONDITION status, but we do it
        * anyway.
        */
       hd = hba->hba_driver;
       sa.sa_targ = targ;
       CDB6(&si)->cdb_cmd = CMD_INQUIRY;
       *(short *)&CDB6(&si)->cdb_lbam = 0;
       CDB6(&si)->cdb_len = sizeof sa.sa_si;
       CDB6(&si)->cdb_ctrl = 0;
       for (unit = 0; unit < 8; unit++) {
               if (scsi_test_unit_ready(hba, targ, unit) == -1)
                       continue;
               sa.sa_unit = unit;
               sa.sa_req_status = scsi_request_sense(hba, targ, unit,
                   (caddr_t)&sa.sa_sn, sizeof sa.sa_sn);
               CDB6(&si)->cdb_lun_lbah = unit << 5;
               sa.sa_inq_status = (*hd->hd_icmd)(hba, targ, &si,
                   (caddr_t)&sa.sa_si, sizeof sa.sa_si, B_READ);
               if ((sa.sa_inq_status & STS_MASK) == STS_GOOD &&
#ifdef notdef /* XXX don't know if this is a reasonable test */
                   (sa.sa_si.si_type & TYPE_QUAL_MASK) == TYPE_QUAL_NOTCONN &&
#endif
                   (sa.sa_si.si_type & TYPE_TYPE_MASK) == TYPE_NP) {
                       continue;
               }
               config_found(&t->t_dev, (void *)&sa, scsi_unitprint);
       }
}

/*
* Each unit calls scsi_establish to tell the hba and target of
* its existence.
*/
void
scsi_establish(u, dev, unit)
       register struct unit *u;
       struct device *dev;
       register int unit;
{
       register struct targ *t;
       register struct hba_softc *hba;
       register struct hbadriver *hbd;

       u->u_dev = dev;
       t = (struct targ *)dev->dv_parent;
       hba = (struct hba_softc *)t->t_dev.dv_parent;
       hbd = hba->hba_driver;
       t->t_units[unit] = u;
       if (t->t_nunits == 0) {
               /*
                * This is the first unit on the target.  We can
                * probably just call the hba start code, avoiding
                * one level of calls and queueing.  If we attach
                * another target we will fix this in the code below.
                */
               u->u_start = hbd->hd_start;
               u->u_go = hbd->hd_go;
               u->u_rel = hbd->hd_rel;
               u->u_updev = &hba->hba_dev;
               t->t_firstunit = unit;
       } else {
               /*
                * This is not the only unit on the target, so we
                * must call the target start code rather than the
                * hba start code.  Fix the linkage on the first
                * target too (possibly for the 2nd, 3rd, ..., time).
                */
               t->t_units[t->t_firstunit]->u_start = scsi_targstart;
               t->t_units[t->t_firstunit]->u_go = scsi_targgo;
               t->t_units[t->t_firstunit]->u_rel = scsi_targrel;
               t->t_units[t->t_firstunit]->u_updev = &t->t_dev;
               u->u_start = scsi_targstart;
               u->u_go = scsi_targgo;
               u->u_rel = scsi_targrel;
               u->u_updev = &t->t_dev;
       }
       t->t_nunits++;                  /* another unit is alive */
       u->u_unit = unit;
       u->u_targ = t->t_targ;          /* record target number, */
       u->u_hba = hba;                 /* hba ... */
       u->u_hbd = hbd;                 /* and driver */
}

/* NO DOUBT SOME OF THE STUFF PRINTED HERE IS USELESS */
void
scsi_printinq(inq)
       register struct scsi_inquiry *inq;
{
       register int iso, ecma, ansi, t;
       static char *types[] = { "disk", "tape", "printer", "processor",
           "WORM", "ROM disk", "scanner", "magneto-optical",
           "jukebox", "lan" };

       if ((t = (inq->si_type & TYPE_QUAL_MASK)) != 0)
               printf("type-qual=0x%x ", t);
       t = inq->si_type & TYPE_TYPE_MASK;
       if (t < sizeof types / sizeof *types)
               printf("%s", types[t]);
       else
               printf("<type %d>", t);
       if (inq->si_qual & QUAL_RMB)
               printf(" (removable)");
       printf(" qual=0x%x", inq->si_qual & QUAL_MASK);
       iso = (inq->si_qual >> VER_ISO_SHIFT) & VER_ISO_MASK;
       ecma = (inq->si_qual >> VER_ECMA_SHIFT) & VER_ECMA_MASK;
       ansi = (inq->si_qual >> VER_ANSI_SHIFT) & VER_ANSI_MASK;
       printf(" version=<iso %d, ecma %d, ansi %d>", iso, ecma, ansi);
       if (ansi == 1 || ansi == 2) {
               char v[9], p[17], r[5];

               scsi_inq_ansi((struct scsi_inq_ansi *)inq, v, p, r);
               printf(" vendor %s, product %s, rev %s", v, p, r);
       }
}

/* copy a counted string but trim trailing blanks; make the dest a C string */
static void
scsi_str(src, dst, len)
       register char *src, *dst;
       register int len;
{

       while (src[len - 1] == ' ') {
               if (--len == 0) {
                       *dst = 0;
                       return;
               }
       }
       bcopy(src, dst, len);
       dst[len] = 0;
}

void
scsi_inq_ansi(si, vendor, product, rev)
       register struct scsi_inq_ansi *si;
       char *vendor, *product, *rev;
{
       register int i, len;

       /* if too short, extend with blanks */
       len = si->si_len + 5;   /* 5 fixed; len is `additional' */
       if (len < sizeof(*si))
               for (i = len; i < sizeof *si; i++)
                       ((char *)si)[i] = ' ';
       scsi_str(si->si_vendor, vendor, sizeof si->si_vendor);
       scsi_str(si->si_product, product, sizeof si->si_product);
       scsi_str(si->si_rev, rev, sizeof si->si_rev);
}

/*
* Tell all the devices on the given hba that it has been reset.
* SHOULD PROBABLY DO MORE HERE
*/
void
scsi_reset_units(hba)
       register struct hba_softc *hba;
{
       register int targ, unit;
       register struct targ *t;
       register struct unit *u;

       for (targ = 0; targ < 8; targ++) {
               if ((t = hba->hba_targets[targ]) == NULL)
                       continue;
               for (unit = 0; unit < 8; unit++)
                       if ((u = t->t_units[unit]) != NULL)
                               (*u->u_driver->ud_reset)(u);
       }
}

/*
* Start a unit on a target.
* If the target is busy, just enqueue the unit;
* once the target becomes free, we will call the hba start routine.
* Otherwise, call the hba start routine now, and then when the hba
* becomes free it will call the unit's dgo routine.
*/
void
scsi_targstart(self, sq, bp, dgo, dev)
       struct device *self;
       register struct sq *sq;
       struct buf *bp;
       scdgo_fn dgo;
       struct device *dev;
{
       register struct targ *t = (struct targ *)self;
       register struct hba_softc *hba;

       sq->sq_forw = NULL;
       if (t->t_head == NULL)
               t->t_head = sq;
       else
               t->t_tail->sq_forw = sq;
       t->t_tail = sq;
       if (t->t_busy == 0) {
               t->t_busy = 1;
               hba = (struct hba_softc *)t->t_dev.dv_parent;
               (*hba->hba_driver->hd_start)(&hba->hba_dev, &t->t_forw, bp,
                   dgo, dev);
       } else {
               sq->sq_bp = bp;
               sq->sq_dgo = dgo;
               sq->sq_dev = dev;
       }
}

/*
* The unit got the bus, and wants the hba to go.
* Remember its interrupt handler; substitute ours instead.
*/
int
scsi_targgo(self, targ, intr, dev, bp, pad)
       struct device *self;
       int targ;
       scintr_fn intr;
       struct device *dev;
       struct buf *bp;
       int pad;
{
       register struct targ *t = (struct targ *)self;
       register struct hba_softc *hba;

       t->t_intr = intr;
       t->t_intrdev = dev;
       hba = (struct hba_softc *)t->t_dev.dv_parent;
       return ((*hba->hba_driver->hd_go)(&hba->hba_dev, targ,
           scsi_targintr, &t->t_dev, bp, pad));
}

/*
* The hba got an interrupt.  Dequeue the unit from the target
* (the target is already off the hba queue) and then call the
* underlying interrupt handler.
*/
void
scsi_targintr(self, stat, resid)
       struct device *self;
       int stat, resid;
{
       register struct targ *t = (struct targ *)self;
       register struct hba_softc *hba;
       register struct sq *sq;

       sq = t->t_head;
if (sq == NULL) panic("scsi_targintr");
       t->t_head = sq = sq->sq_forw;
       (*t->t_intr)(t->t_intrdev, stat, resid);
       if (sq != NULL) {
               hba = (struct hba_softc *)t->t_dev.dv_parent;
               (*hba->hba_driver->hd_start)(&hba->hba_dev, &t->t_forw,
                   sq->sq_bp, sq->sq_dgo, sq->sq_dev);
       } else
               t->t_busy = 0;
}

/*
* The unit decided that it needed to `give up' its hold on the bus early.
*/
void
scsi_targrel(self)
       struct device *self;
{
       register struct targ *t = (struct targ *)self;
       register struct hba_softc *hba;
       register struct sq *sq;

       hba = (struct hba_softc *)t->t_dev.dv_parent;
       sq = t->t_head;
if (sq == NULL) panic("scsi_targrel");
       /*
        * This target is at the head of the hba queue.
        * Remove it by calling hba bus release.  Then, if the
        * target queue is not empty, put it back on the hba queue.
        * (This produces round robin service.)
        */
       (*hba->hba_driver->hd_rel)(&hba->hba_dev);
       sq = sq->sq_forw;
       if ((t->t_head = sq) != NULL)
               (*hba->hba_driver->hd_start)(&hba->hba_dev, &t->t_forw,
                   sq->sq_bp, sq->sq_dgo, sq->sq_dev);
       else
               t->t_busy = 0;
}