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