root/dev/i2o/ioprbs.c

DEFINITIONS

1. ioprbs_match
2. ioprbs_attach
3. ioprbs_unconfig
4. ioprbs_scsi_cmd
5. ioprbsminphys
6. ioprbs_intr
7. ioprbs_intr_event
8. ioprbs_adjqparam
9. ioprbs_enqueue
10. ioprbs_dequeue
11. ioprbs_copy_internal_data
12. ioprbs_internal_cache_cmd
13. ioprbs_get_ccb
14. ioprbs_free_ccb
15. ioprbs_enqueue_ccb
16. ioprbs_start_ccbs
17. ioprbs_exec_ccb
18. ioprbs_start
19. ioprbs_timeout
20. ioprbs_watchdog

    1 /*      $OpenBSD: ioprbs.c,v 1.11 2006/11/28 23:59:45 dlg Exp $ */
    3 /*
    4  * Copyright (c) 2001 Niklas Hallqvist
    5  * All rights reserved.
    6  *
    7  * Redistribution and use in source and binary forms, with or without
    8  * modification, are permitted provided that the following conditions
    9  * are met:
   10  * 1. Redistributions of source code must retain the above copyright
   11  *    notice, this list of conditions and the following disclaimer.
   12  * 2. Redistributions in binary form must reproduce the above copyright
   13  *    notice, this list of conditions and the following disclaimer in the
   14  *    documentation and/or other materials provided with the distribution.
   15  *
   16  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
   17  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
   18  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
   19  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
   20  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
   21  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
   22  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
   23  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
   24  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
   25  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
   26  * SUCH DAMAGE.
   27  */
   29 /*-
   30  * Copyright (c) 2000, 2001 The NetBSD Foundation, Inc.
   31  * All rights reserved.
   32  *
   33  * This code is derived from software contributed to The NetBSD Foundation
   34  * by Andrew Doran.
   35  *
   36  * Redistribution and use in source and binary forms, with or without
   37  * modification, are permitted provided that the following conditions
   38  * are met:
   39  * 1. Redistributions of source code must retain the above copyright
   40  *    notice, this list of conditions and the following disclaimer.
   41  * 2. Redistributions in binary form must reproduce the above copyright
   42  *    notice, this list of conditions and the following disclaimer in the
   43  *    documentation and/or other materials provided with the distribution.
   44  * 3. All advertising materials mentioning features or use of this software
   45  *    must display the following acknowledgement:
   46  *        This product includes software developed by the NetBSD
   47  *        Foundation, Inc. and its contributors.
   48  * 4. Neither the name of The NetBSD Foundation nor the names of its
   49  *    contributors may be used to endorse or promote products derived
   50  *    from this software without specific prior written permission.
   51  *
   52  * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
   53  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
   54  * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
   55  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
   56  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
   57  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
   58  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
   59  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
   60  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
   61  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
   62  * POSSIBILITY OF SUCH DAMAGE.
   63  */
   65 /*
   66  * A driver for I2O "Random block storage" devices, like RAID.
   67  */
   69 /*
   70  * This driver would not have been written if it was not for the hardware
   71  * donation from pi.se.  I want to thank them for their support.  It also
   72  * had been much harder without Andrew Doran's work in NetBSD's ld_iop.c
   73  * driver, from which I have both gotten inspiration and actual code.
   74  * - Niklas Hallqvist
   75  */
   77 #include <sys/param.h>
   78 #include <sys/buf.h>
   79 #include <sys/device.h>
   80 #include <sys/kernel.h>
   81 #include <sys/proc.h>
   82 #include <sys/systm.h>
   84 #include <machine/bus.h>
   86 #include <scsi/scsi_all.h>
   87 #include <scsi/scsi_disk.h>
   88 #include <scsi/scsiconf.h>
   90 #include <dev/i2o/i2o.h>
   91 #include <dev/i2o/iopio.h>
   92 #include <dev/i2o/iopvar.h>
   93 #include <dev/i2o/ioprbsvar.h>
   95 #ifdef I2ODEBUG
   96 #define DPRINTF(x)      printf x
   97 #else
   98 #define DPRINTF(x)
   99 #endif
  101 void    ioprbsminphys(struct buf *);
  102 void    ioprbs_adjqparam(struct device *, int);
  103 void    ioprbs_attach(struct device *, struct device *, void *);
  104 void    ioprbs_copy_internal_data(struct scsi_xfer *, u_int8_t *,
size_t);
  106 struct scsi_xfer *ioprbs_dequeue(struct ioprbs_softc *);
  107 void    ioprbs_enqueue(struct ioprbs_softc *, struct scsi_xfer *, int);
  108 void    ioprbs_enqueue_ccb(struct ioprbs_softc *, struct ioprbs_ccb *);
  109 int     ioprbs_exec_ccb(struct ioprbs_ccb *);
  110 void    ioprbs_free_ccb(struct ioprbs_softc *, struct ioprbs_ccb *);
  111 struct ioprbs_ccb *ioprbs_get_ccb(struct ioprbs_softc *, int);
  112 void    ioprbs_internal_cache_cmd(struct scsi_xfer *);
  113 void    ioprbs_intr(struct device *, struct iop_msg *, void *);
  114 void    ioprbs_intr_event(struct device *, struct iop_msg *, void *);
  115 int     ioprbs_match(struct device *, void *, void *);
  116 int     ioprbs_scsi_cmd(struct scsi_xfer *);
  117 int     ioprbs_start(struct ioprbs_ccb *);
  118 void    ioprbs_start_ccbs(struct ioprbs_softc *);
  119 void    ioprbs_timeout(void *);
  120 void    ioprbs_unconfig(struct ioprbs_softc *, int);
  121 void    ioprbs_watchdog(void *);
  123 struct cfdriver ioprbs_cd = {
NULL, "ioprbs", DV_DULL
  125 };
  127 struct cfattach ioprbs_ca = {
  128         sizeof(struct ioprbs_softc), ioprbs_match, ioprbs_attach
  129 };
  131 struct scsi_adapter ioprbs_switch = {
ioprbs_scsi_cmd, ioprbsminphys, 0, 0,
  133 };
  135 struct scsi_device ioprbs_dev = {
NULL, NULL, NULL, NULL
  137 };
  139 #ifdef I2OVERBOSE
  140 static const char *const ioprbs_errors[] = { 
  141         "success", 
  142         "media error", 
  143         "access error",
  144         "device failure",
  145         "device not ready",
  146         "media not present",
  147         "media locked",
  148         "media failure",
  149         "protocol failure",
  150         "bus failure",
  151         "access violation",
  152         "media write protected",
  153         "device reset",
  154         "volume changed, waiting for acknowledgement",
  155         "timeout",
  156 };
  157 #endif
  159 /*
  160  * Match a supported device.
  161  */
  162 int
ioprbs_match(parent, match, aux)
  164         struct device *parent;
  165         void *match;
  166         void *aux;
  167 {
  168         struct iop_attach_args *ia = aux;
  170         return (ia->ia_class == I2O_CLASS_RANDOM_BLOCK_STORAGE);
  171 }
  173 /*
  174  * Attach a supported device.
  175  */
  176 void
ioprbs_attach(struct device *parent, struct device *self, void *aux)
  178 {
  179         struct iop_attach_args *ia = aux;
  180         struct ioprbs_softc *sc = (struct ioprbs_softc *)self;
  181         struct iop_softc *iop = (struct iop_softc *)parent;
  182         struct scsibus_attach_args saa;
  183         int rv, state = 0;
  184         int enable;
u_int32_t cachesz;
  186         char *typestr, *fixedstr;
  187         struct {
  188                 struct  i2o_param_op_results pr;
  189                 struct  i2o_param_read_results prr;
  190                 union {
  191                         struct  i2o_param_rbs_cache_control cc;
  192                         struct  i2o_param_rbs_device_info bdi;
  193                         struct  i2o_param_rbs_operation op;
  194                 } p;
  195         } param /* XXX gcc __attribute__ ((__packed__)) */;
  196         int i;
TAILQ_INIT(&sc->sc_free_ccb);
TAILQ_INIT(&sc->sc_ccbq);
LIST_INIT(&sc->sc_queue);
  202         /* Initialize the ccbs */
  203         for (i = 0; i < IOPRBS_MAX_CCBS; i++)
TAILQ_INSERT_TAIL(&sc->sc_free_ccb, &sc->sc_ccbs[i],
ic_chain);
  207         /* Register us as an initiator. */
sc->sc_ii.ii_dv = self;
sc->sc_ii.ii_intr = ioprbs_intr;
sc->sc_ii.ii_adjqparam = ioprbs_adjqparam;
sc->sc_ii.ii_flags = 0;
sc->sc_ii.ii_tid = ia->ia_tid;
iop_initiator_register(iop, &sc->sc_ii);
  215         /* Register another initiator to handle events from the device. */
sc->sc_eventii.ii_dv = self;
sc->sc_eventii.ii_intr = ioprbs_intr_event;
sc->sc_eventii.ii_flags = II_DISCARD | II_UTILITY;
sc->sc_eventii.ii_tid = ia->ia_tid;
iop_initiator_register(iop, &sc->sc_eventii);
rv = iop_util_eventreg(iop, &sc->sc_eventii,
I2O_EVENT_GEN_EVENT_MASK_MODIFIED | I2O_EVENT_GEN_DEVICE_RESET |
I2O_EVENT_GEN_STATE_CHANGE | I2O_EVENT_GEN_GENERAL_WARNING);
  225         if (rv != 0) {
printf("%s: unable to register for events", self->dv_xname);
  227                 goto bad;
  228         }
state++;
  231         /*
  232          * Start out with one queued command.  The `iop' driver will adjust
  233          * the queue parameters once we're up and running.
  234          */
sc->sc_maxqueuecnt = 1;
sc->sc_maxxfer = IOP_MAX_XFER;
  239         /* Say what the device is. */
printf(":");
iop_print_ident(iop, ia->ia_tid);
  243         /*
  244          * Claim the device so that we don't get any nasty surprises.  Allow
  245          * failure.
  246          */
rv = iop_util_claim(iop, &sc->sc_ii, 0,
I2O_UTIL_CLAIM_CAPACITY_SENSITIVE |
I2O_UTIL_CLAIM_NO_PEER_SERVICE |
I2O_UTIL_CLAIM_NO_MANAGEMENT_SERVICE |
I2O_UTIL_CLAIM_PRIMARY_USER);
sc->sc_flags = rv ? 0 : IOPRBS_CLAIMED;
rv = iop_param_op(iop, ia->ia_tid, NULL, 0, I2O_PARAM_RBS_DEVICE_INFO,
  255             &param, sizeof param);
  256         if (rv != 0) {
printf("%s: unable to get parameters (0x%04x; %d)\n",
sc->sc_dv.dv_xname, I2O_PARAM_RBS_DEVICE_INFO, rv);
  259                 goto bad;
  260         }
sc->sc_secsize = letoh32(param.p.bdi.blocksize);
sc->sc_secperunit = (int)
  264             (letoh64(param.p.bdi.capacity) / sc->sc_secsize);
  266         switch (param.p.bdi.type) {
  267         case I2O_RBS_TYPE_DIRECT:
typestr = "direct access";
enable = 1;
  270                 break;
  271         case I2O_RBS_TYPE_WORM:
typestr = "WORM";
enable = 0;
  274                 break;
  275         case I2O_RBS_TYPE_CDROM:
typestr = "CD-ROM";
enable = 0;
  278                 break;
  279         case I2O_RBS_TYPE_OPTICAL:
typestr = "optical";
enable = 0;
  282                 break;
  283         default:
typestr = "unknown";
enable = 0;
  286                 break;
  287         }
  289         if ((letoh32(param.p.bdi.capabilities) & I2O_RBS_CAP_REMOVABLE_MEDIA)
  290             != 0) {
  291                 /* sc->sc_flags = IOPRBS_REMOVABLE; */
fixedstr = "removable";
enable = 0;
  294         } else
fixedstr = "fixed";
printf(" %s, %s", typestr, fixedstr);
  299         /*
  300          * Determine if the device has an private cache.  If so, print the
  301          * cache size.  Even if the device doesn't appear to have a cache,
  302          * we perform a flush at shutdown.
  303          */
rv = iop_param_op(iop, ia->ia_tid, NULL, 0,
I2O_PARAM_RBS_CACHE_CONTROL, &param, sizeof(param));
  306         if (rv != 0) {
printf("%s: unable to get parameters (0x%04x; %d)\n",
sc->sc_dv.dv_xname, I2O_PARAM_RBS_CACHE_CONTROL, rv);
  309                 goto bad;
  310         }
  312         if ((cachesz = letoh32(param.p.cc.totalcachesize)) != 0)
printf(", %dkB cache", cachesz >> 10);
printf("\n");
  317         /*
  318          * Configure the DDM's timeout functions to time out all commands
  319          * after 30 seconds.
  320          */
rv = iop_param_op(iop, ia->ia_tid, NULL, 0, I2O_PARAM_RBS_OPERATION,
  322             &param, sizeof(param));
  323         if (rv != 0) {
printf("%s: unable to get parameters (0x%04x; %d)\n",
sc->sc_dv.dv_xname, I2O_PARAM_RBS_OPERATION, rv);
  326                 goto bad;
  327         }
param.p.op.timeoutbase = htole32(IOPRBS_TIMEOUT * 1000); 
param.p.op.rwvtimeoutbase = htole32(IOPRBS_TIMEOUT * 1000); 
param.p.op.rwvtimeout = 0; 
rv = iop_param_op(iop, ia->ia_tid, NULL, 1, I2O_PARAM_RBS_OPERATION,
  334             &param, sizeof(param));
  335 #ifdef notdef
  336         /*
  337          * Intel RAID adapters don't like the above, but do post a
  338          * `parameter changed' event.  Perhaps we're doing something
  339          * wrong...
  340          */
  341         if (rv != 0) {
printf("%s: unable to set parameters (0x%04x; %d)\n",
sc->sc_dv.dv_xname, I2O_PARAM_RBS_OPERATION, rv);
  344                 goto bad;
  345         }
  346 #endif
  348         if (enable)
sc->sc_flags |= IOPRBS_ENABLED;
  350         else
printf("%s: device not yet supported\n", self->dv_xname);
  353         /* Fill in the prototype scsi_link. */
sc->sc_link.adapter_softc = sc;
sc->sc_link.adapter = &ioprbs_switch;
sc->sc_link.device = &ioprbs_dev;
sc->sc_link.openings = 1;
sc->sc_link.adapter_buswidth = 1;
sc->sc_link.adapter_target = 1;
bzero(&saa, sizeof(saa));
saa.saa_sc_link = &sc->sc_link;
config_found(&sc->sc_dv, &saa, scsiprint);
  366         return;
bad:
ioprbs_unconfig(sc, state > 0);
  370 }
  372 void
ioprbs_unconfig(struct ioprbs_softc *sc, int evreg)
  374 {
  375         struct iop_softc *iop;
  376         int s;
iop = (struct iop_softc *)sc->sc_dv.dv_parent;
  380         if ((sc->sc_flags & IOPRBS_CLAIMED) != 0)
iop_util_claim(iop, &sc->sc_ii, 1,
I2O_UTIL_CLAIM_PRIMARY_USER);
  384         if (evreg) {
  385                 /*
  386                  * Mask off events, and wait up to 5 seconds for a reply. 
  387                  * Note that some adapters won't reply to this (XXX We
  388                  * should check the event capabilities).
  389                  */
sc->sc_flags &= ~IOPRBS_NEW_EVTMASK;
iop_util_eventreg(iop, &sc->sc_eventii,
I2O_EVENT_GEN_EVENT_MASK_MODIFIED);
s = splbio();
  394                 if ((sc->sc_flags & IOPRBS_NEW_EVTMASK) == 0)
tsleep(&sc->sc_eventii, PRIBIO, "ioprbsevt", hz * 5);
splx(s);
  397 #ifdef I2ODEBUG
  398                 if ((sc->sc_flags & IOPRBS_NEW_EVTMASK) == 0)
printf("%s: didn't reply to event unregister",
sc->sc_dv.dv_xname);
  401 #endif
  402         }
iop_initiator_unregister(iop, &sc->sc_eventii);
iop_initiator_unregister(iop, &sc->sc_ii);
  406 }
  408 int
ioprbs_scsi_cmd(xs)
  410         struct scsi_xfer *xs;
  411 {
  412         struct scsi_link *link = xs->sc_link;
  413         struct ioprbs_softc *sc = link->adapter_softc;
  414         struct ioprbs_ccb *ccb;
u_int32_t blockno, blockcnt;
  416         struct scsi_rw *rw;
  417         struct scsi_rw_big *rwb;
ioprbs_lock_t lock;
  419         int retval = SUCCESSFULLY_QUEUED;
lock = IOPRBS_LOCK(sc);
  423         /* Don't double enqueue if we came from ioprbs_chain. */
  424         if (xs != LIST_FIRST(&sc->sc_queue))
ioprbs_enqueue(sc, xs, 0);
  427         while ((xs = ioprbs_dequeue(sc))) {
xs->error = XS_NOERROR;
ccb = NULL;
  432                 switch (xs->cmd->opcode) {
  433                 case TEST_UNIT_READY:
  434                 case REQUEST_SENSE:
  435                 case INQUIRY:
  436                 case MODE_SENSE:
  437                 case START_STOP:
  438                 case READ_CAPACITY:
  439 #if 0
  440                 case VERIFY:
  441 #endif
ioprbs_internal_cache_cmd(xs);
xs->flags |= ITSDONE;
scsi_done(xs);
  445                         goto ready;
  447                 case PREVENT_ALLOW:
DPRINTF(("PREVENT/ALLOW "));
  449                         /* XXX Not yet implemented */
xs->error = XS_NOERROR;
xs->flags |= ITSDONE;
scsi_done(xs);
  453                         goto ready;
  455                 case SYNCHRONIZE_CACHE:
DPRINTF(("SYNCHRONIZE_CACHE "));
  457                         /* XXX Not yet implemented */
xs->error = XS_NOERROR;
xs->flags |= ITSDONE;
scsi_done(xs);
  461                         goto ready;
  463                 default:
DPRINTF(("unknown opc %d ", xs->cmd->opcode));
  465                         /* XXX Not yet implemented */
xs->error = XS_DRIVER_STUFFUP;
xs->flags |= ITSDONE;
scsi_done(xs);
  469                         goto ready;
  471                 case READ_COMMAND:
  472                 case READ_BIG:
  473                 case WRITE_COMMAND:
  474                 case WRITE_BIG:
DPRINTF(("rw opc %d ", xs->cmd->opcode));
  477                         if (xs->cmd->opcode != SYNCHRONIZE_CACHE) {
  478                                 /* A read or write operation. */
  479                                 if (xs->cmdlen == 6) {
rw = (struct scsi_rw *)xs->cmd;
blockno = _3btol(rw->addr) &
  482                                             (SRW_TOPADDR << 16 | 0xffff);
blockcnt =
rw->length ? rw->length : 0x100;
  485                                 } else {
rwb = (struct scsi_rw_big *)xs->cmd;
blockno = _4btol(rwb->addr);
blockcnt = _2btol(rwb->length);
  489                                 }
  490                                 if (blockno >= sc->sc_secperunit ||
blockno + blockcnt > sc->sc_secperunit) {
printf(
  493                                             "%s: out of bounds %u-%u >= %u\n",
sc->sc_dv.dv_xname, blockno,
blockcnt, sc->sc_secperunit);
  496                                         /*
  497                                          * XXX Should be XS_SENSE but that
  498                                          * would require setting up a faked
  499                                          * sense too.
  500                                          */
xs->error = XS_DRIVER_STUFFUP;
xs->flags |= ITSDONE;
scsi_done(xs);
  504                                         goto ready;
  505                                 }
  506                         }
ccb = ioprbs_get_ccb(sc, xs->flags);
  510                         /*
  511                          * We are out of commands, try again in a little while.
  512                          */
  513                         if (ccb == NULL) {
IOPRBS_UNLOCK(sc, lock);
  515                                 return (TRY_AGAIN_LATER);
  516                         }
ccb->ic_blockno = blockno;
ccb->ic_blockcnt = blockcnt;
ccb->ic_xs = xs;
ccb->ic_timeout = xs->timeout;
ioprbs_enqueue_ccb(sc, ccb);
  525                         /* XXX what if enqueue did not start a transfer? */
  526                         if (xs->flags & SCSI_POLL) {
  527 #if 0
  528                                 if (!ioprbs_wait(sc, ccb, ccb->ic_timeout)) {
IOPRBS_UNLOCK(sc, lock);
printf("%s: command timed out\n",
sc->sc_dv.dv_xname);
  532                                         return (TRY_AGAIN_LATER);
  533                                 }
xs->flags |= ITSDONE;
scsi_done(xs);
  536 #endif
  537                         }
  538                 }
ready:
  541                 /*
  542                  * Don't process the queue if we are polling.
  543                  */
  544                 if (xs->flags & SCSI_POLL) {
retval = COMPLETE;
  546                         break;
  547                 }
  548         }
IOPRBS_UNLOCK(sc, lock);
  551         return (retval);
  552 }
  554 void
ioprbsminphys(bp)
  556         struct buf *bp;
  557 {
minphys(bp);
  559 }
  561 void
ioprbs_intr(struct device *dv, struct iop_msg *im, void *reply)
  563 {
  564         struct i2o_rbs_reply *rb = reply;
  565         struct ioprbs_ccb *ccb = im->im_dvcontext;
  566         struct buf *bp = ccb->ic_xs->bp;
  567         struct ioprbs_softc *sc = (struct ioprbs_softc *)dv;
  568         struct iop_softc *iop = (struct iop_softc *)dv->dv_parent;
  569         int err, detail;
  570 #ifdef I2OVERBOSE
  571         const char *errstr;
  572 #endif
DPRINTF(("ioprbs_intr(%p, %p, %p) ", dv, im, reply));
timeout_del(&ccb->ic_xs->stimeout);
err = ((rb->msgflags & I2O_MSGFLAGS_FAIL) != 0);
  580         if (!err && rb->reqstatus != I2O_STATUS_SUCCESS) {
detail = letoh16(rb->detail);
  582 #ifdef I2OVERBOSE
  583                 if (detail > sizeof(ioprbs_errors) / sizeof(ioprbs_errors[0]))
errstr = "<unknown>";
  585                 else
errstr = ioprbs_errors[detail];
printf("%s: error 0x%04x: %s\n", dv->dv_xname, detail, errstr);
  588 #else
printf("%s: error 0x%04x\n", dv->dv_xname, detail);
  590 #endif
err = 1;
  592         }
  594         if (bp) {
  595                 if (err) {
bp->b_flags |= B_ERROR;
bp->b_error = EIO;
bp->b_resid = bp->b_bcount;
  599                 } else
bp->b_resid = bp->b_bcount - letoh32(rb->transfercount);
  601         }
iop_msg_unmap(iop, im);
iop_msg_free(iop, im);
scsi_done(ccb->ic_xs);
ioprbs_free_ccb(sc, ccb);
  607 }
  609 void
ioprbs_intr_event(struct device *dv, struct iop_msg *im, void *reply)
  611 {
  612         struct i2o_util_event_register_reply *rb;
  613         struct ioprbs_softc *sc;
u_int event;
rb = reply;
  618         if ((rb->msgflags & I2O_MSGFLAGS_FAIL) != 0)
  619                 return;
event = letoh32(rb->event);
sc = (struct ioprbs_softc *)dv;
  624         if (event == I2O_EVENT_GEN_EVENT_MASK_MODIFIED) {
sc->sc_flags |= IOPRBS_NEW_EVTMASK;
wakeup(&sc->sc_eventii);
  627 #ifndef I2ODEBUG
  628                 return;
  629 #endif
  630         }
printf("%s: event 0x%08x received\n", dv->dv_xname, event);
  633 }
  635 void
ioprbs_adjqparam(struct device *dv, int mpi)
  637 {
  638 #if 0
  639         struct iop_softc *iop;
  641         /*
  642          * AMI controllers seem to lose the plot if you hand off lots of
  643          * queued commands.
  644          */
iop = (struct iop_softc *)dv->dv_parent;
  646         if (letoh16(I2O_ORG_AMI) == iop->sc_status.orgid && mpi > 64)
mpi = 64;
ldadjqparam((struct ld_softc *)dv, mpi);
  650 #endif
  651 }
  653 /*
  654  * Insert a command into the driver queue, either at the front or at the tail.
  655  * It's ok to overload the freelist link as these structures are never on
  656  * the freelist at this time.
  657  */
  658 void
ioprbs_enqueue(sc, xs, infront)
  660         struct ioprbs_softc *sc;
  661         struct scsi_xfer *xs;
  662         int infront;
  663 {
  664         if (infront || LIST_FIRST(&sc->sc_queue) == NULL) {
  665                 if (LIST_FIRST(&sc->sc_queue) == NULL)
sc->sc_queuelast = xs;
LIST_INSERT_HEAD(&sc->sc_queue, xs, free_list);
  668                 return;
  669         }
LIST_INSERT_AFTER(sc->sc_queuelast, xs, free_list);
sc->sc_queuelast = xs;
  672 }
  674 /*
  675  * Pull a command off the front of the driver queue.
  676  */
  677 struct scsi_xfer *
ioprbs_dequeue(sc)
  679         struct ioprbs_softc *sc;
  680 {
  681         struct scsi_xfer *xs;
xs = LIST_FIRST(&sc->sc_queue);
  684         if (xs == NULL)
  685                 return (NULL);
LIST_REMOVE(xs, free_list);
  688         if (LIST_FIRST(&sc->sc_queue) == NULL)
sc->sc_queuelast = NULL;
  691         return (xs);
  692 }
  694 void
ioprbs_copy_internal_data(xs, data, size)
  696         struct scsi_xfer *xs;
u_int8_t *data;
size_t size;
  699 {
size_t copy_cnt;
DPRINTF(("ioprbs_copy_internal_data "));
  704         if (!xs->datalen)
printf("uio move not yet supported\n");
  706         else {
copy_cnt = MIN(size, xs->datalen);
bcopy(data, xs->data, copy_cnt);
  709         }
  710 }
  712 /* Emulated SCSI operation on cache device */
  713 void
ioprbs_internal_cache_cmd(xs)
  715         struct scsi_xfer *xs;
  716 {
  717         struct scsi_link *link = xs->sc_link;
  718         struct ioprbs_softc *sc = link->adapter_softc;
u_int8_t target = link->target;
  720         struct scsi_inquiry_data inq;
  721         struct scsi_sense_data sd;
  722         struct scsi_read_cap_data rcd;
DPRINTF(("ioprbs_internal_cache_cmd "));
xs->error = XS_NOERROR;
  728         if (target > 0 || link->lun != 0) {
xs->error = XS_DRIVER_STUFFUP;
  730                 return;
  731         }
  733         switch (xs->cmd->opcode) {
  734         case TEST_UNIT_READY:
  735         case START_STOP:
  736 #if 0
  737         case VERIFY:
  738 #endif
DPRINTF(("opc %d tgt %d ", xs->cmd->opcode, target));
  740                 break;
  742         case REQUEST_SENSE:
DPRINTF(("REQUEST SENSE tgt %d ", target));
bzero(&sd, sizeof sd);
sd.error_code = 0x70;
sd.segment = 0;
sd.flags = SKEY_NO_SENSE;
bzero(sd.info, sizeof sd.info);
sd.extra_len = 0;
ioprbs_copy_internal_data(xs, (u_int8_t *)&sd, sizeof sd);
  751                 break;
  753         case INQUIRY:
DPRINTF(("INQUIRY tgt %d", target));
bzero(&inq, sizeof inq);
  756                 /* XXX How do we detect removable/CD-ROM devices?  */
inq.device = T_DIRECT;
inq.dev_qual2 = 0;
inq.version = 2;
inq.response_format = 2;
inq.additional_length = 32;
strlcpy(inq.vendor, "I2O", sizeof inq.vendor);
snprintf(inq.product, sizeof inq.product, "Container #%02d",
target);
strlcpy(inq.revision, "   ", sizeof inq.revision);
ioprbs_copy_internal_data(xs, (u_int8_t *)&inq, sizeof inq);
  767                 break;
  769         case READ_CAPACITY:
DPRINTF(("READ CAPACITY tgt %d ", target));
bzero(&rcd, sizeof rcd);
_lto4b(sc->sc_secperunit - 1, rcd.addr);
_lto4b(IOPRBS_BLOCK_SIZE, rcd.length);
ioprbs_copy_internal_data(xs, (u_int8_t *)&rcd, sizeof rcd);
  775                 break;
  777         default:
DPRINTF(("unsupported scsi command %#x tgt %d ",
xs->cmd->opcode, target));
xs->error = XS_DRIVER_STUFFUP;
  781                 return;
  782         }
xs->error = XS_NOERROR;
  785 }
  787 struct ioprbs_ccb *
ioprbs_get_ccb(sc, flags)
  789         struct ioprbs_softc *sc;
  790         int flags;
  791 {
  792         struct ioprbs_ccb *ccb;
ioprbs_lock_t lock;
DPRINTF(("ioprbs_get_ccb(%p, 0x%x) ", sc, flags));
lock = IOPRBS_LOCK(sc);
  799         for (;;) {
ccb = TAILQ_FIRST(&sc->sc_free_ccb);
  801                 if (ccb != NULL)
  802                         break;
  803                 if (flags & SCSI_NOSLEEP)
  804                         goto bail_out;
tsleep(&sc->sc_free_ccb, PRIBIO, "ioprbs_ccb", 0);
  806         }
TAILQ_REMOVE(&sc->sc_free_ccb, ccb, ic_chain);
  810         /* initialise the command */
ccb->ic_flags = 0;
bail_out:
IOPRBS_UNLOCK(sc, lock);
  815         return (ccb);
  816 }
  818 void
ioprbs_free_ccb(sc, ccb)
  820         struct ioprbs_softc *sc;
  821         struct ioprbs_ccb *ccb;
  822 {
ioprbs_lock_t lock;
DPRINTF(("ioprbs_free_ccb(%p, %p) ", sc, ccb));
lock = IOPRBS_LOCK(sc);
TAILQ_INSERT_HEAD(&sc->sc_free_ccb, ccb, ic_chain);
  831         /* If the free list was empty, wake up potential waiters. */
  832         if (TAILQ_NEXT(ccb, ic_chain) == NULL)
wakeup(&sc->sc_free_ccb);
IOPRBS_UNLOCK(sc, lock);
  836 }
  838 void
ioprbs_enqueue_ccb(sc, ccb)
  840         struct ioprbs_softc *sc;
  841         struct ioprbs_ccb *ccb;
  842 {
DPRINTF(("ioprbs_enqueue_ccb(%p, %p) ", sc, ccb));
timeout_set(&ccb->ic_xs->stimeout, ioprbs_timeout, ccb);
TAILQ_INSERT_TAIL(&sc->sc_ccbq, ccb, ic_chain);
ioprbs_start_ccbs(sc);
  848 }
  850 void
ioprbs_start_ccbs(sc)
  852         struct ioprbs_softc *sc;
  853 {
  854         struct ioprbs_ccb *ccb;
  855         struct scsi_xfer *xs;
DPRINTF(("ioprbs_start_ccbs(%p) ", sc));
  859         while ((ccb = TAILQ_FIRST(&sc->sc_ccbq)) != NULL) {
xs = ccb->ic_xs;
  862                 if (ccb->ic_flags & IOPRBS_ICF_WATCHDOG)
timeout_del(&xs->stimeout);
  865                 if (ioprbs_exec_ccb(ccb) == 0) {
ccb->ic_flags |= IOPRBS_ICF_WATCHDOG;
timeout_set(&ccb->ic_xs->stimeout, ioprbs_watchdog,
ccb);
timeout_add(&xs->stimeout,
  870                             (IOPRBS_WATCH_TIMEOUT * hz) / 1000);
  871                         break;
  872                 }
TAILQ_REMOVE(&sc->sc_ccbq, ccb, ic_chain);
  875                 if ((xs->flags & SCSI_POLL) == 0) {
timeout_set(&ccb->ic_xs->stimeout, ioprbs_timeout,
ccb);
timeout_add(&xs->stimeout,
  879                             (ccb->ic_timeout * hz) / 1000);
  880                 }
  881         }
  882 }
  884 int
ioprbs_exec_ccb(ccb)
  886         struct ioprbs_ccb *ccb;
  887 {
  888         struct scsi_xfer *xs = ccb->ic_xs;
DPRINTF(("ioprbs_exec_ccb(%p, %p) ", xs, ccb));
ioprbs_start(ccb);
xs->error = XS_NOERROR;
xs->resid = 0;
  896         return (1);
  897 }
  899 /*
  900  * Deliver a command to the controller; allocate controller resources at the
  901  * last moment when possible.
  902  */
  903 int
ioprbs_start(struct ioprbs_ccb *ccb)
  905 {
  906         struct scsi_xfer *xs = ccb->ic_xs;
  907         struct scsi_link *link = xs->sc_link;
  908         struct ioprbs_softc *sc = link->adapter_softc;
  909 #ifdef I2ODEBUG
u_int8_t target = link->target;
  911 #endif
  912         struct iop_msg *im;
  913         struct iop_softc *iop = (struct iop_softc *)sc->sc_dv.dv_parent;
  914         struct i2o_rbs_block_read *mf;
u_int rv, flags = 0, mode = I2O_RBS_BLOCK_READ;
u_int64_t ba;
u_int32_t mb[IOP_MAX_MSG_SIZE / sizeof(u_int32_t)];
im = iop_msg_alloc(iop, &sc->sc_ii, 0);
im->im_dvcontext = ccb;
  922         switch (xs->cmd->opcode) {
  923         case PREVENT_ALLOW:
  924         case SYNCHRONIZE_CACHE:
  925                 if (xs->cmd->opcode == PREVENT_ALLOW) {
  926                         /* XXX PREVENT_ALLOW support goes here */
  927                 } else {
DPRINTF(("SYNCHRONIZE CACHE tgt %d ", target));
  929                 }
  930                 break;
  932         case WRITE_COMMAND:
  933         case WRITE_BIG:
flags = I2O_RBS_BLOCK_WRITE_CACHE_WB;
mode = I2O_RBS_BLOCK_WRITE;
  936                 /* FALLTHROUGH */
  938         case READ_COMMAND:
  939         case READ_BIG:
ba = (u_int64_t)ccb->ic_blockno * DEV_BSIZE;
  942                 /*
  943                  * Fill the message frame.  We can use the block_read
  944                  * structure for both reads and writes, as it's almost
  945                  * identical to the * block_write structure.
  946                  */
mf = (struct i2o_rbs_block_read *)mb;
mf->msgflags = I2O_MSGFLAGS(i2o_rbs_block_read);
mf->msgfunc = I2O_MSGFUNC(sc->sc_ii.ii_tid, mode);
mf->msgictx = sc->sc_ii.ii_ictx;
mf->msgtctx = im->im_tctx;
mf->flags = flags | (1 << 16);  /* flags & time multiplier */
mf->datasize = ccb->ic_blockcnt * DEV_BSIZE;
mf->lowoffset = (u_int32_t)ba;
mf->highoffset = (u_int32_t)(ba >> 32);
  957                 /* Map the data transfer and enqueue the command. */
rv = iop_msg_map_bio(iop, im, mb, xs->data,
ccb->ic_blockcnt * DEV_BSIZE, mode == I2O_RBS_BLOCK_WRITE);
  960                 if (rv == 0) {
  961                         if ((rv = iop_msg_post(iop, im, mb, 0)) != 0) {
iop_msg_unmap(iop, im);
iop_msg_free(iop, im);
  964                         }
  965                 }
  966                 break;
  967         }
  968         return (0);
  969 }
  971 void
ioprbs_timeout(arg)
  973         void *arg;
  974 {
  975         struct ioprbs_ccb *ccb = arg;
  976         struct scsi_link *link = ccb->ic_xs->sc_link;
  977         struct ioprbs_softc *sc = link->adapter_softc;
ioprbs_lock_t lock;
sc_print_addr(link);
printf("timed out\n");
  983         /* XXX Test for multiple timeouts */
ccb->ic_xs->error = XS_TIMEOUT;
lock = IOPRBS_LOCK(sc);
ioprbs_enqueue_ccb(sc, ccb);
IOPRBS_UNLOCK(sc, lock);
  989 }
  991 void
ioprbs_watchdog(arg)
  993         void *arg;
  994 {
  995         struct ioprbs_ccb *ccb = arg;
  996         struct scsi_link *link = ccb->ic_xs->sc_link;
  997         struct ioprbs_softc *sc = link->adapter_softc;
ioprbs_lock_t lock;
lock = IOPRBS_LOCK(sc);
ccb->ic_flags &= ~IOPRBS_ICF_WATCHDOG;
ioprbs_start_ccbs(sc);
IOPRBS_UNLOCK(sc, lock);
 1004 }