Now available: The Design and Implementation of the FreeBSD Operating System (Second Edition)
[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]
FreeBSD/Linux Kernel Cross Reference
sys/dev/usb/umass.c
Version:
- FREEBSD - FREEBSD-13-STABLE - FREEBSD-13-0 - FREEBSD-12-STABLE - FREEBSD-12-0 - FREEBSD-11-STABLE - FREEBSD-11-0 - FREEBSD-10-STABLE - FREEBSD-10-0 - FREEBSD-9-STABLE - FREEBSD-9-0 - FREEBSD-8-STABLE - FREEBSD-8-0 - FREEBSD-7-STABLE - FREEBSD-7-0 - FREEBSD-6-STABLE - FREEBSD-6-0 - FREEBSD-5-STABLE - FREEBSD-5-0 - FREEBSD-4-STABLE - FREEBSD-3-STABLE - FREEBSD22 - l41 - OPENBSD - linux-2.6 - MK84 - PLAN9 - xnu-8792
SearchContext: - none - 3 - 10
SearchContext: - none - 3 - 10
1 /*- 2 * Copyright (c) 1999 MAEKAWA Masahide <bishop@rr.iij4u.or.jp>, 3 * Nick Hibma <n_hibma@freebsd.org> 4 * All rights reserved. 5 * 6 * Redistribution and use in source and binary forms, with or without 7 * modification, are permitted provided that the following conditions 8 * are met: 9 * 1. Redistributions of source code must retain the above copyright 10 * notice, this list of conditions and the following disclaimer. 11 * 2. Redistributions in binary form must reproduce the above copyright 12 * notice, this list of conditions and the following disclaimer in the 13 * documentation and/or other materials provided with the distribution. 14 * 15 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND 16 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 17 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 18 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE 19 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 20 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 21 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 22 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 23 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 24 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 25 * SUCH DAMAGE. 26 * 27 * $FreeBSD: releng/7.3/sys/dev/usb/umass.c 195528 2009-07-10 06:55:30Z delphij $ 28 * $NetBSD: umass.c,v 1.28 2000/04/02 23:46:53 augustss Exp $ 29 */ 30 31 /* Also already merged from NetBSD: 32 * $NetBSD: umass.c,v 1.67 2001/11/25 19:05:22 augustss Exp $ 33 * $NetBSD: umass.c,v 1.90 2002/11/04 19:17:33 pooka Exp $ 34 * $NetBSD: umass.c,v 1.108 2003/11/07 17:03:25 wiz Exp $ 35 * $NetBSD: umass.c,v 1.109 2003/12/04 13:57:31 keihan Exp $ 36 */ 37 38 /* 39 * Universal Serial Bus Mass Storage Class specs: 40 * http://www.usb.org/developers/devclass_docs/usb_msc_overview_1.2.pdf 41 * http://www.usb.org/developers/devclass_docs/usbmassbulk_10.pdf 42 * http://www.usb.org/developers/devclass_docs/usb_msc_cbi_1.1.pdf 43 * http://www.usb.org/developers/devclass_docs/usbmass-ufi10.pdf 44 */ 45 46 /* 47 * Ported to NetBSD by Lennart Augustsson <augustss@NetBSD.org>. 48 * Parts of the code written by Jason R. Thorpe <thorpej@shagadelic.org>. 49 */ 50 51 /* 52 * The driver handles 3 Wire Protocols 53 * - Command/Bulk/Interrupt (CBI) 54 * - Command/Bulk/Interrupt with Command Completion Interrupt (CBI with CCI) 55 * - Mass Storage Bulk-Only (BBB) 56 * (BBB refers Bulk/Bulk/Bulk for Command/Data/Status phases) 57 * 58 * Over these wire protocols it handles the following command protocols 59 * - SCSI 60 * - UFI (floppy command set) 61 * - 8070i (ATAPI) 62 * 63 * UFI and 8070i (ATAPI) are transformed versions of the SCSI command set. The 64 * sc->transform method is used to convert the commands into the appropriate 65 * format (if at all necessary). For example, UFI requires all commands to be 66 * 12 bytes in length amongst other things. 67 * 68 * The source code below is marked and can be split into a number of pieces 69 * (in this order): 70 * 71 * - probe/attach/detach 72 * - generic transfer routines 73 * - BBB 74 * - CBI 75 * - CBI_I (in addition to functions from CBI) 76 * - CAM (Common Access Method) 77 * - SCSI 78 * - UFI 79 * - 8070i (ATAPI) 80 * 81 * The protocols are implemented using a state machine, for the transfers as 82 * well as for the resets. The state machine is contained in umass_*_state. 83 * The state machine is started through either umass_*_transfer or 84 * umass_*_reset. 85 * 86 * The reason for doing this is a) CAM performs a lot better this way and b) it 87 * avoids using tsleep from interrupt context (for example after a failed 88 * transfer). 89 */ 90 91 /* 92 * The SCSI related part of this driver has been derived from the 93 * dev/ppbus/vpo.c driver, by Nicolas Souchu (nsouch@freebsd.org). 94 * 95 * The CAM layer uses so called actions which are messages sent to the host 96 * adapter for completion. The actions come in through umass_cam_action. The 97 * appropriate block of routines is called depending on the transport protocol 98 * in use. When the transfer has finished, these routines call 99 * umass_cam_cb again to complete the CAM command. 100 */ 101 102 /* 103 * XXX Currently CBI with CCI is not supported because it bombs the system 104 * when the device is detached (low frequency interrupts are detached 105 * too late. 106 */ 107 #undef CBI_I 108 109 #include <sys/param.h> 110 #include <sys/systm.h> 111 #include <sys/kernel.h> 112 #include <sys/module.h> 113 #include <sys/lock.h> 114 #include <sys/mutex.h> 115 #include <sys/bus.h> 116 #include <sys/sysctl.h> 117 118 #include <dev/usb/usb.h> 119 #include <dev/usb/usbdi.h> 120 #include <dev/usb/usbdi_util.h> 121 #include "usbdevs.h" 122 123 #include <cam/cam.h> 124 #include <cam/cam_ccb.h> 125 #include <cam/cam_sim.h> 126 #include <cam/cam_xpt_sim.h> 127 #include <cam/scsi/scsi_all.h> 128 #include <cam/scsi/scsi_da.h> 129 130 #include <cam/cam_periph.h> 131 132 #ifdef USB_DEBUG 133 #define DIF(m, x) if (umassdebug & (m)) do { x ; } while (0) 134 #define DPRINTF(m, x) if (umassdebug & (m)) printf x 135 #define UDMASS_GEN 0x00010000 /* general */ 136 #define UDMASS_SCSI 0x00020000 /* scsi */ 137 #define UDMASS_UFI 0x00040000 /* ufi command set */ 138 #define UDMASS_ATAPI 0x00080000 /* 8070i command set */ 139 #define UDMASS_CMD (UDMASS_SCSI|UDMASS_UFI|UDMASS_ATAPI) 140 #define UDMASS_USB 0x00100000 /* USB general */ 141 #define UDMASS_BBB 0x00200000 /* Bulk-Only transfers */ 142 #define UDMASS_CBI 0x00400000 /* CBI transfers */ 143 #define UDMASS_WIRE (UDMASS_BBB|UDMASS_CBI) 144 #define UDMASS_ALL 0xffff0000 /* all of the above */ 145 int umassdebug = 0; 146 SYSCTL_NODE(_hw_usb, OID_AUTO, umass, CTLFLAG_RW, 0, "USB umass"); 147 SYSCTL_INT(_hw_usb_umass, OID_AUTO, debug, CTLFLAG_RW, 148 &umassdebug, 0, "umass debug level"); 149 #else 150 #define DIF(m, x) /* nop */ 151 #define DPRINTF(m, x) /* nop */ 152 #endif 153 154 155 /* Generic definitions */ 156 157 /* Direction for umass_*_transfer */ 158 #define DIR_NONE 0 159 #define DIR_IN 1 160 #define DIR_OUT 2 161 162 /* device name */ 163 #define DEVNAME "umass" 164 #define DEVNAME_SIM "umass-sim" 165 166 #define UMASS_MAX_TRANSFER_SIZE 65536 167 /* Approximate maximum transfer speeds (assumes 33% overhead). */ 168 #define UMASS_FULL_TRANSFER_SPEED 1000 169 #define UMASS_HIGH_TRANSFER_SPEED 40000 170 #define UMASS_FLOPPY_TRANSFER_SPEED 20 171 172 #define UMASS_TIMEOUT 5000 /* msecs */ 173 174 /* CAM specific definitions */ 175 176 #define UMASS_SCSIID_MAX 1 /* maximum number of drives expected */ 177 #define UMASS_SCSIID_HOST UMASS_SCSIID_MAX 178 179 #define MS_TO_TICKS(ms) ((ms) * hz / 1000) 180 181 182 /* Bulk-Only features */ 183 184 #define UR_BBB_RESET 0xff /* Bulk-Only reset */ 185 #define UR_BBB_GET_MAX_LUN 0xfe /* Get maximum lun */ 186 187 /* Command Block Wrapper */ 188 typedef struct { 189 uDWord dCBWSignature; 190 # define CBWSIGNATURE 0x43425355 191 uDWord dCBWTag; 192 uDWord dCBWDataTransferLength; 193 uByte bCBWFlags; 194 # define CBWFLAGS_OUT 0x00 195 # define CBWFLAGS_IN 0x80 196 uByte bCBWLUN; 197 uByte bCDBLength; 198 # define CBWCDBLENGTH 16 199 uByte CBWCDB[CBWCDBLENGTH]; 200 } umass_bbb_cbw_t; 201 #define UMASS_BBB_CBW_SIZE 31 202 203 /* Command Status Wrapper */ 204 typedef struct { 205 uDWord dCSWSignature; 206 # define CSWSIGNATURE 0x53425355 207 # define CSWSIGNATURE_IMAGINATION_DBX1 0x43425355 208 # define CSWSIGNATURE_OLYMPUS_C1 0x55425355 209 uDWord dCSWTag; 210 uDWord dCSWDataResidue; 211 uByte bCSWStatus; 212 # define CSWSTATUS_GOOD 0x0 213 # define CSWSTATUS_FAILED 0x1 214 # define CSWSTATUS_PHASE 0x2 215 } umass_bbb_csw_t; 216 #define UMASS_BBB_CSW_SIZE 13 217 218 /* CBI features */ 219 220 #define UR_CBI_ADSC 0x00 221 222 typedef unsigned char umass_cbi_cbl_t[16]; /* Command block */ 223 224 typedef union { 225 struct { 226 unsigned char type; 227 #define IDB_TYPE_CCI 0x00 228 unsigned char value; 229 #define IDB_VALUE_PASS 0x00 230 #define IDB_VALUE_FAIL 0x01 231 #define IDB_VALUE_PHASE 0x02 232 #define IDB_VALUE_PERSISTENT 0x03 233 #define IDB_VALUE_STATUS_MASK 0x03 234 } common; 235 236 struct { 237 unsigned char asc; 238 unsigned char ascq; 239 } ufi; 240 } umass_cbi_sbl_t; 241 242 243 244 struct umass_softc; /* see below */ 245 246 typedef void (*transfer_cb_f) (struct umass_softc *sc, void *priv, 247 int residue, int status); 248 #define STATUS_CMD_OK 0 /* everything ok */ 249 #define STATUS_CMD_UNKNOWN 1 /* will have to fetch sense */ 250 #define STATUS_CMD_FAILED 2 /* transfer was ok, command failed */ 251 #define STATUS_WIRE_FAILED 3 /* couldn't even get command across */ 252 253 typedef void (*wire_reset_f) (struct umass_softc *sc, int status); 254 typedef void (*wire_transfer_f) (struct umass_softc *sc, int lun, 255 void *cmd, int cmdlen, void *data, int datalen, 256 int dir, u_int timeout, transfer_cb_f cb, void *priv); 257 typedef void (*wire_state_f) (usbd_xfer_handle xfer, 258 usbd_private_handle priv, usbd_status err); 259 260 typedef int (*command_transform_f) (struct umass_softc *sc, 261 unsigned char *cmd, int cmdlen, 262 unsigned char **rcmd, int *rcmdlen); 263 264 265 struct umass_devdescr_t { 266 u_int32_t vid; 267 # define VID_WILDCARD 0xffffffff 268 # define VID_EOT 0xfffffffe 269 u_int32_t pid; 270 # define PID_WILDCARD 0xffffffff 271 # define PID_EOT 0xfffffffe 272 u_int32_t rid; 273 # define RID_WILDCARD 0xffffffff 274 # define RID_EOT 0xfffffffe 275 276 /* wire and command protocol */ 277 u_int16_t proto; 278 # define UMASS_PROTO_BBB 0x0001 /* USB wire protocol */ 279 # define UMASS_PROTO_CBI 0x0002 280 # define UMASS_PROTO_CBI_I 0x0004 281 # define UMASS_PROTO_WIRE 0x00ff /* USB wire protocol mask */ 282 # define UMASS_PROTO_SCSI 0x0100 /* command protocol */ 283 # define UMASS_PROTO_ATAPI 0x0200 284 # define UMASS_PROTO_UFI 0x0400 285 # define UMASS_PROTO_RBC 0x0800 286 # define UMASS_PROTO_COMMAND 0xff00 /* command protocol mask */ 287 288 /* Device specific quirks */ 289 u_int16_t quirks; 290 # define NO_QUIRKS 0x0000 291 /* The drive does not support Test Unit Ready. Convert to Start Unit 292 */ 293 # define NO_TEST_UNIT_READY 0x0001 294 /* The drive does not reset the Unit Attention state after REQUEST 295 * SENSE has been sent. The INQUIRY command does not reset the UA 296 * either, and so CAM runs in circles trying to retrieve the initial 297 * INQUIRY data. 298 */ 299 # define RS_NO_CLEAR_UA 0x0002 300 /* The drive does not support START STOP. */ 301 # define NO_START_STOP 0x0004 302 /* Don't ask for full inquiry data (255b). */ 303 # define FORCE_SHORT_INQUIRY 0x0008 304 /* Needs to be initialised the Shuttle way */ 305 # define SHUTTLE_INIT 0x0010 306 /* Drive needs to be switched to alternate iface 1 */ 307 # define ALT_IFACE_1 0x0020 308 /* Drive does not do 1Mb/s, but just floppy speeds (20kb/s) */ 309 # define FLOPPY_SPEED 0x0040 310 /* The device can't count and gets the residue of transfers wrong */ 311 # define IGNORE_RESIDUE 0x0080 312 /* No GetMaxLun call */ 313 # define NO_GETMAXLUN 0x0100 314 /* The device uses a weird CSWSIGNATURE. */ 315 # define WRONG_CSWSIG 0x0200 316 /* Device cannot handle INQUIRY so fake a generic response */ 317 # define NO_INQUIRY 0x0400 318 /* Device cannot handle INQUIRY EVPD, return CHECK CONDITION */ 319 # define NO_INQUIRY_EVPD 0x0800 320 /* Pad all RBC requests to 12 bytes. */ 321 # define RBC_PAD_TO_12 0x1000 322 /* Device reports number of sectors from READ_CAPACITY, not max 323 * sector number. 324 */ 325 # define READ_CAPACITY_OFFBY1 0x2000 326 /* Device cannot handle a SCSI synchronize cache command. Normally 327 * this quirk would be handled in the cam layer, but for IDE bridges 328 * we need to associate the quirk with the bridge and not the 329 * underlying disk device. This is handled by faking a success result. 330 */ 331 # define NO_SYNCHRONIZE_CACHE 0x4000 332 }; 333 334 static struct umass_devdescr_t umass_devdescrs[] = { 335 { USB_VENDOR_ADDONICS2, USB_PRODUCT_ADDONICS2_CABLE_205, RID_WILDCARD, 336 UMASS_PROTO_SCSI | UMASS_PROTO_BBB, 337 NO_QUIRKS 338 }, 339 { USB_VENDOR_AIPTEK, USB_PRODUCT_AIPTEK_POCKETCAM3M, RID_WILDCARD, 340 UMASS_PROTO_SCSI | UMASS_PROTO_BBB, 341 NO_QUIRKS 342 }, 343 { USB_VENDOR_ALCOR, USB_PRODUCT_ALCOR_TRANSCEND, RID_WILDCARD, 344 UMASS_PROTO_SCSI | UMASS_PROTO_BBB, 345 NO_GETMAXLUN 346 }, 347 { USB_VENDOR_ALCOR, USB_PRODUCT_ALCOR_UMCR_9361, RID_WILDCARD, 348 UMASS_PROTO_SCSI | UMASS_PROTO_BBB, 349 NO_GETMAXLUN 350 }, 351 { USB_VENDOR_ASAHIOPTICAL, USB_PRODUCT_ASAHIOPTICAL_OPTIO230, RID_WILDCARD, 352 UMASS_PROTO_SCSI | UMASS_PROTO_BBB, 353 NO_INQUIRY 354 }, 355 { USB_VENDOR_ASAHIOPTICAL, USB_PRODUCT_ASAHIOPTICAL_OPTIO330, RID_WILDCARD, 356 UMASS_PROTO_SCSI | UMASS_PROTO_BBB, 357 NO_INQUIRY 358 }, 359 { USB_VENDOR_ASAHIOPTICAL, PID_WILDCARD, RID_WILDCARD, 360 UMASS_PROTO_ATAPI | UMASS_PROTO_CBI_I, 361 RS_NO_CLEAR_UA 362 }, 363 { USB_VENDOR_ADDON, USB_PRODUCT_ADDON_ATTACHE, RID_WILDCARD, 364 UMASS_PROTO_SCSI | UMASS_PROTO_BBB, 365 IGNORE_RESIDUE 366 }, 367 { USB_VENDOR_ADDON, USB_PRODUCT_ADDON_A256MB, RID_WILDCARD, 368 UMASS_PROTO_SCSI | UMASS_PROTO_BBB, 369 IGNORE_RESIDUE 370 }, 371 { USB_VENDOR_ADDON, USB_PRODUCT_ADDON_DISKPRO512, RID_WILDCARD, 372 UMASS_PROTO_SCSI | UMASS_PROTO_BBB, 373 IGNORE_RESIDUE 374 }, 375 { USB_VENDOR_BELKIN, USB_PRODUCT_BELKIN_USB2SCSI, RID_WILDCARD, 376 UMASS_PROTO_SCSI | UMASS_PROTO_BBB, 377 NO_QUIRKS 378 }, 379 { USB_VENDOR_CASIO, USB_PRODUCT_CASIO_QV_DIGICAM, RID_WILDCARD, 380 UMASS_PROTO_SCSI | UMASS_PROTO_CBI, 381 NO_INQUIRY 382 }, 383 { USB_VENDOR_CCYU, USB_PRODUCT_CCYU_ED1064, RID_WILDCARD, 384 UMASS_PROTO_SCSI | UMASS_PROTO_BBB, 385 NO_QUIRKS 386 }, 387 { USB_VENDOR_CENTURY, USB_PRODUCT_CENTURY_EX35QUAT, RID_WILDCARD, 388 UMASS_PROTO_SCSI | UMASS_PROTO_BBB, 389 FORCE_SHORT_INQUIRY | NO_START_STOP | IGNORE_RESIDUE 390 }, 391 { USB_VENDOR_DESKNOTE, USB_PRODUCT_DESKNOTE_UCR_61S2B, RID_WILDCARD, 392 UMASS_PROTO_SCSI | UMASS_PROTO_BBB, 393 NO_QUIRKS 394 }, 395 { USB_VENDOR_DMI, USB_PRODUCT_DMI_CFSM_RW, RID_WILDCARD, 396 UMASS_PROTO_SCSI, 397 NO_GETMAXLUN 398 }, 399 { USB_VENDOR_EPSON, USB_PRODUCT_EPSON_STYLUS_875DC, RID_WILDCARD, 400 UMASS_PROTO_SCSI | UMASS_PROTO_CBI, 401 NO_INQUIRY 402 }, 403 { USB_VENDOR_EPSON, USB_PRODUCT_EPSON_STYLUS_895, RID_WILDCARD, 404 UMASS_PROTO_SCSI | UMASS_PROTO_BBB, 405 NO_GETMAXLUN 406 }, 407 { USB_VENDOR_FEIYA, USB_PRODUCT_FEIYA_5IN1, RID_WILDCARD, 408 UMASS_PROTO_SCSI | UMASS_PROTO_BBB, 409 NO_QUIRKS 410 }, 411 { USB_VENDOR_FREECOM, USB_PRODUCT_FREECOM_DVD, RID_WILDCARD, 412 UMASS_PROTO_SCSI, 413 NO_QUIRKS 414 }, 415 { USB_VENDOR_FUJIPHOTO, USB_PRODUCT_FUJIPHOTO_MASS0100, RID_WILDCARD, 416 UMASS_PROTO_ATAPI | UMASS_PROTO_CBI_I, 417 RS_NO_CLEAR_UA 418 }, 419 { USB_VENDOR_GENESYS, USB_PRODUCT_GENESYS_GL641USB2IDE, RID_WILDCARD, 420 UMASS_PROTO_SCSI | UMASS_PROTO_BBB, 421 FORCE_SHORT_INQUIRY | NO_START_STOP | IGNORE_RESIDUE | 422 NO_SYNCHRONIZE_CACHE 423 }, 424 { USB_VENDOR_GENESYS, USB_PRODUCT_GENESYS_GL641USB2IDE_2, RID_WILDCARD, 425 UMASS_PROTO_ATAPI | UMASS_PROTO_BBB, 426 FORCE_SHORT_INQUIRY | NO_START_STOP | IGNORE_RESIDUE 427 }, 428 { USB_VENDOR_GENESYS, USB_PRODUCT_GENESYS_GL641USB, RID_WILDCARD, 429 UMASS_PROTO_SCSI | UMASS_PROTO_BBB, 430 FORCE_SHORT_INQUIRY | NO_START_STOP | IGNORE_RESIDUE 431 }, 432 { USB_VENDOR_GENESYS, USB_PRODUCT_GENESYS_GL641USB_2, RID_WILDCARD, 433 UMASS_PROTO_SCSI | UMASS_PROTO_BBB, 434 WRONG_CSWSIG 435 }, 436 { USB_VENDOR_HAGIWARA, USB_PRODUCT_HAGIWARA_FG, RID_WILDCARD, 437 UMASS_PROTO_SCSI | UMASS_PROTO_BBB, 438 NO_QUIRKS 439 }, 440 { USB_VENDOR_HAGIWARA, USB_PRODUCT_HAGIWARA_FGSM, RID_WILDCARD, 441 UMASS_PROTO_SCSI | UMASS_PROTO_BBB, 442 NO_QUIRKS 443 }, 444 { USB_VENDOR_HITACHI, USB_PRODUCT_HITACHI_DVDCAM_USB, RID_WILDCARD, 445 UMASS_PROTO_ATAPI | UMASS_PROTO_CBI_I, 446 NO_INQUIRY 447 }, 448 { USB_VENDOR_HITACHI, USB_PRODUCT_HITACHI_DVDCAM_DZ_MV100A, RID_WILDCARD, 449 UMASS_PROTO_SCSI | UMASS_PROTO_CBI, 450 NO_GETMAXLUN 451 }, 452 { USB_VENDOR_HP, USB_PRODUCT_HP_CDW4E, RID_WILDCARD, 453 UMASS_PROTO_ATAPI, 454 NO_QUIRKS 455 }, 456 { USB_VENDOR_HP, USB_PRODUCT_HP_CDW8200, RID_WILDCARD, 457 UMASS_PROTO_ATAPI | UMASS_PROTO_CBI_I, 458 NO_TEST_UNIT_READY | NO_START_STOP 459 }, 460 { USB_VENDOR_IMAGINATION, USB_PRODUCT_IMAGINATION_DBX1, RID_WILDCARD, 461 UMASS_PROTO_SCSI | UMASS_PROTO_BBB, 462 WRONG_CSWSIG 463 }, 464 { USB_VENDOR_INSYSTEM, USB_PRODUCT_INSYSTEM_ATAPI, RID_WILDCARD, 465 UMASS_PROTO_RBC | UMASS_PROTO_CBI, 466 NO_QUIRKS 467 }, 468 { USB_VENDOR_INSYSTEM, USB_PRODUCT_INSYSTEM_STORAGE_V2, RID_WILDCARD, 469 UMASS_PROTO_RBC | UMASS_PROTO_CBI, 470 NO_QUIRKS 471 }, 472 { USB_VENDOR_INSYSTEM, USB_PRODUCT_INSYSTEM_USBCABLE, RID_WILDCARD, 473 UMASS_PROTO_ATAPI | UMASS_PROTO_CBI, 474 NO_TEST_UNIT_READY | NO_START_STOP | ALT_IFACE_1 475 }, 476 { USB_VENDOR_IODATA, USB_PRODUCT_IODATA_IU_CD2, RID_WILDCARD, 477 UMASS_PROTO_SCSI | UMASS_PROTO_BBB, 478 NO_QUIRKS 479 }, 480 { USB_VENDOR_IODATA, USB_PRODUCT_IODATA_DVR_UEH8, RID_WILDCARD, 481 UMASS_PROTO_SCSI | UMASS_PROTO_BBB, 482 NO_QUIRKS 483 }, 484 { USB_VENDOR_IOMEGA, USB_PRODUCT_IOMEGA_ZIP100, RID_WILDCARD, 485 /* XXX This is not correct as there are Zip drives that use ATAPI. 486 */ 487 UMASS_PROTO_SCSI | UMASS_PROTO_BBB, 488 NO_TEST_UNIT_READY 489 }, 490 { USB_VENDOR_KYOCERA, USB_PRODUCT_KYOCERA_FINECAM_L3, RID_WILDCARD, 491 UMASS_PROTO_SCSI | UMASS_PROTO_BBB, 492 NO_INQUIRY 493 }, 494 { USB_VENDOR_KYOCERA, USB_PRODUCT_KYOCERA_FINECAM_S3X, RID_WILDCARD, 495 UMASS_PROTO_ATAPI | UMASS_PROTO_CBI, 496 NO_INQUIRY 497 }, 498 { USB_VENDOR_KYOCERA, USB_PRODUCT_KYOCERA_FINECAM_S4, RID_WILDCARD, 499 UMASS_PROTO_ATAPI | UMASS_PROTO_CBI, 500 NO_INQUIRY 501 }, 502 { USB_VENDOR_KYOCERA, USB_PRODUCT_KYOCERA_FINECAM_S5, RID_WILDCARD, 503 UMASS_PROTO_SCSI | UMASS_PROTO_BBB, 504 NO_INQUIRY 505 }, 506 { USB_VENDOR_LACIE, USB_PRODUCT_LACIE_HD, RID_WILDCARD, 507 UMASS_PROTO_RBC | UMASS_PROTO_CBI, 508 NO_QUIRKS 509 }, 510 { USB_VENDOR_LEXAR, USB_PRODUCT_LEXAR_CF_READER, RID_WILDCARD, 511 UMASS_PROTO_SCSI | UMASS_PROTO_BBB, 512 NO_INQUIRY 513 }, 514 { USB_VENDOR_LEXAR, USB_PRODUCT_LEXAR_JUMPSHOT, RID_WILDCARD, 515 UMASS_PROTO_SCSI, 516 NO_QUIRKS 517 }, 518 { USB_VENDOR_LOGITEC, USB_PRODUCT_LOGITEC_LDR_H443SU2, RID_WILDCARD, 519 UMASS_PROTO_SCSI, 520 NO_QUIRKS 521 }, 522 { USB_VENDOR_LOGITEC, USB_PRODUCT_LOGITEC_LDR_H443U2, RID_WILDCARD, 523 UMASS_PROTO_SCSI | UMASS_PROTO_BBB, 524 NO_QUIRKS 525 }, 526 { USB_VENDOR_MELCO, USB_PRODUCT_MELCO_DUBPXXG, RID_WILDCARD, 527 UMASS_PROTO_SCSI | UMASS_PROTO_BBB, 528 FORCE_SHORT_INQUIRY | NO_START_STOP | IGNORE_RESIDUE 529 }, 530 { USB_VENDOR_MICROTECH, USB_PRODUCT_MICROTECH_DPCM, RID_WILDCARD, 531 UMASS_PROTO_SCSI | UMASS_PROTO_CBI, 532 NO_TEST_UNIT_READY | NO_START_STOP 533 }, 534 { USB_VENDOR_MICROTECH, USB_PRODUCT_MICROTECH_SCSIDB25, RID_WILDCARD, 535 UMASS_PROTO_SCSI | UMASS_PROTO_BBB, 536 NO_QUIRKS 537 }, 538 { USB_VENDOR_MICROTECH, USB_PRODUCT_MICROTECH_SCSIHD50, RID_WILDCARD, 539 UMASS_PROTO_SCSI | UMASS_PROTO_BBB, 540 NO_QUIRKS 541 }, 542 { USB_VENDOR_MINOLTA, USB_PRODUCT_MINOLTA_E223, RID_WILDCARD, 543 UMASS_PROTO_SCSI, 544 NO_QUIRKS 545 }, 546 { USB_VENDOR_MINOLTA, USB_PRODUCT_MINOLTA_F300, RID_WILDCARD, 547 UMASS_PROTO_SCSI | UMASS_PROTO_BBB, 548 NO_QUIRKS 549 }, 550 { USB_VENDOR_MITSUMI, USB_PRODUCT_MITSUMI_CDRRW, RID_WILDCARD, 551 UMASS_PROTO_ATAPI | UMASS_PROTO_CBI, 552 NO_QUIRKS 553 }, 554 { USB_VENDOR_MITSUMI, USB_PRODUCT_MITSUMI_FDD, RID_WILDCARD, 555 UMASS_PROTO_SCSI | UMASS_PROTO_BBB, 556 NO_GETMAXLUN 557 }, 558 { USB_VENDOR_MOTOROLA2, USB_PRODUCT_MOTOROLA2_E398, RID_WILDCARD, 559 UMASS_PROTO_SCSI | UMASS_PROTO_BBB, 560 FORCE_SHORT_INQUIRY | NO_INQUIRY_EVPD | NO_GETMAXLUN 561 }, 562 { USB_VENDOR_MSYSTEMS, USB_PRODUCT_MSYSTEMS_DISKONKEY, RID_WILDCARD, 563 UMASS_PROTO_SCSI | UMASS_PROTO_BBB, 564 IGNORE_RESIDUE | NO_GETMAXLUN | RS_NO_CLEAR_UA 565 }, 566 { USB_VENDOR_MSYSTEMS, USB_PRODUCT_MSYSTEMS_DISKONKEY2, RID_WILDCARD, 567 UMASS_PROTO_ATAPI | UMASS_PROTO_BBB, 568 NO_QUIRKS 569 }, 570 { USB_VENDOR_MYSON, USB_PRODUCT_MYSON_HEDEN, RID_WILDCARD, 571 UMASS_PROTO_SCSI | UMASS_PROTO_BBB, 572 NO_INQUIRY | IGNORE_RESIDUE | NO_SYNCHRONIZE_CACHE 573 }, 574 { USB_VENDOR_MYSON, USB_PRODUCT_MYSON_STARREADER, RID_WILDCARD, 575 UMASS_PROTO_SCSI | UMASS_PROTO_BBB, 576 NO_SYNCHRONIZE_CACHE 577 }, 578 { USB_VENDOR_NEODIO, USB_PRODUCT_NEODIO_ND3260, RID_WILDCARD, 579 UMASS_PROTO_SCSI | UMASS_PROTO_BBB, 580 FORCE_SHORT_INQUIRY 581 }, 582 { USB_VENDOR_NETAC, USB_PRODUCT_NETAC_CF_CARD, RID_WILDCARD, 583 UMASS_PROTO_SCSI | UMASS_PROTO_BBB, 584 NO_INQUIRY 585 }, 586 { USB_VENDOR_NETAC, USB_PRODUCT_NETAC_ONLYDISK, RID_WILDCARD, 587 UMASS_PROTO_SCSI | UMASS_PROTO_BBB, 588 IGNORE_RESIDUE 589 }, 590 { USB_VENDOR_NETCHIP, USB_PRODUCT_NETCHIP_CLIK_40, RID_WILDCARD, 591 UMASS_PROTO_ATAPI, 592 NO_INQUIRY 593 }, 594 { USB_VENDOR_NIKON, USB_PRODUCT_NIKON_D300, RID_WILDCARD, 595 UMASS_PROTO_SCSI | UMASS_PROTO_BBB, 596 NO_QUIRKS 597 }, 598 { USB_VENDOR_OLYMPUS, USB_PRODUCT_OLYMPUS_C1, RID_WILDCARD, 599 UMASS_PROTO_SCSI | UMASS_PROTO_BBB, 600 WRONG_CSWSIG 601 }, 602 { USB_VENDOR_OLYMPUS, USB_PRODUCT_OLYMPUS_C700, RID_WILDCARD, 603 UMASS_PROTO_SCSI, 604 NO_GETMAXLUN 605 }, 606 { USB_VENDOR_ONSPEC, USB_PRODUCT_ONSPEC_CFMS_RW, RID_WILDCARD, 607 UMASS_PROTO_SCSI, 608 NO_QUIRKS 609 }, 610 { USB_VENDOR_ONSPEC, USB_PRODUCT_ONSPEC_CFSM_COMBO, RID_WILDCARD, 611 UMASS_PROTO_SCSI, 612 NO_QUIRKS 613 }, 614 { USB_VENDOR_ONSPEC, USB_PRODUCT_ONSPEC_CFSM_READER, RID_WILDCARD, 615 UMASS_PROTO_SCSI, 616 NO_QUIRKS 617 }, 618 { USB_VENDOR_ONSPEC, USB_PRODUCT_ONSPEC_CFSM_READER2, RID_WILDCARD, 619 UMASS_PROTO_SCSI, 620 NO_QUIRKS 621 }, 622 { USB_VENDOR_ONSPEC, USB_PRODUCT_ONSPEC_SDS_HOTFIND_D, RID_WILDCARD, 623 UMASS_PROTO_SCSI | UMASS_PROTO_BBB, 624 NO_GETMAXLUN | NO_SYNCHRONIZE_CACHE 625 }, 626 { USB_VENDOR_ONSPEC, USB_PRODUCT_ONSPEC_MDCFE_B_CF_READER, RID_WILDCARD, 627 UMASS_PROTO_SCSI, 628 NO_QUIRKS 629 }, 630 { USB_VENDOR_ONSPEC, USB_PRODUCT_ONSPEC_MDSM_B_READER, RID_WILDCARD, 631 UMASS_PROTO_SCSI, 632 NO_INQUIRY 633 }, 634 { USB_VENDOR_ONSPEC, USB_PRODUCT_ONSPEC_READER, RID_WILDCARD, 635 UMASS_PROTO_SCSI, 636 NO_QUIRKS 637 }, 638 { USB_VENDOR_ONSPEC, USB_PRODUCT_ONSPEC_UCF100, RID_WILDCARD, 639 UMASS_PROTO_ATAPI | UMASS_PROTO_BBB, 640 NO_INQUIRY | NO_GETMAXLUN 641 }, 642 { USB_VENDOR_ONSPEC2, USB_PRODUCT_ONSPEC2_IMAGEMATE_SDDR55, RID_WILDCARD, 643 UMASS_PROTO_SCSI, 644 NO_GETMAXLUN 645 }, 646 { USB_VENDOR_PANASONIC, USB_PRODUCT_PANASONIC_KXL840AN, RID_WILDCARD, 647 UMASS_PROTO_ATAPI | UMASS_PROTO_BBB, 648 NO_GETMAXLUN 649 }, 650 { USB_VENDOR_PANASONIC, USB_PRODUCT_PANASONIC_KXLCB20AN, RID_WILDCARD, 651 UMASS_PROTO_SCSI | UMASS_PROTO_BBB, 652 NO_QUIRKS 653 }, 654 { USB_VENDOR_PANASONIC, USB_PRODUCT_PANASONIC_KXLCB35AN, RID_WILDCARD, 655 UMASS_PROTO_SCSI | UMASS_PROTO_BBB, 656 NO_QUIRKS 657 }, 658 { USB_VENDOR_PANASONIC, USB_PRODUCT_PANASONIC_LS120CAM, RID_WILDCARD, 659 UMASS_PROTO_UFI, 660 NO_QUIRKS 661 }, 662 { USB_VENDOR_PLEXTOR, USB_PRODUCT_PLEXTOR_40_12_40U, RID_WILDCARD, 663 UMASS_PROTO_SCSI | UMASS_PROTO_BBB, 664 NO_TEST_UNIT_READY 665 }, 666 { USB_VENDOR_PNY, USB_PRODUCT_PNY_ATTACHE2, RID_WILDCARD, 667 UMASS_PROTO_SCSI | UMASS_PROTO_BBB, 668 IGNORE_RESIDUE | NO_START_STOP 669 }, 670 { USB_VENDOR_SAMSUNG, USB_PRODUCT_SAMSUNG_YP_U2, RID_WILDCARD, 671 UMASS_PROTO_SCSI | UMASS_PROTO_BBB, 672 SHUTTLE_INIT | NO_GETMAXLUN 673 }, 674 { USB_VENDOR_SAMSUNG_TECHWIN, USB_PRODUCT_SAMSUNG_TECHWIN_DIGIMAX_410, RID_WILDCARD, 675 UMASS_PROTO_SCSI | UMASS_PROTO_BBB, 676 NO_INQUIRY 677 }, 678 { USB_VENDOR_SANDISK, USB_PRODUCT_SANDISK_SDDR05A, RID_WILDCARD, 679 UMASS_PROTO_SCSI | UMASS_PROTO_CBI, 680 READ_CAPACITY_OFFBY1 | NO_GETMAXLUN 681 }, 682 { USB_VENDOR_SANDISK, USB_PRODUCT_SANDISK_SDDR09, RID_WILDCARD, 683 UMASS_PROTO_SCSI, 684 READ_CAPACITY_OFFBY1 | NO_GETMAXLUN 685 }, 686 { USB_VENDOR_SANDISK, USB_PRODUCT_SANDISK_SDDR12, RID_WILDCARD, 687 UMASS_PROTO_SCSI | UMASS_PROTO_CBI, 688 READ_CAPACITY_OFFBY1 | NO_GETMAXLUN 689 }, 690 { USB_VENDOR_SANDISK, USB_PRODUCT_SANDISK_SDDR31, RID_WILDCARD, 691 UMASS_PROTO_SCSI | UMASS_PROTO_BBB, 692 READ_CAPACITY_OFFBY1 693 }, 694 { USB_VENDOR_SANDISK, USB_PRODUCT_SANDISK_SDCZ2_256, RID_WILDCARD, 695 UMASS_PROTO_SCSI | UMASS_PROTO_BBB, 696 IGNORE_RESIDUE 697 }, 698 { USB_VENDOR_SANDISK, USB_PRODUCT_SANDISK_SDCZ4_128, RID_WILDCARD, 699 UMASS_PROTO_SCSI | UMASS_PROTO_BBB, 700 IGNORE_RESIDUE 701 }, 702 { USB_VENDOR_SANDISK, USB_PRODUCT_SANDISK_SDCZ4_256, RID_WILDCARD, 703 UMASS_PROTO_SCSI | UMASS_PROTO_BBB, 704 IGNORE_RESIDUE 705 }, 706 { USB_VENDOR_SCANLOGIC, USB_PRODUCT_SCANLOGIC_SL11R, RID_WILDCARD, 707 UMASS_PROTO_ATAPI | UMASS_PROTO_BBB, 708 NO_INQUIRY 709 }, 710 { USB_VENDOR_SHUTTLE, USB_PRODUCT_SHUTTLE_CDRW, RID_WILDCARD, 711 UMASS_PROTO_ATAPI | UMASS_PROTO_CBI, 712 NO_QUIRKS 713 }, 714 { USB_VENDOR_SHUTTLE, USB_PRODUCT_SHUTTLE_CF, RID_WILDCARD, 715 UMASS_PROTO_ATAPI | UMASS_PROTO_CBI, 716 NO_QUIRKS 717 }, 718 { USB_VENDOR_SHUTTLE, USB_PRODUCT_SHUTTLE_EUSB, RID_WILDCARD, 719 UMASS_PROTO_ATAPI | UMASS_PROTO_CBI_I, 720 NO_TEST_UNIT_READY | NO_START_STOP | SHUTTLE_INIT 721 }, 722 { USB_VENDOR_SHUTTLE, USB_PRODUCT_SHUTTLE_EUSBATAPI, RID_WILDCARD, 723 UMASS_PROTO_ATAPI | UMASS_PROTO_CBI, 724 NO_QUIRKS 725 }, 726 { USB_VENDOR_SHUTTLE, USB_PRODUCT_SHUTTLE_EUSBCFSM, RID_WILDCARD, 727 UMASS_PROTO_SCSI, 728 NO_QUIRKS 729 }, 730 { USB_VENDOR_SHUTTLE, USB_PRODUCT_SHUTTLE_EUSCSI, RID_WILDCARD, 731 UMASS_PROTO_SCSI | UMASS_PROTO_BBB, 732 NO_QUIRKS 733 }, 734 { USB_VENDOR_SHUTTLE, USB_PRODUCT_SHUTTLE_HIFD, RID_WILDCARD, 735 UMASS_PROTO_SCSI | UMASS_PROTO_CBI, 736 NO_GETMAXLUN 737 }, 738 { USB_VENDOR_SHUTTLE, USB_PRODUCT_SHUTTLE_SDDR09, RID_WILDCARD, 739 UMASS_PROTO_SCSI, 740 NO_GETMAXLUN 741 }, 742 { USB_VENDOR_SHUTTLE, USB_PRODUCT_SHUTTLE_ZIOMMC, RID_WILDCARD, 743 UMASS_PROTO_SCSI | UMASS_PROTO_CBI, 744 NO_GETMAXLUN 745 }, 746 { USB_VENDOR_SIGMATEL, USB_PRODUCT_SIGMATEL_I_BEAD100, RID_WILDCARD, 747 UMASS_PROTO_SCSI | UMASS_PROTO_BBB, 748 SHUTTLE_INIT 749 }, 750 { USB_VENDOR_SIIG, USB_PRODUCT_SIIG_WINTERREADER, RID_WILDCARD, 751 UMASS_PROTO_SCSI | UMASS_PROTO_BBB, 752 IGNORE_RESIDUE 753 }, 754 { USB_VENDOR_SKANHEX, USB_PRODUCT_SKANHEX_MD_7425, RID_WILDCARD, 755 UMASS_PROTO_SCSI | UMASS_PROTO_BBB, 756 NO_INQUIRY 757 }, 758 { USB_VENDOR_SKANHEX, USB_PRODUCT_SKANHEX_SX_520Z, RID_WILDCARD, 759 UMASS_PROTO_SCSI | UMASS_PROTO_BBB, 760 NO_INQUIRY 761 }, 762 { USB_VENDOR_SONY, USB_PRODUCT_SONY_CLIE_40_MS, RID_WILDCARD, 763 UMASS_PROTO_SCSI | UMASS_PROTO_BBB, 764 NO_INQUIRY 765 }, 766 { USB_VENDOR_SONY, USB_PRODUCT_SONY_DSC, 0x0500, 767 UMASS_PROTO_RBC | UMASS_PROTO_CBI, 768 RBC_PAD_TO_12 769 }, 770 { USB_VENDOR_SONY, USB_PRODUCT_SONY_DSC, 0x0600, 771 UMASS_PROTO_RBC | UMASS_PROTO_CBI, 772 RBC_PAD_TO_12 773 }, 774 { USB_VENDOR_SONY, USB_PRODUCT_SONY_DSC, RID_WILDCARD, 775 UMASS_PROTO_RBC | UMASS_PROTO_CBI, 776 NO_QUIRKS 777 }, 778 { USB_VENDOR_SONY, USB_PRODUCT_SONY_HANDYCAM, 0x0500, 779 UMASS_PROTO_RBC | UMASS_PROTO_CBI, 780 RBC_PAD_TO_12 781 }, 782 { USB_VENDOR_SONY, USB_PRODUCT_SONY_HANDYCAM, RID_WILDCARD, 783 UMASS_PROTO_RBC | UMASS_PROTO_CBI, 784 NO_QUIRKS 785 }, 786 { USB_VENDOR_SONY, USB_PRODUCT_SONY_MS_MSC_U03, RID_WILDCARD, 787 UMASS_PROTO_UFI | UMASS_PROTO_CBI, 788 NO_GETMAXLUN 789 }, 790 { USB_VENDOR_SONY, USB_PRODUCT_SONY_MS_NW_MS7, RID_WILDCARD, 791 UMASS_PROTO_SCSI | UMASS_PROTO_BBB, 792 NO_GETMAXLUN 793 }, 794 { USB_VENDOR_SONY, USB_PRODUCT_SONY_MS_PEG_N760C, RID_WILDCARD, 795 UMASS_PROTO_SCSI | UMASS_PROTO_BBB, 796 NO_INQUIRY 797 }, 798 { USB_VENDOR_SONY, USB_PRODUCT_SONY_MSACUS1, RID_WILDCARD, 799 UMASS_PROTO_SCSI | UMASS_PROTO_BBB, 800 NO_GETMAXLUN 801 }, 802 { USB_VENDOR_SONY, USB_PRODUCT_SONY_MSC, RID_WILDCARD, 803 UMASS_PROTO_RBC | UMASS_PROTO_CBI, 804 NO_QUIRKS 805 }, 806 { USB_VENDOR_SONY, USB_PRODUCT_SONY_PORTABLE_HDD_V2, RID_WILDCARD, 807 UMASS_PROTO_SCSI | UMASS_PROTO_BBB, 808 NO_QUIRKS 809 }, 810 { USB_VENDOR_SUPERTOP, USB_PRODUCT_SUPERTOP_IDE, RID_WILDCARD, 811 UMASS_PROTO_SCSI | UMASS_PROTO_BBB, 812 IGNORE_RESIDUE | NO_SYNCHRONIZE_CACHE 813 }, 814 { USB_VENDOR_TAUGA, USB_PRODUCT_TAUGA_CAMERAMATE, RID_WILDCARD, 815 UMASS_PROTO_SCSI, 816 NO_QUIRKS 817 }, 818 { USB_VENDOR_TEAC, USB_PRODUCT_TEAC_FD05PUB, RID_WILDCARD, 819 UMASS_PROTO_UFI | UMASS_PROTO_CBI, 820 NO_QUIRKS 821 }, 822 { USB_VENDOR_TREK, USB_PRODUCT_TREK_MEMKEY, RID_WILDCARD, 823 UMASS_PROTO_SCSI | UMASS_PROTO_BBB, 824 NO_INQUIRY 825 }, 826 { USB_VENDOR_TREK, USB_PRODUCT_TREK_THUMBDRIVE_8MB, RID_WILDCARD, 827 UMASS_PROTO_ATAPI | UMASS_PROTO_BBB, 828 IGNORE_RESIDUE 829 }, 830 { USB_VENDOR_TRUMPION, USB_PRODUCT_TRUMPION_C3310, RID_WILDCARD, 831 UMASS_PROTO_UFI | UMASS_PROTO_CBI, 832 NO_QUIRKS 833 }, 834 { USB_VENDOR_TRUMPION, USB_PRODUCT_TRUMPION_MP3, RID_WILDCARD, 835 UMASS_PROTO_RBC, 836 NO_QUIRKS 837 }, 838 { USB_VENDOR_TRUMPION, USB_PRODUCT_TRUMPION_T33520, RID_WILDCARD, 839 UMASS_PROTO_SCSI, 840 NO_QUIRKS 841 }, 842 { USB_VENDOR_TWINMOS, USB_PRODUCT_TWINMOS_MDIV, RID_WILDCARD, 843 UMASS_PROTO_SCSI | UMASS_PROTO_BBB, 844 NO_QUIRKS 845 }, 846 { USB_VENDOR_VIA, USB_PRODUCT_VIA_USB2IDEBRIDGE, RID_WILDCARD, 847 UMASS_PROTO_SCSI | UMASS_PROTO_BBB, 848 NO_SYNCHRONIZE_CACHE 849 }, 850 { USB_VENDOR_VIVITAR, USB_PRODUCT_VIVITAR_35XX, RID_WILDCARD, 851 UMASS_PROTO_SCSI | UMASS_PROTO_BBB, 852 NO_INQUIRY 853 }, 854 { USB_VENDOR_WESTERN, USB_PRODUCT_WESTERN_COMBO, RID_WILDCARD, 855 UMASS_PROTO_SCSI | UMASS_PROTO_BBB, 856 FORCE_SHORT_INQUIRY | NO_START_STOP | IGNORE_RESIDUE 857 }, 858 { USB_VENDOR_WESTERN, USB_PRODUCT_WESTERN_EXTHDD, RID_WILDCARD, 859 UMASS_PROTO_SCSI | UMASS_PROTO_BBB, 860 FORCE_SHORT_INQUIRY | NO_START_STOP | IGNORE_RESIDUE 861 }, 862 { USB_VENDOR_WESTERN, USB_PRODUCT_WESTERN_MYBOOK, RID_WILDCARD, 863 UMASS_PROTO_SCSI | UMASS_PROTO_BBB, 864 NO_INQUIRY_EVPD 865 }, 866 { USB_VENDOR_WINMAXGROUP, USB_PRODUCT_WINMAXGROUP_FLASH64MC, RID_WILDCARD, 867 UMASS_PROTO_SCSI | UMASS_PROTO_BBB, 868 NO_INQUIRY 869 }, 870 { USB_VENDOR_YANO, USB_PRODUCT_YANO_FW800HD, RID_WILDCARD, 871 UMASS_PROTO_SCSI | UMASS_PROTO_BBB, 872 FORCE_SHORT_INQUIRY | NO_START_STOP | IGNORE_RESIDUE 873 }, 874 { USB_VENDOR_YANO, USB_PRODUCT_YANO_U640MO, RID_WILDCARD, 875 UMASS_PROTO_ATAPI | UMASS_PROTO_CBI_I, 876 FORCE_SHORT_INQUIRY 877 }, 878 { USB_VENDOR_YEDATA, USB_PRODUCT_YEDATA_FLASHBUSTERU, RID_WILDCARD, 879 UMASS_PROTO_SCSI | UMASS_PROTO_CBI, 880 NO_GETMAXLUN 881 }, 882 { USB_VENDOR_ZORAN, USB_PRODUCT_ZORAN_EX20DSC, RID_WILDCARD, 883 UMASS_PROTO_ATAPI | UMASS_PROTO_CBI, 884 NO_QUIRKS 885 }, 886 { USB_VENDOR_MEIZU, USB_PRODUCT_MEIZU_M6_SL, RID_WILDCARD, 887 UMASS_PROTO_SCSI | UMASS_PROTO_BBB, 888 NO_INQUIRY | NO_SYNCHRONIZE_CACHE 889 }, 890 { USB_VENDOR_ACTIONS, USB_PRODUCT_ACTIONS_MP4, RID_WILDCARD, 891 UMASS_PROTO_SCSI | UMASS_PROTO_BBB, 892 NO_SYNCHRONIZE_CACHE 893 }, 894 { VID_EOT, PID_EOT, RID_EOT, 0, 0 } 895 }; 896 897 898 /* the per device structure */ 899 struct umass_softc { 900 device_t sc_dev; /* base device */ 901 usbd_device_handle sc_udev; /* USB device */ 902 903 struct cam_sim *umass_sim; /* SCSI Interface Module */ 904 905 unsigned char flags; /* various device flags */ 906 # define UMASS_FLAGS_GONE 0x01 /* devices is no more */ 907 908 u_int16_t proto; /* wire and cmd protocol */ 909 u_int16_t quirks; /* they got it almost right */ 910 911 usbd_interface_handle iface; /* Mass Storage interface */ 912 int ifaceno; /* MS iface number */ 913 914 u_int8_t bulkin; /* bulk-in Endpoint Address */ 915 u_int8_t bulkout; /* bulk-out Endpoint Address */ 916 u_int8_t intrin; /* intr-in Endp. (CBI) */ 917 usbd_pipe_handle bulkin_pipe; 918 usbd_pipe_handle bulkout_pipe; 919 usbd_pipe_handle intrin_pipe; 920 921 /* Reset the device in a wire protocol specific way */ 922 wire_reset_f reset; 923 924 /* The start of a wire transfer. It prepares the whole transfer (cmd, 925 * data, and status stage) and initiates it. It is up to the state 926 * machine (below) to handle the various stages and errors in these 927 */ 928 wire_transfer_f transfer; 929 930 /* The state machine, handling the various states during a transfer */ 931 wire_state_f state; 932 933 /* The command transform function is used to conver the SCSI commands 934 * into their derivatives, like UFI, ATAPI, and friends. 935 */ 936 command_transform_f transform; /* command transform */ 937 938 /* Bulk specific variables for transfers in progress */ 939 umass_bbb_cbw_t cbw; /* command block wrapper */ 940 umass_bbb_csw_t csw; /* command status wrapper*/ 941 /* CBI specific variables for transfers in progress */ 942 umass_cbi_cbl_t cbl; /* command block */ 943 umass_cbi_sbl_t sbl; /* status block */ 944 945 /* generic variables for transfers in progress */ 946 /* ctrl transfer requests */ 947 usb_device_request_t request; 948 949 /* xfer handles 950 * Most of our operations are initiated from interrupt context, so 951 * we need to avoid using the one that is in use. We want to avoid 952 * allocating them in the interrupt context as well. 953 */ 954 /* indices into array below */ 955 # define XFER_BBB_CBW 0 /* Bulk-Only */ 956 # define XFER_BBB_DATA 1 957 # define XFER_BBB_DCLEAR 2 958 # define XFER_BBB_CSW1 3 959 # define XFER_BBB_CSW2 4 960 # define XFER_BBB_SCLEAR 5 961 # define XFER_BBB_RESET1 6 962 # define XFER_BBB_RESET2 7 963 # define XFER_BBB_RESET3 8 964 965 # define XFER_CBI_CB 0 /* CBI */ 966 # define XFER_CBI_DATA 1 967 # define XFER_CBI_STATUS 2 968 # define XFER_CBI_DCLEAR 3 969 # define XFER_CBI_SCLEAR 4 970 # define XFER_CBI_RESET1 5 971 # define XFER_CBI_RESET2 6 972 # define XFER_CBI_RESET3 7 973 974 # define XFER_NR 9 /* maximum number */ 975 976 usbd_xfer_handle transfer_xfer[XFER_NR]; /* for ctrl xfers */ 977 978 int transfer_dir; /* data direction */ 979 void *transfer_data; /* data buffer */ 980 int transfer_datalen; /* (maximum) length */ 981 int transfer_actlen; /* actual length */ 982 transfer_cb_f transfer_cb; /* callback */ 983 void *transfer_priv; /* for callback */ 984 int transfer_status; 985 986 int transfer_state; 987 # define TSTATE_ATTACH 0 /* in attach */ 988 # define TSTATE_IDLE 1 989 # define TSTATE_BBB_COMMAND 2 /* CBW transfer */ 990 # define TSTATE_BBB_DATA 3 /* Data transfer */ 991 # define TSTATE_BBB_DCLEAR 4 /* clear endpt stall */ 992 # define TSTATE_BBB_STATUS1 5 /* clear endpt stall */ 993 # define TSTATE_BBB_SCLEAR 6 /* clear endpt stall */ 994 # define TSTATE_BBB_STATUS2 7 /* CSW transfer */ 995 # define TSTATE_BBB_RESET1 8 /* reset command */ 996 # define TSTATE_BBB_RESET2 9 /* in clear stall */ 997 # define TSTATE_BBB_RESET3 10 /* out clear stall */ 998 # define TSTATE_CBI_COMMAND 11 /* command transfer */ 999 # define TSTATE_CBI_DATA 12 /* data transfer */ 1000 # define TSTATE_CBI_STATUS 13 /* status transfer */ 1001 # define TSTATE_CBI_DCLEAR 14 /* clear ep stall */ 1002 # define TSTATE_CBI_SCLEAR 15 /* clear ep stall */ 1003 # define TSTATE_CBI_RESET1 16 /* reset command */ 1004 # define TSTATE_CBI_RESET2 17 /* in clear stall */ 1005 # define TSTATE_CBI_RESET3 18 /* out clear stall */ 1006 # define TSTATE_STATES 19 /* # of states above */ 1007 1008 1009 /* SCSI/CAM specific variables */ 1010 unsigned char cam_scsi_command[CAM_MAX_CDBLEN]; 1011 unsigned char cam_scsi_command2[CAM_MAX_CDBLEN]; 1012 struct scsi_sense cam_scsi_sense; 1013 struct scsi_sense cam_scsi_test_unit_ready; 1014 struct callout cam_scsi_rescan_ch; 1015 1016 int timeout; /* in msecs */ 1017 1018 int maxlun; /* maximum LUN number */ 1019 }; 1020 1021 #ifdef USB_DEBUG 1022 char *states[TSTATE_STATES+1] = { 1023 /* should be kept in sync with the list at transfer_state */ 1024 "Attach", 1025 "Idle", 1026 "BBB CBW", 1027 "BBB Data", 1028 "BBB Data bulk-in/-out clear stall", 1029 "BBB CSW, 1st attempt", 1030 "BBB CSW bulk-in clear stall", 1031 "BBB CSW, 2nd attempt", 1032 "BBB Reset", 1033 "BBB bulk-in clear stall", 1034 "BBB bulk-out clear stall", 1035 "CBI Command", 1036 "CBI Data", 1037 "CBI Status", 1038 "CBI Data bulk-in/-out clear stall", 1039 "CBI Status intr-in clear stall", 1040 "CBI Reset", 1041 "CBI bulk-in clear stall", 1042 "CBI bulk-out clear stall", 1043 NULL 1044 }; 1045 #endif 1046 1047 /* If device cannot return valid inquiry data, fake it */ 1048 static uint8_t fake_inq_data[SHORT_INQUIRY_LENGTH] = { 1049 0, /*removable*/ 0x80, SCSI_REV_2, SCSI_REV_2, 1050 /*additional_length*/ 31, 0, 0, 0 1051 }; 1052 1053 /* USB device probe/attach/detach functions */ 1054 static device_probe_t umass_match; 1055 static device_attach_t umass_attach; 1056 static device_detach_t umass_detach; 1057 1058 static device_method_t umass_methods[] = { 1059 /* Device interface */ 1060 DEVMETHOD(device_probe, umass_match), 1061 DEVMETHOD(device_attach, umass_attach), 1062 DEVMETHOD(device_detach, umass_detach), 1063 1064 { 0, 0 } 1065 }; 1066 1067 static driver_t umass_driver = { 1068 "umass", 1069 umass_methods, 1070 sizeof(struct umass_softc) 1071 }; 1072 1073 static devclass_t umass_devclass; 1074 1075 static int umass_match_proto (struct umass_softc *sc, 1076 usbd_interface_handle iface, 1077 usbd_device_handle udev); 1078 1079 /* quirk functions */ 1080 static void umass_init_shuttle (struct umass_softc *sc); 1081 1082 /* generic transfer functions */ 1083 static usbd_status umass_setup_transfer (struct umass_softc *sc, 1084 usbd_pipe_handle pipe, 1085 void *buffer, int buflen, int flags, 1086 usbd_xfer_handle xfer); 1087 static usbd_status umass_setup_ctrl_transfer (struct umass_softc *sc, 1088 usbd_device_handle udev, 1089 usb_device_request_t *req, 1090 void *buffer, int buflen, int flags, 1091 usbd_xfer_handle xfer); 1092 static void umass_clear_endpoint_stall (struct umass_softc *sc, 1093 u_int8_t endpt, usbd_pipe_handle pipe, 1094 int state, usbd_xfer_handle xfer); 1095 static void umass_reset (struct umass_softc *sc, 1096 transfer_cb_f cb, void *priv); 1097 1098 /* Bulk-Only related functions */ 1099 static void umass_bbb_reset (struct umass_softc *sc, int status); 1100 static void umass_bbb_transfer (struct umass_softc *sc, int lun, 1101 void *cmd, int cmdlen, 1102 void *data, int datalen, int dir, u_int timeout, 1103 transfer_cb_f cb, void *priv); 1104 static void umass_bbb_state (usbd_xfer_handle xfer, 1105 usbd_private_handle priv, 1106 usbd_status err); 1107 static int umass_bbb_get_max_lun 1108 (struct umass_softc *sc); 1109 1110 /* CBI related functions */ 1111 static int umass_cbi_adsc (struct umass_softc *sc, 1112 char *buffer, int buflen, 1113 usbd_xfer_handle xfer); 1114 static void umass_cbi_reset (struct umass_softc *sc, int status); 1115 static void umass_cbi_transfer (struct umass_softc *sc, int lun, 1116 void *cmd, int cmdlen, 1117 void *data, int datalen, int dir, u_int timeout, 1118 transfer_cb_f cb, void *priv); 1119 static void umass_cbi_state (usbd_xfer_handle xfer, 1120 usbd_private_handle priv, usbd_status err); 1121 1122 /* CAM related functions */ 1123 static void umass_cam_action (struct cam_sim *sim, union ccb *ccb); 1124 static void umass_cam_poll (struct cam_sim *sim); 1125 1126 static void umass_cam_cb (struct umass_softc *sc, void *priv, 1127 int residue, int status); 1128 static void umass_cam_sense_cb (struct umass_softc *sc, void *priv, 1129 int residue, int status); 1130 static void umass_cam_quirk_cb (struct umass_softc *sc, void *priv, 1131 int residue, int status); 1132 1133 static void umass_cam_rescan_callback 1134 (struct cam_periph *periph,union ccb *ccb); 1135 static void umass_cam_rescan (void *addr); 1136 1137 static int umass_cam_attach_sim (struct umass_softc *sc); 1138 static int umass_cam_attach (struct umass_softc *sc); 1139 static int umass_cam_detach_sim (struct umass_softc *sc); 1140 1141 1142 /* SCSI specific functions */ 1143 static int umass_scsi_transform (struct umass_softc *sc, 1144 unsigned char *cmd, int cmdlen, 1145 unsigned char **rcmd, int *rcmdlen); 1146 1147 /* UFI specific functions */ 1148 #define UFI_COMMAND_LENGTH 12 /* UFI commands are always 12 bytes */ 1149 static int umass_ufi_transform (struct umass_softc *sc, 1150 unsigned char *cmd, int cmdlen, 1151 unsigned char **rcmd, int *rcmdlen); 1152 1153 /* ATAPI (8070i) specific functions */ 1154 #define ATAPI_COMMAND_LENGTH 12 /* ATAPI commands are always 12 bytes */ 1155 static int umass_atapi_transform (struct umass_softc *sc, 1156 unsigned char *cmd, int cmdlen, 1157 unsigned char **rcmd, int *rcmdlen); 1158 1159 /* RBC specific functions */ 1160 static int umass_rbc_transform (struct umass_softc *sc, 1161 unsigned char *cmd, int cmdlen, 1162 unsigned char **rcmd, int *rcmdlen); 1163 1164 #ifdef USB_DEBUG 1165 /* General debugging functions */ 1166 static void umass_bbb_dump_cbw (struct umass_softc *sc, umass_bbb_cbw_t *cbw); 1167 static void umass_bbb_dump_csw (struct umass_softc *sc, umass_bbb_csw_t *csw); 1168 static void umass_cbi_dump_cmd (struct umass_softc *sc, void *cmd, int cmdlen); 1169 static void umass_dump_buffer (struct umass_softc *sc, u_int8_t *buffer, 1170 int buflen, int printlen); 1171 #endif 1172 1173 MODULE_DEPEND(umass, cam, 1, 1, 1); 1174 MODULE_DEPEND(umass, usb, 1, 1, 1); 1175 1176 /* 1177 * USB device probe/attach/detach 1178 */ 1179 1180 /* 1181 * Match the device we are seeing with the devices supported. Fill in the 1182 * description in the softc accordingly. This function is called from both 1183 * probe and attach. 1184 */ 1185 1186 static int 1187 umass_match_proto(struct umass_softc *sc, usbd_interface_handle iface, 1188 usbd_device_handle udev) 1189 { 1190 usb_device_descriptor_t *dd; 1191 usb_interface_descriptor_t *id; 1192 int i; 1193 int found = 0; 1194 1195 sc->sc_udev = udev; 1196 sc->proto = 0; 1197 sc->quirks = 0; 1198 1199 dd = usbd_get_device_descriptor(udev); 1200 1201 /* An entry specifically for Y-E Data devices as they don't fit in the 1202 * device description table. 1203 */ 1204 if (UGETW(dd->idVendor) == USB_VENDOR_YEDATA 1205 && UGETW(dd->idProduct) == USB_PRODUCT_YEDATA_FLASHBUSTERU) { 1206 1207 /* Revisions < 1.28 do not handle the interrupt endpoint 1208 * very well. 1209 */ 1210 if (UGETW(dd->bcdDevice) < 0x128) { 1211 sc->proto = UMASS_PROTO_UFI | UMASS_PROTO_CBI; 1212 } else { 1213 sc->proto = UMASS_PROTO_UFI | UMASS_PROTO_CBI_I; 1214 } 1215 1216 /* 1217 * Revisions < 1.28 do not have the TEST UNIT READY command 1218 * Revisions == 1.28 have a broken TEST UNIT READY 1219 */ 1220 if (UGETW(dd->bcdDevice) <= 0x128) 1221 sc->quirks |= NO_TEST_UNIT_READY; 1222 1223 sc->quirks |= RS_NO_CLEAR_UA | FLOPPY_SPEED; 1224 return(UMATCH_VENDOR_PRODUCT); 1225 } 1226 1227 /* Check the list of supported devices for a match. While looking, 1228 * check for wildcarded and fully matched. First match wins. 1229 */ 1230 for (i = 0; umass_devdescrs[i].vid != VID_EOT && !found; i++) { 1231 if (umass_devdescrs[i].vid == VID_WILDCARD && 1232 umass_devdescrs[i].pid == PID_WILDCARD && 1233 umass_devdescrs[i].rid == RID_WILDCARD) { 1234 printf("umass: ignoring invalid wildcard quirk\n"); 1235 continue; 1236 } 1237 if ((umass_devdescrs[i].vid == UGETW(dd->idVendor) || 1238 umass_devdescrs[i].vid == VID_WILDCARD) 1239 && (umass_devdescrs[i].pid == UGETW(dd->idProduct) || 1240 umass_devdescrs[i].pid == PID_WILDCARD)) { 1241 if (umass_devdescrs[i].rid == RID_WILDCARD) { 1242 sc->proto = umass_devdescrs[i].proto; 1243 sc->quirks = umass_devdescrs[i].quirks; 1244 return (UMATCH_VENDOR_PRODUCT); 1245 } else if (umass_devdescrs[i].rid == 1246 UGETW(dd->bcdDevice)) { 1247 sc->proto = umass_devdescrs[i].proto; 1248 sc->quirks = umass_devdescrs[i].quirks; 1249 return (UMATCH_VENDOR_PRODUCT_REV); 1250 } /* else RID does not match */ 1251 } 1252 } 1253 1254 /* Check for a standards compliant device */ 1255 id = usbd_get_interface_descriptor(iface); 1256 if (id == NULL || id->bInterfaceClass != UICLASS_MASS) 1257 return(UMATCH_NONE); 1258 1259 switch (id->bInterfaceSubClass) { 1260 case UISUBCLASS_SCSI: 1261 sc->proto |= UMASS_PROTO_SCSI; 1262 break; 1263 case UISUBCLASS_UFI: 1264 sc->proto |= UMASS_PROTO_UFI; 1265 break; 1266 case UISUBCLASS_RBC: 1267 sc->proto |= UMASS_PROTO_RBC; 1268 break; 1269 case UISUBCLASS_SFF8020I: 1270 case UISUBCLASS_SFF8070I: 1271 sc->proto |= UMASS_PROTO_ATAPI; 1272 break; 1273 default: 1274 DPRINTF(UDMASS_GEN, ("%s: Unsupported command protocol %d\n", 1275 device_get_nameunit(sc->sc_dev), id->bInterfaceSubClass)); 1276 return(UMATCH_NONE); 1277 } 1278 1279 switch (id->bInterfaceProtocol) { 1280 case UIPROTO_MASS_CBI: 1281 sc->proto |= UMASS_PROTO_CBI; 1282 break; 1283 case UIPROTO_MASS_CBI_I: 1284 sc->proto |= UMASS_PROTO_CBI_I; 1285 break; 1286 case UIPROTO_MASS_BBB_OLD: 1287 case UIPROTO_MASS_BBB: 1288 sc->proto |= UMASS_PROTO_BBB; 1289 break; 1290 default: 1291 DPRINTF(UDMASS_GEN, ("%s: Unsupported wire protocol %d\n", 1292 device_get_nameunit(sc->sc_dev), id->bInterfaceProtocol)); 1293 return(UMATCH_NONE); 1294 } 1295 1296 return(UMATCH_IFACECLASS_IFACESUBCLASS_IFACEPROTO); 1297 } 1298 1299 static int 1300 umass_match(device_t self) 1301 { 1302 struct usb_attach_arg *uaa = device_get_ivars(self); 1303 struct umass_softc *sc = device_get_softc(self); 1304 1305 sc->sc_dev = self; 1306 if (uaa->iface == NULL) 1307 return(UMATCH_NONE); 1308 1309 return(umass_match_proto(sc, uaa->iface, uaa->device)); 1310 } 1311 1312 static int 1313 umass_attach(device_t self) 1314 { 1315 struct umass_softc *sc = device_get_softc(self); 1316 struct usb_attach_arg *uaa = device_get_ivars(self); 1317 usb_interface_descriptor_t *id; 1318 usb_endpoint_descriptor_t *ed; 1319 int i; 1320 int err; 1321 1322 /* 1323 * the softc struct is bzero-ed in device_set_driver. We can safely 1324 * call umass_detach without specifically initialising the struct. 1325 */ 1326 sc->sc_dev = self; 1327 sc->iface = uaa->iface; 1328 sc->ifaceno = uaa->ifaceno; 1329 callout_init(&sc->cam_scsi_rescan_ch, 0); 1330 1331 /* initialise the proto and drive values in the umass_softc (again) */ 1332 (void) umass_match_proto(sc, sc->iface, uaa->device); 1333 1334 id = usbd_get_interface_descriptor(sc->iface); 1335 #ifdef USB_DEBUG 1336 printf("%s: ", device_get_nameunit(sc->sc_dev)); 1337 switch (sc->proto&UMASS_PROTO_COMMAND) { 1338 case UMASS_PROTO_SCSI: 1339 printf("SCSI"); 1340 break; 1341 case UMASS_PROTO_ATAPI: 1342 printf("8070i (ATAPI)"); 1343 break; 1344 case UMASS_PROTO_UFI: 1345 printf("UFI"); 1346 break; 1347 case UMASS_PROTO_RBC: 1348 printf("RBC"); 1349 break; 1350 default: 1351 printf("(unknown 0x%02x)", sc->proto&UMASS_PROTO_COMMAND); 1352 break; 1353 } 1354 printf(" over "); 1355 switch (sc->proto&UMASS_PROTO_WIRE) { 1356 case UMASS_PROTO_BBB: 1357 printf("Bulk-Only"); 1358 break; 1359 case UMASS_PROTO_CBI: /* uses Comand/Bulk pipes */ 1360 printf("CBI"); 1361 break; 1362 case UMASS_PROTO_CBI_I: /* uses Comand/Bulk/Interrupt pipes */ 1363 printf("CBI with CCI"); 1364 #ifndef CBI_I 1365 printf(" (using CBI)"); 1366 #endif 1367 break; 1368 default: 1369 printf("(unknown 0x%02x)", sc->proto&UMASS_PROTO_WIRE); 1370 } 1371 printf("; quirks = 0x%04x\n", sc->quirks); 1372 #endif 1373 1374 #ifndef CBI_I 1375 if (sc->proto & UMASS_PROTO_CBI_I) { 1376 /* See beginning of file for comment on the use of CBI with CCI */ 1377 sc->proto = (sc->proto & ~UMASS_PROTO_CBI_I) | UMASS_PROTO_CBI; 1378 } 1379 #endif 1380 1381 if (sc->quirks & ALT_IFACE_1) { 1382 err = usbd_set_interface(uaa->iface, 1); 1383 if (err) { 1384 DPRINTF(UDMASS_USB, ("%s: could not switch to " 1385 "Alt Interface %d\n", 1386 device_get_nameunit(sc->sc_dev), 1)); 1387 umass_detach(self); 1388 return ENXIO; 1389 } 1390 } 1391 1392 /* 1393 * In addition to the Control endpoint the following endpoints 1394 * are required: 1395 * a) bulk-in endpoint. 1396 * b) bulk-out endpoint. 1397 * and for Control/Bulk/Interrupt with CCI (CBI_I) 1398 * c) intr-in 1399 * 1400 * The endpoint addresses are not fixed, so we have to read them 1401 * from the device descriptors of the current interface. 1402 */ 1403 for (i = 0 ; i < id->bNumEndpoints ; i++) { 1404 ed = usbd_interface2endpoint_descriptor(sc->iface, i); 1405 if (!ed) { 1406 printf("%s: could not read endpoint descriptor\n", 1407 device_get_nameunit(sc->sc_dev)); 1408 return ENXIO; 1409 } 1410 if (UE_GET_DIR(ed->bEndpointAddress) == UE_DIR_IN 1411 && (ed->bmAttributes & UE_XFERTYPE) == UE_BULK) { 1412 sc->bulkin = ed->bEndpointAddress; 1413 } else if (UE_GET_DIR(ed->bEndpointAddress) == UE_DIR_OUT 1414 && (ed->bmAttributes & UE_XFERTYPE) == UE_BULK) { 1415 sc->bulkout = ed->bEndpointAddress; 1416 } else if (sc->proto & UMASS_PROTO_CBI_I 1417 && UE_GET_DIR(ed->bEndpointAddress) == UE_DIR_IN 1418 && (ed->bmAttributes & UE_XFERTYPE) == UE_INTERRUPT) { 1419 sc->intrin = ed->bEndpointAddress; 1420 #ifdef USB_DEBUG 1421 if (UGETW(ed->wMaxPacketSize) > 2) { 1422 DPRINTF(UDMASS_CBI, ("%s: intr size is %d\n", 1423 device_get_nameunit(sc->sc_dev), 1424 UGETW(ed->wMaxPacketSize))); 1425 } 1426 #endif 1427 } 1428 } 1429 1430 /* check whether we found all the endpoints we need */ 1431 if (!sc->bulkin || !sc->bulkout 1432 || (sc->proto & UMASS_PROTO_CBI_I && !sc->intrin) ) { 1433 DPRINTF(UDMASS_USB, ("%s: endpoint not found %d/%d/%d\n", 1434 device_get_nameunit(sc->sc_dev), 1435 sc->bulkin, sc->bulkout, sc->intrin)); 1436 umass_detach(self); 1437 return ENXIO; 1438 } 1439 1440 /* Open the bulk-in and -out pipe */ 1441 err = usbd_open_pipe(sc->iface, sc->bulkout, 1442 USBD_EXCLUSIVE_USE, &sc->bulkout_pipe); 1443 if (err) { 1444 DPRINTF(UDMASS_USB, ("%s: cannot open %d-out pipe (bulk)\n", 1445 device_get_nameunit(sc->sc_dev), sc->bulkout)); 1446 umass_detach(self); 1447 return ENXIO; 1448 } 1449 err = usbd_open_pipe(sc->iface, sc->bulkin, 1450 USBD_EXCLUSIVE_USE, &sc->bulkin_pipe); 1451 if (err) { 1452 DPRINTF(UDMASS_USB, ("%s: could not open %d-in pipe (bulk)\n", 1453 device_get_nameunit(sc->sc_dev), sc->bulkin)); 1454 umass_detach(self); 1455 return ENXIO; 1456 } 1457 /* Open the intr-in pipe if the protocol is CBI with CCI. 1458 * Note: early versions of the Zip drive do have an interrupt pipe, but 1459 * this pipe is unused. 1460 * 1461 * We do not open the interrupt pipe as an interrupt pipe, but as a 1462 * normal bulk endpoint. We send an IN transfer down the wire at the 1463 * appropriate time, because we know exactly when to expect data on 1464 * that endpoint. This saves bandwidth, but more important, makes the 1465 * code for handling the data on that endpoint simpler. No data 1466 * arriving concurrently. 1467 */ 1468 if (sc->proto & UMASS_PROTO_CBI_I) { 1469 err = usbd_open_pipe(sc->iface, sc->intrin, 1470 USBD_EXCLUSIVE_USE, &sc->intrin_pipe); 1471 if (err) { 1472 DPRINTF(UDMASS_USB, ("%s: couldn't open %d-in (intr)\n", 1473 device_get_nameunit(sc->sc_dev), sc->intrin)); 1474 umass_detach(self); 1475 return ENXIO; 1476 } 1477 } 1478 1479 /* initialisation of generic part */ 1480 sc->transfer_state = TSTATE_ATTACH; 1481 1482 /* request a sufficient number of xfer handles */ 1483 for (i = 0; i < XFER_NR; i++) { 1484 sc->transfer_xfer[i] = usbd_alloc_xfer(uaa->device); 1485 if (!sc->transfer_xfer[i]) { 1486 DPRINTF(UDMASS_USB, ("%s: Out of memory\n", 1487 device_get_nameunit(sc->sc_dev))); 1488 umass_detach(self); 1489 return ENXIO; 1490 } 1491 } 1492 1493 /* Initialise the wire protocol specific methods */ 1494 if (sc->proto & UMASS_PROTO_BBB) { 1495 sc->reset = umass_bbb_reset; 1496 sc->transfer = umass_bbb_transfer; 1497 sc->state = umass_bbb_state; 1498 } else if (sc->proto & (UMASS_PROTO_CBI|UMASS_PROTO_CBI_I)) { 1499 sc->reset = umass_cbi_reset; 1500 sc->transfer = umass_cbi_transfer; 1501 sc->state = umass_cbi_state; 1502 #ifdef USB_DEBUG 1503 } else { 1504 panic("%s:%d: Unknown proto 0x%02x", 1505 __FILE__, __LINE__, sc->proto); 1506 #endif 1507 } 1508 1509 if (sc->proto & UMASS_PROTO_SCSI) 1510 sc->transform = umass_scsi_transform; 1511 else if (sc->proto & UMASS_PROTO_UFI) 1512 sc->transform = umass_ufi_transform; 1513 else if (sc->proto & UMASS_PROTO_ATAPI) 1514 sc->transform = umass_atapi_transform; 1515 else if (sc->proto & UMASS_PROTO_RBC) 1516 sc->transform = umass_rbc_transform; 1517 #ifdef USB_DEBUG 1518 else 1519 panic("No transformation defined for command proto 0x%02x", 1520 sc->proto & UMASS_PROTO_COMMAND); 1521 #endif 1522 1523 /* From here onwards the device can be used. */ 1524 1525 if (sc->quirks & SHUTTLE_INIT) 1526 umass_init_shuttle(sc); 1527 1528 /* Get the maximum LUN supported by the device. 1529 */ 1530 if (((sc->proto & UMASS_PROTO_WIRE) == UMASS_PROTO_BBB) && 1531 !(sc->quirks & NO_GETMAXLUN)) 1532 sc->maxlun = umass_bbb_get_max_lun(sc); 1533 else 1534 sc->maxlun = 0; 1535 1536 if ((sc->proto & UMASS_PROTO_SCSI) || 1537 (sc->proto & UMASS_PROTO_ATAPI) || 1538 (sc->proto & UMASS_PROTO_UFI) || 1539 (sc->proto & UMASS_PROTO_RBC)) { 1540 /* Prepare the SCSI command block */ 1541 sc->cam_scsi_sense.opcode = REQUEST_SENSE; 1542 sc->cam_scsi_test_unit_ready.opcode = TEST_UNIT_READY; 1543 1544 /* register the SIM */ 1545 err = umass_cam_attach_sim(sc); 1546 if (err) { 1547 umass_detach(self); 1548 return ENXIO; 1549 } 1550 /* scan the new sim */ 1551 err = umass_cam_attach(sc); 1552 if (err) { 1553 umass_cam_detach_sim(sc); 1554 umass_detach(self); 1555 return ENXIO; 1556 } 1557 } else { 1558 panic("%s:%d: Unknown proto 0x%02x", 1559 __FILE__, __LINE__, sc->proto); 1560 } 1561 1562 sc->transfer_state = TSTATE_IDLE; 1563 DPRINTF(UDMASS_GEN, ("%s: Attach finished\n", device_get_nameunit(sc->sc_dev))); 1564 1565 return 0; 1566 } 1567 1568 static int 1569 umass_detach(device_t self) 1570 { 1571 struct umass_softc *sc = device_get_softc(self); 1572 int err = 0; 1573 int i; 1574 1575 DPRINTF(UDMASS_USB, ("%s: detached\n", device_get_nameunit(sc->sc_dev))); 1576 1577 sc->flags |= UMASS_FLAGS_GONE; 1578 1579 /* abort all the pipes in case there are transfers active. */ 1580 usbd_abort_default_pipe(sc->sc_udev); 1581 if (sc->bulkout_pipe) 1582 usbd_abort_pipe(sc->bulkout_pipe); 1583 if (sc->bulkin_pipe) 1584 usbd_abort_pipe(sc->bulkin_pipe); 1585 if (sc->intrin_pipe) 1586 usbd_abort_pipe(sc->intrin_pipe); 1587 1588 callout_drain(&sc->cam_scsi_rescan_ch); 1589 if ((sc->proto & UMASS_PROTO_SCSI) || 1590 (sc->proto & UMASS_PROTO_ATAPI) || 1591 (sc->proto & UMASS_PROTO_UFI) || 1592 (sc->proto & UMASS_PROTO_RBC)) 1593 /* detach the SCSI host controller (SIM) */ 1594 err = umass_cam_detach_sim(sc); 1595 1596 for (i = 0; i < XFER_NR; i++) 1597 if (sc->transfer_xfer[i]) 1598 usbd_free_xfer(sc->transfer_xfer[i]); 1599 1600 /* remove all the pipes */ 1601 if (sc->bulkout_pipe) 1602 usbd_close_pipe(sc->bulkout_pipe); 1603 if (sc->bulkin_pipe) 1604 usbd_close_pipe(sc->bulkin_pipe); 1605 if (sc->intrin_pipe) 1606 usbd_close_pipe(sc->intrin_pipe); 1607 1608 return(err); 1609 } 1610 1611 static void 1612 umass_init_shuttle(struct umass_softc *sc) 1613 { 1614 usb_device_request_t req; 1615 u_char status[2]; 1616 1617 /* The Linux driver does this, but no one can tell us what the 1618 * command does. 1619 */ 1620 req.bmRequestType = UT_READ_VENDOR_DEVICE; 1621 req.bRequest = 1; /* XXX unknown command */ 1622 USETW(req.wValue, 0); 1623 USETW(req.wIndex, sc->ifaceno); 1624 USETW(req.wLength, sizeof status); 1625 (void) usbd_do_request(sc->sc_udev, &req, &status); 1626 1627 DPRINTF(UDMASS_GEN, ("%s: Shuttle init returned 0x%02x%02x\n", 1628 device_get_nameunit(sc->sc_dev), status[0], status[1])); 1629 } 1630 1631 /* 1632 * Generic functions to handle transfers 1633 */ 1634 1635 static usbd_status 1636 umass_setup_transfer(struct umass_softc *sc, usbd_pipe_handle pipe, 1637 void *buffer, int buflen, int flags, 1638 usbd_xfer_handle xfer) 1639 { 1640 usbd_status err; 1641 1642 /* Initialise a USB transfer and then schedule it */ 1643 1644 (void) usbd_setup_xfer(xfer, pipe, (void *) sc, buffer, buflen, flags, 1645 sc->timeout, sc->state); 1646 1647 err = usbd_transfer(xfer); 1648 if (err && err != USBD_IN_PROGRESS) { 1649 DPRINTF(UDMASS_BBB, ("%s: failed to setup transfer, %s\n", 1650 device_get_nameunit(sc->sc_dev), usbd_errstr(err))); 1651 return(err); 1652 } 1653 1654 return (USBD_NORMAL_COMPLETION); 1655 } 1656 1657 1658 static usbd_status 1659 umass_setup_ctrl_transfer(struct umass_softc *sc, usbd_device_handle udev, 1660 usb_device_request_t *req, 1661 void *buffer, int buflen, int flags, 1662 usbd_xfer_handle xfer) 1663 { 1664 usbd_status err; 1665 1666 /* Initialise a USB control transfer and then schedule it */ 1667 1668 (void) usbd_setup_default_xfer(xfer, udev, (void *) sc, 1669 sc->timeout, req, buffer, buflen, flags, sc->state); 1670 1671 err = usbd_transfer(xfer); 1672 if (err && err != USBD_IN_PROGRESS) { 1673 DPRINTF(UDMASS_BBB, ("%s: failed to setup ctrl transfer, %s\n", 1674 device_get_nameunit(sc->sc_dev), usbd_errstr(err))); 1675 1676 /* do not reset, as this would make us loop */ 1677 return(err); 1678 } 1679 1680 return (USBD_NORMAL_COMPLETION); 1681 } 1682 1683 static void 1684 umass_clear_endpoint_stall(struct umass_softc *sc, 1685 u_int8_t endpt, usbd_pipe_handle pipe, 1686 int state, usbd_xfer_handle xfer) 1687 { 1688 usbd_device_handle udev; 1689 1690 DPRINTF(UDMASS_BBB, ("%s: Clear endpoint 0x%02x stall\n", 1691 device_get_nameunit(sc->sc_dev), endpt)); 1692 1693 usbd_interface2device_handle(sc->iface, &udev); 1694 1695 sc->transfer_state = state; 1696 1697 usbd_clear_endpoint_toggle(pipe); 1698 1699 sc->request.bmRequestType = UT_WRITE_ENDPOINT; 1700 sc->request.bRequest = UR_CLEAR_FEATURE; 1701 USETW(sc->request.wValue, UF_ENDPOINT_HALT); 1702 USETW(sc->request.wIndex, endpt); 1703 USETW(sc->request.wLength, 0); 1704 umass_setup_ctrl_transfer(sc, udev, &sc->request, NULL, 0, 0, xfer); 1705 } 1706 1707 static void 1708 umass_reset(struct umass_softc *sc, transfer_cb_f cb, void *priv) 1709 { 1710 sc->transfer_cb = cb; 1711 sc->transfer_priv = priv; 1712 1713 /* The reset is a forced reset, so no error (yet) */ 1714 sc->reset(sc, STATUS_CMD_OK); 1715 } 1716 1717 /* 1718 * Bulk protocol specific functions 1719 */ 1720 1721 static void 1722 umass_bbb_reset(struct umass_softc *sc, int status) 1723 { 1724 usbd_device_handle udev; 1725 1726 KASSERT(sc->proto & UMASS_PROTO_BBB, 1727 ("%s: umass_bbb_reset: wrong sc->proto 0x%02x\n", 1728 device_get_nameunit(sc->sc_dev), sc->proto)); 1729 1730 /* 1731 * Reset recovery (5.3.4 in Universal Serial Bus Mass Storage Class) 1732 * 1733 * For Reset Recovery the host shall issue in the following order: 1734 * a) a Bulk-Only Mass Storage Reset 1735 * b) a Clear Feature HALT to the Bulk-In endpoint 1736 * c) a Clear Feature HALT to the Bulk-Out endpoint 1737 * 1738 * This is done in 3 steps, states: 1739 * TSTATE_BBB_RESET1 1740 * TSTATE_BBB_RESET2 1741 * TSTATE_BBB_RESET3 1742 * 1743 * If the reset doesn't succeed, the device should be port reset. 1744 */ 1745 1746 DPRINTF(UDMASS_BBB, ("%s: Bulk Reset\n", 1747 device_get_nameunit(sc->sc_dev))); 1748 1749 sc->transfer_state = TSTATE_BBB_RESET1; 1750 sc->transfer_status = status; 1751 1752 usbd_interface2device_handle(sc->iface, &udev); 1753 1754 /* reset is a class specific interface write */ 1755 sc->request.bmRequestType = UT_WRITE_CLASS_INTERFACE; 1756 sc->request.bRequest = UR_BBB_RESET; 1757 USETW(sc->request.wValue, 0); 1758 USETW(sc->request.wIndex, sc->ifaceno); 1759 USETW(sc->request.wLength, 0); 1760 umass_setup_ctrl_transfer(sc, udev, &sc->request, NULL, 0, 0, 1761 sc->transfer_xfer[XFER_BBB_RESET1]); 1762 } 1763 1764 static void 1765 umass_bbb_transfer(struct umass_softc *sc, int lun, void *cmd, int cmdlen, 1766 void *data, int datalen, int dir, u_int timeout, 1767 transfer_cb_f cb, void *priv) 1768 { 1769 KASSERT(sc->proto & UMASS_PROTO_BBB, 1770 ("%s: umass_bbb_transfer: wrong sc->proto 0x%02x\n", 1771 device_get_nameunit(sc->sc_dev), sc->proto)); 1772 1773 /* Be a little generous. */ 1774 sc->timeout = timeout + UMASS_TIMEOUT; 1775 1776 /* 1777 * Do a Bulk-Only transfer with cmdlen bytes from cmd, possibly 1778 * a data phase of datalen bytes from/to the device and finally a 1779 * csw read phase. 1780 * If the data direction was inbound a maximum of datalen bytes 1781 * is stored in the buffer pointed to by data. 1782 * 1783 * umass_bbb_transfer initialises the transfer and lets the state 1784 * machine in umass_bbb_state handle the completion. It uses the 1785 * following states: 1786 * TSTATE_BBB_COMMAND 1787 * -> TSTATE_BBB_DATA 1788 * -> TSTATE_BBB_STATUS 1789 * -> TSTATE_BBB_STATUS2 1790 * -> TSTATE_BBB_IDLE 1791 * 1792 * An error in any of those states will invoke 1793 * umass_bbb_reset. 1794 */ 1795 1796 /* check the given arguments */ 1797 KASSERT(datalen == 0 || data != NULL, 1798 ("%s: datalen > 0, but no buffer",device_get_nameunit(sc->sc_dev))); 1799 KASSERT(cmdlen <= CBWCDBLENGTH, 1800 ("%s: cmdlen exceeds CDB length in CBW (%d > %d)", 1801 device_get_nameunit(sc->sc_dev), cmdlen, CBWCDBLENGTH)); 1802 KASSERT(dir == DIR_NONE || datalen > 0, 1803 ("%s: datalen == 0 while direction is not NONE\n", 1804 device_get_nameunit(sc->sc_dev))); 1805 KASSERT(datalen == 0 || dir != DIR_NONE, 1806 ("%s: direction is NONE while datalen is not zero\n", 1807 device_get_nameunit(sc->sc_dev))); 1808 KASSERT(sizeof(umass_bbb_cbw_t) == UMASS_BBB_CBW_SIZE, 1809 ("%s: CBW struct does not have the right size (%ld vs. %d)\n", 1810 device_get_nameunit(sc->sc_dev), 1811 (long)sizeof(umass_bbb_cbw_t), UMASS_BBB_CBW_SIZE)); 1812 KASSERT(sizeof(umass_bbb_csw_t) == UMASS_BBB_CSW_SIZE, 1813 ("%s: CSW struct does not have the right size (%ld vs. %d)\n", 1814 device_get_nameunit(sc->sc_dev), 1815 (long)sizeof(umass_bbb_csw_t), UMASS_BBB_CSW_SIZE)); 1816 1817 /* 1818 * Determine the direction of the data transfer and the length. 1819 * 1820 * dCBWDataTransferLength (datalen) : 1821 * This field indicates the number of bytes of data that the host 1822 * intends to transfer on the IN or OUT Bulk endpoint(as indicated by 1823 * the Direction bit) during the execution of this command. If this 1824 * field is set to 0, the device will expect that no data will be 1825 * transferred IN or OUT during this command, regardless of the value 1826 * of the Direction bit defined in dCBWFlags. 1827 * 1828 * dCBWFlags (dir) : 1829 * The bits of the Flags field are defined as follows: 1830 * Bits 0-6 reserved 1831 * Bit 7 Direction - this bit shall be ignored if the 1832 * dCBWDataTransferLength field is zero. 1833 * 0 = data Out from host to device 1834 * 1 = data In from device to host 1835 */ 1836 1837 /* Fill in the Command Block Wrapper 1838 * We fill in all the fields, so there is no need to bzero it first. 1839 */ 1840 USETDW(sc->cbw.dCBWSignature, CBWSIGNATURE); 1841 /* We don't care about the initial value, as long as the values are unique */ 1842 USETDW(sc->cbw.dCBWTag, UGETDW(sc->cbw.dCBWTag) + 1); 1843 USETDW(sc->cbw.dCBWDataTransferLength, datalen); 1844 /* DIR_NONE is treated as DIR_OUT (0x00) */ 1845 sc->cbw.bCBWFlags = (dir == DIR_IN? CBWFLAGS_IN:CBWFLAGS_OUT); 1846 sc->cbw.bCBWLUN = lun; 1847 sc->cbw.bCDBLength = cmdlen; 1848 bcopy(cmd, sc->cbw.CBWCDB, cmdlen); 1849 1850 DIF(UDMASS_BBB, umass_bbb_dump_cbw(sc, &sc->cbw)); 1851 1852 /* store the details for the data transfer phase */ 1853 sc->transfer_dir = dir; 1854 sc->transfer_data = data; 1855 sc->transfer_datalen = datalen; 1856 sc->transfer_actlen = 0; 1857 sc->transfer_cb = cb; 1858 sc->transfer_priv = priv; 1859 sc->transfer_status = STATUS_CMD_OK; 1860 1861 /* move from idle to the command state */ 1862 sc->transfer_state = TSTATE_BBB_COMMAND; 1863 1864 /* Send the CBW from host to device via bulk-out endpoint. */ 1865 if (umass_setup_transfer(sc, sc->bulkout_pipe, 1866 &sc->cbw, UMASS_BBB_CBW_SIZE, 0, 1867 sc->transfer_xfer[XFER_BBB_CBW])) { 1868 umass_bbb_reset(sc, STATUS_WIRE_FAILED); 1869 } 1870 } 1871 1872 1873 static void 1874 umass_bbb_state(usbd_xfer_handle xfer, usbd_private_handle priv, 1875 usbd_status err) 1876 { 1877 struct umass_softc *sc = (struct umass_softc *) priv; 1878 usbd_xfer_handle next_xfer; 1879 int Residue; 1880 1881 KASSERT(sc->proto & UMASS_PROTO_BBB, 1882 ("%s: umass_bbb_state: wrong sc->proto 0x%02x\n", 1883 device_get_nameunit(sc->sc_dev), sc->proto)); 1884 1885 /* 1886 * State handling for BBB transfers. 1887 * 1888 * The subroutine is rather long. It steps through the states given in 1889 * Annex A of the Bulk-Only specification. 1890 * Each state first does the error handling of the previous transfer 1891 * and then prepares the next transfer. 1892 * Each transfer is done asynchronously so after the request/transfer 1893 * has been submitted you will find a 'return;'. 1894 */ 1895 1896 DPRINTF(UDMASS_BBB, ("%s: Handling BBB state %d (%s), xfer=%p, %s\n", 1897 device_get_nameunit(sc->sc_dev), sc->transfer_state, 1898 states[sc->transfer_state], xfer, usbd_errstr(err))); 1899 1900 /* Give up if the device has detached. */ 1901 if (sc->flags & UMASS_FLAGS_GONE) { 1902 sc->transfer_state = TSTATE_IDLE; 1903 sc->transfer_cb(sc, sc->transfer_priv, sc->transfer_datalen, 1904 STATUS_CMD_FAILED); 1905 return; 1906 } 1907 1908 switch (sc->transfer_state) { 1909 1910 /***** Bulk Transfer *****/ 1911 case TSTATE_BBB_COMMAND: 1912 /* Command transport phase, error handling */ 1913 if (err) { 1914 DPRINTF(UDMASS_BBB, ("%s: failed to send CBW\n", 1915 device_get_nameunit(sc->sc_dev))); 1916 /* If the device detects that the CBW is invalid, then 1917 * the device may STALL both bulk endpoints and require 1918 * a Bulk-Reset 1919 */ 1920 umass_bbb_reset(sc, STATUS_WIRE_FAILED); 1921 return; 1922 } 1923 1924 /* Data transport phase, setup transfer */ 1925 sc->transfer_state = TSTATE_BBB_DATA; 1926 if (sc->transfer_dir == DIR_IN) { 1927 if (umass_setup_transfer(sc, sc->bulkin_pipe, 1928 sc->transfer_data, sc->transfer_datalen, 1929 USBD_SHORT_XFER_OK, 1930 sc->transfer_xfer[XFER_BBB_DATA])) 1931 umass_bbb_reset(sc, STATUS_WIRE_FAILED); 1932 1933 return; 1934 } else if (sc->transfer_dir == DIR_OUT) { 1935 if (umass_setup_transfer(sc, sc->bulkout_pipe, 1936 sc->transfer_data, sc->transfer_datalen, 1937 0, /* fixed length transfer */ 1938 sc->transfer_xfer[XFER_BBB_DATA])) 1939 umass_bbb_reset(sc, STATUS_WIRE_FAILED); 1940 1941 return; 1942 } else { 1943 DPRINTF(UDMASS_BBB, ("%s: no data phase\n", 1944 device_get_nameunit(sc->sc_dev))); 1945 } 1946 1947 /* FALLTHROUGH if no data phase, err == 0 */ 1948 case TSTATE_BBB_DATA: 1949 /* Command transport phase, error handling (ignored if no data 1950 * phase (fallthrough from previous state)) */ 1951 if (sc->transfer_dir != DIR_NONE) { 1952 /* retrieve the length of the transfer that was done */ 1953 usbd_get_xfer_status(xfer, NULL, NULL, 1954 &sc->transfer_actlen, NULL); 1955 1956 if (err) { 1957 DPRINTF(UDMASS_BBB, ("%s: Data-%s %db failed, " 1958 "%s\n", device_get_nameunit(sc->sc_dev), 1959 (sc->transfer_dir == DIR_IN?"in":"out"), 1960 sc->transfer_datalen,usbd_errstr(err))); 1961 1962 if (err == USBD_STALLED) { 1963 umass_clear_endpoint_stall(sc, 1964 (sc->transfer_dir == DIR_IN? 1965 sc->bulkin:sc->bulkout), 1966 (sc->transfer_dir == DIR_IN? 1967 sc->bulkin_pipe:sc->bulkout_pipe), 1968 TSTATE_BBB_DCLEAR, 1969 sc->transfer_xfer[XFER_BBB_DCLEAR]); 1970 return; 1971 } else { 1972 /* Unless the error is a pipe stall the 1973 * error is fatal. 1974 */ 1975 umass_bbb_reset(sc,STATUS_WIRE_FAILED); 1976 return; 1977 } 1978 } 1979 } 1980 1981 DIF(UDMASS_BBB, if (sc->transfer_dir == DIR_IN) 1982 umass_dump_buffer(sc, sc->transfer_data, 1983 sc->transfer_datalen, 48)); 1984 1985 1986 1987 /* FALLTHROUGH, err == 0 (no data phase or successfull) */ 1988 case TSTATE_BBB_DCLEAR: /* stall clear after data phase */ 1989 case TSTATE_BBB_SCLEAR: /* stall clear after status phase */ 1990 /* Reading of CSW after bulk stall condition in data phase 1991 * (TSTATE_BBB_DATA2) or bulk-in stall condition after 1992 * reading CSW (TSTATE_BBB_SCLEAR). 1993 * In the case of no data phase or successfull data phase, 1994 * err == 0 and the following if block is passed. 1995 */ 1996 if (err) { /* should not occur */ 1997 /* try the transfer below, even if clear stall failed */ 1998 DPRINTF(UDMASS_BBB, ("%s: bulk-%s stall clear failed" 1999 ", %s\n", device_get_nameunit(sc->sc_dev), 2000 (sc->transfer_dir == DIR_IN? "in":"out"), 2001 usbd_errstr(err))); 2002 umass_bbb_reset(sc, STATUS_WIRE_FAILED); 2003 return; 2004 } 2005 2006 /* Status transport phase, setup transfer */ 2007 if (sc->transfer_state == TSTATE_BBB_COMMAND || 2008 sc->transfer_state == TSTATE_BBB_DATA || 2009 sc->transfer_state == TSTATE_BBB_DCLEAR) { 2010 /* After no data phase, successfull data phase and 2011 * after clearing bulk-in/-out stall condition 2012 */ 2013 sc->transfer_state = TSTATE_BBB_STATUS1; 2014 next_xfer = sc->transfer_xfer[XFER_BBB_CSW1]; 2015 } else { 2016 /* After first attempt of fetching CSW */ 2017 sc->transfer_state = TSTATE_BBB_STATUS2; 2018 next_xfer = sc->transfer_xfer[XFER_BBB_CSW2]; 2019 } 2020 2021 /* Read the Command Status Wrapper via bulk-in endpoint. */ 2022 if (umass_setup_transfer(sc, sc->bulkin_pipe, 2023 &sc->csw, UMASS_BBB_CSW_SIZE, 0, 2024 next_xfer)) { 2025 umass_bbb_reset(sc, STATUS_WIRE_FAILED); 2026 return; 2027 } 2028 2029 return; 2030 case TSTATE_BBB_STATUS1: /* first attempt */ 2031 case TSTATE_BBB_STATUS2: /* second attempt */ 2032 /* Status transfer, error handling */ 2033 if (err) { 2034 DPRINTF(UDMASS_BBB, ("%s: Failed to read CSW, %s%s\n", 2035 device_get_nameunit(sc->sc_dev), usbd_errstr(err), 2036 (sc->transfer_state == TSTATE_BBB_STATUS1? 2037 ", retrying":""))); 2038 2039 /* If this was the first attempt at fetching the CSW 2040 * retry it, otherwise fail. 2041 */ 2042 if (sc->transfer_state == TSTATE_BBB_STATUS1) { 2043 umass_clear_endpoint_stall(sc, 2044 sc->bulkin, sc->bulkin_pipe, 2045 TSTATE_BBB_SCLEAR, 2046 sc->transfer_xfer[XFER_BBB_SCLEAR]); 2047 return; 2048 } else { 2049 umass_bbb_reset(sc, STATUS_WIRE_FAILED); 2050 return; 2051 } 2052 } 2053 2054 DIF(UDMASS_BBB, umass_bbb_dump_csw(sc, &sc->csw)); 2055 2056 /* Translate weird command-status signatures. */ 2057 if (sc->quirks & WRONG_CSWSIG) { 2058 u_int32_t dCSWSignature = UGETDW(sc->csw.dCSWSignature); 2059 if (dCSWSignature == CSWSIGNATURE_OLYMPUS_C1 || 2060 dCSWSignature == CSWSIGNATURE_IMAGINATION_DBX1) 2061 USETDW(sc->csw.dCSWSignature, CSWSIGNATURE); 2062 } 2063 2064 Residue = UGETDW(sc->csw.dCSWDataResidue); 2065 if (Residue == 0 || (sc->quirks & IGNORE_RESIDUE)) 2066 Residue = sc->transfer_datalen - sc->transfer_actlen; 2067 2068 /* Check CSW and handle any error */ 2069 if (UGETDW(sc->csw.dCSWSignature) != CSWSIGNATURE) { 2070 /* Invalid CSW: Wrong signature or wrong tag might 2071 * indicate that the device is confused -> reset it. 2072 */ 2073 printf("%s: Invalid CSW: sig 0x%08x should be 0x%08x\n", 2074 device_get_nameunit(sc->sc_dev), 2075 UGETDW(sc->csw.dCSWSignature), 2076 CSWSIGNATURE); 2077 2078 umass_bbb_reset(sc, STATUS_WIRE_FAILED); 2079 return; 2080 } else if (UGETDW(sc->csw.dCSWTag) 2081 != UGETDW(sc->cbw.dCBWTag)) { 2082 printf("%s: Invalid CSW: tag %d should be %d\n", 2083 device_get_nameunit(sc->sc_dev), 2084 UGETDW(sc->csw.dCSWTag), 2085 UGETDW(sc->cbw.dCBWTag)); 2086 2087 umass_bbb_reset(sc, STATUS_WIRE_FAILED); 2088 return; 2089 2090 /* CSW is valid here */ 2091 } else if (sc->csw.bCSWStatus > CSWSTATUS_PHASE) { 2092 printf("%s: Invalid CSW: status %d > %d\n", 2093 device_get_nameunit(sc->sc_dev), 2094 sc->csw.bCSWStatus, 2095 CSWSTATUS_PHASE); 2096 2097 umass_bbb_reset(sc, STATUS_WIRE_FAILED); 2098 return; 2099 } else if (sc->csw.bCSWStatus == CSWSTATUS_PHASE) { 2100 printf("%s: Phase Error, residue = %d\n", 2101 device_get_nameunit(sc->sc_dev), Residue); 2102 2103 umass_bbb_reset(sc, STATUS_WIRE_FAILED); 2104 return; 2105 2106 } else if (sc->transfer_actlen > sc->transfer_datalen) { 2107 /* Buffer overrun! Don't let this go by unnoticed */ 2108 panic("%s: transferred %db instead of %db", 2109 device_get_nameunit(sc->sc_dev), 2110 sc->transfer_actlen, sc->transfer_datalen); 2111 2112 } else if (sc->csw.bCSWStatus == CSWSTATUS_FAILED) { 2113 DPRINTF(UDMASS_BBB, ("%s: Command Failed, res = %d\n", 2114 device_get_nameunit(sc->sc_dev), Residue)); 2115 2116 /* SCSI command failed but transfer was succesful */ 2117 sc->transfer_state = TSTATE_IDLE; 2118 sc->transfer_cb(sc, sc->transfer_priv, Residue, 2119 STATUS_CMD_FAILED); 2120 return; 2121 2122 } else { /* success */ 2123 sc->transfer_state = TSTATE_IDLE; 2124 sc->transfer_cb(sc, sc->transfer_priv, Residue, 2125 STATUS_CMD_OK); 2126 2127 return; 2128 } 2129 2130 /***** Bulk Reset *****/ 2131 case TSTATE_BBB_RESET1: 2132 if (err) 2133 printf("%s: BBB reset failed, %s\n", 2134 device_get_nameunit(sc->sc_dev), usbd_errstr(err)); 2135 2136 umass_clear_endpoint_stall(sc, 2137 sc->bulkin, sc->bulkin_pipe, TSTATE_BBB_RESET2, 2138 sc->transfer_xfer[XFER_BBB_RESET2]); 2139 2140 return; 2141 case TSTATE_BBB_RESET2: 2142 if (err) /* should not occur */ 2143 printf("%s: BBB bulk-in clear stall failed, %s\n", 2144 device_get_nameunit(sc->sc_dev), usbd_errstr(err)); 2145 /* no error recovery, otherwise we end up in a loop */ 2146 2147 umass_clear_endpoint_stall(sc, 2148 sc->bulkout, sc->bulkout_pipe, TSTATE_BBB_RESET3, 2149 sc->transfer_xfer[XFER_BBB_RESET3]); 2150 2151 return; 2152 case TSTATE_BBB_RESET3: 2153 if (err) /* should not occur */ 2154 printf("%s: BBB bulk-out clear stall failed, %s\n", 2155 device_get_nameunit(sc->sc_dev), usbd_errstr(err)); 2156 /* no error recovery, otherwise we end up in a loop */ 2157 2158 sc->transfer_state = TSTATE_IDLE; 2159 if (sc->transfer_priv) { 2160 sc->transfer_cb(sc, sc->transfer_priv, 2161 sc->transfer_datalen, 2162 sc->transfer_status); 2163 } 2164 2165 return; 2166 2167 /***** Default *****/ 2168 default: 2169 panic("%s: Unknown state %d", 2170 device_get_nameunit(sc->sc_dev), sc->transfer_state); 2171 } 2172 } 2173 2174 static int 2175 umass_bbb_get_max_lun(struct umass_softc *sc) 2176 { 2177 usbd_device_handle udev; 2178 usb_device_request_t req; 2179 usbd_status err; 2180 usb_interface_descriptor_t *id; 2181 int maxlun = 0; 2182 u_int8_t buf = 0; 2183 2184 usbd_interface2device_handle(sc->iface, &udev); 2185 id = usbd_get_interface_descriptor(sc->iface); 2186 2187 /* The Get Max Lun command is a class-specific request. */ 2188 req.bmRequestType = UT_READ_CLASS_INTERFACE; 2189 req.bRequest = UR_BBB_GET_MAX_LUN; 2190 USETW(req.wValue, 0); 2191 USETW(req.wIndex, id->bInterfaceNumber); 2192 USETW(req.wLength, 1); 2193 2194 err = usbd_do_request(udev, &req, &buf); 2195 switch (err) { 2196 case USBD_NORMAL_COMPLETION: 2197 maxlun = buf; 2198 DPRINTF(UDMASS_BBB, ("%s: Max Lun is %d\n", 2199 device_get_nameunit(sc->sc_dev), maxlun)); 2200 break; 2201 case USBD_STALLED: 2202 case USBD_SHORT_XFER: 2203 default: 2204 /* Device doesn't support Get Max Lun request. */ 2205 printf("%s: Get Max Lun not supported (%s)\n", 2206 device_get_nameunit(sc->sc_dev), usbd_errstr(err)); 2207 /* XXX Should we port_reset the device? */ 2208 break; 2209 } 2210 2211 return(maxlun); 2212 } 2213 2214 /* 2215 * Command/Bulk/Interrupt (CBI) specific functions 2216 */ 2217 2218 static int 2219 umass_cbi_adsc(struct umass_softc *sc, char *buffer, int buflen, 2220 usbd_xfer_handle xfer) 2221 { 2222 usbd_device_handle udev; 2223 2224 KASSERT(sc->proto & (UMASS_PROTO_CBI|UMASS_PROTO_CBI_I), 2225 ("%s: umass_cbi_adsc: wrong sc->proto 0x%02x\n", 2226 device_get_nameunit(sc->sc_dev), sc->proto)); 2227 2228 usbd_interface2device_handle(sc->iface, &udev); 2229 2230 sc->request.bmRequestType = UT_WRITE_CLASS_INTERFACE; 2231 sc->request.bRequest = UR_CBI_ADSC; 2232 USETW(sc->request.wValue, 0); 2233 USETW(sc->request.wIndex, sc->ifaceno); 2234 USETW(sc->request.wLength, buflen); 2235 return umass_setup_ctrl_transfer(sc, udev, &sc->request, buffer, 2236 buflen, 0, xfer); 2237 } 2238 2239 2240 static void 2241 umass_cbi_reset(struct umass_softc *sc, int status) 2242 { 2243 int i; 2244 # define SEND_DIAGNOSTIC_CMDLEN 12 2245 2246 KASSERT(sc->proto & (UMASS_PROTO_CBI|UMASS_PROTO_CBI_I), 2247 ("%s: umass_cbi_reset: wrong sc->proto 0x%02x\n", 2248 device_get_nameunit(sc->sc_dev), sc->proto)); 2249 2250 /* 2251 * Command Block Reset Protocol 2252 * 2253 * First send a reset request to the device. Then clear 2254 * any possibly stalled bulk endpoints. 2255 * 2256 * This is done in 3 steps, states: 2257 * TSTATE_CBI_RESET1 2258 * TSTATE_CBI_RESET2 2259 * TSTATE_CBI_RESET3 2260 * 2261 * If the reset doesn't succeed, the device should be port reset. 2262 */ 2263 2264 DPRINTF(UDMASS_CBI, ("%s: CBI Reset\n", 2265 device_get_nameunit(sc->sc_dev))); 2266 2267 KASSERT(sizeof(sc->cbl) >= SEND_DIAGNOSTIC_CMDLEN, 2268 ("%s: CBL struct is too small (%ld < %d)\n", 2269 device_get_nameunit(sc->sc_dev), 2270 (long)sizeof(sc->cbl), SEND_DIAGNOSTIC_CMDLEN)); 2271 2272 sc->transfer_state = TSTATE_CBI_RESET1; 2273 sc->transfer_status = status; 2274 2275 /* The 0x1d code is the SEND DIAGNOSTIC command. To distinguish between 2276 * the two the last 10 bytes of the cbl is filled with 0xff (section 2277 * 2.2 of the CBI spec). 2278 */ 2279 sc->cbl[0] = 0x1d; /* Command Block Reset */ 2280 sc->cbl[1] = 0x04; 2281 for (i = 2; i < SEND_DIAGNOSTIC_CMDLEN; i++) 2282 sc->cbl[i] = 0xff; 2283 2284 umass_cbi_adsc(sc, sc->cbl, SEND_DIAGNOSTIC_CMDLEN, 2285 sc->transfer_xfer[XFER_CBI_RESET1]); 2286 /* XXX if the command fails we should reset the port on the hub */ 2287 } 2288 2289 static void 2290 umass_cbi_transfer(struct umass_softc *sc, int lun, 2291 void *cmd, int cmdlen, void *data, int datalen, int dir, 2292 u_int timeout, transfer_cb_f cb, void *priv) 2293 { 2294 KASSERT(sc->proto & (UMASS_PROTO_CBI|UMASS_PROTO_CBI_I), 2295 ("%s: umass_cbi_transfer: wrong sc->proto 0x%02x\n", 2296 device_get_nameunit(sc->sc_dev), sc->proto)); 2297 2298 /* Be a little generous. */ 2299 sc->timeout = timeout + UMASS_TIMEOUT; 2300 2301 /* 2302 * Do a CBI transfer with cmdlen bytes from cmd, possibly 2303 * a data phase of datalen bytes from/to the device and finally a 2304 * csw read phase. 2305 * If the data direction was inbound a maximum of datalen bytes 2306 * is stored in the buffer pointed to by data. 2307 * 2308 * umass_cbi_transfer initialises the transfer and lets the state 2309 * machine in umass_cbi_state handle the completion. It uses the 2310 * following states: 2311 * TSTATE_CBI_COMMAND 2312 * -> XXX fill in 2313 * 2314 * An error in any of those states will invoke 2315 * umass_cbi_reset. 2316 */ 2317 2318 /* check the given arguments */ 2319 KASSERT(datalen == 0 || data != NULL, 2320 ("%s: datalen > 0, but no buffer",device_get_nameunit(sc->sc_dev))); 2321 KASSERT(datalen == 0 || dir != DIR_NONE, 2322 ("%s: direction is NONE while datalen is not zero\n", 2323 device_get_nameunit(sc->sc_dev))); 2324 2325 /* store the details for the data transfer phase */ 2326 sc->transfer_dir = dir; 2327 sc->transfer_data = data; 2328 sc->transfer_datalen = datalen; 2329 sc->transfer_actlen = 0; 2330 sc->transfer_cb = cb; 2331 sc->transfer_priv = priv; 2332 sc->transfer_status = STATUS_CMD_OK; 2333 2334 /* move from idle to the command state */ 2335 sc->transfer_state = TSTATE_CBI_COMMAND; 2336 2337 DIF(UDMASS_CBI, umass_cbi_dump_cmd(sc, cmd, cmdlen)); 2338 2339 /* Send the Command Block from host to device via control endpoint. */ 2340 if (umass_cbi_adsc(sc, cmd, cmdlen, sc->transfer_xfer[XFER_CBI_CB])) 2341 umass_cbi_reset(sc, STATUS_WIRE_FAILED); 2342 } 2343 2344 static void 2345 umass_cbi_state(usbd_xfer_handle xfer, usbd_private_handle priv, 2346 usbd_status err) 2347 { 2348 struct umass_softc *sc = (struct umass_softc *) priv; 2349 2350 KASSERT(sc->proto & (UMASS_PROTO_CBI|UMASS_PROTO_CBI_I), 2351 ("%s: umass_cbi_state: wrong sc->proto 0x%02x\n", 2352 device_get_nameunit(sc->sc_dev), sc->proto)); 2353 2354 /* 2355 * State handling for CBI transfers. 2356 */ 2357 2358 DPRINTF(UDMASS_CBI, ("%s: Handling CBI state %d (%s), xfer=%p, %s\n", 2359 device_get_nameunit(sc->sc_dev), sc->transfer_state, 2360 states[sc->transfer_state], xfer, usbd_errstr(err))); 2361 2362 /* Give up if the device has detached. */ 2363 if (sc->flags & UMASS_FLAGS_GONE) { 2364 sc->transfer_state = TSTATE_IDLE; 2365 sc->transfer_cb(sc, sc->transfer_priv, sc->transfer_datalen, 2366 STATUS_CMD_FAILED); 2367 return; 2368 } 2369 2370 switch (sc->transfer_state) { 2371 2372 /***** CBI Transfer *****/ 2373 case TSTATE_CBI_COMMAND: 2374 if (err == USBD_STALLED) { 2375 DPRINTF(UDMASS_CBI, ("%s: Command Transport failed\n", 2376 device_get_nameunit(sc->sc_dev))); 2377 /* Status transport by control pipe (section 2.3.2.1). 2378 * The command contained in the command block failed. 2379 * 2380 * The control pipe has already been unstalled by the 2381 * USB stack. 2382 * Section 2.4.3.1.1 states that the bulk in endpoints 2383 * should not be stalled at this point. 2384 */ 2385 2386 sc->transfer_state = TSTATE_IDLE; 2387 sc->transfer_cb(sc, sc->transfer_priv, 2388 sc->transfer_datalen, 2389 STATUS_CMD_FAILED); 2390 2391 return; 2392 } else if (err) { 2393 DPRINTF(UDMASS_CBI, ("%s: failed to send ADSC\n", 2394 device_get_nameunit(sc->sc_dev))); 2395 umass_cbi_reset(sc, STATUS_WIRE_FAILED); 2396 2397 return; 2398 } 2399 2400 sc->transfer_state = TSTATE_CBI_DATA; 2401 if (sc->transfer_dir == DIR_IN) { 2402 if (umass_setup_transfer(sc, sc->bulkin_pipe, 2403 sc->transfer_data, sc->transfer_datalen, 2404 USBD_SHORT_XFER_OK, 2405 sc->transfer_xfer[XFER_CBI_DATA])) 2406 umass_cbi_reset(sc, STATUS_WIRE_FAILED); 2407 2408 } else if (sc->transfer_dir == DIR_OUT) { 2409 if (umass_setup_transfer(sc, sc->bulkout_pipe, 2410 sc->transfer_data, sc->transfer_datalen, 2411 0, /* fixed length transfer */ 2412 sc->transfer_xfer[XFER_CBI_DATA])) 2413 umass_cbi_reset(sc, STATUS_WIRE_FAILED); 2414 2415 } else if (sc->proto & UMASS_PROTO_CBI_I) { 2416 DPRINTF(UDMASS_CBI, ("%s: no data phase\n", 2417 device_get_nameunit(sc->sc_dev))); 2418 sc->transfer_state = TSTATE_CBI_STATUS; 2419 if (umass_setup_transfer(sc, sc->intrin_pipe, 2420 &sc->sbl, sizeof(sc->sbl), 2421 0, /* fixed length transfer */ 2422 sc->transfer_xfer[XFER_CBI_STATUS])){ 2423 umass_cbi_reset(sc, STATUS_WIRE_FAILED); 2424 } 2425 } else { 2426 DPRINTF(UDMASS_CBI, ("%s: no data phase\n", 2427 device_get_nameunit(sc->sc_dev))); 2428 /* No command completion interrupt. Request 2429 * sense data. 2430 */ 2431 sc->transfer_state = TSTATE_IDLE; 2432 sc->transfer_cb(sc, sc->transfer_priv, 2433 0, STATUS_CMD_UNKNOWN); 2434 } 2435 2436 return; 2437 2438 case TSTATE_CBI_DATA: 2439 /* retrieve the length of the transfer that was done */ 2440 usbd_get_xfer_status(xfer,NULL,NULL,&sc->transfer_actlen,NULL); 2441 2442 if (err) { 2443 DPRINTF(UDMASS_CBI, ("%s: Data-%s %db failed, " 2444 "%s\n", device_get_nameunit(sc->sc_dev), 2445 (sc->transfer_dir == DIR_IN?"in":"out"), 2446 sc->transfer_datalen,usbd_errstr(err))); 2447 2448 if (err == USBD_STALLED) { 2449 umass_clear_endpoint_stall(sc, 2450 sc->bulkin, sc->bulkin_pipe, 2451 TSTATE_CBI_DCLEAR, 2452 sc->transfer_xfer[XFER_CBI_DCLEAR]); 2453 } else { 2454 umass_cbi_reset(sc, STATUS_WIRE_FAILED); 2455 } 2456 return; 2457 } 2458 2459 DIF(UDMASS_CBI, if (sc->transfer_dir == DIR_IN) 2460 umass_dump_buffer(sc, sc->transfer_data, 2461 sc->transfer_actlen, 48)); 2462 2463 if (sc->proto & UMASS_PROTO_CBI_I) { 2464 sc->transfer_state = TSTATE_CBI_STATUS; 2465 if (umass_setup_transfer(sc, sc->intrin_pipe, 2466 &sc->sbl, sizeof(sc->sbl), 2467 0, /* fixed length transfer */ 2468 sc->transfer_xfer[XFER_CBI_STATUS])){ 2469 umass_cbi_reset(sc, STATUS_WIRE_FAILED); 2470 } 2471 } else { 2472 /* No command completion interrupt. Request 2473 * sense to get status of command. 2474 */ 2475 sc->transfer_state = TSTATE_IDLE; 2476 sc->transfer_cb(sc, sc->transfer_priv, 2477 sc->transfer_datalen - sc->transfer_actlen, 2478 STATUS_CMD_UNKNOWN); 2479 } 2480 return; 2481 2482 case TSTATE_CBI_STATUS: 2483 if (err) { 2484 DPRINTF(UDMASS_CBI, ("%s: Status Transport failed\n", 2485 device_get_nameunit(sc->sc_dev))); 2486 /* Status transport by interrupt pipe (section 2.3.2.2). 2487 */ 2488 2489 if (err == USBD_STALLED) { 2490 umass_clear_endpoint_stall(sc, 2491 sc->intrin, sc->intrin_pipe, 2492 TSTATE_CBI_SCLEAR, 2493 sc->transfer_xfer[XFER_CBI_SCLEAR]); 2494 } else { 2495 umass_cbi_reset(sc, STATUS_WIRE_FAILED); 2496 } 2497 return; 2498 } 2499 2500 /* Dissect the information in the buffer */ 2501 2502 if (sc->proto & UMASS_PROTO_UFI) { 2503 int status; 2504 2505 /* Section 3.4.3.1.3 specifies that the UFI command 2506 * protocol returns an ASC and ASCQ in the interrupt 2507 * data block. 2508 */ 2509 2510 DPRINTF(UDMASS_CBI, ("%s: UFI CCI, ASC = 0x%02x, " 2511 "ASCQ = 0x%02x\n", 2512 device_get_nameunit(sc->sc_dev), 2513 sc->sbl.ufi.asc, sc->sbl.ufi.ascq)); 2514 2515 if (sc->sbl.ufi.asc == 0 && sc->sbl.ufi.ascq == 0) 2516 status = STATUS_CMD_OK; 2517 else 2518 status = STATUS_CMD_FAILED; 2519 2520 sc->transfer_state = TSTATE_IDLE; 2521 sc->transfer_cb(sc, sc->transfer_priv, 2522 sc->transfer_datalen - sc->transfer_actlen, 2523 status); 2524 } else { 2525 /* Command Interrupt Data Block */ 2526 DPRINTF(UDMASS_CBI, ("%s: type=0x%02x, value=0x%02x\n", 2527 device_get_nameunit(sc->sc_dev), 2528 sc->sbl.common.type, sc->sbl.common.value)); 2529 2530 if (sc->sbl.common.type == IDB_TYPE_CCI) { 2531 int err; 2532 2533 if ((sc->sbl.common.value&IDB_VALUE_STATUS_MASK) 2534 == IDB_VALUE_PASS) { 2535 err = STATUS_CMD_OK; 2536 } else if ((sc->sbl.common.value & IDB_VALUE_STATUS_MASK) 2537 == IDB_VALUE_FAIL || 2538 (sc->sbl.common.value & IDB_VALUE_STATUS_MASK) 2539 == IDB_VALUE_PERSISTENT) { 2540 err = STATUS_CMD_FAILED; 2541 } else { 2542 err = STATUS_WIRE_FAILED; 2543 } 2544 2545 sc->transfer_state = TSTATE_IDLE; 2546 sc->transfer_cb(sc, sc->transfer_priv, 2547 sc->transfer_datalen-sc->transfer_actlen, 2548 err); 2549 } 2550 } 2551 return; 2552 2553 case TSTATE_CBI_DCLEAR: 2554 if (err) { /* should not occur */ 2555 printf("%s: CBI bulk-in/out stall clear failed, %s\n", 2556 device_get_nameunit(sc->sc_dev), usbd_errstr(err)); 2557 umass_cbi_reset(sc, STATUS_WIRE_FAILED); 2558 } 2559 2560 sc->transfer_state = TSTATE_IDLE; 2561 sc->transfer_cb(sc, sc->transfer_priv, 2562 sc->transfer_datalen, 2563 STATUS_CMD_FAILED); 2564 return; 2565 2566 case TSTATE_CBI_SCLEAR: 2567 if (err) /* should not occur */ 2568 printf("%s: CBI intr-in stall clear failed, %s\n", 2569 device_get_nameunit(sc->sc_dev), usbd_errstr(err)); 2570 2571 /* Something really bad is going on. Reset the device */ 2572 umass_cbi_reset(sc, STATUS_CMD_FAILED); 2573 return; 2574 2575 /***** CBI Reset *****/ 2576 case TSTATE_CBI_RESET1: 2577 if (err) 2578 printf("%s: CBI reset failed, %s\n", 2579 device_get_nameunit(sc->sc_dev), usbd_errstr(err)); 2580 2581 umass_clear_endpoint_stall(sc, 2582 sc->bulkin, sc->bulkin_pipe, TSTATE_CBI_RESET2, 2583 sc->transfer_xfer[XFER_CBI_RESET2]); 2584 2585 return; 2586 case TSTATE_CBI_RESET2: 2587 if (err) /* should not occur */ 2588 printf("%s: CBI bulk-in stall clear failed, %s\n", 2589 device_get_nameunit(sc->sc_dev), usbd_errstr(err)); 2590 /* no error recovery, otherwise we end up in a loop */ 2591 2592 umass_clear_endpoint_stall(sc, 2593 sc->bulkout, sc->bulkout_pipe, TSTATE_CBI_RESET3, 2594 sc->transfer_xfer[XFER_CBI_RESET3]); 2595 2596 return; 2597 case TSTATE_CBI_RESET3: 2598 if (err) /* should not occur */ 2599 printf("%s: CBI bulk-out stall clear failed, %s\n", 2600 device_get_nameunit(sc->sc_dev), usbd_errstr(err)); 2601 /* no error recovery, otherwise we end up in a loop */ 2602 2603 sc->transfer_state = TSTATE_IDLE; 2604 if (sc->transfer_priv) { 2605 sc->transfer_cb(sc, sc->transfer_priv, 2606 sc->transfer_datalen, 2607 sc->transfer_status); 2608 } 2609 2610 return; 2611 2612 2613 /***** Default *****/ 2614 default: 2615 panic("%s: Unknown state %d", 2616 device_get_nameunit(sc->sc_dev), sc->transfer_state); 2617 } 2618 } 2619 2620 2621 2622 2623 /* 2624 * CAM specific functions (used by SCSI, UFI, 8070i (ATAPI)) 2625 */ 2626 2627 static int 2628 umass_cam_attach_sim(struct umass_softc *sc) 2629 { 2630 struct cam_devq *devq; /* Per device Queue */ 2631 2632 /* A HBA is attached to the CAM layer. 2633 * 2634 * The CAM layer will then after a while start probing for 2635 * devices on the bus. The number of SIMs is limited to one. 2636 */ 2637 2638 devq = cam_simq_alloc(1 /*maximum openings*/); 2639 if (devq == NULL) 2640 return(ENOMEM); 2641 2642 sc->umass_sim = cam_sim_alloc(umass_cam_action, umass_cam_poll, 2643 DEVNAME_SIM, 2644 sc /*priv*/, 2645 device_get_unit(sc->sc_dev) /*unit number*/, 2646 &Giant, 2647 1 /*maximum device openings*/, 2648 0 /*maximum tagged device openings*/, 2649 devq); 2650 if (sc->umass_sim == NULL) { 2651 cam_simq_free(devq); 2652 return(ENOMEM); 2653 } 2654 2655 if(xpt_bus_register(sc->umass_sim, NULL, device_get_unit(sc->sc_dev)) != 2656 CAM_SUCCESS) 2657 return(ENOMEM); 2658 2659 return(0); 2660 } 2661 2662 static void 2663 umass_cam_rescan_callback(struct cam_periph *periph, union ccb *ccb) 2664 { 2665 #ifdef USB_DEBUG 2666 if (ccb->ccb_h.status != CAM_REQ_CMP) { 2667 DPRINTF(UDMASS_SCSI, ("%s:%d Rescan failed, 0x%04x\n", 2668 periph->periph_name, periph->unit_number, 2669 ccb->ccb_h.status)); 2670 } else { 2671 DPRINTF(UDMASS_SCSI, ("%s%d: Rescan succeeded\n", 2672 periph->periph_name, periph->unit_number)); 2673 } 2674 #endif 2675 2676 xpt_free_path(ccb->ccb_h.path); 2677 free(ccb, M_USBDEV); 2678 } 2679 2680 static void 2681 umass_cam_rescan(void *addr) 2682 { 2683 struct umass_softc *sc = (struct umass_softc *) addr; 2684 struct cam_path *path; 2685 union ccb *ccb; 2686 2687 DPRINTF(UDMASS_SCSI, ("scbus%d: scanning for %s:%d:%d:%d\n", 2688 cam_sim_path(sc->umass_sim), 2689 device_get_nameunit(sc->sc_dev), cam_sim_path(sc->umass_sim), 2690 device_get_unit(sc->sc_dev), CAM_LUN_WILDCARD)); 2691 2692 ccb = malloc(sizeof(union ccb), M_USBDEV, M_NOWAIT | M_ZERO); 2693 if (ccb == NULL) 2694 return; 2695 if (xpt_create_path(&path, xpt_periph, cam_sim_path(sc->umass_sim), 2696 device_get_unit(sc->sc_dev), CAM_LUN_WILDCARD) 2697 != CAM_REQ_CMP) { 2698 free(ccb, M_USBDEV); 2699 return; 2700 } 2701 2702 xpt_setup_ccb(&ccb->ccb_h, path, 5/*priority (low)*/); 2703 ccb->ccb_h.func_code = XPT_SCAN_BUS; 2704 ccb->ccb_h.cbfcnp = umass_cam_rescan_callback; 2705 ccb->crcn.flags = CAM_FLAG_NONE; 2706 xpt_action(ccb); 2707 2708 /* The scan is in progress now. */ 2709 } 2710 2711 static int 2712 umass_cam_attach(struct umass_softc *sc) 2713 { 2714 #ifndef USB_DEBUG 2715 if (bootverbose) 2716 #endif 2717 printf("%s:%d:%d:%d: Attached to scbus%d\n", 2718 device_get_nameunit(sc->sc_dev), cam_sim_path(sc->umass_sim), 2719 device_get_unit(sc->sc_dev), CAM_LUN_WILDCARD, 2720 cam_sim_path(sc->umass_sim)); 2721 2722 if (!cold) { 2723 /* Notify CAM of the new device after a short delay. Any 2724 * failure is benign, as the user can still do it by hand 2725 * (camcontrol rescan <busno>). Only do this if we are not 2726 * booting, because CAM does a scan after booting has 2727 * completed, when interrupts have been enabled. 2728 */ 2729 2730 callout_reset(&sc->cam_scsi_rescan_ch, MS_TO_TICKS(200), 2731 umass_cam_rescan, sc); 2732 } 2733 2734 return(0); /* always succesfull */ 2735 } 2736 2737 /* umass_cam_detach 2738 * detach from the CAM layer 2739 */ 2740 2741 static int 2742 umass_cam_detach_sim(struct umass_softc *sc) 2743 { 2744 if (sc->umass_sim) { 2745 if (xpt_bus_deregister(cam_sim_path(sc->umass_sim))) 2746 cam_sim_free(sc->umass_sim, /*free_devq*/TRUE); 2747 else 2748 return(EBUSY); 2749 2750 sc->umass_sim = NULL; 2751 } 2752 2753 return(0); 2754 } 2755 2756 /* umass_cam_action 2757 * CAM requests for action come through here 2758 */ 2759 2760 static void 2761 umass_cam_action(struct cam_sim *sim, union ccb *ccb) 2762 { 2763 struct umass_softc *sc = (struct umass_softc *)sim->softc; 2764 2765 /* The softc is still there, but marked as going away. umass_cam_detach 2766 * has not yet notified CAM of the lost device however. 2767 */ 2768 if (sc && (sc->flags & UMASS_FLAGS_GONE)) { 2769 DPRINTF(UDMASS_SCSI, ("%s:%d:%d:%d:func_code 0x%04x: " 2770 "Invalid target (gone)\n", 2771 device_get_nameunit(sc->sc_dev), cam_sim_path(sc->umass_sim), 2772 ccb->ccb_h.target_id, ccb->ccb_h.target_lun, 2773 ccb->ccb_h.func_code)); 2774 ccb->ccb_h.status = CAM_TID_INVALID; 2775 xpt_done(ccb); 2776 return; 2777 } 2778 2779 /* Verify, depending on the operation to perform, that we either got a 2780 * valid sc, because an existing target was referenced, or otherwise 2781 * the SIM is addressed. 2782 * 2783 * This avoids bombing out at a printf and does give the CAM layer some 2784 * sensible feedback on errors. 2785 */ 2786 switch (ccb->ccb_h.func_code) { 2787 case XPT_SCSI_IO: 2788 case XPT_RESET_DEV: 2789 case XPT_GET_TRAN_SETTINGS: 2790 case XPT_SET_TRAN_SETTINGS: 2791 case XPT_CALC_GEOMETRY: 2792 /* the opcodes requiring a target. These should never occur. */ 2793 if (sc == NULL) { 2794 printf("%s:%d:%d:%d:func_code 0x%04x: " 2795 "Invalid target (target needed)\n", 2796 DEVNAME_SIM, cam_sim_path(sc->umass_sim), 2797 ccb->ccb_h.target_id, ccb->ccb_h.target_lun, 2798 ccb->ccb_h.func_code); 2799 2800 ccb->ccb_h.status = CAM_TID_INVALID; 2801 xpt_done(ccb); 2802 return; 2803 } 2804 break; 2805 case XPT_PATH_INQ: 2806 case XPT_NOOP: 2807 /* The opcodes sometimes aimed at a target (sc is valid), 2808 * sometimes aimed at the SIM (sc is invalid and target is 2809 * CAM_TARGET_WILDCARD) 2810 */ 2811 if (sc == NULL && ccb->ccb_h.target_id != CAM_TARGET_WILDCARD) { 2812 DPRINTF(UDMASS_SCSI, ("%s:%d:%d:%d:func_code 0x%04x: " 2813 "Invalid target (no wildcard)\n", 2814 DEVNAME_SIM, cam_sim_path(sc->umass_sim), 2815 ccb->ccb_h.target_id, ccb->ccb_h.target_lun, 2816 ccb->ccb_h.func_code)); 2817 2818 ccb->ccb_h.status = CAM_TID_INVALID; 2819 xpt_done(ccb); 2820 return; 2821 } 2822 break; 2823 default: 2824 /* XXX Hm, we should check the input parameters */ 2825 break; 2826 } 2827 2828 /* Perform the requested action */ 2829 switch (ccb->ccb_h.func_code) { 2830 case XPT_SCSI_IO: 2831 { 2832 struct ccb_scsiio *csio = &ccb->csio; /* deref union */ 2833 int dir; 2834 unsigned char *cmd; 2835 int cmdlen; 2836 unsigned char *rcmd; 2837 int rcmdlen; 2838 2839 DPRINTF(UDMASS_SCSI, ("%s:%d:%d:%d:XPT_SCSI_IO: " 2840 "cmd: 0x%02x, flags: 0x%02x, " 2841 "%db cmd/%db data/%db sense\n", 2842 device_get_nameunit(sc->sc_dev), cam_sim_path(sc->umass_sim), 2843 ccb->ccb_h.target_id, ccb->ccb_h.target_lun, 2844 csio->cdb_io.cdb_bytes[0], 2845 ccb->ccb_h.flags & CAM_DIR_MASK, 2846 csio->cdb_len, csio->dxfer_len, 2847 csio->sense_len)); 2848 2849 /* clear the end of the buffer to make sure we don't send out 2850 * garbage. 2851 */ 2852 DIF(UDMASS_SCSI, if ((ccb->ccb_h.flags & CAM_DIR_MASK) 2853 == CAM_DIR_OUT) 2854 umass_dump_buffer(sc, csio->data_ptr, 2855 csio->dxfer_len, 48)); 2856 2857 if (sc->transfer_state != TSTATE_IDLE) { 2858 DPRINTF(UDMASS_SCSI, ("%s:%d:%d:%d:XPT_SCSI_IO: " 2859 "I/O in progress, deferring (state %d, %s)\n", 2860 device_get_nameunit(sc->sc_dev), cam_sim_path(sc->umass_sim), 2861 ccb->ccb_h.target_id, ccb->ccb_h.target_lun, 2862 sc->transfer_state,states[sc->transfer_state])); 2863 ccb->ccb_h.status = CAM_SCSI_BUSY; 2864 xpt_done(ccb); 2865 return; 2866 } 2867 2868 switch(ccb->ccb_h.flags&CAM_DIR_MASK) { 2869 case CAM_DIR_IN: 2870 dir = DIR_IN; 2871 break; 2872 case CAM_DIR_OUT: 2873 dir = DIR_OUT; 2874 break; 2875 default: 2876 dir = DIR_NONE; 2877 } 2878 2879 ccb->ccb_h.status = CAM_REQ_INPROG | CAM_SIM_QUEUED; 2880 2881 2882 if (csio->ccb_h.flags & CAM_CDB_POINTER) { 2883 cmd = (unsigned char *) csio->cdb_io.cdb_ptr; 2884 } else { 2885 cmd = (unsigned char *) &csio->cdb_io.cdb_bytes; 2886 } 2887 cmdlen = csio->cdb_len; 2888 rcmd = (unsigned char *) &sc->cam_scsi_command; 2889 rcmdlen = sizeof(sc->cam_scsi_command); 2890 2891 /* sc->transform will convert the command to the command 2892 * (format) needed by the specific command set and return 2893 * the converted command in a buffer pointed to be rcmd. 2894 * We pass in a buffer, but if the command does not 2895 * have to be transformed it returns a ptr to the original 2896 * buffer (see umass_scsi_transform). 2897 */ 2898 2899 switch (sc->transform(sc, cmd, cmdlen, &rcmd, &rcmdlen)) { 2900 case 1: 2901 /* 2902 * Handle EVPD inquiry for broken devices first 2903 * NO_INQUIRY also implies NO_INQUIRY_EVPD 2904 */ 2905 if ((sc->quirks & (NO_INQUIRY_EVPD | NO_INQUIRY)) && 2906 rcmd[0] == INQUIRY && (rcmd[1] & SI_EVPD)) { 2907 struct scsi_sense_data *sense; 2908 2909 sense = &ccb->csio.sense_data; 2910 bzero(sense, sizeof(*sense)); 2911 sense->error_code = SSD_CURRENT_ERROR; 2912 sense->flags = SSD_KEY_ILLEGAL_REQUEST; 2913 sense->add_sense_code = 0x24; 2914 sense->extra_len = 10; 2915 ccb->csio.scsi_status = SCSI_STATUS_CHECK_COND; 2916 ccb->ccb_h.status = CAM_SCSI_STATUS_ERROR | 2917 CAM_AUTOSNS_VALID; 2918 xpt_done(ccb); 2919 return; 2920 } 2921 /* Return fake inquiry data for broken devices */ 2922 if ((sc->quirks & NO_INQUIRY) && rcmd[0] == INQUIRY) { 2923 struct ccb_scsiio *csio = &ccb->csio; 2924 2925 memcpy(csio->data_ptr, &fake_inq_data, 2926 sizeof(fake_inq_data)); 2927 csio->scsi_status = SCSI_STATUS_OK; 2928 ccb->ccb_h.status = CAM_REQ_CMP; 2929 xpt_done(ccb); 2930 return; 2931 } 2932 if ((sc->quirks & NO_SYNCHRONIZE_CACHE) && 2933 rcmd[0] == SYNCHRONIZE_CACHE) { 2934 struct ccb_scsiio *csio = &ccb->csio; 2935 2936 csio->scsi_status = SCSI_STATUS_OK; 2937 ccb->ccb_h.status = CAM_REQ_CMP; 2938 xpt_done(ccb); 2939 return; 2940 } 2941 if ((sc->quirks & FORCE_SHORT_INQUIRY) && 2942 rcmd[0] == INQUIRY) { 2943 csio->dxfer_len = SHORT_INQUIRY_LENGTH; 2944 } 2945 sc->transfer(sc, ccb->ccb_h.target_lun, rcmd, rcmdlen, 2946 csio->data_ptr, 2947 csio->dxfer_len, dir, ccb->ccb_h.timeout, 2948 umass_cam_cb, (void *) ccb); 2949 break; 2950 case 0: 2951 ccb->ccb_h.status = CAM_REQ_INVALID; 2952 xpt_done(ccb); 2953 break; 2954 case 2: 2955 ccb->ccb_h.status = CAM_REQ_CMP; 2956 xpt_done(ccb); 2957 break; 2958 } 2959 2960 break; 2961 } 2962 case XPT_PATH_INQ: 2963 { 2964 struct ccb_pathinq *cpi = &ccb->cpi; 2965 2966 DPRINTF(UDMASS_SCSI, ("%s:%d:%d:%d:XPT_PATH_INQ:.\n", 2967 (sc == NULL? DEVNAME_SIM:device_get_nameunit(sc->sc_dev)), 2968 cam_sim_path(sc->umass_sim), 2969 ccb->ccb_h.target_id, ccb->ccb_h.target_lun)); 2970 2971 /* host specific information */ 2972 cpi->version_num = 1; 2973 cpi->hba_inquiry = 0; 2974 cpi->target_sprt = 0; 2975 cpi->hba_misc = PIM_NO_6_BYTE; 2976 cpi->hba_eng_cnt = 0; 2977 cpi->max_target = UMASS_SCSIID_MAX; /* one target */ 2978 cpi->initiator_id = UMASS_SCSIID_HOST; 2979 strncpy(cpi->sim_vid, "FreeBSD", SIM_IDLEN); 2980 strncpy(cpi->hba_vid, "USB SCSI", HBA_IDLEN); 2981 strncpy(cpi->dev_name, cam_sim_name(sim), DEV_IDLEN); 2982 cpi->unit_number = cam_sim_unit(sim); 2983 cpi->bus_id = device_get_unit(sc->sc_dev); 2984 cpi->protocol = PROTO_SCSI; 2985 cpi->protocol_version = SCSI_REV_2; 2986 cpi->transport = XPORT_USB; 2987 cpi->transport_version = 0; 2988 2989 if (sc == NULL) { 2990 cpi->base_transfer_speed = 0; 2991 cpi->max_lun = 0; 2992 } else { 2993 if (sc->quirks & FLOPPY_SPEED) { 2994 cpi->base_transfer_speed = 2995 UMASS_FLOPPY_TRANSFER_SPEED; 2996 } else if (usbd_get_speed(sc->sc_udev) == 2997 USB_SPEED_HIGH) { 2998 cpi->base_transfer_speed = 2999 UMASS_HIGH_TRANSFER_SPEED; 3000 } else { 3001 cpi->base_transfer_speed = 3002 UMASS_FULL_TRANSFER_SPEED; 3003 } 3004 cpi->max_lun = sc->maxlun; 3005 } 3006 3007 cpi->ccb_h.status = CAM_REQ_CMP; 3008 xpt_done(ccb); 3009 break; 3010 } 3011 case XPT_RESET_DEV: 3012 { 3013 DPRINTF(UDMASS_SCSI, ("%s:%d:%d:%d:XPT_RESET_DEV:.\n", 3014 device_get_nameunit(sc->sc_dev), cam_sim_path(sc->umass_sim), 3015 ccb->ccb_h.target_id, ccb->ccb_h.target_lun)); 3016 3017 ccb->ccb_h.status = CAM_REQ_INPROG; 3018 umass_reset(sc, umass_cam_cb, (void *) ccb); 3019 break; 3020 } 3021 case XPT_GET_TRAN_SETTINGS: 3022 { 3023 struct ccb_trans_settings *cts = &ccb->cts; 3024 cts->protocol = PROTO_SCSI; 3025 cts->protocol_version = SCSI_REV_2; 3026 cts->transport = XPORT_USB; 3027 cts->transport_version = 0; 3028 cts->xport_specific.valid = 0; 3029 3030 3031 ccb->ccb_h.status = CAM_REQ_CMP; 3032 xpt_done(ccb); 3033 break; 3034 } 3035 case XPT_SET_TRAN_SETTINGS: 3036 { 3037 DPRINTF(UDMASS_SCSI, ("%s:%d:%d:%d:XPT_SET_TRAN_SETTINGS:.\n", 3038 device_get_nameunit(sc->sc_dev), cam_sim_path(sc->umass_sim), 3039 ccb->ccb_h.target_id, ccb->ccb_h.target_lun)); 3040 3041 ccb->ccb_h.status = CAM_FUNC_NOTAVAIL; 3042 xpt_done(ccb); 3043 break; 3044 } 3045 case XPT_CALC_GEOMETRY: 3046 { 3047 cam_calc_geometry(&ccb->ccg, /*extended*/1); 3048 xpt_done(ccb); 3049 break; 3050 } 3051 case XPT_NOOP: 3052 { 3053 DPRINTF(UDMASS_SCSI, ("%s:%d:%d:%d:XPT_NOOP:.\n", 3054 (sc == NULL? DEVNAME_SIM:device_get_nameunit(sc->sc_dev)), 3055 cam_sim_path(sc->umass_sim), 3056 ccb->ccb_h.target_id, ccb->ccb_h.target_lun)); 3057 3058 ccb->ccb_h.status = CAM_REQ_CMP; 3059 xpt_done(ccb); 3060 break; 3061 } 3062 default: 3063 DPRINTF(UDMASS_SCSI, ("%s:%d:%d:%d:func_code 0x%04x: " 3064 "Not implemented\n", 3065 (sc == NULL? DEVNAME_SIM:device_get_nameunit(sc->sc_dev)), 3066 cam_sim_path(sc->umass_sim), 3067 ccb->ccb_h.target_id, ccb->ccb_h.target_lun, 3068 ccb->ccb_h.func_code)); 3069 3070 ccb->ccb_h.status = CAM_FUNC_NOTAVAIL; 3071 xpt_done(ccb); 3072 break; 3073 } 3074 } 3075 3076 static void 3077 umass_cam_poll(struct cam_sim *sim) 3078 { 3079 struct umass_softc *sc = (struct umass_softc *) sim->softc; 3080 3081 DPRINTF(UDMASS_SCSI, ("%s: CAM poll\n", 3082 device_get_nameunit(sc->sc_dev))); 3083 3084 usbd_set_polling(sc->sc_udev, 1); 3085 usbd_dopoll(sc->iface); 3086 usbd_set_polling(sc->sc_udev, 0); 3087 } 3088 3089 3090 /* umass_cam_cb 3091 * finalise a completed CAM command 3092 */ 3093 3094 static void 3095 umass_cam_cb(struct umass_softc *sc, void *priv, int residue, int status) 3096 { 3097 union ccb *ccb = (union ccb *) priv; 3098 struct ccb_scsiio *csio = &ccb->csio; /* deref union */ 3099 3100 /* If the device is gone, just fail the request. */ 3101 if (sc->flags & UMASS_FLAGS_GONE) { 3102 ccb->ccb_h.status = CAM_TID_INVALID; 3103 xpt_done(ccb); 3104 return; 3105 } 3106 3107 csio->resid = residue; 3108 3109 switch (status) { 3110 case STATUS_CMD_OK: 3111 ccb->ccb_h.status = CAM_REQ_CMP; 3112 if ((sc->quirks & READ_CAPACITY_OFFBY1) && 3113 (ccb->ccb_h.func_code == XPT_SCSI_IO) && 3114 (csio->cdb_io.cdb_bytes[0] == READ_CAPACITY)) { 3115 struct scsi_read_capacity_data *rcap; 3116 uint32_t maxsector; 3117 3118 rcap = (struct scsi_read_capacity_data *)csio->data_ptr; 3119 maxsector = scsi_4btoul(rcap->addr) - 1; 3120 scsi_ulto4b(maxsector, rcap->addr); 3121 } 3122 xpt_done(ccb); 3123 break; 3124 3125 case STATUS_CMD_UNKNOWN: 3126 case STATUS_CMD_FAILED: 3127 switch (ccb->ccb_h.func_code) { 3128 case XPT_SCSI_IO: 3129 { 3130 unsigned char *rcmd; 3131 int rcmdlen; 3132 3133 /* fetch sense data */ 3134 /* the rest of the command was filled in at attach */ 3135 sc->cam_scsi_sense.length = csio->sense_len; 3136 3137 DPRINTF(UDMASS_SCSI,("%s: Fetching %db sense data\n", 3138 device_get_nameunit(sc->sc_dev), csio->sense_len)); 3139 3140 rcmd = (unsigned char *) &sc->cam_scsi_command; 3141 rcmdlen = sizeof(sc->cam_scsi_command); 3142 3143 if (sc->transform(sc, 3144 (unsigned char *) &sc->cam_scsi_sense, 3145 sizeof(sc->cam_scsi_sense), 3146 &rcmd, &rcmdlen) == 1) { 3147 if ((sc->quirks & FORCE_SHORT_INQUIRY) && (rcmd[0] == INQUIRY)) { 3148 csio->sense_len = SHORT_INQUIRY_LENGTH; 3149 } 3150 sc->transfer(sc, ccb->ccb_h.target_lun, 3151 rcmd, rcmdlen, 3152 &csio->sense_data, 3153 csio->sense_len, DIR_IN, ccb->ccb_h.timeout, 3154 umass_cam_sense_cb, (void *) ccb); 3155 } else { 3156 panic("transform(REQUEST_SENSE) failed"); 3157 } 3158 break; 3159 } 3160 case XPT_RESET_DEV: /* Reset failed */ 3161 ccb->ccb_h.status = CAM_REQ_CMP_ERR; 3162 xpt_done(ccb); 3163 break; 3164 default: 3165 panic("umass_cam_cb called for func_code %d", 3166 ccb->ccb_h.func_code); 3167 } 3168 break; 3169 3170 case STATUS_WIRE_FAILED: 3171 /* the wire protocol failed and will have recovered 3172 * (hopefully). We return an error to CAM and let CAM retry 3173 * the command if necessary. 3174 */ 3175 ccb->ccb_h.status = CAM_REQ_CMP_ERR; 3176 xpt_done(ccb); 3177 break; 3178 default: 3179 panic("%s: Unknown status %d in umass_cam_cb", 3180 device_get_nameunit(sc->sc_dev), status); 3181 } 3182 } 3183 3184 /* Finalise a completed autosense operation 3185 */ 3186 static void 3187 umass_cam_sense_cb(struct umass_softc *sc, void *priv, int residue, int status) 3188 { 3189 union ccb *ccb = (union ccb *) priv; 3190 struct ccb_scsiio *csio = &ccb->csio; /* deref union */ 3191 unsigned char *rcmd; 3192 int rcmdlen; 3193 3194 if (sc->flags & UMASS_FLAGS_GONE) { 3195 ccb->ccb_h.status = CAM_AUTOSENSE_FAIL; 3196 xpt_done(ccb); 3197 return; 3198 } 3199 3200 switch (status) { 3201 case STATUS_CMD_OK: 3202 case STATUS_CMD_UNKNOWN: 3203 case STATUS_CMD_FAILED: 3204 /* Getting sense data always succeeds (apart from wire 3205 * failures). 3206 */ 3207 if ((sc->quirks & RS_NO_CLEAR_UA) 3208 && csio->cdb_io.cdb_bytes[0] == INQUIRY 3209 && (csio->sense_data.flags & SSD_KEY) 3210 == SSD_KEY_UNIT_ATTENTION) { 3211 /* Ignore unit attention errors in the case where 3212 * the Unit Attention state is not cleared on 3213 * REQUEST SENSE. They will appear again at the next 3214 * command. 3215 */ 3216 ccb->ccb_h.status = CAM_REQ_CMP; 3217 } else if ((csio->sense_data.flags & SSD_KEY) 3218 == SSD_KEY_NO_SENSE) { 3219 /* No problem after all (in the case of CBI without 3220 * CCI) 3221 */ 3222 ccb->ccb_h.status = CAM_REQ_CMP; 3223 } else if ((sc->quirks & RS_NO_CLEAR_UA) && 3224 (csio->cdb_io.cdb_bytes[0] == READ_CAPACITY) && 3225 ((csio->sense_data.flags & SSD_KEY) 3226 == SSD_KEY_UNIT_ATTENTION)) { 3227 /* 3228 * Some devices do not clear the unit attention error 3229 * on request sense. We insert a test unit ready 3230 * command to make sure we clear the unit attention 3231 * condition, then allow the retry to proceed as 3232 * usual. 3233 */ 3234 3235 ccb->ccb_h.status = CAM_SCSI_STATUS_ERROR 3236 | CAM_AUTOSNS_VALID; 3237 csio->scsi_status = SCSI_STATUS_CHECK_COND; 3238 3239 #if 0 3240 DELAY(300000); 3241 #endif 3242 3243 DPRINTF(UDMASS_SCSI,("%s: Doing a sneaky" 3244 "TEST_UNIT_READY\n", 3245 device_get_nameunit(sc->sc_dev))); 3246 3247 /* the rest of the command was filled in at attach */ 3248 3249 rcmd = (unsigned char *) &sc->cam_scsi_command2; 3250 rcmdlen = sizeof(sc->cam_scsi_command2); 3251 3252 if (sc->transform(sc, 3253 (unsigned char *) 3254 &sc->cam_scsi_test_unit_ready, 3255 sizeof(sc->cam_scsi_test_unit_ready), 3256 &rcmd, &rcmdlen) == 1) { 3257 sc->transfer(sc, ccb->ccb_h.target_lun, 3258 rcmd, rcmdlen, 3259 NULL, 0, DIR_NONE, ccb->ccb_h.timeout, 3260 umass_cam_quirk_cb, (void *) ccb); 3261 } else { 3262 panic("transform(TEST_UNIT_READY) failed"); 3263 } 3264 break; 3265 } else { 3266 ccb->ccb_h.status = CAM_SCSI_STATUS_ERROR 3267 | CAM_AUTOSNS_VALID; 3268 csio->scsi_status = SCSI_STATUS_CHECK_COND; 3269 } 3270 xpt_done(ccb); 3271 break; 3272 3273 default: 3274 DPRINTF(UDMASS_SCSI, ("%s: Autosense failed, status %d\n", 3275 device_get_nameunit(sc->sc_dev), status)); 3276 ccb->ccb_h.status = CAM_AUTOSENSE_FAIL; 3277 xpt_done(ccb); 3278 } 3279 } 3280 3281 /* 3282 * This completion code just handles the fact that we sent a test-unit-ready 3283 * after having previously failed a READ CAPACITY with CHECK_COND. Even 3284 * though this command succeeded, we have to tell CAM to retry. 3285 */ 3286 static void 3287 umass_cam_quirk_cb(struct umass_softc *sc, void *priv, int residue, int status) 3288 { 3289 union ccb *ccb = (union ccb *) priv; 3290 3291 DPRINTF(UDMASS_SCSI, ("%s: Test unit ready returned status %d\n", 3292 device_get_nameunit(sc->sc_dev), status)); 3293 3294 if (sc->flags & UMASS_FLAGS_GONE) { 3295 ccb->ccb_h.status = CAM_TID_INVALID; 3296 xpt_done(ccb); 3297 return; 3298 } 3299 #if 0 3300 ccb->ccb_h.status = CAM_REQ_CMP; 3301 #endif 3302 ccb->ccb_h.status = CAM_SCSI_STATUS_ERROR 3303 | CAM_AUTOSNS_VALID; 3304 ccb->csio.scsi_status = SCSI_STATUS_CHECK_COND; 3305 xpt_done(ccb); 3306 } 3307 3308 /* 3309 * SCSI specific functions 3310 */ 3311 3312 static int 3313 umass_scsi_transform(struct umass_softc *sc, unsigned char *cmd, int cmdlen, 3314 unsigned char **rcmd, int *rcmdlen) 3315 { 3316 switch (cmd[0]) { 3317 case TEST_UNIT_READY: 3318 if (sc->quirks & NO_TEST_UNIT_READY) { 3319 KASSERT(*rcmdlen >= sizeof(struct scsi_start_stop_unit), 3320 ("rcmdlen = %d < %ld, buffer too small", 3321 *rcmdlen, 3322 (long)sizeof(struct scsi_start_stop_unit))); 3323 DPRINTF(UDMASS_SCSI, ("%s: Converted TEST_UNIT_READY " 3324 "to START_UNIT\n", device_get_nameunit(sc->sc_dev))); 3325 memset(*rcmd, 0, *rcmdlen); 3326 (*rcmd)[0] = START_STOP_UNIT; 3327 (*rcmd)[4] = SSS_START; 3328 return 1; 3329 } 3330 /* fallthrough */ 3331 case INQUIRY: 3332 /* some drives wedge when asked for full inquiry information. */ 3333 if (sc->quirks & FORCE_SHORT_INQUIRY) { 3334 memcpy(*rcmd, cmd, cmdlen); 3335 *rcmdlen = cmdlen; 3336 (*rcmd)[4] = SHORT_INQUIRY_LENGTH; 3337 return 1; 3338 } 3339 /* fallthrough */ 3340 default: 3341 *rcmd = cmd; /* We don't need to copy it */ 3342 *rcmdlen = cmdlen; 3343 } 3344 3345 return 1; 3346 } 3347 /* RBC specific functions */ 3348 static int 3349 umass_rbc_transform(struct umass_softc *sc, unsigned char *cmd, int cmdlen, 3350 unsigned char **rcmd, int *rcmdlen) 3351 { 3352 switch (cmd[0]) { 3353 /* these commands are defined in RBC: */ 3354 case READ_10: 3355 case READ_CAPACITY: 3356 case START_STOP_UNIT: 3357 case SYNCHRONIZE_CACHE: 3358 case WRITE_10: 3359 case 0x2f: /* VERIFY_10 is absent from scsi_all.h??? */ 3360 case INQUIRY: 3361 case MODE_SELECT_10: 3362 case MODE_SENSE_10: 3363 case TEST_UNIT_READY: 3364 case WRITE_BUFFER: 3365 /* The following commands are not listed in my copy of the RBC specs. 3366 * CAM however seems to want those, and at least the Sony DSC device 3367 * appears to support those as well */ 3368 case REQUEST_SENSE: 3369 case PREVENT_ALLOW: 3370 if ((sc->quirks & RBC_PAD_TO_12) && cmdlen < 12) { 3371 *rcmdlen = 12; 3372 bcopy(cmd, *rcmd, cmdlen); 3373 bzero(*rcmd + cmdlen, 12 - cmdlen); 3374 } else { 3375 *rcmd = cmd; /* We don't need to copy it */ 3376 *rcmdlen = cmdlen; 3377 } 3378 return 1; 3379 /* All other commands are not legal in RBC */ 3380 default: 3381 printf("%s: Unsupported RBC command 0x%02x", 3382 device_get_nameunit(sc->sc_dev), cmd[0]); 3383 printf("\n"); 3384 return 0; /* failure */ 3385 } 3386 } 3387 3388 /* 3389 * UFI specific functions 3390 */ 3391 static int 3392 umass_ufi_transform(struct umass_softc *sc, unsigned char *cmd, int cmdlen, 3393 unsigned char **rcmd, int *rcmdlen) 3394 { 3395 /* A UFI command is always 12 bytes in length */ 3396 KASSERT(*rcmdlen >= UFI_COMMAND_LENGTH, 3397 ("rcmdlen = %d < %d, buffer too small", 3398 *rcmdlen, UFI_COMMAND_LENGTH)); 3399 3400 *rcmdlen = UFI_COMMAND_LENGTH; 3401 memset(*rcmd, 0, UFI_COMMAND_LENGTH); 3402 3403 switch (cmd[0]) { 3404 /* Commands of which the format has been verified. They should work. 3405 * Copy the command into the (zeroed out) destination buffer. 3406 */ 3407 case TEST_UNIT_READY: 3408 if (sc->quirks & NO_TEST_UNIT_READY) { 3409 /* Some devices do not support this command. 3410 * Start Stop Unit should give the same results 3411 */ 3412 DPRINTF(UDMASS_UFI, ("%s: Converted TEST_UNIT_READY " 3413 "to START_UNIT\n", device_get_nameunit(sc->sc_dev))); 3414 (*rcmd)[0] = START_STOP_UNIT; 3415 (*rcmd)[4] = SSS_START; 3416 } else { 3417 memcpy(*rcmd, cmd, cmdlen); 3418 } 3419 return 1; 3420 3421 case REZERO_UNIT: 3422 case REQUEST_SENSE: 3423 case FORMAT_UNIT: 3424 case INQUIRY: 3425 case START_STOP_UNIT: 3426 case SEND_DIAGNOSTIC: 3427 case PREVENT_ALLOW: 3428 case READ_CAPACITY: 3429 case READ_10: 3430 case WRITE_10: 3431 case POSITION_TO_ELEMENT: /* SEEK_10 */ 3432 case WRITE_AND_VERIFY: 3433 case VERIFY: 3434 case MODE_SELECT_10: 3435 case MODE_SENSE_10: 3436 case READ_12: 3437 case WRITE_12: 3438 case READ_FORMAT_CAPACITIES: 3439 memcpy(*rcmd, cmd, cmdlen); 3440 return 1; 3441 3442 /* 3443 * SYNCHRONIZE_CACHE isn't supported by UFI, nor should it be 3444 * required for UFI devices, so it is appropriate to fake 3445 * success. 3446 */ 3447 case SYNCHRONIZE_CACHE: 3448 return 2; 3449 3450 default: 3451 printf("%s: Unsupported UFI command 0x%02x\n", 3452 device_get_nameunit(sc->sc_dev), cmd[0]); 3453 return 0; /* failure */ 3454 } 3455 } 3456 3457 /* 3458 * 8070i (ATAPI) specific functions 3459 */ 3460 static int 3461 umass_atapi_transform(struct umass_softc *sc, unsigned char *cmd, int cmdlen, 3462 unsigned char **rcmd, int *rcmdlen) 3463 { 3464 /* An ATAPI command is always 12 bytes in length. */ 3465 KASSERT(*rcmdlen >= ATAPI_COMMAND_LENGTH, 3466 ("rcmdlen = %d < %d, buffer too small", 3467 *rcmdlen, ATAPI_COMMAND_LENGTH)); 3468 3469 *rcmdlen = ATAPI_COMMAND_LENGTH; 3470 memset(*rcmd, 0, ATAPI_COMMAND_LENGTH); 3471 3472 switch (cmd[0]) { 3473 /* Commands of which the format has been verified. They should work. 3474 * Copy the command into the (zeroed out) destination buffer. 3475 */ 3476 case INQUIRY: 3477 memcpy(*rcmd, cmd, cmdlen); 3478 /* some drives wedge when asked for full inquiry information. */ 3479 if (sc->quirks & FORCE_SHORT_INQUIRY) 3480 (*rcmd)[4] = SHORT_INQUIRY_LENGTH; 3481 return 1; 3482 3483 case TEST_UNIT_READY: 3484 if (sc->quirks & NO_TEST_UNIT_READY) { 3485 KASSERT(*rcmdlen >= sizeof(struct scsi_start_stop_unit), 3486 ("rcmdlen = %d < %ld, buffer too small", 3487 *rcmdlen, 3488 (long)sizeof(struct scsi_start_stop_unit))); 3489 DPRINTF(UDMASS_SCSI, ("%s: Converted TEST_UNIT_READY " 3490 "to START_UNIT\n", device_get_nameunit(sc->sc_dev))); 3491 memset(*rcmd, 0, *rcmdlen); 3492 (*rcmd)[0] = START_STOP_UNIT; 3493 (*rcmd)[4] = SSS_START; 3494 return 1; 3495 } 3496 /* fallthrough */ 3497 case REZERO_UNIT: 3498 case REQUEST_SENSE: 3499 case START_STOP_UNIT: 3500 case SEND_DIAGNOSTIC: 3501 case PREVENT_ALLOW: 3502 case READ_CAPACITY: 3503 case READ_10: 3504 case WRITE_10: 3505 case POSITION_TO_ELEMENT: /* SEEK_10 */ 3506 case SYNCHRONIZE_CACHE: 3507 case MODE_SELECT_10: 3508 case MODE_SENSE_10: 3509 case READ_BUFFER: 3510 case 0x42: /* READ_SUBCHANNEL */ 3511 case 0x43: /* READ_TOC */ 3512 case 0x44: /* READ_HEADER */ 3513 case 0x47: /* PLAY_MSF (Play Minute/Second/Frame) */ 3514 case 0x48: /* PLAY_TRACK */ 3515 case 0x49: /* PLAY_TRACK_REL */ 3516 case 0x4b: /* PAUSE */ 3517 case 0x51: /* READ_DISK_INFO */ 3518 case 0x52: /* READ_TRACK_INFO */ 3519 case 0x54: /* SEND_OPC */ 3520 case 0x59: /* READ_MASTER_CUE */ 3521 case 0x5b: /* CLOSE_TR_SESSION */ 3522 case 0x5c: /* READ_BUFFER_CAP */ 3523 case 0x5d: /* SEND_CUE_SHEET */ 3524 case 0xa1: /* BLANK */ 3525 case 0xa5: /* PLAY_12 */ 3526 case 0xa6: /* EXCHANGE_MEDIUM */ 3527 case 0xad: /* READ_DVD_STRUCTURE */ 3528 case 0xbb: /* SET_CD_SPEED */ 3529 case 0xe5: /* READ_TRACK_INFO_PHILIPS */ 3530 memcpy(*rcmd, cmd, cmdlen); 3531 return 1; 3532 3533 case READ_12: 3534 case WRITE_12: 3535 default: 3536 if (bootverbose) 3537 printf("%s: Unsupported ATAPI command 0x%02x" 3538 " - trying anyway\n", 3539 device_get_nameunit(sc->sc_dev), cmd[0]); 3540 memcpy(*rcmd, cmd, cmdlen); 3541 return 1; 3542 } 3543 } 3544 3545 3546 /* (even the comment is missing) */ 3547 3548 DRIVER_MODULE(umass, uhub, umass_driver, umass_devclass, usbd_driver_load, 0); 3549 3550 3551 3552 #ifdef USB_DEBUG 3553 static void 3554 umass_bbb_dump_cbw(struct umass_softc *sc, umass_bbb_cbw_t *cbw) 3555 { 3556 int clen = cbw->bCDBLength; 3557 int dlen = UGETDW(cbw->dCBWDataTransferLength); 3558 u_int8_t *c = cbw->CBWCDB; 3559 int tag = UGETDW(cbw->dCBWTag); 3560 int flags = cbw->bCBWFlags; 3561 3562 DPRINTF(UDMASS_BBB, ("%s: CBW %d: cmd = %db " 3563 "(0x%02x%02x%02x%02x%02x%02x%s), " 3564 "data = %db, dir = %s\n", 3565 device_get_nameunit(sc->sc_dev), tag, clen, 3566 c[0], c[1], c[2], c[3], c[4], c[5], (clen > 6? "...":""), 3567 dlen, (flags == CBWFLAGS_IN? "in": 3568 (flags == CBWFLAGS_OUT? "out":"<invalid>")))); 3569 } 3570 3571 static void 3572 umass_bbb_dump_csw(struct umass_softc *sc, umass_bbb_csw_t *csw) 3573 { 3574 int sig = UGETDW(csw->dCSWSignature); 3575 int tag = UGETW(csw->dCSWTag); 3576 int res = UGETDW(csw->dCSWDataResidue); 3577 int status = csw->bCSWStatus; 3578 3579 DPRINTF(UDMASS_BBB, ("%s: CSW %d: sig = 0x%08x (%s), tag = %d, " 3580 "res = %d, status = 0x%02x (%s)\n", device_get_nameunit(sc->sc_dev), 3581 tag, sig, (sig == CSWSIGNATURE? "valid":"invalid"), 3582 tag, res, 3583 status, (status == CSWSTATUS_GOOD? "good": 3584 (status == CSWSTATUS_FAILED? "failed": 3585 (status == CSWSTATUS_PHASE? "phase":"<invalid>"))))); 3586 } 3587 3588 static void 3589 umass_cbi_dump_cmd(struct umass_softc *sc, void *cmd, int cmdlen) 3590 { 3591 u_int8_t *c = cmd; 3592 int dir = sc->transfer_dir; 3593 3594 DPRINTF(UDMASS_BBB, ("%s: cmd = %db " 3595 "(0x%02x%02x%02x%02x%02x%02x%s), " 3596 "data = %db, dir = %s\n", 3597 device_get_nameunit(sc->sc_dev), cmdlen, 3598 c[0], c[1], c[2], c[3], c[4], c[5], (cmdlen > 6? "...":""), 3599 sc->transfer_datalen, 3600 (dir == DIR_IN? "in": 3601 (dir == DIR_OUT? "out": 3602 (dir == DIR_NONE? "no data phase": "<invalid>"))))); 3603 } 3604 3605 static void 3606 umass_dump_buffer(struct umass_softc *sc, u_int8_t *buffer, int buflen, 3607 int printlen) 3608 { 3609 int i, j; 3610 char s1[40]; 3611 char s2[40]; 3612 char s3[5]; 3613 3614 s1[0] = '\0'; 3615 s3[0] = '\0'; 3616 3617 sprintf(s2, " buffer=%p, buflen=%d", buffer, buflen); 3618 for (i = 0; i < buflen && i < printlen; i++) { 3619 j = i % 16; 3620 if (j == 0 && i != 0) { 3621 DPRINTF(UDMASS_GEN, ("%s: 0x %s%s\n", 3622 device_get_nameunit(sc->sc_dev), s1, s2)); 3623 s2[0] = '\0'; 3624 } 3625 sprintf(&s1[j*2], "%02x", buffer[i] & 0xff); 3626 } 3627 if (buflen > printlen) 3628 sprintf(s3, " ..."); 3629 DPRINTF(UDMASS_GEN, ("%s: 0x %s%s%s\n", 3630 device_get_nameunit(sc->sc_dev), s1, s2, s3)); 3631 } 3632 #endif
Cache object: 722b1d001def26ea4d27c42ed8a6368d
[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]