xref: /illumos-gate/usr/src/uts/common/io/sata/impl/sata.c (revision 95682cd0d6fefb989a3cdb7f521a5550d9ab19ac) 
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 /*
23  * Copyright (c) 2006, 2010, Oracle and/or its affiliates. All rights reserved.
24  */
25 /*
26  * Copyright 2017 Nexenta Systems, Inc.  All rights reserved.
27  * Copyright 2016 Argo Technologies SA
28  * Copyright 2019 Joyent, Inc.
29  * Copyright 2024 RackTop Systems, Inc.
30  * Copyright 2023 Oxide Computer Company
31  * Copyright 2023 Jason King
32  */
33 
34 /*
35  * SATA Framework
36  * Generic SATA Host Adapter Implementation
37  */
38 
39 #include <sys/conf.h>
40 #include <sys/file.h>
41 #include <sys/ddi.h>
42 #include <sys/sunddi.h>
43 #include <sys/modctl.h>
44 #include <sys/cmn_err.h>
45 #include <sys/errno.h>
46 #include <sys/thread.h>
47 #include <sys/kstat.h>
48 #include <sys/note.h>
49 #include <sys/sysevent.h>
50 #include <sys/sysevent/eventdefs.h>
51 #include <sys/sysevent/dr.h>
52 #include <sys/taskq.h>
53 #include <sys/disp.h>
54 #include <sys/sdt.h>
55 
56 #include <sys/sata/impl/sata.h>
57 #include <sys/sata/sata_hba.h>
58 #include <sys/sata/sata_defs.h>
59 #include <sys/sata/sata_cfgadm.h>
60 #include <sys/sata/sata_blacklist.h>
61 #include <sys/sata/sata_satl.h>
62 
63 #include <sys/scsi/impl/spc3_types.h>
64 
65 /*
66  * FMA header files
67  */
68 #include <sys/ddifm.h>
69 #include <sys/fm/protocol.h>
70 #include <sys/fm/util.h>
71 #include <sys/fm/io/ddi.h>
72 
73 /* Debug flags - defined in sata.h */
74 int	sata_debug_flags = 0;
75 int	sata_msg = 0;
76 
77 /*
78  * Flags enabling selected SATA HBA framework functionality
79  */
80 #define	SATA_ENABLE_QUEUING		1
81 #define	SATA_ENABLE_NCQ			2
82 #define	SATA_ENABLE_PROCESS_EVENTS	4
83 #define	SATA_ENABLE_PMULT_FBS		8 /* FIS-Based Switching */
84 int sata_func_enable =
85 	SATA_ENABLE_PROCESS_EVENTS | SATA_ENABLE_QUEUING | SATA_ENABLE_NCQ;
86 
87 /*
88  * Global variable setting default maximum queue depth (NCQ or TCQ)
89  * Note:minimum queue depth is 1
90  */
91 int sata_max_queue_depth = SATA_MAX_QUEUE_DEPTH; /* max NCQ/TCQ queue depth */
92 
93 /*
94  * Currently used default NCQ/TCQ queue depth. It is set-up during the driver
95  * initialization, using value from sata_max_queue_depth
96  * It is adjusted to minimum supported by the controller and by the device,
97  * if queueing is enabled.
98  */
99 static	int sata_current_max_qdepth;
100 
101 /*
102  * Global variable determining the default behavior after device hotpluggin.
103  * If non-zero, the hotplugged device is onlined (if possible) without explicit
104  * IOCTL request (AP_CONFIGURE).
105  * If zero, hotplugged device is identified, but not onlined.
106  * Enabling (AP_CONNECT) device port with an attached device does not result
107  * in device onlining regardless of the flag setting
108  */
109 int sata_auto_online = 0;
110 
111 #ifdef SATA_DEBUG
112 
113 #define	SATA_LOG_D(args)	sata_log args
114 uint64_t mbuf_count = 0;
115 uint64_t mbuffail_count = 0;
116 
117 sata_atapi_cmd_t sata_atapi_trace[64];
118 uint32_t sata_atapi_trace_index = 0;
119 int sata_atapi_trace_save = 1;
120 static	void sata_save_atapi_trace(sata_pkt_txlate_t *, int);
121 #define	SATAATAPITRACE(spx, count)	\
122 	if (sata_atapi_trace_save)	\
123 	    sata_save_atapi_trace(spx, count)
124 
125 #else
126 #define	SATA_LOG_D(args)	sata_trace_log args
127 #define	SATAATAPITRACE(spx, count)
128 #endif
129 
130 #if 0
131 static void
132 sata_test_atapi_packet_command(sata_hba_inst_t *, int);
133 #endif
134 
135 #ifdef SATA_INJECT_FAULTS
136 
137 #define		SATA_INJECT_PKT_FAULT	1
138 uint32_t	sata_inject_fault = 0;
139 
140 uint32_t	sata_inject_fault_count = 0;
141 uint32_t	sata_inject_fault_pause_count = 0;
142 uint32_t	sata_fault_type = 0;
143 uint32_t	sata_fault_cmd = 0;
144 dev_info_t	*sata_fault_ctrl = NULL;
145 sata_device_t	sata_fault_device;
146 
147 static	void sata_inject_pkt_fault(sata_pkt_t *, int *, int);
148 
149 #endif
150 
151 #define	LEGACY_HWID_LEN	64	/* Model (40) + Serial (20) + pad */
152 
153 /*
154  * SATA cb_ops functions
155  */
156 static	int sata_hba_open(dev_t *, int, int, cred_t *);
157 static	int sata_hba_close(dev_t, int, int, cred_t *);
158 static	int sata_hba_ioctl(dev_t, int, intptr_t, int, cred_t *,	int *);
159 
160 /*
161  * SCSA required entry points
162  */
163 static	int sata_scsi_tgt_init(dev_info_t *, dev_info_t *,
164     scsi_hba_tran_t *, struct scsi_device *);
165 static	int sata_scsi_tgt_probe(struct scsi_device *,
166     int (*callback)(void));
167 static void sata_scsi_tgt_free(dev_info_t *, dev_info_t *,
168     scsi_hba_tran_t *, struct scsi_device *);
169 static	int sata_scsi_start(struct scsi_address *, struct scsi_pkt *);
170 static	int sata_scsi_abort(struct scsi_address *, struct scsi_pkt *);
171 static	int sata_scsi_reset(struct scsi_address *, int);
172 static	int sata_scsi_getcap(struct scsi_address *, char *, int);
173 static	int sata_scsi_setcap(struct scsi_address *, char *, int, int);
174 static	struct scsi_pkt *sata_scsi_init_pkt(struct scsi_address *,
175     struct scsi_pkt *, struct buf *, int, int, int, int, int (*)(caddr_t),
176     caddr_t);
177 static	void sata_scsi_destroy_pkt(struct scsi_address *, struct scsi_pkt *);
178 static	void sata_scsi_dmafree(struct scsi_address *, struct scsi_pkt *);
179 static	void sata_scsi_sync_pkt(struct scsi_address *, struct scsi_pkt *);
180 
181 /*
182  * SATA HBA interface functions are defined in sata_hba.h header file
183  */
184 
185 /* Event processing functions */
186 static	void sata_event_daemon(void *);
187 static	void sata_event_thread_control(int);
188 static	void sata_process_controller_events(sata_hba_inst_t *sata_hba_inst);
189 static	void sata_process_pmult_events(sata_hba_inst_t *, uint8_t);
190 static	void sata_process_device_reset(sata_hba_inst_t *, sata_address_t *);
191 static	void sata_process_pmdevice_reset(sata_hba_inst_t *, sata_address_t *);
192 static	void sata_process_port_failed_event(sata_hba_inst_t *,
193     sata_address_t *);
194 static	void sata_process_port_link_events(sata_hba_inst_t *,
195     sata_address_t *);
196 static	void sata_process_pmport_link_events(sata_hba_inst_t *,
197     sata_address_t *);
198 static	void sata_process_device_detached(sata_hba_inst_t *, sata_address_t *);
199 static	void sata_process_pmdevice_detached(sata_hba_inst_t *,
200     sata_address_t *);
201 static	void sata_process_device_attached(sata_hba_inst_t *, sata_address_t *);
202 static	void sata_process_pmdevice_attached(sata_hba_inst_t *,
203     sata_address_t *);
204 static	void sata_process_port_pwr_change(sata_hba_inst_t *, sata_address_t *);
205 static	void sata_process_cntrl_pwr_level_change(sata_hba_inst_t *);
206 static	void sata_process_target_node_cleanup(sata_hba_inst_t *,
207     sata_address_t *);
208 static	void sata_process_device_autoonline(sata_hba_inst_t *,
209     sata_address_t *saddr);
210 
211 /*
212  * Local translation functions
213  */
214 static	int sata_txlt_inquiry(sata_pkt_txlate_t *);
215 static	int sata_txlt_test_unit_ready(sata_pkt_txlate_t *);
216 static	int sata_txlt_start_stop_unit(sata_pkt_txlate_t *);
217 static	int sata_txlt_read_capacity(sata_pkt_txlate_t *);
218 static	int sata_txlt_read_capacity16(sata_pkt_txlate_t *);
219 static  int sata_txlt_unmap(sata_pkt_txlate_t *);
220 static	int sata_txlt_request_sense(sata_pkt_txlate_t *);
221 static	int sata_txlt_read(sata_pkt_txlate_t *);
222 static	int sata_txlt_write(sata_pkt_txlate_t *);
223 static	int sata_txlt_log_sense(sata_pkt_txlate_t *);
224 static	int sata_txlt_log_select(sata_pkt_txlate_t *);
225 static	int sata_txlt_mode_sense(sata_pkt_txlate_t *);
226 static	int sata_txlt_mode_select(sata_pkt_txlate_t *);
227 static	int sata_txlt_ata_pass_thru(sata_pkt_txlate_t *);
228 static	int sata_txlt_synchronize_cache(sata_pkt_txlate_t *);
229 static	int sata_txlt_write_buffer(sata_pkt_txlate_t *);
230 static	int sata_txlt_nodata_cmd_immediate(sata_pkt_txlate_t *);
231 
232 static	int sata_hba_start(sata_pkt_txlate_t *, int *);
233 static	int sata_txlt_invalid_command(sata_pkt_txlate_t *);
234 static	int sata_txlt_check_condition(sata_pkt_txlate_t *, uchar_t, uchar_t);
235 static	int sata_txlt_lba_out_of_range(sata_pkt_txlate_t *);
236 static	int sata_txlt_ata_pass_thru_illegal_cmd(sata_pkt_txlate_t *);
237 static  int sata_txlt_unmap_nodata_cmd(sata_pkt_txlate_t *);
238 static	void sata_txlt_rw_completion(sata_pkt_t *);
239 static	void sata_txlt_nodata_cmd_completion(sata_pkt_t *);
240 static	void sata_txlt_apt_completion(sata_pkt_t *sata_pkt);
241 static	void sata_txlt_unmap_completion(sata_pkt_t *sata_pkt);
242 static	int sata_emul_rw_completion(sata_pkt_txlate_t *);
243 static	void sata_fill_ata_return_desc(sata_pkt_t *, uint8_t, uint8_t,
244     uint8_t);
245 static	struct scsi_extended_sense *sata_arq_sense(sata_pkt_txlate_t *);
246 
247 static	int sata_txlt_atapi(sata_pkt_txlate_t *);
248 static	void sata_txlt_atapi_completion(sata_pkt_t *);
249 
250 /*
251  * Local functions for ioctl
252  */
253 static	int32_t sata_get_port_num(sata_hba_inst_t *,  struct devctl_iocdata *);
254 static	void sata_cfgadm_state(sata_hba_inst_t *, int32_t,
255     devctl_ap_state_t *);
256 static	dev_info_t *sata_get_target_dip(dev_info_t *, uint8_t, uint8_t);
257 static	dev_info_t *sata_get_scsi_target_dip(dev_info_t *, sata_address_t *);
258 static	dev_info_t *sata_devt_to_devinfo(dev_t);
259 static	int sata_ioctl_connect(sata_hba_inst_t *, sata_device_t *);
260 static	int sata_ioctl_disconnect(sata_hba_inst_t *, sata_device_t *);
261 static	int sata_ioctl_configure(sata_hba_inst_t *, sata_device_t *);
262 static	int sata_ioctl_unconfigure(sata_hba_inst_t *, sata_device_t *);
263 static	int sata_ioctl_activate(sata_hba_inst_t *, sata_device_t *);
264 static	int sata_ioctl_deactivate(sata_hba_inst_t *, sata_device_t *);
265 static	int sata_ioctl_reset_port(sata_hba_inst_t *, sata_device_t *);
266 static	int sata_ioctl_reset_device(sata_hba_inst_t *, sata_device_t *);
267 static	int sata_ioctl_reset_all(sata_hba_inst_t *);
268 static	int sata_ioctl_port_self_test(sata_hba_inst_t *, sata_device_t *);
269 static	int sata_ioctl_get_device_path(sata_hba_inst_t *, sata_device_t *,
270     sata_ioctl_data_t *, int mode);
271 static	int sata_ioctl_get_ap_type(sata_hba_inst_t *, sata_device_t *,
272     sata_ioctl_data_t *, int mode);
273 static	int sata_ioctl_get_model_info(sata_hba_inst_t *, sata_device_t *,
274     sata_ioctl_data_t *, int mode);
275 static	int sata_ioctl_get_revfirmware_info(sata_hba_inst_t *, sata_device_t *,
276     sata_ioctl_data_t *, int mode);
277 static	int sata_ioctl_get_serialnumber_info(sata_hba_inst_t *,
278     sata_device_t *, sata_ioctl_data_t *, int mode);
279 
280 /*
281  * Local functions
282  */
283 static	void sata_remove_hba_instance(dev_info_t *);
284 static	int sata_validate_sata_hba_tran(dev_info_t *, sata_hba_tran_t *);
285 static	void sata_probe_ports(sata_hba_inst_t *);
286 static	void sata_probe_pmports(sata_hba_inst_t *, uint8_t);
287 static	int sata_reprobe_port(sata_hba_inst_t *, sata_device_t *, int);
288 static	int sata_reprobe_pmult(sata_hba_inst_t *, sata_device_t *, int);
289 static	int sata_reprobe_pmport(sata_hba_inst_t *, sata_device_t *, int);
290 static	int sata_alloc_pmult(sata_hba_inst_t *, sata_device_t *);
291 static	void sata_free_pmult(sata_hba_inst_t *, sata_device_t *);
292 static	int sata_add_device(dev_info_t *, sata_hba_inst_t *, sata_device_t *);
293 static	int sata_offline_device(sata_hba_inst_t *, sata_device_t *,
294     sata_drive_info_t *);
295 static	dev_info_t *sata_create_target_node(dev_info_t *, sata_hba_inst_t *,
296     sata_address_t *);
297 static	void sata_remove_target_node(sata_hba_inst_t *,
298     sata_address_t *);
299 static	int sata_validate_scsi_address(sata_hba_inst_t *,
300     struct scsi_address *, sata_device_t *);
301 static	int sata_validate_sata_address(sata_hba_inst_t *, int, int, int);
302 static	sata_pkt_t *sata_pkt_alloc(sata_pkt_txlate_t *, int (*)(caddr_t));
303 static	void sata_pkt_free(sata_pkt_txlate_t *);
304 static	int sata_dma_buf_setup(sata_pkt_txlate_t *, int, int (*)(caddr_t),
305     caddr_t, ddi_dma_attr_t *);
306 static	void sata_common_free_dma_rsrcs(sata_pkt_txlate_t *);
307 static	int sata_probe_device(sata_hba_inst_t *, sata_device_t *);
308 static	sata_drive_info_t *sata_get_device_info(sata_hba_inst_t *,
309     sata_device_t *);
310 static	int sata_identify_device(sata_hba_inst_t *, sata_drive_info_t *);
311 static	void sata_reidentify_device(sata_pkt_txlate_t *);
312 static	struct buf *sata_alloc_local_buffer(sata_pkt_txlate_t *, size_t);
313 static	void sata_free_local_buffer(sata_pkt_txlate_t *);
314 static	uint64_t sata_check_capacity(sata_drive_info_t *);
315 void	sata_adjust_dma_attr(sata_drive_info_t *, ddi_dma_attr_t *,
316     ddi_dma_attr_t *);
317 static	int sata_fetch_device_identify_data(sata_hba_inst_t *,
318     sata_drive_info_t *);
319 static	void sata_update_port_info(sata_hba_inst_t *, sata_device_t *);
320 static	void sata_update_pmport_info(sata_hba_inst_t *, sata_device_t *);
321 static	int sata_set_dma_mode(sata_hba_inst_t *, sata_drive_info_t *);
322 static	int sata_set_cache_mode(sata_hba_inst_t *, sata_drive_info_t *, int);
323 static	int sata_set_rmsn(sata_hba_inst_t *, sata_drive_info_t *, int);
324 static	int sata_set_drive_features(sata_hba_inst_t *,
325     sata_drive_info_t *, int flag);
326 static	void sata_init_write_cache_mode(sata_drive_info_t *sdinfo);
327 static	int sata_initialize_device(sata_hba_inst_t *, sata_drive_info_t *);
328 static	void sata_identdev_to_inquiry(sata_hba_inst_t *, sata_drive_info_t *,
329     uint8_t *);
330 static	int sata_get_atapi_inquiry_data(sata_hba_inst_t *, sata_address_t *,
331     struct scsi_inquiry *);
332 static	int sata_build_msense_page_1(sata_drive_info_t *, int, uint8_t *);
333 static	int sata_build_msense_page_8(sata_drive_info_t *, int, uint8_t *);
334 static	int sata_build_msense_page_1a(sata_drive_info_t *, int, uint8_t *);
335 static	int sata_build_msense_page_1c(sata_drive_info_t *, int, uint8_t *);
336 static	int sata_build_msense_page_30(sata_drive_info_t *, int, uint8_t *);
337 static	int sata_mode_select_page_8(sata_pkt_txlate_t *,
338     struct mode_cache_scsi3 *, int, int *, int *, int *);
339 static	int sata_mode_select_page_1a(sata_pkt_txlate_t *,
340     struct mode_info_power_cond *, int, int *, int *, int *);
341 static	int sata_mode_select_page_1c(sata_pkt_txlate_t *,
342     struct mode_info_excpt_page *, int, int *, int *, int *);
343 static	int sata_mode_select_page_30(sata_pkt_txlate_t *,
344     struct mode_acoustic_management *, int, int *, int *, int *);
345 
346 static	int sata_build_lsense_page_0(sata_drive_info_t *, uint8_t *);
347 static	int sata_build_lsense_page_03(sata_drive_info_t *, uint8_t *,
348     sata_hba_inst_t *);
349 static	int sata_build_lsense_page_0d(sata_drive_info_t *, uint8_t *,
350     sata_hba_inst_t *);
351 static	int sata_build_lsense_page_0e(sata_drive_info_t *, uint8_t *,
352     sata_pkt_txlate_t *);
353 static	int sata_build_lsense_page_10(sata_drive_info_t *, uint8_t *,
354     sata_hba_inst_t *);
355 static	int sata_build_lsense_page_11(sata_drive_info_t *, uint8_t *,
356     sata_hba_inst_t *);
357 static	int sata_build_lsense_page_19(sata_drive_info_t *, uint8_t *,
358     sata_hba_inst_t *);
359 static	int sata_build_lsense_page_2f(sata_drive_info_t *, uint8_t *,
360     sata_hba_inst_t *);
361 static	int sata_build_lsense_page_30(sata_drive_info_t *, uint8_t *,
362     sata_hba_inst_t *);
363 
364 static	void sata_set_arq_data(sata_pkt_t *);
365 static	void sata_build_read_verify_cmd(sata_cmd_t *, uint16_t, uint64_t);
366 static	void sata_build_generic_cmd(sata_cmd_t *, uint8_t);
367 static	uint8_t sata_get_standby_timer(uint8_t *timer);
368 
369 static	void sata_save_drive_settings(sata_drive_info_t *);
370 static	void sata_show_drive_info(sata_hba_inst_t *, sata_drive_info_t *);
371 static	void sata_show_pmult_info(sata_hba_inst_t *, sata_device_t *);
372 static	void sata_log(sata_hba_inst_t *, uint_t, char *fmt, ...);
373 #ifndef SATA_DEBUG
374 static	void sata_trace_log(sata_hba_inst_t *, uint_t, const char *fmt, ...);
375 #endif
376 static	int sata_fetch_smart_return_status(sata_hba_inst_t *,
377     sata_drive_info_t *);
378 static	int sata_fetch_smart_data(sata_hba_inst_t *, sata_drive_info_t *,
379     struct smart_data *);
380 static	int sata_smart_selftest_log(sata_hba_inst_t *,
381     sata_drive_info_t *,
382     struct smart_selftest_log *);
383 static	int sata_ext_smart_selftest_read_log(sata_hba_inst_t *,
384     sata_drive_info_t *, struct smart_ext_selftest_log *, uint16_t);
385 static int sata_read_log_ext(sata_hba_inst_t *, sata_drive_info_t *, uint8_t,
386     uint16_t, void *, uint16_t);
387 static	int sata_smart_read_log(sata_hba_inst_t *, sata_drive_info_t *,
388     uint8_t *, uint8_t, uint8_t);
389 static	int sata_read_log_ext_directory(sata_hba_inst_t *, sata_drive_info_t *,
390     struct read_log_ext_directory *);
391 static	void sata_gen_sysevent(sata_hba_inst_t *, sata_address_t *, int);
392 static	void sata_xlate_errors(sata_pkt_txlate_t *);
393 static	void sata_decode_device_error(sata_pkt_txlate_t *,
394     struct scsi_extended_sense *);
395 static	void sata_set_device_removed(dev_info_t *);
396 static	boolean_t sata_check_device_removed(dev_info_t *);
397 static	void sata_set_target_node_cleanup(sata_hba_inst_t *, sata_address_t *);
398 static	int sata_ncq_err_ret_cmd_setup(sata_pkt_txlate_t *,
399     sata_drive_info_t *);
400 static	int sata_atapi_err_ret_cmd_setup(sata_pkt_txlate_t *,
401     sata_drive_info_t *);
402 static	void sata_atapi_packet_cmd_setup(sata_cmd_t *, sata_drive_info_t *);
403 static	void sata_fixed_sense_data_preset(struct scsi_extended_sense *);
404 static  void sata_target_devid_register(dev_info_t *, sata_drive_info_t *);
405 static  int sata_check_modser(char *, int);
406 
407 /*
408  * FMA
409  */
410 static boolean_t sata_check_for_dma_error(dev_info_t *, sata_pkt_txlate_t *);
411 
412 
413 /*
414  * SATA Framework will ignore SATA HBA driver cb_ops structure and
415  * register following one with SCSA framework.
416  * Open & close are provided, so scsi framework will not use its own
417  */
418 static struct cb_ops sata_cb_ops = {
419 	sata_hba_open,			/* open */
420 	sata_hba_close,			/* close */
421 	nodev,				/* strategy */
422 	nodev,				/* print */
423 	nodev,				/* dump */
424 	nodev,				/* read */
425 	nodev,				/* write */
426 	sata_hba_ioctl,			/* ioctl */
427 	nodev,				/* devmap */
428 	nodev,				/* mmap */
429 	nodev,				/* segmap */
430 	nochpoll,			/* chpoll */
431 	ddi_prop_op,			/* cb_prop_op */
432 	0,				/* streamtab */
433 	D_NEW | D_MP,			/* cb_flag */
434 	CB_REV,				/* rev */
435 	nodev,				/* aread */
436 	nodev				/* awrite */
437 };
438 
439 
440 extern struct mod_ops mod_miscops;
441 extern uchar_t	scsi_cdb_size[];
442 
443 static struct modlmisc modlmisc = {
444 	&mod_miscops,			/* Type of module */
445 	"SATA Module"			/* module name */
446 };
447 
448 
449 static struct modlinkage modlinkage = {
450 	MODREV_1,
451 	(void *)&modlmisc,
452 	NULL
453 };
454 
455 /*
456  * Default sata pkt timeout. Used when a target driver scsi_pkt time is zero,
457  * i.e. when scsi_pkt has not timeout specified.
458  */
459 static int sata_default_pkt_time = 60;	/* 60 seconds */
460 
461 /*
462  * Intermediate buffer device access attributes - they are required,
463  * but not necessarily used.
464  */
465 static ddi_device_acc_attr_t sata_acc_attr = {
466 	DDI_DEVICE_ATTR_V0,
467 	DDI_STRUCTURE_LE_ACC,
468 	DDI_STRICTORDER_ACC
469 };
470 
471 
472 /*
473  * Mutexes protecting structures in multithreaded operations.
474  * Because events are relatively rare, a single global mutex protecting
475  * data structures should be sufficient. To increase performance, add
476  * separate mutex per each sata port and use global mutex only to protect
477  * common data structures.
478  */
479 static	kmutex_t sata_mutex;		/* protects sata_hba_list */
480 static	kmutex_t sata_log_mutex;	/* protects log */
481 
482 static	char sata_log_buf[256];
483 
484 /*
485  * sata trace debug
486  */
487 static	sata_trace_rbuf_t *sata_debug_rbuf;
488 static	sata_trace_dmsg_t *sata_trace_dmsg_alloc(void);
489 static	void sata_trace_dmsg_free(void);
490 static	void sata_trace_rbuf_alloc(void);
491 static	void sata_trace_rbuf_free(void);
492 
493 int	dmsg_ring_size = DMSG_RING_SIZE;
494 
495 /* Default write cache setting for SATA hard disks */
496 int	sata_write_cache = 1;		/* enabled */
497 
498 /* Default write cache setting for SATA ATAPI CD/DVD */
499 int	sata_atapicdvd_write_cache = 1; /* enabled */
500 
501 /* Default write cache setting for SATA ATAPI tape */
502 int	sata_atapitape_write_cache = 1; /* enabled */
503 
504 /* Default write cache setting for SATA ATAPI disk */
505 int	sata_atapidisk_write_cache = 1;	/* enabled */
506 
507 /*
508  * Linked list of HBA instances
509  */
510 static	sata_hba_inst_t *sata_hba_list = NULL;
511 static	sata_hba_inst_t *sata_hba_list_tail = NULL;
512 /*
513  * Pointer to per-instance SATA HBA soft structure is stored in sata_hba_tran
514  * structure and in sata soft state.
515  */
516 
517 /*
518  * Event daemon related variables
519  */
520 static	kmutex_t sata_event_mutex;
521 static	kcondvar_t sata_event_cv;
522 static	kthread_t *sata_event_thread = NULL;
523 static	int sata_event_thread_terminate = 0;
524 static	int sata_event_pending = 0;
525 static	int sata_event_thread_active = 0;
526 extern	pri_t minclsyspri;
527 
528 /*
529  * NCQ error recovery command
530  */
531 static const sata_cmd_t sata_rle_cmd = {
532 	SATA_CMD_REV,
533 	NULL,
534 	{
535 		SATA_DIR_READ
536 	},
537 	ATA_ADDR_LBA48,
538 	0,
539 	0,
540 	0,
541 	0,
542 	0,
543 	1,
544 	READ_LOG_EXT_NCQ_ERROR_RECOVERY,
545 	0,
546 	0,
547 	0,
548 	SATAC_READ_LOG_EXT,
549 	0,
550 	0,
551 	0,
552 };
553 
554 /*
555  * ATAPI error recovery CDB
556  */
557 static const uint8_t sata_rqsense_cdb[SATA_ATAPI_RQSENSE_CDB_LEN] = {
558 	SCMD_REQUEST_SENSE,
559 	0,			/* Only fixed RQ format is supported */
560 	0,
561 	0,
562 	SATA_ATAPI_MIN_RQSENSE_LEN, /* Less data may be returned */
563 	0
564 };
565 
566 
567 /* Warlock directives */
568 
569 _NOTE(SCHEME_PROTECTS_DATA("No Mutex Needed", scsi_hba_tran))
570 _NOTE(SCHEME_PROTECTS_DATA("No Mutex Needed", scsi_device))
571 _NOTE(SCHEME_PROTECTS_DATA("No Mutex Needed", dev_ops))
572 _NOTE(SCHEME_PROTECTS_DATA("No Mutex Needed", scsi_extended_sense))
573 _NOTE(SCHEME_PROTECTS_DATA("No Mutex Needed", scsi_arq_status))
574 _NOTE(SCHEME_PROTECTS_DATA("No Mutex Needed", ddi_dma_attr))
575 _NOTE(SCHEME_PROTECTS_DATA("No Mutex Needed", ddi_dma_cookie_t))
576 _NOTE(SCHEME_PROTECTS_DATA("No Mutex Needed", devctl_ap_state))
577 _NOTE(SCHEME_PROTECTS_DATA("No Mutex Needed", dev_info::devi_state))
578 _NOTE(MUTEX_PROTECTS_DATA(sata_mutex, sata_hba_list))
579 _NOTE(DATA_READABLE_WITHOUT_LOCK(sata_hba_list))
580 _NOTE(MUTEX_PROTECTS_DATA(sata_mutex, sata_hba_inst::satahba_next))
581 _NOTE(MUTEX_PROTECTS_DATA(sata_mutex, sata_hba_inst::satahba_prev))
582 _NOTE(SCHEME_PROTECTS_DATA("No Mutex Needed", \
583     sata_hba_inst::satahba_scsi_tran))
584 _NOTE(SCHEME_PROTECTS_DATA("No Mutex Needed", sata_hba_inst::satahba_tran))
585 _NOTE(SCHEME_PROTECTS_DATA("No Mutex Needed", sata_hba_inst::satahba_dip))
586 _NOTE(SCHEME_PROTECTS_DATA("Scheme", sata_hba_inst::satahba_attached))
587 _NOTE(DATA_READABLE_WITHOUT_LOCK(sata_hba_inst::satahba_dev_port))
588 _NOTE(MUTEX_PROTECTS_DATA(sata_hba_inst::satahba_mutex,
589     sata_hba_inst::satahba_event_flags))
590 _NOTE(MUTEX_PROTECTS_DATA(sata_cport_info::cport_mutex, \
591     sata_cport_info::cport_devp))
592 _NOTE(DATA_READABLE_WITHOUT_LOCK(sata_cport_info::cport_devp))
593 _NOTE(SCHEME_PROTECTS_DATA("Scheme", sata_cport_info::cport_addr))
594 _NOTE(MUTEX_PROTECTS_DATA(sata_cport_info::cport_mutex, \
595     sata_cport_info::cport_dev_type))
596 _NOTE(DATA_READABLE_WITHOUT_LOCK(sata_cport_info::cport_dev_type))
597 _NOTE(MUTEX_PROTECTS_DATA(sata_cport_info::cport_mutex, \
598     sata_cport_info::cport_state))
599 _NOTE(DATA_READABLE_WITHOUT_LOCK(sata_cport_info::cport_state))
600 _NOTE(MUTEX_PROTECTS_DATA(sata_pmport_info::pmport_mutex, \
601     sata_pmport_info::pmport_state))
602 _NOTE(DATA_READABLE_WITHOUT_LOCK(sata_pmport_info::pmport_state))
603 _NOTE(MUTEX_PROTECTS_DATA(sata_pmport_info::pmport_mutex, \
604     sata_pmport_info::pmport_dev_type))
605 _NOTE(DATA_READABLE_WITHOUT_LOCK(sata_pmport_info::pmport_dev_type))
606 _NOTE(MUTEX_PROTECTS_DATA(sata_pmport_info::pmport_mutex, \
607     sata_pmport_info::pmport_sata_drive))
608 _NOTE(MUTEX_PROTECTS_DATA(sata_pmport_info::pmport_mutex, \
609     sata_pmport_info::pmport_tgtnode_clean))
610 _NOTE(MUTEX_PROTECTS_DATA(sata_pmport_info::pmport_mutex, \
611     sata_pmport_info::pmport_event_flags))
612 _NOTE(DATA_READABLE_WITHOUT_LOCK(sata_pmport_info::pmport_sata_drive))
613 _NOTE(DATA_READABLE_WITHOUT_LOCK(sata_pmult_info::pmult_dev_port))
614 _NOTE(DATA_READABLE_WITHOUT_LOCK(sata_pmult_info::pmult_num_dev_ports))
615 #ifdef SATA_DEBUG
616 _NOTE(SCHEME_PROTECTS_DATA("No Mutex Needed", mbuf_count))
617 _NOTE(SCHEME_PROTECTS_DATA("No Mutex Needed", mbuffail_count))
618 _NOTE(SCHEME_PROTECTS_DATA("No Mutex Needed", sata_atapi_trace))
619 _NOTE(SCHEME_PROTECTS_DATA("No Mutex Needed", sata_atapi_trace_index))
620 #endif
621 
622 /* End of warlock directives */
623 
624 /* ************** loadable module configuration functions ************** */
625 
626 int
627 _init()
628 {
629 	int rval;
630 
631 	mutex_init(&sata_mutex, NULL, MUTEX_DRIVER, NULL);
632 	mutex_init(&sata_event_mutex, NULL, MUTEX_DRIVER, NULL);
633 	mutex_init(&sata_log_mutex, NULL, MUTEX_DRIVER, NULL);
634 	cv_init(&sata_event_cv, NULL, CV_DRIVER, NULL);
635 	sata_trace_rbuf_alloc();
636 	if ((rval = mod_install(&modlinkage)) != 0) {
637 #ifdef SATA_DEBUG
638 		cmn_err(CE_WARN, "sata: _init: mod_install failed\n");
639 #endif
640 		sata_trace_rbuf_free();
641 		mutex_destroy(&sata_log_mutex);
642 		cv_destroy(&sata_event_cv);
643 		mutex_destroy(&sata_event_mutex);
644 		mutex_destroy(&sata_mutex);
645 	}
646 	return (rval);
647 }
648 
649 int
650 _fini()
651 {
652 	int rval;
653 
654 	if ((rval = mod_remove(&modlinkage)) != 0)
655 		return (rval);
656 
657 	sata_trace_rbuf_free();
658 	mutex_destroy(&sata_log_mutex);
659 	cv_destroy(&sata_event_cv);
660 	mutex_destroy(&sata_event_mutex);
661 	mutex_destroy(&sata_mutex);
662 	return (rval);
663 }
664 
665 int
666 _info(struct modinfo *modinfop)
667 {
668 	return (mod_info(&modlinkage, modinfop));
669 }
670 
671 
672 
673 /* ********************* SATA HBA entry points ********************* */
674 
675 
676 /*
677  * Called by SATA HBA from _init().
678  * Registers HBA driver instance/sata framework pair with scsi framework, by
679  * calling scsi_hba_init().
680  *
681  * SATA HBA driver cb_ops are ignored - SATA HBA framework cb_ops are used
682  * instead. SATA HBA framework cb_ops pointer overwrites SATA HBA driver
683  * cb_ops pointer in SATA HBA driver dev_ops structure.
684  * SATA HBA framework cb_ops supplies cb_open cb_close and cb_ioctl vectors.
685  *
686  * Return status of the scsi_hba_init() is returned to a calling SATA HBA
687  * driver.
688  */
689 int
690 sata_hba_init(struct modlinkage *modlp)
691 {
692 	int rval;
693 	struct dev_ops *hba_ops;
694 
695 	SATADBG1(SATA_DBG_HBA_IF, NULL,
696 	    "sata_hba_init: name %s \n",
697 	    ((struct modldrv *)(modlp->ml_linkage[0]))->drv_linkinfo);
698 	/*
699 	 * Fill-up cb_ops and dev_ops when necessary
700 	 */
701 	hba_ops = ((struct modldrv *)(modlp->ml_linkage[0]))->drv_dev_ops;
702 	/*
703 	 * Provide pointer to SATA dev_ops
704 	 */
705 	hba_ops->devo_cb_ops = &sata_cb_ops;
706 
707 	/*
708 	 * Register SATA HBA with SCSI framework
709 	 */
710 	if ((rval = scsi_hba_init(modlp)) != 0) {
711 		SATADBG1(SATA_DBG_HBA_IF, NULL,
712 		    "sata_hba_init: scsi hba init failed\n", NULL);
713 		return (rval);
714 	}
715 
716 	return (0);
717 }
718 
719 
720 /* HBA attach stages */
721 #define	HBA_ATTACH_STAGE_SATA_HBA_INST	1
722 #define	HBA_ATTACH_STAGE_SCSI_ATTACHED	2
723 #define	HBA_ATTACH_STAGE_SETUP		4
724 #define	HBA_ATTACH_STAGE_LINKED		8
725 
726 
727 /*
728  *
729  * Called from SATA HBA driver's attach routine to attach an instance of
730  * the HBA.
731  *
732  * For DDI_ATTACH command:
733  * sata_hba_inst structure is allocated here and initialized with pointers to
734  * SATA framework implementation of required scsi tran functions.
735  * The scsi_tran's tran_hba_private field is used by SATA Framework to point
736  * to the soft structure (sata_hba_inst) allocated by SATA framework for
737  * SATA HBA instance related data.
738  * The scsi_tran's tran_hba_private field is used by SATA framework to
739  * store a pointer to per-HBA-instance of sata_hba_inst structure.
740  * The sata_hba_inst structure is cross-linked to scsi tran structure.
741  * Among other info, a pointer to sata_hba_tran structure is stored in
742  * sata_hba_inst. The sata_hba_inst structures for different HBA instances are
743  * linked together into the list, pointed to by sata_hba_list.
744  * On the first HBA instance attach the sata event thread is initialized.
745  * Attachment points are created for all SATA ports of the HBA being attached.
746  * All HBA instance's SATA ports are probed and type of plugged devices is
747  * determined. For each device of a supported type, a target node is created.
748  *
749  * DDI_SUCCESS is returned when attachment process is successful,
750  * DDI_FAILURE is returned otherwise.
751  *
752  * For DDI_RESUME command:
753  * Not implemented at this time (postponed until phase 2 of the development).
754  */
755 int
756 sata_hba_attach(dev_info_t *dip, sata_hba_tran_t *sata_tran,
757     ddi_attach_cmd_t cmd)
758 {
759 	sata_hba_inst_t	*sata_hba_inst;
760 	scsi_hba_tran_t *scsi_tran = NULL;
761 	int hba_attach_state = 0;
762 	char taskq_name[MAXPATHLEN];
763 
764 	SATADBG3(SATA_DBG_HBA_IF, NULL,
765 	    "sata_hba_attach: node %s (%s%d)\n",
766 	    ddi_node_name(dip), ddi_driver_name(dip),
767 	    ddi_get_instance(dip));
768 
769 	if (cmd == DDI_RESUME) {
770 		/*
771 		 * Postponed until phase 2 of the development
772 		 */
773 		return (DDI_FAILURE);
774 	}
775 
776 	if (cmd != DDI_ATTACH) {
777 		return (DDI_FAILURE);
778 	}
779 
780 	/* cmd == DDI_ATTACH */
781 
782 	if (sata_validate_sata_hba_tran(dip, sata_tran) != SATA_SUCCESS) {
783 		SATA_LOG_D((NULL, CE_WARN,
784 		    "sata_hba_attach: invalid sata_hba_tran"));
785 		return (DDI_FAILURE);
786 	}
787 	/*
788 	 * Allocate and initialize SCSI tran structure.
789 	 * SATA copy of tran_bus_config is provided to create port nodes.
790 	 */
791 	scsi_tran = scsi_hba_tran_alloc(dip, SCSI_HBA_CANSLEEP);
792 	if (scsi_tran == NULL)
793 		return (DDI_FAILURE);
794 	/*
795 	 * Allocate soft structure for SATA HBA instance.
796 	 * There is a separate softstate for each HBA instance.
797 	 */
798 	sata_hba_inst = kmem_zalloc(sizeof (struct sata_hba_inst), KM_SLEEP);
799 	ASSERT(sata_hba_inst != NULL); /* this should not fail */
800 	mutex_init(&sata_hba_inst->satahba_mutex, NULL, MUTEX_DRIVER, NULL);
801 	hba_attach_state |= HBA_ATTACH_STAGE_SATA_HBA_INST;
802 
803 	/*
804 	 * scsi_trans's tran_hba_private is used by SATA Framework to point to
805 	 * soft structure allocated by SATA framework for
806 	 * SATA HBA instance related data.
807 	 */
808 	scsi_tran->tran_hba_private	= sata_hba_inst;
809 	scsi_tran->tran_tgt_private	= NULL;
810 
811 	scsi_tran->tran_tgt_init	= sata_scsi_tgt_init;
812 	scsi_tran->tran_tgt_probe	= sata_scsi_tgt_probe;
813 	scsi_tran->tran_tgt_free	= sata_scsi_tgt_free;
814 
815 	scsi_tran->tran_start		= sata_scsi_start;
816 	scsi_tran->tran_reset		= sata_scsi_reset;
817 	scsi_tran->tran_abort		= sata_scsi_abort;
818 	scsi_tran->tran_getcap		= sata_scsi_getcap;
819 	scsi_tran->tran_setcap		= sata_scsi_setcap;
820 	scsi_tran->tran_init_pkt	= sata_scsi_init_pkt;
821 	scsi_tran->tran_destroy_pkt	= sata_scsi_destroy_pkt;
822 
823 	scsi_tran->tran_dmafree		= sata_scsi_dmafree;
824 	scsi_tran->tran_sync_pkt	= sata_scsi_sync_pkt;
825 
826 	scsi_tran->tran_reset_notify	= NULL;
827 	scsi_tran->tran_get_bus_addr	= NULL;
828 	scsi_tran->tran_quiesce		= NULL;
829 	scsi_tran->tran_unquiesce	= NULL;
830 	scsi_tran->tran_bus_reset	= NULL;
831 
832 	if (scsi_hba_attach_setup(dip, sata_tran->sata_tran_hba_dma_attr,
833 	    scsi_tran, 0) != DDI_SUCCESS) {
834 #ifdef SATA_DEBUG
835 		cmn_err(CE_WARN, "?SATA: %s%d hba scsi attach failed",
836 		    ddi_driver_name(dip), ddi_get_instance(dip));
837 #endif
838 		goto fail;
839 	}
840 	hba_attach_state |= HBA_ATTACH_STAGE_SCSI_ATTACHED;
841 
842 	if (!ddi_prop_exists(DDI_DEV_T_ANY, dip, DDI_PROP_DONTPASS, "sata")) {
843 		if (ddi_prop_update_int(DDI_DEV_T_NONE, dip,
844 		    "sata", 1) != DDI_PROP_SUCCESS) {
845 			SATA_LOG_D((NULL, CE_WARN, "sata_hba_attach: "
846 			    "failed to create hba sata prop"));
847 			goto fail;
848 		}
849 	}
850 
851 	/*
852 	 * Save pointers in hba instance soft state.
853 	 */
854 	sata_hba_inst->satahba_scsi_tran = scsi_tran;
855 	sata_hba_inst->satahba_tran = sata_tran;
856 	sata_hba_inst->satahba_dip = dip;
857 
858 	/*
859 	 * Create a task queue to handle emulated commands completion
860 	 * Use node name, dash, instance number as the queue name.
861 	 */
862 	taskq_name[0] = '\0';
863 	(void) strlcat(taskq_name, DEVI(dip)->devi_node_name,
864 	    sizeof (taskq_name));
865 	(void) snprintf(taskq_name + strlen(taskq_name),
866 	    sizeof (taskq_name) - strlen(taskq_name),
867 	    "-%d", DEVI(dip)->devi_instance);
868 	sata_hba_inst->satahba_taskq = taskq_create(taskq_name, 1,
869 	    minclsyspri, 1, sata_tran->sata_tran_hba_num_cports * 4,
870 	    TASKQ_DYNAMIC);
871 
872 	hba_attach_state |= HBA_ATTACH_STAGE_SETUP;
873 
874 	/*
875 	 * Create events thread if not created yet.
876 	 */
877 	sata_event_thread_control(1);
878 
879 	/*
880 	 * Link this hba instance into the list.
881 	 */
882 	mutex_enter(&sata_mutex);
883 
884 	if (sata_hba_list == NULL) {
885 		/*
886 		 * The first instance of HBA is attached.
887 		 * Set current/active default maximum NCQ/TCQ queue depth for
888 		 * all SATA devices. It is done here and now, to eliminate the
889 		 * possibility of the dynamic, programatic modification of the
890 		 * queue depth via global (and public) sata_max_queue_depth
891 		 * variable (this would require special handling in HBA drivers)
892 		 */
893 		sata_current_max_qdepth = sata_max_queue_depth;
894 		if (sata_current_max_qdepth > 32)
895 			sata_current_max_qdepth = 32;
896 		else if (sata_current_max_qdepth < 1)
897 			sata_current_max_qdepth = 1;
898 	}
899 
900 	sata_hba_inst->satahba_next = NULL;
901 	sata_hba_inst->satahba_prev = sata_hba_list_tail;
902 	if (sata_hba_list == NULL) {
903 		sata_hba_list = sata_hba_inst;
904 	}
905 	if (sata_hba_list_tail != NULL) {
906 		sata_hba_list_tail->satahba_next = sata_hba_inst;
907 	}
908 	sata_hba_list_tail = sata_hba_inst;
909 	mutex_exit(&sata_mutex);
910 	hba_attach_state |= HBA_ATTACH_STAGE_LINKED;
911 
912 	/*
913 	 * Create SATA HBA devctl minor node for sata_hba_open, close, ioctl
914 	 * SATA HBA driver should not use its own open/close entry points.
915 	 *
916 	 * Make sure that instance number doesn't overflow
917 	 * when forming minor numbers.
918 	 */
919 	ASSERT(ddi_get_instance(dip) <= (L_MAXMIN >> INST_MINOR_SHIFT));
920 	if (ddi_create_minor_node(dip, "devctl", S_IFCHR,
921 	    INST2DEVCTL(ddi_get_instance(dip)),
922 	    DDI_NT_SATA_NEXUS, 0) != DDI_SUCCESS) {
923 #ifdef SATA_DEBUG
924 		cmn_err(CE_WARN, "sata_hba_attach: "
925 		    "cannot create devctl minor node");
926 #endif
927 		goto fail;
928 	}
929 
930 
931 	/*
932 	 * Set-up kstats here, if necessary.
933 	 * (postponed until future phase of the development).
934 	 */
935 
936 	/*
937 	 * Indicate that HBA is attached. This will enable events processing
938 	 * for this HBA.
939 	 */
940 	sata_hba_inst->satahba_attached = 1;
941 	/*
942 	 * Probe controller ports. This operation will describe a current
943 	 * controller/port/multipliers/device configuration and will create
944 	 * attachment points.
945 	 * We may end-up with just a controller with no devices attached.
946 	 * For the ports with a supported device attached, device target nodes
947 	 * are created and devices are initialized.
948 	 */
949 	sata_probe_ports(sata_hba_inst);
950 
951 	return (DDI_SUCCESS);
952 
953 fail:
954 	if (hba_attach_state & HBA_ATTACH_STAGE_LINKED) {
955 		(void) sata_remove_hba_instance(dip);
956 		if (sata_hba_list == NULL)
957 			sata_event_thread_control(0);
958 	}
959 
960 	if (hba_attach_state & HBA_ATTACH_STAGE_SETUP) {
961 		(void) ddi_prop_remove(DDI_DEV_T_ANY, dip, "sata");
962 		taskq_destroy(sata_hba_inst->satahba_taskq);
963 	}
964 
965 	if (hba_attach_state & HBA_ATTACH_STAGE_SCSI_ATTACHED)
966 		(void) scsi_hba_detach(dip);
967 
968 	if (hba_attach_state & HBA_ATTACH_STAGE_SATA_HBA_INST) {
969 		mutex_destroy(&sata_hba_inst->satahba_mutex);
970 		kmem_free((void *)sata_hba_inst,
971 		    sizeof (struct sata_hba_inst));
972 		scsi_hba_tran_free(scsi_tran);
973 	}
974 
975 	sata_log(NULL, CE_WARN, "?SATA: %s%d hba attach failed",
976 	    ddi_driver_name(dip), ddi_get_instance(dip));
977 
978 	return (DDI_FAILURE);
979 }
980 
981 
982 /*
983  * Called by SATA HBA from to detach an instance of the driver.
984  *
985  * For DDI_DETACH command:
986  * Free local structures allocated for SATA HBA instance during
987  * sata_hba_attach processing.
988  *
989  * Returns DDI_SUCCESS when HBA was detached, DDI_FAILURE otherwise.
990  *
991  * For DDI_SUSPEND command:
992  * Not implemented at this time (postponed until phase 2 of the development)
993  * Returnd DDI_SUCCESS.
994  *
995  * When the last HBA instance is detached, the event daemon is terminated.
996  *
997  * NOTE: Port multiplier is supported.
998  */
999 int
1000 sata_hba_detach(dev_info_t *dip, ddi_detach_cmd_t cmd)
1001 {
1002 	dev_info_t	*tdip;
1003 	sata_hba_inst_t	*sata_hba_inst;
1004 	scsi_hba_tran_t *scsi_hba_tran;
1005 	sata_cport_info_t *cportinfo;
1006 	sata_pmult_info_t *pminfo;
1007 	sata_drive_info_t *sdinfo;
1008 	sata_device_t	sdevice;
1009 	int ncport, npmport;
1010 
1011 	SATADBG3(SATA_DBG_HBA_IF, NULL, "sata_hba_detach: node %s (%s%d)\n",
1012 	    ddi_node_name(dip), ddi_driver_name(dip), ddi_get_instance(dip));
1013 
1014 	switch (cmd) {
1015 	case DDI_DETACH:
1016 
1017 		if ((scsi_hba_tran = ddi_get_driver_private(dip)) == NULL)
1018 			return (DDI_FAILURE);
1019 
1020 		sata_hba_inst = scsi_hba_tran->tran_hba_private;
1021 		if (sata_hba_inst == NULL)
1022 			return (DDI_FAILURE);
1023 
1024 		if (scsi_hba_detach(dip) == DDI_FAILURE) {
1025 			sata_hba_inst->satahba_attached = 1;
1026 			return (DDI_FAILURE);
1027 		}
1028 
1029 		/*
1030 		 * Free all target nodes - at this point
1031 		 * devices should be at least offlined
1032 		 * otherwise scsi_hba_detach() should not be called.
1033 		 */
1034 		for (ncport = 0; ncport < SATA_NUM_CPORTS(sata_hba_inst);
1035 		    ncport++) {
1036 			cportinfo = SATA_CPORT_INFO(sata_hba_inst, ncport);
1037 			if (cportinfo->cport_dev_type != SATA_DTYPE_PMULT) {
1038 				sdinfo = SATA_CPORTINFO_DRV_INFO(cportinfo);
1039 				if (sdinfo != NULL) {
1040 					tdip = sata_get_target_dip(dip,
1041 					    ncport, 0);
1042 					if (tdip != NULL) {
1043 						if (ndi_devi_offline(tdip,
1044 						    NDI_DEVI_REMOVE) !=
1045 						    NDI_SUCCESS) {
1046 							SATA_LOG_D((
1047 							    sata_hba_inst,
1048 							    CE_WARN,
1049 							    "sata_hba_detach: "
1050 							    "Target node not "
1051 							    "removed !"));
1052 							return (DDI_FAILURE);
1053 						}
1054 					}
1055 				}
1056 			} else { /* SATA_DTYPE_PMULT */
1057 				mutex_enter(&cportinfo->cport_mutex);
1058 				pminfo = SATA_CPORTINFO_PMULT_INFO(cportinfo);
1059 
1060 				if (pminfo == NULL) {
1061 					SATA_LOG_D((sata_hba_inst, CE_WARN,
1062 					    "sata_hba_detach: Port multiplier "
1063 					    "not ready yet!"));
1064 					mutex_exit(&cportinfo->cport_mutex);
1065 					return (DDI_FAILURE);
1066 				}
1067 
1068 				/*
1069 				 * Detach would fail if removal of any of the
1070 				 * target nodes is failed - albeit in that
1071 				 * case some of them may have been removed.
1072 				 */
1073 				for (npmport = 0; npmport < SATA_NUM_PMPORTS(
1074 				    sata_hba_inst, ncport); npmport++) {
1075 					tdip = sata_get_target_dip(dip, ncport,
1076 					    npmport);
1077 					if (tdip != NULL) {
1078 						if (ndi_devi_offline(tdip,
1079 						    NDI_DEVI_REMOVE) !=
1080 						    NDI_SUCCESS) {
1081 							SATA_LOG_D((
1082 							    sata_hba_inst,
1083 							    CE_WARN,
1084 							    "sata_hba_detach: "
1085 							    "Target node not "
1086 							    "removed !"));
1087 							mutex_exit(&cportinfo->
1088 							    cport_mutex);
1089 							return (DDI_FAILURE);
1090 						}
1091 					}
1092 				}
1093 				mutex_exit(&cportinfo->cport_mutex);
1094 			}
1095 		}
1096 		/*
1097 		 * Disable sata event daemon processing for this HBA
1098 		 */
1099 		sata_hba_inst->satahba_attached = 0;
1100 
1101 		/*
1102 		 * Remove event daemon thread, if it is last HBA instance.
1103 		 */
1104 
1105 		mutex_enter(&sata_mutex);
1106 		if (sata_hba_list->satahba_next == NULL) {
1107 			mutex_exit(&sata_mutex);
1108 			sata_event_thread_control(0);
1109 			mutex_enter(&sata_mutex);
1110 		}
1111 		mutex_exit(&sata_mutex);
1112 
1113 		/* Remove this HBA instance from the HBA list */
1114 		sata_remove_hba_instance(dip);
1115 
1116 		/*
1117 		 * At this point there should be no target nodes attached.
1118 		 * Detach and destroy device and port info structures.
1119 		 */
1120 		for (ncport = 0; ncport < SATA_NUM_CPORTS(sata_hba_inst);
1121 		    ncport++) {
1122 			cportinfo = SATA_CPORT_INFO(sata_hba_inst, ncport);
1123 			if (cportinfo->cport_dev_type != SATA_DTYPE_PMULT) {
1124 				sdinfo =
1125 				    cportinfo->cport_devp.cport_sata_drive;
1126 				if (sdinfo != NULL) {
1127 					/* Release device structure */
1128 					kmem_free(sdinfo,
1129 					    sizeof (sata_drive_info_t));
1130 				}
1131 				/* Release cport info */
1132 				mutex_destroy(&cportinfo->cport_mutex);
1133 				kmem_free(cportinfo,
1134 				    sizeof (sata_cport_info_t));
1135 			} else { /* SATA_DTYPE_PMULT */
1136 				sdevice.satadev_addr.cport = (uint8_t)ncport;
1137 				sdevice.satadev_addr.qual = SATA_ADDR_PMULT;
1138 				sata_free_pmult(sata_hba_inst, &sdevice);
1139 			}
1140 		}
1141 
1142 		scsi_hba_tran_free(sata_hba_inst->satahba_scsi_tran);
1143 
1144 		(void) ddi_prop_remove(DDI_DEV_T_ANY, dip, "sata");
1145 
1146 		taskq_destroy(sata_hba_inst->satahba_taskq);
1147 
1148 		mutex_destroy(&sata_hba_inst->satahba_mutex);
1149 		kmem_free((void *)sata_hba_inst,
1150 		    sizeof (struct sata_hba_inst));
1151 
1152 		return (DDI_SUCCESS);
1153 
1154 	case DDI_SUSPEND:
1155 		/*
1156 		 * Postponed until phase 2
1157 		 */
1158 		return (DDI_FAILURE);
1159 
1160 	default:
1161 		return (DDI_FAILURE);
1162 	}
1163 }
1164 
1165 
1166 /*
1167  * Called by an HBA drive from _fini() routine.
1168  * Unregisters SATA HBA instance/SATA framework pair from the scsi framework.
1169  */
1170 void
1171 sata_hba_fini(struct modlinkage *modlp)
1172 {
1173 	SATADBG1(SATA_DBG_HBA_IF, NULL,
1174 	    "sata_hba_fini: name %s\n",
1175 	    ((struct modldrv *)(modlp->ml_linkage[0]))->drv_linkinfo);
1176 
1177 	scsi_hba_fini(modlp);
1178 }
1179 
1180 
1181 /*
1182  * Default open and close routine for sata_hba framework.
1183  *
1184  */
1185 /*
1186  * Open devctl node.
1187  *
1188  * Returns:
1189  * 0 if node was open successfully, error code otherwise.
1190  *
1191  *
1192  */
1193 
1194 static int
1195 sata_hba_open(dev_t *devp, int flags, int otyp, cred_t *credp)
1196 {
1197 #ifndef __lock_lint
1198 	_NOTE(ARGUNUSED(credp))
1199 #endif
1200 	int rv = 0;
1201 	dev_info_t *dip;
1202 	scsi_hba_tran_t *scsi_hba_tran;
1203 	sata_hba_inst_t	*sata_hba_inst;
1204 
1205 	SATADBG1(SATA_DBG_IOCTL_IF, NULL, "sata_hba_open: entered", NULL);
1206 
1207 	if (otyp != OTYP_CHR)
1208 		return (EINVAL);
1209 
1210 	dip = sata_devt_to_devinfo(*devp);
1211 	if (dip == NULL)
1212 		return (ENXIO);
1213 
1214 	if ((scsi_hba_tran = ddi_get_driver_private(dip)) == NULL)
1215 		return (ENXIO);
1216 
1217 	sata_hba_inst = scsi_hba_tran->tran_hba_private;
1218 	if (sata_hba_inst == NULL || sata_hba_inst->satahba_attached == 0)
1219 		return (ENXIO);
1220 
1221 	mutex_enter(&sata_mutex);
1222 	if (flags & FEXCL) {
1223 		if (sata_hba_inst->satahba_open_flag != 0) {
1224 			rv = EBUSY;
1225 		} else {
1226 			sata_hba_inst->satahba_open_flag =
1227 			    SATA_DEVCTL_EXOPENED;
1228 		}
1229 	} else {
1230 		if (sata_hba_inst->satahba_open_flag == SATA_DEVCTL_EXOPENED) {
1231 			rv = EBUSY;
1232 		} else {
1233 			sata_hba_inst->satahba_open_flag =
1234 			    SATA_DEVCTL_SOPENED;
1235 		}
1236 	}
1237 	mutex_exit(&sata_mutex);
1238 
1239 	return (rv);
1240 }
1241 
1242 
1243 /*
1244  * Close devctl node.
1245  * Returns:
1246  * 0 if node was closed successfully, error code otherwise.
1247  *
1248  */
1249 
1250 static int
1251 sata_hba_close(dev_t dev, int flag, int otyp, cred_t *credp)
1252 {
1253 #ifndef __lock_lint
1254 	_NOTE(ARGUNUSED(credp))
1255 	_NOTE(ARGUNUSED(flag))
1256 #endif
1257 	dev_info_t *dip;
1258 	scsi_hba_tran_t *scsi_hba_tran;
1259 	sata_hba_inst_t	*sata_hba_inst;
1260 
1261 	SATADBG1(SATA_DBG_IOCTL_IF, NULL, "sata_hba_close: entered", NULL);
1262 
1263 	if (otyp != OTYP_CHR)
1264 		return (EINVAL);
1265 
1266 	dip = sata_devt_to_devinfo(dev);
1267 	if (dip == NULL)
1268 		return (ENXIO);
1269 
1270 	if ((scsi_hba_tran = ddi_get_driver_private(dip)) == NULL)
1271 		return (ENXIO);
1272 
1273 	sata_hba_inst = scsi_hba_tran->tran_hba_private;
1274 	if (sata_hba_inst == NULL || sata_hba_inst->satahba_attached == 0)
1275 		return (ENXIO);
1276 
1277 	mutex_enter(&sata_mutex);
1278 	sata_hba_inst->satahba_open_flag = 0;
1279 	mutex_exit(&sata_mutex);
1280 	return (0);
1281 }
1282 
1283 
1284 
1285 /*
1286  * Standard IOCTL commands for SATA hotplugging.
1287  * Implemented DEVCTL_AP commands:
1288  * DEVCTL_AP_CONNECT
1289  * DEVCTL_AP_DISCONNECT
1290  * DEVCTL_AP_CONFIGURE
1291  * DEVCTL_UNCONFIGURE
1292  * DEVCTL_AP_CONTROL
1293  *
1294  * Commands passed to default ndi ioctl handler:
1295  * DEVCTL_DEVICE_GETSTATE
1296  * DEVCTL_DEVICE_ONLINE
1297  * DEVCTL_DEVICE_OFFLINE
1298  * DEVCTL_DEVICE_REMOVE
1299  * DEVCTL_DEVICE_INSERT
1300  * DEVCTL_BUS_GETSTATE
1301  *
1302  * All other cmds are passed to HBA if it provide ioctl handler, or failed
1303  * if not.
1304  *
1305  * Returns:
1306  * 0 if successful,
1307  * error code if operation failed.
1308  *
1309  * Port Multiplier support is supported now.
1310  *
1311  * NOTE: qual should be SATA_ADDR_DCPORT or SATA_ADDR_DPMPORT
1312  */
1313 
1314 static int
1315 sata_hba_ioctl(dev_t dev, int cmd, intptr_t arg, int mode, cred_t *credp,
1316     int *rvalp)
1317 {
1318 #ifndef __lock_lint
1319 	_NOTE(ARGUNUSED(credp))
1320 	_NOTE(ARGUNUSED(rvalp))
1321 #endif
1322 	int rv = 0;
1323 	int32_t	comp_port = -1;
1324 	dev_info_t *dip;
1325 	devctl_ap_state_t ap_state;
1326 	struct devctl_iocdata *dcp = NULL;
1327 	scsi_hba_tran_t *scsi_hba_tran;
1328 	sata_hba_inst_t *sata_hba_inst;
1329 	sata_device_t sata_device;
1330 	sata_cport_info_t *cportinfo;
1331 	int cport, pmport, qual;
1332 	int rval = SATA_SUCCESS;
1333 
1334 	dip = sata_devt_to_devinfo(dev);
1335 	if (dip == NULL)
1336 		return (ENXIO);
1337 
1338 	if ((scsi_hba_tran = ddi_get_driver_private(dip)) == NULL)
1339 		return (ENXIO);
1340 
1341 	sata_hba_inst = scsi_hba_tran->tran_hba_private;
1342 	if (sata_hba_inst == NULL)
1343 		return (ENXIO);
1344 
1345 	if (sata_hba_inst->satahba_tran == NULL)
1346 		return (ENXIO);
1347 
1348 	switch (cmd) {
1349 
1350 	case DEVCTL_DEVICE_GETSTATE:
1351 	case DEVCTL_DEVICE_ONLINE:
1352 	case DEVCTL_DEVICE_OFFLINE:
1353 	case DEVCTL_DEVICE_REMOVE:
1354 	case DEVCTL_BUS_GETSTATE:
1355 		/*
1356 		 * There may be more cases that we want to pass to default
1357 		 * handler rather than fail them.
1358 		 */
1359 		return (ndi_devctl_ioctl(dip, cmd, arg, mode, 0));
1360 	}
1361 
1362 	cport = pmport = qual = 0;
1363 	cportinfo = NULL;
1364 
1365 	/* read devctl ioctl data */
1366 	if (cmd != DEVCTL_AP_CONTROL && IS_DEVCTL(cmd)) {
1367 		if (ndi_dc_allochdl((void *)arg, &dcp) != NDI_SUCCESS)
1368 			return (EFAULT);
1369 
1370 		if ((comp_port = sata_get_port_num(sata_hba_inst, dcp)) ==
1371 		    -1) {
1372 			if (dcp)
1373 				ndi_dc_freehdl(dcp);
1374 			return (EINVAL);
1375 		}
1376 
1377 		/*
1378 		 * According to SCSI_TO_SATA_ADDR_QUAL, qual should be either
1379 		 * SATA_ADDR_DCPORT or SATA_ADDR_DPMPORT.
1380 		 */
1381 		cport = SCSI_TO_SATA_CPORT(comp_port);
1382 		pmport = SCSI_TO_SATA_PMPORT(comp_port);
1383 		qual = SCSI_TO_SATA_ADDR_QUAL(comp_port);
1384 
1385 		if (sata_validate_sata_address(sata_hba_inst, cport, pmport,
1386 		    qual) != 0) {
1387 			ndi_dc_freehdl(dcp);
1388 			return (EINVAL);
1389 		}
1390 
1391 		cportinfo = SATA_CPORT_INFO(sata_hba_inst, cport);
1392 		mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, cport)->
1393 		    cport_mutex);
1394 		if (cportinfo->cport_event_flags & SATA_EVNT_LOCK_PORT_BUSY) {
1395 			/*
1396 			 * Cannot process ioctl request now. Come back later.
1397 			 */
1398 			mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)->
1399 			    cport_mutex);
1400 			ndi_dc_freehdl(dcp);
1401 			return (EBUSY);
1402 		}
1403 		/* Block event processing for this port */
1404 		cportinfo->cport_event_flags |= SATA_APCTL_LOCK_PORT_BUSY;
1405 		mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex);
1406 
1407 		sata_device.satadev_addr.cport = cport;
1408 		sata_device.satadev_addr.pmport = pmport;
1409 		sata_device.satadev_addr.qual = qual;
1410 		sata_device.satadev_rev = SATA_DEVICE_REV;
1411 	}
1412 
1413 	switch (cmd) {
1414 
1415 	case DEVCTL_AP_DISCONNECT:
1416 
1417 		/*
1418 		 * Normally, cfgadm sata plugin will try to offline
1419 		 * (unconfigure) device before this request. Nevertheless,
1420 		 * if a device is still configured, we need to
1421 		 * attempt to offline and unconfigure device first, and we will
1422 		 * deactivate the port regardless of the unconfigure
1423 		 * operation results.
1424 		 *
1425 		 */
1426 		rv = sata_ioctl_disconnect(sata_hba_inst, &sata_device);
1427 
1428 		break;
1429 
1430 	case DEVCTL_AP_UNCONFIGURE:
1431 
1432 		/*
1433 		 * The unconfigure operation uses generic nexus operation to
1434 		 * offline a device. It leaves a target device node attached.
1435 		 * and obviously sata_drive_info attached as well, because
1436 		 * from the hardware point of view nothing has changed.
1437 		 */
1438 		rv = sata_ioctl_unconfigure(sata_hba_inst, &sata_device);
1439 		break;
1440 
1441 	case DEVCTL_AP_CONNECT:
1442 	{
1443 		/*
1444 		 * The sata cfgadm pluging will invoke this operation only if
1445 		 * port was found in the disconnect state (failed state
1446 		 * is also treated as the disconnected state).
1447 		 * If port activation is successful and a device is found
1448 		 * attached to the port, the initialization sequence is
1449 		 * executed to probe the port and attach
1450 		 * a device structure to a port structure. The device is not
1451 		 * set in configured state (system-wise) by this operation.
1452 		 */
1453 
1454 		rv = sata_ioctl_connect(sata_hba_inst, &sata_device);
1455 
1456 		break;
1457 	}
1458 
1459 	case DEVCTL_AP_CONFIGURE:
1460 	{
1461 		/*
1462 		 * A port may be in an active or shutdown state.
1463 		 * If port is in a failed state, operation is aborted.
1464 		 * If a port is in a shutdown state, sata_tran_port_activate()
1465 		 * is invoked prior to any other operation.
1466 		 *
1467 		 * Onlining the device involves creating a new target node.
1468 		 * If there is an old target node present (belonging to
1469 		 * previously removed device), the operation is aborted - the
1470 		 * old node has to be released and removed before configure
1471 		 * operation is attempted.
1472 		 */
1473 
1474 		rv = sata_ioctl_configure(sata_hba_inst, &sata_device);
1475 
1476 		break;
1477 	}
1478 
1479 	case DEVCTL_AP_GETSTATE:
1480 
1481 		sata_cfgadm_state(sata_hba_inst, comp_port, &ap_state);
1482 
1483 		ap_state.ap_last_change = (time_t)-1;
1484 		ap_state.ap_error_code = 0;
1485 		ap_state.ap_in_transition = 0;
1486 
1487 		/* Copy the return AP-state information to the user space */
1488 		if (ndi_dc_return_ap_state(&ap_state, dcp) != NDI_SUCCESS) {
1489 			rv = EFAULT;
1490 		}
1491 		break;
1492 
1493 	case DEVCTL_AP_CONTROL:
1494 	{
1495 		/*
1496 		 * Generic devctl for hardware specific functionality
1497 		 */
1498 		sata_ioctl_data_t	ioc;
1499 
1500 		ASSERT(dcp == NULL);
1501 
1502 		/* Copy in user ioctl data first */
1503 #ifdef _MULTI_DATAMODEL
1504 		if (ddi_model_convert_from(mode & FMODELS) ==
1505 		    DDI_MODEL_ILP32) {
1506 
1507 			sata_ioctl_data_32_t	ioc32;
1508 
1509 			if (ddi_copyin((void *)arg, (void *)&ioc32,
1510 			    sizeof (ioc32), mode) != 0) {
1511 				rv = EFAULT;
1512 				break;
1513 			}
1514 			ioc.cmd		= (uint_t)ioc32.cmd;
1515 			ioc.port	= (uint_t)ioc32.port;
1516 			ioc.get_size	= (uint_t)ioc32.get_size;
1517 			ioc.buf		= (caddr_t)(uintptr_t)ioc32.buf;
1518 			ioc.bufsiz	= (uint_t)ioc32.bufsiz;
1519 			ioc.misc_arg	= (uint_t)ioc32.misc_arg;
1520 		} else
1521 #endif /* _MULTI_DATAMODEL */
1522 		if (ddi_copyin((void *)arg, (void *)&ioc, sizeof (ioc),
1523 		    mode) != 0) {
1524 			return (EFAULT);
1525 		}
1526 
1527 		SATADBG2(SATA_DBG_IOCTL_IF, sata_hba_inst,
1528 		    "sata_hba_ioctl: DEVCTL_AP_CONTROL "
1529 		    "cmd 0x%x, port 0x%x", ioc.cmd, ioc.port);
1530 
1531 		/*
1532 		 * To avoid BE/LE and 32/64 issues, a get_size always returns
1533 		 * a 32-bit number.
1534 		 */
1535 		if (ioc.get_size != 0 && ioc.bufsiz != (sizeof (uint32_t))) {
1536 			return (EINVAL);
1537 		}
1538 		/* validate address */
1539 		cport = SCSI_TO_SATA_CPORT(ioc.port);
1540 		pmport = SCSI_TO_SATA_PMPORT(ioc.port);
1541 		qual = SCSI_TO_SATA_ADDR_QUAL(ioc.port);
1542 
1543 		SATADBG3(SATA_DBG_IOCTL_IF, sata_hba_inst,
1544 		    "sata_hba_ioctl: target port is %d:%d (%d)",
1545 		    cport, pmport, qual);
1546 
1547 		if (sata_validate_sata_address(sata_hba_inst, cport,
1548 		    pmport, qual) != 0)
1549 			return (EINVAL);
1550 
1551 		cportinfo = SATA_CPORT_INFO(sata_hba_inst, cport);
1552 		mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, cport)->
1553 		    cport_mutex);
1554 		/* Is the port locked by event processing daemon ? */
1555 		if (cportinfo->cport_event_flags & SATA_EVNT_LOCK_PORT_BUSY) {
1556 			/*
1557 			 * Cannot process ioctl request now. Come back later
1558 			 */
1559 			mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)->
1560 			    cport_mutex);
1561 			return (EBUSY);
1562 		}
1563 		/* Block event processing for this port */
1564 		cportinfo->cport_event_flags |= SATA_APCTL_LOCK_PORT_BUSY;
1565 		mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex);
1566 
1567 
1568 		sata_device.satadev_addr.cport = cport;
1569 		sata_device.satadev_addr.pmport = pmport;
1570 		sata_device.satadev_addr.qual = qual;
1571 		sata_device.satadev_rev = SATA_DEVICE_REV;
1572 
1573 		switch (ioc.cmd) {
1574 
1575 		case SATA_CFGA_RESET_PORT:
1576 			/*
1577 			 * There is no protection for configured device.
1578 			 */
1579 			rv = sata_ioctl_reset_port(sata_hba_inst, &sata_device);
1580 			break;
1581 
1582 		case SATA_CFGA_RESET_DEVICE:
1583 			/*
1584 			 * There is no protection for configured device.
1585 			 */
1586 			rv = sata_ioctl_reset_device(sata_hba_inst,
1587 			    &sata_device);
1588 			break;
1589 
1590 		case SATA_CFGA_RESET_ALL:
1591 			/*
1592 			 * There is no protection for configured devices.
1593 			 */
1594 			rv = sata_ioctl_reset_all(sata_hba_inst);
1595 			/*
1596 			 * We return here, because common return is for
1597 			 * a single port operation - we have already unlocked
1598 			 * all ports and no dc handle was allocated.
1599 			 */
1600 			return (rv);
1601 
1602 		case SATA_CFGA_PORT_DEACTIVATE:
1603 			/*
1604 			 * Arbitrarily unconfigure attached device, if any.
1605 			 * Even if the unconfigure fails, proceed with the
1606 			 * port deactivation.
1607 			 */
1608 			rv = sata_ioctl_deactivate(sata_hba_inst, &sata_device);
1609 
1610 			break;
1611 
1612 		case SATA_CFGA_PORT_ACTIVATE:
1613 
1614 			rv = sata_ioctl_activate(sata_hba_inst, &sata_device);
1615 			break;
1616 
1617 		case SATA_CFGA_PORT_SELF_TEST:
1618 
1619 			rv = sata_ioctl_port_self_test(sata_hba_inst,
1620 			    &sata_device);
1621 			break;
1622 
1623 		case SATA_CFGA_GET_DEVICE_PATH:
1624 
1625 			rv = sata_ioctl_get_device_path(sata_hba_inst,
1626 			    &sata_device, &ioc, mode);
1627 			break;
1628 
1629 		case SATA_CFGA_GET_AP_TYPE:
1630 
1631 			rv = sata_ioctl_get_ap_type(sata_hba_inst,
1632 			    &sata_device, &ioc, mode);
1633 			break;
1634 
1635 		case SATA_CFGA_GET_MODEL_INFO:
1636 
1637 			rv = sata_ioctl_get_model_info(sata_hba_inst,
1638 			    &sata_device, &ioc, mode);
1639 			break;
1640 
1641 		case SATA_CFGA_GET_REVFIRMWARE_INFO:
1642 
1643 			rv = sata_ioctl_get_revfirmware_info(sata_hba_inst,
1644 			    &sata_device, &ioc, mode);
1645 			break;
1646 
1647 		case SATA_CFGA_GET_SERIALNUMBER_INFO:
1648 
1649 			rv = sata_ioctl_get_serialnumber_info(sata_hba_inst,
1650 			    &sata_device, &ioc, mode);
1651 			break;
1652 
1653 		default:
1654 			rv = EINVAL;
1655 			break;
1656 
1657 		} /* End of DEVCTL_AP_CONTROL cmd switch */
1658 
1659 		break;
1660 	}
1661 
1662 	default:
1663 	{
1664 		/*
1665 		 * If we got here, we got an IOCTL that SATA HBA Framework
1666 		 * does not recognize. Pass ioctl to HBA driver, in case
1667 		 * it could process it.
1668 		 */
1669 		sata_hba_tran_t *sata_tran = sata_hba_inst->satahba_tran;
1670 		dev_info_t	*mydip = SATA_DIP(sata_hba_inst);
1671 
1672 		SATADBG1(SATA_DBG_IOCTL_IF, sata_hba_inst,
1673 		    "IOCTL 0x%2x not supported in SATA framework, "
1674 		    "passthrough to HBA", cmd);
1675 
1676 		if (sata_tran->sata_tran_ioctl == NULL) {
1677 			rv = EINVAL;
1678 			break;
1679 		}
1680 		rval = (*sata_tran->sata_tran_ioctl)(mydip, cmd, arg);
1681 		if (rval != 0) {
1682 			SATADBG1(SATA_DBG_IOCTL_IF, sata_hba_inst,
1683 			    "IOCTL 0x%2x failed in HBA", cmd);
1684 			rv = rval;
1685 		}
1686 		break;
1687 	}
1688 
1689 	} /* End of main IOCTL switch */
1690 
1691 	if (dcp) {
1692 		ndi_dc_freehdl(dcp);
1693 	}
1694 
1695 	if (IS_DEVCTL(cmd)) {
1696 		mutex_enter(&SATA_CPORT_INFO(sata_hba_inst,
1697 		    cport)->cport_mutex);
1698 		cportinfo->cport_event_flags &= ~SATA_APCTL_LOCK_PORT_BUSY;
1699 		mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex);
1700 	}
1701 
1702 	return (rv);
1703 }
1704 
1705 
1706 /*
1707  * Create error retrieval sata packet
1708  *
1709  * A sata packet is allocated and set-up to contain specified error retrieval
1710  * command and appropriate dma-able data buffer.
1711  * No association with any scsi packet is made and no callback routine is
1712  * specified.
1713  *
1714  * Returns a pointer to sata packet upon successful packet creation.
1715  * Returns NULL, if packet cannot be created.
1716  */
1717 sata_pkt_t *
1718 sata_get_error_retrieval_pkt(dev_info_t *dip, sata_device_t *sata_device,
1719     int pkt_type)
1720 {
1721 	sata_hba_inst_t	*sata_hba_inst;
1722 	sata_pkt_txlate_t *spx;
1723 	sata_pkt_t *spkt;
1724 	sata_drive_info_t *sdinfo;
1725 
1726 	mutex_enter(&sata_mutex);
1727 	for (sata_hba_inst = sata_hba_list; sata_hba_inst != NULL;
1728 	    sata_hba_inst = sata_hba_inst->satahba_next) {
1729 		if (SATA_DIP(sata_hba_inst) == dip)
1730 			break;
1731 	}
1732 	mutex_exit(&sata_mutex);
1733 	ASSERT(sata_hba_inst != NULL);
1734 
1735 	sdinfo = sata_get_device_info(sata_hba_inst, sata_device);
1736 	if (sdinfo == NULL) {
1737 		sata_log(sata_hba_inst, CE_WARN,
1738 		    "sata: error recovery request for non-attached device at "
1739 		    "cport %d", sata_device->satadev_addr.cport);
1740 		return (NULL);
1741 	}
1742 
1743 	spx = kmem_zalloc(sizeof (sata_pkt_txlate_t), KM_SLEEP);
1744 	spx->txlt_sata_hba_inst = sata_hba_inst;
1745 	spx->txlt_scsi_pkt = NULL;		/* No scsi pkt involved */
1746 	spkt = sata_pkt_alloc(spx, NULL);
1747 	if (spkt == NULL) {
1748 		kmem_free(spx, sizeof (sata_pkt_txlate_t));
1749 		return (NULL);
1750 	}
1751 	/* address is needed now */
1752 	spkt->satapkt_device.satadev_addr = sata_device->satadev_addr;
1753 
1754 	switch (pkt_type) {
1755 	case SATA_ERR_RETR_PKT_TYPE_NCQ:
1756 		if (sata_ncq_err_ret_cmd_setup(spx, sdinfo) == SATA_SUCCESS) {
1757 			if (sata_check_for_dma_error(dip, spx)) {
1758 				ddi_fm_service_impact(dip,
1759 				    DDI_SERVICE_UNAFFECTED);
1760 				break;
1761 			}
1762 			return (spkt);
1763 		}
1764 		break;
1765 
1766 	case SATA_ERR_RETR_PKT_TYPE_ATAPI:
1767 		if (sata_atapi_err_ret_cmd_setup(spx, sdinfo) == SATA_SUCCESS) {
1768 			if (sata_check_for_dma_error(dip, spx)) {
1769 				ddi_fm_service_impact(dip,
1770 				    DDI_SERVICE_UNAFFECTED);
1771 				break;
1772 			}
1773 			return (spkt);
1774 		}
1775 		break;
1776 
1777 	default:
1778 		break;
1779 	}
1780 
1781 	sata_pkt_free(spx);
1782 	kmem_free(spx, sizeof (sata_pkt_txlate_t));
1783 	return (NULL);
1784 
1785 }
1786 
1787 
1788 /*
1789  * Free error retrieval sata packet
1790  *
1791  * Free sata packet and any associated resources allocated previously by
1792  * sata_get_error_retrieval_pkt().
1793  *
1794  * Void return.
1795  */
1796 void
1797 sata_free_error_retrieval_pkt(sata_pkt_t *sata_pkt)
1798 {
1799 	sata_pkt_txlate_t *spx =
1800 	    (sata_pkt_txlate_t *)sata_pkt->satapkt_framework_private;
1801 
1802 	ASSERT(sata_pkt != NULL);
1803 
1804 	sata_free_local_buffer(spx);
1805 	sata_pkt_free(spx);
1806 	kmem_free(spx, sizeof (sata_pkt_txlate_t));
1807 
1808 }
1809 
1810 /*
1811  * Create READ PORT MULTIPLIER and WRITE PORT MULTIPLIER sata packet
1812  *
1813  * No association with any scsi packet is made and no callback routine is
1814  * specified.
1815  *
1816  * Returns a pointer to sata packet upon successful packet creation.
1817  * Returns NULL, if packet cannot be created.
1818  *
1819  * NOTE: Input/Output value includes 64 bits accoring to SATA Spec 2.6,
1820  * only lower 32 bits are available currently.
1821  */
1822 sata_pkt_t *
1823 sata_get_rdwr_pmult_pkt(dev_info_t *dip, sata_device_t *sd,
1824     uint16_t regn, uint32_t regv, uint32_t type)
1825 {
1826 	sata_hba_inst_t	*sata_hba_inst;
1827 	sata_pkt_txlate_t *spx;
1828 	sata_pkt_t *spkt;
1829 	sata_cmd_t *scmd;
1830 
1831 	/* Only READ/WRITE commands are accepted. */
1832 	ASSERT(type == SATA_RDWR_PMULT_PKT_TYPE_READ ||
1833 	    type == SATA_RDWR_PMULT_PKT_TYPE_WRITE);
1834 
1835 	mutex_enter(&sata_mutex);
1836 	for (sata_hba_inst = sata_hba_list; sata_hba_inst != NULL;
1837 	    sata_hba_inst = sata_hba_inst->satahba_next) {
1838 		if (SATA_DIP(sata_hba_inst) == dip)
1839 			break;
1840 	}
1841 	mutex_exit(&sata_mutex);
1842 	ASSERT(sata_hba_inst != NULL);
1843 
1844 	spx = kmem_zalloc(sizeof (sata_pkt_txlate_t), KM_SLEEP);
1845 	spx->txlt_sata_hba_inst = sata_hba_inst;
1846 	spx->txlt_scsi_pkt = NULL;	/* No scsi pkt involved */
1847 	spkt = sata_pkt_alloc(spx, SLEEP_FUNC);
1848 	if (spkt == NULL) {
1849 		kmem_free(spx, sizeof (sata_pkt_txlate_t));
1850 		return (NULL);
1851 	}
1852 
1853 	/*
1854 	 * NOTE: We need to send this command to the port multiplier,
1855 	 * that means send to SATA_PMULT_HOSTPORT(0xf) pmport
1856 	 *
1857 	 * sata_device contains the address of actual target device, and the
1858 	 * pmport number in the command comes from the sata_device structure.
1859 	 */
1860 	spkt->satapkt_device.satadev_addr = sd->satadev_addr;
1861 	spkt->satapkt_device.satadev_addr.pmport = SATA_PMULT_HOSTPORT;
1862 	spkt->satapkt_device.satadev_addr.qual = SATA_ADDR_PMULT;
1863 
1864 	/* Fill sata_pkt */
1865 	spkt->satapkt_op_mode = SATA_OPMODE_SYNCH | SATA_OPMODE_POLLING;
1866 	spkt->satapkt_comp = NULL; /* Synchronous mode, no callback */
1867 	spkt->satapkt_time = 10; /* Timeout 10s */
1868 
1869 	/* Build READ PORT MULTIPLIER cmd in the sata_pkt */
1870 	scmd = &spkt->satapkt_cmd;
1871 	scmd->satacmd_features_reg = regn & 0xff;
1872 	scmd->satacmd_features_reg_ext = (regn >> 8) & 0xff;
1873 	scmd->satacmd_device_reg = sd->satadev_addr.pmport;
1874 	scmd->satacmd_addr_type = 0;		/* N/A */
1875 
1876 	scmd->satacmd_flags.sata_ignore_dev_reset = B_TRUE;
1877 
1878 	if (type == SATA_RDWR_PMULT_PKT_TYPE_READ) {
1879 		scmd->satacmd_cmd_reg = SATAC_READ_PORTMULT;
1880 		scmd->satacmd_flags.sata_data_direction = SATA_DIR_READ;
1881 		scmd->satacmd_flags.sata_special_regs = 1;
1882 		scmd->satacmd_flags.sata_copy_out_lba_high_lsb = 1;
1883 		scmd->satacmd_flags.sata_copy_out_lba_mid_lsb = 1;
1884 		scmd->satacmd_flags.sata_copy_out_lba_low_lsb = 1;
1885 		scmd->satacmd_flags.sata_copy_out_sec_count_lsb = 1;
1886 	} else if (type == SATA_RDWR_PMULT_PKT_TYPE_WRITE) {
1887 		scmd->satacmd_cmd_reg = SATAC_WRITE_PORTMULT;
1888 		scmd->satacmd_flags.sata_data_direction = SATA_DIR_WRITE;
1889 		scmd->satacmd_sec_count_lsb = regv & 0xff;
1890 		scmd->satacmd_lba_low_lsb = regv >> 8 & 0xff;
1891 		scmd->satacmd_lba_mid_lsb = regv >> 16 & 0xff;
1892 		scmd->satacmd_lba_high_lsb = regv >> 24 & 0xff;
1893 	}
1894 
1895 	return (spkt);
1896 }
1897 
1898 /*
1899  * Free sata packet and any associated resources allocated previously by
1900  * sata_get_rdwr_pmult_pkt().
1901  *
1902  * Void return.
1903  */
1904 void
1905 sata_free_rdwr_pmult_pkt(sata_pkt_t *sata_pkt)
1906 {
1907 	sata_pkt_txlate_t *spx =
1908 	    (sata_pkt_txlate_t *)sata_pkt->satapkt_framework_private;
1909 
1910 	/* Free allocated resources */
1911 	sata_pkt_free(spx);
1912 	kmem_free(spx, sizeof (sata_pkt_txlate_t));
1913 }
1914 
1915 /*
1916  * Register a port multiplier to framework.
1917  * 1) Store the GSCR values in the previous allocated pmult_info strctures.
1918  * 2) Search in the blacklist and update the number of the device ports of the
1919  * port multiplier.
1920  *
1921  * Void return.
1922  */
1923 void
1924 sata_register_pmult(dev_info_t *dip, sata_device_t *sd, sata_pmult_gscr_t *sg)
1925 {
1926 	sata_hba_inst_t *sata_hba_inst = NULL;
1927 	sata_pmult_info_t *pmultinfo;
1928 	sata_pmult_bl_t *blp;
1929 	int cport = sd->satadev_addr.cport;
1930 
1931 	mutex_enter(&sata_mutex);
1932 	for (sata_hba_inst = sata_hba_list; sata_hba_inst != NULL;
1933 	    sata_hba_inst = sata_hba_inst->satahba_next) {
1934 		if (SATA_DIP(sata_hba_inst) == dip)
1935 			if (sata_hba_inst->satahba_attached == 1)
1936 				break;
1937 	}
1938 	mutex_exit(&sata_mutex);
1939 	/* HBA not attached? */
1940 	if (sata_hba_inst == NULL)
1941 		return;
1942 
1943 	/* Number of pmports */
1944 	sd->satadev_add_info = sg->gscr2 & SATA_PMULT_PORTNUM_MASK;
1945 
1946 	/* Check the blacklist */
1947 	for (blp = sata_pmult_blacklist; blp->bl_gscr0; blp++) {
1948 		if (sg->gscr0 != blp->bl_gscr0 && blp->bl_gscr0)
1949 			continue;
1950 		if (sg->gscr1 != blp->bl_gscr1 && blp->bl_gscr1)
1951 			continue;
1952 		if (sg->gscr2 != blp->bl_gscr2 && blp->bl_gscr2)
1953 			continue;
1954 
1955 		cmn_err(CE_WARN, "!Port multiplier is on the blacklist.");
1956 		sd->satadev_add_info = blp->bl_flags;
1957 		break;
1958 	}
1959 
1960 	/* Register the port multiplier GSCR */
1961 	mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, cport)));
1962 	pmultinfo = SATA_PMULT_INFO(sata_hba_inst, cport);
1963 	if (pmultinfo != NULL) {
1964 		pmultinfo->pmult_gscr = *sg;
1965 		pmultinfo->pmult_num_dev_ports =
1966 		    sd->satadev_add_info & SATA_PMULT_PORTNUM_MASK;
1967 		SATADBG1(SATA_DBG_PMULT, sata_hba_inst,
1968 		    "Port multiplier registered at port %d", cport);
1969 	}
1970 	mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, cport)));
1971 }
1972 
1973 /*
1974  * sata_split_model splits the model ID into vendor and product IDs.
1975  * It assumes that a vendor ID cannot be longer than 8 characters, and
1976  * that vendor and product ID are separated by a whitespace.
1977  */
1978 void
1979 sata_split_model(char *model, char **vendor, char **product)
1980 {
1981 	int i, modlen;
1982 	char *vid, *pid;
1983 
1984 	/*
1985 	 * remove whitespace at the end of model
1986 	 */
1987 	for (i = SATA_ID_MODEL_LEN; i > 0; i--)
1988 		if (model[i] == ' ' || model[i] == '\t' || model[i] == '\0')
1989 			model[i] = '\0';
1990 		else
1991 			break;
1992 
1993 	/*
1994 	 * try to split model into into vid/pid
1995 	 */
1996 	modlen = strlen(model);
1997 	for (i = 0, pid = model; i < modlen; i++, pid++)
1998 		if ((*pid == ' ') || (*pid == '\t'))
1999 			break;
2000 
2001 	/*
2002 	 * only use vid if it is less than 8 chars (as in SCSI)
2003 	 */
2004 	if (i < modlen && i <= 8) {
2005 		vid = model;
2006 		/*
2007 		 * terminate vid, establish pid
2008 		 */
2009 		*pid++ = '\0';
2010 	} else {
2011 		/*
2012 		 * vid will stay "ATA     "
2013 		 */
2014 		vid = NULL;
2015 		/*
2016 		 * model is all pid
2017 		 */
2018 		pid = model;
2019 	}
2020 
2021 	*vendor = vid;
2022 	*product = pid;
2023 }
2024 
2025 /*
2026  * sata_name_child is for composing the name of the node
2027  * the format of the name is "target,0".
2028  */
2029 static int
2030 sata_name_child(dev_info_t *dip, char *name, int namelen)
2031 {
2032 	int target;
2033 
2034 	target = ddi_prop_get_int(DDI_DEV_T_ANY, dip,
2035 	    DDI_PROP_DONTPASS, "target", -1);
2036 	if (target == -1)
2037 		return (DDI_FAILURE);
2038 	(void) snprintf(name, namelen, "%x,0", target);
2039 	return (DDI_SUCCESS);
2040 }
2041 
2042 
2043 
2044 /* ****************** SCSA required entry points *********************** */
2045 
2046 /*
2047  * Implementation of scsi tran_tgt_init.
2048  * sata_scsi_tgt_init() initializes scsi_device structure
2049  *
2050  * If successful, DDI_SUCCESS is returned.
2051  * DDI_FAILURE is returned if addressed device does not exist
2052  */
2053 
2054 static int
2055 sata_scsi_tgt_init(dev_info_t *hba_dip, dev_info_t *tgt_dip,
2056     scsi_hba_tran_t *hba_tran, struct scsi_device *sd)
2057 {
2058 #ifndef __lock_lint
2059 	_NOTE(ARGUNUSED(hba_dip))
2060 	_NOTE(ARGUNUSED(tgt_dip))
2061 #endif
2062 	sata_device_t		sata_device;
2063 	sata_drive_info_t	*sdinfo;
2064 	struct sata_id		*sid;
2065 	sata_hba_inst_t		*sata_hba_inst;
2066 	char			model[SATA_ID_MODEL_LEN + 1];
2067 	char			fw[SATA_ID_FW_LEN + 1];
2068 	char			*vid, *pid;
2069 
2070 	/*
2071 	 * Fail tran_tgt_init for .conf stub node
2072 	 */
2073 	if (ndi_dev_is_persistent_node(tgt_dip) == 0) {
2074 		(void) ndi_merge_node(tgt_dip, sata_name_child);
2075 		ddi_set_name_addr(tgt_dip, NULL);
2076 		return (DDI_FAILURE);
2077 	}
2078 
2079 	sata_hba_inst = (sata_hba_inst_t *)(hba_tran->tran_hba_private);
2080 
2081 	/* Validate scsi device address */
2082 	if (sata_validate_scsi_address(sata_hba_inst, &sd->sd_address,
2083 	    &sata_device) != 0)
2084 		return (DDI_FAILURE);
2085 
2086 	mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst,
2087 	    sata_device.satadev_addr.cport)));
2088 
2089 	/* sata_device now contains a valid sata address */
2090 	sdinfo = sata_get_device_info(sata_hba_inst, &sata_device);
2091 	if (sdinfo == NULL) {
2092 		mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst,
2093 		    sata_device.satadev_addr.cport)));
2094 		return (DDI_FAILURE);
2095 	}
2096 	mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst,
2097 	    sata_device.satadev_addr.cport)));
2098 
2099 	/*
2100 	 * Check if we need to create a legacy devid (i.e cmdk style) for
2101 	 * the target disks.
2102 	 *
2103 	 * HBA devinfo node will have the property "use-cmdk-devid-format"
2104 	 * if we need to create cmdk-style devid for all the disk devices
2105 	 * attached to this controller. This property may have been set
2106 	 * from HBA driver's .conf file or by the HBA driver in its
2107 	 * attach(9E) function.
2108 	 */
2109 	if ((sdinfo->satadrv_type == SATA_DTYPE_ATADISK) &&
2110 	    (ddi_getprop(DDI_DEV_T_ANY, hba_dip, DDI_PROP_DONTPASS,
2111 	    "use-cmdk-devid-format", 0) == 1)) {
2112 		/* register a legacy devid for this target node */
2113 		sata_target_devid_register(tgt_dip, sdinfo);
2114 	}
2115 
2116 
2117 	/*
2118 	 * 'Identify Device Data' does not always fit in standard SCSI
2119 	 * INQUIRY data, so establish INQUIRY_* properties with full-form
2120 	 * of information.
2121 	 */
2122 	sid = &sdinfo->satadrv_id;
2123 #ifdef	_LITTLE_ENDIAN
2124 	swab(sid->ai_model, model, SATA_ID_MODEL_LEN);
2125 	swab(sid->ai_fw, fw, SATA_ID_FW_LEN);
2126 #else	/* _LITTLE_ENDIAN */
2127 	bcopy(sid->ai_model, model, SATA_ID_MODEL_LEN);
2128 	bcopy(sid->ai_fw, fw, SATA_ID_FW_LEN);
2129 #endif	/* _LITTLE_ENDIAN */
2130 	model[SATA_ID_MODEL_LEN] = 0;
2131 	fw[SATA_ID_FW_LEN] = 0;
2132 
2133 	sata_split_model(model, &vid, &pid);
2134 
2135 	if (vid)
2136 		(void) scsi_device_prop_update_inqstring(sd, INQUIRY_VENDOR_ID,
2137 		    vid, strlen(vid));
2138 	if (pid)
2139 		(void) scsi_device_prop_update_inqstring(sd, INQUIRY_PRODUCT_ID,
2140 		    pid, strlen(pid));
2141 	(void) scsi_device_prop_update_inqstring(sd, INQUIRY_REVISION_ID,
2142 	    fw, strlen(fw));
2143 
2144 	return (DDI_SUCCESS);
2145 }
2146 
2147 /*
2148  * Implementation of scsi tran_tgt_probe.
2149  * Probe target, by calling default scsi routine scsi_hba_probe()
2150  */
2151 static int
2152 sata_scsi_tgt_probe(struct scsi_device *sd, int (*callback)(void))
2153 {
2154 	sata_hba_inst_t *sata_hba_inst =
2155 	    (sata_hba_inst_t *)(sd->sd_address.a_hba_tran->tran_hba_private);
2156 	int rval;
2157 	uint32_t pm_cap;
2158 
2159 	rval = scsi_hba_probe(sd, callback);
2160 	pm_cap = SATA_CAP_POWER_CONDITON | SATA_CAP_SMART_PAGE |
2161 	    SATA_CAP_LOG_SENSE;
2162 
2163 	if (rval == SCSIPROBE_EXISTS) {
2164 		/*
2165 		 * Set property "pm-capable" on the target device node, so that
2166 		 * the target driver will not try to fetch scsi cycle counters
2167 		 * before enabling device power-management.
2168 		 */
2169 		if ((ddi_prop_update_int(DDI_DEV_T_NONE, sd->sd_dev,
2170 		    "pm-capable", pm_cap)) != DDI_PROP_SUCCESS) {
2171 			sata_log(sata_hba_inst, CE_WARN,
2172 			    "SATA device at port %d: "
2173 			    "will not be power-managed ",
2174 			    SCSI_TO_SATA_CPORT(sd->sd_address.a_target));
2175 			SATA_LOG_D((sata_hba_inst, CE_WARN,
2176 			    "failure updating pm-capable property"));
2177 		}
2178 	}
2179 	return (rval);
2180 }
2181 
2182 /*
2183  * Implementation of scsi tran_tgt_free.
2184  * Release all resources allocated for scsi_device
2185  */
2186 static void
2187 sata_scsi_tgt_free(dev_info_t *hba_dip, dev_info_t *tgt_dip,
2188     scsi_hba_tran_t *hba_tran, struct scsi_device *sd)
2189 {
2190 #ifndef __lock_lint
2191 	_NOTE(ARGUNUSED(hba_dip))
2192 #endif
2193 	sata_device_t		sata_device;
2194 	sata_drive_info_t	*sdinfo;
2195 	sata_hba_inst_t		*sata_hba_inst;
2196 	ddi_devid_t		devid;
2197 
2198 	sata_hba_inst = (sata_hba_inst_t *)(hba_tran->tran_hba_private);
2199 
2200 	/* Validate scsi device address */
2201 	/*
2202 	 * Note: tgt_free relates to the SCSA view of a device. If called, there
2203 	 * was a device at this address, so even if the sata framework internal
2204 	 * resources were alredy released because a device was detached,
2205 	 * this function should be executed as long as its actions do
2206 	 * not require the internal sata view of a device and the address
2207 	 * refers to a valid sata address.
2208 	 * Validating the address here means that we do not trust SCSA...
2209 	 */
2210 	if (sata_validate_scsi_address(sata_hba_inst, &sd->sd_address,
2211 	    &sata_device) == -1)
2212 		return;
2213 
2214 	mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst,
2215 	    sata_device.satadev_addr.cport)));
2216 
2217 	/* sata_device now should contain a valid sata address */
2218 	sdinfo = sata_get_device_info(sata_hba_inst, &sata_device);
2219 	if (sdinfo == NULL) {
2220 		mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst,
2221 		    sata_device.satadev_addr.cport)));
2222 		return;
2223 	}
2224 	/*
2225 	 * We did not allocate any resources in sata_scsi_tgt_init()
2226 	 * other than few properties.
2227 	 * Free them.
2228 	 */
2229 	mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst,
2230 	    sata_device.satadev_addr.cport)));
2231 	(void) ndi_prop_remove(DDI_DEV_T_NONE, tgt_dip, "pm-capable");
2232 
2233 	/*
2234 	 * If devid was previously created but not freed up from
2235 	 * sd(4D) driver (i.e during detach(9E)) then do it here.
2236 	 */
2237 	if ((sdinfo->satadrv_type == SATA_DTYPE_ATADISK) &&
2238 	    (ddi_getprop(DDI_DEV_T_ANY, hba_dip, DDI_PROP_DONTPASS,
2239 	    "use-cmdk-devid-format", 0) == 1) &&
2240 	    (ddi_devid_get(tgt_dip, &devid) == DDI_SUCCESS)) {
2241 		ddi_devid_unregister(tgt_dip);
2242 		ddi_devid_free(devid);
2243 	}
2244 }
2245 
2246 /*
2247  * Implementation of scsi tran_init_pkt
2248  * Upon successful return, scsi pkt buffer has DMA resources allocated.
2249  *
2250  * It seems that we should always allocate pkt, even if the address is
2251  * for non-existing device - just use some default for dma_attr.
2252  * The reason is that there is no way to communicate this to a caller here.
2253  * Subsequent call to sata_scsi_start may fail appropriately.
2254  * Simply returning NULL does not seem to discourage a target driver...
2255  *
2256  * Returns a pointer to initialized scsi_pkt, or NULL otherwise.
2257  */
2258 static struct scsi_pkt *
2259 sata_scsi_init_pkt(struct scsi_address *ap, struct scsi_pkt *pkt,
2260     struct buf *bp, int cmdlen, int statuslen, int tgtlen, int flags,
2261     int (*callback)(caddr_t), caddr_t arg)
2262 {
2263 	sata_hba_inst_t *sata_hba_inst =
2264 	    (sata_hba_inst_t *)(ap->a_hba_tran->tran_hba_private);
2265 	dev_info_t *dip = SATA_DIP(sata_hba_inst);
2266 	sata_device_t sata_device;
2267 	sata_drive_info_t *sdinfo;
2268 	sata_pkt_txlate_t *spx;
2269 	ddi_dma_attr_t cur_dma_attr;
2270 	int rval;
2271 	boolean_t new_pkt = B_TRUE;
2272 
2273 	ASSERT(ap->a_hba_tran->tran_hba_dip == dip);
2274 
2275 	/*
2276 	 * We need to translate the address, even if it could be
2277 	 * a bogus one, for a non-existing device
2278 	 */
2279 	sata_device.satadev_addr.qual = SCSI_TO_SATA_ADDR_QUAL(ap->a_target);
2280 	sata_device.satadev_addr.cport = SCSI_TO_SATA_CPORT(ap->a_target);
2281 	sata_device.satadev_addr.pmport = SCSI_TO_SATA_PMPORT(ap->a_target);
2282 	sata_device.satadev_rev = SATA_DEVICE_REV;
2283 
2284 	if (pkt == NULL) {
2285 		/*
2286 		 * Have to allocate a brand new scsi packet.
2287 		 * We need to operate with auto request sense enabled.
2288 		 */
2289 		pkt = scsi_hba_pkt_alloc(dip, ap, cmdlen,
2290 		    MAX(statuslen, SATA_MAX_SENSE_LEN),
2291 		    tgtlen, sizeof (sata_pkt_txlate_t), callback, arg);
2292 
2293 		if (pkt == NULL)
2294 			return (NULL);
2295 
2296 		/* Fill scsi packet structure */
2297 		pkt->pkt_comp		= (void (*)())NULL;
2298 		pkt->pkt_time		= 0;
2299 		pkt->pkt_resid		= 0;
2300 		pkt->pkt_statistics	= 0;
2301 		pkt->pkt_reason		= 0;
2302 
2303 		/*
2304 		 * pkt_hba_private will point to sata pkt txlate structure
2305 		 */
2306 		spx = (sata_pkt_txlate_t *)pkt->pkt_ha_private;
2307 		bzero(spx, sizeof (sata_pkt_txlate_t));
2308 
2309 		spx->txlt_scsi_pkt = pkt;
2310 		spx->txlt_sata_hba_inst = sata_hba_inst;
2311 
2312 		/* Allocate sata_pkt */
2313 		spx->txlt_sata_pkt = sata_pkt_alloc(spx, callback);
2314 		if (spx->txlt_sata_pkt == NULL) {
2315 			/* Could not allocate sata pkt */
2316 			scsi_hba_pkt_free(ap, pkt);
2317 			return (NULL);
2318 		}
2319 		/* Set sata address */
2320 		spx->txlt_sata_pkt->satapkt_device.satadev_addr =
2321 		    sata_device.satadev_addr;
2322 		spx->txlt_sata_pkt->satapkt_device.satadev_rev =
2323 		    sata_device.satadev_rev;
2324 
2325 		if ((bp == NULL) || (bp->b_bcount == 0))
2326 			return (pkt);
2327 
2328 		spx->txlt_total_residue = bp->b_bcount;
2329 	} else {
2330 		new_pkt = B_FALSE;
2331 		/*
2332 		 * Packet was preallocated/initialized by previous call
2333 		 */
2334 		spx = (sata_pkt_txlate_t *)pkt->pkt_ha_private;
2335 
2336 		if ((bp == NULL) || (bp->b_bcount == 0)) {
2337 			return (pkt);
2338 		}
2339 
2340 		/* Pkt is available already: spx->txlt_scsi_pkt == pkt; */
2341 	}
2342 
2343 	spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp = bp;
2344 
2345 	/*
2346 	 * We use an adjusted version of the dma_attr, to account
2347 	 * for device addressing limitations.
2348 	 * sata_adjust_dma_attr() will handle sdinfo == NULL which may
2349 	 * happen when a device is not yet configured.
2350 	 */
2351 	mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst,
2352 	    sata_device.satadev_addr.cport)));
2353 	sdinfo = sata_get_device_info(spx->txlt_sata_hba_inst,
2354 	    &spx->txlt_sata_pkt->satapkt_device);
2355 	/* NULL sdinfo may be passsed to sata_adjust_dma_attr() */
2356 	sata_adjust_dma_attr(sdinfo,
2357 	    SATA_DMA_ATTR(spx->txlt_sata_hba_inst), &cur_dma_attr);
2358 	mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst,
2359 	    sata_device.satadev_addr.cport)));
2360 	/*
2361 	 * Allocate necessary DMA resources for the packet's data buffer
2362 	 * NOTE:
2363 	 * In case of read/write commands, DMA resource allocation here is
2364 	 * based on the premise that the transfer length specified in
2365 	 * the read/write scsi cdb will match exactly DMA resources -
2366 	 * returning correct packet residue is crucial.
2367 	 */
2368 	if ((rval = sata_dma_buf_setup(spx, flags, callback, arg,
2369 	    &cur_dma_attr)) != DDI_SUCCESS) {
2370 		/*
2371 		 * If a DMA allocation request fails with
2372 		 * DDI_DMA_NOMAPPING, indicate the error by calling
2373 		 * bioerror(9F) with bp and an error code of EFAULT.
2374 		 * If a DMA allocation request fails with
2375 		 * DDI_DMA_TOOBIG, indicate the error by calling
2376 		 * bioerror(9F) with bp and an error code of EINVAL.
2377 		 * For DDI_DMA_NORESOURCES, we may have some of them allocated.
2378 		 * Request may be repeated later - there is no real error.
2379 		 */
2380 		switch (rval) {
2381 		case DDI_DMA_NORESOURCES:
2382 			bioerror(bp, 0);
2383 			break;
2384 		case DDI_DMA_NOMAPPING:
2385 		case DDI_DMA_BADATTR:
2386 			bioerror(bp, EFAULT);
2387 			break;
2388 		case DDI_DMA_TOOBIG:
2389 		default:
2390 			bioerror(bp, EINVAL);
2391 			break;
2392 		}
2393 		goto fail;
2394 	}
2395 
2396 	if (sata_check_for_dma_error(dip, spx)) {
2397 		ddi_fm_service_impact(dip, DDI_SERVICE_UNAFFECTED);
2398 		bioerror(bp, EFAULT);
2399 		goto fail;
2400 	}
2401 
2402 	/* Set number of bytes that are not yet accounted for */
2403 	pkt->pkt_resid = spx->txlt_total_residue;
2404 	ASSERT(pkt->pkt_resid >= 0);
2405 
2406 	return (pkt);
2407 
2408 fail:
2409 	if (new_pkt == B_TRUE) {
2410 		/*
2411 		 * Since this is a new packet, we can clean-up
2412 		 * everything
2413 		 */
2414 		sata_scsi_destroy_pkt(ap, pkt);
2415 	} else {
2416 		/*
2417 		 * This is a re-used packet. It will be target driver's
2418 		 * responsibility to eventually destroy it (which
2419 		 * will free allocated resources).
2420 		 * Here, we just "complete" the request, leaving
2421 		 * allocated resources intact, so the request may
2422 		 * be retried.
2423 		 */
2424 		spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp = NULL;
2425 		sata_pkt_free(spx);
2426 	}
2427 	return (NULL);
2428 }
2429 
2430 /*
2431  * Implementation of scsi tran_start.
2432  * Translate scsi cmd into sata operation and return status.
2433  * ATAPI CDBs are passed to ATAPI devices - the device determines what commands
2434  * are supported.
2435  * For SATA hard disks, supported scsi commands:
2436  * SCMD_INQUIRY
2437  * SCMD_TEST_UNIT_READY
2438  * SCMD_START_STOP
2439  * SCMD_READ_CAPACITY
2440  * SCMD_SVC_ACTION_IN_G4 (READ CAPACITY (16))
2441  * SCMD_REQUEST_SENSE
2442  * SCMD_LOG_SENSE_G1
2443  * SCMD_LOG_SELECT_G1
2444  * SCMD_MODE_SENSE	(specific pages)
2445  * SCMD_MODE_SENSE_G1	(specific pages)
2446  * SCMD_MODE_SELECT	(specific pages)
2447  * SCMD_MODE_SELECT_G1	(specific pages)
2448  * SCMD_SYNCHRONIZE_CACHE
2449  * SCMD_SYNCHRONIZE_CACHE_G1
2450  * SCMD_READ
2451  * SCMD_READ_G1
2452  * SCMD_READ_G4
2453  * SCMD_READ_G5
2454  * SCMD_WRITE
2455  * SCMD_WRITE_BUFFER
2456  * SCMD_WRITE_G1
2457  * SCMD_WRITE_G4
2458  * SCMD_WRITE_G5
2459  * SCMD_SEEK		(noop)
2460  * SCMD_SDIAG
2461  *
2462  * All other commands are rejected as unsupported.
2463  *
2464  * Returns:
2465  * TRAN_ACCEPT if command was executed successfully or accepted by HBA driver
2466  * for execution. TRAN_ACCEPT may be returned also if device was removed but
2467  * a callback could be scheduled.
2468  * TRAN_BADPKT if cmd was directed to invalid address.
2469  * TRAN_FATAL_ERROR is command was rejected due to hardware error, including
2470  * some unspecified error. TRAN_FATAL_ERROR may be also returned if a device
2471  * was removed and there was no callback specified in scsi pkt.
2472  * TRAN_BUSY if command could not be executed becasue HBA driver or SATA
2473  * framework was busy performing some other operation(s).
2474  *
2475  */
2476 static int
2477 sata_scsi_start(struct scsi_address *ap, struct scsi_pkt *pkt)
2478 {
2479 	sata_hba_inst_t *sata_hba_inst =
2480 	    (sata_hba_inst_t *)(ap->a_hba_tran->tran_hba_private);
2481 	sata_pkt_txlate_t *spx = (sata_pkt_txlate_t *)pkt->pkt_ha_private;
2482 	sata_device_t *sdevice = &spx->txlt_sata_pkt->satapkt_device;
2483 	sata_drive_info_t *sdinfo = NULL;
2484 	struct buf *bp;
2485 	uint8_t cport, pmport;
2486 	boolean_t dev_gone = B_FALSE;
2487 	int rval;
2488 
2489 	SATADBG1(SATA_DBG_SCSI_IF, sata_hba_inst,
2490 	    "sata_scsi_start: cmd 0x%02x\n", pkt->pkt_cdbp[0]);
2491 
2492 	ASSERT(spx != NULL &&
2493 	    spx->txlt_scsi_pkt == pkt && spx->txlt_sata_pkt != NULL);
2494 
2495 	cport = SCSI_TO_SATA_CPORT(ap->a_target);
2496 	pmport = SCSI_TO_SATA_PMPORT(ap->a_target);
2497 
2498 	mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, cport)));
2499 
2500 	if (sdevice->satadev_addr.qual == SATA_ADDR_DCPORT) {
2501 		sdinfo = sata_get_device_info(sata_hba_inst, sdevice);
2502 		if (sdinfo == NULL ||
2503 		    SATA_CPORT_INFO(sata_hba_inst, cport)->
2504 		    cport_tgtnode_clean == B_FALSE ||
2505 		    (sdinfo->satadrv_state & SATA_DSTATE_FAILED) != 0) {
2506 			dev_gone = B_TRUE;
2507 		}
2508 	} else if (sdevice->satadev_addr.qual == SATA_ADDR_DPMPORT) {
2509 		if (SATA_CPORT_DEV_TYPE(sata_hba_inst, cport) !=
2510 		    SATA_DTYPE_PMULT || SATA_PMULT_INFO(sata_hba_inst,
2511 		    cport) == NULL) {
2512 			dev_gone = B_TRUE;
2513 		} else if (SATA_PMPORT_INFO(sata_hba_inst, cport,
2514 		    pmport) == NULL) {
2515 			dev_gone = B_TRUE;
2516 		} else {
2517 			mutex_enter(&(SATA_PMPORT_MUTEX(sata_hba_inst,
2518 			    cport, pmport)));
2519 			sdinfo = sata_get_device_info(sata_hba_inst, sdevice);
2520 			if (sdinfo == NULL ||
2521 			    SATA_PMPORT_INFO(sata_hba_inst, cport, pmport)->
2522 			    pmport_tgtnode_clean == B_FALSE ||
2523 			    (sdinfo->satadrv_state & SATA_DSTATE_FAILED) != 0) {
2524 				dev_gone = B_TRUE;
2525 			}
2526 			mutex_exit(&(SATA_PMPORT_MUTEX(sata_hba_inst,
2527 			    cport, pmport)));
2528 		}
2529 	}
2530 
2531 	if (dev_gone == B_TRUE) {
2532 		mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, cport)));
2533 		pkt->pkt_reason = CMD_DEV_GONE;
2534 		/*
2535 		 * The sd target driver is checking CMD_DEV_GONE pkt_reason
2536 		 * only in callback function (for normal requests) and
2537 		 * in the dump code path.
2538 		 * So, if the callback is available, we need to do
2539 		 * the callback rather than returning TRAN_FATAL_ERROR here.
2540 		 */
2541 		if (pkt->pkt_comp != NULL) {
2542 			/* scsi callback required */
2543 			if (servicing_interrupt()) {
2544 				if (taskq_dispatch(SATA_TXLT_TASKQ(spx),
2545 				    (task_func_t *)spx->txlt_scsi_pkt->pkt_comp,
2546 				    (void *)spx->txlt_scsi_pkt, TQ_NOSLEEP) ==
2547 				    TASKQID_INVALID) {
2548 					return (TRAN_BUSY);
2549 				}
2550 			} else if (taskq_dispatch(SATA_TXLT_TASKQ(spx),
2551 			    (task_func_t *)spx->txlt_scsi_pkt->pkt_comp,
2552 			    spx->txlt_scsi_pkt, TQ_SLEEP) == TASKQID_INVALID) {
2553 				/* Scheduling the callback failed */
2554 				return (TRAN_BUSY);
2555 			}
2556 			return (TRAN_ACCEPT);
2557 		}
2558 		/* No callback available */
2559 		return (TRAN_FATAL_ERROR);
2560 	}
2561 
2562 	if (sdinfo->satadrv_type & SATA_DTYPE_ATAPI) {
2563 		mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, cport)));
2564 		rval = sata_txlt_atapi(spx);
2565 		SATADBG1(SATA_DBG_SCSI_IF, sata_hba_inst,
2566 		    "sata_scsi_start atapi: rval %d\n", rval);
2567 		return (rval);
2568 	}
2569 	mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, cport)));
2570 
2571 	/*
2572 	 * Checking for power state, if it was on
2573 	 * STOPPED state, then the drive is not capable
2574 	 * of processing media access command.  And
2575 	 * TEST_UNIT_READY, REQUEST_SENSE has special handling
2576 	 * in the function for different power state.
2577 	 */
2578 	if (((sdinfo->satadrv_power_level == SATA_POWER_STANDBY) ||
2579 	    (sdinfo->satadrv_power_level == SATA_POWER_STOPPED)) &&
2580 	    (SATA_IS_MEDIUM_ACCESS_CMD(pkt->pkt_cdbp[0]))) {
2581 		return (sata_txlt_check_condition(spx, KEY_NOT_READY,
2582 		    SD_SCSI_ASC_LU_NOT_READY));
2583 	}
2584 
2585 	/* ATA Disk commands processing starts here */
2586 
2587 	bp = spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp;
2588 
2589 	switch (pkt->pkt_cdbp[0]) {
2590 
2591 	case SCMD_INQUIRY:
2592 		/* Mapped to identify device */
2593 		if (bp != NULL && (bp->b_flags & (B_PHYS | B_PAGEIO)))
2594 			bp_mapin(bp);
2595 		rval = sata_txlt_inquiry(spx);
2596 		break;
2597 
2598 	case SCMD_TEST_UNIT_READY:
2599 		/*
2600 		 * SAT "SATA to ATA Translation" doc specifies translation
2601 		 * to ATA CHECK POWER MODE.
2602 		 */
2603 		rval = sata_txlt_test_unit_ready(spx);
2604 		break;
2605 
2606 	case SCMD_START_STOP:
2607 		/* Mapping depends on the command */
2608 		rval = sata_txlt_start_stop_unit(spx);
2609 		break;
2610 
2611 	case SCMD_READ_CAPACITY:
2612 		if (bp != NULL && (bp->b_flags & (B_PHYS | B_PAGEIO)))
2613 			bp_mapin(bp);
2614 		rval = sata_txlt_read_capacity(spx);
2615 		break;
2616 
2617 	case SCMD_SVC_ACTION_IN_G4:		/* READ CAPACITY (16) */
2618 		if (bp != NULL && (bp->b_flags & (B_PHYS | B_PAGEIO)))
2619 			bp_mapin(bp);
2620 		rval = sata_txlt_read_capacity16(spx);
2621 		break;
2622 
2623 	case SCMD_REQUEST_SENSE:
2624 		/*
2625 		 * Always No Sense, since we force ARQ
2626 		 */
2627 		if (bp != NULL && (bp->b_flags & (B_PHYS | B_PAGEIO)))
2628 			bp_mapin(bp);
2629 		rval = sata_txlt_request_sense(spx);
2630 		break;
2631 
2632 	case SCMD_LOG_SENSE_G1:
2633 		if (bp != NULL && (bp->b_flags & (B_PHYS | B_PAGEIO)))
2634 			bp_mapin(bp);
2635 		rval = sata_txlt_log_sense(spx);
2636 		break;
2637 
2638 	case SCMD_LOG_SELECT_G1:
2639 		if (bp != NULL && (bp->b_flags & (B_PHYS | B_PAGEIO)))
2640 			bp_mapin(bp);
2641 		rval = sata_txlt_log_select(spx);
2642 		break;
2643 
2644 	case SCMD_MODE_SENSE:
2645 	case SCMD_MODE_SENSE_G1:
2646 		if (bp != NULL && (bp->b_flags & (B_PHYS | B_PAGEIO)))
2647 			bp_mapin(bp);
2648 		rval = sata_txlt_mode_sense(spx);
2649 		break;
2650 
2651 
2652 	case SCMD_MODE_SELECT:
2653 	case SCMD_MODE_SELECT_G1:
2654 		if (bp != NULL && (bp->b_flags & (B_PHYS | B_PAGEIO)))
2655 			bp_mapin(bp);
2656 		rval = sata_txlt_mode_select(spx);
2657 		break;
2658 
2659 	case SCMD_SYNCHRONIZE_CACHE:
2660 	case SCMD_SYNCHRONIZE_CACHE_G1:
2661 		rval = sata_txlt_synchronize_cache(spx);
2662 		break;
2663 
2664 	case SCMD_READ:
2665 	case SCMD_READ_G1:
2666 	case SCMD_READ_G4:
2667 	case SCMD_READ_G5:
2668 		rval = sata_txlt_read(spx);
2669 		break;
2670 	case SCMD_WRITE_BUFFER:
2671 		if (bp != NULL && (bp->b_flags & (B_PHYS | B_PAGEIO)))
2672 			bp_mapin(bp);
2673 		rval = sata_txlt_write_buffer(spx);
2674 		break;
2675 
2676 	case SCMD_WRITE:
2677 	case SCMD_WRITE_G1:
2678 	case SCMD_WRITE_G4:
2679 	case SCMD_WRITE_G5:
2680 		rval = sata_txlt_write(spx);
2681 		break;
2682 
2683 	case SCMD_SEEK:
2684 		rval = sata_txlt_nodata_cmd_immediate(spx);
2685 		break;
2686 
2687 	case SPC3_CMD_ATA_COMMAND_PASS_THROUGH12:
2688 	case SPC3_CMD_ATA_COMMAND_PASS_THROUGH16:
2689 		if (bp != NULL && (bp->b_flags & (B_PHYS | B_PAGEIO)))
2690 			bp_mapin(bp);
2691 		rval = sata_txlt_ata_pass_thru(spx);
2692 		break;
2693 
2694 		/* Other cases will be filed later */
2695 		/* postponed until phase 2 of the development */
2696 	case SPC3_CMD_UNMAP:
2697 		if (bp != NULL && (bp->b_flags & (B_PHYS | B_PAGEIO)))
2698 			bp_mapin(bp);
2699 		rval = sata_txlt_unmap(spx);
2700 		break;
2701 	default:
2702 		rval = sata_txlt_invalid_command(spx);
2703 		break;
2704 	}
2705 
2706 	SATADBG1(SATA_DBG_SCSI_IF, sata_hba_inst,
2707 	    "sata_scsi_start: rval %d\n", rval);
2708 
2709 	return (rval);
2710 }
2711 
2712 /*
2713  * Implementation of scsi tran_abort.
2714  * Abort specific pkt or all packets.
2715  *
2716  * Returns 1 if one or more packets were aborted, returns 0 otherwise
2717  *
2718  * May be called from an interrupt level.
2719  */
2720 static int
2721 sata_scsi_abort(struct scsi_address *ap, struct scsi_pkt *scsi_pkt)
2722 {
2723 	sata_hba_inst_t *sata_hba_inst =
2724 	    (sata_hba_inst_t *)(ap->a_hba_tran->tran_hba_private);
2725 	sata_device_t	sata_device;
2726 	sata_pkt_t	*sata_pkt;
2727 
2728 	SATADBG2(SATA_DBG_SCSI_IF, sata_hba_inst,
2729 	    "sata_scsi_abort: %s at target: 0x%x\n",
2730 	    scsi_pkt == NULL ? "all packets" : "one pkt", ap->a_target);
2731 
2732 	/* Validate address */
2733 	if (sata_validate_scsi_address(sata_hba_inst, ap, &sata_device) != 0)
2734 		/* Invalid address */
2735 		return (0);
2736 
2737 	mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst,
2738 	    sata_device.satadev_addr.cport)));
2739 	if (sata_get_device_info(sata_hba_inst, &sata_device) == NULL) {
2740 		/* invalid address */
2741 		mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst,
2742 		    sata_device.satadev_addr.cport)));
2743 		return (0);
2744 	}
2745 	if (scsi_pkt == NULL) {
2746 		/*
2747 		 * Abort all packets.
2748 		 * Although we do not have specific packet, we still need
2749 		 * dummy packet structure to pass device address to HBA.
2750 		 * Allocate one, without sleeping. Fail if pkt cannot be
2751 		 * allocated.
2752 		 */
2753 		sata_pkt = kmem_zalloc(sizeof (sata_pkt_t), KM_NOSLEEP);
2754 		if (sata_pkt == NULL) {
2755 			mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst,
2756 			    sata_device.satadev_addr.cport)));
2757 			SATA_LOG_D((sata_hba_inst, CE_WARN, "sata_pkt_abort: "
2758 			    "could not allocate sata_pkt"));
2759 			return (0);
2760 		}
2761 		sata_pkt->satapkt_rev = SATA_PKT_REV;
2762 		sata_pkt->satapkt_device = sata_device;
2763 		sata_pkt->satapkt_device.satadev_rev = SATA_DEVICE_REV;
2764 	} else {
2765 		if (scsi_pkt->pkt_ha_private == NULL) {
2766 			mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst,
2767 			    sata_device.satadev_addr.cport)));
2768 			return (0); /* Bad scsi pkt */
2769 		}
2770 		/* extract pointer to sata pkt */
2771 		sata_pkt = ((sata_pkt_txlate_t *)scsi_pkt->pkt_ha_private)->
2772 		    txlt_sata_pkt;
2773 	}
2774 
2775 	mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst,
2776 	    sata_device.satadev_addr.cport)));
2777 	/* Send abort request to HBA */
2778 	if ((*SATA_ABORT_FUNC(sata_hba_inst))
2779 	    (SATA_DIP(sata_hba_inst), sata_pkt,
2780 	    scsi_pkt == NULL ? SATA_ABORT_ALL_PACKETS : SATA_ABORT_PACKET) ==
2781 	    SATA_SUCCESS) {
2782 		if (scsi_pkt == NULL)
2783 			kmem_free(sata_pkt, sizeof (sata_pkt_t));
2784 		/* Success */
2785 		return (1);
2786 	}
2787 	/* Else, something did not go right */
2788 	if (scsi_pkt == NULL)
2789 		kmem_free(sata_pkt, sizeof (sata_pkt_t));
2790 	/* Failure */
2791 	return (0);
2792 }
2793 
2794 
2795 /*
2796  * Implementation of scsi tran_reset.
2797  * RESET_ALL request is translated into port reset.
2798  * RESET_TARGET requests is translated into a device reset,
2799  * RESET_LUN request is accepted only for LUN 0 and translated into
2800  * device reset.
2801  * The target reset should cause all HBA active and queued packets to
2802  * be terminated and returned with pkt reason SATA_PKT_RESET prior to
2803  * the return. HBA should report reset event for the device.
2804  *
2805  * Returns 1 upon success, 0 upon failure.
2806  */
2807 static int
2808 sata_scsi_reset(struct scsi_address *ap, int level)
2809 {
2810 	sata_hba_inst_t	*sata_hba_inst =
2811 	    (sata_hba_inst_t *)(ap->a_hba_tran->tran_hba_private);
2812 	sata_device_t	sata_device;
2813 	int		val;
2814 
2815 	SATADBG2(SATA_DBG_SCSI_IF, sata_hba_inst,
2816 	    "sata_scsi_reset: level %d target: 0x%x\n",
2817 	    level, ap->a_target);
2818 
2819 	/* Validate address */
2820 	val = sata_validate_scsi_address(sata_hba_inst, ap, &sata_device);
2821 	if (val == -1)
2822 		/* Invalid address */
2823 		return (0);
2824 
2825 	mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst,
2826 	    sata_device.satadev_addr.cport)));
2827 	if (sata_get_device_info(sata_hba_inst, &sata_device) == NULL) {
2828 		/* invalid address */
2829 		mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst,
2830 		    sata_device.satadev_addr.cport)));
2831 		return (0);
2832 	}
2833 	mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst,
2834 	    sata_device.satadev_addr.cport)));
2835 	if (level == RESET_ALL) {
2836 		/* port reset */
2837 		if (sata_device.satadev_addr.qual == SATA_ADDR_DCPORT)
2838 			sata_device.satadev_addr.qual = SATA_ADDR_CPORT;
2839 		else
2840 			sata_device.satadev_addr.qual = SATA_ADDR_PMPORT;
2841 
2842 		if ((*SATA_RESET_DPORT_FUNC(sata_hba_inst))
2843 		    (SATA_DIP(sata_hba_inst), &sata_device) == SATA_SUCCESS)
2844 			return (1);
2845 		else
2846 			return (0);
2847 
2848 	} else if (val == 0 &&
2849 	    (level == RESET_TARGET || level == RESET_LUN)) {
2850 		/* reset device (device attached) */
2851 		if ((*SATA_RESET_DPORT_FUNC(sata_hba_inst))
2852 		    (SATA_DIP(sata_hba_inst), &sata_device) == SATA_SUCCESS)
2853 			return (1);
2854 		else
2855 			return (0);
2856 	}
2857 	return (0);
2858 }
2859 
2860 
2861 /*
2862  * Implementation of scsi tran_getcap (get transport/device capabilities).
2863  * Supported capabilities for SATA hard disks:
2864  * auto-rqsense		(always supported)
2865  * tagged-qing		(supported if HBA supports it)
2866  * untagged-qing	(could be supported if disk supports it, but because
2867  *			 caching behavior allowing untagged queuing actually
2868  *			 results in reduced performance.  sd tries to throttle
2869  *			 back to only 3 outstanding commands, which may
2870  *			 work for real SCSI disks, but with read ahead
2871  *			 caching, having more than 1 outstanding command
2872  *			 results in cache thrashing.)
2873  * sector_size
2874  * dma_max
2875  * interconnect-type	(INTERCONNECT_SATA)
2876  *
2877  * Supported capabilities for ATAPI CD/DVD devices:
2878  * auto-rqsense		(always supported)
2879  * sector_size
2880  * dma_max
2881  * max-cdb-length
2882  * interconnect-type	(INTERCONNECT_SATA)
2883  *
2884  * Supported capabilities for ATAPI TAPE devices:
2885  * auto-rqsense		(always supported)
2886  * dma_max
2887  * max-cdb-length
2888  *
2889  * Supported capabilities for SATA ATAPI hard disks:
2890  * auto-rqsense		(always supported)
2891  * interconnect-type	(INTERCONNECT_SATA)
2892  * max-cdb-length
2893  *
2894  * Request for other capabilities is rejected as unsupported.
2895  *
2896  * Returns supported capability value, or -1 if capability is unsuppported or
2897  * the address is invalid - no device.
2898  */
2899 
2900 static int
2901 sata_scsi_getcap(struct scsi_address *ap, char *cap, int whom)
2902 {
2903 
2904 	sata_hba_inst_t		*sata_hba_inst =
2905 	    (sata_hba_inst_t *)(ap->a_hba_tran->tran_hba_private);
2906 	sata_device_t		sata_device;
2907 	sata_drive_info_t	*sdinfo;
2908 	ddi_dma_attr_t		adj_dma_attr;
2909 	int			rval;
2910 
2911 	SATADBG2(SATA_DBG_SCSI_IF, sata_hba_inst,
2912 	    "sata_scsi_getcap: target: 0x%x, cap: %s\n",
2913 	    ap->a_target, cap);
2914 
2915 	/*
2916 	 * We want to process the capabilities on per port granularity.
2917 	 * So, we are specifically restricting ourselves to whom != 0
2918 	 * to exclude the controller wide handling.
2919 	 */
2920 	if (cap == NULL || whom == 0)
2921 		return (-1);
2922 
2923 	if (sata_validate_scsi_address(sata_hba_inst, ap, &sata_device) != 0) {
2924 		/* Invalid address */
2925 		return (-1);
2926 	}
2927 	mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst,
2928 	    sata_device.satadev_addr.cport)));
2929 	if ((sdinfo = sata_get_device_info(sata_hba_inst, &sata_device)) ==
2930 	    NULL) {
2931 		/* invalid address */
2932 		mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst,
2933 		    sata_device.satadev_addr.cport)));
2934 		return (-1);
2935 	}
2936 
2937 	switch (scsi_hba_lookup_capstr(cap)) {
2938 	case SCSI_CAP_ARQ:
2939 		rval = 1;		/* ARQ supported, turned on */
2940 		break;
2941 
2942 	case SCSI_CAP_SECTOR_SIZE:
2943 		if (sdinfo->satadrv_type == SATA_DTYPE_ATADISK)
2944 			rval = SATA_DISK_SECTOR_SIZE;	/* fixed size */
2945 		else if (sdinfo->satadrv_type == SATA_DTYPE_ATAPICD)
2946 			rval = SATA_ATAPI_SECTOR_SIZE;
2947 		else rval = -1;
2948 		break;
2949 
2950 	/*
2951 	 * untagged queuing cause a performance inversion because of
2952 	 * the way sd operates.  Because of this reason we do not
2953 	 * use it when available.
2954 	 */
2955 	case SCSI_CAP_UNTAGGED_QING:
2956 		if (sdinfo->satadrv_features_enabled &
2957 		    SATA_DEV_F_E_UNTAGGED_QING)
2958 			rval = 1;	/* Untagged queuing available */
2959 		else
2960 			rval = -1;	/* Untagged queuing not available */
2961 		break;
2962 
2963 	case SCSI_CAP_TAGGED_QING:
2964 		if ((sdinfo->satadrv_features_enabled &
2965 		    SATA_DEV_F_E_TAGGED_QING) &&
2966 		    (sdinfo->satadrv_max_queue_depth > 1))
2967 			rval = 1;	/* Tagged queuing available */
2968 		else
2969 			rval = -1;	/* Tagged queuing not available */
2970 		break;
2971 
2972 	case SCSI_CAP_DMA_MAX:
2973 		sata_adjust_dma_attr(sdinfo, SATA_DMA_ATTR(sata_hba_inst),
2974 		    &adj_dma_attr);
2975 		rval = (int)adj_dma_attr.dma_attr_maxxfer;
2976 		/* We rely on the fact that dma_attr_maxxfer < 0x80000000 */
2977 		break;
2978 
2979 	case SCSI_CAP_INTERCONNECT_TYPE:
2980 		rval = INTERCONNECT_SATA;	/* SATA interconnect type */
2981 		break;
2982 
2983 	case SCSI_CAP_CDB_LEN:
2984 		if (sdinfo->satadrv_type & SATA_DTYPE_ATAPI)
2985 			rval = sdinfo->satadrv_atapi_cdb_len;
2986 		else
2987 			rval = -1;
2988 		break;
2989 
2990 	default:
2991 		rval = -1;
2992 		break;
2993 	}
2994 	mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst,
2995 	    sata_device.satadev_addr.cport)));
2996 	return (rval);
2997 }
2998 
2999 /*
3000  * Implementation of scsi tran_setcap
3001  *
3002  * Only SCSI_CAP_UNTAGGED_QING and  SCSI_CAP_TAGGED_QING are changeable.
3003  *
3004  */
3005 static int
3006 sata_scsi_setcap(struct scsi_address *ap, char *cap, int value, int whom)
3007 {
3008 	sata_hba_inst_t	*sata_hba_inst =
3009 	    (sata_hba_inst_t *)(ap->a_hba_tran->tran_hba_private);
3010 	sata_device_t	sata_device;
3011 	sata_drive_info_t	*sdinfo;
3012 	int		rval;
3013 
3014 	SATADBG2(SATA_DBG_SCSI_IF, sata_hba_inst,
3015 	    "sata_scsi_setcap: target: 0x%x, cap: %s\n", ap->a_target, cap);
3016 
3017 	/*
3018 	 * We want to process the capabilities on per port granularity.
3019 	 * So, we are specifically restricting ourselves to whom != 0
3020 	 * to exclude the controller wide handling.
3021 	 */
3022 	if (cap == NULL || whom == 0) {
3023 		return (-1);
3024 	}
3025 
3026 	if (sata_validate_scsi_address(sata_hba_inst, ap, &sata_device) != 0) {
3027 		/* Invalid address */
3028 		return (-1);
3029 	}
3030 	mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst,
3031 	    sata_device.satadev_addr.cport)));
3032 	if ((sdinfo = sata_get_device_info(sata_hba_inst,
3033 	    &sata_device)) == NULL) {
3034 		/* invalid address */
3035 		mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst,
3036 		    sata_device.satadev_addr.cport)));
3037 		return (-1);
3038 	}
3039 	mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst,
3040 	    sata_device.satadev_addr.cport)));
3041 
3042 	switch (scsi_hba_lookup_capstr(cap)) {
3043 	case SCSI_CAP_ARQ:
3044 	case SCSI_CAP_SECTOR_SIZE:
3045 	case SCSI_CAP_DMA_MAX:
3046 	case SCSI_CAP_INTERCONNECT_TYPE:
3047 		rval = 0;
3048 		break;
3049 	case SCSI_CAP_UNTAGGED_QING:
3050 		if (SATA_QDEPTH(sata_hba_inst) > 1) {
3051 			rval = 1;
3052 			if (value == 1) {
3053 				sdinfo->satadrv_features_enabled |=
3054 				    SATA_DEV_F_E_UNTAGGED_QING;
3055 			} else if (value == 0) {
3056 				sdinfo->satadrv_features_enabled &=
3057 				    ~SATA_DEV_F_E_UNTAGGED_QING;
3058 			} else {
3059 				rval = -1;
3060 			}
3061 		} else {
3062 			rval = 0;
3063 		}
3064 		break;
3065 	case SCSI_CAP_TAGGED_QING:
3066 		/* This can TCQ or NCQ */
3067 		if (sata_func_enable & SATA_ENABLE_QUEUING &&
3068 		    ((sdinfo->satadrv_features_support & SATA_DEV_F_TCQ &&
3069 		    SATA_FEATURES(sata_hba_inst) & SATA_CTLF_QCMD) ||
3070 		    (sata_func_enable & SATA_ENABLE_NCQ &&
3071 		    sdinfo->satadrv_features_support & SATA_DEV_F_NCQ &&
3072 		    SATA_FEATURES(sata_hba_inst) & SATA_CTLF_NCQ)) &&
3073 		    (sdinfo->satadrv_max_queue_depth > 1)) {
3074 			rval = 1;
3075 			if (value == 1) {
3076 				sdinfo->satadrv_features_enabled |=
3077 				    SATA_DEV_F_E_TAGGED_QING;
3078 			} else if (value == 0) {
3079 				sdinfo->satadrv_features_enabled &=
3080 				    ~SATA_DEV_F_E_TAGGED_QING;
3081 			} else {
3082 				rval = -1;
3083 			}
3084 		} else {
3085 			rval = 0;
3086 		}
3087 		break;
3088 	default:
3089 		rval = -1;
3090 		break;
3091 	}
3092 	return (rval);
3093 }
3094 
3095 /*
3096  * Implementations of scsi tran_destroy_pkt.
3097  * Free resources allocated by sata_scsi_init_pkt()
3098  */
3099 static void
3100 sata_scsi_destroy_pkt(struct scsi_address *ap, struct scsi_pkt *pkt)
3101 {
3102 	sata_pkt_txlate_t *spx;
3103 
3104 	spx = (sata_pkt_txlate_t *)pkt->pkt_ha_private;
3105 
3106 	sata_common_free_dma_rsrcs(spx);
3107 
3108 	spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp = NULL;
3109 	sata_pkt_free(spx);
3110 
3111 	scsi_hba_pkt_free(ap, pkt);
3112 }
3113 
3114 /*
3115  * Implementation of scsi tran_dmafree.
3116  * Free DMA resources allocated by sata_scsi_init_pkt()
3117  */
3118 
3119 static void
3120 sata_scsi_dmafree(struct scsi_address *ap, struct scsi_pkt *pkt)
3121 {
3122 #ifndef __lock_lint
3123 	_NOTE(ARGUNUSED(ap))
3124 #endif
3125 	sata_pkt_txlate_t *spx;
3126 
3127 	ASSERT(pkt != NULL);
3128 	spx = (sata_pkt_txlate_t *)pkt->pkt_ha_private;
3129 
3130 	sata_common_free_dma_rsrcs(spx);
3131 }
3132 
3133 /*
3134  * Implementation of scsi tran_sync_pkt.
3135  *
3136  * The assumption below is that pkt is unique - there is no need to check ap
3137  *
3138  * Synchronize DMA buffer and, if the intermediate buffer is used, copy data
3139  * into/from the real buffer.
3140  */
3141 static void
3142 sata_scsi_sync_pkt(struct scsi_address *ap __unused, struct scsi_pkt *pkt)
3143 {
3144 	sata_pkt_txlate_t *spx = (sata_pkt_txlate_t *)pkt->pkt_ha_private;
3145 	struct buf *bp;
3146 	int direction;
3147 	int rval;
3148 
3149 	ASSERT(spx != NULL);
3150 	if (spx->txlt_buf_dma_handle == NULL)
3151 		return;
3152 
3153 	if (spx->txlt_sata_pkt == NULL)
3154 		return;
3155 
3156 	direction = spx->txlt_sata_pkt->
3157 	    satapkt_cmd.satacmd_flags.sata_data_direction;
3158 
3159 	if (direction == SATA_DIR_NODATA_XFER)
3160 		return;
3161 
3162 	bp = spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp;
3163 
3164 	if (spx->txlt_tmp_buf != NULL && (direction & SATA_DIR_WRITE) != 0) {
3165 		/* Intermediate DMA buffer used */
3166 		bcopy(bp->b_un.b_addr, spx->txlt_tmp_buf, bp->b_bcount);
3167 	}
3168 
3169 	/* Sync the buffer for device or for CPU */
3170 	rval = ddi_dma_sync(spx->txlt_buf_dma_handle, 0, 0,
3171 	    (direction & SATA_DIR_WRITE) ?
3172 	    DDI_DMA_SYNC_FORDEV : DDI_DMA_SYNC_FORCPU);
3173 	ASSERT3S(rval, ==, DDI_SUCCESS);
3174 
3175 	if (spx->txlt_tmp_buf != NULL && !(direction & SATA_DIR_WRITE)) {
3176 		/* Intermediate DMA buffer used for read */
3177 		bcopy(spx->txlt_tmp_buf, bp->b_un.b_addr, bp->b_bcount);
3178 	}
3179 }
3180 
3181 
3182 
3183 /* *******************  SATA - SCSI Translation functions **************** */
3184 /*
3185  * SCSI to SATA pkt and command translation and SATA to SCSI status/error
3186  * translation.
3187  */
3188 
3189 /*
3190  * Checks if a device exists and can be access and translates common
3191  * scsi_pkt data to sata_pkt data.
3192  *
3193  * Flag argument indicates that a non-read/write ATA command may be sent
3194  * to HBA in arbitrary SYNC mode to execute this packet.
3195  *
3196  * Returns TRAN_ACCEPT and scsi pkt_reason CMD_CMPLT if device exists and
3197  * sata_pkt was set-up.
3198  * Returns TRAN_ACCEPT and scsi pkt_reason CMD_DEV_GONE if device does not
3199  * exist and pkt_comp callback was scheduled.
3200  * Returns other TRAN_XXXXX values when error occured and command should be
3201  * rejected with the returned TRAN_XXXXX value.
3202  *
3203  * This function should be called with port mutex held.
3204  */
3205 static int
3206 sata_txlt_generic_pkt_info(sata_pkt_txlate_t *spx, int *reason, int flag)
3207 {
3208 	sata_drive_info_t *sdinfo;
3209 	sata_device_t sata_device;
3210 	const struct sata_cmd_flags sata_initial_cmd_flags = {
3211 		SATA_DIR_NODATA_XFER,
3212 		/* all other values to 0/FALSE */
3213 	};
3214 	/*
3215 	 * Pkt_reason has to be set if the pkt_comp callback is invoked,
3216 	 * and that implies TRAN_ACCEPT return value. Any other returned value
3217 	 * indicates that the scsi packet was not accepted (the reason will not
3218 	 * be checked by the scsi target driver).
3219 	 * To make debugging easier, we set pkt_reason to know value here.
3220 	 * It may be changed later when different completion reason is
3221 	 * determined.
3222 	 */
3223 	spx->txlt_scsi_pkt->pkt_reason = CMD_TRAN_ERR;
3224 	*reason = CMD_TRAN_ERR;
3225 
3226 	/* Validate address */
3227 	switch (sata_validate_scsi_address(spx->txlt_sata_hba_inst,
3228 	    &spx->txlt_scsi_pkt->pkt_address, &sata_device)) {
3229 
3230 	case -1:
3231 		/* Invalid address or invalid device type */
3232 		return (TRAN_BADPKT);
3233 	case 2:
3234 		/*
3235 		 * Valid address but device type is unknown - Chack if it is
3236 		 * in the reset state and therefore in an indeterminate state.
3237 		 */
3238 		sdinfo = sata_get_device_info(spx->txlt_sata_hba_inst,
3239 		    &spx->txlt_sata_pkt->satapkt_device);
3240 		if (sdinfo != NULL && (sdinfo->satadrv_event_flags &
3241 		    (SATA_EVNT_DEVICE_RESET |
3242 		    SATA_EVNT_INPROC_DEVICE_RESET)) != 0) {
3243 			if (!ddi_in_panic()) {
3244 				spx->txlt_scsi_pkt->pkt_reason = CMD_INCOMPLETE;
3245 				*reason = CMD_INCOMPLETE;
3246 				SATADBG1(SATA_DBG_SCSI_IF,
3247 				    spx->txlt_sata_hba_inst,
3248 				    "sata_scsi_start: rejecting command "
3249 				    "because of device reset state\n", NULL);
3250 				return (TRAN_BUSY);
3251 			}
3252 		}
3253 		/* FALLTHROUGH */
3254 	case 1:
3255 		/* valid address but no valid device - it has disappeared */
3256 		spx->txlt_scsi_pkt->pkt_reason = CMD_DEV_GONE;
3257 		*reason = CMD_DEV_GONE;
3258 		/*
3259 		 * The sd target driver is checking CMD_DEV_GONE pkt_reason
3260 		 * only in callback function (for normal requests) and
3261 		 * in the dump code path.
3262 		 * So, if the callback is available, we need to do
3263 		 * the callback rather than returning TRAN_FATAL_ERROR here.
3264 		 */
3265 		if (spx->txlt_scsi_pkt->pkt_comp != NULL) {
3266 			/* scsi callback required */
3267 			if (servicing_interrupt()) {
3268 				if (taskq_dispatch(SATA_TXLT_TASKQ(spx),
3269 				    (task_func_t *)spx->txlt_scsi_pkt->pkt_comp,
3270 				    (void *)spx->txlt_scsi_pkt, TQ_NOSLEEP) ==
3271 				    TASKQID_INVALID) {
3272 					return (TRAN_BUSY);
3273 				}
3274 			} else if (taskq_dispatch(SATA_TXLT_TASKQ(spx),
3275 			    (task_func_t *)spx->txlt_scsi_pkt->pkt_comp,
3276 			    spx->txlt_scsi_pkt, TQ_SLEEP) == TASKQID_INVALID) {
3277 				/* Scheduling the callback failed */
3278 				return (TRAN_BUSY);
3279 			}
3280 
3281 			return (TRAN_ACCEPT);
3282 		}
3283 		return (TRAN_FATAL_ERROR);
3284 	default:
3285 		/* all OK; pkt reason will be overwritten later */
3286 		break;
3287 	}
3288 	/*
3289 	 * If pkt is to be executed in polling mode and a command will not be
3290 	 * emulated in SATA module (requires sending a non-read/write ATA
3291 	 * command to HBA driver in arbitrary SYNC mode) and we are in the
3292 	 * interrupt context and not in the panic dump, then reject the packet
3293 	 * to avoid a possible interrupt stack overrun or hang caused by
3294 	 * a potentially blocked interrupt.
3295 	 */
3296 	if (((spx->txlt_scsi_pkt->pkt_flags & FLAG_NOINTR) != 0 || flag != 0) &&
3297 	    servicing_interrupt() && !ddi_in_panic()) {
3298 		SATADBG1(SATA_DBG_INTR_CTX, spx->txlt_sata_hba_inst,
3299 		    "sata_scsi_start: rejecting synchronous command because "
3300 		    "of interrupt context\n", NULL);
3301 		return (TRAN_BUSY);
3302 	}
3303 
3304 	sdinfo = sata_get_device_info(spx->txlt_sata_hba_inst,
3305 	    &spx->txlt_sata_pkt->satapkt_device);
3306 
3307 	/*
3308 	 * If device is in reset condition, reject the packet with
3309 	 * TRAN_BUSY, unless:
3310 	 * 1. system is panicking (dumping)
3311 	 * In such case only one thread is running and there is no way to
3312 	 * process reset.
3313 	 * 2. cfgadm operation is is progress (internal APCTL lock is set)
3314 	 * Some cfgadm operations involve drive commands, so reset condition
3315 	 * needs to be ignored for IOCTL operations.
3316 	 */
3317 	if ((sdinfo->satadrv_event_flags &
3318 	    (SATA_EVNT_DEVICE_RESET | SATA_EVNT_INPROC_DEVICE_RESET)) != 0) {
3319 
3320 		if (!ddi_in_panic() &&
3321 		    ((SATA_CPORT_EVENT_FLAGS(spx->txlt_sata_hba_inst,
3322 		    sata_device.satadev_addr.cport) &
3323 		    SATA_APCTL_LOCK_PORT_BUSY) == 0)) {
3324 			spx->txlt_scsi_pkt->pkt_reason = CMD_INCOMPLETE;
3325 			*reason = CMD_INCOMPLETE;
3326 			SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst,
3327 			    "sata_scsi_start: rejecting command because "
3328 			    "of device reset state\n", NULL);
3329 			return (TRAN_BUSY);
3330 		}
3331 	}
3332 
3333 	/*
3334 	 * Fix the dev_type in the sata_pkt->satapkt_device. It was not set by
3335 	 * sata_scsi_pkt_init() because pkt init had to work also with
3336 	 * non-existing devices.
3337 	 * Now we know that the packet was set-up for a real device, so its
3338 	 * type is known.
3339 	 */
3340 	spx->txlt_sata_pkt->satapkt_device.satadev_type = sdinfo->satadrv_type;
3341 
3342 	spx->txlt_sata_pkt->satapkt_cmd.satacmd_flags = sata_initial_cmd_flags;
3343 	if ((SATA_CPORT_INFO(spx->txlt_sata_hba_inst,
3344 	    sata_device.satadev_addr.cport)->cport_event_flags &
3345 	    SATA_APCTL_LOCK_PORT_BUSY) != 0) {
3346 		spx->txlt_sata_pkt->satapkt_cmd.satacmd_flags.
3347 		    sata_ignore_dev_reset = B_TRUE;
3348 	}
3349 	/*
3350 	 * At this point the generic translation routine determined that the
3351 	 * scsi packet should be accepted. Packet completion reason may be
3352 	 * changed later when a different completion reason is determined.
3353 	 */
3354 	spx->txlt_scsi_pkt->pkt_reason = CMD_CMPLT;
3355 	*reason = CMD_CMPLT;
3356 
3357 	if ((spx->txlt_scsi_pkt->pkt_flags & FLAG_NOINTR) != 0) {
3358 		/* Synchronous execution */
3359 		spx->txlt_sata_pkt->satapkt_op_mode = SATA_OPMODE_SYNCH |
3360 		    SATA_OPMODE_POLLING;
3361 		spx->txlt_sata_pkt->satapkt_cmd.satacmd_flags.
3362 		    sata_ignore_dev_reset = ddi_in_panic();
3363 	} else {
3364 		/* Asynchronous execution */
3365 		spx->txlt_sata_pkt->satapkt_op_mode = SATA_OPMODE_ASYNCH |
3366 		    SATA_OPMODE_INTERRUPTS;
3367 	}
3368 	/* Convert queuing information */
3369 	if (spx->txlt_scsi_pkt->pkt_flags & FLAG_STAG)
3370 		spx->txlt_sata_pkt->satapkt_cmd.satacmd_flags.sata_queue_stag =
3371 		    B_TRUE;
3372 	else if (spx->txlt_scsi_pkt->pkt_flags &
3373 	    (FLAG_OTAG | FLAG_HTAG | FLAG_HEAD))
3374 		spx->txlt_sata_pkt->satapkt_cmd.satacmd_flags.sata_queue_otag =
3375 		    B_TRUE;
3376 
3377 	/* Always limit pkt time */
3378 	if (spx->txlt_scsi_pkt->pkt_time == 0)
3379 		spx->txlt_sata_pkt->satapkt_time = sata_default_pkt_time;
3380 	else
3381 		/* Pass on scsi_pkt time */
3382 		spx->txlt_sata_pkt->satapkt_time =
3383 		    spx->txlt_scsi_pkt->pkt_time;
3384 
3385 	return (TRAN_ACCEPT);
3386 }
3387 
3388 
3389 /*
3390  * Translate ATA Identify Device data to SCSI Inquiry data.
3391  * This function may be called only for ATA devices.
3392  * This function should not be called for ATAPI devices - they
3393  * respond directly to SCSI Inquiry command.
3394  *
3395  * SATA Identify Device data has to be valid in sata_drive_info.
3396  * Buffer has to accomodate the inquiry length (36 bytes).
3397  *
3398  * This function should be called with a port mutex held.
3399  */
3400 static	void
3401 sata_identdev_to_inquiry(sata_hba_inst_t *sata_hba_inst,
3402     sata_drive_info_t *sdinfo, uint8_t *buf)
3403 {
3404 
3405 	struct scsi_inquiry *inq = (struct scsi_inquiry *)buf;
3406 	struct sata_id *sid = &sdinfo->satadrv_id;
3407 
3408 	/* Start with a nice clean slate */
3409 	bzero((void *)inq, sizeof (struct scsi_inquiry));
3410 
3411 	/*
3412 	 * Rely on the dev_type for setting paripheral qualifier.
3413 	 * Assume that  DTYPE_RODIRECT applies to CD/DVD R/W devices.
3414 	 * It could be that DTYPE_OPTICAL could also qualify in the future.
3415 	 * ATAPI Inquiry may provide more data to the target driver.
3416 	 */
3417 	inq->inq_dtype = sdinfo->satadrv_type == SATA_DTYPE_ATADISK ?
3418 	    DTYPE_DIRECT : DTYPE_RODIRECT; /* DTYPE_UNKNOWN; */
3419 
3420 	/* CFA type device is not a removable media device */
3421 	inq->inq_rmb = ((sid->ai_config != SATA_CFA_TYPE) &&
3422 	    (sid->ai_config & SATA_REM_MEDIA)) ? 1 : 0;
3423 	inq->inq_qual = 0;	/* Device type qualifier (obsolete in SCSI3? */
3424 	inq->inq_iso = 0;	/* ISO version */
3425 	inq->inq_ecma = 0;	/* ECMA version */
3426 	inq->inq_ansi = 3;	/* ANSI version - SCSI 3 */
3427 	inq->inq_aenc = 0;	/* Async event notification cap. */
3428 	inq->inq_trmiop = 0;	/* Supports TERMINATE I/O PROC msg - NO */
3429 	inq->inq_normaca = 0;	/* setting NACA bit supported - NO */
3430 	inq->inq_rdf = RDF_SCSI2; /* Response data format- SPC-3 */
3431 	inq->inq_len = 31;	/* Additional length */
3432 	inq->inq_dualp = 0;	/* dual port device - NO */
3433 	inq->inq_reladdr = 0;	/* Supports relative addressing - NO */
3434 	inq->inq_sync = 0;	/* Supports synchronous data xfers - NO */
3435 	inq->inq_linked = 0;	/* Supports linked commands - NO */
3436 				/*
3437 				 * Queuing support - controller has to
3438 				 * support some sort of command queuing.
3439 				 */
3440 	if (SATA_QDEPTH(sata_hba_inst) > 1)
3441 		inq->inq_cmdque = 1; /* Supports command queueing - YES */
3442 	else
3443 		inq->inq_cmdque = 0; /* Supports command queueing - NO */
3444 	inq->inq_sftre = 0;	/* Supports Soft Reset option - NO ??? */
3445 	inq->inq_wbus32 = 0;	/* Supports 32 bit wide data xfers - NO */
3446 	inq->inq_wbus16 = 0;	/* Supports 16 bit wide data xfers - NO */
3447 
3448 #ifdef	_LITTLE_ENDIAN
3449 	/* Swap text fields to match SCSI format */
3450 	bcopy("ATA     ", inq->inq_vid, 8);		/* Vendor ID */
3451 	swab(sid->ai_model, inq->inq_pid, 16);		/* Product ID */
3452 	if (strncmp(&sid->ai_fw[4], "    ", 4) == 0)
3453 		swab(sid->ai_fw, inq->inq_revision, 4);	/* Revision level */
3454 	else
3455 		swab(&sid->ai_fw[4], inq->inq_revision, 4);	/* Rev. level */
3456 #else	/* _LITTLE_ENDIAN */
3457 	bcopy("ATA     ", inq->inq_vid, 8);		/* Vendor ID */
3458 	bcopy(sid->ai_model, inq->inq_pid, 16);		/* Product ID */
3459 	if (strncmp(&sid->ai_fw[4], "    ", 4) == 0)
3460 		bcopy(sid->ai_fw, inq->inq_revision, 4); /* Revision level */
3461 	else
3462 		bcopy(&sid->ai_fw[4], inq->inq_revision, 4); /* Rev. level */
3463 #endif	/* _LITTLE_ENDIAN */
3464 }
3465 
3466 
3467 /*
3468  * Scsi response set up for invalid command (command not supported)
3469  *
3470  * Returns TRAN_ACCEPT and appropriate values in scsi_pkt fields.
3471  */
3472 static int
3473 sata_txlt_invalid_command(sata_pkt_txlate_t *spx)
3474 {
3475 	struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt;
3476 	struct scsi_extended_sense *sense;
3477 
3478 	scsipkt->pkt_reason = CMD_CMPLT;
3479 	scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET |
3480 	    STATE_SENT_CMD | STATE_GOT_STATUS;
3481 
3482 	*scsipkt->pkt_scbp = STATUS_CHECK;
3483 
3484 	sense = sata_arq_sense(spx);
3485 	sense->es_key = KEY_ILLEGAL_REQUEST;
3486 	sense->es_add_code = SD_SCSI_ASC_INVALID_COMMAND_CODE;
3487 
3488 	SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst,
3489 	    "Scsi_pkt completion reason %x\n", scsipkt->pkt_reason);
3490 
3491 	if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0 &&
3492 	    scsipkt->pkt_comp != NULL) {
3493 		/* scsi callback required */
3494 		if (servicing_interrupt()) {
3495 			if (taskq_dispatch(SATA_TXLT_TASKQ(spx),
3496 			    (task_func_t *)spx->txlt_scsi_pkt->pkt_comp,
3497 			    (void *)spx->txlt_scsi_pkt, TQ_NOSLEEP) ==
3498 			    TASKQID_INVALID) {
3499 				return (TRAN_BUSY);
3500 			}
3501 		} else if (taskq_dispatch(SATA_TXLT_TASKQ(spx),
3502 		    (task_func_t *)spx->txlt_scsi_pkt->pkt_comp,
3503 		    (void *)spx->txlt_scsi_pkt, TQ_SLEEP) == TASKQID_INVALID) {
3504 			/* Scheduling the callback failed */
3505 			return (TRAN_BUSY);
3506 		}
3507 	}
3508 	return (TRAN_ACCEPT);
3509 }
3510 
3511 /*
3512  * Scsi response set up for check condition with special sense key
3513  * and additional sense code.
3514  *
3515  * Returns TRAN_ACCEPT and appropriate values in scsi_pkt fields.
3516  */
3517 static int
3518 sata_txlt_check_condition(sata_pkt_txlate_t *spx, uchar_t key, uchar_t code)
3519 {
3520 	sata_hba_inst_t *shi = SATA_TXLT_HBA_INST(spx);
3521 	int cport = SATA_TXLT_CPORT(spx);
3522 	struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt;
3523 	struct scsi_extended_sense *sense;
3524 
3525 	mutex_enter(&SATA_CPORT_MUTEX(shi, cport));
3526 	scsipkt->pkt_reason = CMD_CMPLT;
3527 	scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET |
3528 	    STATE_SENT_CMD | STATE_GOT_STATUS;
3529 
3530 	*scsipkt->pkt_scbp = STATUS_CHECK;
3531 
3532 	sense = sata_arq_sense(spx);
3533 	sense->es_key = key;
3534 	sense->es_add_code = code;
3535 
3536 	mutex_exit(&SATA_CPORT_MUTEX(shi, cport));
3537 
3538 	SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst,
3539 	    "Scsi_pkt completion reason %x\n", scsipkt->pkt_reason);
3540 
3541 	if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0 &&
3542 	    scsipkt->pkt_comp != NULL) {
3543 		/* scsi callback required */
3544 		if (servicing_interrupt()) {
3545 			if (taskq_dispatch(SATA_TXLT_TASKQ(spx),
3546 			    (task_func_t *)spx->txlt_scsi_pkt->pkt_comp,
3547 			    (void *)spx->txlt_scsi_pkt, TQ_NOSLEEP) ==
3548 			    TASKQID_INVALID) {
3549 				return (TRAN_BUSY);
3550 			}
3551 		} else if (taskq_dispatch(SATA_TXLT_TASKQ(spx),
3552 		    (task_func_t *)spx->txlt_scsi_pkt->pkt_comp,
3553 		    (void *)spx->txlt_scsi_pkt, TQ_SLEEP) == TASKQID_INVALID) {
3554 			/* Scheduling the callback failed */
3555 			return (TRAN_BUSY);
3556 		}
3557 	}
3558 	return (TRAN_ACCEPT);
3559 }
3560 
3561 /*
3562  * Scsi response setup for
3563  * emulated non-data command that requires no action/return data
3564  *
3565  * Returns TRAN_ACCEPT and appropriate values in scsi_pkt fields.
3566  */
3567 static	int
3568 sata_txlt_nodata_cmd_immediate(sata_pkt_txlate_t *spx)
3569 {
3570 	int rval;
3571 	int reason;
3572 	kmutex_t *cport_mutex =  &(SATA_TXLT_CPORT_MUTEX(spx));
3573 
3574 	mutex_enter(cport_mutex);
3575 
3576 	if (((rval = sata_txlt_generic_pkt_info(spx, &reason, 0)) !=
3577 	    TRAN_ACCEPT) || (reason == CMD_DEV_GONE)) {
3578 		mutex_exit(cport_mutex);
3579 		return (rval);
3580 	}
3581 	mutex_exit(cport_mutex);
3582 
3583 	spx->txlt_scsi_pkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET |
3584 	    STATE_SENT_CMD | STATE_GOT_STATUS;
3585 	spx->txlt_scsi_pkt->pkt_reason = CMD_CMPLT;
3586 	*(spx->txlt_scsi_pkt->pkt_scbp) = STATUS_GOOD;
3587 
3588 	SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst,
3589 	    "Scsi_pkt completion reason %x\n",
3590 	    spx->txlt_scsi_pkt->pkt_reason);
3591 
3592 	if ((spx->txlt_scsi_pkt->pkt_flags & FLAG_NOINTR) == 0 &&
3593 	    spx->txlt_scsi_pkt->pkt_comp != NULL) {
3594 		/* scsi callback required */
3595 		if (servicing_interrupt()) {
3596 			if (taskq_dispatch(SATA_TXLT_TASKQ(spx),
3597 			    (task_func_t *)spx->txlt_scsi_pkt->pkt_comp,
3598 			    (void *)spx->txlt_scsi_pkt, TQ_NOSLEEP) ==
3599 			    TASKQID_INVALID) {
3600 				return (TRAN_BUSY);
3601 			}
3602 		} else if (taskq_dispatch(SATA_TXLT_TASKQ(spx),
3603 		    (task_func_t *)spx->txlt_scsi_pkt->pkt_comp,
3604 		    (void *)spx->txlt_scsi_pkt, TQ_SLEEP) == TASKQID_INVALID) {
3605 			/* Scheduling the callback failed */
3606 			return (TRAN_BUSY);
3607 		}
3608 	}
3609 	return (TRAN_ACCEPT);
3610 }
3611 
3612 
3613 /*
3614  * SATA translate command: Inquiry / Identify Device
3615  * Use cached Identify Device data for now, rather than issuing actual
3616  * Device Identify cmd request. If device is detached and re-attached,
3617  * asynchronous event processing should fetch and refresh Identify Device
3618  * data.
3619  * VPD pages supported now:
3620  * Vital Product Data page
3621  * Unit Serial Number page
3622  * Block Device Characteristics Page
3623  * ATA Information Page
3624  *
3625  * Returns TRAN_ACCEPT and appropriate values in scsi_pkt fields.
3626  */
3627 
3628 #define	EVPD			1	/* Extended Vital Product Data flag */
3629 #define	CMDDT			2	/* Command Support Data - Obsolete */
3630 #define	INQUIRY_SUP_VPD_PAGE	0	/* Supported VPD Pages Page Code */
3631 #define	INQUIRY_USN_PAGE	0x80	/* Unit Serial Number Page Code */
3632 #define	INQUIRY_BDC_PAGE	0xB1	/* Block Device Characteristics Page */
3633 					/* Code */
3634 #define	INQUIRY_ATA_INFO_PAGE	0x89	/* ATA Information Page Code */
3635 #define	INQUIRY_DEV_IDENTIFICATION_PAGE 0x83 /* Device identifiers */
3636 
3637 static int
3638 sata_txlt_inquiry(sata_pkt_txlate_t *spx)
3639 {
3640 	struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt;
3641 	struct buf *bp = spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp;
3642 	sata_drive_info_t *sdinfo;
3643 	struct scsi_extended_sense *sense;
3644 	int count;
3645 	uint8_t *p;
3646 	int i, j;
3647 	uint8_t page_buf[1024]; /* Max length */
3648 	int rval, reason;
3649 	ushort_t rate;
3650 	kmutex_t *cport_mutex = &(SATA_TXLT_CPORT_MUTEX(spx));
3651 
3652 	/*
3653 	 * sata_txlt_generic_pkt_info() and sata_get_device_info() require
3654 	 * cport_mutex to be held while they are called. sdinfo is also
3655 	 * protected by cport_mutex, so we hold cport_mutex until after we've
3656 	 * finished using sdinfo.
3657 	 */
3658 	mutex_enter(cport_mutex);
3659 
3660 	if (((rval = sata_txlt_generic_pkt_info(spx, &reason, 0)) !=
3661 	    TRAN_ACCEPT) || (reason == CMD_DEV_GONE)) {
3662 		mutex_exit(cport_mutex);
3663 		return (rval);
3664 	}
3665 
3666 	sdinfo = sata_get_device_info(spx->txlt_sata_hba_inst,
3667 	    &spx->txlt_sata_pkt->satapkt_device);
3668 
3669 	ASSERT(sdinfo != NULL);
3670 
3671 	scsipkt->pkt_reason = CMD_CMPLT;
3672 	scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET |
3673 	    STATE_SENT_CMD | STATE_GOT_STATUS;
3674 
3675 	/* Reject not supported request */
3676 	if (scsipkt->pkt_cdbp[1] & CMDDT) { /* No support for this bit */
3677 		*scsipkt->pkt_scbp = STATUS_CHECK;
3678 		sense = sata_arq_sense(spx);
3679 		sense->es_key = KEY_ILLEGAL_REQUEST;
3680 		sense->es_add_code = SD_SCSI_ASC_INVALID_FIELD_IN_CDB;
3681 		goto done;
3682 	}
3683 
3684 	/* Valid Inquiry request */
3685 	*scsipkt->pkt_scbp = STATUS_GOOD;
3686 
3687 	if (bp == NULL || bp->b_un.b_addr == NULL || bp->b_bcount == 0)
3688 		goto done;
3689 
3690 	/*
3691 	 * Because it is fully emulated command storing data
3692 	 * programatically in the specified buffer, release
3693 	 * preallocated DMA resources before storing data in the buffer,
3694 	 * so no unwanted DMA sync would take place.
3695 	 */
3696 	sata_scsi_dmafree(NULL, scsipkt);
3697 
3698 	if (!(scsipkt->pkt_cdbp[1] & EVPD)) {
3699 		/* Standard Inquiry Data request */
3700 		struct scsi_inquiry inq;
3701 		unsigned int bufsize;
3702 
3703 		sata_identdev_to_inquiry(spx->txlt_sata_hba_inst,
3704 		    sdinfo, (uint8_t *)&inq);
3705 		/* Copy no more than requested */
3706 		count = MIN(bp->b_bcount, sizeof (struct scsi_inquiry));
3707 		bufsize = scsipkt->pkt_cdbp[4];
3708 		bufsize |= scsipkt->pkt_cdbp[3] << 8;
3709 		count = MIN(count, bufsize);
3710 		bcopy(&inq, bp->b_un.b_addr, count);
3711 
3712 		scsipkt->pkt_state |= STATE_XFERRED_DATA;
3713 		scsipkt->pkt_resid = scsipkt->pkt_cdbp[4] > count ?
3714 		    bufsize - count : 0;
3715 		goto done;
3716 	}
3717 
3718 	/*
3719 	 * peripheral_qualifier = 0;
3720 	 *
3721 	 * We are dealing only with HD and will be
3722 	 * dealing with CD/DVD devices soon
3723 	 */
3724 	uint8_t peripheral_device_type =
3725 	    sdinfo->satadrv_type == SATA_DTYPE_ATADISK ?
3726 	    DTYPE_DIRECT : DTYPE_RODIRECT;
3727 
3728 	bzero(page_buf, sizeof (page_buf));
3729 
3730 	switch ((uint_t)scsipkt->pkt_cdbp[2]) {
3731 	case INQUIRY_SUP_VPD_PAGE:
3732 		/*
3733 		 * Request for supported Vital Product Data pages.
3734 		 */
3735 		page_buf[0] = peripheral_device_type;
3736 		page_buf[1] = INQUIRY_SUP_VPD_PAGE;
3737 		page_buf[2] = 0;
3738 		page_buf[4] = INQUIRY_SUP_VPD_PAGE;
3739 		page_buf[5] = INQUIRY_USN_PAGE;
3740 		page_buf[6] = INQUIRY_BDC_PAGE;
3741 		/*
3742 		 * If WWN info is present, provide a page for it.
3743 		 * Modern drives always have, but some legacy ones do not.
3744 		 */
3745 		if (sdinfo->satadrv_id.ai_naa_ieee_oui != 0) {
3746 			page_buf[3] = 5; /* page length */
3747 			page_buf[7] = INQUIRY_DEV_IDENTIFICATION_PAGE;
3748 			page_buf[8] = INQUIRY_ATA_INFO_PAGE;
3749 			count = 9;
3750 		} else {
3751 			page_buf[3] = 4; /* page length */
3752 			page_buf[7] = INQUIRY_ATA_INFO_PAGE;
3753 			count = 8;
3754 		}
3755 		/* Copy no more than requested */
3756 		count = MIN(bp->b_bcount, count);
3757 		bcopy(page_buf, bp->b_un.b_addr, count);
3758 		break;
3759 
3760 	case INQUIRY_USN_PAGE:
3761 		/*
3762 		 * Request for Unit Serial Number page.
3763 		 * Set-up the page.
3764 		 */
3765 		page_buf[0] = peripheral_device_type;
3766 		page_buf[1] = INQUIRY_USN_PAGE;
3767 		page_buf[2] = 0;
3768 		/* remaining page length */
3769 		page_buf[3] = SATA_ID_SERIAL_LEN;
3770 
3771 		/*
3772 		 * Copy serial number from Identify Device data
3773 		 * words into the inquiry page and swap bytes
3774 		 * when necessary.
3775 		 */
3776 		p = (uint8_t *)(sdinfo->satadrv_id.ai_drvser);
3777 #ifdef	_LITTLE_ENDIAN
3778 		swab(p, &page_buf[4], SATA_ID_SERIAL_LEN);
3779 #else
3780 		bcopy(p, &page_buf[4], SATA_ID_SERIAL_LEN);
3781 #endif
3782 		/*
3783 		 * Least significant character of the serial
3784 		 * number shall appear as the last byte,
3785 		 * according to SBC-3 spec.
3786 		 * Count trailing spaces to determine the
3787 		 * necessary shift length.
3788 		 */
3789 		p = &page_buf[SATA_ID_SERIAL_LEN + 4 - 1];
3790 		for (j = 0; j < SATA_ID_SERIAL_LEN; j++) {
3791 			if (*(p - j) != '\0' && *(p - j) != '\040')
3792 				break;
3793 		}
3794 
3795 		/*
3796 		 * Shift SN string right, so that the last
3797 		 * non-blank character would appear in last
3798 		 * byte of SN field in the page.
3799 		 * 'j' is the shift length.
3800 		 */
3801 		for (i = 0; i < (SATA_ID_SERIAL_LEN - j) && j != 0; i++, p--)
3802 			*p = *(p - j);
3803 
3804 		/*
3805 		 * Add leading spaces - same number as the
3806 		 * shift size
3807 		 */
3808 		for (; j > 0; j--)
3809 			page_buf[4 + j - 1] = '\040';
3810 
3811 		count = MIN(bp->b_bcount, SATA_ID_SERIAL_LEN + 4);
3812 		bcopy(page_buf, bp->b_un.b_addr, count);
3813 		break;
3814 
3815 	case INQUIRY_BDC_PAGE:
3816 		/*
3817 		 * Request for Block Device Characteristics
3818 		 * page.  Set-up the page.
3819 		 */
3820 		page_buf[0] = peripheral_device_type;
3821 		page_buf[1] = INQUIRY_BDC_PAGE;
3822 		page_buf[2] = 0;
3823 		/* remaining page length */
3824 		page_buf[3] = SATA_ID_BDC_LEN;
3825 
3826 		rate = sdinfo->satadrv_id.ai_medrotrate;
3827 		page_buf[4] = (rate >> 8) & 0xff;
3828 		page_buf[5] = rate & 0xff;
3829 		page_buf[6] = 0;
3830 		page_buf[7] = sdinfo->satadrv_id.ai_nomformfactor & 0xf;
3831 
3832 		count = MIN(bp->b_bcount, SATA_ID_BDC_LEN + 4);
3833 		bcopy(page_buf, bp->b_un.b_addr, count);
3834 		break;
3835 
3836 	case INQUIRY_ATA_INFO_PAGE:
3837 		/*
3838 		 * Request for ATA Information page.
3839 		 */
3840 		page_buf[0] = peripheral_device_type;
3841 		page_buf[1] = INQUIRY_ATA_INFO_PAGE;
3842 		page_buf[2] = (SATA_ID_ATA_INFO_LEN >> 8) & 0xff;
3843 		page_buf[3] = SATA_ID_ATA_INFO_LEN & 0xff;
3844 		/* page_buf[4-7] reserved */
3845 #ifdef  _LITTLE_ENDIAN
3846 		bcopy("ATA     ", &page_buf[8], 8);
3847 		swab(sdinfo->satadrv_id.ai_model, &page_buf[16], 16);
3848 		if (strncmp(&sdinfo->satadrv_id.ai_fw[4], "    ", 4) == 0) {
3849 			swab(sdinfo->satadrv_id.ai_fw, &page_buf[32], 4);
3850 		} else {
3851 			swab(&sdinfo->satadrv_id.ai_fw[4], &page_buf[32], 4);
3852 		}
3853 #else   /* _LITTLE_ENDIAN */
3854 		bcopy("ATA     ", &page_buf[8], 8);
3855 		bcopy(sdinfo->satadrv_id.ai_model, &page_buf[16], 16);
3856 		if (strncmp(&sdinfo->satadrv_id.ai_fw[4], "    ", 4) == 0) {
3857 			bcopy(sdinfo->satadrv_id.ai_fw, &page_buf[32], 4);
3858 		} else {
3859 			bcopy(&sdinfo->satadrv_id.ai_fw[4], &page_buf[32], 4);
3860 		}
3861 #endif  /* _LITTLE_ENDIAN */
3862 		/*
3863 		 * page_buf[36-55] which defines the device
3864 		 * signature is not defined at this
3865 		 * time.
3866 		 */
3867 
3868 		/* Set the command code */
3869 		if (sdinfo->satadrv_type == SATA_DTYPE_ATADISK) {
3870 			page_buf[56] = SATAC_ID_DEVICE;
3871 		} else if (sdinfo->satadrv_type == SATA_DTYPE_ATAPI) {
3872 			page_buf[56] = SATAC_ID_PACKET_DEVICE;
3873 		}
3874 		/*
3875 		 * If the command code, page_buf[56], is not
3876 		 * zero and if one of the identify commands
3877 		 * succeeds, return the identify data.
3878 		 */
3879 		if (page_buf[56] != 0) {
3880 			sata_drive_info_t temp_info = {
3881 				.satadrv_addr = sdinfo->satadrv_addr,
3882 				.satadrv_type = sdinfo->satadrv_type,
3883 			};
3884 
3885 			/*
3886 			 * It appears calls to an HBA's start (sata_hba_start)
3887 			 * method (which sata_fetch_device_identify_data_retry()
3888 			 * calls) must not be done while holding cport_mutex.
3889 			 *
3890 			 * A packet's completion routine may call back into
3891 			 * the sata framework and deadlock (and all extant
3892 			 * calls to the HBA's start method either drop and
3893 			 * re-acquire cport_mutex, or never held cport_mutex).
3894 			 *
3895 			 * sdinfo is protected by cport_mutex, so we need to
3896 			 * obtain the SATA address and type from sdinfo
3897 			 * before releasing cport_mutex and submitting the
3898 			 * request. We reacquire cport_mutex to simplfy
3899 			 * cleanup after the done label.
3900 			 */
3901 			mutex_exit(cport_mutex);
3902 			(void) sata_fetch_device_identify_data(
3903 			    spx->txlt_sata_hba_inst, &temp_info);
3904 			mutex_enter(cport_mutex);
3905 
3906 			/*
3907 			 * If sata_fetch_device_identify_data()
3908 			 * fails, the bcopy() is harmless since we're copying
3909 			 * zeros back over zeros. If it succeeds, we're
3910 			 * copying over the portion of the response we need.
3911 			 */
3912 			bcopy(&temp_info.satadrv_id, &page_buf[60],
3913 			    sizeof (sata_id_t));
3914 		}
3915 
3916 		/* Need to copy out the page_buf to bp */
3917 		count = MIN(bp->b_bcount, SATA_ID_ATA_INFO_LEN + 4);
3918 		bcopy(page_buf, bp->b_un.b_addr, count);
3919 		break;
3920 
3921 	case INQUIRY_DEV_IDENTIFICATION_PAGE:
3922 		if (sdinfo->satadrv_id.ai_naa_ieee_oui != 0) {
3923 			/*
3924 			 * Page 83; SAT-5 requires this, and modern
3925 			 * SATA devices all support a WWN.
3926 			 */
3927 			page_buf[0] = peripheral_device_type;
3928 			page_buf[1] = INQUIRY_DEV_IDENTIFICATION_PAGE;
3929 			page_buf[2] = 0;
3930 			page_buf[3] = 12; /* remaining length */
3931 			page_buf[4] = 0x01; /* protocol 0, code set 1 */
3932 			page_buf[5] = 0x03; /* LUN, NAA type */
3933 			page_buf[6] = 0;
3934 			page_buf[7] = 0x08; /* length (64-bit WWN) */
3935 #ifdef	_LITTLE_ENDIAN
3936 			swab(&sdinfo->satadrv_id.ai_naa_ieee_oui, &page_buf[8],
3937 			    8);
3938 #else
3939 			bcopy(&sdinfo->satadrv_id.ai_naa_ieee_oui,
3940 			    &page_buf[8], 8);
3941 #endif
3942 			/* header + designator */
3943 			count = MIN(bp->b_bcount, 12 + 4);
3944 			bcopy(page_buf, bp->b_un.b_addr, count);
3945 			break;
3946 		}
3947 		/* FALLTHROUGH */
3948 
3949 	default:
3950 		/* Request for unsupported VPD page */
3951 		*scsipkt->pkt_scbp = STATUS_CHECK;
3952 		sense = sata_arq_sense(spx);
3953 		sense->es_key = KEY_ILLEGAL_REQUEST;
3954 		sense->es_add_code = SD_SCSI_ASC_INVALID_FIELD_IN_CDB;
3955 		goto done;
3956 	}
3957 
3958 	scsipkt->pkt_state |= STATE_XFERRED_DATA;
3959 	scsipkt->pkt_resid = scsipkt->pkt_cdbp[4] > count ?
3960 	    scsipkt->pkt_cdbp[4] - count : 0;
3961 
3962 done:
3963 	mutex_exit(cport_mutex);
3964 
3965 	SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst,
3966 	    "Scsi_pkt completion reason %x\n",
3967 	    scsipkt->pkt_reason);
3968 
3969 	if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0 &&
3970 	    scsipkt->pkt_comp != NULL) {
3971 		/* scsi callback required */
3972 		if (servicing_interrupt()) {
3973 			if (taskq_dispatch(SATA_TXLT_TASKQ(spx),
3974 			    (task_func_t *)spx->txlt_scsi_pkt->pkt_comp,
3975 			    (void *)spx->txlt_scsi_pkt, TQ_NOSLEEP) ==
3976 			    TASKQID_INVALID) {
3977 				return (TRAN_BUSY);
3978 			}
3979 		} else if (taskq_dispatch(SATA_TXLT_TASKQ(spx),
3980 		    (task_func_t *)spx->txlt_scsi_pkt->pkt_comp,
3981 		    (void *)spx->txlt_scsi_pkt, TQ_SLEEP) == TASKQID_INVALID) {
3982 			/* Scheduling the callback failed */
3983 			return (TRAN_BUSY);
3984 		}
3985 	}
3986 	return (TRAN_ACCEPT);
3987 }
3988 
3989 /*
3990  * SATA translate command: Request Sense.
3991  *
3992  * Returns TRAN_ACCEPT and appropriate values in scsi_pkt fields.
3993  * At the moment this is an emulated command (ATA version for SATA hard disks).
3994  * May be translated into Check Power Mode command in the future.
3995  *
3996  * Note: There is a mismatch between already implemented Informational
3997  * Exception Mode Select page 0x1C and this function.
3998  * When MRIE bit is set in page 0x1C, Request Sense is supposed to return
3999  * NO SENSE and set additional sense code to the exception code - this is not
4000  * implemented here.
4001  */
4002 static int
4003 sata_txlt_request_sense(sata_pkt_txlate_t *spx)
4004 {
4005 	struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt;
4006 	struct scsi_extended_sense sense;
4007 	struct buf *bp = spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp;
4008 	sata_drive_info_t *sdinfo;
4009 	sata_cmd_t *scmd = &spx->txlt_sata_pkt->satapkt_cmd;
4010 	int rval, reason, power_state = 0;
4011 	kmutex_t *cport_mutex;
4012 
4013 	cport_mutex = &(SATA_TXLT_CPORT_MUTEX(spx));
4014 	mutex_enter(cport_mutex);
4015 
4016 	if (((rval = sata_txlt_generic_pkt_info(spx, &reason, 1)) !=
4017 	    TRAN_ACCEPT) || (reason == CMD_DEV_GONE)) {
4018 		mutex_exit(cport_mutex);
4019 		return (rval);
4020 	}
4021 
4022 	scsipkt->pkt_reason = CMD_CMPLT;
4023 	scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET |
4024 	    STATE_SENT_CMD | STATE_GOT_STATUS;
4025 	*scsipkt->pkt_scbp = STATUS_GOOD;
4026 
4027 	/*
4028 	 * when CONTROL field's NACA bit == 1
4029 	 * return ILLEGAL_REQUEST
4030 	 */
4031 	if (scsipkt->pkt_cdbp[5] & CTL_BYTE_NACA_MASK) {
4032 		mutex_exit(cport_mutex);
4033 		return (sata_txlt_check_condition(spx, KEY_ILLEGAL_REQUEST,
4034 		    SD_SCSI_ASC_CMD_SEQUENCE_ERR));
4035 	}
4036 
4037 	sdinfo = sata_get_device_info(spx->txlt_sata_hba_inst,
4038 	    &spx->txlt_sata_pkt->satapkt_device);
4039 	ASSERT(sdinfo != NULL);
4040 
4041 	spx->txlt_sata_pkt->satapkt_op_mode |= SATA_OPMODE_SYNCH;
4042 
4043 	sata_build_generic_cmd(scmd, SATAC_CHECK_POWER_MODE);
4044 	scmd->satacmd_flags.sata_copy_out_sec_count_lsb = B_TRUE;
4045 	scmd->satacmd_flags.sata_copy_out_error_reg = B_TRUE;
4046 	if (sata_hba_start(spx, &rval) != 0) {
4047 		mutex_exit(cport_mutex);
4048 		return (rval);
4049 	}
4050 	if (scmd->satacmd_error_reg != 0) {
4051 		mutex_exit(cport_mutex);
4052 		return (sata_txlt_check_condition(spx, KEY_NO_SENSE,
4053 		    SD_SCSI_ASC_NO_ADD_SENSE));
4054 	}
4055 
4056 	switch (scmd->satacmd_sec_count_lsb) {
4057 	case SATA_PWRMODE_STANDBY: /* device in standby mode */
4058 		if (sdinfo->satadrv_power_level == SATA_POWER_STOPPED)
4059 			power_state = SATA_POWER_STOPPED;
4060 		else {
4061 			power_state = SATA_POWER_STANDBY;
4062 			sdinfo->satadrv_power_level = SATA_POWER_STANDBY;
4063 		}
4064 		break;
4065 	case SATA_PWRMODE_IDLE: /* device in idle mode */
4066 		power_state = SATA_POWER_IDLE;
4067 		sdinfo->satadrv_power_level = SATA_POWER_IDLE;
4068 		break;
4069 	case SATA_PWRMODE_ACTIVE: /* device in active or idle mode */
4070 	default:		  /* 0x40, 0x41 active mode */
4071 		if (sdinfo->satadrv_power_level == SATA_POWER_IDLE)
4072 			power_state = SATA_POWER_IDLE;
4073 		else {
4074 			power_state = SATA_POWER_ACTIVE;
4075 			sdinfo->satadrv_power_level = SATA_POWER_ACTIVE;
4076 		}
4077 		break;
4078 	}
4079 
4080 	mutex_exit(cport_mutex);
4081 
4082 	if (bp != NULL && bp->b_un.b_addr && bp->b_bcount) {
4083 		/*
4084 		 * Because it is fully emulated command storing data
4085 		 * programatically in the specified buffer, release
4086 		 * preallocated DMA resources before storing data in the buffer,
4087 		 * so no unwanted DMA sync would take place.
4088 		 */
4089 		int count = MIN(bp->b_bcount,
4090 		    sizeof (struct scsi_extended_sense));
4091 		sata_scsi_dmafree(NULL, scsipkt);
4092 		bzero(&sense, sizeof (struct scsi_extended_sense));
4093 		sense.es_valid = 0;	/* Valid LBA */
4094 		sense.es_class = 7;	/* Response code 0x70 - current err */
4095 		sense.es_key = KEY_NO_SENSE;
4096 		sense.es_add_len = 6;	/* Additional length */
4097 		/* Copy no more than requested */
4098 		bcopy(&sense, bp->b_un.b_addr, count);
4099 		scsipkt->pkt_state |= STATE_XFERRED_DATA;
4100 		scsipkt->pkt_resid = 0;
4101 		switch (power_state) {
4102 		case SATA_POWER_IDLE:
4103 		case SATA_POWER_STANDBY:
4104 			sense.es_add_code =
4105 			    SD_SCSI_ASC_LOW_POWER_CONDITION_ON;
4106 			break;
4107 		case SATA_POWER_STOPPED:
4108 			sense.es_add_code = SD_SCSI_ASC_NO_ADD_SENSE;
4109 			break;
4110 		case SATA_POWER_ACTIVE:
4111 		default:
4112 			break;
4113 		}
4114 	}
4115 
4116 	SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst,
4117 	    "Scsi_pkt completion reason %x\n",
4118 	    scsipkt->pkt_reason);
4119 
4120 	if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0 &&
4121 	    scsipkt->pkt_comp != NULL) {
4122 		/* scsi callback required */
4123 		if (servicing_interrupt()) {
4124 			if (taskq_dispatch(SATA_TXLT_TASKQ(spx),
4125 			    (task_func_t *)spx->txlt_scsi_pkt->pkt_comp,
4126 			    (void *)spx->txlt_scsi_pkt, TQ_NOSLEEP) ==
4127 			    TASKQID_INVALID) {
4128 				return (TRAN_BUSY);
4129 			}
4130 		} else if (taskq_dispatch(SATA_TXLT_TASKQ(spx),
4131 		    (task_func_t *)spx->txlt_scsi_pkt->pkt_comp,
4132 		    (void *)spx->txlt_scsi_pkt, TQ_SLEEP) == TASKQID_INVALID) {
4133 			/* Scheduling the callback failed */
4134 			return (TRAN_BUSY);
4135 		}
4136 	}
4137 	return (TRAN_ACCEPT);
4138 }
4139 
4140 /*
4141  * SATA translate command: Test Unit Ready
4142  * (ATA version for SATA hard disks).
4143  * It is translated into the Check Power Mode command.
4144  *
4145  * Returns TRAN_ACCEPT and appropriate values in scsi_pkt fields.
4146  */
4147 static int
4148 sata_txlt_test_unit_ready(sata_pkt_txlate_t *spx)
4149 {
4150 	struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt;
4151 	struct scsi_extended_sense *sense;
4152 	sata_cmd_t *scmd = &spx->txlt_sata_pkt->satapkt_cmd;
4153 	sata_drive_info_t *sdinfo;
4154 	int power_state;
4155 	int rval, reason;
4156 	kmutex_t *cport_mutex =  &(SATA_TXLT_CPORT_MUTEX(spx));
4157 
4158 	mutex_enter(cport_mutex);
4159 
4160 	if (((rval = sata_txlt_generic_pkt_info(spx, &reason, 1)) !=
4161 	    TRAN_ACCEPT) || (reason == CMD_DEV_GONE)) {
4162 		mutex_exit(cport_mutex);
4163 		return (rval);
4164 	}
4165 
4166 	sdinfo = sata_get_device_info(spx->txlt_sata_hba_inst,
4167 	    &spx->txlt_sata_pkt->satapkt_device);
4168 	ASSERT(sdinfo != NULL);
4169 
4170 	spx->txlt_sata_pkt->satapkt_op_mode |= SATA_OPMODE_SYNCH;
4171 
4172 	/* send CHECK POWER MODE command */
4173 	sata_build_generic_cmd(scmd, SATAC_CHECK_POWER_MODE);
4174 	scmd->satacmd_flags.sata_copy_out_sec_count_lsb = B_TRUE;
4175 	scmd->satacmd_flags.sata_copy_out_error_reg = B_TRUE;
4176 	if (sata_hba_start(spx, &rval) != 0) {
4177 		mutex_exit(cport_mutex);
4178 		return (rval);
4179 	}
4180 
4181 	if (scmd->satacmd_error_reg != 0) {
4182 		mutex_exit(cport_mutex);
4183 		return (sata_txlt_check_condition(spx, KEY_NOT_READY,
4184 		    SD_SCSI_ASC_LU_NOT_RESPONSE));
4185 	}
4186 
4187 	power_state = scmd->satacmd_sec_count_lsb;
4188 
4189 	/*
4190 	 * return NOT READY when device in STOPPED mode
4191 	 */
4192 	if (power_state == SATA_PWRMODE_STANDBY &&
4193 	    sdinfo->satadrv_power_level == SATA_POWER_STOPPED) {
4194 		*scsipkt->pkt_scbp = STATUS_CHECK;
4195 		sense = sata_arq_sense(spx);
4196 		sense->es_key = KEY_NOT_READY;
4197 		sense->es_add_code = SD_SCSI_ASC_LU_NOT_READY;
4198 	} else {
4199 		/*
4200 		 * For other power mode, return GOOD status
4201 		 */
4202 		*scsipkt->pkt_scbp = STATUS_GOOD;
4203 	}
4204 
4205 	scsipkt->pkt_reason = CMD_CMPLT;
4206 	scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET |
4207 	    STATE_SENT_CMD | STATE_GOT_STATUS;
4208 
4209 	mutex_exit(cport_mutex);
4210 
4211 	SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst,
4212 	    "Scsi_pkt completion reason %x\n", scsipkt->pkt_reason);
4213 
4214 	if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0 &&
4215 	    scsipkt->pkt_comp != NULL) {
4216 		/* scsi callback required */
4217 		if (servicing_interrupt()) {
4218 			if (taskq_dispatch(SATA_TXLT_TASKQ(spx),
4219 			    (task_func_t *)spx->txlt_scsi_pkt->pkt_comp,
4220 			    (void *)spx->txlt_scsi_pkt, TQ_NOSLEEP) ==
4221 			    TASKQID_INVALID) {
4222 				return (TRAN_BUSY);
4223 			}
4224 		} else if (taskq_dispatch(SATA_TXLT_TASKQ(spx),
4225 		    (task_func_t *)spx->txlt_scsi_pkt->pkt_comp,
4226 		    (void *)spx->txlt_scsi_pkt, TQ_SLEEP) == TASKQID_INVALID) {
4227 			/* Scheduling the callback failed */
4228 			return (TRAN_BUSY);
4229 		}
4230 	}
4231 
4232 	return (TRAN_ACCEPT);
4233 }
4234 
4235 /*
4236  * SATA translate command: Start Stop Unit
4237  * Translation depends on a command:
4238  *
4239  * Power condition bits will be supported
4240  * and the power level should be maintained by SATL,
4241  * When SATL received a command, it will check the
4242  * power level firstly, and return the status according
4243  * to SAT2 v2.6 and SAT-2 Standby Modifications
4244  *
4245  * SPC-4/SBC-3      SATL    ATA power condition  SATL      SPC/SBC
4246  * -----------------------------------------------------------------------
4247  * SSU_PC1 Active   <==>     ATA  Active         <==>     SSU:start_bit =1
4248  * SSU_PC2 Idle     <==>     ATA  Idle           <==>     N/A
4249  * SSU_PC3 Standby  <==>     ATA  Standby        <==>     N/A
4250  * SSU_PC4 Stopped  <==>     ATA  Standby        <==>     SSU:start_bit = 0
4251  *
4252  *	Unload Media / NOT SUPPORTED YET
4253  *	Load Media / NOT SUPPROTED YET
4254  *	Immediate bit / NOT SUPPORTED YET (deferred error)
4255  *
4256  * Returns TRAN_ACCEPT or code returned by sata_hba_start() and
4257  * appropriate values in scsi_pkt fields.
4258  */
4259 static int
4260 sata_txlt_start_stop_unit(sata_pkt_txlate_t *spx)
4261 {
4262 	struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt;
4263 	sata_cmd_t *scmd = &spx->txlt_sata_pkt->satapkt_cmd;
4264 	int rval, reason;
4265 	sata_drive_info_t *sdinfo;
4266 	sata_id_t *sata_id;
4267 	kmutex_t *cport_mutex = &(SATA_TXLT_CPORT_MUTEX(spx));
4268 
4269 	SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst,
4270 	    "sata_txlt_start_stop_unit: %d\n", scsipkt->pkt_scbp[4] & 1);
4271 
4272 	mutex_enter(cport_mutex);
4273 
4274 	if (((rval = sata_txlt_generic_pkt_info(spx, &reason, 1)) !=
4275 	    TRAN_ACCEPT) || (reason == CMD_DEV_GONE)) {
4276 		mutex_exit(cport_mutex);
4277 		return (rval);
4278 	}
4279 
4280 	if (scsipkt->pkt_cdbp[1] & START_STOP_IMMED_MASK) {
4281 		/* IMMED bit - not supported */
4282 		mutex_exit(cport_mutex);
4283 		return (sata_txlt_check_condition(spx, KEY_ILLEGAL_REQUEST,
4284 		    SD_SCSI_ASC_INVALID_FIELD_IN_CDB));
4285 	}
4286 
4287 	spx->txlt_sata_pkt->satapkt_op_mode |= SATA_OPMODE_SYNCH;
4288 	spx->txlt_sata_pkt->satapkt_comp = NULL;
4289 
4290 	sdinfo = sata_get_device_info(spx->txlt_sata_hba_inst,
4291 	    &spx->txlt_sata_pkt->satapkt_device);
4292 	ASSERT(sdinfo != NULL);
4293 	sata_id = &sdinfo->satadrv_id;
4294 
4295 	switch ((scsipkt->pkt_cdbp[4] & START_STOP_POWER_COND_MASK) >> 4) {
4296 	case 0:
4297 		if (scsipkt->pkt_cdbp[4] & START_STOP_LOEJ_MASK) {
4298 			/* Load/Unload Media - invalid request */
4299 			goto err_out;
4300 		}
4301 		if (scsipkt->pkt_cdbp[4] & START_STOP_START_MASK) {
4302 			/* Start Unit */
4303 			sata_build_read_verify_cmd(scmd, 1, 5);
4304 			scmd->satacmd_flags.sata_copy_out_error_reg = B_TRUE;
4305 			/* Transfer command to HBA */
4306 			if (sata_hba_start(spx, &rval) != 0) {
4307 				/* Pkt not accepted for execution */
4308 				mutex_exit(cport_mutex);
4309 				return (rval);
4310 			}
4311 			if (scmd->satacmd_error_reg != 0) {
4312 				goto err_out;
4313 			}
4314 			sdinfo->satadrv_power_level = SATA_POWER_ACTIVE;
4315 		} else {
4316 			/* Stop Unit */
4317 			sata_build_generic_cmd(scmd, SATAC_FLUSH_CACHE);
4318 			scmd->satacmd_flags.sata_copy_out_error_reg = B_TRUE;
4319 			if (sata_hba_start(spx, &rval) != 0) {
4320 				mutex_exit(cport_mutex);
4321 				return (rval);
4322 			} else {
4323 				if (scmd->satacmd_error_reg != 0) {
4324 					goto err_out;
4325 				}
4326 			}
4327 			/* ata standby immediate command */
4328 			sata_build_generic_cmd(scmd, SATAC_STANDBY_IM);
4329 			scmd->satacmd_flags.sata_copy_out_error_reg = B_TRUE;
4330 			if (sata_hba_start(spx, &rval) != 0) {
4331 				mutex_exit(cport_mutex);
4332 				return (rval);
4333 			}
4334 			if (scmd->satacmd_error_reg != 0) {
4335 				goto err_out;
4336 			}
4337 			sdinfo->satadrv_power_level = SATA_POWER_STOPPED;
4338 		}
4339 		break;
4340 	case 0x1:
4341 		sata_build_generic_cmd(scmd, SATAC_IDLE);
4342 		scmd->satacmd_flags.sata_copy_out_error_reg = B_TRUE;
4343 		if (sata_hba_start(spx, &rval) != 0) {
4344 			mutex_exit(cport_mutex);
4345 			return (rval);
4346 		}
4347 		if (scmd->satacmd_error_reg != 0) {
4348 			goto err_out;
4349 		}
4350 		sata_build_read_verify_cmd(scmd, 1, 5);
4351 		scmd->satacmd_flags.sata_copy_out_error_reg = B_TRUE;
4352 		/* Transfer command to HBA */
4353 		if (sata_hba_start(spx, &rval) != 0) {
4354 			/* Pkt not accepted for execution */
4355 			mutex_exit(cport_mutex);
4356 			return (rval);
4357 		} else {
4358 			if (scmd->satacmd_error_reg != 0) {
4359 				goto err_out;
4360 			}
4361 		}
4362 		sdinfo->satadrv_power_level = SATA_POWER_ACTIVE;
4363 		break;
4364 	case 0x2:
4365 		sata_build_generic_cmd(scmd, SATAC_FLUSH_CACHE);
4366 		scmd->satacmd_flags.sata_copy_out_error_reg = B_TRUE;
4367 		if (!(scsipkt->pkt_cdbp[4] & START_STOP_NOFLUSH_MASK)) {
4368 			if (sata_hba_start(spx, &rval) != 0) {
4369 				mutex_exit(cport_mutex);
4370 				return (rval);
4371 			}
4372 			if (scmd->satacmd_error_reg != 0) {
4373 				goto err_out;
4374 			}
4375 		}
4376 		sata_build_generic_cmd(scmd, SATAC_IDLE);
4377 		scmd->satacmd_flags.sata_copy_out_error_reg = B_TRUE;
4378 		if (sata_hba_start(spx, &rval) != 0) {
4379 			mutex_exit(cport_mutex);
4380 			return (rval);
4381 		}
4382 		if (scmd->satacmd_error_reg != 0) {
4383 			goto err_out;
4384 		}
4385 		if ((scsipkt->pkt_cdbp[3] & START_STOP_MODIFIER_MASK)) {
4386 			/*
4387 			 *  POWER CONDITION MODIFIER bit set
4388 			 *  to 0x1 or larger it will be handled
4389 			 *  on the same way as bit = 0x1
4390 			 */
4391 			if (!(sata_id->ai_cmdset84 &
4392 			    SATA_IDLE_UNLOAD_SUPPORTED)) {
4393 				sdinfo->satadrv_power_level = SATA_POWER_IDLE;
4394 				break;
4395 			}
4396 			sata_build_generic_cmd(scmd, SATAC_IDLE_IM);
4397 			scmd->satacmd_features_reg = 0x44;
4398 			scmd->satacmd_lba_low_lsb = 0x4c;
4399 			scmd->satacmd_lba_mid_lsb = 0x4e;
4400 			scmd->satacmd_lba_high_lsb = 0x55;
4401 			scmd->satacmd_flags.sata_copy_out_error_reg = B_TRUE;
4402 			if (sata_hba_start(spx, &rval) != 0) {
4403 				mutex_exit(cport_mutex);
4404 				return (rval);
4405 			}
4406 			if (scmd->satacmd_error_reg != 0) {
4407 				goto err_out;
4408 			}
4409 		}
4410 		sdinfo->satadrv_power_level = SATA_POWER_IDLE;
4411 		break;
4412 	case 0x3:
4413 		sata_build_generic_cmd(scmd, SATAC_FLUSH_CACHE);
4414 		scmd->satacmd_flags.sata_copy_out_error_reg = B_TRUE;
4415 		if (!(scsipkt->pkt_cdbp[4] & START_STOP_NOFLUSH_MASK)) {
4416 			if (sata_hba_start(spx, &rval) != 0) {
4417 				mutex_exit(cport_mutex);
4418 				return (rval);
4419 			}
4420 			if (scmd->satacmd_error_reg != 0) {
4421 				goto err_out;
4422 			}
4423 		}
4424 		sata_build_generic_cmd(scmd, SATAC_STANDBY);
4425 		scmd->satacmd_flags.sata_copy_out_error_reg = B_TRUE;
4426 		if (sata_hba_start(spx, &rval) != 0) {
4427 			mutex_exit(cport_mutex);
4428 			return (rval);
4429 		}
4430 		if (scmd->satacmd_error_reg != 0) {
4431 			goto err_out;
4432 		}
4433 		sdinfo->satadrv_power_level = SATA_POWER_STANDBY;
4434 		break;
4435 	case 0x7:
4436 		sata_build_generic_cmd(scmd, SATAC_CHECK_POWER_MODE);
4437 		scmd->satacmd_flags.sata_copy_out_sec_count_lsb = B_TRUE;
4438 		scmd->satacmd_flags.sata_copy_out_error_reg = B_TRUE;
4439 		if (sata_hba_start(spx, &rval) != 0) {
4440 			mutex_exit(cport_mutex);
4441 			return (rval);
4442 		}
4443 		if (scmd->satacmd_error_reg != 0) {
4444 			goto err_out;
4445 		}
4446 		switch (scmd->satacmd_sec_count_lsb) {
4447 		case SATA_PWRMODE_STANDBY:
4448 			sata_build_generic_cmd(scmd, SATAC_STANDBY);
4449 			scmd->satacmd_sec_count_msb = sata_get_standby_timer(
4450 			    sdinfo->satadrv_standby_timer);
4451 			scmd->satacmd_flags.sata_copy_out_error_reg = B_TRUE;
4452 			if (sata_hba_start(spx, &rval) != 0) {
4453 				mutex_exit(cport_mutex);
4454 				return (rval);
4455 			} else {
4456 				if (scmd->satacmd_error_reg != 0) {
4457 					goto err_out;
4458 				}
4459 			}
4460 			break;
4461 		case SATA_PWRMODE_IDLE:
4462 			sata_build_generic_cmd(scmd, SATAC_IDLE);
4463 			scmd->satacmd_sec_count_msb = sata_get_standby_timer(
4464 			    sdinfo->satadrv_standby_timer);
4465 			scmd->satacmd_flags.sata_copy_out_error_reg = B_TRUE;
4466 			if (sata_hba_start(spx, &rval) != 0) {
4467 				mutex_exit(cport_mutex);
4468 				return (rval);
4469 			} else {
4470 				if (scmd->satacmd_error_reg != 0) {
4471 					goto err_out;
4472 				}
4473 			}
4474 			break;
4475 		case SATA_PWRMODE_ACTIVE_SPINDOWN:
4476 		case SATA_PWRMODE_ACTIVE_SPINUP:
4477 		case SATA_PWRMODE_ACTIVE:
4478 			sata_build_generic_cmd(scmd, SATAC_IDLE);
4479 			scmd->satacmd_sec_count_msb = sata_get_standby_timer(
4480 			    sdinfo->satadrv_standby_timer);
4481 			scmd->satacmd_flags.sata_copy_out_error_reg = B_TRUE;
4482 			if (sata_hba_start(spx, &rval) != 0) {
4483 				mutex_exit(cport_mutex);
4484 				return (rval);
4485 			}
4486 			if (scmd->satacmd_error_reg != 0) {
4487 				goto err_out;
4488 			}
4489 			sata_build_read_verify_cmd(scmd, 1, 5);
4490 			scmd->satacmd_flags.sata_copy_out_error_reg = B_TRUE;
4491 			if (sata_hba_start(spx, &rval) != 0) {
4492 				mutex_exit(cport_mutex);
4493 				return (rval);
4494 			}
4495 			if (scmd->satacmd_error_reg != 0) {
4496 				goto err_out;
4497 			}
4498 			break;
4499 		default:
4500 			goto err_out;
4501 		}
4502 		break;
4503 	case 0xb:
4504 		if ((sata_get_standby_timer(sdinfo->satadrv_standby_timer) ==
4505 		    0) || (!(sata_id->ai_cap & SATA_STANDBYTIMER))) {
4506 			mutex_exit(cport_mutex);
4507 			return (sata_txlt_check_condition(spx,
4508 			    KEY_ILLEGAL_REQUEST,
4509 			    SD_SCSI_ASC_INVALID_FIELD_IN_CDB));
4510 		}
4511 		sata_build_generic_cmd(scmd, SATAC_FLUSH_CACHE);
4512 		scmd->satacmd_flags.sata_copy_out_error_reg = B_TRUE;
4513 		if (!(scsipkt->pkt_cdbp[4] & START_STOP_NOFLUSH_MASK)) {
4514 			if (sata_hba_start(spx, &rval) != 0) {
4515 				mutex_exit(cport_mutex);
4516 				return (rval);
4517 			}
4518 			if (scmd->satacmd_error_reg != 0) {
4519 				goto err_out;
4520 			}
4521 			sata_build_generic_cmd(scmd, SATAC_STANDBY_IM);
4522 			scmd->satacmd_flags.sata_copy_out_error_reg = B_TRUE;
4523 			if (sata_hba_start(spx, &rval) != 0) {
4524 				mutex_exit(cport_mutex);
4525 				return (rval);
4526 			}
4527 			if (scmd->satacmd_error_reg != 0) {
4528 				goto err_out;
4529 			}
4530 		}
4531 		bzero(sdinfo->satadrv_standby_timer, sizeof (uchar_t) * 4);
4532 		break;
4533 	default:
4534 err_out:
4535 		mutex_exit(cport_mutex);
4536 		return (sata_txlt_check_condition(spx, KEY_ILLEGAL_REQUEST,
4537 		    SD_SCSI_ASC_INVALID_FIELD_IN_CDB));
4538 	}
4539 
4540 	/*
4541 	 * Since it was a synchronous command,
4542 	 * a callback function will be called directly.
4543 	 */
4544 	mutex_exit(cport_mutex);
4545 	SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst,
4546 	    "synchronous execution status %x\n",
4547 	    spx->txlt_sata_pkt->satapkt_reason);
4548 
4549 	if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0 &&
4550 	    scsipkt->pkt_comp != NULL) {
4551 		sata_set_arq_data(spx->txlt_sata_pkt);
4552 		if (servicing_interrupt()) {
4553 			if (taskq_dispatch(SATA_TXLT_TASKQ(spx),
4554 			    (task_func_t *)spx->txlt_scsi_pkt->pkt_comp,
4555 			    (void *)spx->txlt_scsi_pkt, TQ_NOSLEEP) ==
4556 			    TASKQID_INVALID) {
4557 				return (TRAN_BUSY);
4558 			}
4559 		} else if (taskq_dispatch(SATA_TXLT_TASKQ(spx),
4560 		    (task_func_t *)spx->txlt_scsi_pkt->pkt_comp,
4561 		    (void *)spx->txlt_scsi_pkt, TQ_SLEEP) == TASKQID_INVALID) {
4562 			/* Scheduling the callback failed */
4563 			return (TRAN_BUSY);
4564 		}
4565 	}
4566 	else
4567 
4568 		sata_txlt_nodata_cmd_completion(spx->txlt_sata_pkt);
4569 
4570 	return (TRAN_ACCEPT);
4571 
4572 }
4573 
4574 /*
4575  * SATA translate command:  Read Capacity.
4576  * Emulated command for SATA disks.
4577  * Capacity is retrieved from cached Idenifty Device data.
4578  * Identify Device data shows effective disk capacity, not the native
4579  * capacity, which may be limitted by Set Max Address command.
4580  * This is ATA version for SATA hard disks.
4581  *
4582  * Returns TRAN_ACCEPT and appropriate values in scsi_pkt fields.
4583  */
4584 static int
4585 sata_txlt_read_capacity(sata_pkt_txlate_t *spx)
4586 {
4587 	struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt;
4588 	struct buf *bp = spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp;
4589 	sata_drive_info_t *sdinfo;
4590 	uint64_t val;
4591 	uint32_t lbsize = DEV_BSIZE;
4592 	uchar_t *rbuf;
4593 	int rval, reason;
4594 	kmutex_t *cport_mutex = &(SATA_TXLT_CPORT_MUTEX(spx));
4595 
4596 	SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst,
4597 	    "sata_txlt_read_capacity: ", NULL);
4598 
4599 	mutex_enter(cport_mutex);
4600 
4601 	if (((rval = sata_txlt_generic_pkt_info(spx, &reason, 0)) !=
4602 	    TRAN_ACCEPT) || (reason == CMD_DEV_GONE)) {
4603 		mutex_exit(cport_mutex);
4604 		return (rval);
4605 	}
4606 
4607 	scsipkt->pkt_reason = CMD_CMPLT;
4608 	scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET |
4609 	    STATE_SENT_CMD | STATE_GOT_STATUS;
4610 	*scsipkt->pkt_scbp = STATUS_GOOD;
4611 	if (bp != NULL && bp->b_un.b_addr && bp->b_bcount) {
4612 		/*
4613 		 * Because it is fully emulated command storing data
4614 		 * programatically in the specified buffer, release
4615 		 * preallocated DMA resources before storing data in the buffer,
4616 		 * so no unwanted DMA sync would take place.
4617 		 */
4618 		sata_scsi_dmafree(NULL, scsipkt);
4619 
4620 		sdinfo = sata_get_device_info(
4621 		    spx->txlt_sata_hba_inst,
4622 		    &spx->txlt_sata_pkt->satapkt_device);
4623 
4624 		/*
4625 		 * As per SBC-3, the "returned LBA" is either the highest
4626 		 * addressable LBA or 0xffffffff, whichever is smaller.
4627 		 */
4628 		val = MIN(sdinfo->satadrv_capacity - 1, UINT32_MAX);
4629 
4630 		if (sdinfo->satadrv_id.ai_phys_sect_sz & SATA_L2PS_CHECK_BIT) {
4631 			/* physical/logical sector size word is valid */
4632 
4633 			if (sdinfo->satadrv_id.ai_phys_sect_sz &
4634 			    SATA_L2PS_BIG_SECTORS) {
4635 				/* if this set 117-118 words are valid */
4636 				lbsize = sdinfo->satadrv_id.ai_words_lsec[0] |
4637 				    (sdinfo->satadrv_id.ai_words_lsec[1] << 16);
4638 				lbsize <<= 1; /* convert from words to bytes */
4639 			}
4640 		}
4641 		rbuf = (uchar_t *)bp->b_un.b_addr;
4642 		/* Need to swap endians to match scsi format */
4643 		rbuf[0] = (val >> 24) & 0xff;
4644 		rbuf[1] = (val >> 16) & 0xff;
4645 		rbuf[2] = (val >> 8) & 0xff;
4646 		rbuf[3] = val & 0xff;
4647 		rbuf[4] = (lbsize >> 24) & 0xff;
4648 		rbuf[5] = (lbsize >> 16) & 0xff;
4649 		rbuf[6] = (lbsize >> 8) & 0xff;
4650 		rbuf[7] = lbsize & 0xff;
4651 
4652 		scsipkt->pkt_state |= STATE_XFERRED_DATA;
4653 		scsipkt->pkt_resid = 0;
4654 
4655 		SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst, "%d\n",
4656 		    sdinfo->satadrv_capacity -1);
4657 	}
4658 	mutex_exit(cport_mutex);
4659 	/*
4660 	 * If a callback was requested, do it now.
4661 	 */
4662 	SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst,
4663 	    "Scsi_pkt completion reason %x\n", scsipkt->pkt_reason);
4664 
4665 	if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0 &&
4666 	    scsipkt->pkt_comp != NULL) {
4667 		/* scsi callback required */
4668 		if (servicing_interrupt()) {
4669 			if (taskq_dispatch(SATA_TXLT_TASKQ(spx),
4670 			    (task_func_t *)spx->txlt_scsi_pkt->pkt_comp,
4671 			    (void *)spx->txlt_scsi_pkt, TQ_NOSLEEP) ==
4672 			    TASKQID_INVALID) {
4673 				return (TRAN_BUSY);
4674 			}
4675 		} else if (taskq_dispatch(SATA_TXLT_TASKQ(spx),
4676 		    (task_func_t *)spx->txlt_scsi_pkt->pkt_comp,
4677 		    (void *)spx->txlt_scsi_pkt, TQ_SLEEP) == TASKQID_INVALID) {
4678 			/* Scheduling the callback failed */
4679 			return (TRAN_BUSY);
4680 		}
4681 	}
4682 
4683 	return (TRAN_ACCEPT);
4684 }
4685 
4686 /*
4687  * SATA translate command:  Read Capacity (16).
4688  * Emulated command for SATA disks.
4689  * Info is retrieved from cached Identify Device data.
4690  * Implemented to SBC-3 (draft 21) and SAT-2 (final) specifications.
4691  *
4692  * Returns TRAN_ACCEPT and appropriate values in scsi_pkt fields.
4693  */
4694 static int
4695 sata_txlt_read_capacity16(sata_pkt_txlate_t *spx)
4696 {
4697 	struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt;
4698 	struct buf *bp = spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp;
4699 	sata_drive_info_t *sdinfo;
4700 	uint64_t val;
4701 	uint16_t l2p_exp;
4702 	uint32_t lbsize = DEV_BSIZE;
4703 	uchar_t *rbuf;
4704 	int rval, reason;
4705 #define	TPE	0x80
4706 #define	TPRZ	0x40
4707 	kmutex_t *cport_mutex = &(SATA_TXLT_CPORT_MUTEX(spx));
4708 
4709 	SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst,
4710 	    "sata_txlt_read_capacity: ", NULL);
4711 
4712 	mutex_enter(cport_mutex);
4713 
4714 	if (((rval = sata_txlt_generic_pkt_info(spx, &reason, 0)) !=
4715 	    TRAN_ACCEPT) || (reason == CMD_DEV_GONE)) {
4716 		mutex_exit(cport_mutex);
4717 		return (rval);
4718 	}
4719 
4720 	scsipkt->pkt_reason = CMD_CMPLT;
4721 	scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET |
4722 	    STATE_SENT_CMD | STATE_GOT_STATUS;
4723 	if (bp != NULL && bp->b_un.b_addr && bp->b_bcount) {
4724 		/*
4725 		 * Because it is fully emulated command storing data
4726 		 * programatically in the specified buffer, release
4727 		 * preallocated DMA resources before storing data in the buffer,
4728 		 * so no unwanted DMA sync would take place.
4729 		 */
4730 		sata_scsi_dmafree(NULL, scsipkt);
4731 
4732 		/* Check SERVICE ACTION field */
4733 		if ((scsipkt->pkt_cdbp[1] & 0x1f) !=
4734 		    SSVC_ACTION_READ_CAPACITY_G4) {
4735 			mutex_exit(cport_mutex);
4736 			return (sata_txlt_check_condition(spx,
4737 			    KEY_ILLEGAL_REQUEST,
4738 			    SD_SCSI_ASC_INVALID_FIELD_IN_CDB));
4739 		}
4740 
4741 		/* Check LBA field */
4742 		if ((scsipkt->pkt_cdbp[2] != 0) ||
4743 		    (scsipkt->pkt_cdbp[3] != 0) ||
4744 		    (scsipkt->pkt_cdbp[4] != 0) ||
4745 		    (scsipkt->pkt_cdbp[5] != 0) ||
4746 		    (scsipkt->pkt_cdbp[6] != 0) ||
4747 		    (scsipkt->pkt_cdbp[7] != 0) ||
4748 		    (scsipkt->pkt_cdbp[8] != 0) ||
4749 		    (scsipkt->pkt_cdbp[9] != 0)) {
4750 			mutex_exit(cport_mutex);
4751 			return (sata_txlt_check_condition(spx,
4752 			    KEY_ILLEGAL_REQUEST,
4753 			    SD_SCSI_ASC_INVALID_FIELD_IN_CDB));
4754 		}
4755 
4756 		/* Check PMI bit */
4757 		if (scsipkt->pkt_cdbp[14] & 0x1) {
4758 			mutex_exit(cport_mutex);
4759 			return (sata_txlt_check_condition(spx,
4760 			    KEY_ILLEGAL_REQUEST,
4761 			    SD_SCSI_ASC_INVALID_FIELD_IN_CDB));
4762 		}
4763 
4764 		*scsipkt->pkt_scbp = STATUS_GOOD;
4765 
4766 		sdinfo = sata_get_device_info(
4767 		    spx->txlt_sata_hba_inst,
4768 		    &spx->txlt_sata_pkt->satapkt_device);
4769 
4770 		/* last logical block address */
4771 		val = MIN(sdinfo->satadrv_capacity - 1,
4772 		    SCSI_READ_CAPACITY16_MAX_LBA);
4773 
4774 		/* logical to physical block size exponent */
4775 		l2p_exp = 0;
4776 		if (sdinfo->satadrv_id.ai_phys_sect_sz & SATA_L2PS_CHECK_BIT) {
4777 			/* physical/logical sector size word is valid */
4778 
4779 			if (sdinfo->satadrv_id.ai_phys_sect_sz &
4780 			    SATA_L2PS_HAS_MULT) {
4781 				/* multiple logical sectors per phys sectors */
4782 				l2p_exp =
4783 				    sdinfo->satadrv_id.ai_phys_sect_sz &
4784 				    SATA_L2PS_EXP_MASK;
4785 			}
4786 
4787 			if (sdinfo->satadrv_id.ai_phys_sect_sz &
4788 			    SATA_L2PS_BIG_SECTORS) {
4789 				/* if this set 117-118 words are valid */
4790 				lbsize = sdinfo->satadrv_id.ai_words_lsec[0] |
4791 				    (sdinfo->satadrv_id.ai_words_lsec[1] << 16);
4792 				lbsize <<= 1; /* convert from words to bytes */
4793 			}
4794 		}
4795 
4796 		rbuf = (uchar_t *)bp->b_un.b_addr;
4797 		bzero(rbuf, bp->b_bcount);
4798 
4799 		/* returned logical block address */
4800 		rbuf[0] = (val >> 56) & 0xff;
4801 		rbuf[1] = (val >> 48) & 0xff;
4802 		rbuf[2] = (val >> 40) & 0xff;
4803 		rbuf[3] = (val >> 32) & 0xff;
4804 		rbuf[4] = (val >> 24) & 0xff;
4805 		rbuf[5] = (val >> 16) & 0xff;
4806 		rbuf[6] = (val >> 8) & 0xff;
4807 		rbuf[7] = val & 0xff;
4808 		rbuf[8] = (lbsize >> 24) & 0xff;
4809 		rbuf[9] = (lbsize >> 16) & 0xff;
4810 		rbuf[10] = (lbsize >> 8) & 0xff;
4811 		rbuf[11] = lbsize & 0xff;
4812 
4813 		/* p_type, prot_en, unspecified by SAT-2 */
4814 		/* rbuf[12] = 0; */
4815 
4816 		/* p_i_exponent, undefined by SAT-2 */
4817 		/* logical blocks per physical block exponent */
4818 		rbuf[13] = l2p_exp;
4819 
4820 		/*
4821 		 * tpe and tprz as defined in T10/10-079 r0.
4822 		 * TRIM support is indicated by the relevant bit in the data
4823 		 * set management word. Read-after-trim behavior is indicated
4824 		 * by the additional bits in the identify device word. Of the
4825 		 * three defined possibilities, we only flag read-zero.
4826 		 */
4827 		if (sdinfo->satadrv_id.ai_dsm & SATA_DSM_TRIM) {
4828 			rbuf[14] |= TPE;
4829 
4830 			if ((sdinfo->satadrv_id.ai_addsupported &
4831 			    SATA_DETERMINISTIC_READ) &&
4832 			    (sdinfo->satadrv_id.ai_addsupported &
4833 			    SATA_READ_ZERO)) {
4834 				rbuf[14] |= TPRZ;
4835 			}
4836 		}
4837 
4838 		/* lowest aligned logical block address = 0 (for now) */
4839 		/* rbuf[15] = 0; */
4840 
4841 		scsipkt->pkt_state |= STATE_XFERRED_DATA;
4842 		scsipkt->pkt_resid = 0;
4843 
4844 		SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst, "%llu\n",
4845 		    sdinfo->satadrv_capacity -1);
4846 	}
4847 
4848 	mutex_exit(cport_mutex);
4849 
4850 	/*
4851 	 * If a callback was requested, do it now.
4852 	 */
4853 	SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst,
4854 	    "Scsi_pkt completion reason %x\n", scsipkt->pkt_reason);
4855 
4856 	if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0 &&
4857 	    scsipkt->pkt_comp != NULL) {
4858 		/* scsi callback required */
4859 		if (servicing_interrupt()) {
4860 			if (taskq_dispatch(SATA_TXLT_TASKQ(spx),
4861 			    (task_func_t *)spx->txlt_scsi_pkt->pkt_comp,
4862 			    (void *)spx->txlt_scsi_pkt, TQ_NOSLEEP) ==
4863 			    TASKQID_INVALID) {
4864 				return (TRAN_BUSY);
4865 			}
4866 		} else if (taskq_dispatch(SATA_TXLT_TASKQ(spx),
4867 		    (task_func_t *)spx->txlt_scsi_pkt->pkt_comp,
4868 		    (void *)spx->txlt_scsi_pkt, TQ_SLEEP) == TASKQID_INVALID) {
4869 			/* Scheduling the callback failed */
4870 			return (TRAN_BUSY);
4871 		}
4872 	}
4873 
4874 	return (TRAN_ACCEPT);
4875 }
4876 
4877 static boolean_t
4878 sata_txlt_unmap_supported(sata_pkt_txlate_t *spx, sata_drive_info_t *sdinfo)
4879 {
4880 	const sata_id_t *id = &sdinfo->satadrv_id;
4881 
4882 	ASSERT(MUTEX_HELD(&SATA_TXLT_CPORT_MUTEX(spx)));
4883 
4884 	/*
4885 	 * SAT-5 9.24.1 If the TRIM SUPPORTED bit is zero or the
4886 	 * DRAT SUPPORTED bit is zero, then UNMAP is not supported.
4887 	 */
4888 	if (!(id->ai_dsm & SATA_DSM_TRIM) ||
4889 	    !(id->ai_addsupported & SATA_DETERMINISTIC_READ)) {
4890 		return (B_FALSE);
4891 	}
4892 
4893 	return (B_TRUE);
4894 }
4895 
4896 /*
4897  * Translate command: UNMAP
4898  *
4899  * The function cannot be called in interrupt context since it may sleep.
4900  */
4901 static int
4902 sata_txlt_unmap(sata_pkt_txlate_t *spx)
4903 {
4904 	struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt;
4905 	sata_cmd_t *scmd = &spx->txlt_sata_pkt->satapkt_cmd;
4906 	struct buf *bp = spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp;
4907 	uint16_t count = 0;
4908 	int synch;
4909 	int rval, reason;
4910 	int i, x;
4911 	int bdlen = 0;
4912 	int ranges = 0;
4913 	int paramlen = 8;
4914 	uint8_t *data, *tmpbd;
4915 	sata_drive_info_t *sdinfo;
4916 	kmutex_t *cport_mutex = &(SATA_TXLT_CPORT_MUTEX(spx));
4917 #define	TRIM	0x1
4918 
4919 	SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst,
4920 	    "sata_txlt_unmap: ", NULL);
4921 
4922 	mutex_enter(cport_mutex);
4923 
4924 	sdinfo = sata_get_device_info(spx->txlt_sata_hba_inst,
4925 	    &spx->txlt_sata_pkt->satapkt_device);
4926 	if (sdinfo != NULL) {
4927 		SATADBG2(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst,
4928 		    "DSM support 0x%x, max number of 512 byte blocks of LBA "
4929 		    "range entries 0x%x\n", sdinfo->satadrv_id.ai_dsm,
4930 		    sdinfo->satadrv_id.ai_maxcount);
4931 	}
4932 
4933 	rval = sata_txlt_generic_pkt_info(spx, &reason, 1);
4934 	if ((rval != TRAN_ACCEPT) || (reason == CMD_DEV_GONE)) {
4935 		mutex_exit(cport_mutex);
4936 		return (rval);
4937 	}
4938 
4939 	if (!sata_txlt_unmap_supported(spx, sdinfo)) {
4940 		mutex_exit(cport_mutex);
4941 		return (sata_txlt_invalid_command(spx));
4942 	}
4943 
4944 	/*
4945 	 * Need to modify bp to have TRIM data instead of UNMAP data.
4946 	 * Start by getting the block descriptor data length by subtracting
4947 	 * the 8 byte parameter list header from the parameter list length.
4948 	 * The block descriptor size has to be a multiple of 16 bytes.
4949 	 */
4950 	bdlen = scsipkt->pkt_cdbp[7];
4951 	bdlen = (bdlen << 8) + scsipkt->pkt_cdbp[8] - paramlen;
4952 	if ((bdlen < 0) || ((bdlen % 16) != 0) ||
4953 	    ((bp != NULL) && (bdlen > (bp->b_bcount - paramlen)))) {
4954 		SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst,
4955 		    "sata_txlt_unmap: invalid block descriptor length", NULL);
4956 		mutex_exit(cport_mutex);
4957 		return ((sata_txlt_check_condition(spx, KEY_ILLEGAL_REQUEST,
4958 		    SD_SCSI_ASC_INVALID_FIELD_IN_CDB)));
4959 	}
4960 	/*
4961 	 * If there are no parameter data or block descriptors, it is not
4962 	 * considered an error so just complete the command without sending
4963 	 * TRIM.
4964 	 */
4965 	if ((bdlen == 0) || (bp == NULL) || (bp->b_un.b_addr == NULL) ||
4966 	    (bp->b_bcount == 0)) {
4967 		SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst,
4968 		    "sata_txlt_unmap: no parameter data or block descriptors",
4969 		    NULL);
4970 		mutex_exit(cport_mutex);
4971 		return (sata_txlt_unmap_nodata_cmd(spx));
4972 	}
4973 	tmpbd = (uint8_t *)bp->b_un.b_addr + paramlen;
4974 	data = kmem_zalloc(bdlen, KM_SLEEP);
4975 
4976 	/*
4977 	 * Loop through all the UNMAP block descriptors and convert the data
4978 	 * into TRIM format.
4979 	 */
4980 	for (i = 0, x = 0; i < bdlen; i += 16, x += 8) {
4981 		/* get range length */
4982 		data[x] = tmpbd[i+7];
4983 		data[x+1] = tmpbd[i+6];
4984 		/* get LBA */
4985 		data[x+2] = tmpbd[i+5];
4986 		data[x+3] = tmpbd[i+4];
4987 		data[x+4] = tmpbd[i+3];
4988 		data[x+5] = tmpbd[i+2];
4989 		data[x+6] = tmpbd[i+11];
4990 		data[x+7] = tmpbd[i+10];
4991 
4992 		ranges++;
4993 	}
4994 
4995 	/*
4996 	 * The TRIM command expects the data buffer to be a multiple of
4997 	 * 512-byte blocks of range entries.  This means that the UNMAP buffer
4998 	 * may be too small.  Free the original DMA resources and create a
4999 	 * local buffer.
5000 	 */
5001 	sata_common_free_dma_rsrcs(spx);
5002 
5003 	/*
5004 	 * Get count of 512-byte blocks of range entries.  The length
5005 	 * of a range entry is 8 bytes which means one count has 64 range
5006 	 * entries.
5007 	 */
5008 	count = (ranges + 63)/64;
5009 
5010 	/* Allocate a buffer that is a multiple of 512 bytes. */
5011 	mutex_exit(cport_mutex);
5012 	bp = sata_alloc_local_buffer(spx, (size_t)count * 512);
5013 	if (bp == NULL) {
5014 		SATADBG1(SATA_DBG_ATAPI, spx->txlt_sata_hba_inst,
5015 		    "sata_txlt_unmap: "
5016 		    "cannot allocate buffer for TRIM command", NULL);
5017 		kmem_free(data, bdlen);
5018 		return (TRAN_BUSY);
5019 	}
5020 	bp_mapin(bp); /* make data buffer accessible */
5021 	mutex_enter(cport_mutex);
5022 
5023 	bzero(bp->b_un.b_addr, bp->b_bcount);
5024 	bcopy(data, bp->b_un.b_addr, x);
5025 	kmem_free(data, bdlen);
5026 	rval = ddi_dma_sync(spx->txlt_buf_dma_handle, 0, 0,
5027 	    DDI_DMA_SYNC_FORDEV);
5028 	ASSERT(rval == DDI_SUCCESS);
5029 
5030 	scmd->satacmd_flags.sata_data_direction = SATA_DIR_WRITE;
5031 	scmd->satacmd_addr_type = ATA_ADDR_LBA48;
5032 	scmd->satacmd_cmd_reg = SATAC_DSM;
5033 	scmd->satacmd_sec_count_msb = (count >> 8) & 0xff;
5034 	scmd->satacmd_sec_count_lsb = count & 0xff;
5035 	scmd->satacmd_features_reg = TRIM;
5036 	scmd->satacmd_device_reg = SATA_ADH_LBA;
5037 	scmd->satacmd_status_reg = 0;
5038 	scmd->satacmd_error_reg = 0;
5039 
5040 	/* Start processing command */
5041 	if (!(spx->txlt_sata_pkt->satapkt_op_mode & SATA_OPMODE_SYNCH)) {
5042 		spx->txlt_sata_pkt->satapkt_comp =
5043 		    sata_txlt_unmap_completion;
5044 		synch = FALSE;
5045 	} else {
5046 		synch = TRUE;
5047 	}
5048 
5049 	if (sata_hba_start(spx, &rval) != 0) {
5050 		mutex_exit(cport_mutex);
5051 		return (rval);
5052 	}
5053 
5054 	mutex_exit(cport_mutex);
5055 
5056 	if (synch) {
5057 		sata_txlt_unmap_completion(spx->txlt_sata_pkt);
5058 	}
5059 
5060 	return (TRAN_ACCEPT);
5061 }
5062 
5063 /*
5064  * SATA translate command: Mode Sense.
5065  * Translated into appropriate SATA command or emulated.
5066  * Saved Values Page Control (03) are not supported.
5067  *
5068  * NOTE: only caching mode sense page is currently implemented.
5069  *
5070  * Returns TRAN_ACCEPT and appropriate values in scsi_pkt fields.
5071  */
5072 
5073 #define	LLBAA	0x10	/* Long LBA Accepted */
5074 
5075 static int
5076 sata_txlt_mode_sense(sata_pkt_txlate_t *spx)
5077 {
5078 	struct scsi_pkt	*scsipkt = spx->txlt_scsi_pkt;
5079 	struct buf	*bp = spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp;
5080 	sata_drive_info_t *sdinfo;
5081 	sata_id_t *sata_id;
5082 	struct scsi_extended_sense *sense;
5083 	int		len, bdlen, count, alc_len;
5084 	int		pc;	/* Page Control code */
5085 	uint8_t		*buf;	/* mode sense buffer */
5086 	int		rval, reason;
5087 	kmutex_t	*cport_mutex = &(SATA_TXLT_CPORT_MUTEX(spx));
5088 
5089 	SATADBG2(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst,
5090 	    "sata_txlt_mode_sense, pc %x page code 0x%02x\n",
5091 	    spx->txlt_scsi_pkt->pkt_cdbp[2] >> 6,
5092 	    spx->txlt_scsi_pkt->pkt_cdbp[2] & 0x3f);
5093 
5094 	if (servicing_interrupt()) {
5095 		buf = kmem_zalloc(1024, KM_NOSLEEP);
5096 		if (buf == NULL) {
5097 			return (TRAN_BUSY);
5098 		}
5099 	} else {
5100 		buf = kmem_zalloc(1024, KM_SLEEP);
5101 	}
5102 
5103 	mutex_enter(cport_mutex);
5104 
5105 	if (((rval = sata_txlt_generic_pkt_info(spx, &reason, 0)) !=
5106 	    TRAN_ACCEPT) || (reason == CMD_DEV_GONE)) {
5107 		mutex_exit(cport_mutex);
5108 		kmem_free(buf, 1024);
5109 		return (rval);
5110 	}
5111 
5112 	scsipkt->pkt_reason = CMD_CMPLT;
5113 	scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET |
5114 	    STATE_SENT_CMD | STATE_GOT_STATUS;
5115 
5116 	pc = scsipkt->pkt_cdbp[2] >> 6;
5117 
5118 	if (bp != NULL && bp->b_un.b_addr && bp->b_bcount) {
5119 		/*
5120 		 * Because it is fully emulated command storing data
5121 		 * programatically in the specified buffer, release
5122 		 * preallocated DMA resources before storing data in the buffer,
5123 		 * so no unwanted DMA sync would take place.
5124 		 */
5125 		sata_scsi_dmafree(NULL, scsipkt);
5126 
5127 		len = 0;
5128 		bdlen = 0;
5129 		if (!(scsipkt->pkt_cdbp[1] & 8)) {
5130 			if (scsipkt->pkt_cdbp[0] == SCMD_MODE_SENSE_G1 &&
5131 			    (scsipkt->pkt_cdbp[1] & LLBAA))
5132 				bdlen = 16;
5133 			else
5134 				bdlen = 8;
5135 		}
5136 		/* Build mode parameter header */
5137 		if (spx->txlt_scsi_pkt->pkt_cdbp[0] == SCMD_MODE_SENSE) {
5138 			/* 4-byte mode parameter header */
5139 			buf[len++] = 0;		/* mode data length */
5140 			buf[len++] = 0;		/* medium type */
5141 			buf[len++] = 0;		/* dev-specific param */
5142 			buf[len++] = bdlen;	/* Block Descriptor length */
5143 		} else {
5144 			/* 8-byte mode parameter header */
5145 			buf[len++] = 0;		/* mode data length */
5146 			buf[len++] = 0;
5147 			buf[len++] = 0;		/* medium type */
5148 			buf[len++] = 0;		/* dev-specific param */
5149 			if (bdlen == 16)
5150 				buf[len++] = 1;	/* long lba descriptor */
5151 			else
5152 				buf[len++] = 0;
5153 			buf[len++] = 0;
5154 			buf[len++] = 0;		/* Block Descriptor length */
5155 			buf[len++] = bdlen;
5156 		}
5157 
5158 		sdinfo = sata_get_device_info(
5159 		    spx->txlt_sata_hba_inst,
5160 		    &spx->txlt_sata_pkt->satapkt_device);
5161 
5162 		/* Build block descriptor only if not disabled (DBD) */
5163 		if ((scsipkt->pkt_cdbp[1] & 0x08) == 0) {
5164 			/* Block descriptor - direct-access device format */
5165 			if (bdlen == 8) {
5166 				/* build regular block descriptor */
5167 				buf[len++] =
5168 				    (sdinfo->satadrv_capacity >> 24) & 0xff;
5169 				buf[len++] =
5170 				    (sdinfo->satadrv_capacity >> 16) & 0xff;
5171 				buf[len++] =
5172 				    (sdinfo->satadrv_capacity >> 8) & 0xff;
5173 				buf[len++] = sdinfo->satadrv_capacity & 0xff;
5174 				buf[len++] = 0; /* density code */
5175 				buf[len++] = 0;
5176 				if (sdinfo->satadrv_type ==
5177 				    SATA_DTYPE_ATADISK)
5178 					buf[len++] = 2;
5179 				else
5180 					/* ATAPI */
5181 					buf[len++] = 8;
5182 				buf[len++] = 0;
5183 			} else if (bdlen == 16) {
5184 				/* Long LBA Accepted */
5185 				/* build long lba block descriptor */
5186 #ifndef __lock_lint
5187 				buf[len++] =
5188 				    (sdinfo->satadrv_capacity >> 56) & 0xff;
5189 				buf[len++] =
5190 				    (sdinfo->satadrv_capacity >> 48) & 0xff;
5191 				buf[len++] =
5192 				    (sdinfo->satadrv_capacity >> 40) & 0xff;
5193 				buf[len++] =
5194 				    (sdinfo->satadrv_capacity >> 32) & 0xff;
5195 #endif
5196 				buf[len++] =
5197 				    (sdinfo->satadrv_capacity >> 24) & 0xff;
5198 				buf[len++] =
5199 				    (sdinfo->satadrv_capacity >> 16) & 0xff;
5200 				buf[len++] =
5201 				    (sdinfo->satadrv_capacity >> 8) & 0xff;
5202 				buf[len++] = sdinfo->satadrv_capacity & 0xff;
5203 				buf[len++] = 0;
5204 				buf[len++] = 0; /* density code */
5205 				buf[len++] = 0;
5206 				buf[len++] = 0;
5207 				if (sdinfo->satadrv_type ==
5208 				    SATA_DTYPE_ATADISK)
5209 					buf[len++] = 2;
5210 				else
5211 					/* ATAPI */
5212 					buf[len++] = 8;
5213 				buf[len++] = 0;
5214 			}
5215 		}
5216 
5217 		sata_id = &sdinfo->satadrv_id;
5218 
5219 		/*
5220 		 * Add requested pages.
5221 		 * Page 3 and 4 are obsolete and we are not supporting them.
5222 		 * We deal now with:
5223 		 * caching (read/write cache control).
5224 		 * We should eventually deal with following mode pages:
5225 		 * error recovery  (0x01),
5226 		 * power condition (0x1a),
5227 		 * exception control page (enables SMART) (0x1c),
5228 		 * enclosure management (ses),
5229 		 * protocol-specific port mode (port control).
5230 		 */
5231 		switch (scsipkt->pkt_cdbp[2] & 0x3f) {
5232 		case MODEPAGE_RW_ERRRECOV:
5233 			/* DAD_MODE_ERR_RECOV */
5234 			/* R/W recovery */
5235 			len += sata_build_msense_page_1(sdinfo, pc, buf+len);
5236 			break;
5237 		case MODEPAGE_CACHING:
5238 			/* DAD_MODE_CACHE */
5239 			/* Reject not supported request for saved parameters */
5240 			if (pc == 3) {
5241 				*scsipkt->pkt_scbp = STATUS_CHECK;
5242 				sense = sata_arq_sense(spx);
5243 				sense->es_key = KEY_ILLEGAL_REQUEST;
5244 				sense->es_add_code =
5245 				    SD_SCSI_ASC_SAVING_PARAMS_NOT_SUPPORTED;
5246 				goto done;
5247 			}
5248 
5249 			/* caching */
5250 			len += sata_build_msense_page_8(sdinfo, pc, buf+len);
5251 			break;
5252 		case MODEPAGE_INFO_EXCPT:
5253 			/* exception cntrl */
5254 			if (sata_id->ai_cmdset82 & SATA_SMART_SUPPORTED) {
5255 				len += sata_build_msense_page_1c(sdinfo, pc,
5256 				    buf+len);
5257 			}
5258 			else
5259 				goto err;
5260 			break;
5261 		case MODEPAGE_POWER_COND:
5262 			/* DAD_MODE_POWER_COND */
5263 			/* power condition */
5264 			len += sata_build_msense_page_1a(sdinfo, pc, buf+len);
5265 			break;
5266 
5267 		case MODEPAGE_ACOUSTIC_MANAG:
5268 			/* acoustic management */
5269 			len += sata_build_msense_page_30(sdinfo, pc, buf+len);
5270 			break;
5271 		case MODEPAGE_ALLPAGES:
5272 			/* all pages */
5273 			len += sata_build_msense_page_1(sdinfo, pc, buf+len);
5274 			len += sata_build_msense_page_8(sdinfo, pc, buf+len);
5275 			len += sata_build_msense_page_1a(sdinfo, pc, buf+len);
5276 			if (sata_id->ai_cmdset82 & SATA_SMART_SUPPORTED) {
5277 				len += sata_build_msense_page_1c(sdinfo, pc,
5278 				    buf+len);
5279 			}
5280 			len += sata_build_msense_page_30(sdinfo, pc, buf+len);
5281 			break;
5282 		default:
5283 		err:
5284 			/* Invalid request */
5285 			*scsipkt->pkt_scbp = STATUS_CHECK;
5286 			sense = sata_arq_sense(spx);
5287 			sense->es_key = KEY_ILLEGAL_REQUEST;
5288 			sense->es_add_code = SD_SCSI_ASC_INVALID_FIELD_IN_CDB;
5289 			goto done;
5290 		}
5291 
5292 		/* fix total mode data length */
5293 		if (spx->txlt_scsi_pkt->pkt_cdbp[0] == SCMD_MODE_SENSE) {
5294 			/* 4-byte mode parameter header */
5295 			buf[0] = len - 1;	/* mode data length */
5296 		} else {
5297 			buf[0] = (len -2) >> 8;
5298 			buf[1] = (len -2) & 0xff;
5299 		}
5300 
5301 
5302 		/* Check allocation length */
5303 		if (scsipkt->pkt_cdbp[0] == SCMD_MODE_SENSE) {
5304 			alc_len = scsipkt->pkt_cdbp[4];
5305 		} else {
5306 			alc_len = scsipkt->pkt_cdbp[7];
5307 			alc_len = (alc_len << 8) | scsipkt->pkt_cdbp[8];
5308 		}
5309 		/*
5310 		 * We do not check for possible parameters truncation
5311 		 * (alc_len < len) assuming that the target driver works
5312 		 * correctly. Just avoiding overrun.
5313 		 * Copy no more than requested and possible, buffer-wise.
5314 		 */
5315 		count = MIN(alc_len, len);
5316 		count = MIN(bp->b_bcount, count);
5317 		bcopy(buf, bp->b_un.b_addr, count);
5318 
5319 		scsipkt->pkt_state |= STATE_XFERRED_DATA;
5320 		scsipkt->pkt_resid = alc_len > count ? alc_len - count : 0;
5321 	}
5322 	*scsipkt->pkt_scbp = STATUS_GOOD;
5323 done:
5324 	mutex_exit(cport_mutex);
5325 	(void) kmem_free(buf, 1024);
5326 
5327 	SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst,
5328 	    "Scsi_pkt completion reason %x\n", scsipkt->pkt_reason);
5329 
5330 	if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0 &&
5331 	    scsipkt->pkt_comp != NULL) {
5332 		/* scsi callback required */
5333 		if (servicing_interrupt()) {
5334 			if (taskq_dispatch(SATA_TXLT_TASKQ(spx),
5335 			    (task_func_t *)spx->txlt_scsi_pkt->pkt_comp,
5336 			    (void *)spx->txlt_scsi_pkt, TQ_NOSLEEP) ==
5337 			    TASKQID_INVALID) {
5338 				return (TRAN_BUSY);
5339 			}
5340 		} else if (taskq_dispatch(SATA_TXLT_TASKQ(spx),
5341 		    (task_func_t *)spx->txlt_scsi_pkt->pkt_comp,
5342 		    (void *)spx->txlt_scsi_pkt, TQ_SLEEP) == TASKQID_INVALID) {
5343 			/* Scheduling the callback failed */
5344 			return (TRAN_BUSY);
5345 		}
5346 	}
5347 
5348 	return (TRAN_ACCEPT);
5349 }
5350 
5351 
5352 /*
5353  * SATA translate command: Mode Select.
5354  * Translated into appropriate SATA command or emulated.
5355  * Saving parameters is not supported.
5356  * Changing device capacity is not supported (although theoretically
5357  * possible by executing SET FEATURES/SET MAX ADDRESS)
5358  *
5359  * Assumption is that the target driver is working correctly.
5360  *
5361  * More than one SATA command may be executed to perform operations specified
5362  * by mode select pages. The first error terminates further execution.
5363  * Operations performed successully are not backed-up in such case.
5364  *
5365  * NOTE: Implemented pages:
5366  * - caching page
5367  * - informational exception page
5368  * - acoustic management page
5369  * - power condition page
5370  * Caching setup is remembered so it could be re-stored in case of
5371  * an unexpected device reset.
5372  *
5373  * Returns TRAN_XXXX.
5374  * If TRAN_ACCEPT is returned, appropriate values are set in scsi_pkt fields.
5375  */
5376 
5377 static int
5378 sata_txlt_mode_select(sata_pkt_txlate_t *spx)
5379 {
5380 	struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt;
5381 	struct buf *bp = spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp;
5382 	struct scsi_extended_sense *sense;
5383 	int len, pagelen, count, pllen;
5384 	uint8_t *buf;	/* mode select buffer */
5385 	int rval, stat, reason;
5386 	uint_t nointr_flag;
5387 	int dmod = 0;
5388 	kmutex_t *cport_mutex = &(SATA_TXLT_CPORT_MUTEX(spx));
5389 
5390 	SATADBG2(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst,
5391 	    "sata_txlt_mode_select, pc %x page code 0x%02x\n",
5392 	    spx->txlt_scsi_pkt->pkt_cdbp[2] >> 6,
5393 	    spx->txlt_scsi_pkt->pkt_cdbp[2] & 0x3f);
5394 
5395 	mutex_enter(cport_mutex);
5396 
5397 	if (((rval = sata_txlt_generic_pkt_info(spx, &reason, 1)) !=
5398 	    TRAN_ACCEPT) || (reason == CMD_DEV_GONE)) {
5399 		mutex_exit(cport_mutex);
5400 		return (rval);
5401 	}
5402 
5403 	rval = TRAN_ACCEPT;
5404 
5405 	scsipkt->pkt_reason = CMD_CMPLT;
5406 	scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET |
5407 	    STATE_SENT_CMD | STATE_GOT_STATUS;
5408 	nointr_flag = scsipkt->pkt_flags & FLAG_NOINTR;
5409 
5410 	/* Reject not supported request */
5411 	if (! (scsipkt->pkt_cdbp[1] & 0x10)) { /* No support for PF bit = 0 */
5412 		*scsipkt->pkt_scbp = STATUS_CHECK;
5413 		sense = sata_arq_sense(spx);
5414 		sense->es_key = KEY_ILLEGAL_REQUEST;
5415 		sense->es_add_code = SD_SCSI_ASC_INVALID_FIELD_IN_CDB;
5416 		goto done;
5417 	}
5418 
5419 	if (scsipkt->pkt_cdbp[0] == SCMD_MODE_SELECT) {
5420 		pllen = scsipkt->pkt_cdbp[4];
5421 	} else {
5422 		pllen = scsipkt->pkt_cdbp[7];
5423 		pllen = (pllen << 8) | scsipkt->pkt_cdbp[7];
5424 	}
5425 
5426 	*scsipkt->pkt_scbp = STATUS_GOOD;	/* Presumed outcome */
5427 
5428 	if (bp != NULL && bp->b_un.b_addr && bp->b_bcount && pllen != 0) {
5429 		buf = (uint8_t *)bp->b_un.b_addr;
5430 		count = MIN(bp->b_bcount, pllen);
5431 		scsipkt->pkt_state |= STATE_XFERRED_DATA;
5432 		scsipkt->pkt_resid = 0;
5433 		pllen = count;
5434 
5435 		/*
5436 		 * Check the header to skip the block descriptor(s) - we
5437 		 * do not support setting device capacity.
5438 		 * Existing macros do not recognize long LBA dscriptor,
5439 		 * hence manual calculation.
5440 		 */
5441 		if (scsipkt->pkt_cdbp[0] == SCMD_MODE_SELECT) {
5442 			/* 6-bytes CMD, 4 bytes header */
5443 			if (count <= 4)
5444 				goto done;		/* header only */
5445 			len = buf[3] + 4;
5446 		} else {
5447 			/* 10-bytes CMD, 8 bytes header */
5448 			if (count <= 8)
5449 				goto done;		/* header only */
5450 			len = buf[6];
5451 			len = (len << 8) + buf[7] + 8;
5452 		}
5453 		if (len >= count)
5454 			goto done;	/* header + descriptor(s) only */
5455 
5456 		pllen -= len;		/* remaining data length */
5457 
5458 		/*
5459 		 * We may be executing SATA command and want to execute it
5460 		 * in SYNCH mode, regardless of scsi_pkt setting.
5461 		 * Save scsi_pkt setting and indicate SYNCH mode
5462 		 */
5463 		if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0 &&
5464 		    scsipkt->pkt_comp != NULL) {
5465 			scsipkt->pkt_flags |= FLAG_NOINTR;
5466 		}
5467 		spx->txlt_sata_pkt->satapkt_op_mode = SATA_OPMODE_SYNCH;
5468 
5469 		/*
5470 		 * len is now the offset to a first mode select page
5471 		 * Process all pages
5472 		 */
5473 		while (pllen > 0) {
5474 			switch ((int)buf[len]) {
5475 			case MODEPAGE_CACHING:
5476 				/* No support for SP (saving) */
5477 				if (scsipkt->pkt_cdbp[1] & 0x01) {
5478 					*scsipkt->pkt_scbp = STATUS_CHECK;
5479 					sense = sata_arq_sense(spx);
5480 					sense->es_key = KEY_ILLEGAL_REQUEST;
5481 					sense->es_add_code =
5482 					    SD_SCSI_ASC_INVALID_FIELD_IN_CDB;
5483 					goto done;
5484 				}
5485 				stat = sata_mode_select_page_8(spx,
5486 				    (struct mode_cache_scsi3 *)&buf[len],
5487 				    pllen, &pagelen, &rval, &dmod);
5488 				/*
5489 				 * The pagelen value indicates the number of
5490 				 * parameter bytes already processed.
5491 				 * The rval is the return value from
5492 				 * sata_tran_start().
5493 				 * The stat indicates the overall status of
5494 				 * the operation(s).
5495 				 */
5496 				if (stat != SATA_SUCCESS)
5497 					/*
5498 					 * Page processing did not succeed -
5499 					 * all error info is already set-up,
5500 					 * just return
5501 					 */
5502 					pllen = 0; /* this breaks the loop */
5503 				else {
5504 					len += pagelen;
5505 					pllen -= pagelen;
5506 				}
5507 				break;
5508 
5509 			case MODEPAGE_INFO_EXCPT:
5510 				stat = sata_mode_select_page_1c(spx,
5511 				    (struct mode_info_excpt_page *)&buf[len],
5512 				    pllen, &pagelen, &rval, &dmod);
5513 				/*
5514 				 * The pagelen value indicates the number of
5515 				 * parameter bytes already processed.
5516 				 * The rval is the return value from
5517 				 * sata_tran_start().
5518 				 * The stat indicates the overall status of
5519 				 * the operation(s).
5520 				 */
5521 				if (stat != SATA_SUCCESS)
5522 					/*
5523 					 * Page processing did not succeed -
5524 					 * all error info is already set-up,
5525 					 * just return
5526 					 */
5527 					pllen = 0; /* this breaks the loop */
5528 				else {
5529 					len += pagelen;
5530 					pllen -= pagelen;
5531 				}
5532 				break;
5533 
5534 			case MODEPAGE_ACOUSTIC_MANAG:
5535 				stat = sata_mode_select_page_30(spx,
5536 				    (struct mode_acoustic_management *)
5537 				    &buf[len], pllen, &pagelen, &rval, &dmod);
5538 				/*
5539 				 * The pagelen value indicates the number of
5540 				 * parameter bytes already processed.
5541 				 * The rval is the return value from
5542 				 * sata_tran_start().
5543 				 * The stat indicates the overall status of
5544 				 * the operation(s).
5545 				 */
5546 				if (stat != SATA_SUCCESS)
5547 					/*
5548 					 * Page processing did not succeed -
5549 					 * all error info is already set-up,
5550 					 * just return
5551 					 */
5552 					pllen = 0; /* this breaks the loop */
5553 				else {
5554 					len += pagelen;
5555 					pllen -= pagelen;
5556 				}
5557 
5558 				break;
5559 			case MODEPAGE_POWER_COND:
5560 				stat = sata_mode_select_page_1a(spx,
5561 				    (struct mode_info_power_cond *)&buf[len],
5562 				    pllen, &pagelen, &rval, &dmod);
5563 				/*
5564 				 * The pagelen value indicates the number of
5565 				 * parameter bytes already processed.
5566 				 * The rval is the return value from
5567 				 * sata_tran_start().
5568 				 * The stat indicates the overall status of
5569 				 * the operation(s).
5570 				 */
5571 				if (stat != SATA_SUCCESS)
5572 					/*
5573 					 * Page processing did not succeed -
5574 					 * all error info is already set-up,
5575 					 * just return
5576 					 */
5577 					pllen = 0; /* this breaks the loop */
5578 				else {
5579 					len += pagelen;
5580 					pllen -= pagelen;
5581 				}
5582 				break;
5583 			default:
5584 				*scsipkt->pkt_scbp = STATUS_CHECK;
5585 				sense = sata_arq_sense(spx);
5586 				sense->es_key = KEY_ILLEGAL_REQUEST;
5587 				sense->es_add_code =
5588 				    SD_SCSI_ASC_INVALID_FIELD_IN_PARAMS_LIST;
5589 				goto done;
5590 			}
5591 		}
5592 	}
5593 done:
5594 	mutex_exit(cport_mutex);
5595 	/*
5596 	 * If device parameters were modified, fetch and store the new
5597 	 * Identify Device data. Since port mutex could have been released
5598 	 * for accessing HBA driver, we need to re-check device existence.
5599 	 */
5600 	if (dmod != 0) {
5601 		sata_drive_info_t new_sdinfo, *sdinfo;
5602 		int rv = 0;
5603 
5604 		/*
5605 		 * Following statement has to be changed if this function is
5606 		 * used for devices other than SATA hard disks.
5607 		 */
5608 		new_sdinfo.satadrv_type = SATA_DTYPE_ATADISK;
5609 
5610 		new_sdinfo.satadrv_addr =
5611 		    spx->txlt_sata_pkt->satapkt_device.satadev_addr;
5612 		rv = sata_fetch_device_identify_data(spx->txlt_sata_hba_inst,
5613 		    &new_sdinfo);
5614 
5615 		mutex_enter(cport_mutex);
5616 		/*
5617 		 * Since port mutex could have been released when
5618 		 * accessing HBA driver, we need to re-check that the
5619 		 * framework still holds the device info structure.
5620 		 */
5621 		sdinfo = sata_get_device_info(spx->txlt_sata_hba_inst,
5622 		    &spx->txlt_sata_pkt->satapkt_device);
5623 		if (sdinfo != NULL) {
5624 			/*
5625 			 * Device still has info structure in the
5626 			 * sata framework. Copy newly fetched info
5627 			 */
5628 			if (rv == 0) {
5629 				sdinfo->satadrv_id = new_sdinfo.satadrv_id;
5630 				sata_save_drive_settings(sdinfo);
5631 			} else {
5632 				/*
5633 				 * Could not fetch new data - invalidate
5634 				 * sata_drive_info. That makes device
5635 				 * unusable.
5636 				 */
5637 				sdinfo->satadrv_type = SATA_DTYPE_UNKNOWN;
5638 				sdinfo->satadrv_state = SATA_STATE_UNKNOWN;
5639 			}
5640 		}
5641 		if (rv != 0 || sdinfo == NULL) {
5642 			/*
5643 			 * This changes the overall mode select completion
5644 			 * reason to a failed one !!!!!
5645 			 */
5646 			*scsipkt->pkt_scbp = STATUS_CHECK;
5647 			sense = sata_arq_sense(spx);
5648 			scsipkt->pkt_reason = CMD_INCOMPLETE;
5649 			rval = TRAN_ACCEPT;
5650 		}
5651 		mutex_exit(cport_mutex);
5652 	}
5653 	/* Restore the scsi pkt flags */
5654 	scsipkt->pkt_flags &= ~FLAG_NOINTR;
5655 	scsipkt->pkt_flags |= nointr_flag;
5656 
5657 	SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst,
5658 	    "Scsi_pkt completion reason %x\n", scsipkt->pkt_reason);
5659 
5660 	if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0 &&
5661 	    scsipkt->pkt_comp != NULL) {
5662 		/* scsi callback required */
5663 		if (servicing_interrupt()) {
5664 			if (taskq_dispatch(SATA_TXLT_TASKQ(spx),
5665 			    (task_func_t *)spx->txlt_scsi_pkt->pkt_comp,
5666 			    (void *)spx->txlt_scsi_pkt, TQ_NOSLEEP) ==
5667 			    TASKQID_INVALID) {
5668 				return (TRAN_BUSY);
5669 			}
5670 		} else if (taskq_dispatch(SATA_TXLT_TASKQ(spx),
5671 		    (task_func_t *)spx->txlt_scsi_pkt->pkt_comp,
5672 		    (void *)spx->txlt_scsi_pkt, TQ_SLEEP) == TASKQID_INVALID) {
5673 			/* Scheduling the callback failed */
5674 			return (TRAN_BUSY);
5675 		}
5676 	}
5677 
5678 	return (rval);
5679 }
5680 
5681 /*
5682  * Translate command: ATA Pass Through
5683  * Incomplete implementation.  Only supports No-Data, PIO Data-In, and
5684  * PIO Data-Out protocols.  Also supports CK_COND bit.
5685  *
5686  * Mapping of the incoming CDB bytes to the outgoing satacmd bytes is
5687  * described in Table 111 of SAT-2 (Draft 9).
5688  */
5689 static  int
5690 sata_txlt_ata_pass_thru(sata_pkt_txlate_t *spx)
5691 {
5692 	struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt;
5693 	sata_cmd_t *scmd = &spx->txlt_sata_pkt->satapkt_cmd;
5694 	struct buf *bp = spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp;
5695 	kmutex_t *cport_mutex = &(SATA_TXLT_CPORT_MUTEX(spx));
5696 	uint32_t xfer_len;
5697 	int extend = 0;
5698 	int synch, rval, reason;
5699 
5700 	mutex_enter(cport_mutex);
5701 
5702 	rval = sata_txlt_generic_pkt_info(spx, &reason, 1);
5703 	if ((rval != TRAN_ACCEPT) || (reason == CMD_DEV_GONE)) {
5704 		mutex_exit(cport_mutex);
5705 		return (rval);
5706 	}
5707 
5708 	/* T_DIR bit */
5709 	if (scsipkt->pkt_cdbp[2] & SATL_APT_BM_T_DIR)
5710 		scmd->satacmd_flags.sata_data_direction = SATA_DIR_READ;
5711 	else
5712 		scmd->satacmd_flags.sata_data_direction = SATA_DIR_WRITE;
5713 
5714 	/* MULTIPLE_COUNT field.  If non-zero, invalid command (for now). */
5715 	if (((scsipkt->pkt_cdbp[1] >> 5) & 0x7) != 0) {
5716 		mutex_exit(cport_mutex);
5717 		return (sata_txlt_ata_pass_thru_illegal_cmd(spx));
5718 	}
5719 
5720 	/* OFFLINE field. If non-zero, invalid command (for now). */
5721 	if (((scsipkt->pkt_cdbp[2] >> 6) & 0x3) != 0) {
5722 		mutex_exit(cport_mutex);
5723 		return (sata_txlt_ata_pass_thru_illegal_cmd(spx));
5724 	}
5725 
5726 	/* PROTOCOL field */
5727 	switch ((scsipkt->pkt_cdbp[1] >> 1) & 0xf) {
5728 	case SATL_APT_P_HW_RESET:
5729 	case SATL_APT_P_SRST:
5730 	case SATL_APT_P_DMA:
5731 	case SATL_APT_P_DMA_QUEUED:
5732 	case SATL_APT_P_DEV_DIAG:
5733 	case SATL_APT_P_DEV_RESET:
5734 	case SATL_APT_P_UDMA_IN:
5735 	case SATL_APT_P_UDMA_OUT:
5736 	case SATL_APT_P_FPDMA:
5737 	case SATL_APT_P_RET_RESP:
5738 		/* Not yet implemented */
5739 	default:
5740 		mutex_exit(cport_mutex);
5741 		return (sata_txlt_ata_pass_thru_illegal_cmd(spx));
5742 
5743 	case SATL_APT_P_NON_DATA:
5744 		scmd->satacmd_flags.sata_data_direction = SATA_DIR_NODATA_XFER;
5745 		break;
5746 
5747 	case SATL_APT_P_PIO_DATA_IN:
5748 		/* If PROTOCOL disagrees with T_DIR, invalid command */
5749 		if (scmd->satacmd_flags.sata_data_direction == SATA_DIR_WRITE) {
5750 			mutex_exit(cport_mutex);
5751 			return (sata_txlt_ata_pass_thru_illegal_cmd(spx));
5752 		}
5753 
5754 		/* if there is a buffer, release its DMA resources */
5755 		if ((bp != NULL) && bp->b_un.b_addr && bp->b_bcount) {
5756 			sata_scsi_dmafree(NULL, scsipkt);
5757 		} else {
5758 			/* if there is no buffer, how do you PIO in? */
5759 			mutex_exit(cport_mutex);
5760 			return (sata_txlt_ata_pass_thru_illegal_cmd(spx));
5761 		}
5762 
5763 		break;
5764 
5765 	case SATL_APT_P_PIO_DATA_OUT:
5766 		/* If PROTOCOL disagrees with T_DIR, invalid command */
5767 		if (scmd->satacmd_flags.sata_data_direction == SATA_DIR_READ) {
5768 			mutex_exit(cport_mutex);
5769 			return (sata_txlt_ata_pass_thru_illegal_cmd(spx));
5770 		}
5771 
5772 		/* if there is a buffer, release its DMA resources */
5773 		if ((bp != NULL) && bp->b_un.b_addr && bp->b_bcount) {
5774 			sata_scsi_dmafree(NULL, scsipkt);
5775 		} else {
5776 			/* if there is no buffer, how do you PIO out? */
5777 			mutex_exit(cport_mutex);
5778 			return (sata_txlt_ata_pass_thru_illegal_cmd(spx));
5779 		}
5780 
5781 		break;
5782 	}
5783 
5784 	/* Assume LBA28 by default */
5785 	scmd->satacmd_addr_type = ATA_ADDR_LBA28;
5786 	scmd->satacmd_lba_low_msb = 0;
5787 	scmd->satacmd_lba_mid_msb = 0;
5788 	scmd->satacmd_lba_high_msb = 0;
5789 
5790 	scmd->satacmd_features_reg_ext = 0;
5791 	scmd->satacmd_sec_count_msb = 0;
5792 
5793 	/* Parse the ATA cmd fields, transfer some straight to the satacmd */
5794 	switch ((uint_t)scsipkt->pkt_cdbp[0]) {
5795 	case SPC3_CMD_ATA_COMMAND_PASS_THROUGH12:
5796 		scmd->satacmd_lba_low_lsb = scsipkt->pkt_cdbp[5];
5797 		scmd->satacmd_lba_mid_lsb = scsipkt->pkt_cdbp[6];
5798 		scmd->satacmd_lba_high_lsb = scsipkt->pkt_cdbp[7];
5799 
5800 		scmd->satacmd_features_reg = scsipkt->pkt_cdbp[3];
5801 		scmd->satacmd_sec_count_lsb = scsipkt->pkt_cdbp[4];
5802 
5803 		scmd->satacmd_device_reg = scsipkt->pkt_cdbp[8];
5804 		scmd->satacmd_cmd_reg = scsipkt->pkt_cdbp[9];
5805 		break;
5806 
5807 	case SPC3_CMD_ATA_COMMAND_PASS_THROUGH16:
5808 		scmd->satacmd_device_reg = scsipkt->pkt_cdbp[13];
5809 		scmd->satacmd_cmd_reg = scsipkt->pkt_cdbp[14];
5810 
5811 		scmd->satacmd_lba_low_lsb = scsipkt->pkt_cdbp[8];
5812 		scmd->satacmd_lba_mid_lsb = scsipkt->pkt_cdbp[10];
5813 		scmd->satacmd_lba_high_lsb = scsipkt->pkt_cdbp[12];
5814 
5815 		scmd->satacmd_features_reg = scsipkt->pkt_cdbp[4];
5816 		scmd->satacmd_sec_count_lsb = scsipkt->pkt_cdbp[6];
5817 
5818 		if (scsipkt->pkt_cdbp[1] & SATL_APT_BM_EXTEND) {
5819 			extend = 1;
5820 
5821 			scmd->satacmd_addr_type = ATA_ADDR_LBA48;
5822 			scmd->satacmd_lba_low_msb = scsipkt->pkt_cdbp[7];
5823 			scmd->satacmd_lba_mid_msb = scsipkt->pkt_cdbp[9];
5824 			scmd->satacmd_lba_high_msb = scsipkt->pkt_cdbp[11];
5825 
5826 			scmd->satacmd_features_reg_ext = scsipkt->pkt_cdbp[3];
5827 			scmd->satacmd_sec_count_msb = scsipkt->pkt_cdbp[5];
5828 		}
5829 		break;
5830 
5831 	default:
5832 		/* No other SCSI ops should ever reach this function */
5833 		cmn_err(CE_PANIC, "unexpected ATA pass-thru cmd %x",
5834 		    scsipkt->pkt_cdbp[0]);
5835 	}
5836 
5837 	/* CK_COND bit */
5838 	if (scsipkt->pkt_cdbp[2] & SATL_APT_BM_CK_COND) {
5839 		if (extend) {
5840 			scmd->satacmd_flags.sata_copy_out_sec_count_msb = 1;
5841 			scmd->satacmd_flags.sata_copy_out_lba_low_msb = 1;
5842 			scmd->satacmd_flags.sata_copy_out_lba_mid_msb = 1;
5843 			scmd->satacmd_flags.sata_copy_out_lba_high_msb = 1;
5844 		}
5845 
5846 		scmd->satacmd_flags.sata_copy_out_sec_count_lsb = 1;
5847 		scmd->satacmd_flags.sata_copy_out_lba_low_lsb = 1;
5848 		scmd->satacmd_flags.sata_copy_out_lba_mid_lsb = 1;
5849 		scmd->satacmd_flags.sata_copy_out_lba_high_lsb = 1;
5850 		scmd->satacmd_flags.sata_copy_out_device_reg = 1;
5851 		scmd->satacmd_flags.sata_copy_out_error_reg = 1;
5852 	}
5853 
5854 	/* Determine transfer length */
5855 	switch (scsipkt->pkt_cdbp[2] & 0x03) {		/* T_LENGTH field */
5856 	case 1:
5857 		/* Length is in the FEATURE field */
5858 		xfer_len = (uint32_t)scmd->satacmd_features_reg_ext << 8 |
5859 		    scmd->satacmd_features_reg;
5860 
5861 		/* If BYTE_BLOCK is set, above value is in units of blocks */
5862 		if (((scsipkt->pkt_cdbp[2] >> 2) & 1) == 0)
5863 			xfer_len *= SATA_DISK_SECTOR_SIZE;
5864 		break;
5865 	case 2:
5866 		/* Length is in the COUNT field */
5867 		xfer_len = (uint32_t)scmd->satacmd_sec_count_msb << 8 |
5868 		    scmd->satacmd_sec_count_lsb;
5869 
5870 		/* If BYTE_BLOCK is set, above value is in units of blocks */
5871 		if (((scsipkt->pkt_cdbp[2] >> 2) & 1) == 0)
5872 			xfer_len *= SATA_DISK_SECTOR_SIZE;
5873 		break;
5874 	case 3:
5875 		/*
5876 		 * Length is transport specific. The spec is a bit vague on
5877 		 * this, but it seems like using buf->b_bcount is the most
5878 		 * reasonable analogue in our situation. b_bcount is in
5879 		 * units of bytes.
5880 		 */
5881 		xfer_len = bp->b_bcount;
5882 		break;
5883 	default:
5884 		xfer_len = 0;
5885 	}
5886 
5887 	/* Don't allow a transfer larger than what the struct buf supports */
5888 	if (xfer_len > bp->b_bcount) {
5889 		mutex_exit(cport_mutex);
5890 		return (sata_txlt_ata_pass_thru_illegal_cmd(spx));
5891 	}
5892 
5893 	/* Start processing command */
5894 	if (!(spx->txlt_sata_pkt->satapkt_op_mode & SATA_OPMODE_SYNCH)) {
5895 		spx->txlt_sata_pkt->satapkt_comp = sata_txlt_apt_completion;
5896 		synch = FALSE;
5897 	} else {
5898 		synch = TRUE;
5899 	}
5900 
5901 	if (sata_hba_start(spx, &rval) != 0) {
5902 		mutex_exit(cport_mutex);
5903 		return (rval);
5904 	}
5905 
5906 	mutex_exit(cport_mutex);
5907 
5908 	if (synch) {
5909 		sata_txlt_apt_completion(spx->txlt_sata_pkt);
5910 	}
5911 
5912 	return (TRAN_ACCEPT);
5913 }
5914 
5915 /*
5916  * Translate command: Log Sense
5917  */
5918 static int
5919 sata_txlt_log_sense(sata_pkt_txlate_t *spx)
5920 {
5921 	struct scsi_pkt	*scsipkt = spx->txlt_scsi_pkt;
5922 	struct buf	*bp = spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp;
5923 	sata_drive_info_t *sdinfo;
5924 	struct scsi_extended_sense *sense;
5925 	int		len, count, alc_len;
5926 	int		pc;	/* Page Control code */
5927 	int		page_code;	/* Page code */
5928 	uint8_t		*buf;	/* log sense buffer */
5929 	int		rval, reason;
5930 #define	MAX_LOG_SENSE_PAGE_SIZE	512
5931 	kmutex_t	*cport_mutex = &(SATA_TXLT_CPORT_MUTEX(spx));
5932 
5933 	SATADBG2(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst,
5934 	    "sata_txlt_log_sense, pc 0x%x, page code 0x%x\n",
5935 	    spx->txlt_scsi_pkt->pkt_cdbp[2] >> 6,
5936 	    spx->txlt_scsi_pkt->pkt_cdbp[2] & 0x3f);
5937 
5938 	if (servicing_interrupt()) {
5939 		buf = kmem_zalloc(MAX_LOG_SENSE_PAGE_SIZE, KM_NOSLEEP);
5940 		if (buf == NULL) {
5941 			return (TRAN_BUSY);
5942 		}
5943 	} else {
5944 		buf = kmem_zalloc(MAX_LOG_SENSE_PAGE_SIZE, KM_SLEEP);
5945 	}
5946 
5947 	mutex_enter(cport_mutex);
5948 
5949 	if (((rval = sata_txlt_generic_pkt_info(spx, &reason, 1)) !=
5950 	    TRAN_ACCEPT) || (reason == CMD_DEV_GONE)) {
5951 		mutex_exit(cport_mutex);
5952 		kmem_free(buf, MAX_LOG_SENSE_PAGE_SIZE);
5953 		return (rval);
5954 	}
5955 
5956 	scsipkt->pkt_reason = CMD_CMPLT;
5957 	scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET |
5958 	    STATE_SENT_CMD | STATE_GOT_STATUS;
5959 
5960 	pc = scsipkt->pkt_cdbp[2] >> 6;
5961 	page_code = scsipkt->pkt_cdbp[2] & 0x3f;
5962 
5963 	/* Reject not supported request for all but cumulative values */
5964 	switch (pc) {
5965 	case PC_CUMULATIVE_VALUES:
5966 		break;
5967 	default:
5968 		*scsipkt->pkt_scbp = STATUS_CHECK;
5969 		sense = sata_arq_sense(spx);
5970 		sense->es_key = KEY_ILLEGAL_REQUEST;
5971 		sense->es_add_code = SD_SCSI_ASC_INVALID_FIELD_IN_CDB;
5972 		goto done;
5973 	}
5974 
5975 	switch (page_code) {
5976 	case PAGE_CODE_GET_SUPPORTED_LOG_PAGES:
5977 	case PAGE_CODE_SELF_TEST_RESULTS:
5978 	case PAGE_CODE_INFORMATION_EXCEPTIONS:
5979 	case PAGE_CODE_SMART_READ_DATA:
5980 	case PAGE_CODE_START_STOP_CYCLE_COUNTER:
5981 	case PAGE_CODE_TEMPERATURE:
5982 	case PAGE_CODE_SOLID_STATE_MEDIA:
5983 	case PAGE_CODE_READ_ERRORS:
5984 	case PAGE_CODE_GENERAL_STATS:
5985 		break;
5986 	default:
5987 		*scsipkt->pkt_scbp = STATUS_CHECK;
5988 		sense = sata_arq_sense(spx);
5989 		sense->es_key = KEY_ILLEGAL_REQUEST;
5990 		sense->es_add_code = SD_SCSI_ASC_INVALID_FIELD_IN_CDB;
5991 		goto done;
5992 	}
5993 
5994 	if (bp != NULL && bp->b_un.b_addr && bp->b_bcount) {
5995 		/*
5996 		 * Because log sense uses local buffers for data retrieval from
5997 		 * the devices and sets the data programatically in the
5998 		 * original specified buffer, release preallocated DMA
5999 		 * resources before storing data in the original buffer,
6000 		 * so no unwanted DMA sync would take place.
6001 		 */
6002 		sata_id_t *sata_id;
6003 
6004 		sata_scsi_dmafree(NULL, scsipkt);
6005 
6006 		len = 0;
6007 
6008 		/* Build log parameter header */
6009 		buf[len++] = page_code;	/* page code as in the CDB */
6010 		buf[len++] = 0;		/* reserved */
6011 		buf[len++] = 0;		/* Zero out page length for now (MSB) */
6012 		buf[len++] = 0;		/* (LSB) */
6013 
6014 		sdinfo = sata_get_device_info(
6015 		    spx->txlt_sata_hba_inst,
6016 		    &spx->txlt_sata_pkt->satapkt_device);
6017 
6018 		sata_id = &sdinfo->satadrv_id;
6019 
6020 		/*
6021 		 * Add requested pages.
6022 		 */
6023 		switch (page_code) {
6024 		case PAGE_CODE_GET_SUPPORTED_LOG_PAGES:
6025 			len = sata_build_lsense_page_0(sdinfo, buf + len);
6026 			break;
6027 		case PAGE_CODE_SELF_TEST_RESULTS:
6028 			if ((! (sata_id->ai_cmdset84 &
6029 			    SATA_SMART_SELF_TEST_SUPPORTED)) ||
6030 			    (! (sata_id->ai_features87 &
6031 			    SATA_SMART_SELF_TEST_SUPPORTED))) {
6032 				*scsipkt->pkt_scbp = STATUS_CHECK;
6033 				sense = sata_arq_sense(spx);
6034 				sense->es_key = KEY_ILLEGAL_REQUEST;
6035 				sense->es_add_code =
6036 				    SD_SCSI_ASC_INVALID_FIELD_IN_CDB;
6037 
6038 				goto done;
6039 			}
6040 			len = sata_build_lsense_page_10(sdinfo, buf + len,
6041 			    spx->txlt_sata_hba_inst);
6042 			break;
6043 		case PAGE_CODE_INFORMATION_EXCEPTIONS:
6044 			if (! (sata_id->ai_cmdset82 & SATA_SMART_SUPPORTED)) {
6045 				*scsipkt->pkt_scbp = STATUS_CHECK;
6046 				sense = sata_arq_sense(spx);
6047 				sense->es_key = KEY_ILLEGAL_REQUEST;
6048 				sense->es_add_code =
6049 				    SD_SCSI_ASC_INVALID_FIELD_IN_CDB;
6050 
6051 				goto done;
6052 			}
6053 			if (! (sata_id->ai_features85 & SATA_SMART_ENABLED)) {
6054 				*scsipkt->pkt_scbp = STATUS_CHECK;
6055 				sense = sata_arq_sense(spx);
6056 				sense->es_key = KEY_ABORTED_COMMAND;
6057 				sense->es_add_code =
6058 				    SCSI_ASC_ATA_DEV_FEAT_NOT_ENABLED;
6059 				sense->es_qual_code =
6060 				    SCSI_ASCQ_ATA_DEV_FEAT_NOT_ENABLED;
6061 
6062 				goto done;
6063 			}
6064 
6065 			len = sata_build_lsense_page_2f(sdinfo, buf + len,
6066 			    spx->txlt_sata_hba_inst);
6067 			break;
6068 		case PAGE_CODE_SMART_READ_DATA:
6069 			if (! (sata_id->ai_cmdset82 & SATA_SMART_SUPPORTED)) {
6070 				*scsipkt->pkt_scbp = STATUS_CHECK;
6071 				sense = sata_arq_sense(spx);
6072 				sense->es_key = KEY_ILLEGAL_REQUEST;
6073 				sense->es_add_code =
6074 				    SD_SCSI_ASC_INVALID_FIELD_IN_CDB;
6075 
6076 				goto done;
6077 			}
6078 			if (! (sata_id->ai_features85 & SATA_SMART_ENABLED)) {
6079 				*scsipkt->pkt_scbp = STATUS_CHECK;
6080 				sense = sata_arq_sense(spx);
6081 				sense->es_key = KEY_ABORTED_COMMAND;
6082 				sense->es_add_code =
6083 				    SCSI_ASC_ATA_DEV_FEAT_NOT_ENABLED;
6084 				sense->es_qual_code =
6085 				    SCSI_ASCQ_ATA_DEV_FEAT_NOT_ENABLED;
6086 
6087 				goto done;
6088 			}
6089 
6090 			/* This page doesn't include a page header */
6091 			len = sata_build_lsense_page_30(sdinfo, buf,
6092 			    spx->txlt_sata_hba_inst);
6093 			goto no_header;
6094 		case PAGE_CODE_START_STOP_CYCLE_COUNTER:
6095 			if (! (sata_id->ai_cmdset82 & SATA_SMART_SUPPORTED)) {
6096 				*scsipkt->pkt_scbp = STATUS_CHECK;
6097 				sense = sata_arq_sense(spx);
6098 				sense->es_key = KEY_ILLEGAL_REQUEST;
6099 				sense->es_add_code =
6100 				    SD_SCSI_ASC_INVALID_FIELD_IN_CDB;
6101 
6102 				goto done;
6103 			}
6104 			if (! (sata_id->ai_features85 & SATA_SMART_ENABLED)) {
6105 				*scsipkt->pkt_scbp = STATUS_CHECK;
6106 				sense = sata_arq_sense(spx);
6107 				sense->es_key = KEY_ABORTED_COMMAND;
6108 				sense->es_add_code =
6109 				    SCSI_ASC_ATA_DEV_FEAT_NOT_ENABLED;
6110 				sense->es_qual_code =
6111 				    SCSI_ASCQ_ATA_DEV_FEAT_NOT_ENABLED;
6112 
6113 				goto done;
6114 			}
6115 			len = sata_build_lsense_page_0e(sdinfo, buf, spx);
6116 			goto no_header;
6117 		case PAGE_CODE_TEMPERATURE:
6118 			len = sata_build_lsense_page_0d(sdinfo, buf + len,
6119 			    spx->txlt_sata_hba_inst);
6120 			break;
6121 		case PAGE_CODE_SOLID_STATE_MEDIA:
6122 			len = sata_build_lsense_page_11(sdinfo, buf + len,
6123 			    spx->txlt_sata_hba_inst);
6124 			break;
6125 		case PAGE_CODE_READ_ERRORS:
6126 			len = sata_build_lsense_page_03(sdinfo, buf + len,
6127 			    spx->txlt_sata_hba_inst);
6128 			break;
6129 		case PAGE_CODE_GENERAL_STATS:
6130 			len = sata_build_lsense_page_19(sdinfo, buf + len,
6131 			    spx->txlt_sata_hba_inst);
6132 			break;
6133 		default:
6134 			/* Invalid request */
6135 			*scsipkt->pkt_scbp = STATUS_CHECK;
6136 			sense = sata_arq_sense(spx);
6137 			sense->es_key = KEY_ILLEGAL_REQUEST;
6138 			sense->es_add_code = SD_SCSI_ASC_INVALID_FIELD_IN_CDB;
6139 			goto done;
6140 		}
6141 
6142 		if (len < 0) {
6143 			/* Page not supported by device */
6144 			*scsipkt->pkt_scbp = STATUS_CHECK;
6145 			sense = sata_arq_sense(spx);
6146 			sense->es_key = KEY_ILLEGAL_REQUEST;
6147 			sense->es_add_code = SD_SCSI_ASC_INVALID_FIELD_IN_CDB;
6148 			goto done;
6149 		}
6150 
6151 		/* set parameter log sense data length */
6152 		buf[2] = len >> 8;	/* log sense length (MSB) */
6153 		buf[3] = len & 0xff;	/* log sense length (LSB) */
6154 
6155 		len += SCSI_LOG_PAGE_HDR_LEN;
6156 		ASSERT(len <= MAX_LOG_SENSE_PAGE_SIZE);
6157 
6158 no_header:
6159 		/* Check allocation length */
6160 		alc_len = scsipkt->pkt_cdbp[7];
6161 		alc_len = (alc_len << 8) | scsipkt->pkt_cdbp[8];
6162 
6163 		/*
6164 		 * We do not check for possible parameters truncation
6165 		 * (alc_len < len) assuming that the target driver works
6166 		 * correctly. Just avoiding overrun.
6167 		 * Copy no more than requested and possible, buffer-wise.
6168 		 */
6169 		count = MIN(alc_len, len);
6170 		count = MIN(bp->b_bcount, count);
6171 		bcopy(buf, bp->b_un.b_addr, count);
6172 
6173 		scsipkt->pkt_state |= STATE_XFERRED_DATA;
6174 		scsipkt->pkt_resid = alc_len > count ? alc_len - count : 0;
6175 	}
6176 	*scsipkt->pkt_scbp = STATUS_GOOD;
6177 done:
6178 	mutex_exit(cport_mutex);
6179 	(void) kmem_free(buf, MAX_LOG_SENSE_PAGE_SIZE);
6180 
6181 	SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst,
6182 	    "Scsi_pkt completion reason %x\n", scsipkt->pkt_reason);
6183 
6184 	if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0 &&
6185 	    scsipkt->pkt_comp != NULL) {
6186 		/* scsi callback required */
6187 		if (servicing_interrupt()) {
6188 			if (taskq_dispatch(SATA_TXLT_TASKQ(spx),
6189 			    (task_func_t *)spx->txlt_scsi_pkt->pkt_comp,
6190 			    (void *)spx->txlt_scsi_pkt, TQ_NOSLEEP) ==
6191 			    TASKQID_INVALID) {
6192 				return (TRAN_BUSY);
6193 			}
6194 		} else if (taskq_dispatch(SATA_TXLT_TASKQ(spx),
6195 		    (task_func_t *)spx->txlt_scsi_pkt->pkt_comp,
6196 		    (void *)spx->txlt_scsi_pkt, TQ_SLEEP) == TASKQID_INVALID) {
6197 			/* Scheduling the callback failed */
6198 			return (TRAN_BUSY);
6199 		}
6200 	}
6201 
6202 	return (TRAN_ACCEPT);
6203 }
6204 
6205 /*
6206  * Translate command: Log Select
6207  * Not implemented at this time - returns invalid command response.
6208  */
6209 static	int
6210 sata_txlt_log_select(sata_pkt_txlate_t *spx)
6211 {
6212 	SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst,
6213 	    "sata_txlt_log_select\n", NULL);
6214 
6215 	return (sata_txlt_invalid_command(spx));
6216 }
6217 
6218 
6219 /*
6220  * Translate command: Read (various types).
6221  * Translated into appropriate type of ATA READ command
6222  * for SATA hard disks.
6223  * Both the device capabilities and requested operation mode are
6224  * considered.
6225  *
6226  * Following scsi cdb fields are ignored:
6227  * rdprotect, dpo, fua, fua_nv, group_number.
6228  *
6229  * If SATA_ENABLE_QUEUING flag is set (in the global SATA HBA framework
6230  * enable variable sata_func_enable), the capability of the controller and
6231  * capability of a device are checked and if both support queueing, read
6232  * request will be translated to READ_DMA_QUEUEING or READ_DMA_QUEUEING_EXT
6233  * command rather than plain READ_XXX command.
6234  * If SATA_ENABLE_NCQ flag is set in addition to SATA_ENABLE_QUEUING flag and
6235  * both the controller and device suport such functionality, the read
6236  * request will be translated to READ_FPDMA_QUEUED command.
6237  * In both cases the maximum queue depth is derived as minimum of:
6238  * HBA capability,device capability and sata_max_queue_depth variable setting.
6239  * The value passed to HBA driver is decremented by 1, because only 5 bits are
6240  * used to pass max queue depth value, and the maximum possible queue depth
6241  * is 32.
6242  *
6243  * Returns TRAN_ACCEPT or code returned by sata_hba_start() and
6244  * appropriate values in scsi_pkt fields.
6245  */
6246 static int
6247 sata_txlt_read(sata_pkt_txlate_t *spx)
6248 {
6249 	struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt;
6250 	sata_cmd_t *scmd = &spx->txlt_sata_pkt->satapkt_cmd;
6251 	sata_drive_info_t *sdinfo;
6252 	sata_hba_inst_t *shi = SATA_TXLT_HBA_INST(spx);
6253 	kmutex_t *cport_mutex = &(SATA_TXLT_CPORT_MUTEX(spx));
6254 	uint16_t sec_count;
6255 	uint64_t lba;
6256 	int rval, reason;
6257 	int synch;
6258 
6259 	mutex_enter(cport_mutex);
6260 
6261 	if (((rval = sata_txlt_generic_pkt_info(spx, &reason, 0)) !=
6262 	    TRAN_ACCEPT) || (reason == CMD_DEV_GONE)) {
6263 		mutex_exit(cport_mutex);
6264 		return (rval);
6265 	}
6266 
6267 	sdinfo = sata_get_device_info(spx->txlt_sata_hba_inst,
6268 	    &spx->txlt_sata_pkt->satapkt_device);
6269 
6270 	scmd->satacmd_flags.sata_data_direction = SATA_DIR_READ;
6271 	/*
6272 	 * Extract LBA and sector count from scsi CDB.
6273 	 */
6274 	switch ((uint_t)scsipkt->pkt_cdbp[0]) {
6275 	case SCMD_READ:
6276 		/* 6-byte scsi read cmd : 0x08 */
6277 		lba = (scsipkt->pkt_cdbp[1] & 0x1f);
6278 		lba = (lba << 8) | scsipkt->pkt_cdbp[2];
6279 		lba = (lba << 8) | scsipkt->pkt_cdbp[3];
6280 		sec_count = scsipkt->pkt_cdbp[4];
6281 		/* sec_count 0 will be interpreted as 256 by a device */
6282 		break;
6283 	case SCMD_READ_G1:
6284 		/* 10-bytes scsi read command : 0x28 */
6285 		lba = scsipkt->pkt_cdbp[2];
6286 		lba = (lba << 8) | scsipkt->pkt_cdbp[3];
6287 		lba = (lba << 8) | scsipkt->pkt_cdbp[4];
6288 		lba = (lba << 8) | scsipkt->pkt_cdbp[5];
6289 		sec_count = scsipkt->pkt_cdbp[7];
6290 		sec_count = (sec_count << 8) | scsipkt->pkt_cdbp[8];
6291 		break;
6292 	case SCMD_READ_G5:
6293 		/* 12-bytes scsi read command : 0xA8 */
6294 		lba = scsipkt->pkt_cdbp[2];
6295 		lba = (lba << 8) | scsipkt->pkt_cdbp[3];
6296 		lba = (lba << 8) | scsipkt->pkt_cdbp[4];
6297 		lba = (lba << 8) | scsipkt->pkt_cdbp[5];
6298 		sec_count = scsipkt->pkt_cdbp[6];
6299 		sec_count = (sec_count << 8) | scsipkt->pkt_cdbp[7];
6300 		sec_count = (sec_count << 8) | scsipkt->pkt_cdbp[8];
6301 		sec_count = (sec_count << 8) | scsipkt->pkt_cdbp[9];
6302 		break;
6303 	case SCMD_READ_G4:
6304 		/* 16-bytes scsi read command : 0x88 */
6305 		lba = scsipkt->pkt_cdbp[2];
6306 		lba = (lba << 8) | scsipkt->pkt_cdbp[3];
6307 		lba = (lba << 8) | scsipkt->pkt_cdbp[4];
6308 		lba = (lba << 8) | scsipkt->pkt_cdbp[5];
6309 		lba = (lba << 8) | scsipkt->pkt_cdbp[6];
6310 		lba = (lba << 8) | scsipkt->pkt_cdbp[7];
6311 		lba = (lba << 8) | scsipkt->pkt_cdbp[8];
6312 		lba = (lba << 8) | scsipkt->pkt_cdbp[9];
6313 		sec_count = scsipkt->pkt_cdbp[10];
6314 		sec_count = (sec_count << 8) | scsipkt->pkt_cdbp[11];
6315 		sec_count = (sec_count << 8) | scsipkt->pkt_cdbp[12];
6316 		sec_count = (sec_count << 8) | scsipkt->pkt_cdbp[13];
6317 		break;
6318 	default:
6319 		/* Unsupported command */
6320 		mutex_exit(cport_mutex);
6321 		return (sata_txlt_invalid_command(spx));
6322 	}
6323 
6324 	/*
6325 	 * Check if specified address exceeds device capacity
6326 	 */
6327 	if ((lba >= sdinfo->satadrv_capacity) ||
6328 	    ((lba + sec_count) > sdinfo->satadrv_capacity)) {
6329 		/* LBA out of range */
6330 		mutex_exit(cport_mutex);
6331 		return (sata_txlt_lba_out_of_range(spx));
6332 	}
6333 
6334 	/*
6335 	 * For zero-length transfer, emulate good completion of the command
6336 	 * (reasons for rejecting the command were already checked).
6337 	 * No DMA resources were allocated.
6338 	 */
6339 	if (spx->txlt_dma_cookie_list == NULL) {
6340 		mutex_exit(cport_mutex);
6341 		return (sata_emul_rw_completion(spx));
6342 	}
6343 
6344 	/*
6345 	 * Build cmd block depending on the device capability and
6346 	 * requested operation mode.
6347 	 * Do not bother with non-dma mode - we are working only with
6348 	 * devices supporting DMA.
6349 	 */
6350 	scmd->satacmd_addr_type = ATA_ADDR_LBA;
6351 	scmd->satacmd_device_reg = SATA_ADH_LBA;
6352 	scmd->satacmd_cmd_reg = SATAC_READ_DMA;
6353 	if (sdinfo->satadrv_features_support & SATA_DEV_F_LBA48) {
6354 		scmd->satacmd_addr_type = ATA_ADDR_LBA48;
6355 		scmd->satacmd_cmd_reg = SATAC_READ_DMA_EXT;
6356 		scmd->satacmd_sec_count_msb = sec_count >> 8;
6357 #ifndef __lock_lint
6358 		scmd->satacmd_lba_low_msb = (lba >> 24) & 0xff;
6359 		scmd->satacmd_lba_mid_msb = (lba >> 32) & 0xff;
6360 		scmd->satacmd_lba_high_msb = lba >> 40;
6361 #endif
6362 	} else if (sdinfo->satadrv_features_support & SATA_DEV_F_LBA28) {
6363 		scmd->satacmd_addr_type = ATA_ADDR_LBA28;
6364 		scmd->satacmd_device_reg = SATA_ADH_LBA | ((lba >> 24) & 0xf);
6365 	}
6366 	scmd->satacmd_sec_count_lsb = sec_count & 0xff;
6367 	scmd->satacmd_lba_low_lsb = lba & 0xff;
6368 	scmd->satacmd_lba_mid_lsb = (lba >> 8) & 0xff;
6369 	scmd->satacmd_lba_high_lsb = (lba >> 16) & 0xff;
6370 	scmd->satacmd_features_reg = 0;
6371 	scmd->satacmd_status_reg = 0;
6372 	scmd->satacmd_error_reg = 0;
6373 
6374 	/*
6375 	 * Check if queueing commands should be used and switch
6376 	 * to appropriate command if possible
6377 	 */
6378 	if (sata_func_enable & SATA_ENABLE_QUEUING) {
6379 		boolean_t using_queuing;
6380 
6381 		/* Queuing supported by controller and device? */
6382 		if ((sata_func_enable & SATA_ENABLE_NCQ) &&
6383 		    (sdinfo->satadrv_features_support &
6384 		    SATA_DEV_F_NCQ) &&
6385 		    (SATA_FEATURES(spx->txlt_sata_hba_inst) &
6386 		    SATA_CTLF_NCQ)) {
6387 			using_queuing = B_TRUE;
6388 
6389 			/* NCQ supported - use FPDMA READ */
6390 			scmd->satacmd_cmd_reg =
6391 			    SATAC_READ_FPDMA_QUEUED;
6392 			scmd->satacmd_features_reg_ext =
6393 			    scmd->satacmd_sec_count_msb;
6394 			scmd->satacmd_sec_count_msb = 0;
6395 		} else if ((sdinfo->satadrv_features_support &
6396 		    SATA_DEV_F_TCQ) &&
6397 		    (SATA_FEATURES(spx->txlt_sata_hba_inst) &
6398 		    SATA_CTLF_QCMD)) {
6399 			using_queuing = B_TRUE;
6400 
6401 			/* Legacy queueing */
6402 			if (sdinfo->satadrv_features_support &
6403 			    SATA_DEV_F_LBA48) {
6404 				scmd->satacmd_cmd_reg =
6405 				    SATAC_READ_DMA_QUEUED_EXT;
6406 				scmd->satacmd_features_reg_ext =
6407 				    scmd->satacmd_sec_count_msb;
6408 				scmd->satacmd_sec_count_msb = 0;
6409 			} else {
6410 				scmd->satacmd_cmd_reg =
6411 				    SATAC_READ_DMA_QUEUED;
6412 			}
6413 		} else	/* NCQ nor legacy queuing not supported */
6414 			using_queuing = B_FALSE;
6415 
6416 		/*
6417 		 * If queuing, the sector count goes in the features register
6418 		 * and the secount count will contain the tag.
6419 		 */
6420 		if (using_queuing) {
6421 			scmd->satacmd_features_reg =
6422 			    scmd->satacmd_sec_count_lsb;
6423 			scmd->satacmd_sec_count_lsb = 0;
6424 			scmd->satacmd_flags.sata_queued = B_TRUE;
6425 
6426 			/* Set-up maximum queue depth */
6427 			scmd->satacmd_flags.sata_max_queue_depth =
6428 			    sdinfo->satadrv_max_queue_depth - 1;
6429 		} else if (sdinfo->satadrv_features_enabled &
6430 		    SATA_DEV_F_E_UNTAGGED_QING) {
6431 			/*
6432 			 * Although NCQ/TCQ is not enabled, untagged queuing
6433 			 * may be still used.
6434 			 * Set-up the maximum untagged queue depth.
6435 			 * Use controller's queue depth from sata_hba_tran.
6436 			 * SATA HBA drivers may ignore this value and rely on
6437 			 * the internal limits.For drivers that do not
6438 			 * ignore untaged queue depth, limit the value to
6439 			 * SATA_MAX_QUEUE_DEPTH (32), as this is the
6440 			 * largest value that can be passed via
6441 			 * satacmd_flags.sata_max_queue_depth.
6442 			 */
6443 			scmd->satacmd_flags.sata_max_queue_depth =
6444 			    SATA_QDEPTH(shi) <= SATA_MAX_QUEUE_DEPTH ?
6445 			    SATA_QDEPTH(shi) - 1: SATA_MAX_QUEUE_DEPTH - 1;
6446 
6447 		} else {
6448 			scmd->satacmd_flags.sata_max_queue_depth = 0;
6449 		}
6450 	} else
6451 		scmd->satacmd_flags.sata_max_queue_depth = 0;
6452 
6453 	SATADBG3(SATA_DBG_HBA_IF, spx->txlt_sata_hba_inst,
6454 	    "sata_txlt_read cmd 0x%2x, lba %llx, sec count %x\n",
6455 	    scmd->satacmd_cmd_reg, lba, sec_count);
6456 
6457 	if (!(spx->txlt_sata_pkt->satapkt_op_mode & SATA_OPMODE_SYNCH)) {
6458 		/* Need callback function */
6459 		spx->txlt_sata_pkt->satapkt_comp = sata_txlt_rw_completion;
6460 		synch = FALSE;
6461 	} else
6462 		synch = TRUE;
6463 
6464 	/* Transfer command to HBA */
6465 	if (sata_hba_start(spx, &rval) != 0) {
6466 		/* Pkt not accepted for execution */
6467 		mutex_exit(cport_mutex);
6468 		return (rval);
6469 	}
6470 	mutex_exit(cport_mutex);
6471 	/*
6472 	 * If execution is non-synchronous,
6473 	 * a callback function will handle potential errors, translate
6474 	 * the response and will do a callback to a target driver.
6475 	 * If it was synchronous, check execution status using the same
6476 	 * framework callback.
6477 	 */
6478 	if (synch) {
6479 		SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst,
6480 		    "synchronous execution status %x\n",
6481 		    spx->txlt_sata_pkt->satapkt_reason);
6482 		sata_txlt_rw_completion(spx->txlt_sata_pkt);
6483 	}
6484 	return (TRAN_ACCEPT);
6485 }
6486 
6487 
6488 /*
6489  * SATA translate command: Write (various types)
6490  * Translated into appropriate type of ATA WRITE command
6491  * for SATA hard disks.
6492  * Both the device capabilities and requested operation mode are
6493  * considered.
6494  *
6495  * Following scsi cdb fields are ignored:
6496  * rwprotect, dpo, fua, fua_nv, group_number.
6497  *
6498  * If SATA_ENABLE_QUEUING flag is set (in the global SATA HBA framework
6499  * enable variable sata_func_enable), the capability of the controller and
6500  * capability of a device are checked and if both support queueing, write
6501  * request will be translated to WRITE_DMA_QUEUEING or WRITE_DMA_QUEUEING_EXT
6502  * command rather than plain WRITE_XXX command.
6503  * If SATA_ENABLE_NCQ flag is set in addition to SATA_ENABLE_QUEUING flag and
6504  * both the controller and device suport such functionality, the write
6505  * request will be translated to WRITE_FPDMA_QUEUED command.
6506  * In both cases the maximum queue depth is derived as minimum of:
6507  * HBA capability,device capability and sata_max_queue_depth variable setting.
6508  * The value passed to HBA driver is decremented by 1, because only 5 bits are
6509  * used to pass max queue depth value, and the maximum possible queue depth
6510  * is 32.
6511  *
6512  * Returns TRAN_ACCEPT or code returned by sata_hba_start() and
6513  * appropriate values in scsi_pkt fields.
6514  */
6515 static int
6516 sata_txlt_write(sata_pkt_txlate_t *spx)
6517 {
6518 	struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt;
6519 	sata_cmd_t *scmd = &spx->txlt_sata_pkt->satapkt_cmd;
6520 	sata_drive_info_t *sdinfo;
6521 	sata_hba_inst_t *shi = SATA_TXLT_HBA_INST(spx);
6522 	uint16_t sec_count;
6523 	uint64_t lba;
6524 	int rval, reason;
6525 	int synch;
6526 	kmutex_t *cport_mutex = &(SATA_TXLT_CPORT_MUTEX(spx));
6527 
6528 	mutex_enter(cport_mutex);
6529 
6530 	if (((rval = sata_txlt_generic_pkt_info(spx, &reason, 0)) !=
6531 	    TRAN_ACCEPT) || (reason == CMD_DEV_GONE)) {
6532 		mutex_exit(cport_mutex);
6533 		return (rval);
6534 	}
6535 
6536 	sdinfo = sata_get_device_info(spx->txlt_sata_hba_inst,
6537 	    &spx->txlt_sata_pkt->satapkt_device);
6538 
6539 	scmd->satacmd_flags.sata_data_direction = SATA_DIR_WRITE;
6540 	/*
6541 	 * Extract LBA and sector count from scsi CDB
6542 	 */
6543 	switch ((uint_t)scsipkt->pkt_cdbp[0]) {
6544 	case SCMD_WRITE:
6545 		/* 6-byte scsi read cmd : 0x0A */
6546 		lba = (scsipkt->pkt_cdbp[1] & 0x1f);
6547 		lba = (lba << 8) | scsipkt->pkt_cdbp[2];
6548 		lba = (lba << 8) | scsipkt->pkt_cdbp[3];
6549 		sec_count = scsipkt->pkt_cdbp[4];
6550 		/* sec_count 0 will be interpreted as 256 by a device */
6551 		break;
6552 	case SCMD_WRITE_G1:
6553 		/* 10-bytes scsi write command : 0x2A */
6554 		lba = scsipkt->pkt_cdbp[2];
6555 		lba = (lba << 8) | scsipkt->pkt_cdbp[3];
6556 		lba = (lba << 8) | scsipkt->pkt_cdbp[4];
6557 		lba = (lba << 8) | scsipkt->pkt_cdbp[5];
6558 		sec_count = scsipkt->pkt_cdbp[7];
6559 		sec_count = (sec_count << 8) | scsipkt->pkt_cdbp[8];
6560 		break;
6561 	case SCMD_WRITE_G5:
6562 		/* 12-bytes scsi read command : 0xAA */
6563 		lba = scsipkt->pkt_cdbp[2];
6564 		lba = (lba << 8) | scsipkt->pkt_cdbp[3];
6565 		lba = (lba << 8) | scsipkt->pkt_cdbp[4];
6566 		lba = (lba << 8) | scsipkt->pkt_cdbp[5];
6567 		sec_count = scsipkt->pkt_cdbp[6];
6568 		sec_count = (sec_count << 8) | scsipkt->pkt_cdbp[7];
6569 		sec_count = (sec_count << 8) | scsipkt->pkt_cdbp[8];
6570 		sec_count = (sec_count << 8) | scsipkt->pkt_cdbp[9];
6571 		break;
6572 	case SCMD_WRITE_G4:
6573 		/* 16-bytes scsi write command : 0x8A */
6574 		lba = scsipkt->pkt_cdbp[2];
6575 		lba = (lba << 8) | scsipkt->pkt_cdbp[3];
6576 		lba = (lba << 8) | scsipkt->pkt_cdbp[4];
6577 		lba = (lba << 8) | scsipkt->pkt_cdbp[5];
6578 		lba = (lba << 8) | scsipkt->pkt_cdbp[6];
6579 		lba = (lba << 8) | scsipkt->pkt_cdbp[7];
6580 		lba = (lba << 8) | scsipkt->pkt_cdbp[8];
6581 		lba = (lba << 8) | scsipkt->pkt_cdbp[9];
6582 		sec_count = scsipkt->pkt_cdbp[10];
6583 		sec_count = (sec_count << 8) | scsipkt->pkt_cdbp[11];
6584 		sec_count = (sec_count << 8) | scsipkt->pkt_cdbp[12];
6585 		sec_count = (sec_count << 8) | scsipkt->pkt_cdbp[13];
6586 		break;
6587 	default:
6588 		/* Unsupported command */
6589 		mutex_exit(cport_mutex);
6590 		return (sata_txlt_invalid_command(spx));
6591 	}
6592 
6593 	/*
6594 	 * Check if specified address and length exceeds device capacity
6595 	 */
6596 	if ((lba >= sdinfo->satadrv_capacity) ||
6597 	    ((lba + sec_count) > sdinfo->satadrv_capacity)) {
6598 		/* LBA out of range */
6599 		mutex_exit(cport_mutex);
6600 		return (sata_txlt_lba_out_of_range(spx));
6601 	}
6602 
6603 	/*
6604 	 * For zero-length transfer, emulate good completion of the command
6605 	 * (reasons for rejecting the command were already checked).
6606 	 * No DMA resources were allocated.
6607 	 */
6608 	if (spx->txlt_dma_cookie_list == NULL) {
6609 		mutex_exit(cport_mutex);
6610 		return (sata_emul_rw_completion(spx));
6611 	}
6612 
6613 	/*
6614 	 * Build cmd block depending on the device capability and
6615 	 * requested operation mode.
6616 	 * Do not bother with non-dma mode- we are working only with
6617 	 * devices supporting DMA.
6618 	 */
6619 	scmd->satacmd_addr_type = ATA_ADDR_LBA;
6620 	scmd->satacmd_device_reg = SATA_ADH_LBA;
6621 	scmd->satacmd_cmd_reg = SATAC_WRITE_DMA;
6622 	if (sdinfo->satadrv_features_support & SATA_DEV_F_LBA48) {
6623 		scmd->satacmd_addr_type = ATA_ADDR_LBA48;
6624 		scmd->satacmd_cmd_reg = SATAC_WRITE_DMA_EXT;
6625 		scmd->satacmd_sec_count_msb = sec_count >> 8;
6626 		scmd->satacmd_lba_low_msb = (lba >> 24) & 0xff;
6627 #ifndef __lock_lint
6628 		scmd->satacmd_lba_mid_msb = (lba >> 32) & 0xff;
6629 		scmd->satacmd_lba_high_msb = lba >> 40;
6630 #endif
6631 	} else if (sdinfo->satadrv_features_support & SATA_DEV_F_LBA28) {
6632 		scmd->satacmd_addr_type = ATA_ADDR_LBA28;
6633 		scmd->satacmd_device_reg = SATA_ADH_LBA | ((lba >> 24) & 0xf);
6634 	}
6635 	scmd->satacmd_sec_count_lsb = sec_count & 0xff;
6636 	scmd->satacmd_lba_low_lsb = lba & 0xff;
6637 	scmd->satacmd_lba_mid_lsb = (lba >> 8) & 0xff;
6638 	scmd->satacmd_lba_high_lsb = (lba >> 16) & 0xff;
6639 	scmd->satacmd_features_reg = 0;
6640 	scmd->satacmd_status_reg = 0;
6641 	scmd->satacmd_error_reg = 0;
6642 
6643 	/*
6644 	 * Check if queueing commands should be used and switch
6645 	 * to appropriate command if possible
6646 	 */
6647 	if (sata_func_enable & SATA_ENABLE_QUEUING) {
6648 		boolean_t using_queuing;
6649 
6650 		/* Queuing supported by controller and device? */
6651 		if ((sata_func_enable & SATA_ENABLE_NCQ) &&
6652 		    (sdinfo->satadrv_features_support &
6653 		    SATA_DEV_F_NCQ) &&
6654 		    (SATA_FEATURES(spx->txlt_sata_hba_inst) &
6655 		    SATA_CTLF_NCQ)) {
6656 			using_queuing = B_TRUE;
6657 
6658 			/* NCQ supported - use FPDMA WRITE */
6659 			scmd->satacmd_cmd_reg =
6660 			    SATAC_WRITE_FPDMA_QUEUED;
6661 			scmd->satacmd_features_reg_ext =
6662 			    scmd->satacmd_sec_count_msb;
6663 			scmd->satacmd_sec_count_msb = 0;
6664 		} else if ((sdinfo->satadrv_features_support &
6665 		    SATA_DEV_F_TCQ) &&
6666 		    (SATA_FEATURES(spx->txlt_sata_hba_inst) &
6667 		    SATA_CTLF_QCMD)) {
6668 			using_queuing = B_TRUE;
6669 
6670 			/* Legacy queueing */
6671 			if (sdinfo->satadrv_features_support &
6672 			    SATA_DEV_F_LBA48) {
6673 				scmd->satacmd_cmd_reg =
6674 				    SATAC_WRITE_DMA_QUEUED_EXT;
6675 				scmd->satacmd_features_reg_ext =
6676 				    scmd->satacmd_sec_count_msb;
6677 				scmd->satacmd_sec_count_msb = 0;
6678 			} else {
6679 				scmd->satacmd_cmd_reg =
6680 				    SATAC_WRITE_DMA_QUEUED;
6681 			}
6682 		} else	/*  NCQ nor legacy queuing not supported */
6683 			using_queuing = B_FALSE;
6684 
6685 		if (using_queuing) {
6686 			scmd->satacmd_features_reg =
6687 			    scmd->satacmd_sec_count_lsb;
6688 			scmd->satacmd_sec_count_lsb = 0;
6689 			scmd->satacmd_flags.sata_queued = B_TRUE;
6690 			/* Set-up maximum queue depth */
6691 			scmd->satacmd_flags.sata_max_queue_depth =
6692 			    sdinfo->satadrv_max_queue_depth - 1;
6693 		} else if (sdinfo->satadrv_features_enabled &
6694 		    SATA_DEV_F_E_UNTAGGED_QING) {
6695 			/*
6696 			 * Although NCQ/TCQ is not enabled, untagged queuing
6697 			 * may be still used.
6698 			 * Set-up the maximum untagged queue depth.
6699 			 * Use controller's queue depth from sata_hba_tran.
6700 			 * SATA HBA drivers may ignore this value and rely on
6701 			 * the internal limits. For drivera that do not
6702 			 * ignore untaged queue depth, limit the value to
6703 			 * SATA_MAX_QUEUE_DEPTH (32), as this is the
6704 			 * largest value that can be passed via
6705 			 * satacmd_flags.sata_max_queue_depth.
6706 			 */
6707 			scmd->satacmd_flags.sata_max_queue_depth =
6708 			    SATA_QDEPTH(shi) <= SATA_MAX_QUEUE_DEPTH ?
6709 			    SATA_QDEPTH(shi) - 1: SATA_MAX_QUEUE_DEPTH - 1;
6710 
6711 		} else {
6712 			scmd->satacmd_flags.sata_max_queue_depth = 0;
6713 		}
6714 	} else
6715 		scmd->satacmd_flags.sata_max_queue_depth = 0;
6716 
6717 	SATADBG3(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst,
6718 	    "sata_txlt_write cmd 0x%2x, lba %llx, sec count %x\n",
6719 	    scmd->satacmd_cmd_reg, lba, sec_count);
6720 
6721 	if (!(spx->txlt_sata_pkt->satapkt_op_mode & SATA_OPMODE_SYNCH)) {
6722 		/* Need callback function */
6723 		spx->txlt_sata_pkt->satapkt_comp = sata_txlt_rw_completion;
6724 		synch = FALSE;
6725 	} else
6726 		synch = TRUE;
6727 
6728 	/* Transfer command to HBA */
6729 	if (sata_hba_start(spx, &rval) != 0) {
6730 		/* Pkt not accepted for execution */
6731 		mutex_exit(cport_mutex);
6732 		return (rval);
6733 	}
6734 	mutex_exit(cport_mutex);
6735 
6736 	/*
6737 	 * If execution is non-synchronous,
6738 	 * a callback function will handle potential errors, translate
6739 	 * the response and will do a callback to a target driver.
6740 	 * If it was synchronous, check execution status using the same
6741 	 * framework callback.
6742 	 */
6743 	if (synch) {
6744 		SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst,
6745 		    "synchronous execution status %x\n",
6746 		    spx->txlt_sata_pkt->satapkt_reason);
6747 		sata_txlt_rw_completion(spx->txlt_sata_pkt);
6748 	}
6749 	return (TRAN_ACCEPT);
6750 }
6751 
6752 
6753 /*
6754  * Implements SCSI SBC WRITE BUFFER command download microcode option
6755  */
6756 static int
6757 sata_txlt_write_buffer(sata_pkt_txlate_t *spx)
6758 {
6759 #define	WB_DOWNLOAD_MICROCODE_AND_REVERT_MODE			4
6760 #define	WB_DOWNLOAD_MICROCODE_AND_SAVE_MODE			5
6761 
6762 	struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt;
6763 	struct sata_pkt *sata_pkt = spx->txlt_sata_pkt;
6764 	sata_cmd_t *scmd = &spx->txlt_sata_pkt->satapkt_cmd;
6765 
6766 	struct buf *bp = spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp;
6767 	struct scsi_extended_sense *sense;
6768 	int rval, mode, sector_count, reason;
6769 	kmutex_t *cport_mutex = &(SATA_TXLT_CPORT_MUTEX(spx));
6770 
6771 	mode = scsipkt->pkt_cdbp[1] & 0x1f;
6772 
6773 	SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst,
6774 	    "sata_txlt_write_buffer, mode 0x%x\n", mode);
6775 
6776 	mutex_enter(cport_mutex);
6777 
6778 	if ((rval = sata_txlt_generic_pkt_info(spx, &reason, 1)) !=
6779 	    TRAN_ACCEPT) {
6780 		mutex_exit(cport_mutex);
6781 		return (rval);
6782 	}
6783 
6784 	/* Use synchronous mode */
6785 	spx->txlt_sata_pkt->satapkt_op_mode
6786 	    |= SATA_OPMODE_SYNCH | SATA_OPMODE_INTERRUPTS;
6787 
6788 	scmd->satacmd_flags.sata_data_direction = SATA_DIR_WRITE;
6789 
6790 	scsipkt->pkt_reason = CMD_CMPLT;
6791 	scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET |
6792 	    STATE_SENT_CMD | STATE_GOT_STATUS;
6793 
6794 	/*
6795 	 * The SCSI to ATA translation specification only calls
6796 	 * for WB_DOWNLOAD_MICROCODE_AND_SAVE_MODE.
6797 	 * WB_DOWNLOAD_MICROC_AND_REVERT_MODE is implemented, but
6798 	 * ATA 8 (draft) got rid of download microcode for temp
6799 	 * and it is even optional for ATA 7, so it may be aborted.
6800 	 * WB_DOWNLOAD_MICROCODE_WITH_OFFSET is not implemented as
6801 	 * it is not specified and the buffer offset for SCSI is a 16-bit
6802 	 * value in bytes, but for ATA it is a 16-bit offset in 512 byte
6803 	 * sectors.  Thus the offset really doesn't buy us anything.
6804 	 * If and when ATA 8 is stabilized and the SCSI to ATA specification
6805 	 * is revised, this can be revisisted.
6806 	 */
6807 	/* Reject not supported request */
6808 	switch (mode) {
6809 	case WB_DOWNLOAD_MICROCODE_AND_REVERT_MODE:
6810 		scmd->satacmd_features_reg = SATA_DOWNLOAD_MCODE_TEMP;
6811 		break;
6812 	case WB_DOWNLOAD_MICROCODE_AND_SAVE_MODE:
6813 		scmd->satacmd_features_reg = SATA_DOWNLOAD_MCODE_SAVE;
6814 		break;
6815 	default:
6816 		goto bad_param;
6817 	}
6818 
6819 	*scsipkt->pkt_scbp = STATUS_GOOD;	/* Presumed outcome */
6820 
6821 	scmd->satacmd_cmd_reg = SATAC_DOWNLOAD_MICROCODE;
6822 	if ((bp->b_bcount % SATA_DISK_SECTOR_SIZE) != 0)
6823 		goto bad_param;
6824 	sector_count = bp->b_bcount / SATA_DISK_SECTOR_SIZE;
6825 	scmd->satacmd_sec_count_lsb = (uint8_t)sector_count;
6826 	scmd->satacmd_lba_low_lsb = ((uint16_t)sector_count) >> 8;
6827 	scmd->satacmd_lba_mid_lsb = 0;
6828 	scmd->satacmd_lba_high_lsb = 0;
6829 	scmd->satacmd_device_reg = 0;
6830 	spx->txlt_sata_pkt->satapkt_comp = NULL;
6831 	scmd->satacmd_addr_type = 0;
6832 
6833 	/* Transfer command to HBA */
6834 	if (sata_hba_start(spx, &rval) != 0) {
6835 		/* Pkt not accepted for execution */
6836 		mutex_exit(cport_mutex);
6837 		return (rval);
6838 	}
6839 
6840 	mutex_exit(cport_mutex);
6841 
6842 	/* Then we need synchronous check the status of the disk */
6843 	scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET |
6844 	    STATE_SENT_CMD | STATE_XFERRED_DATA | STATE_GOT_STATUS;
6845 	if (sata_pkt->satapkt_reason == SATA_PKT_COMPLETED) {
6846 		scsipkt->pkt_reason = CMD_CMPLT;
6847 
6848 		/* Download commmand succeed, so probe and identify device */
6849 		sata_reidentify_device(spx);
6850 	} else {
6851 		/* Something went wrong, microcode download command failed */
6852 		scsipkt->pkt_reason = CMD_INCOMPLETE;
6853 		*scsipkt->pkt_scbp = STATUS_CHECK;
6854 		sense = sata_arq_sense(spx);
6855 		switch (sata_pkt->satapkt_reason) {
6856 		case SATA_PKT_PORT_ERROR:
6857 			/*
6858 			 * We have no device data. Assume no data transfered.
6859 			 */
6860 			sense->es_key = KEY_HARDWARE_ERROR;
6861 			break;
6862 
6863 		case SATA_PKT_DEV_ERROR:
6864 			if (sata_pkt->satapkt_cmd.satacmd_status_reg &
6865 			    SATA_STATUS_ERR) {
6866 				/*
6867 				 * determine dev error reason from error
6868 				 * reg content
6869 				 */
6870 				sata_decode_device_error(spx, sense);
6871 				break;
6872 			}
6873 			/* No extended sense key - no info available */
6874 			break;
6875 
6876 		case SATA_PKT_TIMEOUT:
6877 			scsipkt->pkt_reason = CMD_TIMEOUT;
6878 			scsipkt->pkt_statistics |=
6879 			    STAT_TIMEOUT | STAT_DEV_RESET;
6880 			/* No extended sense key ? */
6881 			break;
6882 
6883 		case SATA_PKT_ABORTED:
6884 			scsipkt->pkt_reason = CMD_ABORTED;
6885 			scsipkt->pkt_statistics |= STAT_ABORTED;
6886 			/* No extended sense key ? */
6887 			break;
6888 
6889 		case SATA_PKT_RESET:
6890 			/* pkt aborted by an explicit reset from a host */
6891 			scsipkt->pkt_reason = CMD_RESET;
6892 			scsipkt->pkt_statistics |= STAT_DEV_RESET;
6893 			break;
6894 
6895 		default:
6896 			SATA_LOG_D((spx->txlt_sata_hba_inst, CE_WARN,
6897 			    "sata_txlt_nodata_cmd_completion: "
6898 			    "invalid packet completion reason %d",
6899 			    sata_pkt->satapkt_reason));
6900 			scsipkt->pkt_reason = CMD_TRAN_ERR;
6901 			break;
6902 		}
6903 
6904 		SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst,
6905 		    "scsi_pkt completion reason %x\n", scsipkt->pkt_reason);
6906 
6907 		if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0)
6908 			/* scsi callback required */
6909 			scsi_hba_pkt_comp(scsipkt);
6910 	}
6911 	return (TRAN_ACCEPT);
6912 
6913 bad_param:
6914 	mutex_exit(cport_mutex);
6915 	*scsipkt->pkt_scbp = STATUS_CHECK;
6916 	sense = sata_arq_sense(spx);
6917 	sense->es_key = KEY_ILLEGAL_REQUEST;
6918 	sense->es_add_code = SD_SCSI_ASC_INVALID_FIELD_IN_CDB;
6919 	if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0 &&
6920 	    scsipkt->pkt_comp != NULL) {
6921 		/* scsi callback required */
6922 		if (servicing_interrupt()) {
6923 			if (taskq_dispatch(SATA_TXLT_TASKQ(spx),
6924 			    (task_func_t *)spx->txlt_scsi_pkt->pkt_comp,
6925 			    (void *)spx->txlt_scsi_pkt, TQ_NOSLEEP) ==
6926 			    TASKQID_INVALID) {
6927 				return (TRAN_BUSY);
6928 			}
6929 		} else if (taskq_dispatch(SATA_TXLT_TASKQ(spx),
6930 		    (task_func_t *)spx->txlt_scsi_pkt->pkt_comp,
6931 		    (void *)spx->txlt_scsi_pkt, TQ_SLEEP) == TASKQID_INVALID) {
6932 			/* Scheduling the callback failed */
6933 			return (TRAN_BUSY);
6934 		}
6935 	}
6936 	return (rval);
6937 }
6938 
6939 /*
6940  * Re-identify device after doing a firmware download.
6941  */
6942 static void
6943 sata_reidentify_device(sata_pkt_txlate_t *spx)
6944 {
6945 #define	DOWNLOAD_WAIT_TIME_SECS	60
6946 #define	DOWNLOAD_WAIT_INTERVAL_SECS	1
6947 	int rval;
6948 	int retry_cnt;
6949 	struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt;
6950 	sata_hba_inst_t *sata_hba_inst = spx->txlt_sata_hba_inst;
6951 	sata_device_t sata_device = spx->txlt_sata_pkt->satapkt_device;
6952 	sata_drive_info_t *sdinfo;
6953 
6954 	/*
6955 	 * Before returning good status, probe device.
6956 	 * Device probing will get IDENTIFY DEVICE data, if possible.
6957 	 * The assumption is that the new microcode is applied by the
6958 	 * device. It is a caller responsibility to verify this.
6959 	 */
6960 	for (retry_cnt = 0;
6961 	    retry_cnt < DOWNLOAD_WAIT_TIME_SECS / DOWNLOAD_WAIT_INTERVAL_SECS;
6962 	    retry_cnt++) {
6963 		rval = sata_probe_device(sata_hba_inst, &sata_device);
6964 
6965 		if (rval == SATA_SUCCESS) { /* Set default features */
6966 			sdinfo = sata_get_device_info(sata_hba_inst,
6967 			    &sata_device);
6968 			if (sata_initialize_device(sata_hba_inst, sdinfo) !=
6969 			    SATA_SUCCESS) {
6970 				/* retry */
6971 				rval = sata_initialize_device(sata_hba_inst,
6972 				    sdinfo);
6973 				if (rval == SATA_RETRY)
6974 					sata_log(sata_hba_inst, CE_WARN,
6975 					    "SATA device at port %d pmport %d -"
6976 					    " default device features could not"
6977 					    " be set. Device may not operate "
6978 					    "as expected.",
6979 					    sata_device.satadev_addr.cport,
6980 					    sata_device.satadev_addr.pmport);
6981 			}
6982 			if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0)
6983 				scsi_hba_pkt_comp(scsipkt);
6984 			return;
6985 		} else if (rval == SATA_RETRY) {
6986 			delay(drv_usectohz(1000000 *
6987 			    DOWNLOAD_WAIT_INTERVAL_SECS));
6988 			continue;
6989 		} else	/* failed - no reason to retry */
6990 			break;
6991 	}
6992 
6993 	/*
6994 	 * Something went wrong, device probing failed.
6995 	 */
6996 	SATA_LOG_D((sata_hba_inst, CE_WARN,
6997 	    "Cannot probe device after downloading microcode\n"));
6998 
6999 	/* Reset device to force retrying the probe. */
7000 	(void) (*SATA_RESET_DPORT_FUNC(sata_hba_inst))
7001 	    (SATA_DIP(sata_hba_inst), &sata_device);
7002 
7003 	if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0)
7004 		scsi_hba_pkt_comp(scsipkt);
7005 }
7006 
7007 
7008 /*
7009  * Translate command: Synchronize Cache.
7010  * Translates into Flush Cache command for SATA hard disks.
7011  *
7012  * Returns TRAN_ACCEPT or code returned by sata_hba_start() and
7013  * appropriate values in scsi_pkt fields.
7014  */
7015 static int
7016 sata_txlt_synchronize_cache(sata_pkt_txlate_t *spx)
7017 {
7018 	sata_cmd_t *scmd = &spx->txlt_sata_pkt->satapkt_cmd;
7019 	kmutex_t *cport_mutex = &(SATA_TXLT_CPORT_MUTEX(spx));
7020 	int rval, reason;
7021 	int synch;
7022 
7023 	mutex_enter(cport_mutex);
7024 
7025 	if (((rval = sata_txlt_generic_pkt_info(spx, &reason, 1)) !=
7026 	    TRAN_ACCEPT) || (reason == CMD_DEV_GONE)) {
7027 		mutex_exit(cport_mutex);
7028 		return (rval);
7029 	}
7030 
7031 	scmd->satacmd_addr_type = 0;
7032 	scmd->satacmd_cmd_reg = SATAC_FLUSH_CACHE;
7033 	scmd->satacmd_device_reg = 0;
7034 	scmd->satacmd_sec_count_lsb = 0;
7035 	scmd->satacmd_lba_low_lsb = 0;
7036 	scmd->satacmd_lba_mid_lsb = 0;
7037 	scmd->satacmd_lba_high_lsb = 0;
7038 	scmd->satacmd_features_reg = 0;
7039 	scmd->satacmd_status_reg = 0;
7040 	scmd->satacmd_error_reg = 0;
7041 
7042 	SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst,
7043 	    "sata_txlt_synchronize_cache\n", NULL);
7044 
7045 	if (!(spx->txlt_sata_pkt->satapkt_op_mode & SATA_OPMODE_SYNCH)) {
7046 		/* Need to set-up a callback function */
7047 		spx->txlt_sata_pkt->satapkt_comp =
7048 		    sata_txlt_nodata_cmd_completion;
7049 		synch = FALSE;
7050 	} else
7051 		synch = TRUE;
7052 
7053 	/* Transfer command to HBA */
7054 	if (sata_hba_start(spx, &rval) != 0) {
7055 		/* Pkt not accepted for execution */
7056 		mutex_exit(cport_mutex);
7057 		return (rval);
7058 	}
7059 	mutex_exit(cport_mutex);
7060 
7061 	/*
7062 	 * If execution non-synchronous, it had to be completed
7063 	 * a callback function will handle potential errors, translate
7064 	 * the response and will do a callback to a target driver.
7065 	 * If it was synchronous, check status, using the same
7066 	 * framework callback.
7067 	 */
7068 	if (synch) {
7069 		SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst,
7070 		    "synchronous execution status %x\n",
7071 		    spx->txlt_sata_pkt->satapkt_reason);
7072 		sata_txlt_nodata_cmd_completion(spx->txlt_sata_pkt);
7073 	}
7074 	return (TRAN_ACCEPT);
7075 }
7076 
7077 
7078 /*
7079  * Send pkt to SATA HBA driver
7080  *
7081  * This function may be called only if the operation is requested by scsi_pkt,
7082  * i.e. scsi_pkt is not NULL.
7083  *
7084  * This function has to be called with cport mutex held. It does release
7085  * the mutex when it calls HBA driver sata_tran_start function and
7086  * re-acquires it afterwards.
7087  *
7088  * If return value is 0, pkt was accepted, -1 otherwise
7089  * rval is set to appropriate sata_scsi_start return value.
7090  *
7091  * Note 1:If HBA driver returns value other than TRAN_ACCEPT, it should not
7092  * have called the sata_pkt callback function for this packet.
7093  *
7094  * The scsi callback has to be performed by the caller of this routine.
7095  */
7096 static int
7097 sata_hba_start(sata_pkt_txlate_t *spx, int *rval)
7098 {
7099 	int stat;
7100 	uint8_t cport = SATA_TXLT_CPORT(spx);
7101 	uint8_t pmport = SATA_TXLT_PMPORT(spx);
7102 	sata_hba_inst_t *sata_hba_inst = spx->txlt_sata_hba_inst;
7103 	sata_drive_info_t *sdinfo;
7104 	sata_pmult_info_t *pminfo = NULL;
7105 	sata_pmport_info_t *pmportinfo = NULL;
7106 	sata_device_t *sata_device = NULL;
7107 	uint8_t cmd;
7108 	struct sata_cmd_flags cmd_flags;
7109 
7110 	ASSERT(spx->txlt_sata_pkt != NULL);
7111 
7112 	ASSERT(mutex_owned(&SATA_CPORT_MUTEX(sata_hba_inst, cport)));
7113 
7114 	sdinfo = sata_get_device_info(sata_hba_inst,
7115 	    &spx->txlt_sata_pkt->satapkt_device);
7116 	ASSERT(sdinfo != NULL);
7117 
7118 	/* Clear device reset state? */
7119 	/* qual should be XXX_DPMPORT, but add XXX_PMPORT in case */
7120 	if (sdinfo->satadrv_addr.qual == SATA_ADDR_DPMPORT ||
7121 	    sdinfo->satadrv_addr.qual == SATA_ADDR_PMPORT) {
7122 
7123 		/*
7124 		 * Get the pmult_info of the its parent port multiplier, all
7125 		 * sub-devices share a common device reset flags on in
7126 		 * pmult_info.
7127 		 */
7128 		pminfo = SATA_PMULT_INFO(sata_hba_inst, cport);
7129 		pmportinfo = pminfo->pmult_dev_port[pmport];
7130 		ASSERT(pminfo != NULL);
7131 		if (pminfo->pmult_event_flags & SATA_EVNT_CLEAR_DEVICE_RESET) {
7132 			spx->txlt_sata_pkt->satapkt_cmd.satacmd_flags.
7133 			    sata_clear_dev_reset = B_TRUE;
7134 			pminfo->pmult_event_flags &=
7135 			    ~SATA_EVNT_CLEAR_DEVICE_RESET;
7136 			SATADBG1(SATA_DBG_EVENTS, sata_hba_inst,
7137 			    "sata_hba_start: clearing device reset state"
7138 			    "on pmult.\n", NULL);
7139 		}
7140 	} else {
7141 		if (sdinfo->satadrv_event_flags &
7142 		    SATA_EVNT_CLEAR_DEVICE_RESET) {
7143 			spx->txlt_sata_pkt->satapkt_cmd.satacmd_flags.
7144 			    sata_clear_dev_reset = B_TRUE;
7145 			sdinfo->satadrv_event_flags &=
7146 			    ~SATA_EVNT_CLEAR_DEVICE_RESET;
7147 			SATADBG1(SATA_DBG_EVENTS, sata_hba_inst,
7148 			    "sata_hba_start: clearing device reset state\n",
7149 			    NULL);
7150 		}
7151 	}
7152 
7153 	cmd = spx->txlt_sata_pkt->satapkt_cmd.satacmd_cmd_reg;
7154 	cmd_flags = spx->txlt_sata_pkt->satapkt_cmd.satacmd_flags;
7155 	sata_device = &spx->txlt_sata_pkt->satapkt_device;
7156 
7157 	mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, cport)));
7158 
7159 	SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst,
7160 	    "Sata cmd 0x%2x\n", cmd);
7161 
7162 	stat = (*SATA_START_FUNC(sata_hba_inst))(SATA_DIP(sata_hba_inst),
7163 	    spx->txlt_sata_pkt);
7164 	mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, cport)));
7165 	/*
7166 	 * If sata pkt was accepted and executed in asynchronous mode, i.e.
7167 	 * with the sata callback, the sata_pkt could be already destroyed
7168 	 * by the time we check ther return status from the hba_start()
7169 	 * function, because sata_scsi_destroy_pkt() could have been already
7170 	 * called (perhaps in the interrupt context). So, in such case, there
7171 	 * should be no references to it. In other cases, sata_pkt still
7172 	 * exists.
7173 	 */
7174 	if (stat == SATA_TRAN_ACCEPTED) {
7175 		/*
7176 		 * pkt accepted for execution.
7177 		 * If it was executed synchronously, it is already completed
7178 		 * and pkt completion_reason indicates completion status.
7179 		 */
7180 		*rval = TRAN_ACCEPT;
7181 		return (0);
7182 	}
7183 
7184 	sdinfo = sata_get_device_info(sata_hba_inst, sata_device);
7185 	switch (stat) {
7186 	case SATA_TRAN_QUEUE_FULL:
7187 		/*
7188 		 * Controller detected queue full condition.
7189 		 */
7190 		SATADBG1(SATA_DBG_HBA_IF, sata_hba_inst,
7191 		    "sata_hba_start: queue full\n", NULL);
7192 
7193 		spx->txlt_scsi_pkt->pkt_reason = CMD_INCOMPLETE;
7194 		*spx->txlt_scsi_pkt->pkt_scbp = STATUS_QFULL;
7195 
7196 		*rval = TRAN_BUSY;
7197 		break;
7198 
7199 	case SATA_TRAN_PORT_ERROR:
7200 		/*
7201 		 * Communication/link with device or general port error
7202 		 * detected before pkt execution begun.
7203 		 */
7204 		if (spx->txlt_sata_pkt->satapkt_device.satadev_addr.qual ==
7205 		    SATA_ADDR_CPORT ||
7206 		    spx->txlt_sata_pkt->satapkt_device.satadev_addr.qual ==
7207 		    SATA_ADDR_DCPORT)
7208 			sata_log(sata_hba_inst, CE_CONT,
7209 			    "SATA port %d error",
7210 			    sata_device->satadev_addr.cport);
7211 		else
7212 			sata_log(sata_hba_inst, CE_CONT,
7213 			    "SATA port %d:%d error\n",
7214 			    sata_device->satadev_addr.cport,
7215 			    sata_device->satadev_addr.pmport);
7216 
7217 		/*
7218 		 * Update the port/device structure.
7219 		 * sata_pkt should be still valid. Since port error is
7220 		 * returned, sata_device content should reflect port
7221 		 * state - it means, that sata address have been changed,
7222 		 * because original packet's sata address refered to a device
7223 		 * attached to some port.
7224 		 */
7225 		if (sata_device->satadev_addr.qual == SATA_ADDR_DPMPORT ||
7226 		    sata_device->satadev_addr.qual == SATA_ADDR_PMPORT) {
7227 			mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, cport)));
7228 			mutex_enter(&pmportinfo->pmport_mutex);
7229 			sata_update_pmport_info(sata_hba_inst, sata_device);
7230 			mutex_exit(&pmportinfo->pmport_mutex);
7231 			mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, cport)));
7232 		} else {
7233 			sata_update_port_info(sata_hba_inst, sata_device);
7234 		}
7235 
7236 		spx->txlt_scsi_pkt->pkt_reason = CMD_TRAN_ERR;
7237 		*rval = TRAN_FATAL_ERROR;
7238 		break;
7239 
7240 	case SATA_TRAN_CMD_UNSUPPORTED:
7241 		/*
7242 		 * Command rejected by HBA as unsupported. It was HBA driver
7243 		 * that rejected the command, command was not sent to
7244 		 * an attached device.
7245 		 */
7246 		if ((sdinfo != NULL) &&
7247 		    (sdinfo->satadrv_state & SATA_DSTATE_RESET))
7248 			SATADBG1(SATA_DBG_EVENTS, sata_hba_inst,
7249 			    "sat_hba_start: cmd 0x%2x rejected "
7250 			    "with SATA_TRAN_CMD_UNSUPPORTED status\n", cmd);
7251 
7252 		mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, cport)));
7253 		(void) sata_txlt_invalid_command(spx);
7254 		mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, cport)));
7255 
7256 		*rval = TRAN_ACCEPT;
7257 		break;
7258 
7259 	case SATA_TRAN_BUSY:
7260 		/*
7261 		 * Command rejected by HBA because other operation prevents
7262 		 * accepting the packet, or device is in RESET condition.
7263 		 */
7264 		if (sdinfo != NULL) {
7265 			sdinfo->satadrv_state =
7266 			    spx->txlt_sata_pkt->satapkt_device.satadev_state;
7267 
7268 			if (sdinfo->satadrv_state & SATA_DSTATE_RESET) {
7269 				SATADBG1(SATA_DBG_EVENTS, sata_hba_inst,
7270 				    "sata_hba_start: cmd 0x%2x rejected "
7271 				    "because of device reset condition\n",
7272 				    cmd);
7273 			} else {
7274 				SATADBG1(SATA_DBG_EVENTS, sata_hba_inst,
7275 				    "sata_hba_start: cmd 0x%2x rejected "
7276 				    "with SATA_TRAN_BUSY status\n",
7277 				    cmd);
7278 			}
7279 		}
7280 		spx->txlt_scsi_pkt->pkt_reason = CMD_INCOMPLETE;
7281 		*rval = TRAN_BUSY;
7282 		break;
7283 
7284 	default:
7285 		/* Unrecognized HBA response */
7286 		SATA_LOG_D((sata_hba_inst, CE_WARN,
7287 		    "sata_hba_start: unrecognized HBA response "
7288 		    "to cmd : 0x%2x resp 0x%x", cmd, rval));
7289 		spx->txlt_scsi_pkt->pkt_reason = CMD_TRAN_ERR;
7290 		*rval = TRAN_FATAL_ERROR;
7291 		break;
7292 	}
7293 
7294 	/*
7295 	 * If we got here, the packet was rejected.
7296 	 * Check if we need to remember reset state clearing request
7297 	 */
7298 	if (cmd_flags.sata_clear_dev_reset) {
7299 		/*
7300 		 * Check if device is still configured - it may have
7301 		 * disapeared from the configuration
7302 		 */
7303 		sdinfo = sata_get_device_info(sata_hba_inst, sata_device);
7304 		if (sdinfo != NULL) {
7305 			/*
7306 			 * Restore the flag that requests clearing of
7307 			 * the device reset state,
7308 			 * so the next sata packet may carry it to HBA.
7309 			 */
7310 			if (sdinfo->satadrv_addr.qual == SATA_ADDR_PMPORT ||
7311 			    sdinfo->satadrv_addr.qual == SATA_ADDR_DPMPORT) {
7312 				pminfo->pmult_event_flags |=
7313 				    SATA_EVNT_CLEAR_DEVICE_RESET;
7314 			} else {
7315 				sdinfo->satadrv_event_flags |=
7316 				    SATA_EVNT_CLEAR_DEVICE_RESET;
7317 			}
7318 		}
7319 	}
7320 	return (-1);
7321 }
7322 
7323 /*
7324  * Scsi response setup for invalid LBA
7325  *
7326  * Returns TRAN_ACCEPT and appropriate values in scsi_pkt fields.
7327  */
7328 static int
7329 sata_txlt_lba_out_of_range(sata_pkt_txlate_t *spx)
7330 {
7331 	struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt;
7332 	struct scsi_extended_sense *sense;
7333 
7334 	scsipkt->pkt_reason = CMD_CMPLT;
7335 	scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET |
7336 	    STATE_SENT_CMD | STATE_GOT_STATUS;
7337 	*scsipkt->pkt_scbp = STATUS_CHECK;
7338 
7339 	*scsipkt->pkt_scbp = STATUS_CHECK;
7340 	sense = sata_arq_sense(spx);
7341 	sense->es_key = KEY_ILLEGAL_REQUEST;
7342 	sense->es_add_code = SD_SCSI_ASC_LBA_OUT_OF_RANGE;
7343 
7344 	SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst,
7345 	    "Scsi_pkt completion reason %x\n", scsipkt->pkt_reason);
7346 
7347 	if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0 &&
7348 	    scsipkt->pkt_comp != NULL) {
7349 		/* scsi callback required */
7350 		if (servicing_interrupt()) {
7351 			if (taskq_dispatch(SATA_TXLT_TASKQ(spx),
7352 			    (task_func_t *)spx->txlt_scsi_pkt->pkt_comp,
7353 			    (void *)spx->txlt_scsi_pkt, TQ_NOSLEEP) ==
7354 			    TASKQID_INVALID) {
7355 				return (TRAN_BUSY);
7356 			}
7357 		} else if (taskq_dispatch(SATA_TXLT_TASKQ(spx),
7358 		    (task_func_t *)spx->txlt_scsi_pkt->pkt_comp,
7359 		    (void *)spx->txlt_scsi_pkt, TQ_SLEEP) == TASKQID_INVALID) {
7360 			/* Scheduling the callback failed */
7361 			return (TRAN_BUSY);
7362 		}
7363 	}
7364 	return (TRAN_ACCEPT);
7365 }
7366 
7367 
7368 /*
7369  * Analyze device status and error registers and translate them into
7370  * appropriate scsi sense codes.
7371  * NOTE: non-packet commands only for now
7372  */
7373 static void
7374 sata_decode_device_error(sata_pkt_txlate_t *spx,
7375     struct scsi_extended_sense *sense)
7376 {
7377 	uint8_t err_reg = spx->txlt_sata_pkt->satapkt_cmd.satacmd_error_reg;
7378 
7379 	ASSERT(sense != NULL);
7380 	ASSERT(spx->txlt_sata_pkt->satapkt_cmd.satacmd_status_reg &
7381 	    SATA_STATUS_ERR);
7382 
7383 
7384 	if (err_reg & SATA_ERROR_ICRC) {
7385 		sense->es_key = KEY_ABORTED_COMMAND;
7386 		sense->es_add_code = 0x08; /* Communication failure */
7387 		return;
7388 	}
7389 
7390 	if (err_reg & SATA_ERROR_UNC) {
7391 		sense->es_key = KEY_MEDIUM_ERROR;
7392 		/* Information bytes (LBA) need to be set by a caller */
7393 		return;
7394 	}
7395 
7396 	/* ADD HERE: MC error bit handling for ATAPI CD/DVD */
7397 	if (err_reg & (SATA_ERROR_MCR | SATA_ERROR_NM)) {
7398 		sense->es_key = KEY_UNIT_ATTENTION;
7399 		sense->es_add_code = 0x3a; /* No media present */
7400 		return;
7401 	}
7402 
7403 	if (err_reg & SATA_ERROR_IDNF) {
7404 		if (err_reg & SATA_ERROR_ABORT) {
7405 			sense->es_key = KEY_ABORTED_COMMAND;
7406 		} else {
7407 			sense->es_key = KEY_ILLEGAL_REQUEST;
7408 			sense->es_add_code = 0x21; /* LBA out of range */
7409 		}
7410 		return;
7411 	}
7412 
7413 	if (err_reg & SATA_ERROR_ABORT) {
7414 		ASSERT(spx->txlt_sata_pkt != NULL);
7415 		sense->es_key = KEY_ABORTED_COMMAND;
7416 		return;
7417 	}
7418 }
7419 
7420 /*
7421  * Extract error LBA from sata_pkt.satapkt_cmd register fields
7422  */
7423 static void
7424 sata_extract_error_lba(sata_pkt_txlate_t *spx, uint64_t *lba)
7425 {
7426 	sata_cmd_t *sata_cmd = &spx->txlt_sata_pkt->satapkt_cmd;
7427 
7428 	*lba = 0;
7429 	if (sata_cmd->satacmd_addr_type == ATA_ADDR_LBA48) {
7430 		*lba = sata_cmd->satacmd_lba_high_msb;
7431 		*lba = (*lba << 8) | sata_cmd->satacmd_lba_mid_msb;
7432 		*lba = (*lba << 8) | sata_cmd->satacmd_lba_low_msb;
7433 	} else if (sata_cmd->satacmd_addr_type == ATA_ADDR_LBA28) {
7434 		*lba = sata_cmd->satacmd_device_reg & 0xf;
7435 	}
7436 	*lba = (*lba << 8) | sata_cmd->satacmd_lba_high_lsb;
7437 	*lba = (*lba << 8) | sata_cmd->satacmd_lba_mid_lsb;
7438 	*lba = (*lba << 8) | sata_cmd->satacmd_lba_low_lsb;
7439 }
7440 
7441 /*
7442  * This is fixed sense format - if LBA exceeds the info field size,
7443  * no valid info will be returned (valid bit in extended sense will
7444  * be set to 0).
7445  */
7446 static struct scsi_extended_sense *
7447 sata_arq_sense(sata_pkt_txlate_t *spx)
7448 {
7449 	struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt;
7450 	struct scsi_arq_status *arqs;
7451 	struct scsi_extended_sense *sense;
7452 
7453 	/* Fill ARQ sense data */
7454 	scsipkt->pkt_state |= STATE_ARQ_DONE;
7455 	arqs = (struct scsi_arq_status *)scsipkt->pkt_scbp;
7456 	*(uchar_t *)&arqs->sts_status = STATUS_CHECK;
7457 	*(uchar_t *)&arqs->sts_rqpkt_status = STATUS_GOOD;
7458 	arqs->sts_rqpkt_reason = CMD_CMPLT;
7459 	arqs->sts_rqpkt_state = STATE_GOT_BUS | STATE_GOT_TARGET |
7460 	    STATE_XFERRED_DATA | STATE_SENT_CMD | STATE_GOT_STATUS;
7461 	arqs->sts_rqpkt_resid = 0;
7462 	sense = &arqs->sts_sensedata;
7463 	bzero(sense, sizeof (struct scsi_extended_sense));
7464 	sata_fixed_sense_data_preset(sense);
7465 	return (sense);
7466 }
7467 
7468 /*
7469  * ATA Pass Through support
7470  * Sets flags indicating that an invalid value was found in some
7471  * field in the command.  It could be something illegal according to
7472  * the SAT-2 spec or it could be a feature that is not (yet?)
7473  * supported.
7474  */
7475 static int
7476 sata_txlt_ata_pass_thru_illegal_cmd(sata_pkt_txlate_t *spx)
7477 {
7478 	struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt;
7479 	struct scsi_extended_sense *sense = sata_arq_sense(spx);
7480 
7481 	scsipkt->pkt_reason = CMD_CMPLT;
7482 	*scsipkt->pkt_scbp = STATUS_CHECK;
7483 	scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET |
7484 	    STATE_SENT_CMD | STATE_GOT_STATUS;
7485 
7486 	sense = sata_arq_sense(spx);
7487 	sense->es_key = KEY_ILLEGAL_REQUEST;
7488 	sense->es_add_code = SD_SCSI_ASC_INVALID_FIELD_IN_CDB;
7489 
7490 	if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0 &&
7491 	    scsipkt->pkt_comp != NULL) {
7492 		/* scsi callback required */
7493 		if (servicing_interrupt()) {
7494 			if (taskq_dispatch(SATA_TXLT_TASKQ(spx),
7495 			    (task_func_t *)spx->txlt_scsi_pkt->pkt_comp,
7496 			    (void *)spx->txlt_scsi_pkt, TQ_NOSLEEP) ==
7497 			    TASKQID_INVALID) {
7498 				return (TRAN_BUSY);
7499 			}
7500 		} else if (taskq_dispatch(SATA_TXLT_TASKQ(spx),
7501 		    (task_func_t *)spx->txlt_scsi_pkt->pkt_comp,
7502 		    (void *)spx->txlt_scsi_pkt, TQ_SLEEP) == TASKQID_INVALID) {
7503 			/* Scheduling the callback failed */
7504 			return (TRAN_BUSY);
7505 		}
7506 	}
7507 
7508 	return (TRAN_ACCEPT);
7509 }
7510 
7511 /*
7512  * The UNMAP command considers it not to be an error if the parameter length
7513  * or block descriptor length is 0.  For this case, there is nothing for TRIM
7514  * to do so just complete the command.
7515  */
7516 static int
7517 sata_txlt_unmap_nodata_cmd(sata_pkt_txlate_t *spx)
7518 {
7519 	struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt;
7520 
7521 	scsipkt->pkt_reason = CMD_CMPLT;
7522 	*scsipkt->pkt_scbp = STATUS_GOOD;
7523 	scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET |
7524 	    STATE_SENT_CMD | STATE_GOT_STATUS;
7525 
7526 	if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0 &&
7527 	    scsipkt->pkt_comp != NULL) {
7528 		/* scsi callback required */
7529 		if (taskq_dispatch(SATA_TXLT_TASKQ(spx),
7530 		    (task_func_t *)spx->txlt_scsi_pkt->pkt_comp,
7531 		    (void *)spx->txlt_scsi_pkt, TQ_SLEEP) == TASKQID_INVALID) {
7532 			/* Scheduling the callback failed */
7533 			return (TRAN_BUSY);
7534 		}
7535 	}
7536 
7537 	return (TRAN_ACCEPT);
7538 }
7539 
7540 /*
7541  * Emulated SATA Read/Write command completion for zero-length requests.
7542  * This request always succedes, so in synchronous mode it always returns
7543  * TRAN_ACCEPT, and in non-synchronous mode it may return TRAN_BUSY if the
7544  * callback cannot be scheduled.
7545  */
7546 static int
7547 sata_emul_rw_completion(sata_pkt_txlate_t *spx)
7548 {
7549 	struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt;
7550 
7551 	scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET |
7552 	    STATE_SENT_CMD | STATE_GOT_STATUS;
7553 	scsipkt->pkt_reason = CMD_CMPLT;
7554 	*scsipkt->pkt_scbp = STATUS_GOOD;
7555 	if (!(spx->txlt_sata_pkt->satapkt_op_mode & SATA_OPMODE_SYNCH)) {
7556 		/* scsi callback required - have to schedule it */
7557 		if (servicing_interrupt()) {
7558 			if (taskq_dispatch(SATA_TXLT_TASKQ(spx),
7559 			    (task_func_t *)spx->txlt_scsi_pkt->pkt_comp,
7560 			    (void *)spx->txlt_scsi_pkt, TQ_NOSLEEP) ==
7561 			    TASKQID_INVALID) {
7562 				return (TRAN_BUSY);
7563 			}
7564 		} else if (taskq_dispatch(SATA_TXLT_TASKQ(spx),
7565 		    (task_func_t *)spx->txlt_scsi_pkt->pkt_comp,
7566 		    (void *)spx->txlt_scsi_pkt, TQ_SLEEP) == TASKQID_INVALID) {
7567 			/* Scheduling the callback failed */
7568 			return (TRAN_BUSY);
7569 		}
7570 	}
7571 	return (TRAN_ACCEPT);
7572 }
7573 
7574 
7575 /*
7576  * Translate completion status of SATA read/write commands into scsi response.
7577  * pkt completion_reason is checked to determine the completion status.
7578  * Do scsi callback if necessary.
7579  *
7580  * Note: this function may be called also for synchronously executed
7581  * commands.
7582  * This function may be used only if scsi_pkt is non-NULL.
7583  */
7584 static void
7585 sata_txlt_rw_completion(sata_pkt_t *sata_pkt)
7586 {
7587 	sata_pkt_txlate_t *spx =
7588 	    (sata_pkt_txlate_t *)sata_pkt->satapkt_framework_private;
7589 	sata_cmd_t *scmd = &sata_pkt->satapkt_cmd;
7590 	struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt;
7591 	struct scsi_extended_sense *sense;
7592 	uint64_t lba;
7593 	struct buf *bp;
7594 	int rval;
7595 	if (sata_pkt->satapkt_reason == SATA_PKT_COMPLETED) {
7596 		/* Normal completion */
7597 		scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET |
7598 		    STATE_SENT_CMD | STATE_XFERRED_DATA | STATE_GOT_STATUS;
7599 		scsipkt->pkt_reason = CMD_CMPLT;
7600 		*scsipkt->pkt_scbp = STATUS_GOOD;
7601 		if (spx->txlt_tmp_buf != NULL) {
7602 			/* Temporary buffer was used */
7603 			bp = spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp;
7604 			if (bp->b_flags & B_READ) {
7605 				rval = ddi_dma_sync(
7606 				    spx->txlt_buf_dma_handle, 0, 0,
7607 				    DDI_DMA_SYNC_FORCPU);
7608 				ASSERT(rval == DDI_SUCCESS);
7609 				bcopy(spx->txlt_tmp_buf, bp->b_un.b_addr,
7610 				    bp->b_bcount);
7611 			}
7612 		}
7613 	} else {
7614 		/*
7615 		 * Something went wrong - analyze return
7616 		 */
7617 		scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET |
7618 		    STATE_SENT_CMD | STATE_GOT_STATUS;
7619 		scsipkt->pkt_reason = CMD_INCOMPLETE;
7620 		*scsipkt->pkt_scbp = STATUS_CHECK;
7621 		sense = sata_arq_sense(spx);
7622 		ASSERT(sense != NULL);
7623 
7624 		/*
7625 		 * SATA_PKT_DEV_ERROR is the only case where we may be able to
7626 		 * extract from device registers the failing LBA.
7627 		 */
7628 		if (sata_pkt->satapkt_reason == SATA_PKT_DEV_ERROR) {
7629 			if ((scmd->satacmd_addr_type == ATA_ADDR_LBA48) &&
7630 			    (scmd->satacmd_lba_mid_msb != 0 ||
7631 			    scmd->satacmd_lba_high_msb != 0)) {
7632 				/*
7633 				 * We have problem reporting this cmd LBA
7634 				 * in fixed sense data format, because of
7635 				 * the size of the scsi LBA fields.
7636 				 */
7637 				sense->es_valid = 0;
7638 			} else {
7639 				sata_extract_error_lba(spx, &lba);
7640 				sense->es_info_1 = (lba & 0xFF000000) >> 24;
7641 				sense->es_info_2 = (lba & 0xFF0000) >> 16;
7642 				sense->es_info_3 = (lba & 0xFF00) >> 8;
7643 				sense->es_info_4 = lba & 0xFF;
7644 			}
7645 		} else {
7646 			/* Invalid extended sense info */
7647 			sense->es_valid = 0;
7648 		}
7649 
7650 		switch (sata_pkt->satapkt_reason) {
7651 		case SATA_PKT_PORT_ERROR:
7652 			/* We may want to handle DEV GONE state as well */
7653 			/*
7654 			 * We have no device data. Assume no data transfered.
7655 			 */
7656 			sense->es_key = KEY_HARDWARE_ERROR;
7657 			break;
7658 
7659 		case SATA_PKT_DEV_ERROR:
7660 			if (sata_pkt->satapkt_cmd.satacmd_status_reg &
7661 			    SATA_STATUS_ERR) {
7662 				/*
7663 				 * determine dev error reason from error
7664 				 * reg content
7665 				 */
7666 				sata_decode_device_error(spx, sense);
7667 				if (sense->es_key == KEY_MEDIUM_ERROR) {
7668 					switch (scmd->satacmd_cmd_reg) {
7669 					case SATAC_READ_DMA:
7670 					case SATAC_READ_DMA_EXT:
7671 					case SATAC_READ_DMA_QUEUED:
7672 					case SATAC_READ_DMA_QUEUED_EXT:
7673 					case SATAC_READ_FPDMA_QUEUED:
7674 						/* Unrecovered read error */
7675 						sense->es_add_code =
7676 						    SD_SCSI_ASC_UNREC_READ_ERR;
7677 						break;
7678 					case SATAC_WRITE_DMA:
7679 					case SATAC_WRITE_DMA_EXT:
7680 					case SATAC_WRITE_DMA_QUEUED:
7681 					case SATAC_WRITE_DMA_QUEUED_EXT:
7682 					case SATAC_WRITE_FPDMA_QUEUED:
7683 						/* Write error */
7684 						sense->es_add_code =
7685 						    SD_SCSI_ASC_WRITE_ERR;
7686 						break;
7687 					default:
7688 						/* Internal error */
7689 						SATA_LOG_D((
7690 						    spx->txlt_sata_hba_inst,
7691 						    CE_WARN,
7692 						    "sata_txlt_rw_completion :"
7693 						    "internal error - invalid "
7694 						    "command 0x%2x",
7695 						    scmd->satacmd_cmd_reg));
7696 						break;
7697 					}
7698 				}
7699 				break;
7700 			}
7701 			/* No extended sense key - no info available */
7702 			scsipkt->pkt_reason = CMD_INCOMPLETE;
7703 			break;
7704 
7705 		case SATA_PKT_TIMEOUT:
7706 			scsipkt->pkt_reason = CMD_TIMEOUT;
7707 			scsipkt->pkt_statistics |=
7708 			    STAT_TIMEOUT | STAT_DEV_RESET;
7709 			sense->es_key = KEY_ABORTED_COMMAND;
7710 			break;
7711 
7712 		case SATA_PKT_ABORTED:
7713 			scsipkt->pkt_reason = CMD_ABORTED;
7714 			scsipkt->pkt_statistics |= STAT_ABORTED;
7715 			sense->es_key = KEY_ABORTED_COMMAND;
7716 			break;
7717 
7718 		case SATA_PKT_RESET:
7719 			scsipkt->pkt_reason = CMD_RESET;
7720 			scsipkt->pkt_statistics |= STAT_DEV_RESET;
7721 			sense->es_key = KEY_ABORTED_COMMAND;
7722 			break;
7723 
7724 		default:
7725 			SATA_LOG_D((spx->txlt_sata_hba_inst, CE_WARN,
7726 			    "sata_txlt_rw_completion: "
7727 			    "invalid packet completion reason"));
7728 			scsipkt->pkt_reason = CMD_TRAN_ERR;
7729 			break;
7730 		}
7731 	}
7732 	SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst,
7733 	    "Scsi_pkt completion reason %x\n", scsipkt->pkt_reason);
7734 
7735 	if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0)
7736 		/* scsi callback required */
7737 		scsi_hba_pkt_comp(scsipkt);
7738 }
7739 
7740 
7741 /*
7742  * Translate completion status of non-data commands (i.e. commands returning
7743  * no data).
7744  * pkt completion_reason is checked to determine the completion status.
7745  * Do scsi callback if necessary (FLAG_NOINTR == 0)
7746  *
7747  * Note: this function may be called also for synchronously executed
7748  * commands.
7749  * This function may be used only if scsi_pkt is non-NULL.
7750  */
7751 
7752 static	void
7753 sata_txlt_nodata_cmd_completion(sata_pkt_t *sata_pkt)
7754 {
7755 	sata_pkt_txlate_t *spx =
7756 	    (sata_pkt_txlate_t *)sata_pkt->satapkt_framework_private;
7757 	struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt;
7758 
7759 	sata_set_arq_data(sata_pkt);
7760 
7761 	if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0)
7762 		/* scsi callback required */
7763 		scsi_hba_pkt_comp(scsipkt);
7764 }
7765 
7766 /*
7767  * Completion handler for ATA Pass Through command
7768  */
7769 static void
7770 sata_txlt_apt_completion(sata_pkt_t *sata_pkt)
7771 {
7772 	sata_pkt_txlate_t *spx =
7773 	    (sata_pkt_txlate_t *)sata_pkt->satapkt_framework_private;
7774 	sata_cmd_t *scmd = &sata_pkt->satapkt_cmd;
7775 	struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt;
7776 	struct buf *bp;
7777 	uint8_t sense_key = 0, addl_sense_code = 0, addl_sense_qual = 0;
7778 
7779 	if (sata_pkt->satapkt_reason == SATA_PKT_COMPLETED) {
7780 		/* Normal completion */
7781 		scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET |
7782 		    STATE_SENT_CMD | STATE_XFERRED_DATA | STATE_GOT_STATUS;
7783 		scsipkt->pkt_reason = CMD_CMPLT;
7784 		*scsipkt->pkt_scbp = STATUS_GOOD;
7785 
7786 		/*
7787 		 * If the command has CK_COND set
7788 		 */
7789 		if (scsipkt->pkt_cdbp[2] & SATL_APT_BM_CK_COND) {
7790 			*scsipkt->pkt_scbp = STATUS_CHECK;
7791 			sata_fill_ata_return_desc(sata_pkt,
7792 			    KEY_RECOVERABLE_ERROR,
7793 			    SD_SCSI_ASC_APT_INFO_AVAIL, 0x1d);
7794 		}
7795 
7796 		if (spx->txlt_tmp_buf != NULL) {
7797 			/* Temporary buffer was used */
7798 			bp = spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp;
7799 			if (bp->b_flags & B_READ) {
7800 				bcopy(spx->txlt_tmp_buf, bp->b_un.b_addr,
7801 				    bp->b_bcount);
7802 			}
7803 		}
7804 	} else {
7805 		scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET |
7806 		    STATE_SENT_CMD | STATE_GOT_STATUS;
7807 		scsipkt->pkt_reason = CMD_INCOMPLETE;
7808 		*scsipkt->pkt_scbp = STATUS_CHECK;
7809 
7810 		/*
7811 		 * If DF or ERR was set, the HBA should have copied out the
7812 		 * status and error registers to the satacmd structure.
7813 		 */
7814 		if (scmd->satacmd_status_reg & SATA_STATUS_DF) {
7815 			sense_key = KEY_HARDWARE_ERROR;
7816 			addl_sense_code = SD_SCSI_ASC_INTERNAL_TARGET_FAILURE;
7817 			addl_sense_qual = 0;
7818 		} else if (scmd->satacmd_status_reg & SATA_STATUS_ERR) {
7819 			if (scmd->satacmd_error_reg & SATA_ERROR_NM) {
7820 				sense_key = KEY_NOT_READY;
7821 				addl_sense_code =
7822 				    SD_SCSI_ASC_MEDIUM_NOT_PRESENT;
7823 				addl_sense_qual = 0;
7824 			} else if (scmd->satacmd_error_reg & SATA_ERROR_UNC) {
7825 				sense_key = KEY_MEDIUM_ERROR;
7826 				addl_sense_code = SD_SCSI_ASC_UNREC_READ_ERR;
7827 				addl_sense_qual = 0;
7828 			} else if (scmd->satacmd_error_reg & SATA_ERROR_ILI) {
7829 				sense_key = KEY_DATA_PROTECT;
7830 				addl_sense_code = SD_SCSI_ASC_WRITE_PROTECTED;
7831 				addl_sense_qual = 0;
7832 			} else if (scmd->satacmd_error_reg & SATA_ERROR_IDNF) {
7833 				sense_key = KEY_ILLEGAL_REQUEST;
7834 				addl_sense_code = SD_SCSI_ASC_LBA_OUT_OF_RANGE;
7835 				addl_sense_qual = 0;
7836 			} else if (scmd->satacmd_error_reg & SATA_ERROR_ABORT) {
7837 				sense_key = KEY_ABORTED_COMMAND;
7838 				addl_sense_code = SD_SCSI_ASC_NO_ADD_SENSE;
7839 				addl_sense_qual = 0;
7840 			} else if (scmd->satacmd_error_reg & SATA_ERROR_MC) {
7841 				sense_key = KEY_UNIT_ATTENTION;
7842 				addl_sense_code =
7843 				    SD_SCSI_ASC_MEDIUM_MAY_HAVE_CHANGED;
7844 				addl_sense_qual = 0;
7845 			} else if (scmd->satacmd_error_reg & SATA_ERROR_MCR) {
7846 				sense_key = KEY_UNIT_ATTENTION;
7847 				addl_sense_code = SD_SCSI_ASC_OP_MEDIUM_REM_REQ;
7848 				addl_sense_qual = 0;
7849 			} else if (scmd->satacmd_error_reg & SATA_ERROR_ICRC) {
7850 				sense_key = KEY_ABORTED_COMMAND;
7851 				addl_sense_code =
7852 				    SD_SCSI_ASC_INFO_UNIT_IUCRC_ERR;
7853 				addl_sense_qual = 0;
7854 			}
7855 		}
7856 
7857 		sata_fill_ata_return_desc(sata_pkt, sense_key, addl_sense_code,
7858 		    addl_sense_qual);
7859 	}
7860 
7861 	if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0)
7862 		/* scsi callback required */
7863 		scsi_hba_pkt_comp(scsipkt);
7864 }
7865 
7866 /*
7867  * Completion handler for unmap translation command
7868  */
7869 static void
7870 sata_txlt_unmap_completion(sata_pkt_t *sata_pkt)
7871 {
7872 	sata_pkt_txlate_t *spx =
7873 	    (sata_pkt_txlate_t *)sata_pkt->satapkt_framework_private;
7874 	sata_cmd_t *scmd = &sata_pkt->satapkt_cmd;
7875 	struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt;
7876 	struct buf *bp;
7877 	uint8_t sense_key = 0, addl_sense_code = 0, addl_sense_qual = 0;
7878 
7879 	if (sata_pkt->satapkt_reason == SATA_PKT_COMPLETED) {
7880 		/* Normal completion */
7881 		scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET |
7882 		    STATE_SENT_CMD | STATE_XFERRED_DATA | STATE_GOT_STATUS;
7883 		scsipkt->pkt_reason = CMD_CMPLT;
7884 		*scsipkt->pkt_scbp = STATUS_GOOD;
7885 
7886 		if (spx->txlt_tmp_buf != NULL) {
7887 			/* Temporary buffer was used */
7888 			bp = spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp;
7889 			if (bp->b_flags & B_READ) {
7890 				bcopy(spx->txlt_tmp_buf, bp->b_un.b_addr,
7891 				    bp->b_bcount);
7892 			}
7893 		}
7894 	} else {
7895 		scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET |
7896 		    STATE_SENT_CMD | STATE_GOT_STATUS;
7897 		scsipkt->pkt_reason = CMD_INCOMPLETE;
7898 		*scsipkt->pkt_scbp = STATUS_CHECK;
7899 
7900 		/*
7901 		 * If DF or ERR was set, the HBA should have copied out the
7902 		 * status and error registers to the satacmd structure.
7903 		 */
7904 		if (scmd->satacmd_status_reg & SATA_STATUS_DF) {
7905 			sense_key = KEY_HARDWARE_ERROR;
7906 			addl_sense_code = SD_SCSI_ASC_INTERNAL_TARGET_FAILURE;
7907 			addl_sense_qual = 0;
7908 		} else if (scmd->satacmd_status_reg & SATA_STATUS_ERR) {
7909 			if (scmd->satacmd_error_reg & SATA_ERROR_NM) {
7910 				sense_key = KEY_NOT_READY;
7911 				addl_sense_code =
7912 				    SD_SCSI_ASC_MEDIUM_NOT_PRESENT;
7913 				addl_sense_qual = 0;
7914 			} else if (scmd->satacmd_error_reg & SATA_ERROR_UNC) {
7915 				sense_key = KEY_MEDIUM_ERROR;
7916 				addl_sense_code = SD_SCSI_ASC_WRITE_ERR;
7917 				addl_sense_qual = 0;
7918 			} else if (scmd->satacmd_error_reg & SATA_ERROR_ILI) {
7919 				sense_key = KEY_DATA_PROTECT;
7920 				addl_sense_code = SD_SCSI_ASC_WRITE_PROTECTED;
7921 				addl_sense_qual = 0;
7922 			} else if (scmd->satacmd_error_reg & SATA_ERROR_IDNF) {
7923 				sense_key = KEY_ILLEGAL_REQUEST;
7924 				addl_sense_code = SD_SCSI_ASC_LBA_OUT_OF_RANGE;
7925 				addl_sense_qual = 0;
7926 			} else if (scmd->satacmd_error_reg & SATA_ERROR_ABORT) {
7927 				sense_key = KEY_ABORTED_COMMAND;
7928 				addl_sense_code = SD_SCSI_ASC_NO_ADD_SENSE;
7929 				addl_sense_qual = 0;
7930 			} else if (scmd->satacmd_error_reg & SATA_ERROR_MC) {
7931 				sense_key = KEY_UNIT_ATTENTION;
7932 				addl_sense_code =
7933 				    SD_SCSI_ASC_MEDIUM_MAY_HAVE_CHANGED;
7934 				addl_sense_qual = 0;
7935 			} else if (scmd->satacmd_error_reg & SATA_ERROR_MCR) {
7936 				sense_key = KEY_UNIT_ATTENTION;
7937 				addl_sense_code = SD_SCSI_ASC_OP_MEDIUM_REM_REQ;
7938 				addl_sense_qual = 0;
7939 			} else if (scmd->satacmd_error_reg & SATA_ERROR_ICRC) {
7940 				sense_key = KEY_ABORTED_COMMAND;
7941 				addl_sense_code =
7942 				    SD_SCSI_ASC_INFO_UNIT_IUCRC_ERR;
7943 				addl_sense_qual = 0;
7944 			}
7945 		}
7946 
7947 		sata_fill_ata_return_desc(sata_pkt, sense_key, addl_sense_code,
7948 		    addl_sense_qual);
7949 	}
7950 
7951 	sata_free_local_buffer(spx);
7952 
7953 	if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0)
7954 		/* scsi callback required */
7955 		scsi_hba_pkt_comp(scsipkt);
7956 }
7957 
7958 /*
7959  *
7960  */
7961 static void
7962 sata_fill_ata_return_desc(sata_pkt_t *sata_pkt, uint8_t sense_key,
7963     uint8_t addl_sense_code, uint8_t addl_sense_qual)
7964 {
7965 	sata_pkt_txlate_t *spx =
7966 	    (sata_pkt_txlate_t *)sata_pkt->satapkt_framework_private;
7967 	sata_cmd_t *scmd = &sata_pkt->satapkt_cmd;
7968 	struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt;
7969 	struct sata_apt_sense_data *apt_sd =
7970 	    (struct sata_apt_sense_data *)scsipkt->pkt_scbp;
7971 	struct scsi_descr_sense_hdr *sds = &(apt_sd->apt_sd_hdr);
7972 	struct scsi_ata_status_ret_sense_descr *ata_ret_desc =
7973 	    &(apt_sd->apt_sd_sense);
7974 	int extend = 0;
7975 
7976 	if ((scsipkt->pkt_cdbp[0] == SPC3_CMD_ATA_COMMAND_PASS_THROUGH16) &&
7977 	    (scsipkt->pkt_cdbp[2] & SATL_APT_BM_EXTEND))
7978 		extend = 1;
7979 
7980 	scsipkt->pkt_state |= STATE_ARQ_DONE;
7981 
7982 	/* update the residual count */
7983 	*(uchar_t *)&apt_sd->apt_status = STATUS_CHECK;
7984 	*(uchar_t *)&apt_sd->apt_rqpkt_status = STATUS_GOOD;
7985 	apt_sd->apt_rqpkt_reason = CMD_CMPLT;
7986 	apt_sd->apt_rqpkt_state = STATE_GOT_BUS | STATE_GOT_TARGET |
7987 	    STATE_XFERRED_DATA | STATE_SENT_CMD | STATE_GOT_STATUS;
7988 	apt_sd->apt_rqpkt_resid = scsipkt->pkt_scblen -
7989 	    sizeof (struct sata_apt_sense_data);
7990 
7991 	/*
7992 	 * Fill in the Descriptor sense header
7993 	 */
7994 	bzero(sds, sizeof (struct scsi_descr_sense_hdr));
7995 	sds->ds_code = CODE_FMT_DESCR_CURRENT;
7996 	sds->ds_class = CLASS_EXTENDED_SENSE;
7997 	sds->ds_key = sense_key & 0xf;
7998 	sds->ds_add_code = addl_sense_code;
7999 	sds->ds_qual_code = addl_sense_qual;
8000 	sds->ds_addl_sense_length =
8001 	    sizeof (struct scsi_ata_status_ret_sense_descr);
8002 
8003 	/*
8004 	 * Fill in the ATA Return descriptor sense data
8005 	 */
8006 	bzero(ata_ret_desc, sizeof (struct scsi_ata_status_ret_sense_descr));
8007 	ata_ret_desc->ars_descr_type = DESCR_ATA_STATUS_RETURN;
8008 	ata_ret_desc->ars_addl_length = 0xc;
8009 	ata_ret_desc->ars_error = scmd->satacmd_error_reg;
8010 	ata_ret_desc->ars_sec_count_lsb = scmd->satacmd_sec_count_lsb;
8011 	ata_ret_desc->ars_lba_low_lsb = scmd->satacmd_lba_low_lsb;
8012 	ata_ret_desc->ars_lba_mid_lsb = scmd->satacmd_lba_mid_lsb;
8013 	ata_ret_desc->ars_lba_high_lsb = scmd->satacmd_lba_high_lsb;
8014 	ata_ret_desc->ars_device = scmd->satacmd_device_reg;
8015 	ata_ret_desc->ars_status = scmd->satacmd_status_reg;
8016 
8017 	if (extend == 1) {
8018 		ata_ret_desc->ars_extend = 1;
8019 		ata_ret_desc->ars_sec_count_msb = scmd->satacmd_sec_count_msb;
8020 		ata_ret_desc->ars_lba_low_msb = scmd->satacmd_lba_low_msb;
8021 		ata_ret_desc->ars_lba_mid_msb = scmd->satacmd_lba_mid_msb;
8022 		ata_ret_desc->ars_lba_high_msb = scmd->satacmd_lba_high_msb;
8023 	} else {
8024 		ata_ret_desc->ars_extend = 0;
8025 		ata_ret_desc->ars_sec_count_msb = 0;
8026 		ata_ret_desc->ars_lba_low_msb = 0;
8027 		ata_ret_desc->ars_lba_mid_msb = 0;
8028 		ata_ret_desc->ars_lba_high_msb = 0;
8029 	}
8030 }
8031 
8032 static	void
8033 sata_set_arq_data(sata_pkt_t *sata_pkt)
8034 {
8035 	sata_pkt_txlate_t *spx =
8036 	    (sata_pkt_txlate_t *)sata_pkt->satapkt_framework_private;
8037 	struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt;
8038 	struct scsi_extended_sense *sense;
8039 
8040 	scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET |
8041 	    STATE_SENT_CMD | STATE_GOT_STATUS;
8042 	if (sata_pkt->satapkt_reason == SATA_PKT_COMPLETED) {
8043 		/* Normal completion */
8044 		scsipkt->pkt_reason = CMD_CMPLT;
8045 		*scsipkt->pkt_scbp = STATUS_GOOD;
8046 	} else {
8047 		/* Something went wrong */
8048 		scsipkt->pkt_reason = CMD_INCOMPLETE;
8049 		*scsipkt->pkt_scbp = STATUS_CHECK;
8050 		sense = sata_arq_sense(spx);
8051 		switch (sata_pkt->satapkt_reason) {
8052 		case SATA_PKT_PORT_ERROR:
8053 			/*
8054 			 * We have no device data. Assume no data transfered.
8055 			 */
8056 			sense->es_key = KEY_HARDWARE_ERROR;
8057 			break;
8058 
8059 		case SATA_PKT_DEV_ERROR:
8060 			if (sata_pkt->satapkt_cmd.satacmd_status_reg &
8061 			    SATA_STATUS_ERR) {
8062 				/*
8063 				 * determine dev error reason from error
8064 				 * reg content
8065 				 */
8066 				sata_decode_device_error(spx, sense);
8067 				break;
8068 			}
8069 			/* No extended sense key - no info available */
8070 			break;
8071 
8072 		case SATA_PKT_TIMEOUT:
8073 			scsipkt->pkt_reason = CMD_TIMEOUT;
8074 			scsipkt->pkt_statistics |=
8075 			    STAT_TIMEOUT | STAT_DEV_RESET;
8076 			/* No extended sense key ? */
8077 			break;
8078 
8079 		case SATA_PKT_ABORTED:
8080 			scsipkt->pkt_reason = CMD_ABORTED;
8081 			scsipkt->pkt_statistics |= STAT_ABORTED;
8082 			/* No extended sense key ? */
8083 			break;
8084 
8085 		case SATA_PKT_RESET:
8086 			/* pkt aborted by an explicit reset from a host */
8087 			scsipkt->pkt_reason = CMD_RESET;
8088 			scsipkt->pkt_statistics |= STAT_DEV_RESET;
8089 			break;
8090 
8091 		default:
8092 			SATA_LOG_D((spx->txlt_sata_hba_inst, CE_WARN,
8093 			    "sata_txlt_nodata_cmd_completion: "
8094 			    "invalid packet completion reason %d",
8095 			    sata_pkt->satapkt_reason));
8096 			scsipkt->pkt_reason = CMD_TRAN_ERR;
8097 			break;
8098 		}
8099 
8100 	}
8101 	SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst,
8102 	    "Scsi_pkt completion reason %x\n", scsipkt->pkt_reason);
8103 }
8104 
8105 
8106 /*
8107  * Build Mode sense R/W recovery page
8108  * NOT IMPLEMENTED
8109  */
8110 
8111 static int
8112 sata_build_msense_page_1(sata_drive_info_t *sdinfo, int pcntrl, uint8_t *buf)
8113 {
8114 #ifndef __lock_lint
8115 	_NOTE(ARGUNUSED(sdinfo))
8116 	_NOTE(ARGUNUSED(pcntrl))
8117 	_NOTE(ARGUNUSED(buf))
8118 #endif
8119 	return (0);
8120 }
8121 
8122 /*
8123  * Build Mode sense caching page  -  scsi-3 implementation.
8124  * Page length distinguishes previous format from scsi-3 format.
8125  * buf must have space for 0x12 bytes.
8126  * Only DRA (disable read ahead ) and WCE (write cache enable) are changeable.
8127  *
8128  */
8129 static int
8130 sata_build_msense_page_8(sata_drive_info_t *sdinfo, int pcntrl, uint8_t *buf)
8131 {
8132 	struct mode_cache_scsi3 *page = (struct mode_cache_scsi3 *)buf;
8133 	sata_id_t *sata_id = &sdinfo->satadrv_id;
8134 
8135 	/*
8136 	 * Most of the fields are set to 0, being not supported and/or disabled
8137 	 */
8138 	bzero(buf, PAGELENGTH_DAD_MODE_CACHE_SCSI3);
8139 
8140 	/* Saved paramters not supported */
8141 	if (pcntrl == 3)
8142 		return (0);
8143 	if (pcntrl == 0 || pcntrl == 2) {
8144 		/*
8145 		 * For now treat current and default parameters as same
8146 		 * That may have to change, if target driver will complain
8147 		 */
8148 		page->mode_page.code = MODEPAGE_CACHING;	/* PS = 0 */
8149 		page->mode_page.length = PAGELENGTH_DAD_MODE_CACHE_SCSI3;
8150 
8151 		if (SATA_READ_AHEAD_SUPPORTED(*sata_id) &&
8152 		    !SATA_READ_AHEAD_ENABLED(*sata_id)) {
8153 			page->dra = 1;		/* Read Ahead disabled */
8154 			page->rcd = 1;		/* Read Cache disabled */
8155 		}
8156 		if (SATA_WRITE_CACHE_SUPPORTED(*sata_id) &&
8157 		    SATA_WRITE_CACHE_ENABLED(*sata_id))
8158 			page->wce = 1;		/* Write Cache enabled */
8159 	} else {
8160 		/* Changeable parameters */
8161 		page->mode_page.code = MODEPAGE_CACHING;
8162 		page->mode_page.length = PAGELENGTH_DAD_MODE_CACHE_SCSI3;
8163 		if (SATA_READ_AHEAD_SUPPORTED(*sata_id)) {
8164 			page->dra = 1;
8165 			page->rcd = 1;
8166 		}
8167 		if (SATA_WRITE_CACHE_SUPPORTED(*sata_id))
8168 			page->wce = 1;
8169 	}
8170 	return (PAGELENGTH_DAD_MODE_CACHE_SCSI3 +
8171 	    sizeof (struct mode_page));
8172 }
8173 
8174 /*
8175  * Build Mode sense exception cntrl page
8176  */
8177 static int
8178 sata_build_msense_page_1c(sata_drive_info_t *sdinfo, int pcntrl, uint8_t *buf)
8179 {
8180 	struct mode_info_excpt_page *page = (struct mode_info_excpt_page *)buf;
8181 	sata_id_t *sata_id = &sdinfo->satadrv_id;
8182 
8183 	/*
8184 	 * Most of the fields are set to 0, being not supported and/or disabled
8185 	 */
8186 	bzero(buf, PAGELENGTH_INFO_EXCPT);
8187 
8188 	page->mode_page.code = MODEPAGE_INFO_EXCPT;
8189 	page->mode_page.length = PAGELENGTH_INFO_EXCPT;
8190 
8191 	/* Indicate that this is page is saveable */
8192 	page->mode_page.ps = 1;
8193 
8194 	/*
8195 	 * We will return the same data for default, current and saved page.
8196 	 * The only changeable bit is dexcpt and that bit is required
8197 	 * by the ATA specification to be preserved across power cycles.
8198 	 */
8199 	if (pcntrl != 1) {
8200 		page->dexcpt = !(sata_id->ai_features85 & SATA_SMART_SUPPORTED);
8201 		page->mrie = MRIE_ONLY_ON_REQUEST;
8202 	}
8203 	else
8204 		page->dexcpt = 1;	/* Only changeable parameter */
8205 
8206 	return (PAGELENGTH_INFO_EXCPT + sizeof (struct mode_page));
8207 }
8208 
8209 
8210 static int
8211 sata_build_msense_page_30(sata_drive_info_t *sdinfo, int pcntrl, uint8_t *buf)
8212 {
8213 	struct mode_acoustic_management *page =
8214 	    (struct mode_acoustic_management *)buf;
8215 	sata_id_t *sata_id = &sdinfo->satadrv_id;
8216 
8217 	/*
8218 	 * Most of the fields are set to 0, being not supported and/or disabled
8219 	 */
8220 	bzero(buf, PAGELENGTH_DAD_MODE_ACOUSTIC_MANAGEMENT);
8221 
8222 	switch (pcntrl) {
8223 	case P_CNTRL_DEFAULT:
8224 		/*  default paramters not supported */
8225 		return (0);
8226 
8227 	case P_CNTRL_CURRENT:
8228 	case P_CNTRL_SAVED:
8229 		/* Saved and current are supported and are identical */
8230 		page->mode_page.code = MODEPAGE_ACOUSTIC_MANAG;
8231 		page->mode_page.length =
8232 		    PAGELENGTH_DAD_MODE_ACOUSTIC_MANAGEMENT;
8233 		page->mode_page.ps = 1;
8234 
8235 		/* Word 83 indicates if feature is supported */
8236 		/* If feature is not supported */
8237 		if (!(sata_id->ai_cmdset83 & SATA_ACOUSTIC_MGMT)) {
8238 			page->acoustic_manag_enable =
8239 			    ACOUSTIC_DISABLED;
8240 		} else {
8241 			page->acoustic_manag_enable =
8242 			    ((sata_id->ai_features86 & SATA_ACOUSTIC_MGMT)
8243 			    != 0);
8244 			/* Word 94 inidicates the value */
8245 #ifdef	_LITTLE_ENDIAN
8246 			page->acoustic_manag_level =
8247 			    (uchar_t)sata_id->ai_acoustic;
8248 			page->vendor_recommended_value =
8249 			    sata_id->ai_acoustic >> 8;
8250 #else
8251 			page->acoustic_manag_level =
8252 			    sata_id->ai_acoustic >> 8;
8253 			page->vendor_recommended_value =
8254 			    (uchar_t)sata_id->ai_acoustic;
8255 #endif
8256 		}
8257 		break;
8258 
8259 	case P_CNTRL_CHANGEABLE:
8260 		page->mode_page.code = MODEPAGE_ACOUSTIC_MANAG;
8261 		page->mode_page.length =
8262 		    PAGELENGTH_DAD_MODE_ACOUSTIC_MANAGEMENT;
8263 		page->mode_page.ps = 1;
8264 
8265 		/* Word 83 indicates if the feature is supported */
8266 		if (sata_id->ai_cmdset83 & SATA_ACOUSTIC_MGMT) {
8267 			page->acoustic_manag_enable =
8268 			    ACOUSTIC_ENABLED;
8269 			page->acoustic_manag_level = 0xff;
8270 		}
8271 		break;
8272 	}
8273 	return (PAGELENGTH_DAD_MODE_ACOUSTIC_MANAGEMENT +
8274 	    sizeof (struct mode_page));
8275 }
8276 
8277 
8278 /*
8279  * Build Mode sense power condition page.
8280  */
8281 static int
8282 sata_build_msense_page_1a(sata_drive_info_t *sdinfo, int pcntrl, uint8_t *buf)
8283 {
8284 	struct mode_info_power_cond *page = (struct mode_info_power_cond *)buf;
8285 	sata_id_t *sata_id = &sdinfo->satadrv_id;
8286 
8287 	/*
8288 	 * Most of the fields are set to 0, being not supported and/or disabled
8289 	 * power condition page length was 0x0a
8290 	 */
8291 	bzero(buf, sizeof (struct mode_info_power_cond));
8292 
8293 	if (pcntrl == P_CNTRL_DEFAULT) {
8294 		/*  default paramters not supported */
8295 		return (0);
8296 	}
8297 
8298 	page->mode_page.code = MODEPAGE_POWER_COND;
8299 	page->mode_page.length = sizeof (struct mode_info_power_cond);
8300 
8301 	if (sata_id->ai_cap & SATA_STANDBYTIMER) {
8302 		page->standby = 1;
8303 		bcopy(sdinfo->satadrv_standby_timer, page->standby_cond_timer,
8304 		    sizeof (uchar_t) * 4);
8305 	}
8306 
8307 	return (sizeof (struct mode_info_power_cond));
8308 }
8309 
8310 /*
8311  * Process mode select caching page 8 (scsi3 format only).
8312  * Read Ahead (same as read cache) and Write Cache may be turned on and off
8313  * if these features are supported by the device. If these features are not
8314  * supported, the command will be terminated with STATUS_CHECK.
8315  * This function fails only if the SET FEATURE command sent to
8316  * the device fails. The page format is not verified, assuming that the
8317  * target driver operates correctly - if parameters length is too short,
8318  * we just drop the page.
8319  * Two command may be sent if both Read Cache/Read Ahead and Write Cache
8320  * setting have to be changed.
8321  * SET FEATURE command is executed synchronously, i.e. we wait here until
8322  * it is completed, regardless of the scsi pkt directives.
8323  *
8324  * Note: Mode Select Caching page RCD and DRA bits are tied together, i.e.
8325  * changing DRA will change RCD.
8326  *
8327  * More than one SATA command may be executed to perform operations specified
8328  * by mode select pages. The first error terminates further execution.
8329  * Operations performed successully are not backed-up in such case.
8330  *
8331  * Return SATA_SUCCESS if operation succeeded, SATA_FAILURE otherwise.
8332  * If operation resulted in changing device setup, dmod flag should be set to
8333  * one (1). If parameters were not changed, dmod flag should be set to 0.
8334  * Upon return, if operation required sending command to the device, the rval
8335  * should be set to the value returned by sata_hba_start. If operation
8336  * did not require device access, rval should be set to TRAN_ACCEPT.
8337  * The pagelen should be set to the length of the page.
8338  *
8339  * This function has to be called with a port mutex held.
8340  *
8341  * Returns SATA_SUCCESS if operation was successful, SATA_FAILURE otherwise.
8342  */
8343 int
8344 sata_mode_select_page_8(sata_pkt_txlate_t *spx, struct mode_cache_scsi3 *page,
8345     int parmlen, int *pagelen, int *rval, int *dmod)
8346 {
8347 	struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt;
8348 	sata_drive_info_t *sdinfo;
8349 	sata_cmd_t *scmd = &spx->txlt_sata_pkt->satapkt_cmd;
8350 	sata_id_t *sata_id;
8351 	struct scsi_extended_sense *sense;
8352 	int wce, dra;	/* Current settings */
8353 
8354 	sdinfo = sata_get_device_info(spx->txlt_sata_hba_inst,
8355 	    &spx->txlt_sata_pkt->satapkt_device);
8356 	sata_id = &sdinfo->satadrv_id;
8357 	*dmod = 0;
8358 
8359 	/* Verify parameters length. If too short, drop it */
8360 	if ((PAGELENGTH_DAD_MODE_CACHE_SCSI3 +
8361 	    sizeof (struct mode_page)) > parmlen) {
8362 		*scsipkt->pkt_scbp = STATUS_CHECK;
8363 		sense = sata_arq_sense(spx);
8364 		sense->es_key = KEY_ILLEGAL_REQUEST;
8365 		sense->es_add_code = SD_SCSI_ASC_INVALID_FIELD_IN_PARAMS_LIST;
8366 		*pagelen = parmlen;
8367 		*rval = TRAN_ACCEPT;
8368 		return (SATA_FAILURE);
8369 	}
8370 
8371 	*pagelen = PAGELENGTH_DAD_MODE_CACHE_SCSI3 + sizeof (struct mode_page);
8372 
8373 	/* Current setting of Read Ahead (and Read Cache) */
8374 	if (SATA_READ_AHEAD_ENABLED(*sata_id))
8375 		dra = 0;	/* 0 == not disabled */
8376 	else
8377 		dra = 1;
8378 	/* Current setting of Write Cache */
8379 	if (SATA_WRITE_CACHE_ENABLED(*sata_id))
8380 		wce = 1;
8381 	else
8382 		wce = 0;
8383 
8384 	if (page->dra == dra && page->wce == wce && page->rcd == dra) {
8385 		/* nothing to do */
8386 		*rval = TRAN_ACCEPT;
8387 		return (SATA_SUCCESS);
8388 	}
8389 
8390 	/*
8391 	 * Need to flip some setting
8392 	 * Set-up Internal SET FEATURES command(s)
8393 	 */
8394 	scmd->satacmd_flags.sata_data_direction = SATA_DIR_NODATA_XFER;
8395 	scmd->satacmd_addr_type = 0;
8396 	scmd->satacmd_device_reg = 0;
8397 	scmd->satacmd_status_reg = 0;
8398 	scmd->satacmd_error_reg = 0;
8399 	scmd->satacmd_cmd_reg = SATAC_SET_FEATURES;
8400 	if (page->dra != dra || page->rcd != dra) {
8401 		if (SATA_READ_AHEAD_SUPPORTED(*sata_id)) {
8402 			/* Need to flip read ahead setting */
8403 			if (dra == 0)
8404 				/* Disable read ahead / read cache */
8405 				scmd->satacmd_features_reg =
8406 				    SATAC_SF_DISABLE_READ_AHEAD;
8407 			else
8408 				/* Enable read ahead  / read cache */
8409 				scmd->satacmd_features_reg =
8410 				    SATAC_SF_ENABLE_READ_AHEAD;
8411 
8412 			/* Transfer command to HBA */
8413 			if (sata_hba_start(spx, rval) != 0)
8414 				/*
8415 				 * Pkt not accepted for execution.
8416 				 */
8417 				return (SATA_FAILURE);
8418 
8419 			*dmod = 1;
8420 
8421 			/* Now process return */
8422 			if (spx->txlt_sata_pkt->satapkt_reason !=
8423 			    SATA_PKT_COMPLETED) {
8424 				goto failure;	/* Terminate */
8425 			}
8426 		} else {
8427 			*scsipkt->pkt_scbp = STATUS_CHECK;
8428 			sense = sata_arq_sense(spx);
8429 			sense->es_key = KEY_ILLEGAL_REQUEST;
8430 			sense->es_add_code =
8431 			    SD_SCSI_ASC_INVALID_FIELD_IN_PARAMS_LIST;
8432 			*pagelen = parmlen;
8433 			*rval = TRAN_ACCEPT;
8434 			return (SATA_FAILURE);
8435 		}
8436 	}
8437 
8438 	/* Note that the packet is not removed, so it could be re-used */
8439 	if (page->wce != wce) {
8440 		if (SATA_WRITE_CACHE_SUPPORTED(*sata_id)) {
8441 			/* Need to flip Write Cache setting */
8442 			if (page->wce == 1)
8443 				/* Enable write cache */
8444 				scmd->satacmd_features_reg =
8445 				    SATAC_SF_ENABLE_WRITE_CACHE;
8446 			else
8447 				/* Disable write cache */
8448 				scmd->satacmd_features_reg =
8449 				    SATAC_SF_DISABLE_WRITE_CACHE;
8450 
8451 			/* Transfer command to HBA */
8452 			if (sata_hba_start(spx, rval) != 0)
8453 				/*
8454 				 * Pkt not accepted for execution.
8455 				 */
8456 				return (SATA_FAILURE);
8457 
8458 			*dmod = 1;
8459 
8460 			/* Now process return */
8461 			if (spx->txlt_sata_pkt->satapkt_reason !=
8462 			    SATA_PKT_COMPLETED) {
8463 				goto failure;
8464 			}
8465 		} else {
8466 			*scsipkt->pkt_scbp = STATUS_CHECK;
8467 			sense = sata_arq_sense(spx);
8468 			sense->es_key = KEY_ILLEGAL_REQUEST;
8469 			sense->es_add_code =
8470 			    SD_SCSI_ASC_INVALID_FIELD_IN_PARAMS_LIST;
8471 			*pagelen = parmlen;
8472 			*rval = TRAN_ACCEPT;
8473 			return (SATA_FAILURE);
8474 		}
8475 	}
8476 	return (SATA_SUCCESS);
8477 
8478 failure:
8479 	sata_xlate_errors(spx);
8480 
8481 	return (SATA_FAILURE);
8482 }
8483 
8484 /*
8485  * Process mode select informational exceptions control page 0x1c
8486  *
8487  * The only changeable bit is dexcpt (disable exceptions).
8488  * MRIE (method of reporting informational exceptions) must be
8489  * "only on request".
8490  * This page applies to informational exceptions that report
8491  * additional sense codes with the ADDITIONAL SENSE CODE field set to 5Dh
8492  * (e.g.,FAILURE PREDICTION THRESHOLD EXCEEDED) or 0Bh (e.g., WARNING_).
8493  * Informational exception conditions occur as the result of background scan
8494  * errors, background self-test errors, or vendor specific events within a
8495  * logical unit. An informational exception condition may occur asynchronous
8496  * to any commands.
8497  *
8498  * Returns: SATA_SUCCESS if operation succeeded, SATA_FAILURE otherwise.
8499  * If operation resulted in changing device setup, dmod flag should be set to
8500  * one (1). If parameters were not changed, dmod flag should be set to 0.
8501  * Upon return, if operation required sending command to the device, the rval
8502  * should be set to the value returned by sata_hba_start. If operation
8503  * did not require device access, rval should be set to TRAN_ACCEPT.
8504  * The pagelen should be set to the length of the page.
8505  *
8506  * This function has to be called with a port mutex held.
8507  *
8508  * Returns SATA_SUCCESS if operation was successful, SATA_FAILURE otherwise.
8509  *
8510  * Cannot be called in the interrupt context.
8511  */
8512 static	int
8513 sata_mode_select_page_1c(
8514 	sata_pkt_txlate_t *spx,
8515 	struct mode_info_excpt_page *page,
8516 	int parmlen,
8517 	int *pagelen,
8518 	int *rval,
8519 	int *dmod)
8520 {
8521 	struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt;
8522 	sata_cmd_t *scmd = &spx->txlt_sata_pkt->satapkt_cmd;
8523 	sata_drive_info_t *sdinfo;
8524 	sata_id_t *sata_id;
8525 	struct scsi_extended_sense *sense;
8526 
8527 	sdinfo = sata_get_device_info(spx->txlt_sata_hba_inst,
8528 	    &spx->txlt_sata_pkt->satapkt_device);
8529 	sata_id = &sdinfo->satadrv_id;
8530 
8531 	*dmod = 0;
8532 
8533 	/* Verify parameters length. If too short, drop it */
8534 	if (((PAGELENGTH_INFO_EXCPT + sizeof (struct mode_page)) > parmlen) ||
8535 	    page->perf || page->test || (page->mrie != MRIE_ONLY_ON_REQUEST)) {
8536 		*scsipkt->pkt_scbp = STATUS_CHECK;
8537 		sense = sata_arq_sense(spx);
8538 		sense->es_key = KEY_ILLEGAL_REQUEST;
8539 		sense->es_add_code = SD_SCSI_ASC_INVALID_FIELD_IN_PARAMS_LIST;
8540 		*pagelen = parmlen;
8541 		*rval = TRAN_ACCEPT;
8542 		return (SATA_FAILURE);
8543 	}
8544 
8545 	*pagelen = PAGELENGTH_INFO_EXCPT + sizeof (struct mode_page);
8546 
8547 	if (! (sata_id->ai_cmdset82 & SATA_SMART_SUPPORTED)) {
8548 		*scsipkt->pkt_scbp = STATUS_CHECK;
8549 		sense = sata_arq_sense(spx);
8550 		sense->es_key = KEY_ILLEGAL_REQUEST;
8551 		sense->es_add_code = SD_SCSI_ASC_INVALID_FIELD_IN_CDB;
8552 		*pagelen = parmlen;
8553 		*rval = TRAN_ACCEPT;
8554 		return (SATA_FAILURE);
8555 	}
8556 
8557 	/* If already in the state requested, we are done */
8558 	if (page->dexcpt == ! (sata_id->ai_features85 & SATA_SMART_ENABLED)) {
8559 		/* nothing to do */
8560 		*rval = TRAN_ACCEPT;
8561 		return (SATA_SUCCESS);
8562 	}
8563 
8564 	scmd->satacmd_flags.sata_data_direction = SATA_DIR_NODATA_XFER;
8565 
8566 	/* Build SMART_ENABLE or SMART_DISABLE command */
8567 	scmd->satacmd_addr_type = 0;		/* N/A */
8568 	scmd->satacmd_lba_mid_lsb = SMART_MAGIC_VAL_1;
8569 	scmd->satacmd_lba_high_lsb = SMART_MAGIC_VAL_2;
8570 	scmd->satacmd_features_reg = page->dexcpt ?
8571 	    SATA_SMART_DISABLE_OPS : SATA_SMART_ENABLE_OPS;
8572 	scmd->satacmd_device_reg = 0;		/* Always device 0 */
8573 	scmd->satacmd_cmd_reg = SATAC_SMART;
8574 
8575 	/* Transfer command to HBA */
8576 	if (sata_hba_start(spx, rval) != 0)
8577 		/*
8578 		 * Pkt not accepted for execution.
8579 		 */
8580 		return (SATA_FAILURE);
8581 
8582 	*dmod = 1;	/* At least may have been modified */
8583 
8584 	/* Now process return */
8585 	if (spx->txlt_sata_pkt->satapkt_reason == SATA_PKT_COMPLETED)
8586 		return (SATA_SUCCESS);
8587 
8588 	/* Packet did not complete successfully */
8589 	sata_xlate_errors(spx);
8590 
8591 	return (SATA_FAILURE);
8592 }
8593 
8594 /*
8595  * Process mode select acoustic management control page 0x30
8596  *
8597  *
8598  * This function has to be called with a port mutex held.
8599  *
8600  * Returns SATA_SUCCESS if operation was successful, SATA_FAILURE otherwise.
8601  *
8602  * Cannot be called in the interrupt context.
8603  */
8604 int
8605 sata_mode_select_page_30(sata_pkt_txlate_t *spx, struct
8606     mode_acoustic_management *page, int parmlen, int *pagelen,
8607     int *rval, int *dmod)
8608 {
8609 	struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt;
8610 	sata_drive_info_t *sdinfo;
8611 	sata_cmd_t *scmd = &spx->txlt_sata_pkt->satapkt_cmd;
8612 	sata_id_t *sata_id;
8613 	struct scsi_extended_sense *sense;
8614 
8615 	sdinfo = sata_get_device_info(spx->txlt_sata_hba_inst,
8616 	    &spx->txlt_sata_pkt->satapkt_device);
8617 	sata_id = &sdinfo->satadrv_id;
8618 	*dmod = 0;
8619 
8620 	/* If parmlen is too short or the feature is not supported, drop it */
8621 	if (((PAGELENGTH_DAD_MODE_ACOUSTIC_MANAGEMENT +
8622 	    sizeof (struct mode_page)) > parmlen) ||
8623 	    (! (sata_id->ai_cmdset83 & SATA_ACOUSTIC_MGMT))) {
8624 		*scsipkt->pkt_scbp = STATUS_CHECK;
8625 		sense = sata_arq_sense(spx);
8626 		sense->es_key = KEY_ILLEGAL_REQUEST;
8627 		sense->es_add_code = SD_SCSI_ASC_INVALID_FIELD_IN_PARAMS_LIST;
8628 		*pagelen = parmlen;
8629 		*rval = TRAN_ACCEPT;
8630 		return (SATA_FAILURE);
8631 	}
8632 
8633 	*pagelen = PAGELENGTH_DAD_MODE_ACOUSTIC_MANAGEMENT +
8634 	    sizeof (struct mode_page);
8635 
8636 	/*
8637 	 * We can enable and disable acoustice management and
8638 	 * set the acoustic management level.
8639 	 */
8640 
8641 	/*
8642 	 * Set-up Internal SET FEATURES command(s)
8643 	 */
8644 	scmd->satacmd_flags.sata_data_direction = SATA_DIR_NODATA_XFER;
8645 	scmd->satacmd_addr_type = 0;
8646 	scmd->satacmd_device_reg = 0;
8647 	scmd->satacmd_status_reg = 0;
8648 	scmd->satacmd_error_reg = 0;
8649 	scmd->satacmd_cmd_reg = SATAC_SET_FEATURES;
8650 	if (page->acoustic_manag_enable) {
8651 		scmd->satacmd_features_reg = SATAC_SF_ENABLE_ACOUSTIC;
8652 		scmd->satacmd_sec_count_lsb = page->acoustic_manag_level;
8653 	} else {	/* disabling acoustic management */
8654 		scmd->satacmd_features_reg = SATAC_SF_DISABLE_ACOUSTIC;
8655 	}
8656 
8657 	/* Transfer command to HBA */
8658 	if (sata_hba_start(spx, rval) != 0)
8659 		/*
8660 		 * Pkt not accepted for execution.
8661 		 */
8662 		return (SATA_FAILURE);
8663 
8664 	/* Now process return */
8665 	if (spx->txlt_sata_pkt->satapkt_reason != SATA_PKT_COMPLETED) {
8666 		sata_xlate_errors(spx);
8667 		return (SATA_FAILURE);
8668 	}
8669 
8670 	*dmod = 1;
8671 
8672 	return (SATA_SUCCESS);
8673 }
8674 
8675 /*
8676  * Process mode select power condition page 0x1a
8677  *
8678  * This function has to be called with a port mutex held.
8679  *
8680  * Returns SATA_SUCCESS if operation was successful, SATA_FAILURE otherwise.
8681  *
8682  * Cannot be called in the interrupt context.
8683  */
8684 int
8685 sata_mode_select_page_1a(sata_pkt_txlate_t *spx, struct
8686     mode_info_power_cond *page, int parmlen, int *pagelen,
8687     int *rval, int *dmod)
8688 {
8689 	struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt;
8690 	sata_drive_info_t *sdinfo;
8691 	sata_cmd_t *scmd = &spx->txlt_sata_pkt->satapkt_cmd;
8692 	sata_id_t *sata_id;
8693 	struct scsi_extended_sense *sense;
8694 	uint8_t ata_count;
8695 	int i, len;
8696 
8697 	sdinfo = sata_get_device_info(spx->txlt_sata_hba_inst,
8698 	    &spx->txlt_sata_pkt->satapkt_device);
8699 	sata_id = &sdinfo->satadrv_id;
8700 	*dmod = 0;
8701 
8702 	len = sizeof (struct mode_info_power_cond);
8703 	len += sizeof (struct mode_page);
8704 
8705 	/* If parmlen is too short or the feature is not supported, drop it */
8706 	if ((len < parmlen) || (page->idle == 1) ||
8707 	    (!(sata_id->ai_cap & SATA_STANDBYTIMER) && page->standby == 1)) {
8708 		*scsipkt->pkt_scbp = STATUS_CHECK;
8709 		sense = sata_arq_sense(spx);
8710 		sense->es_key = KEY_ILLEGAL_REQUEST;
8711 		sense->es_add_code = SD_SCSI_ASC_INVALID_FIELD_IN_PARAMS_LIST;
8712 		*pagelen = parmlen;
8713 		*rval = TRAN_ACCEPT;
8714 		return (SATA_FAILURE);
8715 	}
8716 
8717 	*pagelen = len;
8718 
8719 	/*
8720 	 * Set-up Internal STANDBY command(s)
8721 	 */
8722 	if (page->standby == 0)
8723 		goto out;
8724 
8725 	ata_count = sata_get_standby_timer(page->standby_cond_timer);
8726 
8727 	scmd->satacmd_addr_type = 0;
8728 	scmd->satacmd_sec_count_lsb = ata_count;
8729 	scmd->satacmd_lba_low_lsb = 0;
8730 	scmd->satacmd_lba_mid_lsb = 0;
8731 	scmd->satacmd_lba_high_lsb = 0;
8732 	scmd->satacmd_features_reg = 0;
8733 	scmd->satacmd_device_reg = 0;
8734 	scmd->satacmd_status_reg = 0;
8735 	scmd->satacmd_cmd_reg = SATAC_STANDBY;
8736 	scmd->satacmd_flags.sata_special_regs = B_TRUE;
8737 	scmd->satacmd_flags.sata_copy_out_error_reg = B_TRUE;
8738 
8739 	/* Transfer command to HBA */
8740 	if (sata_hba_start(spx, rval) != 0) {
8741 		return (SATA_FAILURE);
8742 	} else {
8743 		if ((scmd->satacmd_error_reg != 0) ||
8744 		    (spx->txlt_sata_pkt->satapkt_reason !=
8745 		    SATA_PKT_COMPLETED)) {
8746 			sata_xlate_errors(spx);
8747 			return (SATA_FAILURE);
8748 		}
8749 	}
8750 
8751 	for (i = 0; i < 4; i++) {
8752 		sdinfo->satadrv_standby_timer[i] = page->standby_cond_timer[i];
8753 	}
8754 out:
8755 	*dmod = 1;
8756 	return (SATA_SUCCESS);
8757 }
8758 
8759 /* Helper functions for manipulating struct log_parameter */
8760 
8761 CTASSERT(sizeof (struct log_parameter) == 4);
8762 
8763 static inline struct log_parameter *
8764 log_param_next(struct log_parameter *lpp)
8765 {
8766 	uint8_t *ptr = (uint8_t *)lpp;
8767 
8768 	ptr += sizeof (*lpp) + lpp->param_len;
8769 	return ((struct log_parameter *)ptr);
8770 }
8771 
8772 static inline int
8773 log_param_size(const struct log_parameter *last, const void *startp)
8774 {
8775 	uintptr_t b = (uintptr_t)last;
8776 	uintptr_t a = (uintptr_t)startp;
8777 
8778 	ASSERT3U(b, >=, a);
8779 	return ((int)(b - a));
8780 }
8781 
8782 /*
8783  * sata_build_lsense_page0() is used to create the
8784  * SCSI LOG SENSE page 0 (supported log pages)
8785  *
8786  * Currently supported pages are 0, 0x10, 0x2f, 0x30 and 0x0e
8787  * (supported log pages, self-test results, informational exceptions
8788  * Sun vendor specific ATA SMART data, and start stop cycle counter).
8789  *
8790  * Takes a sata_drive_info t * and the address of a buffer
8791  * in which to create the page information.
8792  *
8793  * Returns the number of bytes valid in the buffer.
8794  */
8795 static	int
8796 sata_build_lsense_page_0(sata_drive_info_t *sdinfo, uint8_t *buf)
8797 {
8798 	uint8_t *ptr = buf;
8799 	sata_id_t *sata_id = &sdinfo->satadrv_id;
8800 
8801 	/* The supported log pages should be in ascending order */
8802 	*ptr++ = PAGE_CODE_GET_SUPPORTED_LOG_PAGES;
8803 
8804 	if (sata_id->ai_cmdset84 & SATA_GPL_SUPPORTED) {
8805 		*ptr++ = PAGE_CODE_READ_ERRORS;
8806 		*ptr++ = PAGE_CODE_TEMPERATURE;
8807 	}
8808 
8809 	if (sata_id->ai_cmdset82 & SATA_SMART_SUPPORTED) {
8810 		*ptr++ = PAGE_CODE_START_STOP_CYCLE_COUNTER;
8811 		if (sata_id->ai_cmdset84 & SATA_SMART_SELF_TEST_SUPPORTED) {
8812 			*ptr++ = PAGE_CODE_SELF_TEST_RESULTS;
8813 		}
8814 	}
8815 
8816 	if (sata_id->ai_medrotrate == 0x01 &&
8817 	    (sata_id->ai_cmdset84 & SATA_GPL_SUPPORTED))
8818 		*ptr++ = PAGE_CODE_SOLID_STATE_MEDIA;
8819 
8820 	if (sata_id->ai_cmdset84 & SATA_GPL_SUPPORTED) {
8821 		*ptr++ = PAGE_CODE_GENERAL_STATS;
8822 	}
8823 
8824 	if (sata_id->ai_cmdset82 & SATA_SMART_SUPPORTED) {
8825 		*ptr++ = PAGE_CODE_INFORMATION_EXCEPTIONS;
8826 		*ptr++ = PAGE_CODE_SMART_READ_DATA;
8827 	}
8828 
8829 	return ((int)((uintptr_t)ptr - (uintptr_t)buf));
8830 }
8831 
8832 static int
8833 sata_build_lsense_page_03(sata_drive_info_t *sdinfo, uint8_t *buf,
8834     sata_hba_inst_t *sata_hba_inst)
8835 {
8836 	struct log_parameter *lpp = (struct log_parameter *)buf;
8837 	uint64_t *lbuf;
8838 	uint64_t param;
8839 	int rval;
8840 
8841 	if (!(sdinfo->satadrv_id.ai_cmdset84 & SATA_GPL_SUPPORTED))
8842 		return (-1);
8843 
8844 	lbuf = kmem_zalloc(512, KM_SLEEP);
8845 	rval = sata_read_log_ext(sata_hba_inst, sdinfo, DEVICE_STATS_LOG,
8846 	    DEVSTAT_ROTATING_MEDIA_PAGE, lbuf, 1);
8847 	if (rval == 0) {
8848 		param = LE_64(lbuf[5]);		/* Read recovery errors */
8849 		if (SATA_STAT_SUPPORTED(param) && SATA_STAT_VALID(param)) {
8850 			/* Total times corrected algorithm parameter */
8851 			lpp->param_code[0] = 0x00;
8852 			lpp->param_code[1] = 0x04;
8853 			lpp->param_ctrl_flags = LOG_CTRL_LBIN;
8854 			lpp->param_len = sizeof (uint32_t);
8855 			BE_OUT32(&lpp->param_values[0],
8856 			    SATA_STAT_VALUE(param) & 0xffffffff);
8857 
8858 			lpp = log_param_next(lpp);
8859 		}
8860 	}
8861 
8862 	bzero(lbuf, 512);
8863 	rval = sata_read_log_ext(sata_hba_inst, sdinfo, DEVICE_STATS_LOG,
8864 	    DEVSTAT_GENERAL_ERRORS_PAGE, lbuf, 1);
8865 	if (rval == 0) {
8866 		param = LE_64(lbuf[1]); /* Reported uncorrectable errors */
8867 		if (SATA_STAT_SUPPORTED(param) && SATA_STAT_VALID(param)) {
8868 			/* Total Uncorrected Errors parameter */
8869 			lpp->param_code[0] = 0x00;
8870 			lpp->param_code[1] = 0x06;
8871 			lpp->param_ctrl_flags = LOG_CTRL_LBIN;
8872 			lpp->param_len = sizeof (uint32_t);
8873 			BE_OUT32(&lpp->param_values[0],
8874 			    SATA_STAT_VALUE(param) & 0xffffffff);
8875 
8876 			lpp = log_param_next(lpp);
8877 		}
8878 	}
8879 
8880 	kmem_free(lbuf, 512);
8881 
8882 	/*
8883 	 * If neither stat is supported, we treat it as the page not being
8884 	 * supported.
8885 	 */
8886 	return (log_param_size(lpp, buf) > 0 ? log_param_size(lpp, buf) : -1);
8887 }
8888 
8889 /*
8890  * sata_build_lsense_page_10() is used to create the
8891  * SCSI LOG SENSE page 0x10 (self-test results)
8892  *
8893  * Takes a sata_drive_info t * and the address of a buffer
8894  * in which to create the page information as well as a sata_hba_inst_t *.
8895  *
8896  * Returns the number of bytes valid in the buffer.
8897  *
8898  * Note: Self test and SMART data is accessible in device log pages.
8899  * The log pages can be accessed by SMART READ/WRITE LOG (up to 255 sectors
8900  * of data can be transferred by a single command), or by the General Purpose
8901  * Logging commands (GPL) READ LOG EXT and WRITE LOG EXT (up to 65,535 sectors
8902  * - approximately 33MB - can be transferred by a single command.
8903  * The SCT Command response (either error or command) is the same for both
8904  * the SMART and GPL methods of issuing commands.
8905  * This function uses READ LOG EXT command when drive supports LBA48, and
8906  * SMART READ command otherwise.
8907  *
8908  * Since above commands are executed in a synchronous mode, this function
8909  * should not be called in an interrupt context.
8910  */
8911 static	int
8912 sata_build_lsense_page_10(
8913 	sata_drive_info_t *sdinfo,
8914 	uint8_t *buf,
8915 	sata_hba_inst_t *sata_hba_inst)
8916 {
8917 	struct log_parameter *lpp = (struct log_parameter *)buf;
8918 	int rval;
8919 
8920 	if (sdinfo->satadrv_features_support & SATA_DEV_F_LBA48) {
8921 		struct smart_ext_selftest_log *ext_selftest_log;
8922 
8923 		ext_selftest_log = kmem_zalloc(
8924 		    sizeof (struct smart_ext_selftest_log), KM_SLEEP);
8925 
8926 		rval = sata_ext_smart_selftest_read_log(sata_hba_inst, sdinfo,
8927 		    ext_selftest_log, 0);
8928 		if (rval == 0) {
8929 			int index, start_index;
8930 			struct smart_ext_selftest_log_entry *entry;
8931 			static const struct smart_ext_selftest_log_entry empty =
8932 			    {0};
8933 			uint16_t block_num;
8934 			int count;
8935 			boolean_t only_one_block = B_FALSE;
8936 
8937 			index = ext_selftest_log->
8938 			    smart_ext_selftest_log_index[0];
8939 			index |= ext_selftest_log->
8940 			    smart_ext_selftest_log_index[1] << 8;
8941 			if (index == 0)
8942 				goto out;
8943 
8944 			--index;	/* Correct for 0 origin */
8945 			start_index = index;	/* remember where we started */
8946 			block_num = index / ENTRIES_PER_EXT_SELFTEST_LOG_BLK;
8947 			if (block_num != 0) {
8948 				rval = sata_ext_smart_selftest_read_log(
8949 				    sata_hba_inst, sdinfo, ext_selftest_log,
8950 				    block_num);
8951 				if (rval != 0)
8952 					goto out;
8953 			}
8954 			index %= ENTRIES_PER_EXT_SELFTEST_LOG_BLK;
8955 			entry =
8956 			    &ext_selftest_log->
8957 			    smart_ext_selftest_log_entries[index];
8958 
8959 			for (count = 1;
8960 			    count <= SCSI_ENTRIES_IN_LOG_SENSE_SELFTEST_RESULTS;
8961 			    ++count) {
8962 				uint8_t status;
8963 				uint8_t code;
8964 				uint8_t sense_key;
8965 				uint8_t add_sense_code;
8966 				uint8_t add_sense_code_qual;
8967 
8968 				/* If this is an unused entry, we are done */
8969 				if (bcmp(entry, &empty, sizeof (empty)) == 0) {
8970 					/* Broken firmware on some disks */
8971 					if (index + 1 ==
8972 					    ENTRIES_PER_EXT_SELFTEST_LOG_BLK) {
8973 						--entry;
8974 						--index;
8975 						if (bcmp(entry, &empty,
8976 						    sizeof (empty)) == 0)
8977 							goto out;
8978 					} else
8979 						goto out;
8980 				}
8981 
8982 				if (only_one_block &&
8983 				    start_index == index)
8984 					goto out;
8985 
8986 				lpp->param_code[0] = 0;
8987 				lpp->param_code[1] = count;
8988 				lpp->param_ctrl_flags =
8989 				    LOG_CTRL_LP | LOG_CTRL_LBIN;
8990 				lpp->param_len =
8991 				    SCSI_LOG_SENSE_SELFTEST_PARAM_LEN;
8992 
8993 				status = entry->smart_ext_selftest_log_status;
8994 				status >>= 4;
8995 				switch (status) {
8996 				case 0:
8997 				default:
8998 					sense_key = KEY_NO_SENSE;
8999 					add_sense_code =
9000 					    SD_SCSI_ASC_NO_ADD_SENSE;
9001 					add_sense_code_qual = 0;
9002 					break;
9003 				case 1:
9004 					sense_key = KEY_ABORTED_COMMAND;
9005 					add_sense_code =
9006 					    DIAGNOSTIC_FAILURE_ON_COMPONENT;
9007 					add_sense_code_qual = SCSI_COMPONENT_81;
9008 					break;
9009 				case 2:
9010 					sense_key = KEY_ABORTED_COMMAND;
9011 					add_sense_code =
9012 					    DIAGNOSTIC_FAILURE_ON_COMPONENT;
9013 					add_sense_code_qual = SCSI_COMPONENT_82;
9014 					break;
9015 				case 3:
9016 					sense_key = KEY_ABORTED_COMMAND;
9017 					add_sense_code =
9018 					    DIAGNOSTIC_FAILURE_ON_COMPONENT;
9019 					add_sense_code_qual = SCSI_COMPONENT_83;
9020 					break;
9021 				case 4:
9022 					sense_key = KEY_HARDWARE_ERROR;
9023 					add_sense_code =
9024 					    DIAGNOSTIC_FAILURE_ON_COMPONENT;
9025 					add_sense_code_qual = SCSI_COMPONENT_84;
9026 					break;
9027 				case 5:
9028 					sense_key = KEY_HARDWARE_ERROR;
9029 					add_sense_code =
9030 					    DIAGNOSTIC_FAILURE_ON_COMPONENT;
9031 					add_sense_code_qual = SCSI_COMPONENT_85;
9032 					break;
9033 				case 6:
9034 					sense_key = KEY_HARDWARE_ERROR;
9035 					add_sense_code =
9036 					    DIAGNOSTIC_FAILURE_ON_COMPONENT;
9037 					add_sense_code_qual = SCSI_COMPONENT_86;
9038 					break;
9039 				case 7:
9040 					sense_key = KEY_MEDIUM_ERROR;
9041 					add_sense_code =
9042 					    DIAGNOSTIC_FAILURE_ON_COMPONENT;
9043 					add_sense_code_qual = SCSI_COMPONENT_87;
9044 					break;
9045 				case 8:
9046 					sense_key = KEY_HARDWARE_ERROR;
9047 					add_sense_code =
9048 					    DIAGNOSTIC_FAILURE_ON_COMPONENT;
9049 					add_sense_code_qual = SCSI_COMPONENT_88;
9050 					break;
9051 				}
9052 				code = 0;	/* unspecified */
9053 				status |= (code << 4);
9054 				lpp->param_values[0] = status;
9055 				lpp->param_values[1] = 0; /* unspecified */
9056 				lpp->param_values[2] = entry->
9057 				    smart_ext_selftest_log_timestamp[1];
9058 				lpp->param_values[3] = entry->
9059 				    smart_ext_selftest_log_timestamp[0];
9060 				if (status != 0) {
9061 					lpp->param_values[4] = 0;
9062 					lpp->param_values[5] = 0;
9063 					lpp->param_values[6] = entry->
9064 					    smart_ext_selftest_log_failing_lba
9065 					    [5];
9066 					lpp->param_values[7] = entry->
9067 					    smart_ext_selftest_log_failing_lba
9068 					    [4];
9069 					lpp->param_values[8] = entry->
9070 					    smart_ext_selftest_log_failing_lba
9071 					    [3];
9072 					lpp->param_values[9] = entry->
9073 					    smart_ext_selftest_log_failing_lba
9074 					    [2];
9075 					lpp->param_values[10] = entry->
9076 					    smart_ext_selftest_log_failing_lba
9077 					    [1];
9078 					lpp->param_values[11] = entry->
9079 					    smart_ext_selftest_log_failing_lba
9080 					    [0];
9081 				} else {	/* No bad block address */
9082 					lpp->param_values[4] = 0xff;
9083 					lpp->param_values[5] = 0xff;
9084 					lpp->param_values[6] = 0xff;
9085 					lpp->param_values[7] = 0xff;
9086 					lpp->param_values[8] = 0xff;
9087 					lpp->param_values[9] = 0xff;
9088 					lpp->param_values[10] = 0xff;
9089 					lpp->param_values[11] = 0xff;
9090 				}
9091 
9092 				lpp->param_values[12] = sense_key;
9093 				lpp->param_values[13] = add_sense_code;
9094 				lpp->param_values[14] = add_sense_code_qual;
9095 				lpp->param_values[15] = 0; /* undefined */
9096 
9097 				lpp = (struct log_parameter *)
9098 				    (((uint8_t *)lpp) +
9099 				    SCSI_LOG_PARAM_HDR_LEN +
9100 				    SCSI_LOG_SENSE_SELFTEST_PARAM_LEN);
9101 
9102 				--index;	/* Back up to previous entry */
9103 				if (index < 0) {
9104 					if (block_num > 0) {
9105 						--block_num;
9106 					} else {
9107 						struct read_log_ext_directory
9108 						    logdir;
9109 
9110 						rval =
9111 						    sata_read_log_ext_directory(
9112 						    sata_hba_inst, sdinfo,
9113 						    &logdir);
9114 						if (rval == -1)
9115 							goto out;
9116 						if ((logdir.read_log_ext_vers
9117 						    [0] == 0) &&
9118 						    (logdir.read_log_ext_vers
9119 						    [1] == 0))
9120 							goto out;
9121 						block_num =
9122 						    logdir.read_log_ext_nblks
9123 						    [EXT_SMART_SELFTEST_LOG_PAGE
9124 						    - 1][0];
9125 						block_num |= logdir.
9126 						    read_log_ext_nblks
9127 						    [EXT_SMART_SELFTEST_LOG_PAGE
9128 						    - 1][1] << 8;
9129 						--block_num;
9130 						only_one_block =
9131 						    (block_num == 0);
9132 					}
9133 					rval = sata_ext_smart_selftest_read_log(
9134 					    sata_hba_inst, sdinfo,
9135 					    ext_selftest_log, block_num);
9136 					if (rval != 0)
9137 						goto out;
9138 
9139 					index =
9140 					    ENTRIES_PER_EXT_SELFTEST_LOG_BLK -
9141 					    1;
9142 				}
9143 				index %= ENTRIES_PER_EXT_SELFTEST_LOG_BLK;
9144 				entry = &ext_selftest_log->
9145 				    smart_ext_selftest_log_entries[index];
9146 			}
9147 		}
9148 out:
9149 		kmem_free(ext_selftest_log,
9150 		    sizeof (struct smart_ext_selftest_log));
9151 	} else {
9152 		struct smart_selftest_log *selftest_log;
9153 
9154 		selftest_log = kmem_zalloc(sizeof (struct smart_selftest_log),
9155 		    KM_SLEEP);
9156 
9157 		rval = sata_smart_selftest_log(sata_hba_inst, sdinfo,
9158 		    selftest_log);
9159 
9160 		if (rval == 0) {
9161 			int index;
9162 			int count;
9163 			struct smart_selftest_log_entry *entry;
9164 			static const struct smart_selftest_log_entry empty =
9165 			    { 0 };
9166 
9167 			index = selftest_log->smart_selftest_log_index;
9168 			if (index == 0)
9169 				goto done;
9170 			--index;	/* Correct for 0 origin */
9171 			entry = &selftest_log->
9172 			    smart_selftest_log_entries[index];
9173 			for (count = 1;
9174 			    count <= SCSI_ENTRIES_IN_LOG_SENSE_SELFTEST_RESULTS;
9175 			    ++count) {
9176 				uint8_t status;
9177 				uint8_t code;
9178 				uint8_t sense_key;
9179 				uint8_t add_sense_code;
9180 				uint8_t add_sense_code_qual = 0;
9181 
9182 				if (bcmp(entry, &empty, sizeof (empty)) == 0)
9183 					goto done;
9184 
9185 				lpp->param_code[0] = 0;
9186 				lpp->param_code[1] = count;
9187 				lpp->param_ctrl_flags =
9188 				    LOG_CTRL_LP | LOG_CTRL_LBIN;
9189 				lpp->param_len =
9190 				    SCSI_LOG_SENSE_SELFTEST_PARAM_LEN;
9191 
9192 				status = entry->smart_selftest_log_status;
9193 				status >>= 4;
9194 				switch (status) {
9195 				case 0:
9196 				default:
9197 					sense_key = KEY_NO_SENSE;
9198 					add_sense_code =
9199 					    SD_SCSI_ASC_NO_ADD_SENSE;
9200 					break;
9201 				case 1:
9202 					sense_key = KEY_ABORTED_COMMAND;
9203 					add_sense_code =
9204 					    DIAGNOSTIC_FAILURE_ON_COMPONENT;
9205 					add_sense_code_qual = SCSI_COMPONENT_81;
9206 					break;
9207 				case 2:
9208 					sense_key = KEY_ABORTED_COMMAND;
9209 					add_sense_code =
9210 					    DIAGNOSTIC_FAILURE_ON_COMPONENT;
9211 					add_sense_code_qual = SCSI_COMPONENT_82;
9212 					break;
9213 				case 3:
9214 					sense_key = KEY_ABORTED_COMMAND;
9215 					add_sense_code =
9216 					    DIAGNOSTIC_FAILURE_ON_COMPONENT;
9217 					add_sense_code_qual = SCSI_COMPONENT_83;
9218 					break;
9219 				case 4:
9220 					sense_key = KEY_HARDWARE_ERROR;
9221 					add_sense_code =
9222 					    DIAGNOSTIC_FAILURE_ON_COMPONENT;
9223 					add_sense_code_qual = SCSI_COMPONENT_84;
9224 					break;
9225 				case 5:
9226 					sense_key = KEY_HARDWARE_ERROR;
9227 					add_sense_code =
9228 					    DIAGNOSTIC_FAILURE_ON_COMPONENT;
9229 					add_sense_code_qual = SCSI_COMPONENT_85;
9230 					break;
9231 				case 6:
9232 					sense_key = KEY_HARDWARE_ERROR;
9233 					add_sense_code =
9234 					    DIAGNOSTIC_FAILURE_ON_COMPONENT;
9235 					add_sense_code_qual = SCSI_COMPONENT_86;
9236 					break;
9237 				case 7:
9238 					sense_key = KEY_MEDIUM_ERROR;
9239 					add_sense_code =
9240 					    DIAGNOSTIC_FAILURE_ON_COMPONENT;
9241 					add_sense_code_qual = SCSI_COMPONENT_87;
9242 					break;
9243 				case 8:
9244 					sense_key = KEY_HARDWARE_ERROR;
9245 					add_sense_code =
9246 					    DIAGNOSTIC_FAILURE_ON_COMPONENT;
9247 					add_sense_code_qual = SCSI_COMPONENT_88;
9248 					break;
9249 				}
9250 				code = 0;	/* unspecified */
9251 				status |= (code << 4);
9252 				lpp->param_values[0] = status;
9253 				lpp->param_values[1] = 0; /* unspecified */
9254 				lpp->param_values[2] = entry->
9255 				    smart_selftest_log_timestamp[1];
9256 				lpp->param_values[3] = entry->
9257 				    smart_selftest_log_timestamp[0];
9258 				if (status != 0) {
9259 					lpp->param_values[4] = 0;
9260 					lpp->param_values[5] = 0;
9261 					lpp->param_values[6] = 0;
9262 					lpp->param_values[7] = 0;
9263 					lpp->param_values[8] = entry->
9264 					    smart_selftest_log_failing_lba[3];
9265 					lpp->param_values[9] = entry->
9266 					    smart_selftest_log_failing_lba[2];
9267 					lpp->param_values[10] = entry->
9268 					    smart_selftest_log_failing_lba[1];
9269 					lpp->param_values[11] = entry->
9270 					    smart_selftest_log_failing_lba[0];
9271 				} else {	/* No block address */
9272 					lpp->param_values[4] = 0xff;
9273 					lpp->param_values[5] = 0xff;
9274 					lpp->param_values[6] = 0xff;
9275 					lpp->param_values[7] = 0xff;
9276 					lpp->param_values[8] = 0xff;
9277 					lpp->param_values[9] = 0xff;
9278 					lpp->param_values[10] = 0xff;
9279 					lpp->param_values[11] = 0xff;
9280 				}
9281 				lpp->param_values[12] = sense_key;
9282 				lpp->param_values[13] = add_sense_code;
9283 				lpp->param_values[14] = add_sense_code_qual;
9284 				lpp->param_values[15] = 0; /* undefined */
9285 
9286 				lpp = (struct log_parameter *)
9287 				    (((uint8_t *)lpp) +
9288 				    SCSI_LOG_PARAM_HDR_LEN +
9289 				    SCSI_LOG_SENSE_SELFTEST_PARAM_LEN);
9290 				--index;	/* back up to previous entry */
9291 				if (index < 0) {
9292 					index =
9293 					    NUM_SMART_SELFTEST_LOG_ENTRIES - 1;
9294 				}
9295 				entry = &selftest_log->
9296 				    smart_selftest_log_entries[index];
9297 			}
9298 		}
9299 done:
9300 		kmem_free(selftest_log, sizeof (struct smart_selftest_log));
9301 	}
9302 
9303 	return ((SCSI_LOG_PARAM_HDR_LEN + SCSI_LOG_SENSE_SELFTEST_PARAM_LEN) *
9304 	    SCSI_ENTRIES_IN_LOG_SENSE_SELFTEST_RESULTS);
9305 }
9306 
9307 static uint8_t
9308 sata_sct_temp(sata_hba_inst_t *sata_hba_inst, sata_drive_info_t *sdinfo,
9309     void *p, size_t lbufsz)
9310 {
9311 	sata_id_t *sata_id = &sdinfo->satadrv_id;
9312 	uint8_t *lbuf = p;
9313 	int rval;
9314 	uint8_t temp;
9315 
9316 	/* The log buffer we use should be at least 1 block in size */
9317 	ASSERT3U(lbufsz, >=, 512);
9318 
9319 	if ((sata_id->ai_sctsupport & SATA_SCT_CMD_TRANS_SUP) == 0)
9320 		return (SCSI_NO_TEMP);
9321 
9322 	bzero(lbuf, lbufsz);
9323 	rval = sata_smart_read_log(sata_hba_inst, sdinfo, lbuf,
9324 	    SCT_STATUS_LOG_PAGE, 1);
9325 	if (rval == -1)
9326 		return (SCSI_NO_TEMP);
9327 
9328 	/*
9329 	 * ACS-3 8.2.5 Table 186 -- If the value is 0x80, the field (HDA TEMP)
9330 	 * is not valid)
9331 	 */
9332 	temp = lbuf[200];
9333 	if (temp == 0x80)
9334 		return (SCSI_NO_TEMP);
9335 
9336 	/*
9337 	 * SATA temps are signed (with 0x80 being a sentinel value indicating
9338 	 * not valid as noted above). SAT-5 says that values below 0 are
9339 	 * truncated to 0.
9340 	 */
9341 	if ((temp & 0x80) != 0)
9342 		return (0);
9343 
9344 	return (temp);
9345 }
9346 
9347 
9348 /*
9349  * sata_build_lsense_page_2f() is used to create the
9350  * SCSI LOG SENSE page 0x2f (informational exceptions)
9351  *
9352  * Takes a sata_drive_info t * and the address of a buffer
9353  * in which to create the page information as well as a sata_hba_inst_t *.
9354  *
9355  * Returns the number of bytes valid in the buffer.
9356  *
9357  * Because it invokes function(s) that send synchronously executed command
9358  * to the HBA, it cannot be called in the interrupt context.
9359  */
9360 static	int
9361 sata_build_lsense_page_2f(
9362 	sata_drive_info_t *sdinfo,
9363 	uint8_t *buf,
9364 	sata_hba_inst_t *sata_hba_inst)
9365 {
9366 	struct log_parameter *lpp = (struct log_parameter *)buf;
9367 	int rval;
9368 	uint8_t *smart_data;
9369 	uint8_t temp;
9370 	sata_id_t *sata_id;
9371 
9372 	lpp->param_code[0] = 0;
9373 	lpp->param_code[1] = 0;
9374 	lpp->param_ctrl_flags = LOG_CTRL_LP | LOG_CTRL_LBIN;
9375 
9376 	/* Now get the SMART status w.r.t. threshold exceeded */
9377 	rval = sata_fetch_smart_return_status(sata_hba_inst, sdinfo);
9378 	switch (rval) {
9379 	case 1:
9380 		lpp->param_values[0] = SCSI_PREDICTED_FAILURE;
9381 		lpp->param_values[1] = SCSI_GENERAL_HD_FAILURE;
9382 		break;
9383 	case 0:
9384 	case -1:	/* failed to get data */
9385 		lpp->param_values[0] = 0;	/* No failure predicted */
9386 		lpp->param_values[1] = 0;
9387 		break;
9388 #if defined(SATA_DEBUG)
9389 	default:
9390 		cmn_err(CE_PANIC, "sata_build_lsense_page_2f bad return value");
9391 		/* NOTREACHED */
9392 #endif
9393 	}
9394 
9395 	sata_id = &sdinfo->satadrv_id;
9396 	if (! (sata_id->ai_sctsupport & SATA_SCT_CMD_TRANS_SUP)) {
9397 		temp = SCSI_NO_TEMP;
9398 	} else {
9399 		/* Now get the temperature */
9400 		smart_data = kmem_zalloc(512, KM_SLEEP);
9401 		temp = sata_sct_temp(sata_hba_inst, sdinfo, smart_data, 512);
9402 		kmem_free(smart_data, 512);
9403 	}
9404 
9405 	lpp->param_values[2] = temp;	/* most recent temperature */
9406 	lpp->param_values[3] = 0;	/* required vendor specific byte */
9407 
9408 	lpp->param_len = SCSI_INFO_EXCEPTIONS_PARAM_LEN;
9409 
9410 
9411 	return (SCSI_INFO_EXCEPTIONS_PARAM_LEN + SCSI_LOG_PARAM_HDR_LEN);
9412 }
9413 
9414 static int
9415 sata_build_lsense_page_0d(sata_drive_info_t *sdinfo, uint8_t *buf,
9416     sata_hba_inst_t *sata_hba_inst)
9417 {
9418 	struct log_parameter *lpp = (struct log_parameter *)buf;
9419 	uint64_t *lbuf;
9420 	uint64_t param;
9421 	int rval;
9422 	uint8_t temp, ref_temp, sct_temp;
9423 
9424 	if (!(sdinfo->satadrv_id.ai_sctsupport & SATA_SCT_CMD_TRANS_SUP) &&
9425 	    !(sdinfo->satadrv_id.ai_cmdset84 & SATA_GPL_SUPPORTED))
9426 		return (-1);
9427 
9428 	temp = ref_temp = sct_temp = SCSI_NO_TEMP;
9429 
9430 	lbuf = kmem_zalloc(512, KM_SLEEP);
9431 	sct_temp = sata_sct_temp(sata_hba_inst, sdinfo, lbuf, 512);
9432 
9433 	bzero(lbuf, 512);
9434 
9435 	rval = sata_read_log_ext(sata_hba_inst, sdinfo, DEVICE_STATS_LOG,
9436 	    DEVSTAT_TEMP_PAGE, lbuf, 1);
9437 	if (rval == -1)
9438 		goto done;
9439 
9440 	param = LE_64(lbuf[1]);		/* Current temperature */
9441 	if (SATA_STAT_SUPPORTED(param) && SATA_STAT_VALID(param)) {
9442 		/*
9443 		 * SAT-5 10.3.13.2 Table 136 says that only positive
9444 		 * temperatures (SATA temps are signed 8-bit values) -- i.e.
9445 		 * bit 7 is 0 are translated, otherwise 0xff (SCSI_NO_TEMP)
9446 		 * is returned.
9447 		 */
9448 		temp = SATA_STAT_VALUE(param) & 0xff;
9449 		if ((temp & 0x80) != 0)
9450 			temp = SCSI_NO_TEMP;
9451 	}
9452 
9453 	param = LE_64(lbuf[11]);	/* Max operating temp */
9454 	if (SATA_STAT_SUPPORTED(param) && SATA_STAT_VALID(param)) {
9455 		/*
9456 		 * Interestingly, for the reference temperature, while the
9457 		 * SATA value is also an 8-bit signed value), SAT-5 10.3.13.3
9458 		 * Table 137 says that negative temps are translated to 0
9459 		 * unlike the current temperature.
9460 		 */
9461 		int8_t val = (int8_t)(SATA_STAT_VALUE(param) & 0xff);
9462 		ref_temp = (val < 0) ? 0 : val;
9463 	}
9464 
9465 	rval = 0;
9466 
9467 done:
9468 	kmem_free(lbuf, 512);
9469 
9470 	/*
9471 	 * If we support SCT or GPL, we'll always return a value, even if
9472 	 * that value is SCSI_NO_TEMP (as it may be a transient issue and
9473 	 * appears to be allowable per SPC-5).
9474 	 */
9475 
9476 	lpp->param_code[0] = 0;
9477 	lpp->param_code[1] = 0;
9478 	lpp->param_ctrl_flags = LOG_CTRL_LP | LOG_CTRL_LBIN;
9479 	lpp->param_len = 2;
9480 	lpp->param_values[0] = 0;	/* Reserved */
9481 
9482 	/*
9483 	 * Per SAT-5 10.3.13.2 Table 136, The SCT temp is used if
9484 	 * valid, otherwise the current temp from the temp statistics page
9485 	 * is used.
9486 	 */
9487 	lpp->param_values[1] = (sct_temp != SCSI_NO_TEMP) ? sct_temp : temp;
9488 
9489 	lpp = log_param_next(lpp);
9490 
9491 	if (ref_temp != SCSI_NO_TEMP) {
9492 		lpp->param_code[0] = 0x00;
9493 		lpp->param_code[1] = 0x01;	/* Reference Temperature */
9494 		lpp->param_ctrl_flags = LOG_CTRL_LP | LOG_CTRL_LBIN;
9495 		lpp->param_len = 2;
9496 		lpp->param_values[0] = 0;	/* Resreved */
9497 		lpp->param_values[1] = ref_temp;
9498 
9499 		lpp = log_param_next(lpp);
9500 	}
9501 
9502 	return (log_param_size(lpp, buf));
9503 }
9504 
9505 /*
9506  * sata_build_lsense_page_30() is used to create the
9507  * SCSI LOG SENSE page 0x30 (Sun's vendor specific page for ATA SMART data).
9508  *
9509  * Takes a sata_drive_info t * and the address of a buffer
9510  * in which to create the page information as well as a sata_hba_inst_t *.
9511  *
9512  * Returns the number of bytes valid in the buffer.
9513  */
9514 static int
9515 sata_build_lsense_page_30(
9516 	sata_drive_info_t *sdinfo,
9517 	uint8_t *buf,
9518 	sata_hba_inst_t *sata_hba_inst)
9519 {
9520 	struct smart_data *smart_data = (struct smart_data *)buf;
9521 	int rval;
9522 
9523 	/* Now do the SMART READ DATA */
9524 	rval = sata_fetch_smart_data(sata_hba_inst, sdinfo, smart_data);
9525 	if (rval == -1)
9526 		return (0);
9527 
9528 	return (sizeof (struct smart_data));
9529 }
9530 
9531 /*
9532  * sata_build_lsense_page_0e() is used to create the
9533  * SCSI LOG SENSE page 0e (start-stop cycle counter page)
9534  *
9535  * Date of Manufacture (0x0001)
9536  *	YEAR = "0000"
9537  *	WEEK = "00"
9538  * Accounting Date (0x0002)
9539  *	6 ASCII space character(20h)
9540  * Specified cycle count over device lifetime
9541  *	VALUE - THRESH - the delta between max and min;
9542  * Accumulated start-stop cycles
9543  *	VALUE - WORST - the accumulated cycles;
9544  *
9545  * ID FLAG THRESH VALUE WORST RAW on start/stop counter attribute
9546  *
9547  * Takes a sata_drive_info t * and the address of a buffer
9548  * in which to create the page information as well as a sata_hba_inst_t *.
9549  *
9550  * Returns the number of bytes valid in the buffer.
9551  */
9552 static	int
9553 sata_build_lsense_page_0e(sata_drive_info_t *sdinfo, uint8_t *buf,
9554     sata_pkt_txlate_t *spx)
9555 {
9556 	struct start_stop_cycle_counter_log *log_page;
9557 	int i, rval, index;
9558 	uint8_t smart_data[512], id, value, worst, thresh;
9559 	uint32_t max_count, cycles;
9560 
9561 	/* Now do the SMART READ DATA */
9562 	rval = sata_fetch_smart_data(spx->txlt_sata_hba_inst, sdinfo,
9563 	    (struct smart_data *)smart_data);
9564 	if (rval == -1)
9565 		return (0);
9566 	for (i = 0, id = 0; i < SMART_START_STOP_COUNT_ID * 2; i++) {
9567 		index = (i * 12) + 2;
9568 		id = smart_data[index];
9569 		if (id != SMART_START_STOP_COUNT_ID)
9570 			continue;
9571 		else {
9572 			thresh = smart_data[index + 2];
9573 			value = smart_data[index + 3];
9574 			worst = smart_data[index + 4];
9575 			break;
9576 		}
9577 	}
9578 	if (id != SMART_START_STOP_COUNT_ID)
9579 		return (0);
9580 	max_count = value - thresh;
9581 	cycles = value - worst;
9582 
9583 	log_page = (struct start_stop_cycle_counter_log *)buf;
9584 	bzero(log_page, sizeof (struct start_stop_cycle_counter_log));
9585 	log_page->code = 0x0e;
9586 	log_page->page_len_low = 0x24;
9587 
9588 	log_page->manufactor_date_low = 0x1;
9589 	log_page->param_1.fmt_link = 0x1; /* 01b */
9590 	log_page->param_len_1 = 0x06;
9591 	for (i = 0; i < 4; i++) {
9592 		log_page->year_manu[i] = 0x30;
9593 		if (i < 2)
9594 			log_page->week_manu[i] = 0x30;
9595 	}
9596 
9597 	log_page->account_date_low = 0x02;
9598 	log_page->param_2.fmt_link = 0x01; /* 01b */
9599 	log_page->param_len_2 = 0x06;
9600 	for (i = 0; i < 4; i++) {
9601 		log_page->year_account[i] = 0x20;
9602 		if (i < 2)
9603 			log_page->week_account[i] = 0x20;
9604 	}
9605 
9606 	log_page->lifetime_code_low = 0x03;
9607 	log_page->param_3.fmt_link = 0x03; /* 11b */
9608 	log_page->param_len_3 = 0x04;
9609 	/* VALUE - THRESH - the delta between max and min */
9610 	log_page->cycle_code_low = 0x04;
9611 	log_page->param_4.fmt_link = 0x03; /* 11b */
9612 	log_page->param_len_4 = 0x04;
9613 	/* WORST - THRESH - the distance from 'now' to min */
9614 
9615 	for (i = 0; i < 4; i++) {
9616 		log_page->cycle_lifetime[i] =
9617 		    (max_count >> (8 * (3 - i))) & 0xff;
9618 		log_page->cycle_accumulated[i] =
9619 		    (cycles >> (8 * (3 - i))) & 0xff;
9620 	}
9621 
9622 	return (sizeof (struct start_stop_cycle_counter_log));
9623 }
9624 
9625 static int
9626 sata_build_lsense_page_11(sata_drive_info_t *sdinfo, uint8_t *buf,
9627     sata_hba_inst_t *sata_hba_inst)
9628 {
9629 	struct log_parameter *lpp = (struct log_parameter *)buf;
9630 	uint64_t *lbuf;
9631 	uint64_t param;
9632 	int rval = 0;
9633 
9634 	/* Check if device is SSD */
9635 	if (sdinfo->satadrv_id.ai_medrotrate != 0x01 ||
9636 	    !(sdinfo->satadrv_id.ai_cmdset84 & SATA_GPL_SUPPORTED)) {
9637 		return (-1);
9638 	}
9639 
9640 	lbuf = kmem_zalloc(512, KM_SLEEP);
9641 	rval = sata_read_log_ext(sata_hba_inst, sdinfo, DEVICE_STATS_LOG,
9642 	    DEVSTAT_SSD_PAGE, lbuf, 1);
9643 	if (rval == -1)
9644 		goto done;
9645 
9646 	param = LE_64(lbuf[1]);	/* %-age used endurance indicator */
9647 	if (!SATA_STAT_SUPPORTED(param) || !SATA_STAT_VALID(param)) {
9648 		/*
9649 		 * If the wear stat isn't supported or valid, the SAT-5
9650 		 * says this is unspecified. We'll treat it as the
9651 		 * log page being unsupported.
9652 		 */
9653 		rval = -1;
9654 		goto done;
9655 	}
9656 
9657 	lpp->param_code[0] = 0x00;
9658 	lpp->param_code[1] = 0x01;
9659 	lpp->param_ctrl_flags = LOG_CTRL_LP | LOG_CTRL_LBIN;
9660 	lpp->param_len = 4;
9661 	BE_OUT32(&lpp->param_values[0], SATA_STAT_VALUE(param) & 0xffffffff);
9662 
9663 	lpp = log_param_next(lpp);
9664 
9665 done:
9666 	kmem_free(lbuf, 512);
9667 	return ((rval < 0) ? -1 : log_param_size(lpp, buf));
9668 }
9669 
9670 static int
9671 sata_build_lsense_page_19(sata_drive_info_t *sdinfo, uint8_t *buf,
9672     sata_hba_inst_t *sata_hba_inst)
9673 {
9674 	/*
9675 	 * The indexes into lbuf (the SATA general statistics log)
9676 	 * that correspond to the values of the general access statistics
9677 	 * and performance log values. -1 means there is no mapping (e.g.
9678 	 * write 0 for that value).
9679 	 */
9680 	static const int stat_idx[] = {
9681 		6,	/* # of read commands */
9682 		4,	/* # of write commands */
9683 		3,	/* Logical sectors written */
9684 		5,	/* Logical sectors read */
9685 		-1, -1, -1, -1
9686 	};
9687 
9688 	struct log_parameter *lpp = (struct log_parameter *)buf;
9689 	uint64_t *lbuf;
9690 	uint64_t *paramp;
9691 	uint64_t param;
9692 	uint_t nvalid;
9693 	int rval;
9694 
9695 	if (!(sdinfo->satadrv_id.ai_cmdset84 & SATA_GPL_SUPPORTED))
9696 		return (-1);
9697 
9698 	nvalid = 0;
9699 
9700 	lbuf = kmem_zalloc(512, KM_SLEEP);
9701 	rval = sata_read_log_ext(sata_hba_inst, sdinfo, DEVICE_STATS_LOG,
9702 	    DEVSTAT_GENERAL_STATS, lbuf, 1);
9703 	if (rval == -1) {
9704 		kmem_free(lbuf, 512);
9705 		return (-1);
9706 	}
9707 
9708 	lpp->param_code[0] = 0x00;
9709 	lpp->param_code[1] = 0x01;
9710 	/*
9711 	 * SPC-5 and SAT-5 disagree on this value -- SPC-5 7.3.9.2 says this
9712 	 * should be an unbounded data counter (10b LOG_CTRL_LBIN) while SAT-5
9713 	 * 10.3.4.2 Table 110 says this should be a binary format list (11b
9714 	 * aka LOG_CTRL_LP | LOG_CTRL_LBIN). Since SAT-5 is a bit more
9715 	 * explicit on the value, we've followed it. So far no software
9716 	 * has been uncovered to date that seems to care about the value, but
9717 	 * it may need to be updated of the two specs are ever brought into
9718 	 * agreement.
9719 	 */
9720 	lpp->param_ctrl_flags = LOG_CTRL_LP | LOG_CTRL_LBIN;
9721 	lpp->param_len = 0x40;
9722 
9723 	paramp = (uint64_t *)&lpp->param_values[0];
9724 
9725 	/* Zero out all of parameter values */
9726 	bzero(paramp, 0x40);
9727 
9728 	/* The stat parameters are 48 bits long */
9729 #define	PARAM_VAL(x) ((x) & ((1ULL << 48) - 1))
9730 
9731 	for (uint_t i = 0; i < ARRAY_SIZE(stat_idx); i++, paramp++) {
9732 		if (stat_idx[i] == -1) {
9733 			continue;
9734 		}
9735 
9736 		param = LE_64(lbuf[stat_idx[i]]);
9737 
9738 		if (SATA_STAT_SUPPORTED(param) && SATA_STAT_VALID(param)) {
9739 			BE_OUT64(paramp, PARAM_VAL(param));
9740 			nvalid++;
9741 		}
9742 	}
9743 #undef PARAM_VAL
9744 
9745 	kmem_free(lbuf, 512);
9746 
9747 	/* We must return at least one valid value for this page */
9748 	if (nvalid == 0)
9749 		return (-1);
9750 
9751 	/*
9752 	 * SPC-5 says that the IDLE TIME and TIME INTERVAL parameters
9753 	 * are mandatory, but SAT-5 gives no mention of either parameter.
9754 	 * Some utilities (e.g. sg3_utils) strictly follow the guidance of
9755 	 * SPC-5 and expect all three parameters, so we generate dummy
9756 	 * values for the IDLE TIME and TIME INTERVAL parameters.
9757 	 */
9758 	lpp = log_param_next(lpp);
9759 
9760 	/* IDLE TIME */
9761 	lpp->param_code[0] = 0x00;
9762 	lpp->param_code[1] = 0x02;
9763 	lpp->param_ctrl_flags = LOG_CTRL_LP;
9764 	lpp->param_len = 0x08;
9765 
9766 	/*
9767 	 * The value is an 64-bit unsigned int, the address is almost
9768 	 * certainly going to be unaligned, so just set each byte
9769 	 * individually.
9770 	 */
9771 	lpp->param_values[0] = lpp->param_values[1] = lpp->param_values[2] =
9772 	    lpp->param_values[3] = lpp->param_values[4] =
9773 	    lpp->param_values[5] = lpp->param_values[6] =
9774 	    lpp->param_values[7] = 0;
9775 	lpp = log_param_next(lpp);
9776 
9777 	/* TIME INTERVAL */
9778 	lpp->param_code[0] = 0x00;
9779 	lpp->param_code[1] = 0x03;
9780 	lpp->param_ctrl_flags = LOG_CTRL_LP | LOG_CTRL_LBIN;
9781 	lpp->param_len = 0x08;
9782 
9783 	uint32_t *vp = (uint32_t *)&lpp->param_values;
9784 
9785 	/*
9786 	 * SPC-5 7.3.6.7 -- The TIME INTERVAL parameter consists of
9787 	 * two 32-bit unsigned ints -- EXPONENT and INTEGER.
9788 	 * EXPONENT is the _negative_ power of ten (e.g. '3' implies
9789 	 * 10^-3) and INTEGER is the mantissa (e.g. the actual value
9790 	 * is INTEGER * 10^(-EXPONENT)).
9791 	 *
9792 	 * SPC-5 isn't completely clear on this, but from the description
9793 	 * of the fields of the General Access Statistics and Performance
9794 	 * log parameter in section 7.3.9.2, it implies that the TIME INTERVAL
9795 	 * parameter is used to in conjunction with the {READ,WRITE} COMMAND
9796 	 * PROCESSING INTERVAL statistics value. Since these values do not
9797 	 * have a translation defined (there doesn't appear to be any
9798 	 * equivalent statistic in any SATA log page), we always return
9799 	 * 0 for these stats. As a TIME INTERVAL of 0^-0 would be nonsensical
9800 	 * (and mathematically undefined), we choose an arbitrary interval of
9801 	 * 1ms (1 * 10^-3).
9802 	 */
9803 	BE_OUT32(vp, 3);
9804 	vp++;
9805 	BE_OUT32(vp, 1);
9806 
9807 	lpp = log_param_next(lpp);
9808 
9809 	return (log_param_size(lpp, buf));
9810 }
9811 
9812 
9813 /*
9814  * This function was used for build a ATA read verify sector command
9815  */
9816 static void
9817 sata_build_read_verify_cmd(sata_cmd_t *scmd, uint16_t sec, uint64_t lba)
9818 {
9819 	scmd->satacmd_cmd_reg = SATAC_RDVER;
9820 	scmd->satacmd_addr_type = ATA_ADDR_LBA28;
9821 	scmd->satacmd_flags.sata_special_regs = B_TRUE;
9822 
9823 	scmd->satacmd_sec_count_lsb = sec & 0xff;
9824 	scmd->satacmd_lba_low_lsb = lba & 0xff;
9825 	scmd->satacmd_lba_mid_lsb = (lba >> 8) & 0xff;
9826 	scmd->satacmd_lba_high_lsb = (lba >> 16) & 0xff;
9827 	scmd->satacmd_device_reg = (SATA_ADH_LBA | ((lba >> 24) & 0xf));
9828 	scmd->satacmd_features_reg = 0;
9829 	scmd->satacmd_status_reg = 0;
9830 	scmd->satacmd_error_reg = 0;
9831 }
9832 
9833 /*
9834  * This function was used for building an ATA
9835  * command, and only command register need to
9836  * be defined, other register will be zero or na.
9837  */
9838 static void
9839 sata_build_generic_cmd(sata_cmd_t *scmd, uint8_t cmd)
9840 {
9841 	scmd->satacmd_addr_type = 0;
9842 	scmd->satacmd_cmd_reg = cmd;
9843 	scmd->satacmd_device_reg = 0;
9844 	scmd->satacmd_sec_count_lsb = 0;
9845 	scmd->satacmd_lba_low_lsb = 0;
9846 	scmd->satacmd_lba_mid_lsb = 0;
9847 	scmd->satacmd_lba_high_lsb = 0;
9848 	scmd->satacmd_features_reg = 0;
9849 	scmd->satacmd_status_reg = 0;
9850 	scmd->satacmd_error_reg = 0;
9851 	scmd->satacmd_flags.sata_special_regs = B_TRUE;
9852 }
9853 
9854 /*
9855  * This function was used for changing the standby
9856  * timer format from SCSI to ATA.
9857  */
9858 static uint8_t
9859 sata_get_standby_timer(uint8_t *timer)
9860 {
9861 	uint32_t i = 0, count = 0;
9862 	uint8_t ata_count;
9863 
9864 	for (i = 0; i < 4; i++) {
9865 		count = count << 8 | timer[i];
9866 	}
9867 
9868 	if (count == 0)
9869 		return (0);
9870 
9871 	if (count >= 1 && count <= 12000)
9872 		ata_count = (count -1) / 50 + 1;
9873 	else if (count > 12000 && count <= 12600)
9874 		ata_count = 0xfc;
9875 	else if (count > 12601 && count <= 12750)
9876 		ata_count = 0xff;
9877 	else if (count > 12750 && count <= 17999)
9878 		ata_count = 0xf1;
9879 	else if (count > 18000 && count <= 198000)
9880 		ata_count = count / 18000 + 240;
9881 	else
9882 		ata_count = 0xfd;
9883 	return (ata_count);
9884 }
9885 
9886 /* ************************** ATAPI-SPECIFIC FUNCTIONS ********************** */
9887 
9888 /*
9889  * Start command for ATAPI device.
9890  * This function processes scsi_pkt requests.
9891  * Now CD/DVD, tape and ATAPI disk devices are supported.
9892  * Most commands are packet without any translation into Packet Command.
9893  * Some may be trapped and executed as SATA commands (not clear which one).
9894  *
9895  * Returns TRAN_ACCEPT if command is accepted for execution (or completed
9896  * execution).
9897  * Returns other TRAN_XXXX codes if command is not accepted or completed
9898  * (see return values for sata_hba_start()).
9899  *
9900  * Note:
9901  * Inquiry cdb format differs between transport version 2 and 3.
9902  * However, the transport version 3 devices that were checked did not adhere
9903  * to the specification (ignored MSB of the allocation length). Therefore,
9904  * the transport version is not checked, but Inquiry allocation length is
9905  * truncated to 255 bytes if the original allocation length set-up by the
9906  * target driver is greater than 255 bytes.
9907  */
9908 static int
9909 sata_txlt_atapi(sata_pkt_txlate_t *spx)
9910 {
9911 	struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt;
9912 	sata_cmd_t *scmd = &spx->txlt_sata_pkt->satapkt_cmd;
9913 	struct buf *bp = spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp;
9914 	sata_hba_inst_t *sata_hba = SATA_TXLT_HBA_INST(spx);
9915 	sata_drive_info_t *sdinfo = sata_get_device_info(sata_hba,
9916 	    &spx->txlt_sata_pkt->satapkt_device);
9917 	kmutex_t *cport_mutex = &(SATA_TXLT_CPORT_MUTEX(spx));
9918 	int cdblen;
9919 	int rval, reason;
9920 	int synch;
9921 	union scsi_cdb *cdbp = (union scsi_cdb *)scsipkt->pkt_cdbp;
9922 
9923 	mutex_enter(cport_mutex);
9924 
9925 	if (((rval = sata_txlt_generic_pkt_info(spx, &reason, 0)) !=
9926 	    TRAN_ACCEPT) || (reason == CMD_DEV_GONE)) {
9927 		mutex_exit(cport_mutex);
9928 		return (rval);
9929 	}
9930 
9931 	/*
9932 	 * ATAPI device executes some ATA commands in addition to those
9933 	 * commands sent via PACKET command. These ATA commands may be
9934 	 * executed by the regular SATA translation functions. None needs
9935 	 * to be captured now.
9936 	 *
9937 	 * Commands sent via PACKET command include:
9938 	 *	MMC command set for ATAPI CD/DVD device
9939 	 *	SSC command set for ATAPI TAPE device
9940 	 *	SBC command set for ATAPI disk device
9941 	 *
9942 	 */
9943 
9944 	/* Check the size of cdb */
9945 
9946 	switch (GETGROUP(cdbp)) {
9947 	case CDB_GROUPID_3:   /* Reserved, per SPC-4 */
9948 		/*
9949 		 * opcodes 0x7e and 0x7f identify variable-length CDBs and
9950 		 * therefore require special handling.  Return failure, for now.
9951 		 */
9952 		mutex_exit(cport_mutex);
9953 		return (TRAN_BADPKT);
9954 
9955 	case CDB_GROUPID_6:   /* Vendor-specific, per SPC-4 */
9956 	case CDB_GROUPID_7:   /* Vendor-specific, per SPC-4 */
9957 		/* obtain length from the scsi_pkt */
9958 		cdblen = scsipkt->pkt_cdblen;
9959 		break;
9960 
9961 	default:
9962 		/* CDB's length is statically known, per SPC-4 */
9963 		cdblen = scsi_cdb_size[GETGROUP(cdbp)];
9964 		break;
9965 	}
9966 
9967 	if (cdblen <= 0 || cdblen > sdinfo->satadrv_atapi_cdb_len) {
9968 		sata_log(NULL, CE_WARN,
9969 		    "sata: invalid ATAPI cdb length %d",
9970 		    cdblen);
9971 		mutex_exit(cport_mutex);
9972 		return (TRAN_BADPKT);
9973 	}
9974 
9975 	SATAATAPITRACE(spx, cdblen);
9976 
9977 	/*
9978 	 * For non-read/write commands we need to
9979 	 * map buffer
9980 	 */
9981 	switch ((uint_t)scsipkt->pkt_cdbp[0]) {
9982 	case SCMD_READ:
9983 	case SCMD_READ_G1:
9984 	case SCMD_READ_G5:
9985 	case SCMD_READ_G4:
9986 	case SCMD_WRITE:
9987 	case SCMD_WRITE_G1:
9988 	case SCMD_WRITE_G5:
9989 	case SCMD_WRITE_G4:
9990 		break;
9991 	default:
9992 		if (bp != NULL) {
9993 			if (bp->b_flags & (B_PHYS | B_PAGEIO))
9994 				bp_mapin(bp);
9995 		}
9996 		break;
9997 	}
9998 	/*
9999 	 * scmd->satacmd_flags.sata_data_direction default -
10000 	 * SATA_DIR_NODATA_XFER - is set by
10001 	 * sata_txlt_generic_pkt_info().
10002 	 */
10003 	if (scmd->satacmd_bp) {
10004 		if (scmd->satacmd_bp->b_flags & B_READ) {
10005 			scmd->satacmd_flags.sata_data_direction = SATA_DIR_READ;
10006 		} else {
10007 			scmd->satacmd_flags.sata_data_direction =
10008 			    SATA_DIR_WRITE;
10009 		}
10010 	}
10011 
10012 	/*
10013 	 * Set up ATAPI packet command.
10014 	 */
10015 
10016 	sata_atapi_packet_cmd_setup(scmd, sdinfo);
10017 
10018 	/* Copy cdb into sata_cmd */
10019 	scmd->satacmd_acdb_len = sdinfo->satadrv_atapi_cdb_len;
10020 	bzero(scmd->satacmd_acdb, SATA_ATAPI_MAX_CDB_LEN);
10021 	bcopy(cdbp, scmd->satacmd_acdb, cdblen);
10022 
10023 	/* See note in the command header */
10024 	if (scmd->satacmd_acdb[0] == SCMD_INQUIRY) {
10025 		if (scmd->satacmd_acdb[3] != 0)
10026 			scmd->satacmd_acdb[4] = 255;
10027 	}
10028 
10029 #ifdef SATA_DEBUG
10030 	if (sata_debug_flags & SATA_DBG_ATAPI) {
10031 		uint8_t *p = scmd->satacmd_acdb;
10032 		char buf[3 * SATA_ATAPI_MAX_CDB_LEN];
10033 
10034 		(void) snprintf(buf, SATA_ATAPI_MAX_CDB_LEN,
10035 		    "%02x %02x %02x %02x %02x %02x %02x %02x "
10036 		    "%2x %02x %02x %02x %02x %02x %02x %02x",
10037 		    p[0], p[1], p[2], p[3], p[4], p[5], p[6], p[7],
10038 		    p[8], p[9], p[10], p[11], p[12], p[13], p[14], p[15]);
10039 		buf[(3 * SATA_ATAPI_MAX_CDB_LEN) - 1] = '\0';
10040 		cmn_err(CE_NOTE, "ATAPI cdb: %s\n", buf);
10041 	}
10042 #endif
10043 
10044 	/*
10045 	 * Preset request sense data to NO SENSE.
10046 	 * If there is no way to get error information via Request Sense,
10047 	 * the packet request sense data would not have to be modified by HBA,
10048 	 * but it could be returned as is.
10049 	 */
10050 	bzero(scmd->satacmd_rqsense, SATA_ATAPI_RQSENSE_LEN);
10051 	sata_fixed_sense_data_preset(
10052 	    (struct scsi_extended_sense *)scmd->satacmd_rqsense);
10053 
10054 	if (!(spx->txlt_sata_pkt->satapkt_op_mode & SATA_OPMODE_SYNCH)) {
10055 		/* Need callback function */
10056 		spx->txlt_sata_pkt->satapkt_comp = sata_txlt_atapi_completion;
10057 		synch = FALSE;
10058 	} else
10059 		synch = TRUE;
10060 
10061 	/* Transfer command to HBA */
10062 	if (sata_hba_start(spx, &rval) != 0) {
10063 		/* Pkt not accepted for execution */
10064 		mutex_exit(cport_mutex);
10065 		return (rval);
10066 	}
10067 	mutex_exit(cport_mutex);
10068 	/*
10069 	 * If execution is non-synchronous,
10070 	 * a callback function will handle potential errors, translate
10071 	 * the response and will do a callback to a target driver.
10072 	 * If it was synchronous, use the same framework callback to check
10073 	 * an execution status.
10074 	 */
10075 	if (synch) {
10076 		SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst,
10077 		    "synchronous execution status %x\n",
10078 		    spx->txlt_sata_pkt->satapkt_reason);
10079 		sata_txlt_atapi_completion(spx->txlt_sata_pkt);
10080 	}
10081 	return (TRAN_ACCEPT);
10082 }
10083 
10084 
10085 /*
10086  * ATAPI Packet command completion.
10087  *
10088  * Failure of the command passed via Packet command are considered device
10089  * error. SATA HBA driver would have to retrieve error data (via Request
10090  * Sense command delivered via error retrieval sata packet) and copy it
10091  * to satacmd_rqsense array. From there, it is moved into scsi pkt sense data.
10092  */
10093 static void
10094 sata_txlt_atapi_completion(sata_pkt_t *sata_pkt)
10095 {
10096 	sata_pkt_txlate_t *spx =
10097 	    (sata_pkt_txlate_t *)sata_pkt->satapkt_framework_private;
10098 	struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt;
10099 	struct scsi_extended_sense *sense;
10100 	struct buf *bp;
10101 	int rval;
10102 
10103 #ifdef SATA_DEBUG
10104 	uint8_t *rqsp = sata_pkt->satapkt_cmd.satacmd_rqsense;
10105 #endif
10106 
10107 	scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET |
10108 	    STATE_SENT_CMD | STATE_GOT_STATUS;
10109 
10110 	if (sata_pkt->satapkt_reason == SATA_PKT_COMPLETED) {
10111 		/* Normal completion */
10112 		if (sata_pkt->satapkt_cmd.satacmd_bp != NULL)
10113 			scsipkt->pkt_state |= STATE_XFERRED_DATA;
10114 		scsipkt->pkt_reason = CMD_CMPLT;
10115 		*scsipkt->pkt_scbp = STATUS_GOOD;
10116 		if (spx->txlt_tmp_buf != NULL) {
10117 			/* Temporary buffer was used */
10118 			bp = spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp;
10119 			if (bp->b_flags & B_READ) {
10120 				rval = ddi_dma_sync(
10121 				    spx->txlt_buf_dma_handle, 0, 0,
10122 				    DDI_DMA_SYNC_FORCPU);
10123 				ASSERT(rval == DDI_SUCCESS);
10124 				bcopy(spx->txlt_tmp_buf, bp->b_un.b_addr,
10125 				    bp->b_bcount);
10126 			}
10127 		}
10128 	} else {
10129 		/*
10130 		 * Something went wrong - analyze return
10131 		 */
10132 		*scsipkt->pkt_scbp = STATUS_CHECK;
10133 		sense = sata_arq_sense(spx);
10134 
10135 		if (sata_pkt->satapkt_reason == SATA_PKT_DEV_ERROR) {
10136 			/*
10137 			 * pkt_reason should be CMD_CMPLT for DEVICE ERROR.
10138 			 * Under this condition ERR bit is set for ATA command,
10139 			 * and CHK bit set for ATAPI command.
10140 			 *
10141 			 * Please check st_intr & sdintr about how pkt_reason
10142 			 * is used.
10143 			 */
10144 			scsipkt->pkt_reason = CMD_CMPLT;
10145 
10146 			/*
10147 			 * We may not have ARQ data if there was a double
10148 			 * error. But sense data in sata packet was pre-set
10149 			 * with NO SENSE so it is valid even if HBA could
10150 			 * not retrieve a real sense data.
10151 			 * Just copy this sense data into scsi pkt sense area.
10152 			 */
10153 			bcopy(sata_pkt->satapkt_cmd.satacmd_rqsense, sense,
10154 			    SATA_ATAPI_MIN_RQSENSE_LEN);
10155 #ifdef SATA_DEBUG
10156 			if (sata_debug_flags & SATA_DBG_SCSI_IF) {
10157 				sata_log(spx->txlt_sata_hba_inst, CE_WARN,
10158 				    "sata_txlt_atapi_completion: %02x\n"
10159 				    "RQSENSE:  %02x %02x %02x %02x %02x %02x "
10160 				    "          %02x %02x %02x %02x %02x %02x "
10161 				    "          %02x %02x %02x %02x %02x %02x\n",
10162 				    scsipkt->pkt_reason,
10163 				    rqsp[0], rqsp[1], rqsp[2], rqsp[3],
10164 				    rqsp[4], rqsp[5], rqsp[6], rqsp[7],
10165 				    rqsp[8], rqsp[9], rqsp[10], rqsp[11],
10166 				    rqsp[12], rqsp[13], rqsp[14], rqsp[15],
10167 				    rqsp[16], rqsp[17]);
10168 			}
10169 #endif
10170 		} else {
10171 			switch (sata_pkt->satapkt_reason) {
10172 			case SATA_PKT_PORT_ERROR:
10173 				/*
10174 				 * We have no device data.
10175 				 */
10176 				scsipkt->pkt_reason = CMD_INCOMPLETE;
10177 				scsipkt->pkt_state &= ~(STATE_GOT_BUS |
10178 				    STATE_GOT_TARGET | STATE_SENT_CMD |
10179 				    STATE_GOT_STATUS);
10180 				sense->es_key = KEY_HARDWARE_ERROR;
10181 				break;
10182 
10183 			case SATA_PKT_TIMEOUT:
10184 				scsipkt->pkt_reason = CMD_TIMEOUT;
10185 				scsipkt->pkt_statistics |=
10186 				    STAT_TIMEOUT | STAT_DEV_RESET;
10187 				/*
10188 				 * Need to check if HARDWARE_ERROR/
10189 				 * TIMEOUT_ON_LOGICAL_UNIT 4/3E/2 would be more
10190 				 * appropriate.
10191 				 */
10192 				break;
10193 
10194 			case SATA_PKT_ABORTED:
10195 				scsipkt->pkt_reason = CMD_ABORTED;
10196 				scsipkt->pkt_statistics |= STAT_ABORTED;
10197 				/* Should we set key COMMAND_ABPRTED? */
10198 				break;
10199 
10200 			case SATA_PKT_RESET:
10201 				scsipkt->pkt_reason = CMD_RESET;
10202 				scsipkt->pkt_statistics |= STAT_DEV_RESET;
10203 				/*
10204 				 * May be we should set Unit Attention /
10205 				 * Reset. Perhaps the same should be
10206 				 * returned for disks....
10207 				 */
10208 				sense->es_key = KEY_UNIT_ATTENTION;
10209 				sense->es_add_code = SD_SCSI_ASC_RESET;
10210 				break;
10211 
10212 			default:
10213 				SATA_LOG_D((spx->txlt_sata_hba_inst, CE_WARN,
10214 				    "sata_txlt_atapi_completion: "
10215 				    "invalid packet completion reason"));
10216 				scsipkt->pkt_reason = CMD_TRAN_ERR;
10217 				scsipkt->pkt_state &= ~(STATE_GOT_BUS |
10218 				    STATE_GOT_TARGET | STATE_SENT_CMD |
10219 				    STATE_GOT_STATUS);
10220 				break;
10221 			}
10222 		}
10223 	}
10224 
10225 	SATAATAPITRACE(spx, 0);
10226 
10227 	if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0 &&
10228 	    scsipkt->pkt_comp != NULL) {
10229 		/* scsi callback required */
10230 		(*scsipkt->pkt_comp)(scsipkt);
10231 	}
10232 }
10233 
10234 /*
10235  * Set up error retrieval sata command for ATAPI Packet Command error data
10236  * recovery.
10237  *
10238  * Returns SATA_SUCCESS when data buffer is allocated and packet set-up,
10239  * returns SATA_FAILURE otherwise.
10240  */
10241 
10242 static int
10243 sata_atapi_err_ret_cmd_setup(sata_pkt_txlate_t *spx, sata_drive_info_t *sdinfo)
10244 {
10245 	sata_pkt_t *spkt = spx->txlt_sata_pkt;
10246 	sata_cmd_t *scmd;
10247 	struct buf *bp;
10248 
10249 	/*
10250 	 * Allocate dma-able buffer error data.
10251 	 * Buffer allocation will take care of buffer alignment and other DMA
10252 	 * attributes.
10253 	 */
10254 	bp = sata_alloc_local_buffer(spx, SATA_ATAPI_MIN_RQSENSE_LEN);
10255 	if (bp == NULL) {
10256 		SATADBG1(SATA_DBG_ATAPI, spx->txlt_sata_hba_inst,
10257 		    "sata_get_err_retrieval_pkt: "
10258 		    "cannot allocate buffer for error data", NULL);
10259 		return (SATA_FAILURE);
10260 	}
10261 	bp_mapin(bp); /* make data buffer accessible */
10262 
10263 	/* Operation modes are up to the caller */
10264 	spkt->satapkt_op_mode = SATA_OPMODE_SYNCH | SATA_OPMODE_INTERRUPTS;
10265 
10266 	/* Synchronous mode, no callback - may be changed by the caller */
10267 	spkt->satapkt_comp = NULL;
10268 	spkt->satapkt_time = sata_default_pkt_time;
10269 
10270 	scmd = &spkt->satapkt_cmd;
10271 	scmd->satacmd_flags.sata_data_direction = SATA_DIR_READ;
10272 	scmd->satacmd_flags.sata_ignore_dev_reset = B_TRUE;
10273 
10274 	sata_atapi_packet_cmd_setup(scmd, sdinfo);
10275 
10276 	/*
10277 	 * Set-up acdb. Request Sense CDB (packet command content) is
10278 	 * not in DMA-able buffer. Its handling is HBA-specific (how
10279 	 * it is transfered into packet FIS).
10280 	 */
10281 	scmd->satacmd_acdb_len = sdinfo->satadrv_atapi_cdb_len;
10282 	bcopy(sata_rqsense_cdb, scmd->satacmd_acdb, SATA_ATAPI_RQSENSE_CDB_LEN);
10283 	/* Following zeroing of pad bytes may not be necessary */
10284 	bzero(&scmd->satacmd_acdb[SATA_ATAPI_RQSENSE_CDB_LEN],
10285 	    sdinfo->satadrv_atapi_cdb_len - SATA_ATAPI_RQSENSE_CDB_LEN);
10286 
10287 	/*
10288 	 * Set-up pointer to the buffer handle, so HBA can sync buffer
10289 	 * before accessing it. Handle is in usual place in translate struct.
10290 	 */
10291 	scmd->satacmd_err_ret_buf_handle = &spx->txlt_buf_dma_handle;
10292 
10293 	/*
10294 	 * Preset request sense data to NO SENSE.
10295 	 * Here it is redundant, only for a symetry with scsi-originated
10296 	 * packets. It should not be used for anything but debugging.
10297 	 */
10298 	bzero(scmd->satacmd_rqsense, SATA_ATAPI_RQSENSE_LEN);
10299 	sata_fixed_sense_data_preset(
10300 	    (struct scsi_extended_sense *)scmd->satacmd_rqsense);
10301 
10302 	ASSERT(scmd->satacmd_num_dma_cookies != 0);
10303 	ASSERT(scmd->satacmd_dma_cookie_list != NULL);
10304 
10305 	return (SATA_SUCCESS);
10306 }
10307 
10308 /*
10309  * Set-up ATAPI packet command.
10310  * Data transfer direction has to be set-up in sata_cmd structure prior to
10311  * calling this function.
10312  *
10313  * Returns void
10314  */
10315 
10316 static void
10317 sata_atapi_packet_cmd_setup(sata_cmd_t *scmd, sata_drive_info_t *sdinfo)
10318 {
10319 	scmd->satacmd_addr_type = 0;		/* N/A */
10320 	scmd->satacmd_sec_count_lsb = 0;	/* no tag */
10321 	scmd->satacmd_lba_low_lsb = 0;		/* N/A */
10322 	scmd->satacmd_lba_mid_lsb = (uint8_t)SATA_ATAPI_MAX_BYTES_PER_DRQ;
10323 	scmd->satacmd_lba_high_lsb =
10324 	    (uint8_t)(SATA_ATAPI_MAX_BYTES_PER_DRQ >> 8);
10325 	scmd->satacmd_cmd_reg = SATAC_PACKET;	/* Command */
10326 
10327 	/*
10328 	 * We want all data to be transfered via DMA.
10329 	 * But specify it only if drive supports DMA and DMA mode is
10330 	 * selected - some drives are sensitive about it.
10331 	 * Hopefully it wil work for all drives....
10332 	 */
10333 	if (sdinfo->satadrv_settings & SATA_DEV_DMA)
10334 		scmd->satacmd_features_reg = SATA_ATAPI_F_DMA;
10335 
10336 	/*
10337 	 * Features register requires special care for devices that use
10338 	 * Serial ATA bridge - they need an explicit specification of
10339 	 * the data transfer direction for Packet DMA commands.
10340 	 * Setting this bit is harmless if DMA is not used.
10341 	 *
10342 	 * Many drives do not implement word 80, specifying what ATA/ATAPI
10343 	 * spec they follow.
10344 	 * We are arbitrarily following the latest SerialATA 2.6 spec,
10345 	 * which uses ATA/ATAPI 6 specification for Identify Data, unless
10346 	 * ATA/ATAPI-7 support is explicitly indicated.
10347 	 */
10348 	if (sdinfo->satadrv_id.ai_majorversion != 0 &&
10349 	    sdinfo->satadrv_id.ai_majorversion != 0xffff &&
10350 	    (sdinfo->satadrv_id.ai_majorversion & SATA_MAJVER_7) != 0) {
10351 		/*
10352 		 * Specification of major version is valid and version 7
10353 		 * is supported. It does automatically imply that all
10354 		 * spec features are supported. For now, we assume that
10355 		 * DMADIR setting is valid. ATA/ATAPI7 spec is incomplete.
10356 		 */
10357 		if ((sdinfo->satadrv_id.ai_dirdma &
10358 		    SATA_ATAPI_ID_DMADIR_REQ) != 0) {
10359 			if (scmd->satacmd_flags.sata_data_direction ==
10360 			    SATA_DIR_READ) {
10361 				scmd->satacmd_features_reg |=
10362 				    SATA_ATAPI_F_DATA_DIR_READ;
10363 			}
10364 		}
10365 	}
10366 }
10367 
10368 
10369 #ifdef SATA_DEBUG
10370 
10371 /* Display 18 bytes of Inquiry data */
10372 static void
10373 sata_show_inqry_data(uint8_t *buf)
10374 {
10375 	struct scsi_inquiry *inq = (struct scsi_inquiry *)buf;
10376 	uint8_t *p;
10377 
10378 	cmn_err(CE_NOTE, "Inquiry data:");
10379 	cmn_err(CE_NOTE, "device type %x", inq->inq_dtype);
10380 	cmn_err(CE_NOTE, "removable media %x", inq->inq_rmb);
10381 	cmn_err(CE_NOTE, "version %x", inq->inq_ansi);
10382 	cmn_err(CE_NOTE, "ATAPI transport version %d",
10383 	    SATA_ATAPI_TRANS_VERSION(inq));
10384 	cmn_err(CE_NOTE, "response data format %d, aenc %d",
10385 	    inq->inq_rdf, inq->inq_aenc);
10386 	cmn_err(CE_NOTE, " additional length %d", inq->inq_len);
10387 	cmn_err(CE_NOTE, "tpgs %d", inq->inq_tpgs);
10388 	p = (uint8_t *)inq->inq_vid;
10389 	cmn_err(CE_NOTE, "vendor id (binary): %02x %02x %02x %02x "
10390 	    "%02x %02x %02x %02x",
10391 	    p[0], p[1], p[2], p[3], p[4], p[5], p[6], p[7]);
10392 	p = (uint8_t *)inq->inq_vid;
10393 	cmn_err(CE_NOTE, "vendor id: %c %c %c %c %c %c %c %c",
10394 	    p[0], p[1], p[2], p[3], p[4], p[5], p[6], p[7]);
10395 
10396 	p = (uint8_t *)inq->inq_pid;
10397 	cmn_err(CE_NOTE, "product id (binary): %02x %02x %02x %02x "
10398 	    "%02x %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x",
10399 	    p[0], p[1], p[2], p[3], p[4], p[5], p[6], p[7],
10400 	    p[8], p[9], p[10], p[11], p[12], p[13], p[14], p[15]);
10401 	p = (uint8_t *)inq->inq_pid;
10402 	cmn_err(CE_NOTE, "product id: %c %c %c %c %c %c %c %c "
10403 	    "%c %c %c %c %c %c %c %c",
10404 	    p[0], p[1], p[2], p[3], p[4], p[5], p[6], p[7],
10405 	    p[8], p[9], p[10], p[11], p[12], p[13], p[14], p[15]);
10406 
10407 	p = (uint8_t *)inq->inq_revision;
10408 	cmn_err(CE_NOTE, "revision (binary): %02x %02x %02x %02x",
10409 	    p[0], p[1], p[2], p[3]);
10410 	p = (uint8_t *)inq->inq_revision;
10411 	cmn_err(CE_NOTE, "revision: %c %c %c %c",
10412 	    p[0], p[1], p[2], p[3]);
10413 
10414 }
10415 
10416 
10417 static void
10418 sata_save_atapi_trace(sata_pkt_txlate_t *spx, int count)
10419 {
10420 	struct scsi_pkt *scsi_pkt = spx->txlt_scsi_pkt;
10421 
10422 	if (scsi_pkt == NULL)
10423 		return;
10424 	if (count != 0) {
10425 		/* saving cdb */
10426 		bzero(sata_atapi_trace[sata_atapi_trace_index].acdb,
10427 		    SATA_ATAPI_MAX_CDB_LEN);
10428 		bcopy(scsi_pkt->pkt_cdbp,
10429 		    sata_atapi_trace[sata_atapi_trace_index].acdb, count);
10430 	} else {
10431 		bcopy(&((struct scsi_arq_status *)scsi_pkt->pkt_scbp)->
10432 		    sts_sensedata,
10433 		    sata_atapi_trace[sata_atapi_trace_index].arqs,
10434 		    SATA_ATAPI_MIN_RQSENSE_LEN);
10435 		sata_atapi_trace[sata_atapi_trace_index].scsi_pkt_reason =
10436 		    scsi_pkt->pkt_reason;
10437 		sata_atapi_trace[sata_atapi_trace_index].sata_pkt_reason =
10438 		    spx->txlt_sata_pkt->satapkt_reason;
10439 
10440 		if (++sata_atapi_trace_index >= 64)
10441 			sata_atapi_trace_index = 0;
10442 	}
10443 }
10444 
10445 #endif
10446 
10447 /*
10448  * Fetch inquiry data from ATAPI device
10449  * Returns SATA_SUCCESS if operation was successful, SATA_FAILURE otherwise.
10450  *
10451  * Note:
10452  * inqb pointer does not point to a DMA-able buffer. It is a local buffer
10453  * where the caller expects to see the inquiry data.
10454  *
10455  */
10456 
10457 static int
10458 sata_get_atapi_inquiry_data(sata_hba_inst_t *sata_hba,
10459     sata_address_t *saddr, struct scsi_inquiry *inq)
10460 {
10461 	sata_pkt_txlate_t *spx;
10462 	sata_pkt_t *spkt;
10463 	struct buf *bp;
10464 	sata_drive_info_t *sdinfo;
10465 	sata_cmd_t *scmd;
10466 	int rval;
10467 	uint8_t *rqsp;
10468 	dev_info_t *dip = SATA_DIP(sata_hba);
10469 #ifdef SATA_DEBUG
10470 	char msg_buf[MAXPATHLEN];
10471 #endif
10472 	kmutex_t *cport_mutex;
10473 
10474 	ASSERT(sata_hba != NULL);
10475 
10476 	spx = kmem_zalloc(sizeof (sata_pkt_txlate_t), KM_SLEEP);
10477 	spx->txlt_sata_hba_inst = sata_hba;
10478 	spx->txlt_scsi_pkt = NULL;		/* No scsi pkt involved */
10479 	spkt = sata_pkt_alloc(spx, NULL);
10480 	if (spkt == NULL) {
10481 		kmem_free(spx, sizeof (sata_pkt_txlate_t));
10482 		return (SATA_FAILURE);
10483 	}
10484 	/* address is needed now */
10485 	spkt->satapkt_device.satadev_addr = *saddr;
10486 
10487 	/* scsi_inquiry size buffer */
10488 	bp = sata_alloc_local_buffer(spx, sizeof (struct scsi_inquiry));
10489 	if (bp == NULL) {
10490 		sata_pkt_free(spx);
10491 		kmem_free(spx, sizeof (sata_pkt_txlate_t));
10492 		SATA_LOG_D((sata_hba, CE_WARN,
10493 		    "sata_get_atapi_inquiry_data: "
10494 		    "cannot allocate data buffer"));
10495 		return (SATA_FAILURE);
10496 	}
10497 	bp_mapin(bp); /* make data buffer accessible */
10498 
10499 	scmd = &spkt->satapkt_cmd;
10500 	ASSERT(scmd->satacmd_num_dma_cookies != 0);
10501 	ASSERT(scmd->satacmd_dma_cookie_list != NULL);
10502 
10503 	/* Use synchronous mode */
10504 	spkt->satapkt_op_mode = SATA_OPMODE_SYNCH | SATA_OPMODE_INTERRUPTS;
10505 	spkt->satapkt_comp = NULL;
10506 	spkt->satapkt_time = sata_default_pkt_time;
10507 
10508 	/* Issue inquiry command - 6 bytes cdb, data transfer, read */
10509 
10510 	scmd->satacmd_flags.sata_data_direction = SATA_DIR_READ;
10511 	scmd->satacmd_flags.sata_ignore_dev_reset = B_TRUE;
10512 
10513 	cport_mutex = &(SATA_CPORT_MUTEX(sata_hba, saddr->cport));
10514 	mutex_enter(cport_mutex);
10515 	sdinfo = sata_get_device_info(sata_hba,
10516 	    &spx->txlt_sata_pkt->satapkt_device);
10517 	if (sdinfo == NULL) {
10518 		/* we have to be carefull about the disapearing device */
10519 		mutex_exit(cport_mutex);
10520 		rval = SATA_FAILURE;
10521 		goto cleanup;
10522 	}
10523 	sata_atapi_packet_cmd_setup(scmd, sdinfo);
10524 
10525 	/*
10526 	 * Set-up acdb. This works for atapi transport version 2 and later.
10527 	 */
10528 	scmd->satacmd_acdb_len = sdinfo->satadrv_atapi_cdb_len;
10529 	bzero(scmd->satacmd_acdb, SATA_ATAPI_MAX_CDB_LEN);
10530 	scmd->satacmd_acdb[0] = 0x12;	/* Inquiry */
10531 	scmd->satacmd_acdb[1] = 0x00;
10532 	scmd->satacmd_acdb[2] = 0x00;
10533 	scmd->satacmd_acdb[3] = 0x00;
10534 	scmd->satacmd_acdb[4] = sizeof (struct scsi_inquiry);
10535 	scmd->satacmd_acdb[5] = 0x00;
10536 
10537 	sata_fixed_sense_data_preset(
10538 	    (struct scsi_extended_sense *)scmd->satacmd_rqsense);
10539 
10540 	/* Transfer command to HBA */
10541 	if (sata_hba_start(spx, &rval) != 0) {
10542 		/* Pkt not accepted for execution */
10543 		SATADBG1(SATA_DBG_ATAPI, sata_hba,
10544 		    "sata_get_atapi_inquiry_data: "
10545 		    "Packet not accepted for execution - ret: %02x", rval);
10546 		mutex_exit(cport_mutex);
10547 		rval = SATA_FAILURE;
10548 		goto cleanup;
10549 	}
10550 	mutex_exit(cport_mutex);
10551 
10552 	if (spkt->satapkt_reason == SATA_PKT_COMPLETED) {
10553 		SATADBG1(SATA_DBG_ATAPI, sata_hba,
10554 		    "sata_get_atapi_inquiry_data: "
10555 		    "Packet completed successfully - ret: %02x", rval);
10556 		if (spx->txlt_buf_dma_handle != NULL) {
10557 			/*
10558 			 * Sync buffer. Handle is in usual place in translate
10559 			 * struct.
10560 			 */
10561 			rval = ddi_dma_sync(spx->txlt_buf_dma_handle, 0, 0,
10562 			    DDI_DMA_SYNC_FORCPU);
10563 			ASSERT(rval == DDI_SUCCESS);
10564 		}
10565 
10566 		if (sata_check_for_dma_error(dip, spx)) {
10567 			ddi_fm_service_impact(dip, DDI_SERVICE_UNAFFECTED);
10568 			rval = SATA_FAILURE;
10569 		} else {
10570 			/*
10571 			 * Normal completion - copy data into caller's buffer
10572 			 */
10573 			bcopy(bp->b_un.b_addr, (uint8_t *)inq,
10574 			    sizeof (struct scsi_inquiry));
10575 #ifdef SATA_DEBUG
10576 			if (sata_debug_flags & SATA_DBG_ATAPI) {
10577 				sata_show_inqry_data((uint8_t *)inq);
10578 			}
10579 #endif
10580 			rval = SATA_SUCCESS;
10581 		}
10582 	} else {
10583 		/*
10584 		 * Something went wrong - analyze return - check rqsense data
10585 		 */
10586 		rval = SATA_FAILURE;
10587 		if (spkt->satapkt_reason == SATA_PKT_DEV_ERROR) {
10588 			/*
10589 			 * ARQ data hopefull show something other than NO SENSE
10590 			 */
10591 			rqsp = scmd->satacmd_rqsense;
10592 #ifdef SATA_DEBUG
10593 			if (sata_debug_flags & SATA_DBG_ATAPI) {
10594 				msg_buf[0] = '\0';
10595 				(void) snprintf(msg_buf, MAXPATHLEN,
10596 				    "ATAPI packet completion reason: %02x\n"
10597 				    "RQSENSE:  %02x %02x %02x %02x %02x %02x\n"
10598 				    "          %02x %02x %02x %02x %02x %02x\n"
10599 				    "          %02x %02x %02x %02x %02x %02x",
10600 				    spkt->satapkt_reason,
10601 				    rqsp[0], rqsp[1], rqsp[2], rqsp[3],
10602 				    rqsp[4], rqsp[5], rqsp[6], rqsp[7],
10603 				    rqsp[8], rqsp[9], rqsp[10], rqsp[11],
10604 				    rqsp[12], rqsp[13], rqsp[14], rqsp[15],
10605 				    rqsp[16], rqsp[17]);
10606 				sata_log(spx->txlt_sata_hba_inst, CE_WARN,
10607 				    "%s", msg_buf);
10608 			}
10609 #endif
10610 		} else {
10611 			switch (spkt->satapkt_reason) {
10612 			case SATA_PKT_PORT_ERROR:
10613 				SATADBG1(SATA_DBG_ATAPI, sata_hba,
10614 				    "sata_get_atapi_inquiry_data: "
10615 				    "packet reason: port error", NULL);
10616 				break;
10617 
10618 			case SATA_PKT_TIMEOUT:
10619 				SATADBG1(SATA_DBG_ATAPI, sata_hba,
10620 				    "sata_get_atapi_inquiry_data: "
10621 				    "packet reason: timeout", NULL);
10622 				break;
10623 
10624 			case SATA_PKT_ABORTED:
10625 				SATADBG1(SATA_DBG_ATAPI, sata_hba,
10626 				    "sata_get_atapi_inquiry_data: "
10627 				    "packet reason: aborted", NULL);
10628 				break;
10629 
10630 			case SATA_PKT_RESET:
10631 				SATADBG1(SATA_DBG_ATAPI, sata_hba,
10632 				    "sata_get_atapi_inquiry_data: "
10633 				    "packet reason: reset\n", NULL);
10634 				break;
10635 			default:
10636 				SATADBG1(SATA_DBG_ATAPI, sata_hba,
10637 				    "sata_get_atapi_inquiry_data: "
10638 				    "invalid packet reason: %02x\n",
10639 				    spkt->satapkt_reason);
10640 				break;
10641 			}
10642 		}
10643 	}
10644 cleanup:
10645 	sata_free_local_buffer(spx);
10646 	sata_pkt_free(spx);
10647 	kmem_free(spx, sizeof (sata_pkt_txlate_t));
10648 	return (rval);
10649 }
10650 
10651 
10652 
10653 
10654 
10655 #if 0
10656 #ifdef SATA_DEBUG
10657 
10658 /*
10659  * Test ATAPI packet command.
10660  * Single threaded test: send packet command in synch mode, process completion
10661  *
10662  */
10663 static void
10664 sata_test_atapi_packet_command(sata_hba_inst_t *sata_hba_inst, int cport)
10665 {
10666 	sata_pkt_txlate_t *spx;
10667 	sata_pkt_t *spkt;
10668 	struct buf *bp;
10669 	sata_device_t sata_device;
10670 	sata_drive_info_t *sdinfo;
10671 	sata_cmd_t *scmd;
10672 	int rval;
10673 	uint8_t *rqsp;
10674 
10675 	ASSERT(sata_hba_inst != NULL);
10676 	sata_device.satadev_addr.cport = cport;
10677 	sata_device.satadev_addr.pmport = 0;
10678 	sata_device.satadev_addr.qual = SATA_ADDR_DCPORT;
10679 	sata_device.satadev_rev = SATA_DEVICE_REV;
10680 	mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex);
10681 	sdinfo = sata_get_device_info(sata_hba_inst, &sata_device);
10682 	mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex);
10683 	if (sdinfo == NULL) {
10684 		sata_log(sata_hba_inst, CE_WARN,
10685 		    "sata_test_atapi_packet_command: "
10686 		    "no device info for cport %d",
10687 		    sata_device.satadev_addr.cport);
10688 		return;
10689 	}
10690 
10691 	spx = kmem_zalloc(sizeof (sata_pkt_txlate_t), KM_SLEEP);
10692 	spx->txlt_sata_hba_inst = sata_hba_inst;
10693 	spx->txlt_scsi_pkt = NULL;		/* No scsi pkt involved */
10694 	spkt = sata_pkt_alloc(spx, NULL);
10695 	if (spkt == NULL) {
10696 		kmem_free(spx, sizeof (sata_pkt_txlate_t));
10697 		return;
10698 	}
10699 	/* address is needed now */
10700 	spkt->satapkt_device.satadev_addr = sata_device.satadev_addr;
10701 
10702 	/* 1024k buffer */
10703 	bp = sata_alloc_local_buffer(spx, 1024);
10704 	if (bp == NULL) {
10705 		sata_pkt_free(spx);
10706 		kmem_free(spx, sizeof (sata_pkt_txlate_t));
10707 		sata_log(sata_hba_inst, CE_WARN,
10708 		    "sata_test_atapi_packet_command: "
10709 		    "cannot allocate data buffer");
10710 		return;
10711 	}
10712 	bp_mapin(bp); /* make data buffer accessible */
10713 
10714 	scmd = &spkt->satapkt_cmd;
10715 	ASSERT(scmd->satacmd_num_dma_cookies != 0);
10716 	ASSERT(scmd->satacmd_dma_cookie_list != NULL);
10717 
10718 	/* Use synchronous mode */
10719 	spkt->satapkt_op_mode = SATA_OPMODE_SYNCH | SATA_OPMODE_INTERRUPTS;
10720 
10721 	/* Synchronous mode, no callback - may be changed by the caller */
10722 	spkt->satapkt_comp = NULL;
10723 	spkt->satapkt_time = sata_default_pkt_time;
10724 
10725 	/* Issue inquiry command - 6 bytes cdb, data transfer, read */
10726 
10727 	scmd->satacmd_flags.sata_data_direction = SATA_DIR_READ;
10728 	scmd->satacmd_flags.sata_ignore_dev_reset = B_TRUE;
10729 
10730 	sata_atapi_packet_cmd_setup(scmd, sdinfo);
10731 
10732 	/* Set-up acdb. */
10733 	scmd->satacmd_acdb_len = sdinfo->satadrv_atapi_cdb_len;
10734 	bzero(scmd->satacmd_acdb, SATA_ATAPI_MAX_CDB_LEN);
10735 	scmd->satacmd_acdb[0] = 0x12;	/* Inquiry */
10736 	scmd->satacmd_acdb[1] = 0x00;
10737 	scmd->satacmd_acdb[2] = 0x00;
10738 	scmd->satacmd_acdb[3] = 0x00;
10739 	scmd->satacmd_acdb[4] = sizeof (struct scsi_inquiry);
10740 	scmd->satacmd_acdb[5] = 0x00;
10741 
10742 	sata_fixed_sense_data_preset(
10743 	    (struct scsi_extended_sense *)scmd->satacmd_rqsense);
10744 
10745 	/* Transfer command to HBA */
10746 	mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex);
10747 	if (sata_hba_start(spx, &rval) != 0) {
10748 		/* Pkt not accepted for execution */
10749 		sata_log(sata_hba_inst, CE_WARN,
10750 		    "sata_test_atapi_packet_command: "
10751 		    "Packet not accepted for execution - ret: %02x", rval);
10752 		mutex_exit(
10753 		    &SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex);
10754 		goto cleanup;
10755 	}
10756 	mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex);
10757 
10758 	if (spx->txlt_buf_dma_handle != NULL) {
10759 		/*
10760 		 * Sync buffer. Handle is in usual place in translate struct.
10761 		 */
10762 		rval = ddi_dma_sync(spx->txlt_buf_dma_handle, 0, 0,
10763 		    DDI_DMA_SYNC_FORCPU);
10764 		ASSERT(rval == DDI_SUCCESS);
10765 	}
10766 	if (spkt->satapkt_reason == SATA_PKT_COMPLETED) {
10767 		sata_log(sata_hba_inst, CE_WARN,
10768 		    "sata_test_atapi_packet_command: "
10769 		    "Packet completed successfully");
10770 		/*
10771 		 * Normal completion - show inquiry data
10772 		 */
10773 		sata_show_inqry_data((uint8_t *)bp->b_un.b_addr);
10774 	} else {
10775 		/*
10776 		 * Something went wrong - analyze return - check rqsense data
10777 		 */
10778 		if (spkt->satapkt_reason == SATA_PKT_DEV_ERROR) {
10779 			/*
10780 			 * ARQ data hopefull show something other than NO SENSE
10781 			 */
10782 			rqsp = scmd->satacmd_rqsense;
10783 			sata_log(spx->txlt_sata_hba_inst, CE_WARN,
10784 			    "ATAPI packet completion reason: %02x\n"
10785 			    "RQSENSE:  %02x %02x %02x %02x %02x %02x "
10786 			    "          %02x %02x %02x %02x %02x %02x "
10787 			    "          %02x %02x %02x %02x %02x %02x\n",
10788 			    spkt->satapkt_reason,
10789 			    rqsp[0], rqsp[1], rqsp[2], rqsp[3],
10790 			    rqsp[4], rqsp[5], rqsp[6], rqsp[7],
10791 			    rqsp[8], rqsp[9], rqsp[10], rqsp[11],
10792 			    rqsp[12], rqsp[13], rqsp[14], rqsp[15],
10793 			    rqsp[16], rqsp[17]);
10794 		} else {
10795 			switch (spkt->satapkt_reason) {
10796 			case SATA_PKT_PORT_ERROR:
10797 				sata_log(sata_hba_inst, CE_WARN,
10798 				    "sata_test_atapi_packet_command: "
10799 				    "packet reason: port error\n");
10800 				break;
10801 
10802 			case SATA_PKT_TIMEOUT:
10803 				sata_log(sata_hba_inst, CE_WARN,
10804 				    "sata_test_atapi_packet_command: "
10805 				    "packet reason: timeout\n");
10806 				break;
10807 
10808 			case SATA_PKT_ABORTED:
10809 				sata_log(sata_hba_inst, CE_WARN,
10810 				    "sata_test_atapi_packet_command: "
10811 				    "packet reason: aborted\n");
10812 				break;
10813 
10814 			case SATA_PKT_RESET:
10815 				sata_log(sata_hba_inst, CE_WARN,
10816 				    "sata_test_atapi_packet_command: "
10817 				    "packet reason: reset\n");
10818 				break;
10819 			default:
10820 				sata_log(sata_hba_inst, CE_WARN,
10821 				    "sata_test_atapi_packet_command: "
10822 				    "invalid packet reason: %02x\n",
10823 				    spkt->satapkt_reason);
10824 				break;
10825 			}
10826 		}
10827 	}
10828 cleanup:
10829 	sata_free_local_buffer(spx);
10830 	sata_pkt_free(spx);
10831 	kmem_free(spx, sizeof (sata_pkt_txlate_t));
10832 }
10833 
10834 #endif /* SATA_DEBUG */
10835 #endif /* 1 */
10836 
10837 
10838 /* ************************** LOCAL HELPER FUNCTIONS *********************** */
10839 
10840 /*
10841  * Validate sata_tran info
10842  * SATA_FAILURE returns if structure is inconsistent or structure revision
10843  * does not match one used by the framework.
10844  *
10845  * Returns SATA_SUCCESS if sata_hba_tran has matching revision and contains
10846  * required function pointers.
10847  * Returns SATA_FAILURE otherwise.
10848  */
10849 static int
10850 sata_validate_sata_hba_tran(dev_info_t *dip, sata_hba_tran_t *sata_tran)
10851 {
10852 	/*
10853 	 * SATA_TRAN_HBA_REV is the current (highest) revision number
10854 	 * of the SATA interface.
10855 	 */
10856 	if (sata_tran->sata_tran_hba_rev > SATA_TRAN_HBA_REV) {
10857 		sata_log(NULL, CE_WARN,
10858 		    "sata: invalid sata_hba_tran version %d for driver %s",
10859 		    sata_tran->sata_tran_hba_rev, ddi_driver_name(dip));
10860 		return (SATA_FAILURE);
10861 	}
10862 
10863 	if (dip != sata_tran->sata_tran_hba_dip) {
10864 		SATA_LOG_D((NULL, CE_WARN,
10865 		    "sata: inconsistent sata_tran_hba_dip "
10866 		    "%p / %p", sata_tran->sata_tran_hba_dip, dip));
10867 		return (SATA_FAILURE);
10868 	}
10869 
10870 	if (sata_tran->sata_tran_probe_port == NULL ||
10871 	    sata_tran->sata_tran_start == NULL ||
10872 	    sata_tran->sata_tran_abort == NULL ||
10873 	    sata_tran->sata_tran_reset_dport == NULL ||
10874 	    sata_tran->sata_tran_hotplug_ops == NULL ||
10875 	    sata_tran->sata_tran_hotplug_ops->sata_tran_port_activate == NULL ||
10876 	    sata_tran->sata_tran_hotplug_ops->sata_tran_port_deactivate ==
10877 	    NULL) {
10878 		SATA_LOG_D((NULL, CE_WARN, "sata: sata_hba_tran missing "
10879 		    "required functions"));
10880 	}
10881 	return (SATA_SUCCESS);
10882 }
10883 
10884 /*
10885  * Remove HBA instance from sata_hba_list.
10886  */
10887 static void
10888 sata_remove_hba_instance(dev_info_t *dip)
10889 {
10890 	sata_hba_inst_t	*sata_hba_inst;
10891 
10892 	mutex_enter(&sata_mutex);
10893 	for (sata_hba_inst = sata_hba_list;
10894 	    sata_hba_inst != (struct sata_hba_inst *)NULL;
10895 	    sata_hba_inst = sata_hba_inst->satahba_next) {
10896 		if (sata_hba_inst->satahba_dip == dip)
10897 			break;
10898 	}
10899 
10900 	if (sata_hba_inst == (struct sata_hba_inst *)NULL) {
10901 #ifdef SATA_DEBUG
10902 		cmn_err(CE_WARN, "sata_remove_hba_instance: "
10903 		    "unknown HBA instance\n");
10904 #endif
10905 		ASSERT(FALSE);
10906 	}
10907 	if (sata_hba_inst == sata_hba_list) {
10908 		sata_hba_list = sata_hba_inst->satahba_next;
10909 		if (sata_hba_list) {
10910 			sata_hba_list->satahba_prev =
10911 			    (struct sata_hba_inst *)NULL;
10912 		}
10913 		if (sata_hba_inst == sata_hba_list_tail) {
10914 			sata_hba_list_tail = NULL;
10915 		}
10916 	} else if (sata_hba_inst == sata_hba_list_tail) {
10917 		sata_hba_list_tail = sata_hba_inst->satahba_prev;
10918 		if (sata_hba_list_tail) {
10919 			sata_hba_list_tail->satahba_next =
10920 			    (struct sata_hba_inst *)NULL;
10921 		}
10922 	} else {
10923 		sata_hba_inst->satahba_prev->satahba_next =
10924 		    sata_hba_inst->satahba_next;
10925 		sata_hba_inst->satahba_next->satahba_prev =
10926 		    sata_hba_inst->satahba_prev;
10927 	}
10928 	mutex_exit(&sata_mutex);
10929 }
10930 
10931 /*
10932  * Probe all SATA ports of the specified HBA instance.
10933  * The assumption is that there are no target and attachment point minor nodes
10934  * created by the boot subsystems, so we do not need to prune device tree.
10935  *
10936  * This function is called only from sata_hba_attach(). It does not have to
10937  * be protected by controller mutex, because the hba_attached flag is not set
10938  * yet and no one would be touching this HBA instance other than this thread.
10939  * Determines if port is active and what type of the device is attached
10940  * (if any). Allocates necessary structures for each port.
10941  *
10942  * An AP (Attachement Point) node is created for each SATA device port even
10943  * when there is no device attached.
10944  */
10945 
10946 static void
10947 sata_probe_ports(sata_hba_inst_t *sata_hba_inst)
10948 {
10949 	dev_info_t		*dip = SATA_DIP(sata_hba_inst);
10950 	int			ncport;
10951 	sata_cport_info_t	*cportinfo;
10952 	sata_drive_info_t	*drive;
10953 	sata_device_t		sata_device;
10954 	int			rval;
10955 	dev_t			minor_number;
10956 	char			name[16];
10957 	clock_t			start_time, cur_time;
10958 
10959 	/*
10960 	 * Probe controller ports first, to find port status and
10961 	 * any port multiplier attached.
10962 	 */
10963 	for (ncport = 0; ncport < SATA_NUM_CPORTS(sata_hba_inst); ncport++) {
10964 		/* allocate cport structure */
10965 		cportinfo = kmem_zalloc(sizeof (sata_cport_info_t), KM_SLEEP);
10966 		ASSERT(cportinfo != NULL);
10967 		mutex_init(&cportinfo->cport_mutex, NULL, MUTEX_DRIVER, NULL);
10968 
10969 		mutex_enter(&cportinfo->cport_mutex);
10970 
10971 		cportinfo->cport_addr.cport = ncport;
10972 		cportinfo->cport_addr.pmport = 0;
10973 		cportinfo->cport_addr.qual = SATA_ADDR_CPORT;
10974 		cportinfo->cport_state &= ~SATA_PORT_STATE_CLEAR_MASK;
10975 		cportinfo->cport_state |= SATA_STATE_PROBING;
10976 		SATA_CPORT_INFO(sata_hba_inst, ncport) = cportinfo;
10977 
10978 		/*
10979 		 * Regardless if a port is usable or not, create
10980 		 * an attachment point
10981 		 */
10982 		mutex_exit(&cportinfo->cport_mutex);
10983 		minor_number = SATA_MAKE_AP_MINOR(ddi_get_instance(dip),
10984 		    ncport, 0, SATA_ADDR_CPORT);
10985 		(void) sprintf(name, "%d", ncport);
10986 		if (ddi_create_minor_node(dip, name, S_IFCHR,
10987 		    minor_number, DDI_NT_SATA_ATTACHMENT_POINT, 0) !=
10988 		    DDI_SUCCESS) {
10989 			sata_log(sata_hba_inst, CE_WARN, "sata_hba_attach: "
10990 			    "cannot create SATA attachment point for port %d",
10991 			    ncport);
10992 		}
10993 
10994 		/* Probe port */
10995 		start_time = ddi_get_lbolt();
10996 	reprobe_cport:
10997 		sata_device.satadev_addr.cport = ncport;
10998 		sata_device.satadev_addr.pmport = 0;
10999 		sata_device.satadev_addr.qual = SATA_ADDR_CPORT;
11000 		sata_device.satadev_rev = SATA_DEVICE_REV;
11001 
11002 		rval = (*SATA_PROBE_PORT_FUNC(sata_hba_inst))
11003 		    (dip, &sata_device);
11004 
11005 		mutex_enter(&cportinfo->cport_mutex);
11006 		cportinfo->cport_scr = sata_device.satadev_scr;
11007 		if (rval != SATA_SUCCESS) {
11008 			/* Something went wrong? Fail the port */
11009 			cportinfo->cport_state = SATA_PSTATE_FAILED;
11010 			mutex_exit(&cportinfo->cport_mutex);
11011 			continue;
11012 		}
11013 		cportinfo->cport_state &= ~SATA_STATE_PROBING;
11014 		cportinfo->cport_state |= SATA_STATE_PROBED;
11015 		cportinfo->cport_dev_type = sata_device.satadev_type;
11016 
11017 		cportinfo->cport_state |= SATA_STATE_READY;
11018 		if (cportinfo->cport_dev_type == SATA_DTYPE_NONE) {
11019 			mutex_exit(&cportinfo->cport_mutex);
11020 			continue;
11021 		}
11022 		if (cportinfo->cport_dev_type != SATA_DTYPE_PMULT) {
11023 			/*
11024 			 * There is some device attached.
11025 			 * Allocate device info structure
11026 			 */
11027 			if (SATA_CPORTINFO_DRV_INFO(cportinfo) == NULL) {
11028 				mutex_exit(&cportinfo->cport_mutex);
11029 				SATA_CPORTINFO_DRV_INFO(cportinfo) =
11030 				    kmem_zalloc(sizeof (sata_drive_info_t),
11031 				    KM_SLEEP);
11032 				mutex_enter(&cportinfo->cport_mutex);
11033 			}
11034 			drive = SATA_CPORTINFO_DRV_INFO(cportinfo);
11035 			drive->satadrv_addr = cportinfo->cport_addr;
11036 			drive->satadrv_addr.qual = SATA_ADDR_DCPORT;
11037 			drive->satadrv_type = cportinfo->cport_dev_type;
11038 			drive->satadrv_state = SATA_STATE_UNKNOWN;
11039 
11040 			mutex_exit(&cportinfo->cport_mutex);
11041 			if (sata_add_device(dip, sata_hba_inst, &sata_device) !=
11042 			    SATA_SUCCESS) {
11043 				/*
11044 				 * Plugged device was not correctly identified.
11045 				 * Retry, within a SATA_DEV_IDENTIFY_TIMEOUT
11046 				 */
11047 				cur_time = ddi_get_lbolt();
11048 				if ((cur_time - start_time) <
11049 				    drv_usectohz(SATA_DEV_IDENTIFY_TIMEOUT)) {
11050 					/* sleep for a while */
11051 					delay(drv_usectohz(
11052 					    SATA_DEV_RETRY_DLY));
11053 					goto reprobe_cport;
11054 				}
11055 			}
11056 		} else { /* SATA_DTYPE_PMULT */
11057 			mutex_exit(&cportinfo->cport_mutex);
11058 
11059 			/* Allocate sata_pmult_info and sata_pmport_info */
11060 			if (sata_alloc_pmult(sata_hba_inst, &sata_device) !=
11061 			    SATA_SUCCESS)
11062 				continue;
11063 
11064 			/* Log the information of the port multiplier */
11065 			sata_show_pmult_info(sata_hba_inst, &sata_device);
11066 
11067 			/* Probe its pmports */
11068 			sata_probe_pmports(sata_hba_inst, ncport);
11069 		}
11070 	}
11071 }
11072 
11073 /*
11074  * Probe all device ports behind a port multiplier.
11075  *
11076  * PMult-related structure should be allocated before by sata_alloc_pmult().
11077  *
11078  * NOTE1: Only called from sata_probe_ports()
11079  * NOTE2: No mutex should be hold.
11080  */
11081 static void
11082 sata_probe_pmports(sata_hba_inst_t *sata_hba_inst, uint8_t ncport)
11083 {
11084 	dev_info_t		*dip = SATA_DIP(sata_hba_inst);
11085 	sata_pmult_info_t	*pmultinfo = NULL;
11086 	sata_pmport_info_t	*pmportinfo = NULL;
11087 	sata_drive_info_t	*drive = NULL;
11088 	sata_device_t		sata_device;
11089 
11090 	clock_t			start_time, cur_time;
11091 	int			npmport;
11092 	int			rval;
11093 
11094 	pmultinfo = SATA_PMULT_INFO(sata_hba_inst, ncport);
11095 
11096 	/* Probe Port Multiplier ports */
11097 	for (npmport = 0; npmport < pmultinfo->pmult_num_dev_ports; npmport++) {
11098 		pmportinfo = pmultinfo->pmult_dev_port[npmport];
11099 		start_time = ddi_get_lbolt();
11100 reprobe_pmport:
11101 		sata_device.satadev_addr.cport = ncport;
11102 		sata_device.satadev_addr.pmport = npmport;
11103 		sata_device.satadev_addr.qual = SATA_ADDR_PMPORT;
11104 		sata_device.satadev_rev = SATA_DEVICE_REV;
11105 
11106 		/* Let HBA driver probe it. */
11107 		rval = (*SATA_PROBE_PORT_FUNC(sata_hba_inst))
11108 		    (dip, &sata_device);
11109 		mutex_enter(&pmportinfo->pmport_mutex);
11110 
11111 		pmportinfo->pmport_scr = sata_device.satadev_scr;
11112 
11113 		if (rval != SATA_SUCCESS) {
11114 			pmportinfo->pmport_state =
11115 			    SATA_PSTATE_FAILED;
11116 			mutex_exit(&pmportinfo->pmport_mutex);
11117 			continue;
11118 		}
11119 		pmportinfo->pmport_state &= ~SATA_STATE_PROBING;
11120 		pmportinfo->pmport_state |= SATA_STATE_PROBED;
11121 		pmportinfo->pmport_dev_type = sata_device.satadev_type;
11122 
11123 		pmportinfo->pmport_state |= SATA_STATE_READY;
11124 		if (pmportinfo->pmport_dev_type ==
11125 		    SATA_DTYPE_NONE) {
11126 			SATADBG2(SATA_DBG_PMULT, sata_hba_inst,
11127 			    "no device found at port %d:%d", ncport, npmport);
11128 			mutex_exit(&pmportinfo->pmport_mutex);
11129 			continue;
11130 		}
11131 		/* Port multipliers cannot be chained */
11132 		ASSERT(pmportinfo->pmport_dev_type != SATA_DTYPE_PMULT);
11133 		/*
11134 		 * There is something attached to Port
11135 		 * Multiplier device port
11136 		 * Allocate device info structure
11137 		 */
11138 		if (pmportinfo->pmport_sata_drive == NULL) {
11139 			mutex_exit(&pmportinfo->pmport_mutex);
11140 			pmportinfo->pmport_sata_drive =
11141 			    kmem_zalloc(sizeof (sata_drive_info_t), KM_SLEEP);
11142 			mutex_enter(&pmportinfo->pmport_mutex);
11143 		}
11144 		drive = pmportinfo->pmport_sata_drive;
11145 		drive->satadrv_addr.cport = pmportinfo->pmport_addr.cport;
11146 		drive->satadrv_addr.pmport = npmport;
11147 		drive->satadrv_addr.qual = SATA_ADDR_DPMPORT;
11148 		drive->satadrv_type = pmportinfo-> pmport_dev_type;
11149 		drive->satadrv_state = SATA_STATE_UNKNOWN;
11150 
11151 		mutex_exit(&pmportinfo->pmport_mutex);
11152 		rval = sata_add_device(dip, sata_hba_inst, &sata_device);
11153 
11154 		if (rval != SATA_SUCCESS) {
11155 			/*
11156 			 * Plugged device was not correctly identified.
11157 			 * Retry, within the SATA_DEV_IDENTIFY_TIMEOUT
11158 			 */
11159 			cur_time = ddi_get_lbolt();
11160 			if ((cur_time - start_time) < drv_usectohz(
11161 			    SATA_DEV_IDENTIFY_TIMEOUT)) {
11162 				/* sleep for a while */
11163 				delay(drv_usectohz(SATA_DEV_RETRY_DLY));
11164 				goto reprobe_pmport;
11165 			}
11166 		}
11167 	}
11168 }
11169 
11170 /*
11171  * Add SATA device for specified HBA instance & port (SCSI target
11172  * device nodes).
11173  * This function is called (indirectly) only from sata_hba_attach().
11174  * A target node is created when there is a supported type device attached,
11175  * but may be removed if it cannot be put online.
11176  *
11177  * This function cannot be called from an interrupt context.
11178  *
11179  * Create target nodes for disk, CD/DVD, Tape and ATAPI disk devices
11180  *
11181  * Returns SATA_SUCCESS when port/device was fully processed, SATA_FAILURE when
11182  * device identification failed - adding a device could be retried.
11183  *
11184  */
11185 static int
11186 sata_add_device(dev_info_t *pdip, sata_hba_inst_t *sata_hba_inst,
11187     sata_device_t *sata_device)
11188 {
11189 	sata_cport_info_t	*cportinfo;
11190 	sata_pmult_info_t	*pminfo;
11191 	sata_pmport_info_t	*pmportinfo;
11192 	dev_info_t		*cdip;		/* child dip */
11193 	sata_address_t		*saddr = &sata_device->satadev_addr;
11194 	uint8_t			cport, pmport;
11195 	int			rval;
11196 
11197 	cport = saddr->cport;
11198 	pmport = saddr->pmport;
11199 	cportinfo = SATA_CPORT_INFO(sata_hba_inst, cport);
11200 	ASSERT(cportinfo->cport_dev_type != SATA_DTYPE_NONE);
11201 
11202 	/*
11203 	 * Some device is attached to a controller port.
11204 	 * We rely on controllers distinquishing between no-device,
11205 	 * attached port multiplier and other kind of attached device.
11206 	 * We need to get Identify Device data and determine
11207 	 * positively the dev type before trying to attach
11208 	 * the target driver.
11209 	 */
11210 	sata_device->satadev_rev = SATA_DEVICE_REV;
11211 	switch (saddr->qual) {
11212 	case SATA_ADDR_CPORT:
11213 		/*
11214 		 * Add a non-port-multiplier device at controller port.
11215 		 */
11216 		saddr->qual = SATA_ADDR_DCPORT;
11217 
11218 		rval = sata_probe_device(sata_hba_inst, sata_device);
11219 		if (rval != SATA_SUCCESS ||
11220 		    sata_device->satadev_type == SATA_DTYPE_UNKNOWN)
11221 			return (SATA_FAILURE);
11222 
11223 		mutex_enter(&cportinfo->cport_mutex);
11224 		sata_show_drive_info(sata_hba_inst,
11225 		    SATA_CPORTINFO_DRV_INFO(cportinfo));
11226 
11227 		if ((sata_device->satadev_type & SATA_VALID_DEV_TYPE) == 0) {
11228 			/*
11229 			 * Could not determine device type or
11230 			 * a device is not supported.
11231 			 * Degrade this device to unknown.
11232 			 */
11233 			cportinfo->cport_dev_type = SATA_DTYPE_UNKNOWN;
11234 			mutex_exit(&cportinfo->cport_mutex);
11235 			return (SATA_SUCCESS);
11236 		}
11237 		cportinfo->cport_dev_type = sata_device->satadev_type;
11238 		cportinfo->cport_tgtnode_clean = B_TRUE;
11239 		mutex_exit(&cportinfo->cport_mutex);
11240 
11241 		/*
11242 		 * Initialize device to the desired state. Even if it
11243 		 * fails, the device will still attach but syslog
11244 		 * will show the warning.
11245 		 */
11246 		if (sata_initialize_device(sata_hba_inst,
11247 		    SATA_CPORTINFO_DRV_INFO(cportinfo)) != SATA_SUCCESS) {
11248 			/* Retry */
11249 			rval = sata_initialize_device(sata_hba_inst,
11250 			    SATA_CPORTINFO_DRV_INFO(cportinfo));
11251 
11252 			if (rval == SATA_RETRY)
11253 				sata_log(sata_hba_inst, CE_WARN,
11254 				    "SATA device at port %d - "
11255 				    "default device features could not be set."
11256 				    " Device may not operate as expected.",
11257 				    cport);
11258 		}
11259 
11260 		cdip = sata_create_target_node(pdip, sata_hba_inst, saddr);
11261 		if (cdip == NULL) {
11262 			/*
11263 			 * Attaching target node failed.
11264 			 * We retain sata_drive_info structure...
11265 			 */
11266 			return (SATA_SUCCESS);
11267 		}
11268 
11269 		mutex_enter(&cportinfo->cport_mutex);
11270 		(SATA_CPORTINFO_DRV_INFO(cportinfo))->
11271 		    satadrv_state = SATA_STATE_READY;
11272 		mutex_exit(&cportinfo->cport_mutex);
11273 
11274 		break;
11275 
11276 	case SATA_ADDR_PMPORT:
11277 		saddr->qual = SATA_ADDR_DPMPORT;
11278 
11279 		mutex_enter(&cportinfo->cport_mutex);
11280 		/* It must be a Port Multiplier at the controller port */
11281 		ASSERT(cportinfo->cport_dev_type == SATA_DTYPE_PMULT);
11282 
11283 		pminfo = SATA_CPORTINFO_PMULT_INFO(cportinfo);
11284 		pmportinfo = pminfo->pmult_dev_port[saddr->pmport];
11285 		mutex_exit(&cportinfo->cport_mutex);
11286 
11287 		rval = sata_probe_device(sata_hba_inst, sata_device);
11288 		if (rval != SATA_SUCCESS ||
11289 		    sata_device->satadev_type == SATA_DTYPE_UNKNOWN) {
11290 			return (SATA_FAILURE);
11291 		}
11292 
11293 		mutex_enter(&pmportinfo->pmport_mutex);
11294 		sata_show_drive_info(sata_hba_inst,
11295 		    SATA_PMPORTINFO_DRV_INFO(pmportinfo));
11296 
11297 		if ((sata_device->satadev_type & SATA_VALID_DEV_TYPE) == 0) {
11298 			/*
11299 			 * Could not determine device type.
11300 			 * Degrade this device to unknown.
11301 			 */
11302 			pmportinfo->pmport_dev_type = SATA_DTYPE_UNKNOWN;
11303 			mutex_exit(&pmportinfo->pmport_mutex);
11304 			return (SATA_SUCCESS);
11305 		}
11306 		pmportinfo->pmport_dev_type = sata_device->satadev_type;
11307 		pmportinfo->pmport_tgtnode_clean = B_TRUE;
11308 		mutex_exit(&pmportinfo->pmport_mutex);
11309 
11310 		/*
11311 		 * Initialize device to the desired state.
11312 		 * Even if it fails, the device will still
11313 		 * attach but syslog will show the warning.
11314 		 */
11315 		if (sata_initialize_device(sata_hba_inst,
11316 		    pmportinfo->pmport_sata_drive) != SATA_SUCCESS) {
11317 			/* Retry */
11318 			rval = sata_initialize_device(sata_hba_inst,
11319 			    pmportinfo->pmport_sata_drive);
11320 
11321 			if (rval == SATA_RETRY)
11322 				sata_log(sata_hba_inst, CE_WARN,
11323 				    "SATA device at port %d:%d - "
11324 				    "default device features could not be set."
11325 				    " Device may not operate as expected.",
11326 				    cport, pmport);
11327 		}
11328 
11329 		cdip = sata_create_target_node(pdip, sata_hba_inst, saddr);
11330 		if (cdip == NULL) {
11331 			/*
11332 			 * Attaching target node failed.
11333 			 * We retain sata_drive_info structure...
11334 			 */
11335 			return (SATA_SUCCESS);
11336 		}
11337 		mutex_enter(&pmportinfo->pmport_mutex);
11338 		pmportinfo->pmport_sata_drive->satadrv_state |=
11339 		    SATA_STATE_READY;
11340 		mutex_exit(&pmportinfo->pmport_mutex);
11341 
11342 		break;
11343 
11344 	default:
11345 		return (SATA_FAILURE);
11346 	}
11347 
11348 	return (SATA_SUCCESS);
11349 }
11350 
11351 /*
11352  * Clean up target node at specific address.
11353  *
11354  * NOTE: No Mutex should be hold.
11355  */
11356 static int
11357 sata_offline_device(sata_hba_inst_t *sata_hba_inst,
11358     sata_device_t *sata_device, sata_drive_info_t *sdinfo)
11359 {
11360 	uint8_t cport, pmport, qual;
11361 	dev_info_t *tdip;
11362 
11363 	cport = sata_device->satadev_addr.cport;
11364 	pmport = sata_device->satadev_addr.pmport;
11365 	qual = sata_device->satadev_addr.qual;
11366 
11367 	if (qual == SATA_ADDR_DCPORT) {
11368 		SATA_LOG_D((sata_hba_inst, CE_WARN,
11369 		    "sata_hba_ioctl: disconnect device at port %d", cport));
11370 	} else {
11371 		SATA_LOG_D((sata_hba_inst, CE_WARN,
11372 		    "sata_hba_ioctl: disconnect device at port %d:%d",
11373 		    cport, pmport));
11374 	}
11375 
11376 	/* We are addressing attached device, not a port */
11377 	sata_device->satadev_addr.qual =
11378 	    sdinfo->satadrv_addr.qual;
11379 	tdip = sata_get_scsi_target_dip(SATA_DIP(sata_hba_inst),
11380 	    &sata_device->satadev_addr);
11381 	if (tdip != NULL && ndi_devi_offline(tdip,
11382 	    NDI_DEVI_REMOVE) != NDI_SUCCESS) {
11383 		/*
11384 		 * Problem :
11385 		 * The target node remained attached.
11386 		 * This happens when the device file was open
11387 		 * or a node was waiting for resources.
11388 		 * Cannot do anything about it.
11389 		 */
11390 		if (qual == SATA_ADDR_DCPORT) {
11391 			SATA_LOG_D((sata_hba_inst, CE_WARN,
11392 			    "sata_hba_ioctl: disconnect: could "
11393 			    "not unconfigure device before "
11394 			    "disconnecting the SATA port %d",
11395 			    cport));
11396 		} else {
11397 			SATA_LOG_D((sata_hba_inst, CE_WARN,
11398 			    "sata_hba_ioctl: disconnect: could "
11399 			    "not unconfigure device before "
11400 			    "disconnecting the SATA port %d:%d",
11401 			    cport, pmport));
11402 		}
11403 		/*
11404 		 * Set DEVICE REMOVED state in the target
11405 		 * node. It will prevent access to the device
11406 		 * even when a new device is attached, until
11407 		 * the old target node is released, removed and
11408 		 * recreated for a new  device.
11409 		 */
11410 		sata_set_device_removed(tdip);
11411 
11412 		/*
11413 		 * Instruct event daemon to try the target
11414 		 * node cleanup later.
11415 		 */
11416 		sata_set_target_node_cleanup(
11417 		    sata_hba_inst, &sata_device->satadev_addr);
11418 	}
11419 
11420 
11421 	return (SATA_SUCCESS);
11422 }
11423 
11424 
11425 /*
11426  * Create scsi target node for attached device, create node properties and
11427  * attach the node.
11428  * The node could be removed if the device onlining fails.
11429  *
11430  * A dev_info_t pointer is returned if operation is successful, NULL is
11431  * returned otherwise.
11432  */
11433 
11434 static dev_info_t *
11435 sata_create_target_node(dev_info_t *dip, sata_hba_inst_t *sata_hba_inst,
11436     sata_address_t *sata_addr)
11437 {
11438 	dev_info_t *cdip = NULL;
11439 	int rval;
11440 	char *nname = NULL;
11441 	char **compatible = NULL;
11442 	int ncompatible;
11443 	struct scsi_inquiry inq;
11444 	sata_device_t sata_device;
11445 	sata_drive_info_t *sdinfo;
11446 	int target;
11447 	int i;
11448 
11449 	sata_device.satadev_rev = SATA_DEVICE_REV;
11450 	sata_device.satadev_addr = *sata_addr;
11451 
11452 	mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, sata_addr->cport)));
11453 
11454 	sdinfo = sata_get_device_info(sata_hba_inst, &sata_device);
11455 
11456 	target = SATA_TO_SCSI_TARGET(sata_addr->cport,
11457 	    sata_addr->pmport, sata_addr->qual);
11458 
11459 	if (sdinfo == NULL) {
11460 		mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst,
11461 		    sata_addr->cport)));
11462 		SATA_LOG_D((sata_hba_inst, CE_WARN,
11463 		    "sata_create_target_node: no sdinfo for target %x",
11464 		    target));
11465 		return (NULL);
11466 	}
11467 
11468 	/*
11469 	 * create or get scsi inquiry data, expected by
11470 	 * scsi_hba_nodename_compatible_get()
11471 	 * SATA hard disks get Identify Data translated into Inguiry Data.
11472 	 * ATAPI devices respond directly to Inquiry request.
11473 	 */
11474 	if (sdinfo->satadrv_type == SATA_DTYPE_ATADISK) {
11475 		sata_identdev_to_inquiry(sata_hba_inst, sdinfo,
11476 		    (uint8_t *)&inq);
11477 		mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst,
11478 		    sata_addr->cport)));
11479 	} else { /* Assume supported ATAPI device */
11480 		mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst,
11481 		    sata_addr->cport)));
11482 		if (sata_get_atapi_inquiry_data(sata_hba_inst, sata_addr,
11483 		    &inq) == SATA_FAILURE)
11484 			return (NULL);
11485 		/*
11486 		 * Save supported ATAPI transport version
11487 		 */
11488 		sdinfo->satadrv_atapi_trans_ver =
11489 		    SATA_ATAPI_TRANS_VERSION(&inq);
11490 	}
11491 
11492 	/* determine the node name and compatible */
11493 	scsi_hba_nodename_compatible_get(&inq, NULL,
11494 	    inq.inq_dtype, NULL, &nname, &compatible, &ncompatible);
11495 
11496 #ifdef SATA_DEBUG
11497 	if (sata_debug_flags & SATA_DBG_NODES) {
11498 		if (nname == NULL) {
11499 			cmn_err(CE_NOTE, "sata_create_target_node: "
11500 			    "cannot determine nodename for target %d\n",
11501 			    target);
11502 		} else {
11503 			cmn_err(CE_WARN, "sata_create_target_node: "
11504 			    "target %d nodename: %s\n", target, nname);
11505 		}
11506 		if (compatible == NULL) {
11507 			cmn_err(CE_WARN,
11508 			    "sata_create_target_node: no compatible name\n");
11509 		} else {
11510 			for (i = 0; i < ncompatible; i++) {
11511 				cmn_err(CE_WARN, "sata_create_target_node: "
11512 				    "compatible name: %s\n", compatible[i]);
11513 			}
11514 		}
11515 	}
11516 #endif
11517 
11518 	/* if nodename can't be determined, log error and exit */
11519 	if (nname == NULL) {
11520 		SATA_LOG_D((sata_hba_inst, CE_WARN,
11521 		    "sata_create_target_node: cannot determine nodename "
11522 		    "for target %d\n", target));
11523 		scsi_hba_nodename_compatible_free(nname, compatible);
11524 		return (NULL);
11525 	}
11526 	/*
11527 	 * Create scsi target node
11528 	 */
11529 	ndi_devi_alloc_sleep(dip, nname, (pnode_t)DEVI_SID_NODEID, &cdip);
11530 	rval = ndi_prop_update_string(DDI_DEV_T_NONE, cdip,
11531 	    "device-type", "scsi");
11532 
11533 	if (rval != DDI_PROP_SUCCESS) {
11534 		SATA_LOG_D((sata_hba_inst, CE_WARN, "sata_create_target_node: "
11535 		    "updating device_type prop failed %d", rval));
11536 		goto fail;
11537 	}
11538 
11539 	/*
11540 	 * Create target node properties: target & lun
11541 	 */
11542 	rval = ndi_prop_update_int(DDI_DEV_T_NONE, cdip, "target", target);
11543 	if (rval != DDI_PROP_SUCCESS) {
11544 		SATA_LOG_D((sata_hba_inst, CE_WARN, "sata_create_target_node: "
11545 		    "updating target prop failed %d", rval));
11546 		goto fail;
11547 	}
11548 	rval = ndi_prop_update_int(DDI_DEV_T_NONE, cdip, "lun", 0);
11549 	if (rval != DDI_PROP_SUCCESS) {
11550 		SATA_LOG_D((sata_hba_inst, CE_WARN, "sata_create_target_node: "
11551 		    "updating target prop failed %d", rval));
11552 		goto fail;
11553 	}
11554 
11555 	if (sdinfo->satadrv_type & SATA_DTYPE_ATAPI) {
11556 		/*
11557 		 * Add "variant" property
11558 		 */
11559 		rval = ndi_prop_update_string(DDI_DEV_T_NONE, cdip,
11560 		    "variant", "atapi");
11561 		if (rval != DDI_PROP_SUCCESS) {
11562 			SATA_LOG_D((sata_hba_inst, CE_WARN,
11563 			    "sata_create_target_node: variant atapi "
11564 			    "property could not be created: %d", rval));
11565 			goto fail;
11566 		}
11567 	}
11568 	/* decorate the node with compatible */
11569 	if (ndi_prop_update_string_array(DDI_DEV_T_NONE, cdip, "compatible",
11570 	    compatible, ncompatible) != DDI_PROP_SUCCESS) {
11571 		SATA_LOG_D((sata_hba_inst, CE_WARN,
11572 		    "sata_create_target_node: FAIL compatible props cdip 0x%p",
11573 		    (void *)cdip));
11574 		goto fail;
11575 	}
11576 
11577 	if (sdinfo->satadrv_type == SATA_DTYPE_ATADISK) {
11578 		/*
11579 		 * Add "sata-phy" property
11580 		 */
11581 		if (ndi_prop_update_int(DDI_DEV_T_NONE, cdip, "sata-phy",
11582 		    (int)sata_addr->cport) != DDI_PROP_SUCCESS) {
11583 			SATA_LOG_D((sata_hba_inst, CE_WARN,
11584 			    "sata_create_target_node: failed to create "
11585 			    "\"sata-phy\" property: port %d",
11586 			    sata_addr->cport));
11587 		}
11588 	}
11589 
11590 
11591 	/*
11592 	 * Now, try to attach the driver. If probing of the device fails,
11593 	 * the target node may be removed
11594 	 */
11595 	rval = ndi_devi_online(cdip, NDI_ONLINE_ATTACH);
11596 
11597 	scsi_hba_nodename_compatible_free(nname, compatible);
11598 
11599 	if (rval == NDI_SUCCESS)
11600 		return (cdip);
11601 
11602 	/* target node was removed - are we sure? */
11603 	return (NULL);
11604 
11605 fail:
11606 	scsi_hba_nodename_compatible_free(nname, compatible);
11607 	ddi_prop_remove_all(cdip);
11608 	rval = ndi_devi_free(cdip);
11609 	if (rval != NDI_SUCCESS) {
11610 		SATA_LOG_D((sata_hba_inst, CE_WARN, "sata_create_target_node: "
11611 		    "node removal failed %d", rval));
11612 	}
11613 	sata_log(sata_hba_inst, CE_WARN, "sata_create_target_node: "
11614 	    "cannot create target node for SATA device at port %d",
11615 	    sata_addr->cport);
11616 	return (NULL);
11617 }
11618 
11619 /*
11620  * Remove a target node.
11621  */
11622 static void
11623 sata_remove_target_node(sata_hba_inst_t *sata_hba_inst,
11624     sata_address_t *sata_addr)
11625 {
11626 	dev_info_t *tdip;
11627 	uint8_t cport = sata_addr->cport;
11628 	uint8_t pmport = sata_addr->pmport;
11629 	uint8_t qual = sata_addr->qual;
11630 
11631 	/* Note the sata daemon uses the address of the port/pmport */
11632 	ASSERT(qual == SATA_ADDR_CPORT || qual == SATA_ADDR_PMPORT);
11633 
11634 	/* Remove target node */
11635 	tdip = sata_get_target_dip(SATA_DIP(sata_hba_inst), cport, pmport);
11636 	if (tdip != NULL) {
11637 		/*
11638 		 * Target node exists.  Unconfigure device
11639 		 * then remove the target node (one ndi
11640 		 * operation).
11641 		 */
11642 		if (ndi_devi_offline(tdip, NDI_DEVI_REMOVE) != NDI_SUCCESS) {
11643 			/*
11644 			 * PROBLEM - no device, but target node remained. This
11645 			 * happens when the file was open or node was waiting
11646 			 * for resources.
11647 			 */
11648 			SATA_LOG_D((sata_hba_inst, CE_WARN,
11649 			    "sata_remove_target_node: "
11650 			    "Failed to remove target node for "
11651 			    "detached SATA device."));
11652 			/*
11653 			 * Set target node state to DEVI_DEVICE_REMOVED. But
11654 			 * re-check first that the node still exists.
11655 			 */
11656 			tdip = sata_get_target_dip(SATA_DIP(sata_hba_inst),
11657 			    cport, pmport);
11658 			if (tdip != NULL) {
11659 				sata_set_device_removed(tdip);
11660 				/*
11661 				 * Instruct event daemon to retry the cleanup
11662 				 * later.
11663 				 */
11664 				sata_set_target_node_cleanup(sata_hba_inst,
11665 				    sata_addr);
11666 			}
11667 		}
11668 
11669 		if (qual == SATA_ADDR_CPORT)
11670 			sata_log(sata_hba_inst, CE_WARN,
11671 			    "SATA device detached at port %d", cport);
11672 		else
11673 			sata_log(sata_hba_inst, CE_WARN,
11674 			    "SATA device detached at port %d:%d",
11675 			    cport, pmport);
11676 	}
11677 #ifdef SATA_DEBUG
11678 	else {
11679 		if (qual == SATA_ADDR_CPORT)
11680 			sata_log(sata_hba_inst, CE_WARN,
11681 			    "target node not found at port %d", cport);
11682 		else
11683 			sata_log(sata_hba_inst, CE_WARN,
11684 			    "target node not found at port %d:%d",
11685 			    cport, pmport);
11686 	}
11687 #endif
11688 }
11689 
11690 
11691 /*
11692  * Re-probe sata port, check for a device and attach info
11693  * structures when necessary. Identify Device data is fetched, if possible.
11694  * Assumption: sata address is already validated.
11695  * SATA_SUCCESS is returned if port is re-probed sucessfully, regardless of
11696  * the presence of a device and its type.
11697  *
11698  * flag arg specifies that the function should try multiple times to identify
11699  * device type and to initialize it, or it should return immediately on failure.
11700  * SATA_DEV_IDENTIFY_RETRY - retry
11701  * SATA_DEV_IDENTIFY_NORETRY - no retry
11702  *
11703  * SATA_FAILURE is returned if one of the operations failed.
11704  *
11705  * This function cannot be called in interrupt context - it may sleep.
11706  *
11707  * Note: Port multiplier is supported.
11708  */
11709 static int
11710 sata_reprobe_port(sata_hba_inst_t *sata_hba_inst, sata_device_t *sata_device,
11711     int flag)
11712 {
11713 	sata_cport_info_t *cportinfo;
11714 	sata_pmult_info_t *pmultinfo;
11715 	sata_drive_info_t *sdinfo, *osdinfo;
11716 	boolean_t init_device = B_FALSE;
11717 	int prev_device_type = SATA_DTYPE_NONE;
11718 	int prev_device_settings = 0;
11719 	int prev_device_state = 0;
11720 	clock_t start_time = 0;
11721 	int retry = B_FALSE;
11722 	uint8_t cport = sata_device->satadev_addr.cport;
11723 	int rval_probe, rval_init;
11724 
11725 	/*
11726 	 * If target is pmport, sata_reprobe_pmport() will handle it.
11727 	 */
11728 	if (sata_device->satadev_addr.qual == SATA_ADDR_PMPORT ||
11729 	    sata_device->satadev_addr.qual == SATA_ADDR_DPMPORT)
11730 		return (sata_reprobe_pmport(sata_hba_inst, sata_device, flag));
11731 
11732 	/* We only care about host sata cport for now */
11733 	cportinfo = SATA_CPORT_INFO(sata_hba_inst,
11734 	    sata_device->satadev_addr.cport);
11735 
11736 	/*
11737 	 * If a port multiplier was previously attached (we have no idea it
11738 	 * still there or not), sata_reprobe_pmult() will handle it.
11739 	 */
11740 	if (cportinfo->cport_dev_type == SATA_DTYPE_PMULT)
11741 		return (sata_reprobe_pmult(sata_hba_inst, sata_device, flag));
11742 
11743 	/* Store sata_drive_info when a non-pmult device was attached. */
11744 	osdinfo = SATA_CPORTINFO_DRV_INFO(cportinfo);
11745 	if (osdinfo != NULL) {
11746 		/*
11747 		 * We are re-probing port with a previously attached device.
11748 		 * Save previous device type and settings.
11749 		 */
11750 		prev_device_type = cportinfo->cport_dev_type;
11751 		prev_device_settings = osdinfo->satadrv_settings;
11752 		prev_device_state = osdinfo->satadrv_state;
11753 	}
11754 	if (flag == SATA_DEV_IDENTIFY_RETRY) {
11755 		start_time = ddi_get_lbolt();
11756 		retry = B_TRUE;
11757 	}
11758 retry_probe:
11759 
11760 	/* probe port */
11761 	mutex_enter(&cportinfo->cport_mutex);
11762 	cportinfo->cport_state &= ~SATA_PORT_STATE_CLEAR_MASK;
11763 	cportinfo->cport_state |= SATA_STATE_PROBING;
11764 	mutex_exit(&cportinfo->cport_mutex);
11765 
11766 	rval_probe = (*SATA_PROBE_PORT_FUNC(sata_hba_inst))
11767 	    (SATA_DIP(sata_hba_inst), sata_device);
11768 
11769 	mutex_enter(&cportinfo->cport_mutex);
11770 	if (rval_probe != SATA_SUCCESS) {
11771 		cportinfo->cport_state = SATA_PSTATE_FAILED;
11772 		mutex_exit(&cportinfo->cport_mutex);
11773 		SATA_LOG_D((sata_hba_inst, CE_WARN, "sata_reprobe_port: "
11774 		    "SATA port %d probing failed",
11775 		    cportinfo->cport_addr.cport));
11776 		return (SATA_FAILURE);
11777 	}
11778 
11779 	/*
11780 	 * update sata port state and set device type
11781 	 */
11782 	sata_update_port_info(sata_hba_inst, sata_device);
11783 	cportinfo->cport_state &= ~SATA_STATE_PROBING;
11784 
11785 	/*
11786 	 * Sanity check - Port is active? Is the link active?
11787 	 * Is there any device attached?
11788 	 */
11789 	if ((cportinfo->cport_state &
11790 	    (SATA_PSTATE_SHUTDOWN | SATA_PSTATE_FAILED)) ||
11791 	    (cportinfo->cport_scr.sstatus & SATA_PORT_DEVLINK_UP_MASK) !=
11792 	    SATA_PORT_DEVLINK_UP) {
11793 		/*
11794 		 * Port in non-usable state or no link active/no device.
11795 		 * Free info structure if necessary (direct attached drive
11796 		 * only, for now!
11797 		 */
11798 		sdinfo = SATA_CPORTINFO_DRV_INFO(cportinfo);
11799 		SATA_CPORTINFO_DRV_INFO(cportinfo) = NULL;
11800 		/* Add here differentiation for device attached or not */
11801 		cportinfo->cport_dev_type = SATA_DTYPE_NONE;
11802 		mutex_exit(&cportinfo->cport_mutex);
11803 		if (sdinfo != NULL)
11804 			kmem_free(sdinfo, sizeof (sata_drive_info_t));
11805 		return (SATA_SUCCESS);
11806 	}
11807 
11808 	cportinfo->cport_state |= SATA_STATE_READY;
11809 	cportinfo->cport_state |= SATA_STATE_PROBED;
11810 
11811 	cportinfo->cport_dev_type = sata_device->satadev_type;
11812 	sdinfo = SATA_CPORTINFO_DRV_INFO(cportinfo);
11813 
11814 	/*
11815 	 * If we are re-probing the port, there may be
11816 	 * sata_drive_info structure attached
11817 	 */
11818 	if (sata_device->satadev_type == SATA_DTYPE_NONE) {
11819 
11820 		/*
11821 		 * There is no device, so remove device info structure,
11822 		 * if necessary.
11823 		 */
11824 		/* Device change: Drive -> None */
11825 		SATA_CPORTINFO_DRV_INFO(cportinfo) = NULL;
11826 		cportinfo->cport_dev_type = SATA_DTYPE_NONE;
11827 		if (sdinfo != NULL) {
11828 			kmem_free(sdinfo, sizeof (sata_drive_info_t));
11829 			sata_log(sata_hba_inst, CE_WARN,
11830 			    "SATA device detached "
11831 			    "from port %d", cportinfo->cport_addr.cport);
11832 		}
11833 		mutex_exit(&cportinfo->cport_mutex);
11834 		return (SATA_SUCCESS);
11835 
11836 	}
11837 
11838 	if (sata_device->satadev_type != SATA_DTYPE_PMULT) {
11839 
11840 		/* Device (may) change: Drive -> Drive */
11841 		if (sdinfo == NULL) {
11842 			/*
11843 			 * There is some device attached, but there is
11844 			 * no sata_drive_info structure - allocate one
11845 			 */
11846 			mutex_exit(&cportinfo->cport_mutex);
11847 			sdinfo = kmem_zalloc(
11848 			    sizeof (sata_drive_info_t), KM_SLEEP);
11849 			mutex_enter(&cportinfo->cport_mutex);
11850 			/*
11851 			 * Recheck, that the port state did not change when we
11852 			 * released mutex.
11853 			 */
11854 			if (cportinfo->cport_state & SATA_STATE_READY) {
11855 				SATA_CPORTINFO_DRV_INFO(cportinfo) = sdinfo;
11856 				sdinfo->satadrv_addr = cportinfo->cport_addr;
11857 				sdinfo->satadrv_addr.qual = SATA_ADDR_DCPORT;
11858 				sdinfo->satadrv_type = SATA_DTYPE_UNKNOWN;
11859 				sdinfo->satadrv_state = SATA_STATE_UNKNOWN;
11860 			} else {
11861 				/*
11862 				 * Port is not in ready state, we
11863 				 * cannot attach a device.
11864 				 */
11865 				mutex_exit(&cportinfo->cport_mutex);
11866 				kmem_free(sdinfo, sizeof (sata_drive_info_t));
11867 				return (SATA_SUCCESS);
11868 			}
11869 			/*
11870 			 * Since we are adding device, presumably new one,
11871 			 * indicate that it  should be initalized,
11872 			 * as well as some internal framework states).
11873 			 */
11874 			init_device = B_TRUE;
11875 		}
11876 		cportinfo->cport_dev_type = SATA_DTYPE_UNKNOWN;
11877 		sata_device->satadev_addr.qual = sdinfo->satadrv_addr.qual;
11878 	} else {
11879 		/* Device change: Drive -> PMult */
11880 		SATA_CPORTINFO_DRV_INFO(cportinfo) = NULL;
11881 		if (sdinfo != NULL) {
11882 			kmem_free(sdinfo, sizeof (sata_drive_info_t));
11883 			sata_log(sata_hba_inst, CE_WARN,
11884 			    "SATA device detached "
11885 			    "from port %d", cportinfo->cport_addr.cport);
11886 		}
11887 
11888 		sata_log(sata_hba_inst, CE_WARN,
11889 		    "SATA port multiplier detected at port %d",
11890 		    cportinfo->cport_addr.cport);
11891 
11892 		mutex_exit(&cportinfo->cport_mutex);
11893 		if (sata_alloc_pmult(sata_hba_inst, sata_device) !=
11894 		    SATA_SUCCESS)
11895 			return (SATA_FAILURE);
11896 		sata_show_pmult_info(sata_hba_inst, sata_device);
11897 		mutex_enter(&cportinfo->cport_mutex);
11898 
11899 		/*
11900 		 * Mark all the port multiplier port behind the port
11901 		 * multiplier behind with link events, so that the sata daemon
11902 		 * will update their status.
11903 		 */
11904 		pmultinfo = SATA_PMULT_INFO(sata_hba_inst, cport);
11905 		pmultinfo->pmult_event_flags |= SATA_EVNT_DEVICE_RESET;
11906 		mutex_exit(&cportinfo->cport_mutex);
11907 		return (SATA_SUCCESS);
11908 	}
11909 	mutex_exit(&cportinfo->cport_mutex);
11910 
11911 	/*
11912 	 * Figure out what kind of device we are really
11913 	 * dealing with. Failure of identifying device does not fail this
11914 	 * function.
11915 	 */
11916 	rval_probe = sata_probe_device(sata_hba_inst, sata_device);
11917 	rval_init = SATA_FAILURE;
11918 	mutex_enter(&cportinfo->cport_mutex);
11919 	if (rval_probe == SATA_SUCCESS) {
11920 		/*
11921 		 * If we are dealing with the same type of a device as before,
11922 		 * restore its settings flags.
11923 		 */
11924 		if (osdinfo != NULL &&
11925 		    sata_device->satadev_type == prev_device_type)
11926 			sdinfo->satadrv_settings = prev_device_settings;
11927 
11928 		mutex_exit(&cportinfo->cport_mutex);
11929 		rval_init = SATA_SUCCESS;
11930 		/* Set initial device features, if necessary */
11931 		if (init_device == B_TRUE) {
11932 			rval_init = sata_initialize_device(sata_hba_inst,
11933 			    sdinfo);
11934 		}
11935 		if (rval_init == SATA_SUCCESS)
11936 			return (rval_init);
11937 		/* else we will retry if retry was asked for */
11938 
11939 	} else {
11940 		/*
11941 		 * If there was some device info before we probe the device,
11942 		 * restore previous device setting, so we can retry from scratch
11943 		 * later. Providing, of course, that device has not disapear
11944 		 * during probing process.
11945 		 */
11946 		if (sata_device->satadev_type != SATA_DTYPE_NONE) {
11947 			if (osdinfo != NULL) {
11948 				cportinfo->cport_dev_type = prev_device_type;
11949 				sdinfo->satadrv_type = prev_device_type;
11950 				sdinfo->satadrv_state = prev_device_state;
11951 			}
11952 		} else {
11953 			/* device is gone */
11954 			kmem_free(sdinfo, sizeof (sata_drive_info_t));
11955 			cportinfo->cport_dev_type = SATA_DTYPE_NONE;
11956 			SATA_CPORTINFO_DRV_INFO(cportinfo) = NULL;
11957 			mutex_exit(&cportinfo->cport_mutex);
11958 			return (SATA_SUCCESS);
11959 		}
11960 		mutex_exit(&cportinfo->cport_mutex);
11961 	}
11962 
11963 	if (retry) {
11964 		clock_t cur_time = ddi_get_lbolt();
11965 		/*
11966 		 * A device was not successfully identified or initialized.
11967 		 * Track retry time for device identification.
11968 		 */
11969 		if ((cur_time - start_time) <
11970 		    drv_usectohz(SATA_DEV_REPROBE_TIMEOUT)) {
11971 			/* sleep for a while */
11972 			delay(drv_usectohz(SATA_DEV_RETRY_DLY));
11973 			goto retry_probe;
11974 		}
11975 		/* else no more retries */
11976 		mutex_enter(&cportinfo->cport_mutex);
11977 		if (SATA_CPORTINFO_DRV_INFO(cportinfo) != NULL) {
11978 			if (rval_init == SATA_RETRY) {
11979 				/*
11980 				 * Setting drive features have failed, but
11981 				 * because the drive is still accessible,
11982 				 * keep it and emit a warning message.
11983 				 */
11984 				sata_log(sata_hba_inst, CE_WARN,
11985 				    "SATA device at port %d - desired "
11986 				    "drive features could not be set. "
11987 				    "Device may not operate as expected.",
11988 				    cportinfo->cport_addr.cport);
11989 			} else {
11990 				SATA_CPORTINFO_DRV_INFO(cportinfo)->
11991 				    satadrv_state = SATA_DSTATE_FAILED;
11992 			}
11993 		}
11994 		mutex_exit(&cportinfo->cport_mutex);
11995 	}
11996 	return (SATA_SUCCESS);
11997 }
11998 
11999 /*
12000  * Reprobe a controller port that connected to a port multiplier.
12001  *
12002  * NOTE: No Mutex should be hold.
12003  */
12004 static int
12005 sata_reprobe_pmult(sata_hba_inst_t *sata_hba_inst, sata_device_t *sata_device,
12006     int flag)
12007 {
12008 	_NOTE(ARGUNUSED(flag))
12009 	sata_cport_info_t *cportinfo;
12010 	sata_pmult_info_t *pmultinfo;
12011 	uint8_t cport = sata_device->satadev_addr.cport;
12012 	int rval_probe;
12013 
12014 	cportinfo = SATA_CPORT_INFO(sata_hba_inst, cport);
12015 	pmultinfo = SATA_PMULT_INFO(sata_hba_inst, cport);
12016 
12017 	/* probe port */
12018 	mutex_enter(&cportinfo->cport_mutex);
12019 	cportinfo->cport_state &= ~SATA_PORT_STATE_CLEAR_MASK;
12020 	cportinfo->cport_state |= SATA_STATE_PROBING;
12021 	mutex_exit(&cportinfo->cport_mutex);
12022 
12023 	rval_probe = (*SATA_PROBE_PORT_FUNC(sata_hba_inst))
12024 	    (SATA_DIP(sata_hba_inst), sata_device);
12025 
12026 	mutex_enter(&cportinfo->cport_mutex);
12027 	if (rval_probe != SATA_SUCCESS) {
12028 		cportinfo->cport_state = SATA_PSTATE_FAILED;
12029 		SATA_LOG_D((sata_hba_inst, CE_WARN, "sata_reprobe_pmult: "
12030 		    "SATA port %d probing failed", cport));
12031 		sata_log(sata_hba_inst, CE_WARN,
12032 		    "SATA port multiplier detached at port %d", cport);
12033 		mutex_exit(&cportinfo->cport_mutex);
12034 		sata_free_pmult(sata_hba_inst, sata_device);
12035 		return (SATA_FAILURE);
12036 	}
12037 
12038 	/*
12039 	 * update sata port state and set device type
12040 	 */
12041 	sata_update_port_info(sata_hba_inst, sata_device);
12042 	cportinfo->cport_state &= ~SATA_STATE_PROBING;
12043 	cportinfo->cport_state |= SATA_STATE_PROBED;
12044 
12045 	/*
12046 	 * Sanity check - Port is active? Is the link active?
12047 	 * Is there any device attached?
12048 	 */
12049 	if ((cportinfo->cport_state &
12050 	    (SATA_PSTATE_SHUTDOWN | SATA_PSTATE_FAILED)) ||
12051 	    (cportinfo->cport_scr.sstatus & SATA_PORT_DEVLINK_UP_MASK) !=
12052 	    SATA_PORT_DEVLINK_UP ||
12053 	    (sata_device->satadev_type == SATA_DTYPE_NONE)) {
12054 		cportinfo->cport_dev_type = SATA_DTYPE_NONE;
12055 		mutex_exit(&cportinfo->cport_mutex);
12056 		sata_free_pmult(sata_hba_inst, sata_device);
12057 		sata_log(sata_hba_inst, CE_WARN,
12058 		    "SATA port multiplier detached at port %d", cport);
12059 		return (SATA_SUCCESS);
12060 	}
12061 
12062 	/*
12063 	 * Device changed: PMult -> Non-PMult
12064 	 *
12065 	 * This situation is uncommon, most possibly being caused by errors
12066 	 * after which the port multiplier is not correct initialized and
12067 	 * recognized. In that case the new device will be marked as unknown
12068 	 * and will not be automatically probed in this routine. Instead
12069 	 * system administrator could manually restart it via cfgadm(8).
12070 	 */
12071 	if (sata_device->satadev_type != SATA_DTYPE_PMULT) {
12072 		cportinfo->cport_dev_type = SATA_DTYPE_UNKNOWN;
12073 		mutex_exit(&cportinfo->cport_mutex);
12074 		sata_free_pmult(sata_hba_inst, sata_device);
12075 		sata_log(sata_hba_inst, CE_WARN,
12076 		    "SATA port multiplier detached at port %d", cport);
12077 		return (SATA_FAILURE);
12078 	}
12079 
12080 	/*
12081 	 * Now we know it is a port multiplier. However, if this is not the
12082 	 * previously attached port multiplier - they may have different
12083 	 * pmport numbers - we need to re-allocate data structures for every
12084 	 * pmport and drive.
12085 	 *
12086 	 * Port multipliers of the same model have identical values in these
12087 	 * registers, so it is still necessary to update the information of
12088 	 * all drives attached to the previous port multiplier afterwards.
12089 	 */
12090 	/* Device changed: PMult -> another PMult */
12091 	mutex_exit(&cportinfo->cport_mutex);
12092 	sata_free_pmult(sata_hba_inst, sata_device);
12093 	if (sata_alloc_pmult(sata_hba_inst, sata_device) != SATA_SUCCESS)
12094 		return (SATA_FAILURE);
12095 	mutex_enter(&cportinfo->cport_mutex);
12096 
12097 	SATADBG1(SATA_DBG_PMULT, sata_hba_inst,
12098 	    "SATA port multiplier [changed] at port %d", cport);
12099 	sata_log(sata_hba_inst, CE_WARN,
12100 	    "SATA port multiplier detected at port %d", cport);
12101 
12102 	/*
12103 	 * Mark all the port multiplier port behind the port
12104 	 * multiplier behind with link events, so that the sata daemon
12105 	 * will update their status.
12106 	 */
12107 	pmultinfo->pmult_event_flags |= SATA_EVNT_DEVICE_RESET;
12108 	mutex_exit(&cportinfo->cport_mutex);
12109 
12110 	return (SATA_SUCCESS);
12111 }
12112 
12113 /*
12114  * Re-probe a port multiplier port, check for a device and attach info
12115  * structures when necessary. Identify Device data is fetched, if possible.
12116  * Assumption: sata address is already validated as port multiplier port.
12117  * SATA_SUCCESS is returned if port is re-probed sucessfully, regardless of
12118  * the presence of a device and its type.
12119  *
12120  * flag arg specifies that the function should try multiple times to identify
12121  * device type and to initialize it, or it should return immediately on failure.
12122  * SATA_DEV_IDENTIFY_RETRY - retry
12123  * SATA_DEV_IDENTIFY_NORETRY - no retry
12124  *
12125  * SATA_FAILURE is returned if one of the operations failed.
12126  *
12127  * This function cannot be called in interrupt context - it may sleep.
12128  *
12129  * NOTE: Should be only called by sata_probe_port() in case target port is a
12130  *       port multiplier port.
12131  * NOTE: No Mutex should be hold.
12132  */
12133 static int
12134 sata_reprobe_pmport(sata_hba_inst_t *sata_hba_inst, sata_device_t *sata_device,
12135     int flag)
12136 {
12137 	sata_cport_info_t *cportinfo = NULL;
12138 	sata_pmport_info_t *pmportinfo = NULL;
12139 	sata_drive_info_t *sdinfo, *osdinfo;
12140 	sata_device_t sdevice;
12141 	boolean_t init_device = B_FALSE;
12142 	int prev_device_type = SATA_DTYPE_NONE;
12143 	int prev_device_settings = 0;
12144 	int prev_device_state = 0;
12145 	clock_t start_time;
12146 	uint8_t cport = sata_device->satadev_addr.cport;
12147 	uint8_t pmport = sata_device->satadev_addr.pmport;
12148 	int rval;
12149 
12150 	cportinfo = SATA_CPORT_INFO(sata_hba_inst, cport);
12151 	pmportinfo = SATA_PMPORT_INFO(sata_hba_inst, cport, pmport);
12152 	osdinfo = SATA_PMPORTINFO_DRV_INFO(pmportinfo);
12153 
12154 	if (osdinfo != NULL) {
12155 		/*
12156 		 * We are re-probing port with a previously attached device.
12157 		 * Save previous device type and settings.
12158 		 */
12159 		prev_device_type = pmportinfo->pmport_dev_type;
12160 		prev_device_settings = osdinfo->satadrv_settings;
12161 		prev_device_state = osdinfo->satadrv_state;
12162 	}
12163 
12164 	start_time = ddi_get_lbolt();
12165 
12166 	/* check parent status */
12167 	mutex_enter(&cportinfo->cport_mutex);
12168 	if ((cportinfo->cport_state &
12169 	    (SATA_PSTATE_SHUTDOWN | SATA_PSTATE_FAILED)) ||
12170 	    (cportinfo->cport_scr.sstatus & SATA_PORT_DEVLINK_UP_MASK) !=
12171 	    SATA_PORT_DEVLINK_UP) {
12172 		mutex_exit(&cportinfo->cport_mutex);
12173 		return (SATA_FAILURE);
12174 	}
12175 	mutex_exit(&cportinfo->cport_mutex);
12176 
12177 retry_probe_pmport:
12178 
12179 	/* probe port */
12180 	mutex_enter(&pmportinfo->pmport_mutex);
12181 	pmportinfo->pmport_state &= ~SATA_PORT_STATE_CLEAR_MASK;
12182 	pmportinfo->pmport_state |= SATA_STATE_PROBING;
12183 	mutex_exit(&pmportinfo->pmport_mutex);
12184 
12185 	rval = (*SATA_PROBE_PORT_FUNC(sata_hba_inst))
12186 	    (SATA_DIP(sata_hba_inst), sata_device);
12187 
12188 	/* might need retry because we cannot touch registers. */
12189 	if (rval == SATA_FAILURE) {
12190 		mutex_enter(&pmportinfo->pmport_mutex);
12191 		pmportinfo->pmport_state = SATA_PSTATE_FAILED;
12192 		mutex_exit(&pmportinfo->pmport_mutex);
12193 		SATA_LOG_D((sata_hba_inst, CE_WARN, "sata_reprobe_pmport: "
12194 		    "SATA port %d:%d probing failed",
12195 		    cport, pmport));
12196 		return (SATA_FAILURE);
12197 	} else if (rval == SATA_RETRY) {
12198 		SATA_LOG_D((sata_hba_inst, CE_WARN, "sata_reprobe_pmport: "
12199 		    "SATA port %d:%d probing failed, retrying...",
12200 		    cport, pmport));
12201 		clock_t cur_time = ddi_get_lbolt();
12202 		/*
12203 		 * A device was not successfully identified or initialized.
12204 		 * Track retry time for device identification.
12205 		 */
12206 		if ((cur_time - start_time) <
12207 		    drv_usectohz(SATA_DEV_REPROBE_TIMEOUT)) {
12208 			/* sleep for a while */
12209 			delay(drv_usectohz(SATA_DEV_RETRY_DLY));
12210 			goto retry_probe_pmport;
12211 		} else {
12212 			mutex_enter(&pmportinfo->pmport_mutex);
12213 			if (SATA_PMPORTINFO_DRV_INFO(pmportinfo) != NULL)
12214 				SATA_PMPORTINFO_DRV_INFO(pmportinfo)->
12215 				    satadrv_state = SATA_DSTATE_FAILED;
12216 			mutex_exit(&pmportinfo->pmport_mutex);
12217 			return (SATA_SUCCESS);
12218 		}
12219 	}
12220 
12221 	/*
12222 	 * Sanity check - Controller port is active? Is the link active?
12223 	 * Is it still a port multiplier?
12224 	 */
12225 	if ((cportinfo->cport_state &
12226 	    (SATA_PSTATE_SHUTDOWN | SATA_PSTATE_FAILED)) ||
12227 	    (cportinfo->cport_scr.sstatus & SATA_PORT_DEVLINK_UP_MASK) !=
12228 	    SATA_PORT_DEVLINK_UP ||
12229 	    (cportinfo->cport_dev_type != SATA_DTYPE_PMULT)) {
12230 		/*
12231 		 * Port in non-usable state or no link active/no
12232 		 * device. Free info structure.
12233 		 */
12234 		cportinfo->cport_dev_type = SATA_DTYPE_UNKNOWN;
12235 
12236 		sdevice.satadev_addr.cport = cport;
12237 		sdevice.satadev_addr.pmport = pmport;
12238 		sdevice.satadev_addr.qual = SATA_ADDR_PMULT;
12239 		mutex_exit(&cportinfo->cport_mutex);
12240 
12241 		sata_free_pmult(sata_hba_inst, &sdevice);
12242 		return (SATA_FAILURE);
12243 	}
12244 
12245 	/* SATA_SUCCESS NOW */
12246 	/*
12247 	 * update sata port state and set device type
12248 	 */
12249 	mutex_enter(&pmportinfo->pmport_mutex);
12250 	sata_update_pmport_info(sata_hba_inst, sata_device);
12251 	pmportinfo->pmport_state &= ~SATA_STATE_PROBING;
12252 
12253 	/*
12254 	 * Sanity check - Port is active? Is the link active?
12255 	 * Is there any device attached?
12256 	 */
12257 	if ((pmportinfo->pmport_state &
12258 	    (SATA_PSTATE_SHUTDOWN | SATA_PSTATE_FAILED)) ||
12259 	    (pmportinfo->pmport_scr.sstatus & SATA_PORT_DEVLINK_UP_MASK) !=
12260 	    SATA_PORT_DEVLINK_UP) {
12261 		/*
12262 		 * Port in non-usable state or no link active/no device.
12263 		 * Free info structure if necessary (direct attached drive
12264 		 * only, for now!
12265 		 */
12266 		sdinfo = SATA_PMPORTINFO_DRV_INFO(pmportinfo);
12267 		SATA_PMPORTINFO_DRV_INFO(pmportinfo) = NULL;
12268 		/* Add here differentiation for device attached or not */
12269 		pmportinfo->pmport_dev_type = SATA_DTYPE_NONE;
12270 		mutex_exit(&pmportinfo->pmport_mutex);
12271 		if (sdinfo != NULL)
12272 			kmem_free(sdinfo, sizeof (sata_drive_info_t));
12273 		return (SATA_SUCCESS);
12274 	}
12275 
12276 	pmportinfo->pmport_state |= SATA_STATE_READY;
12277 	pmportinfo->pmport_dev_type = sata_device->satadev_type;
12278 	sdinfo = SATA_PMPORTINFO_DRV_INFO(pmportinfo);
12279 
12280 	/*
12281 	 * If we are re-probing the port, there may be
12282 	 * sata_drive_info structure attached
12283 	 * (or sata_pm_info, if PMult is supported).
12284 	 */
12285 	if (sata_device->satadev_type == SATA_DTYPE_NONE) {
12286 		/*
12287 		 * There is no device, so remove device info structure,
12288 		 * if necessary.
12289 		 */
12290 		SATA_PMPORTINFO_DRV_INFO(pmportinfo) = NULL;
12291 		pmportinfo->pmport_dev_type = SATA_DTYPE_NONE;
12292 		if (sdinfo != NULL) {
12293 			kmem_free(sdinfo, sizeof (sata_drive_info_t));
12294 			sata_log(sata_hba_inst, CE_WARN,
12295 			    "SATA device detached from port %d:%d",
12296 			    cport, pmport);
12297 		}
12298 		mutex_exit(&pmportinfo->pmport_mutex);
12299 		return (SATA_SUCCESS);
12300 	}
12301 
12302 	/* this should not be a pmult */
12303 	ASSERT(sata_device->satadev_type != SATA_DTYPE_PMULT);
12304 	if (sdinfo == NULL) {
12305 		/*
12306 		 * There is some device attached, but there is
12307 		 * no sata_drive_info structure - allocate one
12308 		 */
12309 		mutex_exit(&pmportinfo->pmport_mutex);
12310 		sdinfo = kmem_zalloc(sizeof (sata_drive_info_t),
12311 		    KM_SLEEP);
12312 		mutex_enter(&pmportinfo->pmport_mutex);
12313 		/*
12314 		 * Recheck, that the port state did not change when we
12315 		 * released mutex.
12316 		 */
12317 		if (pmportinfo->pmport_state & SATA_STATE_READY) {
12318 			SATA_PMPORTINFO_DRV_INFO(pmportinfo) = sdinfo;
12319 			sdinfo->satadrv_addr = pmportinfo->pmport_addr;
12320 			sdinfo->satadrv_addr.qual = SATA_ADDR_DPMPORT;
12321 			sdinfo->satadrv_type = SATA_DTYPE_UNKNOWN;
12322 			sdinfo->satadrv_state = SATA_STATE_UNKNOWN;
12323 		} else {
12324 			/*
12325 			 * Port is not in ready state, we
12326 			 * cannot attach a device.
12327 			 */
12328 			mutex_exit(&pmportinfo->pmport_mutex);
12329 			kmem_free(sdinfo, sizeof (sata_drive_info_t));
12330 			return (SATA_SUCCESS);
12331 		}
12332 		/*
12333 		 * Since we are adding device, presumably new one,
12334 		 * indicate that it  should be initalized,
12335 		 * as well as some internal framework states).
12336 		 */
12337 		init_device = B_TRUE;
12338 	}
12339 
12340 	pmportinfo->pmport_dev_type = SATA_DTYPE_UNKNOWN;
12341 	sata_device->satadev_addr.qual = sdinfo->satadrv_addr.qual;
12342 
12343 	mutex_exit(&pmportinfo->pmport_mutex);
12344 	/*
12345 	 * Figure out what kind of device we are really
12346 	 * dealing with.
12347 	 */
12348 	rval = sata_probe_device(sata_hba_inst, sata_device);
12349 
12350 	mutex_enter(&pmportinfo->pmport_mutex);
12351 	if (rval == SATA_SUCCESS) {
12352 		/*
12353 		 * If we are dealing with the same type of a device as before,
12354 		 * restore its settings flags.
12355 		 */
12356 		if (osdinfo != NULL &&
12357 		    sata_device->satadev_type == prev_device_type)
12358 			sdinfo->satadrv_settings = prev_device_settings;
12359 
12360 		mutex_exit(&pmportinfo->pmport_mutex);
12361 		/* Set initial device features, if necessary */
12362 		if (init_device == B_TRUE) {
12363 			rval = sata_initialize_device(sata_hba_inst, sdinfo);
12364 		}
12365 		if (rval == SATA_SUCCESS)
12366 			return (rval);
12367 	} else {
12368 		/*
12369 		 * If there was some device info before we probe the device,
12370 		 * restore previous device setting, so we can retry from scratch
12371 		 * later. Providing, of course, that device has not disappeared
12372 		 * during probing process.
12373 		 */
12374 		if (sata_device->satadev_type != SATA_DTYPE_NONE) {
12375 			if (osdinfo != NULL) {
12376 				pmportinfo->pmport_dev_type = prev_device_type;
12377 				sdinfo->satadrv_type = prev_device_type;
12378 				sdinfo->satadrv_state = prev_device_state;
12379 			}
12380 		} else {
12381 			/* device is gone */
12382 			kmem_free(sdinfo, sizeof (sata_drive_info_t));
12383 			pmportinfo->pmport_dev_type = SATA_DTYPE_NONE;
12384 			SATA_PMPORTINFO_DRV_INFO(pmportinfo) = NULL;
12385 			mutex_exit(&pmportinfo->pmport_mutex);
12386 			return (SATA_SUCCESS);
12387 		}
12388 		mutex_exit(&pmportinfo->pmport_mutex);
12389 	}
12390 
12391 	if (flag == SATA_DEV_IDENTIFY_RETRY) {
12392 		clock_t cur_time = ddi_get_lbolt();
12393 		/*
12394 		 * A device was not successfully identified or initialized.
12395 		 * Track retry time for device identification.
12396 		 */
12397 		if ((cur_time - start_time) <
12398 		    drv_usectohz(SATA_DEV_REPROBE_TIMEOUT)) {
12399 			/* sleep for a while */
12400 			delay(drv_usectohz(SATA_DEV_RETRY_DLY));
12401 			goto retry_probe_pmport;
12402 		} else {
12403 			mutex_enter(&pmportinfo->pmport_mutex);
12404 			if (SATA_PMPORTINFO_DRV_INFO(pmportinfo) != NULL)
12405 				SATA_PMPORTINFO_DRV_INFO(pmportinfo)->
12406 				    satadrv_state = SATA_DSTATE_FAILED;
12407 			mutex_exit(&pmportinfo->pmport_mutex);
12408 		}
12409 	}
12410 	return (SATA_SUCCESS);
12411 }
12412 
12413 /*
12414  * Allocated related structure for a port multiplier and its device ports
12415  *
12416  * Port multiplier should be ready and probed, and related information like
12417  * the number of the device ports should be store in sata_device_t.
12418  *
12419  * NOTE: No Mutex should be hold.
12420  */
12421 static int
12422 sata_alloc_pmult(sata_hba_inst_t *sata_hba_inst, sata_device_t *sata_device)
12423 {
12424 	dev_info_t *dip = SATA_DIP(sata_hba_inst);
12425 	sata_cport_info_t *cportinfo = NULL;
12426 	sata_pmult_info_t *pmultinfo = NULL;
12427 	sata_pmport_info_t *pmportinfo = NULL;
12428 	sata_device_t sd;
12429 	dev_t minor_number;
12430 	char name[16];
12431 	uint8_t cport = sata_device->satadev_addr.cport;
12432 	int rval;
12433 	int npmport;
12434 
12435 	cportinfo = SATA_CPORT_INFO(sata_hba_inst, cport);
12436 
12437 	/* This function might be called while a port-mult is hot-plugged. */
12438 	mutex_enter(&cportinfo->cport_mutex);
12439 
12440 	/* dev_type's not updated when get called from sata_reprobe_port() */
12441 	if (SATA_CPORTINFO_PMULT_INFO(cportinfo) == NULL) {
12442 		/* Create a pmult_info structure */
12443 		SATA_CPORTINFO_PMULT_INFO(cportinfo) =
12444 		    kmem_zalloc(sizeof (sata_pmult_info_t), KM_SLEEP);
12445 	}
12446 	pmultinfo = SATA_CPORTINFO_PMULT_INFO(cportinfo);
12447 
12448 	pmultinfo->pmult_addr = sata_device->satadev_addr;
12449 	pmultinfo->pmult_addr.qual = SATA_ADDR_PMULT;
12450 	pmultinfo->pmult_state = SATA_STATE_PROBING;
12451 
12452 	/*
12453 	 * Probe the port multiplier with qualifier SATA_ADDR_PMULT_SPEC,
12454 	 * The HBA driver should initialize and register the port multiplier,
12455 	 * sata_register_pmult() will fill following fields,
12456 	 *   + sata_pmult_info.pmult_gscr
12457 	 *   + sata_pmult_info.pmult_num_dev_ports
12458 	 */
12459 	sd.satadev_addr = sata_device->satadev_addr;
12460 	sd.satadev_addr.qual = SATA_ADDR_PMULT_SPEC;
12461 	mutex_exit(&cportinfo->cport_mutex);
12462 	rval = (*SATA_PROBE_PORT_FUNC(sata_hba_inst))
12463 	    (SATA_DIP(sata_hba_inst), &sd);
12464 	mutex_enter(&cportinfo->cport_mutex);
12465 
12466 	if (rval != SATA_SUCCESS ||
12467 	    (sd.satadev_type != SATA_DTYPE_PMULT) ||
12468 	    !(sd.satadev_state & SATA_DSTATE_PMULT_INIT)) {
12469 		SATA_CPORTINFO_PMULT_INFO(cportinfo) = NULL;
12470 		kmem_free(pmultinfo, sizeof (sata_pmult_info_t));
12471 		cportinfo->cport_state = SATA_PSTATE_FAILED;
12472 		cportinfo->cport_dev_type = SATA_DTYPE_UNKNOWN;
12473 		mutex_exit(&cportinfo->cport_mutex);
12474 		SATADBG1(SATA_DBG_PMULT, sata_hba_inst,
12475 		    "sata_alloc_pmult: failed to initialize pmult "
12476 		    "at port %d.", cport)
12477 		return (SATA_FAILURE);
12478 	}
12479 
12480 	/* Initialize pmport_info structure */
12481 	for (npmport = 0; npmport < pmultinfo->pmult_num_dev_ports;
12482 	    npmport++) {
12483 
12484 		/* if everything is allocated, skip */
12485 		if (SATA_PMPORT_INFO(sata_hba_inst, cport, npmport) != NULL)
12486 			continue;
12487 
12488 		pmportinfo = kmem_zalloc(sizeof (sata_pmport_info_t), KM_SLEEP);
12489 		mutex_init(&pmportinfo->pmport_mutex, NULL, MUTEX_DRIVER, NULL);
12490 		mutex_exit(&cportinfo->cport_mutex);
12491 
12492 		mutex_enter(&pmportinfo->pmport_mutex);
12493 		pmportinfo->pmport_addr.cport = cport;
12494 		pmportinfo->pmport_addr.pmport = (uint8_t)npmport;
12495 		pmportinfo->pmport_addr.qual = SATA_ADDR_PMPORT;
12496 		pmportinfo->pmport_state &= ~SATA_PORT_STATE_CLEAR_MASK;
12497 		mutex_exit(&pmportinfo->pmport_mutex);
12498 
12499 		mutex_enter(&cportinfo->cport_mutex);
12500 		SATA_PMPORT_INFO(sata_hba_inst, cport, npmport) = pmportinfo;
12501 
12502 		/* Create an attachment point */
12503 		minor_number = SATA_MAKE_AP_MINOR(ddi_get_instance(dip),
12504 		    cport, (uint8_t)npmport, SATA_ADDR_PMPORT);
12505 		(void) sprintf(name, "%d.%d", cport, npmport);
12506 
12507 		if (ddi_create_minor_node(dip, name, S_IFCHR, minor_number,
12508 		    DDI_NT_SATA_ATTACHMENT_POINT, 0) != DDI_SUCCESS) {
12509 			sata_log(sata_hba_inst, CE_WARN, "sata_hba_attach: "
12510 			    "cannot create SATA attachment point for "
12511 			    "port %d:%d", cport, npmport);
12512 		}
12513 	}
12514 
12515 	pmultinfo->pmult_state &= ~SATA_STATE_PROBING;
12516 	pmultinfo->pmult_state |= (SATA_STATE_PROBED|SATA_STATE_READY);
12517 	cportinfo->cport_dev_type = SATA_DTYPE_PMULT;
12518 
12519 	mutex_exit(&cportinfo->cport_mutex);
12520 	return (SATA_SUCCESS);
12521 }
12522 
12523 /*
12524  * Free data structures when a port multiplier is removed.
12525  *
12526  * NOTE: No Mutex should be hold.
12527  */
12528 static void
12529 sata_free_pmult(sata_hba_inst_t *sata_hba_inst, sata_device_t *sata_device)
12530 {
12531 	sata_cport_info_t *cportinfo;
12532 	sata_pmult_info_t *pmultinfo;
12533 	sata_pmport_info_t *pmportinfo;
12534 	sata_device_t pmport_device;
12535 	sata_drive_info_t *sdinfo;
12536 	dev_info_t *tdip;
12537 	char name[16];
12538 	uint8_t cport = sata_device->satadev_addr.cport;
12539 	int npmport;
12540 
12541 	cportinfo = SATA_CPORT_INFO(sata_hba_inst, cport);
12542 
12543 	/* This function might be called while port-mult is hot plugged. */
12544 	mutex_enter(&cportinfo->cport_mutex);
12545 
12546 	cportinfo->cport_dev_type = SATA_DTYPE_NONE;
12547 	pmultinfo = SATA_CPORTINFO_PMULT_INFO(cportinfo);
12548 	ASSERT(pmultinfo != NULL);
12549 
12550 	/* Free pmport_info structure */
12551 	for (npmport = 0; npmport < pmultinfo->pmult_num_dev_ports;
12552 	    npmport++) {
12553 		pmportinfo = SATA_PMPORT_INFO(sata_hba_inst, cport, npmport);
12554 		if (pmportinfo == NULL)
12555 			continue;
12556 		mutex_exit(&cportinfo->cport_mutex);
12557 
12558 		mutex_enter(&pmportinfo->pmport_mutex);
12559 		sdinfo = pmportinfo->pmport_sata_drive;
12560 		SATA_PMPORTINFO_DRV_INFO(pmportinfo) = NULL;
12561 		mutex_exit(&pmportinfo->pmport_mutex);
12562 
12563 		/* Remove attachment point. */
12564 		name[0] = '\0';
12565 		(void) sprintf(name, "%d.%d", cport, npmport);
12566 		ddi_remove_minor_node(SATA_DIP(sata_hba_inst), name);
12567 		sata_log(sata_hba_inst, CE_NOTE,
12568 		    "Remove attachment point of port %d:%d",
12569 		    cport, npmport);
12570 
12571 		/*
12572 		 * Rumove target node
12573 		 */
12574 		bzero(&pmport_device, sizeof (sata_device_t));
12575 		pmport_device.satadev_rev = SATA_DEVICE_REV;
12576 		pmport_device.satadev_addr.cport = cport;
12577 		pmport_device.satadev_addr.pmport = (uint8_t)npmport;
12578 		pmport_device.satadev_addr.qual = SATA_ADDR_DPMPORT;
12579 
12580 		tdip = sata_get_scsi_target_dip(SATA_DIP(sata_hba_inst),
12581 		    &(pmport_device.satadev_addr));
12582 		if (tdip != NULL && ndi_devi_offline(tdip,
12583 		    NDI_DEVI_REMOVE) != NDI_SUCCESS) {
12584 			/*
12585 			 * Problem :
12586 			 * The target node remained attached.
12587 			 * This happens when the device file was open
12588 			 * or a node was waiting for resources.
12589 			 * Cannot do anything about it.
12590 			 */
12591 			SATA_LOG_D((sata_hba_inst, CE_WARN,
12592 			    "sata_free_pmult: could not unconfigure device "
12593 			    "before disconnecting the SATA port %d:%d",
12594 			    cport, npmport));
12595 
12596 			/*
12597 			 * Set DEVICE REMOVED state in the target
12598 			 * node. It will prevent access to the device
12599 			 * even when a new device is attached, until
12600 			 * the old target node is released, removed and
12601 			 * recreated for a new  device.
12602 			 */
12603 			sata_set_device_removed(tdip);
12604 
12605 			/*
12606 			 * Instruct event daemon to try the target
12607 			 * node cleanup later.
12608 			 */
12609 			sata_set_target_node_cleanup(
12610 			    sata_hba_inst, &(pmport_device.satadev_addr));
12611 
12612 		}
12613 		mutex_enter(&cportinfo->cport_mutex);
12614 
12615 		/*
12616 		 * Add here differentiation for device attached or not
12617 		 */
12618 		if (sdinfo != NULL)  {
12619 			sata_log(sata_hba_inst, CE_WARN,
12620 			    "SATA device detached from port %d:%d",
12621 			    cport, npmport);
12622 			kmem_free(sdinfo, sizeof (sata_drive_info_t));
12623 		}
12624 
12625 		mutex_destroy(&pmportinfo->pmport_mutex);
12626 		kmem_free(pmportinfo, sizeof (sata_pmport_info_t));
12627 	}
12628 
12629 	kmem_free(pmultinfo, sizeof (sata_pmult_info_t));
12630 
12631 	cportinfo->cport_devp.cport_sata_pmult = NULL;
12632 
12633 	sata_log(sata_hba_inst, CE_WARN,
12634 	    "SATA port multiplier detached at port %d", cport);
12635 
12636 	mutex_exit(&cportinfo->cport_mutex);
12637 }
12638 
12639 /*
12640  * Initialize device
12641  * Specified device is initialized to a default state.
12642  *
12643  * Returns SATA_SUCCESS if all device features are set successfully,
12644  * SATA_RETRY if device is accessible but device features were not set
12645  * successfully, and SATA_FAILURE otherwise.
12646  */
12647 static int
12648 sata_initialize_device(sata_hba_inst_t *sata_hba_inst,
12649     sata_drive_info_t *sdinfo)
12650 {
12651 	int rval;
12652 
12653 	sata_save_drive_settings(sdinfo);
12654 
12655 	sdinfo->satadrv_settings |= SATA_DEV_READ_AHEAD;
12656 
12657 	sata_init_write_cache_mode(sdinfo);
12658 
12659 	rval = sata_set_drive_features(sata_hba_inst, sdinfo, 0);
12660 
12661 	/* Determine current data transfer mode */
12662 	if ((sdinfo->satadrv_id.ai_cap & SATA_DMA_SUPPORT) == 0) {
12663 		sdinfo->satadrv_settings &= ~SATA_DEV_DMA;
12664 	} else if ((sdinfo->satadrv_id.ai_validinfo &
12665 	    SATA_VALIDINFO_88) != 0 &&
12666 	    (sdinfo->satadrv_id.ai_ultradma & SATA_UDMA_SEL_MASK) != 0) {
12667 		sdinfo->satadrv_settings |= SATA_DEV_DMA;
12668 	} else if ((sdinfo->satadrv_id.ai_dworddma &
12669 	    SATA_MDMA_SEL_MASK) != 0) {
12670 		sdinfo->satadrv_settings |= SATA_DEV_DMA;
12671 	} else
12672 		/* DMA supported, not no DMA transfer mode is selected !? */
12673 		sdinfo->satadrv_settings &= ~SATA_DEV_DMA;
12674 
12675 	if ((sdinfo->satadrv_id.ai_cmdset83 & 0x20) &&
12676 	    (sdinfo->satadrv_id.ai_features86 & 0x20))
12677 		sdinfo->satadrv_power_level = SATA_POWER_STANDBY;
12678 	else
12679 		sdinfo->satadrv_power_level = SATA_POWER_ACTIVE;
12680 
12681 	return (rval);
12682 }
12683 
12684 
12685 /*
12686  * Initialize write cache mode.
12687  *
12688  * The default write cache setting for SATA HDD is provided by sata_write_cache
12689  * static variable. ATAPI CD/DVDs devices have write cache default is
12690  * determined by sata_atapicdvd_write_cache static variable.
12691  * ATAPI tape devices have write cache default is determined by
12692  * sata_atapitape_write_cache static variable.
12693  * ATAPI disk devices have write cache default is determined by
12694  * sata_atapidisk_write_cache static variable.
12695  * 1 - enable
12696  * 0 - disable
12697  * any other value - current drive setting
12698  *
12699  * Although there is not reason to disable write cache on CD/DVD devices,
12700  * tape devices and ATAPI disk devices, the default setting control is provided
12701  * for the maximun flexibility.
12702  *
12703  * In the future, it may be overridden by the
12704  * disk-write-cache-enable property setting, if it is defined.
12705  * Returns SATA_SUCCESS if all device features are set successfully,
12706  * SATA_FAILURE otherwise.
12707  */
12708 static void
12709 sata_init_write_cache_mode(sata_drive_info_t *sdinfo)
12710 {
12711 	switch (sdinfo->satadrv_type) {
12712 	case SATA_DTYPE_ATADISK:
12713 		if (sata_write_cache == 1)
12714 			sdinfo->satadrv_settings |= SATA_DEV_WRITE_CACHE;
12715 		else if (sata_write_cache == 0)
12716 			sdinfo->satadrv_settings &= ~SATA_DEV_WRITE_CACHE;
12717 		/*
12718 		 * When sata_write_cache value is not 0 or 1,
12719 		 * a current setting of the drive's write cache is used.
12720 		 */
12721 		break;
12722 	case SATA_DTYPE_ATAPICD:
12723 		if (sata_atapicdvd_write_cache == 1)
12724 			sdinfo->satadrv_settings |= SATA_DEV_WRITE_CACHE;
12725 		else if (sata_atapicdvd_write_cache == 0)
12726 			sdinfo->satadrv_settings &= ~SATA_DEV_WRITE_CACHE;
12727 		/*
12728 		 * When sata_atapicdvd_write_cache value is not 0 or 1,
12729 		 * a current setting of the drive's write cache is used.
12730 		 */
12731 		break;
12732 	case SATA_DTYPE_ATAPITAPE:
12733 		if (sata_atapitape_write_cache == 1)
12734 			sdinfo->satadrv_settings |= SATA_DEV_WRITE_CACHE;
12735 		else if (sata_atapitape_write_cache == 0)
12736 			sdinfo->satadrv_settings &= ~SATA_DEV_WRITE_CACHE;
12737 		/*
12738 		 * When sata_atapitape_write_cache value is not 0 or 1,
12739 		 * a current setting of the drive's write cache is used.
12740 		 */
12741 		break;
12742 	case SATA_DTYPE_ATAPIDISK:
12743 		if (sata_atapidisk_write_cache == 1)
12744 			sdinfo->satadrv_settings |= SATA_DEV_WRITE_CACHE;
12745 		else if (sata_atapidisk_write_cache == 0)
12746 			sdinfo->satadrv_settings &= ~SATA_DEV_WRITE_CACHE;
12747 		/*
12748 		 * When sata_atapidisk_write_cache value is not 0 or 1,
12749 		 * a current setting of the drive's write cache is used.
12750 		 */
12751 		break;
12752 	}
12753 }
12754 
12755 
12756 /*
12757  * Validate sata address.
12758  * Specified cport, pmport and qualifier has to match
12759  * passed sata_scsi configuration info.
12760  * The presence of an attached device is not verified.
12761  *
12762  * Returns 0 when address is valid, -1 otherwise.
12763  */
12764 static int
12765 sata_validate_sata_address(sata_hba_inst_t *sata_hba_inst, int cport,
12766     int pmport, int qual)
12767 {
12768 	if (qual == SATA_ADDR_DCPORT && pmport != 0)
12769 		goto invalid_address;
12770 	if (cport >= SATA_NUM_CPORTS(sata_hba_inst))
12771 		goto invalid_address;
12772 	if ((qual == SATA_ADDR_DPMPORT || qual == SATA_ADDR_PMPORT) &&
12773 	    ((SATA_CPORT_DEV_TYPE(sata_hba_inst, cport) != SATA_DTYPE_PMULT) ||
12774 	    (SATA_PMULT_INFO(sata_hba_inst, cport) == NULL) ||
12775 	    (pmport >= SATA_NUM_PMPORTS(sata_hba_inst, cport))))
12776 		goto invalid_address;
12777 
12778 	return (0);
12779 
12780 invalid_address:
12781 	return (-1);
12782 
12783 }
12784 
12785 /*
12786  * Validate scsi address
12787  * SCSI target address is translated into SATA cport/pmport and compared
12788  * with a controller port/device configuration. LUN has to be 0.
12789  * Returns 0 if a scsi target refers to an attached device,
12790  * returns 1 if address is valid but no valid device is attached,
12791  * returns 2 if address is valid but device type is unknown (not valid device),
12792  * returns -1 if bad address or device is of an unsupported type.
12793  * Upon return sata_device argument is set.
12794  *
12795  * Port multiplier is supported now.
12796  */
12797 static int
12798 sata_validate_scsi_address(sata_hba_inst_t *sata_hba_inst,
12799     struct scsi_address *ap, sata_device_t *sata_device)
12800 {
12801 	int cport, pmport, qual, rval;
12802 
12803 	rval = -1;	/* Invalid address */
12804 	if (ap->a_lun != 0)
12805 		goto out;
12806 
12807 	qual = SCSI_TO_SATA_ADDR_QUAL(ap->a_target);
12808 	cport = SCSI_TO_SATA_CPORT(ap->a_target);
12809 	pmport = SCSI_TO_SATA_PMPORT(ap->a_target);
12810 
12811 	if (qual != SATA_ADDR_DCPORT && qual != SATA_ADDR_DPMPORT)
12812 		goto out;
12813 
12814 	if (sata_validate_sata_address(sata_hba_inst, cport, pmport, qual) ==
12815 	    0) {
12816 
12817 		sata_cport_info_t *cportinfo;
12818 		sata_pmult_info_t *pmultinfo;
12819 		sata_drive_info_t *sdinfo = NULL;
12820 
12821 		sata_device->satadev_addr.qual = qual;
12822 		sata_device->satadev_addr.cport = cport;
12823 		sata_device->satadev_addr.pmport = pmport;
12824 		sata_device->satadev_rev = SATA_DEVICE_REV_1;
12825 
12826 		rval = 1;	/* Valid sata address */
12827 
12828 		cportinfo = SATA_CPORT_INFO(sata_hba_inst, cport);
12829 		if (qual == SATA_ADDR_DCPORT) {
12830 			if (cportinfo == NULL ||
12831 			    cportinfo->cport_dev_type == SATA_DTYPE_NONE)
12832 				goto out;
12833 
12834 			sdinfo = SATA_CPORTINFO_DRV_INFO(cportinfo);
12835 			if (cportinfo->cport_dev_type == SATA_DTYPE_UNKNOWN &&
12836 			    sdinfo != NULL) {
12837 				rval = 2;
12838 				goto out;
12839 			}
12840 
12841 			if ((cportinfo->cport_dev_type &
12842 			    SATA_VALID_DEV_TYPE) == 0) {
12843 				rval = -1;
12844 				goto out;
12845 			}
12846 
12847 		} else if (qual == SATA_ADDR_DPMPORT) {
12848 			pmultinfo = SATA_CPORTINFO_PMULT_INFO(cportinfo);
12849 			if (pmultinfo == NULL) {
12850 				rval = -1;
12851 				goto out;
12852 			}
12853 			if (SATA_PMPORT_INFO(sata_hba_inst, cport, pmport) ==
12854 			    NULL ||
12855 			    SATA_PMPORT_DEV_TYPE(sata_hba_inst, cport,
12856 			    pmport) == SATA_DTYPE_NONE)
12857 				goto out;
12858 
12859 			sdinfo = SATA_PMPORT_DRV_INFO(sata_hba_inst, cport,
12860 			    pmport);
12861 			if (SATA_PMPORT_DEV_TYPE(sata_hba_inst, cport,
12862 			    pmport) == SATA_DTYPE_UNKNOWN && sdinfo != NULL) {
12863 				rval = 2;
12864 				goto out;
12865 			}
12866 
12867 			if ((SATA_PMPORT_DEV_TYPE(sata_hba_inst, cport,
12868 			    pmport) & SATA_VALID_DEV_TYPE) == 0) {
12869 				rval = -1;
12870 				goto out;
12871 			}
12872 
12873 		} else {
12874 			rval = -1;
12875 			goto out;
12876 		}
12877 		if ((sdinfo == NULL) ||
12878 		    (sdinfo->satadrv_type & SATA_VALID_DEV_TYPE) == 0)
12879 			goto out;
12880 
12881 		sata_device->satadev_type = sdinfo->satadrv_type;
12882 
12883 		return (0);
12884 	}
12885 out:
12886 	if (rval > 0) {
12887 		SATADBG2(SATA_DBG_SCSI_IF, sata_hba_inst,
12888 		    "sata_validate_scsi_address: no valid target %x lun %x",
12889 		    ap->a_target, ap->a_lun);
12890 	}
12891 	return (rval);
12892 }
12893 
12894 /*
12895  * Find dip corresponding to passed device number
12896  *
12897  * Returns NULL if invalid device number is passed or device cannot be found,
12898  * Returns dip is device is found.
12899  */
12900 static dev_info_t *
12901 sata_devt_to_devinfo(dev_t dev)
12902 {
12903 	dev_info_t *dip;
12904 #ifndef __lock_lint
12905 	struct devnames *dnp;
12906 	major_t major = getmajor(dev);
12907 	int instance = SATA_MINOR2INSTANCE(getminor(dev));
12908 
12909 	if (major >= devcnt)
12910 		return (NULL);
12911 
12912 	dnp = &devnamesp[major];
12913 	LOCK_DEV_OPS(&(dnp->dn_lock));
12914 	dip = dnp->dn_head;
12915 	while (dip && (ddi_get_instance(dip) != instance)) {
12916 		dip = ddi_get_next(dip);
12917 	}
12918 	UNLOCK_DEV_OPS(&(dnp->dn_lock));
12919 #endif
12920 
12921 	return (dip);
12922 }
12923 
12924 
12925 /*
12926  * Probe device.
12927  * This function issues Identify Device command and initializes local
12928  * sata_drive_info structure if the device can be identified.
12929  * The device type is determined by examining Identify Device
12930  * command response.
12931  * If the sata_hba_inst has linked drive info structure for this
12932  * device address, the Identify Device data is stored into sata_drive_info
12933  * structure linked to the port info structure.
12934  *
12935  * sata_device has to refer to the valid sata port(s) for HBA described
12936  * by sata_hba_inst structure.
12937  *
12938  * Returns:
12939  *	SATA_SUCCESS if device type was successfully probed and port-linked
12940  *		drive info structure was updated;
12941  *	SATA_FAILURE if there is no device, or device was not probed
12942  *		successully;
12943  *	SATA_RETRY if device probe can be retried later.
12944  * If a device cannot be identified, sata_device's dev_state and dev_type
12945  * fields are set to unknown.
12946  * There are no retries in this function. Any retries should be managed by
12947  * the caller.
12948  */
12949 
12950 
12951 static int
12952 sata_probe_device(sata_hba_inst_t *sata_hba_inst, sata_device_t *sata_device)
12953 {
12954 	sata_pmport_info_t *pmportinfo = NULL;
12955 	sata_drive_info_t *sdinfo;
12956 	sata_drive_info_t new_sdinfo;	/* local drive info struct */
12957 	int rval;
12958 
12959 	ASSERT((SATA_CPORT_STATE(sata_hba_inst,
12960 	    sata_device->satadev_addr.cport) &
12961 	    (SATA_STATE_PROBED | SATA_STATE_READY)) != 0);
12962 
12963 	sata_device->satadev_type = SATA_DTYPE_NONE;
12964 
12965 	mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst,
12966 	    sata_device->satadev_addr.cport)));
12967 
12968 	if (sata_device->satadev_addr.qual == SATA_ADDR_DPMPORT) {
12969 		pmportinfo = SATA_PMPORT_INFO(sata_hba_inst,
12970 		    sata_device->satadev_addr.cport,
12971 		    sata_device->satadev_addr.pmport);
12972 		ASSERT(pmportinfo != NULL);
12973 	}
12974 
12975 	/* Get pointer to port-linked sata device info structure */
12976 	sdinfo = sata_get_device_info(sata_hba_inst, sata_device);
12977 	if (sdinfo != NULL) {
12978 		sdinfo->satadrv_state &=
12979 		    ~(SATA_STATE_PROBED | SATA_STATE_READY);
12980 		sdinfo->satadrv_state |= SATA_STATE_PROBING;
12981 	} else {
12982 		/* No device to probe */
12983 		mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst,
12984 		    sata_device->satadev_addr.cport)));
12985 		sata_device->satadev_type = SATA_DTYPE_NONE;
12986 		sata_device->satadev_state = SATA_STATE_UNKNOWN;
12987 		return (SATA_FAILURE);
12988 	}
12989 	/*
12990 	 * Need to issue both types of identify device command and
12991 	 * determine device type by examining retreived data/status.
12992 	 * First, ATA Identify Device.
12993 	 */
12994 	bzero(&new_sdinfo, sizeof (sata_drive_info_t));
12995 	new_sdinfo.satadrv_addr = sata_device->satadev_addr;
12996 	mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst,
12997 	    sata_device->satadev_addr.cport)));
12998 	new_sdinfo.satadrv_type = SATA_DTYPE_ATADISK;
12999 	rval = sata_identify_device(sata_hba_inst, &new_sdinfo);
13000 	if (rval == SATA_RETRY) {
13001 		/* We may try to check for ATAPI device */
13002 		if (SATA_FEATURES(sata_hba_inst) & SATA_CTLF_ATAPI) {
13003 			/*
13004 			 * HBA supports ATAPI - try to issue Identify Packet
13005 			 * Device command.
13006 			 */
13007 			new_sdinfo.satadrv_type = SATA_DTYPE_ATAPI;
13008 			rval = sata_identify_device(sata_hba_inst, &new_sdinfo);
13009 		}
13010 	}
13011 	if (rval == SATA_SUCCESS) {
13012 		/*
13013 		 * Got something responding positively to ATA Identify Device
13014 		 * or to Identify Packet Device cmd.
13015 		 * Save last used device type.
13016 		 */
13017 		sata_device->satadev_type = new_sdinfo.satadrv_type;
13018 
13019 		/* save device info, if possible */
13020 		mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst,
13021 		    sata_device->satadev_addr.cport)));
13022 		sdinfo = sata_get_device_info(sata_hba_inst, sata_device);
13023 		if (sdinfo == NULL) {
13024 			mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst,
13025 			    sata_device->satadev_addr.cport)));
13026 			return (SATA_FAILURE);
13027 		}
13028 		/*
13029 		 * Copy drive info into the port-linked drive info structure.
13030 		 */
13031 		*sdinfo = new_sdinfo;
13032 		sdinfo->satadrv_state &= ~SATA_STATE_PROBING;
13033 		sdinfo->satadrv_state |= SATA_STATE_PROBED;
13034 		if (sata_device->satadev_addr.qual == SATA_ADDR_DCPORT)
13035 			SATA_CPORT_DEV_TYPE(sata_hba_inst,
13036 			    sata_device->satadev_addr.cport) =
13037 			    sdinfo->satadrv_type;
13038 		else { /* SATA_ADDR_DPMPORT */
13039 			mutex_enter(&pmportinfo->pmport_mutex);
13040 			SATA_PMPORT_DEV_TYPE(sata_hba_inst,
13041 			    sata_device->satadev_addr.cport,
13042 			    sata_device->satadev_addr.pmport) =
13043 			    sdinfo->satadrv_type;
13044 			mutex_exit(&pmportinfo->pmport_mutex);
13045 		}
13046 		mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst,
13047 		    sata_device->satadev_addr.cport)));
13048 		return (SATA_SUCCESS);
13049 	}
13050 
13051 	/*
13052 	 * It may be SATA_RETRY or SATA_FAILURE return.
13053 	 * Looks like we cannot determine the device type at this time.
13054 	 */
13055 	mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst,
13056 	    sata_device->satadev_addr.cport)));
13057 	sdinfo = sata_get_device_info(sata_hba_inst, sata_device);
13058 	if (sdinfo != NULL) {
13059 		sata_device->satadev_type = SATA_DTYPE_UNKNOWN;
13060 		sdinfo->satadrv_type = SATA_DTYPE_UNKNOWN;
13061 		sdinfo->satadrv_state &= ~SATA_STATE_PROBING;
13062 		sdinfo->satadrv_state |= SATA_STATE_PROBED;
13063 		if (sata_device->satadev_addr.qual == SATA_ADDR_DCPORT)
13064 			SATA_CPORT_DEV_TYPE(sata_hba_inst,
13065 			    sata_device->satadev_addr.cport) =
13066 			    SATA_DTYPE_UNKNOWN;
13067 		else {
13068 			/* SATA_ADDR_DPMPORT */
13069 			mutex_enter(&pmportinfo->pmport_mutex);
13070 			if ((SATA_PMULT_INFO(sata_hba_inst,
13071 			    sata_device->satadev_addr.cport) != NULL) &&
13072 			    (SATA_PMPORT_INFO(sata_hba_inst,
13073 			    sata_device->satadev_addr.cport,
13074 			    sata_device->satadev_addr.pmport) != NULL))
13075 				SATA_PMPORT_DEV_TYPE(sata_hba_inst,
13076 				    sata_device->satadev_addr.cport,
13077 				    sata_device->satadev_addr.pmport) =
13078 				    SATA_DTYPE_UNKNOWN;
13079 			mutex_exit(&pmportinfo->pmport_mutex);
13080 		}
13081 	}
13082 	mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst,
13083 	    sata_device->satadev_addr.cport)));
13084 	return (rval);
13085 }
13086 
13087 
13088 /*
13089  * Get pointer to sata_drive_info structure.
13090  *
13091  * The sata_device has to contain address (cport, pmport and qualifier) for
13092  * specified sata_scsi structure.
13093  *
13094  * Returns NULL if device address is not valid for this HBA configuration.
13095  * Otherwise, returns a pointer to sata_drive_info structure.
13096  *
13097  * This function should be called with a port mutex held.
13098  */
13099 static sata_drive_info_t *
13100 sata_get_device_info(sata_hba_inst_t *sata_hba_inst,
13101     sata_device_t *sata_device)
13102 {
13103 	uint8_t cport = sata_device->satadev_addr.cport;
13104 	uint8_t pmport = sata_device->satadev_addr.pmport;
13105 	uint8_t qual = sata_device->satadev_addr.qual;
13106 
13107 	if (cport >= SATA_NUM_CPORTS(sata_hba_inst))
13108 		return (NULL);
13109 
13110 	if (!(SATA_CPORT_STATE(sata_hba_inst, cport) &
13111 	    (SATA_STATE_PROBED | SATA_STATE_READY)))
13112 		/* Port not probed yet */
13113 		return (NULL);
13114 
13115 	if (SATA_CPORT_DEV_TYPE(sata_hba_inst, cport) == SATA_DTYPE_NONE)
13116 		return (NULL);
13117 
13118 	if (qual == SATA_ADDR_DCPORT) {
13119 		/* Request for a device on a controller port */
13120 		if (SATA_CPORT_DEV_TYPE(sata_hba_inst, cport) ==
13121 		    SATA_DTYPE_PMULT)
13122 			/* Port multiplier attached */
13123 			return (NULL);
13124 		return (SATA_CPORT_DRV_INFO(sata_hba_inst, cport));
13125 	}
13126 	if (qual == SATA_ADDR_DPMPORT) {
13127 		if (SATA_CPORT_DEV_TYPE(sata_hba_inst, cport) !=
13128 		    SATA_DTYPE_PMULT)
13129 			return (NULL);
13130 
13131 		if (pmport > SATA_NUM_PMPORTS(sata_hba_inst, cport))
13132 			return (NULL);
13133 
13134 		if (!(SATA_PMPORT_STATE(sata_hba_inst, cport, pmport) &
13135 		    (SATA_STATE_PROBED | SATA_STATE_READY)))
13136 			/* Port multiplier port not probed yet */
13137 			return (NULL);
13138 
13139 		return (SATA_PMPORT_DRV_INFO(sata_hba_inst, cport, pmport));
13140 	}
13141 
13142 	/* we should not get here */
13143 	return (NULL);
13144 }
13145 
13146 
13147 /*
13148  * sata_identify_device.
13149  * Send Identify Device command to SATA HBA driver.
13150  * If command executes successfully, update sata_drive_info structure pointed
13151  * to by sdinfo argument, including Identify Device data.
13152  * If command fails, invalidate data in sata_drive_info.
13153  *
13154  * Cannot be called from interrupt level.
13155  *
13156  * Returns:
13157  * SATA_SUCCESS if the device was identified as a supported device,
13158  * SATA_RETRY if the device was not identified but could be retried,
13159  * SATA_FAILURE if the device was not identified and identify attempt
13160  *	should not be retried.
13161  */
13162 static int
13163 sata_identify_device(sata_hba_inst_t *sata_hba_inst,
13164     sata_drive_info_t *sdinfo)
13165 {
13166 	uint16_t cfg_word;
13167 	int rval;
13168 
13169 	/* fetch device identify data */
13170 	if ((rval = sata_fetch_device_identify_data(sata_hba_inst,
13171 	    sdinfo)) != SATA_SUCCESS)
13172 		goto fail_unknown;
13173 
13174 	cfg_word = sdinfo->satadrv_id.ai_config;
13175 
13176 	/* Set the correct device type */
13177 	if ((cfg_word & SATA_ATA_TYPE_MASK) == SATA_ATA_TYPE) {
13178 		sdinfo->satadrv_type = SATA_DTYPE_ATADISK;
13179 	} else if (cfg_word == SATA_CFA_TYPE) {
13180 		/* It's a Compact Flash media via CF-to-SATA HDD adapter */
13181 		sdinfo->satadrv_type = SATA_DTYPE_ATADISK;
13182 	} else if ((cfg_word & SATA_ATAPI_TYPE_MASK) == SATA_ATAPI_TYPE) {
13183 		switch (cfg_word & SATA_ATAPI_ID_DEV_TYPE) {
13184 		case SATA_ATAPI_CDROM_DEV:
13185 			sdinfo->satadrv_type = SATA_DTYPE_ATAPICD;
13186 			break;
13187 		case SATA_ATAPI_SQACC_DEV:
13188 			sdinfo->satadrv_type = SATA_DTYPE_ATAPITAPE;
13189 			break;
13190 		case SATA_ATAPI_DIRACC_DEV:
13191 			sdinfo->satadrv_type = SATA_DTYPE_ATAPIDISK;
13192 			break;
13193 		case SATA_ATAPI_PROC_DEV:
13194 			sdinfo->satadrv_type = SATA_DTYPE_ATAPIPROC;
13195 			break;
13196 		default:
13197 			sdinfo->satadrv_type = SATA_DTYPE_UNKNOWN;
13198 		}
13199 	} else {
13200 			sdinfo->satadrv_type = SATA_DTYPE_UNKNOWN;
13201 	}
13202 
13203 	if (sdinfo->satadrv_type == SATA_DTYPE_ATADISK) {
13204 		if (sdinfo->satadrv_capacity == 0) {
13205 			/* Non-LBA disk. Too bad... */
13206 			sata_log(sata_hba_inst, CE_WARN,
13207 			    "SATA disk device at port %d does not support LBA",
13208 			    sdinfo->satadrv_addr.cport);
13209 			rval = SATA_FAILURE;
13210 			goto fail_unknown;
13211 		}
13212 	}
13213 #if 0
13214 	/* Left for historical reason */
13215 	/*
13216 	 * Some initial version of SATA spec indicated that at least
13217 	 * UDMA mode 4 has to be supported. It is not metioned in
13218 	 * SerialATA 2.6, so this restriction is removed.
13219 	 */
13220 	/* Check for Ultra DMA modes 6 through 0 being supported */
13221 	for (i = 6; i >= 0; --i) {
13222 		if (sdinfo->satadrv_id.ai_ultradma & (1 << i))
13223 			break;
13224 	}
13225 
13226 	/*
13227 	 * At least UDMA 4 mode has to be supported. If mode 4 or
13228 	 * higher are not supported by the device, fail this
13229 	 * device.
13230 	 */
13231 	if (i < 4) {
13232 		/* No required Ultra DMA mode supported */
13233 		sata_log(sata_hba_inst, CE_WARN,
13234 		    "SATA disk device at port %d does not support UDMA "
13235 		    "mode 4 or higher", sdinfo->satadrv_addr.cport);
13236 		SATA_LOG_D((sata_hba_inst, CE_WARN,
13237 		    "mode 4 or higher required, %d supported", i));
13238 		rval = SATA_FAILURE;
13239 		goto fail_unknown;
13240 	}
13241 #endif
13242 
13243 	/*
13244 	 * For Disk devices, if it doesn't support UDMA mode, we would
13245 	 * like to return failure directly.
13246 	 */
13247 	if ((sdinfo->satadrv_type == SATA_DTYPE_ATADISK) &&
13248 	    !((sdinfo->satadrv_id.ai_validinfo & SATA_VALIDINFO_88) != 0 &&
13249 	    (sdinfo->satadrv_id.ai_ultradma & SATA_UDMA_SUP_MASK) != 0)) {
13250 		sata_log(sata_hba_inst, CE_WARN,
13251 		    "SATA disk device at port %d does not support UDMA",
13252 		    sdinfo->satadrv_addr.cport);
13253 		rval = SATA_FAILURE;
13254 		goto fail_unknown;
13255 	}
13256 
13257 	return (SATA_SUCCESS);
13258 
13259 fail_unknown:
13260 	/* Invalidate sata_drive_info ? */
13261 	sdinfo->satadrv_type = SATA_DTYPE_UNKNOWN;
13262 	sdinfo->satadrv_state = SATA_STATE_UNKNOWN;
13263 	return (rval);
13264 }
13265 
13266 /*
13267  * Log/display device information
13268  */
13269 static void
13270 sata_show_drive_info(sata_hba_inst_t *sata_hba_inst,
13271     sata_drive_info_t *sdinfo)
13272 {
13273 	int valid_version = 0;
13274 	char msg_buf[MAXPATHLEN];
13275 	int i;
13276 
13277 	/* Show HBA path */
13278 	(void) ddi_pathname(SATA_DIP(sata_hba_inst), msg_buf);
13279 
13280 	cmn_err(CE_CONT, "?%s :\n", msg_buf);
13281 
13282 	switch (sdinfo->satadrv_type) {
13283 	case SATA_DTYPE_ATADISK:
13284 		(void) sprintf(msg_buf, "SATA disk device at");
13285 		break;
13286 
13287 	case SATA_DTYPE_ATAPICD:
13288 		(void) sprintf(msg_buf, "SATA CD/DVD (ATAPI) device at");
13289 		break;
13290 
13291 	case SATA_DTYPE_ATAPITAPE:
13292 		(void) sprintf(msg_buf, "SATA tape (ATAPI) device at");
13293 		break;
13294 
13295 	case SATA_DTYPE_ATAPIDISK:
13296 		(void) sprintf(msg_buf, "SATA disk (ATAPI) device at");
13297 		break;
13298 
13299 	case SATA_DTYPE_ATAPIPROC:
13300 		(void) sprintf(msg_buf, "SATA processor (ATAPI) device at");
13301 		break;
13302 
13303 	case SATA_DTYPE_UNKNOWN:
13304 		(void) sprintf(msg_buf,
13305 		    "Unsupported SATA device type (cfg 0x%x) at ",
13306 		    sdinfo->satadrv_id.ai_config);
13307 		break;
13308 	}
13309 
13310 	if (sdinfo->satadrv_addr.qual == SATA_ADDR_DCPORT)
13311 		cmn_err(CE_CONT, "?\t%s port %d\n",
13312 		    msg_buf, sdinfo->satadrv_addr.cport);
13313 	else
13314 		cmn_err(CE_CONT, "?\t%s port %d:%d\n",
13315 		    msg_buf, sdinfo->satadrv_addr.cport,
13316 		    sdinfo->satadrv_addr.pmport);
13317 
13318 	bcopy(&sdinfo->satadrv_id.ai_model, msg_buf,
13319 	    sizeof (sdinfo->satadrv_id.ai_model));
13320 	swab(msg_buf, msg_buf, sizeof (sdinfo->satadrv_id.ai_model));
13321 	msg_buf[sizeof (sdinfo->satadrv_id.ai_model)] = '\0';
13322 	cmn_err(CE_CONT, "?\tmodel %s\n", msg_buf);
13323 
13324 	bcopy(&sdinfo->satadrv_id.ai_fw, msg_buf,
13325 	    sizeof (sdinfo->satadrv_id.ai_fw));
13326 	swab(msg_buf, msg_buf, sizeof (sdinfo->satadrv_id.ai_fw));
13327 	msg_buf[sizeof (sdinfo->satadrv_id.ai_fw)] = '\0';
13328 	cmn_err(CE_CONT, "?\tfirmware %s\n", msg_buf);
13329 
13330 	bcopy(&sdinfo->satadrv_id.ai_drvser, msg_buf,
13331 	    sizeof (sdinfo->satadrv_id.ai_drvser));
13332 	swab(msg_buf, msg_buf, sizeof (sdinfo->satadrv_id.ai_drvser));
13333 	msg_buf[sizeof (sdinfo->satadrv_id.ai_drvser)] = '\0';
13334 	if (sdinfo->satadrv_type == SATA_DTYPE_ATADISK) {
13335 		cmn_err(CE_CONT, "?\tserial number %s\n", msg_buf);
13336 	} else {
13337 		/*
13338 		 * Some drives do not implement serial number and may
13339 		 * violate the spec by providing spaces rather than zeros
13340 		 * in serial number field. Scan the buffer to detect it.
13341 		 */
13342 		for (i = 0; i < sizeof (sdinfo->satadrv_id.ai_drvser); i++) {
13343 			if (msg_buf[i] != '\0' && msg_buf[i] != ' ')
13344 				break;
13345 		}
13346 		if (i == sizeof (sdinfo->satadrv_id.ai_drvser)) {
13347 			cmn_err(CE_CONT, "?\tserial number - none\n");
13348 		} else {
13349 			cmn_err(CE_CONT, "?\tserial number %s\n", msg_buf);
13350 		}
13351 	}
13352 
13353 #ifdef SATA_DEBUG
13354 	if (sdinfo->satadrv_id.ai_majorversion != 0 &&
13355 	    sdinfo->satadrv_id.ai_majorversion != 0xffff) {
13356 		int i;
13357 		for (i = 14; i >= 2; i--) {
13358 			if (sdinfo->satadrv_id.ai_majorversion & (1 << i)) {
13359 				valid_version = i;
13360 				break;
13361 			}
13362 		}
13363 		cmn_err(CE_CONT,
13364 		    "?\tATA/ATAPI-%d supported, majver 0x%x minver 0x%x\n",
13365 		    valid_version,
13366 		    sdinfo->satadrv_id.ai_majorversion,
13367 		    sdinfo->satadrv_id.ai_minorversion);
13368 	}
13369 #endif
13370 	/* Log some info */
13371 	cmn_err(CE_CONT, "?\tsupported features:\n");
13372 	msg_buf[0] = '\0';
13373 	if (sdinfo->satadrv_type == SATA_DTYPE_ATADISK) {
13374 		if (sdinfo->satadrv_features_support & SATA_DEV_F_LBA48)
13375 			(void) strlcat(msg_buf, "48-bit LBA, ", MAXPATHLEN);
13376 		else if (sdinfo->satadrv_features_support & SATA_DEV_F_LBA28)
13377 			(void) strlcat(msg_buf, "28-bit LBA, ", MAXPATHLEN);
13378 	}
13379 	if (sdinfo->satadrv_features_support & SATA_DEV_F_DMA)
13380 		(void) strlcat(msg_buf, "DMA", MAXPATHLEN);
13381 	if (sdinfo->satadrv_features_support & SATA_DEV_F_NCQ)
13382 		(void) strlcat(msg_buf, ", Native Command Queueing",
13383 		    MAXPATHLEN);
13384 	if (sdinfo->satadrv_features_support & SATA_DEV_F_TCQ)
13385 		(void) strlcat(msg_buf, ", Legacy Tagged Queuing", MAXPATHLEN);
13386 	if ((sdinfo->satadrv_id.ai_cmdset82 & SATA_SMART_SUPPORTED) &&
13387 	    (sdinfo->satadrv_id.ai_features85 & SATA_SMART_ENABLED))
13388 		(void) strlcat(msg_buf, ", SMART", MAXPATHLEN);
13389 	if ((sdinfo->satadrv_id.ai_cmdset84 & SATA_SMART_SELF_TEST_SUPPORTED) &&
13390 	    (sdinfo->satadrv_id.ai_features87 & SATA_SMART_SELF_TEST_SUPPORTED))
13391 		(void) strlcat(msg_buf, ", SMART self-test", MAXPATHLEN);
13392 	cmn_err(CE_CONT, "?\t %s\n", msg_buf);
13393 	if (sdinfo->satadrv_features_support & SATA_DEV_F_SATA3)
13394 		cmn_err(CE_CONT, "?\tSATA Gen3 signaling speed (6.0Gbps)\n");
13395 	else if (sdinfo->satadrv_features_support & SATA_DEV_F_SATA2)
13396 		cmn_err(CE_CONT, "?\tSATA Gen2 signaling speed (3.0Gbps)\n");
13397 	else if (sdinfo->satadrv_features_support & SATA_DEV_F_SATA1)
13398 		cmn_err(CE_CONT, "?\tSATA Gen1 signaling speed (1.5Gbps)\n");
13399 	if (sdinfo->satadrv_features_support &
13400 	    (SATA_DEV_F_TCQ | SATA_DEV_F_NCQ)) {
13401 		msg_buf[0] = '\0';
13402 		(void) snprintf(msg_buf, MAXPATHLEN,
13403 		    "Supported queue depth %d",
13404 		    sdinfo->satadrv_queue_depth);
13405 		if (!(sata_func_enable &
13406 		    (SATA_ENABLE_QUEUING | SATA_ENABLE_NCQ)))
13407 			(void) strlcat(msg_buf,
13408 			    " - queueing disabled globally", MAXPATHLEN);
13409 		else if (sdinfo->satadrv_queue_depth >
13410 		    sdinfo->satadrv_max_queue_depth) {
13411 			(void) snprintf(&msg_buf[strlen(msg_buf)],
13412 			    MAXPATHLEN - strlen(msg_buf), ", limited to %d",
13413 			    (int)sdinfo->satadrv_max_queue_depth);
13414 		}
13415 		cmn_err(CE_CONT, "?\t%s\n", msg_buf);
13416 	}
13417 
13418 	if (sdinfo->satadrv_type == SATA_DTYPE_ATADISK) {
13419 		(void) sprintf(msg_buf, "\tcapacity = %lu sectors\n",
13420 		    sdinfo->satadrv_capacity);
13421 		cmn_err(CE_CONT, "?%s", msg_buf);
13422 	}
13423 }
13424 
13425 /*
13426  * Log/display port multiplier information
13427  * No Mutex should be hold.
13428  */
13429 static void
13430 sata_show_pmult_info(sata_hba_inst_t *sata_hba_inst,
13431     sata_device_t *sata_device)
13432 {
13433 	_NOTE(ARGUNUSED(sata_hba_inst))
13434 
13435 	int cport = sata_device->satadev_addr.cport;
13436 	sata_pmult_info_t *pmultinfo;
13437 	char msg_buf[MAXPATHLEN];
13438 	uint32_t gscr0, gscr1, gscr2, gscr64;
13439 
13440 	mutex_enter(&SATA_CPORT_MUTEX(sata_hba_inst, cport));
13441 	pmultinfo = SATA_PMULT_INFO(sata_hba_inst, cport);
13442 	if (pmultinfo == NULL) {
13443 		mutex_exit(&SATA_CPORT_MUTEX(sata_hba_inst, cport));
13444 		return;
13445 	}
13446 
13447 	gscr0 = pmultinfo->pmult_gscr.gscr0;
13448 	gscr1 = pmultinfo->pmult_gscr.gscr1;
13449 	gscr2 = pmultinfo->pmult_gscr.gscr2;
13450 	gscr64 = pmultinfo->pmult_gscr.gscr64;
13451 	mutex_exit(&SATA_CPORT_MUTEX(sata_hba_inst, cport));
13452 
13453 	cmn_err(CE_CONT, "?Port Multiplier %d device-ports found at port %d",
13454 	    sata_device->satadev_add_info, sata_device->satadev_addr.cport);
13455 
13456 	(void) sprintf(msg_buf, "\tVendor_ID 0x%04x, Module_ID 0x%04x",
13457 	    gscr0 & 0xffff, (gscr0 >> 16) & 0xffff);
13458 	cmn_err(CE_CONT, "?%s", msg_buf);
13459 
13460 	(void) strcpy(msg_buf, "\tSupport SATA PMP Spec ");
13461 	if (gscr1 & (1 << 3))
13462 		(void) strlcat(msg_buf, "1.2", MAXPATHLEN);
13463 	else if (gscr1 & (1 << 2))
13464 		(void) strlcat(msg_buf, "1.1", MAXPATHLEN);
13465 	else if (gscr1 & (1 << 1))
13466 		(void) strlcat(msg_buf, "1.0", MAXPATHLEN);
13467 	else
13468 		(void) strlcat(msg_buf, "unknown", MAXPATHLEN);
13469 	cmn_err(CE_CONT, "?%s", msg_buf);
13470 
13471 	(void) strcpy(msg_buf, "\tSupport ");
13472 	if (gscr64 & (1 << 3))
13473 		(void) strlcat(msg_buf, "Asy-Notif, ",
13474 		    MAXPATHLEN);
13475 	if (gscr64 & (1 << 2))
13476 		(void) strlcat(msg_buf, "Dyn-SSC, ", MAXPATHLEN);
13477 	if (gscr64 & (1 << 1))
13478 		(void) strlcat(msg_buf, "Iss-PMREQ, ", MAXPATHLEN);
13479 	if (gscr64 & (1 << 0))
13480 		(void) strlcat(msg_buf, "BIST", MAXPATHLEN);
13481 	if ((gscr64 & 0xf) == 0)
13482 		(void) strlcat(msg_buf, "nothing", MAXPATHLEN);
13483 	cmn_err(CE_CONT, "?%s", msg_buf);
13484 
13485 	(void) sprintf(msg_buf, "\tNumber of exposed device fan-out ports: %d",
13486 	    gscr2 & SATA_PMULT_PORTNUM_MASK);
13487 	cmn_err(CE_CONT, "?%s", msg_buf);
13488 }
13489 
13490 /*
13491  * sata_save_drive_settings extracts current setting of the device and stores
13492  * it for future reference, in case the device setup would need to be restored
13493  * after the device reset.
13494  *
13495  * For all devices read ahead and write cache settings are saved, if the
13496  * device supports these features at all.
13497  * For ATAPI devices the Removable Media Status Notification setting is saved.
13498  */
13499 static void
13500 sata_save_drive_settings(sata_drive_info_t *sdinfo)
13501 {
13502 	if (SATA_READ_AHEAD_SUPPORTED(sdinfo->satadrv_id) ||
13503 	    SATA_WRITE_CACHE_SUPPORTED(sdinfo->satadrv_id)) {
13504 
13505 		/* Current setting of Read Ahead (and Read Cache) */
13506 		if (SATA_READ_AHEAD_ENABLED(sdinfo->satadrv_id))
13507 			sdinfo->satadrv_settings |= SATA_DEV_READ_AHEAD;
13508 		else
13509 			sdinfo->satadrv_settings &= ~SATA_DEV_READ_AHEAD;
13510 
13511 		/* Current setting of Write Cache */
13512 		if (SATA_WRITE_CACHE_ENABLED(sdinfo->satadrv_id))
13513 			sdinfo->satadrv_settings |= SATA_DEV_WRITE_CACHE;
13514 		else
13515 			sdinfo->satadrv_settings &= ~SATA_DEV_WRITE_CACHE;
13516 	}
13517 
13518 	if (sdinfo->satadrv_type == SATA_DTYPE_ATAPICD) {
13519 		if (SATA_RM_NOTIFIC_SUPPORTED(sdinfo->satadrv_id))
13520 			sdinfo->satadrv_settings |= SATA_DEV_RMSN;
13521 		else
13522 			sdinfo->satadrv_settings &= ~SATA_DEV_RMSN;
13523 	}
13524 }
13525 
13526 
13527 /*
13528  * sata_check_capacity function determines a disk capacity
13529  * and addressing mode (LBA28/LBA48) by examining a disk identify device data.
13530  *
13531  * NOTE: CHS mode is not supported! If a device does not support LBA,
13532  * this function is not called.
13533  *
13534  * Returns device capacity in number of blocks, i.e. largest addressable LBA+1
13535  */
13536 static uint64_t
13537 sata_check_capacity(sata_drive_info_t *sdinfo)
13538 {
13539 	uint64_t capacity = 0;
13540 	int i;
13541 
13542 	if (sdinfo->satadrv_type != SATA_DTYPE_ATADISK ||
13543 	    (sdinfo->satadrv_id.ai_cap & SATA_LBA_SUPPORT) == 0)
13544 		/* Capacity valid only for LBA-addressable disk devices */
13545 		return (0);
13546 
13547 	if ((sdinfo->satadrv_id.ai_validinfo & SATA_VALIDINFO_88) &&
13548 	    (sdinfo->satadrv_id.ai_cmdset83 & SATA_EXT48) &&
13549 	    (sdinfo->satadrv_id.ai_features86 & SATA_EXT48)) {
13550 		/* LBA48 mode supported and enabled */
13551 		sdinfo->satadrv_features_support |= SATA_DEV_F_LBA48 |
13552 		    SATA_DEV_F_LBA28;
13553 		for (i = 3;  i >= 0;  --i) {
13554 			capacity <<= 16;
13555 			capacity += sdinfo->satadrv_id.ai_addrsecxt[i];
13556 		}
13557 	} else {
13558 		capacity = sdinfo->satadrv_id.ai_addrsec[1];
13559 		capacity <<= 16;
13560 		capacity += sdinfo->satadrv_id.ai_addrsec[0];
13561 		if (capacity >= 0x1000000)
13562 			/* LBA28 mode */
13563 			sdinfo->satadrv_features_support |= SATA_DEV_F_LBA28;
13564 	}
13565 	return (capacity);
13566 }
13567 
13568 
13569 /*
13570  * Allocate consistent buffer for DMA transfer
13571  *
13572  * Cannot be called from interrupt level or with mutex held - it may sleep.
13573  *
13574  * Returns pointer to allocated buffer structure, or NULL if allocation failed.
13575  */
13576 static struct buf *
13577 sata_alloc_local_buffer(sata_pkt_txlate_t *spx, size_t len)
13578 {
13579 	struct scsi_address ap;
13580 	struct buf *bp;
13581 	ddi_dma_attr_t	cur_dma_attr;
13582 
13583 	ASSERT(spx->txlt_sata_pkt != NULL);
13584 	ap.a_hba_tran = spx->txlt_sata_hba_inst->satahba_scsi_tran;
13585 	ap.a_target = SATA_TO_SCSI_TARGET(
13586 	    spx->txlt_sata_pkt->satapkt_device.satadev_addr.cport,
13587 	    spx->txlt_sata_pkt->satapkt_device.satadev_addr.pmport,
13588 	    spx->txlt_sata_pkt->satapkt_device.satadev_addr.qual);
13589 	ap.a_lun = 0;
13590 
13591 	bp = scsi_alloc_consistent_buf(&ap, NULL, len,
13592 	    B_READ, SLEEP_FUNC, NULL);
13593 
13594 	if (bp != NULL) {
13595 		/* Allocate DMA resources for this buffer */
13596 		spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp = bp;
13597 		/*
13598 		 * We use a local version of the dma_attr, to account
13599 		 * for a device addressing limitations.
13600 		 * sata_adjust_dma_attr() will handle sdinfo == NULL which
13601 		 * will cause dma attributes to be adjusted to a lowest
13602 		 * acceptable level.
13603 		 */
13604 		sata_adjust_dma_attr(NULL,
13605 		    SATA_DMA_ATTR(spx->txlt_sata_hba_inst), &cur_dma_attr);
13606 
13607 		if (sata_dma_buf_setup(spx, PKT_CONSISTENT,
13608 		    SLEEP_FUNC, NULL, &cur_dma_attr) != DDI_SUCCESS) {
13609 			scsi_free_consistent_buf(bp);
13610 			spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp = NULL;
13611 			bp = NULL;
13612 		}
13613 	}
13614 	return (bp);
13615 }
13616 
13617 /*
13618  * Release local buffer (consistent buffer for DMA transfer) allocated
13619  * via sata_alloc_local_buffer().
13620  */
13621 static void
13622 sata_free_local_buffer(sata_pkt_txlate_t *spx)
13623 {
13624 	ASSERT(spx->txlt_sata_pkt != NULL);
13625 	ASSERT(spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp != NULL);
13626 
13627 	spx->txlt_sata_pkt->satapkt_cmd.satacmd_num_dma_cookies = 0;
13628 	spx->txlt_sata_pkt->satapkt_cmd.satacmd_dma_cookie_list = NULL;
13629 
13630 	sata_common_free_dma_rsrcs(spx);
13631 
13632 	/* Free buffer */
13633 	scsi_free_consistent_buf(spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp);
13634 	spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp = NULL;
13635 }
13636 
13637 /*
13638  * Allocate sata_pkt
13639  * Pkt structure version and embedded strcutures version are initialized.
13640  * sata_pkt and sata_pkt_txlate structures are cross-linked.
13641  *
13642  * Since this may be called in interrupt context by sata_scsi_init_pkt,
13643  * callback argument determines if it can sleep or not.
13644  * Hence, it should not be called from interrupt context.
13645  *
13646  * If successful, non-NULL pointer to a sata pkt is returned.
13647  * Upon failure, NULL pointer is returned.
13648  */
13649 static sata_pkt_t *
13650 sata_pkt_alloc(sata_pkt_txlate_t *spx, int (*callback)(caddr_t))
13651 {
13652 	sata_pkt_t *spkt;
13653 	int kmsflag;
13654 
13655 	kmsflag = (callback == SLEEP_FUNC) ? KM_SLEEP : KM_NOSLEEP;
13656 	spkt = kmem_zalloc(sizeof (sata_pkt_t), kmsflag);
13657 	if (spkt == NULL) {
13658 		SATA_LOG_D((spx->txlt_sata_hba_inst, CE_WARN,
13659 		    "sata_pkt_alloc: failed"));
13660 		return (NULL);
13661 	}
13662 	spkt->satapkt_rev = SATA_PKT_REV;
13663 	spkt->satapkt_cmd.satacmd_rev = SATA_CMD_REV;
13664 	spkt->satapkt_device.satadev_rev = SATA_DEVICE_REV;
13665 	spkt->satapkt_framework_private = spx;
13666 	spx->txlt_sata_pkt = spkt;
13667 	return (spkt);
13668 }
13669 
13670 /*
13671  * Free sata pkt allocated via sata_pkt_alloc()
13672  */
13673 static void
13674 sata_pkt_free(sata_pkt_txlate_t *spx)
13675 {
13676 	ASSERT(spx->txlt_sata_pkt != NULL);
13677 	ASSERT(spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp == NULL);
13678 	kmem_free(spx->txlt_sata_pkt, sizeof (sata_pkt_t));
13679 	spx->txlt_sata_pkt = NULL;
13680 }
13681 
13682 
13683 /*
13684  * Adjust DMA attributes.
13685  * SCSI cmds block count is up to 24 bits, SATA cmd block count vary
13686  * from 8 bits to 16 bits, depending on a command being used.
13687  * Limiting max block count arbitrarily to 256 for all read/write
13688  * commands may affects performance, so check both the device and
13689  * controller capability before adjusting dma attributes.
13690  */
13691 void
13692 sata_adjust_dma_attr(sata_drive_info_t *sdinfo, ddi_dma_attr_t *dma_attr,
13693     ddi_dma_attr_t *adj_dma_attr)
13694 {
13695 	uint32_t count_max;
13696 
13697 	/* Copy original attributes */
13698 	*adj_dma_attr = *dma_attr;
13699 	/*
13700 	 * Things to consider: device addressing capability,
13701 	 * "excessive" controller DMA capabilities.
13702 	 * If a device is being probed/initialized, there are
13703 	 * no device info - use default limits then.
13704 	 */
13705 	if (sdinfo == NULL) {
13706 		count_max = dma_attr->dma_attr_granular * 0x100;
13707 		if (dma_attr->dma_attr_count_max > count_max)
13708 			adj_dma_attr->dma_attr_count_max = count_max;
13709 		if (dma_attr->dma_attr_maxxfer > count_max)
13710 			adj_dma_attr->dma_attr_maxxfer = count_max;
13711 		return;
13712 	}
13713 
13714 	if (sdinfo->satadrv_type == SATA_DTYPE_ATADISK) {
13715 		if (sdinfo->satadrv_features_support & (SATA_DEV_F_LBA48)) {
13716 			/*
13717 			 * 16-bit sector count may be used - we rely on
13718 			 * the assumption that only read and write cmds
13719 			 * will request more than 256 sectors worth of data
13720 			 */
13721 			count_max = adj_dma_attr->dma_attr_granular * 0x10000;
13722 		} else {
13723 			/*
13724 			 * 8-bit sector count will be used - default limits
13725 			 * for dma attributes
13726 			 */
13727 			count_max = adj_dma_attr->dma_attr_granular * 0x100;
13728 		}
13729 		/*
13730 		 * Adjust controler dma attributes, if necessary
13731 		 */
13732 		if (dma_attr->dma_attr_count_max > count_max)
13733 			adj_dma_attr->dma_attr_count_max = count_max;
13734 		if (dma_attr->dma_attr_maxxfer > count_max)
13735 			adj_dma_attr->dma_attr_maxxfer = count_max;
13736 	}
13737 }
13738 
13739 
13740 /*
13741  * Allocate DMA resources for the buffer
13742  * This function handles initial DMA resource allocation as well as
13743  * DMA window shift and may be called repeatedly for the same DMA window
13744  * until all DMA cookies in the DMA window are processed.
13745  * To guarantee that there is always a coherent set of cookies to process
13746  * by SATA HBA driver (observing alignment, device granularity, etc.),
13747  * the number of slots for DMA cookies is equal to lesser of  a number of
13748  * cookies in a DMA window and a max number of scatter/gather entries.
13749  *
13750  * Returns DDI_SUCCESS upon successful operation.
13751  * Return failure code of a failing command or DDI_FAILURE when
13752  * internal cleanup failed.
13753  */
13754 static int
13755 sata_dma_buf_setup(sata_pkt_txlate_t *spx, int flags,
13756     int (*callback)(caddr_t), caddr_t arg,
13757     ddi_dma_attr_t *cur_dma_attr)
13758 {
13759 	int	rval;
13760 	off_t	offset;
13761 	size_t	size;
13762 	int	max_sg_len, req_len, i;
13763 	uint_t	dma_flags;
13764 	struct buf	*bp;
13765 	uint64_t	cur_txfer_len;
13766 
13767 
13768 	ASSERT(spx->txlt_sata_pkt != NULL);
13769 	bp = spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp;
13770 	ASSERT(bp != NULL);
13771 
13772 
13773 	if (spx->txlt_buf_dma_handle == NULL) {
13774 		/*
13775 		 * No DMA resources allocated so far - this is a first call
13776 		 * for this sata pkt.
13777 		 */
13778 		rval = ddi_dma_alloc_handle(SATA_DIP(spx->txlt_sata_hba_inst),
13779 		    cur_dma_attr, callback, arg, &spx->txlt_buf_dma_handle);
13780 
13781 		if (rval != DDI_SUCCESS) {
13782 			SATA_LOG_D((spx->txlt_sata_hba_inst, CE_WARN,
13783 			    "sata_dma_buf_setup: no buf DMA resources %x",
13784 			    rval));
13785 			return (rval);
13786 		}
13787 
13788 		if (bp->b_flags & B_READ)
13789 			dma_flags = DDI_DMA_READ;
13790 		else
13791 			dma_flags = DDI_DMA_WRITE;
13792 
13793 		if (flags & PKT_CONSISTENT)
13794 			dma_flags |= DDI_DMA_CONSISTENT;
13795 
13796 		if (flags & PKT_DMA_PARTIAL)
13797 			dma_flags |= DDI_DMA_PARTIAL;
13798 
13799 		/*
13800 		 * Check buffer alignment and size against dma attributes
13801 		 * Consider dma_attr_align only. There may be requests
13802 		 * with the size lower than device granularity, but they
13803 		 * will not read/write from/to the device, so no adjustment
13804 		 * is necessary. The dma_attr_minxfer theoretically should
13805 		 * be considered, but no HBA driver is checking it.
13806 		 */
13807 		if (IS_P2ALIGNED(bp->b_un.b_addr,
13808 		    cur_dma_attr->dma_attr_align)) {
13809 			rval = ddi_dma_buf_bind_handle(
13810 			    spx->txlt_buf_dma_handle,
13811 			    bp, dma_flags, callback, arg,
13812 			    &spx->txlt_dma_cookie,
13813 			    &spx->txlt_curwin_num_dma_cookies);
13814 		} else { /* Buffer is not aligned */
13815 
13816 			int	(*ddicallback)(caddr_t);
13817 			size_t	bufsz;
13818 
13819 			/* Check id sleeping is allowed */
13820 			ddicallback = (callback == NULL_FUNC) ?
13821 			    DDI_DMA_DONTWAIT : DDI_DMA_SLEEP;
13822 
13823 			SATADBG2(SATA_DBG_DMA_SETUP, spx->txlt_sata_hba_inst,
13824 			    "mis-aligned buffer: addr=0x%p, cnt=%lu",
13825 			    (void *)bp->b_un.b_addr, bp->b_bcount);
13826 
13827 			if (bp->b_flags & (B_PAGEIO|B_PHYS))
13828 				/*
13829 				 * CPU will need to access data in the buffer
13830 				 * (for copying) so map it.
13831 				 */
13832 				bp_mapin(bp);
13833 
13834 			ASSERT(spx->txlt_tmp_buf == NULL);
13835 
13836 			/* Buffer may be padded by ddi_dma_mem_alloc()! */
13837 			rval = ddi_dma_mem_alloc(
13838 			    spx->txlt_buf_dma_handle,
13839 			    bp->b_bcount,
13840 			    &sata_acc_attr,
13841 			    DDI_DMA_STREAMING,
13842 			    ddicallback, NULL,
13843 			    &spx->txlt_tmp_buf,
13844 			    &bufsz,
13845 			    &spx->txlt_tmp_buf_handle);
13846 
13847 			if (rval != DDI_SUCCESS) {
13848 				/* DMA mapping failed */
13849 				(void) ddi_dma_free_handle(
13850 				    &spx->txlt_buf_dma_handle);
13851 				spx->txlt_buf_dma_handle = NULL;
13852 #ifdef SATA_DEBUG
13853 				mbuffail_count++;
13854 #endif
13855 				SATADBG1(SATA_DBG_DMA_SETUP,
13856 				    spx->txlt_sata_hba_inst,
13857 				    "sata_dma_buf_setup: "
13858 				    "buf dma mem alloc failed %x\n", rval);
13859 				return (rval);
13860 			}
13861 			ASSERT(IS_P2ALIGNED(spx->txlt_tmp_buf,
13862 			    cur_dma_attr->dma_attr_align));
13863 
13864 #ifdef SATA_DEBUG
13865 			mbuf_count++;
13866 
13867 			if (bp->b_bcount != bufsz)
13868 				/*
13869 				 * This will require special handling, because
13870 				 * DMA cookies will be based on the temporary
13871 				 * buffer size, not the original buffer
13872 				 * b_bcount, so the residue may have to
13873 				 * be counted differently.
13874 				 */
13875 				SATADBG2(SATA_DBG_DMA_SETUP,
13876 				    spx->txlt_sata_hba_inst,
13877 				    "sata_dma_buf_setup: bp size %x != "
13878 				    "bufsz %x\n", bp->b_bcount, bufsz);
13879 #endif
13880 			if (dma_flags & DDI_DMA_WRITE) {
13881 				/*
13882 				 * Write operation - copy data into
13883 				 * an aligned temporary buffer. Buffer will be
13884 				 * synced for device by ddi_dma_addr_bind_handle
13885 				 */
13886 				bcopy(bp->b_un.b_addr, spx->txlt_tmp_buf,
13887 				    bp->b_bcount);
13888 			}
13889 
13890 			rval = ddi_dma_addr_bind_handle(
13891 			    spx->txlt_buf_dma_handle,
13892 			    NULL,
13893 			    spx->txlt_tmp_buf,
13894 			    bufsz, dma_flags, ddicallback, 0,
13895 			    &spx->txlt_dma_cookie,
13896 			    &spx->txlt_curwin_num_dma_cookies);
13897 		}
13898 
13899 		switch (rval) {
13900 		case DDI_DMA_PARTIAL_MAP:
13901 			SATADBG1(SATA_DBG_DMA_SETUP, spx->txlt_sata_hba_inst,
13902 			    "sata_dma_buf_setup: DMA Partial Map\n", NULL);
13903 			/*
13904 			 * Partial DMA mapping.
13905 			 * Retrieve number of DMA windows for this request.
13906 			 */
13907 			if (ddi_dma_numwin(spx->txlt_buf_dma_handle,
13908 			    &spx->txlt_num_dma_win) != DDI_SUCCESS) {
13909 				if (spx->txlt_tmp_buf != NULL) {
13910 					ddi_dma_mem_free(
13911 					    &spx->txlt_tmp_buf_handle);
13912 					spx->txlt_tmp_buf = NULL;
13913 				}
13914 				(void) ddi_dma_unbind_handle(
13915 				    spx->txlt_buf_dma_handle);
13916 				(void) ddi_dma_free_handle(
13917 				    &spx->txlt_buf_dma_handle);
13918 				spx->txlt_buf_dma_handle = NULL;
13919 				SATA_LOG_D((spx->txlt_sata_hba_inst, CE_WARN,
13920 				    "sata_dma_buf_setup: numwin failed\n"));
13921 				return (DDI_FAILURE);
13922 			}
13923 			SATADBG2(SATA_DBG_DMA_SETUP,
13924 			    spx->txlt_sata_hba_inst,
13925 			    "sata_dma_buf_setup: windows: %d, cookies: %d\n",
13926 			    spx->txlt_num_dma_win,
13927 			    spx->txlt_curwin_num_dma_cookies);
13928 			spx->txlt_cur_dma_win = 0;
13929 			break;
13930 
13931 		case DDI_DMA_MAPPED:
13932 			/* DMA fully mapped */
13933 			spx->txlt_num_dma_win = 1;
13934 			spx->txlt_cur_dma_win = 0;
13935 			SATADBG1(SATA_DBG_DMA_SETUP,
13936 			    spx->txlt_sata_hba_inst,
13937 			    "sata_dma_buf_setup: windows: 1 "
13938 			    "cookies: %d\n", spx->txlt_curwin_num_dma_cookies);
13939 			break;
13940 
13941 		default:
13942 			/* DMA mapping failed */
13943 			if (spx->txlt_tmp_buf != NULL) {
13944 				ddi_dma_mem_free(
13945 				    &spx->txlt_tmp_buf_handle);
13946 				spx->txlt_tmp_buf = NULL;
13947 			}
13948 			(void) ddi_dma_free_handle(&spx->txlt_buf_dma_handle);
13949 			spx->txlt_buf_dma_handle = NULL;
13950 			SATA_LOG_D((spx->txlt_sata_hba_inst, CE_WARN,
13951 			    "sata_dma_buf_setup: buf dma handle binding "
13952 			    "failed %x\n", rval));
13953 			return (rval);
13954 		}
13955 		spx->txlt_curwin_processed_dma_cookies = 0;
13956 		spx->txlt_dma_cookie_list = NULL;
13957 	} else {
13958 		/*
13959 		 * DMA setup is reused. Check if we need to process more
13960 		 * cookies in current window, or to get next window, if any.
13961 		 */
13962 
13963 		ASSERT(spx->txlt_curwin_processed_dma_cookies <=
13964 		    spx->txlt_curwin_num_dma_cookies);
13965 
13966 		if (spx->txlt_curwin_processed_dma_cookies ==
13967 		    spx->txlt_curwin_num_dma_cookies) {
13968 			/*
13969 			 * All cookies from current DMA window were processed.
13970 			 * Get next DMA window.
13971 			 */
13972 			spx->txlt_cur_dma_win++;
13973 			if (spx->txlt_cur_dma_win < spx->txlt_num_dma_win) {
13974 				(void) ddi_dma_getwin(spx->txlt_buf_dma_handle,
13975 				    spx->txlt_cur_dma_win, &offset, &size,
13976 				    &spx->txlt_dma_cookie,
13977 				    &spx->txlt_curwin_num_dma_cookies);
13978 				spx->txlt_curwin_processed_dma_cookies = 0;
13979 			} else {
13980 				/* No more windows! End of request! */
13981 				/* What to do? - panic for now */
13982 				ASSERT(spx->txlt_cur_dma_win >=
13983 				    spx->txlt_num_dma_win);
13984 
13985 				spx->txlt_curwin_num_dma_cookies = 0;
13986 				spx->txlt_curwin_processed_dma_cookies = 0;
13987 				spx->txlt_sata_pkt->
13988 				    satapkt_cmd.satacmd_num_dma_cookies = 0;
13989 				return (DDI_SUCCESS);
13990 			}
13991 		}
13992 	}
13993 	/* There better be at least one DMA cookie outstanding */
13994 	ASSERT((spx->txlt_curwin_num_dma_cookies -
13995 	    spx->txlt_curwin_processed_dma_cookies) > 0);
13996 
13997 	if (spx->txlt_dma_cookie_list == &spx->txlt_dma_cookie) {
13998 		/* The default cookie slot was used in previous run */
13999 		ASSERT(spx->txlt_curwin_processed_dma_cookies == 0);
14000 		spx->txlt_dma_cookie_list = NULL;
14001 		spx->txlt_dma_cookie_list_len = 0;
14002 	}
14003 	if (spx->txlt_curwin_processed_dma_cookies == 0) {
14004 		/*
14005 		 * Processing a new DMA window - set-up dma cookies list.
14006 		 * We may reuse previously allocated cookie array if it is
14007 		 * possible.
14008 		 */
14009 		if (spx->txlt_dma_cookie_list != NULL &&
14010 		    spx->txlt_dma_cookie_list_len <
14011 		    spx->txlt_curwin_num_dma_cookies) {
14012 			/*
14013 			 * New DMA window contains more cookies than
14014 			 * the previous one. We need larger cookie list - free
14015 			 * the old one.
14016 			 */
14017 			(void) kmem_free(spx->txlt_dma_cookie_list,
14018 			    spx->txlt_dma_cookie_list_len *
14019 			    sizeof (ddi_dma_cookie_t));
14020 			spx->txlt_dma_cookie_list = NULL;
14021 			spx->txlt_dma_cookie_list_len = 0;
14022 		}
14023 		if (spx->txlt_dma_cookie_list == NULL) {
14024 			/*
14025 			 * Calculate lesser of number of cookies in this
14026 			 * DMA window and number of s/g entries.
14027 			 */
14028 			max_sg_len = cur_dma_attr->dma_attr_sgllen;
14029 			req_len = MIN(max_sg_len,
14030 			    spx->txlt_curwin_num_dma_cookies);
14031 
14032 			/* Allocate new dma cookie array if necessary */
14033 			if (req_len == 1) {
14034 				/* Only one cookie - no need for a list */
14035 				spx->txlt_dma_cookie_list =
14036 				    &spx->txlt_dma_cookie;
14037 				spx->txlt_dma_cookie_list_len = 1;
14038 			} else {
14039 				/*
14040 				 * More than one cookie - try to allocate space.
14041 				 */
14042 				spx->txlt_dma_cookie_list = kmem_zalloc(
14043 				    sizeof (ddi_dma_cookie_t) * req_len,
14044 				    callback == NULL_FUNC ? KM_NOSLEEP :
14045 				    KM_SLEEP);
14046 				if (spx->txlt_dma_cookie_list == NULL) {
14047 					SATADBG1(SATA_DBG_DMA_SETUP,
14048 					    spx->txlt_sata_hba_inst,
14049 					    "sata_dma_buf_setup: cookie list "
14050 					    "allocation failed\n", NULL);
14051 					/*
14052 					 * We could not allocate space for
14053 					 * neccessary number of dma cookies in
14054 					 * this window, so we fail this request.
14055 					 * Next invocation would try again to
14056 					 * allocate space for cookie list.
14057 					 * Note:Packet residue was not modified.
14058 					 */
14059 					return (DDI_DMA_NORESOURCES);
14060 				} else {
14061 					spx->txlt_dma_cookie_list_len = req_len;
14062 				}
14063 			}
14064 		}
14065 		/*
14066 		 * Fetch DMA cookies into cookie list in sata_pkt_txlate.
14067 		 * First cookie was already fetched.
14068 		 */
14069 		*(&spx->txlt_dma_cookie_list[0]) = spx->txlt_dma_cookie;
14070 		cur_txfer_len =
14071 		    (uint64_t)spx->txlt_dma_cookie_list[0].dmac_size;
14072 		spx->txlt_sata_pkt->satapkt_cmd.satacmd_num_dma_cookies = 1;
14073 		spx->txlt_curwin_processed_dma_cookies++;
14074 		for (i = 1; (i < spx->txlt_dma_cookie_list_len) &&
14075 		    (i < spx->txlt_curwin_num_dma_cookies); i++) {
14076 			ddi_dma_nextcookie(spx->txlt_buf_dma_handle,
14077 			    &spx->txlt_dma_cookie_list[i]);
14078 			cur_txfer_len +=
14079 			    (uint64_t)spx->txlt_dma_cookie_list[i].dmac_size;
14080 			spx->txlt_curwin_processed_dma_cookies++;
14081 			spx->txlt_sata_pkt->
14082 			    satapkt_cmd.satacmd_num_dma_cookies += 1;
14083 		}
14084 	} else {
14085 		SATADBG2(SATA_DBG_DMA_SETUP, spx->txlt_sata_hba_inst,
14086 		    "sata_dma_buf_setup: sliding within DMA window, "
14087 		    "cur cookie %d, total cookies %d\n",
14088 		    spx->txlt_curwin_processed_dma_cookies,
14089 		    spx->txlt_curwin_num_dma_cookies);
14090 
14091 		/*
14092 		 * Not all cookies from the current dma window were used because
14093 		 * of s/g limitation.
14094 		 * There is no need to re-size the list - it was set at
14095 		 * optimal size, or only default entry is used (s/g = 1).
14096 		 */
14097 		if (spx->txlt_dma_cookie_list == NULL) {
14098 			spx->txlt_dma_cookie_list = &spx->txlt_dma_cookie;
14099 			spx->txlt_dma_cookie_list_len = 1;
14100 		}
14101 		/*
14102 		 * Since we are processing remaining cookies in a DMA window,
14103 		 * there may be less of them than the number of entries in the
14104 		 * current dma cookie list.
14105 		 */
14106 		req_len = MIN(spx->txlt_dma_cookie_list_len,
14107 		    (spx->txlt_curwin_num_dma_cookies -
14108 		    spx->txlt_curwin_processed_dma_cookies));
14109 
14110 		/* Fetch the next batch of cookies */
14111 		for (i = 0, cur_txfer_len = 0; i < req_len; i++) {
14112 			ddi_dma_nextcookie(spx->txlt_buf_dma_handle,
14113 			    &spx->txlt_dma_cookie_list[i]);
14114 			cur_txfer_len +=
14115 			    (uint64_t)spx->txlt_dma_cookie_list[i].dmac_size;
14116 			spx->txlt_sata_pkt->
14117 			    satapkt_cmd.satacmd_num_dma_cookies++;
14118 			spx->txlt_curwin_processed_dma_cookies++;
14119 		}
14120 	}
14121 
14122 	ASSERT(spx->txlt_sata_pkt->satapkt_cmd.satacmd_num_dma_cookies > 0);
14123 
14124 	/* Point sata_cmd to the cookie list */
14125 	spx->txlt_sata_pkt->satapkt_cmd.satacmd_dma_cookie_list =
14126 	    &spx->txlt_dma_cookie_list[0];
14127 
14128 	/* Remember number of DMA cookies passed in sata packet */
14129 	spx->txlt_num_dma_cookies =
14130 	    spx->txlt_sata_pkt->satapkt_cmd.satacmd_num_dma_cookies;
14131 
14132 	ASSERT(cur_txfer_len != 0);
14133 	if (cur_txfer_len <= bp->b_bcount)
14134 		spx->txlt_total_residue -= cur_txfer_len;
14135 	else {
14136 		/*
14137 		 * Temporary DMA buffer has been padded by
14138 		 * ddi_dma_mem_alloc()!
14139 		 * This requires special handling, because DMA cookies are
14140 		 * based on the temporary buffer size, not the b_bcount,
14141 		 * and we have extra bytes to transfer - but the packet
14142 		 * residue has to stay correct because we will copy only
14143 		 * the requested number of bytes.
14144 		 */
14145 		spx->txlt_total_residue -= bp->b_bcount;
14146 	}
14147 
14148 	return (DDI_SUCCESS);
14149 }
14150 
14151 /*
14152  * Common routine for releasing DMA resources
14153  */
14154 static void
14155 sata_common_free_dma_rsrcs(sata_pkt_txlate_t *spx)
14156 {
14157 	if (spx->txlt_buf_dma_handle != NULL) {
14158 		if (spx->txlt_tmp_buf != NULL)  {
14159 			/*
14160 			 * Intermediate DMA buffer was allocated.
14161 			 * Free allocated buffer and associated access handle.
14162 			 */
14163 			ddi_dma_mem_free(&spx->txlt_tmp_buf_handle);
14164 			spx->txlt_tmp_buf = NULL;
14165 		}
14166 		/*
14167 		 * Free DMA resources - cookies and handles
14168 		 */
14169 		/* ASSERT(spx->txlt_dma_cookie_list != NULL); */
14170 		if (spx->txlt_dma_cookie_list != NULL) {
14171 			if (spx->txlt_dma_cookie_list !=
14172 			    &spx->txlt_dma_cookie) {
14173 				(void) kmem_free(spx->txlt_dma_cookie_list,
14174 				    spx->txlt_dma_cookie_list_len *
14175 				    sizeof (ddi_dma_cookie_t));
14176 				spx->txlt_dma_cookie_list = NULL;
14177 			}
14178 		}
14179 		(void) ddi_dma_unbind_handle(spx->txlt_buf_dma_handle);
14180 		(void) ddi_dma_free_handle(&spx->txlt_buf_dma_handle);
14181 		spx->txlt_buf_dma_handle = NULL;
14182 	}
14183 }
14184 
14185 /*
14186  * Free DMA resources
14187  * Used by the HBA driver to release DMA resources that it does not use.
14188  *
14189  * Returns Void
14190  */
14191 void
14192 sata_free_dma_resources(sata_pkt_t *sata_pkt)
14193 {
14194 	sata_pkt_txlate_t *spx;
14195 
14196 	if (sata_pkt == NULL)
14197 		return;
14198 
14199 	spx = (sata_pkt_txlate_t *)sata_pkt->satapkt_framework_private;
14200 
14201 	sata_common_free_dma_rsrcs(spx);
14202 }
14203 
14204 /*
14205  * Fetch Device Identify data.
14206  * Send DEVICE IDENTIFY or IDENTIFY PACKET DEVICE (depending on a device type)
14207  * command to a device and get the device identify data.
14208  * The device_info structure has to be set to device type (for selecting proper
14209  * device identify command).
14210  *
14211  * Returns:
14212  * SATA_SUCCESS if cmd succeeded
14213  * SATA_RETRY if cmd was rejected and could be retried,
14214  * SATA_FAILURE if cmd failed and should not be retried (port error)
14215  *
14216  * Cannot be called in an interrupt context.
14217  */
14218 
14219 static int
14220 sata_fetch_device_identify_data(sata_hba_inst_t *sata_hba_inst,
14221     sata_drive_info_t *sdinfo)
14222 {
14223 	struct buf *bp;
14224 	sata_pkt_t *spkt;
14225 	sata_cmd_t *scmd;
14226 	sata_pkt_txlate_t *spx;
14227 	int rval;
14228 	dev_info_t *dip = SATA_DIP(sata_hba_inst);
14229 
14230 	spx = kmem_zalloc(sizeof (sata_pkt_txlate_t), KM_SLEEP);
14231 	spx->txlt_sata_hba_inst = sata_hba_inst;
14232 	spx->txlt_scsi_pkt = NULL;		/* No scsi pkt involved */
14233 	spkt = sata_pkt_alloc(spx, SLEEP_FUNC);
14234 	if (spkt == NULL) {
14235 		kmem_free(spx, sizeof (sata_pkt_txlate_t));
14236 		return (SATA_RETRY); /* may retry later */
14237 	}
14238 	/* address is needed now */
14239 	spkt->satapkt_device.satadev_addr = sdinfo->satadrv_addr;
14240 
14241 	/*
14242 	 * Allocate buffer for Identify Data return data
14243 	 */
14244 	bp = sata_alloc_local_buffer(spx, sizeof (sata_id_t));
14245 	if (bp == NULL) {
14246 		sata_pkt_free(spx);
14247 		kmem_free(spx, sizeof (sata_pkt_txlate_t));
14248 		SATA_LOG_D((sata_hba_inst, CE_WARN,
14249 		    "sata_fetch_device_identify_data: "
14250 		    "cannot allocate buffer for ID"));
14251 		return (SATA_RETRY); /* may retry later */
14252 	}
14253 
14254 	/* Fill sata_pkt */
14255 	sdinfo->satadrv_state = SATA_STATE_PROBING;
14256 	spkt->satapkt_device.satadev_addr = sdinfo->satadrv_addr;
14257 	spkt->satapkt_op_mode = SATA_OPMODE_SYNCH | SATA_OPMODE_INTERRUPTS;
14258 	/* Synchronous mode, no callback */
14259 	spkt->satapkt_comp = NULL;
14260 	/* Timeout 30s */
14261 	spkt->satapkt_time = sata_default_pkt_time;
14262 
14263 	scmd = &spkt->satapkt_cmd;
14264 	scmd->satacmd_bp = bp;
14265 	scmd->satacmd_flags.sata_data_direction = SATA_DIR_READ;
14266 	scmd->satacmd_flags.sata_ignore_dev_reset = B_TRUE;
14267 
14268 	/* Build Identify Device cmd in the sata_pkt */
14269 	scmd->satacmd_addr_type = 0;		/* N/A */
14270 	scmd->satacmd_sec_count_lsb = 0;	/* N/A */
14271 	scmd->satacmd_lba_low_lsb = 0;		/* N/A */
14272 	scmd->satacmd_lba_mid_lsb = 0;		/* N/A */
14273 	scmd->satacmd_lba_high_lsb = 0;		/* N/A */
14274 	scmd->satacmd_features_reg = 0;		/* N/A */
14275 	scmd->satacmd_device_reg = 0;		/* Always device 0 */
14276 	if (sdinfo->satadrv_type & SATA_DTYPE_ATAPI) {
14277 		/* Identify Packet Device cmd */
14278 		scmd->satacmd_cmd_reg = SATAC_ID_PACKET_DEVICE;
14279 	} else {
14280 		/* Identify Device cmd - mandatory for all other devices */
14281 		scmd->satacmd_cmd_reg = SATAC_ID_DEVICE;
14282 	}
14283 
14284 	/* Send pkt to SATA HBA driver */
14285 	rval = (*SATA_START_FUNC(sata_hba_inst))(SATA_DIP(sata_hba_inst), spkt);
14286 
14287 #ifdef SATA_INJECT_FAULTS
14288 	sata_inject_pkt_fault(spkt, &rval, sata_fault_type);
14289 #endif
14290 
14291 	if (rval == SATA_TRAN_ACCEPTED &&
14292 	    spkt->satapkt_reason == SATA_PKT_COMPLETED) {
14293 		if (spx->txlt_buf_dma_handle != NULL) {
14294 			rval = ddi_dma_sync(spx->txlt_buf_dma_handle, 0, 0,
14295 			    DDI_DMA_SYNC_FORKERNEL);
14296 			ASSERT(rval == DDI_SUCCESS);
14297 			if (sata_check_for_dma_error(dip, spx)) {
14298 				ddi_fm_service_impact(dip,
14299 				    DDI_SERVICE_UNAFFECTED);
14300 				rval = SATA_RETRY;
14301 				goto fail;
14302 			}
14303 
14304 		}
14305 		if ((((sata_id_t *)(bp->b_un.b_addr))->ai_config &
14306 		    SATA_INCOMPLETE_DATA) == SATA_INCOMPLETE_DATA) {
14307 			SATA_LOG_D((sata_hba_inst, CE_WARN,
14308 			    "SATA disk device at port %d - "
14309 			    "partial Identify Data",
14310 			    sdinfo->satadrv_addr.cport));
14311 			rval = SATA_RETRY; /* may retry later */
14312 			goto fail;
14313 		}
14314 		/* Update sata_drive_info */
14315 		bcopy(bp->b_un.b_addr, &sdinfo->satadrv_id,
14316 		    sizeof (sata_id_t));
14317 
14318 		sdinfo->satadrv_features_support = 0;
14319 		if (sdinfo->satadrv_type == SATA_DTYPE_ATADISK) {
14320 			/*
14321 			 * Retrieve capacity (disks only) and addressing mode
14322 			 */
14323 			sdinfo->satadrv_capacity = sata_check_capacity(sdinfo);
14324 		} else {
14325 			/*
14326 			 * For ATAPI devices one would have to issue
14327 			 * Get Capacity cmd for media capacity. Not here.
14328 			 */
14329 			sdinfo->satadrv_capacity = 0;
14330 			/*
14331 			 * Check what cdb length is supported
14332 			 */
14333 			if ((sdinfo->satadrv_id.ai_config &
14334 			    SATA_ATAPI_ID_PKT_SZ) == SATA_ATAPI_ID_PKT_16B)
14335 				sdinfo->satadrv_atapi_cdb_len = 16;
14336 			else
14337 				sdinfo->satadrv_atapi_cdb_len = 12;
14338 		}
14339 		/* Setup supported features flags */
14340 		if (sdinfo->satadrv_id.ai_cap & SATA_DMA_SUPPORT)
14341 			sdinfo->satadrv_features_support |= SATA_DEV_F_DMA;
14342 
14343 		/* Check for SATA GEN and NCQ support */
14344 		if (sdinfo->satadrv_id.ai_satacap != 0 &&
14345 		    sdinfo->satadrv_id.ai_satacap != 0xffff) {
14346 			/* SATA compliance */
14347 			if (sdinfo->satadrv_id.ai_satacap & SATA_NCQ)
14348 				sdinfo->satadrv_features_support |=
14349 				    SATA_DEV_F_NCQ;
14350 			if (sdinfo->satadrv_id.ai_satacap &
14351 			    (SATA_1_SPEED | SATA_2_SPEED | SATA_3_SPEED)) {
14352 				if (sdinfo->satadrv_id.ai_satacap &
14353 				    SATA_3_SPEED)
14354 					sdinfo->satadrv_features_support |=
14355 					    SATA_DEV_F_SATA3;
14356 				if (sdinfo->satadrv_id.ai_satacap &
14357 				    SATA_2_SPEED)
14358 					sdinfo->satadrv_features_support |=
14359 					    SATA_DEV_F_SATA2;
14360 				if (sdinfo->satadrv_id.ai_satacap &
14361 				    SATA_1_SPEED)
14362 					sdinfo->satadrv_features_support |=
14363 					    SATA_DEV_F_SATA1;
14364 			} else {
14365 				sdinfo->satadrv_features_support |=
14366 				    SATA_DEV_F_SATA1;
14367 			}
14368 		}
14369 		if ((sdinfo->satadrv_id.ai_cmdset83 & SATA_RW_DMA_QUEUED_CMD) &&
14370 		    (sdinfo->satadrv_id.ai_features86 & SATA_RW_DMA_QUEUED_CMD))
14371 			sdinfo->satadrv_features_support |= SATA_DEV_F_TCQ;
14372 
14373 		sdinfo->satadrv_queue_depth = sdinfo->satadrv_id.ai_qdepth;
14374 		if ((sdinfo->satadrv_features_support & SATA_DEV_F_NCQ) ||
14375 		    (sdinfo->satadrv_features_support & SATA_DEV_F_TCQ)) {
14376 			++sdinfo->satadrv_queue_depth;
14377 			/* Adjust according to controller capabilities */
14378 			sdinfo->satadrv_max_queue_depth = MIN(
14379 			    sdinfo->satadrv_queue_depth,
14380 			    SATA_QDEPTH(sata_hba_inst));
14381 			/* Adjust according to global queue depth limit */
14382 			sdinfo->satadrv_max_queue_depth = MIN(
14383 			    sdinfo->satadrv_max_queue_depth,
14384 			    sata_current_max_qdepth);
14385 			if (sdinfo->satadrv_max_queue_depth == 0)
14386 				sdinfo->satadrv_max_queue_depth = 1;
14387 		} else
14388 			sdinfo->satadrv_max_queue_depth = 1;
14389 
14390 		rval = SATA_SUCCESS;
14391 	} else {
14392 		/*
14393 		 * Woops, no Identify Data.
14394 		 */
14395 		if (rval == SATA_TRAN_BUSY || rval == SATA_TRAN_QUEUE_FULL) {
14396 			rval = SATA_RETRY; /* may retry later */
14397 		} else if (rval == SATA_TRAN_ACCEPTED) {
14398 			if (spkt->satapkt_reason == SATA_PKT_DEV_ERROR ||
14399 			    spkt->satapkt_reason == SATA_PKT_ABORTED ||
14400 			    spkt->satapkt_reason == SATA_PKT_TIMEOUT ||
14401 			    spkt->satapkt_reason == SATA_PKT_RESET)
14402 				rval = SATA_RETRY; /* may retry later */
14403 			else
14404 				rval = SATA_FAILURE;
14405 		} else {
14406 			rval = SATA_FAILURE;
14407 		}
14408 	}
14409 fail:
14410 	/* Free allocated resources */
14411 	sata_free_local_buffer(spx);
14412 	sata_pkt_free(spx);
14413 	kmem_free(spx, sizeof (sata_pkt_txlate_t));
14414 
14415 	return (rval);
14416 }
14417 
14418 
14419 /*
14420  * Some devices may not come-up with default DMA mode (UDMA or MWDMA).
14421  * UDMA mode is checked first, followed by MWDMA mode.
14422  * set correctly, so this function is setting it to the highest supported level.
14423  * Older SATA spec required that the device supports at least DMA 4 mode and
14424  * UDMA mode is selected.  It is not mentioned in SerialATA 2.6, so this
14425  * restriction has been removed.
14426  *
14427  * Returns SATA_SUCCESS if proper DMA mode is selected or no DMA is supported.
14428  * Returns SATA_FAILURE if proper DMA mode could not be selected.
14429  *
14430  * NOTE: This function should be called only if DMA mode is supported.
14431  */
14432 static int
14433 sata_set_dma_mode(sata_hba_inst_t *sata_hba_inst, sata_drive_info_t *sdinfo)
14434 {
14435 	sata_pkt_t *spkt;
14436 	sata_cmd_t *scmd;
14437 	sata_pkt_txlate_t *spx;
14438 	int i, mode;
14439 	uint8_t subcmd;
14440 	int rval = SATA_SUCCESS;
14441 
14442 	ASSERT(sdinfo != NULL);
14443 	ASSERT(sata_hba_inst != NULL);
14444 
14445 	if ((sdinfo->satadrv_id.ai_validinfo & SATA_VALIDINFO_88) != 0 &&
14446 	    (sdinfo->satadrv_id.ai_ultradma & SATA_UDMA_SUP_MASK) != 0) {
14447 		/* Find highest Ultra DMA mode supported */
14448 		for (mode = 6; mode >= 0; --mode) {
14449 			if (sdinfo->satadrv_id.ai_ultradma & (1 << mode))
14450 				break;
14451 		}
14452 #if 0
14453 		/* Left for historical reasons */
14454 		/*
14455 		 * Some initial version of SATA spec indicated that at least
14456 		 * UDMA mode 4 has to be supported. It is not mentioned in
14457 		 * SerialATA 2.6, so this restriction is removed.
14458 		 */
14459 		if (mode < 4)
14460 			return (SATA_FAILURE);
14461 #endif
14462 
14463 		/*
14464 		 * For disk, we're still going to set DMA mode whatever is
14465 		 * selected by default
14466 		 *
14467 		 * We saw an old maxtor sata drive will select Ultra DMA and
14468 		 * Multi-Word DMA simultaneouly by default, which is going
14469 		 * to cause DMA command timed out, so we need to select DMA
14470 		 * mode even when it's already done by default
14471 		 */
14472 		if (sdinfo->satadrv_type != SATA_DTYPE_ATADISK) {
14473 
14474 			/* Find UDMA mode currently selected */
14475 			for (i = 6; i >= 0; --i) {
14476 				if (sdinfo->satadrv_id.ai_ultradma &
14477 				    (1 << (i + 8)))
14478 					break;
14479 			}
14480 			if (i >= mode)
14481 				/* Nothing to do */
14482 				return (SATA_SUCCESS);
14483 		}
14484 
14485 		subcmd = SATAC_TRANSFER_MODE_ULTRA_DMA;
14486 
14487 	} else if ((sdinfo->satadrv_id.ai_dworddma & SATA_MDMA_SUP_MASK) != 0) {
14488 		/* Find highest MultiWord DMA mode supported */
14489 		for (mode = 2; mode >= 0; --mode) {
14490 			if (sdinfo->satadrv_id.ai_dworddma & (1 << mode))
14491 				break;
14492 		}
14493 
14494 		/*
14495 		 * For disk, We're still going to set DMA mode whatever is
14496 		 * selected by default
14497 		 *
14498 		 * We saw an old maxtor sata drive will select Ultra DMA and
14499 		 * Multi-Word DMA simultaneouly by default, which is going
14500 		 * to cause DMA command timed out, so we need to select DMA
14501 		 * mode even when it's already done by default
14502 		 */
14503 		if (sdinfo->satadrv_type != SATA_DTYPE_ATADISK) {
14504 
14505 			/* Find highest MultiWord DMA mode selected */
14506 			for (i = 2; i >= 0; --i) {
14507 				if (sdinfo->satadrv_id.ai_dworddma &
14508 				    (1 << (i + 8)))
14509 					break;
14510 			}
14511 			if (i >= mode)
14512 				/* Nothing to do */
14513 				return (SATA_SUCCESS);
14514 		}
14515 
14516 		subcmd = SATAC_TRANSFER_MODE_MULTI_WORD_DMA;
14517 	} else
14518 		return (SATA_SUCCESS);
14519 
14520 	/*
14521 	 * Set DMA mode via SET FEATURES COMMAND.
14522 	 * Prepare packet for SET FEATURES COMMAND.
14523 	 */
14524 	spx = kmem_zalloc(sizeof (sata_pkt_txlate_t), KM_SLEEP);
14525 	spx->txlt_sata_hba_inst = sata_hba_inst;
14526 	spx->txlt_scsi_pkt = NULL;	/* No scsi pkt involved */
14527 	spkt = sata_pkt_alloc(spx, SLEEP_FUNC);
14528 	if (spkt == NULL) {
14529 		SATA_LOG_D((sata_hba_inst, CE_WARN,
14530 		    "sata_set_dma_mode: could not set DMA mode %d", mode));
14531 		rval = SATA_FAILURE;
14532 		goto done;
14533 	}
14534 	/* Fill sata_pkt */
14535 	spkt->satapkt_device.satadev_addr = sdinfo->satadrv_addr;
14536 	/* Timeout 30s */
14537 	spkt->satapkt_time = sata_default_pkt_time;
14538 	/* Synchronous mode, no callback, interrupts */
14539 	spkt->satapkt_op_mode = SATA_OPMODE_SYNCH | SATA_OPMODE_INTERRUPTS;
14540 	spkt->satapkt_comp = NULL;
14541 	scmd = &spkt->satapkt_cmd;
14542 	scmd->satacmd_flags.sata_data_direction = SATA_DIR_NODATA_XFER;
14543 	scmd->satacmd_flags.sata_ignore_dev_reset = B_TRUE;
14544 	scmd->satacmd_addr_type = 0;
14545 	scmd->satacmd_device_reg = 0;
14546 	scmd->satacmd_status_reg = 0;
14547 	scmd->satacmd_error_reg = 0;
14548 	scmd->satacmd_cmd_reg = SATAC_SET_FEATURES;
14549 	scmd->satacmd_features_reg = SATAC_SF_TRANSFER_MODE;
14550 	scmd->satacmd_sec_count_lsb = subcmd | mode;
14551 
14552 	/* Transfer command to HBA */
14553 	if ((*SATA_START_FUNC(sata_hba_inst))(SATA_DIP(sata_hba_inst),
14554 	    spkt) != SATA_TRAN_ACCEPTED ||
14555 	    spkt->satapkt_reason != SATA_PKT_COMPLETED) {
14556 		/* Pkt execution failed */
14557 		rval = SATA_FAILURE;
14558 	}
14559 done:
14560 
14561 	/* Free allocated resources */
14562 	if (spkt != NULL)
14563 		sata_pkt_free(spx);
14564 	(void) kmem_free(spx, sizeof (sata_pkt_txlate_t));
14565 
14566 	return (rval);
14567 }
14568 
14569 
14570 /*
14571  * Set device caching mode.
14572  * One of the following operations should be specified:
14573  * SATAC_SF_ENABLE_READ_AHEAD
14574  * SATAC_SF_DISABLE_READ_AHEAD
14575  * SATAC_SF_ENABLE_WRITE_CACHE
14576  * SATAC_SF_DISABLE_WRITE_CACHE
14577  *
14578  * If operation fails, system log messgage is emitted.
14579  * Returns SATA_SUCCESS when the operation succeeds, SATA_RETRY if
14580  * command was sent but did not succeed, and SATA_FAILURE otherwise.
14581  */
14582 
14583 static int
14584 sata_set_cache_mode(sata_hba_inst_t *sata_hba_inst, sata_drive_info_t *sdinfo,
14585     int cache_op)
14586 {
14587 	sata_pkt_t *spkt;
14588 	sata_cmd_t *scmd;
14589 	sata_pkt_txlate_t *spx;
14590 	int rval = SATA_SUCCESS;
14591 	int hba_rval;
14592 	char *infop = NULL;
14593 
14594 	ASSERT(sdinfo != NULL);
14595 	ASSERT(sata_hba_inst != NULL);
14596 	ASSERT(cache_op == SATAC_SF_ENABLE_READ_AHEAD ||
14597 	    cache_op == SATAC_SF_DISABLE_READ_AHEAD ||
14598 	    cache_op == SATAC_SF_ENABLE_WRITE_CACHE ||
14599 	    cache_op == SATAC_SF_DISABLE_WRITE_CACHE);
14600 
14601 
14602 	/* Prepare packet for SET FEATURES COMMAND */
14603 	spx = kmem_zalloc(sizeof (sata_pkt_txlate_t), KM_SLEEP);
14604 	spx->txlt_sata_hba_inst = sata_hba_inst;
14605 	spx->txlt_scsi_pkt = NULL;	/* No scsi pkt involved */
14606 	spkt = sata_pkt_alloc(spx, SLEEP_FUNC);
14607 	if (spkt == NULL) {
14608 		rval = SATA_FAILURE;
14609 		goto failure;
14610 	}
14611 	/* Fill sata_pkt */
14612 	spkt->satapkt_device.satadev_addr = sdinfo->satadrv_addr;
14613 	/* Timeout 30s */
14614 	spkt->satapkt_time = sata_default_pkt_time;
14615 	/* Synchronous mode, no callback, interrupts */
14616 	spkt->satapkt_op_mode =
14617 	    SATA_OPMODE_SYNCH | SATA_OPMODE_INTERRUPTS;
14618 	spkt->satapkt_comp = NULL;
14619 	scmd = &spkt->satapkt_cmd;
14620 	scmd->satacmd_flags.sata_data_direction = SATA_DIR_NODATA_XFER;
14621 	scmd->satacmd_flags.sata_ignore_dev_reset = B_TRUE;
14622 	scmd->satacmd_addr_type = 0;
14623 	scmd->satacmd_device_reg = 0;
14624 	scmd->satacmd_status_reg = 0;
14625 	scmd->satacmd_error_reg = 0;
14626 	scmd->satacmd_cmd_reg = SATAC_SET_FEATURES;
14627 	scmd->satacmd_features_reg = cache_op;
14628 
14629 	/* Transfer command to HBA */
14630 	hba_rval = (*SATA_START_FUNC(sata_hba_inst))(
14631 	    SATA_DIP(sata_hba_inst), spkt);
14632 
14633 #ifdef SATA_INJECT_FAULTS
14634 	sata_inject_pkt_fault(spkt, &rval, sata_fault_type);
14635 #endif
14636 
14637 	if ((hba_rval != SATA_TRAN_ACCEPTED) ||
14638 	    (spkt->satapkt_reason != SATA_PKT_COMPLETED)) {
14639 		/* Pkt execution failed */
14640 		switch (cache_op) {
14641 		case SATAC_SF_ENABLE_READ_AHEAD:
14642 			infop = "enabling read ahead failed";
14643 			break;
14644 		case SATAC_SF_DISABLE_READ_AHEAD:
14645 			infop = "disabling read ahead failed";
14646 			break;
14647 		case SATAC_SF_ENABLE_WRITE_CACHE:
14648 			infop = "enabling write cache failed";
14649 			break;
14650 		case SATAC_SF_DISABLE_WRITE_CACHE:
14651 			infop = "disabling write cache failed";
14652 			break;
14653 		}
14654 		SATA_LOG_D((sata_hba_inst, CE_WARN, "%s", infop));
14655 		rval = SATA_RETRY;
14656 	}
14657 failure:
14658 	/* Free allocated resources */
14659 	if (spkt != NULL)
14660 		sata_pkt_free(spx);
14661 	(void) kmem_free(spx, sizeof (sata_pkt_txlate_t));
14662 	return (rval);
14663 }
14664 
14665 /*
14666  * Set Removable Media Status Notification (enable/disable)
14667  * state == 0 , disable
14668  * state != 0 , enable
14669  *
14670  * If operation fails, system log messgage is emitted.
14671  * Returns SATA_SUCCESS when the operation succeeds, SATA_FAILURE otherwise.
14672  */
14673 
14674 static int
14675 sata_set_rmsn(sata_hba_inst_t *sata_hba_inst, sata_drive_info_t *sdinfo,
14676     int state)
14677 {
14678 	sata_pkt_t *spkt;
14679 	sata_cmd_t *scmd;
14680 	sata_pkt_txlate_t *spx;
14681 	int rval = SATA_SUCCESS;
14682 	char *infop;
14683 
14684 	ASSERT(sdinfo != NULL);
14685 	ASSERT(sata_hba_inst != NULL);
14686 
14687 	/* Prepare packet for SET FEATURES COMMAND */
14688 	spx = kmem_zalloc(sizeof (sata_pkt_txlate_t), KM_SLEEP);
14689 	spx->txlt_sata_hba_inst = sata_hba_inst;
14690 	spx->txlt_scsi_pkt = NULL;	/* No scsi pkt involved */
14691 	spkt = sata_pkt_alloc(spx, SLEEP_FUNC);
14692 	if (spkt == NULL) {
14693 		rval = SATA_FAILURE;
14694 		goto failure;
14695 	}
14696 	/* Fill sata_pkt */
14697 	spkt->satapkt_device.satadev_addr = sdinfo->satadrv_addr;
14698 	/* Timeout 30s */
14699 	spkt->satapkt_time = sata_default_pkt_time;
14700 	/* Synchronous mode, no callback, interrupts */
14701 	spkt->satapkt_op_mode =
14702 	    SATA_OPMODE_SYNCH | SATA_OPMODE_INTERRUPTS;
14703 	spkt->satapkt_comp = NULL;
14704 	scmd = &spkt->satapkt_cmd;
14705 	scmd->satacmd_flags.sata_data_direction = SATA_DIR_NODATA_XFER;
14706 	scmd->satacmd_flags.sata_ignore_dev_reset = B_TRUE;
14707 	scmd->satacmd_addr_type = 0;
14708 	scmd->satacmd_device_reg = 0;
14709 	scmd->satacmd_status_reg = 0;
14710 	scmd->satacmd_error_reg = 0;
14711 	scmd->satacmd_cmd_reg = SATAC_SET_FEATURES;
14712 	if (state == 0)
14713 		scmd->satacmd_features_reg = SATAC_SF_DISABLE_RMSN;
14714 	else
14715 		scmd->satacmd_features_reg = SATAC_SF_ENABLE_RMSN;
14716 
14717 	/* Transfer command to HBA */
14718 	if (((*SATA_START_FUNC(sata_hba_inst))(
14719 	    SATA_DIP(sata_hba_inst), spkt) != SATA_TRAN_ACCEPTED) ||
14720 	    (spkt->satapkt_reason != SATA_PKT_COMPLETED)) {
14721 		/* Pkt execution failed */
14722 		if (state == 0)
14723 			infop = "disabling Removable Media Status "
14724 			    "Notification failed";
14725 		else
14726 			infop = "enabling Removable Media Status "
14727 			    "Notification failed";
14728 
14729 		SATA_LOG_D((sata_hba_inst, CE_WARN, "%s", infop));
14730 		rval = SATA_FAILURE;
14731 	}
14732 failure:
14733 	/* Free allocated resources */
14734 	if (spkt != NULL)
14735 		sata_pkt_free(spx);
14736 	(void) kmem_free(spx, sizeof (sata_pkt_txlate_t));
14737 	return (rval);
14738 }
14739 
14740 
14741 /*
14742  * Update state and copy port ss* values from passed sata_device structure.
14743  * sata_address is validated - if not valid, nothing is changed in sata_scsi
14744  * configuration struct.
14745  *
14746  * SATA_PSTATE_SHUTDOWN in port state is not reset to 0 by this function
14747  * regardless of the state in device argument.
14748  *
14749  * Port mutex should be held while calling this function.
14750  */
14751 static void
14752 sata_update_port_info(sata_hba_inst_t *sata_hba_inst,
14753     sata_device_t *sata_device)
14754 {
14755 	sata_cport_info_t *cportinfo;
14756 
14757 	if (sata_device->satadev_addr.qual == SATA_ADDR_CPORT ||
14758 	    sata_device->satadev_addr.qual == SATA_ADDR_DCPORT) {
14759 		if (SATA_NUM_CPORTS(sata_hba_inst) <=
14760 		    sata_device->satadev_addr.cport)
14761 			return;
14762 
14763 		cportinfo = SATA_CPORT_INFO(sata_hba_inst,
14764 		    sata_device->satadev_addr.cport);
14765 
14766 		ASSERT(mutex_owned(&cportinfo->cport_mutex));
14767 		cportinfo->cport_scr = sata_device->satadev_scr;
14768 
14769 		/* Preserve SATA_PSTATE_SHUTDOWN flag */
14770 		cportinfo->cport_state &= ~(SATA_PSTATE_PWRON |
14771 		    SATA_PSTATE_PWROFF | SATA_PSTATE_FAILED);
14772 		cportinfo->cport_state |=
14773 		    sata_device->satadev_state & SATA_PSTATE_VALID;
14774 	}
14775 }
14776 
14777 void
14778 sata_update_pmport_info(sata_hba_inst_t *sata_hba_inst,
14779     sata_device_t *sata_device)
14780 {
14781 	sata_pmport_info_t *pmportinfo;
14782 
14783 	if ((sata_device->satadev_addr.qual != SATA_ADDR_PMPORT &&
14784 	    sata_device->satadev_addr.qual != SATA_ADDR_DPMPORT) ||
14785 	    SATA_NUM_PMPORTS(sata_hba_inst,
14786 	    sata_device->satadev_addr.cport) <
14787 	    sata_device->satadev_addr.pmport) {
14788 		SATADBG1(SATA_DBG_PMULT, sata_hba_inst,
14789 		    "sata_update_port_info: error address %p.",
14790 		    &sata_device->satadev_addr);
14791 		return;
14792 	}
14793 
14794 	pmportinfo = SATA_PMPORT_INFO(sata_hba_inst,
14795 	    sata_device->satadev_addr.cport,
14796 	    sata_device->satadev_addr.pmport);
14797 
14798 	ASSERT(mutex_owned(&pmportinfo->pmport_mutex));
14799 	pmportinfo->pmport_scr = sata_device->satadev_scr;
14800 
14801 	/* Preserve SATA_PSTATE_SHUTDOWN flag */
14802 	pmportinfo->pmport_state &=
14803 	    ~(SATA_PSTATE_PWRON | SATA_PSTATE_PWROFF | SATA_PSTATE_FAILED);
14804 	pmportinfo->pmport_state |=
14805 	    sata_device->satadev_state & SATA_PSTATE_VALID;
14806 }
14807 
14808 /*
14809  * Extract SATA port specification from an IOCTL argument.
14810  *
14811  * This function return the port the user land send us as is, unless it
14812  * cannot retrieve port spec, then -1 is returned.
14813  *
14814  * Support port multiplier.
14815  */
14816 static int32_t
14817 sata_get_port_num(sata_hba_inst_t *sata_hba_inst, struct devctl_iocdata *dcp)
14818 {
14819 	int32_t port;
14820 
14821 	/* Extract port number from nvpair in dca structure  */
14822 	if (nvlist_lookup_int32(ndi_dc_get_ap_data(dcp), "port", &port) != 0) {
14823 		SATA_LOG_D((sata_hba_inst, CE_NOTE,
14824 		    "sata_get_port_num: invalid port spec 0x%x in ioctl",
14825 		    port));
14826 		port = -1;
14827 	}
14828 
14829 	return (port);
14830 }
14831 
14832 /*
14833  * Get dev_info_t pointer to the device node pointed to by port argument.
14834  * NOTE: target argument is a value used in ioctls to identify
14835  * the AP - it is not a sata_address.
14836  * It is a combination of cport, pmport and address qualifier, encodded same
14837  * way as a scsi target number.
14838  * At this moment it carries only cport number.
14839  *
14840  * PMult hotplug is supported now.
14841  *
14842  * Returns dev_info_t pointer if target device was found, NULL otherwise.
14843  */
14844 
14845 static dev_info_t *
14846 sata_get_target_dip(dev_info_t *dip, uint8_t cport, uint8_t pmport)
14847 {
14848 	dev_info_t	*cdip = NULL;
14849 	int		target, tgt;
14850 	uint8_t		qual;
14851 
14852 	sata_hba_inst_t	*sata_hba_inst;
14853 	scsi_hba_tran_t *scsi_hba_tran;
14854 
14855 	/* Get target id */
14856 	scsi_hba_tran = ddi_get_driver_private(dip);
14857 	if (scsi_hba_tran == NULL)
14858 		return (NULL);
14859 
14860 	sata_hba_inst = scsi_hba_tran->tran_hba_private;
14861 
14862 	if (sata_hba_inst == NULL)
14863 		return (NULL);
14864 
14865 	/* Identify a port-mult by cport_info.cport_dev_type */
14866 	if (SATA_CPORT_DEV_TYPE(sata_hba_inst, cport) == SATA_DTYPE_PMULT)
14867 		qual = SATA_ADDR_DPMPORT;
14868 	else
14869 		qual = SATA_ADDR_DCPORT;
14870 
14871 	target = SATA_TO_SCSI_TARGET(cport, pmport, qual);
14872 
14873 	/* Retrieve target dip */
14874 	ndi_devi_enter(dip);
14875 	for (cdip = ddi_get_child(dip); cdip != NULL; ) {
14876 		dev_info_t *next = ddi_get_next_sibling(cdip);
14877 
14878 		tgt = ddi_prop_get_int(DDI_DEV_T_ANY, cdip,
14879 		    DDI_PROP_DONTPASS, "target", -1);
14880 		if (tgt == -1) {
14881 			/*
14882 			 * This is actually an error condition, but not
14883 			 * a fatal one. Just continue the search.
14884 			 */
14885 			cdip = next;
14886 			continue;
14887 		}
14888 
14889 		if (tgt == target)
14890 			break;
14891 
14892 		cdip = next;
14893 	}
14894 	ndi_devi_exit(dip);
14895 
14896 	return (cdip);
14897 }
14898 
14899 /*
14900  * Get dev_info_t pointer to the device node pointed to by port argument.
14901  * NOTE: target argument is a value used in ioctls to identify
14902  * the AP - it is not a sata_address.
14903  * It is a combination of cport, pmport and address qualifier, encoded same
14904  * way as a scsi target number.
14905  *
14906  * Returns dev_info_t pointer if target device was found, NULL otherwise.
14907  */
14908 
14909 static dev_info_t *
14910 sata_get_scsi_target_dip(dev_info_t *dip, sata_address_t *saddr)
14911 {
14912 	dev_info_t	*cdip = NULL;
14913 	int		target, tgt;
14914 
14915 	target = SATA_TO_SCSI_TARGET(saddr->cport, saddr->pmport, saddr->qual);
14916 
14917 	ndi_devi_enter(dip);
14918 	for (cdip = ddi_get_child(dip); cdip != NULL; ) {
14919 		dev_info_t *next = ddi_get_next_sibling(cdip);
14920 
14921 		tgt = ddi_prop_get_int(DDI_DEV_T_ANY, cdip,
14922 		    DDI_PROP_DONTPASS, "target", -1);
14923 		if (tgt == -1) {
14924 			/*
14925 			 * This is actually an error condition, but not
14926 			 * a fatal one. Just continue the search.
14927 			 */
14928 			cdip = next;
14929 			continue;
14930 		}
14931 
14932 		if (tgt == target)
14933 			break;
14934 
14935 		cdip = next;
14936 	}
14937 	ndi_devi_exit(dip);
14938 
14939 	return (cdip);
14940 }
14941 
14942 /*
14943  * Process sata port disconnect request.
14944  * Normally, cfgadm sata plugin will try to offline (unconfigure) the device
14945  * before this request. Nevertheless, if a device is still configured,
14946  * we need to attempt to offline and unconfigure device.
14947  * Regardless of the unconfigure operation results the port is marked as
14948  * deactivated and no access to the attached device is possible.
14949  * If the target node remains because unconfigure operation failed, its state
14950  * will be set to DEVICE_REMOVED, preventing it to be used again when a device
14951  * is inserted/re-inserted. The event daemon will repeatedly try to unconfigure
14952  * the device and remove old target node.
14953  *
14954  * This function invokes sata_hba_inst->satahba_tran->
14955  * sata_tran_hotplug_ops->sata_tran_port_deactivate().
14956  * If successful, the device structure (if any) attached to the specified port
14957  * is removed and state of the port marked appropriately.
14958  * Failure of the port_deactivate may keep port in the physically active state,
14959  * or may fail the port.
14960  *
14961  * NOTE: Port multiplier is supported.
14962  */
14963 
14964 static int
14965 sata_ioctl_disconnect(sata_hba_inst_t *sata_hba_inst,
14966     sata_device_t *sata_device)
14967 {
14968 	sata_drive_info_t *sdinfo = NULL, *subsdinfo = NULL;
14969 	sata_cport_info_t *cportinfo = NULL;
14970 	sata_pmport_info_t *pmportinfo = NULL;
14971 	sata_pmult_info_t *pmultinfo = NULL;
14972 	sata_device_t subsdevice;
14973 	int cport, pmport, qual;
14974 	int rval = SATA_SUCCESS;
14975 	int npmport = 0;
14976 	int rv = 0;
14977 
14978 	cport = sata_device->satadev_addr.cport;
14979 	pmport = sata_device->satadev_addr.pmport;
14980 	qual = sata_device->satadev_addr.qual;
14981 
14982 	ASSERT(qual == SATA_ADDR_DCPORT || qual == SATA_ADDR_DPMPORT);
14983 	if (qual == SATA_ADDR_DCPORT)
14984 		qual = SATA_ADDR_CPORT;
14985 	else
14986 		qual = SATA_ADDR_PMPORT;
14987 
14988 	/*
14989 	 * DEVCTL_AP_DISCONNECT invokes sata_hba_inst->satahba_tran->
14990 	 * sata_tran_hotplug_ops->sata_tran_port_deactivate().
14991 	 * Do the sanity check.
14992 	 */
14993 	if (SATA_PORT_DEACTIVATE_FUNC(sata_hba_inst) == NULL) {
14994 		/* No physical port deactivation supported. */
14995 		return (EINVAL);
14996 	}
14997 
14998 	/* Check the current state of the port */
14999 	rval = (*SATA_PROBE_PORT_FUNC(sata_hba_inst))
15000 	    (SATA_DIP(sata_hba_inst), sata_device);
15001 
15002 	cportinfo = SATA_CPORT_INFO(sata_hba_inst, cport);
15003 
15004 	/*
15005 	 * Processing port mulitiplier
15006 	 */
15007 	if (qual == SATA_ADDR_CPORT &&
15008 	    SATA_CPORT_DEV_TYPE(sata_hba_inst, cport) == SATA_DTYPE_PMULT) {
15009 		mutex_enter(&cportinfo->cport_mutex);
15010 
15011 		/* Check controller port status */
15012 		sata_update_port_info(sata_hba_inst, sata_device);
15013 		if (rval != SATA_SUCCESS ||
15014 		    (sata_device->satadev_state & SATA_PSTATE_FAILED) != 0) {
15015 			/*
15016 			 * Device port status is unknown or it is in failed
15017 			 * state
15018 			 */
15019 			SATA_CPORT_STATE(sata_hba_inst, cport) =
15020 			    SATA_PSTATE_FAILED;
15021 			SATADBG1(SATA_DBG_IOCTL_IF, sata_hba_inst,
15022 			    "sata_hba_ioctl: connect: failed to deactivate "
15023 			    "SATA port %d", cport);
15024 			mutex_exit(&cportinfo->cport_mutex);
15025 			return (EIO);
15026 		}
15027 
15028 		/* Disconnect all sub-devices. */
15029 		pmultinfo = SATA_CPORTINFO_PMULT_INFO(cportinfo);
15030 		if (pmultinfo != NULL) {
15031 
15032 			for (npmport = 0; npmport < SATA_NUM_PMPORTS(
15033 			    sata_hba_inst, cport); npmport ++) {
15034 				subsdinfo = SATA_PMPORT_DRV_INFO(
15035 				    sata_hba_inst, cport, npmport);
15036 				if (subsdinfo == NULL)
15037 					continue;
15038 
15039 				subsdevice.satadev_addr = subsdinfo->
15040 				    satadrv_addr;
15041 
15042 				mutex_exit(&cportinfo->cport_mutex);
15043 				if (sata_ioctl_disconnect(sata_hba_inst,
15044 				    &subsdevice) == SATA_SUCCESS) {
15045 					SATADBG2(SATA_DBG_PMULT, sata_hba_inst,
15046 					"[Remove] device at port %d:%d "
15047 					"successfully.", cport, npmport);
15048 				}
15049 				mutex_enter(&cportinfo->cport_mutex);
15050 			}
15051 		}
15052 
15053 		/* Disconnect the port multiplier */
15054 		cportinfo->cport_state &= ~SATA_STATE_READY;
15055 		mutex_exit(&cportinfo->cport_mutex);
15056 
15057 		sata_device->satadev_addr.qual = qual;
15058 		rval = (*SATA_PORT_DEACTIVATE_FUNC(sata_hba_inst))
15059 		    (SATA_DIP(sata_hba_inst), sata_device);
15060 
15061 		sata_gen_sysevent(sata_hba_inst, &sata_device->satadev_addr,
15062 		    SE_NO_HINT);
15063 
15064 		mutex_enter(&cportinfo->cport_mutex);
15065 		sata_update_port_info(sata_hba_inst, sata_device);
15066 		if (rval != SATA_SUCCESS &&
15067 		    sata_device->satadev_state & SATA_PSTATE_FAILED) {
15068 			cportinfo->cport_state = SATA_PSTATE_FAILED;
15069 			rv = EIO;
15070 		} else {
15071 			cportinfo->cport_state |= SATA_PSTATE_SHUTDOWN;
15072 		}
15073 		mutex_exit(&cportinfo->cport_mutex);
15074 
15075 		return (rv);
15076 	}
15077 
15078 	/*
15079 	 * Process non-port-multiplier device - it could be a drive connected
15080 	 * to a port multiplier port or a controller port.
15081 	 */
15082 	if (qual == SATA_ADDR_PMPORT) {
15083 		pmportinfo = SATA_PMPORT_INFO(sata_hba_inst, cport, pmport);
15084 		mutex_enter(&pmportinfo->pmport_mutex);
15085 		sata_update_pmport_info(sata_hba_inst, sata_device);
15086 		if (rval != SATA_SUCCESS ||
15087 		    (sata_device->satadev_state & SATA_PSTATE_FAILED) != 0) {
15088 			SATA_PMPORT_STATE(sata_hba_inst, cport, pmport) =
15089 			    SATA_PSTATE_FAILED;
15090 			SATADBG2(SATA_DBG_IOCTL_IF, sata_hba_inst,
15091 			    "sata_hba_ioctl: connect: failed to deactivate "
15092 			    "SATA port %d:%d", cport, pmport);
15093 			mutex_exit(&pmportinfo->pmport_mutex);
15094 			return (EIO);
15095 		}
15096 
15097 		if (pmportinfo->pmport_dev_type != SATA_DTYPE_NONE) {
15098 			sdinfo = pmportinfo->pmport_sata_drive;
15099 			ASSERT(sdinfo != NULL);
15100 		}
15101 
15102 		/*
15103 		 * Set port's dev_state to not ready - this will disable
15104 		 * an access to a potentially attached device.
15105 		 */
15106 		pmportinfo->pmport_state &= ~SATA_STATE_READY;
15107 
15108 		/* Remove and release sata_drive info structure. */
15109 		if (sdinfo != NULL) {
15110 			if ((sdinfo->satadrv_type &
15111 			    SATA_VALID_DEV_TYPE) != 0) {
15112 				/*
15113 				 * If a target node exists, try to offline
15114 				 * a device and remove target node.
15115 				 */
15116 				mutex_exit(&pmportinfo->pmport_mutex);
15117 				(void) sata_offline_device(sata_hba_inst,
15118 				    sata_device, sdinfo);
15119 				mutex_enter(&pmportinfo->pmport_mutex);
15120 			}
15121 
15122 			SATA_PMPORTINFO_DRV_INFO(pmportinfo) = NULL;
15123 			pmportinfo->pmport_dev_type = SATA_DTYPE_NONE;
15124 			(void) kmem_free((void *)sdinfo,
15125 			    sizeof (sata_drive_info_t));
15126 		}
15127 		mutex_exit(&pmportinfo->pmport_mutex);
15128 
15129 	} else if (qual == SATA_ADDR_CPORT) {
15130 		mutex_enter(&cportinfo->cport_mutex);
15131 		sata_update_port_info(sata_hba_inst, sata_device);
15132 		if (rval != SATA_SUCCESS ||
15133 		    (sata_device->satadev_state & SATA_PSTATE_FAILED) != 0) {
15134 			/*
15135 			 * Device port status is unknown or it is in failed
15136 			 * state
15137 			 */
15138 			SATA_CPORT_STATE(sata_hba_inst, cport) =
15139 			    SATA_PSTATE_FAILED;
15140 			SATADBG1(SATA_DBG_IOCTL_IF, sata_hba_inst,
15141 			    "sata_hba_ioctl: connect: failed to deactivate "
15142 			    "SATA port %d", cport);
15143 			mutex_exit(&cportinfo->cport_mutex);
15144 			return (EIO);
15145 		}
15146 
15147 		if (cportinfo->cport_dev_type == SATA_DTYPE_PMULT) {
15148 			pmultinfo = SATA_CPORTINFO_PMULT_INFO(cportinfo);
15149 			ASSERT(pmultinfo != NULL);
15150 		} else if (cportinfo->cport_dev_type != SATA_DTYPE_NONE) {
15151 			sdinfo = SATA_CPORTINFO_DRV_INFO(cportinfo);
15152 			ASSERT(sdinfo != NULL);
15153 		}
15154 		cportinfo->cport_state &= ~SATA_STATE_READY;
15155 
15156 		if (sdinfo != NULL) {
15157 			if ((sdinfo->satadrv_type &
15158 			    SATA_VALID_DEV_TYPE) != 0) {
15159 				/*
15160 				 * If a target node exists, try to offline
15161 				 * a device and remove target node.
15162 				 */
15163 				mutex_exit(&cportinfo->cport_mutex);
15164 				(void) sata_offline_device(sata_hba_inst,
15165 				    sata_device, sdinfo);
15166 				mutex_enter(&cportinfo->cport_mutex);
15167 			}
15168 
15169 			SATA_CPORTINFO_DRV_INFO(cportinfo) = NULL;
15170 			cportinfo->cport_dev_type = SATA_DTYPE_NONE;
15171 			(void) kmem_free((void *)sdinfo,
15172 			    sizeof (sata_drive_info_t));
15173 		}
15174 		mutex_exit(&cportinfo->cport_mutex);
15175 	}
15176 
15177 	/* Just ask HBA driver to deactivate port */
15178 	sata_device->satadev_addr.qual = qual;
15179 
15180 	rval = (*SATA_PORT_DEACTIVATE_FUNC(sata_hba_inst))
15181 	    (SATA_DIP(sata_hba_inst), sata_device);
15182 
15183 	/*
15184 	 * Generate sysevent - EC_DR / ESC_DR_AP_STATE_CHANGE
15185 	 * without the hint (to force listener to investivate the state).
15186 	 */
15187 	sata_gen_sysevent(sata_hba_inst, &sata_device->satadev_addr,
15188 	    SE_NO_HINT);
15189 
15190 	if (qual == SATA_ADDR_PMPORT) {
15191 		mutex_enter(&pmportinfo->pmport_mutex);
15192 		sata_update_pmport_info(sata_hba_inst, sata_device);
15193 
15194 		if (rval != SATA_SUCCESS &&
15195 		    sata_device->satadev_state & SATA_PSTATE_FAILED) {
15196 			/*
15197 			 * Port deactivation failure - do not change port
15198 			 * state unless the state returned by HBA indicates a
15199 			 * port failure.
15200 			 *
15201 			 * NOTE: device structures were released, so devices
15202 			 * now are invisible! Port reset is needed to
15203 			 * re-enumerate devices.
15204 			 */
15205 			pmportinfo->pmport_state = SATA_PSTATE_FAILED;
15206 			rv = EIO;
15207 		} else {
15208 			/*
15209 			 * Deactivation succeded. From now on the sata framework
15210 			 * will not care what is happening to the device, until
15211 			 * the port is activated again.
15212 			 */
15213 			pmportinfo->pmport_state |= SATA_PSTATE_SHUTDOWN;
15214 		}
15215 		mutex_exit(&pmportinfo->pmport_mutex);
15216 	} else if (qual == SATA_ADDR_CPORT) {
15217 		mutex_enter(&cportinfo->cport_mutex);
15218 		sata_update_port_info(sata_hba_inst, sata_device);
15219 
15220 		if (rval != SATA_SUCCESS &&
15221 		    sata_device->satadev_state & SATA_PSTATE_FAILED) {
15222 			cportinfo->cport_state = SATA_PSTATE_FAILED;
15223 			rv = EIO;
15224 		} else {
15225 			cportinfo->cport_state |= SATA_PSTATE_SHUTDOWN;
15226 		}
15227 		mutex_exit(&cportinfo->cport_mutex);
15228 	}
15229 
15230 	return (rv);
15231 }
15232 
15233 
15234 
15235 /*
15236  * Process sata port connect request
15237  * The sata cfgadm pluging will invoke this operation only if port was found
15238  * in the disconnect state (failed state is also treated as the disconnected
15239  * state).
15240  * DEVCTL_AP_CONNECT would invoke  sata_hba_inst->satahba_tran->
15241  * sata_tran_hotplug_ops->sata_tran_port_activate().
15242  * If successful and a device is found attached to the port,
15243  * the initialization sequence is executed to attach a device structure to
15244  * a port structure. The state of the port and a device would be set
15245  * appropriately.
15246  * The device is not set in configured state (system-wise) by this operation.
15247  *
15248  * Note, that activating the port may generate link events,
15249  * so it is important that following processing and the
15250  * event processing does not interfere with each other!
15251  *
15252  * This operation may remove port failed state and will
15253  * try to make port active and in good standing.
15254  *
15255  * NOTE: Port multiplier is supported.
15256  */
15257 
15258 static int
15259 sata_ioctl_connect(sata_hba_inst_t *sata_hba_inst,
15260     sata_device_t *sata_device)
15261 {
15262 	sata_pmport_info_t	*pmportinfo = NULL;
15263 	uint8_t cport, pmport, qual;
15264 	int rv = 0;
15265 
15266 	cport = sata_device->satadev_addr.cport;
15267 	pmport = sata_device->satadev_addr.pmport;
15268 	qual = sata_device->satadev_addr.qual;
15269 
15270 	ASSERT(qual == SATA_ADDR_DCPORT || qual == SATA_ADDR_DPMPORT);
15271 	if (qual == SATA_ADDR_DCPORT)
15272 		qual = SATA_ADDR_CPORT;
15273 	else
15274 		qual = SATA_ADDR_PMPORT;
15275 
15276 	if (qual == SATA_ADDR_PMPORT)
15277 		pmportinfo = SATA_PMPORT_INFO(sata_hba_inst, cport, pmport);
15278 
15279 	/*
15280 	 * DEVCTL_AP_CONNECT would invoke sata_hba_inst->
15281 	 * satahba_tran->sata_tran_hotplug_ops->sata_tran_port_activate().
15282 	 * Perform sanity check now.
15283 	 */
15284 	if (SATA_PORT_ACTIVATE_FUNC(sata_hba_inst) == NULL) {
15285 		/* No physical port activation supported. */
15286 		return (EINVAL);
15287 	}
15288 
15289 	/* Just ask HBA driver to activate port */
15290 	if ((*SATA_PORT_ACTIVATE_FUNC(sata_hba_inst))
15291 	    (SATA_DIP(sata_hba_inst), sata_device) != SATA_SUCCESS) {
15292 		/*
15293 		 * Port activation failure.
15294 		 */
15295 		if (qual == SATA_ADDR_CPORT) {
15296 			mutex_enter(&SATA_CPORT_INFO(sata_hba_inst,
15297 			    cport)->cport_mutex);
15298 			sata_update_port_info(sata_hba_inst, sata_device);
15299 			if (sata_device->satadev_state & SATA_PSTATE_FAILED) {
15300 				SATA_CPORT_STATE(sata_hba_inst, cport) =
15301 				    SATA_PSTATE_FAILED;
15302 				SATADBG1(SATA_DBG_IOCTL_IF, sata_hba_inst,
15303 				    "sata_hba_ioctl: connect: failed to "
15304 				    "activate SATA port %d", cport);
15305 			}
15306 			mutex_exit(&SATA_CPORT_INFO(sata_hba_inst,
15307 			    cport)->cport_mutex);
15308 		} else { /* port multiplier device port */
15309 			mutex_enter(&pmportinfo->pmport_mutex);
15310 			sata_update_pmport_info(sata_hba_inst, sata_device);
15311 			if (sata_device->satadev_state & SATA_PSTATE_FAILED) {
15312 				SATA_PMPORT_STATE(sata_hba_inst, cport,
15313 				    pmport) = SATA_PSTATE_FAILED;
15314 				SATADBG2(SATA_DBG_IOCTL_IF, sata_hba_inst,
15315 				    "sata_hba_ioctl: connect: failed to "
15316 				    "activate SATA port %d:%d", cport, pmport);
15317 			}
15318 			mutex_exit(&pmportinfo->pmport_mutex);
15319 		}
15320 		return (EIO);
15321 	}
15322 
15323 	/* Virgin port state - will be updated by the port re-probe. */
15324 	if (qual == SATA_ADDR_CPORT) {
15325 		mutex_enter(&SATA_CPORT_INFO(sata_hba_inst,
15326 		    cport)->cport_mutex);
15327 		SATA_CPORT_STATE(sata_hba_inst, cport) = 0;
15328 		mutex_exit(&SATA_CPORT_INFO(sata_hba_inst,
15329 		    cport)->cport_mutex);
15330 	} else { /* port multiplier device port */
15331 		mutex_enter(&pmportinfo->pmport_mutex);
15332 		SATA_PMPORT_STATE(sata_hba_inst, cport, pmport) = 0;
15333 		mutex_exit(&pmportinfo->pmport_mutex);
15334 	}
15335 
15336 	/*
15337 	 * Probe the port to find its state and attached device.
15338 	 */
15339 	if (sata_reprobe_port(sata_hba_inst, sata_device,
15340 	    SATA_DEV_IDENTIFY_RETRY) == SATA_FAILURE)
15341 		rv = EIO;
15342 
15343 	/*
15344 	 * Generate sysevent - EC_DR / ESC_DR_AP_STATE_CHANGE
15345 	 * without the hint
15346 	 */
15347 	sata_gen_sysevent(sata_hba_inst, &sata_device->satadev_addr,
15348 	    SE_NO_HINT);
15349 
15350 	/*
15351 	 * If there is a device attached to the port, emit
15352 	 * a message.
15353 	 */
15354 	if (sata_device->satadev_type != SATA_DTYPE_NONE) {
15355 
15356 		if (qual == SATA_ADDR_CPORT) {
15357 			if (sata_device->satadev_type == SATA_DTYPE_PMULT) {
15358 				sata_log(sata_hba_inst, CE_WARN,
15359 				    "SATA port multiplier detected "
15360 				    "at port %d", cport);
15361 			} else {
15362 				sata_log(sata_hba_inst, CE_WARN,
15363 				    "SATA device detected at port %d", cport);
15364 				if (sata_device->satadev_type ==
15365 				    SATA_DTYPE_UNKNOWN) {
15366 				/*
15367 				 * A device was not successfully identified
15368 				 */
15369 				sata_log(sata_hba_inst, CE_WARN,
15370 				    "Could not identify SATA "
15371 				    "device at port %d", cport);
15372 				}
15373 			}
15374 		} else { /* port multiplier device port */
15375 			sata_log(sata_hba_inst, CE_WARN,
15376 			    "SATA device detected at port %d:%d",
15377 			    cport, pmport);
15378 			if (sata_device->satadev_type == SATA_DTYPE_UNKNOWN) {
15379 				/*
15380 				 * A device was not successfully identified
15381 				 */
15382 				sata_log(sata_hba_inst, CE_WARN,
15383 				    "Could not identify SATA "
15384 				    "device at port %d:%d", cport, pmport);
15385 			}
15386 		}
15387 	}
15388 
15389 	return (rv);
15390 }
15391 
15392 
15393 /*
15394  * Process sata device unconfigure request.
15395  * The unconfigure operation uses generic nexus operation to
15396  * offline a device. It leaves a target device node attached.
15397  * and obviously sata_drive_info attached as well, because
15398  * from the hardware point of view nothing has changed.
15399  */
15400 static int
15401 sata_ioctl_unconfigure(sata_hba_inst_t *sata_hba_inst,
15402     sata_device_t *sata_device)
15403 {
15404 	int rv = 0;
15405 	dev_info_t *tdip;
15406 
15407 	/* We are addressing attached device, not a port */
15408 	if (sata_device->satadev_addr.qual == SATA_ADDR_CPORT)
15409 		sata_device->satadev_addr.qual = SATA_ADDR_DCPORT;
15410 	else if (sata_device->satadev_addr.qual == SATA_ADDR_PMPORT)
15411 		sata_device->satadev_addr.qual = SATA_ADDR_DPMPORT;
15412 
15413 	if ((tdip = sata_get_scsi_target_dip(SATA_DIP(sata_hba_inst),
15414 	    &sata_device->satadev_addr)) != NULL) {
15415 
15416 		if (ndi_devi_offline(tdip, NDI_UNCONFIG) != NDI_SUCCESS) {
15417 			SATA_LOG_D((sata_hba_inst, CE_WARN,
15418 			    "sata_hba_ioctl: unconfigure: "
15419 			    "failed to unconfigure device at SATA port %d:%d",
15420 			    sata_device->satadev_addr.cport,
15421 			    sata_device->satadev_addr.pmport));
15422 			rv = EIO;
15423 		}
15424 		/*
15425 		 * The target node devi_state should be marked with
15426 		 * DEVI_DEVICE_OFFLINE by ndi_devi_offline().
15427 		 * This would be the indication for cfgadm that
15428 		 * the AP node occupant state is 'unconfigured'.
15429 		 */
15430 
15431 	} else {
15432 		/*
15433 		 * This would indicate a failure on the part of cfgadm
15434 		 * to detect correct state of the node prior to this
15435 		 * call - one cannot unconfigure non-existing device.
15436 		 */
15437 		SATA_LOG_D((sata_hba_inst, CE_WARN,
15438 		    "sata_hba_ioctl: unconfigure: "
15439 		    "attempt to unconfigure non-existing device "
15440 		    "at SATA port %d:%d",
15441 		    sata_device->satadev_addr.cport,
15442 		    sata_device->satadev_addr.pmport));
15443 		rv = ENXIO;
15444 	}
15445 	return (rv);
15446 }
15447 
15448 /*
15449  * Process sata device configure request
15450  * If port is in a failed state, operation is aborted - one has to use
15451  * an explicit connect or port activate request to try to get a port into
15452  * non-failed mode. Port reset wil also work in such situation.
15453  * If the port is in disconnected (shutdown) state, the connect operation is
15454  * attempted prior to any other action.
15455  * When port is in the active state, there is a device attached and the target
15456  * node exists, a device was most likely offlined.
15457  * If target node does not exist, a new target node is created. In both cases
15458  * an attempt is made to online (configure) the device.
15459  *
15460  * NOTE: Port multiplier is supported.
15461  */
15462 static int
15463 sata_ioctl_configure(sata_hba_inst_t *sata_hba_inst,
15464     sata_device_t *sata_device)
15465 {
15466 	int cport, pmport, qual;
15467 	int rval;
15468 	boolean_t target = B_TRUE;
15469 	sata_cport_info_t *cportinfo;
15470 	sata_pmport_info_t *pmportinfo = NULL;
15471 	dev_info_t *tdip;
15472 	sata_drive_info_t *sdinfo;
15473 
15474 	cport = sata_device->satadev_addr.cport;
15475 	pmport = sata_device->satadev_addr.pmport;
15476 	qual = sata_device->satadev_addr.qual;
15477 
15478 	/* Get current port state */
15479 	rval = (*SATA_PROBE_PORT_FUNC(sata_hba_inst))
15480 	    (SATA_DIP(sata_hba_inst), sata_device);
15481 
15482 	cportinfo = SATA_CPORT_INFO(sata_hba_inst, cport);
15483 	if (qual == SATA_ADDR_DPMPORT) {
15484 		pmportinfo = SATA_PMPORT_INFO(sata_hba_inst, cport, pmport);
15485 		mutex_enter(&pmportinfo->pmport_mutex);
15486 		sata_update_pmport_info(sata_hba_inst, sata_device);
15487 		if (rval != SATA_SUCCESS ||
15488 		    (sata_device->satadev_state & SATA_PSTATE_FAILED) != 0) {
15489 			/*
15490 			 * Obviously, device on a failed port is not visible
15491 			 */
15492 			mutex_exit(&pmportinfo->pmport_mutex);
15493 			return (ENXIO);
15494 		}
15495 		mutex_exit(&pmportinfo->pmport_mutex);
15496 	} else {
15497 		mutex_enter(&SATA_CPORT_INFO(sata_hba_inst,
15498 		    cport)->cport_mutex);
15499 		sata_update_port_info(sata_hba_inst, sata_device);
15500 		if (rval != SATA_SUCCESS ||
15501 		    (sata_device->satadev_state & SATA_PSTATE_FAILED) != 0) {
15502 			/*
15503 			 * Obviously, device on a failed port is not visible
15504 			 */
15505 			mutex_exit(&SATA_CPORT_INFO(sata_hba_inst,
15506 			    cport)->cport_mutex);
15507 			return (ENXIO);
15508 		}
15509 		mutex_exit(&SATA_CPORT_INFO(sata_hba_inst,
15510 		    cport)->cport_mutex);
15511 	}
15512 
15513 	if ((sata_device->satadev_state & SATA_PSTATE_SHUTDOWN) != 0) {
15514 		/* need to activate port */
15515 		target = B_FALSE;
15516 
15517 		/* Sanity check */
15518 		if (SATA_PORT_ACTIVATE_FUNC(sata_hba_inst) == NULL)
15519 			return (ENXIO);
15520 
15521 		/* Just let HBA driver to activate port */
15522 		if ((*SATA_PORT_ACTIVATE_FUNC(sata_hba_inst))
15523 		    (SATA_DIP(sata_hba_inst), sata_device) != SATA_SUCCESS) {
15524 			/*
15525 			 * Port activation failure - do not change port state
15526 			 * unless the state returned by HBA indicates a port
15527 			 * failure.
15528 			 */
15529 			if (qual == SATA_ADDR_DPMPORT) {
15530 				mutex_enter(&pmportinfo->pmport_mutex);
15531 				sata_update_pmport_info(sata_hba_inst,
15532 				    sata_device);
15533 				if (sata_device->satadev_state &
15534 				    SATA_PSTATE_FAILED)
15535 					pmportinfo->pmport_state =
15536 					    SATA_PSTATE_FAILED;
15537 				mutex_exit(&pmportinfo->pmport_mutex);
15538 			} else {
15539 				mutex_enter(&SATA_CPORT_INFO(sata_hba_inst,
15540 				    cport)->cport_mutex);
15541 				sata_update_port_info(sata_hba_inst,
15542 				    sata_device);
15543 				if (sata_device->satadev_state &
15544 				    SATA_PSTATE_FAILED)
15545 					cportinfo->cport_state =
15546 					    SATA_PSTATE_FAILED;
15547 				mutex_exit(&SATA_CPORT_INFO(
15548 				    sata_hba_inst, cport)->cport_mutex);
15549 			}
15550 		}
15551 		SATA_LOG_D((sata_hba_inst, CE_WARN,
15552 		    "sata_hba_ioctl: configure: "
15553 		    "failed to activate SATA port %d:%d",
15554 		    cport, pmport));
15555 		return (EIO);
15556 	}
15557 	/*
15558 	 * Generate sysevent - EC_DR / ESC_DR_AP_STATE_CHANGE
15559 	 * without the hint.
15560 	 */
15561 	sata_gen_sysevent(sata_hba_inst,
15562 	    &sata_device->satadev_addr, SE_NO_HINT);
15563 
15564 	/* Virgin port state */
15565 	if (qual == SATA_ADDR_DPMPORT) {
15566 		mutex_enter(&pmportinfo->pmport_mutex);
15567 		pmportinfo->pmport_state = 0;
15568 		mutex_exit(&pmportinfo->pmport_mutex);
15569 	} else {
15570 		mutex_enter(&SATA_CPORT_INFO(sata_hba_inst,
15571 		    cport)-> cport_mutex);
15572 		cportinfo->cport_state = 0;
15573 		mutex_exit(&SATA_CPORT_INFO(sata_hba_inst,
15574 		    cport)->cport_mutex);
15575 	}
15576 	/*
15577 	 * Always reprobe port, to get current device info.
15578 	 */
15579 	if (sata_reprobe_port(sata_hba_inst, sata_device,
15580 	    SATA_DEV_IDENTIFY_RETRY) != SATA_SUCCESS)
15581 		return (EIO);
15582 
15583 	if (sata_device->satadev_type != SATA_DTYPE_NONE && target == B_FALSE) {
15584 		if (qual == SATA_ADDR_DPMPORT) {
15585 			/*
15586 			 * That's the transition from "inactive" port
15587 			 * to active one with device attached.
15588 			 */
15589 			sata_log(sata_hba_inst, CE_WARN,
15590 			    "SATA device detected at port %d:%d",
15591 			    cport, pmport);
15592 		} else {
15593 			/*
15594 			 * When PM is attached to the cport and cport is
15595 			 * activated, every PM device port needs to be reprobed.
15596 			 * We need to emit message for all devices detected
15597 			 * at port multiplier's device ports.
15598 			 * Add such code here.
15599 			 * For now, just inform about device attached to
15600 			 * cport.
15601 			 */
15602 			sata_log(sata_hba_inst, CE_WARN,
15603 			    "SATA device detected at port %d", cport);
15604 		}
15605 	}
15606 
15607 	/*
15608 	 * This is where real configuration operation starts.
15609 	 *
15610 	 * When PM is attached to the cport and cport is activated,
15611 	 * devices attached PM device ports may have to be configured
15612 	 * explicitly. This may change when port multiplier is supported.
15613 	 * For now, configure only disks and other valid target devices.
15614 	 */
15615 	if (!(sata_device->satadev_type & SATA_VALID_DEV_TYPE)) {
15616 		if (qual == SATA_ADDR_DCPORT) {
15617 			if (sata_device->satadev_type == SATA_DTYPE_UNKNOWN) {
15618 				/*
15619 				 * A device was not successfully identified
15620 				 */
15621 				sata_log(sata_hba_inst, CE_WARN,
15622 				    "Could not identify SATA "
15623 				    "device at port %d", cport);
15624 			}
15625 		} else { /* port multiplier device port */
15626 			if (sata_device->satadev_type == SATA_DTYPE_UNKNOWN) {
15627 				/*
15628 				 * A device was not successfully identified
15629 				 */
15630 				sata_log(sata_hba_inst, CE_WARN,
15631 				    "Could not identify SATA "
15632 				    "device at port %d:%d", cport, pmport);
15633 			}
15634 		}
15635 		return (ENXIO);		/* No device to configure */
15636 	}
15637 
15638 	/*
15639 	 * Here we may have a device in reset condition,
15640 	 * but because we are just configuring it, there is
15641 	 * no need to process the reset other than just
15642 	 * to clear device reset condition in the HBA driver.
15643 	 * Setting the flag SATA_EVNT_CLEAR_DEVICE_RESET will
15644 	 * cause a first command sent the HBA driver with the request
15645 	 * to clear device reset condition.
15646 	 */
15647 	mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex);
15648 	if (qual == SATA_ADDR_DPMPORT)
15649 		sata_device->satadev_addr.qual = SATA_ADDR_DPMPORT;
15650 	else
15651 		sata_device->satadev_addr.qual = SATA_ADDR_DCPORT;
15652 	sdinfo = sata_get_device_info(sata_hba_inst, sata_device);
15653 	if (sdinfo == NULL) {
15654 		mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex);
15655 		return (ENXIO);
15656 	}
15657 	if (sdinfo->satadrv_event_flags &
15658 	    (SATA_EVNT_DEVICE_RESET | SATA_EVNT_INPROC_DEVICE_RESET)) {
15659 		sdinfo->satadrv_event_flags = 0;
15660 	}
15661 	sdinfo->satadrv_event_flags |= SATA_EVNT_CLEAR_DEVICE_RESET;
15662 	mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex);
15663 
15664 	if ((tdip = sata_get_scsi_target_dip(SATA_DIP(sata_hba_inst),
15665 	    &sata_device->satadev_addr)) != NULL) {
15666 		/*
15667 		 * Target node exists. Verify, that it belongs
15668 		 * to existing, attached device and not to
15669 		 * a removed device.
15670 		 */
15671 		if (sata_check_device_removed(tdip) == B_TRUE) {
15672 			if (qual == SATA_ADDR_DPMPORT)
15673 				sata_log(sata_hba_inst, CE_WARN,
15674 				    "SATA device at port %d cannot be "
15675 				    "configured. "
15676 				    "Application(s) accessing "
15677 				    "previously attached device "
15678 				    "have to release it before newly "
15679 				    "inserted device can be made accessible.",
15680 				    cport);
15681 			else
15682 				sata_log(sata_hba_inst, CE_WARN,
15683 				    "SATA device at port %d:%d cannot be"
15684 				    "configured. "
15685 				    "Application(s) accessing "
15686 				    "previously attached device "
15687 				    "have to release it before newly "
15688 				    "inserted device can be made accessible.",
15689 				    cport, pmport);
15690 			return (EIO);
15691 		}
15692 		/*
15693 		 * Device was not removed and re-inserted.
15694 		 * Try to online it.
15695 		 */
15696 		if (ndi_devi_online(tdip, 0) != NDI_SUCCESS) {
15697 			SATA_LOG_D((sata_hba_inst, CE_WARN,
15698 			    "sata_hba_ioctl: configure: "
15699 			    "onlining device at SATA port "
15700 			    "%d:%d failed", cport, pmport));
15701 			return (EIO);
15702 		}
15703 
15704 		if (qual == SATA_ADDR_DPMPORT) {
15705 			mutex_enter(&pmportinfo->pmport_mutex);
15706 			pmportinfo->pmport_tgtnode_clean = B_TRUE;
15707 			mutex_exit(&pmportinfo->pmport_mutex);
15708 		} else {
15709 			mutex_enter(&SATA_CPORT_INFO(sata_hba_inst,
15710 			    cport)->cport_mutex);
15711 			cportinfo-> cport_tgtnode_clean = B_TRUE;
15712 			mutex_exit(&SATA_CPORT_INFO(
15713 			    sata_hba_inst, cport)->cport_mutex);
15714 		}
15715 	} else {
15716 		/*
15717 		 * No target node - need to create a new target node.
15718 		 */
15719 		if (qual == SATA_ADDR_DPMPORT) {
15720 			mutex_enter(&pmportinfo->pmport_mutex);
15721 			pmportinfo->pmport_tgtnode_clean = B_TRUE;
15722 			mutex_exit(&pmportinfo->pmport_mutex);
15723 		} else {
15724 			mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, cport)->
15725 			    cport_mutex);
15726 			cportinfo-> cport_tgtnode_clean = B_TRUE;
15727 			mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)->
15728 			    cport_mutex);
15729 		}
15730 
15731 		tdip = sata_create_target_node(SATA_DIP(sata_hba_inst),
15732 		    sata_hba_inst, &sata_device->satadev_addr);
15733 		if (tdip == NULL) {
15734 			/* Configure operation failed */
15735 			SATA_LOG_D((sata_hba_inst, CE_WARN,
15736 			    "sata_hba_ioctl: configure: "
15737 			    "configuring SATA device at port %d:%d "
15738 			    "failed", cport, pmport));
15739 			return (EIO);
15740 		}
15741 	}
15742 	return (0);
15743 }
15744 
15745 
15746 /*
15747  * Process ioctl deactivate port request.
15748  * Arbitrarily unconfigure attached device, if any.
15749  * Even if the unconfigure fails, proceed with the
15750  * port deactivation.
15751  *
15752  * NOTE: Port Multiplier is supported now.
15753  */
15754 
15755 static int
15756 sata_ioctl_deactivate(sata_hba_inst_t *sata_hba_inst,
15757     sata_device_t *sata_device)
15758 {
15759 	int cport, pmport, qual;
15760 	int rval, rv = 0;
15761 	int npmport;
15762 	sata_cport_info_t *cportinfo;
15763 	sata_pmport_info_t *pmportinfo;
15764 	sata_pmult_info_t *pmultinfo;
15765 	dev_info_t *tdip;
15766 	sata_drive_info_t *sdinfo = NULL;
15767 	sata_device_t subsdevice;
15768 
15769 	/* Sanity check */
15770 	if (SATA_PORT_DEACTIVATE_FUNC(sata_hba_inst) == NULL)
15771 		return (ENOTSUP);
15772 
15773 	cport = sata_device->satadev_addr.cport;
15774 	pmport = sata_device->satadev_addr.pmport;
15775 	qual = sata_device->satadev_addr.qual;
15776 
15777 	/* SCSI_TO_SATA_ADDR_QUAL() translate ap_id into a device qualifier */
15778 	ASSERT(qual == SATA_ADDR_DCPORT || qual == SATA_ADDR_DPMPORT);
15779 	if (qual == SATA_ADDR_DCPORT)
15780 		qual = SATA_ADDR_CPORT;
15781 	else
15782 		qual = SATA_ADDR_PMPORT;
15783 
15784 	cportinfo = SATA_CPORT_INFO(sata_hba_inst, cport);
15785 	if (qual == SATA_ADDR_PMPORT)
15786 		pmportinfo = SATA_PMPORT_INFO(sata_hba_inst, cport, pmport);
15787 
15788 	/*
15789 	 * Processing port multiplier
15790 	 */
15791 	if (qual == SATA_ADDR_CPORT &&
15792 	    SATA_CPORT_DEV_TYPE(sata_hba_inst, cport) == SATA_DTYPE_PMULT) {
15793 		mutex_enter(&cportinfo->cport_mutex);
15794 
15795 		/* Deactivate all sub-deices */
15796 		pmultinfo = SATA_CPORTINFO_PMULT_INFO(cportinfo);
15797 		if (pmultinfo != NULL) {
15798 			for (npmport = 0; npmport < SATA_NUM_PMPORTS(
15799 			    sata_hba_inst, cport); npmport++) {
15800 
15801 				subsdevice.satadev_addr.cport = cport;
15802 				subsdevice.satadev_addr.pmport =
15803 				    (uint8_t)npmport;
15804 				subsdevice.satadev_addr.qual =
15805 				    SATA_ADDR_DPMPORT;
15806 
15807 				SATADBG2(SATA_DBG_PMULT, sata_hba_inst,
15808 				    "sata_hba_ioctl: deactivate: trying to "
15809 				    "deactivate SATA port %d:%d",
15810 				    cport, npmport);
15811 
15812 				mutex_exit(&cportinfo->cport_mutex);
15813 				if (sata_ioctl_deactivate(sata_hba_inst,
15814 				    &subsdevice) == SATA_SUCCESS) {
15815 					SATADBG2(SATA_DBG_PMULT, sata_hba_inst,
15816 					    "[Deactivate] device at port %d:%d "
15817 					    "successfully.", cport, npmport);
15818 				}
15819 				mutex_enter(&cportinfo->cport_mutex);
15820 			}
15821 		}
15822 
15823 		/* Deactivate the port multiplier now. */
15824 		cportinfo->cport_state &= ~SATA_STATE_READY;
15825 		mutex_exit(&cportinfo->cport_mutex);
15826 
15827 		sata_device->satadev_addr.qual = qual;
15828 		rval = (*SATA_PORT_DEACTIVATE_FUNC(sata_hba_inst))
15829 		    (SATA_DIP(sata_hba_inst), sata_device);
15830 
15831 		sata_gen_sysevent(sata_hba_inst, &sata_device->satadev_addr,
15832 		    SE_NO_HINT);
15833 
15834 		mutex_enter(&cportinfo->cport_mutex);
15835 		sata_update_port_info(sata_hba_inst, sata_device);
15836 		if (rval != SATA_SUCCESS) {
15837 			if (sata_device->satadev_state & SATA_PSTATE_FAILED) {
15838 				cportinfo->cport_state = SATA_PSTATE_FAILED;
15839 			}
15840 			rv = EIO;
15841 		} else {
15842 			cportinfo->cport_state |= SATA_PSTATE_SHUTDOWN;
15843 		}
15844 		mutex_exit(&cportinfo->cport_mutex);
15845 
15846 		return (rv);
15847 	}
15848 
15849 	/*
15850 	 * Process non-port-multiplier device - it could be a drive connected
15851 	 * to a port multiplier port or a controller port.
15852 	 */
15853 	mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex);
15854 	if (qual == SATA_ADDR_CPORT) {
15855 		sata_device->satadev_addr.qual = SATA_ADDR_DCPORT;
15856 		if (cportinfo->cport_dev_type != SATA_DTYPE_NONE) {
15857 			/* deal only with valid devices */
15858 			if ((cportinfo->cport_dev_type &
15859 			    SATA_VALID_DEV_TYPE) != 0)
15860 				sdinfo = SATA_CPORTINFO_DRV_INFO(cportinfo);
15861 		}
15862 		cportinfo->cport_state &= ~SATA_STATE_READY;
15863 	} else {
15864 		/* Port multiplier device port */
15865 		mutex_enter(&pmportinfo->pmport_mutex);
15866 		sata_device->satadev_addr.qual = SATA_ADDR_DPMPORT;
15867 		if (pmportinfo->pmport_dev_type != SATA_DTYPE_NONE &&
15868 		    (pmportinfo->pmport_dev_type & SATA_VALID_DEV_TYPE) != 0)
15869 			sdinfo = SATA_PMPORTINFO_DRV_INFO(pmportinfo);
15870 		pmportinfo->pmport_state &= ~SATA_STATE_READY;
15871 		mutex_exit(&pmportinfo->pmport_mutex);
15872 	}
15873 
15874 	if (sdinfo != NULL) {
15875 		/*
15876 		 * If a target node exists, try to offline a device and
15877 		 * to remove a target node.
15878 		 */
15879 		mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)->
15880 		    cport_mutex);
15881 		tdip = sata_get_scsi_target_dip(SATA_DIP(sata_hba_inst),
15882 		    &sata_device->satadev_addr);
15883 		if (tdip != NULL) {
15884 			/* target node exist */
15885 			SATADBG1(SATA_DBG_IOCTL_IF, sata_hba_inst,
15886 			    "sata_hba_ioctl: port deactivate: "
15887 			    "target node exists.", NULL);
15888 
15889 			if (ndi_devi_offline(tdip, NDI_DEVI_REMOVE) !=
15890 			    NDI_SUCCESS) {
15891 				SATA_LOG_D((sata_hba_inst, CE_WARN,
15892 				    "sata_hba_ioctl: port deactivate: "
15893 				    "failed to unconfigure device at port "
15894 				    "%d:%d before deactivating the port",
15895 				    cport, pmport));
15896 				/*
15897 				 * Set DEVICE REMOVED state in the target
15898 				 * node. It will prevent an access to
15899 				 * the device even when a new device is
15900 				 * attached, until the old target node is
15901 				 * released, removed and recreated for a new
15902 				 * device.
15903 				 */
15904 				sata_set_device_removed(tdip);
15905 
15906 				/*
15907 				 * Instruct the event daemon to try the
15908 				 * target node cleanup later.
15909 				 */
15910 				sata_set_target_node_cleanup(sata_hba_inst,
15911 				    &sata_device->satadev_addr);
15912 			}
15913 		}
15914 		mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, cport)->
15915 		    cport_mutex);
15916 		/*
15917 		 * In any case, remove and release sata_drive_info
15918 		 * structure.
15919 		 */
15920 		if (qual == SATA_ADDR_CPORT) {
15921 			SATA_CPORTINFO_DRV_INFO(cportinfo) = NULL;
15922 			cportinfo->cport_dev_type = SATA_DTYPE_NONE;
15923 		} else { /* port multiplier device port */
15924 			mutex_enter(&pmportinfo->pmport_mutex);
15925 			SATA_PMPORTINFO_DRV_INFO(pmportinfo) = NULL;
15926 			pmportinfo->pmport_dev_type = SATA_DTYPE_NONE;
15927 			mutex_exit(&pmportinfo->pmport_mutex);
15928 		}
15929 		(void) kmem_free((void *)sdinfo, sizeof (sata_drive_info_t));
15930 	}
15931 
15932 	if (qual == SATA_ADDR_CPORT) {
15933 		cportinfo->cport_state &= ~(SATA_STATE_PROBED |
15934 		    SATA_STATE_PROBING);
15935 	} else if (qual == SATA_ADDR_PMPORT) {
15936 		mutex_enter(&pmportinfo->pmport_mutex);
15937 		pmportinfo->pmport_state &= ~(SATA_STATE_PROBED |
15938 		    SATA_STATE_PROBING);
15939 		mutex_exit(&pmportinfo->pmport_mutex);
15940 	}
15941 	mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex);
15942 
15943 	/* Just let HBA driver to deactivate port */
15944 	sata_device->satadev_addr.qual = qual;
15945 	rval = (*SATA_PORT_DEACTIVATE_FUNC(sata_hba_inst))
15946 	    (SATA_DIP(sata_hba_inst), sata_device);
15947 
15948 	/*
15949 	 * Generate sysevent - EC_DR / ESC_DR_AP_STATE_CHANGE
15950 	 * without the hint
15951 	 */
15952 	sata_gen_sysevent(sata_hba_inst, &sata_device->satadev_addr,
15953 	    SE_NO_HINT);
15954 
15955 	mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex);
15956 	sata_update_port_info(sata_hba_inst, sata_device);
15957 	if (qual == SATA_ADDR_CPORT) {
15958 		if (rval != SATA_SUCCESS) {
15959 			/*
15960 			 * Port deactivation failure - do not change port state
15961 			 * unless the state returned by HBA indicates a port
15962 			 * failure.
15963 			 */
15964 			if (sata_device->satadev_state & SATA_PSTATE_FAILED) {
15965 				SATA_CPORT_STATE(sata_hba_inst, cport) =
15966 				    SATA_PSTATE_FAILED;
15967 			}
15968 			SATA_LOG_D((sata_hba_inst, CE_WARN,
15969 			    "sata_hba_ioctl: port deactivate: "
15970 			    "cannot deactivate SATA port %d", cport));
15971 			rv = EIO;
15972 		} else {
15973 			cportinfo->cport_state |= SATA_PSTATE_SHUTDOWN;
15974 		}
15975 	} else {
15976 		mutex_enter(&pmportinfo->pmport_mutex);
15977 		if (rval != SATA_SUCCESS) {
15978 			if (sata_device->satadev_state & SATA_PSTATE_FAILED) {
15979 				SATA_PMPORT_STATE(sata_hba_inst, cport,
15980 				    pmport) = SATA_PSTATE_FAILED;
15981 			}
15982 			SATA_LOG_D((sata_hba_inst, CE_WARN,
15983 			    "sata_hba_ioctl: port deactivate: "
15984 			    "cannot deactivate SATA port %d:%d",
15985 			    cport, pmport));
15986 			rv = EIO;
15987 		} else {
15988 			pmportinfo->pmport_state |= SATA_PSTATE_SHUTDOWN;
15989 		}
15990 		mutex_exit(&pmportinfo->pmport_mutex);
15991 	}
15992 
15993 	mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex);
15994 
15995 	return (rv);
15996 }
15997 
15998 /*
15999  * Process ioctl port activate request.
16000  *
16001  * NOTE: Port multiplier is supported now.
16002  */
16003 static int
16004 sata_ioctl_activate(sata_hba_inst_t *sata_hba_inst,
16005     sata_device_t *sata_device)
16006 {
16007 	int cport, pmport, qual;
16008 	sata_cport_info_t *cportinfo;
16009 	sata_pmport_info_t *pmportinfo = NULL;
16010 	boolean_t dev_existed = B_TRUE;
16011 
16012 	/* Sanity check */
16013 	if (SATA_PORT_ACTIVATE_FUNC(sata_hba_inst) == NULL)
16014 		return (ENOTSUP);
16015 
16016 	cport = sata_device->satadev_addr.cport;
16017 	pmport = sata_device->satadev_addr.pmport;
16018 	qual = sata_device->satadev_addr.qual;
16019 
16020 	cportinfo = SATA_CPORT_INFO(sata_hba_inst, cport);
16021 
16022 	/*
16023 	 * The qual translate from ap_id (by SCSI_TO_SATA_ADDR_QUAL())
16024 	 * is a device. But what we are dealing with is port/pmport.
16025 	 */
16026 	ASSERT(qual == SATA_ADDR_DCPORT || qual == SATA_ADDR_DPMPORT);
16027 	if (qual == SATA_ADDR_DCPORT)
16028 		sata_device->satadev_addr.qual = qual = SATA_ADDR_CPORT;
16029 	else
16030 		sata_device->satadev_addr.qual = qual = SATA_ADDR_PMPORT;
16031 
16032 	mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex);
16033 	if (qual == SATA_ADDR_PMPORT) {
16034 		pmportinfo = SATA_PMPORT_INFO(sata_hba_inst, cport, pmport);
16035 		if (pmportinfo->pmport_state & SATA_PSTATE_SHUTDOWN ||
16036 		    pmportinfo->pmport_dev_type == SATA_DTYPE_NONE)
16037 			dev_existed = B_FALSE;
16038 	} else { /* cport */
16039 		if (cportinfo->cport_state & SATA_PSTATE_SHUTDOWN ||
16040 		    cportinfo->cport_dev_type == SATA_DTYPE_NONE)
16041 			dev_existed = B_FALSE;
16042 	}
16043 	mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex);
16044 
16045 	/* Just let HBA driver to activate port, if necessary */
16046 	if ((*SATA_PORT_ACTIVATE_FUNC(sata_hba_inst))
16047 	    (SATA_DIP(sata_hba_inst), sata_device) != SATA_SUCCESS) {
16048 		/*
16049 		 * Port activation failure - do not change port state unless
16050 		 * the state returned by HBA indicates a port failure.
16051 		 */
16052 		mutex_enter(&SATA_CPORT_INFO(sata_hba_inst,
16053 		    cport)->cport_mutex);
16054 		sata_update_port_info(sata_hba_inst, sata_device);
16055 		if (sata_device->satadev_state & SATA_PSTATE_FAILED) {
16056 			if (qual == SATA_ADDR_PMPORT) {
16057 				mutex_enter(&pmportinfo->pmport_mutex);
16058 				pmportinfo->pmport_state = SATA_PSTATE_FAILED;
16059 				mutex_exit(&pmportinfo->pmport_mutex);
16060 			} else
16061 				cportinfo->cport_state = SATA_PSTATE_FAILED;
16062 
16063 			mutex_exit(&SATA_CPORT_INFO(sata_hba_inst,
16064 			    cport)->cport_mutex);
16065 			SATA_LOG_D((sata_hba_inst, CE_WARN,
16066 			    "sata_hba_ioctl: port activate: cannot activate "
16067 			    "SATA port %d:%d", cport, pmport));
16068 			return (EIO);
16069 		}
16070 		mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex);
16071 	}
16072 	mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex);
16073 	if (qual == SATA_ADDR_PMPORT) {
16074 		mutex_enter(&pmportinfo->pmport_mutex);
16075 		pmportinfo->pmport_state &= ~SATA_PSTATE_SHUTDOWN;
16076 		mutex_exit(&pmportinfo->pmport_mutex);
16077 	} else
16078 		cportinfo->cport_state &= ~SATA_PSTATE_SHUTDOWN;
16079 	mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex);
16080 
16081 	/*
16082 	 * Re-probe port to find its current state and possibly attached device.
16083 	 * Port re-probing may change the cportinfo device type if device is
16084 	 * found attached.
16085 	 * If port probing failed, the device type would be set to
16086 	 * SATA_DTYPE_NONE.
16087 	 */
16088 	(void) sata_reprobe_port(sata_hba_inst, sata_device,
16089 	    SATA_DEV_IDENTIFY_RETRY);
16090 
16091 	/*
16092 	 * Generate sysevent - EC_DR / ESC_DR_AP_STATE_CHANGE
16093 	 * without the hint.
16094 	 */
16095 	sata_gen_sysevent(sata_hba_inst, &sata_device->satadev_addr,
16096 	    SE_NO_HINT);
16097 
16098 	if (dev_existed == B_FALSE) {
16099 		if (qual == SATA_ADDR_PMPORT &&
16100 		    pmportinfo->pmport_dev_type != SATA_DTYPE_NONE) {
16101 			/*
16102 			 * That's the transition from the "inactive" port state
16103 			 * or the active port without a device attached to the
16104 			 * active port state with a device attached.
16105 			 */
16106 			sata_log(sata_hba_inst, CE_WARN,
16107 			    "SATA device detected at port %d:%d",
16108 			    cport, pmport);
16109 		} else if (qual == SATA_ADDR_CPORT &&
16110 		    cportinfo->cport_dev_type != SATA_DTYPE_NONE) {
16111 			/*
16112 			 * That's the transition from the "inactive" port state
16113 			 * or the active port without a device attached to the
16114 			 * active port state with a device attached.
16115 			 */
16116 			if (cportinfo->cport_dev_type != SATA_DTYPE_PMULT) {
16117 				sata_log(sata_hba_inst, CE_WARN,
16118 				    "SATA device detected at port %d", cport);
16119 			} else {
16120 				sata_log(sata_hba_inst, CE_WARN,
16121 				    "SATA port multiplier detected at port %d",
16122 				    cport);
16123 			}
16124 		}
16125 	}
16126 	return (0);
16127 }
16128 
16129 
16130 
16131 /*
16132  * Process ioctl reset port request.
16133  *
16134  * NOTE: Port-Multiplier is supported.
16135  */
16136 static int
16137 sata_ioctl_reset_port(sata_hba_inst_t *sata_hba_inst,
16138     sata_device_t *sata_device)
16139 {
16140 	int cport, pmport, qual;
16141 	int rv = 0;
16142 
16143 	cport = sata_device->satadev_addr.cport;
16144 	pmport = sata_device->satadev_addr.pmport;
16145 	qual = sata_device->satadev_addr.qual;
16146 
16147 	/*
16148 	 * The qual translate from ap_id (by SCSI_TO_SATA_ADDR_QUAL())
16149 	 * is a device. But what we are dealing with is port/pmport.
16150 	 */
16151 	if (qual == SATA_ADDR_DCPORT)
16152 		sata_device->satadev_addr.qual = qual = SATA_ADDR_CPORT;
16153 	else
16154 		sata_device->satadev_addr.qual = qual = SATA_ADDR_PMPORT;
16155 	ASSERT(qual == SATA_ADDR_CPORT || qual == SATA_ADDR_PMPORT);
16156 
16157 	/* Sanity check */
16158 	if (SATA_RESET_DPORT_FUNC(sata_hba_inst) == NULL) {
16159 		SATA_LOG_D((sata_hba_inst, CE_WARN,
16160 		    "sata_hba_ioctl: sata_hba_tran missing required "
16161 		    "function sata_tran_reset_dport"));
16162 		return (ENOTSUP);
16163 	}
16164 
16165 	/* Ask HBA to reset port */
16166 	if ((*SATA_RESET_DPORT_FUNC(sata_hba_inst))(SATA_DIP(sata_hba_inst),
16167 	    sata_device) != SATA_SUCCESS) {
16168 		SATA_LOG_D((sata_hba_inst, CE_WARN,
16169 		    "sata_hba_ioctl: reset port: failed %d:%d",
16170 		    cport, pmport));
16171 		mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, cport)->
16172 		    cport_mutex);
16173 		sata_update_port_info(sata_hba_inst, sata_device);
16174 		if (qual == SATA_ADDR_CPORT)
16175 			SATA_CPORT_STATE(sata_hba_inst, cport) =
16176 			    SATA_PSTATE_FAILED;
16177 		else {
16178 			mutex_enter(&SATA_PMPORT_MUTEX(sata_hba_inst, cport,
16179 			    pmport));
16180 			SATA_PMPORT_STATE(sata_hba_inst, cport, pmport) =
16181 			    SATA_PSTATE_FAILED;
16182 			mutex_exit(&SATA_PMPORT_MUTEX(sata_hba_inst, cport,
16183 			    pmport));
16184 		}
16185 		mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)->
16186 		    cport_mutex);
16187 		rv = EIO;
16188 	}
16189 
16190 	return (rv);
16191 }
16192 
16193 /*
16194  * Process ioctl reset device request.
16195  *
16196  * NOTE: Port multiplier is supported.
16197  */
16198 static int
16199 sata_ioctl_reset_device(sata_hba_inst_t *sata_hba_inst,
16200     sata_device_t *sata_device)
16201 {
16202 	sata_drive_info_t *sdinfo = NULL;
16203 	sata_pmult_info_t *pmultinfo = NULL;
16204 	int cport, pmport;
16205 	int rv = 0;
16206 
16207 	/* Sanity check */
16208 	if (SATA_RESET_DPORT_FUNC(sata_hba_inst) == NULL) {
16209 		SATA_LOG_D((sata_hba_inst, CE_WARN,
16210 		    "sata_hba_ioctl: sata_hba_tran missing required "
16211 		    "function sata_tran_reset_dport"));
16212 		return (ENOTSUP);
16213 	}
16214 
16215 	cport = sata_device->satadev_addr.cport;
16216 	pmport = sata_device->satadev_addr.pmport;
16217 
16218 	mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex);
16219 	if (sata_device->satadev_addr.qual == SATA_ADDR_DCPORT) {
16220 		if (SATA_CPORT_DEV_TYPE(sata_hba_inst, cport) ==
16221 		    SATA_DTYPE_PMULT)
16222 			pmultinfo = SATA_CPORT_INFO(sata_hba_inst, cport)->
16223 			    cport_devp.cport_sata_pmult;
16224 		else
16225 			sdinfo = SATA_CPORT_DRV_INFO(sata_hba_inst,
16226 			    sata_device->satadev_addr.cport);
16227 	} else { /* port multiplier */
16228 		sata_device->satadev_addr.qual = SATA_ADDR_DPMPORT;
16229 		sdinfo = SATA_PMPORT_DRV_INFO(sata_hba_inst,
16230 		    sata_device->satadev_addr.cport,
16231 		    sata_device->satadev_addr.pmport);
16232 	}
16233 	if (sdinfo == NULL && pmultinfo == NULL) {
16234 		mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex);
16235 		return (EINVAL);
16236 	}
16237 	mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex);
16238 
16239 	/* Ask HBA to reset device */
16240 	if ((*SATA_RESET_DPORT_FUNC(sata_hba_inst))
16241 	    (SATA_DIP(sata_hba_inst), sata_device) != SATA_SUCCESS) {
16242 		SATA_LOG_D((sata_hba_inst, CE_WARN,
16243 		    "sata_hba_ioctl: reset device: failed at port %d:%d",
16244 		    cport, pmport));
16245 		mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, cport)->
16246 		    cport_mutex);
16247 		sata_update_port_info(sata_hba_inst, sata_device);
16248 		/*
16249 		 * Device info structure remains attached. Another device reset
16250 		 * or port disconnect/connect and re-probing is
16251 		 * needed to change it's state
16252 		 */
16253 		if (sdinfo != NULL) {
16254 			sdinfo->satadrv_state &= ~SATA_STATE_READY;
16255 			sdinfo->satadrv_state |= SATA_DSTATE_FAILED;
16256 		} else if (pmultinfo != NULL) {
16257 			pmultinfo->pmult_state &= ~SATA_STATE_READY;
16258 			pmultinfo->pmult_state |= SATA_DSTATE_FAILED;
16259 		}
16260 
16261 		mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex);
16262 		rv = EIO;
16263 	}
16264 	/*
16265 	 * If attached device was a port multiplier, some extra processing
16266 	 * may be needed to bring it back. SATA specification requies a
16267 	 * mandatory software reset on host port to reliably enumerate a port
16268 	 * multiplier, the HBA driver should handle that after reset
16269 	 * operation.
16270 	 */
16271 	return (rv);
16272 }
16273 
16274 
16275 /*
16276  * Process ioctl reset all request.
16277  */
16278 static int
16279 sata_ioctl_reset_all(sata_hba_inst_t *sata_hba_inst)
16280 {
16281 	sata_device_t sata_device;
16282 	int rv = 0;
16283 	int tcport;
16284 
16285 	sata_device.satadev_rev = SATA_DEVICE_REV;
16286 
16287 	/*
16288 	 * There is no protection here for configured devices.
16289 	 */
16290 	/* Sanity check */
16291 	if (SATA_RESET_DPORT_FUNC(sata_hba_inst) == NULL) {
16292 		SATA_LOG_D((sata_hba_inst, CE_WARN,
16293 		    "sata_hba_ioctl: sata_hba_tran missing required "
16294 		    "function sata_tran_reset_dport"));
16295 		return (ENOTSUP);
16296 	}
16297 
16298 	/*
16299 	 * Need to lock all ports, not just one.
16300 	 * If any port is locked by event processing, fail the whole operation.
16301 	 * One port is already locked, but for simplicity lock it again.
16302 	 */
16303 	for (tcport = 0; tcport < SATA_NUM_CPORTS(sata_hba_inst); tcport++) {
16304 		mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, tcport)->
16305 		    cport_mutex);
16306 		if (((SATA_CPORT_INFO(sata_hba_inst, tcport)->
16307 		    cport_event_flags) & SATA_EVNT_LOCK_PORT_BUSY) != 0) {
16308 			mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, tcport)->
16309 			    cport_mutex);
16310 			rv = EBUSY;
16311 			break;
16312 		} else {
16313 			/*
16314 			 * It is enough to lock cport in command-based
16315 			 * switching mode.
16316 			 */
16317 			SATA_CPORT_INFO(sata_hba_inst, tcport)->
16318 			    cport_event_flags |= SATA_APCTL_LOCK_PORT_BUSY;
16319 		}
16320 		mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, tcport)->
16321 		    cport_mutex);
16322 	}
16323 
16324 	if (rv == 0) {
16325 		/*
16326 		 * All cports were successfully locked.
16327 		 * Reset main SATA controller.
16328 		 * Set the device address to port 0, to have a valid device
16329 		 * address.
16330 		 */
16331 		sata_device.satadev_addr.qual = SATA_ADDR_CNTRL;
16332 		sata_device.satadev_addr.cport = 0;
16333 		sata_device.satadev_addr.pmport = 0;
16334 
16335 		if ((*SATA_RESET_DPORT_FUNC(sata_hba_inst))
16336 		    (SATA_DIP(sata_hba_inst), &sata_device) != SATA_SUCCESS) {
16337 			SATA_LOG_D((sata_hba_inst, CE_WARN,
16338 			    "sata_hba_ioctl: reset controller failed"));
16339 			return (EIO);
16340 		}
16341 	}
16342 	/*
16343 	 * Unlock all ports
16344 	 */
16345 	for (tcport = 0; tcport < SATA_NUM_CPORTS(sata_hba_inst); tcport++) {
16346 		mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, tcport)->
16347 		    cport_mutex);
16348 		SATA_CPORT_INFO(sata_hba_inst, tcport)->
16349 		    cport_event_flags &= ~SATA_APCTL_LOCK_PORT_BUSY;
16350 		mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, tcport)->
16351 		    cport_mutex);
16352 	}
16353 
16354 	/*
16355 	 * This operation returns EFAULT if either reset
16356 	 * controller failed or a re-probing of any port failed.
16357 	 */
16358 	return (rv);
16359 }
16360 
16361 
16362 /*
16363  * Process ioctl port self test request.
16364  *
16365  * NOTE: Port multiplier code is not completed nor tested.
16366  */
16367 static int
16368 sata_ioctl_port_self_test(sata_hba_inst_t *sata_hba_inst,
16369     sata_device_t *sata_device)
16370 {
16371 	int cport, pmport, qual;
16372 	int rv = 0;
16373 
16374 	/* Sanity check */
16375 	if (SATA_SELFTEST_FUNC(sata_hba_inst) == NULL)
16376 		return (ENOTSUP);
16377 
16378 	cport = sata_device->satadev_addr.cport;
16379 	pmport = sata_device->satadev_addr.pmport;
16380 	qual = sata_device->satadev_addr.qual;
16381 
16382 	/*
16383 	 * There is no protection here for a configured
16384 	 * device attached to this port.
16385 	 */
16386 
16387 	if ((*SATA_SELFTEST_FUNC(sata_hba_inst))
16388 	    (SATA_DIP(sata_hba_inst), sata_device) != SATA_SUCCESS) {
16389 		SATA_LOG_D((sata_hba_inst, CE_WARN,
16390 		    "sata_hba_ioctl: port selftest: "
16391 		    "failed port %d:%d", cport, pmport));
16392 		mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, cport)->
16393 		    cport_mutex);
16394 		sata_update_port_info(sata_hba_inst, sata_device);
16395 		if (qual == SATA_ADDR_CPORT)
16396 			SATA_CPORT_STATE(sata_hba_inst, cport) =
16397 			    SATA_PSTATE_FAILED;
16398 		else { /* port multiplier device port */
16399 			mutex_enter(&SATA_PMPORT_MUTEX(sata_hba_inst,
16400 			    cport, pmport));
16401 			SATA_PMPORT_STATE(sata_hba_inst, cport, pmport) =
16402 			    SATA_PSTATE_FAILED;
16403 			mutex_exit(&SATA_PMPORT_MUTEX(sata_hba_inst,
16404 			    cport, pmport));
16405 		}
16406 
16407 		mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)->
16408 		    cport_mutex);
16409 		return (EIO);
16410 	}
16411 	/*
16412 	 * Beacuse the port was reset in the course of testing, it should be
16413 	 * re-probed and attached device state should be restored. At this
16414 	 * point the port state is unknown - it's state is HBA-specific.
16415 	 * Force port re-probing to get it into a known state.
16416 	 */
16417 	if (sata_reprobe_port(sata_hba_inst, sata_device,
16418 	    SATA_DEV_IDENTIFY_RETRY) != SATA_SUCCESS)
16419 		rv = EIO;
16420 	return (rv);
16421 }
16422 
16423 
16424 /*
16425  * sata_cfgadm_state:
16426  * Use the sata port state and state of the target node to figure out
16427  * the cfgadm_state.
16428  *
16429  * The port argument is a value with encoded cport,
16430  * pmport and address qualifier, in the same manner as a scsi target number.
16431  * SCSI_TO_SATA_CPORT macro extracts cport number,
16432  * SCSI_TO_SATA_PMPORT extracts pmport number and
16433  * SCSI_TO_SATA_ADDR_QUAL extracts port mulitplier qualifier flag.
16434  *
16435  * Port multiplier is supported.
16436  */
16437 
16438 static void
16439 sata_cfgadm_state(sata_hba_inst_t *sata_hba_inst, int32_t port,
16440     devctl_ap_state_t *ap_state)
16441 {
16442 	uint8_t		cport, pmport, qual;
16443 	uint32_t	port_state, pmult_state;
16444 	uint32_t	dev_type;
16445 	sata_drive_info_t *sdinfo;
16446 
16447 	cport = SCSI_TO_SATA_CPORT(port);
16448 	pmport = SCSI_TO_SATA_PMPORT(port);
16449 	qual = SCSI_TO_SATA_ADDR_QUAL(port);
16450 
16451 	/* Check cport state */
16452 	port_state = SATA_CPORT_STATE(sata_hba_inst, cport);
16453 	if (port_state & SATA_PSTATE_SHUTDOWN ||
16454 	    port_state & SATA_PSTATE_FAILED) {
16455 		ap_state->ap_rstate = AP_RSTATE_DISCONNECTED;
16456 		ap_state->ap_ostate = AP_OSTATE_UNCONFIGURED;
16457 		if (port_state & SATA_PSTATE_FAILED)
16458 			ap_state->ap_condition = AP_COND_FAILED;
16459 		else
16460 			ap_state->ap_condition = AP_COND_UNKNOWN;
16461 
16462 		return;
16463 	}
16464 
16465 	/* cport state is okay. Now check pmport state */
16466 	if (qual == SATA_ADDR_DPMPORT || qual == SATA_ADDR_PMPORT) {
16467 		/* Sanity check */
16468 		if (SATA_CPORT_DEV_TYPE(sata_hba_inst, cport) !=
16469 		    SATA_DTYPE_PMULT || SATA_PMPORT_INFO(sata_hba_inst,
16470 		    cport, pmport) == NULL)
16471 			return;
16472 		port_state = SATA_PMPORT_STATE(sata_hba_inst, cport, pmport);
16473 		if (port_state & SATA_PSTATE_SHUTDOWN ||
16474 		    port_state & SATA_PSTATE_FAILED) {
16475 			ap_state->ap_rstate = AP_RSTATE_DISCONNECTED;
16476 			ap_state->ap_ostate = AP_OSTATE_UNCONFIGURED;
16477 			if (port_state & SATA_PSTATE_FAILED)
16478 				ap_state->ap_condition = AP_COND_FAILED;
16479 			else
16480 				ap_state->ap_condition = AP_COND_UNKNOWN;
16481 
16482 			return;
16483 		}
16484 	}
16485 
16486 	/* Port is enabled and ready */
16487 	if (qual == SATA_ADDR_DCPORT || qual == SATA_ADDR_CPORT)
16488 		dev_type = SATA_CPORT_DEV_TYPE(sata_hba_inst, cport);
16489 	else
16490 		dev_type = SATA_PMPORT_DEV_TYPE(sata_hba_inst, cport, pmport);
16491 
16492 	switch (dev_type) {
16493 	case SATA_DTYPE_NONE:
16494 	{
16495 		ap_state->ap_ostate = AP_OSTATE_UNCONFIGURED;
16496 		ap_state->ap_condition = AP_COND_OK;
16497 		/* No device attached */
16498 		ap_state->ap_rstate = AP_RSTATE_EMPTY;
16499 		break;
16500 	}
16501 	case SATA_DTYPE_PMULT:
16502 	{
16503 		/* Need to check port multiplier state */
16504 		ASSERT(qual == SATA_ADDR_DCPORT);
16505 		pmult_state = SATA_PMULT_INFO(sata_hba_inst, cport)->
16506 		    pmult_state;
16507 		if (pmult_state & (SATA_PSTATE_SHUTDOWN|SATA_PSTATE_FAILED)) {
16508 			ap_state->ap_rstate = AP_RSTATE_DISCONNECTED;
16509 			ap_state->ap_ostate = AP_OSTATE_UNCONFIGURED;
16510 			if (pmult_state & SATA_PSTATE_FAILED)
16511 				ap_state->ap_condition = AP_COND_FAILED;
16512 			else
16513 				ap_state->ap_condition = AP_COND_UNKNOWN;
16514 
16515 			return;
16516 		}
16517 
16518 		/* Port multiplier is not configurable */
16519 		ap_state->ap_ostate = AP_OSTATE_CONFIGURED;
16520 		ap_state->ap_rstate = AP_RSTATE_CONNECTED;
16521 		ap_state->ap_condition = AP_COND_OK;
16522 		break;
16523 	}
16524 
16525 	case SATA_DTYPE_ATADISK:
16526 	case SATA_DTYPE_ATAPICD:
16527 	case SATA_DTYPE_ATAPITAPE:
16528 	case SATA_DTYPE_ATAPIDISK:
16529 	{
16530 		dev_info_t *tdip = NULL;
16531 		dev_info_t *dip = NULL;
16532 
16533 		dip = SATA_DIP(sata_hba_inst);
16534 		tdip = sata_get_target_dip(dip, cport, pmport);
16535 		ap_state->ap_rstate = AP_RSTATE_CONNECTED;
16536 		if (tdip != NULL) {
16537 			ndi_devi_enter(dip);
16538 			mutex_enter(&(DEVI(tdip)->devi_lock));
16539 			if (DEVI_IS_DEVICE_REMOVED(tdip)) {
16540 				/*
16541 				 * There could be the case where previously
16542 				 * configured and opened device was removed
16543 				 * and unknown device was plugged.
16544 				 * In such case we want to show a device, and
16545 				 * its configured or unconfigured state but
16546 				 * indicate unusable condition untill the
16547 				 * old target node is released and removed.
16548 				 */
16549 				ap_state->ap_condition = AP_COND_UNUSABLE;
16550 			} else {
16551 				mutex_enter(&SATA_CPORT_MUTEX(sata_hba_inst,
16552 				    cport));
16553 				sdinfo = SATA_CPORT_DRV_INFO(sata_hba_inst,
16554 				    cport);
16555 				if (sdinfo != NULL) {
16556 					if ((sdinfo->satadrv_state &
16557 					    SATA_DSTATE_FAILED) != 0)
16558 						ap_state->ap_condition =
16559 						    AP_COND_FAILED;
16560 					else
16561 						ap_state->ap_condition =
16562 						    AP_COND_OK;
16563 				} else {
16564 					ap_state->ap_condition =
16565 					    AP_COND_UNKNOWN;
16566 				}
16567 				mutex_exit(&SATA_CPORT_MUTEX(sata_hba_inst,
16568 				    cport));
16569 			}
16570 			if ((DEVI_IS_DEVICE_OFFLINE(tdip)) ||
16571 			    (DEVI_IS_DEVICE_DOWN(tdip))) {
16572 				ap_state->ap_ostate =
16573 				    AP_OSTATE_UNCONFIGURED;
16574 			} else {
16575 				ap_state->ap_ostate =
16576 				    AP_OSTATE_CONFIGURED;
16577 			}
16578 			mutex_exit(&(DEVI(tdip)->devi_lock));
16579 			ndi_devi_exit(dip);
16580 		} else {
16581 			ap_state->ap_ostate = AP_OSTATE_UNCONFIGURED;
16582 			ap_state->ap_condition = AP_COND_UNKNOWN;
16583 		}
16584 		break;
16585 	}
16586 	case SATA_DTYPE_ATAPIPROC:
16587 		ap_state->ap_rstate = AP_RSTATE_CONNECTED;
16588 		ap_state->ap_ostate = AP_OSTATE_UNCONFIGURED;
16589 		ap_state->ap_condition = AP_COND_OK;
16590 		break;
16591 	default:
16592 		ap_state->ap_rstate = AP_RSTATE_CONNECTED;
16593 		ap_state->ap_ostate = AP_OSTATE_UNCONFIGURED;
16594 		ap_state->ap_condition = AP_COND_UNKNOWN;
16595 		/*
16596 		 * This is actually internal error condition (non fatal),
16597 		 * because we have already checked all defined device types.
16598 		 */
16599 		SATA_LOG_D((sata_hba_inst, CE_WARN,
16600 		    "sata_cfgadm_state: Internal error: "
16601 		    "unknown device type"));
16602 		break;
16603 	}
16604 }
16605 
16606 
16607 /*
16608  * Process ioctl get device path request.
16609  *
16610  * NOTE: Port multiplier has no target dip. Devices connected to port
16611  * multiplier have target node attached to the HBA node. The only difference
16612  * between them and the directly-attached device node is a target address.
16613  */
16614 static int
16615 sata_ioctl_get_device_path(sata_hba_inst_t *sata_hba_inst,
16616     sata_device_t *sata_device, sata_ioctl_data_t *ioc, int mode)
16617 {
16618 	char path[MAXPATHLEN];
16619 	uint32_t size;
16620 	dev_info_t *tdip;
16621 
16622 	(void) strcpy(path, "/devices");
16623 	if ((tdip = sata_get_scsi_target_dip(SATA_DIP(sata_hba_inst),
16624 	    &sata_device->satadev_addr)) == NULL) {
16625 		/*
16626 		 * No such device. If this is a request for a size, do not
16627 		 * return EINVAL for non-existing target, because cfgadm
16628 		 * will then indicate a meaningless ioctl failure.
16629 		 * If this is a request for a path, indicate invalid
16630 		 * argument.
16631 		 */
16632 		if (ioc->get_size == 0)
16633 			return (EINVAL);
16634 	} else {
16635 		(void) ddi_pathname(tdip, path + strlen(path));
16636 	}
16637 	size = strlen(path) + 1;
16638 
16639 	if (ioc->get_size != 0) {
16640 		if (ddi_copyout((void *)&size, ioc->buf, ioc->bufsiz,
16641 		    mode) != 0)
16642 			return (EFAULT);
16643 	} else {
16644 		if (ioc->bufsiz != size)
16645 			return (EINVAL);
16646 
16647 		else if (ddi_copyout((void *)&path, ioc->buf, ioc->bufsiz,
16648 		    mode) != 0)
16649 			return (EFAULT);
16650 	}
16651 	return (0);
16652 }
16653 
16654 /*
16655  * Process ioctl get attachment point type request.
16656  *
16657  * NOTE: Port multiplier is supported.
16658  */
16659 static	int
16660 sata_ioctl_get_ap_type(sata_hba_inst_t *sata_hba_inst,
16661     sata_device_t *sata_device, sata_ioctl_data_t *ioc, int mode)
16662 {
16663 	uint32_t	type_len;
16664 	const char	*ap_type;
16665 	int		dev_type;
16666 
16667 	if (sata_device->satadev_addr.qual == SATA_ADDR_DCPORT)
16668 		dev_type = SATA_CPORT_DEV_TYPE(sata_hba_inst,
16669 		    sata_device->satadev_addr.cport);
16670 	else /* pmport */
16671 		dev_type = SATA_PMPORT_DEV_TYPE(sata_hba_inst,
16672 		    sata_device->satadev_addr.cport,
16673 		    sata_device->satadev_addr.pmport);
16674 
16675 	switch (dev_type) {
16676 	case SATA_DTYPE_NONE:
16677 		ap_type = "port";
16678 		break;
16679 
16680 	case SATA_DTYPE_ATADISK:
16681 	case SATA_DTYPE_ATAPIDISK:
16682 		ap_type = "disk";
16683 		break;
16684 
16685 	case SATA_DTYPE_ATAPICD:
16686 		ap_type = "cd/dvd";
16687 		break;
16688 
16689 	case SATA_DTYPE_ATAPITAPE:
16690 		ap_type = "tape";
16691 		break;
16692 
16693 	case SATA_DTYPE_ATAPIPROC:
16694 		ap_type = "processor";
16695 		break;
16696 
16697 	case SATA_DTYPE_PMULT:
16698 		ap_type = "sata-pmult";
16699 		break;
16700 
16701 	case SATA_DTYPE_UNKNOWN:
16702 		ap_type = "unknown";
16703 		break;
16704 
16705 	default:
16706 		ap_type = "unsupported";
16707 		break;
16708 
16709 	} /* end of dev_type switch */
16710 
16711 	type_len = strlen(ap_type) + 1;
16712 
16713 	if (ioc->get_size) {
16714 		if (ddi_copyout((void *)&type_len, ioc->buf, ioc->bufsiz,
16715 		    mode) != 0)
16716 			return (EFAULT);
16717 	} else {
16718 		if (ioc->bufsiz != type_len)
16719 			return (EINVAL);
16720 
16721 		if (ddi_copyout((void *)ap_type, ioc->buf,
16722 		    ioc->bufsiz, mode) != 0)
16723 			return (EFAULT);
16724 	}
16725 	return (0);
16726 
16727 }
16728 
16729 /*
16730  * Process ioctl get device model info request.
16731  * This operation should return to cfgadm the device model
16732  * information string
16733  *
16734  * NOTE: Port multiplier is supported.
16735  */
16736 static	int
16737 sata_ioctl_get_model_info(sata_hba_inst_t *sata_hba_inst,
16738     sata_device_t *sata_device, sata_ioctl_data_t *ioc, int mode)
16739 {
16740 	sata_drive_info_t *sdinfo;
16741 	uint32_t info_len;
16742 	char ap_info[SATA_ID_MODEL_LEN + 1];
16743 
16744 	mutex_enter(&SATA_CPORT_INFO(sata_hba_inst,
16745 	    sata_device->satadev_addr.cport)->cport_mutex);
16746 	if (sata_device->satadev_addr.qual == SATA_ADDR_DCPORT)
16747 		sdinfo = SATA_CPORT_DRV_INFO(sata_hba_inst,
16748 		    sata_device->satadev_addr.cport);
16749 	else /* port multiplier */
16750 		sdinfo = SATA_PMPORT_DRV_INFO(sata_hba_inst,
16751 		    sata_device->satadev_addr.cport,
16752 		    sata_device->satadev_addr.pmport);
16753 	if (sdinfo == NULL) {
16754 		mutex_exit(&SATA_CPORT_INFO(sata_hba_inst,
16755 		    sata_device->satadev_addr.cport)->cport_mutex);
16756 		return (EINVAL);
16757 	}
16758 
16759 #ifdef	_LITTLE_ENDIAN
16760 	swab(sdinfo->satadrv_id.ai_model, ap_info, SATA_ID_MODEL_LEN);
16761 #else	/* _LITTLE_ENDIAN */
16762 	bcopy(sdinfo->satadrv_id.ai_model, ap_info, SATA_ID_MODEL_LEN);
16763 #endif	/* _LITTLE_ENDIAN */
16764 
16765 	mutex_exit(&SATA_CPORT_INFO(sata_hba_inst,
16766 	    sata_device->satadev_addr.cport)->cport_mutex);
16767 
16768 	ap_info[SATA_ID_MODEL_LEN] = '\0';
16769 
16770 	info_len = strlen(ap_info) + 1;
16771 
16772 	if (ioc->get_size) {
16773 		if (ddi_copyout((void *)&info_len, ioc->buf, ioc->bufsiz,
16774 		    mode) != 0)
16775 			return (EFAULT);
16776 	} else {
16777 		if (ioc->bufsiz < info_len)
16778 			return (EINVAL);
16779 		if (ddi_copyout((void *)ap_info, ioc->buf, ioc->bufsiz,
16780 		    mode) != 0)
16781 			return (EFAULT);
16782 	}
16783 	return (0);
16784 }
16785 
16786 
16787 /*
16788  * Process ioctl get device firmware revision info request.
16789  * This operation should return to cfgadm the device firmware revision
16790  * information string
16791  *
16792  * Port multiplier is supported.
16793  */
16794 static	int
16795 sata_ioctl_get_revfirmware_info(sata_hba_inst_t *sata_hba_inst,
16796     sata_device_t *sata_device, sata_ioctl_data_t *ioc, int mode)
16797 {
16798 	sata_drive_info_t *sdinfo;
16799 	uint32_t info_len;
16800 	char ap_info[SATA_ID_FW_LEN + 1];
16801 
16802 	mutex_enter(&SATA_CPORT_INFO(sata_hba_inst,
16803 	    sata_device->satadev_addr.cport)->cport_mutex);
16804 	if (sata_device->satadev_addr.qual == SATA_ADDR_DCPORT)
16805 		sdinfo = SATA_CPORT_DRV_INFO(sata_hba_inst,
16806 		    sata_device->satadev_addr.cport);
16807 	else /* port multiplier */
16808 		sdinfo = SATA_PMPORT_DRV_INFO(sata_hba_inst,
16809 		    sata_device->satadev_addr.cport,
16810 		    sata_device->satadev_addr.pmport);
16811 	if (sdinfo == NULL) {
16812 		mutex_exit(&SATA_CPORT_INFO(sata_hba_inst,
16813 		    sata_device->satadev_addr.cport)->cport_mutex);
16814 		return (EINVAL);
16815 	}
16816 
16817 #ifdef	_LITTLE_ENDIAN
16818 	swab(sdinfo->satadrv_id.ai_fw, ap_info, SATA_ID_FW_LEN);
16819 #else	/* _LITTLE_ENDIAN */
16820 	bcopy(sdinfo->satadrv_id.ai_fw, ap_info, SATA_ID_FW_LEN);
16821 #endif	/* _LITTLE_ENDIAN */
16822 
16823 	mutex_exit(&SATA_CPORT_INFO(sata_hba_inst,
16824 	    sata_device->satadev_addr.cport)->cport_mutex);
16825 
16826 	ap_info[SATA_ID_FW_LEN] = '\0';
16827 
16828 	info_len = strlen(ap_info) + 1;
16829 
16830 	if (ioc->get_size) {
16831 		if (ddi_copyout((void *)&info_len, ioc->buf, ioc->bufsiz,
16832 		    mode) != 0)
16833 			return (EFAULT);
16834 	} else {
16835 		if (ioc->bufsiz < info_len)
16836 			return (EINVAL);
16837 		if (ddi_copyout((void *)ap_info, ioc->buf, ioc->bufsiz,
16838 		    mode) != 0)
16839 			return (EFAULT);
16840 	}
16841 	return (0);
16842 }
16843 
16844 
16845 /*
16846  * Process ioctl get device serial number info request.
16847  * This operation should return to cfgadm the device serial number string.
16848  *
16849  * NOTE: Port multiplier is supported.
16850  */
16851 static	int
16852 sata_ioctl_get_serialnumber_info(sata_hba_inst_t *sata_hba_inst,
16853     sata_device_t *sata_device, sata_ioctl_data_t *ioc, int mode)
16854 {
16855 	sata_drive_info_t *sdinfo;
16856 	uint32_t info_len;
16857 	char ap_info[SATA_ID_SERIAL_LEN + 1];
16858 
16859 	mutex_enter(&SATA_CPORT_INFO(sata_hba_inst,
16860 	    sata_device->satadev_addr.cport)->cport_mutex);
16861 	if (sata_device->satadev_addr.qual == SATA_ADDR_DCPORT)
16862 		sdinfo = SATA_CPORT_DRV_INFO(sata_hba_inst,
16863 		    sata_device->satadev_addr.cport);
16864 	else /* port multiplier */
16865 		sdinfo = SATA_PMPORT_DRV_INFO(sata_hba_inst,
16866 		    sata_device->satadev_addr.cport,
16867 		    sata_device->satadev_addr.pmport);
16868 	if (sdinfo == NULL) {
16869 		mutex_exit(&SATA_CPORT_INFO(sata_hba_inst,
16870 		    sata_device->satadev_addr.cport)->cport_mutex);
16871 		return (EINVAL);
16872 	}
16873 
16874 #ifdef	_LITTLE_ENDIAN
16875 	swab(sdinfo->satadrv_id.ai_drvser, ap_info, SATA_ID_SERIAL_LEN);
16876 #else	/* _LITTLE_ENDIAN */
16877 	bcopy(sdinfo->satadrv_id.ai_drvser, ap_info, SATA_ID_SERIAL_LEN);
16878 #endif	/* _LITTLE_ENDIAN */
16879 
16880 	mutex_exit(&SATA_CPORT_INFO(sata_hba_inst,
16881 	    sata_device->satadev_addr.cport)->cport_mutex);
16882 
16883 	ap_info[SATA_ID_SERIAL_LEN] = '\0';
16884 
16885 	info_len = strlen(ap_info) + 1;
16886 
16887 	if (ioc->get_size) {
16888 		if (ddi_copyout((void *)&info_len, ioc->buf, ioc->bufsiz,
16889 		    mode) != 0)
16890 			return (EFAULT);
16891 	} else {
16892 		if (ioc->bufsiz < info_len)
16893 			return (EINVAL);
16894 		if (ddi_copyout((void *)ap_info, ioc->buf, ioc->bufsiz,
16895 		    mode) != 0)
16896 			return (EFAULT);
16897 	}
16898 	return (0);
16899 }
16900 
16901 
16902 /*
16903  * Preset scsi extended sense data (to NO SENSE)
16904  * First 18 bytes of the sense data are preset to current valid sense
16905  * with a key NO SENSE data.
16906  *
16907  * Returns void
16908  */
16909 static void
16910 sata_fixed_sense_data_preset(struct scsi_extended_sense *sense)
16911 {
16912 	sense->es_valid = 1;		/* Valid sense */
16913 	sense->es_class = CLASS_EXTENDED_SENSE;	/* 0x70 - current err */
16914 	sense->es_key = KEY_NO_SENSE;
16915 	sense->es_info_1 = 0;
16916 	sense->es_info_2 = 0;
16917 	sense->es_info_3 = 0;
16918 	sense->es_info_4 = 0;
16919 	sense->es_add_len = 10;	/* Additional length - replace with a def */
16920 	sense->es_cmd_info[0] = 0;
16921 	sense->es_cmd_info[1] = 0;
16922 	sense->es_cmd_info[2] = 0;
16923 	sense->es_cmd_info[3] = 0;
16924 	sense->es_add_code = 0;
16925 	sense->es_qual_code = 0;
16926 }
16927 
16928 /*
16929  * Register a legacy cmdk-style devid for the target (disk) device.
16930  *
16931  * Note: This function is called only when the HBA devinfo node has the
16932  * property "use-cmdk-devid-format" set. This property indicates that
16933  * devid compatible with old cmdk (target) driver is to be generated
16934  * for any target device attached to this controller. This will take
16935  * precedence over the devid generated by sd (target) driver.
16936  * This function is derived from cmdk_devid_setup() function in cmdk.c.
16937  */
16938 static void
16939 sata_target_devid_register(dev_info_t *dip, sata_drive_info_t *sdinfo)
16940 {
16941 	char	*hwid;
16942 	int	modlen;
16943 	int	serlen;
16944 	int	rval;
16945 	ddi_devid_t	devid;
16946 
16947 	/*
16948 	 * device ID is a concatanation of model number, "=", serial number.
16949 	 */
16950 	hwid = kmem_zalloc(LEGACY_HWID_LEN, KM_SLEEP);
16951 	bcopy(&sdinfo->satadrv_id.ai_model, hwid,
16952 	    sizeof (sdinfo->satadrv_id.ai_model));
16953 	swab(hwid, hwid, sizeof (sdinfo->satadrv_id.ai_model));
16954 	modlen = sata_check_modser(hwid, sizeof (sdinfo->satadrv_id.ai_model));
16955 	if (modlen == 0)
16956 		goto err;
16957 	hwid[modlen++] = '=';
16958 	bcopy(&sdinfo->satadrv_id.ai_drvser, &hwid[modlen],
16959 	    sizeof (sdinfo->satadrv_id.ai_drvser));
16960 	swab(&hwid[modlen], &hwid[modlen],
16961 	    sizeof (sdinfo->satadrv_id.ai_drvser));
16962 	serlen = sata_check_modser(&hwid[modlen],
16963 	    sizeof (sdinfo->satadrv_id.ai_drvser));
16964 	if (serlen == 0)
16965 		goto err;
16966 	hwid[modlen + serlen] = 0; /* terminate the hwid string */
16967 
16968 	/* initialize/register devid */
16969 	if ((rval = ddi_devid_init(dip, DEVID_ATA_SERIAL,
16970 	    (ushort_t)(modlen + serlen), hwid, &devid)) == DDI_SUCCESS) {
16971 		rval = ddi_devid_register(dip, devid);
16972 		/*
16973 		 * Free up the allocated devid buffer.
16974 		 * NOTE: This doesn't mean unregistering devid.
16975 		 */
16976 		ddi_devid_free(devid);
16977 	}
16978 
16979 	if (rval != DDI_SUCCESS)
16980 		cmn_err(CE_WARN, "sata: failed to create devid for the disk"
16981 		    " on port %d", sdinfo->satadrv_addr.cport);
16982 err:
16983 	kmem_free(hwid, LEGACY_HWID_LEN);
16984 }
16985 
16986 /*
16987  * valid model/serial string must contain a non-zero non-space characters.
16988  * trim trailing spaces/NULLs.
16989  */
16990 static int
16991 sata_check_modser(char *buf, int buf_len)
16992 {
16993 	boolean_t ret;
16994 	char *s;
16995 	int i;
16996 	int tb = 0;
16997 	char ch;
16998 
16999 	ret = B_FALSE;
17000 	s = buf;
17001 	for (i = 0; i < buf_len; i++) {
17002 		ch = *s++;
17003 		if (ch != ' ' && ch != '\0')
17004 			tb = i + 1;
17005 		if (ch != ' ' && ch != '\0' && ch != '0')
17006 			ret = B_TRUE;
17007 	}
17008 
17009 	if (ret == B_FALSE)
17010 		return (0); /* invalid string */
17011 
17012 	return (tb); /* return length */
17013 }
17014 
17015 /*
17016  * sata_set_drive_features function compares current device features setting
17017  * with the saved device features settings and, if there is a difference,
17018  * it restores device features setting to the previously saved state.
17019  * It also arbitrarily tries to select the highest supported DMA mode.
17020  * Device Identify or Identify Packet Device data has to be current.
17021  * At the moment read ahead and write cache are considered for all devices.
17022  * For atapi devices, Removable Media Status Notification is set in addition
17023  * to common features.
17024  *
17025  * This function cannot be called in the interrupt context (it may sleep).
17026  *
17027  * The input argument sdinfo should point to the drive info structure
17028  * to be updated after features are set. Note, that only
17029  * device (packet) identify data is updated, not the flags indicating the
17030  * supported features.
17031  *
17032  * Returns SATA_SUCCESS if successful or there was nothing to do.
17033  * Device Identify data in the drive info structure pointed to by the sdinfo
17034  * arguments is updated even when no features were set or changed.
17035  *
17036  * Returns SATA_FAILURE if device features could not be set or DMA mode
17037  * for a disk cannot be set and device identify data cannot be fetched.
17038  *
17039  * Returns SATA_RETRY if device features could not be set (other than disk
17040  * DMA mode) but the device identify data was fetched successfully.
17041  *
17042  * Note: This function may fail the port, making it inaccessible.
17043  * In such case the explicit port disconnect/connect or physical device
17044  * detach/attach is required to re-evaluate port state again.
17045  */
17046 
17047 static int
17048 sata_set_drive_features(sata_hba_inst_t *sata_hba_inst,
17049     sata_drive_info_t *sdinfo, int restore)
17050 {
17051 	int rval = SATA_SUCCESS;
17052 	int rval_set;
17053 	sata_drive_info_t new_sdinfo;
17054 	char *finfo = "sata_set_drive_features: cannot";
17055 	char *finfox;
17056 	int cache_op;
17057 
17058 	bzero(&new_sdinfo, sizeof (sata_drive_info_t));
17059 	new_sdinfo.satadrv_addr = sdinfo->satadrv_addr;
17060 	new_sdinfo.satadrv_type = sdinfo->satadrv_type;
17061 	if (sata_fetch_device_identify_data(sata_hba_inst, &new_sdinfo) != 0) {
17062 		/*
17063 		 * Cannot get device identification - caller may retry later
17064 		 */
17065 		SATADBG1(SATA_DBG_DEV_SETTINGS, sata_hba_inst,
17066 		    "%s fetch device identify data\n", finfo);
17067 		return (SATA_FAILURE);
17068 	}
17069 	finfox = (restore != 0) ? " restore device features" :
17070 	    " initialize device features\n";
17071 
17072 	switch (sdinfo->satadrv_type) {
17073 	case SATA_DTYPE_ATADISK:
17074 		/* Arbitrarily set UDMA mode */
17075 		if (sata_set_dma_mode(sata_hba_inst, &new_sdinfo) !=
17076 		    SATA_SUCCESS) {
17077 			SATA_LOG_D((sata_hba_inst, CE_WARN,
17078 			    "%s set UDMA mode\n", finfo));
17079 			return (SATA_FAILURE);
17080 		}
17081 		break;
17082 	case SATA_DTYPE_ATAPICD:
17083 	case SATA_DTYPE_ATAPITAPE:
17084 	case SATA_DTYPE_ATAPIDISK:
17085 		/*  Set Removable Media Status Notification, if necessary */
17086 		if (SATA_RM_NOTIFIC_SUPPORTED(new_sdinfo.satadrv_id) &&
17087 		    restore != 0) {
17088 			if (((sdinfo->satadrv_settings & SATA_DEV_RMSN) &&
17089 			    (!SATA_RM_NOTIFIC_ENABLED(new_sdinfo.satadrv_id)))||
17090 			    ((!(sdinfo->satadrv_settings & SATA_DEV_RMSN)) &&
17091 			    SATA_RM_NOTIFIC_ENABLED(new_sdinfo.satadrv_id))) {
17092 				/* Current setting does not match saved one */
17093 				if (sata_set_rmsn(sata_hba_inst, sdinfo,
17094 				    sdinfo->satadrv_settings &
17095 				    SATA_DEV_RMSN) != SATA_SUCCESS)
17096 					rval = SATA_FAILURE;
17097 			}
17098 		}
17099 		/*
17100 		 * We have to set Multiword DMA or UDMA, if it is supported, as
17101 		 * we want to use DMA transfer mode whenever possible.
17102 		 * Some devices require explicit setting of the DMA mode.
17103 		 */
17104 		if (new_sdinfo.satadrv_id.ai_cap & SATA_DMA_SUPPORT) {
17105 			/* Set highest supported DMA mode */
17106 			if (sata_set_dma_mode(sata_hba_inst, &new_sdinfo) !=
17107 			    SATA_SUCCESS) {
17108 				SATA_LOG_D((sata_hba_inst, CE_WARN,
17109 				    "%s set UDMA mode\n", finfo));
17110 				rval = SATA_FAILURE;
17111 			}
17112 		}
17113 		break;
17114 	}
17115 
17116 	if (!SATA_READ_AHEAD_SUPPORTED(new_sdinfo.satadrv_id) &&
17117 	    !SATA_WRITE_CACHE_SUPPORTED(new_sdinfo.satadrv_id)) {
17118 		/*
17119 		 * neither READ AHEAD nor WRITE CACHE is supported
17120 		 * - do nothing
17121 		 */
17122 		SATADBG1(SATA_DBG_DEV_SETTINGS, sata_hba_inst,
17123 		    "settable features not supported\n", NULL);
17124 		goto update_sdinfo;
17125 	}
17126 
17127 	if ((SATA_READ_AHEAD_ENABLED(new_sdinfo.satadrv_id) &&
17128 	    (sdinfo->satadrv_settings & SATA_DEV_READ_AHEAD)) &&
17129 	    (SATA_WRITE_CACHE_ENABLED(new_sdinfo.satadrv_id) &&
17130 	    (sdinfo->satadrv_settings & SATA_DEV_WRITE_CACHE))) {
17131 		/*
17132 		 * both READ AHEAD and WRITE CACHE are enabled
17133 		 * - Nothing to do
17134 		 */
17135 		SATADBG1(SATA_DBG_DEV_SETTINGS, sata_hba_inst,
17136 		    "no device features to set\n", NULL);
17137 		goto update_sdinfo;
17138 	}
17139 
17140 	cache_op = 0;
17141 
17142 	if (SATA_READ_AHEAD_SUPPORTED(new_sdinfo.satadrv_id)) {
17143 		if ((sdinfo->satadrv_settings & SATA_DEV_READ_AHEAD) &&
17144 		    !SATA_READ_AHEAD_ENABLED(new_sdinfo.satadrv_id)) {
17145 			/* Enable read ahead / read cache */
17146 			cache_op = SATAC_SF_ENABLE_READ_AHEAD;
17147 			SATADBG1(SATA_DBG_DEV_SETTINGS, sata_hba_inst,
17148 			    "enabling read cache\n", NULL);
17149 		} else if (!(sdinfo->satadrv_settings & SATA_DEV_READ_AHEAD) &&
17150 		    SATA_READ_AHEAD_ENABLED(new_sdinfo.satadrv_id)) {
17151 			/* Disable read ahead  / read cache */
17152 			cache_op = SATAC_SF_DISABLE_READ_AHEAD;
17153 			SATADBG1(SATA_DBG_DEV_SETTINGS, sata_hba_inst,
17154 			    "disabling read cache\n", NULL);
17155 		}
17156 
17157 		if (cache_op != 0) {
17158 			/* Try to set read cache mode */
17159 			rval_set = sata_set_cache_mode(sata_hba_inst,
17160 			    &new_sdinfo, cache_op);
17161 			if (rval != SATA_FAILURE && rval_set != SATA_SUCCESS)
17162 				rval = rval_set;
17163 		}
17164 	}
17165 
17166 	cache_op = 0;
17167 
17168 	if (SATA_WRITE_CACHE_SUPPORTED(new_sdinfo.satadrv_id)) {
17169 		if ((sdinfo->satadrv_settings & SATA_DEV_WRITE_CACHE) &&
17170 		    !SATA_WRITE_CACHE_ENABLED(new_sdinfo.satadrv_id)) {
17171 			/* Enable write cache */
17172 			cache_op = SATAC_SF_ENABLE_WRITE_CACHE;
17173 			SATADBG1(SATA_DBG_DEV_SETTINGS, sata_hba_inst,
17174 			    "enabling write cache\n", NULL);
17175 		} else if (!(sdinfo->satadrv_settings & SATA_DEV_WRITE_CACHE) &&
17176 		    SATA_WRITE_CACHE_ENABLED(new_sdinfo.satadrv_id)) {
17177 			/* Disable write cache */
17178 			cache_op = SATAC_SF_DISABLE_WRITE_CACHE;
17179 			SATADBG1(SATA_DBG_DEV_SETTINGS, sata_hba_inst,
17180 			    "disabling write cache\n", NULL);
17181 		}
17182 
17183 		if (cache_op != 0) {
17184 			/* Try to set write cache mode */
17185 			rval_set = sata_set_cache_mode(sata_hba_inst,
17186 			    &new_sdinfo, cache_op);
17187 			if (rval != SATA_FAILURE && rval_set != SATA_SUCCESS)
17188 				rval = rval_set;
17189 		}
17190 	}
17191 	if (rval != SATA_SUCCESS)
17192 		SATA_LOG_D((sata_hba_inst, CE_WARN,
17193 		    "%s %s", finfo, finfox));
17194 
17195 update_sdinfo:
17196 	/*
17197 	 * We need to fetch Device Identify data again
17198 	 */
17199 	if (sata_fetch_device_identify_data(sata_hba_inst, &new_sdinfo) != 0) {
17200 		/*
17201 		 * Cannot get device identification - retry later
17202 		 */
17203 		SATA_LOG_D((sata_hba_inst, CE_WARN,
17204 		    "%s re-fetch device identify data\n", finfo));
17205 		rval = SATA_FAILURE;
17206 	}
17207 	/* Copy device sata info. */
17208 	sdinfo->satadrv_id = new_sdinfo.satadrv_id;
17209 
17210 	return (rval);
17211 }
17212 
17213 
17214 /*
17215  *
17216  * Returns 1 if threshold exceeded, 0 if threshold not exceeded, -1 if
17217  * unable to determine.
17218  *
17219  * Cannot be called in an interrupt context.
17220  *
17221  * Called by sata_build_lsense_page_2f()
17222  */
17223 
17224 static int
17225 sata_fetch_smart_return_status(sata_hba_inst_t *sata_hba_inst,
17226     sata_drive_info_t *sdinfo)
17227 {
17228 	sata_pkt_t *spkt;
17229 	sata_cmd_t *scmd;
17230 	sata_pkt_txlate_t *spx;
17231 	int rval;
17232 
17233 	spx = kmem_zalloc(sizeof (sata_pkt_txlate_t), KM_SLEEP);
17234 	spx->txlt_sata_hba_inst = sata_hba_inst;
17235 	spx->txlt_scsi_pkt = NULL;		/* No scsi pkt involved */
17236 	spkt = sata_pkt_alloc(spx, SLEEP_FUNC);
17237 	if (spkt == NULL) {
17238 		kmem_free(spx, sizeof (sata_pkt_txlate_t));
17239 		return (-1);
17240 	}
17241 	/* address is needed now */
17242 	spkt->satapkt_device.satadev_addr = sdinfo->satadrv_addr;
17243 
17244 
17245 	/* Fill sata_pkt */
17246 	spkt->satapkt_device.satadev_addr = sdinfo->satadrv_addr;
17247 	spkt->satapkt_op_mode = SATA_OPMODE_SYNCH | SATA_OPMODE_INTERRUPTS;
17248 	/* Synchronous mode, no callback */
17249 	spkt->satapkt_comp = NULL;
17250 	/* Timeout 30s */
17251 	spkt->satapkt_time = sata_default_pkt_time;
17252 
17253 	scmd = &spkt->satapkt_cmd;
17254 	scmd->satacmd_flags.sata_special_regs = B_TRUE;
17255 	scmd->satacmd_flags.sata_data_direction = SATA_DIR_NODATA_XFER;
17256 
17257 	/* Set up which registers need to be returned */
17258 	scmd->satacmd_flags.sata_copy_out_lba_mid_lsb = B_TRUE;
17259 	scmd->satacmd_flags.sata_copy_out_lba_high_lsb = B_TRUE;
17260 
17261 	/* Build SMART_RETURN_STATUS cmd in the sata_pkt */
17262 	scmd->satacmd_addr_type = 0;		/* N/A */
17263 	scmd->satacmd_sec_count_lsb = 0;	/* N/A */
17264 	scmd->satacmd_lba_low_lsb = 0;		/* N/A */
17265 	scmd->satacmd_lba_mid_lsb = SMART_MAGIC_VAL_1;
17266 	scmd->satacmd_lba_high_lsb = SMART_MAGIC_VAL_2;
17267 	scmd->satacmd_features_reg = SATA_SMART_RETURN_STATUS;
17268 	scmd->satacmd_device_reg = 0;		/* Always device 0 */
17269 	scmd->satacmd_cmd_reg = SATAC_SMART;
17270 	mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst,
17271 	    sdinfo->satadrv_addr.cport)));
17272 
17273 
17274 	/* Send pkt to SATA HBA driver */
17275 	if ((*SATA_START_FUNC(sata_hba_inst))(SATA_DIP(sata_hba_inst), spkt) !=
17276 	    SATA_TRAN_ACCEPTED ||
17277 	    spkt->satapkt_reason != SATA_PKT_COMPLETED) {
17278 		mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst,
17279 		    sdinfo->satadrv_addr.cport)));
17280 		/*
17281 		 * Whoops, no SMART RETURN STATUS
17282 		 */
17283 		rval = -1;
17284 	} else {
17285 		mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst,
17286 		    sdinfo->satadrv_addr.cport)));
17287 		if (scmd->satacmd_error_reg & SATA_ERROR_ABORT) {
17288 			rval = -1;
17289 			goto fail;
17290 		}
17291 		if (scmd->satacmd_status_reg & SATA_STATUS_ERR) {
17292 			rval = -1;
17293 			goto fail;
17294 		}
17295 		if ((scmd->satacmd_lba_mid_lsb == SMART_MAGIC_VAL_1) &&
17296 		    (scmd->satacmd_lba_high_lsb == SMART_MAGIC_VAL_2))
17297 			rval = 0;
17298 		else if ((scmd->satacmd_lba_mid_lsb == SMART_MAGIC_VAL_3) &&
17299 		    (scmd->satacmd_lba_high_lsb == SMART_MAGIC_VAL_4))
17300 			rval = 1;
17301 		else {
17302 			rval = -1;
17303 			goto fail;
17304 		}
17305 	}
17306 fail:
17307 	/* Free allocated resources */
17308 	sata_pkt_free(spx);
17309 	kmem_free(spx, sizeof (sata_pkt_txlate_t));
17310 
17311 	return (rval);
17312 }
17313 
17314 /*
17315  *
17316  * Returns 0 if succeeded, -1 otherwise
17317  *
17318  * Cannot be called in an interrupt context.
17319  *
17320  */
17321 static int
17322 sata_fetch_smart_data(sata_hba_inst_t *sata_hba_inst, sata_drive_info_t *sdinfo,
17323     struct smart_data *smart_data)
17324 {
17325 	sata_pkt_t *spkt;
17326 	sata_cmd_t *scmd;
17327 	sata_pkt_txlate_t *spx;
17328 	int rval = 0;
17329 	dev_info_t *dip = SATA_DIP(sata_hba_inst);
17330 
17331 #if ! defined(lint)
17332 	ASSERT(sizeof (struct smart_data) == 512);
17333 #endif
17334 
17335 	spx = kmem_zalloc(sizeof (sata_pkt_txlate_t), KM_SLEEP);
17336 	spx->txlt_sata_hba_inst = sata_hba_inst;
17337 	spx->txlt_scsi_pkt = NULL;		/* No scsi pkt involved */
17338 	spkt = sata_pkt_alloc(spx, SLEEP_FUNC);
17339 	if (spkt == NULL) {
17340 		kmem_free(spx, sizeof (sata_pkt_txlate_t));
17341 		return (-1);
17342 	}
17343 	/* address is needed now */
17344 	spkt->satapkt_device.satadev_addr = sdinfo->satadrv_addr;
17345 
17346 
17347 	/* Fill sata_pkt */
17348 	spkt->satapkt_device.satadev_addr = sdinfo->satadrv_addr;
17349 	spkt->satapkt_op_mode = SATA_OPMODE_SYNCH | SATA_OPMODE_INTERRUPTS;
17350 	/* Synchronous mode, no callback */
17351 	spkt->satapkt_comp = NULL;
17352 	/* Timeout 30s */
17353 	spkt->satapkt_time = sata_default_pkt_time;
17354 
17355 	scmd = &spkt->satapkt_cmd;
17356 	scmd->satacmd_flags.sata_data_direction = SATA_DIR_READ;
17357 
17358 	/*
17359 	 * Allocate buffer for SMART data
17360 	 */
17361 	scmd->satacmd_bp = sata_alloc_local_buffer(spx,
17362 	    sizeof (struct smart_data));
17363 	if (scmd->satacmd_bp == NULL) {
17364 		sata_pkt_free(spx);
17365 		kmem_free(spx, sizeof (sata_pkt_txlate_t));
17366 		SATA_LOG_D((sata_hba_inst, CE_WARN,
17367 		    "sata_fetch_smart_data: "
17368 		    "cannot allocate buffer"));
17369 		return (-1);
17370 	}
17371 
17372 
17373 	/* Build SMART_READ_DATA cmd in the sata_pkt */
17374 	scmd->satacmd_addr_type = 0;		/* N/A */
17375 	scmd->satacmd_sec_count_lsb = 0;	/* N/A */
17376 	scmd->satacmd_lba_low_lsb = 0;		/* N/A */
17377 	scmd->satacmd_lba_mid_lsb = SMART_MAGIC_VAL_1;
17378 	scmd->satacmd_lba_high_lsb = SMART_MAGIC_VAL_2;
17379 	scmd->satacmd_features_reg = SATA_SMART_READ_DATA;
17380 	scmd->satacmd_device_reg = 0;		/* Always device 0 */
17381 	scmd->satacmd_cmd_reg = SATAC_SMART;
17382 	mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst,
17383 	    sdinfo->satadrv_addr.cport)));
17384 
17385 	/* Send pkt to SATA HBA driver */
17386 	if ((*SATA_START_FUNC(sata_hba_inst))(SATA_DIP(sata_hba_inst), spkt) !=
17387 	    SATA_TRAN_ACCEPTED ||
17388 	    spkt->satapkt_reason != SATA_PKT_COMPLETED) {
17389 		mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst,
17390 		    sdinfo->satadrv_addr.cport)));
17391 		/*
17392 		 * Whoops, no SMART DATA available
17393 		 */
17394 		rval = -1;
17395 		goto fail;
17396 	} else {
17397 		mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst,
17398 		    sdinfo->satadrv_addr.cport)));
17399 		if (spx->txlt_buf_dma_handle != NULL) {
17400 			rval = ddi_dma_sync(spx->txlt_buf_dma_handle, 0, 0,
17401 			    DDI_DMA_SYNC_FORKERNEL);
17402 			ASSERT(rval == DDI_SUCCESS);
17403 			if (sata_check_for_dma_error(dip, spx)) {
17404 				ddi_fm_service_impact(dip,
17405 				    DDI_SERVICE_UNAFFECTED);
17406 				rval = -1;
17407 				goto fail;
17408 			}
17409 		}
17410 		bcopy(scmd->satacmd_bp->b_un.b_addr, (uint8_t *)smart_data,
17411 		    sizeof (struct smart_data));
17412 	}
17413 
17414 fail:
17415 	/* Free allocated resources */
17416 	sata_free_local_buffer(spx);
17417 	sata_pkt_free(spx);
17418 	kmem_free(spx, sizeof (sata_pkt_txlate_t));
17419 
17420 	return (rval);
17421 }
17422 
17423 /*
17424  * Issue a READ LOG EXT command for the given log (log_addr) and page
17425  * (page_num) of the log. The output is written to buf. nsect is the size
17426  * of buf in units of 512-byte sectors.
17427  */
17428 static int
17429 sata_read_log_ext(sata_hba_inst_t *sata_hba_inst, sata_drive_info_t *sdinfo,
17430     uint8_t log_addr, uint16_t page_num, void *buf, uint16_t nsect)
17431 {
17432 	dev_info_t *dip;
17433 	sata_pkt_txlate_t *spx;
17434 	sata_pkt_t *spkt;
17435 	sata_cmd_t *scmd;
17436 	kmutex_t *cmutex;
17437 	int rval;
17438 
17439 	dip = SATA_DIP(sata_hba_inst);
17440 	cmutex = &SATA_CPORT_MUTEX(sata_hba_inst, sdinfo->satadrv_addr.cport);
17441 
17442 	ASSERT(MUTEX_HELD(cmutex));
17443 
17444 	spx = kmem_zalloc(sizeof (*spx), KM_SLEEP);
17445 	spx->txlt_sata_hba_inst = sata_hba_inst;
17446 	spx->txlt_scsi_pkt = NULL;
17447 
17448 	spkt = sata_pkt_alloc(spx, SLEEP_FUNC);
17449 	spkt->satapkt_device.satadev_addr = sdinfo->satadrv_addr;
17450 	spkt->satapkt_op_mode = SATA_OPMODE_SYNCH | SATA_OPMODE_INTERRUPTS;
17451 	spkt->satapkt_comp = NULL;
17452 	spkt->satapkt_time = sata_default_pkt_time;
17453 
17454 	scmd = &spkt->satapkt_cmd;
17455 	scmd->satacmd_bp = sata_alloc_local_buffer(spx, (size_t)nsect * 512);
17456 	if (scmd->satacmd_bp == NULL) {
17457 		sata_pkt_free(spx);
17458 		kmem_free(spx, sizeof (*spx));
17459 		SATA_LOG_D((sata_hba_inst, CE_WARN, "%s: cannot allocate bp",
17460 		    __func__));
17461 		return (-1);
17462 	}
17463 
17464 	scmd->satacmd_cmd_reg = SATAC_READ_LOG_EXT;
17465 	scmd->satacmd_flags.sata_data_direction = SATA_DIR_READ;
17466 	scmd->satacmd_addr_type = ATA_ADDR_LBA48;
17467 	scmd->satacmd_sec_count_lsb = nsect & 0xff;
17468 	scmd->satacmd_sec_count_msb = nsect >> 8;
17469 
17470 	/*
17471 	 * From ACS-3 7.24.3.1 Table 68
17472 	 * LBA[47:40]	Reserved
17473 	 * LBA[39:32]	PAGE NUMBER (15:8)
17474 	 * LBA[31:16]	Reserved
17475 	 * LBA[15:8]	PAGE NUMBER (7:0)
17476 	 * LBA[7:0]	LOG ADDRESS
17477 	 */
17478 	scmd->satacmd_lba_low_lsb = log_addr;		/* LBA[7:0] */
17479 	scmd->satacmd_lba_mid_lsb = page_num & 0xff;	/* LBA[15:8] */
17480 	scmd->satacmd_lba_high_lsb = 0;			/* LBA[23:16] */
17481 	scmd->satacmd_lba_low_msb = 0;			/* LBA[31:24] */
17482 	scmd->satacmd_lba_mid_msb = page_num >> 8;	/* LBA[39:32] */
17483 	scmd->satacmd_lba_high_msb = 0;			/* LBA[47:40] */
17484 
17485 	scmd->satacmd_device_reg = 0;
17486 
17487 	mutex_exit(cmutex);
17488 	rval = (*SATA_START_FUNC(sata_hba_inst))(dip, spkt);
17489 	mutex_enter(cmutex);
17490 
17491 	if (rval != SATA_TRAN_ACCEPTED ||
17492 	    spkt->satapkt_reason != SATA_PKT_COMPLETED) {
17493 		rval = -1;
17494 		goto fail;
17495 	}
17496 
17497 	if (spx->txlt_buf_dma_handle != NULL) {
17498 		rval = ddi_dma_sync(spx->txlt_buf_dma_handle, 0, 0,
17499 		    DDI_DMA_SYNC_FORKERNEL);
17500 		ASSERT3S(rval, ==, DDI_SUCCESS);
17501 		if (sata_check_for_dma_error(dip, spx)) {
17502 			ddi_fm_service_impact(dip, DDI_SERVICE_UNAFFECTED);
17503 			rval = -1;
17504 			goto fail;
17505 		}
17506 
17507 		bcopy(scmd->satacmd_bp->b_un.b_addr, buf, (size_t)nsect * 512);
17508 		rval = 0;
17509 	}
17510 
17511 fail:
17512 	sata_free_local_buffer(spx);
17513 	sata_pkt_free(spx);
17514 	kmem_free(spx, sizeof (*spx));
17515 
17516 	return (rval);
17517 }
17518 
17519 /*
17520  * Used by LOG SENSE page 0x10
17521  * Reads (in synchronous mode) the self test log data using Read Log Ext cmd.
17522  * Note: cannot be called in the interrupt context.
17523  *
17524  * return 0 for success, -1 otherwise
17525  *
17526  */
17527 CTASSERT(sizeof (struct smart_ext_selftest_log) == 512);
17528 
17529 static int
17530 sata_ext_smart_selftest_read_log(sata_hba_inst_t *sata_hba_inst,
17531     sata_drive_info_t *sdinfo, struct smart_ext_selftest_log *ext_selftest_log,
17532     uint16_t block_num)
17533 {
17534 	return (sata_read_log_ext(sata_hba_inst, sdinfo,
17535 	    EXT_SMART_SELFTEST_LOG_PAGE, block_num, ext_selftest_log, 1));
17536 }
17537 
17538 /*
17539  * Returns 0 for success, -1 otherwise
17540  *
17541  * SMART self-test log data is returned in buffer pointed to by selftest_log
17542  */
17543 static int
17544 sata_smart_selftest_log(
17545 	sata_hba_inst_t *sata_hba_inst,
17546 	sata_drive_info_t *sdinfo,
17547 	struct smart_selftest_log *selftest_log)
17548 {
17549 	sata_pkt_t *spkt;
17550 	sata_cmd_t *scmd;
17551 	sata_pkt_txlate_t *spx;
17552 	int rval;
17553 	dev_info_t *dip = SATA_DIP(sata_hba_inst);
17554 
17555 #if ! defined(lint)
17556 	ASSERT(sizeof (struct smart_selftest_log) == 512);
17557 #endif
17558 
17559 	spx = kmem_zalloc(sizeof (sata_pkt_txlate_t), KM_SLEEP);
17560 	spx->txlt_sata_hba_inst = sata_hba_inst;
17561 	spx->txlt_scsi_pkt = NULL;		/* No scsi pkt involved */
17562 	spkt = sata_pkt_alloc(spx, SLEEP_FUNC);
17563 	if (spkt == NULL) {
17564 		kmem_free(spx, sizeof (sata_pkt_txlate_t));
17565 		return (-1);
17566 	}
17567 	/* address is needed now */
17568 	spkt->satapkt_device.satadev_addr = sdinfo->satadrv_addr;
17569 
17570 
17571 	/* Fill sata_pkt */
17572 	spkt->satapkt_device.satadev_addr = sdinfo->satadrv_addr;
17573 	spkt->satapkt_op_mode = SATA_OPMODE_SYNCH | SATA_OPMODE_INTERRUPTS;
17574 	/* Synchronous mode, no callback */
17575 	spkt->satapkt_comp = NULL;
17576 	/* Timeout 30s */
17577 	spkt->satapkt_time = sata_default_pkt_time;
17578 
17579 	scmd = &spkt->satapkt_cmd;
17580 	scmd->satacmd_flags.sata_data_direction = SATA_DIR_READ;
17581 
17582 	/*
17583 	 * Allocate buffer for SMART SELFTEST LOG
17584 	 */
17585 	scmd->satacmd_bp = sata_alloc_local_buffer(spx,
17586 	    sizeof (struct smart_selftest_log));
17587 	if (scmd->satacmd_bp == NULL) {
17588 		sata_pkt_free(spx);
17589 		kmem_free(spx, sizeof (sata_pkt_txlate_t));
17590 		SATA_LOG_D((sata_hba_inst, CE_WARN,
17591 		    "sata_smart_selftest_log: "
17592 		    "cannot allocate buffer"));
17593 		return (-1);
17594 	}
17595 
17596 	/* Build SMART_READ_LOG cmd in the sata_pkt */
17597 	scmd->satacmd_addr_type = 0;		/* N/A */
17598 	scmd->satacmd_sec_count_lsb = 1;	/* One sector of SMART log */
17599 	scmd->satacmd_lba_low_lsb = SMART_SELFTEST_LOG_PAGE;
17600 	scmd->satacmd_lba_mid_lsb = SMART_MAGIC_VAL_1;
17601 	scmd->satacmd_lba_high_lsb = SMART_MAGIC_VAL_2;
17602 	scmd->satacmd_features_reg = SATA_SMART_READ_LOG;
17603 	scmd->satacmd_device_reg = 0;		/* Always device 0 */
17604 	scmd->satacmd_cmd_reg = SATAC_SMART;
17605 	mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst,
17606 	    sdinfo->satadrv_addr.cport)));
17607 
17608 	/* Send pkt to SATA HBA driver */
17609 	if ((*SATA_START_FUNC(sata_hba_inst))(SATA_DIP(sata_hba_inst), spkt) !=
17610 	    SATA_TRAN_ACCEPTED ||
17611 	    spkt->satapkt_reason != SATA_PKT_COMPLETED) {
17612 		mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst,
17613 		    sdinfo->satadrv_addr.cport)));
17614 		/*
17615 		 * Whoops, no SMART DATA available
17616 		 */
17617 		rval = -1;
17618 		goto fail;
17619 	} else {
17620 		mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst,
17621 		    sdinfo->satadrv_addr.cport)));
17622 		if (spx->txlt_buf_dma_handle != NULL) {
17623 			rval = ddi_dma_sync(spx->txlt_buf_dma_handle, 0, 0,
17624 			    DDI_DMA_SYNC_FORKERNEL);
17625 			ASSERT(rval == DDI_SUCCESS);
17626 			if (sata_check_for_dma_error(dip, spx)) {
17627 				ddi_fm_service_impact(dip,
17628 				    DDI_SERVICE_UNAFFECTED);
17629 				rval = -1;
17630 				goto fail;
17631 			}
17632 		}
17633 		bcopy(scmd->satacmd_bp->b_un.b_addr, (uint8_t *)selftest_log,
17634 		    sizeof (struct smart_selftest_log));
17635 		rval = 0;
17636 	}
17637 
17638 fail:
17639 	/* Free allocated resources */
17640 	sata_free_local_buffer(spx);
17641 	sata_pkt_free(spx);
17642 	kmem_free(spx, sizeof (sata_pkt_txlate_t));
17643 
17644 	return (rval);
17645 }
17646 
17647 
17648 /*
17649  * Returns 0 for success, -1 otherwise
17650  *
17651  * SMART READ LOG data is returned in buffer pointed to by smart_log
17652  */
17653 static int
17654 sata_smart_read_log(
17655 	sata_hba_inst_t *sata_hba_inst,
17656 	sata_drive_info_t *sdinfo,
17657 	uint8_t *smart_log,		/* where the data should be returned */
17658 	uint8_t which_log,		/* which log should be returned */
17659 	uint8_t log_size)		/* # of 512 bytes in log */
17660 {
17661 	sata_pkt_t *spkt;
17662 	sata_cmd_t *scmd;
17663 	sata_pkt_txlate_t *spx;
17664 	int rval;
17665 	dev_info_t *dip = SATA_DIP(sata_hba_inst);
17666 
17667 	spx = kmem_zalloc(sizeof (sata_pkt_txlate_t), KM_SLEEP);
17668 	spx->txlt_sata_hba_inst = sata_hba_inst;
17669 	spx->txlt_scsi_pkt = NULL;		/* No scsi pkt involved */
17670 	spkt = sata_pkt_alloc(spx, SLEEP_FUNC);
17671 	if (spkt == NULL) {
17672 		kmem_free(spx, sizeof (sata_pkt_txlate_t));
17673 		return (-1);
17674 	}
17675 	/* address is needed now */
17676 	spkt->satapkt_device.satadev_addr = sdinfo->satadrv_addr;
17677 
17678 
17679 	/* Fill sata_pkt */
17680 	spkt->satapkt_device.satadev_addr = sdinfo->satadrv_addr;
17681 	spkt->satapkt_op_mode = SATA_OPMODE_SYNCH | SATA_OPMODE_INTERRUPTS;
17682 	/* Synchronous mode, no callback */
17683 	spkt->satapkt_comp = NULL;
17684 	/* Timeout 30s */
17685 	spkt->satapkt_time = sata_default_pkt_time;
17686 
17687 	scmd = &spkt->satapkt_cmd;
17688 	scmd->satacmd_flags.sata_data_direction = SATA_DIR_READ;
17689 
17690 	/*
17691 	 * Allocate buffer for SMART READ LOG
17692 	 */
17693 	scmd->satacmd_bp = sata_alloc_local_buffer(spx, (size_t)log_size * 512);
17694 	if (scmd->satacmd_bp == NULL) {
17695 		sata_pkt_free(spx);
17696 		kmem_free(spx, sizeof (sata_pkt_txlate_t));
17697 		SATA_LOG_D((sata_hba_inst, CE_WARN,
17698 		    "sata_smart_read_log: " "cannot allocate buffer"));
17699 		return (-1);
17700 	}
17701 
17702 	/* Build SMART_READ_LOG cmd in the sata_pkt */
17703 	scmd->satacmd_addr_type = 0;		/* N/A */
17704 	scmd->satacmd_sec_count_lsb = log_size;	/* what the caller asked for */
17705 	scmd->satacmd_lba_low_lsb = which_log;	/* which log page */
17706 	scmd->satacmd_lba_mid_lsb = SMART_MAGIC_VAL_1;
17707 	scmd->satacmd_lba_high_lsb = SMART_MAGIC_VAL_2;
17708 	scmd->satacmd_features_reg = SATA_SMART_READ_LOG;
17709 	scmd->satacmd_device_reg = 0;		/* Always device 0 */
17710 	scmd->satacmd_cmd_reg = SATAC_SMART;
17711 
17712 	mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst,
17713 	    sdinfo->satadrv_addr.cport)));
17714 
17715 	/* Send pkt to SATA HBA driver */
17716 	if ((*SATA_START_FUNC(sata_hba_inst))(SATA_DIP(sata_hba_inst), spkt) !=
17717 	    SATA_TRAN_ACCEPTED ||
17718 	    spkt->satapkt_reason != SATA_PKT_COMPLETED) {
17719 		mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst,
17720 		    sdinfo->satadrv_addr.cport)));
17721 
17722 		/*
17723 		 * Whoops, no SMART DATA available
17724 		 */
17725 		rval = -1;
17726 		goto fail;
17727 	} else {
17728 		mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst,
17729 		    sdinfo->satadrv_addr.cport)));
17730 
17731 		if (spx->txlt_buf_dma_handle != NULL) {
17732 			rval = ddi_dma_sync(spx->txlt_buf_dma_handle, 0, 0,
17733 			    DDI_DMA_SYNC_FORKERNEL);
17734 			ASSERT(rval == DDI_SUCCESS);
17735 			if (sata_check_for_dma_error(dip, spx)) {
17736 				ddi_fm_service_impact(dip,
17737 				    DDI_SERVICE_UNAFFECTED);
17738 				rval = -1;
17739 				goto fail;
17740 			}
17741 		}
17742 		bcopy(scmd->satacmd_bp->b_un.b_addr, smart_log, log_size * 512);
17743 		rval = 0;
17744 	}
17745 
17746 fail:
17747 	/* Free allocated resources */
17748 	sata_free_local_buffer(spx);
17749 	sata_pkt_free(spx);
17750 	kmem_free(spx, sizeof (sata_pkt_txlate_t));
17751 
17752 	return (rval);
17753 }
17754 
17755 /*
17756  * Used by LOG SENSE page 0x10
17757  *
17758  * return 0 for success, -1 otherwise
17759  *
17760  */
17761 CTASSERT(sizeof (struct read_log_ext_directory) == 512);
17762 
17763 static int
17764 sata_read_log_ext_directory(sata_hba_inst_t *sata_hba_inst,
17765     sata_drive_info_t *sdinfo, struct read_log_ext_directory *logdir)
17766 {
17767 	return (sata_read_log_ext(sata_hba_inst, sdinfo,
17768 	    READ_LOG_EXT_LOG_DIRECTORY, 0, logdir, 1));
17769 }
17770 
17771 /*
17772  * Set up error retrieval sata command for NCQ command error data
17773  * recovery.
17774  *
17775  * Returns SATA_SUCCESS when data buffer is allocated and packet set-up,
17776  * returns SATA_FAILURE otherwise.
17777  */
17778 static int
17779 sata_ncq_err_ret_cmd_setup(sata_pkt_txlate_t *spx, sata_drive_info_t *sdinfo)
17780 {
17781 #ifndef __lock_lint
17782 	_NOTE(ARGUNUSED(sdinfo))
17783 #endif
17784 
17785 	sata_pkt_t *spkt = spx->txlt_sata_pkt;
17786 	sata_cmd_t *scmd;
17787 	struct buf *bp;
17788 
17789 	/* Operation modes are up to the caller */
17790 	spkt->satapkt_op_mode = SATA_OPMODE_SYNCH | SATA_OPMODE_INTERRUPTS;
17791 
17792 	/* Synchronous mode, no callback - may be changed by the caller */
17793 	spkt->satapkt_comp = NULL;
17794 	spkt->satapkt_time = sata_default_pkt_time;
17795 
17796 	scmd = &spkt->satapkt_cmd;
17797 	bcopy(&sata_rle_cmd, scmd, sizeof (sata_cmd_t));
17798 	scmd->satacmd_flags.sata_ignore_dev_reset = B_TRUE;
17799 
17800 	/*
17801 	 * Allocate dma_able buffer error data.
17802 	 * Buffer allocation will take care of buffer alignment and other DMA
17803 	 * attributes.
17804 	 */
17805 	bp = sata_alloc_local_buffer(spx,
17806 	    sizeof (struct sata_ncq_error_recovery_page));
17807 	if (bp == NULL)
17808 		return (SATA_FAILURE);
17809 
17810 	bp_mapin(bp); /* make data buffer accessible */
17811 	scmd->satacmd_bp = bp;
17812 
17813 	/*
17814 	 * Set-up pointer to the buffer handle, so HBA can sync buffer
17815 	 * before accessing it. Handle is in usual place in translate struct.
17816 	 */
17817 	scmd->satacmd_err_ret_buf_handle = &spx->txlt_buf_dma_handle;
17818 
17819 	ASSERT(scmd->satacmd_num_dma_cookies != 0);
17820 	ASSERT(scmd->satacmd_dma_cookie_list != NULL);
17821 
17822 	return (SATA_SUCCESS);
17823 }
17824 
17825 /*
17826  * sata_xlate_errors() is used to translate (S)ATA error
17827  * information to SCSI information returned in the SCSI
17828  * packet.
17829  */
17830 static void
17831 sata_xlate_errors(sata_pkt_txlate_t *spx)
17832 {
17833 	struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt;
17834 	struct scsi_extended_sense *sense;
17835 
17836 	scsipkt->pkt_reason = CMD_INCOMPLETE;
17837 	*scsipkt->pkt_scbp = STATUS_CHECK;
17838 	sense = sata_arq_sense(spx);
17839 
17840 	switch (spx->txlt_sata_pkt->satapkt_reason) {
17841 	case SATA_PKT_PORT_ERROR:
17842 		/*
17843 		 * We have no device data. Assume no data transfered.
17844 		 */
17845 		sense->es_key = KEY_HARDWARE_ERROR;
17846 		break;
17847 
17848 	case SATA_PKT_DEV_ERROR:
17849 		if (spx->txlt_sata_pkt->satapkt_cmd.satacmd_status_reg &
17850 		    SATA_STATUS_ERR) {
17851 			/*
17852 			 * determine dev error reason from error
17853 			 * reg content
17854 			 */
17855 			sata_decode_device_error(spx, sense);
17856 			break;
17857 		}
17858 		/* No extended sense key - no info available */
17859 		break;
17860 
17861 	case SATA_PKT_TIMEOUT:
17862 		scsipkt->pkt_reason = CMD_TIMEOUT;
17863 		scsipkt->pkt_statistics |= STAT_TIMEOUT | STAT_DEV_RESET;
17864 		/* No extended sense key */
17865 		break;
17866 
17867 	case SATA_PKT_ABORTED:
17868 		scsipkt->pkt_reason = CMD_ABORTED;
17869 		scsipkt->pkt_statistics |= STAT_ABORTED;
17870 		/* No extended sense key */
17871 		break;
17872 
17873 	case SATA_PKT_RESET:
17874 		/*
17875 		 * pkt aborted either by an explicit reset request from
17876 		 * a host, or due to error recovery
17877 		 */
17878 		scsipkt->pkt_reason = CMD_RESET;
17879 		scsipkt->pkt_statistics |= STAT_DEV_RESET;
17880 		break;
17881 
17882 	default:
17883 		scsipkt->pkt_reason = CMD_TRAN_ERR;
17884 		break;
17885 	}
17886 }
17887 
17888 
17889 
17890 
17891 /*
17892  * Log sata message
17893  * dev pathname msg line preceeds the logged message.
17894  */
17895 
17896 static	void
17897 sata_log(sata_hba_inst_t *sata_hba_inst, uint_t level, char *fmt, ...)
17898 {
17899 	char pathname[128];
17900 	dev_info_t *dip = NULL;
17901 	va_list ap;
17902 
17903 	mutex_enter(&sata_log_mutex);
17904 
17905 	va_start(ap, fmt);
17906 	(void) vsprintf(sata_log_buf, fmt, ap);
17907 	va_end(ap);
17908 
17909 	if (sata_hba_inst != NULL) {
17910 		dip = SATA_DIP(sata_hba_inst);
17911 		(void) ddi_pathname(dip, pathname);
17912 	} else {
17913 		pathname[0] = 0;
17914 	}
17915 	if (level == CE_CONT) {
17916 		if (sata_debug_flags == 0)
17917 			cmn_err(level, "?%s:\n %s\n", pathname, sata_log_buf);
17918 		else
17919 			cmn_err(level, "%s:\n %s\n", pathname, sata_log_buf);
17920 	} else {
17921 		if (level != CE_NOTE) {
17922 			cmn_err(level, "%s:\n %s", pathname, sata_log_buf);
17923 		} else if (sata_msg) {
17924 			cmn_err(level, "%s:\n %s", pathname,
17925 			    sata_log_buf);
17926 		}
17927 	}
17928 
17929 	/* sata trace debug */
17930 	sata_trace_debug(dip, sata_log_buf);
17931 
17932 	mutex_exit(&sata_log_mutex);
17933 }
17934 
17935 
17936 /* ******** Asynchronous HBA events handling & hotplugging support ******** */
17937 
17938 /*
17939  * Start or terminate the thread, depending on flag arg and current state
17940  */
17941 static void
17942 sata_event_thread_control(int startstop)
17943 {
17944 	static int sata_event_thread_terminating = 0;
17945 	static int sata_event_thread_starting = 0;
17946 	int i;
17947 
17948 	mutex_enter(&sata_event_mutex);
17949 
17950 	if (startstop == 0 && (sata_event_thread_starting == 1 ||
17951 	    sata_event_thread_terminating == 1)) {
17952 		mutex_exit(&sata_event_mutex);
17953 		return;
17954 	}
17955 	if (startstop == 1 && sata_event_thread_starting == 1) {
17956 		mutex_exit(&sata_event_mutex);
17957 		return;
17958 	}
17959 	if (startstop == 1 && sata_event_thread_terminating == 1) {
17960 		sata_event_thread_starting = 1;
17961 		/* wait til terminate operation completes */
17962 		i = SATA_EVNT_DAEMON_TERM_WAIT/SATA_EVNT_DAEMON_TERM_TIMEOUT;
17963 		while (sata_event_thread_terminating == 1) {
17964 			if (i-- <= 0) {
17965 				sata_event_thread_starting = 0;
17966 				mutex_exit(&sata_event_mutex);
17967 #ifdef SATA_DEBUG
17968 				cmn_err(CE_WARN, "sata_event_thread_control: "
17969 				    "timeout waiting for thread to terminate");
17970 #endif
17971 				return;
17972 			}
17973 			mutex_exit(&sata_event_mutex);
17974 			delay(drv_usectohz(SATA_EVNT_DAEMON_TERM_TIMEOUT));
17975 			mutex_enter(&sata_event_mutex);
17976 		}
17977 	}
17978 	if (startstop == 1) {
17979 		if (sata_event_thread == NULL) {
17980 			sata_event_thread = thread_create(NULL, 0,
17981 			    (void (*)())sata_event_daemon,
17982 			    &sata_hba_list, 0, &p0, TS_RUN, minclsyspri);
17983 		}
17984 		sata_event_thread_starting = 0;
17985 		mutex_exit(&sata_event_mutex);
17986 		return;
17987 	}
17988 
17989 	/*
17990 	 * If we got here, thread may need to be terminated
17991 	 */
17992 	if (sata_event_thread != NULL) {
17993 		int i;
17994 		/* Signal event thread to go away */
17995 		sata_event_thread_terminating = 1;
17996 		sata_event_thread_terminate = 1;
17997 		cv_signal(&sata_event_cv);
17998 		/*
17999 		 * Wait til daemon terminates.
18000 		 */
18001 		i = SATA_EVNT_DAEMON_TERM_WAIT/SATA_EVNT_DAEMON_TERM_TIMEOUT;
18002 		while (sata_event_thread_terminate == 1) {
18003 			mutex_exit(&sata_event_mutex);
18004 			if (i-- <= 0) {
18005 				/* Daemon did not go away !!! */
18006 #ifdef SATA_DEBUG
18007 				cmn_err(CE_WARN, "sata_event_thread_control: "
18008 				    "cannot terminate event daemon thread");
18009 #endif
18010 				mutex_enter(&sata_event_mutex);
18011 				break;
18012 			}
18013 			delay(drv_usectohz(SATA_EVNT_DAEMON_TERM_TIMEOUT));
18014 			mutex_enter(&sata_event_mutex);
18015 		}
18016 		sata_event_thread_terminating = 0;
18017 	}
18018 	ASSERT(sata_event_thread_terminating == 0);
18019 	ASSERT(sata_event_thread_starting == 0);
18020 	mutex_exit(&sata_event_mutex);
18021 }
18022 
18023 
18024 /*
18025  * SATA HBA event notification function.
18026  * Events reported by SATA HBA drivers per HBA instance relate to a change in
18027  * a port and/or device state or a controller itself.
18028  * Events for different addresses/addr types cannot be combined.
18029  * A warning message is generated for each event type.
18030  * Events are not processed by this function, so only the
18031  * event flag(s)is set for an affected entity and the event thread is
18032  * waken up. Event daemon thread processes all events.
18033  *
18034  * NOTE: Since more than one event may be reported at the same time, one
18035  * cannot determine a sequence of events when opposite event are reported, eg.
18036  * LINK_LOST and LINK_ESTABLISHED. Actual port status during event processing
18037  * is taking precedence over reported events, i.e. may cause ignoring some
18038  * events.
18039  */
18040 #define	SATA_EVENT_MAX_MSG_LENGTH	79
18041 
18042 void
18043 sata_hba_event_notify(dev_info_t *dip, sata_device_t *sata_device, int event)
18044 {
18045 	sata_hba_inst_t *sata_hba_inst = NULL;
18046 	sata_address_t *saddr;
18047 	sata_pmult_info_t *pmultinfo;
18048 	sata_drive_info_t *sdinfo;
18049 	sata_port_stats_t *pstats;
18050 	sata_cport_info_t *cportinfo = NULL;
18051 	sata_pmport_info_t *pmportinfo = NULL;
18052 	int cport, pmport;
18053 	char buf1[SATA_EVENT_MAX_MSG_LENGTH + 1];
18054 	char buf2[SATA_EVENT_MAX_MSG_LENGTH + 1];
18055 	char *lcp;
18056 	static char *err_msg_evnt_1 =
18057 	    "sata_hba_event_notify: invalid port event 0x%x ";
18058 	static char *err_msg_evnt_2 =
18059 	    "sata_hba_event_notify: invalid device event 0x%x ";
18060 	int linkevent;
18061 
18062 	/*
18063 	 * There is a possibility that an event will be generated on HBA
18064 	 * that has not completed attachment or is detaching. We still want
18065 	 * to process events until HBA is detached.
18066 	 */
18067 	mutex_enter(&sata_mutex);
18068 	for (sata_hba_inst = sata_hba_list; sata_hba_inst != NULL;
18069 	    sata_hba_inst = sata_hba_inst->satahba_next) {
18070 		if (SATA_DIP(sata_hba_inst) == dip)
18071 			if (sata_hba_inst->satahba_attached == 1)
18072 				break;
18073 	}
18074 	mutex_exit(&sata_mutex);
18075 	if (sata_hba_inst == NULL)
18076 		/* HBA not attached */
18077 		return;
18078 
18079 	ASSERT(sata_device != NULL);
18080 
18081 	/*
18082 	 * Validate address before - do not proceed with invalid address.
18083 	 */
18084 	saddr = &sata_device->satadev_addr;
18085 	if (saddr->cport >= SATA_NUM_CPORTS(sata_hba_inst))
18086 		return;
18087 
18088 	cport = saddr->cport;
18089 	pmport = saddr->pmport;
18090 
18091 	buf1[0] = buf2[0] = '\0';
18092 
18093 	/*
18094 	 * If event relates to port or device, check port state.
18095 	 * Port has to be initialized, or we cannot accept an event.
18096 	 */
18097 	if ((saddr->qual & (SATA_ADDR_CPORT | SATA_ADDR_PMPORT |
18098 	    SATA_ADDR_DCPORT | SATA_ADDR_DPMPORT | SATA_ADDR_PMULT)) != 0) {
18099 		mutex_enter(&sata_hba_inst->satahba_mutex);
18100 		cportinfo = SATA_CPORT_INFO(sata_hba_inst, cport);
18101 		mutex_exit(&sata_hba_inst->satahba_mutex);
18102 		if (cportinfo == NULL || cportinfo->cport_state == 0)
18103 			return;
18104 	}
18105 
18106 	if ((saddr->qual & (SATA_ADDR_PMULT | SATA_ADDR_PMPORT |
18107 	    SATA_ADDR_DPMPORT)) != 0) {
18108 		if (cportinfo->cport_dev_type != SATA_DTYPE_PMULT) {
18109 			SATA_LOG_D((sata_hba_inst, CE_WARN,
18110 			    "sata_hba_event_notify: Non-pmult device (0x%x)"
18111 			    "is attached to port %d, ignore pmult/pmport "
18112 			    "event 0x%x", cportinfo->cport_dev_type,
18113 			    cport, event));
18114 			return;
18115 		}
18116 
18117 		mutex_enter(&cportinfo->cport_mutex);
18118 		pmultinfo = SATA_PMULT_INFO(sata_hba_inst, cport);
18119 		mutex_exit(&cportinfo->cport_mutex);
18120 
18121 		/*
18122 		 * The daemon might be processing attachment of port
18123 		 * multiplier, in that case we should ignore events on its
18124 		 * sub-devices.
18125 		 *
18126 		 * NOTE: Only pmult_state is checked in sata_hba_event_notify.
18127 		 * The pmport_state is checked by sata daemon.
18128 		 */
18129 		if (pmultinfo == NULL ||
18130 		    pmultinfo->pmult_state == SATA_STATE_UNKNOWN) {
18131 			SATA_LOG_D((sata_hba_inst, CE_WARN,
18132 			    "sata_hba_event_notify: pmult is not"
18133 			    "available at port %d:%d, ignore event 0x%x",
18134 			    cport, pmport, event));
18135 			return;
18136 		}
18137 	}
18138 
18139 	if ((saddr->qual &
18140 	    (SATA_ADDR_PMPORT | SATA_ADDR_DPMPORT)) != 0) {
18141 
18142 		mutex_enter(&cportinfo->cport_mutex);
18143 		if (pmport > SATA_NUM_PMPORTS(sata_hba_inst, cport)) {
18144 			SATA_LOG_D((sata_hba_inst, CE_WARN,
18145 			    "sata_hba_event_notify: invalid/"
18146 			    "un-implemented port %d:%d (%d ports), "
18147 			    "ignore event 0x%x", cport, pmport,
18148 			    SATA_NUM_PMPORTS(sata_hba_inst, cport), event));
18149 			mutex_exit(&cportinfo->cport_mutex);
18150 			return;
18151 		}
18152 		mutex_exit(&cportinfo->cport_mutex);
18153 
18154 		mutex_enter(&sata_hba_inst->satahba_mutex);
18155 		pmportinfo = SATA_PMPORT_INFO(sata_hba_inst,
18156 		    cport, pmport);
18157 		mutex_exit(&sata_hba_inst->satahba_mutex);
18158 
18159 		/* pmport is implemented/valid? */
18160 		if (pmportinfo == NULL) {
18161 			SATA_LOG_D((sata_hba_inst, CE_WARN,
18162 			    "sata_hba_event_notify: invalid/"
18163 			    "un-implemented port %d:%d, ignore "
18164 			    "event 0x%x", cport, pmport, event));
18165 			return;
18166 		}
18167 	}
18168 
18169 	/*
18170 	 * Events refer to devices, ports and controllers - each has
18171 	 * unique address. Events for different addresses cannot be combined.
18172 	 */
18173 	if (saddr->qual & (SATA_ADDR_CPORT | SATA_ADDR_PMPORT)) {
18174 
18175 		mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, cport)));
18176 
18177 		/* qualify this event(s) */
18178 		if ((event & SATA_EVNT_PORT_EVENTS) == 0) {
18179 			/* Invalid event for the device port */
18180 			(void) sprintf(buf2, err_msg_evnt_1,
18181 			    event & SATA_EVNT_PORT_EVENTS);
18182 			mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, cport)));
18183 			goto event_info;
18184 		}
18185 		if (saddr->qual == SATA_ADDR_CPORT) {
18186 			/* Controller's device port event */
18187 
18188 			(SATA_CPORT_INFO(sata_hba_inst, cport))->
18189 			    cport_event_flags |=
18190 			    event & SATA_EVNT_PORT_EVENTS;
18191 			pstats =
18192 			    &(SATA_CPORT_INFO(sata_hba_inst, cport))->
18193 			    cport_stats;
18194 		} else {
18195 			mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, cport)));
18196 			mutex_enter(&pmportinfo->pmport_mutex);
18197 			/* Port multiplier's device port event */
18198 			(SATA_PMPORT_INFO(sata_hba_inst, cport, pmport))->
18199 			    pmport_event_flags |=
18200 			    event & SATA_EVNT_PORT_EVENTS;
18201 			pstats =
18202 			    &(SATA_PMPORT_INFO(sata_hba_inst, cport, pmport))->
18203 			    pmport_stats;
18204 			mutex_exit(&pmportinfo->pmport_mutex);
18205 			mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, cport)));
18206 		}
18207 
18208 		/*
18209 		 * Add to statistics and log the message. We have to do it
18210 		 * here rather than in the event daemon, because there may be
18211 		 * multiple events occuring before they are processed.
18212 		 */
18213 		linkevent = event &
18214 		    (SATA_EVNT_LINK_LOST | SATA_EVNT_LINK_ESTABLISHED);
18215 		if (linkevent) {
18216 			if (linkevent == (SATA_EVNT_LINK_LOST |
18217 			    SATA_EVNT_LINK_ESTABLISHED)) {
18218 				/* This is likely event combination */
18219 				(void) strlcat(buf1, "link lost/established, ",
18220 				    SATA_EVENT_MAX_MSG_LENGTH);
18221 
18222 				if (pstats->link_lost < 0xffffffffffffffffULL)
18223 					pstats->link_lost++;
18224 				if (pstats->link_established <
18225 				    0xffffffffffffffffULL)
18226 					pstats->link_established++;
18227 				linkevent = 0;
18228 			} else if (linkevent & SATA_EVNT_LINK_LOST) {
18229 				(void) strlcat(buf1, "link lost, ",
18230 				    SATA_EVENT_MAX_MSG_LENGTH);
18231 
18232 				if (pstats->link_lost < 0xffffffffffffffffULL)
18233 					pstats->link_lost++;
18234 			} else {
18235 				(void) strlcat(buf1, "link established, ",
18236 				    SATA_EVENT_MAX_MSG_LENGTH);
18237 				if (pstats->link_established <
18238 				    0xffffffffffffffffULL)
18239 					pstats->link_established++;
18240 			}
18241 		}
18242 		if (event & SATA_EVNT_DEVICE_ATTACHED) {
18243 			(void) strlcat(buf1, "device attached, ",
18244 			    SATA_EVENT_MAX_MSG_LENGTH);
18245 			if (pstats->device_attached < 0xffffffffffffffffULL)
18246 				pstats->device_attached++;
18247 		}
18248 		if (event & SATA_EVNT_DEVICE_DETACHED) {
18249 			(void) strlcat(buf1, "device detached, ",
18250 			    SATA_EVENT_MAX_MSG_LENGTH);
18251 			if (pstats->device_detached < 0xffffffffffffffffULL)
18252 				pstats->device_detached++;
18253 		}
18254 		if (event & SATA_EVNT_PWR_LEVEL_CHANGED) {
18255 			SATADBG1(SATA_DBG_EVENTS, sata_hba_inst,
18256 			    "port %d power level changed", cport);
18257 			if (pstats->port_pwr_changed < 0xffffffffffffffffULL)
18258 				pstats->port_pwr_changed++;
18259 		}
18260 
18261 		if ((event & ~SATA_EVNT_PORT_EVENTS) != 0) {
18262 			/* There should be no other events for this address */
18263 			(void) sprintf(buf2, err_msg_evnt_1,
18264 			    event & ~SATA_EVNT_PORT_EVENTS);
18265 		}
18266 		mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, cport)));
18267 
18268 	} else if (saddr->qual & (SATA_ADDR_DCPORT | SATA_ADDR_DPMPORT)) {
18269 		mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, cport)));
18270 
18271 		/* qualify this event */
18272 		if ((event & SATA_EVNT_DEVICE_RESET) == 0) {
18273 			/* Invalid event for a device */
18274 			(void) sprintf(buf2, err_msg_evnt_2,
18275 			    event & SATA_EVNT_DEVICE_RESET);
18276 			mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, cport)));
18277 			goto event_info;
18278 		}
18279 		/* drive event */
18280 		sdinfo = sata_get_device_info(sata_hba_inst, sata_device);
18281 		if (sdinfo != NULL) {
18282 			if (event & SATA_EVNT_DEVICE_RESET) {
18283 				(void) strlcat(buf1, "device reset, ",
18284 				    SATA_EVENT_MAX_MSG_LENGTH);
18285 				if (sdinfo->satadrv_stats.drive_reset <
18286 				    0xffffffffffffffffULL)
18287 					sdinfo->satadrv_stats.drive_reset++;
18288 				sdinfo->satadrv_event_flags |=
18289 				    SATA_EVNT_DEVICE_RESET;
18290 			}
18291 		}
18292 		if ((event & ~SATA_EVNT_DEVICE_RESET) != 0) {
18293 			/* Invalid event for a device */
18294 			(void) sprintf(buf2, err_msg_evnt_2,
18295 			    event & ~SATA_EVNT_DRIVE_EVENTS);
18296 		}
18297 		mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, cport)));
18298 	} else if (saddr->qual == SATA_ADDR_PMULT) {
18299 		mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, cport)));
18300 
18301 		/* qualify this event */
18302 		if ((event & (SATA_EVNT_DEVICE_RESET |
18303 		    SATA_EVNT_PMULT_LINK_CHANGED)) == 0) {
18304 			/* Invalid event for a port multiplier */
18305 			(void) sprintf(buf2, err_msg_evnt_2,
18306 			    event & SATA_EVNT_DEVICE_RESET);
18307 			mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, cport)));
18308 			goto event_info;
18309 		}
18310 
18311 		pmultinfo = SATA_PMULT_INFO(sata_hba_inst, cport);
18312 
18313 		if (event & SATA_EVNT_DEVICE_RESET) {
18314 
18315 			SATADBG1(SATA_DBG_PMULT, sata_hba_inst,
18316 			    "[Reset] port-mult on cport %d", cport);
18317 			pmultinfo->pmult_event_flags |=
18318 			    SATA_EVNT_DEVICE_RESET;
18319 			(void) strlcat(buf1, "pmult reset, ",
18320 			    SATA_EVENT_MAX_MSG_LENGTH);
18321 		}
18322 
18323 		if (event & SATA_EVNT_PMULT_LINK_CHANGED) {
18324 
18325 			SATADBG1(SATA_DBG_PMULT, sata_hba_inst,
18326 			    "pmult link changed on cport %d", cport);
18327 			pmultinfo->pmult_event_flags |=
18328 			    SATA_EVNT_PMULT_LINK_CHANGED;
18329 			(void) strlcat(buf1, "pmult link changed, ",
18330 			    SATA_EVENT_MAX_MSG_LENGTH);
18331 		}
18332 		mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, cport)));
18333 
18334 	} else {
18335 		if (saddr->qual != SATA_ADDR_NULL) {
18336 			/* Wrong address qualifier */
18337 			SATA_LOG_D((sata_hba_inst, CE_WARN,
18338 			    "sata_hba_event_notify: invalid address 0x%x",
18339 			    *(uint32_t *)saddr));
18340 			return;
18341 		}
18342 		if ((event & SATA_EVNT_CONTROLLER_EVENTS) == 0 ||
18343 		    (event & ~SATA_EVNT_CONTROLLER_EVENTS) != 0) {
18344 			/* Invalid event for the controller */
18345 			SATA_LOG_D((sata_hba_inst, CE_WARN,
18346 			    "sata_hba_event_notify: invalid event 0x%x for "
18347 			    "controller",
18348 			    event & SATA_EVNT_CONTROLLER_EVENTS));
18349 			return;
18350 		}
18351 		buf1[0] = '\0';
18352 		/* This may be a frequent and not interesting event */
18353 		SATADBG1(SATA_DBG_EVENTS, sata_hba_inst,
18354 		    "controller power level changed\n", NULL);
18355 
18356 		mutex_enter(&sata_hba_inst->satahba_mutex);
18357 		if (sata_hba_inst->satahba_stats.ctrl_pwr_change <
18358 		    0xffffffffffffffffULL)
18359 			sata_hba_inst->satahba_stats.ctrl_pwr_change++;
18360 
18361 		sata_hba_inst->satahba_event_flags |=
18362 		    SATA_EVNT_PWR_LEVEL_CHANGED;
18363 		mutex_exit(&sata_hba_inst->satahba_mutex);
18364 	}
18365 	/*
18366 	 * If we got here, there is something to do with this HBA
18367 	 * instance.
18368 	 */
18369 	mutex_enter(&sata_hba_inst->satahba_mutex);
18370 	sata_hba_inst->satahba_event_flags |= SATA_EVNT_MAIN;
18371 	mutex_exit(&sata_hba_inst->satahba_mutex);
18372 	mutex_enter(&sata_mutex);
18373 	sata_event_pending |= SATA_EVNT_MAIN;	/* global event indicator */
18374 	mutex_exit(&sata_mutex);
18375 
18376 	/* Tickle event thread */
18377 	mutex_enter(&sata_event_mutex);
18378 	if (sata_event_thread_active == 0)
18379 		cv_signal(&sata_event_cv);
18380 	mutex_exit(&sata_event_mutex);
18381 
18382 event_info:
18383 	if (buf1[0] != '\0') {
18384 		lcp = strrchr(buf1, ',');
18385 		if (lcp != NULL)
18386 			*lcp = '\0';
18387 	}
18388 	if (saddr->qual == SATA_ADDR_CPORT ||
18389 	    saddr->qual == SATA_ADDR_DCPORT) {
18390 		if (buf1[0] != '\0') {
18391 			sata_log(sata_hba_inst, CE_NOTE, "port %d: %s\n",
18392 			    cport, buf1);
18393 		}
18394 		if (buf2[0] != '\0') {
18395 			sata_log(sata_hba_inst, CE_NOTE, "port %d: %s\n",
18396 			    cport, buf2);
18397 		}
18398 	} else if (saddr->qual == SATA_ADDR_PMPORT ||
18399 	    saddr->qual == SATA_ADDR_DPMPORT) {
18400 		if (buf1[0] != '\0') {
18401 			sata_log(sata_hba_inst, CE_NOTE,
18402 			    "port %d pmport %d: %s\n", cport, pmport, buf1);
18403 		}
18404 		if (buf2[0] != '\0') {
18405 			sata_log(sata_hba_inst, CE_NOTE,
18406 			    "port %d pmport %d: %s\n", cport, pmport, buf2);
18407 		}
18408 	}
18409 }
18410 
18411 
18412 /*
18413  * Event processing thread.
18414  * Arg is a pointer to the sata_hba_list pointer.
18415  * It is not really needed, because sata_hba_list is global and static
18416  */
18417 static void
18418 sata_event_daemon(void *arg)
18419 {
18420 #ifndef __lock_lint
18421 	_NOTE(ARGUNUSED(arg))
18422 #endif
18423 	sata_hba_inst_t *sata_hba_inst;
18424 	clock_t delta;
18425 
18426 	SATADBG1(SATA_DBG_EVENTS_DAEMON, NULL,
18427 	    "SATA event daemon started\n", NULL);
18428 loop:
18429 	/*
18430 	 * Process events here. Walk through all registered HBAs
18431 	 */
18432 	mutex_enter(&sata_mutex);
18433 	for (sata_hba_inst = sata_hba_list; sata_hba_inst != NULL;
18434 	    sata_hba_inst = sata_hba_inst->satahba_next) {
18435 		ASSERT(sata_hba_inst != NULL);
18436 		mutex_enter(&sata_hba_inst->satahba_mutex);
18437 		if (sata_hba_inst->satahba_attached == 0 ||
18438 		    (sata_hba_inst->satahba_event_flags &
18439 		    SATA_EVNT_SKIP) != 0) {
18440 			mutex_exit(&sata_hba_inst->satahba_mutex);
18441 			continue;
18442 		}
18443 		if (sata_hba_inst->satahba_event_flags & SATA_EVNT_MAIN) {
18444 			sata_hba_inst->satahba_event_flags |= SATA_EVNT_SKIP;
18445 			mutex_exit(&sata_hba_inst->satahba_mutex);
18446 			mutex_exit(&sata_mutex);
18447 			/* Got the controller with pending event */
18448 			sata_process_controller_events(sata_hba_inst);
18449 			/*
18450 			 * Since global mutex was released, there is a
18451 			 * possibility that HBA list has changed, so start
18452 			 * over from the top. Just processed controller
18453 			 * will be passed-over because of the SKIP flag.
18454 			 */
18455 			goto loop;
18456 		}
18457 		mutex_exit(&sata_hba_inst->satahba_mutex);
18458 	}
18459 	/* Clear SKIP flag in all controllers */
18460 	for (sata_hba_inst = sata_hba_list; sata_hba_inst != NULL;
18461 	    sata_hba_inst = sata_hba_inst->satahba_next) {
18462 		mutex_enter(&sata_hba_inst->satahba_mutex);
18463 		sata_hba_inst->satahba_event_flags &= ~SATA_EVNT_SKIP;
18464 		mutex_exit(&sata_hba_inst->satahba_mutex);
18465 	}
18466 	mutex_exit(&sata_mutex);
18467 
18468 	SATADBG1(SATA_DBG_EVENTS_DAEMON, NULL,
18469 	    "SATA EVENT DAEMON suspending itself", NULL);
18470 
18471 #ifdef SATA_DEBUG
18472 	if ((sata_func_enable & SATA_ENABLE_PROCESS_EVENTS) == 0) {
18473 		sata_log(sata_hba_inst, CE_WARN,
18474 		    "SATA EVENTS PROCESSING DISABLED\n");
18475 		thread_exit(); /* Daemon will not run again */
18476 	}
18477 #endif
18478 	mutex_enter(&sata_event_mutex);
18479 	sata_event_thread_active = 0;
18480 	mutex_exit(&sata_event_mutex);
18481 	/*
18482 	 * Go to sleep/suspend itself and wake up either because new event or
18483 	 * wait timeout. Exit if there is a termination request (driver
18484 	 * unload).
18485 	 */
18486 	delta = drv_usectohz(SATA_EVNT_DAEMON_SLEEP_TIME);
18487 	do {
18488 		mutex_enter(&sata_event_mutex);
18489 		(void) cv_reltimedwait(&sata_event_cv, &sata_event_mutex,
18490 		    delta, TR_CLOCK_TICK);
18491 
18492 		if (sata_event_thread_active != 0) {
18493 			mutex_exit(&sata_event_mutex);
18494 			continue;
18495 		}
18496 
18497 		/* Check if it is time to go away */
18498 		if (sata_event_thread_terminate == 1) {
18499 			/*
18500 			 * It is up to the thread setting above flag to make
18501 			 * sure that this thread is not killed prematurely.
18502 			 */
18503 			sata_event_thread_terminate = 0;
18504 			sata_event_thread = NULL;
18505 			mutex_exit(&sata_event_mutex);
18506 			SATADBG1(SATA_DBG_EVENTS_DAEMON, NULL,
18507 			    "SATA_EVENT_DAEMON_TERMINATING", NULL);
18508 			thread_exit();  { _NOTE(NOT_REACHED) }
18509 		}
18510 		mutex_exit(&sata_event_mutex);
18511 	} while (!(sata_event_pending & SATA_EVNT_MAIN));
18512 
18513 	mutex_enter(&sata_event_mutex);
18514 	sata_event_thread_active = 1;
18515 	mutex_exit(&sata_event_mutex);
18516 
18517 	mutex_enter(&sata_mutex);
18518 	sata_event_pending &= ~SATA_EVNT_MAIN;
18519 	mutex_exit(&sata_mutex);
18520 
18521 	SATADBG1(SATA_DBG_EVENTS_DAEMON, NULL,
18522 	    "SATA EVENT DAEMON READY TO PROCESS EVENT", NULL);
18523 
18524 	goto loop;
18525 }
18526 
18527 /*
18528  * Specific HBA instance event processing.
18529  *
18530  * NOTE: At the moment, device event processing is limited to hard disks
18531  * only.
18532  * Port multiplier is supported now.
18533  */
18534 static void
18535 sata_process_controller_events(sata_hba_inst_t *sata_hba_inst)
18536 {
18537 	int ncport;
18538 	uint32_t event_flags;
18539 	sata_address_t *saddr;
18540 	sata_cport_info_t *cportinfo;
18541 	sata_pmult_info_t *pmultinfo;
18542 
18543 	SATADBG1(SATA_DBG_EVENTS_CNTRL, sata_hba_inst,
18544 	    "Processing controller %d event(s)",
18545 	    ddi_get_instance(SATA_DIP(sata_hba_inst)));
18546 
18547 	mutex_enter(&sata_hba_inst->satahba_mutex);
18548 	sata_hba_inst->satahba_event_flags &= ~SATA_EVNT_MAIN;
18549 	event_flags = sata_hba_inst->satahba_event_flags;
18550 	mutex_exit(&sata_hba_inst->satahba_mutex);
18551 	/*
18552 	 * Process controller power change first
18553 	 * HERE
18554 	 */
18555 	if (event_flags & SATA_EVNT_PWR_LEVEL_CHANGED)
18556 		sata_process_cntrl_pwr_level_change(sata_hba_inst);
18557 
18558 	/*
18559 	 * Search through ports/devices to identify affected port/device.
18560 	 * We may have to process events for more than one port/device.
18561 	 */
18562 	for (ncport = 0; ncport < SATA_NUM_CPORTS(sata_hba_inst); ncport++) {
18563 		/*
18564 		 * Not all ports may be processed in attach by the time we
18565 		 * get an event. Check if port info is initialized.
18566 		 */
18567 		mutex_enter(&sata_hba_inst->satahba_mutex);
18568 		cportinfo = SATA_CPORT_INFO(sata_hba_inst, ncport);
18569 		mutex_exit(&sata_hba_inst->satahba_mutex);
18570 		if (cportinfo == NULL || cportinfo->cport_state == 0)
18571 			continue;
18572 
18573 		/* We have initialized controller port info */
18574 		mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, ncport)));
18575 		event_flags = (SATA_CPORT_INFO(sata_hba_inst, ncport))->
18576 		    cport_event_flags;
18577 		/* Check if port was locked by IOCTL processing */
18578 		if (event_flags & SATA_APCTL_LOCK_PORT_BUSY) {
18579 			/*
18580 			 * We ignore port events because port is busy
18581 			 * with AP control processing. Set again
18582 			 * controller and main event flag, so that
18583 			 * events may be processed by the next daemon
18584 			 * run.
18585 			 */
18586 			mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, ncport)));
18587 			mutex_enter(&sata_hba_inst->satahba_mutex);
18588 			sata_hba_inst->satahba_event_flags |= SATA_EVNT_MAIN;
18589 			mutex_exit(&sata_hba_inst->satahba_mutex);
18590 			mutex_enter(&sata_mutex);
18591 			sata_event_pending |= SATA_EVNT_MAIN;
18592 			mutex_exit(&sata_mutex);
18593 			SATADBG1(SATA_DBG_EVENTS_PROCPST, sata_hba_inst,
18594 			    "Event processing postponed until "
18595 			    "AP control processing completes",
18596 			    NULL);
18597 			/* Check other ports */
18598 			continue;
18599 		} else {
18600 			/*
18601 			 * Set BSY flag so that AP control would not
18602 			 * interfere with events processing for
18603 			 * this port.
18604 			 */
18605 			(SATA_CPORT_INFO(sata_hba_inst, ncport))->
18606 			    cport_event_flags |= SATA_EVNT_LOCK_PORT_BUSY;
18607 		}
18608 		mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, ncport)));
18609 
18610 		saddr = &(SATA_CPORT_INFO(sata_hba_inst, ncport))->cport_addr;
18611 
18612 		if ((event_flags &
18613 		    (SATA_EVNT_PORT_EVENTS | SATA_EVNT_DRIVE_EVENTS)) != 0) {
18614 			/*
18615 			 * Got port event.
18616 			 * We need some hierarchy of event processing as they
18617 			 * are affecting each other:
18618 			 * 1. port failed
18619 			 * 2. device detached/attached
18620 			 * 3. link events - link events may trigger device
18621 			 *    detached or device attached events in some
18622 			 *    circumstances.
18623 			 * 4. port power level changed
18624 			 */
18625 			if (event_flags & SATA_EVNT_PORT_FAILED) {
18626 				sata_process_port_failed_event(sata_hba_inst,
18627 				    saddr);
18628 			}
18629 			if (event_flags & SATA_EVNT_DEVICE_DETACHED) {
18630 				sata_process_device_detached(sata_hba_inst,
18631 				    saddr);
18632 			}
18633 			if (event_flags & SATA_EVNT_DEVICE_ATTACHED) {
18634 				sata_process_device_attached(sata_hba_inst,
18635 				    saddr);
18636 			}
18637 			if (event_flags &
18638 			    (SATA_EVNT_LINK_ESTABLISHED |
18639 			    SATA_EVNT_LINK_LOST)) {
18640 				sata_process_port_link_events(sata_hba_inst,
18641 				    saddr);
18642 			}
18643 			if (event_flags & SATA_EVNT_PWR_LEVEL_CHANGED) {
18644 				sata_process_port_pwr_change(sata_hba_inst,
18645 				    saddr);
18646 			}
18647 			if (event_flags & SATA_EVNT_TARGET_NODE_CLEANUP) {
18648 				sata_process_target_node_cleanup(
18649 				    sata_hba_inst, saddr);
18650 			}
18651 			if (event_flags & SATA_EVNT_AUTOONLINE_DEVICE) {
18652 				sata_process_device_autoonline(
18653 				    sata_hba_inst, saddr);
18654 			}
18655 		}
18656 
18657 
18658 		/*
18659 		 * Scan port multiplier and all its sub-ports event flags.
18660 		 * The events are marked by
18661 		 * (1) sata_pmult_info.pmult_event_flags
18662 		 * (2) sata_pmport_info.pmport_event_flags
18663 		 */
18664 		mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, ncport)));
18665 		if (cportinfo->cport_dev_type == SATA_DTYPE_PMULT) {
18666 			/*
18667 			 * There should be another extra check: this
18668 			 * port multiplier still exists?
18669 			 */
18670 			pmultinfo = SATA_PMULT_INFO(sata_hba_inst,
18671 			    ncport);
18672 
18673 			if (pmultinfo != NULL) {
18674 				mutex_exit(&(SATA_CPORT_MUTEX(
18675 				    sata_hba_inst, ncport)));
18676 				sata_process_pmult_events(
18677 				    sata_hba_inst, ncport);
18678 				mutex_enter(&(SATA_CPORT_MUTEX(
18679 				    sata_hba_inst, ncport)));
18680 			} else {
18681 				SATADBG1(SATA_DBG_PMULT, sata_hba_inst,
18682 				    "Port-multiplier is gone. "
18683 				    "Ignore all sub-device events "
18684 				    "at port %d.", ncport);
18685 			}
18686 		}
18687 
18688 		if ((SATA_CPORT_DEV_TYPE(sata_hba_inst, ncport) !=
18689 		    SATA_DTYPE_NONE) &&
18690 		    (SATA_CPORT_DRV_INFO(sata_hba_inst, ncport) != NULL)) {
18691 			if (SATA_CPORT_DRV_INFO(sata_hba_inst, ncport)->
18692 			    satadrv_event_flags &
18693 			    (SATA_EVNT_DEVICE_RESET |
18694 			    SATA_EVNT_INPROC_DEVICE_RESET)) {
18695 				/* Have device event */
18696 				sata_process_device_reset(sata_hba_inst,
18697 				    saddr);
18698 			}
18699 		}
18700 		/* Release PORT_BUSY flag */
18701 		(SATA_CPORT_INFO(sata_hba_inst, ncport))->
18702 		    cport_event_flags &= ~SATA_EVNT_LOCK_PORT_BUSY;
18703 		mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, ncport)));
18704 
18705 	} /* End of loop through the controller SATA ports */
18706 }
18707 
18708 /*
18709  * Specific port multiplier instance event processing. At the moment, device
18710  * event processing is limited to link/attach event only.
18711  *
18712  * NOTE: power management event is not supported yet.
18713  */
18714 static void
18715 sata_process_pmult_events(sata_hba_inst_t *sata_hba_inst, uint8_t cport)
18716 {
18717 	sata_cport_info_t *cportinfo = SATA_CPORT_INFO(sata_hba_inst, cport);
18718 	sata_pmult_info_t *pmultinfo;
18719 	sata_pmport_info_t *pmportinfo;
18720 	sata_address_t *saddr;
18721 	sata_device_t sata_device;
18722 	uint32_t event_flags;
18723 	int npmport;
18724 	int rval;
18725 
18726 	SATADBG2(SATA_DBG_EVENTS_CNTRL|SATA_DBG_PMULT, sata_hba_inst,
18727 	    "Processing pmult event(s) on cport %d of controller %d",
18728 	    cport, ddi_get_instance(SATA_DIP(sata_hba_inst)));
18729 
18730 	/* First process events on port multiplier */
18731 	mutex_enter(&cportinfo->cport_mutex);
18732 	pmultinfo = SATA_PMULT_INFO(sata_hba_inst, cport);
18733 	event_flags = pmultinfo->pmult_event_flags;
18734 
18735 	/*
18736 	 * Reset event (of port multiplier) has higher priority because the
18737 	 * port multiplier itself might be failed or removed after reset.
18738 	 */
18739 	if (event_flags & SATA_EVNT_DEVICE_RESET) {
18740 		/*
18741 		 * The status of the sub-links are uncertain,
18742 		 * so mark all sub-ports as RESET
18743 		 */
18744 		for (npmport = 0; npmport < SATA_NUM_PMPORTS(
18745 		    sata_hba_inst, cport); npmport ++) {
18746 			pmportinfo = SATA_PMPORT_INFO(sata_hba_inst,
18747 			    cport, npmport);
18748 			if (pmportinfo == NULL) {
18749 				/* That's weird. */
18750 				SATA_LOG_D((sata_hba_inst, CE_WARN,
18751 				    "sata_hba_event_notify: "
18752 				    "invalid/un-implemented "
18753 				    "port %d:%d (%d ports), ",
18754 				    cport, npmport, SATA_NUM_PMPORTS(
18755 				    sata_hba_inst, cport)));
18756 				continue;
18757 			}
18758 
18759 			mutex_enter(&pmportinfo->pmport_mutex);
18760 
18761 			/* Mark all pmport to unknow state. */
18762 			pmportinfo->pmport_state = SATA_STATE_UNKNOWN;
18763 			/* Mark all pmports with link events. */
18764 			pmportinfo->pmport_event_flags =
18765 			    (SATA_EVNT_LINK_ESTABLISHED|SATA_EVNT_LINK_LOST);
18766 			mutex_exit(&pmportinfo->pmport_mutex);
18767 		}
18768 
18769 	} else if (event_flags & SATA_EVNT_PMULT_LINK_CHANGED) {
18770 		/*
18771 		 * We need probe the port multiplier to know what has
18772 		 * happened.
18773 		 */
18774 		bzero(&sata_device, sizeof (sata_device_t));
18775 		sata_device.satadev_rev = SATA_DEVICE_REV;
18776 		sata_device.satadev_addr.cport = cport;
18777 		sata_device.satadev_addr.pmport = SATA_PMULT_HOSTPORT;
18778 		sata_device.satadev_addr.qual = SATA_ADDR_PMULT;
18779 
18780 		mutex_exit(&cportinfo->cport_mutex);
18781 		rval = (*SATA_PROBE_PORT_FUNC(sata_hba_inst))
18782 		    (SATA_DIP(sata_hba_inst), &sata_device);
18783 		mutex_enter(&cportinfo->cport_mutex);
18784 		if (rval != SATA_SUCCESS) {
18785 			/* Something went wrong? Fail the port */
18786 			cportinfo->cport_state = SATA_PSTATE_FAILED;
18787 			mutex_exit(&cportinfo->cport_mutex);
18788 			SATA_LOG_D((sata_hba_inst, CE_WARN,
18789 			    "SATA port %d probing failed", cport));
18790 
18791 			/* PMult structure must be released.  */
18792 			sata_free_pmult(sata_hba_inst, &sata_device);
18793 			return;
18794 		}
18795 
18796 		sata_update_port_info(sata_hba_inst, &sata_device);
18797 
18798 		/*
18799 		 * Sanity check - Port is active? Is the link active?
18800 		 * The device is still a port multiplier?
18801 		 */
18802 		if ((cportinfo->cport_state &
18803 		    (SATA_PSTATE_SHUTDOWN | SATA_PSTATE_FAILED)) ||
18804 		    ((cportinfo->cport_scr.sstatus &
18805 		    SATA_PORT_DEVLINK_UP_MASK) != SATA_PORT_DEVLINK_UP) ||
18806 		    (cportinfo->cport_dev_type != SATA_DTYPE_PMULT)) {
18807 			mutex_exit(&cportinfo->cport_mutex);
18808 
18809 			/* PMult structure must be released.  */
18810 			sata_free_pmult(sata_hba_inst, &sata_device);
18811 			return;
18812 		}
18813 
18814 		/* Probed succeed, set port ready. */
18815 		cportinfo->cport_state |=
18816 		    SATA_STATE_PROBED | SATA_STATE_READY;
18817 	}
18818 
18819 	/* Release port multiplier event flags. */
18820 	pmultinfo->pmult_event_flags &=
18821 	    ~(SATA_EVNT_DEVICE_RESET|SATA_EVNT_PMULT_LINK_CHANGED);
18822 	mutex_exit(&cportinfo->cport_mutex);
18823 
18824 	/*
18825 	 * Check all sub-links.
18826 	 */
18827 	for (npmport = 0; npmport < SATA_NUM_PMPORTS(sata_hba_inst, cport);
18828 	    npmport ++) {
18829 		pmportinfo = SATA_PMPORT_INFO(sata_hba_inst, cport, npmport);
18830 		mutex_enter(&pmportinfo->pmport_mutex);
18831 		event_flags = pmportinfo->pmport_event_flags;
18832 		mutex_exit(&pmportinfo->pmport_mutex);
18833 		saddr = &pmportinfo->pmport_addr;
18834 
18835 		if ((event_flags &
18836 		    (SATA_EVNT_PORT_EVENTS | SATA_EVNT_DRIVE_EVENTS)) != 0) {
18837 			/*
18838 			 * Got port multiplier port event.
18839 			 * We need some hierarchy of event processing as they
18840 			 * are affecting each other:
18841 			 * 1. device detached/attached
18842 			 * 2. link events - link events may trigger device
18843 			 *    detached or device attached events in some
18844 			 *    circumstances.
18845 			 */
18846 			if (event_flags & SATA_EVNT_DEVICE_DETACHED) {
18847 				sata_process_pmdevice_detached(sata_hba_inst,
18848 				    saddr);
18849 			}
18850 			if (event_flags & SATA_EVNT_DEVICE_ATTACHED) {
18851 				sata_process_pmdevice_attached(sata_hba_inst,
18852 				    saddr);
18853 			}
18854 			if (event_flags & SATA_EVNT_LINK_ESTABLISHED ||
18855 			    event_flags & SATA_EVNT_LINK_LOST) {
18856 				sata_process_pmport_link_events(sata_hba_inst,
18857 				    saddr);
18858 			}
18859 			if (event_flags & SATA_EVNT_TARGET_NODE_CLEANUP) {
18860 				sata_process_target_node_cleanup(
18861 				    sata_hba_inst, saddr);
18862 			}
18863 		}
18864 
18865 		/* Checking drive event(s). */
18866 		mutex_enter(&pmportinfo->pmport_mutex);
18867 		if (pmportinfo->pmport_dev_type != SATA_DTYPE_NONE &&
18868 		    pmportinfo->pmport_sata_drive != NULL) {
18869 			event_flags = pmportinfo->pmport_sata_drive->
18870 			    satadrv_event_flags;
18871 			if (event_flags & (SATA_EVNT_DEVICE_RESET |
18872 			    SATA_EVNT_INPROC_DEVICE_RESET)) {
18873 
18874 				/* Have device event */
18875 				sata_process_pmdevice_reset(sata_hba_inst,
18876 				    saddr);
18877 			}
18878 		}
18879 		mutex_exit(&pmportinfo->pmport_mutex);
18880 
18881 		/* Release PORT_BUSY flag */
18882 		mutex_enter(&cportinfo->cport_mutex);
18883 		cportinfo->cport_event_flags &= ~SATA_EVNT_LOCK_PORT_BUSY;
18884 		mutex_exit(&cportinfo->cport_mutex);
18885 	}
18886 
18887 	SATADBG2(SATA_DBG_EVENTS_CNTRL|SATA_DBG_PMULT, sata_hba_inst,
18888 	    "[DONE] pmult event(s) on cport %d of controller %d",
18889 	    cport, ddi_get_instance(SATA_DIP(sata_hba_inst)));
18890 }
18891 
18892 /*
18893  * Process HBA power level change reported by HBA driver.
18894  * Not implemented at this time - event is ignored.
18895  */
18896 static void
18897 sata_process_cntrl_pwr_level_change(sata_hba_inst_t *sata_hba_inst)
18898 {
18899 	SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst,
18900 	    "Processing controller power level change", NULL);
18901 
18902 	/* Ignoring it for now */
18903 	mutex_enter(&sata_hba_inst->satahba_mutex);
18904 	sata_hba_inst->satahba_event_flags &= ~SATA_EVNT_PWR_LEVEL_CHANGED;
18905 	mutex_exit(&sata_hba_inst->satahba_mutex);
18906 }
18907 
18908 /*
18909  * Process port power level change reported by HBA driver.
18910  * Not implemented at this time - event is ignored.
18911  */
18912 static void
18913 sata_process_port_pwr_change(sata_hba_inst_t *sata_hba_inst,
18914     sata_address_t *saddr)
18915 {
18916 	sata_cport_info_t *cportinfo;
18917 
18918 	SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst,
18919 	    "Processing port power level change", NULL);
18920 
18921 	cportinfo = SATA_CPORT_INFO(sata_hba_inst, saddr->cport);
18922 	mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex);
18923 	/* Reset event flag */
18924 	cportinfo->cport_event_flags &= ~SATA_EVNT_PWR_LEVEL_CHANGED;
18925 	mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex);
18926 }
18927 
18928 /*
18929  * Process port failure reported by HBA driver.
18930  * cports support only - no pmports.
18931  */
18932 static void
18933 sata_process_port_failed_event(sata_hba_inst_t *sata_hba_inst,
18934     sata_address_t *saddr)
18935 {
18936 	sata_cport_info_t *cportinfo;
18937 
18938 	cportinfo = SATA_CPORT_INFO(sata_hba_inst, saddr->cport);
18939 	mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex);
18940 	/* Reset event flag first */
18941 	cportinfo->cport_event_flags &= ~SATA_EVNT_PORT_FAILED;
18942 	/* If the port is in SHUTDOWN or FAILED state, ignore this event. */
18943 	if ((cportinfo->cport_state &
18944 	    (SATA_PSTATE_SHUTDOWN | SATA_PSTATE_FAILED)) == 0) {
18945 		mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->
18946 		    cport_mutex);
18947 		return;
18948 	}
18949 	/* Fail the port */
18950 	cportinfo->cport_state = SATA_PSTATE_FAILED;
18951 	mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex);
18952 	sata_log(sata_hba_inst, CE_WARN, "SATA port %d failed", saddr->cport);
18953 }
18954 
18955 /*
18956  * Device Reset Event processing.
18957  * The sequence is managed by 3 stage flags:
18958  * - reset event reported,
18959  * - reset event being processed,
18960  * - request to clear device reset state.
18961  *
18962  * NOTE: This function has to be entered with cport mutex held. It exits with
18963  * mutex held as well, but can release mutex during the processing.
18964  */
18965 static void
18966 sata_process_device_reset(sata_hba_inst_t *sata_hba_inst,
18967     sata_address_t *saddr)
18968 {
18969 	sata_drive_info_t old_sdinfo; /* local copy of the drive info */
18970 	sata_drive_info_t *sdinfo;
18971 	sata_cport_info_t *cportinfo;
18972 	sata_device_t sata_device;
18973 	int rval_probe, rval_set;
18974 
18975 	/* We only care about host sata cport for now */
18976 	cportinfo = SATA_CPORT_INFO(sata_hba_inst, saddr->cport);
18977 	sdinfo = SATA_CPORT_DRV_INFO(sata_hba_inst, saddr->cport);
18978 	/*
18979 	 * If the port is in SHUTDOWN or FAILED state, or device is in FAILED
18980 	 * state, ignore reset event.
18981 	 */
18982 	if (((cportinfo->cport_state &
18983 	    (SATA_PSTATE_SHUTDOWN | SATA_PSTATE_FAILED)) != 0) ||
18984 	    (sdinfo->satadrv_state & SATA_DSTATE_FAILED) != 0) {
18985 		sdinfo->satadrv_event_flags &=
18986 		    ~(SATA_EVNT_DEVICE_RESET | SATA_EVNT_INPROC_DEVICE_RESET);
18987 		return;
18988 	}
18989 
18990 	if ((SATA_CPORT_DEV_TYPE(sata_hba_inst, saddr->cport) ==
18991 	    SATA_DTYPE_PMULT)) {
18992 		/*
18993 		 * Should not happened: this is already handled in
18994 		 * sata_hba_event_notify()
18995 		 */
18996 		mutex_exit(&cportinfo->cport_mutex);
18997 		goto done;
18998 	}
18999 
19000 	if ((SATA_CPORT_DEV_TYPE(sata_hba_inst, saddr->cport) &
19001 	    SATA_VALID_DEV_TYPE) == 0) {
19002 		/*
19003 		 * This should not happen - coding error.
19004 		 * But we can recover, so do not panic, just clean up
19005 		 * and if in debug mode, log the message.
19006 		 */
19007 #ifdef SATA_DEBUG
19008 		sata_log(sata_hba_inst, CE_WARN,
19009 		    "sata_process_device_reset: "
19010 		    "Invalid device type with sdinfo!", NULL);
19011 #endif
19012 		sdinfo->satadrv_event_flags = 0;
19013 		return;
19014 	}
19015 
19016 #ifdef SATA_DEBUG
19017 	if ((sdinfo->satadrv_event_flags &
19018 	    (SATA_EVNT_DEVICE_RESET | SATA_EVNT_INPROC_DEVICE_RESET)) == 0) {
19019 		/* Nothing to do */
19020 		/* Something is weird - why we are processing dev reset? */
19021 		SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst,
19022 		    "No device reset event!!!!", NULL);
19023 
19024 		return;
19025 	}
19026 	if ((sdinfo->satadrv_event_flags &
19027 	    (SATA_EVNT_DEVICE_RESET | SATA_EVNT_INPROC_DEVICE_RESET)) ==
19028 	    (SATA_EVNT_DEVICE_RESET | SATA_EVNT_INPROC_DEVICE_RESET)) {
19029 		/* Something is weird - new device reset event */
19030 		SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst,
19031 		    "Overlapping device reset events!", NULL);
19032 	}
19033 #endif
19034 	SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst,
19035 	    "Processing port %d device reset", saddr->cport);
19036 
19037 	/* Clear event flag */
19038 	sdinfo->satadrv_event_flags &= ~SATA_EVNT_DEVICE_RESET;
19039 
19040 	/* It seems that we always need to check the port state first */
19041 	sata_device.satadev_rev = SATA_DEVICE_REV;
19042 	sata_device.satadev_addr = *saddr;
19043 	/*
19044 	 * We have to exit mutex, because the HBA probe port function may
19045 	 * block on its own mutex.
19046 	 */
19047 	mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex);
19048 	rval_probe = (*SATA_PROBE_PORT_FUNC(sata_hba_inst))
19049 	    (SATA_DIP(sata_hba_inst), &sata_device);
19050 	mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex);
19051 	sata_update_port_info(sata_hba_inst, &sata_device);
19052 	if (rval_probe != SATA_SUCCESS) {
19053 		/* Something went wrong? Fail the port */
19054 		cportinfo->cport_state = SATA_PSTATE_FAILED;
19055 		sdinfo = SATA_CPORT_DRV_INFO(sata_hba_inst, saddr->cport);
19056 		if (sdinfo != NULL)
19057 			sdinfo->satadrv_event_flags = 0;
19058 		mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->
19059 		    cport_mutex);
19060 		SATA_LOG_D((sata_hba_inst, CE_WARN,
19061 		    "SATA port %d probing failed",
19062 		    saddr->cport));
19063 		mutex_enter(&SATA_CPORT_INFO(sata_hba_inst,
19064 		    saddr->cport)->cport_mutex);
19065 		return;
19066 	}
19067 	if ((sata_device.satadev_scr.sstatus  &
19068 	    SATA_PORT_DEVLINK_UP_MASK) !=
19069 	    SATA_PORT_DEVLINK_UP ||
19070 	    sata_device.satadev_type == SATA_DTYPE_NONE) {
19071 		/*
19072 		 * No device to process, anymore. Some other event processing
19073 		 * would or have already performed port info cleanup.
19074 		 * To be safe (HBA may need it), request clearing device
19075 		 * reset condition.
19076 		 */
19077 		sdinfo = SATA_CPORT_DRV_INFO(sata_hba_inst, saddr->cport);
19078 		if (sdinfo != NULL) {
19079 			sdinfo->satadrv_event_flags &=
19080 			    ~SATA_EVNT_INPROC_DEVICE_RESET;
19081 			sdinfo->satadrv_event_flags |=
19082 			    SATA_EVNT_CLEAR_DEVICE_RESET;
19083 		}
19084 		return;
19085 	}
19086 
19087 	sdinfo = SATA_CPORT_DRV_INFO(sata_hba_inst, saddr->cport);
19088 	if (sdinfo == NULL) {
19089 		return;
19090 	}
19091 	if ((sdinfo->satadrv_event_flags &
19092 	    SATA_EVNT_INPROC_DEVICE_RESET) == 0) {
19093 		/*
19094 		 * Start tracking time for device feature restoration and
19095 		 * identification. Save current time (lbolt value).
19096 		 */
19097 		sdinfo->satadrv_reset_time = ddi_get_lbolt();
19098 	}
19099 	/* Mark device reset processing as active */
19100 	sdinfo->satadrv_event_flags |= SATA_EVNT_INPROC_DEVICE_RESET;
19101 
19102 	old_sdinfo = *sdinfo;	/* local copy of the drive info */
19103 	mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex);
19104 
19105 	rval_set = sata_set_drive_features(sata_hba_inst, &old_sdinfo, 1);
19106 
19107 	if (rval_set  != SATA_SUCCESS) {
19108 		/*
19109 		 * Restoring drive setting failed.
19110 		 * Probe the port first, to check if the port state has changed
19111 		 */
19112 		sata_device.satadev_rev = SATA_DEVICE_REV;
19113 		sata_device.satadev_addr = *saddr;
19114 		sata_device.satadev_addr.qual = SATA_ADDR_CPORT;
19115 		/* probe port */
19116 		rval_probe = (*SATA_PROBE_PORT_FUNC(sata_hba_inst))
19117 		    (SATA_DIP(sata_hba_inst), &sata_device);
19118 		mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->
19119 		    cport_mutex);
19120 		if (rval_probe == SATA_SUCCESS &&
19121 		    (sata_device.satadev_state &
19122 		    (SATA_PSTATE_SHUTDOWN | SATA_PSTATE_FAILED)) == 0 &&
19123 		    (sata_device.satadev_scr.sstatus  &
19124 		    SATA_PORT_DEVLINK_UP_MASK) == SATA_PORT_DEVLINK_UP &&
19125 		    sata_device.satadev_type != SATA_DTYPE_NONE) {
19126 			/*
19127 			 * We may retry this a bit later - in-process reset
19128 			 * condition should be already set.
19129 			 * Track retry time for device identification.
19130 			 */
19131 			if ((cportinfo->cport_dev_type &
19132 			    SATA_VALID_DEV_TYPE) != 0 &&
19133 			    SATA_CPORTINFO_DRV_INFO(cportinfo) != NULL &&
19134 			    sdinfo->satadrv_reset_time != 0) {
19135 				clock_t cur_time = ddi_get_lbolt();
19136 				/*
19137 				 * If the retry time limit was not
19138 				 * exceeded, retry.
19139 				 */
19140 				if ((cur_time - sdinfo->satadrv_reset_time) <
19141 				    drv_usectohz(SATA_DEV_REPROBE_TIMEOUT)) {
19142 					mutex_enter(
19143 					    &sata_hba_inst->satahba_mutex);
19144 					sata_hba_inst->satahba_event_flags |=
19145 					    SATA_EVNT_MAIN;
19146 					mutex_exit(
19147 					    &sata_hba_inst->satahba_mutex);
19148 					mutex_enter(&sata_mutex);
19149 					sata_event_pending |= SATA_EVNT_MAIN;
19150 					mutex_exit(&sata_mutex);
19151 					return;
19152 				}
19153 				if (rval_set == SATA_RETRY) {
19154 					/*
19155 					 * Setting drive features failed, but
19156 					 * the drive is still accessible,
19157 					 * so emit a warning message before
19158 					 * return.
19159 					 */
19160 					mutex_exit(&SATA_CPORT_INFO(
19161 					    sata_hba_inst,
19162 					    saddr->cport)->cport_mutex);
19163 					goto done;
19164 				}
19165 			}
19166 			/* Fail the drive */
19167 			sdinfo->satadrv_state = SATA_DSTATE_FAILED;
19168 
19169 			sata_log(sata_hba_inst, CE_WARN,
19170 			    "SATA device at port %d - device failed",
19171 			    saddr->cport);
19172 
19173 			DTRACE_PROBE(port_failed_f);
19174 		}
19175 		/*
19176 		 * No point of retrying - device failed or some other event
19177 		 * processing or already did or will do port info cleanup.
19178 		 * To be safe (HBA may need it),
19179 		 * request clearing device reset condition.
19180 		 */
19181 		sdinfo->satadrv_event_flags |= SATA_EVNT_CLEAR_DEVICE_RESET;
19182 		sdinfo->satadrv_event_flags &= ~SATA_EVNT_INPROC_DEVICE_RESET;
19183 		sdinfo->satadrv_reset_time = 0;
19184 		return;
19185 	}
19186 done:
19187 	/*
19188 	 * If setting of drive features failed, but the drive is still
19189 	 * accessible, emit a warning message.
19190 	 */
19191 	if (rval_set == SATA_RETRY) {
19192 		sata_log(sata_hba_inst, CE_WARN,
19193 		    "SATA device at port %d - desired setting could not be "
19194 		    "restored after reset. Device may not operate as expected.",
19195 		    saddr->cport);
19196 	}
19197 	/*
19198 	 * Raise the flag indicating that the next sata command could
19199 	 * be sent with SATA_CLEAR_DEV_RESET_STATE flag, if no new device
19200 	 * reset is reported.
19201 	 */
19202 	mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex);
19203 	if (SATA_CPORTINFO_DRV_INFO(cportinfo) != NULL) {
19204 		sdinfo->satadrv_reset_time = 0;
19205 		if ((cportinfo->cport_dev_type & SATA_VALID_DEV_TYPE) != 0) {
19206 			sdinfo = SATA_CPORTINFO_DRV_INFO(cportinfo);
19207 			sdinfo->satadrv_event_flags &=
19208 			    ~SATA_EVNT_INPROC_DEVICE_RESET;
19209 			sdinfo->satadrv_event_flags |=
19210 			    SATA_EVNT_CLEAR_DEVICE_RESET;
19211 		}
19212 	}
19213 }
19214 
19215 
19216 /*
19217  * Port Multiplier Port Device Reset Event processing.
19218  *
19219  * NOTE: This function has to be entered with pmport mutex held. It exits with
19220  * mutex held as well, but can release mutex during the processing.
19221  */
19222 static void
19223 sata_process_pmdevice_reset(sata_hba_inst_t *sata_hba_inst,
19224     sata_address_t *saddr)
19225 {
19226 	sata_drive_info_t old_sdinfo; /* local copy of the drive info */
19227 	sata_drive_info_t *sdinfo = NULL;
19228 	sata_cport_info_t *cportinfo = NULL;
19229 	sata_pmport_info_t *pmportinfo = NULL;
19230 	sata_pmult_info_t *pminfo = NULL;
19231 	sata_device_t sata_device;
19232 	uint8_t cport = saddr->cport;
19233 	uint8_t pmport = saddr->pmport;
19234 	int rval;
19235 
19236 	SATADBG2(SATA_DBG_EVENTS_PROC, sata_hba_inst,
19237 	    "Processing drive reset at port %d:%d", cport, pmport);
19238 
19239 	cportinfo = SATA_CPORT_INFO(sata_hba_inst, cport);
19240 	pmportinfo = SATA_PMPORT_INFO(sata_hba_inst, cport, pmport);
19241 	sdinfo = SATA_PMPORT_DRV_INFO(sata_hba_inst, cport, pmport);
19242 
19243 	/*
19244 	 * If the port is in SHUTDOWN or FAILED state, or device is in FAILED
19245 	 * state, ignore reset event.
19246 	 */
19247 	if (((cportinfo->cport_state &
19248 	    (SATA_PSTATE_SHUTDOWN | SATA_PSTATE_FAILED)) != 0) ||
19249 	    (sdinfo->satadrv_state & SATA_DSTATE_FAILED) != 0) {
19250 		sdinfo->satadrv_event_flags &=
19251 		    ~(SATA_EVNT_DEVICE_RESET | SATA_EVNT_INPROC_DEVICE_RESET);
19252 		return;
19253 	}
19254 
19255 	if ((pmportinfo->pmport_dev_type & SATA_VALID_DEV_TYPE) == 0) {
19256 		/*
19257 		 * This should not happen - coding error.
19258 		 * But we can recover, so do not panic, just clean up
19259 		 * and if in debug mode, log the message.
19260 		 */
19261 #ifdef SATA_DEBUG
19262 		sata_log(sata_hba_inst, CE_WARN,
19263 		    "sata_process_pmdevice_reset: "
19264 		    "Invalid device type with sdinfo!", NULL);
19265 #endif
19266 		sdinfo->satadrv_event_flags = 0;
19267 		return;
19268 	}
19269 
19270 #ifdef SATA_DEBUG
19271 	if ((sdinfo->satadrv_event_flags &
19272 	    (SATA_EVNT_DEVICE_RESET | SATA_EVNT_INPROC_DEVICE_RESET)) == 0) {
19273 		/* Nothing to do */
19274 		/* Something is weird - why we are processing dev reset? */
19275 		SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst,
19276 		    "No device reset event!!!!", NULL);
19277 
19278 		return;
19279 	}
19280 	if ((sdinfo->satadrv_event_flags &
19281 	    (SATA_EVNT_DEVICE_RESET | SATA_EVNT_INPROC_DEVICE_RESET)) ==
19282 	    (SATA_EVNT_DEVICE_RESET | SATA_EVNT_INPROC_DEVICE_RESET)) {
19283 		/* Something is weird - new device reset event */
19284 		SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst,
19285 		    "Overlapping device reset events!", NULL);
19286 	}
19287 #endif
19288 	SATADBG2(SATA_DBG_EVENTS_PROC, sata_hba_inst,
19289 	    "Processing port %d:%d device reset", cport, pmport);
19290 
19291 	/* Clear event flag */
19292 	sdinfo->satadrv_event_flags &= ~SATA_EVNT_DEVICE_RESET;
19293 
19294 	/* It seems that we always need to check the port state first */
19295 	sata_device.satadev_rev = SATA_DEVICE_REV;
19296 	sata_device.satadev_addr = *saddr;
19297 	/*
19298 	 * We have to exit mutex, because the HBA probe port function may
19299 	 * block on its own mutex.
19300 	 */
19301 	mutex_exit(&pmportinfo->pmport_mutex);
19302 	rval = (*SATA_PROBE_PORT_FUNC(sata_hba_inst))
19303 	    (SATA_DIP(sata_hba_inst), &sata_device);
19304 	mutex_enter(&pmportinfo->pmport_mutex);
19305 
19306 	sata_update_pmport_info(sata_hba_inst, &sata_device);
19307 	if (rval != SATA_SUCCESS) {
19308 		/* Something went wrong? Fail the port */
19309 		pmportinfo->pmport_state = SATA_PSTATE_FAILED;
19310 		sdinfo = SATA_PMPORT_DRV_INFO(sata_hba_inst, saddr->cport,
19311 		    saddr->pmport);
19312 		if (sdinfo != NULL)
19313 			sdinfo->satadrv_event_flags = 0;
19314 		mutex_exit(&pmportinfo->pmport_mutex);
19315 		SATA_LOG_D((sata_hba_inst, CE_WARN,
19316 		    "SATA port %d:%d probing failed",
19317 		    saddr->cport, saddr->pmport));
19318 		mutex_enter(&pmportinfo->pmport_mutex);
19319 		return;
19320 	}
19321 	if ((sata_device.satadev_scr.sstatus  &
19322 	    SATA_PORT_DEVLINK_UP_MASK) !=
19323 	    SATA_PORT_DEVLINK_UP ||
19324 	    sata_device.satadev_type == SATA_DTYPE_NONE) {
19325 		/*
19326 		 * No device to process, anymore. Some other event processing
19327 		 * would or have already performed port info cleanup.
19328 		 * To be safe (HBA may need it), request clearing device
19329 		 * reset condition.
19330 		 */
19331 		sdinfo = SATA_PMPORT_DRV_INFO(sata_hba_inst, saddr->cport,
19332 		    saddr->pmport);
19333 		if (sdinfo != NULL) {
19334 			sdinfo->satadrv_event_flags &=
19335 			    ~SATA_EVNT_INPROC_DEVICE_RESET;
19336 			/* must clear flags on cport */
19337 			pminfo = SATA_PMULT_INFO(sata_hba_inst,
19338 			    saddr->cport);
19339 			pminfo->pmult_event_flags |=
19340 			    SATA_EVNT_CLEAR_DEVICE_RESET;
19341 		}
19342 		return;
19343 	}
19344 
19345 	sdinfo = SATA_PMPORT_DRV_INFO(sata_hba_inst, saddr->cport,
19346 	    saddr->pmport);
19347 	if (sdinfo == NULL) {
19348 		return;
19349 	}
19350 	if ((sdinfo->satadrv_event_flags &
19351 	    SATA_EVNT_INPROC_DEVICE_RESET) == 0) {
19352 		/*
19353 		 * Start tracking time for device feature restoration and
19354 		 * identification. Save current time (lbolt value).
19355 		 */
19356 		sdinfo->satadrv_reset_time = ddi_get_lbolt();
19357 	}
19358 	/* Mark device reset processing as active */
19359 	sdinfo->satadrv_event_flags |= SATA_EVNT_INPROC_DEVICE_RESET;
19360 
19361 	old_sdinfo = *sdinfo;	/* local copy of the drive info */
19362 	mutex_exit(&pmportinfo->pmport_mutex);
19363 
19364 	if (sata_set_drive_features(sata_hba_inst, &old_sdinfo, 1) ==
19365 	    SATA_FAILURE) {
19366 		/*
19367 		 * Restoring drive setting failed.
19368 		 * Probe the port first, to check if the port state has changed
19369 		 */
19370 		sata_device.satadev_rev = SATA_DEVICE_REV;
19371 		sata_device.satadev_addr = *saddr;
19372 		sata_device.satadev_addr.qual = SATA_ADDR_PMPORT;
19373 
19374 		/* probe port */
19375 		rval = (*SATA_PROBE_PORT_FUNC(sata_hba_inst))
19376 		    (SATA_DIP(sata_hba_inst), &sata_device);
19377 		mutex_enter(&pmportinfo->pmport_mutex);
19378 		if (rval == SATA_SUCCESS &&
19379 		    (sata_device.satadev_state &
19380 		    (SATA_PSTATE_SHUTDOWN | SATA_PSTATE_FAILED)) == 0 &&
19381 		    (sata_device.satadev_scr.sstatus  &
19382 		    SATA_PORT_DEVLINK_UP_MASK) == SATA_PORT_DEVLINK_UP &&
19383 		    sata_device.satadev_type != SATA_DTYPE_NONE) {
19384 			/*
19385 			 * We may retry this a bit later - in-process reset
19386 			 * condition should be already set.
19387 			 * Track retry time for device identification.
19388 			 */
19389 			if ((pmportinfo->pmport_dev_type &
19390 			    SATA_VALID_DEV_TYPE) != 0 &&
19391 			    SATA_PMPORTINFO_DRV_INFO(pmportinfo) != NULL &&
19392 			    sdinfo->satadrv_reset_time != 0) {
19393 				clock_t cur_time = ddi_get_lbolt();
19394 				/*
19395 				 * If the retry time limit was not
19396 				 * exceeded, retry.
19397 				 */
19398 				if ((cur_time - sdinfo->satadrv_reset_time) <
19399 				    drv_usectohz(SATA_DEV_REPROBE_TIMEOUT)) {
19400 					mutex_enter(
19401 					    &sata_hba_inst->satahba_mutex);
19402 					sata_hba_inst->satahba_event_flags |=
19403 					    SATA_EVNT_MAIN;
19404 					mutex_exit(
19405 					    &sata_hba_inst->satahba_mutex);
19406 					mutex_enter(&sata_mutex);
19407 					sata_event_pending |= SATA_EVNT_MAIN;
19408 					mutex_exit(&sata_mutex);
19409 					return;
19410 				}
19411 			}
19412 			/* Fail the drive */
19413 			sdinfo->satadrv_state = SATA_DSTATE_FAILED;
19414 
19415 			sata_log(sata_hba_inst, CE_WARN,
19416 			    "SATA device at port %d:%d - device failed",
19417 			    saddr->cport, saddr->pmport);
19418 		} else {
19419 			/*
19420 			 * No point of retrying - some other event processing
19421 			 * would or already did port info cleanup.
19422 			 * To be safe (HBA may need it),
19423 			 * request clearing device reset condition.
19424 			 */
19425 			sdinfo->satadrv_event_flags |=
19426 			    SATA_EVNT_CLEAR_DEVICE_RESET;
19427 		}
19428 		sdinfo->satadrv_event_flags &= ~SATA_EVNT_INPROC_DEVICE_RESET;
19429 		sdinfo->satadrv_reset_time = 0;
19430 		return;
19431 	}
19432 	/*
19433 	 * Raise the flag indicating that the next sata command could
19434 	 * be sent with SATA_CLEAR_DEV_RESET_STATE flag, if no new device
19435 	 * reset is reported.
19436 	 */
19437 	mutex_enter(&pmportinfo->pmport_mutex);
19438 	if (SATA_PMPORTINFO_DRV_INFO(pmportinfo) != NULL) {
19439 		sdinfo->satadrv_reset_time = 0;
19440 		if (pmportinfo->pmport_dev_type & SATA_VALID_DEV_TYPE) {
19441 			sdinfo = SATA_PMPORTINFO_DRV_INFO(pmportinfo);
19442 			sdinfo->satadrv_event_flags &=
19443 			    ~SATA_EVNT_INPROC_DEVICE_RESET;
19444 			/* must clear flags on cport */
19445 			pminfo = SATA_PMULT_INFO(sata_hba_inst,
19446 			    saddr->cport);
19447 			pminfo->pmult_event_flags |=
19448 			    SATA_EVNT_CLEAR_DEVICE_RESET;
19449 		}
19450 	}
19451 }
19452 
19453 /*
19454  * Port Link Events processing.
19455  * Every link established event may involve device reset (due to
19456  * COMRESET signal, equivalent of the hard reset) so arbitrarily
19457  * set device reset event for an attached device (if any).
19458  * If the port is in SHUTDOWN or FAILED state, ignore link events.
19459  *
19460  * The link established event processing varies, depending on the state
19461  * of the target node, HBA hotplugging capabilities, state of the port.
19462  * If the link is not active, the link established event is ignored.
19463  * If HBA cannot detect device attachment and there is no target node,
19464  * the link established event triggers device attach event processing.
19465  * Else, link established event triggers device reset event processing.
19466  *
19467  * The link lost event processing varies, depending on a HBA hotplugging
19468  * capability and the state of the port (link active or not active).
19469  * If the link is active, the lost link event is ignored.
19470  * If HBA cannot detect device removal, the lost link event triggers
19471  * device detached event processing after link lost timeout.
19472  * Else, the event is ignored.
19473  *
19474  * NOTE: Port multiplier ports events are handled by
19475  * sata_process_pmport_link_events();
19476  */
19477 static void
19478 sata_process_port_link_events(sata_hba_inst_t *sata_hba_inst,
19479     sata_address_t *saddr)
19480 {
19481 	sata_device_t sata_device;
19482 	sata_cport_info_t *cportinfo;
19483 	sata_drive_info_t *sdinfo;
19484 	uint32_t event_flags;
19485 	int rval;
19486 
19487 	SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst,
19488 	    "Processing port %d link event(s)", saddr->cport);
19489 
19490 	cportinfo = SATA_CPORT_INFO(sata_hba_inst, saddr->cport);
19491 	mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex);
19492 	event_flags = cportinfo->cport_event_flags;
19493 
19494 	/* Reset event flags first */
19495 	cportinfo->cport_event_flags &=
19496 	    ~(SATA_EVNT_LINK_ESTABLISHED | SATA_EVNT_LINK_LOST);
19497 
19498 	/* If the port is in SHUTDOWN or FAILED state, ignore link events. */
19499 	if ((cportinfo->cport_state &
19500 	    (SATA_PSTATE_SHUTDOWN | SATA_PSTATE_FAILED)) != 0) {
19501 		mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->
19502 		    cport_mutex);
19503 		return;
19504 	}
19505 
19506 	/*
19507 	 * For the sanity sake get current port state.
19508 	 * Set device address only. Other sata_device fields should be
19509 	 * set by HBA driver.
19510 	 */
19511 	sata_device.satadev_rev = SATA_DEVICE_REV;
19512 	sata_device.satadev_addr = *saddr;
19513 	/*
19514 	 * We have to exit mutex, because the HBA probe port function may
19515 	 * block on its own mutex.
19516 	 */
19517 	mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex);
19518 	rval = (*SATA_PROBE_PORT_FUNC(sata_hba_inst))
19519 	    (SATA_DIP(sata_hba_inst), &sata_device);
19520 	mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex);
19521 	sata_update_port_info(sata_hba_inst, &sata_device);
19522 	if (rval != SATA_SUCCESS) {
19523 		/* Something went wrong? Fail the port */
19524 		cportinfo->cport_state = SATA_PSTATE_FAILED;
19525 		mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->
19526 		    cport_mutex);
19527 		SATA_LOG_D((sata_hba_inst, CE_WARN,
19528 		    "SATA port %d probing failed",
19529 		    saddr->cport));
19530 		/*
19531 		 * We may want to release device info structure, but
19532 		 * it is not necessary.
19533 		 */
19534 		return;
19535 	} else {
19536 		/* port probed successfully */
19537 		cportinfo->cport_state |= SATA_STATE_PROBED | SATA_STATE_READY;
19538 	}
19539 	if (event_flags & SATA_EVNT_LINK_ESTABLISHED) {
19540 
19541 		if ((sata_device.satadev_scr.sstatus &
19542 		    SATA_PORT_DEVLINK_UP_MASK) != SATA_PORT_DEVLINK_UP) {
19543 			/* Ignore event */
19544 			SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst,
19545 			    "Ignoring port %d link established event - "
19546 			    "link down",
19547 			    saddr->cport);
19548 			goto linklost;
19549 		}
19550 
19551 		SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst,
19552 		    "Processing port %d link established event",
19553 		    saddr->cport);
19554 
19555 		/*
19556 		 * For the sanity sake check if a device is attached - check
19557 		 * return state of a port probing.
19558 		 */
19559 		if (sata_device.satadev_type != SATA_DTYPE_NONE) {
19560 			/*
19561 			 * HBA port probe indicated that there is a device
19562 			 * attached. Check if the framework had device info
19563 			 * structure attached for this device.
19564 			 */
19565 			if (cportinfo->cport_dev_type != SATA_DTYPE_NONE) {
19566 				ASSERT(SATA_CPORTINFO_DRV_INFO(cportinfo) !=
19567 				    NULL);
19568 
19569 				sdinfo = SATA_CPORTINFO_DRV_INFO(cportinfo);
19570 				if ((sdinfo->satadrv_type &
19571 				    SATA_VALID_DEV_TYPE) != 0) {
19572 					/*
19573 					 * Dev info structure is present.
19574 					 * If dev_type is set to known type in
19575 					 * the framework's drive info struct
19576 					 * then the device existed before and
19577 					 * the link was probably lost
19578 					 * momentarily - in such case
19579 					 * we may want to check device
19580 					 * identity.
19581 					 * Identity check is not supported now.
19582 					 *
19583 					 * Link established event
19584 					 * triggers device reset event.
19585 					 */
19586 					(SATA_CPORTINFO_DRV_INFO(cportinfo))->
19587 					    satadrv_event_flags |=
19588 					    SATA_EVNT_DEVICE_RESET;
19589 				}
19590 			} else if (cportinfo->cport_dev_type ==
19591 			    SATA_DTYPE_NONE) {
19592 				/*
19593 				 * We got new device attached! If HBA does not
19594 				 * generate device attached events, trigger it
19595 				 * here.
19596 				 */
19597 				if (!(SATA_FEATURES(sata_hba_inst) &
19598 				    SATA_CTLF_HOTPLUG)) {
19599 					cportinfo->cport_event_flags |=
19600 					    SATA_EVNT_DEVICE_ATTACHED;
19601 				}
19602 			}
19603 			/* Reset link lost timeout */
19604 			cportinfo->cport_link_lost_time = 0;
19605 		}
19606 	}
19607 linklost:
19608 	if (event_flags & SATA_EVNT_LINK_LOST) {
19609 		if ((sata_device.satadev_scr.sstatus &
19610 		    SATA_PORT_DEVLINK_UP_MASK) == SATA_PORT_DEVLINK_UP) {
19611 			/* Ignore event */
19612 			SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst,
19613 			    "Ignoring port %d link lost event - link is up",
19614 			    saddr->cport);
19615 			goto done;
19616 		}
19617 #ifdef SATA_DEBUG
19618 		if (cportinfo->cport_link_lost_time == 0) {
19619 			SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst,
19620 			    "Processing port %d link lost event",
19621 			    saddr->cport);
19622 		}
19623 #endif
19624 		/*
19625 		 * When HBA cannot generate device attached/detached events,
19626 		 * we need to track link lost time and eventually generate
19627 		 * device detach event.
19628 		 */
19629 		if (!(SATA_FEATURES(sata_hba_inst) & SATA_CTLF_HOTPLUG)) {
19630 			/* We are tracking link lost time */
19631 			if (cportinfo->cport_link_lost_time == 0) {
19632 				/* save current time (lbolt value) */
19633 				cportinfo->cport_link_lost_time =
19634 				    ddi_get_lbolt();
19635 				/* just keep link lost event */
19636 				cportinfo->cport_event_flags |=
19637 				    SATA_EVNT_LINK_LOST;
19638 			} else {
19639 				clock_t cur_time = ddi_get_lbolt();
19640 				if ((cur_time -
19641 				    cportinfo->cport_link_lost_time) >=
19642 				    drv_usectohz(
19643 				    SATA_EVNT_LINK_LOST_TIMEOUT)) {
19644 					/* trigger device detach event */
19645 					cportinfo->cport_event_flags |=
19646 					    SATA_EVNT_DEVICE_DETACHED;
19647 					cportinfo->cport_link_lost_time = 0;
19648 					SATADBG1(SATA_DBG_EVENTS,
19649 					    sata_hba_inst,
19650 					    "Triggering port %d "
19651 					    "device detached event",
19652 					    saddr->cport);
19653 				} else {
19654 					/* keep link lost event */
19655 					cportinfo->cport_event_flags |=
19656 					    SATA_EVNT_LINK_LOST;
19657 				}
19658 			}
19659 		}
19660 		/*
19661 		 * We could change port state to disable/delay access to
19662 		 * the attached device until the link is recovered.
19663 		 */
19664 	}
19665 done:
19666 	event_flags = cportinfo->cport_event_flags;
19667 	mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex);
19668 	if (event_flags != 0) {
19669 		mutex_enter(&sata_hba_inst->satahba_mutex);
19670 		sata_hba_inst->satahba_event_flags |= SATA_EVNT_MAIN;
19671 		mutex_exit(&sata_hba_inst->satahba_mutex);
19672 		mutex_enter(&sata_mutex);
19673 		sata_event_pending |= SATA_EVNT_MAIN;
19674 		mutex_exit(&sata_mutex);
19675 	}
19676 }
19677 
19678 /*
19679  * Port Multiplier Port Link Events processing.
19680  */
19681 static void
19682 sata_process_pmport_link_events(sata_hba_inst_t *sata_hba_inst,
19683     sata_address_t *saddr)
19684 {
19685 	sata_device_t sata_device;
19686 	sata_pmport_info_t *pmportinfo = NULL;
19687 	sata_drive_info_t *sdinfo = NULL;
19688 	uint32_t event_flags;
19689 	uint8_t cport = saddr->cport;
19690 	uint8_t pmport = saddr->pmport;
19691 	int rval;
19692 
19693 	SATADBG2(SATA_DBG_EVENTS_PROC, sata_hba_inst,
19694 	    "Processing port %d:%d link event(s)",
19695 	    cport, pmport);
19696 
19697 	pmportinfo = SATA_PMPORT_INFO(sata_hba_inst, cport, pmport);
19698 	mutex_enter(&pmportinfo->pmport_mutex);
19699 	event_flags = pmportinfo->pmport_event_flags;
19700 
19701 	/* Reset event flags first */
19702 	pmportinfo->pmport_event_flags &=
19703 	    ~(SATA_EVNT_LINK_ESTABLISHED | SATA_EVNT_LINK_LOST);
19704 
19705 	/* If the port is in SHUTDOWN or FAILED state, ignore link events. */
19706 	if ((pmportinfo->pmport_state &
19707 	    (SATA_PSTATE_SHUTDOWN | SATA_PSTATE_FAILED)) != 0) {
19708 		mutex_exit(&pmportinfo->pmport_mutex);
19709 		return;
19710 	}
19711 
19712 	/*
19713 	 * For the sanity sake get current port state.
19714 	 * Set device address only. Other sata_device fields should be
19715 	 * set by HBA driver.
19716 	 */
19717 	sata_device.satadev_rev = SATA_DEVICE_REV;
19718 	sata_device.satadev_addr = *saddr;
19719 	/*
19720 	 * We have to exit mutex, because the HBA probe port function may
19721 	 * block on its own mutex.
19722 	 */
19723 	mutex_exit(&SATA_PMPORT_MUTEX(sata_hba_inst, saddr->cport,
19724 	    saddr->pmport));
19725 	rval = (*SATA_PROBE_PORT_FUNC(sata_hba_inst))
19726 	    (SATA_DIP(sata_hba_inst), &sata_device);
19727 	mutex_enter(&SATA_PMPORT_MUTEX(sata_hba_inst, saddr->cport,
19728 	    saddr->pmport));
19729 	sata_update_pmport_info(sata_hba_inst, &sata_device);
19730 	if (rval != SATA_SUCCESS) {
19731 		/* Something went wrong? Fail the port */
19732 		pmportinfo->pmport_state = SATA_PSTATE_FAILED;
19733 		mutex_exit(&SATA_PMPORT_MUTEX(sata_hba_inst, saddr->cport,
19734 		    saddr->pmport));
19735 		SATA_LOG_D((sata_hba_inst, CE_WARN,
19736 		    "SATA port %d:%d probing failed",
19737 		    saddr->cport, saddr->pmport));
19738 		/*
19739 		 * We may want to release device info structure, but
19740 		 * it is not necessary.
19741 		 */
19742 		return;
19743 	} else {
19744 		/* port probed successfully */
19745 		pmportinfo->pmport_state |=
19746 		    SATA_STATE_PROBED | SATA_STATE_READY;
19747 	}
19748 	mutex_exit(&SATA_PMPORT_MUTEX(sata_hba_inst,
19749 	    saddr->cport, saddr->pmport));
19750 	mutex_enter(&SATA_PMPORT_MUTEX(sata_hba_inst,
19751 	    saddr->cport, saddr->pmport));
19752 	if (event_flags & SATA_EVNT_LINK_ESTABLISHED) {
19753 
19754 		if ((sata_device.satadev_scr.sstatus &
19755 		    SATA_PORT_DEVLINK_UP_MASK) != SATA_PORT_DEVLINK_UP) {
19756 			/* Ignore event */
19757 			SATADBG2(SATA_DBG_EVENTS_PROC, sata_hba_inst,
19758 			    "Ignoring port %d:%d link established event - "
19759 			    "link down",
19760 			    saddr->cport, saddr->pmport);
19761 			goto linklost;
19762 		}
19763 
19764 		SATADBG2(SATA_DBG_EVENTS_PROC, sata_hba_inst,
19765 		    "Processing port %d:%d link established event",
19766 		    cport, pmport);
19767 
19768 		/*
19769 		 * For the sanity sake check if a device is attached - check
19770 		 * return state of a port probing.
19771 		 */
19772 		if (sata_device.satadev_type != SATA_DTYPE_NONE &&
19773 		    sata_device.satadev_type != SATA_DTYPE_PMULT) {
19774 			/*
19775 			 * HBA port probe indicated that there is a device
19776 			 * attached. Check if the framework had device info
19777 			 * structure attached for this device.
19778 			 */
19779 			if (pmportinfo->pmport_dev_type != SATA_DTYPE_NONE) {
19780 				ASSERT(SATA_PMPORTINFO_DRV_INFO(pmportinfo) !=
19781 				    NULL);
19782 
19783 				sdinfo = SATA_PMPORTINFO_DRV_INFO(pmportinfo);
19784 				if ((sdinfo->satadrv_type &
19785 				    SATA_VALID_DEV_TYPE) != 0) {
19786 					/*
19787 					 * Dev info structure is present.
19788 					 * If dev_type is set to known type in
19789 					 * the framework's drive info struct
19790 					 * then the device existed before and
19791 					 * the link was probably lost
19792 					 * momentarily - in such case
19793 					 * we may want to check device
19794 					 * identity.
19795 					 * Identity check is not supported now.
19796 					 *
19797 					 * Link established event
19798 					 * triggers device reset event.
19799 					 */
19800 					(SATA_PMPORTINFO_DRV_INFO(pmportinfo))->
19801 					    satadrv_event_flags |=
19802 					    SATA_EVNT_DEVICE_RESET;
19803 				}
19804 			} else if (pmportinfo->pmport_dev_type ==
19805 			    SATA_DTYPE_NONE) {
19806 				/*
19807 				 * We got new device attached! If HBA does not
19808 				 * generate device attached events, trigger it
19809 				 * here.
19810 				 */
19811 				if (!(SATA_FEATURES(sata_hba_inst) &
19812 				    SATA_CTLF_HOTPLUG)) {
19813 					pmportinfo->pmport_event_flags |=
19814 					    SATA_EVNT_DEVICE_ATTACHED;
19815 				}
19816 			}
19817 			/* Reset link lost timeout */
19818 			pmportinfo->pmport_link_lost_time = 0;
19819 		}
19820 	}
19821 linklost:
19822 	if (event_flags & SATA_EVNT_LINK_LOST) {
19823 #ifdef SATA_DEBUG
19824 		if (pmportinfo->pmport_link_lost_time == 0) {
19825 			SATADBG2(SATA_DBG_EVENTS_PROC, sata_hba_inst,
19826 			    "Processing port %d:%d link lost event",
19827 			    saddr->cport, saddr->pmport);
19828 		}
19829 #endif
19830 		if ((sata_device.satadev_scr.sstatus &
19831 		    SATA_PORT_DEVLINK_UP_MASK) == SATA_PORT_DEVLINK_UP) {
19832 			/* Ignore event */
19833 			SATADBG2(SATA_DBG_EVENTS_PROC, sata_hba_inst,
19834 			    "Ignoring port %d:%d link lost event - link is up",
19835 			    saddr->cport, saddr->pmport);
19836 			goto done;
19837 		}
19838 		/*
19839 		 * When HBA cannot generate device attached/detached events,
19840 		 * we need to track link lost time and eventually generate
19841 		 * device detach event.
19842 		 */
19843 		if (!(SATA_FEATURES(sata_hba_inst) & SATA_CTLF_HOTPLUG)) {
19844 			/* We are tracking link lost time */
19845 			if (pmportinfo->pmport_link_lost_time == 0) {
19846 				/* save current time (lbolt value) */
19847 				pmportinfo->pmport_link_lost_time =
19848 				    ddi_get_lbolt();
19849 				/* just keep link lost event */
19850 				pmportinfo->pmport_event_flags |=
19851 				    SATA_EVNT_LINK_LOST;
19852 			} else {
19853 				clock_t cur_time = ddi_get_lbolt();
19854 				if ((cur_time -
19855 				    pmportinfo->pmport_link_lost_time) >=
19856 				    drv_usectohz(
19857 				    SATA_EVNT_LINK_LOST_TIMEOUT)) {
19858 					/* trigger device detach event */
19859 					pmportinfo->pmport_event_flags |=
19860 					    SATA_EVNT_DEVICE_DETACHED;
19861 					pmportinfo->pmport_link_lost_time = 0;
19862 					SATADBG2(SATA_DBG_EVENTS,
19863 					    sata_hba_inst,
19864 					    "Triggering port %d:%d "
19865 					    "device detached event",
19866 					    saddr->cport, saddr->pmport);
19867 				} else {
19868 					/* keep link lost event */
19869 					pmportinfo->pmport_event_flags |=
19870 					    SATA_EVNT_LINK_LOST;
19871 				}
19872 			}
19873 		}
19874 		/*
19875 		 * We could change port state to disable/delay access to
19876 		 * the attached device until the link is recovered.
19877 		 */
19878 	}
19879 done:
19880 	event_flags = pmportinfo->pmport_event_flags;
19881 	mutex_exit(&SATA_PMPORT_MUTEX(sata_hba_inst, saddr->cport,
19882 	    saddr->pmport));
19883 	if (event_flags != 0) {
19884 		mutex_enter(&sata_hba_inst->satahba_mutex);
19885 		sata_hba_inst->satahba_event_flags |= SATA_EVNT_MAIN;
19886 		mutex_exit(&sata_hba_inst->satahba_mutex);
19887 		mutex_enter(&sata_mutex);
19888 		sata_event_pending |= SATA_EVNT_MAIN;
19889 		mutex_exit(&sata_mutex);
19890 	}
19891 }
19892 
19893 /*
19894  * Device Detached Event processing.
19895  * Port is probed to find if a device is really gone. If so,
19896  * the device info structure is detached from the SATA port info structure
19897  * and released.
19898  * Port status is updated.
19899  *
19900  * NOTE: Port multiplier ports events are handled by
19901  * sata_process_pmdevice_detached()
19902  */
19903 static void
19904 sata_process_device_detached(sata_hba_inst_t *sata_hba_inst,
19905     sata_address_t *saddr)
19906 {
19907 	sata_cport_info_t *cportinfo;
19908 	sata_pmport_info_t *pmportinfo;
19909 	sata_drive_info_t *sdevinfo;
19910 	sata_device_t sata_device;
19911 	sata_address_t pmport_addr;
19912 	char name[16];
19913 	uint8_t cport = saddr->cport;
19914 	int npmport;
19915 	int rval;
19916 
19917 	SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst,
19918 	    "Processing port %d device detached", saddr->cport);
19919 
19920 	cportinfo = SATA_CPORT_INFO(sata_hba_inst, saddr->cport);
19921 	mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex);
19922 	/* Clear event flag */
19923 	cportinfo->cport_event_flags &= ~SATA_EVNT_DEVICE_DETACHED;
19924 
19925 	/* If the port is in SHUTDOWN or FAILED state, ignore detach event. */
19926 	if ((cportinfo->cport_state &
19927 	    (SATA_PSTATE_SHUTDOWN | SATA_PSTATE_FAILED)) != 0) {
19928 		mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->
19929 		    cport_mutex);
19930 		return;
19931 	}
19932 	/* For sanity, re-probe the port */
19933 	sata_device.satadev_rev = SATA_DEVICE_REV;
19934 	sata_device.satadev_addr = *saddr;
19935 
19936 	/*
19937 	 * We have to exit mutex, because the HBA probe port function may
19938 	 * block on its own mutex.
19939 	 */
19940 	mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex);
19941 	rval = (*SATA_PROBE_PORT_FUNC(sata_hba_inst))
19942 	    (SATA_DIP(sata_hba_inst), &sata_device);
19943 	mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex);
19944 	sata_update_port_info(sata_hba_inst, &sata_device);
19945 	if (rval != SATA_SUCCESS) {
19946 		/* Something went wrong? Fail the port */
19947 		cportinfo->cport_state = SATA_PSTATE_FAILED;
19948 		mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->
19949 		    cport_mutex);
19950 		SATA_LOG_D((sata_hba_inst, CE_WARN,
19951 		    "SATA port %d probing failed",
19952 		    saddr->cport));
19953 		/*
19954 		 * We may want to release device info structure, but
19955 		 * it is not necessary.
19956 		 */
19957 		return;
19958 	} else {
19959 		/* port probed successfully */
19960 		cportinfo->cport_state |= SATA_STATE_PROBED | SATA_STATE_READY;
19961 	}
19962 	/*
19963 	 * Check if a device is still attached. For sanity, check also
19964 	 * link status - if no link, there is no device.
19965 	 */
19966 	if ((sata_device.satadev_scr.sstatus & SATA_PORT_DEVLINK_UP_MASK) ==
19967 	    SATA_PORT_DEVLINK_UP && sata_device.satadev_type !=
19968 	    SATA_DTYPE_NONE) {
19969 		/*
19970 		 * Device is still attached - ignore detach event.
19971 		 */
19972 		mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->
19973 		    cport_mutex);
19974 		SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst,
19975 		    "Ignoring detach - device still attached to port %d",
19976 		    sata_device.satadev_addr.cport);
19977 		return;
19978 	}
19979 	/*
19980 	 * We need to detach and release device info structure here
19981 	 */
19982 	if (cportinfo->cport_dev_type == SATA_DTYPE_PMULT) {
19983 		/*
19984 		 * A port-multiplier is removed.
19985 		 *
19986 		 * Calling sata_process_pmdevice_detached() does not work
19987 		 * here. The port multiplier is gone, so we cannot probe
19988 		 * sub-port any more and all pmult-related data structure must
19989 		 * be de-allocated immediately. Following structure of every
19990 		 * implemented sub-port behind the pmult are required to
19991 		 * released.
19992 		 *
19993 		 *   - attachment point
19994 		 *   - target node
19995 		 *   - sata_drive_info
19996 		 *   - sata_pmport_info
19997 		 */
19998 		for (npmport = 0; npmport < SATA_NUM_PMPORTS(sata_hba_inst,
19999 		    cport); npmport ++) {
20000 			SATADBG2(SATA_DBG_PMULT|SATA_DBG_EVENTS_PROC,
20001 			    sata_hba_inst,
20002 			    "Detaching target node at port %d:%d",
20003 			    cport, npmport);
20004 
20005 			mutex_exit(&SATA_CPORT_MUTEX(sata_hba_inst, cport));
20006 
20007 			/* Remove attachment point. */
20008 			name[0] = '\0';
20009 			(void) sprintf(name, "%d.%d", cport, npmport);
20010 			ddi_remove_minor_node(SATA_DIP(sata_hba_inst), name);
20011 			sata_log(sata_hba_inst, CE_NOTE,
20012 			    "Remove attachment point of port %d:%d",
20013 			    cport, npmport);
20014 
20015 			/* Remove target node */
20016 			pmport_addr.cport = cport;
20017 			pmport_addr.pmport = (uint8_t)npmport;
20018 			pmport_addr.qual = SATA_ADDR_PMPORT;
20019 			sata_remove_target_node(sata_hba_inst, &pmport_addr);
20020 
20021 			mutex_enter(&SATA_CPORT_MUTEX(sata_hba_inst, cport));
20022 
20023 			/* Release sata_pmport_info & sata_drive_info. */
20024 			pmportinfo = SATA_PMPORT_INFO(sata_hba_inst,
20025 			    cport, npmport);
20026 			ASSERT(pmportinfo != NULL);
20027 
20028 			sdevinfo = SATA_PMPORTINFO_DRV_INFO(pmportinfo);
20029 			if (sdevinfo != NULL) {
20030 				(void) kmem_free((void *) sdevinfo,
20031 				    sizeof (sata_drive_info_t));
20032 			}
20033 
20034 			/* Release sata_pmport_info at last */
20035 			(void) kmem_free((void *) pmportinfo,
20036 			    sizeof (sata_pmport_info_t));
20037 		}
20038 
20039 		/* Finally, release sata_pmult_info */
20040 		(void) kmem_free((void *)
20041 		    SATA_CPORTINFO_PMULT_INFO(cportinfo),
20042 		    sizeof (sata_pmult_info_t));
20043 		SATA_CPORTINFO_PMULT_INFO(cportinfo) = NULL;
20044 
20045 		sata_log(sata_hba_inst, CE_WARN,
20046 		    "SATA port-multiplier detached at port %d", cport);
20047 
20048 		cportinfo->cport_dev_type = SATA_DTYPE_NONE;
20049 		mutex_exit(&SATA_CPORT_INFO(sata_hba_inst,
20050 		    saddr->cport)->cport_mutex);
20051 	} else {
20052 		if (SATA_CPORTINFO_DRV_INFO(cportinfo) != NULL) {
20053 			sdevinfo = SATA_CPORTINFO_DRV_INFO(cportinfo);
20054 			SATA_CPORTINFO_DRV_INFO(cportinfo) = NULL;
20055 			(void) kmem_free((void *)sdevinfo,
20056 			    sizeof (sata_drive_info_t));
20057 		}
20058 		sata_log(sata_hba_inst, CE_WARN,
20059 		    "SATA device detached at port %d", cport);
20060 
20061 		cportinfo->cport_dev_type = SATA_DTYPE_NONE;
20062 		mutex_exit(&SATA_CPORT_INFO(sata_hba_inst,
20063 		    saddr->cport)->cport_mutex);
20064 
20065 		/*
20066 		 * Try to offline a device and remove target node
20067 		 * if it still exists
20068 		 */
20069 		sata_remove_target_node(sata_hba_inst, saddr);
20070 	}
20071 
20072 
20073 	/*
20074 	 * Generate sysevent - EC_DR / ESC_DR_AP_STATE_CHANGE
20075 	 * with the hint: SE_HINT_REMOVE
20076 	 */
20077 	sata_gen_sysevent(sata_hba_inst, saddr, SE_HINT_REMOVE);
20078 }
20079 
20080 /*
20081  * Port Multiplier Port Device Deattached Event processing.
20082  *
20083  * NOTE: No Mutex should be hold.
20084  */
20085 static void
20086 sata_process_pmdevice_detached(sata_hba_inst_t *sata_hba_inst,
20087     sata_address_t *saddr)
20088 {
20089 	sata_pmport_info_t *pmportinfo;
20090 	sata_drive_info_t *sdevinfo;
20091 	sata_device_t sata_device;
20092 	int rval;
20093 	uint8_t cport, pmport;
20094 
20095 	cport = saddr->cport;
20096 	pmport = saddr->pmport;
20097 
20098 	SATADBG2(SATA_DBG_EVENTS_PROC, sata_hba_inst,
20099 	    "Processing port %d:%d device detached",
20100 	    cport, pmport);
20101 
20102 	pmportinfo = SATA_PMPORT_INFO(sata_hba_inst, cport, pmport);
20103 	mutex_enter(&SATA_PMPORT_MUTEX(sata_hba_inst, cport, pmport));
20104 
20105 	/* Clear event flag */
20106 	pmportinfo->pmport_event_flags &= ~SATA_EVNT_DEVICE_DETACHED;
20107 
20108 	/* If the port is in SHUTDOWN or FAILED state, ignore detach event. */
20109 	if ((pmportinfo->pmport_state &
20110 	    (SATA_PSTATE_SHUTDOWN | SATA_PSTATE_FAILED)) != 0) {
20111 		mutex_exit(&SATA_PMPORT_MUTEX(sata_hba_inst, cport, pmport));
20112 		return;
20113 	}
20114 	/* For sanity, re-probe the port */
20115 	sata_device.satadev_rev = SATA_DEVICE_REV;
20116 	sata_device.satadev_addr = *saddr;
20117 
20118 	/*
20119 	 * We have to exit mutex, because the HBA probe port function may
20120 	 * block on its own mutex.
20121 	 */
20122 	mutex_exit(&SATA_PMPORT_MUTEX(sata_hba_inst, cport, pmport));
20123 	rval = (*SATA_PROBE_PORT_FUNC(sata_hba_inst))
20124 	    (SATA_DIP(sata_hba_inst), &sata_device);
20125 	mutex_enter(&SATA_PMPORT_MUTEX(sata_hba_inst, cport, pmport));
20126 	sata_update_pmport_info(sata_hba_inst, &sata_device);
20127 	if (rval != SATA_SUCCESS) {
20128 		/* Something went wrong? Fail the port */
20129 		pmportinfo->pmport_state = SATA_PSTATE_FAILED;
20130 		mutex_exit(&SATA_PMPORT_MUTEX(sata_hba_inst, cport, pmport));
20131 		SATA_LOG_D((sata_hba_inst, CE_WARN,
20132 		    "SATA port %d:%d probing failed",
20133 		    saddr->pmport));
20134 		/*
20135 		 * We may want to release device info structure, but
20136 		 * it is not necessary.
20137 		 */
20138 		return;
20139 	} else {
20140 		/* port probed successfully */
20141 		pmportinfo->pmport_state |=
20142 		    SATA_STATE_PROBED | SATA_STATE_READY;
20143 	}
20144 	/*
20145 	 * Check if a device is still attached. For sanity, check also
20146 	 * link status - if no link, there is no device.
20147 	 */
20148 	if ((sata_device.satadev_scr.sstatus & SATA_PORT_DEVLINK_UP_MASK) ==
20149 	    SATA_PORT_DEVLINK_UP && sata_device.satadev_type !=
20150 	    SATA_DTYPE_NONE) {
20151 		/*
20152 		 * Device is still attached - ignore detach event.
20153 		 */
20154 		mutex_exit(&SATA_PMPORT_MUTEX(sata_hba_inst, cport, pmport));
20155 		SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst,
20156 		    "Ignoring detach - device still attached to port %d",
20157 		    sata_device.satadev_addr.pmport);
20158 		return;
20159 	}
20160 	/*
20161 	 * We need to detach and release device info structure here
20162 	 */
20163 	if (SATA_PMPORTINFO_DRV_INFO(pmportinfo) != NULL) {
20164 		sdevinfo = SATA_PMPORTINFO_DRV_INFO(pmportinfo);
20165 		SATA_PMPORTINFO_DRV_INFO(pmportinfo) = NULL;
20166 		(void) kmem_free((void *)sdevinfo,
20167 		    sizeof (sata_drive_info_t));
20168 	}
20169 	pmportinfo->pmport_dev_type = SATA_DTYPE_NONE;
20170 	/*
20171 	 * Device cannot be reached anymore, even if the target node may be
20172 	 * still present.
20173 	 */
20174 	mutex_exit(&SATA_PMPORT_MUTEX(sata_hba_inst, cport, pmport));
20175 
20176 	/*
20177 	 * Try to offline a device and remove target node if it still exists
20178 	 */
20179 	sata_remove_target_node(sata_hba_inst, saddr);
20180 
20181 	/*
20182 	 * Generate sysevent - EC_DR / ESC_DR_AP_STATE_CHANGE
20183 	 * with the hint: SE_HINT_REMOVE
20184 	 */
20185 	sata_gen_sysevent(sata_hba_inst, saddr, SE_HINT_REMOVE);
20186 }
20187 
20188 
20189 /*
20190  * Device Attached Event processing.
20191  * Port state is checked to verify that a device is really attached. If so,
20192  * the device info structure is created and attached to the SATA port info
20193  * structure.
20194  *
20195  * If attached device cannot be identified or set-up, the retry for the
20196  * attach processing is set-up. Subsequent daemon run would try again to
20197  * identify the device, until the time limit is reached
20198  * (SATA_DEV_IDENTIFY_TIMEOUT).
20199  *
20200  * This function cannot be called in interrupt context (it may sleep).
20201  *
20202  * NOTE: Port multiplier ports events are handled by
20203  * sata_process_pmdevice_attached()
20204  */
20205 static void
20206 sata_process_device_attached(sata_hba_inst_t *sata_hba_inst,
20207     sata_address_t *saddr)
20208 {
20209 	sata_cport_info_t *cportinfo = NULL;
20210 	sata_drive_info_t *sdevinfo = NULL;
20211 	sata_pmult_info_t *pmultinfo = NULL;
20212 	sata_pmport_info_t *pmportinfo = NULL;
20213 	sata_device_t sata_device;
20214 	dev_info_t *tdip;
20215 	uint32_t event_flags = 0, pmult_event_flags = 0;
20216 	int rval;
20217 	int npmport;
20218 
20219 	SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst,
20220 	    "Processing port %d device attached", saddr->cport);
20221 
20222 	cportinfo = SATA_CPORT_INFO(sata_hba_inst, saddr->cport);
20223 	mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex);
20224 
20225 	/* Clear attach event flag first */
20226 	cportinfo->cport_event_flags &= ~SATA_EVNT_DEVICE_ATTACHED;
20227 
20228 	/* If the port is in SHUTDOWN or FAILED state, ignore event. */
20229 	if ((cportinfo->cport_state &
20230 	    (SATA_PSTATE_SHUTDOWN | SATA_PSTATE_FAILED)) != 0) {
20231 		cportinfo->cport_dev_attach_time = 0;
20232 		mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->
20233 		    cport_mutex);
20234 		return;
20235 	}
20236 
20237 	/*
20238 	 * If the sata_drive_info structure is found attached to the port info,
20239 	 * despite the fact the device was removed and now it is re-attached,
20240 	 * the old drive info structure was not removed.
20241 	 * Arbitrarily release device info structure.
20242 	 */
20243 	if (SATA_CPORTINFO_DRV_INFO(cportinfo) != NULL) {
20244 		sdevinfo = SATA_CPORTINFO_DRV_INFO(cportinfo);
20245 		SATA_CPORTINFO_DRV_INFO(cportinfo) = NULL;
20246 		(void) kmem_free((void *)sdevinfo,
20247 		    sizeof (sata_drive_info_t));
20248 		SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst,
20249 		    "Arbitrarily detaching old device info.", NULL);
20250 	}
20251 	cportinfo->cport_dev_type = SATA_DTYPE_NONE;
20252 
20253 	/* For sanity, re-probe the port */
20254 	sata_device.satadev_rev = SATA_DEVICE_REV;
20255 	sata_device.satadev_addr = *saddr;
20256 
20257 	/*
20258 	 * We have to exit mutex, because the HBA probe port function may
20259 	 * block on its own mutex.
20260 	 */
20261 	mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex);
20262 	rval = (*SATA_PROBE_PORT_FUNC(sata_hba_inst))
20263 	    (SATA_DIP(sata_hba_inst), &sata_device);
20264 	mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex);
20265 	sata_update_port_info(sata_hba_inst, &sata_device);
20266 	if (rval != SATA_SUCCESS) {
20267 		/* Something went wrong? Fail the port */
20268 		cportinfo->cport_state = SATA_PSTATE_FAILED;
20269 		cportinfo->cport_dev_attach_time = 0;
20270 		mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->
20271 		    cport_mutex);
20272 		SATA_LOG_D((sata_hba_inst, CE_WARN,
20273 		    "SATA port %d probing failed",
20274 		    saddr->cport));
20275 		return;
20276 	} else {
20277 		/* port probed successfully */
20278 		cportinfo->cport_state |= SATA_STATE_PROBED | SATA_STATE_READY;
20279 	}
20280 	/*
20281 	 * Check if a device is still attached. For sanity, check also
20282 	 * link status - if no link, there is no device.
20283 	 */
20284 	if ((sata_device.satadev_scr.sstatus & SATA_PORT_DEVLINK_UP_MASK) !=
20285 	    SATA_PORT_DEVLINK_UP || sata_device.satadev_type ==
20286 	    SATA_DTYPE_NONE) {
20287 		/*
20288 		 * No device - ignore attach event.
20289 		 */
20290 		cportinfo->cport_dev_attach_time = 0;
20291 		mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->
20292 		    cport_mutex);
20293 		SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst,
20294 		    "Ignoring attach - no device connected to port %d",
20295 		    sata_device.satadev_addr.cport);
20296 		return;
20297 	}
20298 
20299 	mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex);
20300 	/*
20301 	 * Generate sysevent - EC_DR / ESC_DR_AP_STATE_CHANGE
20302 	 * with the hint: SE_HINT_INSERT
20303 	 */
20304 	sata_gen_sysevent(sata_hba_inst, saddr, SE_HINT_INSERT);
20305 
20306 	/*
20307 	 * Port reprobing will take care of the creation of the device
20308 	 * info structure and determination of the device type.
20309 	 */
20310 	sata_device.satadev_addr = *saddr;
20311 	(void) sata_reprobe_port(sata_hba_inst, &sata_device,
20312 	    SATA_DEV_IDENTIFY_NORETRY);
20313 
20314 	mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->
20315 	    cport_mutex);
20316 	if ((cportinfo->cport_state & SATA_STATE_READY) &&
20317 	    (cportinfo->cport_dev_type != SATA_DTYPE_NONE)) {
20318 		/* Some device is attached to the port */
20319 		if (cportinfo->cport_dev_type == SATA_DTYPE_UNKNOWN) {
20320 			/*
20321 			 * A device was not successfully attached.
20322 			 * Track retry time for device identification.
20323 			 */
20324 			if (cportinfo->cport_dev_attach_time != 0) {
20325 				clock_t cur_time = ddi_get_lbolt();
20326 				/*
20327 				 * If the retry time limit was not exceeded,
20328 				 * reinstate attach event.
20329 				 */
20330 				if ((cur_time -
20331 				    cportinfo->cport_dev_attach_time) <
20332 				    drv_usectohz(
20333 				    SATA_DEV_IDENTIFY_TIMEOUT)) {
20334 					/* OK, restore attach event */
20335 					cportinfo->cport_event_flags |=
20336 					    SATA_EVNT_DEVICE_ATTACHED;
20337 				} else {
20338 					/* Timeout - cannot identify device */
20339 					cportinfo->cport_dev_attach_time = 0;
20340 					sata_log(sata_hba_inst,
20341 					    CE_WARN,
20342 					    "Could not identify SATA device "
20343 					    "at port %d",
20344 					    saddr->cport);
20345 				}
20346 			} else {
20347 				/*
20348 				 * Start tracking time for device
20349 				 * identification.
20350 				 * Save current time (lbolt value).
20351 				 */
20352 				cportinfo->cport_dev_attach_time =
20353 				    ddi_get_lbolt();
20354 				/* Restore attach event */
20355 				cportinfo->cport_event_flags |=
20356 				    SATA_EVNT_DEVICE_ATTACHED;
20357 			}
20358 		} else if (cportinfo->cport_dev_type == SATA_DTYPE_PMULT) {
20359 			cportinfo->cport_dev_attach_time = 0;
20360 			sata_log(sata_hba_inst, CE_NOTE,
20361 			    "SATA port-multiplier detected at port %d",
20362 			    saddr->cport);
20363 
20364 			if (SATA_CPORTINFO_PMULT_INFO(cportinfo) != NULL) {
20365 				/* Log the info of new port multiplier */
20366 				mutex_exit(&SATA_CPORT_INFO(sata_hba_inst,
20367 				    saddr->cport)->cport_mutex);
20368 				sata_show_pmult_info(sata_hba_inst,
20369 				    &sata_device);
20370 				mutex_enter(&SATA_CPORT_INFO(sata_hba_inst,
20371 				    saddr->cport)->cport_mutex);
20372 			}
20373 
20374 			ASSERT(SATA_CPORTINFO_PMULT_INFO(cportinfo) != NULL);
20375 			pmultinfo = SATA_CPORTINFO_PMULT_INFO(cportinfo);
20376 			for (npmport = 0; npmport <
20377 			    pmultinfo->pmult_num_dev_ports; npmport++) {
20378 				pmportinfo = SATA_PMPORT_INFO(sata_hba_inst,
20379 				    saddr->cport, npmport);
20380 				ASSERT(pmportinfo != NULL);
20381 
20382 				mutex_exit(&SATA_CPORT_INFO(sata_hba_inst,
20383 				    saddr->cport)->cport_mutex);
20384 				mutex_enter(&pmportinfo->pmport_mutex);
20385 				/* Marked all pmports with link events. */
20386 				pmportinfo->pmport_event_flags =
20387 				    SATA_EVNT_LINK_ESTABLISHED;
20388 				pmult_event_flags |=
20389 				    pmportinfo->pmport_event_flags;
20390 				mutex_exit(&pmportinfo->pmport_mutex);
20391 				mutex_enter(&SATA_CPORT_INFO(sata_hba_inst,
20392 				    saddr->cport)->cport_mutex);
20393 			}
20394 			/* Auto-online is not available for PMult now. */
20395 
20396 		} else {
20397 			/*
20398 			 * If device was successfully attached, the subsequent
20399 			 * action depends on a state of the
20400 			 * sata_auto_online variable. If it is set to zero.
20401 			 * an explicit 'configure' command will be needed to
20402 			 * configure it. If its value is non-zero, we will
20403 			 * attempt to online (configure) the device.
20404 			 * First, log the message indicating that a device
20405 			 * was attached.
20406 			 */
20407 			cportinfo->cport_dev_attach_time = 0;
20408 			sata_log(sata_hba_inst, CE_WARN,
20409 			    "SATA device detected at port %d", saddr->cport);
20410 
20411 			if (SATA_CPORTINFO_DRV_INFO(cportinfo) != NULL) {
20412 				sata_drive_info_t new_sdinfo;
20413 
20414 				/* Log device info data */
20415 				new_sdinfo = *(SATA_CPORTINFO_DRV_INFO(
20416 				    cportinfo));
20417 				sata_show_drive_info(sata_hba_inst,
20418 				    &new_sdinfo);
20419 			}
20420 
20421 			mutex_exit(&SATA_CPORT_INFO(sata_hba_inst,
20422 			    saddr->cport)->cport_mutex);
20423 
20424 			/*
20425 			 * Make sure that there is no target node for that
20426 			 * device. If so, release it. It should not happen,
20427 			 * unless we had problem removing the node when
20428 			 * device was detached.
20429 			 */
20430 			tdip = sata_get_target_dip(SATA_DIP(sata_hba_inst),
20431 			    saddr->cport, saddr->pmport);
20432 			mutex_enter(&SATA_CPORT_INFO(sata_hba_inst,
20433 			    saddr->cport)->cport_mutex);
20434 			if (tdip != NULL) {
20435 
20436 #ifdef SATA_DEBUG
20437 				if ((cportinfo->cport_event_flags &
20438 				    SATA_EVNT_TARGET_NODE_CLEANUP) == 0)
20439 					sata_log(sata_hba_inst, CE_WARN,
20440 					    "sata_process_device_attached: "
20441 					    "old device target node exists!");
20442 #endif
20443 				/*
20444 				 * target node exists - try to unconfigure
20445 				 * device and remove the node.
20446 				 */
20447 				mutex_exit(&SATA_CPORT_INFO(sata_hba_inst,
20448 				    saddr->cport)->cport_mutex);
20449 				rval = ndi_devi_offline(tdip,
20450 				    NDI_DEVI_REMOVE);
20451 				mutex_enter(&SATA_CPORT_INFO(sata_hba_inst,
20452 				    saddr->cport)->cport_mutex);
20453 
20454 				if (rval == NDI_SUCCESS) {
20455 					cportinfo->cport_event_flags &=
20456 					    ~SATA_EVNT_TARGET_NODE_CLEANUP;
20457 					cportinfo->cport_tgtnode_clean = B_TRUE;
20458 				} else {
20459 					/*
20460 					 * PROBLEM - the target node remained
20461 					 * and it belongs to a previously
20462 					 * attached device.
20463 					 * This happens when the file was open
20464 					 * or the node was waiting for
20465 					 * resources at the time the
20466 					 * associated device was removed.
20467 					 * Instruct event daemon to retry the
20468 					 * cleanup later.
20469 					 */
20470 					sata_log(sata_hba_inst,
20471 					    CE_WARN,
20472 					    "Application(s) accessing "
20473 					    "previously attached SATA "
20474 					    "device have to release "
20475 					    "it before newly inserted "
20476 					    "device can be made accessible.",
20477 					    saddr->cport);
20478 					cportinfo->cport_event_flags |=
20479 					    SATA_EVNT_TARGET_NODE_CLEANUP;
20480 					cportinfo->cport_tgtnode_clean =
20481 					    B_FALSE;
20482 				}
20483 			}
20484 			if (sata_auto_online != 0) {
20485 				cportinfo->cport_event_flags |=
20486 				    SATA_EVNT_AUTOONLINE_DEVICE;
20487 			}
20488 
20489 		}
20490 	} else {
20491 		cportinfo->cport_dev_attach_time = 0;
20492 	}
20493 
20494 	event_flags = cportinfo->cport_event_flags;
20495 	mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex);
20496 	if (event_flags != 0 || pmult_event_flags != 0) {
20497 		mutex_enter(&sata_hba_inst->satahba_mutex);
20498 		sata_hba_inst->satahba_event_flags |= SATA_EVNT_MAIN;
20499 		mutex_exit(&sata_hba_inst->satahba_mutex);
20500 		mutex_enter(&sata_mutex);
20501 		sata_event_pending |= SATA_EVNT_MAIN;
20502 		mutex_exit(&sata_mutex);
20503 	}
20504 }
20505 
20506 /*
20507  * Port Multiplier Port Device Attached Event processing.
20508  *
20509  * NOTE: No Mutex should be hold.
20510  */
20511 static void
20512 sata_process_pmdevice_attached(sata_hba_inst_t *sata_hba_inst,
20513     sata_address_t *saddr)
20514 {
20515 	sata_pmport_info_t *pmportinfo;
20516 	sata_drive_info_t *sdinfo;
20517 	sata_device_t sata_device;
20518 	dev_info_t *tdip;
20519 	uint32_t event_flags;
20520 	uint8_t cport = saddr->cport;
20521 	uint8_t pmport = saddr->pmport;
20522 	int rval;
20523 
20524 	SATADBG2(SATA_DBG_EVENTS_PROC, sata_hba_inst,
20525 	    "Processing port %d:%d device attached", cport, pmport);
20526 
20527 	pmportinfo = SATA_PMPORT_INFO(sata_hba_inst, cport, pmport);
20528 
20529 	mutex_enter(&pmportinfo->pmport_mutex);
20530 
20531 	/* Clear attach event flag first */
20532 	pmportinfo->pmport_event_flags &= ~SATA_EVNT_DEVICE_ATTACHED;
20533 
20534 	/* If the port is in SHUTDOWN or FAILED state, ignore event. */
20535 	if ((pmportinfo->pmport_state &
20536 	    (SATA_PSTATE_SHUTDOWN | SATA_PSTATE_FAILED)) != 0) {
20537 		pmportinfo->pmport_dev_attach_time = 0;
20538 		mutex_exit(&pmportinfo->pmport_mutex);
20539 		return;
20540 	}
20541 
20542 	/*
20543 	 * If the sata_drive_info structure is found attached to the port info,
20544 	 * despite the fact the device was removed and now it is re-attached,
20545 	 * the old drive info structure was not removed.
20546 	 * Arbitrarily release device info structure.
20547 	 */
20548 	if (SATA_PMPORTINFO_DRV_INFO(pmportinfo) != NULL) {
20549 		sdinfo = SATA_PMPORTINFO_DRV_INFO(pmportinfo);
20550 		SATA_PMPORTINFO_DRV_INFO(pmportinfo) = NULL;
20551 		(void) kmem_free((void *)sdinfo,
20552 		    sizeof (sata_drive_info_t));
20553 		SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst,
20554 		    "Arbitrarily detaching old device info.", NULL);
20555 	}
20556 	pmportinfo->pmport_dev_type = SATA_DTYPE_NONE;
20557 
20558 	/* For sanity, re-probe the port */
20559 	sata_device.satadev_rev = SATA_DEVICE_REV;
20560 	sata_device.satadev_addr = *saddr;
20561 
20562 	/*
20563 	 * We have to exit mutex, because the HBA probe port function may
20564 	 * block on its own mutex.
20565 	 */
20566 	mutex_exit(&pmportinfo->pmport_mutex);
20567 	rval = (*SATA_PROBE_PORT_FUNC(sata_hba_inst))
20568 	    (SATA_DIP(sata_hba_inst), &sata_device);
20569 	mutex_enter(&pmportinfo->pmport_mutex);
20570 
20571 	sata_update_pmport_info(sata_hba_inst, &sata_device);
20572 	if (rval != SATA_SUCCESS) {
20573 		/* Something went wrong? Fail the port */
20574 		pmportinfo->pmport_state = SATA_PSTATE_FAILED;
20575 		pmportinfo->pmport_dev_attach_time = 0;
20576 		mutex_exit(&pmportinfo->pmport_mutex);
20577 		SATA_LOG_D((sata_hba_inst, CE_WARN,
20578 		    "SATA port %d:%d probing failed", cport, pmport));
20579 		return;
20580 	} else {
20581 		/* pmport probed successfully */
20582 		pmportinfo->pmport_state |=
20583 		    SATA_STATE_PROBED | SATA_STATE_READY;
20584 	}
20585 	/*
20586 	 * Check if a device is still attached. For sanity, check also
20587 	 * link status - if no link, there is no device.
20588 	 */
20589 	if ((sata_device.satadev_scr.sstatus & SATA_PORT_DEVLINK_UP_MASK) !=
20590 	    SATA_PORT_DEVLINK_UP || sata_device.satadev_type ==
20591 	    SATA_DTYPE_NONE) {
20592 		/*
20593 		 * No device - ignore attach event.
20594 		 */
20595 		pmportinfo->pmport_dev_attach_time = 0;
20596 		mutex_exit(&pmportinfo->pmport_mutex);
20597 		SATADBG2(SATA_DBG_EVENTS_PROC, sata_hba_inst,
20598 		    "Ignoring attach - no device connected to port %d:%d",
20599 		    cport, pmport);
20600 		return;
20601 	}
20602 
20603 	mutex_exit(&pmportinfo->pmport_mutex);
20604 	/*
20605 	 * Generate sysevent - EC_DR / ESC_DR_AP_STATE_CHANGE
20606 	 * with the hint: SE_HINT_INSERT
20607 	 */
20608 	sata_gen_sysevent(sata_hba_inst, saddr, SE_HINT_INSERT);
20609 
20610 	/*
20611 	 * Port reprobing will take care of the creation of the device
20612 	 * info structure and determination of the device type.
20613 	 */
20614 	sata_device.satadev_addr = *saddr;
20615 	(void) sata_reprobe_port(sata_hba_inst, &sata_device,
20616 	    SATA_DEV_IDENTIFY_NORETRY);
20617 
20618 	mutex_enter(&pmportinfo->pmport_mutex);
20619 	if ((pmportinfo->pmport_state & SATA_STATE_READY) &&
20620 	    (pmportinfo->pmport_dev_type != SATA_DTYPE_NONE)) {
20621 		/* Some device is attached to the port */
20622 		if (pmportinfo->pmport_dev_type == SATA_DTYPE_UNKNOWN) {
20623 			/*
20624 			 * A device was not successfully attached.
20625 			 * Track retry time for device identification.
20626 			 */
20627 			if (pmportinfo->pmport_dev_attach_time != 0) {
20628 				clock_t cur_time = ddi_get_lbolt();
20629 				/*
20630 				 * If the retry time limit was not exceeded,
20631 				 * reinstate attach event.
20632 				 */
20633 				if ((cur_time -
20634 				    pmportinfo->pmport_dev_attach_time) <
20635 				    drv_usectohz(
20636 				    SATA_DEV_IDENTIFY_TIMEOUT)) {
20637 					/* OK, restore attach event */
20638 					pmportinfo->pmport_event_flags |=
20639 					    SATA_EVNT_DEVICE_ATTACHED;
20640 				} else {
20641 					/* Timeout - cannot identify device */
20642 					pmportinfo->pmport_dev_attach_time = 0;
20643 					sata_log(sata_hba_inst, CE_WARN,
20644 					    "Could not identify SATA device "
20645 					    "at port %d:%d",
20646 					    cport, pmport);
20647 				}
20648 			} else {
20649 				/*
20650 				 * Start tracking time for device
20651 				 * identification.
20652 				 * Save current time (lbolt value).
20653 				 */
20654 				pmportinfo->pmport_dev_attach_time =
20655 				    ddi_get_lbolt();
20656 				/* Restore attach event */
20657 				pmportinfo->pmport_event_flags |=
20658 				    SATA_EVNT_DEVICE_ATTACHED;
20659 			}
20660 		} else {
20661 			/*
20662 			 * If device was successfully attached, the subsequent
20663 			 * action depends on a state of the
20664 			 * sata_auto_online variable. If it is set to zero.
20665 			 * an explicit 'configure' command will be needed to
20666 			 * configure it. If its value is non-zero, we will
20667 			 * attempt to online (configure) the device.
20668 			 * First, log the message indicating that a device
20669 			 * was attached.
20670 			 */
20671 			pmportinfo->pmport_dev_attach_time = 0;
20672 			sata_log(sata_hba_inst, CE_WARN,
20673 			    "SATA device detected at port %d:%d",
20674 			    cport, pmport);
20675 
20676 			if (SATA_PMPORTINFO_DRV_INFO(pmportinfo) != NULL) {
20677 				sata_drive_info_t new_sdinfo;
20678 
20679 				/* Log device info data */
20680 				new_sdinfo = *(SATA_PMPORTINFO_DRV_INFO(
20681 				    pmportinfo));
20682 				sata_show_drive_info(sata_hba_inst,
20683 				    &new_sdinfo);
20684 			}
20685 
20686 			mutex_exit(&pmportinfo->pmport_mutex);
20687 
20688 			/*
20689 			 * Make sure that there is no target node for that
20690 			 * device. If so, release it. It should not happen,
20691 			 * unless we had problem removing the node when
20692 			 * device was detached.
20693 			 */
20694 			tdip = sata_get_target_dip(SATA_DIP(sata_hba_inst),
20695 			    saddr->cport, saddr->pmport);
20696 			mutex_enter(&pmportinfo->pmport_mutex);
20697 			if (tdip != NULL) {
20698 
20699 #ifdef SATA_DEBUG
20700 				if ((pmportinfo->pmport_event_flags &
20701 				    SATA_EVNT_TARGET_NODE_CLEANUP) == 0)
20702 					sata_log(sata_hba_inst, CE_WARN,
20703 					    "sata_process_device_attached: "
20704 					    "old device target node exists!");
20705 #endif
20706 				/*
20707 				 * target node exists - try to unconfigure
20708 				 * device and remove the node.
20709 				 */
20710 				mutex_exit(&pmportinfo->pmport_mutex);
20711 				rval = ndi_devi_offline(tdip,
20712 				    NDI_DEVI_REMOVE);
20713 				mutex_enter(&pmportinfo->pmport_mutex);
20714 
20715 				if (rval == NDI_SUCCESS) {
20716 					pmportinfo->pmport_event_flags &=
20717 					    ~SATA_EVNT_TARGET_NODE_CLEANUP;
20718 					pmportinfo->pmport_tgtnode_clean =
20719 					    B_TRUE;
20720 				} else {
20721 					/*
20722 					 * PROBLEM - the target node remained
20723 					 * and it belongs to a previously
20724 					 * attached device.
20725 					 * This happens when the file was open
20726 					 * or the node was waiting for
20727 					 * resources at the time the
20728 					 * associated device was removed.
20729 					 * Instruct event daemon to retry the
20730 					 * cleanup later.
20731 					 */
20732 					sata_log(sata_hba_inst,
20733 					    CE_WARN,
20734 					    "Application(s) accessing "
20735 					    "previously attached SATA "
20736 					    "device have to release "
20737 					    "it before newly inserted "
20738 					    "device can be made accessible."
20739 					    "at port %d:%d",
20740 					    cport, pmport);
20741 					pmportinfo->pmport_event_flags |=
20742 					    SATA_EVNT_TARGET_NODE_CLEANUP;
20743 					pmportinfo->pmport_tgtnode_clean =
20744 					    B_FALSE;
20745 				}
20746 			}
20747 			if (sata_auto_online != 0) {
20748 				pmportinfo->pmport_event_flags |=
20749 				    SATA_EVNT_AUTOONLINE_DEVICE;
20750 			}
20751 
20752 		}
20753 	} else {
20754 		pmportinfo->pmport_dev_attach_time = 0;
20755 	}
20756 
20757 	event_flags = pmportinfo->pmport_event_flags;
20758 	mutex_exit(&pmportinfo->pmport_mutex);
20759 	if (event_flags != 0) {
20760 		mutex_enter(&sata_hba_inst->satahba_mutex);
20761 		sata_hba_inst->satahba_event_flags |= SATA_EVNT_MAIN;
20762 		mutex_exit(&sata_hba_inst->satahba_mutex);
20763 		mutex_enter(&sata_mutex);
20764 		sata_event_pending |= SATA_EVNT_MAIN;
20765 		mutex_exit(&sata_mutex);
20766 	}
20767 
20768 	/* clear the reset_in_progress events */
20769 	if (SATA_PMPORTINFO_DRV_INFO(pmportinfo) != NULL) {
20770 		if (pmportinfo->pmport_dev_type & SATA_VALID_DEV_TYPE) {
20771 			/* must clear flags on cport */
20772 			sata_pmult_info_t *pminfo =
20773 			    SATA_PMULT_INFO(sata_hba_inst,
20774 			    saddr->cport);
20775 			pminfo->pmult_event_flags |=
20776 			    SATA_EVNT_CLEAR_DEVICE_RESET;
20777 		}
20778 	}
20779 }
20780 
20781 /*
20782  * Device Target Node Cleanup Event processing.
20783  * If the target node associated with a sata port device is in
20784  * DEVI_DEVICE_REMOVED state, an attempt is made to remove it.
20785  * If the target node cannot be removed, the event flag is left intact,
20786  * so that event daemon may re-run this function later.
20787  *
20788  * This function cannot be called in interrupt context (it may sleep).
20789  *
20790  * NOTE: Processes cport events only, not port multiplier ports.
20791  */
20792 static void
20793 sata_process_target_node_cleanup(sata_hba_inst_t *sata_hba_inst,
20794     sata_address_t *saddr)
20795 {
20796 	sata_cport_info_t *cportinfo;
20797 	dev_info_t *tdip;
20798 
20799 	SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst,
20800 	    "Processing port %d device target node cleanup", saddr->cport);
20801 
20802 	cportinfo = SATA_CPORT_INFO(sata_hba_inst, saddr->cport);
20803 
20804 	/*
20805 	 * Check if there is target node for that device and it is in the
20806 	 * DEVI_DEVICE_REMOVED state. If so, release it.
20807 	 */
20808 	tdip = sata_get_target_dip(SATA_DIP(sata_hba_inst), saddr->cport,
20809 	    saddr->pmport);
20810 	if (tdip != NULL) {
20811 		/*
20812 		 * target node exists - check if it is target node of
20813 		 * a removed device.
20814 		 */
20815 		if (sata_check_device_removed(tdip) == B_TRUE) {
20816 			SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst,
20817 			    "sata_process_target_node_cleanup: "
20818 			    "old device target node exists!", NULL);
20819 			/*
20820 			 * Unconfigure and remove the target node
20821 			 */
20822 			if (ndi_devi_offline(tdip, NDI_DEVI_REMOVE) ==
20823 			    NDI_SUCCESS) {
20824 				mutex_enter(&SATA_CPORT_INFO(sata_hba_inst,
20825 				    saddr->cport)->cport_mutex);
20826 				cportinfo->cport_event_flags &=
20827 				    ~SATA_EVNT_TARGET_NODE_CLEANUP;
20828 				mutex_exit(&SATA_CPORT_INFO(sata_hba_inst,
20829 				    saddr->cport)->cport_mutex);
20830 				return;
20831 			}
20832 			/*
20833 			 * Event daemon will retry the cleanup later.
20834 			 */
20835 			mutex_enter(&sata_hba_inst->satahba_mutex);
20836 			sata_hba_inst->satahba_event_flags |= SATA_EVNT_MAIN;
20837 			mutex_exit(&sata_hba_inst->satahba_mutex);
20838 			mutex_enter(&sata_mutex);
20839 			sata_event_pending |= SATA_EVNT_MAIN;
20840 			mutex_exit(&sata_mutex);
20841 		}
20842 	} else {
20843 		if (saddr->qual == SATA_ADDR_CPORT ||
20844 		    saddr->qual == SATA_ADDR_DCPORT) {
20845 			mutex_enter(&SATA_CPORT_INFO(sata_hba_inst,
20846 			    saddr->cport)->cport_mutex);
20847 			cportinfo->cport_event_flags &=
20848 			    ~SATA_EVNT_TARGET_NODE_CLEANUP;
20849 			mutex_exit(&SATA_CPORT_INFO(sata_hba_inst,
20850 			    saddr->cport)->cport_mutex);
20851 		} else {
20852 			/* sanity check */
20853 			if (SATA_CPORT_DEV_TYPE(sata_hba_inst, saddr->cport) !=
20854 			    SATA_DTYPE_PMULT || SATA_PMULT_INFO(sata_hba_inst,
20855 			    saddr->cport) == NULL)
20856 				return;
20857 			if (SATA_PMPORT_INFO(sata_hba_inst, saddr->cport,
20858 			    saddr->pmport) == NULL)
20859 				return;
20860 
20861 			mutex_enter(&SATA_PMPORT_INFO(sata_hba_inst,
20862 			    saddr->cport, saddr->pmport)->pmport_mutex);
20863 			SATA_PMPORT_INFO(sata_hba_inst, saddr->cport,
20864 			    saddr->pmport)->pmport_event_flags &=
20865 			    ~SATA_EVNT_TARGET_NODE_CLEANUP;
20866 			mutex_exit(&SATA_PMPORT_INFO(sata_hba_inst,
20867 			    saddr->cport, saddr->pmport)->pmport_mutex);
20868 		}
20869 	}
20870 }
20871 
20872 /*
20873  * Device AutoOnline Event processing.
20874  * If attached device is to be onlined, an attempt is made to online this
20875  * device, but only if there is no lingering (old) target node present.
20876  * If the device cannot be onlined, the event flag is left intact,
20877  * so that event daemon may re-run this function later.
20878  *
20879  * This function cannot be called in interrupt context (it may sleep).
20880  *
20881  * NOTE: Processes cport events only, not port multiplier ports.
20882  */
20883 static void
20884 sata_process_device_autoonline(sata_hba_inst_t *sata_hba_inst,
20885     sata_address_t *saddr)
20886 {
20887 	sata_cport_info_t *cportinfo;
20888 	sata_drive_info_t *sdinfo;
20889 	sata_device_t sata_device;
20890 	dev_info_t *tdip;
20891 
20892 	SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst,
20893 	    "Processing port %d attached device auto-onlining", saddr->cport);
20894 
20895 	cportinfo = SATA_CPORT_INFO(sata_hba_inst, saddr->cport);
20896 
20897 	/*
20898 	 * Check if device is present and recognized. If not, reset event.
20899 	 */
20900 	mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex);
20901 	if ((cportinfo->cport_dev_type & SATA_VALID_DEV_TYPE) == 0) {
20902 		/* Nothing to online */
20903 		cportinfo->cport_event_flags &= ~SATA_EVNT_AUTOONLINE_DEVICE;
20904 		mutex_exit(&SATA_CPORT_INFO(sata_hba_inst,
20905 		    saddr->cport)->cport_mutex);
20906 		return;
20907 	}
20908 	mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex);
20909 
20910 	/*
20911 	 * Check if there is target node for this device and if it is in the
20912 	 * DEVI_DEVICE_REMOVED state. If so, abort onlining but keep
20913 	 * the event for later processing.
20914 	 */
20915 	tdip = sata_get_target_dip(SATA_DIP(sata_hba_inst), saddr->cport,
20916 	    saddr->pmport);
20917 	if (tdip != NULL) {
20918 		/*
20919 		 * target node exists - check if it is target node of
20920 		 * a removed device.
20921 		 */
20922 		if (sata_check_device_removed(tdip) == B_TRUE) {
20923 			SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst,
20924 			    "sata_process_device_autoonline: "
20925 			    "old device target node exists!", NULL);
20926 			/*
20927 			 * Event daemon will retry device onlining later.
20928 			 */
20929 			mutex_enter(&sata_hba_inst->satahba_mutex);
20930 			sata_hba_inst->satahba_event_flags |= SATA_EVNT_MAIN;
20931 			mutex_exit(&sata_hba_inst->satahba_mutex);
20932 			mutex_enter(&sata_mutex);
20933 			sata_event_pending |= SATA_EVNT_MAIN;
20934 			mutex_exit(&sata_mutex);
20935 			return;
20936 		}
20937 		/*
20938 		 * If the target node is not in the 'removed" state, assume
20939 		 * that it belongs to this device. There is nothing more to do,
20940 		 * but reset the event.
20941 		 */
20942 	} else {
20943 
20944 		/*
20945 		 * Try to online the device
20946 		 * If there is any reset-related event, remove it. We are
20947 		 * configuring the device and no state restoring is needed.
20948 		 */
20949 		mutex_enter(&SATA_CPORT_INFO(sata_hba_inst,
20950 		    saddr->cport)->cport_mutex);
20951 		sata_device.satadev_addr = *saddr;
20952 		if (saddr->qual == SATA_ADDR_CPORT)
20953 			sata_device.satadev_addr.qual = SATA_ADDR_DCPORT;
20954 		else
20955 			sata_device.satadev_addr.qual = SATA_ADDR_DPMPORT;
20956 		sdinfo = sata_get_device_info(sata_hba_inst, &sata_device);
20957 		if (sdinfo != NULL) {
20958 			if (sdinfo->satadrv_event_flags &
20959 			    (SATA_EVNT_DEVICE_RESET |
20960 			    SATA_EVNT_INPROC_DEVICE_RESET))
20961 				sdinfo->satadrv_event_flags = 0;
20962 			sdinfo->satadrv_event_flags |=
20963 			    SATA_EVNT_CLEAR_DEVICE_RESET;
20964 
20965 			/* Need to create a new target node. */
20966 			cportinfo->cport_tgtnode_clean = B_TRUE;
20967 			mutex_exit(&SATA_CPORT_INFO(sata_hba_inst,
20968 			    saddr->cport)->cport_mutex);
20969 			tdip = sata_create_target_node(SATA_DIP(sata_hba_inst),
20970 			    sata_hba_inst, &sata_device.satadev_addr);
20971 			if (tdip == NULL) {
20972 				/*
20973 				 * Configure (onlining) failed.
20974 				 * We will NOT retry
20975 				 */
20976 				SATA_LOG_D((sata_hba_inst, CE_WARN,
20977 				    "sata_process_device_autoonline: "
20978 				    "configuring SATA device at port %d failed",
20979 				    saddr->cport));
20980 			}
20981 		} else {
20982 			mutex_exit(&SATA_CPORT_INFO(sata_hba_inst,
20983 			    saddr->cport)->cport_mutex);
20984 		}
20985 
20986 	}
20987 	mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex);
20988 	cportinfo->cport_event_flags &= ~SATA_EVNT_AUTOONLINE_DEVICE;
20989 	mutex_exit(&SATA_CPORT_INFO(sata_hba_inst,
20990 	    saddr->cport)->cport_mutex);
20991 }
20992 
20993 
20994 static void
20995 sata_gen_sysevent(sata_hba_inst_t *sata_hba_inst, sata_address_t *saddr,
20996     int hint)
20997 {
20998 	char ap[MAXPATHLEN];
20999 	nvlist_t *ev_attr_list = NULL;
21000 	int err;
21001 
21002 	/* Allocate and build sysevent attribute list */
21003 	err = nvlist_alloc(&ev_attr_list, NV_UNIQUE_NAME_TYPE, DDI_NOSLEEP);
21004 	if (err != 0) {
21005 		SATA_LOG_D((sata_hba_inst, CE_WARN,
21006 		    "sata_gen_sysevent: "
21007 		    "cannot allocate memory for sysevent attributes\n"));
21008 		return;
21009 	}
21010 	/* Add hint attribute */
21011 	err = nvlist_add_string(ev_attr_list, DR_HINT, SE_HINT2STR(hint));
21012 	if (err != 0) {
21013 		SATA_LOG_D((sata_hba_inst, CE_WARN,
21014 		    "sata_gen_sysevent: "
21015 		    "failed to add DR_HINT attr for sysevent"));
21016 		nvlist_free(ev_attr_list);
21017 		return;
21018 	}
21019 	/*
21020 	 * Add AP attribute.
21021 	 * Get controller pathname and convert it into AP pathname by adding
21022 	 * a target number.
21023 	 */
21024 	(void) snprintf(ap, MAXPATHLEN, "/devices");
21025 	(void) ddi_pathname(SATA_DIP(sata_hba_inst), ap + strlen(ap));
21026 	(void) snprintf(ap + strlen(ap), MAXPATHLEN - strlen(ap), ":%d",
21027 	    SATA_MAKE_AP_NUMBER(saddr->cport, saddr->pmport, saddr->qual));
21028 
21029 	err = nvlist_add_string(ev_attr_list, DR_AP_ID, ap);
21030 	if (err != 0) {
21031 		SATA_LOG_D((sata_hba_inst, CE_WARN,
21032 		    "sata_gen_sysevent: "
21033 		    "failed to add DR_AP_ID attr for sysevent"));
21034 		nvlist_free(ev_attr_list);
21035 		return;
21036 	}
21037 
21038 	/* Generate/log sysevent */
21039 	err = ddi_log_sysevent(SATA_DIP(sata_hba_inst), DDI_VENDOR_SUNW, EC_DR,
21040 	    ESC_DR_AP_STATE_CHANGE, ev_attr_list, NULL, DDI_NOSLEEP);
21041 	if (err != DDI_SUCCESS) {
21042 		SATA_LOG_D((sata_hba_inst, CE_WARN,
21043 		    "sata_gen_sysevent: "
21044 		    "cannot log sysevent, err code %x\n", err));
21045 	}
21046 
21047 	nvlist_free(ev_attr_list);
21048 }
21049 
21050 
21051 
21052 
21053 /*
21054  * Set DEVI_DEVICE_REMOVED state in the SATA device target node.
21055  */
21056 static void
21057 sata_set_device_removed(dev_info_t *tdip)
21058 {
21059 	ASSERT(tdip != NULL);
21060 
21061 	ndi_devi_enter(tdip);
21062 	mutex_enter(&DEVI(tdip)->devi_lock);
21063 	DEVI_SET_DEVICE_REMOVED(tdip);
21064 	mutex_exit(&DEVI(tdip)->devi_lock);
21065 	ndi_devi_exit(tdip);
21066 }
21067 
21068 
21069 /*
21070  * Set internal event instructing event daemon to try
21071  * to perform the target node cleanup.
21072  */
21073 static void
21074 sata_set_target_node_cleanup(sata_hba_inst_t *sata_hba_inst,
21075     sata_address_t *saddr)
21076 {
21077 	if (saddr->qual == SATA_ADDR_CPORT ||
21078 	    saddr->qual == SATA_ADDR_DCPORT) {
21079 		mutex_enter(&SATA_CPORT_INFO(sata_hba_inst,
21080 		    saddr->cport)->cport_mutex);
21081 		SATA_CPORT_EVENT_FLAGS(sata_hba_inst, saddr->cport) |=
21082 		    SATA_EVNT_TARGET_NODE_CLEANUP;
21083 		SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->
21084 		    cport_tgtnode_clean = B_FALSE;
21085 		mutex_exit(&SATA_CPORT_INFO(sata_hba_inst,
21086 		    saddr->cport)->cport_mutex);
21087 	} else {
21088 		mutex_enter(&SATA_PMPORT_INFO(sata_hba_inst,
21089 		    saddr->cport, saddr->pmport)->pmport_mutex);
21090 		SATA_PMPORT_EVENT_FLAGS(sata_hba_inst, saddr->cport,
21091 		    saddr->pmport) |= SATA_EVNT_TARGET_NODE_CLEANUP;
21092 		SATA_PMPORT_INFO(sata_hba_inst, saddr->cport, saddr->pmport)->
21093 		    pmport_tgtnode_clean = B_FALSE;
21094 		mutex_exit(&SATA_PMPORT_INFO(sata_hba_inst,
21095 		    saddr->cport, saddr->pmport)->pmport_mutex);
21096 	}
21097 	mutex_enter(&sata_hba_inst->satahba_mutex);
21098 	sata_hba_inst->satahba_event_flags |= SATA_EVNT_MAIN;
21099 	mutex_exit(&sata_hba_inst->satahba_mutex);
21100 	mutex_enter(&sata_mutex);
21101 	sata_event_pending |= SATA_EVNT_MAIN;
21102 	mutex_exit(&sata_mutex);
21103 }
21104 
21105 
21106 /*
21107  * Check if the SATA device target node is in DEVI_DEVICE_REMOVED state,
21108  * i.e. check if the target node state indicates that it belongs to a removed
21109  * device.
21110  *
21111  * Returns B_TRUE if the target node is in DEVI_DEVICE_REMOVED state,
21112  * B_FALSE otherwise.
21113  */
21114 static boolean_t
21115 sata_check_device_removed(dev_info_t *tdip)
21116 {
21117 	ASSERT(tdip != NULL);
21118 
21119 	if (DEVI_IS_DEVICE_REMOVED(tdip))
21120 		return (B_TRUE);
21121 	else
21122 		return (B_FALSE);
21123 }
21124 
21125 
21126 /*
21127  * Check for DMA error. Return B_TRUE if error, B_FALSE otherwise.
21128  */
21129 static boolean_t
21130 sata_check_for_dma_error(dev_info_t *dip, sata_pkt_txlate_t *spx)
21131 {
21132 	int fm_capability = ddi_fm_capable(dip);
21133 	ddi_fm_error_t de;
21134 
21135 	if (fm_capability & DDI_FM_DMACHK_CAPABLE) {
21136 		if (spx->txlt_buf_dma_handle != NULL) {
21137 			ddi_fm_dma_err_get(spx->txlt_buf_dma_handle, &de,
21138 			    DDI_FME_VERSION);
21139 			if (de.fme_status != DDI_SUCCESS)
21140 				return (B_TRUE);
21141 		}
21142 	}
21143 	return (B_FALSE);
21144 }
21145 
21146 
21147 /* ************************ FAULT INJECTTION **************************** */
21148 
21149 #ifdef SATA_INJECT_FAULTS
21150 
21151 static	uint32_t sata_fault_count = 0;
21152 static	uint32_t sata_fault_suspend_count = 0;
21153 
21154 /*
21155  * Inject sata pkt fault
21156  * It modifies returned values of the sata packet.
21157  * It returns immediately if:
21158  * pkt fault injection is not enabled (via sata_inject_fault,
21159  * sata_inject_fault_count), or invalid fault is specified (sata_fault_type),
21160  * or pkt does not contain command to be faulted (set in sata_fault_cmd), or
21161  * pkt is not directed to specified fault controller/device
21162  * (sata_fault_ctrl_dev and sata_fault_device).
21163  * If fault controller is not specified, fault injection applies to all
21164  * controllers and devices.
21165  *
21166  * First argument is the pointer to the executed sata packet.
21167  * Second argument is a pointer to a value returned by the HBA tran_start
21168  * function.
21169  * Third argument specifies injected error. Injected sata packet faults
21170  * are the satapkt_reason values.
21171  * SATA_PKT_BUSY		-1	Not completed, busy
21172  * SATA_PKT_DEV_ERROR		1	Device reported error
21173  * SATA_PKT_QUEUE_FULL		2	Not accepted, queue full
21174  * SATA_PKT_PORT_ERROR		3	Not completed, port error
21175  * SATA_PKT_CMD_UNSUPPORTED	4	Cmd unsupported
21176  * SATA_PKT_ABORTED		5	Aborted by request
21177  * SATA_PKT_TIMEOUT		6	Operation timeut
21178  * SATA_PKT_RESET		7	Aborted by reset request
21179  *
21180  * Additional global variables affecting the execution:
21181  *
21182  * sata_inject_fault_count variable specifies number of times in row the
21183  * error is injected. Value of -1 specifies permanent fault, ie. every time
21184  * the fault injection point is reached, the fault is injected and a pause
21185  * between fault injection specified by sata_inject_fault_pause_count is
21186  * ignored). Fault injection routine decrements sata_inject_fault_count
21187  * (if greater than zero) until it reaches 0. No fault is injected when
21188  * sata_inject_fault_count is 0 (zero).
21189  *
21190  * sata_inject_fault_pause_count variable specifies number of times a fault
21191  * injection is bypassed (pause between fault injections).
21192  * If set to 0, a fault is injected only a number of times specified by
21193  * sata_inject_fault_count.
21194  *
21195  * The fault counts are static, so for periodic errors they have to be manually
21196  * reset to start repetition sequence from scratch.
21197  * If the original value returned by the HBA tran_start function is not
21198  * SATA_TRAN_ACCEPTED and pkt reason is not SATA_PKT_COMPLETED, no error
21199  * is injected (to avoid masking real problems);
21200  *
21201  * NOTE: In its current incarnation, this function should be invoked only for
21202  * commands executed in SYNCHRONOUS mode.
21203  */
21204 
21205 
21206 static void
21207 sata_inject_pkt_fault(sata_pkt_t *spkt, int *rval, int fault)
21208 {
21209 
21210 	if (sata_inject_fault != SATA_INJECT_PKT_FAULT)
21211 		return;
21212 
21213 	if (sata_inject_fault_count == 0)
21214 		return;
21215 
21216 	if (fault == 0)
21217 		return;
21218 
21219 	if (sata_fault_cmd != spkt->satapkt_cmd.satacmd_cmd_reg)
21220 		return;
21221 
21222 	if (sata_fault_ctrl != NULL) {
21223 		sata_pkt_txlate_t *spx =
21224 		    (sata_pkt_txlate_t *)spkt->satapkt_framework_private;
21225 
21226 		if (sata_fault_ctrl != NULL && sata_fault_ctrl !=
21227 		    spx->txlt_sata_hba_inst->satahba_dip)
21228 			return;
21229 
21230 		if (sata_fault_device.satadev_addr.cport !=
21231 		    spkt->satapkt_device.satadev_addr.cport ||
21232 		    sata_fault_device.satadev_addr.pmport !=
21233 		    spkt->satapkt_device.satadev_addr.pmport ||
21234 		    sata_fault_device.satadev_addr.qual !=
21235 		    spkt->satapkt_device.satadev_addr.qual)
21236 			return;
21237 	}
21238 
21239 	/* Modify pkt return parameters */
21240 	if (*rval != SATA_TRAN_ACCEPTED ||
21241 	    spkt->satapkt_reason != SATA_PKT_COMPLETED) {
21242 		sata_fault_count = 0;
21243 		sata_fault_suspend_count = 0;
21244 		return;
21245 	}
21246 	if (sata_fault_count == 0 && sata_fault_suspend_count != 0) {
21247 		/* Pause in the injection */
21248 		sata_fault_suspend_count -= 1;
21249 		return;
21250 	}
21251 
21252 	if (sata_fault_count == 0 && sata_fault_suspend_count == 0) {
21253 		/*
21254 		 * Init inject fault cycle. If fault count is set to -1,
21255 		 * it is a permanent fault.
21256 		 */
21257 		if (sata_inject_fault_count != -1) {
21258 			sata_fault_count = sata_inject_fault_count;
21259 			sata_fault_suspend_count =
21260 			    sata_inject_fault_pause_count;
21261 			if (sata_fault_suspend_count == 0)
21262 				sata_inject_fault_count = 0;
21263 		}
21264 	}
21265 
21266 	if (sata_fault_count != 0)
21267 		sata_fault_count -= 1;
21268 
21269 	switch (fault) {
21270 	case SATA_PKT_BUSY:
21271 		*rval = SATA_TRAN_BUSY;
21272 		spkt->satapkt_reason = SATA_PKT_BUSY;
21273 		break;
21274 
21275 	case SATA_PKT_QUEUE_FULL:
21276 		*rval = SATA_TRAN_QUEUE_FULL;
21277 		spkt->satapkt_reason = SATA_PKT_QUEUE_FULL;
21278 		break;
21279 
21280 	case SATA_PKT_CMD_UNSUPPORTED:
21281 		*rval = SATA_TRAN_CMD_UNSUPPORTED;
21282 		spkt->satapkt_reason = SATA_PKT_CMD_UNSUPPORTED;
21283 		break;
21284 
21285 	case SATA_PKT_PORT_ERROR:
21286 		/* This is "rejected" command */
21287 		*rval = SATA_TRAN_PORT_ERROR;
21288 		spkt->satapkt_reason = SATA_PKT_PORT_ERROR;
21289 		/* Additional error setup could be done here - port state */
21290 		break;
21291 
21292 	case SATA_PKT_DEV_ERROR:
21293 		spkt->satapkt_reason = SATA_PKT_DEV_ERROR;
21294 		/*
21295 		 * Additional error setup could be done here
21296 		 */
21297 		break;
21298 
21299 	case SATA_PKT_ABORTED:
21300 		spkt->satapkt_reason = SATA_PKT_ABORTED;
21301 		break;
21302 
21303 	case SATA_PKT_TIMEOUT:
21304 		spkt->satapkt_reason = SATA_PKT_TIMEOUT;
21305 		/* Additional error setup could be done here */
21306 		break;
21307 
21308 	case SATA_PKT_RESET:
21309 		spkt->satapkt_reason = SATA_PKT_RESET;
21310 		/*
21311 		 * Additional error setup could be done here - device reset
21312 		 */
21313 		break;
21314 
21315 	default:
21316 		break;
21317 	}
21318 }
21319 
21320 #endif
21321 
21322 /*
21323  * SATA Trace Ring Buffer
21324  * ----------------------
21325  *
21326  * Overview
21327  *
21328  * The SATA trace ring buffer is a ring buffer created and managed by
21329  * the SATA framework module that can be used by any module or driver
21330  * within the SATA framework to store debug messages.
21331  *
21332  * Ring Buffer Interfaces:
21333  *
21334  *	sata_vtrace_debug()	<-- Adds debug message to ring buffer
21335  *	sata_trace_debug()	<-- Wraps varargs into sata_vtrace_debug()
21336  *
21337  *	Note that the sata_trace_debug() interface was created to give
21338  *	consumers the flexibilty of sending debug messages to ring buffer
21339  *	as variable arguments.  Consumers can send type va_list debug
21340  *	messages directly to sata_vtrace_debug(). The sata_trace_debug()
21341  *	and sata_vtrace_debug() relationship is similar to that of
21342  *	cmn_err(9F) and vcmn_err(9F).
21343  *
21344  * Below is a diagram of the SATA trace ring buffer interfaces and
21345  * sample consumers:
21346  *
21347  * +---------------------------------+
21348  * |    o  o  SATA Framework Module  |
21349  * | o  SATA  o     +------------------+      +------------------+
21350  * |o   Trace  o <--|sata_vtrace_debug/|<-----|SATA HBA Driver #1|
21351  * |o   R-Buf  o    |sata_trace_debug  |<--+  +------------------+
21352  * | o        o     +------------------+   |  +------------------+
21353  * |    o  o                ^        |     +--|SATA HBA Driver #2|
21354  * |                        |        |        +------------------+
21355  * |           +------------------+  |
21356  * |           |SATA Debug Message|  |
21357  * |           +------------------+  |
21358  * +---------------------------------+
21359  *
21360  * Supporting Routines:
21361  *
21362  *	sata_trace_rbuf_alloc()	<-- Initializes ring buffer
21363  *	sata_trace_rbuf_free()	<-- Destroys ring buffer
21364  *	sata_trace_dmsg_alloc() <-- Creates or reuses buffer in ring buffer
21365  *	sata_trace_dmsg_free()	<-- Destroys content of ring buffer
21366  *
21367  * The default SATA trace ring buffer size is defined by DMSG_RING_SIZE.
21368  * The ring buffer size can be adjusted by setting dmsg_ring_size in
21369  * /etc/system to desired size in unit of bytes.
21370  *
21371  * The individual debug message size in the ring buffer is restricted
21372  * to DMSG_BUF_SIZE.
21373  */
21374 void
21375 sata_vtrace_debug(dev_info_t *dip, const char *fmt, va_list ap)
21376 {
21377 	sata_trace_dmsg_t *dmsg;
21378 
21379 	if (sata_debug_rbuf == NULL) {
21380 		return;
21381 	}
21382 
21383 	/*
21384 	 * If max size of ring buffer is smaller than size
21385 	 * required for one debug message then just return
21386 	 * since we have no room for the debug message.
21387 	 */
21388 	if (sata_debug_rbuf->maxsize < (sizeof (sata_trace_dmsg_t))) {
21389 		return;
21390 	}
21391 
21392 	mutex_enter(&sata_debug_rbuf->lock);
21393 
21394 	/* alloc or reuse on ring buffer */
21395 	dmsg = sata_trace_dmsg_alloc();
21396 
21397 	if (dmsg == NULL) {
21398 		/* resource allocation failed */
21399 		mutex_exit(&sata_debug_rbuf->lock);
21400 		return;
21401 	}
21402 
21403 	dmsg->dip = dip;
21404 	gethrestime(&dmsg->timestamp);
21405 
21406 	(void) vsnprintf(dmsg->buf, sizeof (dmsg->buf), fmt, ap);
21407 
21408 	mutex_exit(&sata_debug_rbuf->lock);
21409 }
21410 
21411 void
21412 sata_trace_debug(dev_info_t *dip, const char *fmt, ...)
21413 {
21414 	va_list ap;
21415 
21416 	va_start(ap, fmt);
21417 	sata_vtrace_debug(dip, fmt, ap);
21418 	va_end(ap);
21419 }
21420 
21421 /*
21422  * This routine is used to manage debug messages
21423  * on ring buffer.
21424  */
21425 static sata_trace_dmsg_t *
21426 sata_trace_dmsg_alloc(void)
21427 {
21428 	sata_trace_dmsg_t *dmsg_alloc, *dmsg = sata_debug_rbuf->dmsgp;
21429 
21430 	if (sata_debug_rbuf->looped == TRUE) {
21431 		sata_debug_rbuf->dmsgp = dmsg->next;
21432 		return (sata_debug_rbuf->dmsgp);
21433 	}
21434 
21435 	/*
21436 	 * If we're looping for the first time,
21437 	 * connect the ring.
21438 	 */
21439 	if (((sata_debug_rbuf->size + (sizeof (sata_trace_dmsg_t))) >
21440 	    sata_debug_rbuf->maxsize) && (sata_debug_rbuf->dmsgh != NULL)) {
21441 		dmsg->next = sata_debug_rbuf->dmsgh;
21442 		sata_debug_rbuf->dmsgp = sata_debug_rbuf->dmsgh;
21443 		sata_debug_rbuf->looped = TRUE;
21444 		return (sata_debug_rbuf->dmsgp);
21445 	}
21446 
21447 	/* If we've gotten this far then memory allocation is needed */
21448 	dmsg_alloc = kmem_zalloc(sizeof (sata_trace_dmsg_t), KM_NOSLEEP);
21449 	if (dmsg_alloc == NULL) {
21450 		sata_debug_rbuf->allocfailed++;
21451 		return (dmsg_alloc);
21452 	} else {
21453 		sata_debug_rbuf->size += sizeof (sata_trace_dmsg_t);
21454 	}
21455 
21456 	if (sata_debug_rbuf->dmsgp != NULL) {
21457 		dmsg->next = dmsg_alloc;
21458 		sata_debug_rbuf->dmsgp = dmsg->next;
21459 		return (sata_debug_rbuf->dmsgp);
21460 	} else {
21461 		/*
21462 		 * We should only be here if we're initializing
21463 		 * the ring buffer.
21464 		 */
21465 		if (sata_debug_rbuf->dmsgh == NULL) {
21466 			sata_debug_rbuf->dmsgh = dmsg_alloc;
21467 		} else {
21468 			/* Something is wrong */
21469 			kmem_free(dmsg_alloc, sizeof (sata_trace_dmsg_t));
21470 			return (NULL);
21471 		}
21472 
21473 		sata_debug_rbuf->dmsgp = dmsg_alloc;
21474 		return (sata_debug_rbuf->dmsgp);
21475 	}
21476 }
21477 
21478 
21479 /*
21480  * Free all messages on debug ring buffer.
21481  */
21482 static void
21483 sata_trace_dmsg_free(void)
21484 {
21485 	sata_trace_dmsg_t *dmsg_next, *dmsg = sata_debug_rbuf->dmsgh;
21486 
21487 	while (dmsg != NULL) {
21488 		dmsg_next = dmsg->next;
21489 		kmem_free(dmsg, sizeof (sata_trace_dmsg_t));
21490 
21491 		/*
21492 		 * If we've looped around the ring than we're done.
21493 		 */
21494 		if (dmsg_next == sata_debug_rbuf->dmsgh) {
21495 			break;
21496 		} else {
21497 			dmsg = dmsg_next;
21498 		}
21499 	}
21500 }
21501 
21502 
21503 /*
21504  * This function can block
21505  */
21506 static void
21507 sata_trace_rbuf_alloc(void)
21508 {
21509 	sata_debug_rbuf = kmem_zalloc(sizeof (sata_trace_rbuf_t), KM_SLEEP);
21510 
21511 	mutex_init(&sata_debug_rbuf->lock, NULL, MUTEX_DRIVER, NULL);
21512 
21513 	if (dmsg_ring_size > 0) {
21514 		sata_debug_rbuf->maxsize = (size_t)dmsg_ring_size;
21515 	}
21516 }
21517 
21518 
21519 static void
21520 sata_trace_rbuf_free(void)
21521 {
21522 	sata_trace_dmsg_free();
21523 	mutex_destroy(&sata_debug_rbuf->lock);
21524 	kmem_free(sata_debug_rbuf, sizeof (sata_trace_rbuf_t));
21525 }
21526 
21527 #ifndef SATA_DEBUG
21528 /*
21529  * If SATA_DEBUG is not defined then this routine is called instead
21530  * of sata_log() via the SATA_LOG_D macro.
21531  */
21532 static void
21533 sata_trace_log(sata_hba_inst_t *sata_hba_inst, uint_t level __unused,
21534     const char *fmt, ...)
21535 {
21536 	dev_info_t *dip = NULL;
21537 	va_list ap;
21538 
21539 	if (sata_hba_inst != NULL) {
21540 		dip = SATA_DIP(sata_hba_inst);
21541 	}
21542 
21543 	va_start(ap, fmt);
21544 	sata_vtrace_debug(dip, fmt, ap);
21545 	va_end(ap);
21546 }
21547 
21548 #endif /* SATA_DEBUG */
21549