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