sys/bus/u4b/storage/ustorage_fs.c

   1 /* $FreeBSD$ */
   2 /*-
   3  * Copyright (C) 2003-2005 Alan Stern
   4  * Copyright (C) 2008 Hans Petter Selasky
   5  * All rights reserved.
   6  *
   7  * Redistribution and use in source and binary forms, with or without
   8  * modification, are permitted provided that the following conditions
   9  * are met:
  10  * 1. Redistributions of source code must retain the above copyright
  11  *    notice, this list of conditions, and the following disclaimer,
  12  *    without modification.
  13  * 2. Redistributions in binary form must reproduce the above copyright
  14  *    notice, this list of conditions and the following disclaimer in the
  15  *    documentation and/or other materials provided with the distribution.
  16  * 3. The names of the above-listed copyright holders may not be used
  17  *    to endorse or promote products derived from this software without
  18  *    specific prior written permission.
  19  *
  20  *
  21  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
  22  * IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
  23  * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  24  * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
  25  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
  26  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
  27  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
  28  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
  29  * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
  30  * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
  31  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  32  */
  33
  34 /*
  35  * NOTE: Much of the SCSI statemachine handling code derives from the
  36  * Linux USB gadget stack.
  37  */
  38
  39 #include <sys/stdint.h>
  40 #include <sys/param.h>
  41 #include <sys/queue.h>
  42 #include <sys/types.h>
  43 #include <sys/systm.h>
  44 #include <sys/kernel.h>
  45 #include <sys/bus.h>
  46 #include <sys/module.h>
  47 #include <sys/lock.h>
  48 #include <sys/mutex.h>
  49 #include <sys/condvar.h>
  50 #include <sys/sysctl.h>
  51 #include <sys/unistd.h>
  52 #include <sys/callout.h>
  53 #include <sys/malloc.h>
  54 #include <sys/priv.h>
  55
  56 #include <bus/u4b/usb.h>
  57 #include <bus/u4b/usbdi.h>
  58 #include "usbdevs.h"
  59 #include "usb_if.h"
  60
  61 #define USB_DEBUG_VAR ustorage_fs_debug
  62 #include <bus/u4b/usb_debug.h>
  63
  64 #ifdef USB_DEBUG
  65 static int ustorage_fs_debug = 0;
  66
  67 SYSCTL_NODE(_hw_usb, OID_AUTO, ustorage_fs, CTLFLAG_RW, 0, "USB ustorage_fs");
  68 SYSCTL_INT(_hw_usb_ustorage_fs, OID_AUTO, debug, CTLFLAG_RW,
  69     &ustorage_fs_debug, 0, "ustorage_fs debug level");
  70 #endif
  71
  72 /* Define some limits */
  73
  74 #ifndef USTORAGE_FS_BULK_SIZE
  75 #define USTORAGE_FS_BULK_SIZE (1UL << 17)       /* bytes */
  76 #endif
  77
  78 #ifndef USTORAGE_FS_MAX_LUN
  79 #define USTORAGE_FS_MAX_LUN     8       /* units */
  80 #endif
  81
  82 #ifndef USTORAGE_QDATA_MAX
  83 #define USTORAGE_QDATA_MAX      40      /* bytes */
  84 #endif
  85
  86 #define sc_cmd_data sc_cbw.CBWCDB
  87
  88 /*
  89  * The SCSI ID string must be exactly 28 characters long
  90  * exluding the terminating zero.
  91  */
  92 #ifndef USTORAGE_FS_ID_STRING
  93 #define USTORAGE_FS_ID_STRING \
  94         "FreeBSD " /* 8 */ \
  95         "File-Stor Gadget" /* 16 */ \
  96         "0101" /* 4 */
  97 #endif
  98
  99 /*
 100  * The following macro defines the number of
 101  * sectors to be allocated for the RAM disk:
 102  */
 103 #ifndef USTORAGE_FS_RAM_SECT
 104 #define USTORAGE_FS_RAM_SECT (1UL << 13)
 105 #endif
 106
 107 static uint8_t *ustorage_fs_ramdisk;
 108
 109 /* USB transfer definitions */
 110
 111 #define USTORAGE_FS_T_BBB_COMMAND     0
 112 #define USTORAGE_FS_T_BBB_DATA_DUMP   1
 113 #define USTORAGE_FS_T_BBB_DATA_READ   2
 114 #define USTORAGE_FS_T_BBB_DATA_WRITE  3
 115 #define USTORAGE_FS_T_BBB_STATUS      4
 116 #define USTORAGE_FS_T_BBB_MAX         5
 117
 118 /* USB data stage direction */
 119
 120 #define DIR_NONE        0
 121 #define DIR_READ        1
 122 #define DIR_WRITE       2
 123
 124 /* USB interface specific control request */
 125
 126 #define UR_BBB_RESET            0xff    /* Bulk-Only reset */
 127 #define UR_BBB_GET_MAX_LUN      0xfe    /* Get maximum lun */
 128
 129 /* Command Block Wrapper */
 130 typedef struct {
 131         uDWord  dCBWSignature;
 132 #define CBWSIGNATURE    0x43425355
 133         uDWord  dCBWTag;
 134         uDWord  dCBWDataTransferLength;
 135         uByte   bCBWFlags;
 136 #define CBWFLAGS_OUT    0x00
 137 #define CBWFLAGS_IN     0x80
 138         uByte   bCBWLUN;
 139         uByte   bCDBLength;
 140 #define CBWCDBLENGTH    16
 141         uByte   CBWCDB[CBWCDBLENGTH];
 142 } __packed ustorage_fs_bbb_cbw_t;
 143
 144 #define USTORAGE_FS_BBB_CBW_SIZE        31
 145
 146 /* Command Status Wrapper */
 147 typedef struct {
 148         uDWord  dCSWSignature;
 149 #define CSWSIGNATURE    0x53425355
 150         uDWord  dCSWTag;
 151         uDWord  dCSWDataResidue;
 152         uByte   bCSWStatus;
 153 #define CSWSTATUS_GOOD  0x0
 154 #define CSWSTATUS_FAILED        0x1
 155 #define CSWSTATUS_PHASE 0x2
 156 } __packed ustorage_fs_bbb_csw_t;
 157
 158 #define USTORAGE_FS_BBB_CSW_SIZE        13
 159
 160 struct ustorage_fs_lun {
 161
 162         uint8_t *memory_image;
 163
 164         uint32_t num_sectors;
 165         uint32_t sense_data;
 166         uint32_t sense_data_info;
 167         uint32_t unit_attention_data;
 168
 169         uint8_t read_only:1;
 170         uint8_t prevent_medium_removal:1;
 171         uint8_t info_valid:1;
 172         uint8_t removable:1;
 173 };
 174
 175 struct ustorage_fs_softc {
 176
 177         ustorage_fs_bbb_cbw_t *sc_cbw;  /* Command Wrapper Block */
 178         ustorage_fs_bbb_csw_t *sc_csw;  /* Command Status Block */
 179         void *sc_dma_ptr;               /* Main data buffer */
 180
 181         struct lock sc_lock;
 182
 183         struct ustorage_fs_lun sc_lun[USTORAGE_FS_MAX_LUN];
 184
 185         struct {
 186                 uint8_t *data_ptr;
 187                 struct ustorage_fs_lun *currlun;
 188
 189                 uint32_t data_rem;      /* bytes, as reported by the command
 190                                          * block wrapper */
 191                 uint32_t offset;        /* bytes */
 192
 193                 uint8_t cbw_dir;
 194                 uint8_t cmd_dir;
 195                 uint8_t lun;
 196                 uint8_t cmd_len;
 197                 uint8_t data_short:1;
 198                 uint8_t data_error:1;
 199         }       sc_transfer;
 200
 201         device_t sc_dev;
 202         struct usb_device *sc_udev;
 203         struct usb_xfer *sc_xfer[USTORAGE_FS_T_BBB_MAX];
 204
 205         uint8_t sc_iface_no;            /* interface number */
 206         uint8_t sc_last_lun;
 207         uint8_t sc_last_xfer_index;
 208         uint8_t sc_qdata[USTORAGE_QDATA_MAX];
 209 };
 210
 211 /* prototypes */
 212
 213 static device_probe_t ustorage_fs_probe;
 214 static device_attach_t ustorage_fs_attach;
 215 static device_detach_t ustorage_fs_detach;
 216 static device_suspend_t ustorage_fs_suspend;
 217 static device_resume_t ustorage_fs_resume;
 218 static usb_handle_request_t ustorage_fs_handle_request;
 219
 220 static usb_callback_t ustorage_fs_t_bbb_command_callback;
 221 static usb_callback_t ustorage_fs_t_bbb_data_dump_callback;
 222 static usb_callback_t ustorage_fs_t_bbb_data_read_callback;
 223 static usb_callback_t ustorage_fs_t_bbb_data_write_callback;
 224 static usb_callback_t ustorage_fs_t_bbb_status_callback;
 225
 226 static void ustorage_fs_transfer_start(struct ustorage_fs_softc *sc, uint8_t xfer_index);
 227 static void ustorage_fs_transfer_stop(struct ustorage_fs_softc *sc);
 228
 229 static uint8_t ustorage_fs_verify(struct ustorage_fs_softc *sc);
 230 static uint8_t ustorage_fs_inquiry(struct ustorage_fs_softc *sc);
 231 static uint8_t ustorage_fs_request_sense(struct ustorage_fs_softc *sc);
 232 static uint8_t ustorage_fs_read_capacity(struct ustorage_fs_softc *sc);
 233 static uint8_t ustorage_fs_mode_sense(struct ustorage_fs_softc *sc);
 234 static uint8_t ustorage_fs_start_stop(struct ustorage_fs_softc *sc);
 235 static uint8_t ustorage_fs_prevent_allow(struct ustorage_fs_softc *sc);
 236 static uint8_t ustorage_fs_read_format_capacities(struct ustorage_fs_softc *sc);
 237 static uint8_t ustorage_fs_mode_select(struct ustorage_fs_softc *sc);
 238 static uint8_t ustorage_fs_min_len(struct ustorage_fs_softc *sc, uint32_t len, uint32_t mask);
 239 static uint8_t ustorage_fs_read(struct ustorage_fs_softc *sc);
 240 static uint8_t ustorage_fs_write(struct ustorage_fs_softc *sc);
 241 static uint8_t ustorage_fs_check_cmd(struct ustorage_fs_softc *sc, uint8_t cmd_size, uint16_t mask, uint8_t needs_medium);
 242 static uint8_t ustorage_fs_do_cmd(struct ustorage_fs_softc *sc);
 243
 244 static device_method_t ustorage_fs_methods[] = {
 245         /* USB interface */
 246         DEVMETHOD(usb_handle_request, ustorage_fs_handle_request),
 247
 248         /* Device interface */
 249         DEVMETHOD(device_probe, ustorage_fs_probe),
 250         DEVMETHOD(device_attach, ustorage_fs_attach),
 251         DEVMETHOD(device_detach, ustorage_fs_detach),
 252         DEVMETHOD(device_suspend, ustorage_fs_suspend),
 253         DEVMETHOD(device_resume, ustorage_fs_resume),
 254
 255         DEVMETHOD_END
 256 };
 257
 258 static driver_t ustorage_fs_driver = {
 259         .name = "ustorage_fs",
 260         .methods = ustorage_fs_methods,
 261         .size = sizeof(struct ustorage_fs_softc),
 262 };
 263
 264 static devclass_t ustorage_fs_devclass;
 265
 266 DRIVER_MODULE(ustorage_fs, uhub, ustorage_fs_driver, ustorage_fs_devclass, NULL, NULL);
 267 MODULE_VERSION(ustorage_fs, 0);
 268 MODULE_DEPEND(ustorage_fs, usb, 1, 1, 1);
 269
 270 static struct usb_config ustorage_fs_bbb_config[USTORAGE_FS_T_BBB_MAX] = {
 271
 272         [USTORAGE_FS_T_BBB_COMMAND] = {
 273                 .type = UE_BULK,
 274                 .endpoint = UE_ADDR_ANY,
 275                 .direction = UE_DIR_OUT,
 276                 .bufsize = sizeof(ustorage_fs_bbb_cbw_t),
 277                 .callback = &ustorage_fs_t_bbb_command_callback,
 278                 .usb_mode = USB_MODE_DEVICE,
 279         },
 280
 281         [USTORAGE_FS_T_BBB_DATA_DUMP] = {
 282                 .type = UE_BULK,
 283                 .endpoint = UE_ADDR_ANY,
 284                 .direction = UE_DIR_OUT,
 285                 .bufsize = 0,   /* use wMaxPacketSize */
 286                 .flags = {.proxy_buffer = 1,.short_xfer_ok = 1,},
 287                 .callback = &ustorage_fs_t_bbb_data_dump_callback,
 288                 .usb_mode = USB_MODE_DEVICE,
 289         },
 290
 291         [USTORAGE_FS_T_BBB_DATA_READ] = {
 292                 .type = UE_BULK,
 293                 .endpoint = UE_ADDR_ANY,
 294                 .direction = UE_DIR_OUT,
 295                 .bufsize = USTORAGE_FS_BULK_SIZE,
 296                 .flags = {.proxy_buffer = 1,.short_xfer_ok = 1},
 297                 .callback = &ustorage_fs_t_bbb_data_read_callback,
 298                 .usb_mode = USB_MODE_DEVICE,
 299         },
 300
 301         [USTORAGE_FS_T_BBB_DATA_WRITE] = {
 302                 .type = UE_BULK,
 303                 .endpoint = UE_ADDR_ANY,
 304                 .direction = UE_DIR_IN,
 305                 .bufsize = USTORAGE_FS_BULK_SIZE,
 306                 .flags = {.proxy_buffer = 1,.short_xfer_ok = 1,.ext_buffer = 1},
 307                 .callback = &ustorage_fs_t_bbb_data_write_callback,
 308                 .usb_mode = USB_MODE_DEVICE,
 309         },
 310
 311         [USTORAGE_FS_T_BBB_STATUS] = {
 312                 .type = UE_BULK,
 313                 .endpoint = UE_ADDR_ANY,
 314                 .direction = UE_DIR_IN,
 315                 .bufsize = sizeof(ustorage_fs_bbb_csw_t),
 316                 .flags = {.short_xfer_ok = 1},
 317                 .callback = &ustorage_fs_t_bbb_status_callback,
 318                 .usb_mode = USB_MODE_DEVICE,
 319         },
 320 };
 321
 322 /*
 323  * USB device probe/attach/detach
 324  */
 325
 326 static int
 327 ustorage_fs_probe(device_t dev)
 328 {
 329         struct usb_attach_arg *uaa = device_get_ivars(dev);
 330         struct usb_interface_descriptor *id;
 331
 332         if (uaa->usb_mode != USB_MODE_DEVICE) {
 333                 return (ENXIO);
 334         }
 335         /* Check for a standards compliant device */
 336         id = usbd_get_interface_descriptor(uaa->iface);
 337         if ((id == NULL) ||
 338             (id->bInterfaceClass != UICLASS_MASS) ||
 339             (id->bInterfaceSubClass != UISUBCLASS_SCSI) ||
 340             (id->bInterfaceProtocol != UIPROTO_MASS_BBB)) {
 341                 return (ENXIO);
 342         }
 343         return (BUS_PROBE_GENERIC);
 344 }
 345
 346 static int
 347 ustorage_fs_attach(device_t dev)
 348 {
 349         struct ustorage_fs_softc *sc = device_get_softc(dev);
 350         struct usb_attach_arg *uaa = device_get_ivars(dev);
 351         struct usb_interface_descriptor *id;
 352         int err;
 353         int unit;
 354
 355         /*
 356          * NOTE: the softc struct is cleared in device_set_driver.
 357          * We can safely call ustorage_fs_detach without specifically
 358          * initializing the struct.
 359          */
 360
 361         sc->sc_dev = dev;
 362         sc->sc_udev = uaa->device;
 363         unit = device_get_unit(dev);
 364
 365         /* enable power saving mode */
 366         usbd_set_power_mode(uaa->device, USB_POWER_MODE_SAVE);
 367
 368         if (unit == 0) {
 369                 if (ustorage_fs_ramdisk == NULL) {
 370                         /*
 371                          * allocate a memory image for our ramdisk until
 372                          * further
 373                          */
 374                         ustorage_fs_ramdisk =
 375                             kmalloc(USTORAGE_FS_RAM_SECT << 9, M_USB,
 376                             M_ZERO | M_WAITOK);
 377
 378                         if (ustorage_fs_ramdisk == NULL) {
 379                                 return (ENOMEM);
 380                         }
 381                 }
 382                 sc->sc_lun[0].memory_image = ustorage_fs_ramdisk;
 383                 sc->sc_lun[0].num_sectors = USTORAGE_FS_RAM_SECT;
 384                 sc->sc_lun[0].removable = 1;
 385         }
 386
 387         device_set_usb_desc(dev);
 388
 389         lockinit(&sc->sc_lock, "USTORAGE_FS lock", 0, LK_CANRECURSE);
 390
 391         /* get interface index */
 392
 393         id = usbd_get_interface_descriptor(uaa->iface);
 394         if (id == NULL) {
 395                 device_printf(dev, "failed to get "
 396                     "interface number\n");
 397                 goto detach;
 398         }
 399         sc->sc_iface_no = id->bInterfaceNumber;
 400
 401         err = usbd_transfer_setup(uaa->device,
 402             &uaa->info.bIfaceIndex, sc->sc_xfer, ustorage_fs_bbb_config,
 403             USTORAGE_FS_T_BBB_MAX, sc, &sc->sc_lock);
 404         if (err) {
 405                 device_printf(dev, "could not setup required "
 406                     "transfers, %s\n", usbd_errstr(err));
 407                 goto detach;
 408         }
 409
 410         sc->sc_cbw = usbd_xfer_get_frame_buffer(sc->sc_xfer[
 411             USTORAGE_FS_T_BBB_COMMAND], 0);
 412         sc->sc_csw = usbd_xfer_get_frame_buffer(sc->sc_xfer[
 413             USTORAGE_FS_T_BBB_STATUS], 0);
 414         sc->sc_dma_ptr = usbd_xfer_get_frame_buffer(sc->sc_xfer[
 415             USTORAGE_FS_T_BBB_DATA_READ], 0);
 416
 417         /* start Mass Storage State Machine */
 418
 419         lockmgr(&sc->sc_lock, LK_EXCLUSIVE);
 420         ustorage_fs_transfer_start(sc, USTORAGE_FS_T_BBB_COMMAND);
 421         lockmgr(&sc->sc_lock, LK_RELEASE);
 422
 423         return (0);                     /* success */
 424
 425 detach:
 426         ustorage_fs_detach(dev);
 427         return (ENXIO);                 /* failure */
 428 }
 429
 430 static int
 431 ustorage_fs_detach(device_t dev)
 432 {
 433         struct ustorage_fs_softc *sc = device_get_softc(dev);
 434
 435         /* teardown our statemachine */
 436
 437         usbd_transfer_unsetup(sc->sc_xfer, USTORAGE_FS_T_BBB_MAX);
 438
 439         lockuninit(&sc->sc_lock);
 440
 441         return (0);                     /* success */
 442 }
 443
 444 static int
 445 ustorage_fs_suspend(device_t dev)
 446 {
 447         device_printf(dev, "suspending\n");
 448         return (0);                     /* success */
 449 }
 450
 451 static int
 452 ustorage_fs_resume(device_t dev)
 453 {
 454         device_printf(dev, "resuming\n");
 455         return (0);                     /* success */
 456 }
 457
 458 /*
 459  * Generic functions to handle transfers
 460  */
 461
 462 static void
 463 ustorage_fs_transfer_start(struct ustorage_fs_softc *sc, uint8_t xfer_index)
 464 {
 465         if (sc->sc_xfer[xfer_index]) {
 466                 sc->sc_last_xfer_index = xfer_index;
 467                 usbd_transfer_start(sc->sc_xfer[xfer_index]);
 468         }
 469 }
 470
 471 static void
 472 ustorage_fs_transfer_stop(struct ustorage_fs_softc *sc)
 473 {
 474         usbd_transfer_stop(sc->sc_xfer[sc->sc_last_xfer_index]);
 475         lockmgr(&sc->sc_lock, LK_RELEASE);
 476         usbd_transfer_drain(sc->sc_xfer[sc->sc_last_xfer_index]);
 477         lockmgr(&sc->sc_lock, LK_EXCLUSIVE);
 478 }
 479
 480 static int
 481 ustorage_fs_handle_request(device_t dev,
 482     const void *preq, void **pptr, uint16_t *plen,
 483     uint16_t offset, uint8_t *pstate)
 484 {
 485         struct ustorage_fs_softc *sc = device_get_softc(dev);
 486         const struct usb_device_request *req = preq;
 487         uint8_t is_complete = *pstate;
 488
 489         if (!is_complete) {
 490                 if ((req->bmRequestType == UT_WRITE_CLASS_INTERFACE) &&
 491                     (req->bRequest == UR_BBB_RESET)) {
 492                         *plen = 0;
 493                         lockmgr(&sc->sc_lock, LK_EXCLUSIVE);
 494                         ustorage_fs_transfer_stop(sc);
 495                         sc->sc_transfer.data_error = 1;
 496                         ustorage_fs_transfer_start(sc,
 497                             USTORAGE_FS_T_BBB_COMMAND);
 498                         lockmgr(&sc->sc_lock, LK_RELEASE);
 499                         return (0);
 500                 } else if ((req->bmRequestType == UT_READ_CLASS_INTERFACE) &&
 501                            (req->bRequest == UR_BBB_GET_MAX_LUN)) {
 502                         if (offset == 0) {
 503                                 *plen = 1;
 504                                 *pptr = &sc->sc_last_lun;
 505                         } else {
 506                                 *plen = 0;
 507                         }
 508                         return (0);
 509                 }
 510         }
 511         return (ENXIO);                 /* use builtin handler */
 512 }
 513
 514 static void
 515 ustorage_fs_t_bbb_command_callback(struct usb_xfer *xfer, usb_error_t error)
 516 {
 517         struct ustorage_fs_softc *sc = usbd_xfer_softc(xfer);
 518         uint32_t tag;
 519         uint8_t err = 0;
 520
 521         DPRINTF("\n");
 522
 523         switch (USB_GET_STATE(xfer)) {
 524         case USB_ST_TRANSFERRED:
 525
 526                 tag = UGETDW(sc->sc_cbw->dCBWSignature);
 527
 528                 if (tag != CBWSIGNATURE) {
 529                         /* do nothing */
 530                         DPRINTF("invalid signature 0x%08x\n", tag);
 531                         break;
 532                 }
 533                 tag = UGETDW(sc->sc_cbw->dCBWTag);
 534
 535                 /* echo back tag */
 536                 USETDW(sc->sc_csw->dCSWTag, tag);
 537
 538                 /* reset status */
 539                 sc->sc_csw->bCSWStatus = 0;
 540
 541                 /* reset data offset, data length and data remainder */
 542                 sc->sc_transfer.offset = 0;
 543                 sc->sc_transfer.data_rem =
 544                     UGETDW(sc->sc_cbw->dCBWDataTransferLength);
 545
 546                 /* reset data flags */
 547                 sc->sc_transfer.data_short = 0;
 548
 549                 /* extract LUN */
 550                 sc->sc_transfer.lun = sc->sc_cbw->bCBWLUN;
 551
 552                 if (sc->sc_transfer.data_rem == 0) {
 553                         sc->sc_transfer.cbw_dir = DIR_NONE;
 554                 } else {
 555                         if (sc->sc_cbw->bCBWFlags & CBWFLAGS_IN) {
 556                                 sc->sc_transfer.cbw_dir = DIR_WRITE;
 557                         } else {
 558                                 sc->sc_transfer.cbw_dir = DIR_READ;
 559                         }
 560                 }
 561
 562                 sc->sc_transfer.cmd_len = sc->sc_cbw->bCDBLength;
 563                 if ((sc->sc_transfer.cmd_len > sizeof(sc->sc_cbw->CBWCDB)) ||
 564                     (sc->sc_transfer.cmd_len == 0)) {
 565                         /* just halt - this is invalid */
 566                         DPRINTF("invalid command length %d bytes\n",
 567                             sc->sc_transfer.cmd_len);
 568                         break;
 569                 }
 570
 571                 err = ustorage_fs_do_cmd(sc);
 572                 if (err) {
 573                         /* got an error */
 574                         DPRINTF("command failed\n");
 575                         break;
 576                 }
 577                 if ((sc->sc_transfer.data_rem > 0) &&
 578                     (sc->sc_transfer.cbw_dir != sc->sc_transfer.cmd_dir)) {
 579                         /* contradicting data transfer direction */
 580                         err = 1;
 581                         DPRINTF("data direction mismatch\n");
 582                         break;
 583                 }
 584                 switch (sc->sc_transfer.cbw_dir) {
 585                 case DIR_READ:
 586                         ustorage_fs_transfer_start(sc, USTORAGE_FS_T_BBB_DATA_READ);
 587                         break;
 588                 case DIR_WRITE:
 589                         ustorage_fs_transfer_start(sc, USTORAGE_FS_T_BBB_DATA_WRITE);
 590                         break;
 591                 default:
 592                         ustorage_fs_transfer_start(sc,
 593                             USTORAGE_FS_T_BBB_STATUS);
 594                         break;
 595                 }
 596                 break;
 597
 598         case USB_ST_SETUP:
 599 tr_setup:
 600                 if (sc->sc_transfer.data_error) {
 601                         sc->sc_transfer.data_error = 0;
 602                         usbd_xfer_set_stall(xfer);
 603                         DPRINTF("stall pipe\n");
 604                 }
 605                 usbd_xfer_set_frame_len(xfer, 0,
 606                     sizeof(ustorage_fs_bbb_cbw_t));
 607                 usbd_transfer_submit(xfer);
 608                 break;
 609
 610         default:                        /* Error */
 611                 DPRINTF("error\n");
 612                 if (error == USB_ERR_CANCELLED) {
 613                         break;
 614                 }
 615                 /* If the pipe is already stalled, don't do another stall */
 616                 if (!usbd_xfer_is_stalled(xfer))
 617                         sc->sc_transfer.data_error = 1;
 618
 619                 /* try again */
 620                 goto tr_setup;
 621         }
 622         if (err) {
 623                 if (sc->sc_csw->bCSWStatus == 0) {
 624                         /* set some default error code */
 625                         sc->sc_csw->bCSWStatus = CSWSTATUS_FAILED;
 626                 }
 627                 if (sc->sc_transfer.cbw_dir == DIR_READ) {
 628                         /* dump all data */
 629                         ustorage_fs_transfer_start(sc,
 630                             USTORAGE_FS_T_BBB_DATA_DUMP);
 631                         return;
 632                 }
 633                 if (sc->sc_transfer.cbw_dir == DIR_WRITE) {
 634                         /* need to stall before status */
 635                         sc->sc_transfer.data_error = 1;
 636                 }
 637                 ustorage_fs_transfer_start(sc, USTORAGE_FS_T_BBB_STATUS);
 638         }
 639 }
 640
 641 static void
 642 ustorage_fs_t_bbb_data_dump_callback(struct usb_xfer *xfer, usb_error_t error)
 643 {
 644         struct ustorage_fs_softc *sc = usbd_xfer_softc(xfer);
 645         uint32_t max_bulk = usbd_xfer_max_len(xfer);
 646         int actlen, sumlen;
 647
 648         usbd_xfer_status(xfer, &actlen, &sumlen, NULL, NULL);
 649
 650         DPRINTF("\n");
 651
 652         switch (USB_GET_STATE(xfer)) {
 653         case USB_ST_TRANSFERRED:
 654                 sc->sc_transfer.data_rem -= actlen;
 655                 sc->sc_transfer.offset += actlen;
 656
 657                 if (actlen != sumlen || sc->sc_transfer.data_rem == 0) {
 658                         /* short transfer or end of data */
 659                         ustorage_fs_transfer_start(sc,
 660                             USTORAGE_FS_T_BBB_STATUS);
 661                         break;
 662                 }
 663                 /* Fallthrough */
 664
 665         case USB_ST_SETUP:
 666 tr_setup:
 667                 if (max_bulk > sc->sc_transfer.data_rem) {
 668                         max_bulk = sc->sc_transfer.data_rem;
 669                 }
 670                 if (sc->sc_transfer.data_error) {
 671                         sc->sc_transfer.data_error = 0;
 672                         usbd_xfer_set_stall(xfer);
 673                 }
 674                 usbd_xfer_set_frame_len(xfer, 0, max_bulk);
 675                 usbd_transfer_submit(xfer);
 676                 break;
 677
 678         default:                        /* Error */
 679                 if (error == USB_ERR_CANCELLED) {
 680                         break;
 681                 }
 682                 /*
 683                  * If the pipe is already stalled, don't do another stall:
 684                  */
 685                 if (!usbd_xfer_is_stalled(xfer))
 686                         sc->sc_transfer.data_error = 1;
 687
 688                 /* try again */
 689                 goto tr_setup;
 690         }
 691 }
 692
 693 static void
 694 ustorage_fs_t_bbb_data_read_callback(struct usb_xfer *xfer, usb_error_t error)
 695 {
 696         struct ustorage_fs_softc *sc = usbd_xfer_softc(xfer);
 697         uint32_t max_bulk = usbd_xfer_max_len(xfer);
 698         int actlen, sumlen;
 699
 700         usbd_xfer_status(xfer, &actlen, &sumlen, NULL, NULL);
 701
 702         DPRINTF("\n");
 703
 704         switch (USB_GET_STATE(xfer)) {
 705         case USB_ST_TRANSFERRED:
 706                 /* XXX copy data from DMA buffer */
 707                 memcpy(sc->sc_transfer.data_ptr, sc->sc_dma_ptr, actlen);
 708
 709                 sc->sc_transfer.data_rem -= actlen;
 710                 sc->sc_transfer.data_ptr += actlen;
 711                 sc->sc_transfer.offset += actlen;
 712
 713                 if (actlen != sumlen || sc->sc_transfer.data_rem == 0) {
 714                         /* short transfer or end of data */
 715                         ustorage_fs_transfer_start(sc,
 716                             USTORAGE_FS_T_BBB_STATUS);
 717                         break;
 718                 }
 719                 /* Fallthrough */
 720
 721         case USB_ST_SETUP:
 722 tr_setup:
 723                 if (max_bulk > sc->sc_transfer.data_rem) {
 724                         max_bulk = sc->sc_transfer.data_rem;
 725                 }
 726                 if (sc->sc_transfer.data_error) {
 727                         sc->sc_transfer.data_error = 0;
 728                         usbd_xfer_set_stall(xfer);
 729                 }
 730
 731                 usbd_xfer_set_frame_data(xfer, 0, sc->sc_dma_ptr, max_bulk);
 732                 usbd_transfer_submit(xfer);
 733                 break;
 734
 735         default:                        /* Error */
 736                 if (error == USB_ERR_CANCELLED) {
 737                         break;
 738                 }
 739                 /* If the pipe is already stalled, don't do another stall */
 740                 if (!usbd_xfer_is_stalled(xfer))
 741                         sc->sc_transfer.data_error = 1;
 742
 743                 /* try again */
 744                 goto tr_setup;
 745         }
 746 }
 747
 748 static void
 749 ustorage_fs_t_bbb_data_write_callback(struct usb_xfer *xfer, usb_error_t error)
 750 {
 751         struct ustorage_fs_softc *sc = usbd_xfer_softc(xfer);
 752         uint32_t max_bulk = usbd_xfer_max_len(xfer);
 753         int actlen, sumlen;
 754
 755         usbd_xfer_status(xfer, &actlen, &sumlen, NULL, NULL);
 756
 757         DPRINTF("\n");
 758
 759         switch (USB_GET_STATE(xfer)) {
 760         case USB_ST_TRANSFERRED:
 761                 sc->sc_transfer.data_rem -= actlen;
 762                 sc->sc_transfer.data_ptr += actlen;
 763                 sc->sc_transfer.offset += actlen;
 764
 765                 if (actlen != sumlen || sc->sc_transfer.data_rem == 0) {
 766                         /* short transfer or end of data */
 767                         ustorage_fs_transfer_start(sc,
 768                             USTORAGE_FS_T_BBB_STATUS);
 769                         break;
 770                 }
 771         case USB_ST_SETUP:
 772 tr_setup:
 773                 if (max_bulk >= sc->sc_transfer.data_rem) {
 774                         max_bulk = sc->sc_transfer.data_rem;
 775                         if (sc->sc_transfer.data_short)
 776                                 usbd_xfer_set_flag(xfer, USB_FORCE_SHORT_XFER);
 777                         else
 778                                 usbd_xfer_clr_flag(xfer, USB_FORCE_SHORT_XFER);
 779                 } else
 780                         usbd_xfer_clr_flag(xfer, USB_FORCE_SHORT_XFER);
 781
 782                 if (sc->sc_transfer.data_error) {
 783                         sc->sc_transfer.data_error = 0;
 784                         usbd_xfer_set_stall(xfer);
 785                 }
 786
 787                 /* XXX copy data to DMA buffer */
 788                 memcpy(sc->sc_dma_ptr, sc->sc_transfer.data_ptr, max_bulk);
 789
 790                 usbd_xfer_set_frame_data(xfer, 0, sc->sc_dma_ptr, max_bulk);
 791                 usbd_transfer_submit(xfer);
 792                 break;
 793
 794         default:                        /* Error */
 795                 if (error == USB_ERR_CANCELLED) {
 796                         break;
 797                 }
 798                 /*
 799                  * If the pipe is already stalled, don't do another
 800                  * stall
 801                  */
 802                 if (!usbd_xfer_is_stalled(xfer))
 803                         sc->sc_transfer.data_error = 1;
 804
 805                 /* try again */
 806                 goto tr_setup;
 807         }
 808 }
 809
 810 static void
 811 ustorage_fs_t_bbb_status_callback(struct usb_xfer *xfer, usb_error_t error)
 812 {
 813         struct ustorage_fs_softc *sc = usbd_xfer_softc(xfer);
 814
 815         DPRINTF("\n");
 816
 817         switch (USB_GET_STATE(xfer)) {
 818         case USB_ST_TRANSFERRED:
 819                 ustorage_fs_transfer_start(sc, USTORAGE_FS_T_BBB_COMMAND);
 820                 break;
 821
 822         case USB_ST_SETUP:
 823 tr_setup:
 824                 USETDW(sc->sc_csw->dCSWSignature, CSWSIGNATURE);
 825                 USETDW(sc->sc_csw->dCSWDataResidue, sc->sc_transfer.data_rem);
 826
 827                 if (sc->sc_transfer.data_error) {
 828                         sc->sc_transfer.data_error = 0;
 829                         usbd_xfer_set_stall(xfer);
 830                 }
 831                 usbd_xfer_set_frame_len(xfer, 0,
 832                     sizeof(ustorage_fs_bbb_csw_t));
 833                 usbd_transfer_submit(xfer);
 834                 break;
 835
 836         default:
 837                 if (error == USB_ERR_CANCELLED) {
 838                         break;
 839                 }
 840                 /* If the pipe is already stalled, don't do another stall */
 841                 if (!usbd_xfer_is_stalled(xfer))
 842                         sc->sc_transfer.data_error = 1;
 843
 844                 /* try again */
 845                 goto tr_setup;
 846         }
 847 }
 848
 849 /* SCSI commands that we recognize */
 850 #define SC_FORMAT_UNIT                  0x04
 851 #define SC_INQUIRY                      0x12
 852 #define SC_MODE_SELECT_6                0x15
 853 #define SC_MODE_SELECT_10               0x55
 854 #define SC_MODE_SENSE_6                 0x1a
 855 #define SC_MODE_SENSE_10                0x5a
 856 #define SC_PREVENT_ALLOW_MEDIUM_REMOVAL 0x1e
 857 #define SC_READ_6                       0x08
 858 #define SC_READ_10                      0x28
 859 #define SC_READ_12                      0xa8
 860 #define SC_READ_CAPACITY                0x25
 861 #define SC_READ_FORMAT_CAPACITIES       0x23
 862 #define SC_RELEASE                      0x17
 863 #define SC_REQUEST_SENSE                0x03
 864 #define SC_RESERVE                      0x16
 865 #define SC_SEND_DIAGNOSTIC              0x1d
 866 #define SC_START_STOP_UNIT              0x1b
 867 #define SC_SYNCHRONIZE_CACHE            0x35
 868 #define SC_TEST_UNIT_READY              0x00
 869 #define SC_VERIFY                       0x2f
 870 #define SC_WRITE_6                      0x0a
 871 #define SC_WRITE_10                     0x2a
 872 #define SC_WRITE_12                     0xaa
 873
 874 /* SCSI Sense Key/Additional Sense Code/ASC Qualifier values */
 875 #define SS_NO_SENSE                             0
 876 #define SS_COMMUNICATION_FAILURE                0x040800
 877 #define SS_INVALID_COMMAND                      0x052000
 878 #define SS_INVALID_FIELD_IN_CDB                 0x052400
 879 #define SS_LOGICAL_BLOCK_ADDRESS_OUT_OF_RANGE   0x052100
 880 #define SS_LOGICAL_UNIT_NOT_SUPPORTED           0x052500
 881 #define SS_MEDIUM_NOT_PRESENT                   0x023a00
 882 #define SS_MEDIUM_REMOVAL_PREVENTED             0x055302
 883 #define SS_NOT_READY_TO_READY_TRANSITION        0x062800
 884 #define SS_RESET_OCCURRED                       0x062900
 885 #define SS_SAVING_PARAMETERS_NOT_SUPPORTED      0x053900
 886 #define SS_UNRECOVERED_READ_ERROR               0x031100
 887 #define SS_WRITE_ERROR                          0x030c02
 888 #define SS_WRITE_PROTECTED                      0x072700
 889
 890 #define SK(x)           ((uint8_t) ((x) >> 16)) /* Sense Key byte, etc. */
 891 #define ASC(x)          ((uint8_t) ((x) >> 8))
 892 #define ASCQ(x)         ((uint8_t) (x))
 893
 894 /* Routines for unaligned data access */
 895
 896 static uint16_t
 897 get_be16(uint8_t *buf)
 898 {
 899         return ((uint16_t)buf[0] << 8) | ((uint16_t)buf[1]);
 900 }
 901
 902 static uint32_t
 903 get_be32(uint8_t *buf)
 904 {
 905         return ((uint32_t)buf[0] << 24) | ((uint32_t)buf[1] << 16) |
 906         ((uint32_t)buf[2] << 8) | ((uint32_t)buf[3]);
 907 }
 908
 909 static void
 910 put_be16(uint8_t *buf, uint16_t val)
 911 {
 912         buf[0] = val >> 8;
 913         buf[1] = val;
 914 }
 915
 916 static void
 917 put_be32(uint8_t *buf, uint32_t val)
 918 {
 919         buf[0] = val >> 24;
 920         buf[1] = val >> 16;
 921         buf[2] = val >> 8;
 922         buf[3] = val & 0xff;
 923 }
 924
 925 /*------------------------------------------------------------------------*
 926  *      ustorage_fs_verify
 927  *
 928  * Returns:
 929  *    0: Success
 930  * Else: Failure
 931  *------------------------------------------------------------------------*/
 932 static uint8_t
 933 ustorage_fs_verify(struct ustorage_fs_softc *sc)
 934 {
 935         struct ustorage_fs_lun *currlun = sc->sc_transfer.currlun;
 936         uint32_t lba;
 937         uint32_t vlen;
 938         uint64_t file_offset;
 939         uint64_t amount_left;
 940
 941         /*
 942          * Get the starting Logical Block Address
 943          */
 944         lba = get_be32(&sc->sc_cbw->CBWCDB[2]);
 945
 946         /*
 947          * We allow DPO (Disable Page Out = don't save data in the cache)
 948          * but we don't implement it.
 949          */
 950         if ((sc->sc_cbw->CBWCDB[1] & ~0x10) != 0) {
 951                 currlun->sense_data = SS_INVALID_FIELD_IN_CDB;
 952                 return (1);
 953         }
 954         vlen = get_be16(&sc->sc_cbw->CBWCDB[7]);
 955         if (vlen == 0) {
 956                 goto done;
 957         }
 958         /* No default reply */
 959
 960         /* Prepare to carry out the file verify */
 961         amount_left = vlen;
 962         amount_left <<= 9;
 963         file_offset = lba;
 964         file_offset <<= 9;
 965
 966         /* Range check */
 967         vlen += lba;
 968
 969         if ((vlen < lba) ||
 970             (vlen > currlun->num_sectors) ||
 971             (lba >= currlun->num_sectors)) {
 972                 currlun->sense_data = SS_LOGICAL_BLOCK_ADDRESS_OUT_OF_RANGE;
 973                 return (1);
 974         }
 975         /* XXX TODO: verify that data is readable */
 976 done:
 977         return (ustorage_fs_min_len(sc, 0, -1U));
 978 }
 979
 980 /*------------------------------------------------------------------------*
 981  *      ustorage_fs_inquiry
 982  *
 983  * Returns:
 984  *    0: Success
 985  * Else: Failure
 986  *------------------------------------------------------------------------*/
 987 static uint8_t
 988 ustorage_fs_inquiry(struct ustorage_fs_softc *sc)
 989 {
 990         uint8_t *buf = sc->sc_transfer.data_ptr;
 991
 992         struct ustorage_fs_lun *currlun = sc->sc_transfer.currlun;
 993
 994         if (!sc->sc_transfer.currlun) {
 995                 /* Unsupported LUNs are okay */
 996                 memset(buf, 0, 36);
 997                 buf[0] = 0x7f;
 998                 /* Unsupported, no device - type */
 999                 return (ustorage_fs_min_len(sc, 36, -1U));
1000         }
1001         memset(buf, 0, 8);
1002         /* Non - removable, direct - access device */
1003         if (currlun->removable)
1004                 buf[1] = 0x80;
1005         buf[2] = 2;
1006         /* ANSI SCSI level 2 */
1007         buf[3] = 2;
1008         /* SCSI - 2 INQUIRY data format */
1009         buf[4] = 31;
1010         /* Additional length */
1011         /* No special options */
1012         /* Copy in ID string */
1013         memcpy(buf + 8, USTORAGE_FS_ID_STRING, 28);
1014
1015 #if (USTORAGE_QDATA_MAX < 36)
1016 #error "(USTORAGE_QDATA_MAX < 36)"
1017 #endif
1018         return (ustorage_fs_min_len(sc, 36, -1U));
1019 }
1020
1021 /*------------------------------------------------------------------------*
1022  *      ustorage_fs_request_sense
1023  *
1024  * Returns:
1025  *    0: Success
1026  * Else: Failure
1027  *------------------------------------------------------------------------*/
1028 static uint8_t
1029 ustorage_fs_request_sense(struct ustorage_fs_softc *sc)
1030 {
1031         uint8_t *buf = sc->sc_transfer.data_ptr;
1032         struct ustorage_fs_lun *currlun = sc->sc_transfer.currlun;
1033         uint32_t sd;
1034         uint32_t sdinfo;
1035         uint8_t valid;
1036
1037         /*
1038          * From the SCSI-2 spec., section 7.9 (Unit attention condition):
1039          *
1040          * If a REQUEST SENSE command is received from an initiator
1041          * with a pending unit attention condition (before the target
1042          * generates the contingent allegiance condition), then the
1043          * target shall either:
1044          *   a) report any pending sense data and preserve the unit
1045          *      attention condition on the logical unit, or,
1046          *   b) report the unit attention condition, may discard any
1047          *      pending sense data, and clear the unit attention
1048          *      condition on the logical unit for that initiator.
1049          *
1050          * FSG normally uses option a); enable this code to use option b).
1051          */
1052 #if 0
1053         if (currlun && currlun->unit_attention_data != SS_NO_SENSE) {
1054                 currlun->sense_data = currlun->unit_attention_data;
1055                 currlun->unit_attention_data = SS_NO_SENSE;
1056         }
1057 #endif
1058
1059         if (!currlun) {
1060                 /* Unsupported LUNs are okay */
1061                 sd = SS_LOGICAL_UNIT_NOT_SUPPORTED;
1062                 sdinfo = 0;
1063                 valid = 0;
1064         } else {
1065                 sd = currlun->sense_data;
1066                 sdinfo = currlun->sense_data_info;
1067                 valid = currlun->info_valid << 7;
1068                 currlun->sense_data = SS_NO_SENSE;
1069                 currlun->sense_data_info = 0;
1070                 currlun->info_valid = 0;
1071         }
1072
1073         memset(buf, 0, 18);
1074         buf[0] = valid | 0x70;
1075         /* Valid, current error */
1076         buf[2] = SK(sd);
1077         put_be32(&buf[3], sdinfo);
1078         /* Sense information */
1079         buf[7] = 18 - 8;
1080         /* Additional sense length */
1081         buf[12] = ASC(sd);
1082         buf[13] = ASCQ(sd);
1083
1084 #if (USTORAGE_QDATA_MAX < 18)
1085 #error "(USTORAGE_QDATA_MAX < 18)"
1086 #endif
1087         return (ustorage_fs_min_len(sc, 18, -1U));
1088 }
1089
1090 /*------------------------------------------------------------------------*
1091  *      ustorage_fs_read_capacity
1092  *
1093  * Returns:
1094  *    0: Success
1095  * Else: Failure
1096  *------------------------------------------------------------------------*/
1097 static uint8_t
1098 ustorage_fs_read_capacity(struct ustorage_fs_softc *sc)
1099 {
1100         uint8_t *buf = sc->sc_transfer.data_ptr;
1101         struct ustorage_fs_lun *currlun = sc->sc_transfer.currlun;
1102         uint32_t lba = get_be32(&sc->sc_cbw->CBWCDB[2]);
1103         uint8_t pmi = sc->sc_cbw->CBWCDB[8];
1104
1105         /* Check the PMI and LBA fields */
1106         if ((pmi > 1) || ((pmi == 0) && (lba != 0))) {
1107                 currlun->sense_data = SS_INVALID_FIELD_IN_CDB;
1108                 return (1);
1109         }
1110         /* Max logical block */
1111         put_be32(&buf[0], currlun->num_sectors - 1);
1112         /* Block length */
1113         put_be32(&buf[4], 512);
1114
1115 #if (USTORAGE_QDATA_MAX < 8)
1116 #error "(USTORAGE_QDATA_MAX < 8)"
1117 #endif
1118         return (ustorage_fs_min_len(sc, 8, -1U));
1119 }
1120
1121 /*------------------------------------------------------------------------*
1122  *      ustorage_fs_mode_sense
1123  *
1124  * Returns:
1125  *    0: Success
1126  * Else: Failure
1127  *------------------------------------------------------------------------*/
1128 static uint8_t
1129 ustorage_fs_mode_sense(struct ustorage_fs_softc *sc)
1130 {
1131         uint8_t *buf = sc->sc_transfer.data_ptr;
1132         struct ustorage_fs_lun *currlun = sc->sc_transfer.currlun;
1133         uint8_t *buf0;
1134         uint16_t len;
1135         uint16_t limit;
1136         uint8_t mscmnd = sc->sc_cbw->CBWCDB[0];
1137         uint8_t pc;
1138         uint8_t page_code;
1139         uint8_t changeable_values;
1140         uint8_t all_pages;
1141
1142         buf0 = buf;
1143
1144         if ((sc->sc_cbw->CBWCDB[1] & ~0x08) != 0) {
1145                 /* Mask away DBD */
1146                 currlun->sense_data = SS_INVALID_FIELD_IN_CDB;
1147                 return (1);
1148         }
1149         pc = sc->sc_cbw->CBWCDB[2] >> 6;
1150         page_code = sc->sc_cbw->CBWCDB[2] & 0x3f;
1151         if (pc == 3) {
1152                 currlun->sense_data = SS_SAVING_PARAMETERS_NOT_SUPPORTED;
1153                 return (1);
1154         }
1155         changeable_values = (pc == 1);
1156         all_pages = (page_code == 0x3f);
1157
1158         /*
1159          * Write the mode parameter header.  Fixed values are: default
1160          * medium type, no cache control (DPOFUA), and no block descriptors.
1161          * The only variable value is the WriteProtect bit.  We will fill in
1162          * the mode data length later.
1163          */
1164         memset(buf, 0, 8);
1165         if (mscmnd == SC_MODE_SENSE_6) {
1166                 buf[2] = (currlun->read_only ? 0x80 : 0x00);
1167                 /* WP, DPOFUA */
1168                 buf += 4;
1169                 limit = 255;
1170         } else {
1171                 /* SC_MODE_SENSE_10 */
1172                 buf[3] = (currlun->read_only ? 0x80 : 0x00);
1173                 /* WP, DPOFUA */
1174                 buf += 8;
1175                 limit = 65535;
1176                 /* Should really be mod_data.buflen */
1177         }
1178
1179         /* No block descriptors */
1180
1181         /*
1182          * The mode pages, in numerical order.
1183          */
1184         if ((page_code == 0x08) || all_pages) {
1185                 buf[0] = 0x08;
1186                 /* Page code */
1187                 buf[1] = 10;
1188                 /* Page length */
1189                 memset(buf + 2, 0, 10);
1190                 /* None of the fields are changeable */
1191
1192                 if (!changeable_values) {
1193                         buf[2] = 0x04;
1194                         /* Write cache enable, */
1195                         /* Read cache not disabled */
1196                         /* No cache retention priorities */
1197                         put_be16(&buf[4], 0xffff);
1198                         /* Don 't disable prefetch */
1199                         /* Minimum prefetch = 0 */
1200                         put_be16(&buf[8], 0xffff);
1201                         /* Maximum prefetch */
1202                         put_be16(&buf[10], 0xffff);
1203                         /* Maximum prefetch ceiling */
1204                 }
1205                 buf += 12;
1206         }
1207         /*
1208          * Check that a valid page was requested and the mode data length
1209          * isn't too long.
1210          */
1211         len = buf - buf0;
1212         if (len > limit) {
1213                 currlun->sense_data = SS_INVALID_FIELD_IN_CDB;
1214                 return (1);
1215         }
1216         /* Store the mode data length */
1217         if (mscmnd == SC_MODE_SENSE_6)
1218                 buf0[0] = len - 1;
1219         else
1220                 put_be16(buf0, len - 2);
1221
1222 #if (USTORAGE_QDATA_MAX < 24)
1223 #error "(USTORAGE_QDATA_MAX < 24)"
1224 #endif
1225         return (ustorage_fs_min_len(sc, len, -1U));
1226 }
1227
1228 /*------------------------------------------------------------------------*
1229  *      ustorage_fs_start_stop
1230  *
1231  * Returns:
1232  *    0: Success
1233  * Else: Failure
1234  *------------------------------------------------------------------------*/
1235 static uint8_t
1236 ustorage_fs_start_stop(struct ustorage_fs_softc *sc)
1237 {
1238         struct ustorage_fs_lun *currlun = sc->sc_transfer.currlun;
1239         uint8_t loej;
1240         uint8_t start;
1241         uint8_t immed;
1242
1243         if (!currlun->removable) {
1244                 currlun->sense_data = SS_INVALID_COMMAND;
1245                 return (1);
1246         }
1247         immed = sc->sc_cbw->CBWCDB[1] & 0x01;
1248         loej = sc->sc_cbw->CBWCDB[4] & 0x02;
1249         start = sc->sc_cbw->CBWCDB[4] & 0x01;
1250
1251         if (immed || loej || start) {
1252                 /* compile fix */
1253         }
1254         return (0);
1255 }
1256
1257 /*------------------------------------------------------------------------*
1258  *      ustorage_fs_prevent_allow
1259  *
1260  * Returns:
1261  *    0: Success
1262  * Else: Failure
1263  *------------------------------------------------------------------------*/
1264 static uint8_t
1265 ustorage_fs_prevent_allow(struct ustorage_fs_softc *sc)
1266 {
1267         struct ustorage_fs_lun *currlun = sc->sc_transfer.currlun;
1268         uint8_t prevent;
1269
1270         if (!currlun->removable) {
1271                 currlun->sense_data = SS_INVALID_COMMAND;
1272                 return (1);
1273         }
1274         prevent = sc->sc_cbw->CBWCDB[4] & 0x01;
1275         if ((sc->sc_cbw->CBWCDB[4] & ~0x01) != 0) {
1276                 /* Mask away Prevent */
1277                 currlun->sense_data = SS_INVALID_FIELD_IN_CDB;
1278                 return (1);
1279         }
1280         if (currlun->prevent_medium_removal && !prevent) {
1281                 //fsync_sub(currlun);
1282         }
1283         currlun->prevent_medium_removal = prevent;
1284         return (0);
1285 }
1286
1287 /*------------------------------------------------------------------------*
1288  *      ustorage_fs_read_format_capacities
1289  *
1290  * Returns:
1291  *    0: Success
1292  * Else: Failure
1293  *------------------------------------------------------------------------*/
1294 static uint8_t
1295 ustorage_fs_read_format_capacities(struct ustorage_fs_softc *sc)
1296 {
1297         uint8_t *buf = sc->sc_transfer.data_ptr;
1298         struct ustorage_fs_lun *currlun = sc->sc_transfer.currlun;
1299
1300         buf[0] = buf[1] = buf[2] = 0;
1301         buf[3] = 8;
1302         /* Only the Current / Maximum Capacity Descriptor */
1303         buf += 4;
1304
1305         /* Number of blocks */
1306         put_be32(&buf[0], currlun->num_sectors);
1307         /* Block length */
1308         put_be32(&buf[4], 512);
1309         /* Current capacity */
1310         buf[4] = 0x02;
1311
1312 #if (USTORAGE_QDATA_MAX < 12)
1313 #error "(USTORAGE_QDATA_MAX < 12)"
1314 #endif
1315         return (ustorage_fs_min_len(sc, 12, -1U));
1316 }
1317
1318 /*------------------------------------------------------------------------*
1319  *      ustorage_fs_mode_select
1320  *
1321  * Return values:
1322  *    0: Success
1323  * Else: Failure
1324  *------------------------------------------------------------------------*/
1325 static uint8_t
1326 ustorage_fs_mode_select(struct ustorage_fs_softc *sc)
1327 {
1328         struct ustorage_fs_lun *currlun = sc->sc_transfer.currlun;
1329
1330         /* We don't support MODE SELECT */
1331         currlun->sense_data = SS_INVALID_COMMAND;
1332         return (1);
1333 }
1334
1335 /*------------------------------------------------------------------------*
1336  *      ustorage_fs_synchronize_cache
1337  *
1338  * Return values:
1339  *    0: Success
1340  * Else: Failure
1341  *------------------------------------------------------------------------*/
1342 static uint8_t
1343 ustorage_fs_synchronize_cache(struct ustorage_fs_softc *sc)
1344 {
1345 #if 0
1346         struct ustorage_fs_lun *currlun = sc->sc_transfer.currlun;
1347         uint8_t rc;
1348
1349         /*
1350          * We ignore the requested LBA and write out all dirty data buffers.
1351          */
1352         rc = 0;
1353         if (rc) {
1354                 currlun->sense_data = SS_WRITE_ERROR;
1355         }
1356 #endif
1357         return (0);
1358 }
1359
1360 /*------------------------------------------------------------------------*
1361  *      ustorage_fs_read - read data from disk
1362  *
1363  * Return values:
1364  *    0: Success
1365  * Else: Failure
1366  *------------------------------------------------------------------------*/
1367 static uint8_t
1368 ustorage_fs_read(struct ustorage_fs_softc *sc)
1369 {
1370         struct ustorage_fs_lun *currlun = sc->sc_transfer.currlun;
1371         uint64_t file_offset;
1372         uint32_t lba;
1373         uint32_t len;
1374
1375         /*
1376          * Get the starting Logical Block Address and check that it's not
1377          * too big
1378          */
1379         if (sc->sc_cbw->CBWCDB[0] == SC_READ_6) {
1380                 lba = (((uint32_t)sc->sc_cbw->CBWCDB[1]) << 16) |
1381                     get_be16(&sc->sc_cbw->CBWCDB[2]);
1382         } else {
1383                 lba = get_be32(&sc->sc_cbw->CBWCDB[2]);
1384
1385                 /*
1386                  * We allow DPO (Disable Page Out = don't save data in the
1387                  * cache) and FUA (Force Unit Access = don't read from the
1388                  * cache), but we don't implement them.
1389                  */
1390                 if ((sc->sc_cbw->CBWCDB[1] & ~0x18) != 0) {
1391                         currlun->sense_data = SS_INVALID_FIELD_IN_CDB;
1392                         return (1);
1393                 }
1394         }
1395         len = sc->sc_transfer.data_rem >> 9;
1396         len += lba;
1397
1398         if ((len < lba) ||
1399             (len > currlun->num_sectors) ||
1400             (lba >= currlun->num_sectors)) {
1401                 currlun->sense_data = SS_LOGICAL_BLOCK_ADDRESS_OUT_OF_RANGE;
1402                 return (1);
1403         }
1404         file_offset = lba;
1405         file_offset <<= 9;
1406
1407         sc->sc_transfer.data_ptr = currlun->memory_image + file_offset;
1408
1409         return (0);
1410 }
1411
1412 /*------------------------------------------------------------------------*
1413  *      ustorage_fs_write - write data to disk
1414  *
1415  * Return values:
1416  *    0: Success
1417  * Else: Failure
1418  *------------------------------------------------------------------------*/
1419 static uint8_t
1420 ustorage_fs_write(struct ustorage_fs_softc *sc)
1421 {
1422         struct ustorage_fs_lun *currlun = sc->sc_transfer.currlun;
1423         uint64_t file_offset;
1424         uint32_t lba;
1425         uint32_t len;
1426
1427         if (currlun->read_only) {
1428                 currlun->sense_data = SS_WRITE_PROTECTED;
1429                 return (1);
1430         }
1431         /* XXX clear SYNC */
1432
1433         /*
1434          * Get the starting Logical Block Address and check that it's not
1435          * too big.
1436          */
1437         if (sc->sc_cbw->CBWCDB[0] == SC_WRITE_6)
1438                 lba = (((uint32_t)sc->sc_cbw->CBWCDB[1]) << 16) |
1439                     get_be16(&sc->sc_cbw->CBWCDB[2]);
1440         else {
1441                 lba = get_be32(&sc->sc_cbw->CBWCDB[2]);
1442
1443                 /*
1444                  * We allow DPO (Disable Page Out = don't save data in the
1445                  * cache) and FUA (Force Unit Access = write directly to the
1446                  * medium).  We don't implement DPO; we implement FUA by
1447                  * performing synchronous output.
1448                  */
1449                 if ((sc->sc_cbw->CBWCDB[1] & ~0x18) != 0) {
1450                         currlun->sense_data = SS_INVALID_FIELD_IN_CDB;
1451                         return (1);
1452                 }
1453                 if (sc->sc_cbw->CBWCDB[1] & 0x08) {
1454                         /* FUA */
1455                         /* XXX set SYNC flag here */
1456                 }
1457         }
1458
1459         len = sc->sc_transfer.data_rem >> 9;
1460         len += lba;
1461
1462         if ((len < lba) ||
1463             (len > currlun->num_sectors) ||
1464             (lba >= currlun->num_sectors)) {
1465                 currlun->sense_data = SS_LOGICAL_BLOCK_ADDRESS_OUT_OF_RANGE;
1466                 return (1);
1467         }
1468         file_offset = lba;
1469         file_offset <<= 9;
1470
1471         sc->sc_transfer.data_ptr = currlun->memory_image + file_offset;
1472
1473         return (0);
1474 }
1475
1476 /*------------------------------------------------------------------------*
1477  *      ustorage_fs_min_len
1478  *
1479  * Return values:
1480  *    0: Success
1481  * Else: Failure
1482  *------------------------------------------------------------------------*/
1483 static uint8_t
1484 ustorage_fs_min_len(struct ustorage_fs_softc *sc, uint32_t len, uint32_t mask)
1485 {
1486         if (len != sc->sc_transfer.data_rem) {
1487
1488                 if (sc->sc_transfer.cbw_dir == DIR_READ) {
1489                         /*
1490                          * there must be something wrong about this SCSI
1491                          * command
1492                          */
1493                         sc->sc_csw->bCSWStatus = CSWSTATUS_PHASE;
1494                         return (1);
1495                 }
1496                 /* compute the minimum length */
1497
1498                 if (sc->sc_transfer.data_rem > len) {
1499                         /* data ends prematurely */
1500                         sc->sc_transfer.data_rem = len;
1501                         sc->sc_transfer.data_short = 1;
1502                 }
1503                 /* check length alignment */
1504
1505                 if (sc->sc_transfer.data_rem & ~mask) {
1506                         /* data ends prematurely */
1507                         sc->sc_transfer.data_rem &= mask;
1508                         sc->sc_transfer.data_short = 1;
1509                 }
1510         }
1511         return (0);
1512 }
1513
1514 /*------------------------------------------------------------------------*
1515  *      ustorage_fs_check_cmd - check command routine
1516  *
1517  * Check whether the command is properly formed and whether its data
1518  * size and direction agree with the values we already have.
1519  *
1520  * Return values:
1521  *    0: Success
1522  * Else: Failure
1523  *------------------------------------------------------------------------*/
1524 static uint8_t
1525 ustorage_fs_check_cmd(struct ustorage_fs_softc *sc, uint8_t min_cmd_size,
1526     uint16_t mask, uint8_t needs_medium)
1527 {
1528         struct ustorage_fs_lun *currlun;
1529         uint8_t lun = (sc->sc_cbw->CBWCDB[1] >> 5);
1530         uint8_t i;
1531
1532         /* Verify the length of the command itself */
1533         if (min_cmd_size > sc->sc_transfer.cmd_len) {
1534                 DPRINTF("%u > %u\n",
1535                     min_cmd_size, sc->sc_transfer.cmd_len);
1536                 sc->sc_csw->bCSWStatus = CSWSTATUS_PHASE;
1537                 return (1);
1538         }
1539         /* Mask away the LUN */
1540         sc->sc_cbw->CBWCDB[1] &= 0x1f;
1541
1542         /* Check if LUN is correct */
1543         if (lun != sc->sc_transfer.lun) {
1544
1545         }
1546         /* Check the LUN */
1547         if (sc->sc_transfer.lun <= sc->sc_last_lun) {
1548                 sc->sc_transfer.currlun = currlun =
1549                     sc->sc_lun + sc->sc_transfer.lun;
1550                 if (sc->sc_cbw->CBWCDB[0] != SC_REQUEST_SENSE) {
1551                         currlun->sense_data = SS_NO_SENSE;
1552                         currlun->sense_data_info = 0;
1553                         currlun->info_valid = 0;
1554                 }
1555                 /*
1556                  * If a unit attention condition exists, only INQUIRY
1557                  * and REQUEST SENSE commands are allowed. Anything
1558                  * else must fail!
1559                  */
1560                 if ((currlun->unit_attention_data != SS_NO_SENSE) &&
1561                     (sc->sc_cbw->CBWCDB[0] != SC_INQUIRY) &&
1562                     (sc->sc_cbw->CBWCDB[0] != SC_REQUEST_SENSE)) {
1563                         currlun->sense_data = currlun->unit_attention_data;
1564                         currlun->unit_attention_data = SS_NO_SENSE;
1565                         return (1);
1566                 }
1567         } else {
1568                 sc->sc_transfer.currlun = currlun = NULL;
1569
1570                 /*
1571                  * INQUIRY and REQUEST SENSE commands are explicitly allowed
1572                  * to use unsupported LUNs; all others may not.
1573                  */
1574                 if ((sc->sc_cbw->CBWCDB[0] != SC_INQUIRY) &&
1575                     (sc->sc_cbw->CBWCDB[0] != SC_REQUEST_SENSE)) {
1576                         return (1);
1577                 }
1578         }
1579
1580         /*
1581          * Check that only command bytes listed in the mask are
1582          * non-zero.
1583          */
1584         for (i = 0; i != min_cmd_size; i++) {
1585                 if (sc->sc_cbw->CBWCDB[i] && !(mask & (1UL << i))) {
1586                         if (currlun) {
1587                                 currlun->sense_data = SS_INVALID_FIELD_IN_CDB;
1588                         }
1589                         return (1);
1590                 }
1591         }
1592
1593         /*
1594          * If the medium isn't mounted and the command needs to access
1595          * it, return an error.
1596          */
1597         if (currlun && (!currlun->memory_image) && needs_medium) {
1598                 currlun->sense_data = SS_MEDIUM_NOT_PRESENT;
1599                 return (1);
1600         }
1601         return (0);
1602 }
1603
1604 /*------------------------------------------------------------------------*
1605  *      ustorage_fs_do_cmd - do command
1606  *
1607  * Return values:
1608  *    0: Success
1609  * Else: Failure
1610  *------------------------------------------------------------------------*/
1611 static uint8_t
1612 ustorage_fs_do_cmd(struct ustorage_fs_softc *sc)
1613 {
1614         uint8_t error = 1;
1615         uint8_t i;
1616         uint32_t temp;
1617         const uint32_t mask9 = (0xFFFFFFFFUL >> 9) << 9;
1618
1619         /* set default data transfer pointer */
1620         sc->sc_transfer.data_ptr = sc->sc_qdata;
1621
1622         DPRINTF("cmd_data[0]=0x%02x, data_rem=0x%08x\n",
1623             sc->sc_cbw->CBWCDB[0], sc->sc_transfer.data_rem);
1624
1625         switch (sc->sc_cbw->CBWCDB[0]) {
1626         case SC_INQUIRY:
1627                 sc->sc_transfer.cmd_dir = DIR_WRITE;
1628                 error = ustorage_fs_min_len(sc, sc->sc_cbw->CBWCDB[4], -1U);
1629                 if (error) {
1630                         break;
1631                 }
1632                 error = ustorage_fs_check_cmd(sc, 6,
1633                     (1UL << 4) | 1, 0);
1634                 if (error) {
1635                         break;
1636                 }
1637                 error = ustorage_fs_inquiry(sc);
1638
1639                 break;
1640
1641         case SC_MODE_SELECT_6:
1642                 sc->sc_transfer.cmd_dir = DIR_READ;
1643                 error = ustorage_fs_min_len(sc, sc->sc_cbw->CBWCDB[4], -1U);
1644                 if (error) {
1645                         break;
1646                 }
1647                 error = ustorage_fs_check_cmd(sc, 6,
1648                     (1UL << 1) | (1UL << 4) | 1, 0);
1649                 if (error) {
1650                         break;
1651                 }
1652                 error = ustorage_fs_mode_select(sc);
1653
1654                 break;
1655
1656         case SC_MODE_SELECT_10:
1657                 sc->sc_transfer.cmd_dir = DIR_READ;
1658                 error = ustorage_fs_min_len(sc,
1659                     get_be16(&sc->sc_cbw->CBWCDB[7]), -1U);
1660                 if (error) {
1661                         break;
1662                 }
1663                 error = ustorage_fs_check_cmd(sc, 10,
1664                     (1UL << 1) | (3UL << 7) | 1, 0);
1665                 if (error) {
1666                         break;
1667                 }
1668                 error = ustorage_fs_mode_select(sc);
1669
1670                 break;
1671
1672         case SC_MODE_SENSE_6:
1673                 sc->sc_transfer.cmd_dir = DIR_WRITE;
1674                 error = ustorage_fs_min_len(sc, sc->sc_cbw->CBWCDB[4], -1U);
1675                 if (error) {
1676                         break;
1677                 }
1678                 error = ustorage_fs_check_cmd(sc, 6,
1679                     (1UL << 1) | (1UL << 2) | (1UL << 4) | 1, 0);
1680                 if (error) {
1681                         break;
1682                 }
1683                 error = ustorage_fs_mode_sense(sc);
1684
1685                 break;
1686
1687         case SC_MODE_SENSE_10:
1688                 sc->sc_transfer.cmd_dir = DIR_WRITE;
1689                 error = ustorage_fs_min_len(sc,
1690                     get_be16(&sc->sc_cbw->CBWCDB[7]), -1U);
1691                 if (error) {
1692                         break;
1693                 }
1694                 error = ustorage_fs_check_cmd(sc, 10,
1695                     (1UL << 1) | (1UL << 2) | (3UL << 7) | 1, 0);
1696                 if (error) {
1697                         break;
1698                 }
1699                 error = ustorage_fs_mode_sense(sc);
1700
1701                 break;
1702
1703         case SC_PREVENT_ALLOW_MEDIUM_REMOVAL:
1704                 error = ustorage_fs_min_len(sc, 0, -1U);
1705                 if (error) {
1706                         break;
1707                 }
1708                 error = ustorage_fs_check_cmd(sc, 6,
1709                     (1UL << 4) | 1, 0);
1710                 if (error) {
1711                         break;
1712                 }
1713                 error = ustorage_fs_prevent_allow(sc);
1714
1715                 break;
1716
1717         case SC_READ_6:
1718                 i = sc->sc_cbw->CBWCDB[4];
1719                 sc->sc_transfer.cmd_dir = DIR_WRITE;
1720                 temp = ((i == 0) ? 256UL : i);
1721                 error = ustorage_fs_min_len(sc, temp << 9, mask9);
1722                 if (error) {
1723                         break;
1724                 }
1725                 error = ustorage_fs_check_cmd(sc, 6,
1726                     (7UL << 1) | (1UL << 4) | 1, 1);
1727                 if (error) {
1728                         break;
1729                 }
1730                 error = ustorage_fs_read(sc);
1731
1732                 break;
1733
1734         case SC_READ_10:
1735                 sc->sc_transfer.cmd_dir = DIR_WRITE;
1736                 temp = get_be16(&sc->sc_cbw->CBWCDB[7]);
1737                 error = ustorage_fs_min_len(sc, temp << 9, mask9);
1738                 if (error) {
1739                         break;
1740                 }
1741                 error = ustorage_fs_check_cmd(sc, 10,
1742                     (1UL << 1) | (0xfUL << 2) | (3UL << 7) | 1, 1);
1743                 if (error) {
1744                         break;
1745                 }
1746                 error = ustorage_fs_read(sc);
1747
1748                 break;
1749
1750         case SC_READ_12:
1751                 sc->sc_transfer.cmd_dir = DIR_WRITE;
1752                 temp = get_be32(&sc->sc_cbw->CBWCDB[6]);
1753                 if (temp >= (1UL << (32 - 9))) {
1754                         /* numerical overflow */
1755                         sc->sc_csw->bCSWStatus = CSWSTATUS_FAILED;
1756                         error = 1;
1757                         break;
1758                 }
1759                 error = ustorage_fs_min_len(sc, temp << 9, mask9);
1760                 if (error) {
1761                         break;
1762                 }
1763                 error = ustorage_fs_check_cmd(sc, 12,
1764                     (1UL << 1) | (0xfUL << 2) | (0xfUL << 6) | 1, 1);
1765                 if (error) {
1766                         break;
1767                 }
1768                 error = ustorage_fs_read(sc);
1769
1770                 break;
1771
1772         case SC_READ_CAPACITY:
1773                 sc->sc_transfer.cmd_dir = DIR_WRITE;
1774                 error = ustorage_fs_check_cmd(sc, 10,
1775                     (0xfUL << 2) | (1UL << 8) | 1, 1);
1776                 if (error) {
1777                         break;
1778                 }
1779                 error = ustorage_fs_read_capacity(sc);
1780
1781                 break;
1782
1783         case SC_READ_FORMAT_CAPACITIES:
1784                 sc->sc_transfer.cmd_dir = DIR_WRITE;
1785                 error = ustorage_fs_min_len(sc,
1786                     get_be16(&sc->sc_cbw->CBWCDB[7]), -1U);
1787                 if (error) {
1788                         break;
1789                 }
1790                 error = ustorage_fs_check_cmd(sc, 10,
1791                     (3UL << 7) | 1, 1);
1792                 if (error) {
1793                         break;
1794                 }
1795                 error = ustorage_fs_read_format_capacities(sc);
1796
1797                 break;
1798
1799         case SC_REQUEST_SENSE:
1800                 sc->sc_transfer.cmd_dir = DIR_WRITE;
1801                 error = ustorage_fs_min_len(sc, sc->sc_cbw->CBWCDB[4], -1U);
1802                 if (error) {
1803                         break;
1804                 }
1805                 error = ustorage_fs_check_cmd(sc, 6,
1806                     (1UL << 4) | 1, 0);
1807                 if (error) {
1808                         break;
1809                 }
1810                 error = ustorage_fs_request_sense(sc);
1811
1812                 break;
1813
1814         case SC_START_STOP_UNIT:
1815                 error = ustorage_fs_min_len(sc, 0, -1U);
1816                 if (error) {
1817                         break;
1818                 }
1819                 error = ustorage_fs_check_cmd(sc, 6,
1820                     (1UL << 1) | (1UL << 4) | 1, 0);
1821                 if (error) {
1822                         break;
1823                 }
1824                 error = ustorage_fs_start_stop(sc);
1825
1826                 break;
1827
1828         case SC_SYNCHRONIZE_CACHE:
1829                 error = ustorage_fs_min_len(sc, 0, -1U);
1830                 if (error) {
1831                         break;
1832                 }
1833                 error = ustorage_fs_check_cmd(sc, 10,
1834                     (0xfUL << 2) | (3UL << 7) | 1, 1);
1835                 if (error) {
1836                         break;
1837                 }
1838                 error = ustorage_fs_synchronize_cache(sc);
1839
1840                 break;
1841
1842         case SC_TEST_UNIT_READY:
1843                 error = ustorage_fs_min_len(sc, 0, -1U);
1844                 if (error) {
1845                         break;
1846                 }
1847                 error = ustorage_fs_check_cmd(sc, 6,
1848                     0 | 1, 1);
1849                 break;
1850
1851                 /*
1852                  * Although optional, this command is used by MS-Windows.
1853                  * We support a minimal version: BytChk must be 0.
1854                  */
1855         case SC_VERIFY:
1856                 error = ustorage_fs_min_len(sc, 0, -1U);
1857                 if (error) {
1858                         break;
1859                 }
1860                 error = ustorage_fs_check_cmd(sc, 10,
1861                     (1UL << 1) | (0xfUL << 2) | (3UL << 7) | 1, 1);
1862                 if (error) {
1863                         break;
1864                 }
1865                 error = ustorage_fs_verify(sc);
1866
1867                 break;
1868
1869         case SC_WRITE_6:
1870                 i = sc->sc_cbw->CBWCDB[4];
1871                 sc->sc_transfer.cmd_dir = DIR_READ;
1872                 temp = ((i == 0) ? 256UL : i);
1873                 error = ustorage_fs_min_len(sc, temp << 9, mask9);
1874                 if (error) {
1875                         break;
1876                 }
1877                 error = ustorage_fs_check_cmd(sc, 6,
1878                     (7UL << 1) | (1UL << 4) | 1, 1);
1879                 if (error) {
1880                         break;
1881                 }
1882                 error = ustorage_fs_write(sc);
1883
1884                 break;
1885
1886         case SC_WRITE_10:
1887                 sc->sc_transfer.cmd_dir = DIR_READ;
1888                 temp = get_be16(&sc->sc_cbw->CBWCDB[7]);
1889                 error = ustorage_fs_min_len(sc, temp << 9, mask9);
1890                 if (error) {
1891                         break;
1892                 }
1893                 error = ustorage_fs_check_cmd(sc, 10,
1894                     (1UL << 1) | (0xfUL << 2) | (3UL << 7) | 1, 1);
1895                 if (error) {
1896                         break;
1897                 }
1898                 error = ustorage_fs_write(sc);
1899
1900                 break;
1901
1902         case SC_WRITE_12:
1903                 sc->sc_transfer.cmd_dir = DIR_READ;
1904                 temp = get_be32(&sc->sc_cbw->CBWCDB[6]);
1905                 if (temp > (mask9 >> 9)) {
1906                         /* numerical overflow */
1907                         sc->sc_csw->bCSWStatus = CSWSTATUS_FAILED;
1908                         error = 1;
1909                         break;
1910                 }
1911                 error = ustorage_fs_min_len(sc, temp << 9, mask9);
1912                 if (error) {
1913                         break;
1914                 }
1915                 error = ustorage_fs_check_cmd(sc, 12,
1916                     (1UL << 1) | (0xfUL << 2) | (0xfUL << 6) | 1, 1);
1917                 if (error) {
1918                         break;
1919                 }
1920                 error = ustorage_fs_write(sc);
1921
1922                 break;
1923
1924                 /*
1925                  * Some mandatory commands that we recognize but don't
1926                  * implement.  They don't mean much in this setting.
1927                  * It's left as an exercise for anyone interested to
1928                  * implement RESERVE and RELEASE in terms of Posix
1929                  * locks.
1930                  */
1931         case SC_FORMAT_UNIT:
1932         case SC_RELEASE:
1933         case SC_RESERVE:
1934         case SC_SEND_DIAGNOSTIC:
1935                 /* Fallthrough */
1936
1937         default:
1938                 error = ustorage_fs_min_len(sc, 0, -1U);
1939                 if (error) {
1940                         break;
1941                 }
1942                 error = ustorage_fs_check_cmd(sc, sc->sc_transfer.cmd_len,
1943                     0xff, 0);
1944                 if (error) {
1945                         break;
1946                 }
1947                 sc->sc_transfer.currlun->sense_data =
1948                     SS_INVALID_COMMAND;
1949                 error = 1;
1950
1951                 break;
1952         }
1953         return (error);
1954 }