sys/dev/usb/storage/cfumass.c

   1 /*-
   2  * Copyright (c) 2016 The FreeBSD Foundation
   3  * All rights reserved.
   4  *
   5  * This software was developed by Edward Tomasz Napierala under sponsorship
   6  * from the FreeBSD Foundation.
   7  *
   8  * Redistribution and use in source and binary forms, with or without
   9  * modification, are permitted provided that the following conditions
  10  * are met:
  11  * 1. Redistributions of source code must retain the above copyright
  12  *    notice, this list of conditions and the following disclaimer.
  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  *
  17  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  18  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  19  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  20  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  21  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  22  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  23  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  24  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  25  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  26  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  27  * SUCH DAMAGE.
  28  *
  29  */
  30 /*
  31  * USB Mass Storage Class Bulk-Only (BBB) Transport target.
  32  *
  33  * http://www.usb.org/developers/docs/devclass_docs/usbmassbulk_10.pdf
  34  *
  35  * This code implements the USB Mass Storage frontend driver for the CAM
  36  * Target Layer (ctl(4)) subsystem.
  37  */
  38
  39 #include <sys/cdefs.h>
  40 __FBSDID("$FreeBSD$");
  41
  42 #include <sys/param.h>
  43 #include <sys/bus.h>
  44 #include <sys/kernel.h>
  45 #include <sys/lock.h>
  46 #include <sys/module.h>
  47 #include <sys/mutex.h>
  48 #include <sys/refcount.h>
  49 #include <sys/stdint.h>
  50 #include <sys/sysctl.h>
  51 #include <sys/systm.h>
  52
  53 #include <dev/usb/usb.h>
  54 #include <dev/usb/usbdi.h>
  55 #include "usbdevs.h"
  56 #include "usb_if.h"
  57
  58 #include <cam/scsi/scsi_all.h>
  59 #include <cam/scsi/scsi_da.h>
  60 #include <cam/ctl/ctl_io.h>
  61 #include <cam/ctl/ctl.h>
  62 #include <cam/ctl/ctl_backend.h>
  63 #include <cam/ctl/ctl_error.h>
  64 #include <cam/ctl/ctl_frontend.h>
  65 #include <cam/ctl/ctl_debug.h>
  66 #include <cam/ctl/ctl_ha.h>
  67 #include <cam/ctl/ctl_ioctl.h>
  68 #include <cam/ctl/ctl_private.h>
  69
  70 SYSCTL_NODE(_hw_usb, OID_AUTO, cfumass, CTLFLAG_RW, 0,
  71     "CAM Target Layer USB Mass Storage Frontend");
  72 static int debug = 1;
  73 SYSCTL_INT(_hw_usb_cfumass, OID_AUTO, debug, CTLFLAG_RWTUN,
  74     &debug, 1, "Enable debug messages");
  75 static int max_lun = 0;
  76 SYSCTL_INT(_hw_usb_cfumass, OID_AUTO, max_lun, CTLFLAG_RWTUN,
  77     &max_lun, 1, "Maximum advertised LUN number");
  78 static int ignore_stop = 1;
  79 SYSCTL_INT(_hw_usb_cfumass, OID_AUTO, ignore_stop, CTLFLAG_RWTUN,
  80     &ignore_stop, 1, "Ignore START STOP UNIT with START and LOEJ bits cleared");
  81
  82 /*
  83  * The driver uses a single, global CTL port.  It could create its ports
  84  * in cfumass_attach() instead, but that would make it impossible to specify
  85  * "port cfumass0" in ctl.conf(5), as the port generally wouldn't exist
  86  * at the time ctld(8) gets run.
  87  */
  88 struct ctl_port cfumass_port;
  89 bool            cfumass_port_online;
  90 volatile u_int  cfumass_refcount;
  91
  92 #ifndef CFUMASS_BULK_SIZE
  93 #define CFUMASS_BULK_SIZE       (1U << 17)      /* bytes */
  94 #endif
  95
  96 /*
  97  * USB transfer definitions.
  98  */
  99 #define CFUMASS_T_COMMAND       0
 100 #define CFUMASS_T_DATA_OUT      1
 101 #define CFUMASS_T_DATA_IN       2
 102 #define CFUMASS_T_STATUS        3
 103 #define CFUMASS_T_MAX           4
 104
 105 /*
 106  * USB interface specific control requests.
 107  */
 108 #define UR_RESET        0xff    /* Bulk-Only Mass Storage Reset */
 109 #define UR_GET_MAX_LUN  0xfe    /* Get Max LUN */
 110
 111 /*
 112  * Command Block Wrapper.
 113  */
 114 struct cfumass_cbw_t {
 115         uDWord  dCBWSignature;
 116 #define CBWSIGNATURE            0x43425355 /* "USBC" */
 117         uDWord  dCBWTag;
 118         uDWord  dCBWDataTransferLength;
 119         uByte   bCBWFlags;
 120 #define CBWFLAGS_OUT            0x00
 121 #define CBWFLAGS_IN             0x80
 122         uByte   bCBWLUN;
 123         uByte   bCDBLength;
 124 #define CBWCBLENGTH             16
 125         uByte   CBWCB[CBWCBLENGTH];
 126 } __packed;
 127
 128 #define CFUMASS_CBW_SIZE        31
 129 CTASSERT(sizeof(struct cfumass_cbw_t) == CFUMASS_CBW_SIZE);
 130
 131 /*
 132  * Command Status Wrapper.
 133  */
 134 struct cfumass_csw_t {
 135         uDWord  dCSWSignature;
 136 #define CSWSIGNATURE            0x53425355 /* "USBS" */
 137         uDWord  dCSWTag;
 138         uDWord  dCSWDataResidue;
 139         uByte   bCSWStatus;
 140 #define CSWSTATUS_GOOD          0x0
 141 #define CSWSTATUS_FAILED        0x1
 142 #define CSWSTATUS_PHASE         0x2
 143 } __packed;
 144
 145 #define CFUMASS_CSW_SIZE        13
 146 CTASSERT(sizeof(struct cfumass_csw_t) == CFUMASS_CSW_SIZE);
 147
 148 struct cfumass_softc {
 149         device_t                sc_dev;
 150         struct usb_device       *sc_udev;
 151         struct usb_xfer         *sc_xfer[CFUMASS_T_MAX];
 152
 153         struct cfumass_cbw_t *sc_cbw;
 154         struct cfumass_csw_t *sc_csw;
 155
 156         struct mtx      sc_mtx;
 157         int             sc_online;
 158         int             sc_ctl_initid;
 159
 160         /*
 161          * This is used to communicate between CTL callbacks
 162          * and USB callbacks; basically, it holds the state
 163          * for the current command ("the" command, since there
 164          * is no queueing in USB Mass Storage).
 165          */
 166         bool            sc_current_stalled;
 167
 168         /*
 169          * The following are set upon receiving a SCSI command.
 170          */
 171         int             sc_current_tag;
 172         int             sc_current_transfer_length;
 173         int             sc_current_flags;
 174
 175         /*
 176          * The following are set in ctl_datamove().
 177          */
 178         int             sc_current_residue;
 179         union ctl_io    *sc_ctl_io;
 180
 181         /*
 182          * The following is set in cfumass_done().
 183          */
 184         int             sc_current_status;
 185
 186         /*
 187          * Number of requests queued to CTL.
 188          */
 189         volatile u_int  sc_queued;
 190 };
 191
 192 /*
 193  * USB interface.
 194  */
 195 static device_probe_t           cfumass_probe;
 196 static device_attach_t          cfumass_attach;
 197 static device_detach_t          cfumass_detach;
 198 static device_suspend_t         cfumass_suspend;
 199 static device_resume_t          cfumass_resume;
 200 static usb_handle_request_t     cfumass_handle_request;
 201
 202 static usb_callback_t           cfumass_t_command_callback;
 203 static usb_callback_t           cfumass_t_data_callback;
 204 static usb_callback_t           cfumass_t_status_callback;
 205
 206 static device_method_t cfumass_methods[] = {
 207
 208         /* USB interface. */
 209         DEVMETHOD(usb_handle_request, cfumass_handle_request),
 210
 211         /* Device interface. */
 212         DEVMETHOD(device_probe, cfumass_probe),
 213         DEVMETHOD(device_attach, cfumass_attach),
 214         DEVMETHOD(device_detach, cfumass_detach),
 215         DEVMETHOD(device_suspend, cfumass_suspend),
 216         DEVMETHOD(device_resume, cfumass_resume),
 217
 218         DEVMETHOD_END
 219 };
 220
 221 static driver_t cfumass_driver = {
 222         .name = "cfumass",
 223         .methods = cfumass_methods,
 224         .size = sizeof(struct cfumass_softc),
 225 };
 226
 227 static devclass_t cfumass_devclass;
 228
 229 DRIVER_MODULE(cfumass, uhub, cfumass_driver, cfumass_devclass, NULL, 0);
 230 MODULE_VERSION(cfumass, 0);
 231 MODULE_DEPEND(cfumass, usb, 1, 1, 1);
 232 MODULE_DEPEND(cfumass, usb_template, 1, 1, 1);
 233
 234 static struct usb_config cfumass_config[CFUMASS_T_MAX] = {
 235
 236         [CFUMASS_T_COMMAND] = {
 237                 .type = UE_BULK,
 238                 .endpoint = UE_ADDR_ANY,
 239                 .direction = UE_DIR_OUT,
 240                 .bufsize = sizeof(struct cfumass_cbw_t),
 241                 .callback = &cfumass_t_command_callback,
 242                 .usb_mode = USB_MODE_DEVICE,
 243         },
 244
 245         [CFUMASS_T_DATA_OUT] = {
 246                 .type = UE_BULK,
 247                 .endpoint = UE_ADDR_ANY,
 248                 .direction = UE_DIR_OUT,
 249                 .bufsize = CFUMASS_BULK_SIZE,
 250                 .flags = {.proxy_buffer = 1, .short_xfer_ok = 1,
 251                     .ext_buffer = 1},
 252                 .callback = &cfumass_t_data_callback,
 253                 .usb_mode = USB_MODE_DEVICE,
 254         },
 255
 256         [CFUMASS_T_DATA_IN] = {
 257                 .type = UE_BULK,
 258                 .endpoint = UE_ADDR_ANY,
 259                 .direction = UE_DIR_IN,
 260                 .bufsize = CFUMASS_BULK_SIZE,
 261                 .flags = {.proxy_buffer = 1, .short_xfer_ok = 1,
 262                     .ext_buffer = 1},
 263                 .callback = &cfumass_t_data_callback,
 264                 .usb_mode = USB_MODE_DEVICE,
 265         },
 266
 267         [CFUMASS_T_STATUS] = {
 268                 .type = UE_BULK,
 269                 .endpoint = UE_ADDR_ANY,
 270                 .direction = UE_DIR_IN,
 271                 .bufsize = sizeof(struct cfumass_csw_t),
 272                 .flags = {.short_xfer_ok = 1},
 273                 .callback = &cfumass_t_status_callback,
 274                 .usb_mode = USB_MODE_DEVICE,
 275         },
 276 };
 277
 278 /*
 279  * CTL frontend interface.
 280  */
 281 static int      cfumass_init(void);
 282 static int      cfumass_shutdown(void);
 283 static void     cfumass_online(void *arg);
 284 static void     cfumass_offline(void *arg);
 285 static void     cfumass_datamove(union ctl_io *io);
 286 static void     cfumass_done(union ctl_io *io);
 287
 288 static struct ctl_frontend cfumass_frontend = {
 289         .name = "umass",
 290         .init = cfumass_init,
 291         .shutdown = cfumass_shutdown,
 292 };
 293 CTL_FRONTEND_DECLARE(ctlcfumass, cfumass_frontend);
 294
 295 #define CFUMASS_DEBUG(S, X, ...)                                        \
 296         do {                                                            \
 297                 if (debug > 1) {                                        \
 298                         device_printf(S->sc_dev, "%s: " X "\n",         \
 299                             __func__, ## __VA_ARGS__);                  \
 300                 }                                                       \
 301         } while (0)
 302
 303 #define CFUMASS_WARN(S, X, ...)                                         \
 304         do {                                                            \
 305                 if (debug > 0) {                                        \
 306                         device_printf(S->sc_dev, "WARNING: %s: " X "\n",\
 307                             __func__, ## __VA_ARGS__);                  \
 308                 }                                                       \
 309         } while (0)
 310
 311 #define CFUMASS_LOCK(X)         mtx_lock(&X->sc_mtx)
 312 #define CFUMASS_UNLOCK(X)       mtx_unlock(&X->sc_mtx)
 313
 314 static void     cfumass_transfer_start(struct cfumass_softc *sc,
 315                     uint8_t xfer_index);
 316 static void     cfumass_terminate(struct cfumass_softc *sc);
 317
 318 static int
 319 cfumass_probe(device_t dev)
 320 {
 321         struct usb_attach_arg *uaa;
 322         struct usb_interface_descriptor *id;
 323
 324         uaa = device_get_ivars(dev);
 325
 326         if (uaa->usb_mode != USB_MODE_DEVICE)
 327                 return (ENXIO);
 328
 329         /*
 330          * Check for a compliant device.
 331          */
 332         id = usbd_get_interface_descriptor(uaa->iface);
 333         if ((id == NULL) ||
 334             (id->bInterfaceClass != UICLASS_MASS) ||
 335             (id->bInterfaceSubClass != UISUBCLASS_SCSI) ||
 336             (id->bInterfaceProtocol != UIPROTO_MASS_BBB)) {
 337                 return (ENXIO);
 338         }
 339
 340         return (BUS_PROBE_GENERIC);
 341 }
 342
 343 static int
 344 cfumass_attach(device_t dev)
 345 {
 346         struct cfumass_softc *sc;
 347         struct usb_attach_arg *uaa;
 348         int error;
 349
 350         sc = device_get_softc(dev);
 351         uaa = device_get_ivars(dev);
 352
 353         sc->sc_dev = dev;
 354         sc->sc_udev = uaa->device;
 355
 356         CFUMASS_DEBUG(sc, "go");
 357
 358         usbd_set_power_mode(uaa->device, USB_POWER_MODE_SAVE);
 359         device_set_usb_desc(dev);
 360
 361         mtx_init(&sc->sc_mtx, "cfumass", NULL, MTX_DEF);
 362         refcount_acquire(&cfumass_refcount);
 363
 364         error = usbd_transfer_setup(uaa->device,
 365             &uaa->info.bIfaceIndex, sc->sc_xfer, cfumass_config,
 366             CFUMASS_T_MAX, sc, &sc->sc_mtx);
 367         if (error != 0) {
 368                 CFUMASS_WARN(sc, "usbd_transfer_setup() failed: %s",
 369                     usbd_errstr(error));
 370                 refcount_release(&cfumass_refcount);
 371                 return (ENXIO);
 372         }
 373
 374         sc->sc_cbw =
 375             usbd_xfer_get_frame_buffer(sc->sc_xfer[CFUMASS_T_COMMAND], 0);
 376         sc->sc_csw =
 377             usbd_xfer_get_frame_buffer(sc->sc_xfer[CFUMASS_T_STATUS], 0);
 378
 379         sc->sc_ctl_initid = ctl_add_initiator(&cfumass_port, -1, 0, NULL);
 380         if (sc->sc_ctl_initid < 0) {
 381                 CFUMASS_WARN(sc, "ctl_add_initiator() failed with error %d",
 382                     sc->sc_ctl_initid);
 383                 usbd_transfer_unsetup(sc->sc_xfer, CFUMASS_T_MAX);
 384                 refcount_release(&cfumass_refcount);
 385                 return (ENXIO);
 386         }
 387
 388         refcount_init(&sc->sc_queued, 0);
 389
 390         CFUMASS_LOCK(sc);
 391         cfumass_transfer_start(sc, CFUMASS_T_COMMAND);
 392         CFUMASS_UNLOCK(sc);
 393
 394         return (0);
 395 }
 396
 397 static int
 398 cfumass_detach(device_t dev)
 399 {
 400         struct cfumass_softc *sc;
 401         int error;
 402
 403         sc = device_get_softc(dev);
 404
 405         CFUMASS_DEBUG(sc, "go");
 406
 407         CFUMASS_LOCK(sc);
 408         cfumass_terminate(sc);
 409         CFUMASS_UNLOCK(sc);
 410         usbd_transfer_unsetup(sc->sc_xfer, CFUMASS_T_MAX);
 411
 412         if (sc->sc_ctl_initid != -1) {
 413                 error = ctl_remove_initiator(&cfumass_port, sc->sc_ctl_initid);
 414                 if (error != 0) {
 415                         CFUMASS_WARN(sc, "ctl_remove_initiator() failed "
 416                             "with error %d", error);
 417                 }
 418                 sc->sc_ctl_initid = -1;
 419         }
 420
 421         mtx_destroy(&sc->sc_mtx);
 422         refcount_release(&cfumass_refcount);
 423
 424         return (0);
 425 }
 426
 427 static int
 428 cfumass_suspend(device_t dev)
 429 {
 430         struct cfumass_softc *sc;
 431
 432         sc = device_get_softc(dev);
 433         CFUMASS_DEBUG(sc, "go");
 434
 435         return (0);
 436 }
 437
 438 static int
 439 cfumass_resume(device_t dev)
 440 {
 441         struct cfumass_softc *sc;
 442
 443         sc = device_get_softc(dev);
 444         CFUMASS_DEBUG(sc, "go");
 445
 446         return (0);
 447 }
 448
 449 static void
 450 cfumass_transfer_start(struct cfumass_softc *sc, uint8_t xfer_index)
 451 {
 452
 453         usbd_transfer_start(sc->sc_xfer[xfer_index]);
 454 }
 455
 456 static void
 457 cfumass_transfer_stop_and_drain(struct cfumass_softc *sc, uint8_t xfer_index)
 458 {
 459
 460         usbd_transfer_stop(sc->sc_xfer[xfer_index]);
 461         CFUMASS_UNLOCK(sc);
 462         usbd_transfer_drain(sc->sc_xfer[xfer_index]);
 463         CFUMASS_LOCK(sc);
 464 }
 465
 466 static void
 467 cfumass_terminate(struct cfumass_softc *sc)
 468 {
 469         int last;
 470
 471         for (;;) {
 472                 cfumass_transfer_stop_and_drain(sc, CFUMASS_T_COMMAND);
 473                 cfumass_transfer_stop_and_drain(sc, CFUMASS_T_DATA_IN);
 474                 cfumass_transfer_stop_and_drain(sc, CFUMASS_T_DATA_OUT);
 475
 476                 if (sc->sc_ctl_io != NULL) {
 477                         CFUMASS_DEBUG(sc, "terminating CTL transfer");
 478                         ctl_set_data_phase_error(&sc->sc_ctl_io->scsiio);
 479                         sc->sc_ctl_io->scsiio.be_move_done(sc->sc_ctl_io);
 480                         sc->sc_ctl_io = NULL;
 481                 }
 482
 483                 cfumass_transfer_stop_and_drain(sc, CFUMASS_T_STATUS);
 484
 485                 refcount_acquire(&sc->sc_queued);
 486                 last = refcount_release(&sc->sc_queued);
 487                 if (last != 0)
 488                         break;
 489
 490                 CFUMASS_DEBUG(sc, "%d CTL tasks pending", sc->sc_queued);
 491                 msleep(__DEVOLATILE(void *, &sc->sc_queued), &sc->sc_mtx,
 492                     0, "cfumass_reset", hz / 100);
 493         }
 494 }
 495
 496 static int
 497 cfumass_handle_request(device_t dev,
 498     const void *preq, void **pptr, uint16_t *plen,
 499     uint16_t offset, uint8_t *pstate)
 500 {
 501         static uint8_t max_lun_tmp;
 502         struct cfumass_softc *sc;
 503         const struct usb_device_request *req;
 504         uint8_t is_complete;
 505
 506         sc = device_get_softc(dev);
 507         req = preq;
 508         is_complete = *pstate;
 509
 510         CFUMASS_DEBUG(sc, "go");
 511
 512         if (is_complete)
 513                 return (ENXIO);
 514
 515         if ((req->bmRequestType == UT_WRITE_CLASS_INTERFACE) &&
 516             (req->bRequest == UR_RESET)) {
 517                 CFUMASS_WARN(sc, "received Bulk-Only Mass Storage Reset");
 518                 *plen = 0;
 519
 520                 CFUMASS_LOCK(sc);
 521                 cfumass_terminate(sc);
 522                 cfumass_transfer_start(sc, CFUMASS_T_COMMAND);
 523                 CFUMASS_UNLOCK(sc);
 524
 525                 CFUMASS_DEBUG(sc, "Bulk-Only Mass Storage Reset done");
 526                 return (0);
 527         }
 528
 529         if ((req->bmRequestType == UT_READ_CLASS_INTERFACE) &&
 530             (req->bRequest == UR_GET_MAX_LUN)) {
 531                 CFUMASS_DEBUG(sc, "received Get Max LUN");
 532                 if (offset == 0) {
 533                         *plen = 1;
 534                         /*
 535                          * The protocol doesn't support LUN numbers higher
 536                          * than 15.  Also, some initiators (namely Windows XP
 537                          * SP3 Version 2002) can't properly query the number
 538                          * of LUNs, resulting in inaccessible "fake" ones - thus
 539                          * the default limit of one LUN.
 540                          */
 541                         if (max_lun < 0 || max_lun > 15) {
 542                                 CFUMASS_WARN(sc,
 543                                     "invalid hw.usb.cfumass.max_lun, must be "
 544                                     "between 0 and 15; defaulting to 0");
 545                                 max_lun_tmp = 0;
 546                         } else {
 547                                 max_lun_tmp = max_lun;
 548                         }
 549                         *pptr = &max_lun_tmp;
 550                 } else {
 551                         *plen = 0;
 552                 }
 553                 return (0);
 554         }
 555
 556         return (ENXIO);
 557 }
 558
 559 static int
 560 cfumass_quirk(struct cfumass_softc *sc, unsigned char *cdb, int cdb_len)
 561 {
 562         struct scsi_start_stop_unit *sssu;
 563
 564         switch (cdb[0]) {
 565         case START_STOP_UNIT:
 566                 /*
 567                  * Some initiators - eg OSX, Darwin Kernel Version 15.6.0,
 568                  * root:xnu-3248.60.11~2/RELEASE_X86_64 - attempt to stop
 569                  * the unit on eject, but fail to start it when it's plugged
 570                  * back.  Just ignore the command.
 571                  */
 572
 573                 if (cdb_len < sizeof(*sssu)) {
 574                         CFUMASS_DEBUG(sc, "received START STOP UNIT with "
 575                             "bCDBLength %d, should be %zd",
 576                             cdb_len, sizeof(*sssu));
 577                         break;
 578                 }
 579
 580                 sssu = (struct scsi_start_stop_unit *)cdb;
 581                 if ((sssu->how & SSS_PC_MASK) != 0)
 582                         break;
 583
 584                 if ((sssu->how & SSS_START) != 0)
 585                         break;
 586
 587                 if ((sssu->how & SSS_LOEJ) != 0)
 588                         break;
 589
 590                 if (ignore_stop == 0) {
 591                         break;
 592                 } else if (ignore_stop == 1) {
 593                         CFUMASS_WARN(sc, "ignoring START STOP UNIT request");
 594                 } else {
 595                         CFUMASS_DEBUG(sc, "ignoring START STOP UNIT request");
 596                 }
 597
 598                 sc->sc_current_status = 0;
 599                 cfumass_transfer_start(sc, CFUMASS_T_STATUS);
 600
 601                 return (1);
 602         default:
 603                 break;
 604         }
 605
 606         return (0);
 607 }
 608
 609 static void
 610 cfumass_t_command_callback(struct usb_xfer *xfer, usb_error_t usb_error)
 611 {
 612         struct cfumass_softc *sc;
 613         uint32_t signature;
 614         union ctl_io *io;
 615         int error = 0;
 616
 617         sc = usbd_xfer_softc(xfer);
 618
 619         KASSERT(sc->sc_ctl_io == NULL,
 620             ("sc_ctl_io is %p, should be NULL", sc->sc_ctl_io));
 621
 622         switch (USB_GET_STATE(xfer)) {
 623         case USB_ST_TRANSFERRED:
 624                 CFUMASS_DEBUG(sc, "USB_ST_TRANSFERRED");
 625
 626                 signature = UGETDW(sc->sc_cbw->dCBWSignature);
 627                 if (signature != CBWSIGNATURE) {
 628                         CFUMASS_WARN(sc, "wrong dCBWSignature 0x%08x, "
 629                             "should be 0x%08x", signature, CBWSIGNATURE);
 630                         break;
 631                 }
 632
 633                 if (sc->sc_cbw->bCDBLength <= 0 ||
 634                     sc->sc_cbw->bCDBLength > sizeof(sc->sc_cbw->CBWCB)) {
 635                         CFUMASS_WARN(sc, "invalid bCDBLength %d, should be <= %zd",
 636                             sc->sc_cbw->bCDBLength, sizeof(sc->sc_cbw->CBWCB));
 637                         break;
 638                 }
 639
 640                 sc->sc_current_stalled = false;
 641                 sc->sc_current_status = 0;
 642                 sc->sc_current_tag = UGETDW(sc->sc_cbw->dCBWTag);
 643                 sc->sc_current_transfer_length =
 644                     UGETDW(sc->sc_cbw->dCBWDataTransferLength);
 645                 sc->sc_current_flags = sc->sc_cbw->bCBWFlags;
 646
 647                 /*
 648                  * Make sure to report proper residue if the datamove wasn't
 649                  * required, or wasn't called due to SCSI error.
 650                  */
 651                 sc->sc_current_residue = sc->sc_current_transfer_length;
 652
 653                 if (cfumass_quirk(sc,
 654                     sc->sc_cbw->CBWCB, sc->sc_cbw->bCDBLength) != 0)
 655                         break;
 656
 657                 if (!cfumass_port_online) {
 658                         CFUMASS_DEBUG(sc, "cfumass port is offline; stalling");
 659                         usbd_xfer_set_stall(xfer);
 660                         break;
 661                 }
 662
 663                 /*
 664                  * Those CTL functions cannot be called with mutex held.
 665                  */
 666                 CFUMASS_UNLOCK(sc);
 667                 io = ctl_alloc_io(cfumass_port.ctl_pool_ref);
 668                 ctl_zero_io(io);
 669                 io->io_hdr.ctl_private[CTL_PRIV_FRONTEND].ptr = sc;
 670                 io->io_hdr.io_type = CTL_IO_SCSI;
 671                 io->io_hdr.nexus.initid = sc->sc_ctl_initid;
 672                 io->io_hdr.nexus.targ_port = cfumass_port.targ_port;
 673                 io->io_hdr.nexus.targ_lun = ctl_decode_lun(sc->sc_cbw->bCBWLUN);
 674                 io->scsiio.tag_num = UGETDW(sc->sc_cbw->dCBWTag);
 675                 io->scsiio.tag_type = CTL_TAG_UNTAGGED;
 676                 io->scsiio.cdb_len = sc->sc_cbw->bCDBLength;
 677                 memcpy(io->scsiio.cdb, sc->sc_cbw->CBWCB, sc->sc_cbw->bCDBLength);
 678                 refcount_acquire(&sc->sc_queued);
 679                 error = ctl_queue(io);
 680                 if (error != CTL_RETVAL_COMPLETE) {
 681                         CFUMASS_WARN(sc,
 682                             "ctl_queue() failed; error %d; stalling", error);
 683                         ctl_free_io(io);
 684                         refcount_release(&sc->sc_queued);
 685                         CFUMASS_LOCK(sc);
 686                         usbd_xfer_set_stall(xfer);
 687                         break;
 688                 }
 689
 690                 CFUMASS_LOCK(sc);
 691                 break;
 692
 693         case USB_ST_SETUP:
 694 tr_setup:
 695                 CFUMASS_DEBUG(sc, "USB_ST_SETUP");
 696
 697                 usbd_xfer_set_frame_len(xfer, 0, sizeof(*sc->sc_cbw));
 698                 usbd_transfer_submit(xfer);
 699                 break;
 700
 701         default:
 702                 if (usb_error == USB_ERR_CANCELLED) {
 703                         CFUMASS_DEBUG(sc, "USB_ERR_CANCELLED");
 704                         break;
 705                 }
 706
 707                 CFUMASS_DEBUG(sc, "USB_ST_ERROR: %s", usbd_errstr(usb_error));
 708
 709                 goto tr_setup;
 710         }
 711 }
 712
 713 static void
 714 cfumass_t_data_callback(struct usb_xfer *xfer, usb_error_t usb_error)
 715 {
 716         struct cfumass_softc *sc = usbd_xfer_softc(xfer);
 717         union ctl_io *io = sc->sc_ctl_io;
 718         uint32_t max_bulk;
 719         struct ctl_sg_entry sg_entry, *sglist;
 720         int actlen, sumlen, sg_count;
 721
 722         switch (USB_GET_STATE(xfer)) {
 723         case USB_ST_TRANSFERRED:
 724                 CFUMASS_DEBUG(sc, "USB_ST_TRANSFERRED");
 725
 726                 usbd_xfer_status(xfer, &actlen, &sumlen, NULL, NULL);
 727                 sc->sc_current_residue -= actlen;
 728                 io->scsiio.ext_data_filled += actlen;
 729                 io->scsiio.kern_data_resid -= actlen;
 730                 if (actlen < sumlen ||
 731                     sc->sc_current_residue == 0 ||
 732                     io->scsiio.kern_data_resid == 0) {
 733                         sc->sc_ctl_io = NULL;
 734                         io->scsiio.be_move_done(io);
 735                         break;
 736                 }
 737                 /* FALLTHROUGH */
 738
 739         case USB_ST_SETUP:
 740 tr_setup:
 741                 CFUMASS_DEBUG(sc, "USB_ST_SETUP");
 742
 743                 if (io->scsiio.kern_sg_entries > 0) {
 744                         sglist = (struct ctl_sg_entry *)io->scsiio.kern_data_ptr;
 745                         sg_count = io->scsiio.kern_sg_entries;
 746                 } else {
 747                         sglist = &sg_entry;
 748                         sglist->addr = io->scsiio.kern_data_ptr;
 749                         sglist->len = io->scsiio.kern_data_len;
 750                         sg_count = 1;
 751                 }
 752
 753                 sumlen = io->scsiio.ext_data_filled -
 754                     io->scsiio.kern_rel_offset;
 755                 while (sumlen >= sglist->len && sg_count > 0) {
 756                         sumlen -= sglist->len;
 757                         sglist++;
 758                         sg_count--;
 759                 }
 760                 KASSERT(sg_count > 0, ("Run out of S/G list entries"));
 761
 762                 max_bulk = usbd_xfer_max_len(xfer);
 763                 actlen = min(sglist->len - sumlen, max_bulk);
 764                 actlen = min(actlen, sc->sc_current_transfer_length -
 765                     io->scsiio.ext_data_filled);
 766                 CFUMASS_DEBUG(sc, "requested %d, done %d, max_bulk %d, "
 767                     "segment %zd => transfer %d",
 768                     sc->sc_current_transfer_length, io->scsiio.ext_data_filled,
 769                     max_bulk, sglist->len - sumlen, actlen);
 770
 771                 usbd_xfer_set_frame_data(xfer, 0,
 772                     (uint8_t *)sglist->addr + sumlen, actlen);
 773                 usbd_transfer_submit(xfer);
 774                 break;
 775
 776         default:
 777                 if (usb_error == USB_ERR_CANCELLED) {
 778                         CFUMASS_DEBUG(sc, "USB_ERR_CANCELLED");
 779                         break;
 780                 }
 781                 CFUMASS_DEBUG(sc, "USB_ST_ERROR: %s", usbd_errstr(usb_error));
 782                 goto tr_setup;
 783         }
 784 }
 785
 786 static void
 787 cfumass_t_status_callback(struct usb_xfer *xfer, usb_error_t usb_error)
 788 {
 789         struct cfumass_softc *sc;
 790
 791         sc = usbd_xfer_softc(xfer);
 792
 793         KASSERT(sc->sc_ctl_io == NULL,
 794             ("sc_ctl_io is %p, should be NULL", sc->sc_ctl_io));
 795
 796         switch (USB_GET_STATE(xfer)) {
 797         case USB_ST_TRANSFERRED:
 798                 CFUMASS_DEBUG(sc, "USB_ST_TRANSFERRED");
 799
 800                 cfumass_transfer_start(sc, CFUMASS_T_COMMAND);
 801                 break;
 802
 803         case USB_ST_SETUP:
 804 tr_setup:
 805                 CFUMASS_DEBUG(sc, "USB_ST_SETUP");
 806
 807                 if (sc->sc_current_residue > 0 && !sc->sc_current_stalled) {
 808                         CFUMASS_DEBUG(sc, "non-zero residue, stalling");
 809                         usbd_xfer_set_stall(xfer);
 810                         sc->sc_current_stalled = true;
 811                 }
 812
 813                 USETDW(sc->sc_csw->dCSWSignature, CSWSIGNATURE);
 814                 USETDW(sc->sc_csw->dCSWTag, sc->sc_current_tag);
 815                 USETDW(sc->sc_csw->dCSWDataResidue, sc->sc_current_residue);
 816                 sc->sc_csw->bCSWStatus = sc->sc_current_status;
 817
 818                 usbd_xfer_set_frame_len(xfer, 0, sizeof(*sc->sc_csw));
 819                 usbd_transfer_submit(xfer);
 820                 break;
 821
 822         default:
 823                 if (usb_error == USB_ERR_CANCELLED) {
 824                         CFUMASS_DEBUG(sc, "USB_ERR_CANCELLED");
 825                         break;
 826                 }
 827
 828                 CFUMASS_DEBUG(sc, "USB_ST_ERROR: %s",
 829                     usbd_errstr(usb_error));
 830
 831                 goto tr_setup;
 832         }
 833 }
 834
 835 static void
 836 cfumass_online(void *arg __unused)
 837 {
 838
 839         cfumass_port_online = true;
 840 }
 841
 842 static void
 843 cfumass_offline(void *arg __unused)
 844 {
 845
 846         cfumass_port_online = false;
 847 }
 848
 849 static void
 850 cfumass_datamove(union ctl_io *io)
 851 {
 852         struct cfumass_softc *sc;
 853
 854         sc = io->io_hdr.ctl_private[CTL_PRIV_FRONTEND].ptr;
 855
 856         CFUMASS_DEBUG(sc, "go");
 857
 858         CFUMASS_LOCK(sc);
 859
 860         KASSERT(sc->sc_ctl_io == NULL,
 861             ("sc_ctl_io is %p, should be NULL", sc->sc_ctl_io));
 862         sc->sc_ctl_io = io;
 863
 864         if ((io->io_hdr.flags & CTL_FLAG_DATA_MASK) == CTL_FLAG_DATA_IN) {
 865                 /*
 866                  * Verify that CTL wants us to send the data in the direction
 867                  * expected by the initiator.
 868                  */
 869                 if (sc->sc_current_flags != CBWFLAGS_IN) {
 870                         CFUMASS_WARN(sc, "wrong bCBWFlags 0x%x, should be 0x%x",
 871                             sc->sc_current_flags, CBWFLAGS_IN);
 872                         goto fail;
 873                 }
 874
 875                 cfumass_transfer_start(sc, CFUMASS_T_DATA_IN);
 876         } else {
 877                 if (sc->sc_current_flags != CBWFLAGS_OUT) {
 878                         CFUMASS_WARN(sc, "wrong bCBWFlags 0x%x, should be 0x%x",
 879                             sc->sc_current_flags, CBWFLAGS_OUT);
 880                         goto fail;
 881                 }
 882
 883                 cfumass_transfer_start(sc, CFUMASS_T_DATA_OUT);
 884         }
 885
 886         CFUMASS_UNLOCK(sc);
 887         return;
 888
 889 fail:
 890         ctl_set_data_phase_error(&io->scsiio);
 891         io->scsiio.be_move_done(io);
 892         sc->sc_ctl_io = NULL;
 893 }
 894
 895 static void
 896 cfumass_done(union ctl_io *io)
 897 {
 898         struct cfumass_softc *sc;
 899
 900         sc = io->io_hdr.ctl_private[CTL_PRIV_FRONTEND].ptr;
 901
 902         CFUMASS_DEBUG(sc, "go");
 903
 904         KASSERT(((io->io_hdr.status & CTL_STATUS_MASK) != CTL_STATUS_NONE),
 905             ("invalid CTL status %#x", io->io_hdr.status));
 906         KASSERT(sc->sc_ctl_io == NULL,
 907             ("sc_ctl_io is %p, should be NULL", sc->sc_ctl_io));
 908
 909         if (io->io_hdr.io_type == CTL_IO_TASK &&
 910             io->taskio.task_action == CTL_TASK_I_T_NEXUS_RESET) {
 911                 /*
 912                  * Implicit task termination has just completed; nothing to do.
 913                  */
 914                 ctl_free_io(io);
 915                 return;
 916         }
 917
 918         /*
 919          * Do not return status for aborted commands.
 920          * There are exceptions, but none supported by CTL yet.
 921          */
 922         if (((io->io_hdr.flags & CTL_FLAG_ABORT) &&
 923              (io->io_hdr.flags & CTL_FLAG_ABORT_STATUS) == 0) ||
 924             (io->io_hdr.flags & CTL_FLAG_STATUS_SENT)) {
 925                 ctl_free_io(io);
 926                 return;
 927         }
 928
 929         if ((io->io_hdr.status & CTL_STATUS_MASK) == CTL_SUCCESS)
 930                 sc->sc_current_status = 0;
 931         else
 932                 sc->sc_current_status = 1;
 933
 934         /* XXX: How should we report BUSY, RESERVATION CONFLICT, etc? */
 935         if ((io->io_hdr.status & CTL_STATUS_MASK) == CTL_SCSI_ERROR &&
 936             io->scsiio.scsi_status == SCSI_STATUS_CHECK_COND)
 937                 ctl_queue_sense(io);
 938         else
 939                 ctl_free_io(io);
 940
 941         CFUMASS_LOCK(sc);
 942         cfumass_transfer_start(sc, CFUMASS_T_STATUS);
 943         CFUMASS_UNLOCK(sc);
 944
 945         refcount_release(&sc->sc_queued);
 946 }
 947
 948 int
 949 cfumass_init(void)
 950 {
 951         int error;
 952
 953         cfumass_port.frontend = &cfumass_frontend;
 954         cfumass_port.port_type = CTL_PORT_UMASS;
 955         cfumass_port.num_requested_ctl_io = 1;
 956         cfumass_port.port_name = "cfumass";
 957         cfumass_port.physical_port = 0;
 958         cfumass_port.virtual_port = 0;
 959         cfumass_port.port_online = cfumass_online;
 960         cfumass_port.port_offline = cfumass_offline;
 961         cfumass_port.onoff_arg = NULL;
 962         cfumass_port.fe_datamove = cfumass_datamove;
 963         cfumass_port.fe_done = cfumass_done;
 964         cfumass_port.targ_port = -1;
 965
 966         error = ctl_port_register(&cfumass_port);
 967         if (error != 0) {
 968                 printf("%s: ctl_port_register() failed "
 969                     "with error %d", __func__, error);
 970         }
 971
 972         cfumass_port_online = true;
 973         refcount_init(&cfumass_refcount, 0);
 974
 975         return (error);
 976 }
 977
 978 int
 979 cfumass_shutdown(void)
 980 {
 981         int error;
 982
 983         if (cfumass_refcount > 0) {
 984                 if (debug > 1) {
 985                         printf("%s: still have %u attachments; "
 986                             "returning EBUSY\n", __func__, cfumass_refcount);
 987                 }
 988                 return (EBUSY);
 989         }
 990
 991         error = ctl_port_deregister(&cfumass_port);
 992         if (error != 0) {
 993                 printf("%s: ctl_port_deregister() failed "
 994                     "with error %d\n", __func__, error);
 995         }
 996
 997         return (error);
 998 }