root/dev/usb/umass_scsi.c

DEFINITIONS

1. umass_scsi_attach
2. umass_atapi_attach
3. umass_scsi_setup
4. umass_scsi_cmd
5. umass_scsi_minphys
6. umass_scsi_cb
7. umass_scsi_sense_cb

    1 /*      $OpenBSD: umass_scsi.c,v 1.18 2007/06/13 10:33:52 mbalmer Exp $ */
    2 /*      $NetBSD: umass_scsipi.c,v 1.9 2003/02/16 23:14:08 augustss Exp $        */
    3 /*
    4  * Copyright (c) 2001 The NetBSD Foundation, Inc.
    5  * All rights reserved.
    6  *
    7  * This code is derived from software contributed to The NetBSD Foundation
    8  * by Lennart Augustsson (lennart@augustsson.net) at
    9  * Carlstedt Research & Technology.
   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 #include "atapiscsi.h"
   42 #include <sys/param.h>
   43 #include <sys/systm.h>
   44 #include <sys/kernel.h>
   45 #include <sys/conf.h>
   46 #include <sys/buf.h>
   47 #include <sys/device.h>
   48 #include <sys/ioctl.h>
   49 #include <sys/malloc.h>
   51 #include <dev/usb/usb.h>
   52 #include <dev/usb/usbdi.h>
   53 #include <dev/usb/usbdi_util.h>
   54 #include <dev/usb/usbdevs.h>
   56 #include <dev/usb/umassvar.h>
   57 #include <dev/usb/umass_scsi.h>
   59 #include <scsi/scsi_all.h>
   60 #include <scsi/scsiconf.h>
   61 #include <scsi/scsi_disk.h>
   62 #include <machine/bus.h>
   64 struct umass_scsi_softc {
   65         struct umassbus_softc   base;
   66         struct scsi_link        sc_link;
   67         struct scsi_adapter     sc_adapter;
   69         struct scsi_sense       sc_sense_cmd;
   70 };
   73 #define UMASS_SCSIID_HOST       0x00
   74 #define UMASS_SCSIID_DEVICE     0x01
   76 #define UMASS_ATAPI_DRIVE       0
   78 int umass_scsi_cmd(struct scsi_xfer *);
   79 void umass_scsi_minphys(struct buf *);
   81 void umass_scsi_cb(struct umass_softc *sc, void *priv, int residue,
   82                    int status);
   83 void umass_scsi_sense_cb(struct umass_softc *sc, void *priv, int residue,
   84                          int status);
   85 struct umass_scsi_softc *umass_scsi_setup(struct umass_softc *);
   87 struct scsi_device umass_scsi_dev = { NULL, NULL, NULL, NULL, };
   89 #if NATAPISCSI > 0
   90 struct scsi_device umass_atapiscsi_dev = { NULL, NULL, NULL, NULL, };
   91 #endif
   93 int
umass_scsi_attach(struct umass_softc *sc)
   95 {
   96         struct scsibus_attach_args saa;
   97         struct umass_scsi_softc *scbus;
scbus = umass_scsi_setup(sc);
scbus->sc_link.adapter_target = UMASS_SCSIID_HOST;
scbus->sc_link.luns = sc->maxlun + 1;
scbus->sc_link.flags &= ~SDEV_ATAPI;
scbus->sc_link.flags |= SDEV_UMASS;
scbus->sc_link.device = &umass_scsi_dev;
bzero(&saa, sizeof(saa));
saa.saa_sc_link = &scbus->sc_link;
DPRINTF(UDMASS_USB, ("%s: umass_attach_bus: SCSI\n"
  110                              "sc = 0x%x, scbus = 0x%x\n",
sc->sc_dev.dv_xname, sc, scbus));
sc->sc_refcnt++;
scbus->base.sc_child =
config_found((struct device *)sc, &saa, scsiprint);
  116         if (--sc->sc_refcnt < 0)
usb_detach_wakeup(&sc->sc_dev);
  119         return (0);
  120 }
  122 #if NATAPISCSI > 0
  123 int
umass_atapi_attach(struct umass_softc *sc)
  125 {
  126         struct scsibus_attach_args saa;
  127         struct umass_scsi_softc *scbus;
scbus = umass_scsi_setup(sc);
scbus->sc_link.adapter_target = UMASS_SCSIID_HOST;
scbus->sc_link.luns = 1;
scbus->sc_link.openings = 1;
scbus->sc_link.flags |= SDEV_ATAPI;
scbus->sc_link.device = &umass_atapiscsi_dev;
bzero(&saa, sizeof(saa));
saa.saa_sc_link = &scbus->sc_link;
DPRINTF(UDMASS_USB, ("%s: umass_attach_bus: ATAPI\n"
  140                              "sc = 0x%x, scbus = 0x%x\n",
sc->sc_dev.dv_xname, sc, scbus));
sc->sc_refcnt++;
scbus->base.sc_child = config_found((struct device *)sc,
  145             &saa, scsiprint);
  146         if (--sc->sc_refcnt < 0)
usb_detach_wakeup(&sc->sc_dev);
  149         return (0);
  150 }
  151 #endif
  153 struct umass_scsi_softc *
umass_scsi_setup(struct umass_softc *sc)
  155 {
  156         struct umass_scsi_softc *scbus;
scbus = malloc(sizeof(struct umass_scsi_softc), M_DEVBUF, M_WAITOK);
memset(&scbus->sc_link, 0, sizeof(struct scsi_link));
memset(&scbus->sc_adapter, 0, sizeof(struct scsi_adapter));
sc->bus = (struct umassbus_softc *)scbus;
  164         /* Fill in the adapter. */
scbus->sc_adapter.scsi_cmd = umass_scsi_cmd;
scbus->sc_adapter.scsi_minphys = umass_scsi_minphys;
  168         /* Fill in the link. */
scbus->sc_link.adapter_buswidth = 2;
scbus->sc_link.adapter = &scbus->sc_adapter;
scbus->sc_link.adapter_softc = sc;
scbus->sc_link.openings = 1;
scbus->sc_link.quirks |= SDEV_ONLYBIG | sc->sc_busquirks;
  175         return (scbus);
  176 }
  178 int
umass_scsi_cmd(struct scsi_xfer *xs)
  180 {
  181         struct scsi_link *sc_link = xs->sc_link;
  182         struct umass_softc *sc = sc_link->adapter_softc;
  184         struct scsi_generic *cmd;
  185         int cmdlen, dir, s;
  187 #ifdef UMASS_DEBUG
microtime(&sc->tv);
  189 #endif
DIF(UDMASS_UPPER, sc_link->flags |= SCSIDEBUG_LEVEL);
DPRINTF(UDMASS_CMD, ("%s: umass_scsi_cmd: at %lu.%06lu: %d:%d "
  194                 "xs=%p cmd=0x%02x datalen=%d (quirks=0x%x, poll=%d)\n",
sc->sc_dev.dv_xname, sc->tv.tv_sec, sc->tv.tv_usec,
sc_link->target, sc_link->lun, xs, xs->cmd->opcode,
xs->datalen, sc_link->quirks, xs->flags & SCSI_POLL));
  199 #if defined(USB_DEBUG) && defined(SCSIDEBUG)
  200         if (umassdebug & UDMASS_SCSI)
show_scsi_xs(xs);
  202         else if (umassdebug & ~UDMASS_CMD)
show_scsi_cmd(xs);
  204 #endif
  206         if (sc->sc_dying) {
xs->error = XS_DRIVER_STUFFUP;
  208                 goto done;
  209         }
  211 #if defined(UMASS_DEBUG)
  212         if (sc_link->target != UMASS_SCSIID_DEVICE) {
DPRINTF(UDMASS_SCSI, ("%s: wrong SCSI ID %d\n",
sc->sc_dev.dv_xname, sc_link->target));
xs->error = XS_DRIVER_STUFFUP;
  216                 goto done;
  217         }
  218 #endif
cmd = xs->cmd;
cmdlen = xs->cmdlen;
dir = DIR_NONE;
  224         if (xs->datalen) {
  225                 switch (xs->flags & (SCSI_DATA_IN | SCSI_DATA_OUT)) {
  226                 case SCSI_DATA_IN:
dir = DIR_IN;
  228                         break;
  229                 case SCSI_DATA_OUT:
dir = DIR_OUT;
  231                         break;
  232                 }
  233         }
  235         if (xs->datalen > UMASS_MAX_TRANSFER_SIZE) {
printf("umass_cmd: large datalen, %d\n", xs->datalen);
xs->error = XS_DRIVER_STUFFUP;
  238                 goto done;
  239         }
  241         if (xs->flags & SCSI_POLL) {
DPRINTF(UDMASS_SCSI, ("umass_scsi_cmd: sync dir=%d\n", dir));
usbd_set_polling(sc->sc_udev, 1);
sc->sc_xfer_flags = USBD_SYNCHRONOUS;
sc->polled_xfer_status = USBD_INVAL;
sc->sc_methods->wire_xfer(sc, sc_link->lun, cmd, cmdlen,
xs->data, xs->datalen, dir,
xs->timeout, umass_scsi_cb, xs);
sc->sc_xfer_flags = 0;
DPRINTF(UDMASS_SCSI, ("umass_scsi_cmd: done err=%d\n",
sc->polled_xfer_status));
  252                 if (xs->error == XS_NOERROR) {
  253                         switch (sc->polled_xfer_status) {
  254                         case USBD_NORMAL_COMPLETION:
xs->error = XS_NOERROR;
  256                                 break;
  257                         case USBD_TIMEOUT:
xs->error = XS_TIMEOUT;
  259                                 break;
  260                         default:
xs->error = XS_DRIVER_STUFFUP;
  262                                 break;
  263                         }
  264                 }
usbd_set_polling(sc->sc_udev, 0);
DPRINTF(UDMASS_SCSI, ("umass_scsi_cmd: done, error=%d\n",
xs->error));
  268         } else {
DPRINTF(UDMASS_SCSI,
  270                         ("umass_scsi_cmd: async dir=%d, cmdlen=%d"
  271                          " datalen=%d\n",
dir, cmdlen, xs->datalen));
sc->sc_methods->wire_xfer(sc, sc_link->lun, cmd, cmdlen,
xs->data, xs->datalen, dir,
xs->timeout, umass_scsi_cb, xs);
  276                 return (SUCCESSFULLY_QUEUED);
  277         }
  279         /* Return if command finishes early. */
done:
xs->flags |= ITSDONE;
s = splbio();
scsi_done(xs);
splx(s);
  286         if (xs->flags & SCSI_POLL)
  287                 return (COMPLETE);
  288         else
  289                 return (SUCCESSFULLY_QUEUED);
  290 }
  292 void
umass_scsi_minphys(struct buf *bp)
  294 {
  295         if (bp->b_bcount > UMASS_MAX_TRANSFER_SIZE)
bp->b_bcount = UMASS_MAX_TRANSFER_SIZE;
minphys(bp);
  299 }
  301 void
umass_scsi_cb(struct umass_softc *sc, void *priv, int residue, int status)
  303 {
  304         struct umass_scsi_softc *scbus = (struct umass_scsi_softc *)sc->bus;
  305         struct scsi_xfer *xs = priv;
  306         struct scsi_link *link = xs->sc_link;
  307         int cmdlen;
  308         int s;
  309 #ifdef UMASS_DEBUG
  310         struct timeval tv;
u_int delta;
microtime(&tv);
delta = (tv.tv_sec - sc->tv.tv_sec) * 1000000 +
tv.tv_usec - sc->tv.tv_usec;
  315 #endif
DPRINTF(UDMASS_CMD,
  318                 ("umass_scsi_cb: at %lu.%06lu, delta=%u: xs=%p residue=%d"
  319                  " status=%d\n", tv.tv_sec, tv.tv_usec, delta, xs, residue,
status));
xs->resid = residue;
  324         switch (status) {
  325         case STATUS_CMD_OK:
xs->error = XS_NOERROR;
  327                 break;
  329         case STATUS_CMD_UNKNOWN:
DPRINTF(UDMASS_CMD, ("umass_scsi_cb: status cmd unknown\n"));
  331                 /* we can't issue REQUEST SENSE */
  332                 if (xs->sc_link->quirks & ADEV_NOSENSE) {
  333                         /*
  334                          * If no residue and no other USB error,
  335                          * command succeeded.
  336                          */
  337                         if (residue == 0) {
xs->error = XS_NOERROR;
  339                                 break;
  340                         }
  342                         /*
  343                          * Some devices return a short INQUIRY
  344                          * response, omitting response data from the
  345                          * "vendor specific data" on...
  346                          */
  347                         if (xs->cmd->opcode == INQUIRY &&
residue < xs->datalen) {
xs->error = XS_NOERROR;
  350                                 break;
  351                         }
xs->error = XS_DRIVER_STUFFUP;
  354                         break;
  355                 }
  356                 /* FALLTHROUGH */
  357         case STATUS_CMD_FAILED:
DPRINTF(UDMASS_CMD, ("umass_scsi_cb: status cmd failed for "
  359                     "scsi op 0x%02x\n", xs->cmd->opcode));
  360                 /* fetch sense data */
sc->sc_sense = 1;
memset(&scbus->sc_sense_cmd, 0, sizeof(scbus->sc_sense_cmd));
scbus->sc_sense_cmd.opcode = REQUEST_SENSE;
scbus->sc_sense_cmd.byte2 = link->lun << SCSI_CMD_LUN_SHIFT;
scbus->sc_sense_cmd.length = sizeof(xs->sense);
cmdlen = sizeof(scbus->sc_sense_cmd);
sc->sc_methods->wire_xfer(sc, link->lun,
  369                                           &scbus->sc_sense_cmd, cmdlen,
  370                                           &xs->sense, sizeof(xs->sense),
DIR_IN, xs->timeout,
umass_scsi_sense_cb, xs);
  373                 return;
  375         case STATUS_WIRE_FAILED:
xs->error = XS_RESET;
  377                 break;
  379         default:
panic("%s: Unknown status %d in umass_scsi_cb",
sc->sc_dev.dv_xname, status);
  382         }
  384         if (xs->flags & SCSI_POLL)
  385                 return;
xs->flags |= ITSDONE;
DPRINTF(UDMASS_CMD,("umass_scsi_cb: at %lu.%06lu: return error=%d, "
  390                             "status=0x%x resid=%d\n",
tv.tv_sec, tv.tv_usec,
xs->error, xs->status, xs->resid));
s = splbio();
scsi_done(xs);
splx(s);
  397 }
  399 /*
  400  * Finalise a completed autosense operation
  401  */
  402 void
umass_scsi_sense_cb(struct umass_softc *sc, void *priv, int residue,
  404                     int status)
  405 {
  406         struct scsi_xfer *xs = priv;
  407         int s;
DPRINTF(UDMASS_CMD,("umass_scsi_sense_cb: xs=%p residue=%d "
  410                 "status=%d\n", xs, residue, status));
sc->sc_sense = 0;
  413         switch (status) {
  414         case STATUS_CMD_OK:
  415         case STATUS_CMD_UNKNOWN:
  416                 /* getting sense data succeeded */
  417                 if (residue == 0 || residue == 14)/* XXX */
xs->error = XS_SENSE;
  419                 else
xs->error = XS_SHORTSENSE;
  421                 break;
  422         default:
DPRINTF(UDMASS_SCSI, ("%s: Autosense failed, status %d\n",
sc->sc_dev.dv_xname, status));
xs->error = XS_DRIVER_STUFFUP;
  426                 break;
  427         }
xs->flags |= ITSDONE;
DPRINTF(UDMASS_CMD,("umass_scsi_sense_cb: return xs->error=%d, "
  432                 "xs->flags=0x%x xs->resid=%d\n", xs->error, xs->status,
xs->resid));
s = splbio();
scsi_done(xs);
splx(s);
  438 }