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