root/dev/i2o/iopsp.c

DEFINITIONS

1. iopsp_match
2. iopsp_attach
3. iopsp_reconfig
4. iopsp_rescan
5. iopspminphys
6. iopsp_scsi_cmd
7. iopsp_scsi_abort
8. iopsp_intr
9. iopsp_adjqparam

    1 /*      $OpenBSD: iopsp.c,v 1.9 2006/11/28 23:59:45 dlg Exp $   */
    2 /*      $NetBSD$        */
    4 /*-
    5  * Copyright (c) 2000, 2001 The NetBSD Foundation, Inc.
    6  * All rights reserved.
    7  *
    8  * This code is derived from software contributed to The NetBSD Foundation
    9  * by Andrew Doran.
   10  *
   11  * Redistribution and use in source and binary forms, with or without
   12  * modification, are permitted provided that the following conditions
   13  * are met:
   14  * 1. Redistributions of source code must retain the above copyright
   15  *    notice, this list of conditions and the following disclaimer.
   16  * 2. Redistributions in binary form must reproduce the above copyright
   17  *    notice, this list of conditions and the following disclaimer in the
   18  *    documentation and/or other materials provided with the distribution.
   19  * 3. All advertising materials mentioning features or use of this software
   20  *    must display the following acknowledgement:
   21  *        This product includes software developed by the NetBSD
   22  *        Foundation, Inc. and its contributors.
   23  * 4. Neither the name of The NetBSD Foundation nor the names of its
   24  *    contributors may be used to endorse or promote products derived
   25  *    from this software without specific prior written permission.
   26  *
   27  * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
   28  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
   29  * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
   30  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
   31  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
   32  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
   33  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
   34  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
   35  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
   36  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
   37  * POSSIBILITY OF SUCH DAMAGE.
   38  */
   40 /*
   41  * Raw SCSI device support for I2O.  IOPs present SCSI devices individually;
   42  * we group them by controlling port.
   43  */
   45 #include <sys/param.h>
   46 #include <sys/systm.h>
   47 #include <sys/kernel.h>
   48 #include <sys/device.h>
   49 #include <sys/queue.h>
   50 #include <sys/proc.h>
   51 #include <sys/buf.h>
   52 #include <sys/endian.h>
   53 #include <sys/malloc.h>
   54 #include <sys/scsiio.h>
   55 #include <sys/lock.h>
   57 #include <machine/bus.h>
   59 #include <scsi/scsi_all.h>
   60 #include <scsi/scsi_disk.h>
   61 #include <scsi/scsi_all.h>
   62 #include <scsi/scsiconf.h>
   63 #include <scsi/scsi_message.h>
   65 #include <dev/i2o/i2o.h>
   66 #include <dev/i2o/iopio.h>
   67 #include <dev/i2o/iopvar.h>
   68 #include <dev/i2o/iopspvar.h>
   70 struct cfdriver iopsp_cd = {
NULL, "iopsp", DV_DULL
   72 };
   74 int     iopsp_match(struct device *, void *, void *);
   75 void    iopsp_attach(struct device *, struct device *, void *);
   77 struct cfattach iopsp_ca = {
   78         sizeof(struct iopsp_softc), iopsp_match, iopsp_attach
   79 };
   81 int     iopsp_scsi_cmd(struct scsi_xfer *);
   82 void    iopspminphys(struct buf *bp);
   84 struct scsi_adapter iopsp_switch = {
iopsp_scsi_cmd, iopspminphys, 0, 0,
   86 };
   88 struct scsi_device iopsp_dev = {
NULL, NULL, NULL, NULL
   90 };
   92 void    iopsp_adjqparam(struct device *, int);
   93 void    iopsp_intr(struct device *, struct iop_msg *, void *);
   94 int     iopsp_rescan(struct iopsp_softc *);
   95 int     iopsp_reconfig(struct device *);
   97 /*
   98  * Match a supported device.
   99  */
  100 int
iopsp_match(struct device *parent, void *match, void *aux)
  102 {
  103         struct iop_attach_args *ia = aux;
  104         struct {
  105                 struct  i2o_param_op_results pr;
  106                 struct  i2o_param_read_results prr;
  107                 struct  i2o_param_hba_ctlr_info ci;
  108         } __attribute__ ((__packed__)) param;
  109         int rv;
  111         if (ia->ia_class != I2O_CLASS_BUS_ADAPTER_PORT)
  112                 return (0);
  114         if ((rv = iop_param_op((struct iop_softc *)parent, ia->ia_tid, NULL, 0,
I2O_PARAM_HBA_CTLR_INFO, &param, sizeof(param)))) {
  116 #ifdef I2ODEBUG
printf("iopsp_match: iop_param_op failed, status = %d\n", rv);
  118 #endif
  119                 return (0);
  120         }
  122 #ifdef I2ODEBUG
printf("iopsp_match: bustype = %d\n", param.ci.bustype);
  124 #endif
  126         return (param.ci.bustype == I2O_HBA_BUS_SCSI ||
param.ci.bustype == I2O_HBA_BUS_FCA);
  128 }
  130 /*
  131  * Attach a supported device.
  132  */
  133 void
iopsp_attach(struct device *parent, struct device *self, void *aux)
  135 {
  136         struct iop_softc *iop = (struct iop_softc *)parent;
  137         struct iopsp_softc *sc = (struct iopsp_softc *)self;
  138         struct iop_attach_args *ia = (struct iop_attach_args *)aux;
  139         struct scsibus_attach_args saa;
  140         struct {
  141                 struct  i2o_param_op_results pr;
  142                 struct  i2o_param_read_results prr;
  143                 union {
  144                         struct  i2o_param_hba_ctlr_info ci;
  145                         struct  i2o_param_hba_scsi_ctlr_info sci;
  146                         struct  i2o_param_hba_scsi_port_info spi;
  147                 } p;
  148         } __attribute__ ((__packed__)) param;
  149         int fcal, rv;
  150 #ifdef I2OVERBOSE
  151         int size;
  152 #endif
  154         /* Register us as an initiator. */
sc->sc_ii.ii_dv = self;
sc->sc_ii.ii_intr = iopsp_intr;
sc->sc_ii.ii_flags = 0;
sc->sc_ii.ii_tid = ia->ia_tid;
sc->sc_ii.ii_reconfig = iopsp_reconfig;
sc->sc_ii.ii_adjqparam = iopsp_adjqparam;
iop_initiator_register(iop, &sc->sc_ii);
rv = iop_param_op(iop, ia->ia_tid, NULL, 0, I2O_PARAM_HBA_CTLR_INFO,
  164             &param, sizeof(param));
  165         if (rv != 0) {
printf("%s: unable to get parameters (0x%04x; %d)\n",
sc->sc_dv.dv_xname, I2O_PARAM_HBA_CTLR_INFO, rv);
  168                 goto bad;
  169         }
fcal = (param.p.ci.bustype == I2O_HBA_BUS_FCA);         /* XXX */
  173         /* 
  174          * Say what the device is.  If we can find out what the controling
  175          * device is, say what that is too.
  176          */
printf(": SCSI port");
iop_print_ident(iop, ia->ia_tid);
printf("\n");
rv = iop_param_op(iop, ia->ia_tid, NULL, 0,
I2O_PARAM_HBA_SCSI_CTLR_INFO, &param, sizeof(param));
  183         if (rv != 0) {
printf("%s: unable to get parameters (0x%04x; %d)\n",
sc->sc_dv.dv_xname, I2O_PARAM_HBA_SCSI_CTLR_INFO, rv);
  186                 goto bad;
  187         }
  189 #ifdef I2OVERBOSE
printf("%s: %d-bit, max sync rate %dMHz, initiator ID %d\n",
sc->sc_dv.dv_xname, param.p.sci.maxdatawidth,
  192             (u_int32_t)letoh64(param.p.sci.maxsyncrate) / 1000,
letoh32(param.p.sci.initiatorid));
  194 #endif
sc->sc_link.adapter_softc = sc;
sc->sc_link.adapter = &iopsp_switch;
sc->sc_link.adapter_target = letoh32(param.p.sci.initiatorid);
sc->sc_link.device = &iopsp_dev;
sc->sc_link.openings = 1;
sc->sc_link.adapter_buswidth = fcal?
IOPSP_MAX_FCAL_TARGET : param.p.sci.maxdatawidth;
sc->sc_link.luns = IOPSP_MAX_LUN;
  205 #ifdef I2OVERBOSE
  206         /*
  207          * Allocate the target map.  Currently used for informational
  208          * purposes only.
  209          */
size = sc->sc_link.adapter_buswidth * sizeof(struct iopsp_target);
sc->sc_targetmap = malloc(size, M_DEVBUF, M_NOWAIT);
bzero(sc->sc_targetmap, size);
  213 #endif
  215         /* Build the two maps, and attach to scsi. */
  216         if (iopsp_reconfig(self) != 0) {
printf("%s: configure failed\n", sc->sc_dv.dv_xname);
  218                 goto bad;
  219         }
bzero(&saa, sizeof(saa));
saa.saa_sc_link = &sc->sc_link;
config_found(&sc->sc_dv, &saa, scsiprint);
  225         return;
bad:
iop_initiator_unregister(iop, &sc->sc_ii);
  229 }
  231 /*
  232  * Scan the LCT to determine which devices we control, and enter them into
  233  * the maps.
  234  */
  235 int
iopsp_reconfig(struct device *dv)
  237 {
  238         struct iopsp_softc *sc = (struct iopsp_softc *)dv;
  239         struct iop_softc *iop = (struct iop_softc *)sc->sc_dv.dv_parent;
  240         struct i2o_lct_entry *le;
  241         struct {
  242                 struct  i2o_param_op_results pr;
  243                 struct  i2o_param_read_results prr;
  244                 struct  i2o_param_scsi_device_info sdi;
  245         } __attribute__ ((__packed__)) param;
u_int tid, nent, i, targ, lun, size, s, rv, bptid;
u_short *tidmap;
  248 #ifdef I2OVERBOSE
  249         struct iopsp_target *it;
  250         int syncrate;   
  251 #endif
  253         /* Anything to do? */
  254         if (iop->sc_chgind == sc->sc_chgind)
  255                 return (0);
  257         /*
  258          * Allocate memory for the target/LUN -> TID map.  Use zero to
  259          * denote absent targets (zero is the TID of the I2O executive,
  260          * and we never address that here).
  261          */
size = sc->sc_link.adapter_buswidth * IOPSP_MAX_LUN * sizeof(u_short);
  263         if (!(tidmap = malloc(size, M_DEVBUF, M_NOWAIT)))
  264                 return (ENOMEM);
bzero(tidmap, size);
  267 #ifdef I2OVERBOSE
  268         for (i = 0; i < sc->sc_link.adapter_buswidth; i++)
sc->sc_targetmap[i].it_flags &= ~IT_PRESENT;
  270 #endif
  272         /*
  273          * A quick hack to handle Intel's stacked bus port arrangement.
  274          */
bptid = sc->sc_ii.ii_tid;
nent = iop->sc_nlctent;
  277         for (le = iop->sc_lct->entry; nent != 0; nent--, le++)
  278                 if ((letoh16(le->classid) & 4095) ==
I2O_CLASS_BUS_ADAPTER_PORT &&
  280                     (letoh32(le->usertid) & 4095) == bptid) {
bptid = letoh16(le->localtid) & 4095;
  282                         break;
  283                 }
nent = iop->sc_nlctent;
  286         for (i = 0, le = iop->sc_lct->entry; i < nent; i++, le++) {
  287                 if ((letoh16(le->classid) & I2O_CLASS_MASK) !=
I2O_CLASS_SCSI_PERIPHERAL ||
  289                     ((letoh32(le->usertid) >> 12) & 4095) != bptid)
  290                         continue;
tid = letoh16(le->localtid) & I2O_LCT_ENTRY_TID_MASK;
rv = iop_param_op(iop, tid, NULL, 0, I2O_PARAM_SCSI_DEVICE_INFO,
  294                     &param, sizeof(param));
  295                 if (rv != 0) {
printf("%s: unable to get parameters (0x%04x; %d)\n",
sc->sc_dv.dv_xname, I2O_PARAM_SCSI_DEVICE_INFO,
rv);
  299                         continue;
  300                 }
targ = letoh32(param.sdi.identifier);
lun = param.sdi.luninfo[1];
  303 #if defined(DIAGNOSTIC) || defined(I2ODEBUG)
  304                 if (targ >= sc->sc_link.adapter_buswidth ||
lun >= sc->sc_link.adapter_buswidth) {
printf("%s: target %d,%d (tid %d): bad target/LUN\n",
sc->sc_dv.dv_xname, targ, lun, tid);
  308                         continue;
  309                 }
  310 #endif
  312 #ifdef I2OVERBOSE
  313                 /*
  314                  * If we've already described this target, and nothing has
  315                  * changed, then don't describe it again.
  316                  */
it = &sc->sc_targetmap[targ];
it->it_flags |= IT_PRESENT;
syncrate = (int)((letoh64(param.sdi.negsyncrate) + 500) / 1000);
  320                 if (it->it_width == param.sdi.negdatawidth &&
it->it_offset == param.sdi.negoffset &&
it->it_syncrate == syncrate)
  323                         continue;
it->it_width = param.sdi.negdatawidth;
it->it_offset = param.sdi.negoffset;
it->it_syncrate = syncrate;
printf("%s: target %d (tid %d): %d-bit, ", sc->sc_dv.dv_xname,
targ, tid, it->it_width);
  331                 if (it->it_syncrate == 0)
printf("asynchronous\n");
  333                 else
printf("synchronous at %dMHz, offset 0x%x\n",
it->it_syncrate, it->it_offset);
  336 #endif
  338                 /* Ignore the device if it's in use by somebody else. */
  339                 if ((letoh32(le->usertid) & 4095) != I2O_TID_NONE) {
  340 #ifdef I2OVERBOSE
  341                         if (sc->sc_tidmap == NULL ||
IOPSP_TIDMAP(sc->sc_tidmap, targ, lun) !=
IOPSP_TID_INUSE)
printf("%s: target %d,%d (tid %d): in use by"
  345                                     " tid %d\n", sc->sc_dv.dv_xname,
targ, lun, tid,
letoh32(le->usertid) & 4095);
  348 #endif
IOPSP_TIDMAP(tidmap, targ, lun) = IOPSP_TID_INUSE;
  350                 } else
IOPSP_TIDMAP(tidmap, targ, lun) = (u_short)tid;
  352         }
  354 #ifdef I2OVERBOSE
  355         for (i = 0; i < sc->sc_link.adapter_buswidth; i++)
  356                 if ((sc->sc_targetmap[i].it_flags & IT_PRESENT) == 0)
sc->sc_targetmap[i].it_width = 0;
  358 #endif
  360         /* Swap in the new map and return. */
s = splbio();
  362         if (sc->sc_tidmap != NULL)
free(sc->sc_tidmap, M_DEVBUF);
sc->sc_tidmap = tidmap;
splx(s);
sc->sc_chgind = iop->sc_chgind;
  367         return (0);
  368 }
  370 /*
  371  * Re-scan the bus; to be called from a higher level (e.g. scsi).
  372  */
  373 int
iopsp_rescan(struct iopsp_softc *sc)
  375 {
  376         struct iop_softc *iop;
  377         struct iop_msg *im;
  378         struct i2o_hba_bus_scan mf;
  379         int rv;
iop = (struct iop_softc *)sc->sc_dv.dv_parent;
rv = lockmgr(&iop->sc_conflock, LK_EXCLUSIVE, NULL);
  384         if (rv != 0) {
  385 #ifdef I2ODEBUG
printf("iopsp_rescan: unable to acquire lock\n");
  387 #endif
  388                 return (rv);
  389         }
im = iop_msg_alloc(iop, &sc->sc_ii, IM_WAIT);
mf.msgflags = I2O_MSGFLAGS(i2o_hba_bus_scan);
mf.msgfunc = I2O_MSGFUNC(sc->sc_ii.ii_tid, I2O_HBA_BUS_SCAN);
mf.msgictx = sc->sc_ii.ii_ictx;
mf.msgtctx = im->im_tctx;
rv = iop_msg_post(iop, im, &mf, 5*60*1000);
iop_msg_free(iop, im);
  400         if (rv != 0)
printf("%s: bus rescan failed (error %d)\n",
sc->sc_dv.dv_xname, rv);
  404         if ((rv = iop_lct_get(iop)) == 0)
rv = iopsp_reconfig(&sc->sc_dv);
lockmgr(&iop->sc_conflock, LK_RELEASE, NULL);
  408         return (rv);
  409 }
  411 void
iopspminphys(bp)
  413         struct buf *bp;
  414 {
  415         if (bp->b_bcount > IOP_MAX_XFER)
bp->b_bcount = IOP_MAX_XFER;
minphys(bp);
  418 }
  420 /*
  421  * Start a SCSI command.
  422  */
  423 int
iopsp_scsi_cmd(xs)
  425         struct scsi_xfer *xs;
  426 {
  427         struct scsi_link *link = xs->sc_link;
  428         struct iopsp_softc *sc = (struct iopsp_softc *)link->adapter_softc;
  429         struct iop_softc *iop = (struct iop_softc *)sc->sc_dv.dv_parent;
  430         struct iop_msg *im;
  431         struct i2o_scsi_scb_exec *mf;
  432         int error, tid, s;
u_int32_t mb[IOP_MAX_MSG_SIZE / sizeof(u_int32_t)];
tid = IOPSP_TIDMAP(sc->sc_tidmap, link->target, link->lun);
  436         if (tid == IOPSP_TID_ABSENT || tid == IOPSP_TID_INUSE) {
xs->error = XS_SELTIMEOUT;
scsi_done(xs);
  439                 return (COMPLETE);
  440         }
SC_DEBUG(xs->sc_link, SDEV_DB2, ("iopsp_scsi_cmd: run_xfer\n"));
  444         /* Need to reset the target? */
  445         if ((xs->flags & XS_RESET) != 0) {
  446                 if (iop_simple_cmd(iop, tid, I2O_SCSI_DEVICE_RESET,
sc->sc_ii.ii_ictx, 1, 30*1000) != 0) {
  448 #ifdef I2ODEBUG
printf("%s: reset failed\n",
sc->sc_dv.dv_xname);
  451 #endif
xs->error = XS_DRIVER_STUFFUP;
  453                 } else
xs->error = XS_NOERROR;
scsi_done(xs);
  457                 return (COMPLETE);
  458         }
  460 #if defined(I2ODEBUG) || defined(SCSIDEBUG)
  461         if (xs->cmdlen > sizeof(mf->cdb))
panic("%s: CDB too large", sc->sc_dv.dv_xname);
  463 #endif
im = iop_msg_alloc(iop, &sc->sc_ii, IM_POLL_INTR |
IM_NOSTATUS | ((xs->flags & SCSI_POLL) != 0 ? IM_POLL : 0));
im->im_dvcontext = xs;
mf = (struct i2o_scsi_scb_exec *)mb;
mf->msgflags = I2O_MSGFLAGS(i2o_scsi_scb_exec);
mf->msgfunc = I2O_MSGFUNC(tid, I2O_SCSI_SCB_EXEC);
mf->msgictx = sc->sc_ii.ii_ictx;
mf->msgtctx = im->im_tctx;
mf->flags = xs->cmdlen | I2O_SCB_FLAG_ENABLE_DISCONNECT |
I2O_SCB_FLAG_SENSE_DATA_IN_MESSAGE;
mf->datalen = xs->datalen;
memcpy(mf->cdb, xs->cmd, xs->cmdlen);
  479 #if 0
  480         switch (xs->xs_tag_type) {
  481         case MSG_ORDERED_Q_TAG:
mf->flags |= I2O_SCB_FLAG_ORDERED_QUEUE_TAG;
  483                 break;
  484         case MSG_SIMPLE_Q_TAG:
mf->flags |= I2O_SCB_FLAG_SIMPLE_QUEUE_TAG;
  486                 break;
  487         case MSG_HEAD_OF_Q_TAG:
mf->flags |= I2O_SCB_FLAG_HEAD_QUEUE_TAG;
  489                 break;
  490         default:
  491                 break;
  492         }
  493 #endif
  495         if (xs->datalen != 0) {
error = iop_msg_map_bio(iop, im, mb, xs->data,
xs->datalen, (xs->flags & SCSI_DATA_OUT) == 0);
  498                 if (error) {
xs->error = XS_DRIVER_STUFFUP;
iop_msg_free(iop, im);
scsi_done(xs);
  502                         return (COMPLETE);
  503                 }
  504                 if ((xs->flags & SCSI_DATA_IN) == 0)
mf->flags |= I2O_SCB_FLAG_XFER_TO_DEVICE;
  506                 else
mf->flags |= I2O_SCB_FLAG_XFER_FROM_DEVICE;
  508         }
s = splbio();
sc->sc_curqd++;
splx(s);
  514         if (iop_msg_post(iop, im, mb, xs->timeout)) {
s = splbio();
sc->sc_curqd--;
splx(s);
  518                 if (xs->datalen != 0)
iop_msg_unmap(iop, im);
iop_msg_free(iop, im);
xs->error = XS_DRIVER_STUFFUP;
scsi_done(xs);
  523                 return (COMPLETE);
  524         }
  526         return (xs->flags & SCSI_POLL? COMPLETE : SUCCESSFULLY_QUEUED);
  527 }
  529 #ifdef notyet
  530 /*
  531  * Abort the specified I2O_SCSI_SCB_EXEC message and its associated SCB.
  532  */
  533 int
  534 iopsp_scsi_abort(struct iopsp_softc *sc, int atid, struct iop_msg *aim)
  535 {
  536         struct iop_msg *im;
  537         struct i2o_scsi_scb_abort mf;
  538         struct iop_softc *iop;
  539         int rv, s;
iop = (struct iop_softc *)sc->sc_dv.dv_parent;
im = iop_msg_alloc(iop, &sc->sc_ii, IM_POLL);
mf.msgflags = I2O_MSGFLAGS(i2o_scsi_scb_abort);
mf.msgfunc = I2O_MSGFUNC(atid, I2O_SCSI_SCB_ABORT);
mf.msgictx = sc->sc_ii.ii_ictx;
mf.msgtctx = im->im_tctx;
mf.tctxabort = aim->im_tctx;
s = splbio();
rv = iop_msg_post(iop, im, &mf, 30000);
splx(s);
iop_msg_free(iop, im);
  554         return (rv);
  555 }
  556 #endif
  558 /*
  559  * We have a message which has been processed and replied to by the IOP -
  560  * deal with it.
  561  */
  562 void
iopsp_intr(struct device *dv, struct iop_msg *im, void *reply)
  564 {
  565         struct scsi_xfer *xs;
  566         struct iopsp_softc *sc;
  567         struct i2o_scsi_reply *rb;
  568         struct iop_softc *iop;
u_int sl;
sc = (struct iopsp_softc *)dv;
xs = (struct scsi_xfer *)im->im_dvcontext;
iop = (struct iop_softc *)dv->dv_parent;
rb = reply;
SC_DEBUG(xs->sc_link, SDEV_DB2, ("iopsp_intr\n"));
  578         if ((rb->msgflags & I2O_MSGFLAGS_FAIL) != 0) {
xs->error = XS_DRIVER_STUFFUP;
xs->resid = xs->datalen;
  581         } else {
  582                 if (rb->hbastatus != I2O_SCSI_DSC_SUCCESS) {
  583                         switch (rb->hbastatus) {
  584                         case I2O_SCSI_DSC_ADAPTER_BUSY:
  585                         case I2O_SCSI_DSC_SCSI_BUS_RESET:
  586                         case I2O_SCSI_DSC_BUS_BUSY:
xs->error = XS_BUSY;
  588                                 break;
  589                         case I2O_SCSI_DSC_SELECTION_TIMEOUT:
xs->error = XS_SELTIMEOUT;
  591                                 break;
  592                         case I2O_SCSI_DSC_COMMAND_TIMEOUT:
  593                         case I2O_SCSI_DSC_DEVICE_NOT_PRESENT:
  594                         case I2O_SCSI_DSC_LUN_INVALID:
  595                         case I2O_SCSI_DSC_SCSI_TID_INVALID:
xs->error = XS_TIMEOUT;
  597                                 break;
  598                         default:
xs->error = XS_DRIVER_STUFFUP;
  600                                 break;
  601                         }
printf("%s: HBA status 0x%02x\n", sc->sc_dv.dv_xname,
rb->hbastatus);
  604                 } else if (rb->scsistatus != SCSI_OK) {
  605                         switch (rb->scsistatus) {
  606                         case SCSI_CHECK:
xs->error = XS_SENSE;
sl = letoh32(rb->senselen);
  609                                 if (sl > sizeof(xs->sense))
sl = sizeof(xs->sense);
bcopy(rb->sense, &xs->sense, sl);
  612                                 break;
  613                         case SCSI_QUEUE_FULL:
  614                         case SCSI_BUSY:
xs->error = XS_BUSY;
  616                                 break;
  617                         default:
xs->error = XS_DRIVER_STUFFUP;
  619                                 break;
  620                         }
  621                 } else
xs->error = XS_NOERROR;
xs->resid = xs->datalen - letoh32(rb->datalen);
xs->status = rb->scsistatus;
  626         }
  628         /* Free the message wrapper and pass the news to scsi. */
  629         if (xs->datalen != 0)
iop_msg_unmap(iop, im);
iop_msg_free(iop, im);
  633         if (--sc->sc_curqd == sc->sc_link.openings)
wakeup(&sc->sc_curqd);
scsi_done(xs);
  637 }
  639 /*
  640  * The number of openings available to us has changed, so inform scsi.
  641  */
  642 void
iopsp_adjqparam(struct device *dv, int mpi)
  644 {
  645         struct iopsp_softc *sc = (struct iopsp_softc *)dv;
  646         int s;
s = splbio();
sc->sc_link.openings = mpi;
  650         if (mpi < sc->sc_curqd)
tsleep(&sc->sc_curqd, PWAIT, "iopspdrn", 0);
splx(s);
  653 }