root/dev/ic/cac.c

DEFINITIONS

1. cac_init
2. cac_flush
3. cac_shutdown
4. cac_intr
5. cac_cmd
6. cac_ccb_poll
7. cac_ccb_start
8. cac_ccb_done
9. cac_ccb_alloc
10. cac_ccb_free
11. cac_get_dinfo
12. cacminphys
13. cac_copy_internal_data
14. cac_scsi_cmd
15. cac_l0_fifo_full
16. cac_l0_submit
17. cac_l0_completed
18. cac_l0_intr_pending
19. cac_l0_intr_enable

    1 /*      $OpenBSD: cac.c,v 1.23 2006/11/28 23:59:45 dlg Exp $    */
    2 /*      $NetBSD: cac.c,v 1.15 2000/11/08 19:20:35 ad Exp $      */
    4 /*
    5  * Copyright (c) 2001,2003 Michael Shalayeff
    6  * All rights reserved.
    7  *
    8  * The SCSI emulation layer is derived from gdt(4) driver,
    9  * Copyright (c) 1999, 2000 Niklas Hallqvist. All rights reserved.
   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  *
   20  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
   21  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
   22  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
   23  * IN NO EVENT SHALL THE AUTHOR OR HIS RELATIVES BE LIABLE FOR ANY DIRECT,
   24  * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
   25  * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
   26  * SERVICES; LOSS OF MIND, USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
   27  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
   28  * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
   29  * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
   30  * THE POSSIBILITY OF SUCH DAMAGE.
   31  */
   32 /*-
   33  * Copyright (c) 2000 The NetBSD Foundation, Inc.
   34  * All rights reserved.
   35  *
   36  * This code is derived from software contributed to The NetBSD Foundation
   37  * by Andrew Doran.
   38  *
   39  * Redistribution and use in source and binary forms, with or without
   40  * modification, are permitted provided that the following conditions
   41  * are met:
   42  * 1. Redistributions of source code must retain the above copyright
   43  *    notice, this list of conditions and the following disclaimer.
   44  * 2. Redistributions in binary form must reproduce the above copyright
   45  *    notice, this list of conditions and the following disclaimer in the
   46  *    documentation and/or other materials provided with the distribution.
   47  * 3. All advertising materials mentioning features or use of this software
   48  *    must display the following acknowledgement:
   49  *        This product includes software developed by the NetBSD
   50  *        Foundation, Inc. and its contributors.
   51  * 4. Neither the name of The NetBSD Foundation nor the names of its
   52  *    contributors may be used to endorse or promote products derived
   53  *    from this software without specific prior written permission.
   54  *
   55  * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
   56  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
   57  * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
   58  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
   59  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
   60  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
   61  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
   62  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
   63  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
   64  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
   65  * POSSIBILITY OF SUCH DAMAGE.
   66  */
   68 /*
   69  * Driver for Compaq array controllers.
   70  */
   72 /* #define      CAC_DEBUG */
   74 #include <sys/param.h>
   75 #include <sys/systm.h>
   76 #include <sys/kernel.h>
   77 #include <sys/device.h>
   78 #include <sys/queue.h>
   79 #include <sys/proc.h>
   80 #include <sys/buf.h>
   81 #include <sys/endian.h>
   82 #include <sys/malloc.h>
   83 #include <sys/pool.h>
   85 #include <machine/bus.h>
   87 #include <scsi/scsi_all.h>
   88 #include <scsi/scsi_disk.h>
   89 #include <scsi/scsiconf.h>
   91 #include <dev/ic/cacreg.h>
   92 #include <dev/ic/cacvar.h>
   94 struct cfdriver cac_cd = {
NULL, "cac", DV_DULL
   96 };
   98 int     cac_scsi_cmd(struct scsi_xfer *);
   99 void    cacminphys(struct buf *bp);
  101 struct scsi_adapter cac_switch = {
cac_scsi_cmd, cacminphys, 0, 0,
  103 };
  105 struct scsi_device cac_dev = {
NULL, NULL, NULL, NULL
  107 };
  109 struct  cac_ccb *cac_ccb_alloc(struct cac_softc *, int);
  110 void    cac_ccb_done(struct cac_softc *, struct cac_ccb *);
  111 void    cac_ccb_free(struct cac_softc *, struct cac_ccb *);
  112 int     cac_ccb_poll(struct cac_softc *, struct cac_ccb *, int);
  113 int     cac_ccb_start(struct cac_softc *, struct cac_ccb *);
  114 int     cac_cmd(struct cac_softc *sc, int command, void *data, int datasize,
  115         int drive, int blkno, int flags, struct scsi_xfer *xs);
  116 int     cac_get_dinfo(struct cac_softc *sc, int target);
  117 int     cac_flush(struct cac_softc *sc);
  118 void    cac_shutdown(void *);
  119 void    cac_copy_internal_data(struct scsi_xfer *xs, void *v, size_t size);
  121 struct  cac_ccb *cac_l0_completed(struct cac_softc *);
  122 int     cac_l0_fifo_full(struct cac_softc *);
  123 void    cac_l0_intr_enable(struct cac_softc *, int);
  124 int     cac_l0_intr_pending(struct cac_softc *);
  125 void    cac_l0_submit(struct cac_softc *, struct cac_ccb *);
  127 void    *cac_sdh;       /* shutdown hook */
  129 const
  130 struct cac_linkage cac_l0 = {
cac_l0_completed,
cac_l0_fifo_full,
cac_l0_intr_enable,
cac_l0_intr_pending,
cac_l0_submit
  136 };
  138 /*
  139  * Initialise our interface to the controller.
  140  */
  141 int
cac_init(struct cac_softc *sc, int startfw)
  143 {
  144         struct scsibus_attach_args saa;
  145         struct cac_controller_info cinfo;
  146         int error, rseg, size, i;
bus_dma_segment_t seg[1];
  148         struct cac_ccb *ccb;
SIMPLEQ_INIT(&sc->sc_ccb_free);
SIMPLEQ_INIT(&sc->sc_ccb_queue);
size = sizeof(struct cac_ccb) * CAC_MAX_CCBS;
  155         if ((error = bus_dmamem_alloc(sc->sc_dmat, size, PAGE_SIZE, 0, seg, 1,
  156             &rseg, BUS_DMA_NOWAIT)) != 0) {
printf("%s: unable to allocate CCBs, error = %d\n",
sc->sc_dv.dv_xname, error);
  159                 return (-1);
  160         }
  162         if ((error = bus_dmamem_map(sc->sc_dmat, seg, rseg, size,
  163             &sc->sc_ccbs, BUS_DMA_NOWAIT | BUS_DMA_COHERENT)) != 0) {
printf("%s: unable to map CCBs, error = %d\n",
sc->sc_dv.dv_xname, error);
  166                 return (-1);
  167         }
  169         if ((error = bus_dmamap_create(sc->sc_dmat, size, 1, size, 0,
BUS_DMA_NOWAIT, &sc->sc_dmamap)) != 0) {
printf("%s: unable to create CCB DMA map, error = %d\n",
sc->sc_dv.dv_xname, error);
  173                 return (-1);
  174         }
  176         if ((error = bus_dmamap_load(sc->sc_dmat, sc->sc_dmamap, sc->sc_ccbs,
size, NULL, BUS_DMA_NOWAIT)) != 0) {
printf("%s: unable to load CCB DMA map, error = %d\n",
sc->sc_dv.dv_xname, error);
  180                 return (-1);
  181         }
sc->sc_ccbs_paddr = sc->sc_dmamap->dm_segs[0].ds_addr;
memset(sc->sc_ccbs, 0, size);
ccb = (struct cac_ccb *)sc->sc_ccbs;
  187         for (i = 0; i < CAC_MAX_CCBS; i++, ccb++) {
  188                 /* Create the DMA map for this CCB's data */
error = bus_dmamap_create(sc->sc_dmat, CAC_MAX_XFER,
CAC_SG_SIZE, CAC_MAX_XFER, 0,
BUS_DMA_NOWAIT | BUS_DMA_ALLOCNOW,
  192                     &ccb->ccb_dmamap_xfer);
  194                 if (error) {
printf("%s: can't create ccb dmamap (%d)\n",
sc->sc_dv.dv_xname, error);
  197                         break;
  198                 }
ccb->ccb_paddr = sc->sc_ccbs_paddr + i * sizeof(struct cac_ccb);
SIMPLEQ_INSERT_TAIL(&sc->sc_ccb_free, ccb, ccb_chain);
  202         }
  204         /* Start firmware background tasks, if needed. */
  205         if (startfw) {
  206                 if (cac_cmd(sc, CAC_CMD_START_FIRMWARE, &cinfo, sizeof(cinfo),
  207                     0, 0, CAC_CCB_DATA_IN, NULL)) {
printf("%s: CAC_CMD_START_FIRMWARE failed\n",
sc->sc_dv.dv_xname);
  210                         return (-1);
  211                 }
  212         }
  214         if (cac_cmd(sc, CAC_CMD_GET_CTRL_INFO, &cinfo, sizeof(cinfo), 0, 0,
CAC_CCB_DATA_IN, NULL)) {
printf("%s: CAC_CMD_GET_CTRL_INFO failed\n",
sc->sc_dv.dv_xname);
  218                 return (-1);
  219         }
  221         if (!cinfo.num_drvs) {
printf("%s: no volumes defined\n", sc->sc_dv.dv_xname);
  223                 return (-1);
  224         }
sc->sc_nunits = cinfo.num_drvs;
sc->sc_dinfos = malloc(cinfo.num_drvs * sizeof(struct cac_drive_info),
M_DEVBUF, M_NOWAIT);
  229         if (sc->sc_dinfos == NULL) {
printf("%s: cannot allocate memory for drive_info\n",
sc->sc_dv.dv_xname);
  232                 return (-1);
  233         }
bzero(sc->sc_dinfos, cinfo.num_drvs * sizeof(struct cac_drive_info));
sc->sc_link.adapter_softc = sc;
sc->sc_link.adapter = &cac_switch;
sc->sc_link.adapter_target = cinfo.num_drvs;
sc->sc_link.adapter_buswidth = cinfo.num_drvs;
sc->sc_link.device = &cac_dev;
sc->sc_link.openings = CAC_MAX_CCBS / sc->sc_nunits;
  242         if (sc->sc_link.openings < 4 )
sc->sc_link.openings = 4;
bzero(&saa, sizeof(saa));
saa.saa_sc_link = &sc->sc_link;
config_found(&sc->sc_dv, &saa, scsiprint);
  250         /* Set our `shutdownhook' before we start any device activity. */
  251         if (cac_sdh == NULL)
cac_sdh = shutdownhook_establish(cac_shutdown, NULL);
  254         (*sc->sc_cl->cl_intr_enable)(sc, 1);
  256         return (0);
  257 }
  259 int
cac_flush(sc)
  261         struct cac_softc *sc;
  262 {
u_int8_t buf[512];
memset(buf, 0, sizeof(buf));
buf[0] = 1;
  267         return cac_cmd(sc, CAC_CMD_FLUSH_CACHE, buf, sizeof(buf), 0, 0,
CAC_CCB_DATA_OUT, NULL);
  269 }
  271 /*
  272  * Shut down all `cac' controllers.
  273  */
  274 void
cac_shutdown(void *cookie)
  276 {
  277         extern struct cfdriver cac_cd;
  278         struct cac_softc *sc;
  279         int i;
  281         for (i = 0; i < cac_cd.cd_ndevs; i++) {
  282                 if ((sc = (struct cac_softc *)device_lookup(&cac_cd, i)) == NULL)
  283                         continue;
cac_flush(sc);
  285         }
  286 }
  288 /*
  289  * Handle an interrupt from the controller: process finished CCBs and
  290  * dequeue any waiting CCBs.
  291  */
  292 int
cac_intr(v)
  294         void *v;
  295 {
  296         struct cac_softc *sc = v;
  297         struct cac_ccb *ccb;
  298         int istat, ret = 0;
  300         if (!(istat = (sc->sc_cl->cl_intr_pending)(sc)))
  301                 return 0;
  303         if (istat & CAC_INTR_FIFO_NEMPTY)
  304                 while ((ccb = (*sc->sc_cl->cl_completed)(sc)) != NULL) {
ret = 1;
cac_ccb_done(sc, ccb);
  307                 }
cac_ccb_start(sc, NULL);
  310         return (ret);
  311 }
  313 /*
  314  * Execute a [polled] command.
  315  */
  316 int
cac_cmd(struct cac_softc *sc, int command, void *data, int datasize,
  318         int drive, int blkno, int flags, struct scsi_xfer *xs)
  319 {
  320         struct cac_ccb *ccb;
  321         struct cac_sgb *sgb;
  322         int i, rv, size, nsegs;
  324 #ifdef CAC_DEBUG
printf("cac_cmd op=%x drv=%d blk=%d data=%p[%x] fl=%x xs=%p ",
command, drive, blkno, data, datasize, flags, xs);
  327 #endif
  329         if ((ccb = cac_ccb_alloc(sc, 0)) == NULL) {
printf("%s: unable to alloc CCB\n", sc->sc_dv.dv_xname);
  331                 return (ENOMEM);
  332         }
  334         if ((flags & (CAC_CCB_DATA_IN | CAC_CCB_DATA_OUT)) != 0) {
bus_dmamap_load(sc->sc_dmat, ccb->ccb_dmamap_xfer,
  336                     (void *)data, datasize, NULL, BUS_DMA_NOWAIT);
bus_dmamap_sync(sc->sc_dmat, ccb->ccb_dmamap_xfer, 0,
ccb->ccb_dmamap_xfer->dm_mapsize,
  340                     (flags & CAC_CCB_DATA_IN) != 0 ? BUS_DMASYNC_PREREAD :
BUS_DMASYNC_PREWRITE);
sgb = ccb->ccb_seg;
nsegs = ccb->ccb_dmamap_xfer->dm_nsegs;
  345                 if (nsegs > CAC_SG_SIZE)
panic("cac_cmd: nsegs botch");
size = 0;
  349                 for (i = 0; i < nsegs; i++, sgb++) {
size += ccb->ccb_dmamap_xfer->dm_segs[i].ds_len;
sgb->length =
htole32(ccb->ccb_dmamap_xfer->dm_segs[i].ds_len);
sgb->addr =
htole32(ccb->ccb_dmamap_xfer->dm_segs[i].ds_addr);
  355                 }
  356         } else {
size = datasize;
nsegs = 0;
  359         }
ccb->ccb_hdr.drive = drive;
ccb->ccb_hdr.priority = 0;
ccb->ccb_hdr.size = htole16((sizeof(struct cac_req) +
  364             sizeof(struct cac_sgb) * CAC_SG_SIZE) >> 2);
ccb->ccb_req.next = 0;
ccb->ccb_req.command = command;
ccb->ccb_req.error = 0;
ccb->ccb_req.blkno = htole32(blkno);
ccb->ccb_req.bcount = htole16(howmany(size, DEV_BSIZE));
ccb->ccb_req.sgcount = nsegs;
ccb->ccb_req.reserved = 0;
ccb->ccb_flags = flags;
ccb->ccb_datasize = size;
ccb->ccb_xs = xs;
  378         if (!xs || xs->flags & SCSI_POLL) {
  380                 /* Synchronous commands musn't wait. */
  381                 if ((*sc->sc_cl->cl_fifo_full)(sc)) {
cac_ccb_free(sc, ccb);
rv = -1;
  384                 } else {
ccb->ccb_flags |= CAC_CCB_ACTIVE;
  386                         (*sc->sc_cl->cl_submit)(sc, ccb);
rv = cac_ccb_poll(sc, ccb, 2000);
  388                 }
  389         } else
rv = cac_ccb_start(sc, ccb);
  392         return (rv);
  393 }
  395 /*
  396  * Wait for the specified CCB to complete.  Must be called at splbio.
  397  */
  398 int
cac_ccb_poll(struct cac_softc *sc, struct cac_ccb *wantccb, int timo)
  400 {
  401         struct cac_ccb *ccb;
  402         int t = timo * 10;
  404         do {
  405                 for (; t--; DELAY(100))
  406                         if ((ccb = (*sc->sc_cl->cl_completed)(sc)) != NULL)
  407                                 break;
  408                 if (t < 0) {
printf("%s: timeout\n", sc->sc_dv.dv_xname);
  410                         return (EBUSY);
  411                 }
cac_ccb_done(sc, ccb);
  413         } while (ccb != wantccb);
  415         return (0);
  416 }
  418 /*
  419  * Enqueue the specified command (if any) and attempt to start all enqueued
  420  * commands.  Must be called at splbio.
  421  */
  422 int
cac_ccb_start(struct cac_softc *sc, struct cac_ccb *ccb)
  424 {
  425         if (ccb != NULL)
SIMPLEQ_INSERT_TAIL(&sc->sc_ccb_queue, ccb, ccb_chain);
  428         while ((ccb = SIMPLEQ_FIRST(&sc->sc_ccb_queue)) != NULL &&
  429             !(*sc->sc_cl->cl_fifo_full)(sc)) {
SIMPLEQ_REMOVE_HEAD(&sc->sc_ccb_queue, ccb_chain);
ccb->ccb_flags |= CAC_CCB_ACTIVE;
  432                 (*sc->sc_cl->cl_submit)(sc, ccb);
  433         }
  435         return (0);
  436 }
  438 /*
  439  * Process a finished CCB.
  440  */
  441 void
cac_ccb_done(struct cac_softc *sc, struct cac_ccb *ccb)
  443 {
  444         struct scsi_xfer *xs = ccb->ccb_xs;
  445         int error = 0;
  447         if ((ccb->ccb_flags & CAC_CCB_ACTIVE) == 0) {
printf("%s: CCB not active, xs=%p\n", sc->sc_dv.dv_xname, xs);
  449                 if (xs) {
xs->error = XS_DRIVER_STUFFUP;
scsi_done(xs);
  452                 }
  453                 return;
  454         }
  456         if ((ccb->ccb_flags & (CAC_CCB_DATA_IN | CAC_CCB_DATA_OUT)) != 0) {
bus_dmamap_sync(sc->sc_dmat, ccb->ccb_dmamap_xfer, 0,
ccb->ccb_dmamap_xfer->dm_mapsize,
ccb->ccb_flags & CAC_CCB_DATA_IN ?
BUS_DMASYNC_POSTREAD : BUS_DMASYNC_POSTWRITE);
bus_dmamap_unload(sc->sc_dmat, ccb->ccb_dmamap_xfer);
  462         }
  464         if ((ccb->ccb_req.error & CAC_RET_SOFT_ERROR) != 0)
printf("%s: soft error; corrected\n", sc->sc_dv.dv_xname);
  466         if ((ccb->ccb_req.error & CAC_RET_HARD_ERROR) != 0) {
error = 1;
printf("%s: hard error\n", sc->sc_dv.dv_xname);
  469         }
  470         if ((ccb->ccb_req.error & CAC_RET_CMD_REJECTED) != 0) {
error = 1;
printf("%s: invalid request\n", sc->sc_dv.dv_xname);
  473         }
cac_ccb_free(sc, ccb);
  476         if (xs) {
  477                 if (error)
xs->error = XS_DRIVER_STUFFUP;
  479                 else
xs->resid = 0;
xs->flags |= ITSDONE;
scsi_done(xs);
  484         }
  485 }
  487 /*
  488  * Allocate a CCB.
  489  */
  490 struct cac_ccb *
cac_ccb_alloc(struct cac_softc *sc, int nosleep)
  492 {
  493         struct cac_ccb *ccb;
  495         if ((ccb = SIMPLEQ_FIRST(&sc->sc_ccb_free)) != NULL)
SIMPLEQ_REMOVE_HEAD(&sc->sc_ccb_free, ccb_chain);
  497         else
ccb = NULL;
  499         return (ccb);
  500 }
  502 /*
  503  * Put a CCB onto the freelist.
  504  */
  505 void
cac_ccb_free(struct cac_softc *sc, struct cac_ccb *ccb)
  507 {
ccb->ccb_flags = 0;
SIMPLEQ_INSERT_HEAD(&sc->sc_ccb_free, ccb, ccb_chain);
  511 }
  513 int
cac_get_dinfo(sc, target)
  515         struct cac_softc *sc;
  516         int target;
  517 {
  518         if (sc->sc_dinfos[target].ncylinders)
  519                 return (0);
  521         if (cac_cmd(sc, CAC_CMD_GET_LOG_DRV_INFO, &sc->sc_dinfos[target],
  522             sizeof(*sc->sc_dinfos), target, 0, CAC_CCB_DATA_IN, NULL)) {
printf("%s: CMD_GET_LOG_DRV_INFO failed\n",
sc->sc_dv.dv_xname);
  525                 return (-1);
  526         }
  528         return (0);
  529 }
  531 void
cacminphys(bp)
  533         struct buf *bp;
  534 {
  535         if (bp->b_bcount > CAC_MAX_XFER)
bp->b_bcount = CAC_MAX_XFER;
minphys(bp);
  538 }
  540 void
cac_copy_internal_data(xs, v, size)
  542         struct scsi_xfer *xs;
  543         void *v;
size_t size;
  545 {
size_t copy_cnt;
  548         if (!xs->datalen)
printf("uio move is not yet supported\n");
  550         else {
copy_cnt = MIN(size, xs->datalen);
bcopy(v, xs->data, copy_cnt);
  553         }
  554 }
  556 int
cac_scsi_cmd(xs)
  558         struct scsi_xfer *xs;
  559 {
  560         struct scsi_link *link = xs->sc_link;
  561         struct cac_softc *sc = link->adapter_softc;
  562         struct cac_drive_info *dinfo;
  563         struct scsi_inquiry_data inq;
  564         struct scsi_sense_data sd;
  565         struct scsi_read_cap_data rcd;
u_int8_t target = link->target;
u_int32_t blockno, blockcnt, size;
  568         struct scsi_rw *rw;
  569         struct scsi_rw_big *rwb;
  570         int op, flags, s, error, poll;
  571         const char *p;
  573         if (target >= sc->sc_nunits || link->lun != 0) {
xs->error = XS_DRIVER_STUFFUP;
  575                 return (COMPLETE);
  576         }
s = splbio();
xs->error = XS_NOERROR;
xs->free_list.le_next = NULL;
dinfo = &sc->sc_dinfos[target];
  583         switch (xs->cmd->opcode) {
  584         case TEST_UNIT_READY:
  585         case START_STOP:
  586 #if 0
  587         case VERIFY:
  588 #endif
  589                 break;
  591         case REQUEST_SENSE:
bzero(&sd, sizeof sd);
sd.error_code = 0x70;
sd.segment = 0;
sd.flags = SKEY_NO_SENSE;
  596                 *(u_int32_t*)sd.info = htole32(0);
sd.extra_len = 0;
cac_copy_internal_data(xs, &sd, sizeof sd);
  599                 break;
  601         case INQUIRY:
  602                 if (cac_get_dinfo(sc, target)) {
xs->error = XS_DRIVER_STUFFUP;
  604                         break;
  605                 }
bzero(&inq, sizeof inq);
inq.device = T_DIRECT;
inq.dev_qual2 = 0;
inq.version = 2;
inq.response_format = 2;
inq.additional_length = 32;
strlcpy(inq.vendor, "Compaq  ", sizeof inq.vendor);
  613                 switch (CAC_GET1(dinfo->mirror)) {
  614                 case 0: p = "RAID0";    break;
  615                 case 1: p = "RAID4";    break;
  616                 case 2: p = "RAID1";    break;
  617                 case 3: p = "RAID5";    break;
  618                 default:p = "<UNK>";    break;
  619                 }
snprintf(inq.product, sizeof inq.product, "%s vol  #%02d",
p, target);
strlcpy(inq.revision, "   ", sizeof inq.revision);
cac_copy_internal_data(xs, &inq, sizeof inq);
  624                 break;
  626         case READ_CAPACITY:
  627                 if (cac_get_dinfo(sc, target)) {
xs->error = XS_DRIVER_STUFFUP;
  629                         break;
  630                 }
bzero(&rcd, sizeof rcd);
_lto4b( CAC_GET2(dinfo->ncylinders) * CAC_GET1(dinfo->nheads) *
CAC_GET1(dinfo->nsectors) - 1, rcd.addr);
_lto4b(CAC_SECTOR_SIZE, rcd.length);
cac_copy_internal_data(xs, &rcd, sizeof rcd);
  636                 break;
  638         case PREVENT_ALLOW:
  639                 break;
  641         case SYNCHRONIZE_CACHE:
  642                 if (cac_flush(sc))
xs->error = XS_DRIVER_STUFFUP;
  644                 break;
  646         case READ_COMMAND:
  647         case READ_BIG:
  648         case WRITE_COMMAND:
  649         case WRITE_BIG:
flags = 0;
  652                 /* A read or write operation. */
  653                 if (xs->cmdlen == 6) {
rw = (struct scsi_rw *)xs->cmd;
blockno = _3btol(rw->addr) &
  656                             (SRW_TOPADDR << 16 | 0xffff);
blockcnt = rw->length ? rw->length : 0x100;
  658                 } else {
rwb = (struct scsi_rw_big *)xs->cmd;
blockno = _4btol(rwb->addr);
blockcnt = _2btol(rwb->length);
  662                 }
size = CAC_GET2(dinfo->ncylinders) *
CAC_GET1(dinfo->nheads) * CAC_GET1(dinfo->nsectors);
  665                 if (blockno >= size || blockno + blockcnt > size) {
printf("%s: out of bounds %u-%u >= %u\n",
sc->sc_dv.dv_xname, blockno, blockcnt, size);
xs->error = XS_DRIVER_STUFFUP;
scsi_done(xs);
  670                         break;
  671                 }
  673                 switch (xs->cmd->opcode) {
  674                 case READ_COMMAND:
  675                 case READ_BIG:
op = CAC_CMD_READ;
flags = CAC_CCB_DATA_IN;
  678                         break;
  679                 case WRITE_COMMAND:
  680                 case WRITE_BIG:
op = CAC_CMD_WRITE;
flags = CAC_CCB_DATA_OUT;
  683                         break;
  684                 }
poll = xs->flags & SCSI_POLL;
  687                 if ((error = cac_cmd(sc, op, xs->data, blockcnt * DEV_BSIZE,
target, blockno, flags, xs))) {
  690                         if (error == ENOMEM) {
splx(s);
  692                                 return (TRY_AGAIN_LATER);
  693                         } else if (poll) {
splx(s);
  695                                 return (TRY_AGAIN_LATER);
  696                         } else {
xs->error = XS_DRIVER_STUFFUP;
scsi_done(xs);
  699                                 break;
  700                         }
  701                 }
splx(s);
  705                 if (poll)
  706                         return (COMPLETE);
  707                 else
  708                         return (SUCCESSFULLY_QUEUED);
  710         default:
SC_DEBUG(link, SDEV_DB1, ("unsupported scsi command %#x "
  712                     "tgt %d ", xs->cmd->opcode, target));
xs->error = XS_DRIVER_STUFFUP;
  714         }
splx(s);
  717         return (COMPLETE);
  718 }
  720 /*
  721  * Board specific linkage shared between multiple bus types.
  722  */
  724 int
cac_l0_fifo_full(struct cac_softc *sc)
  726 {
  728         return (cac_inl(sc, CAC_REG_CMD_FIFO) == 0);
  729 }
  731 void
cac_l0_submit(struct cac_softc *sc, struct cac_ccb *ccb)
  733 {
  734 #ifdef CAC_DEBUG
printf("submit-%x ", ccb->ccb_paddr);
  736 #endif
bus_dmamap_sync(sc->sc_dmat, sc->sc_dmamap, 0,
sc->sc_dmamap->dm_mapsize,
BUS_DMASYNC_PREWRITE | BUS_DMASYNC_PREREAD);
cac_outl(sc, CAC_REG_CMD_FIFO, ccb->ccb_paddr);
  741 }
  743 struct cac_ccb *
cac_l0_completed(sc)
  745         struct cac_softc *sc;
  746 {
  747         struct cac_ccb *ccb;
paddr_t off;
  750         if (!(off = cac_inl(sc, CAC_REG_DONE_FIFO)))
  751                 return NULL;
  752 #ifdef CAC_DEBUG
printf("compl-%x ", off);
  754 #endif
  755         if (off & 3 && ccb->ccb_req.error == 0)
ccb->ccb_req.error = CAC_RET_CMD_INVALID;
off = (off & ~3) - sc->sc_ccbs_paddr;
ccb = (struct cac_ccb *)(sc->sc_ccbs + off);
bus_dmamap_sync(sc->sc_dmat, sc->sc_dmamap, 0,
sc->sc_dmamap->dm_mapsize,
BUS_DMASYNC_POSTWRITE | BUS_DMASYNC_POSTREAD);
  765         return (ccb);
  766 }
  768 int
cac_l0_intr_pending(struct cac_softc *sc)
  770 {
  772         return (cac_inl(sc, CAC_REG_INTR_PENDING));
  773 }
  775 void
cac_l0_intr_enable(struct cac_softc *sc, int state)
  777 {
cac_outl(sc, CAC_REG_INTR_MASK,
state ? CAC_INTR_ENABLE : CAC_INTR_DISABLE);
  781 }