xref: /titanic_50/usr/src/uts/common/io/usb/scsa2usb/scsa2usb.c (revision 3d729aecc03ea6ebb9bd5d56b8dccd24f57daa41)
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_usectohz(1000000));
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_usectohz(1000000));
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 */
5836