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