1 /* 2 * CDDL HEADER START 3 * 4 * The contents of this file are subject to the terms of the 5 * Common Development and Distribution License (the "License"). 6 * You may not use this file except in compliance with the License. 7 * 8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE 9 * or http://www.opensolaris.org/os/licensing. 10 * See the License for the specific language governing permissions 11 * and limitations under the License. 12 * 13 * When distributing Covered Code, include this CDDL HEADER in each 14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE. 15 * If applicable, add the following below this CDDL HEADER, with the 16 * fields enclosed by brackets "[]" replaced with your own identifying 17 * information: Portions Copyright [yyyy] [name of copyright owner] 18 * 19 * CDDL HEADER END 20 * 21 * Copyright 2010 Sun Microsystems, Inc. All rights reserved. 22 * Use is subject to license terms. 23 * 24 * Copyright 2019, Joyent, Inc. 25 * Copyright 2019 Joshua M. Clulow <josh@sysmgr.org> 26 */ 27 28 #ifndef _SYS_USB_SCSA2USB_H 29 #define _SYS_USB_SCSA2USB_H 30 31 32 #ifdef __cplusplus 33 extern "C" { 34 #endif 35 36 #include <sys/usb/usba/usbai_private.h> 37 38 /* 39 * SCSA2USB: This header file contains the internal structures 40 * and variable definitions used in USB mass storage disk driver. 41 */ 42 43 44 #define SCSA2USB_MAX_CLONE 256 45 #define SCSA2USB_INITIAL_ALLOC 4 /* initial soft space alloc */ 46 47 #define MAX_COMPAT_NAMES 1 /* max compatible names for children */ 48 #define SERIAL_NUM_LEN 64 /* for reading string descriptor */ 49 #define SCSA2USB_SERIAL_LEN 12 /* len of serial no in scsi_inquiry */ 50 51 #define SCSA2USB_MAX_LUNS 0x10 /* maximum luns supported. */ 52 53 /* 54 * limit the max transfer size to under <= 64K. Some devices 55 * have problems with large transfers 56 */ 57 #define SCSA2USB_MAX_BULK_XFER_SIZE (64 * 1024) 58 59 /* 60 * Identify devices with quirks of implementation that we need to work around: 61 */ 62 #define MS_HAGIWARA_SYS_COM_VID 0x693 /* VendorId of Hagiwara Sys-Com */ 63 #define MS_HAGIWARA_SYSCOM_PID1 0x1 /* PID for SmartMedia(SM) device */ 64 #define MS_HAGIWARA_SYSCOM_PID2 0x3 /* PID for CompactFlash(CF) device */ 65 #define MS_HAGIWARA_SYSCOM_PID3 0x5 /* PID for SM/CF Combo device */ 66 #define MS_HAGIWARA_SYSCOM_PID4 0x2 /* PID for new SM device */ 67 #define MS_HAGIWARA_SYSCOM_PID5 0x4 /* PID for new CF device */ 68 69 #define MS_IOMEGA_VID 0x59b /* VendorId of Iomega */ 70 #define MS_IOMEGA_PID1_ZIP100 0x1 /* PID of an Older Iomega Zip100 */ 71 #define MS_IOMEGA_PID2_ZIP100 0x2 /* PID of Newer Iomega Zip100 */ 72 #define MS_IOMEGA_PID3_ZIP100 0x31 /* PID of Newer Iomega Zip100 */ 73 #define MS_IOMEGA_PID_ZIP250 0x30 /* PID of Newer Iomega Zip250 */ 74 #define MS_IOMEGA_PID_CLIK 0x60 /* PID of Iomega Clik! drive */ 75 76 #define MS_MITSUMI_VID 0x3ee /* VendorId of Mitsumi Inc */ 77 #define MS_MITSUMI_DEVICE_242 0x242 /* bcdDevice of Mitsumi CR-4804TU */ 78 #define MS_MITSUMI_DEVICE_24 0x24 /* bcdDevice of Mitsumi CR-4802TU */ 79 80 #define MS_YEDATA_VID 0x57b /* VendorId of Y-E Data Corp */ 81 #define MS_SMSC_VID 0x424 /* Vendor Id of SMSC */ 82 #define MS_SMSC_PID0 0xfdc /* floppy from SMSC */ 83 84 #define MS_NEODIO_VID 0xaec /* Neodio Technologies Corporation */ 85 #define MS_NEODIO_DEVICE_3050 0x3050 /* PID of ND3050/Soyo BayOne */ 86 /* SM/CF/MS/SD */ 87 #define MS_SONY_FLASH_VID 0x54c /* sony flash device */ 88 #define MS_SONY_FLASH_PID 0x8b 89 90 #define MS_TREK_FLASH_VID 0xa16 /* Trek flash device */ 91 #define MS_TREK_FLASH_PID 0x9988 92 93 #define MS_PENN_FLASH_VID 0xd7d /* Penn flash device */ 94 #define MS_PENN_FLASH_PID 0x1320 95 96 #define MS_SIMPLETECH_VID 0x7c4 /* VendorId of Simpltech */ 97 #define MS_SIMPLETECH_PID1 0xa400 /* PID for UCF-100 device */ 98 99 #define MS_ADDONICS_CARD_READER_VID 0x7cc /* addonics */ 100 #define MS_ADDONICS_CARD_READER_PID 0x320 101 102 #define MS_ACOMDATA_VID 0xc0b /* VendorId of DMI (Acomdata) */ 103 #define MS_ACOMDATA_PID1 0x5fab /* PID for 80GB USB/1394 disk */ 104 105 #define MS_OTI_VID 0xea0 /* VendorID of OTI */ 106 #define MS_OTI_DEVICE_6828 0x6828 /* PID for 6828 flash disk */ 107 108 #define MS_SCANLOGIC_VID 0x04ce /* VendorID of ScanLogic */ 109 #define MS_SCANLOGIC_PID1 0x0002 /* SL USB Storage Device */ 110 111 #define MS_SUPERTOP_VID 0x14cd /* Super Top USB 2.0 IDE enclosure */ 112 #define MS_SUPERTOP_DEVICE_6600 0x6600 113 114 #define MS_AIGO_VID 0xed1 /* VendorID of Aigo */ 115 #define MS_AIGO_DEVICE_6981 0x6981 /* Aigo Miniking Device NEHFSP14 */ 116 117 #define MS_ALCOR_VID 0x58f /* Vendor ID of Alcor Micro Corp */ 118 #define MS_ALCOR_PID0 0x6387 /* PID for 6387 flash disk */ 119 120 #define MS_TOSHIBA_VID 0x930 /* Vendor ID of Toshiba Corp */ 121 #define MS_TOSHIBA_PID0 0x6545 /* Kingston DataTraveler / PNY Attache Stick */ 122 123 #define MS_PNY_VID 0x154b /* Vendor ID of PNY Corp */ 124 #define MS_PNY_PID0 0x16 /* PNY floppy drive */ 125 126 #define MS_WD_VID 0x1058 /* Vendor ID of Western Digital */ 127 #define MS_WD_PID 0x1001 /* PID for Western Digital USB External HDD */ 128 129 /* 130 * The virtual CD-ROM device emulated by at least some Insyde BMCs is not 131 * completely implemented. It hangs when a MODE SENSE command is sent. 132 */ 133 #define MS_INSYDE_VID 0xb1f /* Vendor: Insyde Software Corp */ 134 #define MS_INSYDE_PID_CDROM 0x03ea /* Product: BMC Virtual CD-ROM */ 135 136 /* 137 * The AMI virtual floppy device is not a real USB storage device, but 138 * emulated by the SP firmware shipped together with important Sun x86 139 * products such as Galaxy and Thumper platforms. The device causes 140 * very long delay in boot process of these platforms which is a big 141 * performance issue. Improvement in firmware may solve the issue, but 142 * before the firmware is fixed, it needs to be taken care of by software 143 * to avoid the huge impact on user experience. 144 * 145 * The long boot delay is caused by timeouts and retries of READ CAPACITY 146 * command issued to the device. The device is a USB ufi subclass device 147 * using CBI protocol. When READ CAPACITY command is issued, the device 148 * returns STALL on the bulk endpoint during the data stage, however, it 149 * doesn't return status on the intr pipe during status stage, so the intr 150 * pipe can only fail with timeout. 151 * 152 * Reducing timeout value to 1 second can help a little bit, but the delay 153 * is still noticeable, because the target driver would make many retries 154 * for this command. It is not desirable to mess with the target driver 155 * for a broken USB device. So adding the device to the scsa2usb quirks list 156 * is the best choice we have. 157 * 158 * It is found that the READ CAPACITY failure only happens when there is 159 * no media in the floppy drive. When there is a media, the device works 160 * just fine. So READ CAPACITY command cannot be arbitrarily disabled. 161 * Media status needs to be checked before issuing the command by sending 162 * an additional TEST UNIT READY command. If TEST UNIT READY command 163 * return STATUS_GOOD, it means the media is ready and then READ CAPACITY 164 * can be issued. 165 * 166 * SCSA2USB_ATTRS_NO_MEDIA_CHECK is added below for this purpose. It is 167 * overrided in scsa2usb.c for the AMI virtual floppy device to take care 168 * of the special need. 169 */ 170 #define MS_AMI_VID 0x46b /* VendorId of AMI */ 171 #define MS_AMI_VIRTUAL_FLOPPY 0xff40 /* PID for AMI virtual floppy */ 172 173 /* 174 * List the attributes that need special case in the driver 175 * SCSA2USB_ATTRS_GET_LUN: Bulk Only Transport Get_Max_Lun class specific 176 * command is not implemented by these devices 177 * SCSA2USB_ATTRS_PM: Some devices don't like being power managed. 178 * SCSA2USB_ATTRS_START_STOP: Some devices don't do anything with 179 * SCMD_START_STOP opcode (for e.g. SmartMedia/CompactFlash/ 180 * Clik!/MemoryStick/MMC USB readers/writers. 181 * SCSA2USB_ATTRS_GET_CONF: SCMD_GET_CONFIGURATION is not supported 182 * SCMD_TEST_UNIT_READY: for floppies this needs to be converted to 183 * SCMD_START_STOP as floppies don't support this 184 * SCSA2USB_ATTRS_GET_PERF: SCMD_GET_PERFORMANCE not supported by 185 * Mitsumi's CD-RW devices. 186 * SCSA2USB_ATTRS_BIG_TIMEOUT: Mitsumi's CD-RW devices need large 187 * timeout with SCMD_START_STOP cmd 188 * SCSA2USB_ATTRS_RMB: Pay attention to the device's RMB setting, 189 * instead of automatically treating it as removable 190 * SCSA2USB_ATTRS_USE_CSW_RESIDUE: Some devices report false residue in 191 * the CSW of bulk-only transfer status stage though data 192 * was successfully transfered, so need to ignore residue. 193 * SCSA2USB_ATTRS_NO_MEDIA_CHECK: AMI Virtual Floppy devices need to 194 * check if media is ready before issuing READ CAPACITY. 195 * SCSA2USB_ATTRS_NO_CAP_ADJUST: Some devices return total logical block number 196 * instead of highest logical block address on READ_CAPACITY cmd. 197 * 198 * NOTE: If a device simply STALLs the GET_MAX_LUN BO class-specific command 199 * and recovers then it will not be added to the scsa2usb_quirks[] table 200 * in scsa2usb.c. The other attributes will not be taken of the table unless 201 * their inclusion causes a recovery and retries (thus seriously affecting 202 * the driver performance). 203 */ 204 #define SCSA2USB_ATTRS_GET_LUN 0x01 /* GET_MAX_LUN (Bulk Only) */ 205 #define SCSA2USB_ATTRS_PM 0x02 /* Some don't support PM */ 206 #define SCSA2USB_ATTRS_START_STOP 0x04 /* SCMD_START_STOP */ 207 #define SCSA2USB_ATTRS_GET_CONF 0x08 /* SCMD_GET_CONFIGURATION */ 208 #define SCSA2USB_ATTRS_GET_PERF 0x10 /* SCMD_GET_PERFORMANCE */ 209 #define SCSA2USB_ATTRS_BIG_TIMEOUT 0x40 /* for SCMD_START_STOP */ 210 #define SCSA2USB_ATTRS_DOORLOCK 0x80 /* for SCMD_DOORLOCK */ 211 #define SCSA2USB_ATTRS_RMB 0x100 /* Pay attention to RMB */ 212 #define SCSA2USB_ATTRS_MODE_SENSE 0x200 /* SCMD_MODE_SENSE */ 213 #define SCSA2USB_ATTRS_INQUIRY 0x400 /* SCMD_INQUIRY */ 214 #define SCSA2USB_ATTRS_USE_CSW_RESIDUE 0x800 /* for residue checking */ 215 #define SCSA2USB_ATTRS_NO_MEDIA_CHECK 0x1000 /* for media checking */ 216 #define SCSA2USB_ATTRS_NO_CAP_ADJUST 0x2000 /* for CAPACITY adjusting */ 217 #define SCSA2USB_ATTRS_INQUIRY_EVPD 0x4000 /* SCMD_INQUIRY with evpd */ 218 #define SCSA2USB_ATTRS_REDUCED_CMD \ 219 (SCSA2USB_ATTRS_DOORLOCK|SCSA2USB_ATTRS_MODE_SENSE| \ 220 SCSA2USB_ATTRS_START_STOP|SCSA2USB_ATTRS_INQUIRY| \ 221 SCSA2USB_ATTRS_USE_CSW_RESIDUE) 222 223 #define SCSA2USB_ALL_ATTRS 0xFFFF /* All of the above */ 224 225 /* max inquiry length */ 226 #define SCSA2USB_MAX_INQ_LEN (offsetof(struct scsi_inquiry, inq_serial)) 227 228 /* page code of scsi mode page */ 229 #ifndef SD_MODE_SENSE_PAGE3_CODE 230 #define SD_MODE_SENSE_PAGE3_CODE 0x03 231 #endif 232 233 #ifndef SD_MODE_SENSE_PAGE4_CODE 234 #define SD_MODE_SENSE_PAGE4_CODE 0x04 235 #endif 236 237 #define SD_MODE_SENSE_PAGE_MASK 0x3F 238 239 /* 240 * PM support 241 */ 242 typedef struct scsa2usb_power { 243 /* device busy accounting */ 244 int scsa2usb_pm_busy; 245 /* this is the bit mask of the power states that device has */ 246 uint8_t scsa2usb_pwr_states; 247 248 uint8_t scsa2usb_wakeup_enabled; 249 250 /* current power level the device is in */ 251 uint8_t scsa2usb_current_power; 252 } scsa2usb_power_t; 253 254 /* 255 * CPR support: 256 * keep track of the last command issued to the drive. If it 257 * was TUR or EJECT then allow issuing a CPR suspend. 258 */ 259 #define LOEJECT 2 /* eject bit in start/stop cmd */ 260 261 typedef struct scsa2usb_last_cmd { 262 /* this is the cdb of the last command issued */ 263 uchar_t cdb[SCSI_CDB_SIZE]; 264 265 /* this is the status of the last command issued */ 266 uint_t status; 267 } scsa2usb_last_cmd_t; 268 269 /* 270 * override values 271 * These values may be set in scsa2usb.conf for particular devices 272 */ 273 typedef struct scsa2usb_ov { 274 int vid; /* vendor id */ 275 int pid; /* product id */ 276 int rev; /* revision */ 277 int subclass; /* subclass override */ 278 int protocol; /* protocol override */ 279 int pmoff; /* power management override */ 280 int fake_removable; /* removable device override */ 281 int no_modesense; /* no mode sense */ 282 /* no modesense, doorlock, PM, start/stop */ 283 int reduced_cmd_support; 284 } scsa2usb_ov_t; 285 286 287 /* 288 * Per bulk device "state" data structure. 289 */ 290 typedef struct scsa2usb_state { 291 int scsa2usb_instance; /* Instance number */ 292 int scsa2usb_dev_state; /* USB device state */ 293 int scsa2usb_flags; /* Per instance flags */ 294 int scsa2usb_intfc_num; /* Interface number */ 295 dev_info_t *scsa2usb_dip; /* Per device. info */ 296 scsa2usb_power_t *scsa2usb_pm; /* PM state info */ 297 298 int scsa2usb_transport_busy; /* ugen/sd traffic */ 299 int scsa2usb_ugen_open_count; 300 kcondvar_t scsa2usb_transport_busy_cv; 301 struct proc *scsa2usb_busy_proc; /* owner of the hardware */ 302 303 kmutex_t scsa2usb_mutex; /* Per instance lock */ 304 305 struct scsi_hba_tran *scsa2usb_tran; /* SCSI transport ptr */ 306 struct scsi_pkt *scsa2usb_cur_pkt; /* SCSI packet ptr */ 307 308 usba_list_entry_t scsa2usb_waitQ[SCSA2USB_MAX_LUNS]; 309 /* waitQ list */ 310 struct scsa2usb_cmd *scsa2usb_arq_cmd; /* ARQ cmd */ 311 struct buf *scsa2usb_arq_bp; /* ARQ buf */ 312 313 dev_info_t *scsa2usb_lun_dip[SCSA2USB_MAX_LUNS]; 314 /* store devinfo per LUN */ 315 struct scsi_inquiry scsa2usb_lun_inquiry[SCSA2USB_MAX_LUNS]; 316 /* store inquiry per LUN */ 317 usb_if_descr_t scsa2usb_intfc_descr; /* Interface descr */ 318 usb_ep_xdescr_t scsa2usb_bulkin_xept; /* Bulk In descriptor */ 319 usb_ep_xdescr_t scsa2usb_bulkout_xept; /* Bulkout descriptor */ 320 usb_ep_xdescr_t scsa2usb_intr_xept; /* Intr ept descr */ 321 322 usb_pipe_handle_t scsa2usb_default_pipe; /* Default pipe Hndle */ 323 usb_pipe_handle_t scsa2usb_intr_pipe; /* Intr polling Hndle */ 324 usb_pipe_handle_t scsa2usb_bulkin_pipe; /* Bulk Inpipe Handle */ 325 usb_pipe_handle_t scsa2usb_bulkout_pipe; /* Bulk Outpipe Hndle */ 326 327 uint_t scsa2usb_pipe_state; /* resetting state */ 328 uint_t scsa2usb_tag; /* current tag */ 329 uint_t scsa2usb_pkt_state; /* packet state */ 330 uint_t scsa2usb_n_luns; /* number of luns */ 331 332 usb_log_handle_t scsa2usb_log_handle; /* log handle */ 333 struct scsa2usb_cpr *scsa2usb_panic_info; /* for cpr info */ 334 335 size_t scsa2usb_lbasize[SCSA2USB_MAX_LUNS]; 336 /* sector size */ 337 size_t scsa2usb_totalsec[SCSA2USB_MAX_LUNS]; 338 /* total sectors */ 339 size_t scsa2usb_secsz[SCSA2USB_MAX_LUNS]; 340 /* sector size */ 341 size_t scsa2usb_max_bulk_xfer_size; /* from HCD */ 342 343 usb_client_dev_data_t *scsa2usb_dev_data; /* USB registration */ 344 scsa2usb_last_cmd_t scsa2usb_last_cmd; /* last/prev command */ 345 346 uint_t scsa2usb_attrs; /* for bad devices */ 347 uint_t scsa2usb_cmd_protocol; /* CMD protocol used */ 348 kthread_t *scsa2usb_work_thread_id; /* handle commands */ 349 350 /* conf file override values */ 351 uint_t scsa2usb_subclass_override; 352 uint_t scsa2usb_protocol_override; 353 char *scsa2usb_override_str; 354 355 /* suppress repetitive disconnect warnings */ 356 boolean_t scsa2usb_warning_given; 357 358 boolean_t scsa2usb_rcvd_not_ready; /* received NOT */ 359 /* READY sense data */ 360 361 usb_ugen_hdl_t scsa2usb_ugen_hdl; /* ugen support */ 362 363 uint8_t scsa2usb_clones[SCSA2USB_MAX_CLONE]; 364 } scsa2usb_state_t; 365 366 /* 367 * These macros were added as part of updating scsa2usb to support USB 3.0 and 368 * newer devices to minimize driver changes. There's no reason these can't be 369 * expanded by someone who wants to. 370 */ 371 #define scsa2usb_bulkin_ept scsa2usb_bulkin_xept.uex_ep 372 #define scsa2usb_bulkout_ept scsa2usb_bulkout_xept.uex_ep 373 #define scsa2usb_intr_ept scsa2usb_intr_xept.uex_ep 374 375 376 /* for warlock */ 377 _NOTE(MUTEX_PROTECTS_DATA(scsa2usb_state::scsa2usb_mutex, scsa2usb_state)) 378 _NOTE(DATA_READABLE_WITHOUT_LOCK(scsa2usb_state::scsa2usb_instance)) 379 _NOTE(DATA_READABLE_WITHOUT_LOCK(scsa2usb_state::scsa2usb_dip)) 380 _NOTE(DATA_READABLE_WITHOUT_LOCK(scsa2usb_state::scsa2usb_arq_cmd)) 381 _NOTE(DATA_READABLE_WITHOUT_LOCK(scsa2usb_state::scsa2usb_arq_bp)) 382 _NOTE(DATA_READABLE_WITHOUT_LOCK(scsa2usb_state::scsa2usb_intr_ept)) 383 _NOTE(DATA_READABLE_WITHOUT_LOCK(scsa2usb_state::scsa2usb_default_pipe)) 384 _NOTE(DATA_READABLE_WITHOUT_LOCK(scsa2usb_state::scsa2usb_intr_pipe)) 385 _NOTE(DATA_READABLE_WITHOUT_LOCK(scsa2usb_state::scsa2usb_bulkin_pipe)) 386 _NOTE(DATA_READABLE_WITHOUT_LOCK(scsa2usb_state::scsa2usb_log_handle)) 387 _NOTE(DATA_READABLE_WITHOUT_LOCK(scsa2usb_state::scsa2usb_intfc_num)) 388 _NOTE(DATA_READABLE_WITHOUT_LOCK(scsa2usb_state::scsa2usb_dev_data)) 389 _NOTE(DATA_READABLE_WITHOUT_LOCK(scsa2usb_state::scsa2usb_ugen_hdl)) 390 _NOTE(DATA_READABLE_WITHOUT_LOCK(scsa2usb_state::scsa2usb_pm)) 391 _NOTE(SCHEME_PROTECTS_DATA("stable data", scsa2usb_power_t)) 392 _NOTE(SCHEME_PROTECTS_DATA("stable data", scsi_hba_tran_t)) 393 _NOTE(SCHEME_PROTECTS_DATA("unshared data", usb_bulk_req_t)) 394 395 /* scsa2usb_pipe_state values */ 396 #define SCSA2USB_PIPE_NORMAL 0x00 /* no reset or clearing */ 397 #define SCSA2USB_PIPE_CLOSING 0x01 /* closing all pipes */ 398 #define SCSA2USB_PIPE_DEV_RESET 0x02 /* device specific reset */ 399 400 /* pkt xfer state machine */ 401 #define SCSA2USB_PKT_NONE 0 /* device is idle */ 402 #define SCSA2USB_PKT_PROCESS_CSW 1 /* device doing status again */ 403 #define SCSA2USB_PKT_DO_COMP 2 /* device is done xfer */ 404 405 /* scsa2usb_flags values */ 406 #define SCSA2USB_FLAGS_PIPES_OPENED 0x001 /* usb pipes are open */ 407 #define SCSA2USB_FLAGS_HBA_ATTACH_SETUP 0x002 /* scsi hba setup done */ 408 #define SCSA2USB_FLAGS_LOCKS_INIT 0x004 /* basic inits done */ 409 410 /* scsa2usb_cmd_protocol values */ 411 #define SCSA2USB_UNKNOWN_PROTOCOL 0x0000 /* unknown wire protocol */ 412 #define SCSA2USB_CB_PROTOCOL 0x0001 /* CBI wire protocol */ 413 #define SCSA2USB_CBI_PROTOCOL 0x0002 /* CBI w/ intr wire protocol */ 414 #define SCSA2USB_BULK_ONLY_PROTOCOL 0x0004 /* Bulk Only wire protocol */ 415 416 #define SCSA2USB_SCSI_CMDSET 0x1000 /* SCSI command set followed */ 417 #define SCSA2USB_ATAPI_CMDSET 0x2000 /* ATAPI command set followed */ 418 #define SCSA2USB_UFI_CMDSET 0x4000 /* UFI command set followed */ 419 #define SCSA2USB_CMDSET_MASK 0x7000 /* OR al the above */ 420 421 #define SCSA2USB_IS_UFI_CMDSET(s) \ 422 (((s)->scsa2usb_cmd_protocol & SCSA2USB_UFI_CMDSET)) 423 #define SCSA2USB_IS_SCSI_CMDSET(s) \ 424 (((s)->scsa2usb_cmd_protocol & SCSA2USB_SCSI_CMDSET)) 425 #define SCSA2USB_IS_ATAPI_CMDSET(s) \ 426 (((s)->scsa2usb_cmd_protocol & SCSA2USB_ATAPI_CMDSET)) 427 428 #define SCSA2USB_IS_CB(s) \ 429 (((s)->scsa2usb_cmd_protocol & SCSA2USB_CB_PROTOCOL)) 430 431 #define SCSA2USB_IS_CBI(s) \ 432 (((s)->scsa2usb_cmd_protocol & SCSA2USB_CBI_PROTOCOL)) 433 434 #define SCSA2USB_IS_BULK_ONLY(s) \ 435 (((s)->scsa2usb_cmd_protocol & SCSA2USB_BULK_ONLY_PROTOCOL)) 436 437 /* check if it is ok to access the device and send command to it */ 438 #define SCSA2USB_DEVICE_ACCESS_OK(s) \ 439 ((s)->scsa2usb_dev_state == USB_DEV_ONLINE) 440 441 /* check if we are in any reset */ 442 #define SCSA2USB_IN_RESET(s) \ 443 (((s)->scsa2usb_pipe_state & SCSA2USB_PIPE_DEV_RESET) != 0) 444 445 /* check if the device is busy */ 446 #define SCSA2USB_BUSY(s) \ 447 (((s)->scsa2usb_cur_pkt) || \ 448 ((s)->scsa2usb_pipe_state != SCSA2USB_PIPE_NORMAL) || \ 449 ((s)->scsa2usb_pkt_state != SCSA2USB_PKT_NONE)) 450 451 /* check if we're doing cpr */ 452 #define SCSA2USB_CHK_CPR(s) \ 453 (((s)->scsa2usb_dev_state == USB_DEV_SUSPENDED)) 454 455 /* check if we're either paniced or in cpr state */ 456 #define SCSA2USB_CHK_PANIC_CPR(s) \ 457 (ddi_in_panic() || SCSA2USB_CHK_CPR(s)) 458 459 /* reset scsa2usb state after pkt_comp is called */ 460 #define SCSA2USB_RESET_CUR_PKT(s) \ 461 (s)->scsa2usb_cur_pkt = NULL; \ 462 (s)->scsa2usb_pkt_state = SCSA2USB_PKT_NONE; 463 464 /* print a panic sync message to the console */ 465 #define SCSA2USB_PRINT_SYNC_MSG(m, s) \ 466 if ((m) == B_TRUE) { \ 467 USB_DPRINTF_L1(DPRINT_MASK_SCSA, (s)->scsa2usb_log_handle, \ 468 "syncing not supported"); \ 469 (m) = B_FALSE; \ 470 } 471 472 /* Cancel callbacks registered during attach time */ 473 #define SCSA2USB_CANCEL_CB(id) \ 474 if ((id)) { \ 475 (void) callb_delete((id)); \ 476 (id) = 0; \ 477 } 478 479 /* Set SCSA2USB_PKT_DO_COMP state if there is active I/O */ 480 #define SCSA2USB_SET_PKT_DO_COMP_STATE(s) \ 481 if ((s)->scsa2usb_cur_pkt) { \ 482 (s)->scsa2usb_pkt_state = SCSA2USB_PKT_DO_COMP; \ 483 } 484 485 #define SCSA2USB_FREE_MSG(data) \ 486 if ((data)) { \ 487 freemsg((data)); \ 488 } 489 490 #define SCSA2USB_FREE_BULK_REQ(req) \ 491 if ((req)) { \ 492 usb_free_bulk_req((req)); /* Free request */ \ 493 } 494 495 496 /* SCSA related */ 497 #define ADDR2TRAN(ap) ((ap)->a_hba_tran) 498 #define TRAN2SCSA2USB(tran) ((scsa2usb_state_t *)(tran)->tran_hba_private) 499 #define ADDR2SCSA2USB(ap) (TRAN2SCSA2USB(ADDR2TRAN(ap))) 500 501 #define PKT_PRIV_LEN 16 502 503 #define PKT_DEFAULT_TIMEOUT 5 504 505 /* 506 * auto request sense 507 */ 508 #define RQ_MAKECOM_COMMON(pktp, flag, cmd) \ 509 (pktp)->pkt_flags = (flag), \ 510 ((union scsi_cdb *)(pktp)->pkt_cdbp)->scc_cmd = (cmd), \ 511 ((union scsi_cdb *)(pktp)->pkt_cdbp)->scc_lun = \ 512 (pktp)->pkt_address.a_lun 513 514 #define RQ_MAKECOM_G0(pktp, flag, cmd, addr, cnt) \ 515 RQ_MAKECOM_COMMON((pktp), (flag), (cmd)), \ 516 FORMG0ADDR(((union scsi_cdb *)(pktp)->pkt_cdbp), (addr)), \ 517 FORMG0COUNT(((union scsi_cdb *)(pktp)->pkt_cdbp), (cnt)) 518 519 520 /* 521 * Transport dispositions for commands: 522 */ 523 #define SCSA2USB_JUST_ACCEPT 0 /* Simulate command without device */ 524 #define SCSA2USB_TRANSPORT 1 /* Send the command to the device */ 525 #define SCSA2USB_REJECT -1 /* Reject with immediate fatal error */ 526 527 /* 528 * The scsa2usb_cpr_info data structure is used for cpr related 529 * callbacks. It is used for panic callbacks as well. 530 */ 531 typedef struct scsa2usb_cpr { 532 callb_cpr_t cpr; /* for cpr related info */ 533 struct scsa2usb_state *statep; /* for scsa2usb state info */ 534 kmutex_t lockp; /* mutex used by cpr_info_t */ 535 } scsa2usb_cpr_t; 536 537 _NOTE(DATA_READABLE_WITHOUT_LOCK(scsa2usb_cpr_t::cpr)) 538 _NOTE(DATA_READABLE_WITHOUT_LOCK(scsa2usb_cpr_t::statep)) 539 540 /* 541 * The scsa2usb_cmd data structure is defined here. It gets 542 * initialized per command that is sent to the device. 543 */ 544 typedef struct scsa2usb_cmd { 545 struct scsi_pkt *cmd_pkt; /* copy of pkt ptr */ 546 struct buf *cmd_bp; /* copy of bp ptr */ 547 size_t cmd_xfercount; /* current xfer count */ 548 size_t cmd_resid_xfercount; /* last xfer resid */ 549 int cmd_scblen; /* status length */ 550 int cmd_tag; /* tag */ 551 int cmd_timeout; /* copy of pkt_time */ 552 uchar_t cmd_cdb[SCSI_CDB_SIZE]; /* CDB */ 553 uchar_t cmd_dir; /* direction */ 554 uchar_t cmd_actual_len; /* cdb len */ 555 uchar_t cmd_cdblen; /* requested cdb len */ 556 struct scsi_arq_status cmd_scb; /* status, w/ arq */ 557 558 /* used in multiple xfers */ 559 size_t cmd_total_xfercount; /* total xfer val */ 560 size_t cmd_offset; /* offset into buf */ 561 uint64_t cmd_lba; /* current xfer lba */ 562 int cmd_done; /* command done? */ 563 int cmd_blksize; /* block size */ 564 usba_list_entry_t cmd_waitQ; /* waitQ element */ 565 } scsa2usb_cmd_t; 566 567 /* for warlock */ 568 _NOTE(SCHEME_PROTECTS_DATA("unique per packet or safe sharing", 569 scsi_cdb scsi_status scsi_pkt buf scsa2usb_cmd scsi_arq_status)) 570 _NOTE(SCHEME_PROTECTS_DATA("stable data", scsi_device scsi_address)) 571 572 /* scsa2usb_cdb position of fields in CDB */ 573 #define SCSA2USB_OPCODE 0 /* Opcode field */ 574 #define SCSA2USB_LUN 1 /* LUN field */ 575 #define SCSA2USB_LBA_0 2 /* LBA[0] field */ 576 #define SCSA2USB_LBA_1 3 /* LBA[1] field */ 577 #define SCSA2USB_LBA_2 4 /* LBA[2] field */ 578 #define SCSA2USB_LBA_3 5 /* LBA[3] field */ 579 #define SCSA2USB_LEN_0 7 /* LEN[0] field */ 580 #define SCSA2USB_LEN_1 8 /* LEN[1] field */ 581 582 /* 583 * Extract LBA and length from 6, 10, 12, and 16-byte commands: 584 */ 585 #define SCSA2USB_LBA_6BYTE(pkt) \ 586 (((pkt)->pkt_cdbp[1] & 0x1f) << 16) + \ 587 ((pkt)->pkt_cdbp[2] << 8) + (pkt)->pkt_cdbp[3] 588 #define SCSA2USB_LEN_6BYTE(pkt) (pkt)->pkt_cdbp[4] 589 590 #define SCSA2USB_LEN_10BYTE(pkt) \ 591 ((pkt)->pkt_cdbp[7] << 8) + (pkt)->pkt_cdbp[8] 592 #define SCSA2USB_LBA_10BYTE(pkt) \ 593 ((pkt)->pkt_cdbp[2] << 24) + ((pkt)->pkt_cdbp[3] << 16) + \ 594 ((pkt)->pkt_cdbp[4] << 8) + (pkt)->pkt_cdbp[5] 595 596 #define SCSA2USB_LEN_12BYTE(pkt) \ 597 ((pkt)->pkt_cdbp[6] << 24) + ((pkt)->pkt_cdbp[7] << 16) + \ 598 ((pkt)->pkt_cdbp[8] << 8) + (pkt)->pkt_cdbp[9] 599 #define SCSA2USB_LBA_12BYTE(pkt) \ 600 ((pkt)->pkt_cdbp[2] << 24) + ((pkt)->pkt_cdbp[3] << 16) + \ 601 ((pkt)->pkt_cdbp[4] << 8) + (pkt)->pkt_cdbp[5] 602 603 #define SCSA2USB_LEN_16BYTE(pkt) \ 604 (((pkt)->pkt_cdbp[10] << 24) + ((pkt)->pkt_cdbp[11] << 16) + \ 605 ((pkt)->pkt_cdbp[12] << 8) + (pkt)->pkt_cdbp[13]) 606 #define SCSA2USB_LBA_16BYTE(pkt) ((uint64_t)( \ 607 ((uint64_t)(pkt)->pkt_cdbp[2] << 56) + \ 608 ((uint64_t)(pkt)->pkt_cdbp[3] << 48) + \ 609 ((uint64_t)(pkt)->pkt_cdbp[4] << 40) + \ 610 ((uint64_t)(pkt)->pkt_cdbp[5] << 32) + \ 611 ((uint64_t)(pkt)->pkt_cdbp[6] << 24) + \ 612 ((uint64_t)(pkt)->pkt_cdbp[7] << 16) + \ 613 ((uint64_t)(pkt)->pkt_cdbp[8] << 8) + \ 614 ((uint64_t)(pkt)->pkt_cdbp[9]))) 615 616 /* macros to convert a pkt to cmd and vice-versa */ 617 #define PKT2CMD(pkt) ((scsa2usb_cmd_t *)(pkt)->pkt_ha_private) 618 #define CMD2PKT(sp) ((sp)->cmd_pkt) 619 620 /* bulk pipe default timeout value - how long the command to be tried? */ 621 #define SCSA2USB_BULK_PIPE_TIMEOUT (2 * USB_PIPE_TIMEOUT) 622 623 /* drain timeout in seconds on the work thread */ 624 #define SCSA2USB_DRAIN_TIMEOUT 60 625 626 /* scsa2usb pkt xfer status phase retry times */ 627 #define SCSA2USB_STATUS_RETRIES 3 628 629 /* 630 * limit on the number of requests that can be queued per LUN: 631 * 3 for untagged queueing, 1 for scsiwatch and a margin of 2 632 */ 633 #define SCSA2USB_MAX_REQ_PER_LUN 6 634 635 /* 636 * The following data structure is used to save the values returned 637 * by the READ_CAPACITY command. lba is the max allowed logical block 638 * address and blen is max allowed block size. 639 */ 640 typedef struct scsa2usb_read_cap { 641 uchar_t scsa2usb_read_cap_lba3; /* Max lba supported */ 642 uchar_t scsa2usb_read_cap_lba2; 643 uchar_t scsa2usb_read_cap_lba1; 644 uchar_t scsa2usb_read_cap_lba0; 645 uchar_t scsa2usb_read_cap_blen3; /* Max block size supported */ 646 uchar_t scsa2usb_read_cap_blen2; 647 uchar_t scsa2usb_read_cap_blen1; 648 uchar_t scsa2usb_read_cap_blen0; 649 } scsa2usb_read_cap_t; 650 651 #define SCSA2USB_MK_32BIT(a, b, c, d) \ 652 (((a) << 24) | ((b) << 16) | ((c) << 8) | (d)) 653 654 /* position of fields for SCMD_READ_CD CDB */ 655 #define SCSA2USB_READ_CD_LEN_0 6 /* LEN[0] of SCMD_READ_CD */ 656 #define SCSA2USB_READ_CD_LEN_1 7 /* LEN[1] of SCMD_READ_CD */ 657 #define SCSA2USB_READ_CD_LEN_2 8 /* LEN[2] of SCMD_READ_CD */ 658 659 /* macro to calculate LEN for SCMD_READ_CD command */ 660 #define SCSA2USB_LEN_READ_CD(pkt) \ 661 (((pkt)->pkt_cdbp[SCSA2USB_READ_CD_LEN_0] << 16) +\ 662 ((pkt)->pkt_cdbp[SCSA2USB_READ_CD_LEN_1] << 8) +\ 663 (pkt)->pkt_cdbp[SCSA2USB_READ_CD_LEN_2]) 664 665 /* Figure out Block Size before issuing a WRITE to CD-RW device */ 666 #define SCSA2USB_CDRW_BLKSZ(bcount, len) ((bcount) / (len)); 667 #define SCSA2USB_VALID_CDRW_BLKSZ(blksz) \ 668 (((blksz) == CDROM_BLK_2048) || ((blksz) == CDROM_BLK_2352) || \ 669 ((blksz) == CDROM_BLK_2336) || ((blksz) == CDROM_BLK_2324) || \ 670 ((blksz) == 0)) 671 672 /* debug and error msg logging */ 673 #define DPRINT_MASK_SCSA 0x0001 /* for SCSA */ 674 #define DPRINT_MASK_ATTA 0x0002 /* for ATTA */ 675 #define DPRINT_MASK_EVENTS 0x0004 /* for event handling */ 676 #define DPRINT_MASK_CALLBACKS 0x0008 /* for callbacks */ 677 #define DPRINT_MASK_TIMEOUT 0x0010 /* for timeouts */ 678 #define DPRINT_MASK_DUMPING 0x0020 /* for dumping */ 679 #define DPRINT_MASK_PM 0x0040 /* for pwr mgmt */ 680 #define DPRINT_MASK_ALL 0xffffffff /* for everything */ 681 682 #ifdef DEBUG 683 #define SCSA2USB_PRINT_CDB scsa2usb_print_cdb 684 #else 685 #define SCSA2USB_PRINT_CDB(...) (void)(0) 686 #endif 687 688 /* ugen support */ 689 #define SCSA2USB_MINOR_UGEN_BITS_MASK 0xff 690 #define SCSA2USB_MINOR_INSTANCE_MASK ~SCSA2USB_MINOR_UGEN_BITS_MASK 691 #define SCSA2USB_MINOR_INSTANCE_SHIFT 8 692 693 #define SCSA2USB_MINOR_TO_INSTANCE(minor) \ 694 (((minor) & SCSA2USB_MINOR_INSTANCE_MASK) >> \ 695 SCSA2USB_MINOR_INSTANCE_SHIFT) 696 697 #ifdef __cplusplus 698 } 699 #endif 700 701 #endif /* _SYS_USB_SCSA2USB_H */ 702