root/dev/usb/umass.c

DEFINITIONS

1. umass_match
2. umass_attach
3. umass_detach
4. umass_activate
5. umass_disco
6. umass_polled_transfer
7. umass_setup_transfer
8. umass_setup_ctrl_transfer
9. umass_adjust_transfer
10. umass_clear_endpoint_stall
11. umass_reset
12. umass_bbb_reset
13. umass_bbb_transfer
14. umass_bbb_state
15. umass_cbi_adsc
16. umass_cbi_reset
17. umass_cbi_transfer
18. umass_cbi_state
19. umass_bbb_get_max_lun
20. umass_bbb_dump_cbw
21. umass_bbb_dump_csw
22. umass_dump_buffer

    1 /*      $OpenBSD: umass.c,v 1.52 2007/06/14 10:11:16 mbalmer Exp $ */
    2 /*      $NetBSD: umass.c,v 1.116 2004/06/30 05:53:46 mycroft Exp $      */
    4 /*
    5  * Copyright (c) 2003 The NetBSD Foundation, Inc.
    6  * All rights reserved.
    7  *
    8  * This code is derived from software contributed to The NetBSD Foundation
    9  * by Charles M. Hannum.
   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  * Copyright (c) 1999 MAEKAWA Masahide <bishop@rr.iij4u.or.jp>,
   42  *                    Nick Hibma <n_hibma@freebsd.org>
   43  * All rights reserved.
   44  *
   45  * Redistribution and use in source and binary forms, with or without
   46  * modification, are permitted provided that the following conditions
   47  * are met:
   48  * 1. Redistributions of source code must retain the above copyright
   49  *    notice, this list of conditions and the following disclaimer.
   50  * 2. Redistributions in binary form must reproduce the above copyright
   51  *    notice, this list of conditions and the following disclaimer in the
   52  *    documentation and/or other materials provided with the distribution.
   53  *
   54  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
   55  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
   56  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
   57  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
   58  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
   59  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
   60  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
   61  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
   62  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
   63  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
   64  * SUCH DAMAGE.
   65  *
   66  *     $FreeBSD: src/sys/dev/usb/umass.c,v 1.13 2000/03/26 01:39:12 n_hibma Exp $
   67  */
   69 /*
   70  * Universal Serial Bus Mass Storage Class specs:
   71  * http://www.usb.org/developers/devclass_docs/usb_msc_overview_1.2.pdf
   72  * http://www.usb.org/developers/devclass_docs/usbmassbulk_10.pdf
   73  * http://www.usb.org/developers/devclass_docs/usb_msc_cbi_1.1.pdf
   74  * http://www.usb.org/developers/devclass_docs/usbmass-ufi10.pdf
   75  */
   77 /*
   78  * Ported to NetBSD by Lennart Augustsson <augustss@NetBSD.org>.
   79  * Parts of the code written by Jason R. Thorpe <thorpej@shagadelic.org>.
   80  */
   82 /*
   83  * The driver handles 3 Wire Protocols
   84  * - Command/Bulk/Interrupt (CBI)
   85  * - Command/Bulk/Interrupt with Command Completion Interrupt (CBI with CCI)
   86  * - Mass Storage Bulk-Only (BBB)
   87  *   (BBB refers Bulk/Bulk/Bulk for Command/Data/Status phases)
   88  *
   89  * Over these wire protocols it handles the following command protocols
   90  * - SCSI
   91  * - 8070 (ATA/ATAPI for rewritable removable media)
   92  * - UFI (USB Floppy Interface)
   93  *
   94  * 8070i is a transformed version of the SCSI command set. UFI is a transformed
   95  * version of the 8070i command set.  The sc->transform method is used to
   96  * convert the commands into the appropriate format (if at all necessary).
   97  * For example, ATAPI requires all commands to be 12 bytes in length amongst
   98  * other things.
   99  *
  100  * The source code below is marked and can be split into a number of pieces
  101  * (in this order):
  102  *
  103  * - probe/attach/detach
  104  * - generic transfer routines
  105  * - BBB
  106  * - CBI
  107  * - CBI_I (in addition to functions from CBI)
  108  * - CAM (Common Access Method)
  109  * - SCSI
  110  * - UFI
  111  * - 8070i
  112  *
  113  * The protocols are implemented using a state machine, for the transfers as
  114  * well as for the resets. The state machine is contained in umass_*_state.
  115  * The state machine is started through either umass_*_transfer or
  116  * umass_*_reset.
  117  *
  118  * The reason for doing this is a) CAM performs a lot better this way and b) it
  119  * avoids using tsleep from interrupt context (for example after a failed
  120  * transfer).
  121  */
  123 /*
  124  * The SCSI related part of this driver has been derived from the
  125  * dev/ppbus/vpo.c driver, by Nicolas Souchu (nsouch@freebsd.org).
  126  *
  127  * The CAM layer uses so called actions which are messages sent to the host
  128  * adapter for completion. The actions come in through umass_cam_action. The
  129  * appropriate block of routines is called depending on the transport protocol
  130  * in use. When the transfer has finished, these routines call
  131  * umass_cam_cb again to complete the CAM command.
  132  */
  134 #include "atapiscsi.h"
  136 #include <sys/param.h>
  137 #include <sys/systm.h>
  138 #include <sys/kernel.h>
  139 #include <sys/conf.h>
  140 #include <sys/buf.h>
  141 #include <sys/device.h>
  142 #include <sys/malloc.h>
  143 #include <sys/timeout.h>
  144 #undef KASSERT
  145 #define KASSERT(cond, msg)
  146 #include <machine/bus.h>
  148 #include <scsi/scsi_all.h>
  150 #include <dev/usb/usb.h>
  151 #include <dev/usb/usbdi.h>
  152 #include <dev/usb/usbdi_util.h>
  153 #include <dev/usb/usbdivar.h>
  154 #include <dev/usb/usbdevs.h>
  156 #include <dev/usb/umassvar.h>
  157 #include <dev/usb/umass_quirks.h>
  158 #include <dev/usb/umass_scsi.h>
  161 #ifdef UMASS_DEBUG
  162 int umassdebug = 0;
  164 char *states[TSTATE_STATES+1] = {
  165         /* should be kept in sync with the list at transfer_state */
  166         "Idle",
  167         "BBB CBW",
  168         "BBB Data",
  169         "BBB Data bulk-in/-out clear stall",
  170         "BBB CSW, 1st attempt",
  171         "BBB CSW bulk-in clear stall",
  172         "BBB CSW, 2nd attempt",
  173         "BBB Reset",
  174         "BBB bulk-in clear stall",
  175         "BBB bulk-out clear stall",
  176         "CBI Command",
  177         "CBI Data",
  178         "CBI Status",
  179         "CBI Data bulk-in/-out clear stall",
  180         "CBI Status intr-in clear stall",
  181         "CBI Reset",
  182         "CBI bulk-in clear stall",
  183         "CBI bulk-out clear stall",
NULL
  185 };
  186 #endif
  188 /* USB device probe/attach/detach functions */
  189 int umass_match(struct device *, void *, void *); 
  190 void umass_attach(struct device *, struct device *, void *); 
  191 int umass_detach(struct device *, int); 
  192 int umass_activate(struct device *, enum devact); 
  194 struct cfdriver umass_cd = { 
NULL, "umass", DV_DULL 
  196 }; 
  198 const struct cfattach umass_ca = { 
  199         sizeof(struct umass_softc), 
umass_match, 
umass_attach, 
umass_detach, 
umass_activate, 
  204 };
  205 void umass_disco(struct umass_softc *sc);
  207 /* generic transfer functions */
usbd_status umass_polled_transfer(struct umass_softc *sc,
usbd_xfer_handle xfer);
usbd_status umass_setup_transfer(struct umass_softc *sc,
usbd_pipe_handle pipe,
  212                                 void *buffer, int buflen, int flags,
usbd_xfer_handle xfer);
usbd_status umass_setup_ctrl_transfer(struct umass_softc *sc,
usb_device_request_t *req,
  216                                 void *buffer, int buflen, int flags,
usbd_xfer_handle xfer);
  218 void umass_clear_endpoint_stall(struct umass_softc *sc, int endpt,
usbd_xfer_handle xfer);
  220 void umass_adjust_transfer(struct umass_softc *);
  221 #if 0
  222 void umass_reset(struct umass_softc *sc,        transfer_cb_f cb, void *priv);
  223 #endif
  225 /* Bulk-Only related functions */
  226 void umass_bbb_transfer(struct umass_softc *, int, void *, int, void *,
  227                                int, int, u_int, umass_callback, void *);
  228 void umass_bbb_reset(struct umass_softc *, int);
  229 void umass_bbb_state(usbd_xfer_handle, usbd_private_handle, usbd_status);
usbd_status umass_bbb_get_max_lun(struct umass_softc *, u_int8_t *);
  233 /* CBI related functions */
  234 void umass_cbi_transfer(struct umass_softc *, int, void *, int, void *,
  235                                int, int, u_int, umass_callback, void *);
  236 void umass_cbi_reset(struct umass_softc *, int);
  237 void umass_cbi_state(usbd_xfer_handle, usbd_private_handle, usbd_status);
  239 int umass_cbi_adsc(struct umass_softc *, char *, int, usbd_xfer_handle);
  241 const struct umass_wire_methods umass_bbb_methods = {
umass_bbb_transfer,
umass_bbb_reset,
umass_bbb_state
  245 };
  247 const struct umass_wire_methods umass_cbi_methods = {
umass_cbi_transfer,
umass_cbi_reset,
umass_cbi_state
  251 };
  253 #ifdef UMASS_DEBUG
  254 /* General debugging functions */
  255 void umass_bbb_dump_cbw(struct umass_softc *sc,
umass_bbb_cbw_t *cbw);
  257 void umass_bbb_dump_csw(struct umass_softc *sc,
umass_bbb_csw_t *csw);
  259 void umass_dump_buffer(struct umass_softc *sc, u_int8_t *buffer,
  260                                 int buflen, int printlen);
  261 #endif
  264 /*
  265  * USB device probe/attach/detach
  266  */
  268 int
umass_match(struct device *parent, void *match, void *aux)
  270 {
  271         struct usb_attach_arg *uaa = aux;
  272         const struct umass_quirk *quirk;
usb_interface_descriptor_t *id;
  275         if (uaa->iface == NULL)
  276                 return (UMATCH_NONE);
quirk = umass_lookup(uaa->vendor, uaa->product);
  279         if (quirk != NULL)
  280                 return (quirk->uq_match);
id = usbd_get_interface_descriptor(uaa->iface);
  283         if (id == NULL || id->bInterfaceClass != UICLASS_MASS)
  284                 return (UMATCH_NONE);
  286         switch (id->bInterfaceSubClass) {
  287         case UISUBCLASS_RBC:
  288         case UISUBCLASS_SFF8020I:
  289         case UISUBCLASS_QIC157:
  290         case UISUBCLASS_UFI:
  291         case UISUBCLASS_SFF8070I:
  292         case UISUBCLASS_SCSI:
  293                 break;
  294         default:
  295                 return (UMATCH_IFACECLASS);
  296         }
  298         switch (id->bInterfaceProtocol) {
  299         case UIPROTO_MASS_CBI_I:
  300         case UIPROTO_MASS_CBI:
  301         case UIPROTO_MASS_BBB_OLD:
  302         case UIPROTO_MASS_BBB:
  303                 break;
  304         default:
  305                 return (UMATCH_IFACECLASS_IFACESUBCLASS);
  306         }
  308         return (UMATCH_IFACECLASS_IFACESUBCLASS_IFACEPROTO);
  309 }
  311 void
umass_attach(struct device *parent, struct device *self, void *aux)
  313 {
  314         struct umass_softc *sc = (struct umass_softc *)self;
  315         struct usb_attach_arg *uaa = aux;
  316         const struct umass_quirk *quirk;
usb_interface_descriptor_t *id;
usb_endpoint_descriptor_t *ed;
  319         const char *sWire, *sCommand;
  320         char *devinfop;
usbd_status err;
  322         int i, bno, error;
devinfop = usbd_devinfo_alloc(uaa->device, 0);
printf("\n%s: %s\n", sc->sc_dev.dv_xname, devinfop);
usbd_devinfo_free(devinfop);
sc->sc_udev = uaa->device;
sc->sc_iface = uaa->iface;
sc->sc_ifaceno = uaa->ifaceno;
quirk = umass_lookup(uaa->vendor, uaa->product);
  333         if (quirk != NULL) {
sc->sc_wire = quirk->uq_wire;
sc->sc_cmd = quirk->uq_cmd;
sc->sc_quirks = quirk->uq_flags;
sc->sc_busquirks = quirk->uq_busquirks;
  339                 if (quirk->uq_fixup != NULL)
  340                         (*quirk->uq_fixup)(sc);
  341         } else {
sc->sc_wire = UMASS_WPROTO_UNSPEC;
sc->sc_cmd = UMASS_CPROTO_UNSPEC;
sc->sc_quirks = 0;
sc->sc_busquirks = 0;
  346         }
id = usbd_get_interface_descriptor(sc->sc_iface);
  349         if (id == NULL)
  350                 return;
  352         if (sc->sc_wire == UMASS_WPROTO_UNSPEC) {
  353                 switch (id->bInterfaceProtocol) {
  354                 case UIPROTO_MASS_CBI:
sc->sc_wire = UMASS_WPROTO_CBI;
  356                         break;
  357                 case UIPROTO_MASS_CBI_I:
sc->sc_wire = UMASS_WPROTO_CBI_I;
  359                         break;
  360                 case UIPROTO_MASS_BBB:
  361                 case UIPROTO_MASS_BBB_OLD:
sc->sc_wire = UMASS_WPROTO_BBB;
  363                         break;
  364                 default:
DPRINTF(UDMASS_GEN,
  366                                 ("%s: Unsupported wire protocol %u\n",
sc->sc_dev.dv_xname,
id->bInterfaceProtocol));
  369                         return;
  370                 }
  371         }
  373         if (sc->sc_cmd == UMASS_CPROTO_UNSPEC) {
  374                 switch (id->bInterfaceSubClass) {
  375                 case UISUBCLASS_SCSI:
sc->sc_cmd = UMASS_CPROTO_SCSI;
  377                         break;
  378                 case UISUBCLASS_UFI:
sc->sc_cmd = UMASS_CPROTO_UFI;
  380                         break;
  381                 case UISUBCLASS_SFF8020I:
  382                 case UISUBCLASS_SFF8070I:
  383                 case UISUBCLASS_QIC157:
sc->sc_cmd = UMASS_CPROTO_ATAPI;
  385                         break;
  386                 case UISUBCLASS_RBC:
sc->sc_cmd = UMASS_CPROTO_RBC;
  388                         break;
  389                 default:
DPRINTF(UDMASS_GEN,
  391                                 ("%s: Unsupported command protocol %u\n",
sc->sc_dev.dv_xname,
id->bInterfaceSubClass));
  394                         return;
  395                 }
  396         }
  398         switch (sc->sc_wire) {
  399         case UMASS_WPROTO_CBI:
sWire = "CBI";
  401                 break;
  402         case UMASS_WPROTO_CBI_I:
sWire = "CBI with CCI";
  404                 break;
  405         case UMASS_WPROTO_BBB:
sWire = "Bulk-Only";
  407                 break;
  408         default:
sWire = "unknown";
  410                 break;
  411         }
  413         switch (sc->sc_cmd) {
  414         case UMASS_CPROTO_RBC:
sCommand = "RBC";
  416                 break;
  417         case UMASS_CPROTO_SCSI:
sCommand = "SCSI";
  419                 break;
  420         case UMASS_CPROTO_UFI:
sCommand = "UFI";
  422                 break;
  423         case UMASS_CPROTO_ATAPI:
sCommand = "ATAPI";
  425                 break;
  426         case UMASS_CPROTO_ISD_ATA:
sCommand = "ISD-ATA";
  428                 break;
  429         default:
sCommand = "unknown";
  431                 break;
  432         }
printf("%s: using %s over %s\n", sc->sc_dev.dv_xname, sCommand,
sWire);
  437         if (quirk != NULL && quirk->uq_init != NULL) {
err = (*quirk->uq_init)(sc);
  439                 if (err) {
umass_disco(sc);
  441                         return;
  442                 }
  443         }
  445         /*
  446          * In addition to the Control endpoint the following endpoints
  447          * are required:
  448          * a) bulk-in endpoint.
  449          * b) bulk-out endpoint.
  450          * and for Control/Bulk/Interrupt with CCI (CBI_I)
  451          * c) intr-in
  452          *
  453          * The endpoint addresses are not fixed, so we have to read them
  454          * from the device descriptors of the current interface.
  455          */
  456         for (i = 0 ; i < id->bNumEndpoints ; i++) {
ed = usbd_interface2endpoint_descriptor(sc->sc_iface, i);
  458                 if (ed == NULL) {
printf("%s: could not read endpoint descriptor\n",
sc->sc_dev.dv_xname);
  461                         return;
  462                 }
  463                 if (UE_GET_DIR(ed->bEndpointAddress) == UE_DIR_IN
  464                     && (ed->bmAttributes & UE_XFERTYPE) == UE_BULK) {
sc->sc_epaddr[UMASS_BULKIN] = ed->bEndpointAddress;
  466                 } else if (UE_GET_DIR(ed->bEndpointAddress) == UE_DIR_OUT
  467                     && (ed->bmAttributes & UE_XFERTYPE) == UE_BULK) {
sc->sc_epaddr[UMASS_BULKOUT] = ed->bEndpointAddress;
  469                 } else if (sc->sc_wire == UMASS_WPROTO_CBI_I
  470                     && UE_GET_DIR(ed->bEndpointAddress) == UE_DIR_IN
  471                     && (ed->bmAttributes & UE_XFERTYPE) == UE_INTERRUPT) {
sc->sc_epaddr[UMASS_INTRIN] = ed->bEndpointAddress;
  473 #ifdef UMASS_DEBUG
  474                         if (UGETW(ed->wMaxPacketSize) > 2) {
DPRINTF(UDMASS_CBI, ("%s: intr size is %d\n",
sc->sc_dev.dv_xname,
UGETW(ed->wMaxPacketSize)));
  478                         }
  479 #endif
  480                 }
  481         }
  483         /* check whether we found all the endpoints we need */
  484         if (!sc->sc_epaddr[UMASS_BULKIN] || !sc->sc_epaddr[UMASS_BULKOUT] ||
  485             (sc->sc_wire == UMASS_WPROTO_CBI_I &&
  486              !sc->sc_epaddr[UMASS_INTRIN])) {
DPRINTF(UDMASS_USB, ("%s: endpoint not found %u/%u/%u\n",
sc->sc_dev.dv_xname, sc->sc_epaddr[UMASS_BULKIN],
sc->sc_epaddr[UMASS_BULKOUT],
sc->sc_epaddr[UMASS_INTRIN]));
  491                 return;
  492         }
  494         /*
  495          * Get the maximum LUN supported by the device.
  496          */
  497         if (sc->sc_wire == UMASS_WPROTO_BBB) {
err = umass_bbb_get_max_lun(sc, &sc->maxlun);
  499                 if (err) {
printf("%s: unable to get Max Lun: %s\n",
sc->sc_dev.dv_xname, usbd_errstr(err));
  502                         return;
  503                 }
  504         } else {
sc->maxlun = 0;
  506         }
  508         /* Open the bulk-in and -out pipe */
DPRINTF(UDMASS_USB, ("%s: opening iface %p epaddr %d for BULKOUT\n",
sc->sc_dev.dv_xname, sc->sc_iface,
sc->sc_epaddr[UMASS_BULKOUT]));
err = usbd_open_pipe(sc->sc_iface, sc->sc_epaddr[UMASS_BULKOUT],
USBD_EXCLUSIVE_USE,
  514                                 &sc->sc_pipe[UMASS_BULKOUT]);
  515         if (err) {
DPRINTF(UDMASS_USB, ("%s: cannot open %u-out pipe (bulk)\n",
sc->sc_dev.dv_xname, sc->sc_epaddr[UMASS_BULKOUT]));
umass_disco(sc);
  519                 return;
  520         }
DPRINTF(UDMASS_USB, ("%s: opening iface %p epaddr %d for BULKIN\n",
sc->sc_dev.dv_xname, sc->sc_iface,
sc->sc_epaddr[UMASS_BULKIN]));
err = usbd_open_pipe(sc->sc_iface, sc->sc_epaddr[UMASS_BULKIN],
USBD_EXCLUSIVE_USE, &sc->sc_pipe[UMASS_BULKIN]);
  526         if (err) {
DPRINTF(UDMASS_USB, ("%s: could not open %u-in pipe (bulk)\n",
sc->sc_dev.dv_xname, sc->sc_epaddr[UMASS_BULKIN]));
umass_disco(sc);
  530                 return;
  531         }
  532         /*
  533          * Open the intr-in pipe if the protocol is CBI with CCI.
  534          * Note: early versions of the Zip drive do have an interrupt pipe, but
  535          * this pipe is unused
  536          *
  537          * We do not open the interrupt pipe as an interrupt pipe, but as a
  538          * normal bulk endpoint. We send an IN transfer down the wire at the
  539          * appropriate time, because we know exactly when to expect data on
  540          * that endpoint. This saves bandwidth, but more important, makes the
  541          * code for handling the data on that endpoint simpler. No data
  542          * arriving concurrently.
  543          */
  544         if (sc->sc_wire == UMASS_WPROTO_CBI_I) {
DPRINTF(UDMASS_USB, ("%s: opening iface %p epaddr %d for INTRIN\n",
sc->sc_dev.dv_xname, sc->sc_iface,
sc->sc_epaddr[UMASS_INTRIN]));
err = usbd_open_pipe(sc->sc_iface, sc->sc_epaddr[UMASS_INTRIN],
USBD_EXCLUSIVE_USE, &sc->sc_pipe[UMASS_INTRIN]);
  550                 if (err) {
DPRINTF(UDMASS_USB, ("%s: couldn't open %u-in (intr)\n",
sc->sc_dev.dv_xname,
sc->sc_epaddr[UMASS_INTRIN]));
umass_disco(sc);
  555                         return;
  556                 }
  557         }
  559         /* initialisation of generic part */
sc->transfer_state = TSTATE_IDLE;
  562         /* request a sufficient number of xfer handles */
  563         for (i = 0; i < XFER_NR; i++) {
sc->transfer_xfer[i] = usbd_alloc_xfer(uaa->device);
  565                 if (sc->transfer_xfer[i] == NULL) {
DPRINTF(UDMASS_USB, ("%s: Out of memory\n",
sc->sc_dev.dv_xname));
umass_disco(sc);
  569                         return;
  570                 }
  571         }
  572         /* Allocate buffer for data transfer (it's huge). */
  573         switch (sc->sc_wire) {
  574         case UMASS_WPROTO_BBB:
bno = XFER_BBB_DATA;
  576                 goto dalloc;
  577         case UMASS_WPROTO_CBI:
bno = XFER_CBI_DATA;
  579                 goto dalloc;
  580         case UMASS_WPROTO_CBI_I:
bno = XFER_CBI_DATA;
dalloc:
sc->data_buffer = usbd_alloc_buffer(sc->transfer_xfer[bno],
UMASS_MAX_TRANSFER_SIZE);
  585                 if (sc->data_buffer == NULL) {
umass_disco(sc);
  587                         return;
  588                 }
  589                 break;
  590         default:
  591                 break;
  592         }
  594         /* Initialise the wire protocol specific methods */
  595         switch (sc->sc_wire) {
  596         case UMASS_WPROTO_BBB:
sc->sc_methods = &umass_bbb_methods;
  598                 break;
  599         case UMASS_WPROTO_CBI:
  600         case UMASS_WPROTO_CBI_I:
sc->sc_methods = &umass_cbi_methods;
  602                 break;
  603         default:
umass_disco(sc);
  605                 return;
  606         }
error = 0;
  609         switch (sc->sc_cmd) {
  610         case UMASS_CPROTO_RBC:
  611         case UMASS_CPROTO_SCSI:
error = umass_scsi_attach(sc);
  613                 break;
  615         case UMASS_CPROTO_UFI:
  616         case UMASS_CPROTO_ATAPI:
  617 #if (NATAPIBUS > 0) || (NATAPISCSI > 0)
error = umass_atapi_attach(sc);
  619 #else
printf("%s: atapiscsi not configured\n", sc->sc_dev.dv_xname);
  621 #endif
  622                 break;
  624         case UMASS_CPROTO_ISD_ATA:
printf("%s: isdata not configured\n", sc->sc_dev.dv_xname);
  626                 break;
  628         default:
printf("%s: command protocol=0x%x not supported\n",
sc->sc_dev.dv_xname, sc->sc_cmd);
umass_disco(sc);
  632                 return;
  633         }
  634         if (error) {
printf("%s: bus attach failed\n", sc->sc_dev.dv_xname);
umass_disco(sc);
  637                 return;
  638         }
usbd_add_drv_event(USB_EVENT_DRIVER_ATTACH, sc->sc_udev,
  641                            &sc->sc_dev);
DPRINTF(UDMASS_GEN, ("%s: Attach finished\n", sc->sc_dev.dv_xname));
  644 }
  646 int
umass_detach(struct device *self, int flags)
  648 {
  649         struct umass_softc *sc = (struct umass_softc *)self;
  650         struct umassbus_softc *scbus;
  651         int rv = 0, i, s;
DPRINTF(UDMASS_USB, ("%s: detached\n", sc->sc_dev.dv_xname));
  655         /* Abort the pipes to wake up any waiting processes. */
  656         for (i = 0 ; i < UMASS_NEP ; i++) {
  657                 if (sc->sc_pipe[i] != NULL) {
usbd_abort_pipe(sc->sc_pipe[i]);
sc->sc_pipe[i] = NULL;
  660                 }
  661         }
  663         /* Do we really need reference counting?  Perhaps in ioctl() */
s = splusb();
  665         if (--sc->sc_refcnt >= 0) {
  666 #ifdef DIAGNOSTIC
printf("%s: waiting for refcnt\n", sc->sc_dev.dv_xname);
  668 #endif
  669                 /* Wait for processes to go away. */
usb_detach_wait(&sc->sc_dev);
  671         }
splx(s);
scbus = sc->bus;
  675         if (scbus != NULL) {
  676                 if (scbus->sc_child != NULL)
rv = config_detach(scbus->sc_child, flags);
free(scbus, M_DEVBUF);
sc->bus = NULL;
  680         }
  682         if (rv != 0)
  683                 return (rv);
umass_disco(sc);
usbd_add_drv_event(USB_EVENT_DRIVER_DETACH, sc->sc_udev,
  688                            &sc->sc_dev);
  690         return (rv);
  691 }
  693 int
umass_activate(struct device *dev, enum devact act)
  695 {
  696         struct umass_softc *sc = (struct umass_softc *)dev;
  697         struct umassbus_softc *scbus = sc->bus;
  698         int rv = 0;
DPRINTF(UDMASS_USB, ("%s: umass_activate: %d\n",
sc->sc_dev.dv_xname, act));
  703         switch (act) {
  704         case DVACT_ACTIVATE:
  705                 break;
  707         case DVACT_DEACTIVATE:
sc->sc_dying = 1;
  709                 if (scbus == NULL || scbus->sc_child == NULL)
  710                         break;
rv = config_deactivate(scbus->sc_child);
DPRINTF(UDMASS_USB, ("%s: umass_activate: child "
  713                     "returned %d\n", sc->sc_dev.dv_xname, rv));
  714                 break;
  715         }
  716         return (rv);
  717 }
  719 void
umass_disco(struct umass_softc *sc)
  721 {
  722         int i;
DPRINTF(UDMASS_GEN, ("umass_disco\n"));
  726         /* Free the xfers. */
  727         for (i = 0; i < XFER_NR; i++)
  728                 if (sc->transfer_xfer[i] != NULL) {
usbd_free_xfer(sc->transfer_xfer[i]);
sc->transfer_xfer[i] = NULL;
  731                 }
  733         /* Remove all the pipes. */
  734         for (i = 0 ; i < UMASS_NEP ; i++) {
  735                 if (sc->sc_pipe[i] != NULL) {
usbd_close_pipe(sc->sc_pipe[i]);
sc->sc_pipe[i] = NULL;
  738                 }
  739         }
  740 }
  742 /*
  743  * Generic functions to handle transfers
  744  */
usbd_status
umass_polled_transfer(struct umass_softc *sc, usbd_xfer_handle xfer)
  748 {
usbd_status err;
  751         if (sc->sc_dying)
  752                 return (USBD_IOERROR);
  754         /*
  755          * If a polled transfer is already in progress, preserve the new
  756          * usbd_xfer_handle and run it after the running one completes.
  757          * This converts the recursive calls into the umass_*_state callbacks
  758          * into iteration, preventing us from running out of stack under
  759          * error conditions.
  760          */
  761         if (sc->polling_depth) {
  762                 if (sc->next_polled_xfer)
panic("%s: got polled xfer %p, but %p already "
  764                             "pending\n", sc->sc_dev.dv_xname, xfer,
sc->next_polled_xfer);
DPRINTF(UDMASS_XFER, ("%s: saving polled xfer %p\n",
sc->sc_dev.dv_xname, xfer));
sc->next_polled_xfer = xfer;
  771                 return (USBD_IN_PROGRESS);
  772         }
sc->polling_depth++;
start_next_xfer:
DPRINTF(UDMASS_XFER, ("%s: start polled xfer %p\n",
sc->sc_dev.dv_xname, xfer));
err = usbd_transfer(xfer);
  780         if (err && err != USBD_IN_PROGRESS && sc->next_polled_xfer == NULL) {
DPRINTF(UDMASS_BBB, ("%s: failed to setup transfer, %s\n",
sc->sc_dev.dv_xname, usbd_errstr(err)));
sc->polling_depth--;
  784                 return (err);
  785         }
  787         if (err && err != USBD_IN_PROGRESS) {
DPRINTF(UDMASS_XFER, ("umass_polled_xfer %p has error %s\n",
xfer, usbd_errstr(err)));
  790         }
  792         if (sc->next_polled_xfer != NULL) {
DPRINTF(UDMASS_XFER, ("umass_polled_xfer running next "
  794                     "transaction %p\n", sc->next_polled_xfer));
xfer = sc->next_polled_xfer;
sc->next_polled_xfer = NULL;
  797                 goto start_next_xfer;
  798         }
sc->polling_depth--;
  802         return (USBD_NORMAL_COMPLETION);
  803 }
usbd_status
umass_setup_transfer(struct umass_softc *sc, usbd_pipe_handle pipe,
  807                         void *buffer, int buflen, int flags,
usbd_xfer_handle xfer)
  809 {
usbd_status err;
  812         if (sc->sc_dying)
  813                 return (USBD_IOERROR);
  815         /* Initialise a USB transfer and then schedule it */
usbd_setup_xfer(xfer, pipe, (void *)sc, buffer, buflen,
flags | sc->sc_xfer_flags, sc->timeout, sc->sc_methods->wire_state);
  820         if (sc->sc_udev->bus->use_polling) {
DPRINTF(UDMASS_XFER,("%s: start polled xfer buffer=%p "
  822                     "buflen=%d flags=0x%x timeout=%d\n", sc->sc_dev.dv_xname,
buffer, buflen, flags | sc->sc_xfer_flags, sc->timeout));
err = umass_polled_transfer(sc, xfer);
  825         } else {
err = usbd_transfer(xfer);
DPRINTF(UDMASS_XFER,("%s: start xfer buffer=%p buflen=%d "
  828                     "flags=0x%x timeout=%d\n", sc->sc_dev.dv_xname,
buffer, buflen, flags | sc->sc_xfer_flags, sc->timeout));
  830         }
  831         if (err && err != USBD_IN_PROGRESS) {
DPRINTF(UDMASS_BBB, ("%s: failed to setup transfer, %s\n",
sc->sc_dev.dv_xname, usbd_errstr(err)));
  834                 return (err);
  835         }
  837         return (USBD_NORMAL_COMPLETION);
  838 }
usbd_status
umass_setup_ctrl_transfer(struct umass_softc *sc, usb_device_request_t *req,
  843          void *buffer, int buflen, int flags, usbd_xfer_handle xfer)
  844 {
usbd_status err;
  847         if (sc->sc_dying)
  848                 return (USBD_IOERROR);
  850         /* Initialise a USB control transfer and then schedule it */
usbd_setup_default_xfer(xfer, sc->sc_udev, (void *) sc,
USBD_DEFAULT_TIMEOUT, req, buffer, buflen, flags,
sc->sc_methods->wire_state);
  856         if (sc->sc_udev->bus->use_polling) {
DPRINTF(UDMASS_XFER,("%s: start polled ctrl xfer buffer=%p "
  858                     "buflen=%d flags=0x%x\n", sc->sc_dev.dv_xname, buffer,
buflen, flags));
err = umass_polled_transfer(sc, xfer);
  861         } else {
DPRINTF(UDMASS_XFER,("%s: start ctrl xfer buffer=%p buflen=%d "
  863                     "flags=0x%x\n", sc->sc_dev.dv_xname, buffer, buflen,
flags));
err = usbd_transfer(xfer);
  866         }
  867         if (err && err != USBD_IN_PROGRESS) {
DPRINTF(UDMASS_BBB, ("%s: failed to setup ctrl transfer, %s\n",
sc->sc_dev.dv_xname, usbd_errstr(err)));
  871                 /* do not reset, as this would make us loop */
  872                 return (err);
  873         }
  875         return (USBD_NORMAL_COMPLETION);
  876 }
  878 void
umass_adjust_transfer(struct umass_softc *sc)
  880 {
  881         switch (sc->sc_cmd) {
  882         case UMASS_CPROTO_UFI:
sc->cbw.bCDBLength = UFI_COMMAND_LENGTH; 
  884                 /* Adjust the length field in certain scsi commands. */
  885                 switch (sc->cbw.CBWCDB[0]) {
  886                 case INQUIRY:
  887                         if (sc->transfer_datalen > 36) {
sc->transfer_datalen = 36;
sc->cbw.CBWCDB[4] = 36;
  890                         }
  891                         break;
  892                 case MODE_SENSE_BIG:
  893                         if (sc->transfer_datalen > 8) {
sc->transfer_datalen = 8;
sc->cbw.CBWCDB[7] = 0;
sc->cbw.CBWCDB[8] = 8;
  897                         }
  898                         break;
  899                 case REQUEST_SENSE:
  900                         if (sc->transfer_datalen > 18) {
sc->transfer_datalen = 18;
sc->cbw.CBWCDB[4] = 18;
  903                         }
  904                         break;
  905                 }
  906                 break;
  907         case UMASS_CPROTO_ATAPI:
sc->cbw.bCDBLength = UFI_COMMAND_LENGTH; 
  909                 break;
  910         }
  911 }
  913 void
umass_clear_endpoint_stall(struct umass_softc *sc, int endpt,
usbd_xfer_handle xfer)
  916 {
  917         if (sc->sc_dying)
  918                 return;
DPRINTF(UDMASS_BBB, ("%s: Clear endpoint 0x%02x stall\n",
sc->sc_dev.dv_xname, sc->sc_epaddr[endpt]));
usbd_clear_endpoint_toggle(sc->sc_pipe[endpt]);
sc->sc_req.bmRequestType = UT_WRITE_ENDPOINT;
sc->sc_req.bRequest = UR_CLEAR_FEATURE;
USETW(sc->sc_req.wValue, UF_ENDPOINT_HALT);
USETW(sc->sc_req.wIndex, sc->sc_epaddr[endpt]);
USETW(sc->sc_req.wLength, 0);
umass_setup_ctrl_transfer(sc, &sc->sc_req, NULL, 0, 0, xfer);
  931 }
  933 #if 0
  934 void
umass_reset(struct umass_softc *sc, transfer_cb_f cb, void *priv)
  936 {
sc->transfer_cb = cb;
sc->transfer_priv = priv;
  940         /* The reset is a forced reset, so no error (yet) */
sc->reset(sc, STATUS_CMD_OK);
  942 }
  943 #endif
  945 /*
  946  * Bulk protocol specific functions
  947  */
  949 void
umass_bbb_reset(struct umass_softc *sc, int status)
  951 {
KASSERT(sc->sc_wire & UMASS_WPROTO_BBB,
  953                 ("sc->sc_wire == 0x%02x wrong for umass_bbb_reset\n",
sc->sc_wire));
  956         if (sc->sc_dying)
  957                 return;
  959         /*
  960          * Reset recovery (5.3.4 in Universal Serial Bus Mass Storage Class)
  961          *
  962          * For Reset Recovery the host shall issue in the following order:
  963          * a) a Bulk-Only Mass Storage Reset
  964          * b) a Clear Feature HALT to the Bulk-In endpoint
  965          * c) a Clear Feature HALT to the Bulk-Out endpoint
  966          *
  967          * This is done in 3 steps, states:
  968          * TSTATE_BBB_RESET1
  969          * TSTATE_BBB_RESET2
  970          * TSTATE_BBB_RESET3
  971          *
  972          * If the reset doesn't succeed, the device should be port reset.
  973          */
DPRINTF(UDMASS_BBB, ("%s: Bulk Reset\n",
sc->sc_dev.dv_xname));
sc->transfer_state = TSTATE_BBB_RESET1;
sc->transfer_status = status;
  981         /* reset is a class specific interface write */
sc->sc_req.bmRequestType = UT_WRITE_CLASS_INTERFACE;
sc->sc_req.bRequest = UR_BBB_RESET;
USETW(sc->sc_req.wValue, 0);
USETW(sc->sc_req.wIndex, sc->sc_ifaceno);
USETW(sc->sc_req.wLength, 0);
umass_setup_ctrl_transfer(sc, &sc->sc_req, NULL, 0, 0,
sc->transfer_xfer[XFER_BBB_RESET1]);
  989 }
  991 void
umass_bbb_transfer(struct umass_softc *sc, int lun, void *cmd, int cmdlen,
  993                    void *data, int datalen, int dir, u_int timeout,
umass_callback cb, void *priv)
  995 {
  996         static int dCBWtag = 42;        /* unique for CBW of transfer */
usbd_status err;
DPRINTF(UDMASS_BBB,("%s: umass_bbb_transfer cmd=0x%02x\n",
sc->sc_dev.dv_xname, *(u_char *)cmd));
KASSERT(sc->sc_wire & UMASS_WPROTO_BBB,
 1003                 ("sc->sc_wire == 0x%02x wrong for umass_bbb_transfer\n",
sc->sc_wire));
 1006         if (sc->sc_dying) {
sc->polled_xfer_status = USBD_IOERROR;
 1008                 return;
 1009         }
 1011         /* Be a little generous. */
sc->timeout = timeout + USBD_DEFAULT_TIMEOUT;
 1014         /*
 1015          * Do a Bulk-Only transfer with cmdlen bytes from cmd, possibly
 1016          * a data phase of datalen bytes from/to the device and finally a
 1017          * csw read phase.
 1018          * If the data direction was inbound a maximum of datalen bytes
 1019          * is stored in the buffer pointed to by data.
 1020          *
 1021          * umass_bbb_transfer initialises the transfer and lets the state
 1022          * machine in umass_bbb_state handle the completion. It uses the
 1023          * following states:
 1024          * TSTATE_BBB_COMMAND
 1025          *   -> TSTATE_BBB_DATA
 1026          *   -> TSTATE_BBB_STATUS
 1027          *   -> TSTATE_BBB_STATUS2
 1028          *   -> TSTATE_BBB_IDLE
 1029          *
 1030          * An error in any of those states will invoke
 1031          * umass_bbb_reset.
 1032          */
 1034         /* check the given arguments */
KASSERT(datalen == 0 || data != NULL,
 1036                 ("%s: datalen > 0, but no buffer",sc->sc_dev.dv_xname));
KASSERT(cmdlen <= CBWCDBLENGTH,
 1038                 ("%s: cmdlen exceeds CDB length in CBW (%d > %d)",
sc->sc_dev.dv_xname, cmdlen, CBWCDBLENGTH));
KASSERT(dir == DIR_NONE || datalen > 0,
 1041                 ("%s: datalen == 0 while direction is not NONE\n",
sc->sc_dev.dv_xname));
KASSERT(datalen == 0 || dir != DIR_NONE,
 1044                 ("%s: direction is NONE while datalen is not zero\n",
sc->sc_dev.dv_xname));
KASSERT(sizeof(umass_bbb_cbw_t) == UMASS_BBB_CBW_SIZE,
 1047                 ("%s: CBW struct does not have the right size (%d vs. %d)\n",
sc->sc_dev.dv_xname,
 1049                         sizeof(umass_bbb_cbw_t), UMASS_BBB_CBW_SIZE));
KASSERT(sizeof(umass_bbb_csw_t) == UMASS_BBB_CSW_SIZE,
 1051                 ("%s: CSW struct does not have the right size (%d vs. %d)\n",
sc->sc_dev.dv_xname,
 1053                         sizeof(umass_bbb_csw_t), UMASS_BBB_CSW_SIZE));
 1055         /*
 1056          * Determine the direction of the data transfer and the length.
 1057          *
 1058          * dCBWDataTransferLength (datalen) :
 1059          *   This field indicates the number of bytes of data that the host
 1060          *   intends to transfer on the IN or OUT Bulk endpoint(as indicated by
 1061          *   the Direction bit) during the execution of this command. If this
 1062          *   field is set to 0, the device will expect that no data will be
 1063          *   transferred IN or OUT during this command, regardless of the value
 1064          *   of the Direction bit defined in dCBWFlags.
 1065          *
 1066          * dCBWFlags (dir) :
 1067          *   The bits of the Flags field are defined as follows:
 1068          *     Bits 0-6  reserved
 1069          *     Bit  7    Direction - this bit shall be ignored if the
 1070          *                           dCBWDataTransferLength field is zero.
 1071          *               0 = data Out from host to device
 1072          *               1 = data In from device to host
 1073          */
 1075         /* Fill in the Command Block Wrapper */
USETDW(sc->cbw.dCBWSignature, CBWSIGNATURE);
USETDW(sc->cbw.dCBWTag, dCBWtag);
dCBWtag++;      /* cannot be done in macro (it will be done 4 times) */
USETDW(sc->cbw.dCBWDataTransferLength, datalen);
 1080         /* DIR_NONE is treated as DIR_OUT (0x00) */
sc->cbw.bCBWFlags = (dir == DIR_IN? CBWFLAGS_IN:CBWFLAGS_OUT);
sc->cbw.bCBWLUN = lun;
sc->cbw.bCDBLength = cmdlen;
bzero(sc->cbw.CBWCDB, sizeof(sc->cbw.CBWCDB));
memcpy(sc->cbw.CBWCDB, cmd, cmdlen);
DIF(UDMASS_BBB, umass_bbb_dump_cbw(sc, &sc->cbw));
 1089         /* store the details for the data transfer phase */
sc->transfer_dir = dir;
sc->transfer_data = data;
sc->transfer_datalen = datalen;
sc->transfer_actlen = 0;
sc->transfer_cb = cb;
sc->transfer_priv = priv;
sc->transfer_status = STATUS_CMD_OK;
 1098         /* move from idle to the command state */
sc->transfer_state = TSTATE_BBB_COMMAND;
 1101         /* Send the CBW from host to device via bulk-out endpoint. */
umass_adjust_transfer(sc);
 1103         if ((err = umass_setup_transfer(sc, sc->sc_pipe[UMASS_BULKOUT],
 1104                         &sc->cbw, UMASS_BBB_CBW_SIZE, 0,
sc->transfer_xfer[XFER_BBB_CBW])))
umass_bbb_reset(sc, STATUS_WIRE_FAILED);
 1108         if (sc->sc_udev->bus->use_polling)
sc->polled_xfer_status = err;
 1110 }
 1112 void
umass_bbb_state(usbd_xfer_handle xfer, usbd_private_handle priv,
usbd_status err)
 1115 {
 1116         struct umass_softc *sc = (struct umass_softc *) priv;
usbd_xfer_handle next_xfer;
KASSERT(sc->sc_wire & UMASS_WPROTO_BBB,
 1120                 ("sc->sc_wire == 0x%02x wrong for umass_bbb_state\n",
sc->sc_wire));
 1123         if (sc->sc_dying)
 1124                 return;
 1126         /*
 1127          * State handling for BBB transfers.
 1128          *
 1129          * The subroutine is rather long. It steps through the states given in
 1130          * Annex A of the Bulk-Only specification.
 1131          * Each state first does the error handling of the previous transfer
 1132          * and then prepares the next transfer.
 1133          * Each transfer is done asynchronously so after the request/transfer
 1134          * has been submitted you will find a 'return;'.
 1135          */
DPRINTF(UDMASS_BBB, ("%s: Handling BBB state %d (%s), xfer=%p, %s\n",
sc->sc_dev.dv_xname, sc->transfer_state,
states[sc->transfer_state], xfer, usbd_errstr(err)));
 1141         switch (sc->transfer_state) {
 1143         /***** Bulk Transfer *****/
 1144         case TSTATE_BBB_COMMAND:
 1145                 /* Command transport phase, error handling */
 1146                 if (err) {
DPRINTF(UDMASS_BBB, ("%s: failed to send CBW\n",
sc->sc_dev.dv_xname));
 1149                         /* If the device detects that the CBW is invalid, then
 1150                          * the device may STALL both bulk endpoints and require
 1151                          * a Bulk-Reset
 1152                          */
umass_bbb_reset(sc, STATUS_WIRE_FAILED);
 1154                         return;
 1155                 }
 1157                 /* Data transport phase, setup transfer */
sc->transfer_state = TSTATE_BBB_DATA;
 1159                 if (sc->transfer_dir == DIR_IN) {
 1160                         if (umass_setup_transfer(sc, sc->sc_pipe[UMASS_BULKIN],
sc->data_buffer, sc->transfer_datalen,
USBD_SHORT_XFER_OK | USBD_NO_COPY,
sc->transfer_xfer[XFER_BBB_DATA]))
umass_bbb_reset(sc, STATUS_WIRE_FAILED);
 1166                         return;
 1167                 } else if (sc->transfer_dir == DIR_OUT) {
memcpy(sc->data_buffer, sc->transfer_data,
sc->transfer_datalen);
 1170                         if (umass_setup_transfer(sc, sc->sc_pipe[UMASS_BULKOUT],
sc->data_buffer, sc->transfer_datalen,
USBD_NO_COPY,/* fixed length transfer */
sc->transfer_xfer[XFER_BBB_DATA]))
umass_bbb_reset(sc, STATUS_WIRE_FAILED);
 1176                         return;
 1177                 } else {
DPRINTF(UDMASS_BBB, ("%s: no data phase\n",
sc->sc_dev.dv_xname));
 1180                 }
 1182                 /* FALLTHROUGH if no data phase, err == 0 */
 1183         case TSTATE_BBB_DATA:
 1184                 /* Command transport phase error handling (ignored if no data
 1185                  * phase (fallthrough from previous state)) */
 1186                 if (sc->transfer_dir != DIR_NONE) {
 1187                         /* retrieve the length of the transfer that was done */
usbd_get_xfer_status(xfer, NULL, NULL,
 1189                              &sc->transfer_actlen, NULL);
DPRINTF(UDMASS_BBB, ("%s: BBB_DATA actlen=%d\n",
sc->sc_dev.dv_xname, sc->transfer_actlen));
 1193                         if (err) {
DPRINTF(UDMASS_BBB, ("%s: Data-%s %d failed, "
 1195                                         "%s\n", sc->sc_dev.dv_xname,
 1196                                         (sc->transfer_dir == DIR_IN?"in":"out"),
sc->transfer_datalen,usbd_errstr(err)));
 1199                                 if (err == USBD_STALLED) {
sc->transfer_state = TSTATE_BBB_DCLEAR;
umass_clear_endpoint_stall(sc,
 1202                                           (sc->transfer_dir == DIR_IN?
UMASS_BULKIN:UMASS_BULKOUT),
sc->transfer_xfer[XFER_BBB_DCLEAR]);
 1205                                 } else {
 1206                                         /* Unless the error is a pipe stall the
 1207                                          * error is fatal.
 1208                                          */
umass_bbb_reset(sc,STATUS_WIRE_FAILED);
 1210                                 }
 1211                                 return;
 1212                         }
 1213                 }
 1215                 /* FALLTHROUGH, err == 0 (no data phase or successful) */
 1216         case TSTATE_BBB_DCLEAR: /* stall clear after data phase */
 1217                 if (sc->transfer_dir == DIR_IN)
memcpy(sc->transfer_data, sc->data_buffer,
sc->transfer_actlen);
DIF(UDMASS_BBB, if (sc->transfer_dir == DIR_IN)
umass_dump_buffer(sc, sc->transfer_data,
sc->transfer_datalen, 48));
 1225                 /* FALLTHROUGH, err == 0 (no data phase or successful) */
 1226         case TSTATE_BBB_SCLEAR: /* stall clear after status phase */
 1227                 /* Reading of CSW after bulk stall condition in data phase
 1228                  * (TSTATE_BBB_DATA2) or bulk-in stall condition after
 1229                  * reading CSW (TSTATE_BBB_SCLEAR).
 1230                  * In the case of no data phase or successful data phase,
 1231                  * err == 0 and the following if block is passed.
 1232                  */
 1233                 if (err) {      /* should not occur */
printf("%s: BBB bulk-%s stall clear failed, %s\n",
sc->sc_dev.dv_xname,
 1236                             (sc->transfer_dir == DIR_IN? "in":"out"),
usbd_errstr(err));
umass_bbb_reset(sc, STATUS_WIRE_FAILED);
 1239                         return;
 1240                 }
 1242                 /* Status transport phase, setup transfer */
 1243                 if (sc->transfer_state == TSTATE_BBB_COMMAND ||
sc->transfer_state == TSTATE_BBB_DATA ||
sc->transfer_state == TSTATE_BBB_DCLEAR) {
 1246                         /* After no data phase, successful data phase and
 1247                          * after clearing bulk-in/-out stall condition
 1248                          */
sc->transfer_state = TSTATE_BBB_STATUS1;
next_xfer = sc->transfer_xfer[XFER_BBB_CSW1];
 1251                 } else {
 1252                         /* After first attempt of fetching CSW */
sc->transfer_state = TSTATE_BBB_STATUS2;
next_xfer = sc->transfer_xfer[XFER_BBB_CSW2];
 1255                 }
 1257                 /* Read the Command Status Wrapper via bulk-in endpoint. */
 1258                 if (umass_setup_transfer(sc, sc->sc_pipe[UMASS_BULKIN],
 1259                         &sc->csw, UMASS_BBB_CSW_SIZE, 0, next_xfer)) {
umass_bbb_reset(sc, STATUS_WIRE_FAILED);
 1261                         return;
 1262                 }
 1264                 return;
 1265         case TSTATE_BBB_STATUS1:        /* first attempt */
 1266         case TSTATE_BBB_STATUS2:        /* second attempt */
 1267                 /* Status transfer, error handling */
 1268                 if (err) {
DPRINTF(UDMASS_BBB, ("%s: Failed to read CSW, %s%s\n",
sc->sc_dev.dv_xname, usbd_errstr(err),
 1271                                 (sc->transfer_state == TSTATE_BBB_STATUS1?
 1272                                         ", retrying":"")));
 1274                         /* If this was the first attempt at fetching the CSW
 1275                          * retry it, otherwise fail.
 1276                          */
 1277                         if (sc->transfer_state == TSTATE_BBB_STATUS1) {
sc->transfer_state = TSTATE_BBB_SCLEAR;
umass_clear_endpoint_stall(sc, UMASS_BULKIN,
sc->transfer_xfer[XFER_BBB_SCLEAR]);
 1281                                 return;
 1282                         } else {
umass_bbb_reset(sc, STATUS_WIRE_FAILED);
 1284                                 return;
 1285                         }
 1286                 }
DIF(UDMASS_BBB, umass_bbb_dump_csw(sc, &sc->csw));
 1290                 /* Translate weird command-status signatures. */
 1291                 if ((sc->sc_quirks & UMASS_QUIRK_WRONG_CSWSIG) &&
UGETDW(sc->csw.dCSWSignature) == CSWSIGNATURE_OLYMPUS_C1)
USETDW(sc->csw.dCSWSignature, CSWSIGNATURE);
 1295                 /* Translate invalid command-status tags */
 1296                 if (sc->sc_quirks & UMASS_QUIRK_WRONG_CSWTAG)
USETDW(sc->csw.dCSWTag, UGETDW(sc->cbw.dCBWTag));
 1299                 /* Check CSW and handle any error */
 1300                 if (UGETDW(sc->csw.dCSWSignature) != CSWSIGNATURE) {
 1301                         /* Invalid CSW: Wrong signature or wrong tag might
 1302                          * indicate that the device is confused -> reset it.
 1303                          */
printf("%s: Invalid CSW: sig 0x%08x should be 0x%08x\n",
sc->sc_dev.dv_xname,
UGETDW(sc->csw.dCSWSignature),
CSWSIGNATURE);
umass_bbb_reset(sc, STATUS_WIRE_FAILED);
 1310                         return;
 1311                 } else if (UGETDW(sc->csw.dCSWTag)
 1312                                 != UGETDW(sc->cbw.dCBWTag)) {
printf("%s: Invalid CSW: tag %d should be %d\n",
sc->sc_dev.dv_xname,
UGETDW(sc->csw.dCSWTag),
UGETDW(sc->cbw.dCBWTag));
umass_bbb_reset(sc, STATUS_WIRE_FAILED);
 1319                         return;
 1321                 /* CSW is valid here */
 1322                 } else if (sc->csw.bCSWStatus > CSWSTATUS_PHASE) {
printf("%s: Invalid CSW: status %d > %d\n",
sc->sc_dev.dv_xname,
sc->csw.bCSWStatus,
CSWSTATUS_PHASE);
umass_bbb_reset(sc, STATUS_WIRE_FAILED);
 1329                         return;
 1330                 } else if (sc->csw.bCSWStatus == CSWSTATUS_PHASE) {
printf("%s: Phase Error, residue = %d\n",
sc->sc_dev.dv_xname,
UGETDW(sc->csw.dCSWDataResidue));
umass_bbb_reset(sc, STATUS_WIRE_FAILED);
 1336                         return;
 1338                 } else if (sc->transfer_actlen > sc->transfer_datalen) {
 1339                         /* Buffer overrun! Don't let this go by unnoticed */
panic("%s: transferred %d bytes instead of %d bytes",
sc->sc_dev.dv_xname,
sc->transfer_actlen, sc->transfer_datalen);
 1343 #if 0
 1344                 } else if (sc->transfer_datalen - sc->transfer_actlen
 1345                            != UGETDW(sc->csw.dCSWDataResidue)) {
DPRINTF(UDMASS_BBB, ("%s: actlen=%d != residue=%d\n",
sc->sc_dev.dv_xname,
sc->transfer_datalen - sc->transfer_actlen,
UGETDW(sc->csw.dCSWDataResidue)));
umass_bbb_reset(sc, STATUS_WIRE_FAILED);
 1352                         return;
 1353 #endif
 1354                 } else if (sc->csw.bCSWStatus == CSWSTATUS_FAILED) {
DPRINTF(UDMASS_BBB, ("%s: Command Failed, res = %d\n",
sc->sc_dev.dv_xname,
UGETDW(sc->csw.dCSWDataResidue)));
 1359                         /* SCSI command failed but transfer was successful */
sc->transfer_state = TSTATE_IDLE;
sc->transfer_cb(sc, sc->transfer_priv,
UGETDW(sc->csw.dCSWDataResidue),
STATUS_CMD_FAILED);
 1365                         return;
 1367                 } else {        /* success */
sc->transfer_state = TSTATE_IDLE;
sc->transfer_cb(sc, sc->transfer_priv,
UGETDW(sc->csw.dCSWDataResidue),
STATUS_CMD_OK);
 1373                         return;
 1374                 }
 1376         /***** Bulk Reset *****/
 1377         case TSTATE_BBB_RESET1:
 1378                 if (err)
printf("%s: BBB reset failed, %s\n",
sc->sc_dev.dv_xname, usbd_errstr(err));
sc->transfer_state = TSTATE_BBB_RESET2;
umass_clear_endpoint_stall(sc, UMASS_BULKIN,
sc->transfer_xfer[XFER_BBB_RESET2]);
 1386                 return;
 1387         case TSTATE_BBB_RESET2:
 1388                 if (err)        /* should not occur */
printf("%s: BBB bulk-in clear stall failed, %s\n",
sc->sc_dev.dv_xname, usbd_errstr(err));
 1391                         /* no error recovery, otherwise we end up in a loop */
sc->transfer_state = TSTATE_BBB_RESET3;
umass_clear_endpoint_stall(sc, UMASS_BULKOUT,
sc->transfer_xfer[XFER_BBB_RESET3]);
 1397                 return;
 1398         case TSTATE_BBB_RESET3:
 1399                 if (err)        /* should not occur */
printf("%s: BBB bulk-out clear stall failed, %s\n",
sc->sc_dev.dv_xname, usbd_errstr(err));
 1402                         /* no error recovery, otherwise we end up in a loop */
sc->transfer_state = TSTATE_IDLE;
 1405                 if (sc->transfer_priv) {
sc->transfer_cb(sc, sc->transfer_priv,
sc->transfer_datalen,
sc->transfer_status);
 1409                 }
 1411                 return;
 1413         /***** Default *****/
 1414         default:
panic("%s: Unknown state %d",
sc->sc_dev.dv_xname, sc->transfer_state);
 1417         }
 1418 }
 1420 /*
 1421  * Command/Bulk/Interrupt (CBI) specific functions
 1422  */
 1424 int
umass_cbi_adsc(struct umass_softc *sc, char *buffer, int buflen,
usbd_xfer_handle xfer)
 1427 {
KASSERT(sc->sc_wire & (UMASS_WPROTO_CBI|UMASS_WPROTO_CBI_I),
 1429                 ("sc->sc_wire == 0x%02x wrong for umass_cbi_adsc\n",
sc->sc_wire));
sc->sc_req.bmRequestType = UT_WRITE_CLASS_INTERFACE;
sc->sc_req.bRequest = UR_CBI_ADSC;
USETW(sc->sc_req.wValue, 0);
USETW(sc->sc_req.wIndex, sc->sc_ifaceno);
USETW(sc->sc_req.wLength, buflen);
 1437         return umass_setup_ctrl_transfer(sc, &sc->sc_req, buffer,
buflen, 0, xfer);
 1439 }
 1442 void
umass_cbi_reset(struct umass_softc *sc, int status)
 1444 {
 1445         int i;
 1446 #       define SEND_DIAGNOSTIC_CMDLEN   12
KASSERT(sc->sc_wire & (UMASS_WPROTO_CBI|UMASS_WPROTO_CBI_I),
 1449                 ("sc->sc_wire == 0x%02x wrong for umass_cbi_reset\n",
sc->sc_wire));
 1452         if (sc->sc_dying)
 1453                 return;
 1455         /*
 1456          * Command Block Reset Protocol
 1457          *
 1458          * First send a reset request to the device. Then clear
 1459          * any possibly stalled bulk endpoints.
 1460 
 1461          * This is done in 3 steps, states:
 1462          * TSTATE_CBI_RESET1
 1463          * TSTATE_CBI_RESET2
 1464          * TSTATE_CBI_RESET3
 1465          *
 1466          * If the reset doesn't succeed, the device should be port reset.
 1467          */
DPRINTF(UDMASS_CBI, ("%s: CBI Reset\n",
sc->sc_dev.dv_xname));
KASSERT(sizeof(sc->cbl) >= SEND_DIAGNOSTIC_CMDLEN,
 1473                 ("%s: CBL struct is too small (%d < %d)\n",
sc->sc_dev.dv_xname,
 1475                         sizeof(sc->cbl), SEND_DIAGNOSTIC_CMDLEN));
sc->transfer_state = TSTATE_CBI_RESET1;
sc->transfer_status = status;
 1480         /* The 0x1d code is the SEND DIAGNOSTIC command. To distinguish between
 1481          * the two the last 10 bytes of the cbl is filled with 0xff (section
 1482          * 2.2 of the CBI spec).
 1483          */
sc->cbl[0] = 0x1d;      /* Command Block Reset */
sc->cbl[1] = 0x04;
 1486         for (i = 2; i < SEND_DIAGNOSTIC_CMDLEN; i++)
sc->cbl[i] = 0xff;
umass_cbi_adsc(sc, sc->cbl, SEND_DIAGNOSTIC_CMDLEN,
sc->transfer_xfer[XFER_CBI_RESET1]);
 1491         /* XXX if the command fails we should reset the port on the bub */
 1492 }
 1494 void
umass_cbi_transfer(struct umass_softc *sc, int lun,
 1496                    void *cmd, int cmdlen, void *data, int datalen, int dir,
u_int timeout, umass_callback cb, void *priv)
 1498 {
usbd_status err;
DPRINTF(UDMASS_CBI,("%s: umass_cbi_transfer cmd=0x%02x, len=%d\n",
sc->sc_dev.dv_xname, *(u_char *)cmd, datalen));
KASSERT(sc->sc_wire & (UMASS_WPROTO_CBI|UMASS_WPROTO_CBI_I),
 1505                 ("sc->sc_wire == 0x%02x wrong for umass_cbi_transfer\n",
sc->sc_wire));
 1508         if (sc->sc_dying) {
sc->polled_xfer_status = USBD_IOERROR;
 1510                 return;
 1511         }
 1513         /* Be a little generous. */
sc->timeout = timeout + USBD_DEFAULT_TIMEOUT;
 1516         /*
 1517          * Do a CBI transfer with cmdlen bytes from cmd, possibly
 1518          * a data phase of datalen bytes from/to the device and finally a
 1519          * csw read phase.
 1520          * If the data direction was inbound a maximum of datalen bytes
 1521          * is stored in the buffer pointed to by data.
 1522          *
 1523          * umass_cbi_transfer initialises the transfer and lets the state
 1524          * machine in umass_cbi_state handle the completion. It uses the
 1525          * following states:
 1526          * TSTATE_CBI_COMMAND
 1527          *   -> XXX fill in
 1528          *
 1529          * An error in any of those states will invoke
 1530          * umass_cbi_reset.
 1531          */
 1533         /* check the given arguments */
KASSERT(datalen == 0 || data != NULL,
 1535                 ("%s: datalen > 0, but no buffer",sc->sc_dev.dv_xname));
KASSERT(datalen == 0 || dir != DIR_NONE,
 1537                 ("%s: direction is NONE while datalen is not zero\n",
sc->sc_dev.dv_xname));
 1540         /* store the details for the data transfer phase */
sc->transfer_dir = dir;
sc->transfer_data = data;
sc->transfer_datalen = datalen;
sc->transfer_actlen = 0;
sc->transfer_cb = cb;
sc->transfer_priv = priv;
sc->transfer_status = STATUS_CMD_OK;
 1549         /* move from idle to the command state */
sc->transfer_state = TSTATE_CBI_COMMAND;
 1552         /* Send the Command Block from host to device via control endpoint. */
sc->cbw.bCDBLength = cmdlen;
bzero(sc->cbw.CBWCDB, sizeof(sc->cbw.CBWCDB));
memcpy(sc->cbw.CBWCDB, cmd, cmdlen);
umass_adjust_transfer(sc);
 1557         if ((err = umass_cbi_adsc(sc, (void *)sc->cbw.CBWCDB, sc->cbw.bCDBLength,
sc->transfer_xfer[XFER_CBI_CB])))
umass_cbi_reset(sc, STATUS_WIRE_FAILED);
 1561         if (sc->sc_udev->bus->use_polling)
sc->polled_xfer_status = err;
 1563 }
 1565 void
umass_cbi_state(usbd_xfer_handle xfer, usbd_private_handle priv,
usbd_status err)
 1568 {
 1569         struct umass_softc *sc = (struct umass_softc *) priv;
KASSERT(sc->sc_wire & (UMASS_WPROTO_CBI|UMASS_WPROTO_CBI_I),
 1572                 ("sc->sc_wire == 0x%02x wrong for umass_cbi_state\n",
sc->sc_wire));
 1575         if (sc->sc_dying)
 1576                 return;
 1578         /*
 1579          * State handling for CBI transfers.
 1580          */
DPRINTF(UDMASS_CBI, ("%s: Handling CBI state %d (%s), xfer=%p, %s\n",
sc->sc_dev.dv_xname, sc->transfer_state,
states[sc->transfer_state], xfer, usbd_errstr(err)));
 1586         switch (sc->transfer_state) {
 1588         /***** CBI Transfer *****/
 1589         case TSTATE_CBI_COMMAND:
 1590                 if (err == USBD_STALLED) {
DPRINTF(UDMASS_CBI, ("%s: Command Transport failed\n",
sc->sc_dev.dv_xname));
 1593                         /* Status transport by control pipe (section 2.3.2.1).
 1594                          * The command contained in the command block failed.
 1595                          *
 1596                          * The control pipe has already been unstalled by the
 1597                          * USB stack.
 1598                          * Section 2.4.3.1.1 states that the bulk in endpoints
 1599                          * should not stalled at this point.
 1600                          */
sc->transfer_state = TSTATE_IDLE;
sc->transfer_cb(sc, sc->transfer_priv,
sc->transfer_datalen,
STATUS_CMD_FAILED);
 1607                         return;
 1608                 } else if (err) {
DPRINTF(UDMASS_CBI, ("%s: failed to send ADSC\n",
sc->sc_dev.dv_xname));
umass_cbi_reset(sc, STATUS_WIRE_FAILED);
 1612                         return;
 1613                 }
 1615                 /* Data transport phase, setup transfer */
sc->transfer_state = TSTATE_CBI_DATA;
 1617                 if (sc->transfer_dir == DIR_IN) {
 1618                         if (umass_setup_transfer(sc, sc->sc_pipe[UMASS_BULKIN],
sc->data_buffer, sc->transfer_datalen,
USBD_SHORT_XFER_OK | USBD_NO_COPY,
sc->transfer_xfer[XFER_CBI_DATA]))
umass_cbi_reset(sc, STATUS_WIRE_FAILED);
 1624                         return;
 1625                 } else if (sc->transfer_dir == DIR_OUT) {
memcpy(sc->data_buffer, sc->transfer_data,
sc->transfer_datalen);
 1628                         if (umass_setup_transfer(sc, sc->sc_pipe[UMASS_BULKOUT],
sc->data_buffer, sc->transfer_datalen,
USBD_NO_COPY,/* fixed length transfer */
sc->transfer_xfer[XFER_CBI_DATA]))
umass_cbi_reset(sc, STATUS_WIRE_FAILED);
 1634                         return;
 1635                 } else {
DPRINTF(UDMASS_CBI, ("%s: no data phase\n",
sc->sc_dev.dv_xname));
 1638                 }
 1640                 /* FALLTHROUGH if no data phase, err == 0 */
 1641         case TSTATE_CBI_DATA:
 1642                 /* Command transport phase error handling (ignored if no data
 1643                  * phase (fallthrough from previous state)) */
 1644                 if (sc->transfer_dir != DIR_NONE) {
 1645                         /* retrieve the length of the transfer that was done */
usbd_get_xfer_status(xfer, NULL, NULL,
 1647                             &sc->transfer_actlen, NULL);
DPRINTF(UDMASS_CBI, ("%s: CBI_DATA actlen=%d\n",
sc->sc_dev.dv_xname, sc->transfer_actlen));
 1651                         if (err) {
DPRINTF(UDMASS_CBI, ("%s: Data-%s %d failed, "
 1653                                         "%s\n", sc->sc_dev.dv_xname,
 1654                                         (sc->transfer_dir == DIR_IN?"in":"out"),
sc->transfer_datalen,usbd_errstr(err)));
 1657                                 if (err == USBD_STALLED) {
sc->transfer_state = TSTATE_CBI_DCLEAR;
umass_clear_endpoint_stall(sc,
 1660                                           (sc->transfer_dir == DIR_IN?
UMASS_BULKIN:UMASS_BULKOUT),
sc->transfer_xfer[XFER_CBI_DCLEAR]);
 1663                                 } else {
 1664                                         /* Unless the error is a pipe stall the
 1665                                          * error is fatal.
 1666                                          */
umass_cbi_reset(sc, STATUS_WIRE_FAILED);
 1668                                 }
 1669                                 return;
 1670                         }
 1671                 }
 1673                 if (sc->transfer_dir == DIR_IN)
memcpy(sc->transfer_data, sc->data_buffer,
sc->transfer_actlen);
DIF(UDMASS_CBI, if (sc->transfer_dir == DIR_IN)
umass_dump_buffer(sc, sc->transfer_data,
sc->transfer_actlen, 48));
 1681                 /* Status phase */
 1682                 if (sc->sc_wire == UMASS_WPROTO_CBI_I) {
sc->transfer_state = TSTATE_CBI_STATUS;
memset(&sc->sbl, 0, sizeof(sc->sbl));
 1685                         if (umass_setup_transfer(sc, sc->sc_pipe[UMASS_INTRIN],
 1686                                     &sc->sbl, sizeof(sc->sbl),
 1687                                     0,  /* fixed length transfer */
sc->transfer_xfer[XFER_CBI_STATUS]))
umass_cbi_reset(sc, STATUS_WIRE_FAILED);
 1690                 } else {
 1691                         /* No command completion interrupt. Request
 1692                          * sense to get status of command.
 1693                          */
sc->transfer_state = TSTATE_IDLE;
sc->transfer_cb(sc, sc->transfer_priv,
sc->transfer_datalen - sc->transfer_actlen,
STATUS_CMD_UNKNOWN);
 1698                 }
 1699                 return;
 1701         case TSTATE_CBI_STATUS:
 1702                 if (err) {
DPRINTF(UDMASS_CBI, ("%s: Status Transport failed\n",
sc->sc_dev.dv_xname));
 1705                         /* Status transport by interrupt pipe (section 2.3.2.2).
 1706                          */
 1708                         if (err == USBD_STALLED) {
sc->transfer_state = TSTATE_CBI_SCLEAR;
umass_clear_endpoint_stall(sc, UMASS_INTRIN,
sc->transfer_xfer[XFER_CBI_SCLEAR]);
 1712                         } else {
umass_cbi_reset(sc, STATUS_WIRE_FAILED);
 1714                         }
 1715                         return;
 1716                 }
 1718                 /* Dissect the information in the buffer */
 1720                 {
u_int32_t actlen;
usbd_get_xfer_status(xfer, NULL, NULL, &actlen, NULL);
DPRINTF(UDMASS_CBI, ("%s: CBI_STATUS actlen=%d\n",
sc->sc_dev.dv_xname, actlen));
 1725                         if (actlen != 2)
 1726                                 break;
 1727                 }
 1729                 if (sc->sc_cmd == UMASS_CPROTO_UFI) {
 1730                         int status;
 1732                         /* Section 3.4.3.1.3 specifies that the UFI command
 1733                          * protocol returns an ASC and ASCQ in the interrupt
 1734                          * data block.
 1735                          */
DPRINTF(UDMASS_CBI, ("%s: UFI CCI, ASC = 0x%02x, "
 1738                                 "ASCQ = 0x%02x\n",
sc->sc_dev.dv_xname,
sc->sbl.ufi.asc, sc->sbl.ufi.ascq));
 1742                         if ((sc->sbl.ufi.asc == 0 && sc->sbl.ufi.ascq == 0) ||
sc->sc_sense)
status = STATUS_CMD_OK;
 1745                         else
status = STATUS_CMD_FAILED;
 1748                         /* No autosense, command successful */
sc->transfer_state = TSTATE_IDLE;
sc->transfer_cb(sc, sc->transfer_priv,
sc->transfer_datalen - sc->transfer_actlen, status);
 1752                 } else {
 1753                         int status;
 1755                         /* Command Interrupt Data Block */
DPRINTF(UDMASS_CBI, ("%s: type=0x%02x, value=0x%02x\n",
sc->sc_dev.dv_xname,
sc->sbl.common.type, sc->sbl.common.value));
 1761                         if (sc->sbl.common.type == IDB_TYPE_CCI) {
 1762                                 switch (sc->sbl.common.value &
IDB_VALUE_STATUS_MASK) {
 1764                                 case IDB_VALUE_PASS:
status = STATUS_CMD_OK;
 1766                                         break;
 1767                                 case IDB_VALUE_FAIL:
 1768                                 case IDB_VALUE_PERSISTENT:
status = STATUS_CMD_FAILED;
 1770                                         break;
 1771                                 case IDB_VALUE_PHASE:
status = STATUS_WIRE_FAILED;
 1773                                         break;
 1774                                 }
sc->transfer_state = TSTATE_IDLE;
sc->transfer_cb(sc, sc->transfer_priv,
sc->transfer_datalen - sc->transfer_actlen,
status);
 1780                         }
 1781                 }
 1782                 return;
 1784         case TSTATE_CBI_DCLEAR:
 1785                 if (err) {      /* should not occur */
printf("%s: CBI bulk-in/out stall clear failed, %s\n",
sc->sc_dev.dv_xname, usbd_errstr(err));
umass_cbi_reset(sc, STATUS_WIRE_FAILED);
 1789                 } else {
sc->transfer_state = TSTATE_IDLE;
sc->transfer_cb(sc, sc->transfer_priv,
sc->transfer_datalen, STATUS_CMD_FAILED);
 1793                 }
 1794                 return;
 1796         case TSTATE_CBI_SCLEAR:
 1797                 if (err) {      /* should not occur */
printf("%s: CBI intr-in stall clear failed, %s\n",
sc->sc_dev.dv_xname, usbd_errstr(err));
umass_cbi_reset(sc, STATUS_WIRE_FAILED);
 1801                 } else {
sc->transfer_state = TSTATE_IDLE;
sc->transfer_cb(sc, sc->transfer_priv,
sc->transfer_datalen, STATUS_CMD_FAILED);
 1805                 }
 1806                 return;
 1808         /***** CBI Reset *****/
 1809         case TSTATE_CBI_RESET1:
 1810                 if (err)
printf("%s: CBI reset failed, %s\n",
sc->sc_dev.dv_xname, usbd_errstr(err));
sc->transfer_state = TSTATE_CBI_RESET2;
umass_clear_endpoint_stall(sc, UMASS_BULKIN,
sc->transfer_xfer[XFER_CBI_RESET2]);
 1818                 return;
 1819         case TSTATE_CBI_RESET2:
 1820                 if (err)        /* should not occur */
printf("%s: CBI bulk-in stall clear failed, %s\n",
sc->sc_dev.dv_xname, usbd_errstr(err));
 1823                         /* no error recovery, otherwise we end up in a loop */
sc->transfer_state = TSTATE_CBI_RESET3;
umass_clear_endpoint_stall(sc, UMASS_BULKOUT,
sc->transfer_xfer[XFER_CBI_RESET3]);
 1829                 return;
 1830         case TSTATE_CBI_RESET3:
 1831                 if (err)        /* should not occur */
printf("%s: CBI bulk-out stall clear failed, %s\n",
sc->sc_dev.dv_xname, usbd_errstr(err));
 1834                         /* no error recovery, otherwise we end up in a loop */
sc->transfer_state = TSTATE_IDLE;
 1837                 if (sc->transfer_priv) {
sc->transfer_cb(sc, sc->transfer_priv,
sc->transfer_datalen,
sc->transfer_status);
 1841                 }
 1843                 return;
 1846         /***** Default *****/
 1847         default:
panic("%s: Unknown state %d",
sc->sc_dev.dv_xname, sc->transfer_state);
 1850         }
 1851 }
usbd_status
umass_bbb_get_max_lun(struct umass_softc *sc, u_int8_t *maxlun)
 1855 {
usb_device_request_t req;
usbd_status err;
 1859         *maxlun = 0;            /* Default to 0. */
DPRINTF(UDMASS_BBB, ("%s: Get Max Lun\n", sc->sc_dev.dv_xname));
 1863         /* The Get Max Lun command is a class-specific request. */
req.bmRequestType = UT_READ_CLASS_INTERFACE;
req.bRequest = UR_BBB_GET_MAX_LUN;
USETW(req.wValue, 0);
USETW(req.wIndex, sc->sc_ifaceno);
USETW(req.wLength, 1);
err = usbd_do_request_flags(sc->sc_udev, &req, maxlun,
USBD_SHORT_XFER_OK, 0, USBD_DEFAULT_TIMEOUT);
 1872         switch (err) {
 1873         case USBD_NORMAL_COMPLETION:
DPRINTF(UDMASS_BBB, ("%s: Max Lun %d\n",
sc->sc_dev.dv_xname, *maxlun));
 1876                 break;
 1878         case USBD_STALLED:
 1879                 /*
 1880                  * Device doesn't support Get Max Lun request.
 1881                  */
err = USBD_NORMAL_COMPLETION;
DPRINTF(UDMASS_BBB, ("%s: Get Max Lun not supported\n",
sc->sc_dev.dv_xname));
 1885                 break;
 1887         case USBD_SHORT_XFER:
 1888                 /*
 1889                  * XXX This must mean Get Max Lun is not supported, too!
 1890                  */
err = USBD_NORMAL_COMPLETION;
DPRINTF(UDMASS_BBB, ("%s: Get Max Lun SHORT_XFER\n",
sc->sc_dev.dv_xname));
 1894                 break;
 1896         default:
printf("%s: Get Max Lun failed: %s\n",
sc->sc_dev.dv_xname, usbd_errstr(err));
 1899                 /* XXX Should we port_reset the device? */
 1900                 break;
 1901         }
 1903         return (err);
 1904 }
 1906 #ifdef UMASS_DEBUG
 1907 void
umass_bbb_dump_cbw(struct umass_softc *sc, umass_bbb_cbw_t *cbw)
 1909 {
 1910         int clen = cbw->bCDBLength;
 1911         int dlen = UGETDW(cbw->dCBWDataTransferLength);
u_int8_t *c = cbw->CBWCDB;
 1913         int tag = UGETDW(cbw->dCBWTag);
 1914         int flags = cbw->bCBWFlags;
DPRINTF(UDMASS_BBB, ("%s: CBW %d: cmdlen=%d "
 1917                 "(0x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%s), "
 1918                 "data = %d bytes, dir = %s\n",
sc->sc_dev.dv_xname, tag, clen,
c[0], c[1], c[2], c[3], c[4], c[5],
c[6], c[7], c[8], c[9],
 1922                 (clen > 10? "...":""),
dlen, (flags == CBWFLAGS_IN? "in":
 1924                        (flags == CBWFLAGS_OUT? "out":"<invalid>"))));
 1925 }
 1927 void
umass_bbb_dump_csw(struct umass_softc *sc, umass_bbb_csw_t *csw)
 1929 {
 1930         int sig = UGETDW(csw->dCSWSignature);
 1931         int tag = UGETDW(csw->dCSWTag);
 1932         int res = UGETDW(csw->dCSWDataResidue);
 1933         int status = csw->bCSWStatus;
DPRINTF(UDMASS_BBB, ("%s: CSW %d: sig = 0x%08x (%s), tag = %d, "
 1936                 "res = %d, status = 0x%02x (%s)\n", sc->sc_dev.dv_xname,
tag, sig, (sig == CSWSIGNATURE?  "valid":"invalid"),
tag, res,
status, (status == CSWSTATUS_GOOD? "good":
 1940                          (status == CSWSTATUS_FAILED? "failed":
 1941                           (status == CSWSTATUS_PHASE? "phase":"<invalid>")))));
 1942 }
 1944 void
umass_dump_buffer(struct umass_softc *sc, u_int8_t *buffer, int buflen,
 1946                   int printlen)
 1947 {
 1948         int i, j;
 1949         char s1[40];
 1950         char s2[40];
 1951         char s3[5];
s1[0] = '\0';
s3[0] = '\0';
snprintf(s2, sizeof s2, " buffer=%p, buflen=%d", buffer, buflen);
 1957         for (i = 0; i < buflen && i < printlen; i++) {
j = i % 16;
 1959                 if (j == 0 && i != 0) {
DPRINTF(UDMASS_GEN, ("%s: 0x %s%s\n",
sc->sc_dev.dv_xname, s1, s2));
s2[0] = '\0';
 1963                 }
snprintf(&s1[j*2], sizeof s1 - j*2, "%02x", buffer[i] & 0xff);
 1965         }
 1966         if (buflen > printlen)
snprintf(s3, sizeof s3, " ...");
DPRINTF(UDMASS_GEN, ("%s: 0x %s%s%s\n",
sc->sc_dev.dv_xname, s1, s2, s3));
 1970 }
 1971 #endif