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 /*
  22  * Copyright 2010 Sun Microsystems, Inc.  All rights reserved.
  23  * Use is subject to license terms.
  24  */
  25 
  26 
  27 /*
  28  * scsa2usb bridge nexus driver:
  29  *
  30  * This driver supports the following wire transports:
  31  * a. Bulk Only transport (see usb_ms_bulkonly.c)
  32  * b. CB transport (see usb_ms_cbi.c)
  33  * c. CBI transport with interrupt status completion (see usb_ms_cbi.c)
  34  *
  35  * It handles the following command sets:
  36  * a. SCSI
  37  * b. ATAPI command set (subset of SCSI command set)
  38  * c. UFI command set (
  39  *      http://www.usb.org/developers/devclass_docs/usbmass-ufi10.pdf)
  40  *
  41  * For details on USB Mass Storage Class overview:
  42  *      http://www.usb.org/developers/devclass_docs/usbmassover_11.pdf
  43  */
  44 #if defined(lint) && !defined(DEBUG)
  45 #define DEBUG   1
  46 #endif
  47 
  48 #include <sys/usb/usba/usbai_version.h>
  49 #include <sys/scsi/scsi.h>
  50 #include <sys/cdio.h>
  51 #include <sys/sunndi.h>
  52 #include <sys/esunddi.h>
  53 #include <sys/callb.h>
  54 #include <sys/kobj.h>
  55 #include <sys/kobj_lex.h>
  56 #include <sys/strsubr.h>
  57 #include <sys/strsun.h>
  58 #include <sys/sysmacros.h>
  59 
  60 #include <sys/usb/usba.h>
  61 #include <sys/usb/clients/ugen/usb_ugen.h>
  62 #include <sys/usb/usba/usba_ugen.h>
  63 
  64 #include <sys/usb/usba/usba_private.h>
  65 #include <sys/usb/usba/usba_ugend.h>
  66 #include <sys/usb/clients/mass_storage/usb_bulkonly.h>
  67 #include <sys/usb/scsa2usb/scsa2usb.h>
  68 
  69 /*
  70  * Function Prototypes
  71  */
  72 static int      scsa2usb_attach(dev_info_t *, ddi_attach_cmd_t);
  73 static int      scsa2usb_info(dev_info_t *, ddi_info_cmd_t, void *,
  74                                                 void **);
  75 static int      scsa2usb_detach(dev_info_t *, ddi_detach_cmd_t);
  76 static int      scsa2usb_cleanup(dev_info_t *, scsa2usb_state_t *);
  77 static void     scsa2usb_validate_attrs(scsa2usb_state_t *);
  78 static void     scsa2usb_create_luns(scsa2usb_state_t *);
  79 static int      scsa2usb_is_usb(dev_info_t *);
  80 static void     scsa2usb_fake_inquiry(scsa2usb_state_t *,
  81                     struct scsi_inquiry *);
  82 static void     scsa2usb_do_inquiry(scsa2usb_state_t *,
  83                                                 uint_t, uint_t);
  84 static int      scsa2usb_do_tur(scsa2usb_state_t *, struct scsi_address *);
  85 
  86 /* override property handling */
  87 static void     scsa2usb_override(scsa2usb_state_t *);
  88 static int      scsa2usb_parse_input_str(char *, scsa2usb_ov_t *,
  89                     scsa2usb_state_t *);
  90 static void     scsa2usb_override_error(char *, scsa2usb_state_t *);
  91 static char     *scsa2usb_strtok_r(char *, char *, char **);
  92 
  93 
  94 /* PANIC callback handling */
  95 static void     scsa2usb_panic_callb_init(scsa2usb_state_t *);
  96 static void     scsa2usb_panic_callb_fini(scsa2usb_state_t *);
  97 static boolean_t scsa2usb_panic_callb(void *, int);
  98 
  99 /* SCSA support */
 100 static int      scsa2usb_scsi_tgt_probe(struct scsi_device *, int (*)(void));
 101 static int      scsa2usb_scsi_tgt_init(dev_info_t *, dev_info_t *,
 102                     scsi_hba_tran_t *, struct scsi_device *);
 103 static void     scsa2usb_scsi_tgt_free(dev_info_t *, dev_info_t *,
 104                     scsi_hba_tran_t *, struct scsi_device *);
 105 static struct   scsi_pkt *scsa2usb_scsi_init_pkt(struct scsi_address *,
 106                     struct scsi_pkt *, struct buf *, int, int,
 107                     int, int, int (*)(), caddr_t);
 108 static void     scsa2usb_scsi_destroy_pkt(struct scsi_address *,
 109                     struct scsi_pkt *);
 110 static int      scsa2usb_scsi_start(struct scsi_address *, struct scsi_pkt *);
 111 static int      scsa2usb_scsi_abort(struct scsi_address *, struct scsi_pkt *);
 112 static int      scsa2usb_scsi_reset(struct scsi_address *, int);
 113 static int      scsa2usb_scsi_getcap(struct scsi_address *, char *, int);
 114 static int      scsa2usb_scsi_setcap(struct scsi_address *, char *, int, int);
 115 static int      scsa2usb_scsi_bus_config(dev_info_t *, uint_t,
 116                     ddi_bus_config_op_t, void *, dev_info_t **);
 117 static int      scsa2usb_scsi_bus_unconfig(dev_info_t *, uint_t,
 118                     ddi_bus_config_op_t, void *);
 119 
 120 /* functions for command and transport support */
 121 static void     scsa2usb_prepare_pkt(scsa2usb_state_t *, struct scsi_pkt *);
 122 static int      scsa2usb_cmd_transport(scsa2usb_state_t *, scsa2usb_cmd_t *);
 123 static int      scsa2usb_check_bulkonly_blacklist_attrs(scsa2usb_state_t *,
 124                     scsa2usb_cmd_t *, uchar_t);
 125 static int      scsa2usb_check_ufi_blacklist_attrs(scsa2usb_state_t *, uchar_t,
 126                     scsa2usb_cmd_t *);
 127 static int      scsa2usb_handle_scsi_cmd_sub_class(scsa2usb_state_t *,
 128                     scsa2usb_cmd_t *, struct scsi_pkt *);
 129 static int      scsa2usb_handle_ufi_subclass_cmd(scsa2usb_state_t *,
 130                     scsa2usb_cmd_t *, struct scsi_pkt *);
 131 
 132 /* waitQ handling */
 133 static void     scsa2usb_work_thread(void *);
 134 static void     scsa2usb_transport_request(scsa2usb_state_t *, uint_t);
 135 static void     scsa2usb_flush_waitQ(scsa2usb_state_t *, uint_t, uchar_t);
 136 static int      scsa2usb_all_waitQs_empty(scsa2usb_state_t *);
 137 
 138 /* auto request sense handling */
 139 static int      scsa2usb_create_arq_pkt(scsa2usb_state_t *,
 140                     struct scsi_address *);
 141 static void     scsa2usb_delete_arq_pkt(scsa2usb_state_t *);
 142 static void     scsa2usb_complete_arq_pkt(scsa2usb_state_t *, struct scsi_pkt *,
 143                     scsa2usb_cmd_t *, struct buf *);
 144 
 145 /* utility functions for any transport */
 146 static int      scsa2usb_open_usb_pipes(scsa2usb_state_t *);
 147 void            scsa2usb_close_usb_pipes(scsa2usb_state_t *);
 148 
 149 static void     scsa2usb_fill_up_cdb_len(scsa2usb_cmd_t *, int);
 150 static void     scsa2usb_fill_up_cdb_lba(scsa2usb_cmd_t *, int);
 151 static void     scsa2usb_fill_up_ReadCD_cdb_len(scsa2usb_cmd_t *, int, int);
 152 static void     scsa2usb_fill_up_12byte_cdb_len(scsa2usb_cmd_t *, int, int);
 153 static int      scsa2usb_read_cd_blk_size(uchar_t);
 154 int             scsa2usb_rw_transport(scsa2usb_state_t *, struct scsi_pkt *);
 155 void            scsa2usb_setup_next_xfer(scsa2usb_state_t *, scsa2usb_cmd_t *);
 156 
 157 static mblk_t   *scsa2usb_bp_to_mblk(scsa2usb_state_t *);
 158 int             scsa2usb_handle_data_start(scsa2usb_state_t *,
 159                     scsa2usb_cmd_t *, usb_bulk_req_t *);
 160 void            scsa2usb_handle_data_done(scsa2usb_state_t *,
 161                     scsa2usb_cmd_t *cmd, usb_bulk_req_t *);
 162 
 163 usb_bulk_req_t *scsa2usb_init_bulk_req(scsa2usb_state_t *,
 164                             size_t, uint_t, usb_req_attrs_t, usb_flags_t);
 165 int             scsa2usb_bulk_timeout(int);
 166 int             scsa2usb_clear_ept_stall(scsa2usb_state_t *, uint_t,
 167                     usb_pipe_handle_t, char *);
 168 static void     scsa2usb_pkt_completion(scsa2usb_state_t *, struct scsi_pkt *);
 169 
 170 /* event handling */
 171 static int      scsa2usb_reconnect_event_cb(dev_info_t *);
 172 static int      scsa2usb_disconnect_event_cb(dev_info_t *);
 173 static int      scsa2usb_cpr_suspend(dev_info_t *);
 174 static void     scsa2usb_cpr_resume(dev_info_t *);
 175 static void     scsa2usb_restore_device_state(dev_info_t *, scsa2usb_state_t *);
 176 
 177 /* PM handling */
 178 static void     scsa2usb_create_pm_components(dev_info_t *, scsa2usb_state_t *);
 179 static void     scsa2usb_raise_power(scsa2usb_state_t *);
 180 static int      scsa2usb_pwrlvl0(scsa2usb_state_t *);
 181 static int      scsa2usb_pwrlvl1(scsa2usb_state_t *);
 182 static int      scsa2usb_pwrlvl2(scsa2usb_state_t *);
 183 static int      scsa2usb_pwrlvl3(scsa2usb_state_t *);
 184 static int      scsa2usb_power(dev_info_t *, int comp, int level);
 185 static void     scsa2usb_pm_busy_component(scsa2usb_state_t *);
 186 static void     scsa2usb_pm_idle_component(scsa2usb_state_t *);
 187 
 188 /* external functions for Bulk only (BO) support */
 189 extern int      scsa2usb_bulk_only_transport(scsa2usb_state_t *,
 190                     scsa2usb_cmd_t *);
 191 extern int      scsa2usb_bulk_only_get_max_lun(scsa2usb_state_t *);
 192 
 193 /* external functions for CB/CBI support */
 194 extern int      scsa2usb_cbi_transport(scsa2usb_state_t *, scsa2usb_cmd_t *);
 195 extern void     scsa2usb_cbi_stop_intr_polling(scsa2usb_state_t *);
 196 
 197 
 198 /* cmd decoding */
 199 static char *scsa2usb_cmds[] = {
 200         "\000tur",
 201         "\001rezero",
 202         "\003rqsense",
 203         "\004format",
 204         "\014cartprot",
 205         "\022inquiry",
 206         "\026tranlba",
 207         "\030fmtverify",
 208         "\032modesense",
 209         "\033start",
 210         "\035snddiag",
 211         "\036doorlock",
 212         "\043formatcap",
 213         "\045readcap",
 214         "\050read10",
 215         "\052write10",
 216         "\053seek10",
 217         "\056writeverify",
 218         "\057verify",
 219         "\065synchcache",
 220         "\076readlong",
 221         "\077writelong",
 222         "\102readsubchan",
 223         "\103readtoc",
 224         "\104readhdr",
 225         "\105playaudio10",
 226         "\107playaudio_msf",
 227         "\110playaudio_ti",
 228         "\111playtrk_r10",
 229         "\112geteventnotify",
 230         "\113pause_resume",
 231         "\116stop/play_scan",
 232         "\121readdiscinfo",
 233         "\122readtrkinfo",
 234         "\123reservedtrk",
 235         "\124sendopcinfo",
 236         "\125modeselect",
 237         "\132modesense",
 238         "\133closetrksession",
 239         "\135sendcuesheet",
 240         "\136prin",
 241         "\137prout",
 242         "\241blankcd",
 243         "\245playaudio12",
 244         "\250read12",
 245         "\251playtrk12",
 246         "\252write12",
 247         "\254getperf",
 248         "\271readcdmsf",
 249         "\273setcdspeed",
 250         "\275mechanism_sts",
 251         "\276readcd",
 252         NULL
 253 };
 254 
 255 
 256 /*
 257  * Mass-Storage devices masquerade as "sd" disks.
 258  *
 259  * These devices may not support all SCSI CDBs in their
 260  * entirety due to their hardware implementation limitations.
 261  *
 262  * As such, following is a list of some of the black-listed
 263  * devices w/ the attributes that they do not support.
 264  * (See scsa2usb.h for description on each attribute)
 265  */
 266 #define X       ((uint16_t)(-1))
 267 
 268 static struct blacklist {
 269         uint16_t        idVendor;       /* vendor ID                    */
 270         uint16_t        idProduct;      /* product ID                   */
 271         uint16_t        bcdDevice;      /* device release number in bcd */
 272         uint16_t        attributes;     /* attributes to blacklist      */
 273 } scsa2usb_blacklist[] = {
 274         /* Iomega Zip100 drive (prototype) with flaky bridge */
 275         {MS_IOMEGA_VID, MS_IOMEGA_PID1_ZIP100, 0,
 276             SCSA2USB_ATTRS_GET_LUN | SCSA2USB_ATTRS_PM},
 277 
 278         /* Iomega Zip100 drive (newer model) with flaky bridge */
 279         {MS_IOMEGA_VID, MS_IOMEGA_PID2_ZIP100, 0,
 280             SCSA2USB_ATTRS_GET_LUN | SCSA2USB_ATTRS_PM},
 281 
 282         /* Iomega Zip100 drive (newer model) with flaky bridge */
 283         {MS_IOMEGA_VID, MS_IOMEGA_PID3_ZIP100, 0,
 284             SCSA2USB_ATTRS_GET_LUN | SCSA2USB_ATTRS_PM},
 285 
 286         /* Iomega Zip250 drive */
 287         {MS_IOMEGA_VID, MS_IOMEGA_PID_ZIP250, 0, SCSA2USB_ATTRS_GET_LUN},
 288 
 289         /* Iomega Clik! drive */
 290         {MS_IOMEGA_VID, MS_IOMEGA_PID_CLIK, 0,
 291             SCSA2USB_ATTRS_GET_LUN | SCSA2USB_ATTRS_START_STOP},
 292 
 293         /* Kingston DataTraveler Stick / PNY Attache Stick */
 294         {MS_TOSHIBA_VID, MS_TOSHIBA_PID0, 0,
 295             SCSA2USB_ATTRS_GET_LUN},
 296 
 297         /* PNY Floppy drive */
 298         {MS_PNY_VID, MS_PNY_PID0, 0,
 299             SCSA2USB_ATTRS_GET_LUN},
 300 
 301         /* SMSC floppy Device - and its clones */
 302         {MS_SMSC_VID, X, 0, SCSA2USB_ATTRS_START_STOP},
 303 
 304         /* Hagiwara SmartMedia Device */
 305         {MS_HAGIWARA_SYS_COM_VID, MS_HAGIWARA_SYSCOM_PID1, 0,
 306             SCSA2USB_ATTRS_GET_LUN | SCSA2USB_ATTRS_START_STOP},
 307 
 308         /* Hagiwara CompactFlash Device */
 309         {MS_HAGIWARA_SYS_COM_VID, MS_HAGIWARA_SYSCOM_PID2, 0,
 310             SCSA2USB_ATTRS_GET_LUN | SCSA2USB_ATTRS_START_STOP},
 311 
 312         /* Hagiwara SmartMedia/CompactFlash Combo Device */
 313         {MS_HAGIWARA_SYS_COM_VID, MS_HAGIWARA_SYSCOM_PID3, 0,
 314             SCSA2USB_ATTRS_START_STOP},
 315 
 316         /* Hagiwara new SM Device */
 317         {MS_HAGIWARA_SYS_COM_VID, MS_HAGIWARA_SYSCOM_PID4, 0,
 318             SCSA2USB_ATTRS_GET_LUN | SCSA2USB_ATTRS_START_STOP},
 319 
 320         /* Hagiwara new CF Device */
 321         {MS_HAGIWARA_SYS_COM_VID, MS_HAGIWARA_SYSCOM_PID5, 0,
 322             SCSA2USB_ATTRS_GET_LUN | SCSA2USB_ATTRS_START_STOP},
 323 
 324         /* Mitsumi CD-RW Device(s) */
 325         {MS_MITSUMI_VID, X, X, SCSA2USB_ATTRS_BIG_TIMEOUT |
 326             SCSA2USB_ATTRS_GET_CONF | SCSA2USB_ATTRS_GET_PERF},
 327 
 328         /* Neodio Technologies Corporation SM/CF/MS/SD Combo Device */
 329         {MS_NEODIO_VID, MS_NEODIO_DEVICE_3050, 0,
 330             SCSA2USB_ATTRS_MODE_SENSE },
 331 
 332         /* dumb flash devices */
 333         {MS_SONY_FLASH_VID, MS_SONY_FLASH_PID, 0,
 334             SCSA2USB_ATTRS_REDUCED_CMD},
 335 
 336         {MS_TREK_FLASH_VID, MS_TREK_FLASH_PID, 0,
 337             SCSA2USB_ATTRS_REDUCED_CMD},
 338 
 339         {MS_PENN_FLASH_VID, MS_PENN_FLASH_PID, 0,
 340             SCSA2USB_ATTRS_REDUCED_CMD},
 341 
 342         /* SimpleTech UCF-100 CF Device */
 343         {MS_SIMPLETECH_VID, MS_SIMPLETECH_PID1, 0,
 344             SCSA2USB_ATTRS_REDUCED_CMD},
 345 
 346         {MS_ADDONICS_CARD_READER_VID, MS_ADDONICS_CARD_READER_PID,
 347             0, SCSA2USB_ATTRS_REDUCED_CMD},
 348 
 349         /* Acomdata 80GB USB/1394 Hard Disk */
 350         {MS_ACOMDATA_VID, MS_ACOMDATA_PID1, 0,
 351             SCSA2USB_ATTRS_USE_CSW_RESIDUE},
 352 
 353         /* OTi6828 Flash Disk */
 354         {MS_OTI_VID, MS_OTI_DEVICE_6828, 0,
 355             SCSA2USB_ATTRS_USE_CSW_RESIDUE},
 356 
 357         /* AMI Virtual Floppy */
 358         {MS_AMI_VID, MS_AMI_VIRTUAL_FLOPPY, 0,
 359             SCSA2USB_ATTRS_NO_MEDIA_CHECK},
 360 
 361         /* ScanLogic USB Storage Device */
 362         {MS_SCANLOGIC_VID, MS_SCANLOGIC_PID1, 0,
 363             SCSA2USB_ATTRS_NO_CAP_ADJUST},
 364 
 365         /* Super Top USB 2.0 IDE Device */
 366         {MS_SUPERTOP_VID, MS_SUPERTOP_DEVICE_6600, 0,
 367             SCSA2USB_ATTRS_USE_CSW_RESIDUE},
 368 
 369         /* Aigo Miniking Device NEHFSP14 */
 370         {MS_AIGO_VID, MS_AIGO_DEVICE_6981, 0,
 371             SCSA2USB_ATTRS_USE_CSW_RESIDUE},
 372 
 373         /* Alcor Micro Corp 6387 flash disk */
 374         {MS_ALCOR_VID, MS_ALCOR_PID0, 0,
 375             SCSA2USB_ATTRS_GET_LUN | SCSA2USB_ATTRS_USE_CSW_RESIDUE},
 376 
 377         /* Western Digital External HDD */
 378         {MS_WD_VID, MS_WD_PID, 0,
 379             SCSA2USB_ATTRS_INQUIRY_EVPD}
 380 };
 381 
 382 
 383 #define N_SCSA2USB_BLACKLIST (sizeof (scsa2usb_blacklist))/ \
 384                                 sizeof (struct blacklist)
 385 
 386 /*
 387  * Attribute values can be overridden by values
 388  * contained in the scsa2usb.conf file.
 389  * These arrays define possible user input values.
 390  */
 391 
 392 struct scsa2usb_subclass_protocol_override {
 393         char    *name;
 394         int     value;
 395 };
 396 
 397 static struct scsa2usb_subclass_protocol_override scsa2usb_protocol[] =  {
 398         {"CB", SCSA2USB_CB_PROTOCOL},
 399         {"CBI", SCSA2USB_CBI_PROTOCOL},
 400         {"BO", SCSA2USB_BULK_ONLY_PROTOCOL}
 401 };
 402 
 403 static struct scsa2usb_subclass_protocol_override scsa2usb_subclass[] = {
 404         {"SCSI", SCSA2USB_SCSI_CMDSET},
 405         {"ATAPI", SCSA2USB_ATAPI_CMDSET},
 406         {"UFI", SCSA2USB_UFI_CMDSET}
 407 };
 408 
 409 
 410 #define N_SCSA2USB_SUBC_OVERRIDE (sizeof (scsa2usb_subclass))/ \
 411                         sizeof (struct scsa2usb_subclass_protocol_override)
 412 
 413 #define N_SCSA2USB_PROT_OVERRIDE (sizeof (scsa2usb_protocol))/ \
 414                         sizeof (struct scsa2usb_subclass_protocol_override)
 415 
 416 /* global variables */
 417 static void *scsa2usb_statep;                           /* for soft state */
 418 static boolean_t scsa2usb_sync_message = B_TRUE;        /* for syncing */
 419 
 420 /* for debug messages */
 421 uint_t  scsa2usb_errmask        = (uint_t)DPRINT_MASK_ALL;
 422 uint_t  scsa2usb_errlevel       = USB_LOG_L4;
 423 uint_t  scsa2usb_instance_debug = (uint_t)-1;
 424 uint_t  scsa2usb_scsi_bus_config_debug = 0;
 425 uint_t  scsa2usb_long_timeout   = 50 * SCSA2USB_BULK_PIPE_TIMEOUT;
 426 
 427 
 428 /*
 429  * Some devices have problems with big bulk transfers,
 430  * transfers >= 128kbytes hang the device.  This tunable allows to
 431  * limit the maximum bulk transfers rate.
 432  */
 433 uint_t  scsa2usb_max_bulk_xfer_size = SCSA2USB_MAX_BULK_XFER_SIZE;
 434 
 435 
 436 #ifdef  SCSA2USB_BULK_ONLY_TEST
 437 /*
 438  * Test BO 13 cases. (See USB Mass Storage Class - Bulk Only Transport).
 439  * We are not covering test cases 1, 6, and 12 as these are the "good"
 440  * test cases and are tested as part of the normal drive access operations.
 441  *
 442  * NOTE: This is for testing only. It will be replaced by a uscsi test.
 443  * Some are listed here while; other test cases are moved to usb_bulkonly.c
 444  */
 445 static int scsa2usb_test_case_5 = 0;
 446 int scsa2usb_test_case_8 = 0;
 447 int scsa2usb_test_case_10 = 0;
 448 static int scsa2usb_test_case_11 = 0;
 449 
 450 static void     scsa2usb_test_mblk(scsa2usb_state_t *, boolean_t);
 451 #endif  /* SCSA2USB_BULK_ONLY_TEST */
 452 
 453 static int      scsa2usb_ugen_open(dev_t *, int, int, cred_t *);
 454 static int      scsa2usb_ugen_close(dev_t, int, int, cred_t *);
 455 static int      scsa2usb_ugen_read(dev_t, struct uio *, cred_t *);
 456 static int      scsa2usb_ugen_write(dev_t, struct uio *, cred_t *);
 457 static int      scsa2usb_ugen_poll(dev_t, short, int,  short *,
 458                                                 struct pollhead **);
 459 
 460 /* scsa2usb cb_ops */
 461 static struct cb_ops scsa2usb_cbops = {
 462         scsa2usb_ugen_open,     /* open  */
 463         scsa2usb_ugen_close,    /* close */
 464         nodev,                  /* strategy */
 465         nodev,                  /* print */
 466         nodev,                  /* dump */
 467         scsa2usb_ugen_read,     /* read */
 468         scsa2usb_ugen_write,    /* write */
 469         nodev,                  /* ioctl */
 470         nodev,                  /* devmap */
 471         nodev,                  /* mmap */
 472         nodev,                  /* segmap */
 473         scsa2usb_ugen_poll,     /* poll */
 474         ddi_prop_op,            /* prop_op */
 475         NULL,                   /* stream */
 476         D_MP,                   /* cb_flag */
 477         CB_REV,                 /* rev */
 478         nodev,                  /* int (*cb_aread)() */
 479         nodev                   /* int (*cb_awrite)() */
 480 };
 481 
 482 /* modloading support */
 483 static struct dev_ops scsa2usb_ops = {
 484         DEVO_REV,               /* devo_rev, */
 485         0,                      /* refcnt  */
 486         scsa2usb_info,          /* info */
 487         nulldev,                /* identify */
 488         nulldev,                /* probe */
 489         scsa2usb_attach,        /* attach */
 490         scsa2usb_detach,        /* detach */
 491         nodev,                  /* reset */
 492         &scsa2usb_cbops,    /* driver operations */
 493         NULL,                   /* bus operations */
 494         scsa2usb_power,         /* power */
 495         ddi_quiesce_not_needed,         /* quiesce */
 496 };
 497 
 498 static struct modldrv modldrv = {
 499         &mod_driverops,                     /* Module type. This one is a driver */
 500         "SCSA to USB Driver",   /* Name of the module. */
 501         &scsa2usb_ops,                      /* driver ops */
 502 };
 503 
 504 static struct modlinkage modlinkage = {
 505         MODREV_1, (void *)&modldrv, NULL
 506 };
 507 
 508 /* event support */
 509 static usb_event_t scsa2usb_events = {
 510         scsa2usb_disconnect_event_cb,
 511         scsa2usb_reconnect_event_cb,
 512         NULL, NULL
 513 };
 514 
 515 int
 516 _init(void)
 517 {
 518         int rval;
 519 
 520         if (((rval = ddi_soft_state_init(&scsa2usb_statep,
 521             sizeof (scsa2usb_state_t), SCSA2USB_INITIAL_ALLOC)) != 0)) {
 522 
 523                 return (rval);
 524         }
 525 
 526         if ((rval = scsi_hba_init(&modlinkage)) != 0) {
 527                 ddi_soft_state_fini(&scsa2usb_statep);
 528 
 529                 return (rval);
 530         }
 531 
 532         if ((rval = mod_install(&modlinkage)) != 0) {
 533                 scsi_hba_fini(&modlinkage);
 534                 ddi_soft_state_fini(&scsa2usb_statep);
 535 
 536                 return (rval);
 537         }
 538 
 539         return (rval);
 540 }
 541 
 542 
 543 int
 544 _fini(void)
 545 {
 546         int     rval;
 547 
 548         if ((rval = mod_remove(&modlinkage)) == 0) {
 549                 scsi_hba_fini(&modlinkage);
 550                 ddi_soft_state_fini(&scsa2usb_statep);
 551         }
 552 
 553         return (rval);
 554 }
 555 
 556 
 557 int
 558 _info(struct modinfo *modinfop)
 559 {
 560         return (mod_info(&modlinkage, modinfop));
 561 }
 562 
 563 
 564 /*
 565  * scsa2usb_info :
 566  *      Get minor number, soft state structure etc.
 567  */
 568 /*ARGSUSED*/
 569 static int
 570 scsa2usb_info(dev_info_t *dip, ddi_info_cmd_t infocmd,
 571     void *arg, void **result)
 572 {
 573         scsa2usb_state_t *scsa2usbp = NULL;
 574         int error = DDI_FAILURE;
 575         int instance = SCSA2USB_MINOR_TO_INSTANCE(getminor((dev_t)arg));
 576 
 577         switch (infocmd) {
 578         case DDI_INFO_DEVT2DEVINFO:
 579                 if (((scsa2usbp = ddi_get_soft_state(scsa2usb_statep,
 580                     instance)) != NULL) &&
 581                     scsa2usbp->scsa2usb_dip) {
 582                         *result = scsa2usbp->scsa2usb_dip;
 583                         error = DDI_SUCCESS;
 584                 } else {
 585                         *result = NULL;
 586                 }
 587                 break;
 588         case DDI_INFO_DEVT2INSTANCE:
 589                 *result = (void *)(uintptr_t)instance;
 590                 error = DDI_SUCCESS;
 591                 break;
 592         default:
 593                 break;
 594         }
 595 
 596         return (error);
 597 }
 598 
 599 
 600 /*
 601  * scsa2usb_attach:
 602  *      Attach driver
 603  *      Allocate a "scsi_hba_tran" - call scsi_hba_tran_alloc()
 604  *      Invoke scsi_hba_attach_setup
 605  *      Get the serialno of the device
 606  *      Open bulk pipes
 607  *      Create disk child(ren)
 608  *      Register events
 609  *      Create and register panic callback
 610  *
 611  * NOTE: Replaced CBW_DIR_OUT with USB_EP_DIR_OUT and CBW_DIR_IN with
 612  * USB_EP_DIR_IN as they are the same #defines.
 613  */
 614 static int
 615 scsa2usb_attach(dev_info_t *dip, ddi_attach_cmd_t cmd)
 616 {
 617         int                     instance = ddi_get_instance(dip);
 618         int                     interface;
 619         uint_t                  lun;
 620         boolean_t               ept_check = B_TRUE;
 621         scsi_hba_tran_t         *tran;          /* scsi transport */
 622         scsa2usb_state_t        *scsa2usbp;
 623         usb_log_handle_t        log_handle;
 624         usb_ep_data_t           *ep_data;
 625         usb_client_dev_data_t   *dev_data;
 626         usb_alt_if_data_t       *altif_data;
 627         usb_ugen_info_t         usb_ugen_info;
 628 
 629         USB_DPRINTF_L4(DPRINT_MASK_SCSA, NULL,
 630             "scsa2usb_attach: dip = 0x%p", (void *)dip);
 631 
 632         switch (cmd) {
 633         case DDI_ATTACH:
 634                 break;
 635         case DDI_RESUME:
 636                 scsa2usb_cpr_resume(dip);
 637 
 638                 return (DDI_SUCCESS);
 639         default:
 640                 USB_DPRINTF_L2(DPRINT_MASK_SCSA, NULL,
 641                     "scsa2usb_attach: failed");
 642 
 643                 return (DDI_FAILURE);
 644         }
 645 
 646         /* Allocate softc information */
 647         if (ddi_soft_state_zalloc(scsa2usb_statep, instance) != DDI_SUCCESS) {
 648                 ddi_prop_remove_all(dip);
 649 
 650                 return (DDI_FAILURE);
 651         }
 652 
 653         /* get soft state space and initialize */
 654         if ((scsa2usbp = ddi_get_soft_state(scsa2usb_statep,
 655             instance)) == NULL) {
 656                 USB_DPRINTF_L2(DPRINT_MASK_SCSA, NULL,
 657                     "scsa2usb%d: bad soft state", instance);
 658                 ddi_prop_remove_all(dip);
 659 
 660                 return (DDI_FAILURE);
 661         }
 662 
 663         scsa2usbp->scsa2usb_dip      = dip;
 664         scsa2usbp->scsa2usb_instance = instance;
 665 
 666         /* allocate a log handle for debug/error messages */
 667         scsa2usbp->scsa2usb_log_handle = log_handle =
 668             usb_alloc_log_hdl(dip, "s2u",
 669             &scsa2usb_errlevel,
 670             &scsa2usb_errmask, &scsa2usb_instance_debug,
 671             0);
 672 
 673         /* attach to USBA */
 674         if (usb_client_attach(dip, USBDRV_VERSION, 0) != USB_SUCCESS) {
 675                 USB_DPRINTF_L2(DPRINT_MASK_SCSA, log_handle,
 676                     "usb_client_attach failed");
 677 
 678                 goto fail;
 679         }
 680         if (usb_get_dev_data(dip, &dev_data, USB_PARSE_LVL_IF, 0) !=
 681             USB_SUCCESS) {
 682                 USB_DPRINTF_L2(DPRINT_MASK_SCSA, log_handle,
 683                     "usb_get_dev_data failed");
 684 
 685                 goto fail;
 686         }
 687 
 688         /* initialize the mutex with the right cookie */
 689         mutex_init(&scsa2usbp->scsa2usb_mutex, NULL, MUTEX_DRIVER,
 690             dev_data->dev_iblock_cookie);
 691         cv_init(&scsa2usbp->scsa2usb_transport_busy_cv, NULL, CV_DRIVER, NULL);
 692 
 693         for (lun = 0; lun < SCSA2USB_MAX_LUNS; lun++) {
 694                 usba_init_list(&scsa2usbp->scsa2usb_waitQ[lun], NULL,
 695                     dev_data->dev_iblock_cookie);
 696         }
 697         mutex_enter(&scsa2usbp->scsa2usb_mutex);
 698         scsa2usbp->scsa2usb_dip      = dip;
 699         scsa2usbp->scsa2usb_instance = instance;
 700         scsa2usbp->scsa2usb_attrs    = SCSA2USB_ALL_ATTRS;
 701         scsa2usbp->scsa2usb_dev_data = dev_data;
 702 
 703 
 704         /* save the default pipe handle */
 705         scsa2usbp->scsa2usb_default_pipe = dev_data->dev_default_ph;
 706 
 707         /* basic inits are done */
 708         scsa2usbp->scsa2usb_flags |= SCSA2USB_FLAGS_LOCKS_INIT;
 709 
 710         USB_DPRINTF_L4(DPRINT_MASK_SCSA, log_handle,
 711             "curr_cfg=%ld, curr_if=%d",
 712             (long)(dev_data->dev_curr_cfg - &dev_data->dev_cfg[0]),
 713             dev_data->dev_curr_if);
 714 
 715         interface = dev_data->dev_curr_if;
 716         scsa2usbp->scsa2usb_intfc_num = dev_data->dev_curr_if;
 717 
 718         /* now find out relevant descriptors for alternate 0 */
 719         altif_data = &dev_data->dev_curr_cfg->cfg_if[interface].if_alt[0];
 720 
 721         if (altif_data->altif_n_ep == 0) {
 722                 USB_DPRINTF_L2(DPRINT_MASK_SCSA, log_handle,
 723                     "invalid alt 0 for interface %d", interface);
 724                 mutex_exit(&scsa2usbp->scsa2usb_mutex);
 725 
 726                 goto fail;
 727         }
 728 
 729         /* All CB/CBI, BO devices should have this value set */
 730         if (altif_data->altif_descr.bInterfaceClass !=
 731             USB_CLASS_MASS_STORAGE) {
 732                 USB_DPRINTF_L2(DPRINT_MASK_SCSA, log_handle,
 733                     "invalid interface class (0x%x)",
 734                     altif_data->altif_descr.bInterfaceClass);
 735         }
 736         scsa2usbp->scsa2usb_intfc_descr = altif_data->altif_descr;
 737 
 738         /* figure out the endpoints and copy the descr */
 739         if ((ep_data = usb_lookup_ep_data(dip, dev_data, interface, 0, 0,
 740             USB_EP_ATTR_BULK, USB_EP_DIR_OUT)) != NULL) {
 741                 scsa2usbp->scsa2usb_bulkout_ept = ep_data->ep_descr;
 742         }
 743         if ((ep_data = usb_lookup_ep_data(dip, dev_data, interface, 0, 0,
 744             USB_EP_ATTR_BULK, USB_EP_DIR_IN)) != NULL) {
 745                 scsa2usbp->scsa2usb_bulkin_ept = ep_data->ep_descr;
 746         }
 747         if ((ep_data = usb_lookup_ep_data(dip, dev_data, interface, 0, 0,
 748             USB_EP_ATTR_INTR, USB_EP_DIR_IN)) != NULL) {
 749                 scsa2usbp->scsa2usb_intr_ept = ep_data->ep_descr;
 750         }
 751 
 752         /*
 753          * check here for protocol and subclass supported by this driver
 754          *
 755          * first check if conf file has override values
 756          * Note: override values are not used if supplied values are legal
 757          */
 758         scsa2usb_override(scsa2usbp);
 759 
 760         USB_DPRINTF_L3(DPRINT_MASK_SCSA, log_handle,
 761             "protocol=0x%x override=0x%x subclass=0x%x override=0x%x",
 762             scsa2usbp->scsa2usb_intfc_descr.bInterfaceProtocol,
 763             scsa2usbp->scsa2usb_protocol_override,
 764             scsa2usbp->scsa2usb_intfc_descr.bInterfaceSubClass,
 765             scsa2usbp->scsa2usb_subclass_override);
 766 
 767         switch (scsa2usbp->scsa2usb_intfc_descr.bInterfaceProtocol) {
 768         case USB_PROTO_MS_CBI:
 769                 scsa2usbp->scsa2usb_cmd_protocol |= SCSA2USB_CB_PROTOCOL;
 770                 break;
 771         case USB_PROTO_MS_CBI_WC:
 772                 scsa2usbp->scsa2usb_cmd_protocol |= SCSA2USB_CBI_PROTOCOL;
 773                 break;
 774         case USB_PROTO_MS_ISD_1999_SILICN:
 775         case USB_PROTO_MS_BULK_ONLY:
 776                 scsa2usbp->scsa2usb_cmd_protocol |= SCSA2USB_BULK_ONLY_PROTOCOL;
 777                 break;
 778         default:
 779                 if (scsa2usbp->scsa2usb_protocol_override) {
 780                         scsa2usbp->scsa2usb_cmd_protocol |=
 781                             scsa2usbp->scsa2usb_protocol_override;
 782                         USB_DPRINTF_L2(DPRINT_MASK_SCSA, log_handle,
 783                             "overriding protocol %x",
 784                             scsa2usbp->scsa2usb_intfc_descr.bInterfaceProtocol);
 785                         break;
 786                 }
 787 
 788                 USB_DPRINTF_L2(DPRINT_MASK_SCSA, log_handle,
 789                     "unsupported protocol = %x",
 790                     scsa2usbp->scsa2usb_intfc_descr.bInterfaceProtocol);
 791                 mutex_exit(&scsa2usbp->scsa2usb_mutex);
 792 
 793                 goto fail;
 794         }
 795 
 796         switch (scsa2usbp->scsa2usb_intfc_descr.bInterfaceSubClass) {
 797         case USB_SUBCLS_MS_SCSI:                /* transparent SCSI */
 798                 scsa2usbp->scsa2usb_cmd_protocol |= SCSA2USB_SCSI_CMDSET;
 799                 break;
 800         case USB_SUBCLS_MS_SFF8020I:
 801         case USB_SUBCLS_MS_SFF8070I:
 802                 scsa2usbp->scsa2usb_cmd_protocol |= SCSA2USB_ATAPI_CMDSET;
 803                 break;
 804         case USB_SUBCLS_MS_UFI:         /* UFI */
 805                 scsa2usbp->scsa2usb_cmd_protocol |= SCSA2USB_UFI_CMDSET;
 806                 break;
 807         default:
 808                 if (scsa2usbp->scsa2usb_subclass_override) {
 809                         scsa2usbp->scsa2usb_cmd_protocol |=
 810                             scsa2usbp->scsa2usb_subclass_override;
 811                         USB_DPRINTF_L2(DPRINT_MASK_SCSA, log_handle,
 812                             "overriding subclass %x",
 813                             scsa2usbp->scsa2usb_intfc_descr.bInterfaceSubClass);
 814                         break;
 815                 }
 816 
 817                 USB_DPRINTF_L2(DPRINT_MASK_SCSA, log_handle,
 818                     "unsupported subclass = %x",
 819                     scsa2usbp->scsa2usb_intfc_descr.bInterfaceSubClass);
 820                 mutex_exit(&scsa2usbp->scsa2usb_mutex);
 821 
 822                 goto fail;
 823         }
 824 
 825         /* check that we have the right set of endpoint descriptors */
 826         if (SCSA2USB_IS_BULK_ONLY(scsa2usbp) || SCSA2USB_IS_CB(scsa2usbp)) {
 827                 if ((scsa2usbp->scsa2usb_bulkout_ept.bLength == 0) ||
 828                     (scsa2usbp->scsa2usb_bulkin_ept.bLength == 0)) {
 829                         ept_check = B_FALSE;
 830                 }
 831         } else if (SCSA2USB_IS_CBI(scsa2usbp)) {
 832                 if ((scsa2usbp->scsa2usb_bulkout_ept.bLength == 0) ||
 833                     (scsa2usbp->scsa2usb_bulkin_ept.bLength == 0) ||
 834                     (scsa2usbp->scsa2usb_intr_ept.bLength == 0)) {
 835                         ept_check = B_FALSE;
 836                 }
 837         }
 838 
 839         if (ept_check == B_FALSE) {
 840                 USB_DPRINTF_L2(DPRINT_MASK_SCSA, log_handle,
 841                     "scsa2usb%d doesn't support minimum required endpoints",
 842                     instance);
 843                 mutex_exit(&scsa2usbp->scsa2usb_mutex);
 844 
 845                 goto fail;
 846         }
 847 
 848         /*
 849          * Validate the black-listed attributes
 850          */
 851         scsa2usb_validate_attrs(scsa2usbp);
 852 
 853         /* Print the serial number from the registration data */
 854         if (scsa2usbp->scsa2usb_dev_data->dev_serial) {
 855                 USB_DPRINTF_L4(DPRINT_MASK_SCSA,
 856                     scsa2usbp->scsa2usb_log_handle, "Serial Number = %s",
 857                     scsa2usbp->scsa2usb_dev_data->dev_serial);
 858         }
 859 
 860         /*
 861          * Allocate a SCSA transport structure
 862          */
 863         tran = scsi_hba_tran_alloc(dip, SCSI_HBA_CANSLEEP);
 864         scsa2usbp->scsa2usb_tran = tran;
 865 
 866         /*
 867          * initialize transport structure
 868          */
 869         tran->tran_hba_private               = scsa2usbp;
 870         tran->tran_tgt_private               = NULL;
 871         tran->tran_tgt_init          = scsa2usb_scsi_tgt_init;
 872         tran->tran_tgt_probe         = scsa2usb_scsi_tgt_probe;
 873         tran->tran_tgt_free          = scsa2usb_scsi_tgt_free;
 874         tran->tran_start             = scsa2usb_scsi_start;
 875         tran->tran_abort             = scsa2usb_scsi_abort;
 876         tran->tran_reset             = scsa2usb_scsi_reset;
 877         tran->tran_getcap            = scsa2usb_scsi_getcap;
 878         tran->tran_setcap            = scsa2usb_scsi_setcap;
 879         tran->tran_init_pkt          = scsa2usb_scsi_init_pkt;
 880         tran->tran_destroy_pkt               = scsa2usb_scsi_destroy_pkt;
 881         tran->tran_dmafree           = NULL;
 882         tran->tran_sync_pkt          = NULL;
 883         tran->tran_reset_notify              = NULL;
 884         tran->tran_get_bus_addr              = NULL;
 885         tran->tran_get_name          = NULL;
 886         tran->tran_quiesce           = NULL;
 887         tran->tran_unquiesce         = NULL;
 888         tran->tran_bus_reset         = NULL;
 889         tran->tran_add_eventcall     = NULL;
 890         tran->tran_get_eventcookie   = NULL;
 891         tran->tran_post_event                = NULL;
 892         tran->tran_remove_eventcall  = NULL;
 893         tran->tran_bus_config                = scsa2usb_scsi_bus_config;
 894         tran->tran_bus_unconfig              = scsa2usb_scsi_bus_unconfig;
 895 
 896         /*
 897          * register with SCSA as an HBA
 898          * Note that the dma attributes are from parent nexus
 899          */
 900         if (scsi_hba_attach_setup(dip, usba_get_hc_dma_attr(dip), tran, 0)) {
 901                 USB_DPRINTF_L2(DPRINT_MASK_SCSA, log_handle,
 902                     "scsi_hba_attach_setup failed");
 903                 mutex_exit(&scsa2usbp->scsa2usb_mutex);
 904 
 905                 goto fail;
 906         }
 907 
 908         scsa2usbp->scsa2usb_flags |= SCSA2USB_FLAGS_HBA_ATTACH_SETUP;
 909 
 910         /* create minor node */
 911         if (ddi_create_minor_node(dip, "scsa2usb", S_IFCHR,
 912             instance << SCSA2USB_MINOR_INSTANCE_SHIFT,
 913             DDI_NT_SCSI_NEXUS, 0) != DDI_SUCCESS) {
 914                 USB_DPRINTF_L2(DPRINT_MASK_SCSA, scsa2usbp->scsa2usb_log_handle,
 915                     "scsi_attach: ddi_create_minor_node failed");
 916                 mutex_exit(&scsa2usbp->scsa2usb_mutex);
 917 
 918                 goto fail;
 919         }
 920 
 921         /* open pipes and set scsa2usb_flags */
 922         if (scsa2usb_open_usb_pipes(scsa2usbp) == USB_FAILURE) {
 923                 USB_DPRINTF_L2(DPRINT_MASK_SCSA, log_handle,
 924                     "error opening pipes");
 925                 mutex_exit(&scsa2usbp->scsa2usb_mutex);
 926 
 927                 goto fail;
 928         }
 929 
 930         /* set default block size. updated after read cap cmd */
 931         for (lun = 0; lun < SCSA2USB_MAX_LUNS; lun++) {
 932                 scsa2usbp->scsa2usb_lbasize[lun] = DEV_BSIZE;
 933         }
 934 
 935         mutex_exit(&scsa2usbp->scsa2usb_mutex);
 936 
 937         /* initialize PANIC callback */
 938         scsa2usb_panic_callb_init(scsa2usbp);
 939 
 940         /* finally we are all done 'initializing' the device */
 941         mutex_enter(&scsa2usbp->scsa2usb_mutex);
 942         scsa2usbp->scsa2usb_dev_state = USB_DEV_ONLINE;
 943 
 944         /* enable PM, mutex needs to be held across this */
 945         scsa2usb_create_pm_components(dip, scsa2usbp);
 946         mutex_exit(&scsa2usbp->scsa2usb_mutex);
 947 
 948         /* register for connect/disconnect events */
 949         if (usb_register_event_cbs(scsa2usbp->scsa2usb_dip, &scsa2usb_events,
 950             0) != USB_SUCCESS) {
 951                 USB_DPRINTF_L2(DPRINT_MASK_SCSA, log_handle,
 952                     "error cb registering");
 953                 goto fail;
 954         }
 955 
 956         /* free the dev_data tree, we no longer need it */
 957         usb_free_descr_tree(dip, dev_data);
 958 
 959         scsa2usb_pm_idle_component(scsa2usbp);
 960 
 961         /* log the conf file override string if there is one */
 962         if (scsa2usbp->scsa2usb_override_str) {
 963                 USB_DPRINTF_L2(DPRINT_MASK_SCSA, scsa2usbp->scsa2usb_log_handle,
 964                     "scsa2usb.conf override: %s",
 965                     scsa2usbp->scsa2usb_override_str);
 966         }
 967 
 968         if (usb_owns_device(dip)) {
 969                 /* get a ugen handle */
 970                 bzero(&usb_ugen_info, sizeof (usb_ugen_info));
 971                 usb_ugen_info.usb_ugen_flags = 0;
 972                 usb_ugen_info.usb_ugen_minor_node_ugen_bits_mask =
 973                     (dev_t)SCSA2USB_MINOR_UGEN_BITS_MASK;
 974                 usb_ugen_info.usb_ugen_minor_node_instance_mask =
 975                     (dev_t)~SCSA2USB_MINOR_UGEN_BITS_MASK;
 976                 scsa2usbp->scsa2usb_ugen_hdl =
 977                     usb_ugen_get_hdl(dip, &usb_ugen_info);
 978 
 979                 if (usb_ugen_attach(scsa2usbp->scsa2usb_ugen_hdl, cmd) !=
 980                     USB_SUCCESS) {
 981                         USB_DPRINTF_L2(DPRINT_MASK_SCSA,
 982                             scsa2usbp->scsa2usb_log_handle,
 983                             "usb_ugen_attach failed");
 984 
 985                         usb_ugen_release_hdl(scsa2usbp->scsa2usb_ugen_hdl);
 986                         scsa2usbp->scsa2usb_ugen_hdl = NULL;
 987                 }
 988         }
 989 
 990         /* report device */
 991         ddi_report_dev(dip);
 992 
 993         return (DDI_SUCCESS);
 994 
 995 fail:
 996         if (scsa2usbp) {
 997                 (void) scsa2usb_cleanup(dip, scsa2usbp);
 998         }
 999 
1000         return (DDI_FAILURE);
1001 }
1002 
1003 
1004 /*
1005  * scsa2usb_detach:
1006  *      detach or suspend driver instance
1007  */
1008 static int
1009 scsa2usb_detach(dev_info_t *dip, ddi_detach_cmd_t cmd)
1010 {
1011         scsi_hba_tran_t *tran;
1012         scsa2usb_state_t *scsa2usbp;
1013         int rval;
1014 
1015         tran = ddi_get_driver_private(dip);
1016         ASSERT(tran != NULL);
1017 
1018         scsa2usbp = (scsa2usb_state_t *)tran->tran_hba_private;
1019         ASSERT(scsa2usbp);
1020 
1021         USB_DPRINTF_L4(DPRINT_MASK_SCSA, scsa2usbp->scsa2usb_log_handle,
1022             "scsa2usb_detach: dip = 0x%p, cmd = %d", (void *)dip, cmd);
1023 
1024         switch (cmd) {
1025         case DDI_DETACH:
1026 
1027                 if (scsa2usb_cleanup(dip, scsa2usbp) != USB_SUCCESS) {
1028 
1029                         return (DDI_FAILURE);
1030                 }
1031 
1032                 return (DDI_SUCCESS);
1033         case DDI_SUSPEND:
1034                 rval = scsa2usb_cpr_suspend(dip);
1035 
1036                 return ((rval == USB_SUCCESS) ? DDI_SUCCESS : DDI_FAILURE);
1037         default:
1038 
1039                 return (DDI_FAILURE);
1040         }
1041 }
1042 
1043 /*
1044  * ugen support
1045  */
1046 /*
1047  * scsa2usb_ugen_open()
1048  * (all ugen opens and pipe opens are by definition exclusive so it is OK
1049  * to count opens)
1050  */
1051 static int
1052 scsa2usb_ugen_open(dev_t *devp, int flag, int sflag, cred_t *cr)
1053 {
1054         scsa2usb_state_t *scsa2usbp;
1055         int             rval;
1056 
1057         if ((scsa2usbp = ddi_get_soft_state(scsa2usb_statep,
1058             SCSA2USB_MINOR_TO_INSTANCE(getminor(*devp)))) == NULL) {
1059                 /* deferred detach */
1060 
1061                 return (ENXIO);
1062         }
1063 
1064         USB_DPRINTF_L4(DPRINT_MASK_SCSA, scsa2usbp->scsa2usb_log_handle,
1065             "scsa2usb_ugen_open: dev_t=0x%lx", *devp);
1066 
1067         mutex_enter(&scsa2usbp->scsa2usb_mutex);
1068 
1069         /* if this is the first ugen open, check on transport busy */
1070         if (scsa2usbp->scsa2usb_busy_proc != curproc) {
1071                 while (scsa2usbp->scsa2usb_transport_busy ||
1072                     (scsa2usb_all_waitQs_empty(scsa2usbp) !=
1073                     USB_SUCCESS)) {
1074                         rval = cv_wait_sig(
1075                             &scsa2usbp->scsa2usb_transport_busy_cv,
1076                             &scsa2usbp->scsa2usb_mutex);
1077                         if (rval == 0) {
1078                                 mutex_exit(&scsa2usbp->scsa2usb_mutex);
1079 
1080                                 return (EINTR);
1081                         }
1082                 }
1083                 scsa2usbp->scsa2usb_transport_busy++;
1084                 scsa2usbp->scsa2usb_busy_proc = curproc;
1085         }
1086 
1087         scsa2usbp->scsa2usb_ugen_open_count++;
1088 
1089         scsa2usb_raise_power(scsa2usbp);
1090 
1091         scsa2usb_close_usb_pipes(scsa2usbp);
1092 
1093         mutex_exit(&scsa2usbp->scsa2usb_mutex);
1094 
1095         rval = usb_ugen_open(scsa2usbp->scsa2usb_ugen_hdl, devp, flag,
1096             sflag, cr);
1097         if (!rval) {
1098                 /*
1099                  * if usb_ugen_open() succeeded, we'll change the minor number
1100                  * so that we can keep track of every open()/close() issued by
1101                  * the userland processes. We need to pick a minor number that
1102                  * is not used by the ugen framework
1103                  */
1104 
1105                 usb_ugen_hdl_impl_t     *usb_ugen_hdl_impl;
1106                 ugen_state_t            *ugenp;
1107                 int                     ugen_minor, clone;
1108 
1109                 mutex_enter(&scsa2usbp->scsa2usb_mutex);
1110 
1111                 usb_ugen_hdl_impl =
1112                     (usb_ugen_hdl_impl_t *)scsa2usbp->scsa2usb_ugen_hdl;
1113                 ugenp =  usb_ugen_hdl_impl->hdl_ugenp;
1114 
1115                 /* 'clone' is bigger than any ugen minor in use */
1116                 for (clone = ugenp->ug_minor_node_table_index + 1;
1117                     clone < SCSA2USB_MAX_CLONE; clone++) {
1118                         if (!scsa2usbp->scsa2usb_clones[clone])
1119                                 break;
1120                 }
1121 
1122                 if (clone >= SCSA2USB_MAX_CLONE) {
1123                         cmn_err(CE_WARN, "scsa2usb_ugen_open: too many clones");
1124                         rval = EBUSY;
1125                         mutex_exit(&scsa2usbp->scsa2usb_mutex);
1126                         goto open_done;
1127                 }
1128 
1129                 ugen_minor = getminor(*devp) & SCSA2USB_MINOR_UGEN_BITS_MASK;
1130                 *devp = makedevice(getmajor(*devp),
1131                     (scsa2usbp->scsa2usb_instance
1132                     << SCSA2USB_MINOR_INSTANCE_SHIFT)
1133                     + clone);
1134 
1135                 /* save the ugen minor */
1136                 scsa2usbp->scsa2usb_clones[clone] = (uint8_t)ugen_minor;
1137                 USB_DPRINTF_L4(DPRINT_MASK_SCSA, scsa2usbp->scsa2usb_log_handle,
1138                     "scsa2usb_ugen_open: new dev=%lx, old minor=%x",
1139                     *devp, ugen_minor);
1140 
1141                 mutex_exit(&scsa2usbp->scsa2usb_mutex);
1142         }
1143 
1144 open_done:
1145 
1146         if (rval) {
1147                 mutex_enter(&scsa2usbp->scsa2usb_mutex);
1148 
1149                 /* reopen the pipes */
1150                 if (--scsa2usbp->scsa2usb_ugen_open_count == 0) {
1151                         scsa2usbp->scsa2usb_transport_busy--;
1152                         scsa2usbp->scsa2usb_busy_proc = NULL;
1153                         cv_signal(&scsa2usbp->scsa2usb_transport_busy_cv);
1154                 }
1155                 mutex_exit(&scsa2usbp->scsa2usb_mutex);
1156 
1157                 scsa2usb_pm_idle_component(scsa2usbp);
1158         }
1159 
1160         return (rval);
1161 }
1162 
1163 
1164 /*
1165  * scsa2usb_ugen_close()
1166  */
1167 static int
1168 scsa2usb_ugen_close(dev_t dev, int flag, int otype, cred_t *cr)
1169 {
1170         int rval;
1171         int     ugen_minor, clone;
1172 
1173         scsa2usb_state_t *scsa2usbp = ddi_get_soft_state(scsa2usb_statep,
1174             SCSA2USB_MINOR_TO_INSTANCE(getminor(dev)));
1175 
1176         if (scsa2usbp == NULL) {
1177 
1178                 return (ENXIO);
1179         }
1180 
1181         USB_DPRINTF_L4(DPRINT_MASK_SCSA, scsa2usbp->scsa2usb_log_handle,
1182             "scsa2usb_ugen_close: dev_t=0x%lx", dev);
1183 
1184         clone = getminor(dev) & SCSA2USB_MINOR_UGEN_BITS_MASK;
1185         ugen_minor = scsa2usbp->scsa2usb_clones[clone];
1186         dev = makedevice(getmajor(dev),
1187             (scsa2usbp->scsa2usb_instance << SCSA2USB_MINOR_INSTANCE_SHIFT)
1188             + ugen_minor);
1189         USB_DPRINTF_L4(DPRINT_MASK_SCSA, scsa2usbp->scsa2usb_log_handle,
1190             "scsa2usb_ugen_close: old dev=%lx", dev);
1191         rval = usb_ugen_close(scsa2usbp->scsa2usb_ugen_hdl, dev, flag,
1192             otype, cr);
1193 
1194         if (rval == 0) {
1195                 mutex_enter(&scsa2usbp->scsa2usb_mutex);
1196 
1197                 scsa2usbp->scsa2usb_clones[clone] = 0;
1198                 /* reopen the pipes */
1199                 if (--scsa2usbp->scsa2usb_ugen_open_count == 0) {
1200                         scsa2usbp->scsa2usb_transport_busy--;
1201                         scsa2usbp->scsa2usb_busy_proc = NULL;
1202                         cv_signal(&scsa2usbp->scsa2usb_transport_busy_cv);
1203                 }
1204                 mutex_exit(&scsa2usbp->scsa2usb_mutex);
1205 
1206                 scsa2usb_pm_idle_component(scsa2usbp);
1207         }
1208 
1209         return (rval);
1210 }
1211 
1212 
1213 /*
1214  * scsa2usb_ugen_read/write()
1215  */
1216 /*ARGSUSED*/
1217 static int
1218 scsa2usb_ugen_read(dev_t dev, struct uio *uiop, cred_t *credp)
1219 {
1220         int clone, ugen_minor;
1221         scsa2usb_state_t *scsa2usbp = ddi_get_soft_state(scsa2usb_statep,
1222             SCSA2USB_MINOR_TO_INSTANCE(getminor(dev)));
1223 
1224         if (scsa2usbp == NULL) {
1225 
1226                 return (ENXIO);
1227         }
1228 
1229         USB_DPRINTF_L4(DPRINT_MASK_SCSA, scsa2usbp->scsa2usb_log_handle,
1230             "scsa2usb_ugen_read: dev_t=0x%lx", dev);
1231 
1232         clone = getminor(dev) & SCSA2USB_MINOR_UGEN_BITS_MASK;
1233         ugen_minor = scsa2usbp->scsa2usb_clones[clone];
1234         dev = makedevice(getmajor(dev),
1235             (scsa2usbp->scsa2usb_instance << SCSA2USB_MINOR_INSTANCE_SHIFT)
1236             + ugen_minor);
1237 
1238         return (usb_ugen_read(scsa2usbp->scsa2usb_ugen_hdl, dev,
1239             uiop, credp));
1240 }
1241 
1242 
1243 /*ARGSUSED*/
1244 static int
1245 scsa2usb_ugen_write(dev_t dev, struct uio *uiop, cred_t *credp)
1246 {
1247         int clone, ugen_minor;
1248         scsa2usb_state_t *scsa2usbp = ddi_get_soft_state(scsa2usb_statep,
1249             SCSA2USB_MINOR_TO_INSTANCE(getminor(dev)));
1250 
1251         if (scsa2usbp == NULL) {
1252 
1253                 return (ENXIO);
1254         }
1255 
1256         USB_DPRINTF_L4(DPRINT_MASK_SCSA, scsa2usbp->scsa2usb_log_handle,
1257             "scsa2usb_ugen_write: dev_t=0x%lx", dev);
1258 
1259         clone = getminor(dev) & SCSA2USB_MINOR_UGEN_BITS_MASK;
1260         ugen_minor = scsa2usbp->scsa2usb_clones[clone];
1261         dev = makedevice(getmajor(dev),
1262             (scsa2usbp->scsa2usb_instance << SCSA2USB_MINOR_INSTANCE_SHIFT)
1263             + ugen_minor);
1264 
1265         return (usb_ugen_write(scsa2usbp->scsa2usb_ugen_hdl,
1266             dev, uiop, credp));
1267 }
1268 
1269 
1270 /*
1271  * scsa2usb_ugen_poll
1272  */
1273 static int
1274 scsa2usb_ugen_poll(dev_t dev, short events,
1275     int anyyet,  short *reventsp, struct pollhead **phpp)
1276 {
1277         int clone, ugen_minor;
1278         scsa2usb_state_t *scsa2usbp = ddi_get_soft_state(scsa2usb_statep,
1279             SCSA2USB_MINOR_TO_INSTANCE(getminor(dev)));
1280 
1281         if (scsa2usbp == NULL) {
1282 
1283                 return (ENXIO);
1284         }
1285 
1286         USB_DPRINTF_L4(DPRINT_MASK_SCSA, scsa2usbp->scsa2usb_log_handle,
1287             "scsa2usb_ugen_poll: dev_t=0x%lx", dev);
1288 
1289         clone = getminor(dev) & SCSA2USB_MINOR_UGEN_BITS_MASK;
1290         ugen_minor = scsa2usbp->scsa2usb_clones[clone];
1291         dev = makedevice(getmajor(dev),
1292             (scsa2usbp->scsa2usb_instance << SCSA2USB_MINOR_INSTANCE_SHIFT)
1293             + ugen_minor);
1294 
1295         return (usb_ugen_poll(scsa2usbp->scsa2usb_ugen_hdl, dev, events,
1296             anyyet, reventsp, phpp));
1297 }
1298 
1299 
1300 /*
1301  * scsa2usb_cleanup:
1302  *      cleanup whatever attach has setup
1303  */
1304 static int
1305 scsa2usb_cleanup(dev_info_t *dip, scsa2usb_state_t *scsa2usbp)
1306 {
1307         int             rval, i;
1308         scsa2usb_power_t *pm;
1309         uint_t          lun;
1310 
1311         USB_DPRINTF_L4(DPRINT_MASK_SCSA, scsa2usbp->scsa2usb_log_handle,
1312             "scsa2usb_cleanup:");
1313 
1314         /* wait till the work thread is done */
1315         mutex_enter(&scsa2usbp->scsa2usb_mutex);
1316         for (i = 0; i < SCSA2USB_DRAIN_TIMEOUT; i++) {
1317                 if (scsa2usbp->scsa2usb_work_thread_id == NULL) {
1318 
1319                         break;
1320                 }
1321                 mutex_exit(&scsa2usbp->scsa2usb_mutex);
1322                 delay(drv_sectohz(1));
1323                 mutex_enter(&scsa2usbp->scsa2usb_mutex);
1324         }
1325         mutex_exit(&scsa2usbp->scsa2usb_mutex);
1326 
1327         if (i >= SCSA2USB_DRAIN_TIMEOUT) {
1328 
1329                 return (USB_FAILURE);
1330         }
1331 
1332         /*
1333          * Disable the event callbacks first, after this point, event
1334          * callbacks will never get called. Note we shouldn't hold
1335          * mutex while unregistering events because there may be a
1336          * competing event callback thread. Event callbacks are done
1337          * with ndi mutex held and this can cause a potential deadlock.
1338          */
1339         usb_unregister_event_cbs(scsa2usbp->scsa2usb_dip, &scsa2usb_events);
1340 
1341         if (scsa2usbp->scsa2usb_flags & SCSA2USB_FLAGS_LOCKS_INIT) {
1342                 /*
1343                  * if a waitQ exists, get rid of it before destroying it
1344                  */
1345                 for (lun = 0; lun < SCSA2USB_MAX_LUNS; lun++) {
1346                         scsa2usb_flush_waitQ(scsa2usbp, lun, CMD_TRAN_ERR);
1347                         usba_destroy_list(&scsa2usbp->scsa2usb_waitQ[lun]);
1348                 }
1349 
1350                 mutex_enter(&scsa2usbp->scsa2usb_mutex);
1351                 if (scsa2usbp->scsa2usb_flags &
1352                     SCSA2USB_FLAGS_HBA_ATTACH_SETUP) {
1353                         (void) scsi_hba_detach(dip);
1354                         scsi_hba_tran_free(scsa2usbp->scsa2usb_tran);
1355                 }
1356 
1357                 if (scsa2usbp->scsa2usb_flags &
1358                     SCSA2USB_FLAGS_PIPES_OPENED) {
1359                         scsa2usb_close_usb_pipes(scsa2usbp);
1360                 }
1361 
1362                 /* Lower the power */
1363                 pm = scsa2usbp->scsa2usb_pm;
1364 
1365                 if (pm && (scsa2usbp->scsa2usb_dev_state !=
1366                     USB_DEV_DISCONNECTED)) {
1367                         if (pm->scsa2usb_wakeup_enabled) {
1368                                 mutex_exit(&scsa2usbp->scsa2usb_mutex);
1369                                 (void) pm_raise_power(dip, 0,
1370                                     USB_DEV_OS_FULL_PWR);
1371 
1372                                 if ((rval = usb_handle_remote_wakeup(dip,
1373                                     USB_REMOTE_WAKEUP_DISABLE)) !=
1374                                     USB_SUCCESS) {
1375                                         USB_DPRINTF_L2(DPRINT_MASK_SCSA,
1376                                             scsa2usbp->scsa2usb_log_handle,
1377                                             "disable remote wakeup failed "
1378                                             "(%d)", rval);
1379                                 }
1380                         } else {
1381                                 mutex_exit(&scsa2usbp->scsa2usb_mutex);
1382                         }
1383 
1384                         (void) pm_lower_power(dip, 0, USB_DEV_OS_PWR_OFF);
1385 
1386                         mutex_enter(&scsa2usbp->scsa2usb_mutex);
1387                 }
1388 
1389                 if (pm) {
1390                         kmem_free(pm, sizeof (scsa2usb_power_t));
1391                 }
1392 
1393                 if (scsa2usbp->scsa2usb_override_str) {
1394                         kmem_free(scsa2usbp->scsa2usb_override_str,
1395                             strlen(scsa2usbp->scsa2usb_override_str) + 1);
1396                         scsa2usbp->scsa2usb_override_str = NULL;
1397                 }
1398 
1399                 /* remove the minor nodes */
1400                 ddi_remove_minor_node(dip, NULL);
1401 
1402                 /* Cancel the registered panic callback */
1403                 scsa2usb_panic_callb_fini(scsa2usbp);
1404 
1405                 mutex_exit(&scsa2usbp->scsa2usb_mutex);
1406 
1407                 mutex_destroy(&scsa2usbp->scsa2usb_mutex);
1408                 cv_destroy(&scsa2usbp->scsa2usb_transport_busy_cv);
1409         }
1410 
1411         usb_client_detach(scsa2usbp->scsa2usb_dip,
1412             scsa2usbp->scsa2usb_dev_data);
1413 
1414         if (scsa2usbp->scsa2usb_ugen_hdl) {
1415                 (void) usb_ugen_detach(scsa2usbp->scsa2usb_ugen_hdl,
1416                     DDI_DETACH);
1417                 usb_ugen_release_hdl(scsa2usbp->scsa2usb_ugen_hdl);
1418         }
1419 
1420         usb_free_log_hdl(scsa2usbp->scsa2usb_log_handle);
1421 
1422         ddi_prop_remove_all(dip);
1423 
1424         ddi_soft_state_free(scsa2usb_statep, ddi_get_instance(dip));
1425 
1426         return (USB_SUCCESS);
1427 }
1428 
1429 
1430 /*
1431  * scsa2usb_override:
1432  *      some devices may be attached even though their subclass or
1433  *      protocol info is not according to spec.
1434  *      these can be determined by the 'subclass-protocol-override'
1435  *      property set in the conf file.
1436  */
1437 static void
1438 scsa2usb_override(scsa2usb_state_t *scsa2usbp)
1439 {
1440         scsa2usb_ov_t ov;
1441         char    **override_str = NULL;
1442         char    *override_str_cpy;
1443         uint_t  override_str_len, override_str_cpy_len;
1444         uint_t  i;
1445         usb_dev_descr_t *descr = scsa2usbp->scsa2usb_dev_data->dev_descr;
1446 
1447         ASSERT(mutex_owned(&scsa2usbp->scsa2usb_mutex));
1448 
1449         scsa2usbp->scsa2usb_subclass_override =
1450             scsa2usbp->scsa2usb_protocol_override = 0;
1451 
1452         if (ddi_prop_lookup_string_array(DDI_DEV_T_ANY, scsa2usbp->scsa2usb_dip,
1453             DDI_PROP_DONTPASS, "attribute-override-list",
1454             &override_str, &override_str_len) != DDI_PROP_SUCCESS) {
1455 
1456                 return;
1457         }
1458 
1459         /* parse each string in the subclass-protocol-override property */
1460         for (i = 0; i < override_str_len; i++) {
1461 
1462                 USB_DPRINTF_L4(DPRINT_MASK_SCSA, scsa2usbp->scsa2usb_log_handle,
1463                     "override_str[%d] = %s", i, override_str[i]);
1464 
1465                 /*
1466                  * save a copy of the override string for possible
1467                  * inclusion in soft state later
1468                  */
1469                 override_str_cpy_len = strlen(override_str[i]) + 1;
1470                 override_str_cpy = kmem_zalloc(override_str_cpy_len, KM_SLEEP);
1471                 (void) strcpy(override_str_cpy, override_str[i]);
1472 
1473                 bzero(&ov, sizeof (scsa2usb_ov_t));
1474 
1475                 if (scsa2usb_parse_input_str(override_str[i], &ov,
1476                     scsa2usbp) == USB_FAILURE) {
1477                         kmem_free(override_str_cpy, override_str_cpy_len);
1478                         continue;
1479                 }
1480 
1481                 /*
1482                  * see if subclass/protocol needs to be overridden for device
1483                  * or if device should not be power managed
1484                  * if there'a a match, save the override string in soft state
1485                  */
1486                 if (((descr->idVendor == (uint16_t)ov.vid) || (ov.vid == 0)) &&
1487                     ((descr->idProduct == (uint16_t)ov.pid) || (ov.pid == 0)) &&
1488                     ((descr->bcdDevice == (uint16_t)ov.rev) || (ov.rev == 0))) {
1489                         scsa2usbp->scsa2usb_subclass_override = ov.subclass;
1490                         scsa2usbp->scsa2usb_protocol_override = ov.protocol;
1491 
1492                         USB_DPRINTF_L2(DPRINT_MASK_SCSA,
1493                             scsa2usbp->scsa2usb_log_handle,
1494                             "vid=0x%x pid=0x%x rev=0x%x subclass=0x%x "
1495                             "protocol=0x%x "
1496                             "pmoff=%d fake_removable=%d modesense=%d "
1497                             "reduced-cmd-support=%d",
1498                             ov.vid, ov.pid, ov.rev, ov.subclass, ov.protocol,
1499                             ov.pmoff, ov.fake_removable, ov.no_modesense,
1500                             ov.reduced_cmd_support);
1501 
1502                         if (ov.pmoff) {
1503                                 scsa2usbp->scsa2usb_attrs &= ~SCSA2USB_ATTRS_PM;
1504                         }
1505                         if (ov.fake_removable) {
1506                                 scsa2usbp->scsa2usb_attrs &=
1507                                     ~SCSA2USB_ATTRS_RMB;
1508                         }
1509                         if (ov.no_modesense) {
1510                                 scsa2usbp->scsa2usb_attrs &=
1511                                     ~SCSA2USB_ATTRS_MODE_SENSE;
1512                         }
1513                         if (ov.reduced_cmd_support) {
1514                                 scsa2usbp->scsa2usb_attrs &=
1515                                     ~SCSA2USB_ATTRS_REDUCED_CMD;
1516                         }
1517                         scsa2usbp->scsa2usb_override_str = override_str_cpy;
1518                         break;
1519                 } else {
1520                         kmem_free(override_str_cpy, override_str_cpy_len);
1521                 }
1522         }
1523 
1524         ddi_prop_free(override_str);
1525 }
1526 
1527 
1528 /*
1529  * scsa2usb_parse_input_str:
1530  *      parse one conf file subclass-protocol-override string
1531  *      return vendor id, product id, revision, subclass, protocol
1532  *      function return is success or failure
1533  */
1534 static int
1535 scsa2usb_parse_input_str(char *str, scsa2usb_ov_t *ovp,
1536     scsa2usb_state_t *scsa2usbp)
1537 {
1538         char            *input_field, *input_value;
1539         char            *lasts;
1540         uint_t          i;
1541         u_longlong_t    value;
1542 
1543         /* parse all the input pairs in the string */
1544         for (input_field = scsa2usb_strtok_r(str, "=", &lasts);
1545             input_field != NULL;
1546             input_field = scsa2usb_strtok_r(lasts, "=", &lasts)) {
1547 
1548                 if ((input_value = scsa2usb_strtok_r(lasts, " ", &lasts)) ==
1549                     NULL) {
1550                         scsa2usb_override_error("format", scsa2usbp);
1551 
1552                         return (USB_FAILURE);
1553                 }
1554                 /* if input value is a 'don't care', skip to the next pair */
1555                 if (strcmp(input_value, "*") == 0) {
1556                         continue;
1557                 }
1558                 if (strcasecmp(input_field, "vid") == 0) {
1559                         if (kobj_getvalue(input_value, &value) == -1) {
1560                                 scsa2usb_override_error("vendor id", scsa2usbp);
1561 
1562                                 return (USB_FAILURE);
1563                         }
1564                         ovp->vid = (int)value;
1565                 } else if (strcasecmp(input_field, "pid") == 0) {
1566                         if (kobj_getvalue(input_value, &value) == -1) {
1567                                 scsa2usb_override_error("product id",
1568                                     scsa2usbp);
1569 
1570                                 return (USB_FAILURE);
1571                         }
1572                         ovp->pid = (int)value;
1573                 } else if (strcasecmp(input_field, "rev") == 0) {
1574                         if (kobj_getvalue(input_value, &value) == -1) {
1575                                 scsa2usb_override_error("revision id",
1576                                     scsa2usbp);
1577 
1578                                 return (USB_FAILURE);
1579                         }
1580                         ovp->rev = (int)value;
1581                 } else if (strcasecmp(input_field, "subclass") == 0) {
1582                         for (i = 0; i < N_SCSA2USB_SUBC_OVERRIDE; i++) {
1583                                 if (strcasecmp(input_value,
1584                                     scsa2usb_subclass[i].name) == 0) {
1585                                         ovp->subclass =
1586                                             scsa2usb_subclass[i].value;
1587                                         break;
1588                                 }
1589                         }
1590                         if (ovp->subclass == 0) {
1591                                 scsa2usb_override_error("subclass", scsa2usbp);
1592 
1593                                 return (USB_FAILURE);
1594                         }
1595                 } else if (strcasecmp(input_field, "protocol") == 0) {
1596                         for (i = 0; i < N_SCSA2USB_PROT_OVERRIDE; i++) {
1597                                 if (strcasecmp(input_value,
1598                                     scsa2usb_protocol[i].name) == 0) {
1599                                         ovp->protocol =
1600                                             scsa2usb_protocol[i].value;
1601                                         break;
1602                                 }
1603                         }
1604                         if (ovp->protocol == 0) {
1605                                 scsa2usb_override_error("protocol", scsa2usbp);
1606 
1607                                 return (USB_FAILURE);
1608                         }
1609                 } else if (strcasecmp(input_field, "pm") == 0) {
1610                         if (strcasecmp(input_value, "off") == 0) {
1611                                 ovp->pmoff = 1;
1612                                 break;
1613                         } else {
1614                                 scsa2usb_override_error("pm", scsa2usbp);
1615 
1616                                 return (USB_FAILURE);
1617                         }
1618                 } else if (strcasecmp(input_field, "removable") == 0) {
1619                         if (strcasecmp(input_value, "true") == 0) {
1620                                 ovp->fake_removable = 1;
1621                                 break;
1622                         } else {
1623                                 scsa2usb_override_error("removable", scsa2usbp);
1624 
1625                                 return (USB_FAILURE);
1626                         }
1627                 } else if (strcasecmp(input_field, "modesense") == 0) {
1628                         if (strcasecmp(input_value, "false") == 0) {
1629                                 ovp->no_modesense = 1;
1630                                 break;
1631                         } else {
1632                                 scsa2usb_override_error("modesense",
1633                                     scsa2usbp);
1634 
1635                                 return (USB_FAILURE);
1636                         }
1637                 } else if (strcasecmp(input_field,
1638                     "reduced-cmd-support") == 0) {
1639                         if (strcasecmp(input_value, "true") == 0) {
1640                                 ovp->reduced_cmd_support = 1;
1641                                 break;
1642                         } else {
1643                                 scsa2usb_override_error(
1644                                     "reduced-cmd-support", scsa2usbp);
1645 
1646                                 return (USB_FAILURE);
1647                         }
1648                 } else {
1649                         scsa2usb_override_error(input_field, scsa2usbp);
1650 
1651                         return (USB_FAILURE);
1652                 }
1653         }
1654 
1655         return (USB_SUCCESS);
1656 }
1657 
1658 
1659 /*
1660  * scsa2usb_override_error:
1661  *      print an error message if conf file string is bad format
1662  */
1663 static void
1664 scsa2usb_override_error(char *input_field, scsa2usb_state_t *scsa2usbp)
1665 {
1666         USB_DPRINTF_L1(DPRINT_MASK_SCSA, scsa2usbp->scsa2usb_log_handle,
1667             "invalid %s in scsa2usb.conf file entry", input_field);
1668 }
1669 
1670 /*
1671  * scsa2usb_strtok_r:
1672  *      parse a list of tokens
1673  */
1674 static char *
1675 scsa2usb_strtok_r(char *p, char *sep, char **lasts)
1676 {
1677         char    *e;
1678         char    *tok = NULL;
1679 
1680         if (p == 0 || *p == 0) {
1681 
1682                 return (NULL);
1683         }
1684 
1685         e = p+strlen(p);
1686 
1687         do {
1688                 if (strchr(sep, *p) != NULL) {
1689                         if (tok != NULL) {
1690                                 *p = 0;
1691                                 *lasts = p+1;
1692 
1693                                 return (tok);
1694                         }
1695                 } else if (tok == NULL) {
1696                         tok = p;
1697                 }
1698         } while (++p < e);
1699 
1700         *lasts = NULL;
1701 
1702         return (tok);
1703 }
1704 
1705 
1706 /*
1707  * scsa2usb_validate_attrs:
1708  *      many devices have BO/CB/CBI protocol support issues.
1709  *      use vendor/product info to reset the
1710  *      individual erroneous attributes
1711  *
1712  * NOTE: we look at only device at a time (at attach time)
1713  */
1714 static void
1715 scsa2usb_validate_attrs(scsa2usb_state_t *scsa2usbp)
1716 {
1717         int i, mask;
1718         usb_dev_descr_t *desc = scsa2usbp->scsa2usb_dev_data->dev_descr;
1719 
1720         if (!SCSA2USB_IS_BULK_ONLY(scsa2usbp)) {
1721                 scsa2usbp->scsa2usb_attrs &= ~SCSA2USB_ATTRS_GET_LUN;
1722         }
1723 
1724         /* determine if this device is on the blacklist */
1725         for (i = 0; i < N_SCSA2USB_BLACKLIST; i++) {
1726                 if ((scsa2usb_blacklist[i].idVendor == desc->idVendor) &&
1727                     ((scsa2usb_blacklist[i].idProduct == desc->idProduct) ||
1728                     (scsa2usb_blacklist[i].idProduct == X))) {
1729                         scsa2usbp->scsa2usb_attrs &=
1730                             ~(scsa2usb_blacklist[i].attributes);
1731                         break;
1732                 }
1733         }
1734 
1735         /*
1736          * Mitsumi's CD-RW drives subclass isn't UFI.
1737          * But they support UFI command-set (this code ensures that)
1738          * NOTE: This is a special case, and is being called out so.
1739          */
1740         if (desc->idVendor == MS_MITSUMI_VID) {
1741                 mask = scsa2usbp->scsa2usb_cmd_protocol & SCSA2USB_CMDSET_MASK;
1742                 if (mask) {
1743                         scsa2usbp->scsa2usb_cmd_protocol &= ~mask;
1744                 }
1745                 scsa2usbp->scsa2usb_cmd_protocol |= SCSA2USB_UFI_CMDSET;
1746         }
1747 
1748         if (scsa2usbp->scsa2usb_attrs != SCSA2USB_ALL_ATTRS) {
1749                 USB_DPRINTF_L2(DPRINT_MASK_SCSA,
1750                     scsa2usbp->scsa2usb_log_handle,
1751                     "scsa2usb attributes modified: 0x%x",
1752                     scsa2usbp->scsa2usb_attrs);
1753         }
1754 }
1755 
1756 
1757 /*
1758  * scsa2usb_create_luns:
1759  *      check the number of luns but continue if the check fails,
1760  *      create child nodes for each lun
1761  */
1762 static void
1763 scsa2usb_create_luns(scsa2usb_state_t *scsa2usbp)
1764 {
1765         int             lun, rval;
1766         char            *compatible[MAX_COMPAT_NAMES];  /* compatible names */
1767         dev_info_t      *cdip;
1768         uchar_t         dtype;
1769         char            *node_name;
1770         char            *driver_name = NULL;
1771 
1772         USB_DPRINTF_L4(DPRINT_MASK_SCSA, scsa2usbp->scsa2usb_log_handle,
1773             "scsa2usb_create_luns:");
1774 
1775         mutex_enter(&scsa2usbp->scsa2usb_mutex);
1776 
1777         /* Set n_luns to 1 by default (for floppies and other devices) */
1778         scsa2usbp->scsa2usb_n_luns = 1;
1779 
1780         /*
1781          * Check if there are any device out there which don't
1782          * support the GET_MAX_LUN command. If so, don't issue
1783          * control request to them.
1784          */
1785         if ((scsa2usbp->scsa2usb_attrs & SCSA2USB_ATTRS_GET_LUN) == 0) {
1786                 USB_DPRINTF_L2(DPRINT_MASK_SCSA, scsa2usbp->scsa2usb_log_handle,
1787                     "get_max_lun cmd not supported");
1788         } else {
1789                 if (SCSA2USB_IS_BULK_ONLY(scsa2usbp)) {
1790                         scsa2usbp->scsa2usb_n_luns =
1791                             scsa2usb_bulk_only_get_max_lun(scsa2usbp);
1792                 }
1793         }
1794 
1795         USB_DPRINTF_L3(DPRINT_MASK_SCSA, scsa2usbp->scsa2usb_log_handle,
1796             "scsa2usb_create_luns: %d luns found", scsa2usbp->scsa2usb_n_luns);
1797 
1798         /*
1799          * create disk child for each lun
1800          */
1801         for (lun = 0; lun < scsa2usbp->scsa2usb_n_luns; lun++) {
1802                 ASSERT(scsa2usbp->scsa2usb_lun_dip[lun] == NULL);
1803 
1804                 /* do an inquiry to get the dtype of this lun */
1805                 scsa2usb_do_inquiry(scsa2usbp, 0, lun);
1806 
1807                 dtype = scsa2usbp->scsa2usb_lun_inquiry[lun].
1808                     inq_dtype & DTYPE_MASK;
1809 
1810                 USB_DPRINTF_L3(DPRINT_MASK_SCSA, scsa2usbp->scsa2usb_log_handle,
1811                     "dtype[%d]=0x%x", lun, dtype);
1812 
1813                 driver_name = NULL;
1814 
1815                 switch (dtype) {
1816                 case DTYPE_DIRECT:
1817                 case DTYPE_RODIRECT:
1818                 case DTYPE_OPTICAL:
1819                         node_name = "disk";
1820                         driver_name = "sd";
1821 
1822                         break;
1823                 case DTYPE_SEQUENTIAL:
1824                         node_name = "tape";
1825                         driver_name = "st";
1826 
1827                         break;
1828                 case DTYPE_PRINTER:
1829                         node_name = "printer";
1830 
1831                         break;
1832                 case DTYPE_PROCESSOR:
1833                         node_name = "processor";
1834 
1835                         break;
1836                 case DTYPE_WORM:
1837                         node_name = "worm";
1838 
1839                         break;
1840                 case DTYPE_SCANNER:
1841                         node_name = "scanner";
1842 
1843                         break;
1844                 case DTYPE_CHANGER:
1845                         node_name = "changer";
1846 
1847                         break;
1848                 case DTYPE_COMM:
1849                         node_name = "comm";
1850 
1851                         break;
1852                 case DTYPE_ARRAY_CTRL:
1853                         node_name = "array_ctrl";
1854 
1855                         break;
1856                 case DTYPE_ESI:
1857                         node_name = "esi";
1858                         driver_name = "ses";
1859 
1860                         break;
1861                 default:
1862                         node_name = "generic";
1863 
1864                         break;
1865                 }
1866 
1867                 if (driver_name) {
1868                         compatible[0] = driver_name;
1869                 }
1870 
1871                 ndi_devi_alloc_sleep(scsa2usbp->scsa2usb_dip, node_name,
1872                     (pnode_t)DEVI_SID_NODEID, &cdip);
1873 
1874                 /* attach target & lun properties */
1875                 rval = ndi_prop_update_int(DDI_DEV_T_NONE, cdip, "target", 0);
1876                 if (rval != DDI_PROP_SUCCESS) {
1877                         USB_DPRINTF_L2(DPRINT_MASK_SCSA,
1878                             scsa2usbp->scsa2usb_log_handle,
1879                             "ndi_prop_update_int target failed %d", rval);
1880                         (void) ndi_devi_free(cdip);
1881                         continue;
1882                 }
1883 
1884                 rval = ndi_prop_create_boolean(DDI_DEV_T_NONE, cdip,
1885                     "hotpluggable");
1886                 if (rval != DDI_PROP_SUCCESS) {
1887                         USB_DPRINTF_L2(DPRINT_MASK_SCSA,
1888                             scsa2usbp->scsa2usb_log_handle,
1889                             "ndi_prop_create_boolean hotpluggable failed %d",
1890                             rval);
1891                         ddi_prop_remove_all(cdip);
1892                         (void) ndi_devi_free(cdip);
1893                         continue;
1894                 }
1895                 /*
1896                  * Some devices don't support LOG SENSE, so tells
1897                  * sd driver not to send this command.
1898                  */
1899                 rval = ndi_prop_update_int(DDI_DEV_T_NONE, cdip,
1900                     "pm-capable", 1);
1901                 if (rval != DDI_PROP_SUCCESS) {
1902                         USB_DPRINTF_L2(DPRINT_MASK_SCSA,
1903                             scsa2usbp->scsa2usb_log_handle,
1904                             "ndi_prop_update_int pm-capable failed %d", rval);
1905                         ddi_prop_remove_all(cdip);
1906                         (void) ndi_devi_free(cdip);
1907                         continue;
1908                 }
1909 
1910                 rval = ndi_prop_update_int(DDI_DEV_T_NONE, cdip, "lun", lun);
1911                 if (rval != DDI_PROP_SUCCESS) {
1912                         USB_DPRINTF_L2(DPRINT_MASK_SCSA,
1913                             scsa2usbp->scsa2usb_log_handle,
1914                             "ndi_prop_update_int lun failed %d", rval);
1915                         ddi_prop_remove_all(cdip);
1916                         (void) ndi_devi_free(cdip);
1917                         continue;
1918                 }
1919 
1920                 if (driver_name) {
1921                         rval = ndi_prop_update_string_array(DDI_DEV_T_NONE,
1922                             cdip, "compatible", (char **)compatible,
1923                             MAX_COMPAT_NAMES);
1924                         if (rval != DDI_PROP_SUCCESS) {
1925                                 USB_DPRINTF_L2(DPRINT_MASK_SCSA,
1926                                     scsa2usbp->scsa2usb_log_handle,
1927                                     "ndi_prop_update_string_array failed %d",
1928                                     rval);
1929                                 ddi_prop_remove_all(cdip);
1930                                 (void) ndi_devi_free(cdip);
1931                                 continue;
1932                         }
1933                 }
1934 
1935                 /*
1936                  * add property "usb" so we always verify that it is our child
1937                  */
1938                 rval = ndi_prop_create_boolean(DDI_DEV_T_NONE, cdip, "usb");
1939                 if (rval != DDI_PROP_SUCCESS) {
1940                         USB_DPRINTF_L2(DPRINT_MASK_SCSA,
1941                             scsa2usbp->scsa2usb_log_handle,
1942                             "ndi_prop_create_boolean failed %d", rval);
1943                         ddi_prop_remove_all(cdip);
1944                         (void) ndi_devi_free(cdip);
1945                         continue;
1946                 }
1947 
1948                 mutex_exit(&scsa2usbp->scsa2usb_mutex);
1949                 (void) ddi_initchild(scsa2usbp->scsa2usb_dip, cdip);
1950                 mutex_enter(&scsa2usbp->scsa2usb_mutex);
1951 
1952                 usba_set_usba_device(cdip,
1953                     usba_get_usba_device(scsa2usbp->scsa2usb_dip));
1954         }
1955         mutex_exit(&scsa2usbp->scsa2usb_mutex);
1956 }
1957 
1958 
1959 /*
1960  * scsa2usb_is_usb:
1961  *      scsa2usb gets called for all possible sd children.
1962  *      we can only accept usb children
1963  */
1964 static int
1965 scsa2usb_is_usb(dev_info_t *dip)
1966 {
1967         if (dip) {
1968                 return (ddi_prop_exists(DDI_DEV_T_ANY, dip,
1969                     DDI_PROP_DONTPASS, "usb"));
1970         }
1971         return (0);
1972 }
1973 
1974 
1975 /*
1976  * Panic Stuff
1977  * scsa2usb_panic_callb_init:
1978  *      initialize PANIC callb and free allocated resources
1979  */
1980 static void
1981 scsa2usb_panic_callb_init(scsa2usb_state_t *scsa2usbp)
1982 {
1983         /*
1984          * In case the system panics, the sync command flushes
1985          * dirty FS pages or buffers. This would cause a hang
1986          * in USB.
1987          * The reason for the failure is that we enter
1988          * polled mode (interrupts disabled) and HCD gets stuck
1989          * trying to execute bulk requests
1990          * The panic_callback registered below provides a warning
1991          * that a panic has occurred and from that point onwards, we
1992          * complete each request successfully and immediately. This
1993          * will fake successful syncing so at least the rest of the
1994          * filesystems complete syncing.
1995          */
1996         scsa2usbp->scsa2usb_panic_info =
1997             kmem_zalloc(sizeof (scsa2usb_cpr_t), KM_SLEEP);
1998         mutex_init(&scsa2usbp->scsa2usb_panic_info->lockp,
1999             NULL, MUTEX_DRIVER,
2000             scsa2usbp->scsa2usb_dev_data->dev_iblock_cookie);
2001         scsa2usbp->scsa2usb_panic_info->statep = scsa2usbp;
2002         scsa2usbp->scsa2usb_panic_info->cpr.cc_lockp =
2003             &scsa2usbp->scsa2usb_panic_info->lockp;
2004         scsa2usbp->scsa2usb_panic_info->cpr.cc_id =
2005             callb_add(scsa2usb_panic_callb,
2006             (void *)scsa2usbp->scsa2usb_panic_info,
2007             CB_CL_PANIC, "scsa2usb");
2008 }
2009 
2010 
2011 /*
2012  * scsa2usb_panic_callb_fini:
2013  *      cancel out PANIC callb and free allocated resources
2014  */
2015 static void
2016 scsa2usb_panic_callb_fini(scsa2usb_state_t *scsa2usbp)
2017 {
2018         if (scsa2usbp->scsa2usb_panic_info) {
2019                 SCSA2USB_CANCEL_CB(scsa2usbp->scsa2usb_panic_info->cpr.cc_id);
2020                 mutex_destroy(&scsa2usbp->scsa2usb_panic_info->lockp);
2021                 scsa2usbp->scsa2usb_panic_info->statep = NULL;
2022                 kmem_free(scsa2usbp->scsa2usb_panic_info,
2023                     sizeof (scsa2usb_cpr_t));
2024                 scsa2usbp->scsa2usb_panic_info = NULL;
2025         }
2026 }
2027 
2028 
2029 /*
2030  * scsa2usb_panic_callb:
2031  *      This routine is called when there is a system panic.
2032  */
2033 /* ARGSUSED */
2034 static boolean_t
2035 scsa2usb_panic_callb(void *arg, int code)
2036 {
2037         scsa2usb_cpr_t *cpr_infop;
2038         scsa2usb_state_t *scsa2usbp;
2039         uint_t          lun;
2040 
2041         _NOTE(NO_COMPETING_THREADS_NOW);
2042         cpr_infop = (scsa2usb_cpr_t *)arg;
2043         scsa2usbp = (scsa2usb_state_t *)cpr_infop->statep;
2044 
2045         USB_DPRINTF_L4(DPRINT_MASK_SCSA, scsa2usbp->scsa2usb_log_handle,
2046             "scsa2usb_panic_callb: code=%d", code);
2047 
2048         /*
2049          * If we return error here, "sd" prints lots of error
2050          * messages and could retry the same pkt over and over again.
2051          * The sync recovery isn't "smooth" in that case. By faking
2052          * a success return, instead,  we force sync to complete.
2053          */
2054         if (scsa2usbp->scsa2usb_cur_pkt) {
2055                 /*
2056                  * Do not print the "no sync" warning here. it will then be
2057                  * displayed before we actually start syncing. Also we don't
2058                  * replace this code with a call to scsa2usb_pkt_completion().
2059                  * NOTE: mutexes are disabled during panic.
2060                  */
2061                 scsa2usbp->scsa2usb_cur_pkt->pkt_reason = CMD_CMPLT;
2062                 mutex_enter(&scsa2usbp->scsa2usb_mutex);
2063                 scsa2usb_pkt_completion(scsa2usbp, scsa2usbp->scsa2usb_cur_pkt);
2064                 mutex_exit(&scsa2usbp->scsa2usb_mutex);
2065         }
2066 
2067         /* get rid of waitQ */
2068         for (lun = 0; lun < SCSA2USB_MAX_LUNS; lun++) {
2069                 scsa2usb_flush_waitQ(scsa2usbp, lun, CMD_CMPLT);
2070         }
2071 
2072 #ifndef lint
2073         _NOTE(COMPETING_THREADS_NOW);
2074 #endif
2075 
2076         return (B_TRUE);
2077 }
2078 
2079 /*
2080  * scsa2usb_cpr_suspend
2081  *      determine if the device's state can be changed to SUSPENDED
2082  *      close pipes if there is no activity
2083  */
2084 /* ARGSUSED */
2085 static int
2086 scsa2usb_cpr_suspend(dev_info_t *dip)
2087 {
2088         scsa2usb_state_t *scsa2usbp;
2089         int     prev_state;
2090         int     rval = USB_FAILURE;
2091 
2092         scsa2usbp = ddi_get_soft_state(scsa2usb_statep, ddi_get_instance(dip));
2093 
2094         ASSERT(scsa2usbp != NULL);
2095 
2096         USB_DPRINTF_L4(DPRINT_MASK_SCSA, scsa2usbp->scsa2usb_log_handle,
2097             "scsa2usb_cpr_suspend:");
2098 
2099         mutex_enter(&scsa2usbp->scsa2usb_mutex);
2100         switch (scsa2usbp->scsa2usb_dev_state) {
2101         case USB_DEV_ONLINE:
2102         case USB_DEV_PWRED_DOWN:
2103         case USB_DEV_DISCONNECTED:
2104                 prev_state = scsa2usbp->scsa2usb_dev_state;
2105                 scsa2usbp->scsa2usb_dev_state = USB_DEV_SUSPENDED;
2106 
2107                 /*
2108                  * If the device is busy, we cannot suspend
2109                  */
2110                 if (SCSA2USB_BUSY(scsa2usbp)) {
2111                         USB_DPRINTF_L3(DPRINT_MASK_SCSA,
2112                             scsa2usbp->scsa2usb_log_handle,
2113                             "scsa2usb_cpr_suspend: I/O active");
2114 
2115                         /* fall back to previous state */
2116                         scsa2usbp->scsa2usb_dev_state = prev_state;
2117                 } else {
2118                         rval = USB_SUCCESS;
2119                 }
2120 
2121                 break;
2122         case USB_DEV_SUSPENDED:
2123         default:
2124                 USB_DPRINTF_L2(DPRINT_MASK_SCSA, scsa2usbp->scsa2usb_log_handle,
2125                     "scsa2usb_cpr_suspend: Illegal dev state: %d",
2126                     scsa2usbp->scsa2usb_dev_state);
2127 
2128                 break;
2129         }
2130         mutex_exit(&scsa2usbp->scsa2usb_mutex);
2131 
2132         if ((rval == USB_SUCCESS) && scsa2usbp->scsa2usb_ugen_hdl) {
2133                 rval = usb_ugen_detach(scsa2usbp->scsa2usb_ugen_hdl,
2134                     DDI_SUSPEND);
2135         }
2136 
2137         return (rval);
2138 }
2139 
2140 
2141 /*
2142  * scsa2usb_cpr_resume:
2143  *      restore device's state
2144  */
2145 static void
2146 scsa2usb_cpr_resume(dev_info_t *dip)
2147 {
2148         scsa2usb_state_t *scsa2usbp =
2149             ddi_get_soft_state(scsa2usb_statep, ddi_get_instance(dip));
2150 
2151         ASSERT(scsa2usbp != NULL);
2152 
2153         USB_DPRINTF_L4(DPRINT_MASK_SCSA, scsa2usbp->scsa2usb_log_handle,
2154             "scsa2usb_cpr_resume: dip = 0x%p", (void *)dip);
2155 
2156         scsa2usb_restore_device_state(dip, scsa2usbp);
2157 
2158         if (scsa2usbp->scsa2usb_ugen_hdl) {
2159                 (void) usb_ugen_attach(scsa2usbp->scsa2usb_ugen_hdl,
2160                     DDI_RESUME);
2161         }
2162 }
2163 
2164 
2165 /*
2166  * scsa2usb_restore_device_state:
2167  *      - raise the device's power
2168  *      - reopen all the pipes
2169  */
2170 static void
2171 scsa2usb_restore_device_state(dev_info_t *dip, scsa2usb_state_t *scsa2usbp)
2172 {
2173         uint_t  prev_state;
2174 
2175         USB_DPRINTF_L4(DPRINT_MASK_SCSA, scsa2usbp->scsa2usb_log_handle,
2176             "scsa2usb_restore_device_state:");
2177 
2178         mutex_enter(&scsa2usbp->scsa2usb_mutex);
2179         prev_state = scsa2usbp->scsa2usb_dev_state;
2180 
2181         scsa2usb_raise_power(scsa2usbp);
2182 
2183         ASSERT((prev_state == USB_DEV_DISCONNECTED) ||
2184             (prev_state == USB_DEV_SUSPENDED));
2185 
2186         mutex_exit(&scsa2usbp->scsa2usb_mutex);
2187 
2188         /* Check for the same device */
2189         if (usb_check_same_device(dip, scsa2usbp->scsa2usb_log_handle,
2190             USB_LOG_L0, DPRINT_MASK_ALL, USB_CHK_ALL, NULL) != USB_SUCCESS) {
2191 
2192                 /* change the flags to active */
2193                 mutex_enter(&scsa2usbp->scsa2usb_mutex);
2194                 scsa2usbp->scsa2usb_dev_state = USB_DEV_DISCONNECTED;
2195                 mutex_exit(&scsa2usbp->scsa2usb_mutex);
2196 
2197                 scsa2usb_pm_idle_component(scsa2usbp);
2198 
2199                 return;
2200         }
2201 
2202         /*
2203          * if the device had remote wakeup earlier,
2204          * enable it again
2205          */
2206         mutex_enter(&scsa2usbp->scsa2usb_mutex);
2207         if (scsa2usbp->scsa2usb_pm &&
2208             scsa2usbp->scsa2usb_pm->scsa2usb_wakeup_enabled) {
2209                 mutex_exit(&scsa2usbp->scsa2usb_mutex);
2210                 (void) usb_handle_remote_wakeup(scsa2usbp->scsa2usb_dip,
2211                     USB_REMOTE_WAKEUP_ENABLE);
2212                 mutex_enter(&scsa2usbp->scsa2usb_mutex);
2213         }
2214 
2215         scsa2usbp->scsa2usb_dev_state = USB_DEV_ONLINE;
2216         scsa2usbp->scsa2usb_pkt_state = SCSA2USB_PKT_NONE;
2217         mutex_exit(&scsa2usbp->scsa2usb_mutex);
2218 
2219         scsa2usb_pm_idle_component(scsa2usbp);
2220 }
2221 
2222 
2223 /*
2224  * SCSA entry points:
2225  *
2226  * scsa2usb_scsi_tgt_probe:
2227  * scsa functions are exported by means of the transport table
2228  * Issue a probe to get the inquiry data.
2229  */
2230 /* ARGSUSED */
2231 static int
2232 scsa2usb_scsi_tgt_probe(struct scsi_device *sd, int (*waitfunc)(void))
2233 {
2234         scsi_hba_tran_t *tran;
2235         scsa2usb_state_t *scsa2usbp;
2236         dev_info_t *dip = ddi_get_parent(sd->sd_dev);
2237         int     rval;
2238 
2239         ASSERT(dip);
2240 
2241         tran = ddi_get_driver_private(dip);
2242         ASSERT(tran != NULL);
2243         scsa2usbp = (scsa2usb_state_t *)tran->tran_hba_private;
2244         ASSERT(scsa2usbp);
2245 
2246         USB_DPRINTF_L4(DPRINT_MASK_SCSA, scsa2usbp->scsa2usb_log_handle,
2247             "scsa2usb_scsi_tgt_probe:");
2248 
2249         /* if device is disconnected (ie. pipes closed), fail immediately */
2250         mutex_enter(&scsa2usbp->scsa2usb_mutex);
2251         if (!(SCSA2USB_DEVICE_ACCESS_OK(scsa2usbp))) {
2252                 mutex_exit(&scsa2usbp->scsa2usb_mutex);
2253 
2254                 return (SCSIPROBE_FAILURE);
2255         }
2256         mutex_exit(&scsa2usbp->scsa2usb_mutex);
2257 
2258         USB_DPRINTF_L4(DPRINT_MASK_SCSA, scsa2usbp->scsa2usb_log_handle,
2259             "scsa2usb_scsi_tgt_probe: scsi_device = 0x%p", (void *)sd);
2260 
2261         if ((rval = scsi_hba_probe(sd, waitfunc)) == SCSIPROBE_EXISTS) {
2262                 /*
2263                  * respect the removable bit on all USB storage devices
2264                  * unless overridden by a scsa2usb.conf entry
2265                  */
2266                 mutex_enter(&scsa2usbp->scsa2usb_mutex);
2267                 if (!(scsa2usbp->scsa2usb_attrs & SCSA2USB_ATTRS_RMB)) {
2268                         _NOTE(SCHEME_PROTECTS_DATA("unshared", scsi_inquiry))
2269                         sd->sd_inq->inq_rmb = 1;
2270                 }
2271                 mutex_exit(&scsa2usbp->scsa2usb_mutex);
2272         }
2273 
2274         return (rval);
2275 }
2276 
2277 
2278 /*
2279  * scsa2usb_scsi_tgt_init:
2280  *      check whether we created this child ourselves
2281  */
2282 /* ARGSUSED */
2283 static int
2284 scsa2usb_scsi_tgt_init(dev_info_t *dip, dev_info_t *cdip,
2285     scsi_hba_tran_t *tran, struct scsi_device *sd)
2286 {
2287         scsa2usb_state_t *scsa2usbp = (scsa2usb_state_t *)
2288             tran->tran_hba_private;
2289         int lun;
2290         int t_len = sizeof (lun);
2291 
2292         if (ddi_prop_op(DDI_DEV_T_ANY, cdip, PROP_LEN_AND_VAL_BUF,
2293             DDI_PROP_DONTPASS|DDI_PROP_CANSLEEP, "lun", (caddr_t)&lun,
2294             &t_len) != DDI_PROP_SUCCESS) {
2295 
2296                 return (DDI_FAILURE);
2297         }
2298 
2299         USB_DPRINTF_L4(DPRINT_MASK_SCSA, scsa2usbp->scsa2usb_log_handle,
2300             "scsa2usb_scsi_tgt_init: %s, lun%d", ddi_driver_name(cdip), lun);
2301 
2302         /* is this a child we created? */
2303         if (scsa2usb_is_usb(cdip) == 0) {
2304 
2305                 USB_DPRINTF_L2(DPRINT_MASK_SCSA, scsa2usbp->scsa2usb_log_handle,
2306                     "scsa2usb_scsi_tgt_init: new child %s%d",
2307                     ddi_driver_name(cdip), ddi_get_instance(cdip));
2308 
2309                 /*
2310                  * add property "usb" so we can always verify that it
2311                  * is our child
2312                  */
2313                 if (ndi_prop_create_boolean(DDI_DEV_T_NONE, cdip, "usb") !=
2314                     DDI_PROP_SUCCESS) {
2315                         USB_DPRINTF_L2(DPRINT_MASK_SCSA,
2316                             scsa2usbp->scsa2usb_log_handle,
2317                             "ndi_prop_create_boolean failed");
2318 
2319                         return (DDI_FAILURE);
2320                 }
2321 
2322                 usba_set_usba_device(cdip,
2323                     usba_get_usba_device(scsa2usbp->scsa2usb_dip));
2324 
2325                 /*
2326                  * we don't store this dip in scsa2usb_lun_dip, there
2327                  * might be multiple dips for the same device
2328                  */
2329 
2330                 return (DDI_SUCCESS);
2331         }
2332 
2333         mutex_enter(&scsa2usbp->scsa2usb_mutex);
2334         if ((lun >= scsa2usbp->scsa2usb_n_luns) ||
2335             (scsa2usbp->scsa2usb_lun_dip[lun] != NULL)) {
2336                 mutex_exit(&scsa2usbp->scsa2usb_mutex);
2337 
2338                 return (DDI_FAILURE);
2339         }
2340 
2341         scsa2usbp->scsa2usb_lun_dip[lun] = cdip;
2342         mutex_exit(&scsa2usbp->scsa2usb_mutex);
2343 
2344         return (DDI_SUCCESS);
2345 }
2346 
2347 
2348 /*
2349  * scsa2usb_scsi_tgt_free:
2350  */
2351 /* ARGSUSED */
2352 static void
2353 scsa2usb_scsi_tgt_free(dev_info_t *hba_dip, dev_info_t *cdip,
2354         scsi_hba_tran_t *tran, struct scsi_device *sd)
2355 {
2356         scsa2usb_state_t *scsa2usbp = (scsa2usb_state_t *)
2357             tran->tran_hba_private;
2358         int lun;
2359         int t_len = sizeof (lun);
2360 
2361         /* is this our child? */
2362         if (scsa2usb_is_usb(cdip) == 0) {
2363 
2364                 return;
2365         }
2366 
2367         if (ddi_prop_op(DDI_DEV_T_ANY, cdip, PROP_LEN_AND_VAL_BUF,
2368             DDI_PROP_DONTPASS|DDI_PROP_CANSLEEP, "lun", (caddr_t)&lun,
2369             &t_len) != DDI_PROP_SUCCESS) {
2370 
2371                 return;
2372         }
2373 
2374         USB_DPRINTF_L4(DPRINT_MASK_SCSA, scsa2usbp->scsa2usb_log_handle,
2375             "scsa2usb_scsi_tgt_free: %s lun%d", ddi_driver_name(cdip), lun);
2376 
2377         mutex_enter(&scsa2usbp->scsa2usb_mutex);
2378         if (lun < scsa2usbp->scsa2usb_n_luns) {
2379                 if (scsa2usbp->scsa2usb_lun_dip[lun] == cdip) {
2380                         scsa2usbp->scsa2usb_lun_dip[lun] = NULL;
2381                 }
2382         }
2383         mutex_exit(&scsa2usbp->scsa2usb_mutex);
2384 }
2385 
2386 
2387 /*
2388  * bus enumeration entry points
2389  */
2390 static int
2391 scsa2usb_scsi_bus_config(dev_info_t *dip, uint_t flag, ddi_bus_config_op_t op,
2392     void *arg, dev_info_t **child)
2393 {
2394         int     circ;
2395         int     rval;
2396 
2397         scsa2usb_state_t *scsa2usbp =
2398             ddi_get_soft_state(scsa2usb_statep, ddi_get_instance(dip));
2399 
2400         ASSERT(scsa2usbp != NULL);
2401 
2402         USB_DPRINTF_L2(DPRINT_MASK_SCSA, scsa2usbp->scsa2usb_log_handle,
2403             "scsa2usb_scsi_bus_config: op=%d", op);
2404 
2405         if (scsa2usb_scsi_bus_config_debug) {
2406                 flag |= NDI_DEVI_DEBUG;
2407         }
2408 
2409         ndi_devi_enter(dip, &circ);
2410         /* create children if necessary */
2411         if (DEVI(dip)->devi_child == NULL) {
2412                 scsa2usb_create_luns(scsa2usbp);
2413         }
2414 
2415         rval = ndi_busop_bus_config(dip, flag, op, arg, child, 0);
2416 
2417         ndi_devi_exit(dip, circ);
2418 
2419         return (rval);
2420 }
2421 
2422 
2423 static int
2424 scsa2usb_scsi_bus_unconfig(dev_info_t *dip, uint_t flag, ddi_bus_config_op_t op,
2425     void *arg)
2426 {
2427         scsa2usb_state_t *scsa2usbp =
2428             ddi_get_soft_state(scsa2usb_statep, ddi_get_instance(dip));
2429 
2430         int             circular_count;
2431         int             rval = NDI_SUCCESS;
2432         uint_t          save_flag = flag;
2433 
2434         ASSERT(scsa2usbp != NULL);
2435 
2436         USB_DPRINTF_L4(DPRINT_MASK_SCSA, scsa2usbp->scsa2usb_log_handle,
2437             "scsa2usb_scsi_bus_unconfig: op=%d", op);
2438 
2439         if (scsa2usb_scsi_bus_config_debug) {
2440                 flag |= NDI_DEVI_DEBUG;
2441         }
2442 
2443         /*
2444          * first offline and if offlining successful, then
2445          * remove children
2446          */
2447         if (op == BUS_UNCONFIG_ALL) {
2448                 flag &= ~(NDI_DEVI_REMOVE | NDI_UNCONFIG);
2449         }
2450 
2451         ndi_devi_enter(dip, &circular_count);
2452         rval = ndi_busop_bus_unconfig(dip, flag, op, arg);
2453 
2454         /*
2455          * If unconfig is successful and not part of modunload
2456          * daemon, attempt to remove children.
2457          */
2458         if (op == BUS_UNCONFIG_ALL && rval == NDI_SUCCESS &&
2459             (flag & NDI_AUTODETACH) == 0) {
2460                 flag |= NDI_DEVI_REMOVE;
2461                 rval = ndi_busop_bus_unconfig(dip, flag, op, arg);
2462         }
2463         ndi_devi_exit(dip, circular_count);
2464 
2465         if ((rval != NDI_SUCCESS) && (op == BUS_UNCONFIG_ALL) &&
2466             (save_flag & NDI_DEVI_REMOVE)) {
2467                 mutex_enter(&scsa2usbp->scsa2usb_mutex);
2468                 if (scsa2usbp->scsa2usb_warning_given != B_TRUE) {
2469                         USB_DPRINTF_L2(DPRINT_MASK_SCSA,
2470                             scsa2usbp->scsa2usb_log_handle,
2471                             "Disconnected device was busy, "
2472                             "please reconnect.");
2473                         scsa2usbp->scsa2usb_warning_given = B_TRUE;
2474                 }
2475                 mutex_exit(&scsa2usbp->scsa2usb_mutex);
2476         }
2477 
2478         USB_DPRINTF_L4(DPRINT_MASK_SCSA, scsa2usbp->scsa2usb_log_handle,
2479             "scsa2usb_scsi_bus_unconfig: rval=%d", rval);
2480 
2481         return (rval);
2482 }
2483 
2484 
2485 /*
2486  * scsa2usb_scsi_init_pkt:
2487  *      Set up the scsi_pkt for transport. Also initialize
2488  *      scsa2usb_cmd struct for the transport.
2489  *      NOTE: We do not do any DMA setup here as USBA framework
2490  *      does that for us.
2491  */
2492 static struct scsi_pkt *
2493 scsa2usb_scsi_init_pkt(struct scsi_address *ap,
2494     struct scsi_pkt *pkt, struct buf *bp, int cmdlen, int statuslen,
2495     int tgtlen, int flags, int (*callback)(), caddr_t arg)
2496 {
2497         scsa2usb_cmd_t   *cmd;
2498         scsa2usb_state_t *scsa2usbp;
2499         struct scsi_pkt  *in_pkt = pkt;
2500 
2501         ASSERT(callback == NULL_FUNC || callback == SLEEP_FUNC);
2502 
2503         scsa2usbp = (scsa2usb_state_t *)ADDR2SCSA2USB(ap);
2504 
2505         /* Print sync message */
2506         if (ddi_in_panic()) {
2507                 mutex_enter(&scsa2usbp->scsa2usb_mutex);
2508                 SCSA2USB_PRINT_SYNC_MSG(scsa2usb_sync_message, scsa2usbp);
2509                 mutex_exit(&scsa2usbp->scsa2usb_mutex);
2510                 /* continue so caller will not hang or complain */
2511         }
2512 
2513         /* allocate a pkt, if none already allocated */
2514         if (pkt == NULL) {
2515                 if (statuslen < sizeof (struct scsi_arq_status)) {
2516                         statuslen = sizeof (struct scsi_arq_status);
2517                 }
2518 
2519                 pkt = scsi_hba_pkt_alloc(scsa2usbp->scsa2usb_dip, ap, cmdlen,
2520                     statuslen, tgtlen, sizeof (scsa2usb_cmd_t),
2521                     callback, arg);
2522                 if (pkt == NULL) {
2523 
2524                         return (NULL);
2525                 }
2526 
2527                 cmd = PKT2CMD(pkt);
2528                 cmd->cmd_pkt = pkt; /* back link to pkt */
2529                 cmd->cmd_scblen      = statuslen;
2530                 cmd->cmd_cdblen      = (uchar_t)cmdlen;
2531 
2532                 mutex_enter(&scsa2usbp->scsa2usb_mutex);
2533                 cmd->cmd_tag = scsa2usbp->scsa2usb_tag++;
2534                 mutex_exit(&scsa2usbp->scsa2usb_mutex);
2535 
2536                 cmd->cmd_bp  = bp;
2537                 /*
2538                  * The buffer size of cmd->cmd_scb is constrained
2539                  * to sizeof (struct scsi_arq_status), if the scblen
2540                  * is bigger than that, we use pkt->pkt_scbp directly.
2541                  */
2542                 if (cmd->cmd_scblen == sizeof (struct scsi_arq_status)) {
2543                         pkt->pkt_scbp = (opaque_t)&cmd->cmd_scb;
2544                 }
2545 
2546                 usba_init_list(&cmd->cmd_waitQ, (usb_opaque_t)cmd,
2547                     scsa2usbp->scsa2usb_dev_data->dev_iblock_cookie);
2548         } else {
2549                 USB_DPRINTF_L2(DPRINT_MASK_SCSA, scsa2usbp->scsa2usb_log_handle,
2550                     "scsa2usb: pkt != NULL");
2551 
2552                 /* nothing to do */
2553         }
2554 
2555         if (bp && (bp->b_bcount != 0)) {
2556                 if ((bp_mapin_common(bp, (callback == SLEEP_FUNC) ?
2557                     VM_SLEEP : VM_NOSLEEP)) == NULL) {
2558                         if (pkt != in_pkt) {
2559                                 scsi_hba_pkt_free(ap, pkt);
2560                         }
2561 
2562                         return (NULL);
2563                 }
2564 
2565                 USB_DPRINTF_L3(DPRINT_MASK_SCSA,
2566                     scsa2usbp->scsa2usb_log_handle,
2567                     "scsa2usb_scsi_init_pkt: mapped in 0x%p, addr=0x%p",
2568                     (void *)bp, (void *)bp->b_un.b_addr);
2569         }
2570 
2571         USB_DPRINTF_L4(DPRINT_MASK_SCSA, scsa2usbp->scsa2usb_log_handle,
2572             "scsa2usb_scsi_init_pkt: ap = 0x%p pkt: 0x%p\n\t"
2573             "bp = 0x%p cmdlen = %x stlen = 0x%x tlen = 0x%x flags = 0x%x",
2574             (void *)ap, (void *)pkt, (void *)bp, cmdlen, statuslen,
2575             tgtlen, flags);
2576 
2577         return (pkt);
2578 }
2579 
2580 
2581 /*
2582  * scsa2usb_scsi_destroy_pkt:
2583  *      We are done with the packet. Get rid of it.
2584  */
2585 static void
2586 scsa2usb_scsi_destroy_pkt(struct scsi_address *ap, struct scsi_pkt *pkt)
2587 {
2588         scsa2usb_cmd_t *cmd = PKT2CMD(pkt);
2589         scsa2usb_state_t *scsa2usbp = ADDR2SCSA2USB(ap);
2590 
2591         USB_DPRINTF_L4(DPRINT_MASK_SCSA, scsa2usbp->scsa2usb_log_handle,
2592             "scsa2usb_scsi_destroy_pkt: pkt=0x%p", (void *)pkt);
2593 
2594         usba_destroy_list(&cmd->cmd_waitQ);
2595         scsi_hba_pkt_free(ap, pkt);
2596 }
2597 
2598 
2599 /*
2600  * scsa2usb_scsi_start:
2601  *      For each command being issued, build up the CDB
2602  *      and call scsi_transport to issue the command. This
2603  *      function is based on the assumption that USB allows
2604  *      a subset of SCSI commands. Other SCSI commands we fail.
2605  */
2606 static int
2607 scsa2usb_scsi_start(struct scsi_address *ap, struct scsi_pkt *pkt)
2608 {
2609         scsa2usb_cmd_t          *cmd;
2610         scsa2usb_state_t        *scsa2usbp = ADDR2SCSA2USB(ap);
2611         uint_t                  lun = ap->a_lun;
2612 
2613         mutex_enter(&scsa2usbp->scsa2usb_mutex);
2614 
2615         cmd = PKT2CMD(pkt);
2616         USB_DPRINTF_L3(DPRINT_MASK_SCSA, scsa2usbp->scsa2usb_log_handle,
2617             "scsa2usb_scsi_start:\n\t"
2618             "bp: 0x%p ap: 0x%p pkt: 0x%p flag: 0x%x time: 0x%x\n\tcdb0: 0x%x "
2619             "dev_state: 0x%x pkt_state: 0x%x flags: 0x%x pipe_state: 0x%x",
2620             (void *)cmd->cmd_bp, (void *)ap, (void *)pkt, pkt->pkt_flags,
2621             pkt->pkt_time, pkt->pkt_cdbp[0], scsa2usbp->scsa2usb_dev_state,
2622             scsa2usbp->scsa2usb_pkt_state, scsa2usbp->scsa2usb_flags,
2623             scsa2usbp->scsa2usb_pipe_state);
2624 
2625         if (pkt->pkt_time == 0) {
2626                 USB_DPRINTF_L1(DPRINT_MASK_SCSA, scsa2usbp->scsa2usb_log_handle,
2627                     "pkt submitted with 0 timeout which may cause indefinite "
2628                     "hangs");
2629         }
2630 
2631         /*
2632          * if we are in panic, we are in polled mode, so we can just
2633          * accept the request, drop it and return
2634          * if we fail this request, the rest of the file systems do not
2635          * get synced
2636          */
2637         if (ddi_in_panic()) {
2638                 extern int do_polled_io;
2639 
2640                 ASSERT(do_polled_io);
2641                 scsa2usb_prepare_pkt(scsa2usbp, pkt);
2642                 SCSA2USB_PRINT_SYNC_MSG(scsa2usb_sync_message, scsa2usbp);
2643                 mutex_exit(&scsa2usbp->scsa2usb_mutex);
2644 
2645                 return (TRAN_ACCEPT);
2646         }
2647 
2648         /* we cannot do polling, this should not happen */
2649         if (pkt->pkt_flags & FLAG_NOINTR) {
2650                 USB_DPRINTF_L2(DPRINT_MASK_SCSA, scsa2usbp->scsa2usb_log_handle,
2651                     "NOINTR packet: opcode = 0%x", pkt->pkt_cdbp[0]);
2652                 mutex_exit(&scsa2usbp->scsa2usb_mutex);
2653 
2654                 return (TRAN_BADPKT);
2655         }
2656 
2657         /* prepare packet */
2658         scsa2usb_prepare_pkt(scsa2usbp, pkt);
2659 
2660         /* just queue up the requests in the waitQ if below max */
2661         if (usba_list_entry_count(&scsa2usbp->scsa2usb_waitQ[lun]) >
2662             SCSA2USB_MAX_REQ_PER_LUN) {
2663                 USB_DPRINTF_L2(DPRINT_MASK_SCSA,
2664                     scsa2usbp->scsa2usb_log_handle,
2665                     "scsa2usb_scsi_start: limit (%d) exceeded",
2666                     SCSA2USB_MAX_REQ_PER_LUN);
2667                 mutex_exit(&scsa2usbp->scsa2usb_mutex);
2668 
2669                 return (TRAN_BUSY);
2670         }
2671 
2672         usba_add_to_list(&scsa2usbp->scsa2usb_waitQ[lun], &cmd->cmd_waitQ);
2673 
2674         USB_DPRINTF_L3(DPRINT_MASK_SCSA, scsa2usbp->scsa2usb_log_handle,
2675             "scsa2usb_work_thread_id=0x%p, count=%d, lun=%d",
2676             (void *)scsa2usbp->scsa2usb_work_thread_id,
2677             usba_list_entry_count(&scsa2usbp->scsa2usb_waitQ[lun]), lun);
2678 
2679         /* fire up a thread to start executing the protocol */
2680         if (scsa2usbp->scsa2usb_work_thread_id == 0) {
2681                 if ((usb_async_req(scsa2usbp->scsa2usb_dip,
2682                     scsa2usb_work_thread,
2683                     (void *)scsa2usbp, USB_FLAGS_SLEEP)) != USB_SUCCESS) {
2684                         USB_DPRINTF_L2(DPRINT_MASK_SCSA,
2685                             scsa2usbp->scsa2usb_log_handle,
2686                             "no work thread started");
2687 
2688                         if (usba_rm_from_list(
2689                             &scsa2usbp->scsa2usb_waitQ[lun],
2690                             &cmd->cmd_waitQ) == USB_SUCCESS) {
2691                                 mutex_exit(&scsa2usbp->scsa2usb_mutex);
2692 
2693                                 return (TRAN_BUSY);
2694                         } else {
2695 
2696                                 mutex_exit(&scsa2usbp->scsa2usb_mutex);
2697 
2698                                 return (TRAN_ACCEPT);
2699                         }
2700                 }
2701                 scsa2usbp->scsa2usb_work_thread_id = (kthread_t *)1;
2702         }
2703 
2704         mutex_exit(&scsa2usbp->scsa2usb_mutex);
2705 
2706         return (TRAN_ACCEPT);
2707 }
2708 
2709 
2710 /*
2711  * scsa2usb_scsi_abort:
2712  *      Issue SCSI abort command. This function is a NOP.
2713  */
2714 /* ARGSUSED */
2715 static int
2716 scsa2usb_scsi_abort(struct scsi_address *ap, struct scsi_pkt *pkt)
2717 {
2718         scsa2usb_state_t *scsa2usbp = (scsa2usb_state_t *)ADDR2SCSA2USB(ap);
2719 
2720         USB_DPRINTF_L4(DPRINT_MASK_SCSA, scsa2usbp->scsa2usb_log_handle,
2721             "scsa2usb_scsi_abort: pkt = %p", (void *)pkt);
2722 
2723         /* if device is disconnected (ie. pipes closed), fail immediately */
2724         mutex_enter(&scsa2usbp->scsa2usb_mutex);
2725         if (!(SCSA2USB_DEVICE_ACCESS_OK(scsa2usbp))) {
2726                 mutex_exit(&scsa2usbp->scsa2usb_mutex);
2727 
2728                 return (0);
2729         }
2730 
2731         /* flush waitQ if target and lun match */
2732         if ((ap->a_target == pkt->pkt_address.a_target) &&
2733             (ap->a_lun == pkt->pkt_address.a_lun)) {
2734                 mutex_exit(&scsa2usbp->scsa2usb_mutex);
2735                 scsa2usb_flush_waitQ(scsa2usbp, ap->a_lun, CMD_ABORTED);
2736                 mutex_enter(&scsa2usbp->scsa2usb_mutex);
2737         }
2738         mutex_exit(&scsa2usbp->scsa2usb_mutex);
2739 
2740         return (0);
2741 }
2742 
2743 
2744 /*
2745  * scsa2usb_scsi_reset:
2746  *      device reset may turn the device into a brick and bus reset
2747  *      is not applicable.
2748  *      just flush the waitQ
2749  *      We return success, always.
2750  */
2751 /* ARGSUSED */
2752 static int
2753 scsa2usb_scsi_reset(struct scsi_address *ap, int level)
2754 {
2755         scsa2usb_state_t *scsa2usbp = (scsa2usb_state_t *)ADDR2SCSA2USB(ap);
2756 
2757         USB_DPRINTF_L4(DPRINT_MASK_SCSA, scsa2usbp->scsa2usb_log_handle,
2758             "scsa2usb_scsi_reset: ap = 0x%p, level = %d", (void *)ap, level);
2759 
2760         /* flush waitQ */
2761         scsa2usb_flush_waitQ(scsa2usbp, ap->a_lun, CMD_RESET);
2762 
2763         return (1);
2764 }
2765 
2766 
2767 /*
2768  * scsa2usb_scsi_getcap:
2769  *      Get SCSI capabilities.
2770  */
2771 /* ARGSUSED */
2772 static int
2773 scsa2usb_scsi_getcap(struct scsi_address *ap, char *cap, int whom)
2774 {
2775         int rval = -1;
2776         uint_t cidx;
2777         size_t dev_bsize_cap;
2778         scsa2usb_state_t *scsa2usbp = (scsa2usb_state_t *)ADDR2SCSA2USB(ap);
2779         ASSERT(scsa2usbp);
2780 
2781         if (cap == NULL) {
2782                 USB_DPRINTF_L2(DPRINT_MASK_SCSA, scsa2usbp->scsa2usb_log_handle,
2783                     "scsa2usb_scsi_getcap: invalid arg, "
2784                     "cap = 0x%p whom = %d", (void *)cap, whom);
2785 
2786                 return (rval);
2787         }
2788 
2789         USB_DPRINTF_L4(DPRINT_MASK_SCSA, scsa2usbp->scsa2usb_log_handle,
2790             "scsa2usb_scsi_getcap: cap = %s", cap);
2791 
2792         mutex_enter(&scsa2usbp->scsa2usb_mutex);
2793 
2794         /* if device is disconnected (ie. pipes closed), fail immediately */
2795         if (!(SCSA2USB_DEVICE_ACCESS_OK(scsa2usbp))) {
2796 
2797                 mutex_exit(&scsa2usbp->scsa2usb_mutex);
2798 
2799                 return (rval);
2800         }
2801 
2802         cidx =  scsi_hba_lookup_capstr(cap);
2803         switch (cidx) {
2804         case SCSI_CAP_GEOMETRY:
2805                 /* Just check and fail immediately if zero, rarely happens */
2806                 if (scsa2usbp->scsa2usb_secsz[ap->a_lun] == 0) {
2807                         USB_DPRINTF_L2(DPRINT_MASK_SCSA,
2808                             scsa2usbp->scsa2usb_log_handle,
2809                             "scsa2usb_scsi_getcap failed:"
2810                             "scsa2usbp->scsa2usb_secsz[ap->a_lun] == 0");
2811                         mutex_exit(&scsa2usbp->scsa2usb_mutex);
2812 
2813                         return (rval);
2814                 }
2815 
2816                 dev_bsize_cap = scsa2usbp->scsa2usb_totalsec[ap->a_lun];
2817 
2818                 if (scsa2usbp->scsa2usb_secsz[ap->a_lun] > DEV_BSIZE) {
2819                         dev_bsize_cap *=
2820                             scsa2usbp->scsa2usb_secsz[ap->a_lun] / DEV_BSIZE;
2821                 } else if (scsa2usbp->scsa2usb_secsz[ap->a_lun] <
2822                     DEV_BSIZE) {
2823                         dev_bsize_cap /=
2824                             DEV_BSIZE / scsa2usbp->scsa2usb_secsz[ap->a_lun];
2825                 }
2826 
2827                 if (dev_bsize_cap < 65536 * 2 * 18) {                /* < ~1GB */
2828                         /* unlabeled floppy, 18k per cylinder */
2829                         rval = ((2 << 16) | 18);
2830                 } else if (dev_bsize_cap < 65536 * 64 * 32) {        /* < 64GB */
2831                         /* 1024k per cylinder */
2832                         rval = ((64 << 16) | 32);
2833                 } else if (dev_bsize_cap < 65536 * 255 * 63) {       /* < ~500GB */
2834                         /* ~8m per cylinder */
2835                         rval = ((255 << 16) | 63);
2836                 } else {                                        /* .. 8TB */
2837                         /* 64m per cylinder */
2838                         rval = ((512 << 16) | 256);
2839                 }
2840                 break;
2841 
2842         case SCSI_CAP_DMA_MAX:
2843                 rval = scsa2usbp->scsa2usb_max_bulk_xfer_size;
2844                 break;
2845         case SCSI_CAP_SCSI_VERSION:
2846                 rval = SCSI_VERSION_2;
2847                 break;
2848         case SCSI_CAP_INTERCONNECT_TYPE:
2849                 rval = INTERCONNECT_USB;
2850                 break;
2851         case SCSI_CAP_ARQ:
2852                 /* FALLTHRU */
2853         case SCSI_CAP_UNTAGGED_QING:
2854                 rval = 1;
2855                 break;
2856         default:
2857                 USB_DPRINTF_L2(DPRINT_MASK_SCSA, scsa2usbp->scsa2usb_log_handle,
2858                     "scsa2usb_scsi_getcap: unsupported cap = %s", cap);
2859                 break;
2860         }
2861 
2862         USB_DPRINTF_L4(DPRINT_MASK_SCSA, scsa2usbp->scsa2usb_log_handle,
2863             "scsa2usb_scsi_getcap: cap = %s, returned = %d", cap, rval);
2864 
2865         mutex_exit(&scsa2usbp->scsa2usb_mutex);
2866 
2867         return (rval);
2868 }
2869 
2870 
2871 /*
2872  * scsa2usb_scsi_setcap:
2873  *      Set SCSI capabilities.
2874  */
2875 /* ARGSUSED */
2876 static int
2877 scsa2usb_scsi_setcap(struct scsi_address *ap, char *cap, int value, int whom)
2878 {
2879         int rval = -1; /* default is cap undefined */
2880         uint_t cidx;
2881         scsa2usb_state_t *scsa2usbp = (scsa2usb_state_t *)ADDR2SCSA2USB(ap);
2882         ASSERT(scsa2usbp);
2883 
2884         if (cap == NULL || whom == 0) {
2885                 USB_DPRINTF_L2(DPRINT_MASK_SCSA, scsa2usbp->scsa2usb_log_handle,
2886                     "scsa2usb_scsi_setcap: invalid arg");
2887 
2888                 return (rval);
2889         }
2890 
2891         mutex_enter(&scsa2usbp->scsa2usb_mutex);
2892         /* if device is disconnected (ie. pipes closed), fail immediately */
2893         if (!(SCSA2USB_DEVICE_ACCESS_OK(scsa2usbp))) {
2894                 mutex_exit(&scsa2usbp->scsa2usb_mutex);
2895 
2896                 return (rval);
2897         }
2898 
2899         cidx =  scsi_hba_lookup_capstr(cap);
2900         USB_DPRINTF_L2(DPRINT_MASK_SCSA, scsa2usbp->scsa2usb_log_handle,
2901             "scsa2usb_scsi_setcap: ap = 0x%p value = 0x%x whom = 0x%x "
2902             "cidx = 0x%x", (void *)ap, value, whom, cidx);
2903 
2904         switch (cidx) {
2905         case SCSI_CAP_SECTOR_SIZE:
2906                 if (value) {
2907                         scsa2usbp->scsa2usb_secsz[ap->a_lun] = value;
2908                 }
2909                 break;
2910         case SCSI_CAP_TOTAL_SECTORS:
2911                 if (value) {
2912                         scsa2usbp->scsa2usb_totalsec[ap->a_lun] = value;
2913                 }
2914                 break;
2915         case SCSI_CAP_ARQ:
2916                 rval = 1;
2917                 break;
2918         case SCSI_CAP_DMA_MAX:
2919         case SCSI_CAP_SCSI_VERSION:
2920         case SCSI_CAP_INTERCONNECT_TYPE:
2921         case SCSI_CAP_UNTAGGED_QING:
2922                 /* supported but not settable */
2923                 rval = 0;
2924                 break;
2925         default:
2926                 USB_DPRINTF_L2(DPRINT_MASK_SCSA, scsa2usbp->scsa2usb_log_handle,
2927                     "scsa2usb_scsi_setcap: unsupported cap = %s", cap);
2928                 break;
2929         }
2930 
2931         mutex_exit(&scsa2usbp->scsa2usb_mutex);
2932 
2933         return (rval);
2934 }
2935 
2936 
2937 /*
2938  * scsa2usb - cmd and transport stuff
2939  */
2940 /*
2941  * scsa2usb_prepare_pkt:
2942  *      initialize some fields of the pkt and cmd
2943  *      (the pkt may have been resubmitted/retried)
2944  */
2945 static void
2946 scsa2usb_prepare_pkt(scsa2usb_state_t *scsa2usbp, struct scsi_pkt *pkt)
2947 {
2948         scsa2usb_cmd_t  *cmd = PKT2CMD(pkt);
2949 
2950         USB_DPRINTF_L3(DPRINT_MASK_SCSA, scsa2usbp->scsa2usb_log_handle,
2951             "scsa2usb_prepare_pkt: pkt=0x%p cdb: 0x%x (%s)",
2952             (void *)pkt, pkt->pkt_cdbp[0],
2953             scsi_cname(pkt->pkt_cdbp[0], scsa2usb_cmds));
2954 
2955         pkt->pkt_reason = CMD_CMPLT; /* Set reason to pkt_complete */
2956         pkt->pkt_state = 0;          /* Reset next three fields */
2957         pkt->pkt_statistics = 0;
2958         pkt->pkt_resid = 0;
2959         bzero(pkt->pkt_scbp, cmd->cmd_scblen); /* Set status to good */
2960 
2961         if (cmd) {
2962                 cmd->cmd_timeout = pkt->pkt_time;
2963                 cmd->cmd_xfercount = 0;              /* Reset the fields */
2964                 cmd->cmd_total_xfercount = 0;
2965                 cmd->cmd_lba = 0;
2966                 cmd->cmd_done = 0;
2967                 cmd->cmd_dir = 0;
2968                 cmd->cmd_offset = 0;
2969                 cmd->cmd_actual_len = cmd->cmd_cdblen;
2970         }
2971 }
2972 
2973 
2974 /*
2975  * scsa2usb_force_invalid_request
2976  */
2977 static void
2978 scsa2usb_force_invalid_request(scsa2usb_state_t *scsa2usbp,
2979     scsa2usb_cmd_t *cmd)
2980 {
2981         struct scsi_arq_status  *arqp;
2982 
2983         USB_DPRINTF_L3(DPRINT_MASK_SCSA, scsa2usbp->scsa2usb_log_handle,
2984             "scsa2usb_force_invalid_request: pkt = 0x%p", (void *)cmd->cmd_pkt);
2985 
2986         if (cmd->cmd_scblen >= sizeof (struct scsi_arq_status)) {
2987                 arqp = (struct scsi_arq_status *)cmd->cmd_pkt->pkt_scbp;
2988                 bzero(arqp, cmd->cmd_scblen);
2989 
2990                 arqp->sts_status.sts_chk = 1;
2991                 arqp->sts_rqpkt_reason = CMD_CMPLT;
2992                 arqp->sts_rqpkt_state = STATE_XFERRED_DATA |
2993                     STATE_GOT_BUS | STATE_GOT_STATUS;
2994                 arqp->sts_sensedata.es_valid = 1;
2995                 arqp->sts_sensedata.es_class = 7;
2996                 arqp->sts_sensedata.es_key = KEY_ILLEGAL_REQUEST;
2997 
2998                 cmd->cmd_pkt->pkt_state = STATE_ARQ_DONE |
2999                     STATE_GOT_BUS | STATE_GOT_BUS | STATE_GOT_BUS |
3000                     STATE_GOT_STATUS;
3001 #ifdef DEBUG
3002                 {
3003                         uchar_t *p = (uchar_t *)(&arqp->sts_sensedata);
3004                         USB_DPRINTF_L2(DPRINT_MASK_SCSA,
3005                             scsa2usbp->scsa2usb_log_handle,
3006                             "cdb: %x rqsense: "
3007                             "%x %x %x %x %x %x %x %x %x %x "
3008                             "%x %x %x %x %x %x %x %x %x %x",
3009                             cmd->cmd_pkt->pkt_cdbp[0],
3010                             p[0], p[1], p[2], p[3], p[4],
3011                             p[5], p[6], p[7], p[8], p[9],
3012                             p[10], p[11], p[12], p[13], p[14],
3013                             p[15], p[16], p[17], p[18], p[19]);
3014                 }
3015 #endif
3016 
3017         }
3018 }
3019 
3020 
3021 /*
3022  * scsa2usb_cmd_transport:
3023  */
3024 static int
3025 scsa2usb_cmd_transport(scsa2usb_state_t *scsa2usbp, scsa2usb_cmd_t *cmd)
3026 {
3027         int rval, transport;
3028         struct scsi_pkt *pkt;
3029 
3030         USB_DPRINTF_L3(DPRINT_MASK_SCSA, scsa2usbp->scsa2usb_log_handle,
3031             "scsa2usb_cmd_transport: pkt: 0x%p, cur_pkt = 0x%p",
3032             (void *)cmd->cmd_pkt, (void *)scsa2usbp->scsa2usb_cur_pkt);
3033 
3034         ASSERT(mutex_owned(&scsa2usbp->scsa2usb_mutex));
3035         ASSERT(scsa2usbp->scsa2usb_cur_pkt == NULL);
3036 
3037         pkt = scsa2usbp->scsa2usb_cur_pkt = cmd->cmd_pkt;
3038 
3039         /* check black-listed attrs first */
3040         if (SCSA2USB_IS_BULK_ONLY(scsa2usbp)) {
3041                 transport = scsa2usb_check_bulkonly_blacklist_attrs(scsa2usbp,
3042                     cmd, pkt->pkt_cdbp[0]);
3043         } else if (SCSA2USB_IS_CB(scsa2usbp) || SCSA2USB_IS_CBI(scsa2usbp)) {
3044                 transport =  scsa2usb_check_ufi_blacklist_attrs(scsa2usbp,
3045                     pkt->pkt_cdbp[0], cmd);
3046         }
3047 
3048         /* just accept the command or return error */
3049         if (transport == SCSA2USB_JUST_ACCEPT) {
3050                 SCSA2USB_SET_PKT_DO_COMP_STATE(scsa2usbp);
3051 
3052                 return (TRAN_ACCEPT);
3053         } else if (transport == SCSA2USB_REJECT) {
3054                 return (TRAN_FATAL_ERROR);
3055         }
3056 
3057         /* check command set next */
3058         if (SCSA2USB_IS_SCSI_CMDSET(scsa2usbp) ||
3059             SCSA2USB_IS_ATAPI_CMDSET(scsa2usbp)) {
3060                 transport =
3061                     scsa2usb_handle_scsi_cmd_sub_class(scsa2usbp, cmd, pkt);
3062         } else if (SCSA2USB_IS_UFI_CMDSET(scsa2usbp)) {
3063                 transport =
3064                     scsa2usb_handle_ufi_subclass_cmd(scsa2usbp, cmd, pkt);
3065         } else {
3066                 transport = SCSA2USB_REJECT;
3067         }
3068 
3069         switch (transport) {
3070         case SCSA2USB_TRANSPORT:
3071                 if (SCSA2USB_IS_BULK_ONLY(scsa2usbp)) {
3072                         rval = scsa2usb_bulk_only_transport(scsa2usbp, cmd);
3073                 } else if (SCSA2USB_IS_CB(scsa2usbp) ||
3074                     SCSA2USB_IS_CBI(scsa2usbp)) {
3075                         rval = scsa2usb_cbi_transport(scsa2usbp, cmd);
3076                 } else {
3077                         rval = TRAN_FATAL_ERROR;
3078                 }
3079                 break;
3080         case SCSA2USB_JUST_ACCEPT:
3081                 SCSA2USB_SET_PKT_DO_COMP_STATE(scsa2usbp);
3082                 rval = TRAN_ACCEPT;
3083                 break;
3084         default:
3085                 rval = TRAN_FATAL_ERROR;
3086         }
3087 
3088         return (rval);
3089 }
3090 
3091 
3092 /*
3093  * scsa2usb_check_bulkonly_blacklist_attrs:
3094  *      validate "scsa2usb_blacklist_attrs" (see scsa2usb.h)
3095  *      if blacklisted attrs match accept the request
3096  *      attributes checked are:-
3097  *              SCSA2USB_ATTRS_START_STOP
3098  */
3099 int
3100 scsa2usb_check_bulkonly_blacklist_attrs(scsa2usb_state_t *scsa2usbp,
3101     scsa2usb_cmd_t *cmd, uchar_t opcode)
3102 {
3103         struct scsi_inquiry *inq =
3104             &scsa2usbp->scsa2usb_lun_inquiry[cmd->cmd_pkt->pkt_address.a_lun];
3105 
3106         USB_DPRINTF_L4(DPRINT_MASK_SCSA, scsa2usbp->scsa2usb_log_handle,
3107             "scsa2usb_check_bulkonly_blacklist_attrs: opcode = %s",
3108             scsi_cname(opcode, scsa2usb_cmds));
3109 
3110         ASSERT(mutex_owned(&scsa2usbp->scsa2usb_mutex));
3111 
3112         /*
3113          * decode and convert the packet
3114          * for most cmds, we can bcopy the cdb
3115          */
3116         switch (opcode) {
3117         case SCMD_DOORLOCK:
3118                 if (!(scsa2usbp->scsa2usb_attrs & SCSA2USB_ATTRS_DOORLOCK)) {
3119 
3120                         return (SCSA2USB_JUST_ACCEPT);
3121 
3122                 /*
3123                  * only lock the door for CD and DVD drives
3124                  */
3125                 } else if ((inq->inq_dtype == DTYPE_RODIRECT) ||
3126                     (inq->inq_dtype == DTYPE_OPTICAL)) {
3127 
3128                         if (inq->inq_rmb) {
3129 
3130                                 break;
3131                         }
3132                 }
3133 
3134                 return (SCSA2USB_JUST_ACCEPT);
3135 
3136         case SCMD_START_STOP:   /* SCMD_LOAD for sequential devices */
3137                 /*
3138                  * these devices don't have mechanics that spin the
3139                  * media up and down. So, it doesn't make much sense
3140                  * to issue this cmd.
3141                  *
3142                  * Furthermore, Hagiwara devices do not handle these
3143                  * cmds well. just accept this command as success.
3144                  */
3145                 if (!(scsa2usbp->scsa2usb_attrs & SCSA2USB_ATTRS_START_STOP)) {
3146 
3147                         return (SCSA2USB_JUST_ACCEPT);
3148 
3149                 } else if (inq->inq_dtype == DTYPE_SEQUENTIAL) {
3150                         /*
3151                          * In case of USB tape device, we need to send the
3152                          * command to the device to unload the media.
3153                          */
3154                         break;
3155 
3156                 } else if (cmd->cmd_pkt->pkt_cdbp[4] & LOEJECT) {
3157                         /*
3158                          * if the device is really a removable then
3159                          * pass it on to the device, else just accept
3160                          */
3161                         if (inq->inq_rmb) {
3162 
3163                                 break;
3164                         }
3165 
3166                         return (SCSA2USB_JUST_ACCEPT);
3167 
3168                 } else if (!scsa2usbp->scsa2usb_rcvd_not_ready) {
3169                         /*
3170                          * if we have not received a NOT READY condition,
3171                          * just accept since some device choke on this too.
3172                          * we do have to let EJECT get through though
3173                          */
3174                         return (SCSA2USB_JUST_ACCEPT);
3175                 }
3176 
3177                 break;
3178         case SCMD_INQUIRY:
3179                 /*
3180                  * Some devices do not handle the inquiry cmd well
3181                  * so build an inquiry and accept this command as
3182                  * success.
3183                  */
3184                 if (!(scsa2usbp->scsa2usb_attrs & SCSA2USB_ATTRS_INQUIRY)) {
3185                         uchar_t evpd = 0x01;
3186                         unsigned int bufsize;
3187                         int count;
3188 
3189                         if (cmd->cmd_pkt->pkt_cdbp[1] & evpd)
3190                                 return (SCSA2USB_REJECT);
3191 
3192                         scsa2usb_fake_inquiry(scsa2usbp, inq);
3193 
3194                         /* Copy no more than requested */
3195                         count = MIN(cmd->cmd_bp->b_bcount,
3196                             sizeof (struct scsi_inquiry));
3197                         bufsize = cmd->cmd_pkt->pkt_cdbp[4];
3198                         count = MIN(count, bufsize);
3199                         bcopy(inq, cmd->cmd_bp->b_un.b_addr, count);
3200 
3201                         cmd->cmd_pkt->pkt_resid = bufsize - count;
3202                         cmd->cmd_pkt->pkt_state |= STATE_XFERRED_DATA;
3203 
3204                         return (SCSA2USB_JUST_ACCEPT);
3205                 } else if (!(scsa2usbp->scsa2usb_attrs &
3206                     SCSA2USB_ATTRS_INQUIRY_EVPD)) {
3207                         /*
3208                          * Some devices do not handle the inquiry cmd with
3209                          * evpd bit set well, e.g. some devices return the
3210                          * same page 0x83 data which will cause the generated
3211                          * devid by sd is not unique, thus return CHECK
3212                          * CONDITION directly to sd.
3213                          */
3214                         uchar_t evpd = 0x01;
3215 
3216                         if (!(cmd->cmd_pkt->pkt_cdbp[1] & evpd))
3217                                 break;
3218 
3219                         if (cmd->cmd_bp) {
3220                                 cmd->cmd_pkt->pkt_resid = cmd->cmd_bp->
3221                                     b_bcount;
3222                         }
3223                         scsa2usb_force_invalid_request(scsa2usbp, cmd);
3224 
3225                         return (SCSA2USB_JUST_ACCEPT);
3226                 }
3227                 break;
3228         /*
3229          * Fake accepting the following  Opcodes
3230          * (as most drives don't support these)
3231          * These are needed by format command.
3232          */
3233         case SCMD_RESERVE:
3234         case SCMD_RELEASE:
3235         case SCMD_PERSISTENT_RESERVE_IN:
3236         case SCMD_PERSISTENT_RESERVE_OUT:
3237 
3238                 return (SCSA2USB_JUST_ACCEPT);
3239 
3240         case SCMD_MODE_SENSE:
3241         case SCMD_MODE_SELECT:
3242         case SCMD_MODE_SENSE_G1:
3243         case SCMD_MODE_SELECT_G1:
3244                 if (!(scsa2usbp->scsa2usb_attrs & SCSA2USB_ATTRS_MODE_SENSE)) {
3245                         if (cmd->cmd_bp) {
3246                                 cmd->cmd_pkt->pkt_resid = cmd->cmd_bp->
3247                                     b_bcount;
3248                         }
3249                         scsa2usb_force_invalid_request(scsa2usbp, cmd);
3250 
3251                         return (SCSA2USB_JUST_ACCEPT);
3252                 }
3253 
3254                 break;
3255         default:
3256 
3257                 break;
3258         }
3259 
3260         return (SCSA2USB_TRANSPORT);
3261 }
3262 
3263 
3264 /*
3265  * scsa2usb_handle_scsi_cmd_sub_class:
3266  *      prepare a scsi cmd
3267  *      returns SCSA2USB_TRANSPORT, SCSA2USB_REJECT, SCSA2USB_JUST_ACCEPT
3268  */
3269 int
3270 scsa2usb_handle_scsi_cmd_sub_class(scsa2usb_state_t *scsa2usbp,
3271     scsa2usb_cmd_t *cmd, struct scsi_pkt *pkt)
3272 {
3273         uchar_t evpd = 0x01;
3274         USB_DPRINTF_L4(DPRINT_MASK_SCSA, scsa2usbp->scsa2usb_log_handle,
3275             "scsa2usb_handle_scsi_cmd_sub_class: cmd = 0x%p pkt = 0x%p",
3276             (void *)cmd, (void *)pkt);
3277 
3278         ASSERT(mutex_owned(&scsa2usbp->scsa2usb_mutex));
3279 
3280         bzero(&cmd->cmd_cdb, SCSI_CDB_SIZE);
3281         cmd->cmd_cdb[SCSA2USB_OPCODE] = pkt->pkt_cdbp[0];   /* Set the opcode */
3282         cmd->cmd_cdb[SCSA2USB_LUN] = pkt->pkt_cdbp[1];
3283 
3284         /*
3285          * decode and convert the packet
3286          * for most cmds, we can bcopy the cdb
3287          */
3288         switch (pkt->pkt_cdbp[0]) {
3289         case SCMD_FORMAT:
3290                 /*
3291                  * SCMD_FORMAT used to limit cmd->cmd_xfercount
3292                  * to 4 bytes, but this hangs
3293                  * formatting dvd media using cdrecord (that is,
3294                  * a SCSI FORMAT UNIT command with a parameter list > 4 bytes)
3295                  * (bit 4 in cdb1 is the Fmtdata bit)
3296                  */
3297                 if ((pkt->pkt_cdbp[1] & 0x10) && cmd->cmd_bp) {
3298                         cmd->cmd_xfercount = cmd->cmd_bp->b_bcount;
3299                 } else {
3300                         cmd->cmd_xfercount = 4;
3301                 }
3302                 cmd->cmd_dir = CBW_DIR_OUT;
3303                 cmd->cmd_actual_len = CDB_GROUP0;
3304                 bcopy(pkt->pkt_cdbp, &cmd->cmd_cdb, cmd->cmd_cdblen);
3305                 break;
3306 
3307         case SCMD_INQUIRY:
3308                 cmd->cmd_dir = CBW_DIR_IN;
3309                 cmd->cmd_actual_len = CDB_GROUP0;
3310                 cmd->cmd_cdb[SCSA2USB_LBA_0] = pkt->pkt_cdbp[2];
3311 
3312                 /*
3313                  * If vpd pages data is limited to maximum SCSA2USB_MAX_INQ_LEN,
3314                  * the page data may be truncated, which may cause some issues
3315                  * such as making the unique page 0x83 or 0x80 data from
3316                  * different devices become the same. So don't limit return
3317                  * length for vpd page inquiry cmd.
3318                  * Another, in order to maintain compatibility, the original
3319                  * length limitation for standard inquiry retains here. It
3320                  * can be removed in future if it is verified that enough
3321                  * devices can work well.
3322                  */
3323                 if (pkt->pkt_cdbp[1] & evpd) {
3324                         cmd->cmd_cdb[SCSA2USB_LBA_2] = cmd->cmd_xfercount =
3325                             (cmd->cmd_bp ? cmd->cmd_bp->b_bcount : 0);
3326                 } else {
3327                         cmd->cmd_cdb[SCSA2USB_LBA_2] = cmd->cmd_xfercount =
3328                             min(SCSA2USB_MAX_INQ_LEN,
3329                             cmd->cmd_bp ? cmd->cmd_bp->b_bcount : 0);
3330                 }
3331                 break;
3332 
3333         case SCMD_READ_CAPACITY:
3334                 cmd->cmd_dir = CBW_DIR_IN;
3335                 bcopy(pkt->pkt_cdbp, &cmd->cmd_cdb, cmd->cmd_cdblen);
3336                 cmd->cmd_xfercount = sizeof (scsa2usb_read_cap_t);
3337                 break;
3338 
3339         /*
3340          * SCMD_READ/SCMD_WRITE are converted to G1 cmds
3341          * (as ATAPI devices don't recognize G0 commands)
3342          *
3343          * SCMD_READ_LONG/SCMD_WRITE_LONG are handled in
3344          * scsa2usb_rw_transport() along with other commands.
3345          *
3346          * USB Host Controllers cannot handle large (read/write)
3347          * xfers. We split the large request to chunks of
3348          * smaller ones to meet the HCD limitations.
3349          */
3350         case SCMD_READ:
3351         case SCMD_WRITE:
3352         case SCMD_READ_G1:
3353         case SCMD_WRITE_G1:
3354         case SCMD_READ_G5:
3355         case SCMD_WRITE_G5:
3356         case SCMD_READ_LONG:
3357         case SCMD_WRITE_LONG:
3358         case SCMD_READ_CD:
3359                 switch (scsa2usbp->
3360                     scsa2usb_lun_inquiry[pkt->pkt_address.a_lun].
3361                     inq_dtype & DTYPE_MASK) {
3362                 case DTYPE_DIRECT:
3363                 case DTYPE_RODIRECT:
3364                 case DTYPE_OPTICAL:
3365                         return (scsa2usb_rw_transport(
3366                             scsa2usbp, pkt));
3367                 default:
3368                         bcopy(pkt->pkt_cdbp, &cmd->cmd_cdb, cmd->cmd_cdblen);
3369                         if (cmd->cmd_bp) {
3370                                 cmd->cmd_dir =
3371                                     (cmd->cmd_bp->b_flags & B_READ) ?
3372                                     CBW_DIR_IN : CBW_DIR_OUT;
3373                                 cmd->cmd_xfercount =
3374                                     cmd->cmd_bp->b_bcount;
3375                         }
3376                         break;
3377                 }
3378                 break;
3379 
3380         case SCMD_REQUEST_SENSE:
3381                 cmd->cmd_dir = CBW_DIR_IN;
3382                 cmd->cmd_xfercount = pkt->pkt_cdbp[4];
3383                 cmd->cmd_cdb[SCSA2USB_LBA_2] = pkt->pkt_cdbp[4];
3384                 cmd->cmd_actual_len = CDB_GROUP0;
3385                 break;
3386 
3387         case SCMD_DOORLOCK:
3388         case SCMD_START_STOP:
3389         case SCMD_TEST_UNIT_READY:
3390                 bcopy(pkt->pkt_cdbp, &cmd->cmd_cdb, cmd->cmd_cdblen);
3391                 break;
3392 
3393         /*
3394          * Needed by zip protocol to reset the device
3395          */
3396         case SCMD_SDIAG:
3397         case SCMD_REZERO_UNIT:
3398                 bcopy(pkt->pkt_cdbp, &cmd->cmd_cdb, cmd->cmd_cdblen);
3399                 cmd->cmd_actual_len = CDB_GROUP1;
3400                 break;
3401 
3402         case SCMD_WRITE_VERIFY:
3403                 bcopy(pkt->pkt_cdbp, &cmd->cmd_cdb, cmd->cmd_cdblen);
3404                 cmd->cmd_dir = CBW_DIR_OUT;
3405                 cmd->cmd_xfercount = (pkt->pkt_cdbp[7] << 8) | pkt->pkt_cdbp[8];
3406                 cmd->cmd_actual_len = CDB_GROUP1;
3407                 break;
3408 
3409         /*
3410          * Next command does not have a SCSI equivalent as
3411          * it is vendor specific.
3412          * It was listed in the vendor's ATAPI Zip specs.
3413          */
3414         case SCMD_READ_FORMAT_CAP:
3415                 bcopy(pkt->pkt_cdbp, &cmd->cmd_cdb, cmd->cmd_cdblen);
3416                 cmd->cmd_dir = CBW_DIR_IN;
3417                 cmd->cmd_xfercount = (pkt->pkt_cdbp[7] << 8) | pkt->pkt_cdbp[8];
3418                 cmd->cmd_actual_len = CDB_GROUP1;
3419                 break;
3420         case IOMEGA_CMD_CARTRIDGE_PROTECT:
3421                 cmd->cmd_dir = CBW_DIR_OUT;
3422                 cmd->cmd_cdb[SCSA2USB_LBA_2] = pkt->pkt_cdbp[4];
3423                 cmd->cmd_cdb[SCSA2USB_LBA_2] &= ~1;      /* Make it even */
3424                 cmd->cmd_cdb[SCSA2USB_LUN] = pkt->pkt_cdbp[1];
3425                 cmd->cmd_actual_len = CDB_GROUP0;
3426                 cmd->cmd_xfercount = pkt->pkt_cdbp[4]; /* Length of password */
3427                 break;
3428 
3429         /*
3430          * Do not convert SCMD_MODE_SENSE/SELECT to G1 cmds because
3431          * the mode header is different as well. USB devices don't
3432          * support 0x03 & 0x04 mode pages, which are already obsoleted
3433          * by SPC-2 specification.
3434          */
3435         case SCMD_MODE_SENSE:
3436         case SCMD_MODE_SELECT:
3437                 if (((pkt->pkt_cdbp[2] & SD_MODE_SENSE_PAGE_MASK)
3438                     == SD_MODE_SENSE_PAGE3_CODE) ||
3439                     ((pkt->pkt_cdbp[2] & SD_MODE_SENSE_PAGE_MASK)
3440                     == SD_MODE_SENSE_PAGE4_CODE)) {
3441                         if (cmd->cmd_bp) {
3442                                 cmd->cmd_pkt->pkt_resid = cmd->cmd_bp->b_bcount;
3443                         }
3444                         scsa2usb_force_invalid_request(scsa2usbp, cmd);
3445                         return (SCSA2USB_JUST_ACCEPT);
3446                 }
3447                 /* FALLTHROUGH */
3448 
3449         default:
3450                 /*
3451                  * an unknown command may be a uscsi cmd which we
3452                  * should let go thru without mapping
3453                  */
3454                 bcopy(pkt->pkt_cdbp, &cmd->cmd_cdb, cmd->cmd_cdblen);
3455                 if (cmd->cmd_bp) {
3456                         cmd->cmd_dir = (cmd->cmd_bp->b_flags & B_READ) ?
3457                             CBW_DIR_IN : CBW_DIR_OUT;
3458                         cmd->cmd_xfercount = cmd->cmd_bp->b_bcount;
3459                 }
3460 
3461                 break;
3462         } /* end of switch */
3463 
3464         USB_DPRINTF_L2(DPRINT_MASK_SCSA, scsa2usbp->scsa2usb_log_handle,
3465             "scsa2usb_handle_scsi_cmd_sub_class: opcode = 0x%x count = 0x%lx",
3466             pkt->pkt_cdbp[SCSA2USB_OPCODE], cmd->cmd_xfercount);
3467 
3468         cmd->cmd_total_xfercount = cmd->cmd_xfercount;
3469 
3470         return (SCSA2USB_TRANSPORT);
3471 }
3472 
3473 
3474 /*
3475  * scsa2usb_do_tur is performed before READ CAPACITY command is issued.
3476  * It returns media status, 0 for media ready, -1 for media not ready
3477  * or other errors.
3478  */
3479 static int
3480 scsa2usb_do_tur(scsa2usb_state_t *scsa2usbp, struct scsi_address *ap)
3481 {
3482         struct scsi_pkt         *pkt;
3483         scsa2usb_cmd_t          *turcmd;
3484         int                     rval = -1;
3485 
3486         USB_DPRINTF_L4(DPRINT_MASK_SCSA, scsa2usbp->scsa2usb_log_handle,
3487             "scsa2usb_do_tur:");
3488 
3489         ASSERT(mutex_owned(&scsa2usbp->scsa2usb_mutex));
3490 
3491         mutex_exit(&scsa2usbp->scsa2usb_mutex);
3492         if ((pkt = scsi_init_pkt(ap, NULL, NULL, CDB_GROUP0, 1,
3493             PKT_PRIV_LEN, PKT_CONSISTENT, SLEEP_FUNC, NULL)) == NULL) {
3494                 mutex_enter(&scsa2usbp->scsa2usb_mutex);
3495                 USB_DPRINTF_L2(DPRINT_MASK_SCSA,
3496                     scsa2usbp->scsa2usb_log_handle,
3497                     "scsa2usb_do_tur: init pkt failed");
3498 
3499                 return (rval);
3500         }
3501 
3502         RQ_MAKECOM_G0(pkt, FLAG_HEAD | FLAG_NODISCON,
3503             (char)SCMD_TEST_UNIT_READY, 0, 0);
3504 
3505         pkt->pkt_comp = NULL;
3506         pkt->pkt_time = PKT_DEFAULT_TIMEOUT;
3507         turcmd = PKT2CMD(pkt);
3508 
3509         mutex_enter(&scsa2usbp->scsa2usb_mutex);
3510         scsa2usb_prepare_pkt(scsa2usbp, turcmd->cmd_pkt);
3511 
3512         if (scsa2usb_cmd_transport(scsa2usbp, turcmd) != TRAN_ACCEPT) {
3513                 USB_DPRINTF_L2(DPRINT_MASK_SCSA,
3514                     scsa2usbp->scsa2usb_log_handle,
3515                     "scsa2usb_do_tur: cmd transport failed, "
3516                     "pkt_reason=0x%x", turcmd->cmd_pkt->pkt_reason);
3517         } else if (*(turcmd->cmd_pkt->pkt_scbp) != STATUS_GOOD) {
3518                 /*
3519                  * Theoretically, the sense data should be retrieved and
3520                  * sense key be checked when check condition happens. If
3521                  * the sense key is UNIT ATTENTION, TEST UNIT READY cmd
3522                  * needs to be sent again to clear the UNIT ATTENTION and
3523                  * another TUR to be sent to get the real media status.
3524                  * But the AMI virtual floppy device simply cannot recover
3525                  * from UNIT ATTENTION by re-sending a TUR cmd, so it
3526                  * doesn't make any difference whether to check sense key
3527                  * or not. Just ignore sense key checking here and assume
3528                  * the device is NOT READY.
3529                  */
3530                 USB_DPRINTF_L2(DPRINT_MASK_SCSA,
3531                     scsa2usbp->scsa2usb_log_handle,
3532                     "scsa2usb_do_tur: media not ready");
3533         } else {
3534                 rval = 0;
3535         }
3536 
3537         mutex_exit(&scsa2usbp->scsa2usb_mutex);
3538         scsi_destroy_pkt(pkt);
3539         mutex_enter(&scsa2usbp->scsa2usb_mutex);
3540 
3541         return (rval);
3542 }
3543 
3544 
3545 /*
3546  * scsa2usb_check_ufi_blacklist_attrs:
3547  *      validate "scsa2usb_blacklist_attrs" (see scsa2usb.h)
3548  *      if blacklisted attrs match accept the request
3549  *      attributes checked are:-
3550  *              SCSA2USB_ATTRS_GET_CONF
3551  *              SCSA2USB_ATTRS_GET_PERF
3552  *              SCSA2USB_ATTRS_GET_START_STOP
3553  */
3554 static int
3555 scsa2usb_check_ufi_blacklist_attrs(scsa2usb_state_t *scsa2usbp, uchar_t opcode,
3556     scsa2usb_cmd_t *cmd)
3557 {
3558         int     rval = SCSA2USB_TRANSPORT;
3559 
3560         ASSERT(mutex_owned(&scsa2usbp->scsa2usb_mutex));
3561 
3562         switch (opcode) {
3563         case SCMD_PRIN:
3564         case SCMD_PROUT:
3565                 rval = SCSA2USB_JUST_ACCEPT;
3566                 break;
3567         case SCMD_MODE_SENSE:
3568         case SCMD_MODE_SELECT:
3569                 if (cmd->cmd_bp) {
3570                         cmd->cmd_pkt->pkt_resid = cmd->cmd_bp->b_bcount;
3571                 }
3572                 scsa2usb_force_invalid_request(scsa2usbp, cmd);
3573                 rval = SCSA2USB_JUST_ACCEPT;
3574                 break;
3575         case SCMD_GET_CONFIGURATION:
3576                 if (!(scsa2usbp->scsa2usb_attrs & SCSA2USB_ATTRS_GET_CONF)) {
3577                         rval = SCSA2USB_JUST_ACCEPT;
3578                 }
3579                 break;
3580         case SCMD_GET_PERFORMANCE:
3581                 if (!(scsa2usbp->scsa2usb_attrs & SCSA2USB_ATTRS_GET_PERF)) {
3582                         rval = SCSA2USB_JUST_ACCEPT;
3583                 }
3584                 break;
3585         case SCMD_START_STOP:
3586                 /*
3587                  * some CB/CBI devices don't have mechanics that spin the
3588                  * media up and down. So, it doesn't make much sense
3589                  * to issue this cmd to those devices.
3590                  */
3591                 if (!(scsa2usbp->scsa2usb_attrs & SCSA2USB_ATTRS_START_STOP)) {
3592                         rval = SCSA2USB_JUST_ACCEPT;
3593                 }
3594                 break;
3595         case SCMD_READ_CAPACITY:
3596                 /*
3597                  * Some devices don't support READ CAPACITY command
3598                  * when media is not ready. Need to check media status
3599                  * before issuing the cmd to such device.
3600                  */
3601                 if (!(scsa2usbp->scsa2usb_attrs &
3602                     SCSA2USB_ATTRS_NO_MEDIA_CHECK)) {
3603                         struct scsi_pkt *pkt = cmd->cmd_pkt;
3604 
3605                         ASSERT(scsa2usbp->scsa2usb_cur_pkt == pkt);
3606                         scsa2usbp->scsa2usb_cur_pkt = NULL;
3607 
3608                         if (scsa2usb_do_tur(scsa2usbp,
3609                             &pkt->pkt_address) != 0) {
3610                                 /* media not ready, force cmd invalid */
3611                                 if (cmd->cmd_bp) {
3612                                         cmd->cmd_pkt->pkt_resid =
3613                                             cmd->cmd_bp->b_bcount;
3614                                 }
3615                                 scsa2usb_force_invalid_request(scsa2usbp, cmd);
3616                                 rval = SCSA2USB_JUST_ACCEPT;
3617                         }
3618 
3619                         scsa2usbp->scsa2usb_cur_pkt = pkt;
3620                 }
3621                 break;
3622         default:
3623                 break;
3624         }
3625 
3626         return (rval);
3627 }
3628 
3629 
3630 /*
3631  * scsa2usb_handle_ufi_subclass_cmd:
3632  *      prepare a UFI cmd
3633  *      returns SCSA2USB_TRANSPORT, SCSA2USB_REJECT
3634  */
3635 int
3636 scsa2usb_handle_ufi_subclass_cmd(scsa2usb_state_t *scsa2usbp,
3637     scsa2usb_cmd_t *cmd, struct scsi_pkt *pkt)
3638 {
3639         uchar_t opcode =  pkt->pkt_cdbp[0];
3640 
3641         USB_DPRINTF_L4(DPRINT_MASK_SCSA, scsa2usbp->scsa2usb_log_handle,
3642             "scsa2usb_handle_ufi_subclass_cmd: cmd = 0x%p pkt = 0x%p",
3643             (void *)cmd, (void *)pkt);
3644 
3645         ASSERT(mutex_owned(&scsa2usbp->scsa2usb_mutex));
3646 
3647         bzero(&cmd->cmd_cdb, SCSI_CDB_SIZE);
3648         cmd->cmd_cdb[SCSA2USB_OPCODE] = opcode;   /* Set the opcode */
3649         cmd->cmd_cdb[SCSA2USB_LUN] = pkt->pkt_cdbp[1];
3650 
3651         /*
3652          * decode and convert the packet if necessary
3653          * for most cmds, we can bcopy the cdb
3654          */
3655         switch (opcode) {
3656         case SCMD_FORMAT:
3657                 /* if parameter list is specified */
3658                 if (pkt->pkt_cdbp[1] & 0x10) {
3659                         cmd->cmd_xfercount =
3660                             (pkt->pkt_cdbp[7] << 8) | pkt->pkt_cdbp[8];
3661                         cmd->cmd_dir = USB_EP_DIR_OUT;
3662                         cmd->cmd_actual_len = CDB_GROUP5;
3663                 }
3664                 bcopy(pkt->pkt_cdbp, &cmd->cmd_cdb, cmd->cmd_cdblen);
3665                 break;
3666         case SCMD_INQUIRY:
3667                 cmd->cmd_dir = USB_EP_DIR_IN;
3668                 cmd->cmd_actual_len = CDB_GROUP0;
3669                 cmd->cmd_cdb[SCSA2USB_LBA_0] = pkt->pkt_cdbp[2];
3670                 cmd->cmd_cdb[SCSA2USB_LBA_2] = cmd->cmd_xfercount =
3671                     min(SCSA2USB_MAX_INQ_LEN,
3672                     cmd->cmd_bp ? cmd->cmd_bp->b_bcount : 0);
3673                 break;
3674         case SCMD_READ_CAPACITY:
3675                 cmd->cmd_dir = USB_EP_DIR_IN;
3676                 bcopy(pkt->pkt_cdbp, &cmd->cmd_cdb, cmd->cmd_cdblen);
3677                 cmd->cmd_xfercount = sizeof (scsa2usb_read_cap_t);
3678                 break;
3679         case SCMD_REQUEST_SENSE:
3680                 cmd->cmd_dir = USB_EP_DIR_IN;
3681                 cmd->cmd_xfercount = pkt->pkt_cdbp[4];
3682                 cmd->cmd_cdb[SCSA2USB_LBA_2] = pkt->pkt_cdbp[4];
3683                 cmd->cmd_actual_len = CDB_GROUP0;
3684                 break;
3685 
3686         /*
3687          * do not convert SCMD_MODE_SENSE/SELECT because the
3688          * mode header is different as well
3689          */
3690 
3691         /*
3692          * see usb_bulkonly.c for comments on the next set of commands
3693          */
3694         case SCMD_READ:
3695         case SCMD_WRITE:
3696         case SCMD_READ_G1:
3697         case SCMD_WRITE_G1:
3698         case SCMD_READ_G5:
3699         case SCMD_WRITE_G5:
3700         case SCMD_READ_LONG:
3701         case SCMD_WRITE_LONG:
3702         case SCMD_READ_CD:
3703 
3704                 return (scsa2usb_rw_transport(scsa2usbp, pkt));
3705 
3706         case SCMD_TEST_UNIT_READY:
3707                 /*
3708                  * Some CB/CBI devices may not support TUR.
3709                  */
3710                 bcopy(pkt->pkt_cdbp, &cmd->cmd_cdb, cmd->cmd_cdblen);
3711                 break;
3712         case SCMD_READ_FORMAT_CAP:
3713                 bcopy(pkt->pkt_cdbp, &cmd->cmd_cdb, cmd->cmd_cdblen);
3714                 cmd->cmd_dir = USB_EP_DIR_IN;
3715                 cmd->cmd_actual_len = CDB_GROUP1;
3716                 cmd->cmd_xfercount = (pkt->pkt_cdbp[7] << 8) | pkt->pkt_cdbp[8];
3717                 break;
3718         case SCMD_WRITE_VERIFY:
3719                 bcopy(pkt->pkt_cdbp, &cmd->cmd_cdb, cmd->cmd_cdblen);
3720                 cmd->cmd_dir = USB_EP_DIR_OUT;
3721                 cmd->cmd_actual_len = CDB_GROUP1;
3722                 cmd->cmd_xfercount = (pkt->pkt_cdbp[7] << 8) | pkt->pkt_cdbp[8];
3723                 break;
3724         case SCMD_START_STOP:
3725                 /* A larger timeout is needed for 'flaky' CD-RW devices */
3726                 if (!(scsa2usbp->scsa2usb_attrs & SCSA2USB_ATTRS_BIG_TIMEOUT)) {
3727                         cmd->cmd_timeout = max(cmd->cmd_timeout,
3728                             20 * SCSA2USB_BULK_PIPE_TIMEOUT);
3729                 }
3730                 /* FALLTHRU */
3731         default:
3732                 /*
3733                  * all other commands don't need special mapping
3734                  */
3735                 bcopy(pkt->pkt_cdbp, &cmd->cmd_cdb, cmd->cmd_cdblen);
3736                 if (cmd->cmd_bp) {
3737                         cmd->cmd_dir = (cmd->cmd_bp->b_flags & B_READ) ?
3738                             CBW_DIR_IN : CBW_DIR_OUT;
3739                         cmd->cmd_xfercount = cmd->cmd_bp->b_bcount;
3740                 }
3741                 break;
3742 
3743         } /* end of switch */
3744 
3745         USB_DPRINTF_L4(DPRINT_MASK_SCSA, scsa2usbp->scsa2usb_log_handle,
3746             "scsa2usb_handle_ufi_subclass_cmd: opcode = 0x%x count = 0x%lx",
3747             opcode, cmd->cmd_xfercount);
3748 
3749         cmd->cmd_total_xfercount = cmd->cmd_xfercount;
3750 
3751         return (SCSA2USB_TRANSPORT);
3752 }
3753 
3754 
3755 /*
3756  * scsa2usb_rw_transport:
3757  *      Handle splitting READ and WRITE requests to the
3758  *      device to a size that the host controller allows.
3759  *
3760  *      returns TRAN_* values and not USB_SUCCESS/FAILURE
3761  *
3762  * To support CD-R/CD-RW/DVD media, we need to support a
3763  * variety of block sizes for the different types of CD
3764  * data (audio, data, video, CD-XA, yellowbook, redbook etc.)
3765  *
3766  * Some of the block sizes used are:- 512, 1k, 2k, 2056, 2336
3767  * 2340, 2352, 2368, 2448, 2646, 2647 etc.
3768  *
3769  * NOTE: the driver could be entertaining a SCSI CDB that uses
3770  * any of the above listed block sizes at a given time, and a
3771  * totally different block size at any other given time for a
3772  * different CDB.
3773  *
3774  * We need to compute block size every time and figure out
3775  * matching LBA and LEN accordingly.
3776  *
3777  * Also UHCI has a limitation that it can only xfer 32k at a
3778  * given time. So, with "odd" sized blocks and a limitation of
3779  * how much we can xfer per shot, we need to compute xfer_count
3780  * as well each time.
3781  *
3782  * The same computation is also done in the function
3783  * scsa2usb_setup_next_xfer().  To save computing block_size in
3784  * this function, I am saving block_size in "cmd" now.
3785  */
3786 int
3787 scsa2usb_rw_transport(scsa2usb_state_t *scsa2usbp, struct scsi_pkt *pkt)
3788 {
3789         scsa2usb_cmd_t *cmd = PKT2CMD(pkt);
3790         int lba, dir, opcode;
3791         struct buf *bp = cmd->cmd_bp;
3792         size_t len, xfer_count;
3793         size_t blk_size;        /* calculate the block size to be used */
3794         int sz;
3795 
3796         USB_DPRINTF_L4(DPRINT_MASK_SCSA, scsa2usbp->scsa2usb_log_handle,
3797             "scsa2usb_rw_transport:");
3798 
3799         ASSERT(mutex_owned(&scsa2usbp->scsa2usb_mutex));
3800 
3801         opcode = pkt->pkt_cdbp[0];
3802         blk_size  = scsa2usbp->scsa2usb_lbasize[pkt->pkt_address.a_lun];
3803                                                 /* set to default */
3804 
3805         switch (opcode) {
3806         case SCMD_READ:
3807                 /*
3808                  * Note that READ/WRITE(6) are not supported by the drive.
3809                  * convert it into a 10 byte read/write.
3810                  */
3811                 lba = SCSA2USB_LBA_6BYTE(pkt);
3812                 len = SCSA2USB_LEN_6BYTE(pkt);
3813                 opcode = SCMD_READ_G1;  /* Overwrite it w/ byte 10 cmd val */
3814                 dir = USB_EP_DIR_IN;
3815                 break;
3816         case SCMD_WRITE:
3817                 lba = SCSA2USB_LBA_6BYTE(pkt);
3818                 len = SCSA2USB_LEN_6BYTE(pkt);
3819                 opcode = SCMD_WRITE_G1; /* Overwrite it w/ byte 10 cmd val */
3820                 dir = USB_EP_DIR_OUT;
3821                 break;
3822         case SCMD_READ_G1:
3823         case SCMD_READ_LONG:
3824                 lba = SCSA2USB_LBA_10BYTE(pkt);
3825                 len = SCSA2USB_LEN_10BYTE(pkt);
3826                 dir = USB_EP_DIR_IN;
3827                 break;
3828         case SCMD_WRITE_G1:
3829         case SCMD_WRITE_LONG:
3830                 lba = SCSA2USB_LBA_10BYTE(pkt);
3831                 len = SCSA2USB_LEN_10BYTE(pkt);
3832                 dir = USB_EP_DIR_OUT;
3833                 if (len) {
3834                         sz = SCSA2USB_CDRW_BLKSZ(bp ? bp->b_bcount : 0, len);
3835                         if (SCSA2USB_VALID_CDRW_BLKSZ(sz)) {
3836                                 blk_size = sz;  /* change it accordingly */
3837                         }
3838                 }
3839                 break;
3840         case SCMD_READ_CD:
3841                 lba = SCSA2USB_LBA_10BYTE(pkt);
3842                 len = SCSA2USB_LEN_READ_CD(pkt);
3843                 dir = USB_EP_DIR_IN;
3844 
3845                 /* Figure out the block size */
3846                 blk_size = scsa2usb_read_cd_blk_size(pkt->pkt_cdbp[1] >> 2);
3847                 break;
3848         case SCMD_READ_G5:
3849                 lba = SCSA2USB_LBA_12BYTE(pkt);
3850                 len = SCSA2USB_LEN_12BYTE(pkt);
3851                 dir = USB_EP_DIR_IN;
3852                 break;
3853         case SCMD_WRITE_G5:
3854                 lba = SCSA2USB_LBA_12BYTE(pkt);
3855                 len = SCSA2USB_LEN_12BYTE(pkt);
3856                 dir = USB_EP_DIR_OUT;
3857                 break;
3858         }
3859 
3860         cmd->cmd_total_xfercount = xfer_count = len * blk_size;
3861 
3862         /* reduce xfer count if necessary */
3863         if (blk_size &&
3864             (xfer_count > scsa2usbp->scsa2usb_max_bulk_xfer_size)) {
3865                 /*
3866                  * For CD-RW devices reduce the xfer count based
3867                  * on the block size used by these devices. The
3868                  * block size could change for READ_CD and WRITE
3869                  * opcodes.
3870                  *
3871                  * Also as UHCI allows a max xfer of 32k at a time;
3872                  * compute the xfer_count based on the new block_size.
3873                  *
3874                  * The len part of the cdb changes as a result of that.
3875                  */
3876                 if (SCSA2USB_VALID_CDRW_BLKSZ(blk_size)) {
3877                         xfer_count = ((scsa2usbp->scsa2usb_max_bulk_xfer_size/
3878                             blk_size) * blk_size);
3879                         len = xfer_count/blk_size;
3880                         xfer_count = blk_size * len;
3881                 } else {
3882                         xfer_count = scsa2usbp->scsa2usb_max_bulk_xfer_size;
3883                         len = xfer_count/blk_size;
3884                 }
3885         }
3886 
3887         cmd->cmd_xfercount = xfer_count;
3888         cmd->cmd_dir = (uchar_t)dir;
3889         cmd->cmd_blksize = (int)blk_size;
3890 
3891         /*
3892          * Having figure out the 'partial' xfer len based on he
3893          * block size; fill it in to the cmd->cmd_cdb
3894          */
3895         cmd->cmd_cdb[SCSA2USB_OPCODE] = (uchar_t)opcode;
3896         switch (opcode) {
3897         case SCMD_READ_CD:
3898                 bcopy(pkt->pkt_cdbp, &cmd->cmd_cdb, cmd->cmd_cdblen);
3899                 scsa2usb_fill_up_ReadCD_cdb_len(cmd, len, CDB_GROUP5);
3900                 break;
3901         case SCMD_WRITE_G5:
3902         case SCMD_READ_G5:
3903                 scsa2usb_fill_up_12byte_cdb_len(cmd, len, CDB_GROUP5);
3904                 break;
3905         default:
3906                 scsa2usb_fill_up_cdb_len(cmd, len);
3907                 cmd->cmd_actual_len = CDB_GROUP1;
3908                 break;
3909         }
3910 
3911         scsa2usb_fill_up_cdb_lba(cmd, lba);
3912 
3913         USB_DPRINTF_L3(DPRINT_MASK_SCSA, scsa2usbp->scsa2usb_log_handle,
3914             "bcount=0x%lx lba=0x%x len=0x%lx xfercount=0x%lx total=0x%lx",
3915             bp ? bp->b_bcount : 0, lba, len, cmd->cmd_xfercount,
3916             cmd->cmd_total_xfercount);
3917 
3918         /* Set the timeout value as per command request */
3919         if ((opcode == SCMD_WRITE_G1) && SCSA2USB_VALID_CDRW_BLKSZ(blk_size)) {
3920                 /*
3921                  * We increase the time as CD-RW writes have two things
3922                  * to do. After writing out the data to the media, a
3923                  * TOC needs to be filled up at the beginning of the media
3924                  * This is when the write gets "finalized".
3925                  * Hence the actual write could take longer than the
3926                  * value specified in cmd->cmd_timeout.
3927                  */
3928                 cmd->cmd_timeout *= 4;
3929 
3930                 USB_DPRINTF_L4(DPRINT_MASK_SCSA,
3931                     scsa2usbp->scsa2usb_log_handle,
3932                     "new timeout value = 0x%x", cmd->cmd_timeout);
3933         }
3934 
3935         USB_DPRINTF_L4(DPRINT_MASK_SCSA, scsa2usbp->scsa2usb_log_handle,
3936             "lba 0x%x len 0x%lx xfercount 0x%lx total 0x%lx",
3937             lba, len, cmd->cmd_xfercount, cmd->cmd_total_xfercount);
3938 
3939         return (SCSA2USB_TRANSPORT);
3940 }
3941 
3942 
3943 /*
3944  * scsa2usb_setup_next_xfer:
3945  *      For READs and WRITEs we split up the transfer in terms of
3946  *      HCD understood units. This function handles the split transfers.
3947  *
3948  * See comments in the previous function scsa2usb_rw_transport
3949  *
3950  * The lba computation was being done based on scsa2usb_max_bulk_xfer_size
3951  * earlier. With CD-RW devices, the xfer_count and the block_size may
3952  * no longer be a multiple of scsa2usb_max_bulk_xfer_size. So compute
3953  * xfer_count all over again. Adjust lba, based on the previous requests'
3954  * len. Find out the len and add it to cmd->cmd_lba to get the new lba
3955  */
3956 void
3957 scsa2usb_setup_next_xfer(scsa2usb_state_t *scsa2usbp, scsa2usb_cmd_t *cmd)
3958 {
3959         int xfer_len = min(scsa2usbp->scsa2usb_max_bulk_xfer_size,
3960             cmd->cmd_total_xfercount);
3961         int cdb_len;
3962         size_t blk_size;
3963 
3964         ASSERT(mutex_owned(&scsa2usbp->scsa2usb_mutex));
3965 
3966         USB_DPRINTF_L4(DPRINT_MASK_SCSA, scsa2usbp->scsa2usb_log_handle,
3967             "scsa2usb_setup_next_xfer: opcode = 0x%x lba = 0x%x "
3968             "total count = 0x%lx", cmd->cmd_cdb[SCSA2USB_OPCODE],
3969             cmd->cmd_lba, cmd->cmd_total_xfercount);
3970 
3971         ASSERT(cmd->cmd_total_xfercount > 0);
3972         cmd->cmd_xfercount = xfer_len;
3973         blk_size = scsa2usbp->scsa2usb_lbasize[
3974             cmd->cmd_pkt->pkt_address.a_lun];
3975 
3976         /*
3977          * For CD-RW devices reduce the xfer count based on the
3978          * block_size used by these devices. See changes below
3979          * where xfer_count is being adjusted.
3980          *
3981          * Also adjust len/lba based on the block_size and xfer_count.
3982          * NOTE: Always calculate lba first, as it based on previous
3983          * commands' values.
3984          */
3985         switch (cmd->cmd_cdb[SCSA2USB_OPCODE]) {
3986         case SCMD_READ_CD:
3987                 /* calculate lba = current_lba + len_of_prev_cmd */
3988                 cmd->cmd_lba += (cmd->cmd_cdb[6] << 16) +
3989                     (cmd->cmd_cdb[7] << 8) + cmd->cmd_cdb[8];
3990                 cdb_len = xfer_len/cmd->cmd_blksize;
3991                 cmd->cmd_cdb[SCSA2USB_READ_CD_LEN_2] = (uchar_t)cdb_len;
3992                 /* re-adjust xfer count */
3993                 cmd->cmd_xfercount = cdb_len * cmd->cmd_blksize;
3994                 break;
3995         case SCMD_WRITE_G5:
3996         case SCMD_READ_G5:
3997                 /* calculate lba = current_lba + len_of_prev_cmd */
3998                 cmd->cmd_lba += (cmd->cmd_cdb[6] << 24) +
3999                     (cmd->cmd_cdb[7] << 16) + (cmd->cmd_cdb[8] << 8) +
4000                     cmd->cmd_cdb[9];
4001                 if (blk_size) {
4002                         xfer_len /= blk_size;
4003                 }
4004                 scsa2usb_fill_up_12byte_cdb_len(cmd, xfer_len, CDB_GROUP5);
4005                 break;
4006         case SCMD_WRITE_G1:
4007         case SCMD_WRITE_LONG:
4008                 /* calculate lba = current_lba + len_of_prev_cmd */
4009                 cmd->cmd_lba += (cmd->cmd_cdb[7] << 8) + cmd->cmd_cdb[8];
4010                 if (SCSA2USB_VALID_CDRW_BLKSZ(cmd->cmd_blksize)) {
4011                         blk_size = cmd->cmd_blksize;
4012                 }
4013                 cdb_len = xfer_len/blk_size;
4014                 scsa2usb_fill_up_cdb_len(cmd, cdb_len);
4015                 /* re-adjust xfer count */
4016                 cmd->cmd_xfercount = cdb_len * blk_size;
4017                 break;
4018         default:
4019                 if (blk_size) {
4020                         xfer_len /= blk_size;
4021                 }
4022                 scsa2usb_fill_up_cdb_len(cmd, xfer_len);
4023                 cmd->cmd_lba += scsa2usbp->scsa2usb_max_bulk_xfer_size/blk_size;
4024         }
4025 
4026         /* fill in the lba */
4027         scsa2usb_fill_up_cdb_lba(cmd, cmd->cmd_lba);
4028 
4029         USB_DPRINTF_L4(DPRINT_MASK_SCSA, scsa2usbp->scsa2usb_log_handle,
4030             "scsa2usb_setup_next_xfer:\n\tlba = 0x%x xfer_len = 0x%x "
4031             "xfercount = 0x%lx total = 0x%lx", cmd->cmd_lba, xfer_len,
4032             cmd->cmd_xfercount, cmd->cmd_total_xfercount);
4033 }
4034 
4035 
4036 /*
4037  * take one request from the lun's waitQ and transport it
4038  */
4039 static void
4040 scsa2usb_transport_request(scsa2usb_state_t *scsa2usbp, uint_t lun)
4041 {
4042         int                     rval;
4043         struct scsi_pkt         *pkt;
4044         struct scsa2usb_cmd     *cmd, *arqcmd;
4045 
4046         if ((cmd = (scsa2usb_cmd_t *)
4047             usba_rm_first_pvt_from_list(
4048             &scsa2usbp->scsa2usb_waitQ[lun])) == NULL) {
4049 
4050                 return;
4051         }
4052         pkt = cmd->cmd_pkt;
4053 
4054         /*
4055          * if device has been disconnected, just complete it
4056          */
4057         if (scsa2usbp->scsa2usb_dev_state == USB_DEV_DISCONNECTED) {
4058                 USB_DPRINTF_L2(DPRINT_MASK_SCSA, scsa2usbp->scsa2usb_log_handle,
4059                     "device not accessible");
4060                 pkt->pkt_reason = CMD_DEV_GONE;
4061                 SCSA2USB_SET_PKT_DO_COMP_STATE(scsa2usbp);
4062                 scsa2usb_pkt_completion(scsa2usbp, pkt);
4063 
4064                 return;
4065         }
4066 
4067         USB_DPRINTF_L4(DPRINT_MASK_SCSA,
4068             scsa2usbp->scsa2usb_log_handle,
4069             "scsa2usb_transport_request: cmd=0x%p bp=0x%p addr=0x%p",
4070             (void *)cmd, (void *)cmd->cmd_bp,
4071             (void *)(cmd->cmd_bp ? cmd->cmd_bp->b_un.b_addr : NULL));
4072 
4073         rval = scsa2usb_cmd_transport(scsa2usbp, cmd);
4074 
4075         USB_DPRINTF_L3(DPRINT_MASK_SCSA,
4076             scsa2usbp->scsa2usb_log_handle,
4077             "scsa2usb_transport_request: transport rval = %d",
4078             rval);
4079 
4080         if (scsa2usbp->scsa2usb_cur_pkt == NULL) {
4081 
4082                 return;
4083         }
4084 
4085         ASSERT(pkt == scsa2usbp->scsa2usb_cur_pkt);
4086 
4087         if (ddi_in_panic()) {
4088                 pkt->pkt_reason = CMD_CMPLT;
4089                 scsa2usb_pkt_completion(scsa2usbp, pkt);
4090 
4091                 return;
4092         }
4093 
4094         /*
4095          * start an auto-request sense iff
4096          * there was a check condition, we have enough
4097          * space in the status block, and we have not
4098          * faked an auto request sense
4099          */
4100         if ((*(pkt->pkt_scbp) == STATUS_CHECK) &&
4101             (cmd->cmd_scblen >= sizeof (struct scsi_arq_status)) &&
4102             ((pkt->pkt_state & STATE_ARQ_DONE) == 0) &&
4103             (scsa2usb_create_arq_pkt(scsa2usbp,
4104             &pkt->pkt_address) == USB_SUCCESS)) {
4105                 arqcmd = scsa2usbp->scsa2usb_arq_cmd;
4106 
4107                 /*
4108                  * copy the timeout from the
4109                  * original packet
4110                  * for lack of a better value
4111                  */
4112                 arqcmd->cmd_pkt->pkt_time = pkt->pkt_time;
4113                 scsa2usb_prepare_pkt(scsa2usbp,
4114                     arqcmd->cmd_pkt);
4115 
4116                 scsa2usbp->scsa2usb_cur_pkt = NULL;
4117                 if (scsa2usb_cmd_transport(
4118                     scsa2usbp, arqcmd) == TRAN_ACCEPT) {
4119 
4120                         /* finish w/ this packet */
4121                         scsa2usb_complete_arq_pkt(
4122                             scsa2usbp, arqcmd->cmd_pkt, cmd,
4123                             scsa2usbp->scsa2usb_arq_bp);
4124 
4125                         /*
4126                          * we have valid request sense
4127                          * data so clear the pkt_reason
4128                          */
4129                         pkt->pkt_reason = CMD_CMPLT;
4130                 }
4131                 scsa2usbp->scsa2usb_cur_pkt = pkt;
4132                 scsa2usb_delete_arq_pkt(scsa2usbp);
4133         }
4134 
4135         if ((rval != TRAN_ACCEPT) &&
4136             (pkt->pkt_reason == CMD_CMPLT)) {
4137                 pkt->pkt_reason = CMD_TRAN_ERR;
4138         }
4139 
4140         SCSA2USB_SET_PKT_DO_COMP_STATE(scsa2usbp);
4141         scsa2usb_pkt_completion(scsa2usbp, pkt);
4142 
4143         ASSERT(scsa2usbp->scsa2usb_cur_pkt == NULL);
4144 }
4145 
4146 
4147 /*
4148  * scsa2usb_work_thread:
4149  *      The taskq thread that kicks off the transport (BO and CB/CBI)
4150  */
4151 static void
4152 scsa2usb_work_thread(void *arg)
4153 {
4154         scsa2usb_state_t        *scsa2usbp = (scsa2usb_state_t *)arg;
4155         uint_t                  lun;
4156         uint_t                  count;
4157 
4158         mutex_enter(&scsa2usbp->scsa2usb_mutex);
4159         USB_DPRINTF_L4(DPRINT_MASK_SCSA, scsa2usbp->scsa2usb_log_handle,
4160             "scsa2usb_work_thread start: thread_id=0x%p",
4161             (void *)scsa2usbp->scsa2usb_work_thread_id);
4162 
4163         ASSERT(scsa2usbp->scsa2usb_work_thread_id == (kthread_t *)1);
4164         scsa2usbp->scsa2usb_work_thread_id = curthread;
4165 
4166         /* exclude ugen accesses */
4167         while (scsa2usbp->scsa2usb_transport_busy) {
4168                 cv_wait(&scsa2usbp->scsa2usb_transport_busy_cv,
4169                     &scsa2usbp->scsa2usb_mutex);
4170         }
4171         ASSERT(scsa2usbp->scsa2usb_ugen_open_count == 0);
4172         scsa2usbp->scsa2usb_transport_busy++;
4173         scsa2usbp->scsa2usb_busy_proc = curproc;
4174 
4175         scsa2usb_raise_power(scsa2usbp);
4176 
4177         /* reopen the pipes if necessary */
4178         (void) scsa2usb_open_usb_pipes(scsa2usbp);
4179 
4180         for (;;) {
4181                 ASSERT(scsa2usbp->scsa2usb_ugen_open_count == 0);
4182                 for (lun = 0; lun < scsa2usbp->scsa2usb_n_luns; lun++) {
4183                         scsa2usb_transport_request(scsa2usbp, lun);
4184                 }
4185                 count = 0;
4186                 for (lun = 0; lun < SCSA2USB_MAX_LUNS; lun++) {
4187                         count += usba_list_entry_count(
4188                             &scsa2usbp->scsa2usb_waitQ[lun]);
4189                 }
4190 
4191                 if (count == 0) {
4192 
4193                         break;
4194                 }
4195         }
4196 
4197         scsa2usbp->scsa2usb_work_thread_id = 0;
4198 
4199         ASSERT(scsa2usbp->scsa2usb_ugen_open_count == 0);
4200 
4201         scsa2usbp->scsa2usb_transport_busy--;
4202         scsa2usbp->scsa2usb_busy_proc = NULL;
4203         cv_signal(&scsa2usbp->scsa2usb_transport_busy_cv);
4204 
4205         USB_DPRINTF_L4(DPRINT_MASK_SCSA, scsa2usbp->scsa2usb_log_handle,
4206             "scsa2usb_work_thread: exit");
4207 
4208         mutex_exit(&scsa2usbp->scsa2usb_mutex);
4209 
4210         scsa2usb_pm_idle_component(scsa2usbp);
4211 }
4212 
4213 
4214 /*
4215  * scsa2usb_flush_waitQ:
4216  *      empties the entire waitQ with errors asap.
4217  *
4218  * It is called from scsa2usb_scsi_reset and scsa2usb_panic_callb.
4219  * If the device is reset; we should empty the waitQ right away.
4220  * If the system has paniced; we should empty the waitQ right away.
4221  *
4222  * CPR suspend will only succeed if device is idle. No need to call
4223  * this function for CPR suspend case.
4224  */
4225 static void
4226 scsa2usb_flush_waitQ(scsa2usb_state_t *scsa2usbp, uint_t lun,
4227     uchar_t error)
4228 {
4229         struct scsi_pkt         *pkt;
4230         struct scsa2usb_cmd     *cmd;
4231         usba_list_entry_t       head;
4232 
4233         mutex_enter(&scsa2usbp->scsa2usb_mutex);
4234 
4235         usba_move_list(&scsa2usbp->scsa2usb_waitQ[lun], &head,
4236             scsa2usbp->scsa2usb_dev_data->dev_iblock_cookie);
4237         mutex_exit(&scsa2usbp->scsa2usb_mutex);
4238 
4239         while ((cmd = (scsa2usb_cmd_t *)usba_rm_first_pvt_from_list(&head)) !=
4240             NULL) {
4241                 pkt = cmd->cmd_pkt;
4242                 pkt->pkt_reason = error;     /* set error */
4243 
4244                 mutex_enter(&scsa2usbp->scsa2usb_mutex);
4245                 scsa2usbp->scsa2usb_pkt_state = SCSA2USB_PKT_DO_COMP;
4246                 scsa2usb_pkt_completion(scsa2usbp, pkt);
4247                 mutex_exit(&scsa2usbp->scsa2usb_mutex);
4248         } /* end of while */
4249 }
4250 
4251 
4252 /*
4253  * scsa2usb_do_inquiry is performed before INIT CHILD and we have
4254  * to fake a few things normally done by SCSA
4255  */
4256 static void
4257 scsa2usb_do_inquiry(scsa2usb_state_t *scsa2usbp, uint_t target, uint_t lun)
4258 {
4259         struct buf      *bp;
4260         struct scsi_pkt *pkt;
4261         struct scsi_address ap;
4262         int             len = SCSA2USB_MAX_INQ_LEN;
4263 
4264         USB_DPRINTF_L4(DPRINT_MASK_SCSA, scsa2usbp->scsa2usb_log_handle,
4265             "scsa2usb_do_inquiry: %d bytes", len);
4266 
4267         /* is it inquiry-challenged? */
4268         if (!(scsa2usbp->scsa2usb_attrs & SCSA2USB_ATTRS_INQUIRY)) {
4269                 scsa2usb_fake_inquiry(scsa2usbp,
4270                     &scsa2usbp->scsa2usb_lun_inquiry[lun]);
4271                 return;
4272         }
4273 
4274         ASSERT(mutex_owned(&scsa2usbp->scsa2usb_mutex));
4275 
4276         bzero(&ap, sizeof (struct scsi_address));
4277         ap.a_hba_tran = scsa2usbp->scsa2usb_tran;
4278         ap.a_target = (ushort_t)target;
4279         ap.a_lun = (uchar_t)lun;
4280 
4281         /* limit inquiry to 36 bytes */
4282         mutex_exit(&scsa2usbp->scsa2usb_mutex);
4283         if ((bp = scsi_alloc_consistent_buf(&ap, (struct buf *)NULL,
4284             len, B_READ, SLEEP_FUNC, NULL)) == NULL) {
4285                 mutex_enter(&scsa2usbp->scsa2usb_mutex);
4286                 USB_DPRINTF_L2(DPRINT_MASK_SCSA,
4287                     scsa2usbp->scsa2usb_log_handle,
4288                     "scsa2usb_do_inquiry: failed");
4289 
4290                 return;
4291         }
4292 
4293         pkt = scsi_init_pkt(&ap, NULL, bp, CDB_GROUP0, 1,
4294             PKT_PRIV_LEN, PKT_CONSISTENT, SLEEP_FUNC, NULL);
4295 
4296         RQ_MAKECOM_G0(pkt, FLAG_NOINTR, (char)SCMD_INQUIRY, 0, (char)len);
4297 
4298         pkt->pkt_comp = NULL;
4299         pkt->pkt_time = 5;
4300         bzero(bp->b_un.b_addr, len);
4301 
4302         USB_DPRINTF_L3(DPRINT_MASK_SCSA, scsa2usbp->scsa2usb_log_handle,
4303             "scsa2usb_do_inquiry:INQUIRY");
4304 
4305         (void) scsi_transport(pkt);
4306 
4307         if (pkt->pkt_reason) {
4308                 USB_DPRINTF_L2(DPRINT_MASK_SCSA,
4309                     scsa2usbp->scsa2usb_log_handle,
4310                     "INQUIRY failed, cannot determine device type, "
4311                     "pkt_reason=0x%x", pkt->pkt_reason);
4312 
4313                 /* not much hope for other cmds, reduce */
4314                 mutex_enter(&scsa2usbp->scsa2usb_mutex);
4315                 scsa2usbp->scsa2usb_attrs &=
4316                     ~SCSA2USB_ATTRS_REDUCED_CMD;
4317                 scsa2usb_fake_inquiry(scsa2usbp,
4318                     &scsa2usbp->scsa2usb_lun_inquiry[lun]);
4319                 mutex_exit(&scsa2usbp->scsa2usb_mutex);
4320         }
4321 
4322         scsi_destroy_pkt(pkt);
4323         scsi_free_consistent_buf(bp);
4324 
4325         mutex_enter(&scsa2usbp->scsa2usb_mutex);
4326 }
4327 
4328 
4329 /*
4330  * scsa2usb_fake_inquiry:
4331  *    build an inquiry for a given device that doesnt like inquiry
4332  *    commands.
4333  */
4334 static void
4335 scsa2usb_fake_inquiry(scsa2usb_state_t *scsa2usbp, struct scsi_inquiry *inqp)
4336 {
4337         usb_client_dev_data_t *dev_data = scsa2usbp->scsa2usb_dev_data;
4338         int len;
4339 
4340         USB_DPRINTF_L4(DPRINT_MASK_SCSA, scsa2usbp->scsa2usb_log_handle,
4341             "scsa2usb_fake_inquiry:");
4342 
4343         bzero(inqp, sizeof (struct scsi_inquiry));
4344         for (len = 0; len < sizeof (inqp->inq_vid); len++) {
4345                 *(inqp->inq_vid + len) = ' ';
4346         }
4347 
4348         for (len = 0; len < sizeof (inqp->inq_pid); len++) {
4349                 *(inqp->inq_pid + len) = ' ';
4350         }
4351 
4352         inqp->inq_dtype = DTYPE_DIRECT;
4353         inqp->inq_rmb = 1;
4354         inqp->inq_ansi = 2;
4355         inqp->inq_rdf = RDF_SCSI2;
4356         inqp->inq_len = sizeof (struct scsi_inquiry)-4;
4357 
4358         /* Fill in the Vendor id/Product id strings */
4359         if (dev_data->dev_mfg) {
4360                 if ((len = strlen(dev_data->dev_mfg)) >
4361                     sizeof (inqp->inq_vid)) {
4362                         len = sizeof (inqp->inq_vid);
4363                 }
4364                 bcopy(dev_data->dev_mfg, inqp->inq_vid, len);
4365         }
4366 
4367         if (dev_data->dev_product) {
4368                 if ((len = strlen(dev_data->dev_product)) >
4369                     sizeof (inqp->inq_pid)) {
4370                         len = sizeof (inqp->inq_pid);
4371                 }
4372                 bcopy(dev_data->dev_product, inqp->inq_pid, len);
4373         }
4374 
4375         /* Set the Revision to the Device */
4376         inqp->inq_revision[0] = 0x30 +
4377             ((dev_data->dev_descr->bcdDevice>>12) & 0xF);
4378         inqp->inq_revision[1] = 0x30 +
4379             ((dev_data->dev_descr->bcdDevice>>8) & 0xF);
4380         inqp->inq_revision[2] = 0x30 +
4381             ((dev_data->dev_descr->bcdDevice>>4) & 0xF);
4382         inqp->inq_revision[3] = 0x30 +
4383             ((dev_data->dev_descr->bcdDevice) & 0xF);
4384 }
4385 
4386 
4387 /*
4388  * scsa2usb_create_arq_pkt:
4389  *      Create and ARQ packet to get request sense data
4390  */
4391 static int
4392 scsa2usb_create_arq_pkt(scsa2usb_state_t *scsa2usbp, struct scsi_address *ap)
4393 {
4394         struct buf *bp;
4395         scsa2usb_cmd_t *arq_cmd;
4396 
4397         USB_DPRINTF_L4(DPRINT_MASK_SCSA, scsa2usbp->scsa2usb_log_handle,
4398             "scsa2usb_create_arq_pkt: scsa2usbp: %p, ap: %p",
4399             (void *)scsa2usbp, (void *)ap);
4400 
4401         ASSERT(mutex_owned(&scsa2usbp->scsa2usb_mutex));
4402 
4403         mutex_exit(&scsa2usbp->scsa2usb_mutex);
4404         if ((bp = scsi_alloc_consistent_buf(ap, (struct buf *)NULL,
4405             SENSE_LENGTH, B_READ, SLEEP_FUNC, NULL)) == NULL) {
4406                 mutex_enter(&scsa2usbp->scsa2usb_mutex);
4407 
4408                 return (USB_FAILURE);
4409         }
4410 
4411         arq_cmd = PKT2CMD(scsi_init_pkt(ap, NULL, bp, CDB_GROUP0, 1,
4412             PKT_PRIV_LEN, PKT_CONSISTENT, SLEEP_FUNC, NULL));
4413         mutex_enter(&scsa2usbp->scsa2usb_mutex);
4414 
4415         RQ_MAKECOM_G0(arq_cmd->cmd_pkt,
4416             FLAG_SENSING | FLAG_HEAD | FLAG_NODISCON,
4417             (char)SCMD_REQUEST_SENSE, 0, (char)SENSE_LENGTH);
4418 
4419         arq_cmd->cmd_pkt->pkt_ha_private = arq_cmd;
4420         scsa2usbp->scsa2usb_arq_cmd = arq_cmd;
4421         scsa2usbp->scsa2usb_arq_bp = bp;
4422         arq_cmd->cmd_pkt->pkt_comp = NULL;
4423         bzero(bp->b_un.b_addr, SENSE_LENGTH);
4424 
4425         return (USB_SUCCESS);
4426 }
4427 
4428 
4429 /*
4430  * scsa2usb_delete_arq_pkt:
4431  *      Destroy the ARQ packet
4432  */
4433 static void
4434 scsa2usb_delete_arq_pkt(scsa2usb_state_t *scsa2usbp)
4435 {
4436         USB_DPRINTF_L4(DPRINT_MASK_SCSA, scsa2usbp->scsa2usb_log_handle,
4437             "scsa2usb_delete_arq_pkt: cmd: 0x%p",
4438             (void *)scsa2usbp->scsa2usb_arq_cmd);
4439 
4440         ASSERT(mutex_owned(&scsa2usbp->scsa2usb_mutex));
4441 
4442         if (scsa2usbp->scsa2usb_arq_cmd != NULL) {
4443                 scsi_destroy_pkt(scsa2usbp->scsa2usb_arq_cmd->cmd_pkt);
4444                 scsi_free_consistent_buf(scsa2usbp->scsa2usb_arq_bp);
4445         }
4446         scsa2usbp->scsa2usb_arq_cmd = NULL;
4447         scsa2usbp->scsa2usb_arq_bp = NULL;
4448 }
4449 
4450 
4451 /*
4452  * scsa2usb_complete_arq_pkt:
4453  *      finish processing the arq packet
4454  */
4455 static void
4456 scsa2usb_complete_arq_pkt(scsa2usb_state_t *scsa2usbp,
4457     struct scsi_pkt *pkt, scsa2usb_cmd_t *ssp, struct buf *bp)
4458 {
4459         scsa2usb_cmd_t          *sp = pkt->pkt_ha_private;
4460         struct scsi_arq_status  *arqp;
4461 
4462         ASSERT(mutex_owned(&scsa2usbp->scsa2usb_mutex));
4463 
4464         arqp = (struct scsi_arq_status *)(ssp->cmd_pkt->pkt_scbp);
4465         arqp->sts_rqpkt_status = *((struct scsi_status *)
4466             (sp->cmd_pkt->pkt_scbp));
4467         arqp->sts_rqpkt_reason = CMD_CMPLT;
4468         arqp->sts_rqpkt_state |= STATE_XFERRED_DATA;
4469         arqp->sts_rqpkt_statistics = arqp->sts_rqpkt_resid = 0;
4470 
4471         /* is this meaningful sense data */
4472         if (*(bp->b_un.b_addr) != 0) {
4473                 bcopy(bp->b_un.b_addr, &arqp->sts_sensedata, SENSE_LENGTH);
4474                 ssp->cmd_pkt->pkt_state |= STATE_ARQ_DONE;
4475         }
4476 
4477         /* we will not sense start cmd until we receive a NOT READY */
4478         if (arqp->sts_sensedata.es_key == KEY_NOT_READY) {
4479                 scsa2usbp->scsa2usb_rcvd_not_ready = B_TRUE;
4480         }
4481 }
4482 
4483 
4484 /*
4485  * Miscellaneous functions for any command/transport
4486  */
4487 /*
4488  * scsa2usb_open_usb_pipes:
4489  *      set up a pipe policy
4490  *      open usb bulk pipes (BO and CB/CBI)
4491  *      open usb interrupt pipe (CBI)
4492  */
4493 static int
4494 scsa2usb_open_usb_pipes(scsa2usb_state_t *scsa2usbp)
4495 {
4496         int                     rval;
4497         usb_pipe_policy_t       policy; /* bulk pipe policy */
4498         size_t                  sz;
4499 
4500         ASSERT(scsa2usbp);
4501         ASSERT(mutex_owned(&scsa2usbp->scsa2usb_mutex));
4502 
4503         USB_DPRINTF_L4(DPRINT_MASK_SCSA, scsa2usbp->scsa2usb_log_handle,
4504             "scsa2usb_open_usb_pipes: dip = 0x%p flag = 0x%x",
4505             (void *)scsa2usbp->scsa2usb_dip, scsa2usbp->scsa2usb_flags);
4506 
4507         if (!(scsa2usbp->scsa2usb_flags & SCSA2USB_FLAGS_PIPES_OPENED)) {
4508 
4509                 /*
4510                  * one pipe policy for all bulk pipes
4511                  */
4512                 bzero(&policy, sizeof (usb_pipe_policy_t));
4513                 /* at least 2, for the normal and exceptional callbacks */
4514                 policy.pp_max_async_reqs = 1;
4515 
4516                 USB_DPRINTF_L4(DPRINT_MASK_SCSA, scsa2usbp->scsa2usb_log_handle,
4517                     "scsa2usb_open_usb_pipes: opening bulk pipes");
4518 
4519                 mutex_exit(&scsa2usbp->scsa2usb_mutex);
4520 
4521                 /* Open the USB bulk-in pipe */
4522                 if ((rval = usb_pipe_open(scsa2usbp->scsa2usb_dip,
4523                     &scsa2usbp->scsa2usb_bulkin_ept, &policy, USB_FLAGS_SLEEP,
4524                     &scsa2usbp->scsa2usb_bulkin_pipe)) != USB_SUCCESS) {
4525                         mutex_enter(&scsa2usbp->scsa2usb_mutex);
4526                         USB_DPRINTF_L2(DPRINT_MASK_SCSA,
4527                             scsa2usbp->scsa2usb_log_handle,
4528                             "scsa2usb_open_usb_pipes: bulk/in pipe open "
4529                             " failed rval = %d", rval);
4530 
4531                         return (USB_FAILURE);
4532                 }
4533 
4534                 /* Open the bulk-out pipe  using the same policy */
4535                 if ((rval = usb_pipe_open(scsa2usbp->scsa2usb_dip,
4536                     &scsa2usbp->scsa2usb_bulkout_ept, &policy, USB_FLAGS_SLEEP,
4537                     &scsa2usbp->scsa2usb_bulkout_pipe)) != USB_SUCCESS) {
4538                         usb_pipe_close(scsa2usbp->scsa2usb_dip,
4539                             scsa2usbp->scsa2usb_bulkin_pipe,
4540                             USB_FLAGS_SLEEP, NULL, NULL);
4541 
4542                         mutex_enter(&scsa2usbp->scsa2usb_mutex);
4543                         scsa2usbp->scsa2usb_bulkin_pipe = NULL;
4544 
4545                         USB_DPRINTF_L2(DPRINT_MASK_SCSA,
4546                             scsa2usbp->scsa2usb_log_handle,
4547                             "scsa2usb_open_usb_pipes: bulk/out pipe open"
4548                             " failed rval = %d", rval);
4549 
4550                         return (USB_FAILURE);
4551                 }
4552 
4553                 mutex_enter(&scsa2usbp->scsa2usb_mutex);
4554 
4555                 /* open interrupt pipe for CBI protocol */
4556                 if (SCSA2USB_IS_CBI(scsa2usbp)) {
4557                         mutex_exit(&scsa2usbp->scsa2usb_mutex);
4558 
4559                         if ((rval = usb_pipe_open(scsa2usbp->scsa2usb_dip,
4560                             &scsa2usbp->scsa2usb_intr_ept, &policy,
4561                             USB_FLAGS_SLEEP, &scsa2usbp->scsa2usb_intr_pipe)) !=
4562                             USB_SUCCESS) {
4563                                 usb_pipe_close(scsa2usbp->scsa2usb_dip,
4564                                     scsa2usbp->scsa2usb_bulkin_pipe,
4565                                     USB_FLAGS_SLEEP, NULL, NULL);
4566 
4567                                 usb_pipe_close(scsa2usbp->scsa2usb_dip,
4568                                     scsa2usbp->scsa2usb_bulkout_pipe,
4569                                     USB_FLAGS_SLEEP, NULL, NULL);
4570 
4571                                 mutex_enter(&scsa2usbp->scsa2usb_mutex);
4572                                 scsa2usbp->scsa2usb_bulkin_pipe = NULL;
4573                                 scsa2usbp->scsa2usb_bulkout_pipe = NULL;
4574 
4575                                 USB_DPRINTF_L2(DPRINT_MASK_SCSA,
4576                                     scsa2usbp->scsa2usb_log_handle,
4577                                     "scsa2usb_open_usb_pipes: intr pipe open"
4578                                     " failed rval = %d", rval);
4579 
4580                                 return (USB_FAILURE);
4581                         }
4582 
4583                         mutex_enter(&scsa2usbp->scsa2usb_mutex);
4584                 }
4585 
4586                 mutex_exit(&scsa2usbp->scsa2usb_mutex);
4587 
4588                 /* get the max transfer size of the bulk pipe */
4589                 if (usb_pipe_get_max_bulk_transfer_size(scsa2usbp->scsa2usb_dip,
4590                     &sz) == USB_SUCCESS) {
4591                         mutex_enter(&scsa2usbp->scsa2usb_mutex);
4592                         scsa2usbp->scsa2usb_max_bulk_xfer_size = sz;
4593                 } else {
4594                         mutex_enter(&scsa2usbp->scsa2usb_mutex);
4595                         scsa2usbp->scsa2usb_max_bulk_xfer_size = DEV_BSIZE;
4596                 }
4597 
4598                 /* limit the xfer size */
4599                 scsa2usbp->scsa2usb_max_bulk_xfer_size = min(
4600                     scsa2usbp->scsa2usb_max_bulk_xfer_size,
4601                     scsa2usb_max_bulk_xfer_size);
4602 
4603                 USB_DPRINTF_L4(DPRINT_MASK_SCSA, scsa2usbp->scsa2usb_log_handle,
4604                     "scsa2usb_open_usb_pipes: max bulk transfer size = %lx",
4605                     scsa2usbp->scsa2usb_max_bulk_xfer_size);
4606 
4607                 /* Set the pipes opened flag */
4608                 scsa2usbp->scsa2usb_flags |= SCSA2USB_FLAGS_PIPES_OPENED;
4609 
4610                 scsa2usbp->scsa2usb_pipe_state = SCSA2USB_PIPE_NORMAL;
4611 
4612                 /* Set the state to NONE */
4613                 scsa2usbp->scsa2usb_pkt_state = SCSA2USB_PKT_NONE;
4614         }
4615 
4616         return (USB_SUCCESS);
4617 }
4618 
4619 
4620 /*
4621  * scsa2usb_close_usb_pipes:
4622  *      close all pipes synchronously
4623  */
4624 void
4625 scsa2usb_close_usb_pipes(scsa2usb_state_t *scsa2usbp)
4626 {
4627         usb_flags_t flags = USB_FLAGS_SLEEP;
4628 
4629         USB_DPRINTF_L4(DPRINT_MASK_SCSA, scsa2usbp->scsa2usb_log_handle,
4630             "scsa2usb_close_usb_pipes: scsa2usb_state = 0x%p",
4631             (void *)scsa2usbp);
4632 
4633         ASSERT(scsa2usbp);
4634         ASSERT(mutex_owned(&scsa2usbp->scsa2usb_mutex));
4635 
4636         if ((scsa2usbp->scsa2usb_flags & SCSA2USB_FLAGS_PIPES_OPENED) == 0) {
4637 
4638                 return;
4639         }
4640 
4641         scsa2usbp->scsa2usb_pipe_state = SCSA2USB_PIPE_CLOSING;
4642         /* to avoid races, reset the flag first */
4643         scsa2usbp->scsa2usb_flags &= ~SCSA2USB_FLAGS_PIPES_OPENED;
4644 
4645         mutex_exit(&scsa2usbp->scsa2usb_mutex);
4646 
4647         usb_pipe_close(scsa2usbp->scsa2usb_dip,
4648             scsa2usbp->scsa2usb_bulkout_pipe, flags, NULL, NULL);
4649 
4650         usb_pipe_close(scsa2usbp->scsa2usb_dip,
4651             scsa2usbp->scsa2usb_bulkin_pipe, flags, NULL, NULL);
4652 
4653         mutex_enter(&scsa2usbp->scsa2usb_mutex);
4654         if (SCSA2USB_IS_CBI(scsa2usbp)) {
4655                 mutex_exit(&scsa2usbp->scsa2usb_mutex);
4656                 usb_pipe_close(scsa2usbp->scsa2usb_dip,
4657                     scsa2usbp->scsa2usb_intr_pipe, flags, NULL, NULL);
4658                 mutex_enter(&scsa2usbp->scsa2usb_mutex);
4659         }
4660         scsa2usbp->scsa2usb_bulkout_pipe = NULL;
4661         scsa2usbp->scsa2usb_bulkin_pipe = NULL;
4662         scsa2usbp->scsa2usb_intr_pipe = NULL;
4663 
4664         scsa2usbp->scsa2usb_pipe_state = SCSA2USB_PIPE_NORMAL;
4665 }
4666 
4667 
4668 /*
4669  * scsa2usb_fill_up_cdb_lba:
4670  *      fill up command CDBs' LBA part
4671  */
4672 static void
4673 scsa2usb_fill_up_cdb_lba(scsa2usb_cmd_t *cmd, int lba)
4674 {
4675         /* zero cdb1, lba bits so they won't get copied in the new cdb */
4676         cmd->cmd_cdb[SCSA2USB_LUN] &= 0xE0;
4677         cmd->cmd_cdb[SCSA2USB_LBA_0] = lba >> 24;
4678         cmd->cmd_cdb[SCSA2USB_LBA_1] = lba >> 16;
4679         cmd->cmd_cdb[SCSA2USB_LBA_2] = lba >> 8;
4680         cmd->cmd_cdb[SCSA2USB_LBA_3] = (uchar_t)lba;
4681         cmd->cmd_lba = lba;
4682 }
4683 
4684 
4685 /*
4686  * scsa2usb_fill_up_ReadCD_cdb_len:
4687  *      fill up READ_CD command CDBs' len part
4688  */
4689 static void
4690 scsa2usb_fill_up_ReadCD_cdb_len(scsa2usb_cmd_t *cmd, int len, int actual_len)
4691 {
4692         cmd->cmd_cdb[SCSA2USB_READ_CD_LEN_0] = len >> 16;
4693         cmd->cmd_cdb[SCSA2USB_READ_CD_LEN_1] = len >> 8;
4694         cmd->cmd_cdb[SCSA2USB_READ_CD_LEN_2] = (uchar_t)len;
4695         cmd->cmd_actual_len = (uchar_t)actual_len;
4696 }
4697 
4698 
4699 /*
4700  * scsa2usb_fill_up_12byte_cdb_len:
4701  *      fill up generic 12-byte command CDBs' len part
4702  */
4703 static void
4704 scsa2usb_fill_up_12byte_cdb_len(scsa2usb_cmd_t *cmd, int len, int actual_len)
4705 {
4706         cmd->cmd_cdb[6] = len >> 24;
4707         cmd->cmd_cdb[7] = len >> 16;
4708         cmd->cmd_cdb[8] = len >> 8;
4709         cmd->cmd_cdb[9] = (uchar_t)len;
4710         cmd->cmd_actual_len = (uchar_t)actual_len;
4711 }
4712 
4713 
4714 /*
4715  * scsa2usb_fill_up_cdb_len:
4716  *      fill up generic 10-byte command CDBs' len part
4717  */
4718 static void
4719 scsa2usb_fill_up_cdb_len(scsa2usb_cmd_t *cmd, int len)
4720 {
4721         cmd->cmd_cdb[SCSA2USB_LEN_0] = len >> 8;
4722         cmd->cmd_cdb[SCSA2USB_LEN_1] = (uchar_t)len;
4723 }
4724 
4725 
4726 /*
4727  * scsa2usb_read_cd_blk_size:
4728  *      For SCMD_READ_CD opcode (0xbe). Figure out the
4729  *      block size based on expected sector type field
4730  *      definition. See MMC SCSI Specs section 6.1.15
4731  *
4732  *      Based on the value of the "expected_sector_type"
4733  *      field, the block size could be different.
4734  */
4735 static int
4736 scsa2usb_read_cd_blk_size(uchar_t expected_sector_type)
4737 {
4738         int blk_size;
4739 
4740         switch (expected_sector_type) {
4741         case READ_CD_EST_CDDA:
4742                 blk_size = CDROM_BLK_2352;
4743                 break;
4744         case READ_CD_EST_MODE2:
4745                 blk_size = CDROM_BLK_2336;
4746                 break;
4747         case READ_CD_EST_MODE2FORM2:
4748                 blk_size = CDROM_BLK_2324;
4749                 break;
4750         case READ_CD_EST_MODE2FORM1:
4751         case READ_CD_EST_ALLTYPE:
4752         case READ_CD_EST_MODE1:
4753         default:
4754                 blk_size = CDROM_BLK_2048;
4755         }
4756 
4757         USB_DPRINTF_L4(DPRINT_MASK_SCSA, NULL, "scsa2usb_read_cd_blk_size: "
4758             "est = 0x%x blk_size = %d", expected_sector_type, blk_size);
4759 
4760         return (blk_size);
4761 }
4762 
4763 
4764 /*
4765  * scsa2usb_bp_to_mblk:
4766  *      Convert a bp to mblk_t. USBA framework understands mblk_t.
4767  */
4768 static mblk_t *
4769 scsa2usb_bp_to_mblk(scsa2usb_state_t *scsa2usbp)
4770 {
4771         size_t          size;
4772         mblk_t          *mp;
4773         struct buf      *bp;
4774         scsa2usb_cmd_t  *cmd = PKT2CMD(scsa2usbp->scsa2usb_cur_pkt);
4775 
4776         USB_DPRINTF_L4(DPRINT_MASK_SCSA, scsa2usbp->scsa2usb_log_handle,
4777             "scsa2usb_bp_to_mblk: ");
4778 
4779         ASSERT(scsa2usbp->scsa2usb_cur_pkt);
4780         ASSERT(mutex_owned(&scsa2usbp->scsa2usb_mutex));
4781 
4782         bp = cmd->cmd_bp;
4783 
4784         if (bp && (bp->b_bcount > 0)) {
4785                 size = ((bp->b_bcount > cmd->cmd_xfercount) ?
4786                     cmd->cmd_xfercount : bp->b_bcount);
4787         } else {
4788 
4789                 return (NULL);
4790         }
4791 
4792         mp = esballoc_wait((uchar_t *)bp->b_un.b_addr + cmd->cmd_offset,
4793             size, BPRI_LO, &frnop);
4794 
4795         USB_DPRINTF_L3(DPRINT_MASK_SCSA, scsa2usbp->scsa2usb_log_handle,
4796             "scsa2usb_bp_to_mblk: "
4797             "mp=0x%p bp=0x%p pkt=0x%p off=0x%lx sz=%lu add=0x%p",
4798             (void *)mp, (void *)bp, (void *)scsa2usbp->scsa2usb_cur_pkt,
4799             cmd->cmd_offset, bp->b_bcount - cmd->cmd_offset,
4800             (void *)bp->b_un.b_addr);
4801 
4802         mp->b_wptr += size;
4803         cmd->cmd_offset += size;
4804 
4805         return (mp);
4806 }
4807 
4808 
4809 /*
4810  * scsa2usb_handle_data_start:
4811  *      Initiate the data xfer. It could be IN/OUT direction.
4812  *
4813  *      Data IN:
4814  *              Send out the bulk-xfer request
4815  *              if rval implies STALL
4816  *                      clear endpoint stall and reset bulk-in pipe
4817  *                      handle data read in so far; set cmd->cmd_done
4818  *                      also adjust data xfer length accordingly
4819  *              else other error
4820  *                      report back to transport
4821  *                      typically transport will call reset recovery
4822  *              else (no error)
4823  *                      return success
4824  *
4825  *      Data OUT:
4826  *              Send out the bulk-xfer request
4827  *              if rval implies STALL
4828  *                      clear endpoint stall and reset bulk-in pipe
4829  *                      adjust data xfer length
4830  *              else other error
4831  *                      report back to transport
4832  *                      typically transport will call reset recovery
4833  *              else (no error)
4834  *                      return success
4835  *
4836  *      NOTE: We call this function only if there is xfercount.
4837  */
4838 int
4839 scsa2usb_handle_data_start(scsa2usb_state_t *scsa2usbp,
4840     scsa2usb_cmd_t *cmd, usb_bulk_req_t *req)
4841 {
4842         int             rval = USB_SUCCESS;
4843         uint_t          ept_addr;
4844         usb_flags_t     flags = USB_FLAGS_SLEEP;
4845 #ifdef  SCSA2USB_BULK_ONLY_TEST
4846         usb_req_attrs_t attrs = 0;
4847 #else
4848         usb_req_attrs_t attrs = USB_ATTRS_SHORT_XFER_OK;
4849 #endif
4850 
4851         USB_DPRINTF_L4(DPRINT_MASK_SCSA, scsa2usbp->scsa2usb_log_handle,
4852             "scsa2usb_handle_data_start: BEGIN cmd = %p, req = %p",
4853             (void *)cmd, (void *)req);
4854 
4855         ASSERT(mutex_owned(&scsa2usbp->scsa2usb_mutex));
4856 
4857         switch (cmd->cmd_dir) {
4858         case USB_EP_DIR_IN:
4859 #ifdef  SCSA2USB_BULK_ONLY_TEST
4860                 /*
4861                  * This case occurs when the host expects to receive
4862                  * more data than the device actually transfers. Hi > Di
4863                  */
4864                 if (scsa2usb_test_case_5) {
4865                         usb_bulk_req_t *req2;
4866 
4867                         req->bulk_len = cmd->cmd_xfercount - 1;
4868                         req->bulk_attributes = 0;
4869                         mutex_exit(&scsa2usbp->scsa2usb_mutex);
4870                         SCSA2USB_FREE_MSG(req->bulk_data);
4871                         req->bulk_data = allocb_wait(req->bulk_len, BPRI_LO,
4872                             STR_NOSIG, NULL);
4873 
4874                         ASSERT(req->bulk_timeout);
4875                         rval = usb_pipe_bulk_xfer(
4876                             scsa2usbp->scsa2usb_bulkin_pipe, req, flags);
4877                         mutex_enter(&scsa2usbp->scsa2usb_mutex);
4878                         USB_DPRINTF_L1(DPRINT_MASK_SCSA,
4879                             scsa2usbp->scsa2usb_log_handle, "rval = %x", rval);
4880 
4881                         req2 = scsa2usb_init_bulk_req(scsa2usbp,
4882                             cmd->cmd_xfercount + 2,
4883                             cmd->cmd_timeout, 0, flags);
4884                         req2->bulk_len = cmd->cmd_xfercount + 2;
4885                         mutex_exit(&scsa2usbp->scsa2usb_mutex);
4886 
4887                         ASSERT(req2->bulk_timeout);
4888                         rval = usb_pipe_bulk_xfer(
4889                             scsa2usbp->scsa2usb_bulkin_pipe, req2, flags);
4890                         mutex_enter(&scsa2usbp->scsa2usb_mutex);
4891 
4892                         USB_DPRINTF_L1(DPRINT_MASK_SCSA,
4893                             scsa2usbp->scsa2usb_log_handle,
4894                             "TEST 5: Hi > Di: rval = 0x%x", rval);
4895                         scsa2usb_test_case_5 = 0;
4896                         usb_free_bulk_req(req2);
4897 
4898                         return (rval);
4899                 }
4900 
4901                 /*
4902                  * This happens when the host expects to send data to the
4903                  * device while the device intends to send data to the host.
4904                  */
4905                 if (scsa2usb_test_case_8 && (cmd->cmd_cdb[0] == SCMD_READ_G1)) {
4906                         USB_DPRINTF_L1(DPRINT_MASK_SCSA,
4907                             scsa2usbp->scsa2usb_log_handle,
4908                             "TEST 8: Hi <> Do: Step 2");
4909                         scsa2usb_test_mblk(scsa2usbp, B_TRUE);
4910                         scsa2usb_test_case_8 = 0;
4911 
4912                         return (rval);
4913                 }
4914 #endif  /* SCSA2USB_BULK_ONLY_TEST */
4915 
4916                 ept_addr = scsa2usbp->scsa2usb_bulkin_ept.bEndpointAddress;
4917                 req->bulk_len = cmd->cmd_xfercount;
4918                 req->bulk_attributes = attrs;
4919                 SCSA2USB_FREE_MSG(req->bulk_data);
4920                 mutex_exit(&scsa2usbp->scsa2usb_mutex);
4921 
4922                 req->bulk_data = esballoc_wait(
4923                     (uchar_t *)cmd->cmd_bp->b_un.b_addr +
4924                     cmd->cmd_offset,
4925                     req->bulk_len, BPRI_LO, &frnop);
4926 
4927                 ASSERT(req->bulk_timeout);
4928                 rval = usb_pipe_bulk_xfer(scsa2usbp->scsa2usb_bulkin_pipe,
4929                     req, flags);
4930                 mutex_enter(&scsa2usbp->scsa2usb_mutex);
4931 
4932                 break;
4933 
4934         case USB_EP_DIR_OUT:
4935 #ifdef  SCSA2USB_BULK_ONLY_TEST
4936                 /*
4937                  * This happens when the host expects to receive data
4938                  * from the device while the device intends to receive
4939                  * data from the host.
4940                  */
4941                 if (scsa2usb_test_case_10 &&
4942                     (cmd->cmd_cdb[0] == SCMD_WRITE_G1)) {
4943                         req->bulk_len = CSW_LEN;
4944                         mutex_exit(&scsa2usbp->scsa2usb_mutex);
4945 
4946                         ASSERT(req->bulk_timeout);
4947                         rval = usb_pipe_bulk_xfer(
4948                             scsa2usbp->scsa2usb_bulkin_pipe, req, flags);
4949                         mutex_enter(&scsa2usbp->scsa2usb_mutex);
4950 
4951                         USB_DPRINTF_L1(DPRINT_MASK_SCSA,
4952                             scsa2usbp->scsa2usb_log_handle,
4953                             "TEST 10: Ho <> Di: done rval = 0x%x",  rval);
4954                         scsa2usb_test_case_10 = 0;
4955 
4956                         return (rval);
4957                 }
4958 #endif  /* SCSA2USB_BULK_ONLY_TEST */
4959 
4960                 req->bulk_data = scsa2usb_bp_to_mblk(scsa2usbp);
4961                 if (req->bulk_data == NULL) {
4962 
4963                         return (USB_FAILURE);
4964                 }
4965 
4966 #ifdef  SCSA2USB_BULK_ONLY_TEST
4967                 if (scsa2usb_test_case_11) {
4968                         /*
4969                          * Host expects to send data to the device and
4970                          * device doesn't expect to receive any data
4971                          */
4972                         USB_DPRINTF_L1(DPRINT_MASK_SCSA,
4973                             scsa2usbp->scsa2usb_log_handle, "TEST 11: Ho > Do");
4974 
4975                         scsa2usb_test_mblk(scsa2usbp, B_FALSE);
4976                         scsa2usb_test_case_11 = 0;
4977                 }
4978 #endif  /* SCSA2USB_BULK_ONLY_TEST */
4979 
4980                 ept_addr = scsa2usbp->scsa2usb_bulkout_ept.bEndpointAddress;
4981                 req->bulk_len = MBLKL(req->bulk_data);
4982                 req->bulk_timeout = scsa2usb_bulk_timeout(cmd->cmd_timeout);
4983                 mutex_exit(&scsa2usbp->scsa2usb_mutex);
4984 
4985                 ASSERT(req->bulk_timeout);
4986                 rval = usb_pipe_bulk_xfer(scsa2usbp->scsa2usb_bulkout_pipe,
4987                     req, flags);
4988                 mutex_enter(&scsa2usbp->scsa2usb_mutex);
4989                 break;
4990         }
4991 
4992         USB_DPRINTF_L3(DPRINT_MASK_SCSA,
4993             scsa2usbp->scsa2usb_log_handle,
4994             "scsa2usb_handle_data_start: rval=%d cr=%d", rval,
4995             req->bulk_completion_reason);
4996 
4997         if (rval != USB_SUCCESS) {
4998                 /* Handle Errors now */
4999                 if (req->bulk_completion_reason == USB_CR_STALL) {
5000                         if (cmd->cmd_dir == USB_EP_DIR_IN) {
5001                                 (void) scsa2usb_clear_ept_stall(
5002                                     scsa2usbp, ept_addr,
5003                                     scsa2usbp-> scsa2usb_bulkin_pipe,
5004                                     "bulk-in");
5005                         } else {
5006                                 (void) scsa2usb_clear_ept_stall(
5007                                     scsa2usbp, ept_addr,
5008                                     scsa2usbp-> scsa2usb_bulkout_pipe,
5009                                     "bulk-out");
5010                         }
5011                 }
5012 
5013                 /* no more data to transfer after this */
5014                 cmd->cmd_done = 1;
5015         }
5016 
5017         USB_DPRINTF_L4(DPRINT_MASK_SCSA, scsa2usbp->scsa2usb_log_handle,
5018             "scsa2usb_handle_data_start: END %s data rval = %d",
5019             (cmd->cmd_dir == USB_EP_DIR_IN) ? "bulk-in" : "bulk-out", rval);
5020 
5021         return (rval);
5022 }
5023 
5024 
5025 /*
5026  * scsa2usb_handle_data_done:
5027  *      This function handles the completion of the data xfer.
5028  *      It also massages the inquiry data. This function may
5029  *      also be called after a stall.
5030  */
5031 void
5032 scsa2usb_handle_data_done(scsa2usb_state_t *scsa2usbp,
5033     scsa2usb_cmd_t *cmd, usb_bulk_req_t *req)
5034 {
5035         struct buf      *bp = cmd->cmd_bp;
5036         struct scsi_pkt *pkt = scsa2usbp->scsa2usb_cur_pkt;
5037         mblk_t          *data = req->bulk_data;
5038         int             len = data ? MBLKL(data) : 0;
5039         uint32_t        max_lba;
5040 
5041         ASSERT(mutex_owned(&scsa2usbp->scsa2usb_mutex));
5042 
5043         USB_DPRINTF_L4(DPRINT_MASK_SCSA, scsa2usbp->scsa2usb_log_handle,
5044             "scsa2usb_handle_data_done:\n\tcmd = 0x%p data = 0x%p len = 0x%x",
5045             (void *)cmd, (void *)data, len);
5046 
5047         cmd->cmd_resid_xfercount = cmd->cmd_xfercount - len;
5048 
5049         if (len)  {
5050                 uchar_t *p;
5051                 uchar_t dtype;
5052                 scsa2usb_read_cap_t *cap;
5053                 struct scsi_inquiry *inq;
5054 
5055                 switch (cmd->cmd_cdb[SCSA2USB_OPCODE]) {
5056                 case SCMD_INQUIRY:
5057                         /*
5058                          * cache a copy of the inquiry data for our own use
5059                          * but ensure that we have at least up to
5060                          * inq_revision, inq_serial is not required.
5061                          * ignore inquiry data returned for inquiry commands
5062                          * with SCSI-3 EVPD, CmdDt bits set.
5063                          */
5064                         if (((cmd->cmd_cdb[SCSA2USB_LUN] & 0x1f) == 0) &&
5065                             (len >= SCSA2USB_MAX_INQ_LEN)) {
5066                                 inq = (struct scsi_inquiry *)data->b_rptr;
5067                                 dtype = inq->inq_dtype & DTYPE_MASK;
5068                                 /*
5069                                  * scsi framework sends zero byte write(10) cmd
5070                                  * to (Simplified) direct-access devices with
5071                                  * inquiry version > 2 for reservation changes.
5072                                  * But some USB devices don't support zero byte
5073                                  * write(10) even though they have inquiry
5074                                  * version > 2. Considering scsa2usb driver
5075                                  * doesn't support reservation and all the
5076                                  * reservation cmds are being faked, we fake
5077                                  * the inquiry version to 0 to make scsi
5078                                  * framework send test unit ready cmd which is
5079                                  * supported by all the usb devices.
5080                                  */
5081                                 if (((dtype == DTYPE_DIRECT) ||
5082                                     (dtype == DTYPE_RBC)) &&
5083                                     (inq->inq_ansi > 2)) {
5084                                         inq->inq_ansi = 0;
5085                                 }
5086 
5087                                 bzero(&scsa2usbp->scsa2usb_lun_inquiry
5088                                     [pkt->pkt_address.a_lun],
5089                                     sizeof (struct scsi_inquiry));
5090                                 bcopy(data->b_rptr,
5091                                     &scsa2usbp->scsa2usb_lun_inquiry
5092                                     [pkt->pkt_address.a_lun], len);
5093                         }
5094 
5095                         USB_DPRINTF_L3(DPRINT_MASK_SCSA,
5096                             scsa2usbp->scsa2usb_log_handle,
5097                             "scsi inquiry type = 0x%x",
5098                             scsa2usbp->scsa2usb_lun_inquiry
5099                             [pkt->pkt_address.a_lun].inq_dtype);
5100 
5101                         cmd->cmd_done = 1;
5102                         goto handle_data;
5103 
5104                 case SCMD_READ_CAPACITY:
5105                         cap = (scsa2usb_read_cap_t *)data->b_rptr;
5106 
5107                         /* Figure out the logical block size */
5108                         if ((len >= sizeof (struct scsa2usb_read_cap)) &&
5109                             (req->bulk_completion_reason == USB_CR_OK)) {
5110                                 scsa2usbp->
5111                                     scsa2usb_lbasize[pkt->pkt_address.a_lun] =
5112                                     SCSA2USB_MK_32BIT(
5113                                     cap->scsa2usb_read_cap_blen3,
5114                                     cap->scsa2usb_read_cap_blen2,
5115                                     cap->scsa2usb_read_cap_blen1,
5116                                     cap->scsa2usb_read_cap_blen0);
5117 
5118                                 max_lba = SCSA2USB_MK_32BIT(
5119                                     cap->scsa2usb_read_cap_lba3,
5120                                     cap->scsa2usb_read_cap_lba2,
5121                                     cap->scsa2usb_read_cap_lba1,
5122                                     cap->scsa2usb_read_cap_lba0);
5123 
5124                                 /*
5125                                  * Some devices return total logical block
5126                                  * number instead of highest logical block
5127                                  * address. Adjust the value by minus 1.
5128                                  */
5129                                 if (max_lba > 0 && (scsa2usbp->scsa2usb_attrs &
5130                                     SCSA2USB_ATTRS_NO_CAP_ADJUST) == 0) {
5131                                         max_lba -= 1;
5132                                         cap->scsa2usb_read_cap_lba0 =
5133                                             (uchar_t)(max_lba & 0xFF);
5134                                         cap->scsa2usb_read_cap_lba1 =
5135                                             (uchar_t)(max_lba >> 8 & 0xFF);
5136                                         cap->scsa2usb_read_cap_lba2 =
5137                                             (uchar_t)(max_lba >> 16 & 0xFF);
5138                                         cap->scsa2usb_read_cap_lba3 =
5139                                             (uchar_t)(max_lba >> 24 & 0xFF);
5140                                 }
5141 
5142                                 USB_DPRINTF_L2(DPRINT_MASK_SCSA,
5143                                     scsa2usbp->scsa2usb_log_handle,
5144                                     "bytes in each logical block=0x%lx,"
5145                                     "number of total logical blocks=0x%x",
5146                                     scsa2usbp->
5147                                     scsa2usb_lbasize[pkt->pkt_address.a_lun],
5148                                     max_lba + 1);
5149                         }
5150                         cmd->cmd_done = 1;
5151                         goto handle_data;
5152 
5153                 case SCMD_REQUEST_SENSE:
5154                         p = data->b_rptr;
5155                         USB_DPRINTF_L2(DPRINT_MASK_SCSA,
5156                             scsa2usbp->scsa2usb_log_handle,
5157                             "cdb: %x rqsense: "
5158                             "%x %x %x %x %x %x %x %x %x %x\n\t"
5159                             "%x %x %x %x %x %x %x %x %x %x",
5160                             cmd->cmd_cdb[0],
5161                             p[0], p[1], p[2], p[3], p[4],
5162                             p[5], p[6], p[7], p[8], p[9],
5163                             p[10], p[11], p[12], p[13], p[14],
5164                             p[15], p[16], p[17], p[18], p[19]);
5165 
5166                         scsa2usbp->scsa2usb_last_cmd.status = p[2];
5167                         cmd->cmd_done = 1;
5168                         /* FALLTHROUGH */
5169 
5170                 default:
5171 handle_data:
5172                         if (bp && len && (cmd->cmd_dir == USB_EP_DIR_IN)) {
5173                                 /*
5174                                  * we don't have to copy the data, the
5175                                  * data pointers for the mblk_t for
5176                                  * the bulk-in xfer points to the
5177                                  * struct buf * data.
5178                                  */
5179                                 cmd->cmd_offset += len;
5180                         }
5181 
5182                         USB_DPRINTF_L3(DPRINT_MASK_SCSA,
5183                             scsa2usbp->scsa2usb_log_handle,
5184                             "len = 0x%x total = 0x%lx offset = 0x%lx",
5185                             len, cmd->cmd_total_xfercount, cmd->cmd_offset);
5186 
5187                         /*
5188                          * update total_xfercount now but it may be
5189                          * adjusted after receiving the residue
5190                          */
5191                         cmd->cmd_total_xfercount -= len;
5192 
5193                         if ((req->bulk_completion_reason != USB_CR_OK) ||
5194                             (cmd->cmd_resid_xfercount != 0) ||
5195                             (cmd->cmd_total_xfercount == 0)) {
5196                                 /* set pkt_resid to total to be sure */
5197                                 pkt->pkt_resid = cmd->cmd_total_xfercount;
5198                                 cmd->cmd_done = 1;
5199                         }
5200 
5201                         break;
5202                 }
5203         } else {
5204                 if (cmd->cmd_dir == USB_EP_DIR_OUT) {
5205                         if (cmd->cmd_total_xfercount == 0) {
5206                                 cmd->cmd_done = 1;
5207                         }
5208                 }
5209         }
5210 }
5211 
5212 
5213 /*
5214  * scsa2usb_init_bulk_req:
5215  *      Allocate (synchronously) and fill in a bulk-request
5216  */
5217 usb_bulk_req_t *
5218 scsa2usb_init_bulk_req(scsa2usb_state_t *scsa2usbp, size_t length,
5219     uint_t timeout, usb_req_attrs_t attrs, usb_flags_t flags)
5220 {
5221         usb_bulk_req_t  *req;
5222 
5223         ASSERT(mutex_owned(&scsa2usbp->scsa2usb_mutex));
5224 
5225         req = usb_alloc_bulk_req(scsa2usbp->scsa2usb_dip, length,
5226             flags | USB_FLAGS_SLEEP);
5227 
5228         req->bulk_len = (uint_t)length;                      /* xfer length */
5229         req->bulk_timeout = scsa2usb_bulk_timeout(timeout); /* xfer timeout */
5230         req->bulk_attributes = attrs;                /* xfer attrs */
5231         req->bulk_client_private = (usb_opaque_t)scsa2usbp; /* statep */
5232 
5233         return (req);
5234 }
5235 
5236 
5237 /*
5238  * scsa2usb_bulk_timeout:
5239  *      ensure that bulk requests do not have infinite timeout values
5240  */
5241 int
5242 scsa2usb_bulk_timeout(int timeout)
5243 {
5244         return ((timeout == 0) ? scsa2usb_long_timeout : timeout);
5245 }
5246 
5247 
5248 /*
5249  * scsa2usb_clear_ept_stall:
5250  *      clear endpoint stall and reset pipes
5251  */
5252 int
5253 scsa2usb_clear_ept_stall(scsa2usb_state_t *scsa2usbp, uint_t ept_addr,
5254     usb_pipe_handle_t ph, char *what)
5255 {
5256         int rval;
5257         dev_info_t *dip = scsa2usbp->scsa2usb_dip;
5258 
5259         ASSERT(mutex_owned(&scsa2usbp->scsa2usb_mutex));
5260         if (!(SCSA2USB_DEVICE_ACCESS_OK(scsa2usbp))) {
5261 
5262                 return (USB_FAILURE);
5263         }
5264 
5265         mutex_exit(&scsa2usbp->scsa2usb_mutex);
5266         rval = usb_clr_feature(dip, USB_DEV_REQ_RCPT_EP, 0, ept_addr,
5267             USB_FLAGS_SLEEP, NULL, NULL);
5268 
5269         usb_pipe_reset(dip, ph, USB_FLAGS_SLEEP, NULL, NULL);
5270 
5271         mutex_enter(&scsa2usbp->scsa2usb_mutex);
5272         USB_DPRINTF_L4(DPRINT_MASK_SCSA, scsa2usbp->scsa2usb_log_handle,
5273             "scsa2usb_clear_ept_stall: on %s: ept = 0x%x rval = %d",
5274             what, ept_addr, rval);
5275 
5276         return (rval);
5277 }
5278 
5279 
5280 /*
5281  * scsa2usb_pkt_completion:
5282  *      Handle pkt completion.
5283  */
5284 static void
5285 scsa2usb_pkt_completion(scsa2usb_state_t *scsa2usbp, struct scsi_pkt *pkt)
5286 {
5287         scsa2usb_cmd_t *cmd = PKT2CMD(pkt);
5288         size_t len;
5289 
5290         ASSERT(pkt);
5291         ASSERT(mutex_owned(&scsa2usbp->scsa2usb_mutex));
5292 
5293         USB_DPRINTF_L3(DPRINT_MASK_SCSA, scsa2usbp->scsa2usb_log_handle,
5294             "scsa2usb_pkt_completion:\n\tscsa2usbp = 0x%p "
5295             "reason=%d, status=%d state=0x%x stats=0x%x resid=0x%lx",
5296             (void *)scsa2usbp, pkt->pkt_reason, *(pkt->pkt_scbp),
5297             pkt->pkt_state, pkt->pkt_statistics, pkt->pkt_resid);
5298 
5299         if (pkt->pkt_reason == CMD_CMPLT) {
5300                 pkt->pkt_state |= STATE_GOT_BUS | STATE_GOT_TARGET |
5301                     STATE_SENT_CMD | STATE_GOT_STATUS;
5302                 if (cmd->cmd_xfercount) {
5303                         pkt->pkt_state |= STATE_XFERRED_DATA;
5304                 }
5305         } else {
5306                 pkt->pkt_state |= STATE_GOT_BUS | STATE_GOT_TARGET |
5307                     STATE_SENT_CMD;
5308         }
5309 
5310         /*
5311          * don't zap the current state when in panic as this will
5312          * make debugging harder
5313          */
5314         if ((scsa2usbp->scsa2usb_cur_pkt == pkt) && !ddi_in_panic()) {
5315                 SCSA2USB_RESET_CUR_PKT(scsa2usbp);
5316 
5317                 len = sizeof (scsa2usbp->scsa2usb_last_cmd.cdb);
5318                 bzero(scsa2usbp->scsa2usb_last_cmd.cdb, len);
5319 
5320                 len = (len < cmd->cmd_cdblen) ? len : cmd->cmd_cdblen;
5321                 USB_DPRINTF_L3(DPRINT_MASK_SCSA,
5322                     scsa2usbp->scsa2usb_log_handle,
5323                     "scsa2usb_pkt_completion: save last cmd, len=%ld", len);
5324 
5325                 /* save the last command */
5326                 bcopy(pkt->pkt_cdbp, scsa2usbp->scsa2usb_last_cmd.cdb, len);
5327 
5328                 /* reset the scsa2usb_last_cmd.status value */
5329                 if ((pkt->pkt_cdbp[0] != SCMD_REQUEST_SENSE) &&
5330                     (pkt->pkt_cdbp[0] != SCMD_INQUIRY)) {
5331                         scsa2usbp->scsa2usb_last_cmd.status = 0;
5332                 }
5333 
5334                 /*
5335                  * set pkt state to NONE *before* calling back as the target
5336                  * driver will immediately submit the next packet
5337                  */
5338                 scsa2usbp->scsa2usb_pkt_state = SCSA2USB_PKT_NONE;
5339         }
5340 
5341         if (pkt->pkt_comp) {
5342                 mutex_exit(&scsa2usbp->scsa2usb_mutex);
5343                 scsi_hba_pkt_comp(pkt);
5344                 mutex_enter(&scsa2usbp->scsa2usb_mutex);
5345 
5346         }
5347 }
5348 
5349 
5350 /*
5351  * Even handling functions:
5352  *
5353  * scsa2usb_reconnect_event_cb:
5354  *      event handling
5355  */
5356 static int
5357 scsa2usb_reconnect_event_cb(dev_info_t *dip)
5358 {
5359         scsa2usb_state_t *scsa2usbp =
5360             ddi_get_soft_state(scsa2usb_statep, ddi_get_instance(dip));
5361         dev_info_t      *cdip;
5362         int             circ;
5363         int             rval = USB_SUCCESS;
5364 
5365         ASSERT(scsa2usbp != NULL);
5366 
5367         USB_DPRINTF_L4(DPRINT_MASK_SCSA, scsa2usbp->scsa2usb_log_handle,
5368             "scsa2usb_reconnect_event_cb: dip = 0x%p", (void *)dip);
5369 
5370         scsa2usb_restore_device_state(dip, scsa2usbp);
5371 
5372         USB_DPRINTF_L0(DPRINT_MASK_SCSA, scsa2usbp->scsa2usb_log_handle,
5373             "Reinserted device is accessible again.");
5374 
5375         ndi_devi_enter(dip, &circ);
5376         for (cdip = ddi_get_child(dip); cdip; ) {
5377                 dev_info_t *next = ddi_get_next_sibling(cdip);
5378 
5379                 mutex_enter(&DEVI(cdip)->devi_lock);
5380                 DEVI_SET_DEVICE_REINSERTED(cdip);
5381                 mutex_exit(&DEVI(cdip)->devi_lock);
5382 
5383                 cdip = next;
5384         }
5385         ndi_devi_exit(dip, circ);
5386 
5387         /* stop suppressing warnings */
5388         mutex_enter(&scsa2usbp->scsa2usb_mutex);
5389         scsa2usbp->scsa2usb_warning_given = B_FALSE;
5390         mutex_exit(&scsa2usbp->scsa2usb_mutex);
5391 
5392         if (scsa2usbp->scsa2usb_ugen_hdl) {
5393                 rval = usb_ugen_reconnect_ev_cb(
5394                     scsa2usbp->scsa2usb_ugen_hdl);
5395         }
5396 
5397         return (rval);
5398 }
5399 
5400 
5401 /*
5402  * scsa2usb_all_waitQs_empty:
5403  *      check if all waitQs empty
5404  */
5405 static int
5406 scsa2usb_all_waitQs_empty(scsa2usb_state_t *scsa2usbp)
5407 {
5408         uint_t  lun;
5409 
5410         for (lun = 0; lun < SCSA2USB_MAX_LUNS; lun++) {
5411                 if (usba_list_entry_count(
5412                     &scsa2usbp->scsa2usb_waitQ[lun])) {
5413 
5414                         return (USB_FAILURE);
5415                 }
5416         }
5417 
5418         return (USB_SUCCESS);
5419 }
5420 
5421 
5422 /*
5423  * scsa2usb_disconnect_event_cb:
5424  *      callback for disconnect events
5425  */
5426 static int
5427 scsa2usb_disconnect_event_cb(dev_info_t *dip)
5428 {
5429         scsa2usb_state_t *scsa2usbp =
5430             ddi_get_soft_state(scsa2usb_statep, ddi_get_instance(dip));
5431         dev_info_t      *cdip;
5432         int             circ, i;
5433         int             rval = USB_SUCCESS;
5434 
5435         ASSERT(scsa2usbp != NULL);
5436 
5437         USB_DPRINTF_L4(DPRINT_MASK_SCSA, scsa2usbp->scsa2usb_log_handle,
5438             "scsa2usb_disconnect_event_cb: dip = 0x%p", (void *)dip);
5439 
5440         mutex_enter(&scsa2usbp->scsa2usb_mutex);
5441         scsa2usbp->scsa2usb_dev_state = USB_DEV_DISCONNECTED;
5442 
5443         /*
5444          * wait till the work thread is done, carry on regardless
5445          * if not.
5446          */
5447         for (i = 0; i < SCSA2USB_DRAIN_TIMEOUT; i++) {
5448                 if ((scsa2usbp->scsa2usb_work_thread_id == NULL) &&
5449                     (scsa2usbp->scsa2usb_cur_pkt == NULL) &&
5450                     (scsa2usb_all_waitQs_empty(scsa2usbp) ==
5451                     USB_SUCCESS)) {
5452 
5453                         break;
5454                 }
5455                 mutex_exit(&scsa2usbp->scsa2usb_mutex);
5456                 delay(drv_sectohz(1));
5457                 mutex_enter(&scsa2usbp->scsa2usb_mutex);
5458         }
5459         mutex_exit(&scsa2usbp->scsa2usb_mutex);
5460 
5461         ndi_devi_enter(dip, &circ);
5462         for (cdip = ddi_get_child(dip); cdip; ) {
5463                 dev_info_t *next = ddi_get_next_sibling(cdip);
5464 
5465                 mutex_enter(&DEVI(cdip)->devi_lock);
5466                 DEVI_SET_DEVICE_REMOVED(cdip);
5467                 mutex_exit(&DEVI(cdip)->devi_lock);
5468 
5469                 cdip = next;
5470         }
5471         ndi_devi_exit(dip, circ);
5472 
5473         if (scsa2usbp->scsa2usb_ugen_hdl) {
5474                 rval = usb_ugen_disconnect_ev_cb(
5475                     scsa2usbp->scsa2usb_ugen_hdl);
5476         }
5477 
5478         return (rval);
5479 }
5480 
5481 
5482 /*
5483  * PM support
5484  *
5485  * scsa2usb_create_pm_components:
5486  *      create the pm components required for power management
5487  *      no mutex is need when calling USBA interfaces
5488  */
5489 static void
5490 scsa2usb_create_pm_components(dev_info_t *dip, scsa2usb_state_t *scsa2usbp)
5491 {
5492         scsa2usb_power_t *pm;
5493         uint_t          pwr_states;
5494 
5495         ASSERT(mutex_owned(&scsa2usbp->scsa2usb_mutex));
5496 
5497         USB_DPRINTF_L4(DPRINT_MASK_PM, scsa2usbp->scsa2usb_log_handle,
5498             "scsa2usb_create_pm_components: dip = 0x%p, scsa2usbp = 0x%p",
5499             (void *)dip, (void *)scsa2usbp);
5500 
5501         /*
5502          * determine if this device is on the blacklist
5503          * or if a conf file entry has disabled PM
5504          */
5505         if ((scsa2usbp->scsa2usb_attrs & SCSA2USB_ATTRS_PM) == 0) {
5506                 USB_DPRINTF_L2(DPRINT_MASK_PM, scsa2usbp->scsa2usb_log_handle,
5507                     "device cannot be power managed");
5508 
5509                 return;
5510         }
5511 
5512         /* Allocate the PM state structure */
5513         pm = kmem_zalloc(sizeof (scsa2usb_power_t), KM_SLEEP);
5514 
5515         scsa2usbp->scsa2usb_pm = pm;
5516         pm->scsa2usb_current_power = USB_DEV_OS_FULL_PWR;
5517         mutex_exit(&scsa2usbp->scsa2usb_mutex);
5518 
5519         if (usb_create_pm_components(dip, &pwr_states) ==
5520             USB_SUCCESS) {
5521                 if (usb_handle_remote_wakeup(dip,
5522                     USB_REMOTE_WAKEUP_ENABLE) == USB_SUCCESS) {
5523                         pm->scsa2usb_wakeup_enabled = 1;
5524                 }
5525 
5526                 mutex_enter(&scsa2usbp->scsa2usb_mutex);
5527                 pm->scsa2usb_pwr_states = (uint8_t)pwr_states;
5528                 scsa2usb_raise_power(scsa2usbp);
5529                 mutex_exit(&scsa2usbp->scsa2usb_mutex);
5530         }
5531 
5532         mutex_enter(&scsa2usbp->scsa2usb_mutex);
5533 }
5534 
5535 
5536 /*
5537  * scsa2usb_raise_power:
5538  *      check if the device is using full power or not
5539  */
5540 static void
5541 scsa2usb_raise_power(scsa2usb_state_t *scsa2usbp)
5542 {
5543         USB_DPRINTF_L4(DPRINT_MASK_PM, scsa2usbp->scsa2usb_log_handle,
5544             "scsa2usb_raise_power:");
5545 
5546         ASSERT(mutex_owned(&scsa2usbp->scsa2usb_mutex));
5547 
5548         if (scsa2usbp->scsa2usb_pm) {
5549                 scsa2usb_pm_busy_component(scsa2usbp);
5550                 if (scsa2usbp->scsa2usb_pm->scsa2usb_current_power !=
5551                     USB_DEV_OS_FULL_PWR) {
5552                         mutex_exit(&scsa2usbp->scsa2usb_mutex);
5553                         (void) pm_raise_power(scsa2usbp->scsa2usb_dip,
5554                             0, USB_DEV_OS_FULL_PWR);
5555                         mutex_enter(&scsa2usbp->scsa2usb_mutex);
5556                 }
5557         }
5558 }
5559 
5560 
5561 /*
5562  * functions to handle power transition for OS levels 0 -> 3
5563  */
5564 static int
5565 scsa2usb_pwrlvl0(scsa2usb_state_t *scsa2usbp)
5566 {
5567         int     rval;
5568 
5569         switch (scsa2usbp->scsa2usb_dev_state) {
5570         case USB_DEV_ONLINE:
5571                 /* Deny the powerdown request if the device is busy */
5572                 if (scsa2usbp->scsa2usb_pm->scsa2usb_pm_busy != 0) {
5573 
5574                         return (USB_FAILURE);
5575                 }
5576 
5577                 /*
5578                  * stop polling on interrupt pipe
5579                  */
5580                 scsa2usb_cbi_stop_intr_polling(scsa2usbp);
5581 
5582                 /* Issue USB D3 command to the device here */
5583                 rval = usb_set_device_pwrlvl3(scsa2usbp->scsa2usb_dip);
5584                 ASSERT(rval == USB_SUCCESS);
5585 
5586                 scsa2usbp->scsa2usb_dev_state = USB_DEV_PWRED_DOWN;
5587 
5588                 /* FALLTHRU */
5589         case USB_DEV_DISCONNECTED:
5590         case USB_DEV_SUSPENDED:
5591         case USB_DEV_PWRED_DOWN:
5592         default:
5593                 scsa2usbp->scsa2usb_pm->scsa2usb_current_power =
5594                     USB_DEV_OS_PWR_OFF;
5595 
5596                 return (USB_SUCCESS);
5597         }
5598 }
5599 
5600 
5601 static int
5602 scsa2usb_pwrlvl1(scsa2usb_state_t *scsa2usbp)
5603 {
5604         int     rval;
5605 
5606         /* Issue USB D2 command to the device here */
5607         rval = usb_set_device_pwrlvl2(scsa2usbp->scsa2usb_dip);
5608         ASSERT(rval == USB_SUCCESS);
5609 
5610         return (DDI_FAILURE);
5611 }
5612 
5613 
5614 static int
5615 scsa2usb_pwrlvl2(scsa2usb_state_t *scsa2usbp)
5616 {
5617         int     rval;
5618 
5619         /* Issue USB D1 command to the device here */
5620         rval = usb_set_device_pwrlvl1(scsa2usbp->scsa2usb_dip);
5621         ASSERT(rval == USB_SUCCESS);
5622 
5623         return (DDI_FAILURE);
5624 }
5625 
5626 
5627 static int
5628 scsa2usb_pwrlvl3(scsa2usb_state_t *scsa2usbp)
5629 {
5630         int     rval;
5631 
5632         /*
5633          * PM framework tries to put us in full power
5634          * during system shutdown. If we are disconnected
5635          * return success anyways
5636          */
5637         if (scsa2usbp->scsa2usb_dev_state != USB_DEV_DISCONNECTED) {
5638                 /* Issue USB D0 command to the device here */
5639                 rval = usb_set_device_pwrlvl0(scsa2usbp->scsa2usb_dip);
5640                 ASSERT(rval == USB_SUCCESS);
5641 
5642                 scsa2usbp->scsa2usb_dev_state = USB_DEV_ONLINE;
5643         }
5644         scsa2usbp->scsa2usb_pm->scsa2usb_current_power = USB_DEV_OS_FULL_PWR;
5645 
5646         return (DDI_SUCCESS);
5647 }
5648 
5649 
5650 /*
5651  * scsa2usb_power:
5652  *      power entry point
5653  */
5654 /* ARGSUSED */
5655 static int
5656 scsa2usb_power(dev_info_t *dip, int comp, int level)
5657 {
5658         scsa2usb_state_t        *scsa2usbp;
5659         scsa2usb_power_t        *pm;
5660         int                     rval = DDI_FAILURE;
5661 
5662         scsa2usbp = ddi_get_soft_state(scsa2usb_statep, ddi_get_instance(dip));
5663 
5664         USB_DPRINTF_L3(DPRINT_MASK_PM, scsa2usbp->scsa2usb_log_handle,
5665             "scsa2usb_power: Begin scsa2usbp (%p): level = %d",
5666             (void *)scsa2usbp, level);
5667 
5668         mutex_enter(&scsa2usbp->scsa2usb_mutex);
5669         if (SCSA2USB_BUSY(scsa2usbp)) {
5670                 USB_DPRINTF_L2(DPRINT_MASK_PM, scsa2usbp->scsa2usb_log_handle,
5671                     "scsa2usb_power: busy");
5672                 mutex_exit(&scsa2usbp->scsa2usb_mutex);
5673 
5674                 return (rval);
5675         }
5676 
5677         pm = scsa2usbp->scsa2usb_pm;
5678         if (pm == NULL) {
5679                 USB_DPRINTF_L2(DPRINT_MASK_PM, scsa2usbp->scsa2usb_log_handle,
5680                     "scsa2usb_power: pm NULL");
5681                 mutex_exit(&scsa2usbp->scsa2usb_mutex);
5682 
5683                 return (rval);
5684         }
5685 
5686         /* check if we are transitioning to a legal power level */
5687         if (USB_DEV_PWRSTATE_OK(pm->scsa2usb_pwr_states, level)) {
5688                 USB_DPRINTF_L2(DPRINT_MASK_PM, scsa2usbp->scsa2usb_log_handle,
5689                     "scsa2usb_power: illegal power level = %d "
5690                     "pwr_states: %x", level, pm->scsa2usb_pwr_states);
5691                 mutex_exit(&scsa2usbp->scsa2usb_mutex);
5692 
5693                 return (rval);
5694         }
5695 
5696         switch (level) {
5697         case USB_DEV_OS_PWR_OFF :
5698                 rval = scsa2usb_pwrlvl0(scsa2usbp);
5699                 break;
5700         case USB_DEV_OS_PWR_1 :
5701                 rval = scsa2usb_pwrlvl1(scsa2usbp);
5702                 break;
5703         case USB_DEV_OS_PWR_2 :
5704                 rval = scsa2usb_pwrlvl2(scsa2usbp);
5705                 break;
5706         case USB_DEV_OS_FULL_PWR :
5707                 rval = scsa2usb_pwrlvl3(scsa2usbp);
5708                 break;
5709         }
5710 
5711         mutex_exit(&scsa2usbp->scsa2usb_mutex);
5712 
5713         return ((rval == USB_SUCCESS) ? DDI_SUCCESS : DDI_FAILURE);
5714 }
5715 
5716 
5717 static void
5718 scsa2usb_pm_busy_component(scsa2usb_state_t *scsa2usbp)
5719 {
5720         ASSERT(mutex_owned(&scsa2usbp->scsa2usb_mutex));
5721 
5722         if (scsa2usbp->scsa2usb_pm) {
5723                 scsa2usbp->scsa2usb_pm->scsa2usb_pm_busy++;
5724 
5725                 USB_DPRINTF_L4(DPRINT_MASK_PM,
5726                     scsa2usbp->scsa2usb_log_handle,
5727                     "scsa2usb_pm_busy_component: %d",
5728                     scsa2usbp->scsa2usb_pm->scsa2usb_pm_busy);
5729 
5730                 mutex_exit(&scsa2usbp->scsa2usb_mutex);
5731 
5732                 if (pm_busy_component(scsa2usbp->scsa2usb_dip, 0) !=
5733                     DDI_SUCCESS) {
5734                         mutex_enter(&scsa2usbp->scsa2usb_mutex);
5735                         ASSERT(scsa2usbp->scsa2usb_pm->scsa2usb_pm_busy > 0);
5736                         scsa2usbp->scsa2usb_pm->scsa2usb_pm_busy--;
5737 
5738                         USB_DPRINTF_L2(DPRINT_MASK_PM,
5739                             scsa2usbp->scsa2usb_log_handle,
5740                             "scsa2usb_pm_busy_component failed: %d",
5741                             scsa2usbp->scsa2usb_pm->scsa2usb_pm_busy);
5742 
5743                         return;
5744                 }
5745                 mutex_enter(&scsa2usbp->scsa2usb_mutex);
5746         }
5747 }
5748 
5749 
5750 /*
5751  * scsa2usb_pm_idle_component:
5752  *      idles the device
5753  */
5754 static void
5755 scsa2usb_pm_idle_component(scsa2usb_state_t *scsa2usbp)
5756 {
5757         ASSERT(!mutex_owned(&scsa2usbp->scsa2usb_mutex));
5758 
5759         if (scsa2usbp->scsa2usb_pm) {
5760                 if (pm_idle_component(scsa2usbp->scsa2usb_dip, 0) ==
5761                     DDI_SUCCESS) {
5762                         mutex_enter(&scsa2usbp->scsa2usb_mutex);
5763                         ASSERT(scsa2usbp->scsa2usb_pm->scsa2usb_pm_busy > 0);
5764                         scsa2usbp->scsa2usb_pm->scsa2usb_pm_busy--;
5765 
5766                         USB_DPRINTF_L4(DPRINT_MASK_PM,
5767                             scsa2usbp->scsa2usb_log_handle,
5768                             "scsa2usb_pm_idle_component: %d",
5769                             scsa2usbp->scsa2usb_pm->scsa2usb_pm_busy);
5770 
5771                         mutex_exit(&scsa2usbp->scsa2usb_mutex);
5772                 }
5773         }
5774 }
5775 
5776 
5777 #ifdef  DEBUG
5778 /*
5779  * scsa2usb_print_cdb:
5780  *      prints CDB
5781  */
5782 void
5783 scsa2usb_print_cdb(scsa2usb_state_t *scsa2usbp, scsa2usb_cmd_t *cmd)
5784 {
5785         uchar_t *c = (uchar_t *)&cmd->cmd_cdb;
5786 
5787         USB_DPRINTF_L3(DPRINT_MASK_SCSA, scsa2usbp->scsa2usb_log_handle,
5788             "cmd = 0x%p opcode=%s "
5789             "cdb: %x %x %x %x %x %x %x %x %x %x %x %x %x %x %x %x",
5790             (void *)cmd,
5791             scsi_cname(cmd->cmd_cdb[SCSA2USB_OPCODE], scsa2usb_cmds),
5792             c[0], c[1], c[2], c[3], c[4], c[5], c[6], c[7], c[8],
5793             c[9], c[10], c[11], c[12], c[13], c[14], c[15]);
5794 }
5795 #endif  /* DEBUG */
5796 
5797 
5798 #ifdef  SCSA2USB_BULK_ONLY_TEST
5799 /*
5800  * scsa2usb_test_mblk:
5801  *      This function sends a dummy data mblk_t to simulate
5802  *      the following test cases: 5 and 11.
5803  */
5804 static void
5805 scsa2usb_test_mblk(scsa2usb_state_t *scsa2usbp, boolean_t large)
5806 {
5807         int                     i, rval;
5808         size_t                  len;
5809         usb_flags_t             flags = USB_FLAGS_SLEEP;
5810         usb_bulk_req_t          *req;
5811 
5812         ASSERT(mutex_owned(&scsa2usbp->scsa2usb_mutex));
5813 
5814         /* should we create a larger mblk? */
5815         len = (large == B_TRUE) ? DEV_BSIZE : USB_BULK_CBWCMD_LEN;
5816 
5817         req = scsa2usb_init_bulk_req(scsa2usbp, len,
5818             SCSA2USB_BULK_PIPE_TIMEOUT, 0, flags);
5819 
5820         /* fill up the data mblk */
5821         for (i = 0; i < len; i++) {
5822                 *req->bulk_data->b_wptr++ = (uchar_t)i;
5823         }
5824 
5825         mutex_exit(&scsa2usbp->scsa2usb_mutex);
5826         ASSERT(req->bulk_timeout);
5827         rval = usb_pipe_bulk_xfer(scsa2usbp->scsa2usb_bulkout_pipe, req, flags);
5828         mutex_enter(&scsa2usbp->scsa2usb_mutex);
5829 
5830         USB_DPRINTF_L1(DPRINT_MASK_SCSA, scsa2usbp->scsa2usb_log_handle,
5831             "scsa2usb_test_mblk: Sent Data Out rval = 0x%x", rval);
5832 
5833         usb_free_bulk_req(req);
5834 }
5835 #endif  /* SCSA2USB_BULK_ONLY_TEST */