1 #include <sys/cdefs.h> 2 __FBSDID("$FreeBSD$"); 3 4 /*- 5 * Copyright (c) 1999 MAEKAWA Masahide <[email protected]>, 6 * Nick Hibma <[email protected]> 7 * All rights reserved. 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 * $FreeBSD$ 31 * $NetBSD: umass.c,v 1.28 2000/04/02 23:46:53 augustss Exp $ 32 */ 33 34 /* Also already merged from NetBSD: 35 * $NetBSD: umass.c,v 1.67 2001/11/25 19:05:22 augustss Exp $ 36 * $NetBSD: umass.c,v 1.90 2002/11/04 19:17:33 pooka Exp $ 37 * $NetBSD: umass.c,v 1.108 2003/11/07 17:03:25 wiz Exp $ 38 * $NetBSD: umass.c,v 1.109 2003/12/04 13:57:31 keihan Exp $ 39 */ 40 41 /* 42 * Universal Serial Bus Mass Storage Class specs: 43 * http://www.usb.org/developers/devclass_docs/usb_msc_overview_1.2.pdf 44 * http://www.usb.org/developers/devclass_docs/usbmassbulk_10.pdf 45 * http://www.usb.org/developers/devclass_docs/usb_msc_cbi_1.1.pdf 46 * http://www.usb.org/developers/devclass_docs/usbmass-ufi10.pdf 47 */ 48 49 /* 50 * Ported to NetBSD by Lennart Augustsson <[email protected]>. 51 * Parts of the code written by Jason R. Thorpe <[email protected]>. 52 */ 53 54 /* 55 * The driver handles 3 Wire Protocols 56 * - Command/Bulk/Interrupt (CBI) 57 * - Command/Bulk/Interrupt with Command Completion Interrupt (CBI with CCI) 58 * - Mass Storage Bulk-Only (BBB) 59 * (BBB refers Bulk/Bulk/Bulk for Command/Data/Status phases) 60 * 61 * Over these wire protocols it handles the following command protocols 62 * - SCSI 63 * - UFI (floppy command set) 64 * - 8070i (ATAPI) 65 * 66 * UFI and 8070i (ATAPI) are transformed versions of the SCSI command set. The 67 * sc->sc_transform method is used to convert the commands into the appropriate 68 * format (if at all necessary). For example, UFI requires all commands to be 69 * 12 bytes in length amongst other things. 70 * 71 * The source code below is marked and can be split into a number of pieces 72 * (in this order): 73 * 74 * - probe/attach/detach 75 * - generic transfer routines 76 * - BBB 77 * - CBI 78 * - CBI_I (in addition to functions from CBI) 79 * - CAM (Common Access Method) 80 * - SCSI 81 * - UFI 82 * - 8070i (ATAPI) 83 * 84 * The protocols are implemented using a state machine, for the transfers as 85 * well as for the resets. The state machine is contained in umass_t_*_callback. 86 * The state machine is started through either umass_command_start() or 87 * umass_reset(). 88 * 89 * The reason for doing this is a) CAM performs a lot better this way and b) it 90 * avoids using tsleep from interrupt context (for example after a failed 91 * transfer). 92 */ 93 94 /* 95 * The SCSI related part of this driver has been derived from the 96 * dev/ppbus/vpo.c driver, by Nicolas Souchu ([email protected]). 97 * 98 * The CAM layer uses so called actions which are messages sent to the host 99 * adapter for completion. The actions come in through umass_cam_action. The 100 * appropriate block of routines is called depending on the transport protocol 101 * in use. When the transfer has finished, these routines call 102 * umass_cam_cb again to complete the CAM command. 103 */ 104 105 #include <sys/stdint.h> 106 #include <sys/stddef.h> 107 #include <sys/param.h> 108 #include <sys/queue.h> 109 #include <sys/types.h> 110 #include <sys/systm.h> 111 #include <sys/kernel.h> 112 #include <sys/bus.h> 113 #include <sys/linker_set.h> 114 #include <sys/module.h> 115 #include <sys/lock.h> 116 #include <sys/mutex.h> 117 #include <sys/condvar.h> 118 #include <sys/sysctl.h> 119 #include <sys/sx.h> 120 #include <sys/unistd.h> 121 #include <sys/callout.h> 122 #include <sys/malloc.h> 123 #include <sys/priv.h> 124 125 #include <dev/usb/usb.h> 126 #include <dev/usb/usbdi.h> 127 #include <dev/usb/usbdi_util.h> 128 #include "usbdevs.h" 129 130 #include <dev/usb/quirk/usb_quirk.h> 131 132 #include <cam/cam.h> 133 #include <cam/cam_ccb.h> 134 #include <cam/cam_sim.h> 135 #include <cam/cam_xpt_sim.h> 136 #include <cam/scsi/scsi_all.h> 137 #include <cam/scsi/scsi_da.h> 138 139 #include <cam/cam_periph.h> 140 141 #define UMASS_EXT_BUFFER 142 #ifdef UMASS_EXT_BUFFER 143 /* this enables loading of virtual buffers into DMA */ 144 #define UMASS_USB_FLAGS .ext_buffer=1, 145 #else 146 #define UMASS_USB_FLAGS 147 #endif 148 149 #ifdef USB_DEBUG 150 #define DIF(m, x) \ 151 do { \ 152 if (umass_debug & (m)) { x ; } \ 153 } while (0) 154 155 #define DPRINTF(sc, m, fmt, ...) \ 156 do { \ 157 if (umass_debug & (m)) { \ 158 printf("%s:%s: " fmt, \ 159 (sc) ? (const char *)(sc)->sc_name : \ 160 (const char *)"umassX", \ 161 __FUNCTION__ ,## __VA_ARGS__); \ 162 } \ 163 } while (0) 164 165 #define UDMASS_GEN 0x00010000 /* general */ 166 #define UDMASS_SCSI 0x00020000 /* scsi */ 167 #define UDMASS_UFI 0x00040000 /* ufi command set */ 168 #define UDMASS_ATAPI 0x00080000 /* 8070i command set */ 169 #define UDMASS_CMD (UDMASS_SCSI|UDMASS_UFI|UDMASS_ATAPI) 170 #define UDMASS_USB 0x00100000 /* USB general */ 171 #define UDMASS_BBB 0x00200000 /* Bulk-Only transfers */ 172 #define UDMASS_CBI 0x00400000 /* CBI transfers */ 173 #define UDMASS_WIRE (UDMASS_BBB|UDMASS_CBI) 174 #define UDMASS_ALL 0xffff0000 /* all of the above */ 175 static int umass_debug = 0; 176 177 SYSCTL_NODE(_hw_usb, OID_AUTO, umass, CTLFLAG_RW, 0, "USB umass"); 178 SYSCTL_INT(_hw_usb_umass, OID_AUTO, debug, CTLFLAG_RW, 179 &umass_debug, 0, "umass debug level"); 180 181 TUNABLE_INT("hw.usb.umass.debug", &umass_debug); 182 #else 183 #define DIF(...) do { } while (0) 184 #define DPRINTF(...) do { } while (0) 185 #endif 186 187 #define UMASS_GONE ((struct umass_softc *)1) 188 189 #define UMASS_BULK_SIZE (1 << 17) 190 #define UMASS_CBI_DIAGNOSTIC_CMDLEN 12 /* bytes */ 191 #define UMASS_MAX_CMDLEN MAX(12, CAM_MAX_CDBLEN) /* bytes */ 192 193 /* USB transfer definitions */ 194 195 #define UMASS_T_BBB_RESET1 0 /* Bulk-Only */ 196 #define UMASS_T_BBB_RESET2 1 197 #define UMASS_T_BBB_RESET3 2 198 #define UMASS_T_BBB_COMMAND 3 199 #define UMASS_T_BBB_DATA_READ 4 200 #define UMASS_T_BBB_DATA_RD_CS 5 201 #define UMASS_T_BBB_DATA_WRITE 6 202 #define UMASS_T_BBB_DATA_WR_CS 7 203 #define UMASS_T_BBB_STATUS 8 204 #define UMASS_T_BBB_MAX 9 205 206 #define UMASS_T_CBI_RESET1 0 /* CBI */ 207 #define UMASS_T_CBI_RESET2 1 208 #define UMASS_T_CBI_RESET3 2 209 #define UMASS_T_CBI_COMMAND 3 210 #define UMASS_T_CBI_DATA_READ 4 211 #define UMASS_T_CBI_DATA_RD_CS 5 212 #define UMASS_T_CBI_DATA_WRITE 6 213 #define UMASS_T_CBI_DATA_WR_CS 7 214 #define UMASS_T_CBI_STATUS 8 215 #define UMASS_T_CBI_RESET4 9 216 #define UMASS_T_CBI_MAX 10 217 218 #define UMASS_T_MAX MAX(UMASS_T_CBI_MAX, UMASS_T_BBB_MAX) 219 220 /* Generic definitions */ 221 222 /* Direction for transfer */ 223 #define DIR_NONE 0 224 #define DIR_IN 1 225 #define DIR_OUT 2 226 227 /* device name */ 228 #define DEVNAME "umass" 229 #define DEVNAME_SIM "umass-sim" 230 231 /* Approximate maximum transfer speeds (assumes 33% overhead). */ 232 #define UMASS_FULL_TRANSFER_SPEED 1000 233 #define UMASS_HIGH_TRANSFER_SPEED 40000 234 #define UMASS_SUPER_TRANSFER_SPEED 400000 235 #define UMASS_FLOPPY_TRANSFER_SPEED 20 236 237 #define UMASS_TIMEOUT 5000 /* ms */ 238 239 /* CAM specific definitions */ 240 241 #define UMASS_SCSIID_MAX 1 /* maximum number of drives expected */ 242 #define UMASS_SCSIID_HOST UMASS_SCSIID_MAX 243 244 /* Bulk-Only features */ 245 246 #define UR_BBB_RESET 0xff /* Bulk-Only reset */ 247 #define UR_BBB_GET_MAX_LUN 0xfe /* Get maximum lun */ 248 249 /* Command Block Wrapper */ 250 typedef struct { 251 uDWord dCBWSignature; 252 #define CBWSIGNATURE 0x43425355 253 uDWord dCBWTag; 254 uDWord dCBWDataTransferLength; 255 uByte bCBWFlags; 256 #define CBWFLAGS_OUT 0x00 257 #define CBWFLAGS_IN 0x80 258 uByte bCBWLUN; 259 uByte bCDBLength; 260 #define CBWCDBLENGTH 16 261 uByte CBWCDB[CBWCDBLENGTH]; 262 } __packed umass_bbb_cbw_t; 263 264 #define UMASS_BBB_CBW_SIZE 31 265 266 /* Command Status Wrapper */ 267 typedef struct { 268 uDWord dCSWSignature; 269 #define CSWSIGNATURE 0x53425355 270 #define CSWSIGNATURE_IMAGINATION_DBX1 0x43425355 271 #define CSWSIGNATURE_OLYMPUS_C1 0x55425355 272 uDWord dCSWTag; 273 uDWord dCSWDataResidue; 274 uByte bCSWStatus; 275 #define CSWSTATUS_GOOD 0x0 276 #define CSWSTATUS_FAILED 0x1 277 #define CSWSTATUS_PHASE 0x2 278 } __packed umass_bbb_csw_t; 279 280 #define UMASS_BBB_CSW_SIZE 13 281 282 /* CBI features */ 283 284 #define UR_CBI_ADSC 0x00 285 286 typedef union { 287 struct { 288 uint8_t type; 289 #define IDB_TYPE_CCI 0x00 290 uint8_t value; 291 #define IDB_VALUE_PASS 0x00 292 #define IDB_VALUE_FAIL 0x01 293 #define IDB_VALUE_PHASE 0x02 294 #define IDB_VALUE_PERSISTENT 0x03 295 #define IDB_VALUE_STATUS_MASK 0x03 296 } __packed common; 297 298 struct { 299 uint8_t asc; 300 uint8_t ascq; 301 } __packed ufi; 302 } __packed umass_cbi_sbl_t; 303 304 struct umass_softc; /* see below */ 305 306 typedef void (umass_callback_t)(struct umass_softc *sc, union ccb *ccb, 307 uint32_t residue, uint8_t status); 308 309 #define STATUS_CMD_OK 0 /* everything ok */ 310 #define STATUS_CMD_UNKNOWN 1 /* will have to fetch sense */ 311 #define STATUS_CMD_FAILED 2 /* transfer was ok, command failed */ 312 #define STATUS_WIRE_FAILED 3 /* couldn't even get command across */ 313 314 typedef uint8_t (umass_transform_t)(struct umass_softc *sc, uint8_t *cmd_ptr, 315 uint8_t cmd_len); 316 317 /* Wire and command protocol */ 318 #define UMASS_PROTO_BBB 0x0001 /* USB wire protocol */ 319 #define UMASS_PROTO_CBI 0x0002 320 #define UMASS_PROTO_CBI_I 0x0004 321 #define UMASS_PROTO_WIRE 0x00ff /* USB wire protocol mask */ 322 #define UMASS_PROTO_SCSI 0x0100 /* command protocol */ 323 #define UMASS_PROTO_ATAPI 0x0200 324 #define UMASS_PROTO_UFI 0x0400 325 #define UMASS_PROTO_RBC 0x0800 326 #define UMASS_PROTO_COMMAND 0xff00 /* command protocol mask */ 327 328 /* Device specific quirks */ 329 #define NO_QUIRKS 0x0000 330 /* 331 * The drive does not support Test Unit Ready. Convert to Start Unit 332 */ 333 #define NO_TEST_UNIT_READY 0x0001 334 /* 335 * The drive does not reset the Unit Attention state after REQUEST 336 * SENSE has been sent. The INQUIRY command does not reset the UA 337 * either, and so CAM runs in circles trying to retrieve the initial 338 * INQUIRY data. 339 */ 340 #define RS_NO_CLEAR_UA 0x0002 341 /* The drive does not support START STOP. */ 342 #define NO_START_STOP 0x0004 343 /* Don't ask for full inquiry data (255b). */ 344 #define FORCE_SHORT_INQUIRY 0x0008 345 /* Needs to be initialised the Shuttle way */ 346 #define SHUTTLE_INIT 0x0010 347 /* Drive needs to be switched to alternate iface 1 */ 348 #define ALT_IFACE_1 0x0020 349 /* Drive does not do 1Mb/s, but just floppy speeds (20kb/s) */ 350 #define FLOPPY_SPEED 0x0040 351 /* The device can't count and gets the residue of transfers wrong */ 352 #define IGNORE_RESIDUE 0x0080 353 /* No GetMaxLun call */ 354 #define NO_GETMAXLUN 0x0100 355 /* The device uses a weird CSWSIGNATURE. */ 356 #define WRONG_CSWSIG 0x0200 357 /* Device cannot handle INQUIRY so fake a generic response */ 358 #define NO_INQUIRY 0x0400 359 /* Device cannot handle INQUIRY EVPD, return CHECK CONDITION */ 360 #define NO_INQUIRY_EVPD 0x0800 361 /* Pad all RBC requests to 12 bytes. */ 362 #define RBC_PAD_TO_12 0x1000 363 /* 364 * Device reports number of sectors from READ_CAPACITY, not max 365 * sector number. 366 */ 367 #define READ_CAPACITY_OFFBY1 0x2000 368 /* 369 * Device cannot handle a SCSI synchronize cache command. Normally 370 * this quirk would be handled in the cam layer, but for IDE bridges 371 * we need to associate the quirk with the bridge and not the 372 * underlying disk device. This is handled by faking a success 373 * result. 374 */ 375 #define NO_SYNCHRONIZE_CACHE 0x4000 376 377 struct umass_softc { 378 379 struct scsi_sense cam_scsi_sense; 380 struct scsi_test_unit_ready cam_scsi_test_unit_ready; 381 struct mtx sc_mtx; 382 struct { 383 uint8_t *data_ptr; 384 union ccb *ccb; 385 umass_callback_t *callback; 386 387 uint32_t data_len; /* bytes */ 388 uint32_t data_rem; /* bytes */ 389 uint32_t data_timeout; /* ms */ 390 uint32_t actlen; /* bytes */ 391 392 uint8_t cmd_data[UMASS_MAX_CMDLEN]; 393 uint8_t cmd_len; /* bytes */ 394 uint8_t dir; 395 uint8_t lun; 396 } sc_transfer; 397 398 /* Bulk specific variables for transfers in progress */ 399 umass_bbb_cbw_t cbw; /* command block wrapper */ 400 umass_bbb_csw_t csw; /* command status wrapper */ 401 402 /* CBI specific variables for transfers in progress */ 403 umass_cbi_sbl_t sbl; /* status block */ 404 405 device_t sc_dev; 406 struct usb_device *sc_udev; 407 struct cam_sim *sc_sim; /* SCSI Interface Module */ 408 struct usb_xfer *sc_xfer[UMASS_T_MAX]; 409 410 /* 411 * The command transform function is used to convert the SCSI 412 * commands into their derivatives, like UFI, ATAPI, and friends. 413 */ 414 umass_transform_t *sc_transform; 415 416 uint32_t sc_unit; 417 uint32_t sc_quirks; /* they got it almost right */ 418 uint32_t sc_proto; /* wire and cmd protocol */ 419 420 uint8_t sc_name[16]; 421 uint8_t sc_iface_no; /* interface number */ 422 uint8_t sc_maxlun; /* maximum LUN number, inclusive */ 423 uint8_t sc_last_xfer_index; 424 uint8_t sc_status_try; 425 }; 426 427 struct umass_probe_proto { 428 uint32_t quirks; 429 uint32_t proto; 430 431 int error; 432 }; 433 434 /* prototypes */ 435 436 static device_probe_t umass_probe; 437 static device_attach_t umass_attach; 438 static device_detach_t umass_detach; 439 440 static usb_callback_t umass_tr_error; 441 static usb_callback_t umass_t_bbb_reset1_callback; 442 static usb_callback_t umass_t_bbb_reset2_callback; 443 static usb_callback_t umass_t_bbb_reset3_callback; 444 static usb_callback_t umass_t_bbb_command_callback; 445 static usb_callback_t umass_t_bbb_data_read_callback; 446 static usb_callback_t umass_t_bbb_data_rd_cs_callback; 447 static usb_callback_t umass_t_bbb_data_write_callback; 448 static usb_callback_t umass_t_bbb_data_wr_cs_callback; 449 static usb_callback_t umass_t_bbb_status_callback; 450 static usb_callback_t umass_t_cbi_reset1_callback; 451 static usb_callback_t umass_t_cbi_reset2_callback; 452 static usb_callback_t umass_t_cbi_reset3_callback; 453 static usb_callback_t umass_t_cbi_reset4_callback; 454 static usb_callback_t umass_t_cbi_command_callback; 455 static usb_callback_t umass_t_cbi_data_read_callback; 456 static usb_callback_t umass_t_cbi_data_rd_cs_callback; 457 static usb_callback_t umass_t_cbi_data_write_callback; 458 static usb_callback_t umass_t_cbi_data_wr_cs_callback; 459 static usb_callback_t umass_t_cbi_status_callback; 460 461 static void umass_cancel_ccb(struct umass_softc *); 462 static void umass_init_shuttle(struct umass_softc *); 463 static void umass_reset(struct umass_softc *); 464 static void umass_t_bbb_data_clear_stall_callback(struct usb_xfer *, 465 uint8_t, uint8_t, usb_error_t); 466 static void umass_command_start(struct umass_softc *, uint8_t, void *, 467 uint32_t, uint32_t, umass_callback_t *, union ccb *); 468 static uint8_t umass_bbb_get_max_lun(struct umass_softc *); 469 static void umass_cbi_start_status(struct umass_softc *); 470 static void umass_t_cbi_data_clear_stall_callback(struct usb_xfer *, 471 uint8_t, uint8_t, usb_error_t); 472 static int umass_cam_attach_sim(struct umass_softc *); 473 static void umass_cam_attach(struct umass_softc *); 474 static void umass_cam_detach_sim(struct umass_softc *); 475 static void umass_cam_action(struct cam_sim *, union ccb *); 476 static void umass_cam_poll(struct cam_sim *); 477 static void umass_cam_cb(struct umass_softc *, union ccb *, uint32_t, 478 uint8_t); 479 static void umass_cam_sense_cb(struct umass_softc *, union ccb *, uint32_t, 480 uint8_t); 481 static void umass_cam_quirk_cb(struct umass_softc *, union ccb *, uint32_t, 482 uint8_t); 483 static uint8_t umass_scsi_transform(struct umass_softc *, uint8_t *, uint8_t); 484 static uint8_t umass_rbc_transform(struct umass_softc *, uint8_t *, uint8_t); 485 static uint8_t umass_ufi_transform(struct umass_softc *, uint8_t *, uint8_t); 486 static uint8_t umass_atapi_transform(struct umass_softc *, uint8_t *, 487 uint8_t); 488 static uint8_t umass_no_transform(struct umass_softc *, uint8_t *, uint8_t); 489 static uint8_t umass_std_transform(struct umass_softc *, union ccb *, uint8_t 490 *, uint8_t); 491 492 #ifdef USB_DEBUG 493 static void umass_bbb_dump_cbw(struct umass_softc *, umass_bbb_cbw_t *); 494 static void umass_bbb_dump_csw(struct umass_softc *, umass_bbb_csw_t *); 495 static void umass_cbi_dump_cmd(struct umass_softc *, void *, uint8_t); 496 static void umass_dump_buffer(struct umass_softc *, uint8_t *, uint32_t, 497 uint32_t); 498 #endif 499 500 static struct usb_config umass_bbb_config[UMASS_T_BBB_MAX] = { 501 502 [UMASS_T_BBB_RESET1] = { 503 .type = UE_CONTROL, 504 .endpoint = 0x00, /* Control pipe */ 505 .direction = UE_DIR_ANY, 506 .bufsize = sizeof(struct usb_device_request), 507 .callback = &umass_t_bbb_reset1_callback, 508 .timeout = 5000, /* 5 seconds */ 509 .interval = 500, /* 500 milliseconds */ 510 }, 511 512 [UMASS_T_BBB_RESET2] = { 513 .type = UE_CONTROL, 514 .endpoint = 0x00, /* Control pipe */ 515 .direction = UE_DIR_ANY, 516 .bufsize = sizeof(struct usb_device_request), 517 .callback = &umass_t_bbb_reset2_callback, 518 .timeout = 5000, /* 5 seconds */ 519 .interval = 50, /* 50 milliseconds */ 520 }, 521 522 [UMASS_T_BBB_RESET3] = { 523 .type = UE_CONTROL, 524 .endpoint = 0x00, /* Control pipe */ 525 .direction = UE_DIR_ANY, 526 .bufsize = sizeof(struct usb_device_request), 527 .callback = &umass_t_bbb_reset3_callback, 528 .timeout = 5000, /* 5 seconds */ 529 .interval = 50, /* 50 milliseconds */ 530 }, 531 532 [UMASS_T_BBB_COMMAND] = { 533 .type = UE_BULK, 534 .endpoint = UE_ADDR_ANY, 535 .direction = UE_DIR_OUT, 536 .bufsize = sizeof(umass_bbb_cbw_t), 537 .callback = &umass_t_bbb_command_callback, 538 .timeout = 5000, /* 5 seconds */ 539 }, 540 541 [UMASS_T_BBB_DATA_READ] = { 542 .type = UE_BULK, 543 .endpoint = UE_ADDR_ANY, 544 .direction = UE_DIR_IN, 545 .bufsize = UMASS_BULK_SIZE, 546 .flags = {.proxy_buffer = 1,.short_xfer_ok = 1, UMASS_USB_FLAGS}, 547 .callback = &umass_t_bbb_data_read_callback, 548 .timeout = 0, /* overwritten later */ 549 }, 550 551 [UMASS_T_BBB_DATA_RD_CS] = { 552 .type = UE_CONTROL, 553 .endpoint = 0x00, /* Control pipe */ 554 .direction = UE_DIR_ANY, 555 .bufsize = sizeof(struct usb_device_request), 556 .callback = &umass_t_bbb_data_rd_cs_callback, 557 .timeout = 5000, /* 5 seconds */ 558 }, 559 560 [UMASS_T_BBB_DATA_WRITE] = { 561 .type = UE_BULK, 562 .endpoint = UE_ADDR_ANY, 563 .direction = UE_DIR_OUT, 564 .bufsize = UMASS_BULK_SIZE, 565 .flags = {.proxy_buffer = 1,.short_xfer_ok = 1, UMASS_USB_FLAGS}, 566 .callback = &umass_t_bbb_data_write_callback, 567 .timeout = 0, /* overwritten later */ 568 }, 569 570 [UMASS_T_BBB_DATA_WR_CS] = { 571 .type = UE_CONTROL, 572 .endpoint = 0x00, /* Control pipe */ 573 .direction = UE_DIR_ANY, 574 .bufsize = sizeof(struct usb_device_request), 575 .callback = &umass_t_bbb_data_wr_cs_callback, 576 .timeout = 5000, /* 5 seconds */ 577 }, 578 579 [UMASS_T_BBB_STATUS] = { 580 .type = UE_BULK, 581 .endpoint = UE_ADDR_ANY, 582 .direction = UE_DIR_IN, 583 .bufsize = sizeof(umass_bbb_csw_t), 584 .flags = {.short_xfer_ok = 1,}, 585 .callback = &umass_t_bbb_status_callback, 586 .timeout = 5000, /* ms */ 587 }, 588 }; 589 590 static struct usb_config umass_cbi_config[UMASS_T_CBI_MAX] = { 591 592 [UMASS_T_CBI_RESET1] = { 593 .type = UE_CONTROL, 594 .endpoint = 0x00, /* Control pipe */ 595 .direction = UE_DIR_ANY, 596 .bufsize = (sizeof(struct usb_device_request) + 597 UMASS_CBI_DIAGNOSTIC_CMDLEN), 598 .callback = &umass_t_cbi_reset1_callback, 599 .timeout = 5000, /* 5 seconds */ 600 .interval = 500, /* 500 milliseconds */ 601 }, 602 603 [UMASS_T_CBI_RESET2] = { 604 .type = UE_CONTROL, 605 .endpoint = 0x00, /* Control pipe */ 606 .direction = UE_DIR_ANY, 607 .bufsize = sizeof(struct usb_device_request), 608 .callback = &umass_t_cbi_reset2_callback, 609 .timeout = 5000, /* 5 seconds */ 610 .interval = 50, /* 50 milliseconds */ 611 }, 612 613 [UMASS_T_CBI_RESET3] = { 614 .type = UE_CONTROL, 615 .endpoint = 0x00, /* Control pipe */ 616 .direction = UE_DIR_ANY, 617 .bufsize = sizeof(struct usb_device_request), 618 .callback = &umass_t_cbi_reset3_callback, 619 .timeout = 5000, /* 5 seconds */ 620 .interval = 50, /* 50 milliseconds */ 621 }, 622 623 [UMASS_T_CBI_COMMAND] = { 624 .type = UE_CONTROL, 625 .endpoint = 0x00, /* Control pipe */ 626 .direction = UE_DIR_ANY, 627 .bufsize = (sizeof(struct usb_device_request) + 628 UMASS_MAX_CMDLEN), 629 .callback = &umass_t_cbi_command_callback, 630 .timeout = 5000, /* 5 seconds */ 631 }, 632 633 [UMASS_T_CBI_DATA_READ] = { 634 .type = UE_BULK, 635 .endpoint = UE_ADDR_ANY, 636 .direction = UE_DIR_IN, 637 .bufsize = UMASS_BULK_SIZE, 638 .flags = {.proxy_buffer = 1,.short_xfer_ok = 1, UMASS_USB_FLAGS}, 639 .callback = &umass_t_cbi_data_read_callback, 640 .timeout = 0, /* overwritten later */ 641 }, 642 643 [UMASS_T_CBI_DATA_RD_CS] = { 644 .type = UE_CONTROL, 645 .endpoint = 0x00, /* Control pipe */ 646 .direction = UE_DIR_ANY, 647 .bufsize = sizeof(struct usb_device_request), 648 .callback = &umass_t_cbi_data_rd_cs_callback, 649 .timeout = 5000, /* 5 seconds */ 650 }, 651 652 [UMASS_T_CBI_DATA_WRITE] = { 653 .type = UE_BULK, 654 .endpoint = UE_ADDR_ANY, 655 .direction = UE_DIR_OUT, 656 .bufsize = UMASS_BULK_SIZE, 657 .flags = {.proxy_buffer = 1,.short_xfer_ok = 1, UMASS_USB_FLAGS}, 658 .callback = &umass_t_cbi_data_write_callback, 659 .timeout = 0, /* overwritten later */ 660 }, 661 662 [UMASS_T_CBI_DATA_WR_CS] = { 663 .type = UE_CONTROL, 664 .endpoint = 0x00, /* Control pipe */ 665 .direction = UE_DIR_ANY, 666 .bufsize = sizeof(struct usb_device_request), 667 .callback = &umass_t_cbi_data_wr_cs_callback, 668 .timeout = 5000, /* 5 seconds */ 669 }, 670 671 [UMASS_T_CBI_STATUS] = { 672 .type = UE_INTERRUPT, 673 .endpoint = UE_ADDR_ANY, 674 .direction = UE_DIR_IN, 675 .flags = {.short_xfer_ok = 1,.no_pipe_ok = 1,}, 676 .bufsize = sizeof(umass_cbi_sbl_t), 677 .callback = &umass_t_cbi_status_callback, 678 .timeout = 5000, /* ms */ 679 }, 680 681 [UMASS_T_CBI_RESET4] = { 682 .type = UE_CONTROL, 683 .endpoint = 0x00, /* Control pipe */ 684 .direction = UE_DIR_ANY, 685 .bufsize = sizeof(struct usb_device_request), 686 .callback = &umass_t_cbi_reset4_callback, 687 .timeout = 5000, /* ms */ 688 }, 689 }; 690 691 /* If device cannot return valid inquiry data, fake it */ 692 static const uint8_t fake_inq_data[SHORT_INQUIRY_LENGTH] = { 693 0, /* removable */ 0x80, SCSI_REV_2, SCSI_REV_2, 694 /* additional_length */ 31, 0, 0, 0 695 }; 696 697 #define UFI_COMMAND_LENGTH 12 /* UFI commands are always 12 bytes */ 698 #define ATAPI_COMMAND_LENGTH 12 /* ATAPI commands are always 12 bytes */ 699 700 static devclass_t umass_devclass; 701 702 static device_method_t umass_methods[] = { 703 /* Device interface */ 704 DEVMETHOD(device_probe, umass_probe), 705 DEVMETHOD(device_attach, umass_attach), 706 DEVMETHOD(device_detach, umass_detach), 707 {0, 0} 708 }; 709 710 static driver_t umass_driver = { 711 .name = "umass", 712 .methods = umass_methods, 713 .size = sizeof(struct umass_softc), 714 }; 715 716 DRIVER_MODULE(umass, uhub, umass_driver, umass_devclass, NULL, 0); 717 MODULE_DEPEND(umass, usb, 1, 1, 1); 718 MODULE_DEPEND(umass, cam, 1, 1, 1); 719 MODULE_VERSION(umass, 1); 720 721 /* 722 * USB device probe/attach/detach 723 */ 724 725 static uint16_t 726 umass_get_proto(struct usb_interface *iface) 727 { 728 struct usb_interface_descriptor *id; 729 uint16_t retval; 730 731 retval = 0; 732 733 /* Check for a standards compliant device */ 734 id = usbd_get_interface_descriptor(iface); 735 if ((id == NULL) || 736 (id->bInterfaceClass != UICLASS_MASS)) { 737 goto done; 738 } 739 switch (id->bInterfaceSubClass) { 740 case UISUBCLASS_SCSI: 741 retval |= UMASS_PROTO_SCSI; 742 break; 743 case UISUBCLASS_UFI: 744 retval |= UMASS_PROTO_UFI; 745 break; 746 case UISUBCLASS_RBC: 747 retval |= UMASS_PROTO_RBC; 748 break; 749 case UISUBCLASS_SFF8020I: 750 case UISUBCLASS_SFF8070I: 751 retval |= UMASS_PROTO_ATAPI; 752 break; 753 default: 754 goto done; 755 } 756 757 switch (id->bInterfaceProtocol) { 758 case UIPROTO_MASS_CBI: 759 retval |= UMASS_PROTO_CBI; 760 break; 761 case UIPROTO_MASS_CBI_I: 762 retval |= UMASS_PROTO_CBI_I; 763 break; 764 case UIPROTO_MASS_BBB_OLD: 765 case UIPROTO_MASS_BBB: 766 retval |= UMASS_PROTO_BBB; 767 break; 768 default: 769 goto done; 770 } 771 done: 772 return (retval); 773 } 774 775 /* 776 * Match the device we are seeing with the devices supported. 777 */ 778 static struct umass_probe_proto 779 umass_probe_proto(device_t dev, struct usb_attach_arg *uaa) 780 { 781 struct umass_probe_proto ret; 782 uint32_t quirks = NO_QUIRKS; 783 uint32_t proto = umass_get_proto(uaa->iface); 784 785 memset(&ret, 0, sizeof(ret)); 786 787 /* Search for protocol enforcement */ 788 789 if (usb_test_quirk(uaa, UQ_MSC_FORCE_WIRE_BBB)) { 790 proto &= ~UMASS_PROTO_WIRE; 791 proto |= UMASS_PROTO_BBB; 792 } else if (usb_test_quirk(uaa, UQ_MSC_FORCE_WIRE_CBI)) { 793 proto &= ~UMASS_PROTO_WIRE; 794 proto |= UMASS_PROTO_CBI; 795 } else if (usb_test_quirk(uaa, UQ_MSC_FORCE_WIRE_CBI_I)) { 796 proto &= ~UMASS_PROTO_WIRE; 797 proto |= UMASS_PROTO_CBI_I; 798 } 799 800 if (usb_test_quirk(uaa, UQ_MSC_FORCE_PROTO_SCSI)) { 801 proto &= ~UMASS_PROTO_COMMAND; 802 proto |= UMASS_PROTO_SCSI; 803 } else if (usb_test_quirk(uaa, UQ_MSC_FORCE_PROTO_ATAPI)) { 804 proto &= ~UMASS_PROTO_COMMAND; 805 proto |= UMASS_PROTO_ATAPI; 806 } else if (usb_test_quirk(uaa, UQ_MSC_FORCE_PROTO_UFI)) { 807 proto &= ~UMASS_PROTO_COMMAND; 808 proto |= UMASS_PROTO_UFI; 809 } else if (usb_test_quirk(uaa, UQ_MSC_FORCE_PROTO_RBC)) { 810 proto &= ~UMASS_PROTO_COMMAND; 811 proto |= UMASS_PROTO_RBC; 812 } 813 814 /* Check if the protocol is invalid */ 815 816 if ((proto & UMASS_PROTO_COMMAND) == 0) { 817 ret.error = ENXIO; 818 goto done; 819 } 820 821 if ((proto & UMASS_PROTO_WIRE) == 0) { 822 ret.error = ENXIO; 823 goto done; 824 } 825 826 /* Search for quirks */ 827 828 if (usb_test_quirk(uaa, UQ_MSC_NO_TEST_UNIT_READY)) 829 quirks |= NO_TEST_UNIT_READY; 830 if (usb_test_quirk(uaa, UQ_MSC_NO_RS_CLEAR_UA)) 831 quirks |= RS_NO_CLEAR_UA; 832 if (usb_test_quirk(uaa, UQ_MSC_NO_START_STOP)) 833 quirks |= NO_START_STOP; 834 if (usb_test_quirk(uaa, UQ_MSC_NO_GETMAXLUN)) 835 quirks |= NO_GETMAXLUN; 836 if (usb_test_quirk(uaa, UQ_MSC_NO_INQUIRY)) 837 quirks |= NO_INQUIRY; 838 if (usb_test_quirk(uaa, UQ_MSC_NO_INQUIRY_EVPD)) 839 quirks |= NO_INQUIRY_EVPD; 840 if (usb_test_quirk(uaa, UQ_MSC_NO_SYNC_CACHE)) 841 quirks |= NO_SYNCHRONIZE_CACHE; 842 if (usb_test_quirk(uaa, UQ_MSC_SHUTTLE_INIT)) 843 quirks |= SHUTTLE_INIT; 844 if (usb_test_quirk(uaa, UQ_MSC_ALT_IFACE_1)) 845 quirks |= ALT_IFACE_1; 846 if (usb_test_quirk(uaa, UQ_MSC_FLOPPY_SPEED)) 847 quirks |= FLOPPY_SPEED; 848 if (usb_test_quirk(uaa, UQ_MSC_IGNORE_RESIDUE)) 849 quirks |= IGNORE_RESIDUE; 850 if (usb_test_quirk(uaa, UQ_MSC_WRONG_CSWSIG)) 851 quirks |= WRONG_CSWSIG; 852 if (usb_test_quirk(uaa, UQ_MSC_RBC_PAD_TO_12)) 853 quirks |= RBC_PAD_TO_12; 854 if (usb_test_quirk(uaa, UQ_MSC_READ_CAP_OFFBY1)) 855 quirks |= READ_CAPACITY_OFFBY1; 856 if (usb_test_quirk(uaa, UQ_MSC_FORCE_SHORT_INQ)) 857 quirks |= FORCE_SHORT_INQUIRY; 858 859 done: 860 ret.quirks = quirks; 861 ret.proto = proto; 862 return (ret); 863 } 864 865 static int 866 umass_probe(device_t dev) 867 { 868 struct usb_attach_arg *uaa = device_get_ivars(dev); 869 struct umass_probe_proto temp; 870 871 if (uaa->usb_mode != USB_MODE_HOST) { 872 return (ENXIO); 873 } 874 if (uaa->use_generic == 0) { 875 /* give other drivers a try first */ 876 return (ENXIO); 877 } 878 temp = umass_probe_proto(dev, uaa); 879 880 return (temp.error); 881 } 882 883 static int 884 umass_attach(device_t dev) 885 { 886 struct umass_softc *sc = device_get_softc(dev); 887 struct usb_attach_arg *uaa = device_get_ivars(dev); 888 struct umass_probe_proto temp = umass_probe_proto(dev, uaa); 889 struct usb_interface_descriptor *id; 890 int32_t err; 891 892 /* 893 * NOTE: the softc struct is bzero-ed in device_set_driver. 894 * We can safely call umass_detach without specifically 895 * initializing the struct. 896 */ 897 898 sc->sc_dev = dev; 899 sc->sc_udev = uaa->device; 900 sc->sc_proto = temp.proto; 901 sc->sc_quirks = temp.quirks; 902 sc->sc_unit = device_get_unit(dev); 903 904 snprintf(sc->sc_name, sizeof(sc->sc_name), 905 "%s", device_get_nameunit(dev)); 906 907 device_set_usb_desc(dev); 908 909 mtx_init(&sc->sc_mtx, device_get_nameunit(dev), 910 NULL, MTX_DEF | MTX_RECURSE); 911 912 /* get interface index */ 913 914 id = usbd_get_interface_descriptor(uaa->iface); 915 if (id == NULL) { 916 device_printf(dev, "failed to get " 917 "interface number\n"); 918 goto detach; 919 } 920 sc->sc_iface_no = id->bInterfaceNumber; 921 922 #ifdef USB_DEBUG 923 device_printf(dev, " "); 924 925 switch (sc->sc_proto & UMASS_PROTO_COMMAND) { 926 case UMASS_PROTO_SCSI: 927 printf("SCSI"); 928 break; 929 case UMASS_PROTO_ATAPI: 930 printf("8070i (ATAPI)"); 931 break; 932 case UMASS_PROTO_UFI: 933 printf("UFI"); 934 break; 935 case UMASS_PROTO_RBC: 936 printf("RBC"); 937 break; 938 default: 939 printf("(unknown 0x%02x)", 940 sc->sc_proto & UMASS_PROTO_COMMAND); 941 break; 942 } 943 944 printf(" over "); 945 946 switch (sc->sc_proto & UMASS_PROTO_WIRE) { 947 case UMASS_PROTO_BBB: 948 printf("Bulk-Only"); 949 break; 950 case UMASS_PROTO_CBI: /* uses Comand/Bulk pipes */ 951 printf("CBI"); 952 break; 953 case UMASS_PROTO_CBI_I: /* uses Comand/Bulk/Interrupt pipes */ 954 printf("CBI with CCI"); 955 break; 956 default: 957 printf("(unknown 0x%02x)", 958 sc->sc_proto & UMASS_PROTO_WIRE); 959 } 960 961 printf("; quirks = 0x%04x\n", sc->sc_quirks); 962 #endif 963 964 if (sc->sc_quirks & ALT_IFACE_1) { 965 err = usbd_set_alt_interface_index 966 (uaa->device, uaa->info.bIfaceIndex, 1); 967 968 if (err) { 969 DPRINTF(sc, UDMASS_USB, "could not switch to " 970 "Alt Interface 1\n"); 971 goto detach; 972 } 973 } 974 /* allocate all required USB transfers */ 975 976 if (sc->sc_proto & UMASS_PROTO_BBB) { 977 978 err = usbd_transfer_setup(uaa->device, 979 &uaa->info.bIfaceIndex, sc->sc_xfer, umass_bbb_config, 980 UMASS_T_BBB_MAX, sc, &sc->sc_mtx); 981 982 /* skip reset first time */ 983 sc->sc_last_xfer_index = UMASS_T_BBB_COMMAND; 984 985 } else if (sc->sc_proto & (UMASS_PROTO_CBI | UMASS_PROTO_CBI_I)) { 986 987 err = usbd_transfer_setup(uaa->device, 988 &uaa->info.bIfaceIndex, sc->sc_xfer, umass_cbi_config, 989 UMASS_T_CBI_MAX, sc, &sc->sc_mtx); 990 991 /* skip reset first time */ 992 sc->sc_last_xfer_index = UMASS_T_CBI_COMMAND; 993 994 } else { 995 err = USB_ERR_INVAL; 996 } 997 998 if (err) { 999 device_printf(dev, "could not setup required " 1000 "transfers, %s\n", usbd_errstr(err)); 1001 goto detach; 1002 } 1003 sc->sc_transform = 1004 (sc->sc_proto & UMASS_PROTO_SCSI) ? &umass_scsi_transform : 1005 (sc->sc_proto & UMASS_PROTO_UFI) ? &umass_ufi_transform : 1006 (sc->sc_proto & UMASS_PROTO_ATAPI) ? &umass_atapi_transform : 1007 (sc->sc_proto & UMASS_PROTO_RBC) ? &umass_rbc_transform : 1008 &umass_no_transform; 1009 1010 /* from here onwards the device can be used. */ 1011 1012 if (sc->sc_quirks & SHUTTLE_INIT) { 1013 umass_init_shuttle(sc); 1014 } 1015 /* get the maximum LUN supported by the device */ 1016 1017 if (((sc->sc_proto & UMASS_PROTO_WIRE) == UMASS_PROTO_BBB) && 1018 !(sc->sc_quirks & NO_GETMAXLUN)) 1019 sc->sc_maxlun = umass_bbb_get_max_lun(sc); 1020 else 1021 sc->sc_maxlun = 0; 1022 1023 /* Prepare the SCSI command block */ 1024 sc->cam_scsi_sense.opcode = REQUEST_SENSE; 1025 sc->cam_scsi_test_unit_ready.opcode = TEST_UNIT_READY; 1026 1027 /* 1028 * some devices need a delay after that the configuration value is 1029 * set to function properly: 1030 */ 1031 usb_pause_mtx(NULL, hz); 1032 1033 /* register the SIM */ 1034 err = umass_cam_attach_sim(sc); 1035 if (err) { 1036 goto detach; 1037 } 1038 /* scan the SIM */ 1039 umass_cam_attach(sc); 1040 1041 DPRINTF(sc, UDMASS_GEN, "Attach finished\n"); 1042 1043 return (0); /* success */ 1044 1045 detach: 1046 umass_detach(dev); 1047 return (ENXIO); /* failure */ 1048 } 1049 1050 static int 1051 umass_detach(device_t dev) 1052 { 1053 struct umass_softc *sc = device_get_softc(dev); 1054 1055 DPRINTF(sc, UDMASS_USB, "\n"); 1056 1057 /* teardown our statemachine */ 1058 1059 usbd_transfer_unsetup(sc->sc_xfer, UMASS_T_MAX); 1060 1061 #if (__FreeBSD_version >= 700037) 1062 mtx_lock(&sc->sc_mtx); 1063 #endif 1064 umass_cam_detach_sim(sc); 1065 1066 #if (__FreeBSD_version >= 700037) 1067 mtx_unlock(&sc->sc_mtx); 1068 #endif 1069 mtx_destroy(&sc->sc_mtx); 1070 1071 return (0); /* success */ 1072 } 1073 1074 static void 1075 umass_init_shuttle(struct umass_softc *sc) 1076 { 1077 struct usb_device_request req; 1078 usb_error_t err; 1079 uint8_t status[2] = {0, 0}; 1080 1081 /* 1082 * The Linux driver does this, but no one can tell us what the 1083 * command does. 1084 */ 1085 req.bmRequestType = UT_READ_VENDOR_DEVICE; 1086 req.bRequest = 1; /* XXX unknown command */ 1087 USETW(req.wValue, 0); 1088 req.wIndex[0] = sc->sc_iface_no; 1089 req.wIndex[1] = 0; 1090 USETW(req.wLength, sizeof(status)); 1091 err = usbd_do_request(sc->sc_udev, NULL, &req, &status); 1092 1093 DPRINTF(sc, UDMASS_GEN, "Shuttle init returned 0x%02x%02x\n", 1094 status[0], status[1]); 1095 } 1096 1097 /* 1098 * Generic functions to handle transfers 1099 */ 1100 1101 static void 1102 umass_transfer_start(struct umass_softc *sc, uint8_t xfer_index) 1103 { 1104 DPRINTF(sc, UDMASS_GEN, "transfer index = " 1105 "%d\n", xfer_index); 1106 1107 if (sc->sc_xfer[xfer_index]) { 1108 sc->sc_last_xfer_index = xfer_index; 1109 usbd_transfer_start(sc->sc_xfer[xfer_index]); 1110 } else { 1111 umass_cancel_ccb(sc); 1112 } 1113 } 1114 1115 static void 1116 umass_reset(struct umass_softc *sc) 1117 { 1118 DPRINTF(sc, UDMASS_GEN, "resetting device\n"); 1119 1120 /* 1121 * stop the last transfer, if not already stopped: 1122 */ 1123 usbd_transfer_stop(sc->sc_xfer[sc->sc_last_xfer_index]); 1124 umass_transfer_start(sc, 0); 1125 } 1126 1127 static void 1128 umass_cancel_ccb(struct umass_softc *sc) 1129 { 1130 union ccb *ccb; 1131 1132 mtx_assert(&sc->sc_mtx, MA_OWNED); 1133 1134 ccb = sc->sc_transfer.ccb; 1135 sc->sc_transfer.ccb = NULL; 1136 sc->sc_last_xfer_index = 0; 1137 1138 if (ccb) { 1139 (sc->sc_transfer.callback) 1140 (sc, ccb, (sc->sc_transfer.data_len - 1141 sc->sc_transfer.actlen), STATUS_WIRE_FAILED); 1142 } 1143 } 1144 1145 static void 1146 umass_tr_error(struct usb_xfer *xfer, usb_error_t error) 1147 { 1148 struct umass_softc *sc = usbd_xfer_softc(xfer); 1149 1150 if (error != USB_ERR_CANCELLED) { 1151 1152 DPRINTF(sc, UDMASS_GEN, "transfer error, %s -> " 1153 "reset\n", usbd_errstr(error)); 1154 } 1155 umass_cancel_ccb(sc); 1156 } 1157 1158 /* 1159 * BBB protocol specific functions 1160 */ 1161 1162 static void 1163 umass_t_bbb_reset1_callback(struct usb_xfer *xfer, usb_error_t error) 1164 { 1165 struct umass_softc *sc = usbd_xfer_softc(xfer); 1166 struct usb_device_request req; 1167 struct usb_page_cache *pc; 1168 1169 switch (USB_GET_STATE(xfer)) { 1170 case USB_ST_TRANSFERRED: 1171 umass_transfer_start(sc, UMASS_T_BBB_RESET2); 1172 return; 1173 1174 case USB_ST_SETUP: 1175 /* 1176 * Reset recovery (5.3.4 in Universal Serial Bus Mass Storage Class) 1177 * 1178 * For Reset Recovery the host shall issue in the following order: 1179 * a) a Bulk-Only Mass Storage Reset 1180 * b) a Clear Feature HALT to the Bulk-In endpoint 1181 * c) a Clear Feature HALT to the Bulk-Out endpoint 1182 * 1183 * This is done in 3 steps, using 3 transfers: 1184 * UMASS_T_BBB_RESET1 1185 * UMASS_T_BBB_RESET2 1186 * UMASS_T_BBB_RESET3 1187 */ 1188 1189 DPRINTF(sc, UDMASS_BBB, "BBB reset!\n"); 1190 1191 req.bmRequestType = UT_WRITE_CLASS_INTERFACE; 1192 req.bRequest = UR_BBB_RESET; /* bulk only reset */ 1193 USETW(req.wValue, 0); 1194 req.wIndex[0] = sc->sc_iface_no; 1195 req.wIndex[1] = 0; 1196 USETW(req.wLength, 0); 1197 1198 pc = usbd_xfer_get_frame(xfer, 0); 1199 usbd_copy_in(pc, 0, &req, sizeof(req)); 1200 1201 usbd_xfer_set_frame_len(xfer, 0, sizeof(req)); 1202 usbd_xfer_set_frames(xfer, 1); 1203 usbd_transfer_submit(xfer); 1204 return; 1205 1206 default: /* Error */ 1207 umass_tr_error(xfer, error); 1208 return; 1209 1210 } 1211 } 1212 1213 static void 1214 umass_t_bbb_reset2_callback(struct usb_xfer *xfer, usb_error_t error) 1215 { 1216 umass_t_bbb_data_clear_stall_callback(xfer, UMASS_T_BBB_RESET3, 1217 UMASS_T_BBB_DATA_READ, error); 1218 } 1219 1220 static void 1221 umass_t_bbb_reset3_callback(struct usb_xfer *xfer, usb_error_t error) 1222 { 1223 umass_t_bbb_data_clear_stall_callback(xfer, UMASS_T_BBB_COMMAND, 1224 UMASS_T_BBB_DATA_WRITE, error); 1225 } 1226 1227 static void 1228 umass_t_bbb_data_clear_stall_callback(struct usb_xfer *xfer, 1229 uint8_t next_xfer, uint8_t stall_xfer, usb_error_t error) 1230 { 1231 struct umass_softc *sc = usbd_xfer_softc(xfer); 1232 1233 switch (USB_GET_STATE(xfer)) { 1234 case USB_ST_TRANSFERRED: 1235 tr_transferred: 1236 umass_transfer_start(sc, next_xfer); 1237 return; 1238 1239 case USB_ST_SETUP: 1240 if (usbd_clear_stall_callback(xfer, sc->sc_xfer[stall_xfer])) { 1241 goto tr_transferred; 1242 } 1243 return; 1244 1245 default: /* Error */ 1246 umass_tr_error(xfer, error); 1247 return; 1248 1249 } 1250 } 1251 1252 static void 1253 umass_t_bbb_command_callback(struct usb_xfer *xfer, usb_error_t error) 1254 { 1255 struct umass_softc *sc = usbd_xfer_softc(xfer); 1256 union ccb *ccb = sc->sc_transfer.ccb; 1257 struct usb_page_cache *pc; 1258 uint32_t tag; 1259 1260 switch (USB_GET_STATE(xfer)) { 1261 case USB_ST_TRANSFERRED: 1262 umass_transfer_start 1263 (sc, ((sc->sc_transfer.dir == DIR_IN) ? UMASS_T_BBB_DATA_READ : 1264 (sc->sc_transfer.dir == DIR_OUT) ? UMASS_T_BBB_DATA_WRITE : 1265 UMASS_T_BBB_STATUS)); 1266 return; 1267 1268 case USB_ST_SETUP: 1269 1270 sc->sc_status_try = 0; 1271 1272 if (ccb) { 1273 1274 /* 1275 * the initial value is not important, 1276 * as long as the values are unique: 1277 */ 1278 tag = UGETDW(sc->cbw.dCBWTag) + 1; 1279 1280 USETDW(sc->cbw.dCBWSignature, CBWSIGNATURE); 1281 USETDW(sc->cbw.dCBWTag, tag); 1282 1283 /* 1284 * dCBWDataTransferLength: 1285 * This field indicates the number of bytes of data that the host 1286 * intends to transfer on the IN or OUT Bulk endpoint(as indicated by 1287 * the Direction bit) during the execution of this command. If this 1288 * field is set to 0, the device will expect that no data will be 1289 * transferred IN or OUT during this command, regardless of the value 1290 * of the Direction bit defined in dCBWFlags. 1291 */ 1292 USETDW(sc->cbw.dCBWDataTransferLength, sc->sc_transfer.data_len); 1293 1294 /* 1295 * dCBWFlags: 1296 * The bits of the Flags field are defined as follows: 1297 * Bits 0-6 reserved 1298 * Bit 7 Direction - this bit shall be ignored if the 1299 * dCBWDataTransferLength field is zero. 1300 * 0 = data Out from host to device 1301 * 1 = data In from device to host 1302 */ 1303 sc->cbw.bCBWFlags = ((sc->sc_transfer.dir == DIR_IN) ? 1304 CBWFLAGS_IN : CBWFLAGS_OUT); 1305 sc->cbw.bCBWLUN = sc->sc_transfer.lun; 1306 1307 if (sc->sc_transfer.cmd_len > sizeof(sc->cbw.CBWCDB)) { 1308 sc->sc_transfer.cmd_len = sizeof(sc->cbw.CBWCDB); 1309 DPRINTF(sc, UDMASS_BBB, "Truncating long command!\n"); 1310 } 1311 sc->cbw.bCDBLength = sc->sc_transfer.cmd_len; 1312 1313 bcopy(sc->sc_transfer.cmd_data, sc->cbw.CBWCDB, 1314 sc->sc_transfer.cmd_len); 1315 1316 bzero(sc->sc_transfer.cmd_data + sc->sc_transfer.cmd_len, 1317 sizeof(sc->cbw.CBWCDB) - sc->sc_transfer.cmd_len); 1318 1319 DIF(UDMASS_BBB, umass_bbb_dump_cbw(sc, &sc->cbw)); 1320 1321 pc = usbd_xfer_get_frame(xfer, 0); 1322 usbd_copy_in(pc, 0, &sc->cbw, sizeof(sc->cbw)); 1323 usbd_xfer_set_frame_len(xfer, 0, sizeof(sc->cbw)); 1324 1325 usbd_transfer_submit(xfer); 1326 } 1327 return; 1328 1329 default: /* Error */ 1330 umass_tr_error(xfer, error); 1331 return; 1332 1333 } 1334 } 1335 1336 static void 1337 umass_t_bbb_data_read_callback(struct usb_xfer *xfer, usb_error_t error) 1338 { 1339 struct umass_softc *sc = usbd_xfer_softc(xfer); 1340 uint32_t max_bulk = usbd_xfer_max_len(xfer); 1341 #ifndef UMASS_EXT_BUFFER 1342 struct usb_page_cache *pc; 1343 #endif 1344 int actlen, sumlen; 1345 1346 usbd_xfer_status(xfer, &actlen, &sumlen, NULL, NULL); 1347 1348 switch (USB_GET_STATE(xfer)) { 1349 case USB_ST_TRANSFERRED: 1350 #ifndef UMASS_EXT_BUFFER 1351 pc = usbd_xfer_get_frame(xfer, 0); 1352 usbd_copy_out(pc, 0, sc->sc_transfer.data_ptr, actlen); 1353 #endif 1354 sc->sc_transfer.data_rem -= actlen; 1355 sc->sc_transfer.data_ptr += actlen; 1356 sc->sc_transfer.actlen += actlen; 1357 1358 if (actlen < sumlen) { 1359 /* short transfer */ 1360 sc->sc_transfer.data_rem = 0; 1361 } 1362 case USB_ST_SETUP: 1363 DPRINTF(sc, UDMASS_BBB, "max_bulk=%d, data_rem=%d\n", 1364 max_bulk, sc->sc_transfer.data_rem); 1365 1366 if (sc->sc_transfer.data_rem == 0) { 1367 umass_transfer_start(sc, UMASS_T_BBB_STATUS); 1368 return; 1369 } 1370 if (max_bulk > sc->sc_transfer.data_rem) { 1371 max_bulk = sc->sc_transfer.data_rem; 1372 } 1373 usbd_xfer_set_timeout(xfer, sc->sc_transfer.data_timeout); 1374 1375 #ifdef UMASS_EXT_BUFFER 1376 usbd_xfer_set_frame_data(xfer, 0, sc->sc_transfer.data_ptr, 1377 max_bulk); 1378 #else 1379 usbd_xfer_set_frame_len(xfer, 0, max_bulk); 1380 #endif 1381 usbd_transfer_submit(xfer); 1382 return; 1383 1384 default: /* Error */ 1385 if (error == USB_ERR_CANCELLED) { 1386 umass_tr_error(xfer, error); 1387 } else { 1388 umass_transfer_start(sc, UMASS_T_BBB_DATA_RD_CS); 1389 } 1390 return; 1391 1392 } 1393 } 1394 1395 static void 1396 umass_t_bbb_data_rd_cs_callback(struct usb_xfer *xfer, usb_error_t error) 1397 { 1398 umass_t_bbb_data_clear_stall_callback(xfer, UMASS_T_BBB_STATUS, 1399 UMASS_T_BBB_DATA_READ, error); 1400 } 1401 1402 static void 1403 umass_t_bbb_data_write_callback(struct usb_xfer *xfer, usb_error_t error) 1404 { 1405 struct umass_softc *sc = usbd_xfer_softc(xfer); 1406 uint32_t max_bulk = usbd_xfer_max_len(xfer); 1407 #ifndef UMASS_EXT_BUFFER 1408 struct usb_page_cache *pc; 1409 #endif 1410 int actlen, sumlen; 1411 1412 usbd_xfer_status(xfer, &actlen, &sumlen, NULL, NULL); 1413 1414 switch (USB_GET_STATE(xfer)) { 1415 case USB_ST_TRANSFERRED: 1416 sc->sc_transfer.data_rem -= actlen; 1417 sc->sc_transfer.data_ptr += actlen; 1418 sc->sc_transfer.actlen += actlen; 1419 1420 if (actlen < sumlen) { 1421 /* short transfer */ 1422 sc->sc_transfer.data_rem = 0; 1423 } 1424 case USB_ST_SETUP: 1425 DPRINTF(sc, UDMASS_BBB, "max_bulk=%d, data_rem=%d\n", 1426 max_bulk, sc->sc_transfer.data_rem); 1427 1428 if (sc->sc_transfer.data_rem == 0) { 1429 umass_transfer_start(sc, UMASS_T_BBB_STATUS); 1430 return; 1431 } 1432 if (max_bulk > sc->sc_transfer.data_rem) { 1433 max_bulk = sc->sc_transfer.data_rem; 1434 } 1435 usbd_xfer_set_timeout(xfer, sc->sc_transfer.data_timeout); 1436 1437 #ifdef UMASS_EXT_BUFFER 1438 usbd_xfer_set_frame_data(xfer, 0, sc->sc_transfer.data_ptr, 1439 max_bulk); 1440 #else 1441 pc = usbd_xfer_get_frame(xfer, 0); 1442 usbd_copy_in(pc, 0, sc->sc_transfer.data_ptr, max_bulk); 1443 usbd_xfer_set_frame_len(xfer, 0, max_bulk); 1444 #endif 1445 1446 usbd_transfer_submit(xfer); 1447 return; 1448 1449 default: /* Error */ 1450 if (error == USB_ERR_CANCELLED) { 1451 umass_tr_error(xfer, error); 1452 } else { 1453 umass_transfer_start(sc, UMASS_T_BBB_DATA_WR_CS); 1454 } 1455 return; 1456 1457 } 1458 } 1459 1460 static void 1461 umass_t_bbb_data_wr_cs_callback(struct usb_xfer *xfer, usb_error_t error) 1462 { 1463 umass_t_bbb_data_clear_stall_callback(xfer, UMASS_T_BBB_STATUS, 1464 UMASS_T_BBB_DATA_WRITE, error); 1465 } 1466 1467 static void 1468 umass_t_bbb_status_callback(struct usb_xfer *xfer, usb_error_t error) 1469 { 1470 struct umass_softc *sc = usbd_xfer_softc(xfer); 1471 union ccb *ccb = sc->sc_transfer.ccb; 1472 struct usb_page_cache *pc; 1473 uint32_t residue; 1474 int actlen; 1475 1476 usbd_xfer_status(xfer, &actlen, NULL, NULL, NULL); 1477 1478 switch (USB_GET_STATE(xfer)) { 1479 case USB_ST_TRANSFERRED: 1480 1481 /* 1482 * Do a full reset if there is something wrong with the CSW: 1483 */ 1484 sc->sc_status_try = 1; 1485 1486 /* Zero missing parts of the CSW: */ 1487 1488 if (actlen < sizeof(sc->csw)) { 1489 bzero(&sc->csw, sizeof(sc->csw)); 1490 } 1491 pc = usbd_xfer_get_frame(xfer, 0); 1492 usbd_copy_out(pc, 0, &sc->csw, actlen); 1493 1494 DIF(UDMASS_BBB, umass_bbb_dump_csw(sc, &sc->csw)); 1495 1496 residue = UGETDW(sc->csw.dCSWDataResidue); 1497 1498 if ((!residue) || (sc->sc_quirks & IGNORE_RESIDUE)) { 1499 residue = (sc->sc_transfer.data_len - 1500 sc->sc_transfer.actlen); 1501 } 1502 if (residue > sc->sc_transfer.data_len) { 1503 DPRINTF(sc, UDMASS_BBB, "truncating residue from %d " 1504 "to %d bytes\n", residue, sc->sc_transfer.data_len); 1505 residue = sc->sc_transfer.data_len; 1506 } 1507 /* translate weird command-status signatures: */ 1508 if (sc->sc_quirks & WRONG_CSWSIG) { 1509 1510 uint32_t temp = UGETDW(sc->csw.dCSWSignature); 1511 1512 if ((temp == CSWSIGNATURE_OLYMPUS_C1) || 1513 (temp == CSWSIGNATURE_IMAGINATION_DBX1)) { 1514 USETDW(sc->csw.dCSWSignature, CSWSIGNATURE); 1515 } 1516 } 1517 /* check CSW and handle eventual error */ 1518 if (UGETDW(sc->csw.dCSWSignature) != CSWSIGNATURE) { 1519 DPRINTF(sc, UDMASS_BBB, "bad CSW signature 0x%08x != 0x%08x\n", 1520 UGETDW(sc->csw.dCSWSignature), CSWSIGNATURE); 1521 /* 1522 * Invalid CSW: Wrong signature or wrong tag might 1523 * indicate that we lost synchronization. Reset the 1524 * device. 1525 */ 1526 goto tr_error; 1527 } else if (UGETDW(sc->csw.dCSWTag) != UGETDW(sc->cbw.dCBWTag)) { 1528 DPRINTF(sc, UDMASS_BBB, "Invalid CSW: tag 0x%08x should be " 1529 "0x%08x\n", UGETDW(sc->csw.dCSWTag), 1530 UGETDW(sc->cbw.dCBWTag)); 1531 goto tr_error; 1532 } else if (sc->csw.bCSWStatus > CSWSTATUS_PHASE) { 1533 DPRINTF(sc, UDMASS_BBB, "Invalid CSW: status %d > %d\n", 1534 sc->csw.bCSWStatus, CSWSTATUS_PHASE); 1535 goto tr_error; 1536 } else if (sc->csw.bCSWStatus == CSWSTATUS_PHASE) { 1537 DPRINTF(sc, UDMASS_BBB, "Phase error, residue = " 1538 "%d\n", residue); 1539 goto tr_error; 1540 } else if (sc->sc_transfer.actlen > sc->sc_transfer.data_len) { 1541 DPRINTF(sc, UDMASS_BBB, "Buffer overrun %d > %d\n", 1542 sc->sc_transfer.actlen, sc->sc_transfer.data_len); 1543 goto tr_error; 1544 } else if (sc->csw.bCSWStatus == CSWSTATUS_FAILED) { 1545 DPRINTF(sc, UDMASS_BBB, "Command failed, residue = " 1546 "%d\n", residue); 1547 1548 sc->sc_transfer.ccb = NULL; 1549 1550 sc->sc_last_xfer_index = UMASS_T_BBB_COMMAND; 1551 1552 (sc->sc_transfer.callback) 1553 (sc, ccb, residue, STATUS_CMD_FAILED); 1554 } else { 1555 sc->sc_transfer.ccb = NULL; 1556 1557 sc->sc_last_xfer_index = UMASS_T_BBB_COMMAND; 1558 1559 (sc->sc_transfer.callback) 1560 (sc, ccb, residue, STATUS_CMD_OK); 1561 } 1562 return; 1563 1564 case USB_ST_SETUP: 1565 usbd_xfer_set_frame_len(xfer, 0, usbd_xfer_max_len(xfer)); 1566 usbd_transfer_submit(xfer); 1567 return; 1568 1569 default: 1570 tr_error: 1571 DPRINTF(sc, UDMASS_BBB, "Failed to read CSW: %s, try %d\n", 1572 usbd_errstr(error), sc->sc_status_try); 1573 1574 if ((error == USB_ERR_CANCELLED) || 1575 (sc->sc_status_try)) { 1576 umass_tr_error(xfer, error); 1577 } else { 1578 sc->sc_status_try = 1; 1579 umass_transfer_start(sc, UMASS_T_BBB_DATA_RD_CS); 1580 } 1581 return; 1582 1583 } 1584 } 1585 1586 static void 1587 umass_command_start(struct umass_softc *sc, uint8_t dir, 1588 void *data_ptr, uint32_t data_len, 1589 uint32_t data_timeout, umass_callback_t *callback, 1590 union ccb *ccb) 1591 { 1592 sc->sc_transfer.lun = ccb->ccb_h.target_lun; 1593 1594 /* 1595 * NOTE: assumes that "sc->sc_transfer.cmd_data" and 1596 * "sc->sc_transfer.cmd_len" has been properly 1597 * initialized. 1598 */ 1599 1600 sc->sc_transfer.dir = data_len ? dir : DIR_NONE; 1601 sc->sc_transfer.data_ptr = data_ptr; 1602 sc->sc_transfer.data_len = data_len; 1603 sc->sc_transfer.data_rem = data_len; 1604 sc->sc_transfer.data_timeout = (data_timeout + UMASS_TIMEOUT); 1605 1606 sc->sc_transfer.actlen = 0; 1607 sc->sc_transfer.callback = callback; 1608 sc->sc_transfer.ccb = ccb; 1609 1610 if (sc->sc_xfer[sc->sc_last_xfer_index]) { 1611 usbd_transfer_start(sc->sc_xfer[sc->sc_last_xfer_index]); 1612 } else { 1613 ccb->ccb_h.status = CAM_TID_INVALID; 1614 xpt_done(ccb); 1615 } 1616 } 1617 1618 static uint8_t 1619 umass_bbb_get_max_lun(struct umass_softc *sc) 1620 { 1621 struct usb_device_request req; 1622 usb_error_t err; 1623 uint8_t buf = 0; 1624 1625 /* The Get Max Lun command is a class-specific request. */ 1626 req.bmRequestType = UT_READ_CLASS_INTERFACE; 1627 req.bRequest = UR_BBB_GET_MAX_LUN; 1628 USETW(req.wValue, 0); 1629 req.wIndex[0] = sc->sc_iface_no; 1630 req.wIndex[1] = 0; 1631 USETW(req.wLength, 1); 1632 1633 err = usbd_do_request(sc->sc_udev, NULL, &req, &buf); 1634 if (err) { 1635 buf = 0; 1636 1637 /* Device doesn't support Get Max Lun request. */ 1638 printf("%s: Get Max Lun not supported (%s)\n", 1639 sc->sc_name, usbd_errstr(err)); 1640 } 1641 return (buf); 1642 } 1643 1644 /* 1645 * Command/Bulk/Interrupt (CBI) specific functions 1646 */ 1647 1648 static void 1649 umass_cbi_start_status(struct umass_softc *sc) 1650 { 1651 if (sc->sc_xfer[UMASS_T_CBI_STATUS]) { 1652 umass_transfer_start(sc, UMASS_T_CBI_STATUS); 1653 } else { 1654 union ccb *ccb = sc->sc_transfer.ccb; 1655 1656 sc->sc_transfer.ccb = NULL; 1657 1658 sc->sc_last_xfer_index = UMASS_T_CBI_COMMAND; 1659 1660 (sc->sc_transfer.callback) 1661 (sc, ccb, (sc->sc_transfer.data_len - 1662 sc->sc_transfer.actlen), STATUS_CMD_UNKNOWN); 1663 } 1664 } 1665 1666 static void 1667 umass_t_cbi_reset1_callback(struct usb_xfer *xfer, usb_error_t error) 1668 { 1669 struct umass_softc *sc = usbd_xfer_softc(xfer); 1670 struct usb_device_request req; 1671 struct usb_page_cache *pc; 1672 uint8_t buf[UMASS_CBI_DIAGNOSTIC_CMDLEN]; 1673 1674 uint8_t i; 1675 1676 switch (USB_GET_STATE(xfer)) { 1677 case USB_ST_TRANSFERRED: 1678 umass_transfer_start(sc, UMASS_T_CBI_RESET2); 1679 break; 1680 1681 case USB_ST_SETUP: 1682 /* 1683 * Command Block Reset Protocol 1684 * 1685 * First send a reset request to the device. Then clear 1686 * any possibly stalled bulk endpoints. 1687 * 1688 * This is done in 3 steps, using 3 transfers: 1689 * UMASS_T_CBI_RESET1 1690 * UMASS_T_CBI_RESET2 1691 * UMASS_T_CBI_RESET3 1692 * UMASS_T_CBI_RESET4 (only if there is an interrupt endpoint) 1693 */ 1694 1695 DPRINTF(sc, UDMASS_CBI, "CBI reset!\n"); 1696 1697 req.bmRequestType = UT_WRITE_CLASS_INTERFACE; 1698 req.bRequest = UR_CBI_ADSC; 1699 USETW(req.wValue, 0); 1700 req.wIndex[0] = sc->sc_iface_no; 1701 req.wIndex[1] = 0; 1702 USETW(req.wLength, UMASS_CBI_DIAGNOSTIC_CMDLEN); 1703 1704 /* 1705 * The 0x1d code is the SEND DIAGNOSTIC command. To 1706 * distinguish between the two, the last 10 bytes of the CBL 1707 * is filled with 0xff (section 2.2 of the CBI 1708 * specification) 1709 */ 1710 buf[0] = 0x1d; /* Command Block Reset */ 1711 buf[1] = 0x04; 1712 1713 for (i = 2; i < UMASS_CBI_DIAGNOSTIC_CMDLEN; i++) { 1714 buf[i] = 0xff; 1715 } 1716 1717 pc = usbd_xfer_get_frame(xfer, 0); 1718 usbd_copy_in(pc, 0, &req, sizeof(req)); 1719 pc = usbd_xfer_get_frame(xfer, 1); 1720 usbd_copy_in(pc, 0, buf, sizeof(buf)); 1721 1722 usbd_xfer_set_frame_len(xfer, 0, sizeof(req)); 1723 usbd_xfer_set_frame_len(xfer, 1, sizeof(buf)); 1724 usbd_xfer_set_frames(xfer, 2); 1725 usbd_transfer_submit(xfer); 1726 break; 1727 1728 default: /* Error */ 1729 if (error == USB_ERR_CANCELLED) 1730 umass_tr_error(xfer, error); 1731 else 1732 umass_transfer_start(sc, UMASS_T_CBI_RESET2); 1733 break; 1734 1735 } 1736 } 1737 1738 static void 1739 umass_t_cbi_reset2_callback(struct usb_xfer *xfer, usb_error_t error) 1740 { 1741 umass_t_cbi_data_clear_stall_callback(xfer, UMASS_T_CBI_RESET3, 1742 UMASS_T_CBI_DATA_READ, error); 1743 } 1744 1745 static void 1746 umass_t_cbi_reset3_callback(struct usb_xfer *xfer, usb_error_t error) 1747 { 1748 struct umass_softc *sc = usbd_xfer_softc(xfer); 1749 1750 umass_t_cbi_data_clear_stall_callback 1751 (xfer, (sc->sc_xfer[UMASS_T_CBI_RESET4] && 1752 sc->sc_xfer[UMASS_T_CBI_STATUS]) ? 1753 UMASS_T_CBI_RESET4 : UMASS_T_CBI_COMMAND, 1754 UMASS_T_CBI_DATA_WRITE, error); 1755 } 1756 1757 static void 1758 umass_t_cbi_reset4_callback(struct usb_xfer *xfer, usb_error_t error) 1759 { 1760 umass_t_cbi_data_clear_stall_callback(xfer, UMASS_T_CBI_COMMAND, 1761 UMASS_T_CBI_STATUS, error); 1762 } 1763 1764 static void 1765 umass_t_cbi_data_clear_stall_callback(struct usb_xfer *xfer, 1766 uint8_t next_xfer, uint8_t stall_xfer, usb_error_t error) 1767 { 1768 struct umass_softc *sc = usbd_xfer_softc(xfer); 1769 1770 switch (USB_GET_STATE(xfer)) { 1771 case USB_ST_TRANSFERRED: 1772 tr_transferred: 1773 if (next_xfer == UMASS_T_CBI_STATUS) { 1774 umass_cbi_start_status(sc); 1775 } else { 1776 umass_transfer_start(sc, next_xfer); 1777 } 1778 break; 1779 1780 case USB_ST_SETUP: 1781 if (usbd_clear_stall_callback(xfer, sc->sc_xfer[stall_xfer])) { 1782 goto tr_transferred; /* should not happen */ 1783 } 1784 break; 1785 1786 default: /* Error */ 1787 umass_tr_error(xfer, error); 1788 break; 1789 1790 } 1791 } 1792 1793 static void 1794 umass_t_cbi_command_callback(struct usb_xfer *xfer, usb_error_t error) 1795 { 1796 struct umass_softc *sc = usbd_xfer_softc(xfer); 1797 union ccb *ccb = sc->sc_transfer.ccb; 1798 struct usb_device_request req; 1799 struct usb_page_cache *pc; 1800 1801 switch (USB_GET_STATE(xfer)) { 1802 case USB_ST_TRANSFERRED: 1803 1804 if (sc->sc_transfer.dir == DIR_NONE) { 1805 umass_cbi_start_status(sc); 1806 } else { 1807 umass_transfer_start 1808 (sc, (sc->sc_transfer.dir == DIR_IN) ? 1809 UMASS_T_CBI_DATA_READ : UMASS_T_CBI_DATA_WRITE); 1810 } 1811 break; 1812 1813 case USB_ST_SETUP: 1814 1815 if (ccb) { 1816 1817 /* 1818 * do a CBI transfer with cmd_len bytes from 1819 * cmd_data, possibly a data phase of data_len 1820 * bytes from/to the device and finally a status 1821 * read phase. 1822 */ 1823 1824 req.bmRequestType = UT_WRITE_CLASS_INTERFACE; 1825 req.bRequest = UR_CBI_ADSC; 1826 USETW(req.wValue, 0); 1827 req.wIndex[0] = sc->sc_iface_no; 1828 req.wIndex[1] = 0; 1829 req.wLength[0] = sc->sc_transfer.cmd_len; 1830 req.wLength[1] = 0; 1831 1832 pc = usbd_xfer_get_frame(xfer, 0); 1833 usbd_copy_in(pc, 0, &req, sizeof(req)); 1834 pc = usbd_xfer_get_frame(xfer, 1); 1835 usbd_copy_in(pc, 0, sc->sc_transfer.cmd_data, 1836 sc->sc_transfer.cmd_len); 1837 1838 usbd_xfer_set_frame_len(xfer, 0, sizeof(req)); 1839 usbd_xfer_set_frame_len(xfer, 1, sc->sc_transfer.cmd_len); 1840 usbd_xfer_set_frames(xfer, 1841 sc->sc_transfer.cmd_len ? 2 : 1); 1842 1843 DIF(UDMASS_CBI, 1844 umass_cbi_dump_cmd(sc, 1845 sc->sc_transfer.cmd_data, 1846 sc->sc_transfer.cmd_len)); 1847 1848 usbd_transfer_submit(xfer); 1849 } 1850 break; 1851 1852 default: /* Error */ 1853 umass_tr_error(xfer, error); 1854 /* skip reset */ 1855 sc->sc_last_xfer_index = UMASS_T_CBI_COMMAND; 1856 break; 1857 } 1858 } 1859 1860 static void 1861 umass_t_cbi_data_read_callback(struct usb_xfer *xfer, usb_error_t error) 1862 { 1863 struct umass_softc *sc = usbd_xfer_softc(xfer); 1864 uint32_t max_bulk = usbd_xfer_max_len(xfer); 1865 #ifndef UMASS_EXT_BUFFER 1866 struct usb_page_cache *pc; 1867 #endif 1868 int actlen, sumlen; 1869 1870 usbd_xfer_status(xfer, &actlen, &sumlen, NULL, NULL); 1871 1872 switch (USB_GET_STATE(xfer)) { 1873 case USB_ST_TRANSFERRED: 1874 #ifndef UMASS_EXT_BUFFER 1875 pc = usbd_xfer_get_frame(xfer, 0); 1876 usbd_copy_out(pc, 0, sc->sc_transfer.data_ptr, actlen); 1877 #endif 1878 sc->sc_transfer.data_rem -= actlen; 1879 sc->sc_transfer.data_ptr += actlen; 1880 sc->sc_transfer.actlen += actlen; 1881 1882 if (actlen < sumlen) { 1883 /* short transfer */ 1884 sc->sc_transfer.data_rem = 0; 1885 } 1886 case USB_ST_SETUP: 1887 DPRINTF(sc, UDMASS_CBI, "max_bulk=%d, data_rem=%d\n", 1888 max_bulk, sc->sc_transfer.data_rem); 1889 1890 if (sc->sc_transfer.data_rem == 0) { 1891 umass_cbi_start_status(sc); 1892 break; 1893 } 1894 if (max_bulk > sc->sc_transfer.data_rem) { 1895 max_bulk = sc->sc_transfer.data_rem; 1896 } 1897 usbd_xfer_set_timeout(xfer, sc->sc_transfer.data_timeout); 1898 1899 #ifdef UMASS_EXT_BUFFER 1900 usbd_xfer_set_frame_data(xfer, 0, sc->sc_transfer.data_ptr, 1901 max_bulk); 1902 #else 1903 usbd_xfer_set_frame_len(xfer, 0, max_bulk); 1904 #endif 1905 usbd_transfer_submit(xfer); 1906 break; 1907 1908 default: /* Error */ 1909 if ((error == USB_ERR_CANCELLED) || 1910 (sc->sc_transfer.callback != &umass_cam_cb)) { 1911 umass_tr_error(xfer, error); 1912 } else { 1913 umass_transfer_start(sc, UMASS_T_CBI_DATA_RD_CS); 1914 } 1915 break; 1916 1917 } 1918 } 1919 1920 static void 1921 umass_t_cbi_data_rd_cs_callback(struct usb_xfer *xfer, usb_error_t error) 1922 { 1923 umass_t_cbi_data_clear_stall_callback(xfer, UMASS_T_CBI_STATUS, 1924 UMASS_T_CBI_DATA_READ, error); 1925 } 1926 1927 static void 1928 umass_t_cbi_data_write_callback(struct usb_xfer *xfer, usb_error_t error) 1929 { 1930 struct umass_softc *sc = usbd_xfer_softc(xfer); 1931 uint32_t max_bulk = usbd_xfer_max_len(xfer); 1932 #ifndef UMASS_EXT_BUFFER 1933 struct usb_page_cache *pc; 1934 #endif 1935 int actlen, sumlen; 1936 1937 usbd_xfer_status(xfer, &actlen, &sumlen, NULL, NULL); 1938 1939 switch (USB_GET_STATE(xfer)) { 1940 case USB_ST_TRANSFERRED: 1941 sc->sc_transfer.data_rem -= actlen; 1942 sc->sc_transfer.data_ptr += actlen; 1943 sc->sc_transfer.actlen += actlen; 1944 1945 if (actlen < sumlen) { 1946 /* short transfer */ 1947 sc->sc_transfer.data_rem = 0; 1948 } 1949 case USB_ST_SETUP: 1950 DPRINTF(sc, UDMASS_CBI, "max_bulk=%d, data_rem=%d\n", 1951 max_bulk, sc->sc_transfer.data_rem); 1952 1953 if (sc->sc_transfer.data_rem == 0) { 1954 umass_cbi_start_status(sc); 1955 break; 1956 } 1957 if (max_bulk > sc->sc_transfer.data_rem) { 1958 max_bulk = sc->sc_transfer.data_rem; 1959 } 1960 usbd_xfer_set_timeout(xfer, sc->sc_transfer.data_timeout); 1961 1962 #ifdef UMASS_EXT_BUFFER 1963 usbd_xfer_set_frame_data(xfer, 0, sc->sc_transfer.data_ptr, 1964 max_bulk); 1965 #else 1966 pc = usbd_xfer_get_frame(xfer, 0); 1967 usbd_copy_in(pc, 0, sc->sc_transfer.data_ptr, max_bulk); 1968 usbd_xfer_set_frame_len(xfer, 0, max_bulk); 1969 #endif 1970 1971 usbd_transfer_submit(xfer); 1972 break; 1973 1974 default: /* Error */ 1975 if ((error == USB_ERR_CANCELLED) || 1976 (sc->sc_transfer.callback != &umass_cam_cb)) { 1977 umass_tr_error(xfer, error); 1978 } else { 1979 umass_transfer_start(sc, UMASS_T_CBI_DATA_WR_CS); 1980 } 1981 break; 1982 1983 } 1984 } 1985 1986 static void 1987 umass_t_cbi_data_wr_cs_callback(struct usb_xfer *xfer, usb_error_t error) 1988 { 1989 umass_t_cbi_data_clear_stall_callback(xfer, UMASS_T_CBI_STATUS, 1990 UMASS_T_CBI_DATA_WRITE, error); 1991 } 1992 1993 static void 1994 umass_t_cbi_status_callback(struct usb_xfer *xfer, usb_error_t error) 1995 { 1996 struct umass_softc *sc = usbd_xfer_softc(xfer); 1997 union ccb *ccb = sc->sc_transfer.ccb; 1998 struct usb_page_cache *pc; 1999 uint32_t residue; 2000 uint8_t status; 2001 int actlen; 2002 2003 usbd_xfer_status(xfer, &actlen, NULL, NULL, NULL); 2004 2005 switch (USB_GET_STATE(xfer)) { 2006 case USB_ST_TRANSFERRED: 2007 2008 if (actlen < sizeof(sc->sbl)) { 2009 goto tr_setup; 2010 } 2011 pc = usbd_xfer_get_frame(xfer, 0); 2012 usbd_copy_out(pc, 0, &sc->sbl, sizeof(sc->sbl)); 2013 2014 residue = (sc->sc_transfer.data_len - 2015 sc->sc_transfer.actlen); 2016 2017 /* dissect the information in the buffer */ 2018 2019 if (sc->sc_proto & UMASS_PROTO_UFI) { 2020 2021 /* 2022 * Section 3.4.3.1.3 specifies that the UFI command 2023 * protocol returns an ASC and ASCQ in the interrupt 2024 * data block. 2025 */ 2026 2027 DPRINTF(sc, UDMASS_CBI, "UFI CCI, ASC = 0x%02x, " 2028 "ASCQ = 0x%02x\n", sc->sbl.ufi.asc, 2029 sc->sbl.ufi.ascq); 2030 2031 status = (((sc->sbl.ufi.asc == 0) && 2032 (sc->sbl.ufi.ascq == 0)) ? 2033 STATUS_CMD_OK : STATUS_CMD_FAILED); 2034 2035 sc->sc_transfer.ccb = NULL; 2036 2037 sc->sc_last_xfer_index = UMASS_T_CBI_COMMAND; 2038 2039 (sc->sc_transfer.callback) 2040 (sc, ccb, residue, status); 2041 2042 break; 2043 2044 } else { 2045 2046 /* Command Interrupt Data Block */ 2047 2048 DPRINTF(sc, UDMASS_CBI, "type=0x%02x, value=0x%02x\n", 2049 sc->sbl.common.type, sc->sbl.common.value); 2050 2051 if (sc->sbl.common.type == IDB_TYPE_CCI) { 2052 2053 status = (sc->sbl.common.value & IDB_VALUE_STATUS_MASK); 2054 2055 status = ((status == IDB_VALUE_PASS) ? STATUS_CMD_OK : 2056 (status == IDB_VALUE_FAIL) ? STATUS_CMD_FAILED : 2057 (status == IDB_VALUE_PERSISTENT) ? STATUS_CMD_FAILED : 2058 STATUS_WIRE_FAILED); 2059 2060 sc->sc_transfer.ccb = NULL; 2061 2062 sc->sc_last_xfer_index = UMASS_T_CBI_COMMAND; 2063 2064 (sc->sc_transfer.callback) 2065 (sc, ccb, residue, status); 2066 2067 break; 2068 } 2069 } 2070 2071 /* fallthrough */ 2072 2073 case USB_ST_SETUP: 2074 tr_setup: 2075 usbd_xfer_set_frame_len(xfer, 0, usbd_xfer_max_len(xfer)); 2076 usbd_transfer_submit(xfer); 2077 break; 2078 2079 default: /* Error */ 2080 DPRINTF(sc, UDMASS_CBI, "Failed to read CSW: %s\n", 2081 usbd_errstr(error)); 2082 umass_tr_error(xfer, error); 2083 break; 2084 2085 } 2086 } 2087 2088 /* 2089 * CAM specific functions (used by SCSI, UFI, 8070i (ATAPI)) 2090 */ 2091 2092 static int 2093 umass_cam_attach_sim(struct umass_softc *sc) 2094 { 2095 struct cam_devq *devq; /* Per device Queue */ 2096 2097 /* 2098 * A HBA is attached to the CAM layer. 2099 * 2100 * The CAM layer will then after a while start probing for devices on 2101 * the bus. The number of SIMs is limited to one. 2102 */ 2103 2104 devq = cam_simq_alloc(1 /* maximum openings */ ); 2105 if (devq == NULL) { 2106 return (ENOMEM); 2107 } 2108 sc->sc_sim = cam_sim_alloc 2109 (&umass_cam_action, &umass_cam_poll, 2110 DEVNAME_SIM, 2111 sc /* priv */ , 2112 sc->sc_unit /* unit number */ , 2113 #if (__FreeBSD_version >= 700037) 2114 &sc->sc_mtx /* mutex */ , 2115 #endif 2116 1 /* maximum device openings */ , 2117 0 /* maximum tagged device openings */ , 2118 devq); 2119 2120 if (sc->sc_sim == NULL) { 2121 cam_simq_free(devq); 2122 return (ENOMEM); 2123 } 2124 2125 #if (__FreeBSD_version >= 700037) 2126 mtx_lock(&sc->sc_mtx); 2127 #endif 2128 2129 #if (__FreeBSD_version >= 700048) 2130 if (xpt_bus_register(sc->sc_sim, sc->sc_dev, sc->sc_unit) != CAM_SUCCESS) { 2131 mtx_unlock(&sc->sc_mtx); 2132 return (ENOMEM); 2133 } 2134 #else 2135 if (xpt_bus_register(sc->sc_sim, sc->sc_unit) != CAM_SUCCESS) { 2136 #if (__FreeBSD_version >= 700037) 2137 mtx_unlock(&sc->sc_mtx); 2138 #endif 2139 return (ENOMEM); 2140 } 2141 #endif 2142 2143 #if (__FreeBSD_version >= 700037) 2144 mtx_unlock(&sc->sc_mtx); 2145 #endif 2146 return (0); 2147 } 2148 2149 static void 2150 umass_cam_attach(struct umass_softc *sc) 2151 { 2152 #ifndef USB_DEBUG 2153 if (bootverbose) 2154 #endif 2155 printf("%s:%d:%d:%d: Attached to scbus%d\n", 2156 sc->sc_name, cam_sim_path(sc->sc_sim), 2157 sc->sc_unit, CAM_LUN_WILDCARD, 2158 cam_sim_path(sc->sc_sim)); 2159 } 2160 2161 /* umass_cam_detach 2162 * detach from the CAM layer 2163 */ 2164 2165 static void 2166 umass_cam_detach_sim(struct umass_softc *sc) 2167 { 2168 if (sc->sc_sim != NULL) { 2169 if (xpt_bus_deregister(cam_sim_path(sc->sc_sim))) { 2170 /* accessing the softc is not possible after this */ 2171 sc->sc_sim->softc = UMASS_GONE; 2172 cam_sim_free(sc->sc_sim, /* free_devq */ TRUE); 2173 } else { 2174 panic("%s: CAM layer is busy\n", 2175 sc->sc_name); 2176 } 2177 sc->sc_sim = NULL; 2178 } 2179 } 2180 2181 /* umass_cam_action 2182 * CAM requests for action come through here 2183 */ 2184 2185 static void 2186 umass_cam_action(struct cam_sim *sim, union ccb *ccb) 2187 { 2188 struct umass_softc *sc = (struct umass_softc *)sim->softc; 2189 2190 if (sc == UMASS_GONE || 2191 (sc != NULL && !usbd_device_attached(sc->sc_udev))) { 2192 ccb->ccb_h.status = CAM_SEL_TIMEOUT; 2193 xpt_done(ccb); 2194 return; 2195 } 2196 if (sc) { 2197 #if (__FreeBSD_version < 700037) 2198 mtx_lock(&sc->sc_mtx); 2199 #endif 2200 } 2201 /* 2202 * Verify, depending on the operation to perform, that we either got 2203 * a valid sc, because an existing target was referenced, or 2204 * otherwise the SIM is addressed. 2205 * 2206 * This avoids bombing out at a printf and does give the CAM layer some 2207 * sensible feedback on errors. 2208 */ 2209 switch (ccb->ccb_h.func_code) { 2210 case XPT_SCSI_IO: 2211 case XPT_RESET_DEV: 2212 case XPT_GET_TRAN_SETTINGS: 2213 case XPT_SET_TRAN_SETTINGS: 2214 case XPT_CALC_GEOMETRY: 2215 /* the opcodes requiring a target. These should never occur. */ 2216 if (sc == NULL) { 2217 DPRINTF(sc, UDMASS_GEN, "%s:%d:%d:%d:func_code 0x%04x: " 2218 "Invalid target (target needed)\n", 2219 DEVNAME_SIM, cam_sim_path(sc->sc_sim), 2220 ccb->ccb_h.target_id, ccb->ccb_h.target_lun, 2221 ccb->ccb_h.func_code); 2222 2223 ccb->ccb_h.status = CAM_TID_INVALID; 2224 xpt_done(ccb); 2225 goto done; 2226 } 2227 break; 2228 case XPT_PATH_INQ: 2229 case XPT_NOOP: 2230 /* 2231 * The opcodes sometimes aimed at a target (sc is valid), 2232 * sometimes aimed at the SIM (sc is invalid and target is 2233 * CAM_TARGET_WILDCARD) 2234 */ 2235 if ((sc == NULL) && 2236 (ccb->ccb_h.target_id != CAM_TARGET_WILDCARD)) { 2237 DPRINTF(sc, UDMASS_SCSI, "%s:%d:%d:%d:func_code 0x%04x: " 2238 "Invalid target (no wildcard)\n", 2239 DEVNAME_SIM, cam_sim_path(sc->sc_sim), 2240 ccb->ccb_h.target_id, ccb->ccb_h.target_lun, 2241 ccb->ccb_h.func_code); 2242 2243 ccb->ccb_h.status = CAM_TID_INVALID; 2244 xpt_done(ccb); 2245 goto done; 2246 } 2247 break; 2248 default: 2249 /* XXX Hm, we should check the input parameters */ 2250 break; 2251 } 2252 2253 /* Perform the requested action */ 2254 switch (ccb->ccb_h.func_code) { 2255 case XPT_SCSI_IO: 2256 { 2257 uint8_t *cmd; 2258 uint8_t dir; 2259 2260 if (ccb->csio.ccb_h.flags & CAM_CDB_POINTER) { 2261 cmd = (uint8_t *)(ccb->csio.cdb_io.cdb_ptr); 2262 } else { 2263 cmd = (uint8_t *)(ccb->csio.cdb_io.cdb_bytes); 2264 } 2265 2266 DPRINTF(sc, UDMASS_SCSI, "%d:%d:%d:XPT_SCSI_IO: " 2267 "cmd: 0x%02x, flags: 0x%02x, " 2268 "%db cmd/%db data/%db sense\n", 2269 cam_sim_path(sc->sc_sim), ccb->ccb_h.target_id, 2270 ccb->ccb_h.target_lun, cmd[0], 2271 ccb->ccb_h.flags & CAM_DIR_MASK, ccb->csio.cdb_len, 2272 ccb->csio.dxfer_len, ccb->csio.sense_len); 2273 2274 if (sc->sc_transfer.ccb) { 2275 DPRINTF(sc, UDMASS_SCSI, "%d:%d:%d:XPT_SCSI_IO: " 2276 "I/O in progress, deferring\n", 2277 cam_sim_path(sc->sc_sim), ccb->ccb_h.target_id, 2278 ccb->ccb_h.target_lun); 2279 ccb->ccb_h.status = CAM_SCSI_BUSY; 2280 xpt_done(ccb); 2281 goto done; 2282 } 2283 switch (ccb->ccb_h.flags & CAM_DIR_MASK) { 2284 case CAM_DIR_IN: 2285 dir = DIR_IN; 2286 break; 2287 case CAM_DIR_OUT: 2288 dir = DIR_OUT; 2289 DIF(UDMASS_SCSI, 2290 umass_dump_buffer(sc, ccb->csio.data_ptr, 2291 ccb->csio.dxfer_len, 48)); 2292 break; 2293 default: 2294 dir = DIR_NONE; 2295 } 2296 2297 ccb->ccb_h.status = CAM_REQ_INPROG | CAM_SIM_QUEUED; 2298 2299 /* 2300 * sc->sc_transform will convert the command to the 2301 * command format needed by the specific command set 2302 * and return the converted command in 2303 * "sc->sc_transfer.cmd_data" 2304 */ 2305 if (umass_std_transform(sc, ccb, cmd, ccb->csio.cdb_len)) { 2306 2307 if (sc->sc_transfer.cmd_data[0] == INQUIRY) { 2308 const char *pserial; 2309 2310 pserial = usb_get_serial(sc->sc_udev); 2311 2312 /* 2313 * Umass devices don't generally report their serial numbers 2314 * in the usual SCSI way. Emulate it here. 2315 */ 2316 if ((sc->sc_transfer.cmd_data[1] & SI_EVPD) && 2317 (sc->sc_transfer.cmd_data[2] == SVPD_UNIT_SERIAL_NUMBER) && 2318 (pserial[0] != '\0')) { 2319 struct scsi_vpd_unit_serial_number *vpd_serial; 2320 2321 vpd_serial = (struct scsi_vpd_unit_serial_number *)ccb->csio.data_ptr; 2322 vpd_serial->length = strlen(pserial); 2323 if (vpd_serial->length > sizeof(vpd_serial->serial_num)) 2324 vpd_serial->length = sizeof(vpd_serial->serial_num); 2325 memcpy(vpd_serial->serial_num, pserial, vpd_serial->length); 2326 ccb->csio.scsi_status = SCSI_STATUS_OK; 2327 ccb->ccb_h.status = CAM_REQ_CMP; 2328 xpt_done(ccb); 2329 goto done; 2330 } 2331 2332 /* 2333 * Handle EVPD inquiry for broken devices first 2334 * NO_INQUIRY also implies NO_INQUIRY_EVPD 2335 */ 2336 if ((sc->sc_quirks & (NO_INQUIRY_EVPD | NO_INQUIRY)) && 2337 (sc->sc_transfer.cmd_data[1] & SI_EVPD)) { 2338 struct scsi_sense_data *sense; 2339 2340 sense = &ccb->csio.sense_data; 2341 bzero(sense, sizeof(*sense)); 2342 sense->error_code = SSD_CURRENT_ERROR; 2343 sense->flags = SSD_KEY_ILLEGAL_REQUEST; 2344 sense->add_sense_code = 0x24; 2345 sense->extra_len = 10; 2346 ccb->csio.scsi_status = SCSI_STATUS_CHECK_COND; 2347 ccb->ccb_h.status = CAM_SCSI_STATUS_ERROR | 2348 CAM_AUTOSNS_VALID; 2349 xpt_done(ccb); 2350 goto done; 2351 } 2352 /* 2353 * Return fake inquiry data for 2354 * broken devices 2355 */ 2356 if (sc->sc_quirks & NO_INQUIRY) { 2357 memcpy(ccb->csio.data_ptr, &fake_inq_data, 2358 sizeof(fake_inq_data)); 2359 ccb->csio.scsi_status = SCSI_STATUS_OK; 2360 ccb->ccb_h.status = CAM_REQ_CMP; 2361 xpt_done(ccb); 2362 goto done; 2363 } 2364 if (sc->sc_quirks & FORCE_SHORT_INQUIRY) { 2365 ccb->csio.dxfer_len = SHORT_INQUIRY_LENGTH; 2366 } 2367 } else if (sc->sc_transfer.cmd_data[0] == SYNCHRONIZE_CACHE) { 2368 if (sc->sc_quirks & NO_SYNCHRONIZE_CACHE) { 2369 ccb->csio.scsi_status = SCSI_STATUS_OK; 2370 ccb->ccb_h.status = CAM_REQ_CMP; 2371 xpt_done(ccb); 2372 goto done; 2373 } 2374 } 2375 umass_command_start(sc, dir, ccb->csio.data_ptr, 2376 ccb->csio.dxfer_len, 2377 ccb->ccb_h.timeout, 2378 &umass_cam_cb, ccb); 2379 } 2380 break; 2381 } 2382 case XPT_PATH_INQ: 2383 { 2384 struct ccb_pathinq *cpi = &ccb->cpi; 2385 2386 DPRINTF(sc, UDMASS_SCSI, "%d:%d:%d:XPT_PATH_INQ:.\n", 2387 sc ? cam_sim_path(sc->sc_sim) : -1, ccb->ccb_h.target_id, 2388 ccb->ccb_h.target_lun); 2389 2390 /* host specific information */ 2391 cpi->version_num = 1; 2392 cpi->hba_inquiry = 0; 2393 cpi->target_sprt = 0; 2394 cpi->hba_misc = PIM_NO_6_BYTE; 2395 cpi->hba_eng_cnt = 0; 2396 cpi->max_target = UMASS_SCSIID_MAX; /* one target */ 2397 cpi->initiator_id = UMASS_SCSIID_HOST; 2398 strlcpy(cpi->sim_vid, "FreeBSD", SIM_IDLEN); 2399 strlcpy(cpi->hba_vid, "USB SCSI", HBA_IDLEN); 2400 strlcpy(cpi->dev_name, cam_sim_name(sim), DEV_IDLEN); 2401 cpi->unit_number = cam_sim_unit(sim); 2402 cpi->bus_id = sc->sc_unit; 2403 #if (__FreeBSD_version >= 700025) 2404 cpi->protocol = PROTO_SCSI; 2405 cpi->protocol_version = SCSI_REV_2; 2406 cpi->transport = XPORT_USB; 2407 cpi->transport_version = 0; 2408 #endif 2409 if (sc == NULL) { 2410 cpi->base_transfer_speed = 0; 2411 cpi->max_lun = 0; 2412 } else { 2413 if (sc->sc_quirks & FLOPPY_SPEED) { 2414 cpi->base_transfer_speed = 2415 UMASS_FLOPPY_TRANSFER_SPEED; 2416 } else { 2417 switch (usbd_get_speed(sc->sc_udev)) { 2418 case USB_SPEED_SUPER: 2419 cpi->base_transfer_speed = 2420 UMASS_SUPER_TRANSFER_SPEED; 2421 cpi->maxio = MAXPHYS; 2422 break; 2423 case USB_SPEED_HIGH: 2424 cpi->base_transfer_speed = 2425 UMASS_HIGH_TRANSFER_SPEED; 2426 break; 2427 default: 2428 cpi->base_transfer_speed = 2429 UMASS_FULL_TRANSFER_SPEED; 2430 break; 2431 } 2432 } 2433 cpi->max_lun = sc->sc_maxlun; 2434 } 2435 2436 cpi->ccb_h.status = CAM_REQ_CMP; 2437 xpt_done(ccb); 2438 break; 2439 } 2440 case XPT_RESET_DEV: 2441 { 2442 DPRINTF(sc, UDMASS_SCSI, "%d:%d:%d:XPT_RESET_DEV:.\n", 2443 cam_sim_path(sc->sc_sim), ccb->ccb_h.target_id, 2444 ccb->ccb_h.target_lun); 2445 2446 umass_reset(sc); 2447 2448 ccb->ccb_h.status = CAM_REQ_CMP; 2449 xpt_done(ccb); 2450 break; 2451 } 2452 case XPT_GET_TRAN_SETTINGS: 2453 { 2454 struct ccb_trans_settings *cts = &ccb->cts; 2455 2456 DPRINTF(sc, UDMASS_SCSI, "%d:%d:%d:XPT_GET_TRAN_SETTINGS:.\n", 2457 cam_sim_path(sc->sc_sim), ccb->ccb_h.target_id, 2458 ccb->ccb_h.target_lun); 2459 2460 #if (__FreeBSD_version >= 700025) 2461 cts->protocol = PROTO_SCSI; 2462 cts->protocol_version = SCSI_REV_2; 2463 cts->transport = XPORT_USB; 2464 cts->transport_version = 0; 2465 cts->xport_specific.valid = 0; 2466 #else 2467 cts->valid = 0; 2468 cts->flags = 0; /* no disconnection, tagging */ 2469 #endif 2470 ccb->ccb_h.status = CAM_REQ_CMP; 2471 xpt_done(ccb); 2472 break; 2473 } 2474 case XPT_SET_TRAN_SETTINGS: 2475 { 2476 DPRINTF(sc, UDMASS_SCSI, "%d:%d:%d:XPT_SET_TRAN_SETTINGS:.\n", 2477 cam_sim_path(sc->sc_sim), ccb->ccb_h.target_id, 2478 ccb->ccb_h.target_lun); 2479 2480 ccb->ccb_h.status = CAM_FUNC_NOTAVAIL; 2481 xpt_done(ccb); 2482 break; 2483 } 2484 case XPT_CALC_GEOMETRY: 2485 { 2486 cam_calc_geometry(&ccb->ccg, /* extended */ 1); 2487 xpt_done(ccb); 2488 break; 2489 } 2490 case XPT_NOOP: 2491 { 2492 DPRINTF(sc, UDMASS_SCSI, "%d:%d:%d:XPT_NOOP:.\n", 2493 sc ? cam_sim_path(sc->sc_sim) : -1, ccb->ccb_h.target_id, 2494 ccb->ccb_h.target_lun); 2495 2496 ccb->ccb_h.status = CAM_REQ_CMP; 2497 xpt_done(ccb); 2498 break; 2499 } 2500 default: 2501 DPRINTF(sc, UDMASS_SCSI, "%d:%d:%d:func_code 0x%04x: " 2502 "Not implemented\n", 2503 sc ? cam_sim_path(sc->sc_sim) : -1, ccb->ccb_h.target_id, 2504 ccb->ccb_h.target_lun, ccb->ccb_h.func_code); 2505 2506 ccb->ccb_h.status = CAM_FUNC_NOTAVAIL; 2507 xpt_done(ccb); 2508 break; 2509 } 2510 2511 done: 2512 #if (__FreeBSD_version < 700037) 2513 if (sc) { 2514 mtx_unlock(&sc->sc_mtx); 2515 } 2516 #endif 2517 return; 2518 } 2519 2520 static void 2521 umass_cam_poll(struct cam_sim *sim) 2522 { 2523 struct umass_softc *sc = (struct umass_softc *)sim->softc; 2524 2525 if (sc == UMASS_GONE) 2526 return; 2527 2528 DPRINTF(sc, UDMASS_SCSI, "CAM poll\n"); 2529 2530 usbd_transfer_poll(sc->sc_xfer, UMASS_T_MAX); 2531 } 2532 2533 2534 /* umass_cam_cb 2535 * finalise a completed CAM command 2536 */ 2537 2538 static void 2539 umass_cam_cb(struct umass_softc *sc, union ccb *ccb, uint32_t residue, 2540 uint8_t status) 2541 { 2542 ccb->csio.resid = residue; 2543 2544 switch (status) { 2545 case STATUS_CMD_OK: 2546 ccb->ccb_h.status = CAM_REQ_CMP; 2547 if ((sc->sc_quirks & READ_CAPACITY_OFFBY1) && 2548 (ccb->ccb_h.func_code == XPT_SCSI_IO) && 2549 (ccb->csio.cdb_io.cdb_bytes[0] == READ_CAPACITY)) { 2550 struct scsi_read_capacity_data *rcap; 2551 uint32_t maxsector; 2552 2553 rcap = (void *)(ccb->csio.data_ptr); 2554 maxsector = scsi_4btoul(rcap->addr) - 1; 2555 scsi_ulto4b(maxsector, rcap->addr); 2556 } 2557 /* 2558 * We have to add SVPD_UNIT_SERIAL_NUMBER to the list 2559 * of pages supported by the device - otherwise, CAM 2560 * will never ask us for the serial number if the 2561 * device cannot handle that by itself. 2562 */ 2563 if (ccb->ccb_h.func_code == XPT_SCSI_IO && 2564 sc->sc_transfer.cmd_data[0] == INQUIRY && 2565 (sc->sc_transfer.cmd_data[1] & SI_EVPD) && 2566 sc->sc_transfer.cmd_data[2] == SVPD_SUPPORTED_PAGE_LIST && 2567 (usb_get_serial(sc->sc_udev)[0] != '\0')) { 2568 struct ccb_scsiio *csio; 2569 struct scsi_vpd_supported_page_list *page_list; 2570 2571 csio = &ccb->csio; 2572 page_list = (struct scsi_vpd_supported_page_list *)csio->data_ptr; 2573 if (page_list->length + 1 < SVPD_SUPPORTED_PAGES_SIZE) { 2574 page_list->list[page_list->length] = SVPD_UNIT_SERIAL_NUMBER; 2575 page_list->length++; 2576 } 2577 } 2578 xpt_done(ccb); 2579 break; 2580 2581 case STATUS_CMD_UNKNOWN: 2582 case STATUS_CMD_FAILED: 2583 2584 /* fetch sense data */ 2585 2586 /* the rest of the command was filled in at attach */ 2587 sc->cam_scsi_sense.length = ccb->csio.sense_len; 2588 2589 DPRINTF(sc, UDMASS_SCSI, "Fetching %d bytes of " 2590 "sense data\n", ccb->csio.sense_len); 2591 2592 if (umass_std_transform(sc, ccb, &sc->cam_scsi_sense.opcode, 2593 sizeof(sc->cam_scsi_sense))) { 2594 2595 if ((sc->sc_quirks & FORCE_SHORT_INQUIRY) && 2596 (sc->sc_transfer.cmd_data[0] == INQUIRY)) { 2597 ccb->csio.sense_len = SHORT_INQUIRY_LENGTH; 2598 } 2599 umass_command_start(sc, DIR_IN, &ccb->csio.sense_data.error_code, 2600 ccb->csio.sense_len, ccb->ccb_h.timeout, 2601 &umass_cam_sense_cb, ccb); 2602 } 2603 break; 2604 2605 default: 2606 /* 2607 * The wire protocol failed and will hopefully have 2608 * recovered. We return an error to CAM and let CAM 2609 * retry the command if necessary. In case of SCSI IO 2610 * commands we ask the CAM layer to check the 2611 * condition first. This is a quick hack to make 2612 * certain devices work. 2613 */ 2614 if (ccb->ccb_h.func_code == XPT_SCSI_IO) { 2615 ccb->ccb_h.status = CAM_SCSI_STATUS_ERROR; 2616 ccb->csio.scsi_status = SCSI_STATUS_CHECK_COND; 2617 } else { 2618 ccb->ccb_h.status = CAM_REQ_CMP_ERR; 2619 } 2620 xpt_done(ccb); 2621 break; 2622 } 2623 } 2624 2625 /* 2626 * Finalise a completed autosense operation 2627 */ 2628 static void 2629 umass_cam_sense_cb(struct umass_softc *sc, union ccb *ccb, uint32_t residue, 2630 uint8_t status) 2631 { 2632 uint8_t *cmd; 2633 uint8_t key; 2634 2635 switch (status) { 2636 case STATUS_CMD_OK: 2637 case STATUS_CMD_UNKNOWN: 2638 case STATUS_CMD_FAILED: 2639 2640 if (ccb->csio.ccb_h.flags & CAM_CDB_POINTER) { 2641 cmd = (uint8_t *)(ccb->csio.cdb_io.cdb_ptr); 2642 } else { 2643 cmd = (uint8_t *)(ccb->csio.cdb_io.cdb_bytes); 2644 } 2645 2646 key = (ccb->csio.sense_data.flags & SSD_KEY); 2647 2648 /* 2649 * Getting sense data always succeeds (apart from wire 2650 * failures): 2651 */ 2652 if ((sc->sc_quirks & RS_NO_CLEAR_UA) && 2653 (cmd[0] == INQUIRY) && 2654 (key == SSD_KEY_UNIT_ATTENTION)) { 2655 /* 2656 * Ignore unit attention errors in the case where 2657 * the Unit Attention state is not cleared on 2658 * REQUEST SENSE. They will appear again at the next 2659 * command. 2660 */ 2661 ccb->ccb_h.status = CAM_REQ_CMP; 2662 } else if (key == SSD_KEY_NO_SENSE) { 2663 /* 2664 * No problem after all (in the case of CBI without 2665 * CCI) 2666 */ 2667 ccb->ccb_h.status = CAM_REQ_CMP; 2668 } else if ((sc->sc_quirks & RS_NO_CLEAR_UA) && 2669 (cmd[0] == READ_CAPACITY) && 2670 (key == SSD_KEY_UNIT_ATTENTION)) { 2671 /* 2672 * Some devices do not clear the unit attention error 2673 * on request sense. We insert a test unit ready 2674 * command to make sure we clear the unit attention 2675 * condition, then allow the retry to proceed as 2676 * usual. 2677 */ 2678 2679 ccb->ccb_h.status = CAM_SCSI_STATUS_ERROR 2680 | CAM_AUTOSNS_VALID; 2681 ccb->csio.scsi_status = SCSI_STATUS_CHECK_COND; 2682 2683 #if 0 2684 DELAY(300000); 2685 #endif 2686 DPRINTF(sc, UDMASS_SCSI, "Doing a sneaky" 2687 "TEST_UNIT_READY\n"); 2688 2689 /* the rest of the command was filled in at attach */ 2690 2691 if (umass_std_transform(sc, ccb, 2692 &sc->cam_scsi_test_unit_ready.opcode, 2693 sizeof(sc->cam_scsi_test_unit_ready))) { 2694 umass_command_start(sc, DIR_NONE, NULL, 0, 2695 ccb->ccb_h.timeout, 2696 &umass_cam_quirk_cb, ccb); 2697 } 2698 break; 2699 } else { 2700 ccb->ccb_h.status = CAM_SCSI_STATUS_ERROR 2701 | CAM_AUTOSNS_VALID; 2702 ccb->csio.scsi_status = SCSI_STATUS_CHECK_COND; 2703 } 2704 xpt_done(ccb); 2705 break; 2706 2707 default: 2708 DPRINTF(sc, UDMASS_SCSI, "Autosense failed, " 2709 "status %d\n", status); 2710 ccb->ccb_h.status = CAM_AUTOSENSE_FAIL; 2711 xpt_done(ccb); 2712 } 2713 } 2714 2715 /* 2716 * This completion code just handles the fact that we sent a test-unit-ready 2717 * after having previously failed a READ CAPACITY with CHECK_COND. Even 2718 * though this command succeeded, we have to tell CAM to retry. 2719 */ 2720 static void 2721 umass_cam_quirk_cb(struct umass_softc *sc, union ccb *ccb, uint32_t residue, 2722 uint8_t status) 2723 { 2724 DPRINTF(sc, UDMASS_SCSI, "Test unit ready " 2725 "returned status %d\n", status); 2726 2727 ccb->ccb_h.status = CAM_SCSI_STATUS_ERROR 2728 | CAM_AUTOSNS_VALID; 2729 ccb->csio.scsi_status = SCSI_STATUS_CHECK_COND; 2730 xpt_done(ccb); 2731 } 2732 2733 /* 2734 * SCSI specific functions 2735 */ 2736 2737 static uint8_t 2738 umass_scsi_transform(struct umass_softc *sc, uint8_t *cmd_ptr, 2739 uint8_t cmd_len) 2740 { 2741 if ((cmd_len == 0) || 2742 (cmd_len > sizeof(sc->sc_transfer.cmd_data))) { 2743 DPRINTF(sc, UDMASS_SCSI, "Invalid command " 2744 "length: %d bytes\n", cmd_len); 2745 return (0); /* failure */ 2746 } 2747 sc->sc_transfer.cmd_len = cmd_len; 2748 2749 switch (cmd_ptr[0]) { 2750 case TEST_UNIT_READY: 2751 if (sc->sc_quirks & NO_TEST_UNIT_READY) { 2752 DPRINTF(sc, UDMASS_SCSI, "Converted TEST_UNIT_READY " 2753 "to START_UNIT\n"); 2754 bzero(sc->sc_transfer.cmd_data, cmd_len); 2755 sc->sc_transfer.cmd_data[0] = START_STOP_UNIT; 2756 sc->sc_transfer.cmd_data[4] = SSS_START; 2757 return (1); 2758 } 2759 break; 2760 2761 case INQUIRY: 2762 /* 2763 * some drives wedge when asked for full inquiry 2764 * information. 2765 */ 2766 if (sc->sc_quirks & FORCE_SHORT_INQUIRY) { 2767 bcopy(cmd_ptr, sc->sc_transfer.cmd_data, cmd_len); 2768 sc->sc_transfer.cmd_data[4] = SHORT_INQUIRY_LENGTH; 2769 return (1); 2770 } 2771 break; 2772 } 2773 2774 bcopy(cmd_ptr, sc->sc_transfer.cmd_data, cmd_len); 2775 return (1); 2776 } 2777 2778 static uint8_t 2779 umass_rbc_transform(struct umass_softc *sc, uint8_t *cmd_ptr, uint8_t cmd_len) 2780 { 2781 if ((cmd_len == 0) || 2782 (cmd_len > sizeof(sc->sc_transfer.cmd_data))) { 2783 DPRINTF(sc, UDMASS_SCSI, "Invalid command " 2784 "length: %d bytes\n", cmd_len); 2785 return (0); /* failure */ 2786 } 2787 switch (cmd_ptr[0]) { 2788 /* these commands are defined in RBC: */ 2789 case READ_10: 2790 case READ_CAPACITY: 2791 case START_STOP_UNIT: 2792 case SYNCHRONIZE_CACHE: 2793 case WRITE_10: 2794 case 0x2f: /* VERIFY_10 is absent from 2795 * scsi_all.h??? */ 2796 case INQUIRY: 2797 case MODE_SELECT_10: 2798 case MODE_SENSE_10: 2799 case TEST_UNIT_READY: 2800 case WRITE_BUFFER: 2801 /* 2802 * The following commands are not listed in my copy of the 2803 * RBC specs. CAM however seems to want those, and at least 2804 * the Sony DSC device appears to support those as well 2805 */ 2806 case REQUEST_SENSE: 2807 case PREVENT_ALLOW: 2808 2809 bcopy(cmd_ptr, sc->sc_transfer.cmd_data, cmd_len); 2810 2811 if ((sc->sc_quirks & RBC_PAD_TO_12) && (cmd_len < 12)) { 2812 bzero(sc->sc_transfer.cmd_data + cmd_len, 12 - cmd_len); 2813 cmd_len = 12; 2814 } 2815 sc->sc_transfer.cmd_len = cmd_len; 2816 return (1); /* sucess */ 2817 2818 /* All other commands are not legal in RBC */ 2819 default: 2820 DPRINTF(sc, UDMASS_SCSI, "Unsupported RBC " 2821 "command 0x%02x\n", cmd_ptr[0]); 2822 return (0); /* failure */ 2823 } 2824 } 2825 2826 static uint8_t 2827 umass_ufi_transform(struct umass_softc *sc, uint8_t *cmd_ptr, 2828 uint8_t cmd_len) 2829 { 2830 if ((cmd_len == 0) || 2831 (cmd_len > sizeof(sc->sc_transfer.cmd_data))) { 2832 DPRINTF(sc, UDMASS_SCSI, "Invalid command " 2833 "length: %d bytes\n", cmd_len); 2834 return (0); /* failure */ 2835 } 2836 /* An UFI command is always 12 bytes in length */ 2837 sc->sc_transfer.cmd_len = UFI_COMMAND_LENGTH; 2838 2839 /* Zero the command data */ 2840 bzero(sc->sc_transfer.cmd_data, UFI_COMMAND_LENGTH); 2841 2842 switch (cmd_ptr[0]) { 2843 /* 2844 * Commands of which the format has been verified. They 2845 * should work. Copy the command into the (zeroed out) 2846 * destination buffer. 2847 */ 2848 case TEST_UNIT_READY: 2849 if (sc->sc_quirks & NO_TEST_UNIT_READY) { 2850 /* 2851 * Some devices do not support this command. Start 2852 * Stop Unit should give the same results 2853 */ 2854 DPRINTF(sc, UDMASS_UFI, "Converted TEST_UNIT_READY " 2855 "to START_UNIT\n"); 2856 2857 sc->sc_transfer.cmd_data[0] = START_STOP_UNIT; 2858 sc->sc_transfer.cmd_data[4] = SSS_START; 2859 return (1); 2860 } 2861 break; 2862 2863 case REZERO_UNIT: 2864 case REQUEST_SENSE: 2865 case FORMAT_UNIT: 2866 case INQUIRY: 2867 case START_STOP_UNIT: 2868 case SEND_DIAGNOSTIC: 2869 case PREVENT_ALLOW: 2870 case READ_CAPACITY: 2871 case READ_10: 2872 case WRITE_10: 2873 case POSITION_TO_ELEMENT: /* SEEK_10 */ 2874 case WRITE_AND_VERIFY: 2875 case VERIFY: 2876 case MODE_SELECT_10: 2877 case MODE_SENSE_10: 2878 case READ_12: 2879 case WRITE_12: 2880 case READ_FORMAT_CAPACITIES: 2881 break; 2882 2883 /* 2884 * SYNCHRONIZE_CACHE isn't supported by UFI, nor should it be 2885 * required for UFI devices, so it is appropriate to fake 2886 * success. 2887 */ 2888 case SYNCHRONIZE_CACHE: 2889 return (2); 2890 2891 default: 2892 DPRINTF(sc, UDMASS_SCSI, "Unsupported UFI " 2893 "command 0x%02x\n", cmd_ptr[0]); 2894 return (0); /* failure */ 2895 } 2896 2897 bcopy(cmd_ptr, sc->sc_transfer.cmd_data, cmd_len); 2898 return (1); /* success */ 2899 } 2900 2901 /* 2902 * 8070i (ATAPI) specific functions 2903 */ 2904 static uint8_t 2905 umass_atapi_transform(struct umass_softc *sc, uint8_t *cmd_ptr, 2906 uint8_t cmd_len) 2907 { 2908 if ((cmd_len == 0) || 2909 (cmd_len > sizeof(sc->sc_transfer.cmd_data))) { 2910 DPRINTF(sc, UDMASS_SCSI, "Invalid command " 2911 "length: %d bytes\n", cmd_len); 2912 return (0); /* failure */ 2913 } 2914 /* An ATAPI command is always 12 bytes in length. */ 2915 sc->sc_transfer.cmd_len = ATAPI_COMMAND_LENGTH; 2916 2917 /* Zero the command data */ 2918 bzero(sc->sc_transfer.cmd_data, ATAPI_COMMAND_LENGTH); 2919 2920 switch (cmd_ptr[0]) { 2921 /* 2922 * Commands of which the format has been verified. They 2923 * should work. Copy the command into the destination 2924 * buffer. 2925 */ 2926 case INQUIRY: 2927 /* 2928 * some drives wedge when asked for full inquiry 2929 * information. 2930 */ 2931 if (sc->sc_quirks & FORCE_SHORT_INQUIRY) { 2932 bcopy(cmd_ptr, sc->sc_transfer.cmd_data, cmd_len); 2933 2934 sc->sc_transfer.cmd_data[4] = SHORT_INQUIRY_LENGTH; 2935 return (1); 2936 } 2937 break; 2938 2939 case TEST_UNIT_READY: 2940 if (sc->sc_quirks & NO_TEST_UNIT_READY) { 2941 DPRINTF(sc, UDMASS_SCSI, "Converted TEST_UNIT_READY " 2942 "to START_UNIT\n"); 2943 sc->sc_transfer.cmd_data[0] = START_STOP_UNIT; 2944 sc->sc_transfer.cmd_data[4] = SSS_START; 2945 return (1); 2946 } 2947 break; 2948 2949 case REZERO_UNIT: 2950 case REQUEST_SENSE: 2951 case START_STOP_UNIT: 2952 case SEND_DIAGNOSTIC: 2953 case PREVENT_ALLOW: 2954 case READ_CAPACITY: 2955 case READ_10: 2956 case WRITE_10: 2957 case POSITION_TO_ELEMENT: /* SEEK_10 */ 2958 case SYNCHRONIZE_CACHE: 2959 case MODE_SELECT_10: 2960 case MODE_SENSE_10: 2961 case READ_BUFFER: 2962 case 0x42: /* READ_SUBCHANNEL */ 2963 case 0x43: /* READ_TOC */ 2964 case 0x44: /* READ_HEADER */ 2965 case 0x47: /* PLAY_MSF (Play Minute/Second/Frame) */ 2966 case 0x48: /* PLAY_TRACK */ 2967 case 0x49: /* PLAY_TRACK_REL */ 2968 case 0x4b: /* PAUSE */ 2969 case 0x51: /* READ_DISK_INFO */ 2970 case 0x52: /* READ_TRACK_INFO */ 2971 case 0x54: /* SEND_OPC */ 2972 case 0x59: /* READ_MASTER_CUE */ 2973 case 0x5b: /* CLOSE_TR_SESSION */ 2974 case 0x5c: /* READ_BUFFER_CAP */ 2975 case 0x5d: /* SEND_CUE_SHEET */ 2976 case 0xa1: /* BLANK */ 2977 case 0xa5: /* PLAY_12 */ 2978 case 0xa6: /* EXCHANGE_MEDIUM */ 2979 case 0xad: /* READ_DVD_STRUCTURE */ 2980 case 0xbb: /* SET_CD_SPEED */ 2981 case 0xe5: /* READ_TRACK_INFO_PHILIPS */ 2982 break; 2983 2984 case READ_12: 2985 case WRITE_12: 2986 default: 2987 DPRINTF(sc, UDMASS_SCSI, "Unsupported ATAPI " 2988 "command 0x%02x - trying anyway\n", 2989 cmd_ptr[0]); 2990 break; 2991 } 2992 2993 bcopy(cmd_ptr, sc->sc_transfer.cmd_data, cmd_len); 2994 return (1); /* success */ 2995 } 2996 2997 static uint8_t 2998 umass_no_transform(struct umass_softc *sc, uint8_t *cmd, 2999 uint8_t cmdlen) 3000 { 3001 return (0); /* failure */ 3002 } 3003 3004 static uint8_t 3005 umass_std_transform(struct umass_softc *sc, union ccb *ccb, 3006 uint8_t *cmd, uint8_t cmdlen) 3007 { 3008 uint8_t retval; 3009 3010 retval = (sc->sc_transform) (sc, cmd, cmdlen); 3011 3012 if (retval == 2) { 3013 ccb->ccb_h.status = CAM_REQ_CMP; 3014 xpt_done(ccb); 3015 return (0); 3016 } else if (retval == 0) { 3017 ccb->ccb_h.status = CAM_REQ_INVALID; 3018 xpt_done(ccb); 3019 return (0); 3020 } 3021 /* Command should be executed */ 3022 return (1); 3023 } 3024 3025 #ifdef USB_DEBUG 3026 static void 3027 umass_bbb_dump_cbw(struct umass_softc *sc, umass_bbb_cbw_t *cbw) 3028 { 3029 uint8_t *c = cbw->CBWCDB; 3030 3031 uint32_t dlen = UGETDW(cbw->dCBWDataTransferLength); 3032 uint32_t tag = UGETDW(cbw->dCBWTag); 3033 3034 uint8_t clen = cbw->bCDBLength; 3035 uint8_t flags = cbw->bCBWFlags; 3036 uint8_t lun = cbw->bCBWLUN; 3037 3038 DPRINTF(sc, UDMASS_BBB, "CBW %d: cmd = %db " 3039 "(0x%02x%02x%02x%02x%02x%02x%s), " 3040 "data = %db, lun = %d, dir = %s\n", 3041 tag, clen, 3042 c[0], c[1], c[2], c[3], c[4], c[5], (clen > 6 ? "..." : ""), 3043 dlen, lun, (flags == CBWFLAGS_IN ? "in" : 3044 (flags == CBWFLAGS_OUT ? "out" : "<invalid>"))); 3045 } 3046 3047 static void 3048 umass_bbb_dump_csw(struct umass_softc *sc, umass_bbb_csw_t *csw) 3049 { 3050 uint32_t sig = UGETDW(csw->dCSWSignature); 3051 uint32_t tag = UGETDW(csw->dCSWTag); 3052 uint32_t res = UGETDW(csw->dCSWDataResidue); 3053 uint8_t status = csw->bCSWStatus; 3054 3055 DPRINTF(sc, UDMASS_BBB, "CSW %d: sig = 0x%08x (%s), tag = 0x%08x, " 3056 "res = %d, status = 0x%02x (%s)\n", 3057 tag, sig, (sig == CSWSIGNATURE ? "valid" : "invalid"), 3058 tag, res, 3059 status, (status == CSWSTATUS_GOOD ? "good" : 3060 (status == CSWSTATUS_FAILED ? "failed" : 3061 (status == CSWSTATUS_PHASE ? "phase" : "<invalid>")))); 3062 } 3063 3064 static void 3065 umass_cbi_dump_cmd(struct umass_softc *sc, void *cmd, uint8_t cmdlen) 3066 { 3067 uint8_t *c = cmd; 3068 uint8_t dir = sc->sc_transfer.dir; 3069 3070 DPRINTF(sc, UDMASS_BBB, "cmd = %db " 3071 "(0x%02x%02x%02x%02x%02x%02x%s), " 3072 "data = %db, dir = %s\n", 3073 cmdlen, 3074 c[0], c[1], c[2], c[3], c[4], c[5], (cmdlen > 6 ? "..." : ""), 3075 sc->sc_transfer.data_len, 3076 (dir == DIR_IN ? "in" : 3077 (dir == DIR_OUT ? "out" : 3078 (dir == DIR_NONE ? "no data phase" : "<invalid>")))); 3079 } 3080 3081 static void 3082 umass_dump_buffer(struct umass_softc *sc, uint8_t *buffer, uint32_t buflen, 3083 uint32_t printlen) 3084 { 3085 uint32_t i, j; 3086 char s1[40]; 3087 char s2[40]; 3088 char s3[5]; 3089 3090 s1[0] = '\0'; 3091 s3[0] = '\0'; 3092 3093 sprintf(s2, " buffer=%p, buflen=%d", buffer, buflen); 3094 for (i = 0; (i < buflen) && (i < printlen); i++) { 3095 j = i % 16; 3096 if (j == 0 && i != 0) { 3097 DPRINTF(sc, UDMASS_GEN, "0x %s%s\n", 3098 s1, s2); 3099 s2[0] = '\0'; 3100 } 3101 sprintf(&s1[j * 2], "%02x", buffer[i] & 0xff); 3102 } 3103 if (buflen > printlen) 3104 sprintf(s3, " ..."); 3105 DPRINTF(sc, UDMASS_GEN, "0x %s%s%s\n", 3106 s1, s2, s3); 3107 } 3108 3109 #endif 3110