xref: /titanic_50/usr/src/uts/common/io/sata/impl/sata.c (revision a833a696f1726fd5d95ded0820612f465a2dad8d) 
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 2013 Nexenta Systems, Inc.  All rights reserved.
27  */
28 
29 /*
30  * SATA Framework
31  * Generic SATA Host Adapter Implementation
32  */
33 
34 #include <sys/conf.h>
35 #include <sys/file.h>
36 #include <sys/ddi.h>
37 #include <sys/sunddi.h>
38 #include <sys/modctl.h>
39 #include <sys/cmn_err.h>
40 #include <sys/errno.h>
41 #include <sys/thread.h>
42 #include <sys/kstat.h>
43 #include <sys/note.h>
44 #include <sys/sysevent.h>
45 #include <sys/sysevent/eventdefs.h>
46 #include <sys/sysevent/dr.h>
47 #include <sys/taskq.h>
48 #include <sys/disp.h>
49 #include <sys/sdt.h>
50 
51 #include <sys/sata/impl/sata.h>
52 #include <sys/sata/sata_hba.h>
53 #include <sys/sata/sata_defs.h>
54 #include <sys/sata/sata_cfgadm.h>
55 #include <sys/sata/sata_blacklist.h>
56 #include <sys/sata/sata_satl.h>
57 
58 #include <sys/scsi/impl/spc3_types.h>
59 
60 /*
61  * FMA header files
62  */
63 #include <sys/ddifm.h>
64 #include <sys/fm/protocol.h>
65 #include <sys/fm/util.h>
66 #include <sys/fm/io/ddi.h>
67 
68 /* Debug flags - defined in sata.h */
69 int	sata_debug_flags = 0;
70 int	sata_msg = 0;
71 
72 /*
73  * Flags enabling selected SATA HBA framework functionality
74  */
75 #define	SATA_ENABLE_QUEUING		1
76 #define	SATA_ENABLE_NCQ			2
77 #define	SATA_ENABLE_PROCESS_EVENTS	4
78 #define	SATA_ENABLE_PMULT_FBS		8 /* FIS-Based Switching */
79 int sata_func_enable =
80 	SATA_ENABLE_PROCESS_EVENTS | SATA_ENABLE_QUEUING | SATA_ENABLE_NCQ;
81 
82 /*
83  * Global variable setting default maximum queue depth (NCQ or TCQ)
84  * Note:minimum queue depth is 1
85  */
86 int sata_max_queue_depth = SATA_MAX_QUEUE_DEPTH; /* max NCQ/TCQ queue depth */
87 
88 /*
89  * Currently used default NCQ/TCQ queue depth. It is set-up during the driver
90  * initialization, using value from sata_max_queue_depth
91  * It is adjusted to minimum supported by the controller and by the device,
92  * if queueing is enabled.
93  */
94 static	int sata_current_max_qdepth;
95 
96 /*
97  * Global variable determining the default behavior after device hotpluggin.
98  * If non-zero, the hotplugged device is onlined (if possible) without explicit
99  * IOCTL request (AP_CONFIGURE).
100  * If zero, hotplugged device is identified, but not onlined.
101  * Enabling (AP_CONNECT) device port with an attached device does not result
102  * in device onlining regardless of the flag setting
103  */
104 int sata_auto_online = 0;
105 
106 #ifdef SATA_DEBUG
107 
108 #define	SATA_LOG_D(args)	sata_log args
109 uint64_t mbuf_count = 0;
110 uint64_t mbuffail_count = 0;
111 
112 sata_atapi_cmd_t sata_atapi_trace[64];
113 uint32_t sata_atapi_trace_index = 0;
114 int sata_atapi_trace_save = 1;
115 static	void sata_save_atapi_trace(sata_pkt_txlate_t *, int);
116 #define	SATAATAPITRACE(spx, count)	if (sata_atapi_trace_save) \
117     sata_save_atapi_trace(spx, count);
118 
119 #else
120 #define	SATA_LOG_D(args)	sata_trace_log args
121 #define	SATAATAPITRACE(spx, count)
122 #endif
123 
124 #if 0
125 static void
126 sata_test_atapi_packet_command(sata_hba_inst_t *, int);
127 #endif
128 
129 #ifdef SATA_INJECT_FAULTS
130 
131 #define		SATA_INJECT_PKT_FAULT	1
132 uint32_t	sata_inject_fault = 0;
133 
134 uint32_t	sata_inject_fault_count = 0;
135 uint32_t	sata_inject_fault_pause_count = 0;
136 uint32_t	sata_fault_type = 0;
137 uint32_t	sata_fault_cmd = 0;
138 dev_info_t	*sata_fault_ctrl = NULL;
139 sata_device_t	sata_fault_device;
140 
141 static	void sata_inject_pkt_fault(sata_pkt_t *, int *, int);
142 
143 #endif
144 
145 #define	LEGACY_HWID_LEN	64	/* Model (40) + Serial (20) + pad */
146 
147 static char sata_rev_tag[] = {"1.46"};
148 
149 /*
150  * SATA cb_ops functions
151  */
152 static 	int sata_hba_open(dev_t *, int, int, cred_t *);
153 static 	int sata_hba_close(dev_t, int, int, cred_t *);
154 static 	int sata_hba_ioctl(dev_t, int, intptr_t, int, cred_t *,	int *);
155 
156 /*
157  * SCSA required entry points
158  */
159 static	int sata_scsi_tgt_init(dev_info_t *, dev_info_t *,
160     scsi_hba_tran_t *, struct scsi_device *);
161 static	int sata_scsi_tgt_probe(struct scsi_device *,
162     int (*callback)(void));
163 static void sata_scsi_tgt_free(dev_info_t *, dev_info_t *,
164     scsi_hba_tran_t *, struct scsi_device *);
165 static 	int sata_scsi_start(struct scsi_address *, struct scsi_pkt *);
166 static 	int sata_scsi_abort(struct scsi_address *, struct scsi_pkt *);
167 static 	int sata_scsi_reset(struct scsi_address *, int);
168 static 	int sata_scsi_getcap(struct scsi_address *, char *, int);
169 static 	int sata_scsi_setcap(struct scsi_address *, char *, int, int);
170 static 	struct scsi_pkt *sata_scsi_init_pkt(struct scsi_address *,
171     struct scsi_pkt *, struct buf *, int, int, int, int, int (*)(caddr_t),
172     caddr_t);
173 static 	void sata_scsi_destroy_pkt(struct scsi_address *, struct scsi_pkt *);
174 static 	void sata_scsi_dmafree(struct scsi_address *, struct scsi_pkt *);
175 static 	void sata_scsi_sync_pkt(struct scsi_address *, struct scsi_pkt *);
176 
177 /*
178  * SATA HBA interface functions are defined in sata_hba.h header file
179  */
180 
181 /* Event processing functions */
182 static	void sata_event_daemon(void *);
183 static	void sata_event_thread_control(int);
184 static	void sata_process_controller_events(sata_hba_inst_t *sata_hba_inst);
185 static	void sata_process_pmult_events(sata_hba_inst_t *, uint8_t);
186 static	void sata_process_device_reset(sata_hba_inst_t *, sata_address_t *);
187 static	void sata_process_pmdevice_reset(sata_hba_inst_t *, sata_address_t *);
188 static	void sata_process_port_failed_event(sata_hba_inst_t *,
189     sata_address_t *);
190 static	void sata_process_port_link_events(sata_hba_inst_t *,
191     sata_address_t *);
192 static	void sata_process_pmport_link_events(sata_hba_inst_t *,
193     sata_address_t *);
194 static	void sata_process_device_detached(sata_hba_inst_t *, sata_address_t *);
195 static	void sata_process_pmdevice_detached(sata_hba_inst_t *,
196     sata_address_t *);
197 static	void sata_process_device_attached(sata_hba_inst_t *, sata_address_t *);
198 static	void sata_process_pmdevice_attached(sata_hba_inst_t *,
199     sata_address_t *);
200 static	void sata_process_port_pwr_change(sata_hba_inst_t *, sata_address_t *);
201 static	void sata_process_cntrl_pwr_level_change(sata_hba_inst_t *);
202 static	void sata_process_target_node_cleanup(sata_hba_inst_t *,
203     sata_address_t *);
204 static	void sata_process_device_autoonline(sata_hba_inst_t *,
205     sata_address_t *saddr);
206 
207 /*
208  * Local translation functions
209  */
210 static	int sata_txlt_inquiry(sata_pkt_txlate_t *);
211 static	int sata_txlt_test_unit_ready(sata_pkt_txlate_t *);
212 static	int sata_txlt_start_stop_unit(sata_pkt_txlate_t *);
213 static	int sata_txlt_read_capacity(sata_pkt_txlate_t *);
214 static	int sata_txlt_read_capacity16(sata_pkt_txlate_t *);
215 static  int sata_txlt_unmap(sata_pkt_txlate_t *);
216 static	int sata_txlt_request_sense(sata_pkt_txlate_t *);
217 static	int sata_txlt_read(sata_pkt_txlate_t *);
218 static	int sata_txlt_write(sata_pkt_txlate_t *);
219 static	int sata_txlt_log_sense(sata_pkt_txlate_t *);
220 static	int sata_txlt_log_select(sata_pkt_txlate_t *);
221 static	int sata_txlt_mode_sense(sata_pkt_txlate_t *);
222 static	int sata_txlt_mode_select(sata_pkt_txlate_t *);
223 static	int sata_txlt_ata_pass_thru(sata_pkt_txlate_t *);
224 static	int sata_txlt_synchronize_cache(sata_pkt_txlate_t *);
225 static	int sata_txlt_write_buffer(sata_pkt_txlate_t *);
226 static	int sata_txlt_nodata_cmd_immediate(sata_pkt_txlate_t *);
227 
228 static	int sata_hba_start(sata_pkt_txlate_t *, int *);
229 static	int sata_txlt_invalid_command(sata_pkt_txlate_t *);
230 static	int sata_txlt_check_condition(sata_pkt_txlate_t *, uchar_t, uchar_t);
231 static	int sata_txlt_lba_out_of_range(sata_pkt_txlate_t *);
232 static	int sata_txlt_ata_pass_thru_illegal_cmd(sata_pkt_txlate_t *);
233 static  int sata_txlt_unmap_nodata_cmd(sata_pkt_txlate_t *);
234 static	void sata_txlt_rw_completion(sata_pkt_t *);
235 static	void sata_txlt_nodata_cmd_completion(sata_pkt_t *);
236 static	void sata_txlt_apt_completion(sata_pkt_t *sata_pkt);
237 static	void sata_txlt_unmap_completion(sata_pkt_t *sata_pkt);
238 static	void sata_txlt_download_mcode_cmd_completion(sata_pkt_t *);
239 static	int sata_emul_rw_completion(sata_pkt_txlate_t *);
240 static	void sata_fill_ata_return_desc(sata_pkt_t *, uint8_t, uint8_t,
241     uint8_t);
242 static	struct scsi_extended_sense *sata_immediate_error_response(
243     sata_pkt_txlate_t *, int);
244 static	struct scsi_extended_sense *sata_arq_sense(sata_pkt_txlate_t *);
245 
246 static	int sata_txlt_atapi(sata_pkt_txlate_t *);
247 static	void sata_txlt_atapi_completion(sata_pkt_t *);
248 
249 /*
250  * Local functions for ioctl
251  */
252 static	int32_t sata_get_port_num(sata_hba_inst_t *,  struct devctl_iocdata *);
253 static	void sata_cfgadm_state(sata_hba_inst_t *, int32_t,
254     devctl_ap_state_t *);
255 static	dev_info_t *sata_get_target_dip(dev_info_t *, uint8_t, uint8_t);
256 static	dev_info_t *sata_get_scsi_target_dip(dev_info_t *, sata_address_t *);
257 static	dev_info_t *sata_devt_to_devinfo(dev_t);
258 static	int sata_ioctl_connect(sata_hba_inst_t *, sata_device_t *);
259 static	int sata_ioctl_disconnect(sata_hba_inst_t *, sata_device_t *);
260 static	int sata_ioctl_configure(sata_hba_inst_t *, sata_device_t *);
261 static	int sata_ioctl_unconfigure(sata_hba_inst_t *, sata_device_t *);
262 static	int sata_ioctl_activate(sata_hba_inst_t *, sata_device_t *);
263 static	int sata_ioctl_deactivate(sata_hba_inst_t *, sata_device_t *);
264 static	int sata_ioctl_reset_port(sata_hba_inst_t *, sata_device_t *);
265 static	int sata_ioctl_reset_device(sata_hba_inst_t *, sata_device_t *);
266 static	int sata_ioctl_reset_all(sata_hba_inst_t *);
267 static	int sata_ioctl_port_self_test(sata_hba_inst_t *, sata_device_t *);
268 static	int sata_ioctl_get_device_path(sata_hba_inst_t *, sata_device_t *,
269     sata_ioctl_data_t *, int mode);
270 static	int sata_ioctl_get_ap_type(sata_hba_inst_t *, sata_device_t *,
271     sata_ioctl_data_t *, int mode);
272 static	int sata_ioctl_get_model_info(sata_hba_inst_t *, sata_device_t *,
273     sata_ioctl_data_t *, int mode);
274 static	int sata_ioctl_get_revfirmware_info(sata_hba_inst_t *, sata_device_t *,
275     sata_ioctl_data_t *, int mode);
276 static	int sata_ioctl_get_serialnumber_info(sata_hba_inst_t *,
277     sata_device_t *, sata_ioctl_data_t *, int mode);
278 
279 /*
280  * Local functions
281  */
282 static 	void sata_remove_hba_instance(dev_info_t *);
283 static 	int sata_validate_sata_hba_tran(dev_info_t *, sata_hba_tran_t *);
284 static 	void sata_probe_ports(sata_hba_inst_t *);
285 static	void sata_probe_pmports(sata_hba_inst_t *, uint8_t);
286 static 	int sata_reprobe_port(sata_hba_inst_t *, sata_device_t *, int);
287 static 	int sata_reprobe_pmult(sata_hba_inst_t *, sata_device_t *, int);
288 static 	int sata_reprobe_pmport(sata_hba_inst_t *, sata_device_t *, int);
289 static	int sata_alloc_pmult(sata_hba_inst_t *, sata_device_t *);
290 static	void sata_free_pmult(sata_hba_inst_t *, sata_device_t *);
291 static 	int sata_add_device(dev_info_t *, sata_hba_inst_t *, sata_device_t *);
292 static	int sata_offline_device(sata_hba_inst_t *, sata_device_t *,
293     sata_drive_info_t *);
294 static 	dev_info_t *sata_create_target_node(dev_info_t *, sata_hba_inst_t *,
295     sata_address_t *);
296 static 	void sata_remove_target_node(sata_hba_inst_t *,
297     sata_address_t *);
298 static 	int sata_validate_scsi_address(sata_hba_inst_t *,
299     struct scsi_address *, sata_device_t *);
300 static 	int sata_validate_sata_address(sata_hba_inst_t *, int, int, int);
301 static	sata_pkt_t *sata_pkt_alloc(sata_pkt_txlate_t *, int (*)(caddr_t));
302 static	void sata_pkt_free(sata_pkt_txlate_t *);
303 static	int sata_dma_buf_setup(sata_pkt_txlate_t *, int, int (*)(caddr_t),
304     caddr_t, ddi_dma_attr_t *);
305 static	void sata_common_free_dma_rsrcs(sata_pkt_txlate_t *);
306 static	int sata_probe_device(sata_hba_inst_t *, sata_device_t *);
307 static	sata_drive_info_t *sata_get_device_info(sata_hba_inst_t *,
308     sata_device_t *);
309 static 	int sata_identify_device(sata_hba_inst_t *, sata_drive_info_t *);
310 static	void sata_reidentify_device(sata_pkt_txlate_t *);
311 static	struct buf *sata_alloc_local_buffer(sata_pkt_txlate_t *, int);
312 static 	void sata_free_local_buffer(sata_pkt_txlate_t *);
313 static 	uint64_t sata_check_capacity(sata_drive_info_t *);
314 void 	sata_adjust_dma_attr(sata_drive_info_t *, ddi_dma_attr_t *,
315     ddi_dma_attr_t *);
316 static 	int sata_fetch_device_identify_data(sata_hba_inst_t *,
317     sata_drive_info_t *);
318 static	void sata_update_port_info(sata_hba_inst_t *, sata_device_t *);
319 static	void sata_update_pmport_info(sata_hba_inst_t *, sata_device_t *);
320 static	void sata_update_port_scr(sata_port_scr_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_10(sata_drive_info_t *, uint8_t *,
348     sata_hba_inst_t *);
349 static	int sata_build_lsense_page_2f(sata_drive_info_t *, uint8_t *,
350     sata_hba_inst_t *);
351 static	int sata_build_lsense_page_30(sata_drive_info_t *, uint8_t *,
352     sata_hba_inst_t *);
353 static	int sata_build_lsense_page_0e(sata_drive_info_t *, uint8_t *,
354     sata_pkt_txlate_t *);
355 
356 static	void sata_set_arq_data(sata_pkt_t *);
357 static	void sata_build_read_verify_cmd(sata_cmd_t *, uint16_t, uint64_t);
358 static	void sata_build_generic_cmd(sata_cmd_t *, uint8_t);
359 static	uint8_t sata_get_standby_timer(uint8_t *timer);
360 
361 static	void sata_save_drive_settings(sata_drive_info_t *);
362 static	void sata_show_drive_info(sata_hba_inst_t *, sata_drive_info_t *);
363 static	void sata_show_pmult_info(sata_hba_inst_t *, sata_device_t *);
364 static	void sata_log(sata_hba_inst_t *, uint_t, char *fmt, ...);
365 static	void sata_trace_log(sata_hba_inst_t *, uint_t, const char *fmt, ...);
366 static	int sata_fetch_smart_return_status(sata_hba_inst_t *,
367     sata_drive_info_t *);
368 static	int sata_fetch_smart_data(sata_hba_inst_t *, sata_drive_info_t *,
369     struct smart_data *);
370 static	int sata_smart_selftest_log(sata_hba_inst_t *,
371     sata_drive_info_t *,
372     struct smart_selftest_log *);
373 static	int sata_ext_smart_selftest_read_log(sata_hba_inst_t *,
374     sata_drive_info_t *, struct smart_ext_selftest_log *, uint16_t);
375 static	int sata_smart_read_log(sata_hba_inst_t *, sata_drive_info_t *,
376     uint8_t *, uint8_t, uint8_t);
377 static	int sata_read_log_ext_directory(sata_hba_inst_t *, sata_drive_info_t *,
378     struct read_log_ext_directory *);
379 static	void sata_gen_sysevent(sata_hba_inst_t *, sata_address_t *, int);
380 static	void sata_xlate_errors(sata_pkt_txlate_t *);
381 static	void sata_decode_device_error(sata_pkt_txlate_t *,
382     struct scsi_extended_sense *);
383 static	void sata_set_device_removed(dev_info_t *);
384 static	boolean_t sata_check_device_removed(dev_info_t *);
385 static	void sata_set_target_node_cleanup(sata_hba_inst_t *, sata_address_t *);
386 static	int sata_ncq_err_ret_cmd_setup(sata_pkt_txlate_t *,
387     sata_drive_info_t *);
388 static	int sata_atapi_err_ret_cmd_setup(sata_pkt_txlate_t *,
389     sata_drive_info_t *);
390 static	void sata_atapi_packet_cmd_setup(sata_cmd_t *, sata_drive_info_t *);
391 static	void sata_fixed_sense_data_preset(struct scsi_extended_sense *);
392 static  void sata_target_devid_register(dev_info_t *, sata_drive_info_t *);
393 static  int sata_check_modser(char *, int);
394 
395 /*
396  * FMA
397  */
398 static boolean_t sata_check_for_dma_error(dev_info_t *, sata_pkt_txlate_t *);
399 
400 
401 /*
402  * SATA Framework will ignore SATA HBA driver cb_ops structure and
403  * register following one with SCSA framework.
404  * Open & close are provided, so scsi framework will not use its own
405  */
406 static struct cb_ops sata_cb_ops = {
407 	sata_hba_open,			/* open */
408 	sata_hba_close,			/* close */
409 	nodev,				/* strategy */
410 	nodev,				/* print */
411 	nodev,				/* dump */
412 	nodev,				/* read */
413 	nodev,				/* write */
414 	sata_hba_ioctl,			/* ioctl */
415 	nodev,				/* devmap */
416 	nodev,				/* mmap */
417 	nodev,				/* segmap */
418 	nochpoll,			/* chpoll */
419 	ddi_prop_op,			/* cb_prop_op */
420 	0,				/* streamtab */
421 	D_NEW | D_MP,			/* cb_flag */
422 	CB_REV,				/* rev */
423 	nodev,				/* aread */
424 	nodev				/* awrite */
425 };
426 
427 
428 extern struct mod_ops mod_miscops;
429 extern uchar_t	scsi_cdb_size[];
430 
431 static struct modlmisc modlmisc = {
432 	&mod_miscops,			/* Type of module */
433 	"SATA Module"			/* module name */
434 };
435 
436 
437 static struct modlinkage modlinkage = {
438 	MODREV_1,
439 	(void *)&modlmisc,
440 	NULL
441 };
442 
443 /*
444  * Default sata pkt timeout. Used when a target driver scsi_pkt time is zero,
445  * i.e. when scsi_pkt has not timeout specified.
446  */
447 static int sata_default_pkt_time = 60;	/* 60 seconds */
448 
449 /*
450  * Intermediate buffer device access attributes - they are required,
451  * but not necessarily used.
452  */
453 static ddi_device_acc_attr_t sata_acc_attr = {
454 	DDI_DEVICE_ATTR_V0,
455 	DDI_STRUCTURE_LE_ACC,
456 	DDI_STRICTORDER_ACC
457 };
458 
459 
460 /*
461  * Mutexes protecting structures in multithreaded operations.
462  * Because events are relatively rare, a single global mutex protecting
463  * data structures should be sufficient. To increase performance, add
464  * separate mutex per each sata port and use global mutex only to protect
465  * common data structures.
466  */
467 static	kmutex_t sata_mutex;		/* protects sata_hba_list */
468 static	kmutex_t sata_log_mutex;	/* protects log */
469 
470 static 	char sata_log_buf[256];
471 
472 /*
473  * sata trace debug
474  */
475 static	sata_trace_rbuf_t *sata_debug_rbuf;
476 static	sata_trace_dmsg_t *sata_trace_dmsg_alloc(void);
477 static	void sata_trace_dmsg_free(void);
478 static	void sata_trace_rbuf_alloc(void);
479 static	void sata_trace_rbuf_free(void);
480 
481 int	dmsg_ring_size = DMSG_RING_SIZE;
482 
483 /* Default write cache setting for SATA hard disks */
484 int	sata_write_cache = 1;		/* enabled */
485 
486 /* Default write cache setting for SATA ATAPI CD/DVD */
487 int	sata_atapicdvd_write_cache = 1; /* enabled */
488 
489 /* Default write cache setting for SATA ATAPI tape */
490 int	sata_atapitape_write_cache = 1; /* enabled */
491 
492 /* Default write cache setting for SATA ATAPI disk */
493 int	sata_atapidisk_write_cache = 1;	/* enabled */
494 
495 /*
496  * Linked list of HBA instances
497  */
498 static 	sata_hba_inst_t *sata_hba_list = NULL;
499 static 	sata_hba_inst_t *sata_hba_list_tail = NULL;
500 /*
501  * Pointer to per-instance SATA HBA soft structure is stored in sata_hba_tran
502  * structure and in sata soft state.
503  */
504 
505 /*
506  * Event daemon related variables
507  */
508 static 	kmutex_t sata_event_mutex;
509 static 	kcondvar_t sata_event_cv;
510 static 	kthread_t *sata_event_thread = NULL;
511 static 	int sata_event_thread_terminate = 0;
512 static 	int sata_event_pending = 0;
513 static 	int sata_event_thread_active = 0;
514 extern 	pri_t minclsyspri;
515 
516 /*
517  * NCQ error recovery command
518  */
519 static const sata_cmd_t sata_rle_cmd = {
520 	SATA_CMD_REV,
521 	NULL,
522 	{
523 		SATA_DIR_READ
524 	},
525 	ATA_ADDR_LBA48,
526 	0,
527 	0,
528 	0,
529 	0,
530 	0,
531 	1,
532 	READ_LOG_EXT_NCQ_ERROR_RECOVERY,
533 	0,
534 	0,
535 	0,
536 	SATAC_READ_LOG_EXT,
537 	0,
538 	0,
539 	0,
540 };
541 
542 /*
543  * ATAPI error recovery CDB
544  */
545 static const uint8_t sata_rqsense_cdb[SATA_ATAPI_RQSENSE_CDB_LEN] = {
546 	SCMD_REQUEST_SENSE,
547 	0,			/* Only fixed RQ format is supported */
548 	0,
549 	0,
550 	SATA_ATAPI_MIN_RQSENSE_LEN, /* Less data may be returned */
551 	0
552 };
553 
554 
555 /* Warlock directives */
556 
557 _NOTE(SCHEME_PROTECTS_DATA("No Mutex Needed", scsi_hba_tran))
558 _NOTE(SCHEME_PROTECTS_DATA("No Mutex Needed", scsi_device))
559 _NOTE(SCHEME_PROTECTS_DATA("No Mutex Needed", dev_ops))
560 _NOTE(SCHEME_PROTECTS_DATA("No Mutex Needed", scsi_extended_sense))
561 _NOTE(SCHEME_PROTECTS_DATA("No Mutex Needed", scsi_arq_status))
562 _NOTE(SCHEME_PROTECTS_DATA("No Mutex Needed", ddi_dma_attr))
563 _NOTE(SCHEME_PROTECTS_DATA("No Mutex Needed", ddi_dma_cookie_t))
564 _NOTE(SCHEME_PROTECTS_DATA("No Mutex Needed", devctl_ap_state))
565 _NOTE(SCHEME_PROTECTS_DATA("No Mutex Needed", dev_info::devi_state))
566 _NOTE(MUTEX_PROTECTS_DATA(sata_mutex, sata_hba_list))
567 _NOTE(DATA_READABLE_WITHOUT_LOCK(sata_hba_list))
568 _NOTE(MUTEX_PROTECTS_DATA(sata_mutex, sata_hba_inst::satahba_next))
569 _NOTE(MUTEX_PROTECTS_DATA(sata_mutex, sata_hba_inst::satahba_prev))
570 _NOTE(SCHEME_PROTECTS_DATA("No Mutex Needed", \
571     sata_hba_inst::satahba_scsi_tran))
572 _NOTE(SCHEME_PROTECTS_DATA("No Mutex Needed", sata_hba_inst::satahba_tran))
573 _NOTE(SCHEME_PROTECTS_DATA("No Mutex Needed", sata_hba_inst::satahba_dip))
574 _NOTE(SCHEME_PROTECTS_DATA("Scheme", sata_hba_inst::satahba_attached))
575 _NOTE(DATA_READABLE_WITHOUT_LOCK(sata_hba_inst::satahba_dev_port))
576 _NOTE(MUTEX_PROTECTS_DATA(sata_hba_inst::satahba_mutex,
577     sata_hba_inst::satahba_event_flags))
578 _NOTE(MUTEX_PROTECTS_DATA(sata_cport_info::cport_mutex, \
579     sata_cport_info::cport_devp))
580 _NOTE(DATA_READABLE_WITHOUT_LOCK(sata_cport_info::cport_devp))
581 _NOTE(SCHEME_PROTECTS_DATA("Scheme", sata_cport_info::cport_addr))
582 _NOTE(MUTEX_PROTECTS_DATA(sata_cport_info::cport_mutex, \
583     sata_cport_info::cport_dev_type))
584 _NOTE(DATA_READABLE_WITHOUT_LOCK(sata_cport_info::cport_dev_type))
585 _NOTE(MUTEX_PROTECTS_DATA(sata_cport_info::cport_mutex, \
586     sata_cport_info::cport_state))
587 _NOTE(DATA_READABLE_WITHOUT_LOCK(sata_cport_info::cport_state))
588 _NOTE(MUTEX_PROTECTS_DATA(sata_pmport_info::pmport_mutex, \
589     sata_pmport_info::pmport_state))
590 _NOTE(DATA_READABLE_WITHOUT_LOCK(sata_pmport_info::pmport_state))
591 _NOTE(MUTEX_PROTECTS_DATA(sata_pmport_info::pmport_mutex, \
592     sata_pmport_info::pmport_dev_type))
593 _NOTE(DATA_READABLE_WITHOUT_LOCK(sata_pmport_info::pmport_dev_type))
594 _NOTE(MUTEX_PROTECTS_DATA(sata_pmport_info::pmport_mutex, \
595     sata_pmport_info::pmport_sata_drive))
596 _NOTE(MUTEX_PROTECTS_DATA(sata_pmport_info::pmport_mutex, \
597     sata_pmport_info::pmport_tgtnode_clean))
598 _NOTE(MUTEX_PROTECTS_DATA(sata_pmport_info::pmport_mutex, \
599     sata_pmport_info::pmport_event_flags))
600 _NOTE(DATA_READABLE_WITHOUT_LOCK(sata_pmport_info::pmport_sata_drive))
601 _NOTE(DATA_READABLE_WITHOUT_LOCK(sata_pmult_info::pmult_dev_port))
602 _NOTE(DATA_READABLE_WITHOUT_LOCK(sata_pmult_info::pmult_num_dev_ports))
603 #ifdef SATA_DEBUG
604 _NOTE(SCHEME_PROTECTS_DATA("No Mutex Needed", mbuf_count))
605 _NOTE(SCHEME_PROTECTS_DATA("No Mutex Needed", mbuffail_count))
606 _NOTE(SCHEME_PROTECTS_DATA("No Mutex Needed", sata_atapi_trace))
607 _NOTE(SCHEME_PROTECTS_DATA("No Mutex Needed", sata_atapi_trace_index))
608 #endif
609 
610 /* End of warlock directives */
611 
612 /* ************** loadable module configuration functions ************** */
613 
614 int
615 _init()
616 {
617 	int rval;
618 
619 	mutex_init(&sata_mutex, NULL, MUTEX_DRIVER, NULL);
620 	mutex_init(&sata_event_mutex, NULL, MUTEX_DRIVER, NULL);
621 	mutex_init(&sata_log_mutex, NULL, MUTEX_DRIVER, NULL);
622 	cv_init(&sata_event_cv, NULL, CV_DRIVER, NULL);
623 	sata_trace_rbuf_alloc();
624 	if ((rval = mod_install(&modlinkage)) != 0) {
625 #ifdef SATA_DEBUG
626 		cmn_err(CE_WARN, "sata: _init: mod_install failed\n");
627 #endif
628 		sata_trace_rbuf_free();
629 		mutex_destroy(&sata_log_mutex);
630 		cv_destroy(&sata_event_cv);
631 		mutex_destroy(&sata_event_mutex);
632 		mutex_destroy(&sata_mutex);
633 	}
634 	return (rval);
635 }
636 
637 int
638 _fini()
639 {
640 	int rval;
641 
642 	if ((rval = mod_remove(&modlinkage)) != 0)
643 		return (rval);
644 
645 	sata_trace_rbuf_free();
646 	mutex_destroy(&sata_log_mutex);
647 	cv_destroy(&sata_event_cv);
648 	mutex_destroy(&sata_event_mutex);
649 	mutex_destroy(&sata_mutex);
650 	return (rval);
651 }
652 
653 int
654 _info(struct modinfo *modinfop)
655 {
656 	return (mod_info(&modlinkage, modinfop));
657 }
658 
659 
660 
661 /* ********************* SATA HBA entry points ********************* */
662 
663 
664 /*
665  * Called by SATA HBA from _init().
666  * Registers HBA driver instance/sata framework pair with scsi framework, by
667  * calling scsi_hba_init().
668  *
669  * SATA HBA driver cb_ops are ignored - SATA HBA framework cb_ops are used
670  * instead. SATA HBA framework cb_ops pointer overwrites SATA HBA driver
671  * cb_ops pointer in SATA HBA driver dev_ops structure.
672  * SATA HBA framework cb_ops supplies cb_open cb_close and cb_ioctl vectors.
673  *
674  * Return status of the scsi_hba_init() is returned to a calling SATA HBA
675  * driver.
676  */
677 int
678 sata_hba_init(struct modlinkage *modlp)
679 {
680 	int rval;
681 	struct dev_ops *hba_ops;
682 
683 	SATADBG1(SATA_DBG_HBA_IF, NULL,
684 	    "sata_hba_init: name %s \n",
685 	    ((struct modldrv *)(modlp->ml_linkage[0]))->drv_linkinfo);
686 	/*
687 	 * Fill-up cb_ops and dev_ops when necessary
688 	 */
689 	hba_ops = ((struct modldrv *)(modlp->ml_linkage[0]))->drv_dev_ops;
690 	/*
691 	 * Provide pointer to SATA dev_ops
692 	 */
693 	hba_ops->devo_cb_ops = &sata_cb_ops;
694 
695 	/*
696 	 * Register SATA HBA with SCSI framework
697 	 */
698 	if ((rval = scsi_hba_init(modlp)) != 0) {
699 		SATADBG1(SATA_DBG_HBA_IF, NULL,
700 		    "sata_hba_init: scsi hba init failed\n", NULL);
701 		return (rval);
702 	}
703 
704 	return (0);
705 }
706 
707 
708 /* HBA attach stages */
709 #define	HBA_ATTACH_STAGE_SATA_HBA_INST	1
710 #define	HBA_ATTACH_STAGE_SCSI_ATTACHED	2
711 #define	HBA_ATTACH_STAGE_SETUP		4
712 #define	HBA_ATTACH_STAGE_LINKED		8
713 
714 
715 /*
716  *
717  * Called from SATA HBA driver's attach routine to attach an instance of
718  * the HBA.
719  *
720  * For DDI_ATTACH command:
721  * sata_hba_inst structure is allocated here and initialized with pointers to
722  * SATA framework implementation of required scsi tran functions.
723  * The scsi_tran's tran_hba_private field is used by SATA Framework to point
724  * to the soft structure (sata_hba_inst) allocated by SATA framework for
725  * SATA HBA instance related data.
726  * The scsi_tran's tran_hba_private field is used by SATA framework to
727  * store a pointer to per-HBA-instance of sata_hba_inst structure.
728  * The sata_hba_inst structure is cross-linked to scsi tran structure.
729  * Among other info, a pointer to sata_hba_tran structure is stored in
730  * sata_hba_inst. The sata_hba_inst structures for different HBA instances are
731  * linked together into the list, pointed to by sata_hba_list.
732  * On the first HBA instance attach the sata event thread is initialized.
733  * Attachment points are created for all SATA ports of the HBA being attached.
734  * All HBA instance's SATA ports are probed and type of plugged devices is
735  * determined. For each device of a supported type, a target node is created.
736  *
737  * DDI_SUCCESS is returned when attachment process is successful,
738  * DDI_FAILURE is returned otherwise.
739  *
740  * For DDI_RESUME command:
741  * Not implemented at this time (postponed until phase 2 of the development).
742  */
743 int
744 sata_hba_attach(dev_info_t *dip, sata_hba_tran_t *sata_tran,
745     ddi_attach_cmd_t cmd)
746 {
747 	sata_hba_inst_t	*sata_hba_inst;
748 	scsi_hba_tran_t *scsi_tran = NULL;
749 	int hba_attach_state = 0;
750 	char taskq_name[MAXPATHLEN];
751 
752 	SATADBG3(SATA_DBG_HBA_IF, NULL,
753 	    "sata_hba_attach: node %s (%s%d)\n",
754 	    ddi_node_name(dip), ddi_driver_name(dip),
755 	    ddi_get_instance(dip));
756 
757 	if (cmd == DDI_RESUME) {
758 		/*
759 		 * Postponed until phase 2 of the development
760 		 */
761 		return (DDI_FAILURE);
762 	}
763 
764 	if (cmd != DDI_ATTACH) {
765 		return (DDI_FAILURE);
766 	}
767 
768 	/* cmd == DDI_ATTACH */
769 
770 	if (sata_validate_sata_hba_tran(dip, sata_tran) != SATA_SUCCESS) {
771 		SATA_LOG_D((NULL, CE_WARN,
772 		    "sata_hba_attach: invalid sata_hba_tran"));
773 		return (DDI_FAILURE);
774 	}
775 	/*
776 	 * Allocate and initialize SCSI tran structure.
777 	 * SATA copy of tran_bus_config is provided to create port nodes.
778 	 */
779 	scsi_tran = scsi_hba_tran_alloc(dip, SCSI_HBA_CANSLEEP);
780 	if (scsi_tran == NULL)
781 		return (DDI_FAILURE);
782 	/*
783 	 * Allocate soft structure for SATA HBA instance.
784 	 * There is a separate softstate for each HBA instance.
785 	 */
786 	sata_hba_inst = kmem_zalloc(sizeof (struct sata_hba_inst), KM_SLEEP);
787 	ASSERT(sata_hba_inst != NULL); /* this should not fail */
788 	mutex_init(&sata_hba_inst->satahba_mutex, NULL, MUTEX_DRIVER, NULL);
789 	hba_attach_state |= HBA_ATTACH_STAGE_SATA_HBA_INST;
790 
791 	/*
792 	 * scsi_trans's tran_hba_private is used by SATA Framework to point to
793 	 * soft structure allocated by SATA framework for
794 	 * SATA HBA instance related data.
795 	 */
796 	scsi_tran->tran_hba_private	= sata_hba_inst;
797 	scsi_tran->tran_tgt_private	= NULL;
798 
799 	scsi_tran->tran_tgt_init	= sata_scsi_tgt_init;
800 	scsi_tran->tran_tgt_probe	= sata_scsi_tgt_probe;
801 	scsi_tran->tran_tgt_free	= sata_scsi_tgt_free;
802 
803 	scsi_tran->tran_start		= sata_scsi_start;
804 	scsi_tran->tran_reset		= sata_scsi_reset;
805 	scsi_tran->tran_abort		= sata_scsi_abort;
806 	scsi_tran->tran_getcap		= sata_scsi_getcap;
807 	scsi_tran->tran_setcap		= sata_scsi_setcap;
808 	scsi_tran->tran_init_pkt	= sata_scsi_init_pkt;
809 	scsi_tran->tran_destroy_pkt	= sata_scsi_destroy_pkt;
810 
811 	scsi_tran->tran_dmafree		= sata_scsi_dmafree;
812 	scsi_tran->tran_sync_pkt	= sata_scsi_sync_pkt;
813 
814 	scsi_tran->tran_reset_notify	= NULL;
815 	scsi_tran->tran_get_bus_addr	= NULL;
816 	scsi_tran->tran_quiesce		= NULL;
817 	scsi_tran->tran_unquiesce	= NULL;
818 	scsi_tran->tran_bus_reset	= NULL;
819 
820 	if (scsi_hba_attach_setup(dip, sata_tran->sata_tran_hba_dma_attr,
821 	    scsi_tran, 0) != DDI_SUCCESS) {
822 #ifdef SATA_DEBUG
823 		cmn_err(CE_WARN, "?SATA: %s%d hba scsi attach failed",
824 		    ddi_driver_name(dip), ddi_get_instance(dip));
825 #endif
826 		goto fail;
827 	}
828 	hba_attach_state |= HBA_ATTACH_STAGE_SCSI_ATTACHED;
829 
830 	if (!ddi_prop_exists(DDI_DEV_T_ANY, dip, DDI_PROP_DONTPASS, "sata")) {
831 		if (ddi_prop_update_int(DDI_DEV_T_NONE, dip,
832 		    "sata", 1) != DDI_PROP_SUCCESS) {
833 			SATA_LOG_D((NULL, CE_WARN, "sata_hba_attach: "
834 			    "failed to create hba sata prop"));
835 			goto fail;
836 		}
837 	}
838 
839 	/*
840 	 * Save pointers in hba instance soft state.
841 	 */
842 	sata_hba_inst->satahba_scsi_tran = scsi_tran;
843 	sata_hba_inst->satahba_tran = sata_tran;
844 	sata_hba_inst->satahba_dip = dip;
845 
846 	/*
847 	 * Create a task queue to handle emulated commands completion
848 	 * Use node name, dash, instance number as the queue name.
849 	 */
850 	taskq_name[0] = '\0';
851 	(void) strlcat(taskq_name, DEVI(dip)->devi_node_name,
852 	    sizeof (taskq_name));
853 	(void) snprintf(taskq_name + strlen(taskq_name),
854 	    sizeof (taskq_name) - strlen(taskq_name),
855 	    "-%d", DEVI(dip)->devi_instance);
856 	sata_hba_inst->satahba_taskq = taskq_create(taskq_name, 1,
857 	    minclsyspri, 1, sata_tran->sata_tran_hba_num_cports * 4,
858 	    TASKQ_DYNAMIC);
859 
860 	hba_attach_state |= HBA_ATTACH_STAGE_SETUP;
861 
862 	/*
863 	 * Create events thread if not created yet.
864 	 */
865 	sata_event_thread_control(1);
866 
867 	/*
868 	 * Link this hba instance into the list.
869 	 */
870 	mutex_enter(&sata_mutex);
871 
872 	if (sata_hba_list == NULL) {
873 		/*
874 		 * The first instance of HBA is attached.
875 		 * Set current/active default maximum NCQ/TCQ queue depth for
876 		 * all SATA devices. It is done here and now, to eliminate the
877 		 * possibility of the dynamic, programatic modification of the
878 		 * queue depth via global (and public) sata_max_queue_depth
879 		 * variable (this would require special handling in HBA drivers)
880 		 */
881 		sata_current_max_qdepth = sata_max_queue_depth;
882 		if (sata_current_max_qdepth > 32)
883 			sata_current_max_qdepth = 32;
884 		else if (sata_current_max_qdepth < 1)
885 			sata_current_max_qdepth = 1;
886 	}
887 
888 	sata_hba_inst->satahba_next = NULL;
889 	sata_hba_inst->satahba_prev = sata_hba_list_tail;
890 	if (sata_hba_list == NULL) {
891 		sata_hba_list = sata_hba_inst;
892 	}
893 	if (sata_hba_list_tail != NULL) {
894 		sata_hba_list_tail->satahba_next = sata_hba_inst;
895 	}
896 	sata_hba_list_tail = sata_hba_inst;
897 	mutex_exit(&sata_mutex);
898 	hba_attach_state |= HBA_ATTACH_STAGE_LINKED;
899 
900 	/*
901 	 * Create SATA HBA devctl minor node for sata_hba_open, close, ioctl
902 	 * SATA HBA driver should not use its own open/close entry points.
903 	 *
904 	 * Make sure that instance number doesn't overflow
905 	 * when forming minor numbers.
906 	 */
907 	ASSERT(ddi_get_instance(dip) <= (L_MAXMIN >> INST_MINOR_SHIFT));
908 	if (ddi_create_minor_node(dip, "devctl", S_IFCHR,
909 	    INST2DEVCTL(ddi_get_instance(dip)),
910 	    DDI_NT_SATA_NEXUS, 0) != DDI_SUCCESS) {
911 #ifdef SATA_DEBUG
912 		cmn_err(CE_WARN, "sata_hba_attach: "
913 		    "cannot create devctl minor node");
914 #endif
915 		goto fail;
916 	}
917 
918 
919 	/*
920 	 * Set-up kstats here, if necessary.
921 	 * (postponed until future phase of the development).
922 	 */
923 
924 	/*
925 	 * Indicate that HBA is attached. This will enable events processing
926 	 * for this HBA.
927 	 */
928 	sata_hba_inst->satahba_attached = 1;
929 	/*
930 	 * Probe controller ports. This operation will describe a current
931 	 * controller/port/multipliers/device configuration and will create
932 	 * attachment points.
933 	 * We may end-up with just a controller with no devices attached.
934 	 * For the ports with a supported device attached, device target nodes
935 	 * are created and devices are initialized.
936 	 */
937 	sata_probe_ports(sata_hba_inst);
938 
939 	return (DDI_SUCCESS);
940 
941 fail:
942 	if (hba_attach_state & HBA_ATTACH_STAGE_LINKED) {
943 		(void) sata_remove_hba_instance(dip);
944 		if (sata_hba_list == NULL)
945 			sata_event_thread_control(0);
946 	}
947 
948 	if (hba_attach_state & HBA_ATTACH_STAGE_SETUP) {
949 		(void) ddi_prop_remove(DDI_DEV_T_ANY, dip, "sata");
950 		taskq_destroy(sata_hba_inst->satahba_taskq);
951 	}
952 
953 	if (hba_attach_state & HBA_ATTACH_STAGE_SCSI_ATTACHED)
954 		(void) scsi_hba_detach(dip);
955 
956 	if (hba_attach_state & HBA_ATTACH_STAGE_SATA_HBA_INST) {
957 		mutex_destroy(&sata_hba_inst->satahba_mutex);
958 		kmem_free((void *)sata_hba_inst,
959 		    sizeof (struct sata_hba_inst));
960 		scsi_hba_tran_free(scsi_tran);
961 	}
962 
963 	sata_log(NULL, CE_WARN, "?SATA: %s%d hba attach failed",
964 	    ddi_driver_name(dip), ddi_get_instance(dip));
965 
966 	return (DDI_FAILURE);
967 }
968 
969 
970 /*
971  * Called by SATA HBA from to detach an instance of the driver.
972  *
973  * For DDI_DETACH command:
974  * Free local structures allocated for SATA HBA instance during
975  * sata_hba_attach processing.
976  *
977  * Returns DDI_SUCCESS when HBA was detached, DDI_FAILURE otherwise.
978  *
979  * For DDI_SUSPEND command:
980  * Not implemented at this time (postponed until phase 2 of the development)
981  * Returnd DDI_SUCCESS.
982  *
983  * When the last HBA instance is detached, the event daemon is terminated.
984  *
985  * NOTE: Port multiplier is supported.
986  */
987 int
988 sata_hba_detach(dev_info_t *dip, ddi_detach_cmd_t cmd)
989 {
990 	dev_info_t	*tdip;
991 	sata_hba_inst_t	*sata_hba_inst;
992 	scsi_hba_tran_t *scsi_hba_tran;
993 	sata_cport_info_t *cportinfo;
994 	sata_pmult_info_t *pminfo;
995 	sata_drive_info_t *sdinfo;
996 	sata_device_t	sdevice;
997 	int ncport, npmport;
998 
999 	SATADBG3(SATA_DBG_HBA_IF, NULL, "sata_hba_detach: node %s (%s%d)\n",
1000 	    ddi_node_name(dip), ddi_driver_name(dip), ddi_get_instance(dip));
1001 
1002 	switch (cmd) {
1003 	case DDI_DETACH:
1004 
1005 		if ((scsi_hba_tran = ddi_get_driver_private(dip)) == NULL)
1006 			return (DDI_FAILURE);
1007 
1008 		sata_hba_inst = scsi_hba_tran->tran_hba_private;
1009 		if (sata_hba_inst == NULL)
1010 			return (DDI_FAILURE);
1011 
1012 		if (scsi_hba_detach(dip) == DDI_FAILURE) {
1013 			sata_hba_inst->satahba_attached = 1;
1014 			return (DDI_FAILURE);
1015 		}
1016 
1017 		/*
1018 		 * Free all target nodes - at this point
1019 		 * devices should be at least offlined
1020 		 * otherwise scsi_hba_detach() should not be called.
1021 		 */
1022 		for (ncport = 0; ncport < SATA_NUM_CPORTS(sata_hba_inst);
1023 		    ncport++) {
1024 			cportinfo = SATA_CPORT_INFO(sata_hba_inst, ncport);
1025 			if (cportinfo->cport_dev_type != SATA_DTYPE_PMULT) {
1026 				sdinfo = SATA_CPORTINFO_DRV_INFO(cportinfo);
1027 				if (sdinfo != NULL) {
1028 					tdip = sata_get_target_dip(dip,
1029 					    ncport, 0);
1030 					if (tdip != NULL) {
1031 						if (ndi_devi_offline(tdip,
1032 						    NDI_DEVI_REMOVE) !=
1033 						    NDI_SUCCESS) {
1034 							SATA_LOG_D((
1035 							    sata_hba_inst,
1036 							    CE_WARN,
1037 							    "sata_hba_detach: "
1038 							    "Target node not "
1039 							    "removed !"));
1040 							return (DDI_FAILURE);
1041 						}
1042 					}
1043 				}
1044 			} else { /* SATA_DTYPE_PMULT */
1045 				mutex_enter(&cportinfo->cport_mutex);
1046 				pminfo = SATA_CPORTINFO_PMULT_INFO(cportinfo);
1047 
1048 				if (pminfo == NULL) {
1049 					SATA_LOG_D((sata_hba_inst, CE_WARN,
1050 					    "sata_hba_detach: Port multiplier "
1051 					    "not ready yet!"));
1052 					mutex_exit(&cportinfo->cport_mutex);
1053 					return (DDI_FAILURE);
1054 				}
1055 
1056 				/*
1057 				 * Detach would fail if removal of any of the
1058 				 * target nodes is failed - albeit in that
1059 				 * case some of them may have been removed.
1060 				 */
1061 				for (npmport = 0; npmport < SATA_NUM_PMPORTS(
1062 				    sata_hba_inst, ncport); npmport++) {
1063 					tdip = sata_get_target_dip(dip, ncport,
1064 					    npmport);
1065 					if (tdip != NULL) {
1066 						if (ndi_devi_offline(tdip,
1067 						    NDI_DEVI_REMOVE) !=
1068 						    NDI_SUCCESS) {
1069 							SATA_LOG_D((
1070 							    sata_hba_inst,
1071 							    CE_WARN,
1072 							    "sata_hba_detach: "
1073 							    "Target node not "
1074 							    "removed !"));
1075 							mutex_exit(&cportinfo->
1076 							    cport_mutex);
1077 							return (DDI_FAILURE);
1078 						}
1079 					}
1080 				}
1081 				mutex_exit(&cportinfo->cport_mutex);
1082 			}
1083 		}
1084 		/*
1085 		 * Disable sata event daemon processing for this HBA
1086 		 */
1087 		sata_hba_inst->satahba_attached = 0;
1088 
1089 		/*
1090 		 * Remove event daemon thread, if it is last HBA instance.
1091 		 */
1092 
1093 		mutex_enter(&sata_mutex);
1094 		if (sata_hba_list->satahba_next == NULL) {
1095 			mutex_exit(&sata_mutex);
1096 			sata_event_thread_control(0);
1097 			mutex_enter(&sata_mutex);
1098 		}
1099 		mutex_exit(&sata_mutex);
1100 
1101 		/* Remove this HBA instance from the HBA list */
1102 		sata_remove_hba_instance(dip);
1103 
1104 		/*
1105 		 * At this point there should be no target nodes attached.
1106 		 * Detach and destroy device and port info structures.
1107 		 */
1108 		for (ncport = 0; ncport < SATA_NUM_CPORTS(sata_hba_inst);
1109 		    ncport++) {
1110 			cportinfo = SATA_CPORT_INFO(sata_hba_inst, ncport);
1111 			if (cportinfo->cport_dev_type != SATA_DTYPE_PMULT) {
1112 				sdinfo =
1113 				    cportinfo->cport_devp.cport_sata_drive;
1114 				if (sdinfo != NULL) {
1115 					/* Release device structure */
1116 					kmem_free(sdinfo,
1117 					    sizeof (sata_drive_info_t));
1118 				}
1119 				/* Release cport info */
1120 				mutex_destroy(&cportinfo->cport_mutex);
1121 				kmem_free(cportinfo,
1122 				    sizeof (sata_cport_info_t));
1123 			} else { /* SATA_DTYPE_PMULT */
1124 				sdevice.satadev_addr.cport = (uint8_t)ncport;
1125 				sdevice.satadev_addr.qual = SATA_ADDR_PMULT;
1126 				sata_free_pmult(sata_hba_inst, &sdevice);
1127 			}
1128 		}
1129 
1130 		scsi_hba_tran_free(sata_hba_inst->satahba_scsi_tran);
1131 
1132 		(void) ddi_prop_remove(DDI_DEV_T_ANY, dip, "sata");
1133 
1134 		taskq_destroy(sata_hba_inst->satahba_taskq);
1135 
1136 		mutex_destroy(&sata_hba_inst->satahba_mutex);
1137 		kmem_free((void *)sata_hba_inst,
1138 		    sizeof (struct sata_hba_inst));
1139 
1140 		return (DDI_SUCCESS);
1141 
1142 	case DDI_SUSPEND:
1143 		/*
1144 		 * Postponed until phase 2
1145 		 */
1146 		return (DDI_FAILURE);
1147 
1148 	default:
1149 		return (DDI_FAILURE);
1150 	}
1151 }
1152 
1153 
1154 /*
1155  * Called by an HBA drive from _fini() routine.
1156  * Unregisters SATA HBA instance/SATA framework pair from the scsi framework.
1157  */
1158 void
1159 sata_hba_fini(struct modlinkage *modlp)
1160 {
1161 	SATADBG1(SATA_DBG_HBA_IF, NULL,
1162 	    "sata_hba_fini: name %s\n",
1163 	    ((struct modldrv *)(modlp->ml_linkage[0]))->drv_linkinfo);
1164 
1165 	scsi_hba_fini(modlp);
1166 }
1167 
1168 
1169 /*
1170  * Default open and close routine for sata_hba framework.
1171  *
1172  */
1173 /*
1174  * Open devctl node.
1175  *
1176  * Returns:
1177  * 0 if node was open successfully, error code otherwise.
1178  *
1179  *
1180  */
1181 
1182 static int
1183 sata_hba_open(dev_t *devp, int flags, int otyp, cred_t *credp)
1184 {
1185 #ifndef __lock_lint
1186 	_NOTE(ARGUNUSED(credp))
1187 #endif
1188 	int rv = 0;
1189 	dev_info_t *dip;
1190 	scsi_hba_tran_t *scsi_hba_tran;
1191 	sata_hba_inst_t	*sata_hba_inst;
1192 
1193 	SATADBG1(SATA_DBG_IOCTL_IF, NULL, "sata_hba_open: entered", NULL);
1194 
1195 	if (otyp != OTYP_CHR)
1196 		return (EINVAL);
1197 
1198 	dip = sata_devt_to_devinfo(*devp);
1199 	if (dip == NULL)
1200 		return (ENXIO);
1201 
1202 	if ((scsi_hba_tran = ddi_get_driver_private(dip)) == NULL)
1203 		return (ENXIO);
1204 
1205 	sata_hba_inst = scsi_hba_tran->tran_hba_private;
1206 	if (sata_hba_inst == NULL || sata_hba_inst->satahba_attached == 0)
1207 		return (ENXIO);
1208 
1209 	mutex_enter(&sata_mutex);
1210 	if (flags & FEXCL) {
1211 		if (sata_hba_inst->satahba_open_flag != 0) {
1212 			rv = EBUSY;
1213 		} else {
1214 			sata_hba_inst->satahba_open_flag =
1215 			    SATA_DEVCTL_EXOPENED;
1216 		}
1217 	} else {
1218 		if (sata_hba_inst->satahba_open_flag == SATA_DEVCTL_EXOPENED) {
1219 			rv = EBUSY;
1220 		} else {
1221 			sata_hba_inst->satahba_open_flag =
1222 			    SATA_DEVCTL_SOPENED;
1223 		}
1224 	}
1225 	mutex_exit(&sata_mutex);
1226 
1227 	return (rv);
1228 }
1229 
1230 
1231 /*
1232  * Close devctl node.
1233  * Returns:
1234  * 0 if node was closed successfully, error code otherwise.
1235  *
1236  */
1237 
1238 static int
1239 sata_hba_close(dev_t dev, int flag, int otyp, cred_t *credp)
1240 {
1241 #ifndef __lock_lint
1242 	_NOTE(ARGUNUSED(credp))
1243 	_NOTE(ARGUNUSED(flag))
1244 #endif
1245 	dev_info_t *dip;
1246 	scsi_hba_tran_t *scsi_hba_tran;
1247 	sata_hba_inst_t	*sata_hba_inst;
1248 
1249 	SATADBG1(SATA_DBG_IOCTL_IF, NULL, "sata_hba_close: entered", NULL);
1250 
1251 	if (otyp != OTYP_CHR)
1252 		return (EINVAL);
1253 
1254 	dip = sata_devt_to_devinfo(dev);
1255 	if (dip == NULL)
1256 		return (ENXIO);
1257 
1258 	if ((scsi_hba_tran = ddi_get_driver_private(dip)) == NULL)
1259 		return (ENXIO);
1260 
1261 	sata_hba_inst = scsi_hba_tran->tran_hba_private;
1262 	if (sata_hba_inst == NULL || sata_hba_inst->satahba_attached == 0)
1263 		return (ENXIO);
1264 
1265 	mutex_enter(&sata_mutex);
1266 	sata_hba_inst->satahba_open_flag = 0;
1267 	mutex_exit(&sata_mutex);
1268 	return (0);
1269 }
1270 
1271 
1272 
1273 /*
1274  * Standard IOCTL commands for SATA hotplugging.
1275  * Implemented DEVCTL_AP commands:
1276  * DEVCTL_AP_CONNECT
1277  * DEVCTL_AP_DISCONNECT
1278  * DEVCTL_AP_CONFIGURE
1279  * DEVCTL_UNCONFIGURE
1280  * DEVCTL_AP_CONTROL
1281  *
1282  * Commands passed to default ndi ioctl handler:
1283  * DEVCTL_DEVICE_GETSTATE
1284  * DEVCTL_DEVICE_ONLINE
1285  * DEVCTL_DEVICE_OFFLINE
1286  * DEVCTL_DEVICE_REMOVE
1287  * DEVCTL_DEVICE_INSERT
1288  * DEVCTL_BUS_GETSTATE
1289  *
1290  * All other cmds are passed to HBA if it provide ioctl handler, or failed
1291  * if not.
1292  *
1293  * Returns:
1294  * 0 if successful,
1295  * error code if operation failed.
1296  *
1297  * Port Multiplier support is supported now.
1298  *
1299  * NOTE: qual should be SATA_ADDR_DCPORT or SATA_ADDR_DPMPORT
1300  */
1301 
1302 static int
1303 sata_hba_ioctl(dev_t dev, int cmd, intptr_t arg, int mode, cred_t *credp,
1304     int *rvalp)
1305 {
1306 #ifndef __lock_lint
1307 	_NOTE(ARGUNUSED(credp))
1308 	_NOTE(ARGUNUSED(rvalp))
1309 #endif
1310 	int rv = 0;
1311 	int32_t	comp_port = -1;
1312 	dev_info_t *dip;
1313 	devctl_ap_state_t ap_state;
1314 	struct devctl_iocdata *dcp = NULL;
1315 	scsi_hba_tran_t *scsi_hba_tran;
1316 	sata_hba_inst_t *sata_hba_inst;
1317 	sata_device_t sata_device;
1318 	sata_cport_info_t *cportinfo;
1319 	int cport, pmport, qual;
1320 	int rval = SATA_SUCCESS;
1321 
1322 	dip = sata_devt_to_devinfo(dev);
1323 	if (dip == NULL)
1324 		return (ENXIO);
1325 
1326 	if ((scsi_hba_tran = ddi_get_driver_private(dip)) == NULL)
1327 		return (ENXIO);
1328 
1329 	sata_hba_inst = scsi_hba_tran->tran_hba_private;
1330 	if (sata_hba_inst == NULL)
1331 		return (ENXIO);
1332 
1333 	if (sata_hba_inst->satahba_tran == NULL)
1334 		return (ENXIO);
1335 
1336 	switch (cmd) {
1337 
1338 	case DEVCTL_DEVICE_GETSTATE:
1339 	case DEVCTL_DEVICE_ONLINE:
1340 	case DEVCTL_DEVICE_OFFLINE:
1341 	case DEVCTL_DEVICE_REMOVE:
1342 	case DEVCTL_BUS_GETSTATE:
1343 		/*
1344 		 * There may be more cases that we want to pass to default
1345 		 * handler rather than fail them.
1346 		 */
1347 		return (ndi_devctl_ioctl(dip, cmd, arg, mode, 0));
1348 	}
1349 
1350 	/* read devctl ioctl data */
1351 	if (cmd != DEVCTL_AP_CONTROL) {
1352 		if (ndi_dc_allochdl((void *)arg, &dcp) != NDI_SUCCESS)
1353 			return (EFAULT);
1354 
1355 		if ((comp_port = sata_get_port_num(sata_hba_inst, dcp)) ==
1356 		    -1) {
1357 			if (dcp)
1358 				ndi_dc_freehdl(dcp);
1359 			return (EINVAL);
1360 		}
1361 
1362 		/*
1363 		 * According to SCSI_TO_SATA_ADDR_QUAL, qual should be either
1364 		 * SATA_ADDR_DCPORT or SATA_ADDR_DPMPORT.
1365 		 */
1366 		cport = SCSI_TO_SATA_CPORT(comp_port);
1367 		pmport = SCSI_TO_SATA_PMPORT(comp_port);
1368 		qual = SCSI_TO_SATA_ADDR_QUAL(comp_port);
1369 
1370 		if (sata_validate_sata_address(sata_hba_inst, cport, pmport,
1371 		    qual) != 0) {
1372 			ndi_dc_freehdl(dcp);
1373 			return (EINVAL);
1374 		}
1375 
1376 		cportinfo = SATA_CPORT_INFO(sata_hba_inst, cport);
1377 		mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, cport)->
1378 		    cport_mutex);
1379 		if (cportinfo->cport_event_flags & SATA_EVNT_LOCK_PORT_BUSY) {
1380 			/*
1381 			 * Cannot process ioctl request now. Come back later.
1382 			 */
1383 			mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)->
1384 			    cport_mutex);
1385 			ndi_dc_freehdl(dcp);
1386 			return (EBUSY);
1387 		}
1388 		/* Block event processing for this port */
1389 		cportinfo->cport_event_flags |= SATA_APCTL_LOCK_PORT_BUSY;
1390 		mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex);
1391 
1392 		sata_device.satadev_addr.cport = cport;
1393 		sata_device.satadev_addr.pmport = pmport;
1394 		sata_device.satadev_addr.qual = qual;
1395 		sata_device.satadev_rev = SATA_DEVICE_REV;
1396 	}
1397 
1398 	switch (cmd) {
1399 
1400 	case DEVCTL_AP_DISCONNECT:
1401 
1402 		/*
1403 		 * Normally, cfgadm sata plugin will try to offline
1404 		 * (unconfigure) device before this request. Nevertheless,
1405 		 * if a device is still configured, we need to
1406 		 * attempt to offline and unconfigure device first, and we will
1407 		 * deactivate the port regardless of the unconfigure
1408 		 * operation results.
1409 		 *
1410 		 */
1411 		rv = sata_ioctl_disconnect(sata_hba_inst, &sata_device);
1412 
1413 		break;
1414 
1415 	case DEVCTL_AP_UNCONFIGURE:
1416 
1417 		/*
1418 		 * The unconfigure operation uses generic nexus operation to
1419 		 * offline a device. It leaves a target device node attached.
1420 		 * and obviously sata_drive_info attached as well, because
1421 		 * from the hardware point of view nothing has changed.
1422 		 */
1423 		rv = sata_ioctl_unconfigure(sata_hba_inst, &sata_device);
1424 		break;
1425 
1426 	case DEVCTL_AP_CONNECT:
1427 	{
1428 		/*
1429 		 * The sata cfgadm pluging will invoke this operation only if
1430 		 * port was found in the disconnect state (failed state
1431 		 * is also treated as the disconnected state).
1432 		 * If port activation is successful and a device is found
1433 		 * attached to the port, the initialization sequence is
1434 		 * executed to probe the port and attach
1435 		 * a device structure to a port structure. The device is not
1436 		 * set in configured state (system-wise) by this operation.
1437 		 */
1438 
1439 		rv = sata_ioctl_connect(sata_hba_inst, &sata_device);
1440 
1441 		break;
1442 	}
1443 
1444 	case DEVCTL_AP_CONFIGURE:
1445 	{
1446 		/*
1447 		 * A port may be in an active or shutdown state.
1448 		 * If port is in a failed state, operation is aborted.
1449 		 * If a port is in a shutdown state, sata_tran_port_activate()
1450 		 * is invoked prior to any other operation.
1451 		 *
1452 		 * Onlining the device involves creating a new target node.
1453 		 * If there is an old target node present (belonging to
1454 		 * previously removed device), the operation is aborted - the
1455 		 * old node has to be released and removed before configure
1456 		 * operation is attempted.
1457 		 */
1458 
1459 		rv = sata_ioctl_configure(sata_hba_inst, &sata_device);
1460 
1461 		break;
1462 	}
1463 
1464 	case DEVCTL_AP_GETSTATE:
1465 
1466 		sata_cfgadm_state(sata_hba_inst, comp_port, &ap_state);
1467 
1468 		ap_state.ap_last_change = (time_t)-1;
1469 		ap_state.ap_error_code = 0;
1470 		ap_state.ap_in_transition = 0;
1471 
1472 		/* Copy the return AP-state information to the user space */
1473 		if (ndi_dc_return_ap_state(&ap_state, dcp) != NDI_SUCCESS) {
1474 			rv = EFAULT;
1475 		}
1476 		break;
1477 
1478 	case DEVCTL_AP_CONTROL:
1479 	{
1480 		/*
1481 		 * Generic devctl for hardware specific functionality
1482 		 */
1483 		sata_ioctl_data_t	ioc;
1484 
1485 		ASSERT(dcp == NULL);
1486 
1487 		/* Copy in user ioctl data first */
1488 #ifdef _MULTI_DATAMODEL
1489 		if (ddi_model_convert_from(mode & FMODELS) ==
1490 		    DDI_MODEL_ILP32) {
1491 
1492 			sata_ioctl_data_32_t	ioc32;
1493 
1494 			if (ddi_copyin((void *)arg, (void *)&ioc32,
1495 			    sizeof (ioc32), mode) != 0) {
1496 				rv = EFAULT;
1497 				break;
1498 			}
1499 			ioc.cmd 	= (uint_t)ioc32.cmd;
1500 			ioc.port	= (uint_t)ioc32.port;
1501 			ioc.get_size	= (uint_t)ioc32.get_size;
1502 			ioc.buf		= (caddr_t)(uintptr_t)ioc32.buf;
1503 			ioc.bufsiz	= (uint_t)ioc32.bufsiz;
1504 			ioc.misc_arg	= (uint_t)ioc32.misc_arg;
1505 		} else
1506 #endif /* _MULTI_DATAMODEL */
1507 		if (ddi_copyin((void *)arg, (void *)&ioc, sizeof (ioc),
1508 		    mode) != 0) {
1509 			return (EFAULT);
1510 		}
1511 
1512 		SATADBG2(SATA_DBG_IOCTL_IF, sata_hba_inst,
1513 		    "sata_hba_ioctl: DEVCTL_AP_CONTROL "
1514 		    "cmd 0x%x, port 0x%x", ioc.cmd, ioc.port);
1515 
1516 		/*
1517 		 * To avoid BE/LE and 32/64 issues, a get_size always returns
1518 		 * a 32-bit number.
1519 		 */
1520 		if (ioc.get_size != 0 && ioc.bufsiz != (sizeof (uint32_t))) {
1521 			return (EINVAL);
1522 		}
1523 		/* validate address */
1524 		cport = SCSI_TO_SATA_CPORT(ioc.port);
1525 		pmport = SCSI_TO_SATA_PMPORT(ioc.port);
1526 		qual = SCSI_TO_SATA_ADDR_QUAL(ioc.port);
1527 
1528 		SATADBG3(SATA_DBG_IOCTL_IF, sata_hba_inst,
1529 		    "sata_hba_ioctl: target port is %d:%d (%d)",
1530 		    cport, pmport, qual);
1531 
1532 		if (sata_validate_sata_address(sata_hba_inst, cport,
1533 		    pmport, qual) != 0)
1534 			return (EINVAL);
1535 
1536 		cportinfo = SATA_CPORT_INFO(sata_hba_inst, cport);
1537 		mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, cport)->
1538 		    cport_mutex);
1539 		/* Is the port locked by event processing daemon ? */
1540 		if (cportinfo->cport_event_flags & SATA_EVNT_LOCK_PORT_BUSY) {
1541 			/*
1542 			 * Cannot process ioctl request now. Come back later
1543 			 */
1544 			mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)->
1545 			    cport_mutex);
1546 			return (EBUSY);
1547 		}
1548 		/* Block event processing for this port */
1549 		cportinfo->cport_event_flags |= SATA_APCTL_LOCK_PORT_BUSY;
1550 		mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex);
1551 
1552 
1553 		sata_device.satadev_addr.cport = cport;
1554 		sata_device.satadev_addr.pmport = pmport;
1555 		sata_device.satadev_addr.qual = qual;
1556 		sata_device.satadev_rev = SATA_DEVICE_REV;
1557 
1558 		switch (ioc.cmd) {
1559 
1560 		case SATA_CFGA_RESET_PORT:
1561 			/*
1562 			 * There is no protection for configured device.
1563 			 */
1564 			rv = sata_ioctl_reset_port(sata_hba_inst, &sata_device);
1565 			break;
1566 
1567 		case SATA_CFGA_RESET_DEVICE:
1568 			/*
1569 			 * There is no protection for configured device.
1570 			 */
1571 			rv = sata_ioctl_reset_device(sata_hba_inst,
1572 			    &sata_device);
1573 			break;
1574 
1575 		case SATA_CFGA_RESET_ALL:
1576 			/*
1577 			 * There is no protection for configured devices.
1578 			 */
1579 			rv = sata_ioctl_reset_all(sata_hba_inst);
1580 			/*
1581 			 * We return here, because common return is for
1582 			 * a single port operation - we have already unlocked
1583 			 * all ports and no dc handle was allocated.
1584 			 */
1585 			return (rv);
1586 
1587 		case SATA_CFGA_PORT_DEACTIVATE:
1588 			/*
1589 			 * Arbitrarily unconfigure attached device, if any.
1590 			 * Even if the unconfigure fails, proceed with the
1591 			 * port deactivation.
1592 			 */
1593 			rv = sata_ioctl_deactivate(sata_hba_inst, &sata_device);
1594 
1595 			break;
1596 
1597 		case SATA_CFGA_PORT_ACTIVATE:
1598 
1599 			rv = sata_ioctl_activate(sata_hba_inst, &sata_device);
1600 			break;
1601 
1602 		case SATA_CFGA_PORT_SELF_TEST:
1603 
1604 			rv = sata_ioctl_port_self_test(sata_hba_inst,
1605 			    &sata_device);
1606 			break;
1607 
1608 		case SATA_CFGA_GET_DEVICE_PATH:
1609 
1610 			rv = sata_ioctl_get_device_path(sata_hba_inst,
1611 			    &sata_device, &ioc, mode);
1612 			break;
1613 
1614 		case SATA_CFGA_GET_AP_TYPE:
1615 
1616 			rv = sata_ioctl_get_ap_type(sata_hba_inst,
1617 			    &sata_device, &ioc, mode);
1618 			break;
1619 
1620 		case SATA_CFGA_GET_MODEL_INFO:
1621 
1622 			rv = sata_ioctl_get_model_info(sata_hba_inst,
1623 			    &sata_device, &ioc, mode);
1624 			break;
1625 
1626 		case SATA_CFGA_GET_REVFIRMWARE_INFO:
1627 
1628 			rv = sata_ioctl_get_revfirmware_info(sata_hba_inst,
1629 			    &sata_device, &ioc, mode);
1630 			break;
1631 
1632 		case SATA_CFGA_GET_SERIALNUMBER_INFO:
1633 
1634 			rv = sata_ioctl_get_serialnumber_info(sata_hba_inst,
1635 			    &sata_device, &ioc, mode);
1636 			break;
1637 
1638 		default:
1639 			rv = EINVAL;
1640 			break;
1641 
1642 		} /* End of DEVCTL_AP_CONTROL cmd switch */
1643 
1644 		break;
1645 	}
1646 
1647 	default:
1648 	{
1649 		/*
1650 		 * If we got here, we got an IOCTL that SATA HBA Framework
1651 		 * does not recognize. Pass ioctl to HBA driver, in case
1652 		 * it could process it.
1653 		 */
1654 		sata_hba_tran_t *sata_tran = sata_hba_inst->satahba_tran;
1655 		dev_info_t	*mydip = SATA_DIP(sata_hba_inst);
1656 
1657 		SATADBG1(SATA_DBG_IOCTL_IF, sata_hba_inst,
1658 		    "IOCTL 0x%2x not supported in SATA framework, "
1659 		    "passthrough to HBA", cmd);
1660 
1661 		if (sata_tran->sata_tran_ioctl == NULL) {
1662 			rv = EINVAL;
1663 			break;
1664 		}
1665 		rval = (*sata_tran->sata_tran_ioctl)(mydip, cmd, arg);
1666 		if (rval != 0) {
1667 			SATADBG1(SATA_DBG_IOCTL_IF, sata_hba_inst,
1668 			    "IOCTL 0x%2x failed in HBA", cmd);
1669 			rv = rval;
1670 		}
1671 		break;
1672 	}
1673 
1674 	} /* End of main IOCTL switch */
1675 
1676 	if (dcp) {
1677 		ndi_dc_freehdl(dcp);
1678 	}
1679 	mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex);
1680 	cportinfo->cport_event_flags &= ~SATA_APCTL_LOCK_PORT_BUSY;
1681 	mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex);
1682 
1683 	return (rv);
1684 }
1685 
1686 
1687 /*
1688  * Create error retrieval sata packet
1689  *
1690  * A sata packet is allocated and set-up to contain specified error retrieval
1691  * command and appropriate dma-able data buffer.
1692  * No association with any scsi packet is made and no callback routine is
1693  * specified.
1694  *
1695  * Returns a pointer to sata packet upon successful packet creation.
1696  * Returns NULL, if packet cannot be created.
1697  */
1698 sata_pkt_t *
1699 sata_get_error_retrieval_pkt(dev_info_t *dip, sata_device_t *sata_device,
1700     int pkt_type)
1701 {
1702 	sata_hba_inst_t	*sata_hba_inst;
1703 	sata_pkt_txlate_t *spx;
1704 	sata_pkt_t *spkt;
1705 	sata_drive_info_t *sdinfo;
1706 
1707 	mutex_enter(&sata_mutex);
1708 	for (sata_hba_inst = sata_hba_list; sata_hba_inst != NULL;
1709 	    sata_hba_inst = sata_hba_inst->satahba_next) {
1710 		if (SATA_DIP(sata_hba_inst) == dip)
1711 			break;
1712 	}
1713 	mutex_exit(&sata_mutex);
1714 	ASSERT(sata_hba_inst != NULL);
1715 
1716 	sdinfo = sata_get_device_info(sata_hba_inst, sata_device);
1717 	if (sdinfo == NULL) {
1718 		sata_log(sata_hba_inst, CE_WARN,
1719 		    "sata: error recovery request for non-attached device at "
1720 		    "cport %d", sata_device->satadev_addr.cport);
1721 		return (NULL);
1722 	}
1723 
1724 	spx = kmem_zalloc(sizeof (sata_pkt_txlate_t), KM_SLEEP);
1725 	spx->txlt_sata_hba_inst = sata_hba_inst;
1726 	spx->txlt_scsi_pkt = NULL;		/* No scsi pkt involved */
1727 	spkt = sata_pkt_alloc(spx, NULL);
1728 	if (spkt == NULL) {
1729 		kmem_free(spx, sizeof (sata_pkt_txlate_t));
1730 		return (NULL);
1731 	}
1732 	/* address is needed now */
1733 	spkt->satapkt_device.satadev_addr = sata_device->satadev_addr;
1734 
1735 	switch (pkt_type) {
1736 	case SATA_ERR_RETR_PKT_TYPE_NCQ:
1737 		if (sata_ncq_err_ret_cmd_setup(spx, sdinfo) == SATA_SUCCESS) {
1738 			if (sata_check_for_dma_error(dip, spx)) {
1739 				ddi_fm_service_impact(dip,
1740 				    DDI_SERVICE_UNAFFECTED);
1741 				break;
1742 			}
1743 			return (spkt);
1744 		}
1745 		break;
1746 
1747 	case SATA_ERR_RETR_PKT_TYPE_ATAPI:
1748 		if (sata_atapi_err_ret_cmd_setup(spx, sdinfo) == SATA_SUCCESS) {
1749 			if (sata_check_for_dma_error(dip, spx)) {
1750 				ddi_fm_service_impact(dip,
1751 				    DDI_SERVICE_UNAFFECTED);
1752 				break;
1753 			}
1754 			return (spkt);
1755 		}
1756 		break;
1757 
1758 	default:
1759 		break;
1760 	}
1761 
1762 	sata_pkt_free(spx);
1763 	kmem_free(spx, sizeof (sata_pkt_txlate_t));
1764 	return (NULL);
1765 
1766 }
1767 
1768 
1769 /*
1770  * Free error retrieval sata packet
1771  *
1772  * Free sata packet and any associated resources allocated previously by
1773  * sata_get_error_retrieval_pkt().
1774  *
1775  * Void return.
1776  */
1777 void
1778 sata_free_error_retrieval_pkt(sata_pkt_t *sata_pkt)
1779 {
1780 	sata_pkt_txlate_t *spx =
1781 	    (sata_pkt_txlate_t *)sata_pkt->satapkt_framework_private;
1782 
1783 	ASSERT(sata_pkt != NULL);
1784 
1785 	sata_free_local_buffer(spx);
1786 	sata_pkt_free(spx);
1787 	kmem_free(spx, sizeof (sata_pkt_txlate_t));
1788 
1789 }
1790 
1791 /*
1792  * Create READ PORT MULTIPLIER and WRITE PORT MULTIPLIER sata packet
1793  *
1794  * No association with any scsi packet is made and no callback routine is
1795  * specified.
1796  *
1797  * Returns a pointer to sata packet upon successful packet creation.
1798  * Returns NULL, if packet cannot be created.
1799  *
1800  * NOTE: Input/Output value includes 64 bits accoring to SATA Spec 2.6,
1801  * only lower 32 bits are available currently.
1802  */
1803 sata_pkt_t *
1804 sata_get_rdwr_pmult_pkt(dev_info_t *dip, sata_device_t *sd,
1805     uint8_t regn, uint32_t regv, uint32_t type)
1806 {
1807 	sata_hba_inst_t	*sata_hba_inst;
1808 	sata_pkt_txlate_t *spx;
1809 	sata_pkt_t *spkt;
1810 	sata_cmd_t *scmd;
1811 
1812 	/* Only READ/WRITE commands are accepted. */
1813 	ASSERT(type == SATA_RDWR_PMULT_PKT_TYPE_READ ||
1814 	    type == SATA_RDWR_PMULT_PKT_TYPE_WRITE);
1815 
1816 	mutex_enter(&sata_mutex);
1817 	for (sata_hba_inst = sata_hba_list; sata_hba_inst != NULL;
1818 	    sata_hba_inst = sata_hba_inst->satahba_next) {
1819 		if (SATA_DIP(sata_hba_inst) == dip)
1820 			break;
1821 	}
1822 	mutex_exit(&sata_mutex);
1823 	ASSERT(sata_hba_inst != NULL);
1824 
1825 	spx = kmem_zalloc(sizeof (sata_pkt_txlate_t), KM_SLEEP);
1826 	spx->txlt_sata_hba_inst = sata_hba_inst;
1827 	spx->txlt_scsi_pkt = NULL;	/* No scsi pkt involved */
1828 	spkt = sata_pkt_alloc(spx, SLEEP_FUNC);
1829 	if (spkt == NULL) {
1830 		kmem_free(spx, sizeof (sata_pkt_txlate_t));
1831 		return (NULL);
1832 	}
1833 
1834 	/*
1835 	 * NOTE: We need to send this command to the port multiplier,
1836 	 * that means send to SATA_PMULT_HOSTPORT(0xf) pmport
1837 	 *
1838 	 * sata_device contains the address of actual target device, and the
1839 	 * pmport number in the command comes from the sata_device structure.
1840 	 */
1841 	spkt->satapkt_device.satadev_addr = sd->satadev_addr;
1842 	spkt->satapkt_device.satadev_addr.pmport = SATA_PMULT_HOSTPORT;
1843 	spkt->satapkt_device.satadev_addr.qual = SATA_ADDR_PMULT;
1844 
1845 	/* Fill sata_pkt */
1846 	spkt->satapkt_op_mode = SATA_OPMODE_SYNCH | SATA_OPMODE_POLLING;
1847 	spkt->satapkt_comp = NULL; /* Synchronous mode, no callback */
1848 	spkt->satapkt_time = 10; /* Timeout 10s */
1849 
1850 	/* Build READ PORT MULTIPLIER cmd in the sata_pkt */
1851 	scmd = &spkt->satapkt_cmd;
1852 	scmd->satacmd_features_reg = regn & 0xff;
1853 	scmd->satacmd_features_reg_ext = (regn >> 8) & 0xff;
1854 	scmd->satacmd_device_reg = sd->satadev_addr.pmport;
1855 	scmd->satacmd_addr_type = 0;		/* N/A */
1856 
1857 	scmd->satacmd_flags.sata_ignore_dev_reset = B_TRUE;
1858 
1859 	if (type == SATA_RDWR_PMULT_PKT_TYPE_READ) {
1860 		scmd->satacmd_cmd_reg = SATAC_READ_PORTMULT;
1861 		scmd->satacmd_flags.sata_data_direction = SATA_DIR_READ;
1862 		scmd->satacmd_flags.sata_special_regs = 1;
1863 		scmd->satacmd_flags.sata_copy_out_lba_high_lsb = 1;
1864 		scmd->satacmd_flags.sata_copy_out_lba_mid_lsb = 1;
1865 		scmd->satacmd_flags.sata_copy_out_lba_low_lsb = 1;
1866 		scmd->satacmd_flags.sata_copy_out_sec_count_lsb = 1;
1867 	} else if (type == SATA_RDWR_PMULT_PKT_TYPE_WRITE) {
1868 		scmd->satacmd_cmd_reg = SATAC_WRITE_PORTMULT;
1869 		scmd->satacmd_flags.sata_data_direction = SATA_DIR_WRITE;
1870 		scmd->satacmd_sec_count_lsb = regv & 0xff;
1871 		scmd->satacmd_lba_low_lsb = regv >> 8 & 0xff;
1872 		scmd->satacmd_lba_mid_lsb = regv >> 16 & 0xff;
1873 		scmd->satacmd_lba_high_lsb = regv >> 24 & 0xff;
1874 	}
1875 
1876 	return (spkt);
1877 }
1878 
1879 /*
1880  * Free sata packet and any associated resources allocated previously by
1881  * sata_get_rdwr_pmult_pkt().
1882  *
1883  * Void return.
1884  */
1885 void
1886 sata_free_rdwr_pmult_pkt(sata_pkt_t *sata_pkt)
1887 {
1888 	sata_pkt_txlate_t *spx =
1889 	    (sata_pkt_txlate_t *)sata_pkt->satapkt_framework_private;
1890 
1891 	/* Free allocated resources */
1892 	sata_pkt_free(spx);
1893 	kmem_free(spx, sizeof (sata_pkt_txlate_t));
1894 }
1895 
1896 /*
1897  * Register a port multiplier to framework.
1898  * 1) Store the GSCR values in the previous allocated pmult_info strctures.
1899  * 2) Search in the blacklist and update the number of the device ports of the
1900  * port multiplier.
1901  *
1902  * Void return.
1903  */
1904 void
1905 sata_register_pmult(dev_info_t *dip, sata_device_t *sd, sata_pmult_gscr_t *sg)
1906 {
1907 	sata_hba_inst_t *sata_hba_inst = NULL;
1908 	sata_pmult_info_t *pmultinfo;
1909 	sata_pmult_bl_t *blp;
1910 	int cport = sd->satadev_addr.cport;
1911 
1912 	mutex_enter(&sata_mutex);
1913 	for (sata_hba_inst = sata_hba_list; sata_hba_inst != NULL;
1914 	    sata_hba_inst = sata_hba_inst->satahba_next) {
1915 		if (SATA_DIP(sata_hba_inst) == dip)
1916 			if (sata_hba_inst->satahba_attached == 1)
1917 				break;
1918 	}
1919 	mutex_exit(&sata_mutex);
1920 	/* HBA not attached? */
1921 	if (sata_hba_inst == NULL)
1922 		return;
1923 
1924 	/* Number of pmports */
1925 	sd->satadev_add_info = sg->gscr2 & SATA_PMULT_PORTNUM_MASK;
1926 
1927 	/* Check the blacklist */
1928 	for (blp = sata_pmult_blacklist; blp->bl_gscr0; blp++) {
1929 		if (sg->gscr0 != blp->bl_gscr0 && blp->bl_gscr0)
1930 			continue;
1931 		if (sg->gscr1 != blp->bl_gscr1 && blp->bl_gscr1)
1932 			continue;
1933 		if (sg->gscr2 != blp->bl_gscr2 && blp->bl_gscr2)
1934 			continue;
1935 
1936 		cmn_err(CE_WARN, "!Port multiplier is on the blacklist.");
1937 		sd->satadev_add_info = blp->bl_flags;
1938 		break;
1939 	}
1940 
1941 	/* Register the port multiplier GSCR */
1942 	mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, cport)));
1943 	pmultinfo = SATA_PMULT_INFO(sata_hba_inst, cport);
1944 	if (pmultinfo != NULL) {
1945 		pmultinfo->pmult_gscr = *sg;
1946 		pmultinfo->pmult_num_dev_ports =
1947 		    sd->satadev_add_info & SATA_PMULT_PORTNUM_MASK;
1948 		SATADBG1(SATA_DBG_PMULT, sata_hba_inst,
1949 		    "Port multiplier registered at port %d", cport);
1950 	}
1951 	mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, cport)));
1952 }
1953 
1954 /*
1955  * sata_name_child is for composing the name of the node
1956  * the format of the name is "target,0".
1957  */
1958 static int
1959 sata_name_child(dev_info_t *dip, char *name, int namelen)
1960 {
1961 	int target;
1962 
1963 	target = ddi_prop_get_int(DDI_DEV_T_ANY, dip,
1964 	    DDI_PROP_DONTPASS, "target", -1);
1965 	if (target == -1)
1966 		return (DDI_FAILURE);
1967 	(void) snprintf(name, namelen, "%x,0", target);
1968 	return (DDI_SUCCESS);
1969 }
1970 
1971 
1972 
1973 /* ****************** SCSA required entry points *********************** */
1974 
1975 /*
1976  * Implementation of scsi tran_tgt_init.
1977  * sata_scsi_tgt_init() initializes scsi_device structure
1978  *
1979  * If successful, DDI_SUCCESS is returned.
1980  * DDI_FAILURE is returned if addressed device does not exist
1981  */
1982 
1983 static int
1984 sata_scsi_tgt_init(dev_info_t *hba_dip, dev_info_t *tgt_dip,
1985     scsi_hba_tran_t *hba_tran, struct scsi_device *sd)
1986 {
1987 #ifndef __lock_lint
1988 	_NOTE(ARGUNUSED(hba_dip))
1989 	_NOTE(ARGUNUSED(tgt_dip))
1990 #endif
1991 	sata_device_t		sata_device;
1992 	sata_drive_info_t	*sdinfo;
1993 	struct sata_id		*sid;
1994 	sata_hba_inst_t		*sata_hba_inst;
1995 	char			model[SATA_ID_MODEL_LEN + 1];
1996 	char			fw[SATA_ID_FW_LEN + 1];
1997 	char			*vid, *pid;
1998 	int			i;
1999 
2000 	/*
2001 	 * Fail tran_tgt_init for .conf stub node
2002 	 */
2003 	if (ndi_dev_is_persistent_node(tgt_dip) == 0) {
2004 		(void) ndi_merge_node(tgt_dip, sata_name_child);
2005 		ddi_set_name_addr(tgt_dip, NULL);
2006 		return (DDI_FAILURE);
2007 	}
2008 
2009 	sata_hba_inst = (sata_hba_inst_t *)(hba_tran->tran_hba_private);
2010 
2011 	/* Validate scsi device address */
2012 	if (sata_validate_scsi_address(sata_hba_inst, &sd->sd_address,
2013 	    &sata_device) != 0)
2014 		return (DDI_FAILURE);
2015 
2016 	mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst,
2017 	    sata_device.satadev_addr.cport)));
2018 
2019 	/* sata_device now contains a valid sata address */
2020 	sdinfo = sata_get_device_info(sata_hba_inst, &sata_device);
2021 	if (sdinfo == NULL) {
2022 		mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst,
2023 		    sata_device.satadev_addr.cport)));
2024 		return (DDI_FAILURE);
2025 	}
2026 	mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst,
2027 	    sata_device.satadev_addr.cport)));
2028 
2029 	/*
2030 	 * Check if we need to create a legacy devid (i.e cmdk style) for
2031 	 * the target disks.
2032 	 *
2033 	 * HBA devinfo node will have the property "use-cmdk-devid-format"
2034 	 * if we need to create cmdk-style devid for all the disk devices
2035 	 * attached to this controller. This property may have been set
2036 	 * from HBA driver's .conf file or by the HBA driver in its
2037 	 * attach(9F) function.
2038 	 */
2039 	if ((sdinfo->satadrv_type == SATA_DTYPE_ATADISK) &&
2040 	    (ddi_getprop(DDI_DEV_T_ANY, hba_dip, DDI_PROP_DONTPASS,
2041 	    "use-cmdk-devid-format", 0) == 1)) {
2042 		/* register a legacy devid for this target node */
2043 		sata_target_devid_register(tgt_dip, sdinfo);
2044 	}
2045 
2046 
2047 	/*
2048 	 * 'Identify Device Data' does not always fit in standard SCSI
2049 	 * INQUIRY data, so establish INQUIRY_* properties with full-form
2050 	 * of information.
2051 	 */
2052 	sid = &sdinfo->satadrv_id;
2053 #ifdef	_LITTLE_ENDIAN
2054 	swab(sid->ai_model, model, SATA_ID_MODEL_LEN);
2055 	swab(sid->ai_fw, fw, SATA_ID_FW_LEN);
2056 #else	/* _LITTLE_ENDIAN */
2057 	bcopy(sid->ai_model, model, SATA_ID_MODEL_LEN);
2058 	bcopy(sid->ai_fw, fw, SATA_ID_FW_LEN);
2059 #endif	/* _LITTLE_ENDIAN */
2060 	model[SATA_ID_MODEL_LEN] = 0;
2061 	fw[SATA_ID_FW_LEN] = 0;
2062 
2063 	/* split model into into vid/pid */
2064 	for (i = 0, pid = model; i < SATA_ID_MODEL_LEN; i++, pid++)
2065 		if ((*pid == ' ') || (*pid == '\t'))
2066 			break;
2067 	if (i < SATA_ID_MODEL_LEN) {
2068 		vid = model;
2069 		*pid++ = 0;		/* terminate vid, establish pid */
2070 	} else {
2071 		vid = NULL;		/* vid will stay "ATA     " */
2072 		pid = model;		/* model is all pid */
2073 	}
2074 
2075 	if (vid)
2076 		(void) scsi_device_prop_update_inqstring(sd, INQUIRY_VENDOR_ID,
2077 		    vid, strlen(vid));
2078 	if (pid)
2079 		(void) scsi_device_prop_update_inqstring(sd, INQUIRY_PRODUCT_ID,
2080 		    pid, strlen(pid));
2081 	(void) scsi_device_prop_update_inqstring(sd, INQUIRY_REVISION_ID,
2082 	    fw, strlen(fw));
2083 
2084 	return (DDI_SUCCESS);
2085 }
2086 
2087 /*
2088  * Implementation of scsi tran_tgt_probe.
2089  * Probe target, by calling default scsi routine scsi_hba_probe()
2090  */
2091 static int
2092 sata_scsi_tgt_probe(struct scsi_device *sd, int (*callback)(void))
2093 {
2094 	sata_hba_inst_t *sata_hba_inst =
2095 	    (sata_hba_inst_t *)(sd->sd_address.a_hba_tran->tran_hba_private);
2096 	int rval;
2097 	uint32_t pm_cap;
2098 
2099 	rval = scsi_hba_probe(sd, callback);
2100 	pm_cap = SATA_CAP_POWER_CONDITON | SATA_CAP_SMART_PAGE |
2101 	    SATA_CAP_LOG_SENSE;
2102 
2103 	if (rval == SCSIPROBE_EXISTS) {
2104 		/*
2105 		 * Set property "pm-capable" on the target device node, so that
2106 		 * the target driver will not try to fetch scsi cycle counters
2107 		 * before enabling device power-management.
2108 		 */
2109 		if ((ddi_prop_update_int(DDI_DEV_T_NONE, sd->sd_dev,
2110 		    "pm-capable", pm_cap)) != DDI_PROP_SUCCESS) {
2111 			sata_log(sata_hba_inst, CE_WARN,
2112 			    "SATA device at port %d: "
2113 			    "will not be power-managed ",
2114 			    SCSI_TO_SATA_CPORT(sd->sd_address.a_target));
2115 			SATA_LOG_D((sata_hba_inst, CE_WARN,
2116 			    "failure updating pm-capable property"));
2117 		}
2118 	}
2119 	return (rval);
2120 }
2121 
2122 /*
2123  * Implementation of scsi tran_tgt_free.
2124  * Release all resources allocated for scsi_device
2125  */
2126 static void
2127 sata_scsi_tgt_free(dev_info_t *hba_dip, dev_info_t *tgt_dip,
2128     scsi_hba_tran_t *hba_tran, struct scsi_device *sd)
2129 {
2130 #ifndef __lock_lint
2131 	_NOTE(ARGUNUSED(hba_dip))
2132 #endif
2133 	sata_device_t		sata_device;
2134 	sata_drive_info_t	*sdinfo;
2135 	sata_hba_inst_t		*sata_hba_inst;
2136 	ddi_devid_t		devid;
2137 
2138 	sata_hba_inst = (sata_hba_inst_t *)(hba_tran->tran_hba_private);
2139 
2140 	/* Validate scsi device address */
2141 	/*
2142 	 * Note: tgt_free relates to the SCSA view of a device. If called, there
2143 	 * was a device at this address, so even if the sata framework internal
2144 	 * resources were alredy released because a device was detached,
2145 	 * this function should be executed as long as its actions do
2146 	 * not require the internal sata view of a device and the address
2147 	 * refers to a valid sata address.
2148 	 * Validating the address here means that we do not trust SCSA...
2149 	 */
2150 	if (sata_validate_scsi_address(sata_hba_inst, &sd->sd_address,
2151 	    &sata_device) == -1)
2152 		return;
2153 
2154 	mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst,
2155 	    sata_device.satadev_addr.cport)));
2156 
2157 	/* sata_device now should contain a valid sata address */
2158 	sdinfo = sata_get_device_info(sata_hba_inst, &sata_device);
2159 	if (sdinfo == NULL) {
2160 		mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst,
2161 		    sata_device.satadev_addr.cport)));
2162 		return;
2163 	}
2164 	/*
2165 	 * We did not allocate any resources in sata_scsi_tgt_init()
2166 	 * other than few properties.
2167 	 * Free them.
2168 	 */
2169 	mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst,
2170 	    sata_device.satadev_addr.cport)));
2171 	(void) ndi_prop_remove(DDI_DEV_T_NONE, tgt_dip, "pm-capable");
2172 
2173 	/*
2174 	 * If devid was previously created but not freed up from
2175 	 * sd(7D) driver (i.e during detach(9F)) then do it here.
2176 	 */
2177 	if ((sdinfo->satadrv_type == SATA_DTYPE_ATADISK) &&
2178 	    (ddi_getprop(DDI_DEV_T_ANY, hba_dip, DDI_PROP_DONTPASS,
2179 	    "use-cmdk-devid-format", 0) == 1) &&
2180 	    (ddi_devid_get(tgt_dip, &devid) == DDI_SUCCESS)) {
2181 		ddi_devid_unregister(tgt_dip);
2182 		ddi_devid_free(devid);
2183 	}
2184 }
2185 
2186 /*
2187  * Implementation of scsi tran_init_pkt
2188  * Upon successful return, scsi pkt buffer has DMA resources allocated.
2189  *
2190  * It seems that we should always allocate pkt, even if the address is
2191  * for non-existing device - just use some default for dma_attr.
2192  * The reason is that there is no way to communicate this to a caller here.
2193  * Subsequent call to sata_scsi_start may fail appropriately.
2194  * Simply returning NULL does not seem to discourage a target driver...
2195  *
2196  * Returns a pointer to initialized scsi_pkt, or NULL otherwise.
2197  */
2198 static struct scsi_pkt *
2199 sata_scsi_init_pkt(struct scsi_address *ap, struct scsi_pkt *pkt,
2200     struct buf *bp, int cmdlen, int statuslen, int tgtlen, int flags,
2201     int (*callback)(caddr_t), caddr_t arg)
2202 {
2203 	sata_hba_inst_t *sata_hba_inst =
2204 	    (sata_hba_inst_t *)(ap->a_hba_tran->tran_hba_private);
2205 	dev_info_t *dip = SATA_DIP(sata_hba_inst);
2206 	sata_device_t sata_device;
2207 	sata_drive_info_t *sdinfo;
2208 	sata_pkt_txlate_t *spx;
2209 	ddi_dma_attr_t cur_dma_attr;
2210 	int rval;
2211 	boolean_t new_pkt = B_TRUE;
2212 
2213 	ASSERT(ap->a_hba_tran->tran_hba_dip == dip);
2214 
2215 	/*
2216 	 * We need to translate the address, even if it could be
2217 	 * a bogus one, for a non-existing device
2218 	 */
2219 	sata_device.satadev_addr.qual = SCSI_TO_SATA_ADDR_QUAL(ap->a_target);
2220 	sata_device.satadev_addr.cport = SCSI_TO_SATA_CPORT(ap->a_target);
2221 	sata_device.satadev_addr.pmport = SCSI_TO_SATA_PMPORT(ap->a_target);
2222 	sata_device.satadev_rev = SATA_DEVICE_REV;
2223 
2224 	if (pkt == NULL) {
2225 		/*
2226 		 * Have to allocate a brand new scsi packet.
2227 		 * We need to operate with auto request sense enabled.
2228 		 */
2229 		pkt = scsi_hba_pkt_alloc(dip, ap, cmdlen,
2230 		    MAX(statuslen, SATA_MAX_SENSE_LEN),
2231 		    tgtlen, sizeof (sata_pkt_txlate_t), callback, arg);
2232 
2233 		if (pkt == NULL)
2234 			return (NULL);
2235 
2236 		/* Fill scsi packet structure */
2237 		pkt->pkt_comp		= (void (*)())NULL;
2238 		pkt->pkt_time		= 0;
2239 		pkt->pkt_resid		= 0;
2240 		pkt->pkt_statistics	= 0;
2241 		pkt->pkt_reason		= 0;
2242 
2243 		/*
2244 		 * pkt_hba_private will point to sata pkt txlate structure
2245 		 */
2246 		spx = (sata_pkt_txlate_t *)pkt->pkt_ha_private;
2247 		bzero(spx, sizeof (sata_pkt_txlate_t));
2248 
2249 		spx->txlt_scsi_pkt = pkt;
2250 		spx->txlt_sata_hba_inst = sata_hba_inst;
2251 
2252 		/* Allocate sata_pkt */
2253 		spx->txlt_sata_pkt = sata_pkt_alloc(spx, callback);
2254 		if (spx->txlt_sata_pkt == NULL) {
2255 			/* Could not allocate sata pkt */
2256 			scsi_hba_pkt_free(ap, pkt);
2257 			return (NULL);
2258 		}
2259 		/* Set sata address */
2260 		spx->txlt_sata_pkt->satapkt_device.satadev_addr =
2261 		    sata_device.satadev_addr;
2262 		spx->txlt_sata_pkt->satapkt_device.satadev_rev =
2263 		    sata_device.satadev_rev;
2264 
2265 		if ((bp == NULL) || (bp->b_bcount == 0))
2266 			return (pkt);
2267 
2268 		spx->txlt_total_residue = bp->b_bcount;
2269 	} else {
2270 		new_pkt = B_FALSE;
2271 		/*
2272 		 * Packet was preallocated/initialized by previous call
2273 		 */
2274 		spx = (sata_pkt_txlate_t *)pkt->pkt_ha_private;
2275 
2276 		if ((bp == NULL) || (bp->b_bcount == 0)) {
2277 			return (pkt);
2278 		}
2279 
2280 		/* Pkt is available already: spx->txlt_scsi_pkt == pkt; */
2281 	}
2282 
2283 	spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp = bp;
2284 
2285 	/*
2286 	 * We use an adjusted version of the dma_attr, to account
2287 	 * for device addressing limitations.
2288 	 * sata_adjust_dma_attr() will handle sdinfo == NULL which may
2289 	 * happen when a device is not yet configured.
2290 	 */
2291 	mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst,
2292 	    sata_device.satadev_addr.cport)));
2293 	sdinfo = sata_get_device_info(spx->txlt_sata_hba_inst,
2294 	    &spx->txlt_sata_pkt->satapkt_device);
2295 	/* NULL sdinfo may be passsed to sata_adjust_dma_attr() */
2296 	sata_adjust_dma_attr(sdinfo,
2297 	    SATA_DMA_ATTR(spx->txlt_sata_hba_inst), &cur_dma_attr);
2298 	mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst,
2299 	    sata_device.satadev_addr.cport)));
2300 	/*
2301 	 * Allocate necessary DMA resources for the packet's data buffer
2302 	 * NOTE:
2303 	 * In case of read/write commands, DMA resource allocation here is
2304 	 * based on the premise that the transfer length specified in
2305 	 * the read/write scsi cdb will match exactly DMA resources -
2306 	 * returning correct packet residue is crucial.
2307 	 */
2308 	if ((rval = sata_dma_buf_setup(spx, flags, callback, arg,
2309 	    &cur_dma_attr)) != DDI_SUCCESS) {
2310 		/*
2311 		 * If a DMA allocation request fails with
2312 		 * DDI_DMA_NOMAPPING, indicate the error by calling
2313 		 * bioerror(9F) with bp and an error code of EFAULT.
2314 		 * If a DMA allocation request fails with
2315 		 * DDI_DMA_TOOBIG, indicate the error by calling
2316 		 * bioerror(9F) with bp and an error code of EINVAL.
2317 		 * For DDI_DMA_NORESOURCES, we may have some of them allocated.
2318 		 * Request may be repeated later - there is no real error.
2319 		 */
2320 		switch (rval) {
2321 		case DDI_DMA_NORESOURCES:
2322 			bioerror(bp, 0);
2323 			break;
2324 		case DDI_DMA_NOMAPPING:
2325 		case DDI_DMA_BADATTR:
2326 			bioerror(bp, EFAULT);
2327 			break;
2328 		case DDI_DMA_TOOBIG:
2329 		default:
2330 			bioerror(bp, EINVAL);
2331 			break;
2332 		}
2333 		goto fail;
2334 	}
2335 
2336 	if (sata_check_for_dma_error(dip, spx)) {
2337 		ddi_fm_service_impact(dip, DDI_SERVICE_UNAFFECTED);
2338 		bioerror(bp, EFAULT);
2339 		goto fail;
2340 	}
2341 
2342 success:
2343 	/* Set number of bytes that are not yet accounted for */
2344 	pkt->pkt_resid = spx->txlt_total_residue;
2345 	ASSERT(pkt->pkt_resid >= 0);
2346 
2347 	return (pkt);
2348 
2349 fail:
2350 	if (new_pkt == B_TRUE) {
2351 		/*
2352 		 * Since this is a new packet, we can clean-up
2353 		 * everything
2354 		 */
2355 		sata_scsi_destroy_pkt(ap, pkt);
2356 	} else {
2357 		/*
2358 		 * This is a re-used packet. It will be target driver's
2359 		 * responsibility to eventually destroy it (which
2360 		 * will free allocated resources).
2361 		 * Here, we just "complete" the request, leaving
2362 		 * allocated resources intact, so the request may
2363 		 * be retried.
2364 		 */
2365 		spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp = NULL;
2366 		sata_pkt_free(spx);
2367 	}
2368 	return (NULL);
2369 }
2370 
2371 /*
2372  * Implementation of scsi tran_start.
2373  * Translate scsi cmd into sata operation and return status.
2374  * ATAPI CDBs are passed to ATAPI devices - the device determines what commands
2375  * are supported.
2376  * For SATA hard disks, supported scsi commands:
2377  * SCMD_INQUIRY
2378  * SCMD_TEST_UNIT_READY
2379  * SCMD_START_STOP
2380  * SCMD_READ_CAPACITY
2381  * SCMD_SVC_ACTION_IN_G4 (READ CAPACITY (16))
2382  * SCMD_REQUEST_SENSE
2383  * SCMD_LOG_SENSE_G1
2384  * SCMD_LOG_SELECT_G1
2385  * SCMD_MODE_SENSE	(specific pages)
2386  * SCMD_MODE_SENSE_G1	(specific pages)
2387  * SCMD_MODE_SELECT	(specific pages)
2388  * SCMD_MODE_SELECT_G1	(specific pages)
2389  * SCMD_SYNCHRONIZE_CACHE
2390  * SCMD_SYNCHRONIZE_CACHE_G1
2391  * SCMD_READ
2392  * SCMD_READ_G1
2393  * SCMD_READ_G4
2394  * SCMD_READ_G5
2395  * SCMD_WRITE
2396  * SCMD_WRITE_BUFFER
2397  * SCMD_WRITE_G1
2398  * SCMD_WRITE_G4
2399  * SCMD_WRITE_G5
2400  * SCMD_SEEK		(noop)
2401  * SCMD_SDIAG
2402  *
2403  * All other commands are rejected as unsupported.
2404  *
2405  * Returns:
2406  * TRAN_ACCEPT if command was executed successfully or accepted by HBA driver
2407  * for execution. TRAN_ACCEPT may be returned also if device was removed but
2408  * a callback could be scheduled.
2409  * TRAN_BADPKT if cmd was directed to invalid address.
2410  * TRAN_FATAL_ERROR is command was rejected due to hardware error, including
2411  * some unspecified error. TRAN_FATAL_ERROR may be also returned if a device
2412  * was removed and there was no callback specified in scsi pkt.
2413  * TRAN_BUSY if command could not be executed becasue HBA driver or SATA
2414  * framework was busy performing some other operation(s).
2415  *
2416  */
2417 static int
2418 sata_scsi_start(struct scsi_address *ap, struct scsi_pkt *pkt)
2419 {
2420 	sata_hba_inst_t *sata_hba_inst =
2421 	    (sata_hba_inst_t *)(ap->a_hba_tran->tran_hba_private);
2422 	sata_pkt_txlate_t *spx = (sata_pkt_txlate_t *)pkt->pkt_ha_private;
2423 	sata_device_t *sdevice = &spx->txlt_sata_pkt->satapkt_device;
2424 	sata_drive_info_t *sdinfo;
2425 	struct buf *bp;
2426 	uint8_t cport, pmport;
2427 	boolean_t dev_gone = B_FALSE;
2428 	int rval;
2429 
2430 	SATADBG1(SATA_DBG_SCSI_IF, sata_hba_inst,
2431 	    "sata_scsi_start: cmd 0x%02x\n", pkt->pkt_cdbp[0]);
2432 
2433 	ASSERT(spx != NULL &&
2434 	    spx->txlt_scsi_pkt == pkt && spx->txlt_sata_pkt != NULL);
2435 
2436 	cport = SCSI_TO_SATA_CPORT(ap->a_target);
2437 	pmport = SCSI_TO_SATA_PMPORT(ap->a_target);
2438 
2439 	mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, cport)));
2440 
2441 	if (sdevice->satadev_addr.qual == SATA_ADDR_DCPORT) {
2442 		sdinfo = sata_get_device_info(sata_hba_inst, sdevice);
2443 		if (sdinfo == NULL ||
2444 		    SATA_CPORT_INFO(sata_hba_inst, cport)->
2445 		    cport_tgtnode_clean == B_FALSE ||
2446 		    (sdinfo->satadrv_state & SATA_DSTATE_FAILED) != 0) {
2447 			dev_gone = B_TRUE;
2448 		}
2449 	} else if (sdevice->satadev_addr.qual == SATA_ADDR_DPMPORT) {
2450 		if (SATA_CPORT_DEV_TYPE(sata_hba_inst, cport) !=
2451 		    SATA_DTYPE_PMULT || SATA_PMULT_INFO(sata_hba_inst,
2452 		    cport) == NULL) {
2453 			dev_gone = B_TRUE;
2454 		} else if (SATA_PMPORT_INFO(sata_hba_inst, cport,
2455 		    pmport) == NULL) {
2456 			dev_gone = B_TRUE;
2457 		} else {
2458 			mutex_enter(&(SATA_PMPORT_MUTEX(sata_hba_inst,
2459 			    cport, pmport)));
2460 			sdinfo = sata_get_device_info(sata_hba_inst, sdevice);
2461 			if (sdinfo == NULL ||
2462 			    SATA_PMPORT_INFO(sata_hba_inst, cport, pmport)->
2463 			    pmport_tgtnode_clean == B_FALSE ||
2464 			    (sdinfo->satadrv_state & SATA_DSTATE_FAILED) != 0) {
2465 				dev_gone = B_TRUE;
2466 			}
2467 			mutex_exit(&(SATA_PMPORT_MUTEX(sata_hba_inst,
2468 			    cport, pmport)));
2469 		}
2470 	}
2471 
2472 	if (dev_gone == B_TRUE) {
2473 		mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, cport)));
2474 		pkt->pkt_reason = CMD_DEV_GONE;
2475 		/*
2476 		 * The sd target driver is checking CMD_DEV_GONE pkt_reason
2477 		 * only in callback function (for normal requests) and
2478 		 * in the dump code path.
2479 		 * So, if the callback is available, we need to do
2480 		 * the callback rather than returning TRAN_FATAL_ERROR here.
2481 		 */
2482 		if (pkt->pkt_comp != NULL) {
2483 			/* scsi callback required */
2484 			if (servicing_interrupt()) {
2485 				if (taskq_dispatch(SATA_TXLT_TASKQ(spx),
2486 				    (task_func_t *)spx->txlt_scsi_pkt->pkt_comp,
2487 				    (void *)spx->txlt_scsi_pkt, TQ_NOSLEEP) ==
2488 				    NULL) {
2489 					return (TRAN_BUSY);
2490 				}
2491 			} else if (taskq_dispatch(SATA_TXLT_TASKQ(spx),
2492 			    (task_func_t *)spx->txlt_scsi_pkt->pkt_comp,
2493 			    (void *)spx->txlt_scsi_pkt, TQ_SLEEP) == NULL) {
2494 				/* Scheduling the callback failed */
2495 				return (TRAN_BUSY);
2496 			}
2497 			return (TRAN_ACCEPT);
2498 		}
2499 		/* No callback available */
2500 		return (TRAN_FATAL_ERROR);
2501 	}
2502 
2503 	if (sdinfo->satadrv_type & SATA_DTYPE_ATAPI) {
2504 		mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, cport)));
2505 		rval = sata_txlt_atapi(spx);
2506 		SATADBG1(SATA_DBG_SCSI_IF, sata_hba_inst,
2507 		    "sata_scsi_start atapi: rval %d\n", rval);
2508 		return (rval);
2509 	}
2510 	mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, cport)));
2511 
2512 	/*
2513 	 * Checking for power state, if it was on
2514 	 * STOPPED state, then the drive is not capable
2515 	 * of processing media access command.  And
2516 	 * TEST_UNIT_READY, REQUEST_SENSE has special handling
2517 	 * in the function for different power state.
2518 	 */
2519 	if (((sdinfo->satadrv_power_level == SATA_POWER_STANDBY) ||
2520 	    (sdinfo->satadrv_power_level == SATA_POWER_STOPPED)) &&
2521 	    (SATA_IS_MEDIUM_ACCESS_CMD(pkt->pkt_cdbp[0]))) {
2522 		return (sata_txlt_check_condition(spx, KEY_NOT_READY,
2523 		    SD_SCSI_ASC_LU_NOT_READY));
2524 	}
2525 
2526 	/* ATA Disk commands processing starts here */
2527 
2528 	bp = spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp;
2529 
2530 	switch (pkt->pkt_cdbp[0]) {
2531 
2532 	case SCMD_INQUIRY:
2533 		/* Mapped to identify device */
2534 		if (bp != NULL && (bp->b_flags & (B_PHYS | B_PAGEIO)))
2535 			bp_mapin(bp);
2536 		rval = sata_txlt_inquiry(spx);
2537 		break;
2538 
2539 	case SCMD_TEST_UNIT_READY:
2540 		/*
2541 		 * SAT "SATA to ATA Translation" doc specifies translation
2542 		 * to ATA CHECK POWER MODE.
2543 		 */
2544 		rval = sata_txlt_test_unit_ready(spx);
2545 		break;
2546 
2547 	case SCMD_START_STOP:
2548 		/* Mapping depends on the command */
2549 		rval = sata_txlt_start_stop_unit(spx);
2550 		break;
2551 
2552 	case SCMD_READ_CAPACITY:
2553 		if (bp != NULL && (bp->b_flags & (B_PHYS | B_PAGEIO)))
2554 			bp_mapin(bp);
2555 		rval = sata_txlt_read_capacity(spx);
2556 		break;
2557 
2558 	case SCMD_SVC_ACTION_IN_G4:		/* READ CAPACITY (16) */
2559 		if (bp != NULL && (bp->b_flags & (B_PHYS | B_PAGEIO)))
2560 			bp_mapin(bp);
2561 		rval = sata_txlt_read_capacity16(spx);
2562 		break;
2563 
2564 	case SCMD_REQUEST_SENSE:
2565 		/*
2566 		 * Always No Sense, since we force ARQ
2567 		 */
2568 		if (bp != NULL && (bp->b_flags & (B_PHYS | B_PAGEIO)))
2569 			bp_mapin(bp);
2570 		rval = sata_txlt_request_sense(spx);
2571 		break;
2572 
2573 	case SCMD_LOG_SENSE_G1:
2574 		if (bp != NULL && (bp->b_flags & (B_PHYS | B_PAGEIO)))
2575 			bp_mapin(bp);
2576 		rval = sata_txlt_log_sense(spx);
2577 		break;
2578 
2579 	case SCMD_LOG_SELECT_G1:
2580 		if (bp != NULL && (bp->b_flags & (B_PHYS | B_PAGEIO)))
2581 			bp_mapin(bp);
2582 		rval = sata_txlt_log_select(spx);
2583 		break;
2584 
2585 	case SCMD_MODE_SENSE:
2586 	case SCMD_MODE_SENSE_G1:
2587 		if (bp != NULL && (bp->b_flags & (B_PHYS | B_PAGEIO)))
2588 			bp_mapin(bp);
2589 		rval = sata_txlt_mode_sense(spx);
2590 		break;
2591 
2592 
2593 	case SCMD_MODE_SELECT:
2594 	case SCMD_MODE_SELECT_G1:
2595 		if (bp != NULL && (bp->b_flags & (B_PHYS | B_PAGEIO)))
2596 			bp_mapin(bp);
2597 		rval = sata_txlt_mode_select(spx);
2598 		break;
2599 
2600 	case SCMD_SYNCHRONIZE_CACHE:
2601 	case SCMD_SYNCHRONIZE_CACHE_G1:
2602 		rval = sata_txlt_synchronize_cache(spx);
2603 		break;
2604 
2605 	case SCMD_READ:
2606 	case SCMD_READ_G1:
2607 	case SCMD_READ_G4:
2608 	case SCMD_READ_G5:
2609 		rval = sata_txlt_read(spx);
2610 		break;
2611 	case SCMD_WRITE_BUFFER:
2612 		if (bp != NULL && (bp->b_flags & (B_PHYS | B_PAGEIO)))
2613 			bp_mapin(bp);
2614 		rval = sata_txlt_write_buffer(spx);
2615 		break;
2616 
2617 	case SCMD_WRITE:
2618 	case SCMD_WRITE_G1:
2619 	case SCMD_WRITE_G4:
2620 	case SCMD_WRITE_G5:
2621 		rval = sata_txlt_write(spx);
2622 		break;
2623 
2624 	case SCMD_SEEK:
2625 		rval = sata_txlt_nodata_cmd_immediate(spx);
2626 		break;
2627 
2628 	case SPC3_CMD_ATA_COMMAND_PASS_THROUGH12:
2629 	case SPC3_CMD_ATA_COMMAND_PASS_THROUGH16:
2630 		if (bp != NULL && (bp->b_flags & (B_PHYS | B_PAGEIO)))
2631 			bp_mapin(bp);
2632 		rval = sata_txlt_ata_pass_thru(spx);
2633 		break;
2634 
2635 		/* Other cases will be filed later */
2636 		/* postponed until phase 2 of the development */
2637 	case SPC3_CMD_UNMAP:
2638 		if (bp != NULL && (bp->b_flags & (B_PHYS | B_PAGEIO)))
2639 			bp_mapin(bp);
2640 		rval = sata_txlt_unmap(spx);
2641 		break;
2642 	default:
2643 		rval = sata_txlt_invalid_command(spx);
2644 		break;
2645 	}
2646 
2647 	SATADBG1(SATA_DBG_SCSI_IF, sata_hba_inst,
2648 	    "sata_scsi_start: rval %d\n", rval);
2649 
2650 	return (rval);
2651 }
2652 
2653 /*
2654  * Implementation of scsi tran_abort.
2655  * Abort specific pkt or all packets.
2656  *
2657  * Returns 1 if one or more packets were aborted, returns 0 otherwise
2658  *
2659  * May be called from an interrupt level.
2660  */
2661 static int
2662 sata_scsi_abort(struct scsi_address *ap, struct scsi_pkt *scsi_pkt)
2663 {
2664 	sata_hba_inst_t *sata_hba_inst =
2665 	    (sata_hba_inst_t *)(ap->a_hba_tran->tran_hba_private);
2666 	sata_device_t	sata_device;
2667 	sata_pkt_t	*sata_pkt;
2668 
2669 	SATADBG2(SATA_DBG_SCSI_IF, sata_hba_inst,
2670 	    "sata_scsi_abort: %s at target: 0x%x\n",
2671 	    scsi_pkt == NULL ? "all packets" : "one pkt", ap->a_target);
2672 
2673 	/* Validate address */
2674 	if (sata_validate_scsi_address(sata_hba_inst, ap, &sata_device) != 0)
2675 		/* Invalid address */
2676 		return (0);
2677 
2678 	mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst,
2679 	    sata_device.satadev_addr.cport)));
2680 	if (sata_get_device_info(sata_hba_inst, &sata_device) == NULL) {
2681 		/* invalid address */
2682 		mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst,
2683 		    sata_device.satadev_addr.cport)));
2684 		return (0);
2685 	}
2686 	if (scsi_pkt == NULL) {
2687 		/*
2688 		 * Abort all packets.
2689 		 * Although we do not have specific packet, we still need
2690 		 * dummy packet structure to pass device address to HBA.
2691 		 * Allocate one, without sleeping. Fail if pkt cannot be
2692 		 * allocated.
2693 		 */
2694 		sata_pkt = kmem_zalloc(sizeof (sata_pkt_t), KM_NOSLEEP);
2695 		if (sata_pkt == NULL) {
2696 			mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst,
2697 			    sata_device.satadev_addr.cport)));
2698 			SATA_LOG_D((sata_hba_inst, CE_WARN, "sata_pkt_abort: "
2699 			    "could not allocate sata_pkt"));
2700 			return (0);
2701 		}
2702 		sata_pkt->satapkt_rev = SATA_PKT_REV;
2703 		sata_pkt->satapkt_device = sata_device;
2704 		sata_pkt->satapkt_device.satadev_rev = SATA_DEVICE_REV;
2705 	} else {
2706 		if (scsi_pkt->pkt_ha_private == NULL) {
2707 			mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst,
2708 			    sata_device.satadev_addr.cport)));
2709 			return (0); /* Bad scsi pkt */
2710 		}
2711 		/* extract pointer to sata pkt */
2712 		sata_pkt = ((sata_pkt_txlate_t *)scsi_pkt->pkt_ha_private)->
2713 		    txlt_sata_pkt;
2714 	}
2715 
2716 	mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst,
2717 	    sata_device.satadev_addr.cport)));
2718 	/* Send abort request to HBA */
2719 	if ((*SATA_ABORT_FUNC(sata_hba_inst))
2720 	    (SATA_DIP(sata_hba_inst), sata_pkt,
2721 	    scsi_pkt == NULL ? SATA_ABORT_ALL_PACKETS : SATA_ABORT_PACKET) ==
2722 	    SATA_SUCCESS) {
2723 		if (scsi_pkt == NULL)
2724 			kmem_free(sata_pkt, sizeof (sata_pkt_t));
2725 		/* Success */
2726 		return (1);
2727 	}
2728 	/* Else, something did not go right */
2729 	if (scsi_pkt == NULL)
2730 		kmem_free(sata_pkt, sizeof (sata_pkt_t));
2731 	/* Failure */
2732 	return (0);
2733 }
2734 
2735 
2736 /*
2737  * Implementation of scsi tran_reset.
2738  * RESET_ALL request is translated into port reset.
2739  * RESET_TARGET requests is translated into a device reset,
2740  * RESET_LUN request is accepted only for LUN 0 and translated into
2741  * device reset.
2742  * The target reset should cause all HBA active and queued packets to
2743  * be terminated and returned with pkt reason SATA_PKT_RESET prior to
2744  * the return. HBA should report reset event for the device.
2745  *
2746  * Returns 1 upon success, 0 upon failure.
2747  */
2748 static int
2749 sata_scsi_reset(struct scsi_address *ap, int level)
2750 {
2751 	sata_hba_inst_t	*sata_hba_inst =
2752 	    (sata_hba_inst_t *)(ap->a_hba_tran->tran_hba_private);
2753 	sata_device_t	sata_device;
2754 	int		val;
2755 
2756 	SATADBG2(SATA_DBG_SCSI_IF, sata_hba_inst,
2757 	    "sata_scsi_reset: level %d target: 0x%x\n",
2758 	    level, ap->a_target);
2759 
2760 	/* Validate address */
2761 	val = sata_validate_scsi_address(sata_hba_inst, ap, &sata_device);
2762 	if (val == -1)
2763 		/* Invalid address */
2764 		return (0);
2765 
2766 	mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst,
2767 	    sata_device.satadev_addr.cport)));
2768 	if (sata_get_device_info(sata_hba_inst, &sata_device) == NULL) {
2769 		/* invalid address */
2770 		mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst,
2771 		    sata_device.satadev_addr.cport)));
2772 		return (0);
2773 	}
2774 	mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst,
2775 	    sata_device.satadev_addr.cport)));
2776 	if (level == RESET_ALL) {
2777 		/* port reset */
2778 		if (sata_device.satadev_addr.qual == SATA_ADDR_DCPORT)
2779 			sata_device.satadev_addr.qual = SATA_ADDR_CPORT;
2780 		else
2781 			sata_device.satadev_addr.qual = SATA_ADDR_PMPORT;
2782 
2783 		if ((*SATA_RESET_DPORT_FUNC(sata_hba_inst))
2784 		    (SATA_DIP(sata_hba_inst), &sata_device) == SATA_SUCCESS)
2785 			return (1);
2786 		else
2787 			return (0);
2788 
2789 	} else if (val == 0 &&
2790 	    (level == RESET_TARGET || level == RESET_LUN)) {
2791 		/* reset device (device attached) */
2792 		if ((*SATA_RESET_DPORT_FUNC(sata_hba_inst))
2793 		    (SATA_DIP(sata_hba_inst), &sata_device) == SATA_SUCCESS)
2794 			return (1);
2795 		else
2796 			return (0);
2797 	}
2798 	return (0);
2799 }
2800 
2801 
2802 /*
2803  * Implementation of scsi tran_getcap (get transport/device capabilities).
2804  * Supported capabilities for SATA hard disks:
2805  * auto-rqsense		(always supported)
2806  * tagged-qing		(supported if HBA supports it)
2807  * untagged-qing	(could be supported if disk supports it, but because
2808  *			 caching behavior allowing untagged queuing actually
2809  *			 results in reduced performance.  sd tries to throttle
2810  *			 back to only 3 outstanding commands, which may
2811  *			 work for real SCSI disks, but with read ahead
2812  *			 caching, having more than 1 outstanding command
2813  *			 results in cache thrashing.)
2814  * sector_size
2815  * dma_max
2816  * interconnect-type	(INTERCONNECT_SATA)
2817  *
2818  * Supported capabilities for ATAPI CD/DVD devices:
2819  * auto-rqsense		(always supported)
2820  * sector_size
2821  * dma_max
2822  * max-cdb-length
2823  * interconnect-type	(INTERCONNECT_SATA)
2824  *
2825  * Supported capabilities for ATAPI TAPE devices:
2826  * auto-rqsense		(always supported)
2827  * dma_max
2828  * max-cdb-length
2829  *
2830  * Supported capabilities for SATA ATAPI hard disks:
2831  * auto-rqsense		(always supported)
2832  * interconnect-type	(INTERCONNECT_SATA)
2833  * max-cdb-length
2834  *
2835  * Request for other capabilities is rejected as unsupported.
2836  *
2837  * Returns supported capability value, or -1 if capability is unsuppported or
2838  * the address is invalid - no device.
2839  */
2840 
2841 static int
2842 sata_scsi_getcap(struct scsi_address *ap, char *cap, int whom)
2843 {
2844 
2845 	sata_hba_inst_t 	*sata_hba_inst =
2846 	    (sata_hba_inst_t *)(ap->a_hba_tran->tran_hba_private);
2847 	sata_device_t		sata_device;
2848 	sata_drive_info_t	*sdinfo;
2849 	ddi_dma_attr_t		adj_dma_attr;
2850 	int 			rval;
2851 
2852 	SATADBG2(SATA_DBG_SCSI_IF, sata_hba_inst,
2853 	    "sata_scsi_getcap: target: 0x%x, cap: %s\n",
2854 	    ap->a_target, cap);
2855 
2856 	/*
2857 	 * We want to process the capabilities on per port granularity.
2858 	 * So, we are specifically restricting ourselves to whom != 0
2859 	 * to exclude the controller wide handling.
2860 	 */
2861 	if (cap == NULL || whom == 0)
2862 		return (-1);
2863 
2864 	if (sata_validate_scsi_address(sata_hba_inst, ap, &sata_device) != 0) {
2865 		/* Invalid address */
2866 		return (-1);
2867 	}
2868 	mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst,
2869 	    sata_device.satadev_addr.cport)));
2870 	if ((sdinfo = sata_get_device_info(sata_hba_inst, &sata_device)) ==
2871 	    NULL) {
2872 		/* invalid address */
2873 		mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst,
2874 		    sata_device.satadev_addr.cport)));
2875 		return (-1);
2876 	}
2877 
2878 	switch (scsi_hba_lookup_capstr(cap)) {
2879 	case SCSI_CAP_ARQ:
2880 		rval = 1;		/* ARQ supported, turned on */
2881 		break;
2882 
2883 	case SCSI_CAP_SECTOR_SIZE:
2884 		if (sdinfo->satadrv_type == SATA_DTYPE_ATADISK)
2885 			rval = SATA_DISK_SECTOR_SIZE;	/* fixed size */
2886 		else if (sdinfo->satadrv_type == SATA_DTYPE_ATAPICD)
2887 			rval = SATA_ATAPI_SECTOR_SIZE;
2888 		else rval = -1;
2889 		break;
2890 
2891 	/*
2892 	 * untagged queuing cause a performance inversion because of
2893 	 * the way sd operates.  Because of this reason we do not
2894 	 * use it when available.
2895 	 */
2896 	case SCSI_CAP_UNTAGGED_QING:
2897 		if (sdinfo->satadrv_features_enabled &
2898 		    SATA_DEV_F_E_UNTAGGED_QING)
2899 			rval = 1;	/* Untagged queuing available */
2900 		else
2901 			rval = -1;	/* Untagged queuing not available */
2902 		break;
2903 
2904 	case SCSI_CAP_TAGGED_QING:
2905 		if ((sdinfo->satadrv_features_enabled &
2906 		    SATA_DEV_F_E_TAGGED_QING) &&
2907 		    (sdinfo->satadrv_max_queue_depth > 1))
2908 			rval = 1;	/* Tagged queuing available */
2909 		else
2910 			rval = -1;	/* Tagged queuing not available */
2911 		break;
2912 
2913 	case SCSI_CAP_DMA_MAX:
2914 		sata_adjust_dma_attr(sdinfo, SATA_DMA_ATTR(sata_hba_inst),
2915 		    &adj_dma_attr);
2916 		rval = (int)adj_dma_attr.dma_attr_maxxfer;
2917 		/* We rely on the fact that dma_attr_maxxfer < 0x80000000 */
2918 		break;
2919 
2920 	case SCSI_CAP_INTERCONNECT_TYPE:
2921 		rval = INTERCONNECT_SATA;	/* SATA interconnect type */
2922 		break;
2923 
2924 	case SCSI_CAP_CDB_LEN:
2925 		if (sdinfo->satadrv_type & SATA_DTYPE_ATAPI)
2926 			rval = sdinfo->satadrv_atapi_cdb_len;
2927 		else
2928 			rval = -1;
2929 		break;
2930 
2931 	default:
2932 		rval = -1;
2933 		break;
2934 	}
2935 	mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst,
2936 	    sata_device.satadev_addr.cport)));
2937 	return (rval);
2938 }
2939 
2940 /*
2941  * Implementation of scsi tran_setcap
2942  *
2943  * Only SCSI_CAP_UNTAGGED_QING and  SCSI_CAP_TAGGED_QING are changeable.
2944  *
2945  */
2946 static int
2947 sata_scsi_setcap(struct scsi_address *ap, char *cap, int value, int whom)
2948 {
2949 	sata_hba_inst_t	*sata_hba_inst =
2950 	    (sata_hba_inst_t *)(ap->a_hba_tran->tran_hba_private);
2951 	sata_device_t	sata_device;
2952 	sata_drive_info_t	*sdinfo;
2953 	int		rval;
2954 
2955 	SATADBG2(SATA_DBG_SCSI_IF, sata_hba_inst,
2956 	    "sata_scsi_setcap: target: 0x%x, cap: %s\n", ap->a_target, cap);
2957 
2958 	/*
2959 	 * We want to process the capabilities on per port granularity.
2960 	 * So, we are specifically restricting ourselves to whom != 0
2961 	 * to exclude the controller wide handling.
2962 	 */
2963 	if (cap == NULL || whom == 0) {
2964 		return (-1);
2965 	}
2966 
2967 	if (sata_validate_scsi_address(sata_hba_inst, ap, &sata_device) != 0) {
2968 		/* Invalid address */
2969 		return (-1);
2970 	}
2971 	mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst,
2972 	    sata_device.satadev_addr.cport)));
2973 	if ((sdinfo = sata_get_device_info(sata_hba_inst,
2974 	    &sata_device)) == NULL) {
2975 		/* invalid address */
2976 		mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst,
2977 		    sata_device.satadev_addr.cport)));
2978 		return (-1);
2979 	}
2980 	mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst,
2981 	    sata_device.satadev_addr.cport)));
2982 
2983 	switch (scsi_hba_lookup_capstr(cap)) {
2984 	case SCSI_CAP_ARQ:
2985 	case SCSI_CAP_SECTOR_SIZE:
2986 	case SCSI_CAP_DMA_MAX:
2987 	case SCSI_CAP_INTERCONNECT_TYPE:
2988 		rval = 0;
2989 		break;
2990 	case SCSI_CAP_UNTAGGED_QING:
2991 		if (SATA_QDEPTH(sata_hba_inst) > 1) {
2992 			rval = 1;
2993 			if (value == 1) {
2994 				sdinfo->satadrv_features_enabled |=
2995 				    SATA_DEV_F_E_UNTAGGED_QING;
2996 			} else if (value == 0) {
2997 				sdinfo->satadrv_features_enabled &=
2998 				    ~SATA_DEV_F_E_UNTAGGED_QING;
2999 			} else {
3000 				rval = -1;
3001 			}
3002 		} else {
3003 			rval = 0;
3004 		}
3005 		break;
3006 	case SCSI_CAP_TAGGED_QING:
3007 		/* This can TCQ or NCQ */
3008 		if (sata_func_enable & SATA_ENABLE_QUEUING &&
3009 		    ((sdinfo->satadrv_features_support & SATA_DEV_F_TCQ &&
3010 		    SATA_FEATURES(sata_hba_inst) & SATA_CTLF_QCMD) ||
3011 		    (sata_func_enable & SATA_ENABLE_NCQ &&
3012 		    sdinfo->satadrv_features_support & SATA_DEV_F_NCQ &&
3013 		    SATA_FEATURES(sata_hba_inst) & SATA_CTLF_NCQ)) &&
3014 		    (sdinfo->satadrv_max_queue_depth > 1)) {
3015 			rval = 1;
3016 			if (value == 1) {
3017 				sdinfo->satadrv_features_enabled |=
3018 				    SATA_DEV_F_E_TAGGED_QING;
3019 			} else if (value == 0) {
3020 				sdinfo->satadrv_features_enabled &=
3021 				    ~SATA_DEV_F_E_TAGGED_QING;
3022 			} else {
3023 				rval = -1;
3024 			}
3025 		} else {
3026 			rval = 0;
3027 		}
3028 		break;
3029 	default:
3030 		rval = -1;
3031 		break;
3032 	}
3033 	return (rval);
3034 }
3035 
3036 /*
3037  * Implementations of scsi tran_destroy_pkt.
3038  * Free resources allocated by sata_scsi_init_pkt()
3039  */
3040 static void
3041 sata_scsi_destroy_pkt(struct scsi_address *ap, struct scsi_pkt *pkt)
3042 {
3043 	sata_pkt_txlate_t *spx;
3044 
3045 	spx = (sata_pkt_txlate_t *)pkt->pkt_ha_private;
3046 
3047 	sata_common_free_dma_rsrcs(spx);
3048 
3049 	spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp = NULL;
3050 	sata_pkt_free(spx);
3051 
3052 	scsi_hba_pkt_free(ap, pkt);
3053 }
3054 
3055 /*
3056  * Implementation of scsi tran_dmafree.
3057  * Free DMA resources allocated by sata_scsi_init_pkt()
3058  */
3059 
3060 static void
3061 sata_scsi_dmafree(struct scsi_address *ap, struct scsi_pkt *pkt)
3062 {
3063 #ifndef __lock_lint
3064 	_NOTE(ARGUNUSED(ap))
3065 #endif
3066 	sata_pkt_txlate_t *spx;
3067 
3068 	ASSERT(pkt != NULL);
3069 	spx = (sata_pkt_txlate_t *)pkt->pkt_ha_private;
3070 
3071 	sata_common_free_dma_rsrcs(spx);
3072 }
3073 
3074 /*
3075  * Implementation of scsi tran_sync_pkt.
3076  *
3077  * The assumption below is that pkt is unique - there is no need to check ap
3078  *
3079  * Synchronize DMA buffer and, if the intermediate buffer is used, copy data
3080  * into/from the real buffer.
3081  */
3082 static void
3083 sata_scsi_sync_pkt(struct scsi_address *ap, struct scsi_pkt *pkt)
3084 {
3085 #ifndef __lock_lint
3086 	_NOTE(ARGUNUSED(ap))
3087 #endif
3088 	int rval;
3089 	sata_pkt_txlate_t *spx = (sata_pkt_txlate_t *)pkt->pkt_ha_private;
3090 	struct buf *bp;
3091 	int direction;
3092 
3093 	ASSERT(spx != NULL);
3094 	if (spx->txlt_buf_dma_handle != NULL) {
3095 		direction = spx->txlt_sata_pkt->
3096 		    satapkt_cmd.satacmd_flags.sata_data_direction;
3097 		if (spx->txlt_sata_pkt != NULL &&
3098 		    direction != SATA_DIR_NODATA_XFER) {
3099 			if (spx->txlt_tmp_buf != NULL) {
3100 				/* Intermediate DMA buffer used */
3101 				bp = spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp;
3102 
3103 				if (direction & SATA_DIR_WRITE) {
3104 					bcopy(bp->b_un.b_addr,
3105 					    spx->txlt_tmp_buf, bp->b_bcount);
3106 				}
3107 			}
3108 			/* Sync the buffer for device or for CPU */
3109 			rval = ddi_dma_sync(spx->txlt_buf_dma_handle,   0, 0,
3110 			    (direction & SATA_DIR_WRITE) ?
3111 			    DDI_DMA_SYNC_FORDEV :  DDI_DMA_SYNC_FORCPU);
3112 			ASSERT(rval == DDI_SUCCESS);
3113 			if (spx->txlt_tmp_buf != NULL &&
3114 			    !(direction & SATA_DIR_WRITE)) {
3115 				/* Intermediate DMA buffer used for read */
3116 				bcopy(spx->txlt_tmp_buf,
3117 				    bp->b_un.b_addr, bp->b_bcount);
3118 			}
3119 
3120 		}
3121 	}
3122 }
3123 
3124 
3125 
3126 /* *******************  SATA - SCSI Translation functions **************** */
3127 /*
3128  * SCSI to SATA pkt and command translation and SATA to SCSI status/error
3129  * translation.
3130  */
3131 
3132 /*
3133  * Checks if a device exists and can be access and translates common
3134  * scsi_pkt data to sata_pkt data.
3135  *
3136  * Flag argument indicates that a non-read/write ATA command may be sent
3137  * to HBA in arbitrary SYNC mode to execute this packet.
3138  *
3139  * Returns TRAN_ACCEPT and scsi pkt_reason CMD_CMPLT if device exists and
3140  * sata_pkt was set-up.
3141  * Returns TRAN_ACCEPT and scsi pkt_reason CMD_DEV_GONE if device does not
3142  * exist and pkt_comp callback was scheduled.
3143  * Returns other TRAN_XXXXX values when error occured and command should be
3144  * rejected with the returned TRAN_XXXXX value.
3145  *
3146  * This function should be called with port mutex held.
3147  */
3148 static int
3149 sata_txlt_generic_pkt_info(sata_pkt_txlate_t *spx, int *reason, int flag)
3150 {
3151 	sata_drive_info_t *sdinfo;
3152 	sata_device_t sata_device;
3153 	const struct sata_cmd_flags sata_initial_cmd_flags = {
3154 		SATA_DIR_NODATA_XFER,
3155 		/* all other values to 0/FALSE */
3156 	};
3157 	/*
3158 	 * Pkt_reason has to be set if the pkt_comp callback is invoked,
3159 	 * and that implies TRAN_ACCEPT return value. Any other returned value
3160 	 * indicates that the scsi packet was not accepted (the reason will not
3161 	 * be checked by the scsi target driver).
3162 	 * To make debugging easier, we set pkt_reason to know value here.
3163 	 * It may be changed later when different completion reason is
3164 	 * determined.
3165 	 */
3166 	spx->txlt_scsi_pkt->pkt_reason = CMD_TRAN_ERR;
3167 	*reason = CMD_TRAN_ERR;
3168 
3169 	/* Validate address */
3170 	switch (sata_validate_scsi_address(spx->txlt_sata_hba_inst,
3171 	    &spx->txlt_scsi_pkt->pkt_address, &sata_device)) {
3172 
3173 	case -1:
3174 		/* Invalid address or invalid device type */
3175 		return (TRAN_BADPKT);
3176 	case 2:
3177 		/*
3178 		 * Valid address but device type is unknown - Chack if it is
3179 		 * in the reset state and therefore in an indeterminate state.
3180 		 */
3181 		sdinfo = sata_get_device_info(spx->txlt_sata_hba_inst,
3182 		    &spx->txlt_sata_pkt->satapkt_device);
3183 		if (sdinfo != NULL && (sdinfo->satadrv_event_flags &
3184 		    (SATA_EVNT_DEVICE_RESET |
3185 		    SATA_EVNT_INPROC_DEVICE_RESET)) != 0) {
3186 			if (!ddi_in_panic()) {
3187 				spx->txlt_scsi_pkt->pkt_reason = CMD_INCOMPLETE;
3188 				*reason = CMD_INCOMPLETE;
3189 				SATADBG1(SATA_DBG_SCSI_IF,
3190 				    spx->txlt_sata_hba_inst,
3191 				    "sata_scsi_start: rejecting command "
3192 				    "because of device reset state\n", NULL);
3193 				return (TRAN_BUSY);
3194 			}
3195 		}
3196 		/* FALLTHROUGH */
3197 	case 1:
3198 		/* valid address but no valid device - it has disappeared */
3199 		spx->txlt_scsi_pkt->pkt_reason = CMD_DEV_GONE;
3200 		*reason = CMD_DEV_GONE;
3201 		/*
3202 		 * The sd target driver is checking CMD_DEV_GONE pkt_reason
3203 		 * only in callback function (for normal requests) and
3204 		 * in the dump code path.
3205 		 * So, if the callback is available, we need to do
3206 		 * the callback rather than returning TRAN_FATAL_ERROR here.
3207 		 */
3208 		if (spx->txlt_scsi_pkt->pkt_comp != NULL) {
3209 			/* scsi callback required */
3210 			if (servicing_interrupt()) {
3211 				if (taskq_dispatch(SATA_TXLT_TASKQ(spx),
3212 				    (task_func_t *)spx->txlt_scsi_pkt->pkt_comp,
3213 				    (void *)spx->txlt_scsi_pkt, TQ_NOSLEEP) ==
3214 				    NULL) {
3215 					return (TRAN_BUSY);
3216 				}
3217 			} else if (taskq_dispatch(SATA_TXLT_TASKQ(spx),
3218 			    (task_func_t *)spx->txlt_scsi_pkt->pkt_comp,
3219 			    (void *)spx->txlt_scsi_pkt, TQ_SLEEP) == NULL) {
3220 				/* Scheduling the callback failed */
3221 				return (TRAN_BUSY);
3222 			}
3223 
3224 			return (TRAN_ACCEPT);
3225 		}
3226 		return (TRAN_FATAL_ERROR);
3227 	default:
3228 		/* all OK; pkt reason will be overwritten later */
3229 		break;
3230 	}
3231 	/*
3232 	 * If pkt is to be executed in polling mode and a command will not be
3233 	 * emulated in SATA module (requires sending a non-read/write ATA
3234 	 * command to HBA driver in arbitrary SYNC mode) and we are in the
3235 	 * interrupt context and not in the panic dump, then reject the packet
3236 	 * to avoid a possible interrupt stack overrun or hang caused by
3237 	 * a potentially blocked interrupt.
3238 	 */
3239 	if (((spx->txlt_scsi_pkt->pkt_flags & FLAG_NOINTR) != 0 || flag != 0) &&
3240 	    servicing_interrupt() && !ddi_in_panic()) {
3241 		SATADBG1(SATA_DBG_INTR_CTX, spx->txlt_sata_hba_inst,
3242 		    "sata_scsi_start: rejecting synchronous command because "
3243 		    "of interrupt context\n", NULL);
3244 		return (TRAN_BUSY);
3245 	}
3246 
3247 	sdinfo = sata_get_device_info(spx->txlt_sata_hba_inst,
3248 	    &spx->txlt_sata_pkt->satapkt_device);
3249 
3250 	/*
3251 	 * If device is in reset condition, reject the packet with
3252 	 * TRAN_BUSY, unless:
3253 	 * 1. system is panicking (dumping)
3254 	 * In such case only one thread is running and there is no way to
3255 	 * process reset.
3256 	 * 2. cfgadm operation is is progress (internal APCTL lock is set)
3257 	 * Some cfgadm operations involve drive commands, so reset condition
3258 	 * needs to be ignored for IOCTL operations.
3259 	 */
3260 	if ((sdinfo->satadrv_event_flags &
3261 	    (SATA_EVNT_DEVICE_RESET | SATA_EVNT_INPROC_DEVICE_RESET)) != 0) {
3262 
3263 		if (!ddi_in_panic() &&
3264 		    ((SATA_CPORT_EVENT_FLAGS(spx->txlt_sata_hba_inst,
3265 		    sata_device.satadev_addr.cport) &
3266 		    SATA_APCTL_LOCK_PORT_BUSY) == 0)) {
3267 			spx->txlt_scsi_pkt->pkt_reason = CMD_INCOMPLETE;
3268 			*reason = CMD_INCOMPLETE;
3269 			SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst,
3270 			    "sata_scsi_start: rejecting command because "
3271 			    "of device reset state\n", NULL);
3272 			return (TRAN_BUSY);
3273 		}
3274 	}
3275 
3276 	/*
3277 	 * Fix the dev_type in the sata_pkt->satapkt_device. It was not set by
3278 	 * sata_scsi_pkt_init() because pkt init had to work also with
3279 	 * non-existing devices.
3280 	 * Now we know that the packet was set-up for a real device, so its
3281 	 * type is known.
3282 	 */
3283 	spx->txlt_sata_pkt->satapkt_device.satadev_type = sdinfo->satadrv_type;
3284 
3285 	spx->txlt_sata_pkt->satapkt_cmd.satacmd_flags = sata_initial_cmd_flags;
3286 	if ((SATA_CPORT_INFO(spx->txlt_sata_hba_inst,
3287 	    sata_device.satadev_addr.cport)->cport_event_flags &
3288 	    SATA_APCTL_LOCK_PORT_BUSY) != 0) {
3289 		spx->txlt_sata_pkt->satapkt_cmd.satacmd_flags.
3290 		    sata_ignore_dev_reset = B_TRUE;
3291 	}
3292 	/*
3293 	 * At this point the generic translation routine determined that the
3294 	 * scsi packet should be accepted. Packet completion reason may be
3295 	 * changed later when a different completion reason is determined.
3296 	 */
3297 	spx->txlt_scsi_pkt->pkt_reason = CMD_CMPLT;
3298 	*reason = CMD_CMPLT;
3299 
3300 	if ((spx->txlt_scsi_pkt->pkt_flags & FLAG_NOINTR) != 0) {
3301 		/* Synchronous execution */
3302 		spx->txlt_sata_pkt->satapkt_op_mode = SATA_OPMODE_SYNCH |
3303 		    SATA_OPMODE_POLLING;
3304 		spx->txlt_sata_pkt->satapkt_cmd.satacmd_flags.
3305 		    sata_ignore_dev_reset = ddi_in_panic();
3306 	} else {
3307 		/* Asynchronous execution */
3308 		spx->txlt_sata_pkt->satapkt_op_mode = SATA_OPMODE_ASYNCH |
3309 		    SATA_OPMODE_INTERRUPTS;
3310 	}
3311 	/* Convert queuing information */
3312 	if (spx->txlt_scsi_pkt->pkt_flags & FLAG_STAG)
3313 		spx->txlt_sata_pkt->satapkt_cmd.satacmd_flags.sata_queue_stag =
3314 		    B_TRUE;
3315 	else if (spx->txlt_scsi_pkt->pkt_flags &
3316 	    (FLAG_OTAG | FLAG_HTAG | FLAG_HEAD))
3317 		spx->txlt_sata_pkt->satapkt_cmd.satacmd_flags.sata_queue_otag =
3318 		    B_TRUE;
3319 
3320 	/* Always limit pkt time */
3321 	if (spx->txlt_scsi_pkt->pkt_time == 0)
3322 		spx->txlt_sata_pkt->satapkt_time = sata_default_pkt_time;
3323 	else
3324 		/* Pass on scsi_pkt time */
3325 		spx->txlt_sata_pkt->satapkt_time =
3326 		    spx->txlt_scsi_pkt->pkt_time;
3327 
3328 	return (TRAN_ACCEPT);
3329 }
3330 
3331 
3332 /*
3333  * Translate ATA Identify Device data to SCSI Inquiry data.
3334  * This function may be called only for ATA devices.
3335  * This function should not be called for ATAPI devices - they
3336  * respond directly to SCSI Inquiry command.
3337  *
3338  * SATA Identify Device data has to be valid in sata_drive_info.
3339  * Buffer has to accomodate the inquiry length (36 bytes).
3340  *
3341  * This function should be called with a port mutex held.
3342  */
3343 static	void
3344 sata_identdev_to_inquiry(sata_hba_inst_t *sata_hba_inst,
3345     sata_drive_info_t *sdinfo, uint8_t *buf)
3346 {
3347 
3348 	struct scsi_inquiry *inq = (struct scsi_inquiry *)buf;
3349 	struct sata_id *sid = &sdinfo->satadrv_id;
3350 
3351 	/* Start with a nice clean slate */
3352 	bzero((void *)inq, sizeof (struct scsi_inquiry));
3353 
3354 	/*
3355 	 * Rely on the dev_type for setting paripheral qualifier.
3356 	 * Assume that  DTYPE_RODIRECT applies to CD/DVD R/W devices.
3357 	 * It could be that DTYPE_OPTICAL could also qualify in the future.
3358 	 * ATAPI Inquiry may provide more data to the target driver.
3359 	 */
3360 	inq->inq_dtype = sdinfo->satadrv_type == SATA_DTYPE_ATADISK ?
3361 	    DTYPE_DIRECT : DTYPE_RODIRECT; /* DTYPE_UNKNOWN; */
3362 
3363 	/* CFA type device is not a removable media device */
3364 	inq->inq_rmb = ((sid->ai_config != SATA_CFA_TYPE) &&
3365 	    (sid->ai_config & SATA_REM_MEDIA)) ? 1 : 0;
3366 	inq->inq_qual = 0;	/* Device type qualifier (obsolete in SCSI3? */
3367 	inq->inq_iso = 0;	/* ISO version */
3368 	inq->inq_ecma = 0;	/* ECMA version */
3369 	inq->inq_ansi = 3;	/* ANSI version - SCSI 3 */
3370 	inq->inq_aenc = 0;	/* Async event notification cap. */
3371 	inq->inq_trmiop = 0;	/* Supports TERMINATE I/O PROC msg - NO */
3372 	inq->inq_normaca = 0;	/* setting NACA bit supported - NO */
3373 	inq->inq_rdf = RDF_SCSI2; /* Response data format- SPC-3 */
3374 	inq->inq_len = 31;	/* Additional length */
3375 	inq->inq_dualp = 0;	/* dual port device - NO */
3376 	inq->inq_reladdr = 0;	/* Supports relative addressing - NO */
3377 	inq->inq_sync = 0;	/* Supports synchronous data xfers - NO */
3378 	inq->inq_linked = 0;	/* Supports linked commands - NO */
3379 				/*
3380 				 * Queuing support - controller has to
3381 				 * support some sort of command queuing.
3382 				 */
3383 	if (SATA_QDEPTH(sata_hba_inst) > 1)
3384 		inq->inq_cmdque = 1; /* Supports command queueing - YES */
3385 	else
3386 		inq->inq_cmdque = 0; /* Supports command queueing - NO */
3387 	inq->inq_sftre = 0;	/* Supports Soft Reset option - NO ??? */
3388 	inq->inq_wbus32 = 0;	/* Supports 32 bit wide data xfers - NO */
3389 	inq->inq_wbus16 = 0;	/* Supports 16 bit wide data xfers - NO */
3390 
3391 #ifdef	_LITTLE_ENDIAN
3392 	/* Swap text fields to match SCSI format */
3393 	bcopy("ATA     ", inq->inq_vid, 8);		/* Vendor ID */
3394 	swab(sid->ai_model, inq->inq_pid, 16);		/* Product ID */
3395 	if (strncmp(&sid->ai_fw[4], "    ", 4) == 0)
3396 		swab(sid->ai_fw, inq->inq_revision, 4);	/* Revision level */
3397 	else
3398 		swab(&sid->ai_fw[4], inq->inq_revision, 4);	/* Rev. level */
3399 #else	/* _LITTLE_ENDIAN */
3400 	bcopy("ATA     ", inq->inq_vid, 8);		/* Vendor ID */
3401 	bcopy(sid->ai_model, inq->inq_pid, 16);		/* Product ID */
3402 	if (strncmp(&sid->ai_fw[4], "    ", 4) == 0)
3403 		bcopy(sid->ai_fw, inq->inq_revision, 4); /* Revision level */
3404 	else
3405 		bcopy(&sid->ai_fw[4], inq->inq_revision, 4); /* Rev. level */
3406 #endif	/* _LITTLE_ENDIAN */
3407 }
3408 
3409 
3410 /*
3411  * Scsi response set up for invalid command (command not supported)
3412  *
3413  * Returns TRAN_ACCEPT and appropriate values in scsi_pkt fields.
3414  */
3415 static int
3416 sata_txlt_invalid_command(sata_pkt_txlate_t *spx)
3417 {
3418 	struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt;
3419 	struct scsi_extended_sense *sense;
3420 
3421 	scsipkt->pkt_reason = CMD_CMPLT;
3422 	scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET |
3423 	    STATE_SENT_CMD | STATE_GOT_STATUS;
3424 
3425 	*scsipkt->pkt_scbp = STATUS_CHECK;
3426 
3427 	sense = sata_arq_sense(spx);
3428 	sense->es_key = KEY_ILLEGAL_REQUEST;
3429 	sense->es_add_code = SD_SCSI_ASC_INVALID_COMMAND_CODE;
3430 
3431 	SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst,
3432 	    "Scsi_pkt completion reason %x\n", scsipkt->pkt_reason);
3433 
3434 	if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0 &&
3435 	    scsipkt->pkt_comp != NULL) {
3436 		/* scsi callback required */
3437 		if (servicing_interrupt()) {
3438 			if (taskq_dispatch(SATA_TXLT_TASKQ(spx),
3439 			    (task_func_t *)spx->txlt_scsi_pkt->pkt_comp,
3440 			    (void *)spx->txlt_scsi_pkt, TQ_NOSLEEP) == NULL) {
3441 				return (TRAN_BUSY);
3442 			}
3443 		} else if (taskq_dispatch(SATA_TXLT_TASKQ(spx),
3444 		    (task_func_t *)spx->txlt_scsi_pkt->pkt_comp,
3445 		    (void *)spx->txlt_scsi_pkt, TQ_SLEEP) == NULL) {
3446 			/* Scheduling the callback failed */
3447 			return (TRAN_BUSY);
3448 		}
3449 	}
3450 	return (TRAN_ACCEPT);
3451 }
3452 
3453 /*
3454  * Scsi response set up for check condition with special sense key
3455  * and additional sense code.
3456  *
3457  * Returns TRAN_ACCEPT and appropriate values in scsi_pkt fields.
3458  */
3459 static int
3460 sata_txlt_check_condition(sata_pkt_txlate_t *spx, uchar_t key, uchar_t code)
3461 {
3462 	sata_hba_inst_t *shi = SATA_TXLT_HBA_INST(spx);
3463 	int cport = SATA_TXLT_CPORT(spx);
3464 	struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt;
3465 	struct scsi_extended_sense *sense;
3466 
3467 	mutex_enter(&SATA_CPORT_MUTEX(shi, cport));
3468 	scsipkt->pkt_reason = CMD_CMPLT;
3469 	scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET |
3470 	    STATE_SENT_CMD | STATE_GOT_STATUS;
3471 
3472 	*scsipkt->pkt_scbp = STATUS_CHECK;
3473 
3474 	sense = sata_arq_sense(spx);
3475 	sense->es_key = key;
3476 	sense->es_add_code = code;
3477 
3478 	mutex_exit(&SATA_CPORT_MUTEX(shi, cport));
3479 
3480 	SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst,
3481 	    "Scsi_pkt completion reason %x\n", scsipkt->pkt_reason);
3482 
3483 	if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0 &&
3484 	    scsipkt->pkt_comp != NULL) {
3485 		/* scsi callback required */
3486 		if (servicing_interrupt()) {
3487 			if (taskq_dispatch(SATA_TXLT_TASKQ(spx),
3488 			    (task_func_t *)spx->txlt_scsi_pkt->pkt_comp,
3489 			    (void *)spx->txlt_scsi_pkt, TQ_NOSLEEP) == NULL) {
3490 				return (TRAN_BUSY);
3491 			}
3492 		} else if (taskq_dispatch(SATA_TXLT_TASKQ(spx),
3493 		    (task_func_t *)spx->txlt_scsi_pkt->pkt_comp,
3494 		    (void *)spx->txlt_scsi_pkt, TQ_SLEEP) == NULL) {
3495 			/* Scheduling the callback failed */
3496 			return (TRAN_BUSY);
3497 		}
3498 	}
3499 	return (TRAN_ACCEPT);
3500 }
3501 
3502 /*
3503  * Scsi response setup for
3504  * emulated non-data command that requires no action/return data
3505  *
3506  * Returns TRAN_ACCEPT and appropriate values in scsi_pkt fields.
3507  */
3508 static	int
3509 sata_txlt_nodata_cmd_immediate(sata_pkt_txlate_t *spx)
3510 {
3511 	int rval;
3512 	int reason;
3513 	kmutex_t *cport_mutex =  &(SATA_TXLT_CPORT_MUTEX(spx));
3514 
3515 	mutex_enter(cport_mutex);
3516 
3517 	if (((rval = sata_txlt_generic_pkt_info(spx, &reason, 0)) !=
3518 	    TRAN_ACCEPT) || (reason == CMD_DEV_GONE)) {
3519 		mutex_exit(cport_mutex);
3520 		return (rval);
3521 	}
3522 	mutex_exit(cport_mutex);
3523 
3524 	spx->txlt_scsi_pkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET |
3525 	    STATE_SENT_CMD | STATE_GOT_STATUS;
3526 	spx->txlt_scsi_pkt->pkt_reason = CMD_CMPLT;
3527 	*(spx->txlt_scsi_pkt->pkt_scbp) = STATUS_GOOD;
3528 
3529 	SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst,
3530 	    "Scsi_pkt completion reason %x\n",
3531 	    spx->txlt_scsi_pkt->pkt_reason);
3532 
3533 	if ((spx->txlt_scsi_pkt->pkt_flags & FLAG_NOINTR) == 0 &&
3534 	    spx->txlt_scsi_pkt->pkt_comp != NULL) {
3535 		/* scsi callback required */
3536 		if (servicing_interrupt()) {
3537 			if (taskq_dispatch(SATA_TXLT_TASKQ(spx),
3538 			    (task_func_t *)spx->txlt_scsi_pkt->pkt_comp,
3539 			    (void *)spx->txlt_scsi_pkt, TQ_NOSLEEP) == NULL) {
3540 				return (TRAN_BUSY);
3541 			}
3542 		} else if (taskq_dispatch(SATA_TXLT_TASKQ(spx),
3543 		    (task_func_t *)spx->txlt_scsi_pkt->pkt_comp,
3544 		    (void *)spx->txlt_scsi_pkt, TQ_SLEEP) == NULL) {
3545 			/* Scheduling the callback failed */
3546 			return (TRAN_BUSY);
3547 		}
3548 	}
3549 	return (TRAN_ACCEPT);
3550 }
3551 
3552 
3553 /*
3554  * SATA translate command: Inquiry / Identify Device
3555  * Use cached Identify Device data for now, rather than issuing actual
3556  * Device Identify cmd request. If device is detached and re-attached,
3557  * asynchronous event processing should fetch and refresh Identify Device
3558  * data.
3559  * VPD pages supported now:
3560  * Vital Product Data page
3561  * Unit Serial Number page
3562  * Block Device Characteristics Page
3563  * ATA Information Page
3564  *
3565  * Returns TRAN_ACCEPT and appropriate values in scsi_pkt fields.
3566  */
3567 
3568 #define	EVPD			1	/* Extended Vital Product Data flag */
3569 #define	CMDDT			2	/* Command Support Data - Obsolete */
3570 #define	INQUIRY_SUP_VPD_PAGE	0	/* Supported VPD Pages Page Code */
3571 #define	INQUIRY_USN_PAGE	0x80	/* Unit Serial Number Page Code */
3572 #define	INQUIRY_BDC_PAGE	0xB1	/* Block Device Characteristics Page */
3573 					/* Code */
3574 #define	INQUIRY_ATA_INFO_PAGE	0x89	/* ATA Information Page Code */
3575 #define	INQUIRY_DEV_IDENTIFICATION_PAGE 0x83 /* Not needed yet */
3576 
3577 static int
3578 sata_txlt_inquiry(sata_pkt_txlate_t *spx)
3579 {
3580 	struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt;
3581 	struct buf *bp = spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp;
3582 	sata_drive_info_t *sdinfo;
3583 	struct scsi_extended_sense *sense;
3584 	int count;
3585 	uint8_t *p;
3586 	int i, j;
3587 	uint8_t page_buf[1024]; /* Max length */
3588 	int rval, reason;
3589 	ushort_t rate;
3590 	kmutex_t *cport_mutex = &(SATA_TXLT_CPORT_MUTEX(spx));
3591 
3592 	mutex_enter(cport_mutex);
3593 
3594 	if (((rval = sata_txlt_generic_pkt_info(spx, &reason, 0)) !=
3595 	    TRAN_ACCEPT) || (reason == CMD_DEV_GONE)) {
3596 		mutex_exit(cport_mutex);
3597 		return (rval);
3598 	}
3599 
3600 	sdinfo = sata_get_device_info(spx->txlt_sata_hba_inst,
3601 	    &spx->txlt_sata_pkt->satapkt_device);
3602 
3603 	ASSERT(sdinfo != NULL);
3604 
3605 	scsipkt->pkt_reason = CMD_CMPLT;
3606 	scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET |
3607 	    STATE_SENT_CMD | STATE_GOT_STATUS;
3608 
3609 	/* Reject not supported request */
3610 	if (scsipkt->pkt_cdbp[1] & CMDDT) { /* No support for this bit */
3611 		*scsipkt->pkt_scbp = STATUS_CHECK;
3612 		sense = sata_arq_sense(spx);
3613 		sense->es_key = KEY_ILLEGAL_REQUEST;
3614 		sense->es_add_code = SD_SCSI_ASC_INVALID_FIELD_IN_CDB;
3615 		goto done;
3616 	}
3617 
3618 	/* Valid Inquiry request */
3619 	*scsipkt->pkt_scbp = STATUS_GOOD;
3620 
3621 	if (bp != NULL && bp->b_un.b_addr && bp->b_bcount) {
3622 
3623 		/*
3624 		 * Because it is fully emulated command storing data
3625 		 * programatically in the specified buffer, release
3626 		 * preallocated DMA resources before storing data in the buffer,
3627 		 * so no unwanted DMA sync would take place.
3628 		 */
3629 		sata_scsi_dmafree(NULL, scsipkt);
3630 
3631 		if (!(scsipkt->pkt_cdbp[1] & EVPD)) {
3632 			/* Standard Inquiry Data request */
3633 			struct scsi_inquiry inq;
3634 			unsigned int bufsize;
3635 
3636 			sata_identdev_to_inquiry(spx->txlt_sata_hba_inst,
3637 			    sdinfo, (uint8_t *)&inq);
3638 			/* Copy no more than requested */
3639 			count = MIN(bp->b_bcount,
3640 			    sizeof (struct scsi_inquiry));
3641 			bufsize = scsipkt->pkt_cdbp[4];
3642 			bufsize |= scsipkt->pkt_cdbp[3] << 8;
3643 			count = MIN(count, bufsize);
3644 			bcopy(&inq, bp->b_un.b_addr, count);
3645 
3646 			scsipkt->pkt_state |= STATE_XFERRED_DATA;
3647 			scsipkt->pkt_resid = scsipkt->pkt_cdbp[4] > count ?
3648 			    bufsize - count : 0;
3649 		} else {
3650 			/*
3651 			 * peripheral_qualifier = 0;
3652 			 *
3653 			 * We are dealing only with HD and will be
3654 			 * dealing with CD/DVD devices soon
3655 			 */
3656 			uint8_t peripheral_device_type =
3657 			    sdinfo->satadrv_type == SATA_DTYPE_ATADISK ?
3658 			    DTYPE_DIRECT : DTYPE_RODIRECT;
3659 
3660 			bzero(page_buf, sizeof (page_buf));
3661 
3662 			switch ((uint_t)scsipkt->pkt_cdbp[2]) {
3663 			case INQUIRY_SUP_VPD_PAGE:
3664 				/*
3665 				 * Request for supported Vital Product Data
3666 				 * pages.
3667 				 */
3668 				page_buf[0] = peripheral_device_type;
3669 				page_buf[1] = INQUIRY_SUP_VPD_PAGE;
3670 				page_buf[2] = 0;
3671 				page_buf[3] = 4; /* page length */
3672 				page_buf[4] = INQUIRY_SUP_VPD_PAGE;
3673 				page_buf[5] = INQUIRY_USN_PAGE;
3674 				page_buf[6] = INQUIRY_BDC_PAGE;
3675 				page_buf[7] = INQUIRY_ATA_INFO_PAGE;
3676 				/* Copy no more than requested */
3677 				count = MIN(bp->b_bcount, 8);
3678 				bcopy(page_buf, bp->b_un.b_addr, count);
3679 				break;
3680 
3681 			case INQUIRY_USN_PAGE:
3682 				/*
3683 				 * Request for Unit Serial Number page.
3684 				 * Set-up the page.
3685 				 */
3686 				page_buf[0] = peripheral_device_type;
3687 				page_buf[1] = INQUIRY_USN_PAGE;
3688 				page_buf[2] = 0;
3689 				/* remaining page length */
3690 				page_buf[3] = SATA_ID_SERIAL_LEN;
3691 
3692 				/*
3693 				 * Copy serial number from Identify Device data
3694 				 * words into the inquiry page and swap bytes
3695 				 * when necessary.
3696 				 */
3697 				p = (uint8_t *)(sdinfo->satadrv_id.ai_drvser);
3698 #ifdef	_LITTLE_ENDIAN
3699 				swab(p, &page_buf[4], SATA_ID_SERIAL_LEN);
3700 #else
3701 				bcopy(p, &page_buf[4], SATA_ID_SERIAL_LEN);
3702 #endif
3703 				/*
3704 				 * Least significant character of the serial
3705 				 * number shall appear as the last byte,
3706 				 * according to SBC-3 spec.
3707 				 * Count trailing spaces to determine the
3708 				 * necessary shift length.
3709 				 */
3710 				p = &page_buf[SATA_ID_SERIAL_LEN + 4 - 1];
3711 				for (j = 0; j < SATA_ID_SERIAL_LEN; j++) {
3712 					if (*(p - j) != '\0' &&
3713 					    *(p - j) != '\040')
3714 						break;
3715 				}
3716 
3717 				/*
3718 				 * Shift SN string right, so that the last
3719 				 * non-blank character would appear in last
3720 				 * byte of SN field in the page.
3721 				 * 'j' is the shift length.
3722 				 */
3723 				for (i = 0;
3724 				    i < (SATA_ID_SERIAL_LEN - j) && j != 0;
3725 				    i++, p--)
3726 					*p = *(p - j);
3727 
3728 				/*
3729 				 * Add leading spaces - same number as the
3730 				 * shift size
3731 				 */
3732 				for (; j > 0; j--)
3733 					page_buf[4 + j - 1] = '\040';
3734 
3735 				count = MIN(bp->b_bcount,
3736 				    SATA_ID_SERIAL_LEN + 4);
3737 				bcopy(page_buf, bp->b_un.b_addr, count);
3738 				break;
3739 
3740 			case INQUIRY_BDC_PAGE:
3741 				/*
3742 				 * Request for Block Device Characteristics
3743 				 * page.  Set-up the page.
3744 				 */
3745 				page_buf[0] = peripheral_device_type;
3746 				page_buf[1] = INQUIRY_BDC_PAGE;
3747 				page_buf[2] = 0;
3748 				/* remaining page length */
3749 				page_buf[3] = SATA_ID_BDC_LEN;
3750 
3751 				rate = sdinfo->satadrv_id.ai_medrotrate;
3752 				page_buf[4] = (rate >> 8) & 0xff;
3753 				page_buf[5] = rate & 0xff;
3754 				page_buf[6] = 0;
3755 				page_buf[7] = sdinfo->satadrv_id.
3756 				    ai_nomformfactor & 0xf;
3757 
3758 				count = MIN(bp->b_bcount,
3759 				    SATA_ID_BDC_LEN + 4);
3760 				bcopy(page_buf, bp->b_un.b_addr, count);
3761 				break;
3762 
3763 			case INQUIRY_ATA_INFO_PAGE:
3764 				/*
3765 				 * Request for ATA Information page.
3766 				 */
3767 				page_buf[0] = peripheral_device_type;
3768 				page_buf[1] = INQUIRY_ATA_INFO_PAGE;
3769 				page_buf[2] = (SATA_ID_ATA_INFO_LEN >> 8) &
3770 				    0xff;
3771 				page_buf[3] = SATA_ID_ATA_INFO_LEN & 0xff;
3772 				/* page_buf[4-7] reserved */
3773 #ifdef  _LITTLE_ENDIAN
3774 				bcopy("ATA     ", &page_buf[8], 8);
3775 				swab(sdinfo->satadrv_id.ai_model,
3776 				    &page_buf[16], 16);
3777 				if (strncmp(&sdinfo->satadrv_id.ai_fw[4],
3778 				    "    ", 4) == 0) {
3779 					swab(sdinfo->satadrv_id.ai_fw,
3780 					    &page_buf[32], 4);
3781 				} else {
3782 					swab(&sdinfo->satadrv_id.ai_fw[4],
3783 					    &page_buf[32], 4);
3784 				}
3785 #else   /* _LITTLE_ENDIAN */
3786 				bcopy("ATA     ", &page_buf[8], 8);
3787 				bcopy(sdinfo->satadrv_id.ai_model,
3788 				    &page_buf[16], 16);
3789 				if (strncmp(&sdinfo->satadrv_id.ai_fw[4],
3790 				    "    ", 4) == 0) {
3791 					bcopy(sdinfo->satadrv_id.ai_fw,
3792 					    &page_buf[32], 4);
3793 				} else {
3794 					bcopy(&sdinfo->satadrv_id.ai_fw[4],
3795 					    &page_buf[32], 4);
3796 				}
3797 #endif  /* _LITTLE_ENDIAN */
3798 				/*
3799 				 * page_buf[36-55] which defines the device
3800 				 * signature is not defined at this
3801 				 * time.
3802 				 */
3803 
3804 				/* Set the command code */
3805 				if (sdinfo->satadrv_type ==
3806 				    SATA_DTYPE_ATADISK) {
3807 					page_buf[56] = SATAC_ID_DEVICE;
3808 				} else if (sdinfo->satadrv_type ==
3809 				    SATA_DTYPE_ATAPI) {
3810 					page_buf[56] = SATAC_ID_PACKET_DEVICE;
3811 				}
3812 				/*
3813 				 * If the command code, page_buf[56], is not
3814 				 * zero and if one of the identify commands
3815 				 * succeeds, return the identify data.
3816 				 */
3817 				if ((page_buf[56] != 0) &&
3818 				    (sata_fetch_device_identify_data(
3819 				    spx->txlt_sata_hba_inst, sdinfo) ==
3820 				    SATA_SUCCESS)) {
3821 					bcopy(&sdinfo->satadrv_id,
3822 					    &page_buf[60], sizeof (sata_id_t));
3823 				}
3824 
3825 				/* Need to copy out the page_buf to bp */
3826 				count = MIN(bp->b_bcount,
3827 				    SATA_ID_ATA_INFO_LEN + 4);
3828 				bcopy(page_buf, bp->b_un.b_addr, count);
3829 				break;
3830 
3831 			case INQUIRY_DEV_IDENTIFICATION_PAGE:
3832 				/*
3833 				 * We may want to implement this page, when
3834 				 * identifiers are common for SATA devices
3835 				 * But not now.
3836 				 */
3837 				/*FALLTHROUGH*/
3838 
3839 			default:
3840 				/* Request for unsupported VPD page */
3841 				*scsipkt->pkt_scbp = STATUS_CHECK;
3842 				sense = sata_arq_sense(spx);
3843 				sense->es_key = KEY_ILLEGAL_REQUEST;
3844 				sense->es_add_code =
3845 				    SD_SCSI_ASC_INVALID_FIELD_IN_CDB;
3846 				goto done;
3847 			}
3848 		}
3849 		scsipkt->pkt_state |= STATE_XFERRED_DATA;
3850 		scsipkt->pkt_resid = scsipkt->pkt_cdbp[4] > count ?
3851 		    scsipkt->pkt_cdbp[4] - count : 0;
3852 	}
3853 done:
3854 	mutex_exit(cport_mutex);
3855 
3856 	SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst,
3857 	    "Scsi_pkt completion reason %x\n",
3858 	    scsipkt->pkt_reason);
3859 
3860 	if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0 &&
3861 	    scsipkt->pkt_comp != NULL) {
3862 		/* scsi callback required */
3863 		if (servicing_interrupt()) {
3864 			if (taskq_dispatch(SATA_TXLT_TASKQ(spx),
3865 			    (task_func_t *)spx->txlt_scsi_pkt->pkt_comp,
3866 			    (void *)spx->txlt_scsi_pkt, TQ_NOSLEEP) == NULL) {
3867 				return (TRAN_BUSY);
3868 			}
3869 		} else if (taskq_dispatch(SATA_TXLT_TASKQ(spx),
3870 		    (task_func_t *)spx->txlt_scsi_pkt->pkt_comp,
3871 		    (void *)spx->txlt_scsi_pkt, TQ_SLEEP) == NULL) {
3872 			/* Scheduling the callback failed */
3873 			return (TRAN_BUSY);
3874 		}
3875 	}
3876 	return (TRAN_ACCEPT);
3877 }
3878 
3879 /*
3880  * SATA translate command: Request Sense.
3881  *
3882  * Returns TRAN_ACCEPT and appropriate values in scsi_pkt fields.
3883  * At the moment this is an emulated command (ATA version for SATA hard disks).
3884  * May be translated into Check Power Mode command in the future.
3885  *
3886  * Note: There is a mismatch between already implemented Informational
3887  * Exception Mode Select page 0x1C and this function.
3888  * When MRIE bit is set in page 0x1C, Request Sense is supposed to return
3889  * NO SENSE and set additional sense code to the exception code - this is not
3890  * implemented here.
3891  */
3892 static int
3893 sata_txlt_request_sense(sata_pkt_txlate_t *spx)
3894 {
3895 	struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt;
3896 	struct scsi_extended_sense sense;
3897 	struct buf *bp = spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp;
3898 	sata_drive_info_t *sdinfo;
3899 	sata_cmd_t *scmd = &spx->txlt_sata_pkt->satapkt_cmd;
3900 	int rval, reason, power_state = 0;
3901 	kmutex_t *cport_mutex;
3902 
3903 	cport_mutex = &(SATA_TXLT_CPORT_MUTEX(spx));
3904 	mutex_enter(cport_mutex);
3905 
3906 	if (((rval = sata_txlt_generic_pkt_info(spx, &reason, 1)) !=
3907 	    TRAN_ACCEPT) || (reason == CMD_DEV_GONE)) {
3908 		mutex_exit(cport_mutex);
3909 		return (rval);
3910 	}
3911 
3912 	scsipkt->pkt_reason = CMD_CMPLT;
3913 	scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET |
3914 	    STATE_SENT_CMD | STATE_GOT_STATUS;
3915 	*scsipkt->pkt_scbp = STATUS_GOOD;
3916 
3917 	/*
3918 	 * when CONTROL field's NACA bit == 1
3919 	 * return ILLEGAL_REQUEST
3920 	 */
3921 	if (scsipkt->pkt_cdbp[5] & CTL_BYTE_NACA_MASK) {
3922 		mutex_exit(cport_mutex);
3923 		return (sata_txlt_check_condition(spx, KEY_ILLEGAL_REQUEST,
3924 		    SD_SCSI_ASC_CMD_SEQUENCE_ERR));
3925 	}
3926 
3927 	sdinfo = sata_get_device_info(spx->txlt_sata_hba_inst,
3928 	    &spx->txlt_sata_pkt->satapkt_device);
3929 	ASSERT(sdinfo != NULL);
3930 
3931 	spx->txlt_sata_pkt->satapkt_op_mode |= SATA_OPMODE_SYNCH;
3932 
3933 	sata_build_generic_cmd(scmd, SATAC_CHECK_POWER_MODE);
3934 	scmd->satacmd_flags.sata_copy_out_sec_count_lsb = B_TRUE;
3935 	scmd->satacmd_flags.sata_copy_out_error_reg = B_TRUE;
3936 	if (sata_hba_start(spx, &rval) != 0) {
3937 		mutex_exit(cport_mutex);
3938 		return (rval);
3939 	}
3940 	if (scmd->satacmd_error_reg != 0) {
3941 		mutex_exit(cport_mutex);
3942 		return (sata_txlt_check_condition(spx, KEY_NO_SENSE,
3943 		    SD_SCSI_ASC_NO_ADD_SENSE));
3944 	}
3945 
3946 	switch (scmd->satacmd_sec_count_lsb) {
3947 	case SATA_PWRMODE_STANDBY: /* device in standby mode */
3948 		if (sdinfo->satadrv_power_level == SATA_POWER_STOPPED)
3949 			power_state = SATA_POWER_STOPPED;
3950 		else {
3951 			power_state = SATA_POWER_STANDBY;
3952 			sdinfo->satadrv_power_level = SATA_POWER_STANDBY;
3953 		}
3954 		break;
3955 	case SATA_PWRMODE_IDLE: /* device in idle mode */
3956 		power_state = SATA_POWER_IDLE;
3957 		sdinfo->satadrv_power_level = SATA_POWER_IDLE;
3958 		break;
3959 	case SATA_PWRMODE_ACTIVE: /* device in active or idle mode */
3960 	default:		  /* 0x40, 0x41 active mode */
3961 		if (sdinfo->satadrv_power_level == SATA_POWER_IDLE)
3962 			power_state = SATA_POWER_IDLE;
3963 		else {
3964 			power_state = SATA_POWER_ACTIVE;
3965 			sdinfo->satadrv_power_level = SATA_POWER_ACTIVE;
3966 		}
3967 		break;
3968 	}
3969 
3970 	mutex_exit(cport_mutex);
3971 
3972 	if (bp != NULL && bp->b_un.b_addr && bp->b_bcount) {
3973 		/*
3974 		 * Because it is fully emulated command storing data
3975 		 * programatically in the specified buffer, release
3976 		 * preallocated DMA resources before storing data in the buffer,
3977 		 * so no unwanted DMA sync would take place.
3978 		 */
3979 		int count = MIN(bp->b_bcount,
3980 		    sizeof (struct scsi_extended_sense));
3981 		sata_scsi_dmafree(NULL, scsipkt);
3982 		bzero(&sense, sizeof (struct scsi_extended_sense));
3983 		sense.es_valid = 0;	/* Valid LBA */
3984 		sense.es_class = 7;	/* Response code 0x70 - current err */
3985 		sense.es_key = KEY_NO_SENSE;
3986 		sense.es_add_len = 6;	/* Additional length */
3987 		/* Copy no more than requested */
3988 		bcopy(&sense, bp->b_un.b_addr, count);
3989 		scsipkt->pkt_state |= STATE_XFERRED_DATA;
3990 		scsipkt->pkt_resid = 0;
3991 		switch (power_state) {
3992 		case SATA_POWER_IDLE:
3993 		case SATA_POWER_STANDBY:
3994 			sense.es_add_code =
3995 			    SD_SCSI_ASC_LOW_POWER_CONDITION_ON;
3996 			break;
3997 		case SATA_POWER_STOPPED:
3998 			sense.es_add_code = SD_SCSI_ASC_NO_ADD_SENSE;
3999 			break;
4000 		case SATA_POWER_ACTIVE:
4001 		default:
4002 			break;
4003 		}
4004 	}
4005 
4006 	SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst,
4007 	    "Scsi_pkt completion reason %x\n",
4008 	    scsipkt->pkt_reason);
4009 
4010 	if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0 &&
4011 	    scsipkt->pkt_comp != NULL) {
4012 		/* scsi callback required */
4013 		if (servicing_interrupt()) {
4014 			if (taskq_dispatch(SATA_TXLT_TASKQ(spx),
4015 			    (task_func_t *)spx->txlt_scsi_pkt->pkt_comp,
4016 			    (void *)spx->txlt_scsi_pkt, TQ_NOSLEEP) == NULL) {
4017 				return (TRAN_BUSY);
4018 			}
4019 		} else if (taskq_dispatch(SATA_TXLT_TASKQ(spx),
4020 		    (task_func_t *)spx->txlt_scsi_pkt->pkt_comp,
4021 		    (void *)spx->txlt_scsi_pkt, TQ_SLEEP) == NULL) {
4022 			/* Scheduling the callback failed */
4023 			return (TRAN_BUSY);
4024 		}
4025 	}
4026 	return (TRAN_ACCEPT);
4027 }
4028 
4029 /*
4030  * SATA translate command: Test Unit Ready
4031  * (ATA version for SATA hard disks).
4032  * It is translated into the Check Power Mode command.
4033  *
4034  * Returns TRAN_ACCEPT and appropriate values in scsi_pkt fields.
4035  */
4036 static int
4037 sata_txlt_test_unit_ready(sata_pkt_txlate_t *spx)
4038 {
4039 	struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt;
4040 	struct scsi_extended_sense *sense;
4041 	sata_cmd_t *scmd = &spx->txlt_sata_pkt->satapkt_cmd;
4042 	sata_drive_info_t *sdinfo;
4043 	int power_state;
4044 	int rval, reason;
4045 	kmutex_t *cport_mutex =  &(SATA_TXLT_CPORT_MUTEX(spx));
4046 
4047 	mutex_enter(cport_mutex);
4048 
4049 	if (((rval = sata_txlt_generic_pkt_info(spx, &reason, 1)) !=
4050 	    TRAN_ACCEPT) || (reason == CMD_DEV_GONE)) {
4051 		mutex_exit(cport_mutex);
4052 		return (rval);
4053 	}
4054 
4055 	sdinfo = sata_get_device_info(spx->txlt_sata_hba_inst,
4056 	    &spx->txlt_sata_pkt->satapkt_device);
4057 	ASSERT(sdinfo != NULL);
4058 
4059 	spx->txlt_sata_pkt->satapkt_op_mode |= SATA_OPMODE_SYNCH;
4060 
4061 	/* send CHECK POWER MODE command */
4062 	sata_build_generic_cmd(scmd, SATAC_CHECK_POWER_MODE);
4063 	scmd->satacmd_flags.sata_copy_out_sec_count_lsb = B_TRUE;
4064 	scmd->satacmd_flags.sata_copy_out_error_reg = B_TRUE;
4065 	if (sata_hba_start(spx, &rval) != 0) {
4066 		mutex_exit(cport_mutex);
4067 		return (rval);
4068 	}
4069 
4070 	if (scmd->satacmd_error_reg != 0) {
4071 		mutex_exit(cport_mutex);
4072 		return (sata_txlt_check_condition(spx, KEY_NOT_READY,
4073 		    SD_SCSI_ASC_LU_NOT_RESPONSE));
4074 	}
4075 
4076 	power_state = scmd->satacmd_sec_count_lsb;
4077 
4078 	/*
4079 	 * return NOT READY when device in STOPPED mode
4080 	 */
4081 	if (power_state == SATA_PWRMODE_STANDBY &&
4082 	    sdinfo->satadrv_power_level == SATA_POWER_STOPPED) {
4083 		*scsipkt->pkt_scbp = STATUS_CHECK;
4084 		sense = sata_arq_sense(spx);
4085 		sense->es_key = KEY_NOT_READY;
4086 		sense->es_add_code = SD_SCSI_ASC_LU_NOT_READY;
4087 	} else {
4088 		/*
4089 		 * For other power mode, return GOOD status
4090 		 */
4091 		*scsipkt->pkt_scbp = STATUS_GOOD;
4092 	}
4093 
4094 	scsipkt->pkt_reason = CMD_CMPLT;
4095 	scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET |
4096 	    STATE_SENT_CMD | STATE_GOT_STATUS;
4097 
4098 	mutex_exit(cport_mutex);
4099 
4100 	SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst,
4101 	    "Scsi_pkt completion reason %x\n", scsipkt->pkt_reason);
4102 
4103 	if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0 &&
4104 	    scsipkt->pkt_comp != NULL) {
4105 		/* scsi callback required */
4106 		if (servicing_interrupt()) {
4107 			if (taskq_dispatch(SATA_TXLT_TASKQ(spx),
4108 			    (task_func_t *)spx->txlt_scsi_pkt->pkt_comp,
4109 			    (void *)spx->txlt_scsi_pkt, TQ_NOSLEEP) == NULL) {
4110 				return (TRAN_BUSY);
4111 			}
4112 		} else if (taskq_dispatch(SATA_TXLT_TASKQ(spx),
4113 		    (task_func_t *)spx->txlt_scsi_pkt->pkt_comp,
4114 		    (void *)spx->txlt_scsi_pkt, TQ_SLEEP) == NULL) {
4115 			/* Scheduling the callback failed */
4116 			return (TRAN_BUSY);
4117 		}
4118 	}
4119 
4120 	return (TRAN_ACCEPT);
4121 }
4122 
4123 /*
4124  * SATA translate command: Start Stop Unit
4125  * Translation depends on a command:
4126  *
4127  * Power condition bits will be supported
4128  * and the power level should be maintained by SATL,
4129  * When SATL received a command, it will check the
4130  * power level firstly, and return the status according
4131  * to SAT2 v2.6 and SAT-2 Standby Modifications
4132  *
4133  * SPC-4/SBC-3      SATL    ATA power condition  SATL      SPC/SBC
4134  * -----------------------------------------------------------------------
4135  * SSU_PC1 Active   <==>     ATA  Active         <==>     SSU:start_bit =1
4136  * SSU_PC2 Idle     <==>     ATA  Idle           <==>     N/A
4137  * SSU_PC3 Standby  <==>     ATA  Standby        <==>     N/A
4138  * SSU_PC4 Stopped  <==>     ATA  Standby        <==>     SSU:start_bit = 0
4139  *
4140  *	Unload Media / NOT SUPPORTED YET
4141  *	Load Media / NOT SUPPROTED YET
4142  *	Immediate bit / NOT SUPPORTED YET (deferred error)
4143  *
4144  * Returns TRAN_ACCEPT or code returned by sata_hba_start() and
4145  * appropriate values in scsi_pkt fields.
4146  */
4147 static int
4148 sata_txlt_start_stop_unit(sata_pkt_txlate_t *spx)
4149 {
4150 	struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt;
4151 	sata_cmd_t *scmd = &spx->txlt_sata_pkt->satapkt_cmd;
4152 	int rval, reason;
4153 	sata_drive_info_t *sdinfo;
4154 	sata_id_t *sata_id;
4155 	kmutex_t *cport_mutex = &(SATA_TXLT_CPORT_MUTEX(spx));
4156 
4157 	SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst,
4158 	    "sata_txlt_start_stop_unit: %d\n", scsipkt->pkt_scbp[4] & 1);
4159 
4160 	mutex_enter(cport_mutex);
4161 
4162 	if (((rval = sata_txlt_generic_pkt_info(spx, &reason, 1)) !=
4163 	    TRAN_ACCEPT) || (reason == CMD_DEV_GONE)) {
4164 		mutex_exit(cport_mutex);
4165 		return (rval);
4166 	}
4167 
4168 	if (scsipkt->pkt_cdbp[1] & START_STOP_IMMED_MASK) {
4169 		/* IMMED bit - not supported */
4170 		mutex_exit(cport_mutex);
4171 		return (sata_txlt_check_condition(spx, KEY_ILLEGAL_REQUEST,
4172 		    SD_SCSI_ASC_INVALID_FIELD_IN_CDB));
4173 	}
4174 
4175 	spx->txlt_sata_pkt->satapkt_op_mode |= SATA_OPMODE_SYNCH;
4176 	spx->txlt_sata_pkt->satapkt_comp = NULL;
4177 
4178 	sdinfo = sata_get_device_info(spx->txlt_sata_hba_inst,
4179 	    &spx->txlt_sata_pkt->satapkt_device);
4180 	ASSERT(sdinfo != NULL);
4181 	sata_id = &sdinfo->satadrv_id;
4182 
4183 	switch ((scsipkt->pkt_cdbp[4] & START_STOP_POWER_COND_MASK) >> 4) {
4184 	case 0:
4185 		if (scsipkt->pkt_cdbp[4] & START_STOP_LOEJ_MASK) {
4186 			/* Load/Unload Media - invalid request */
4187 			goto err_out;
4188 		}
4189 		if (scsipkt->pkt_cdbp[4] & START_STOP_START_MASK) {
4190 			/* Start Unit */
4191 			sata_build_read_verify_cmd(scmd, 1, 5);
4192 			scmd->satacmd_flags.sata_copy_out_error_reg = B_TRUE;
4193 			/* Transfer command to HBA */
4194 			if (sata_hba_start(spx, &rval) != 0) {
4195 				/* Pkt not accepted for execution */
4196 				mutex_exit(cport_mutex);
4197 				return (rval);
4198 			}
4199 			if (scmd->satacmd_error_reg != 0) {
4200 				goto err_out;
4201 			}
4202 			sdinfo->satadrv_power_level = SATA_POWER_ACTIVE;
4203 		} else {
4204 			/* Stop Unit */
4205 			sata_build_generic_cmd(scmd, SATAC_FLUSH_CACHE);
4206 			scmd->satacmd_flags.sata_copy_out_error_reg = B_TRUE;
4207 			if (sata_hba_start(spx, &rval) != 0) {
4208 				mutex_exit(cport_mutex);
4209 				return (rval);
4210 			} else {
4211 				if (scmd->satacmd_error_reg != 0) {
4212 					goto err_out;
4213 				}
4214 			}
4215 			/* ata standby immediate command */
4216 			sata_build_generic_cmd(scmd, SATAC_STANDBY_IM);
4217 			scmd->satacmd_flags.sata_copy_out_error_reg = B_TRUE;
4218 			if (sata_hba_start(spx, &rval) != 0) {
4219 				mutex_exit(cport_mutex);
4220 				return (rval);
4221 			}
4222 			if (scmd->satacmd_error_reg != 0) {
4223 				goto err_out;
4224 			}
4225 			sdinfo->satadrv_power_level = SATA_POWER_STOPPED;
4226 		}
4227 		break;
4228 	case 0x1:
4229 		sata_build_generic_cmd(scmd, SATAC_IDLE);
4230 		scmd->satacmd_flags.sata_copy_out_error_reg = B_TRUE;
4231 		if (sata_hba_start(spx, &rval) != 0) {
4232 			mutex_exit(cport_mutex);
4233 			return (rval);
4234 		}
4235 		if (scmd->satacmd_error_reg != 0) {
4236 			goto err_out;
4237 		}
4238 		sata_build_read_verify_cmd(scmd, 1, 5);
4239 		scmd->satacmd_flags.sata_copy_out_error_reg = B_TRUE;
4240 		/* Transfer command to HBA */
4241 		if (sata_hba_start(spx, &rval) != 0) {
4242 			/* Pkt not accepted for execution */
4243 			mutex_exit(cport_mutex);
4244 			return (rval);
4245 		} else {
4246 			if (scmd->satacmd_error_reg != 0) {
4247 				goto err_out;
4248 			}
4249 		}
4250 		sdinfo->satadrv_power_level = SATA_POWER_ACTIVE;
4251 		break;
4252 	case 0x2:
4253 		sata_build_generic_cmd(scmd, SATAC_FLUSH_CACHE);
4254 		scmd->satacmd_flags.sata_copy_out_error_reg = B_TRUE;
4255 		if (!(scsipkt->pkt_cdbp[4] & START_STOP_NOFLUSH_MASK)) {
4256 			if (sata_hba_start(spx, &rval) != 0) {
4257 				mutex_exit(cport_mutex);
4258 				return (rval);
4259 			}
4260 			if (scmd->satacmd_error_reg != 0) {
4261 				goto err_out;
4262 			}
4263 		}
4264 		sata_build_generic_cmd(scmd, SATAC_IDLE);
4265 		scmd->satacmd_flags.sata_copy_out_error_reg = B_TRUE;
4266 		if (sata_hba_start(spx, &rval) != 0) {
4267 			mutex_exit(cport_mutex);
4268 			return (rval);
4269 		}
4270 		if (scmd->satacmd_error_reg != 0) {
4271 			goto err_out;
4272 		}
4273 		if ((scsipkt->pkt_cdbp[3] & START_STOP_MODIFIER_MASK)) {
4274 			/*
4275 			 *  POWER CONDITION MODIFIER bit set
4276 			 *  to 0x1 or larger it will be handled
4277 			 *  on the same way as bit = 0x1
4278 			 */
4279 			if (!(sata_id->ai_cmdset84 &
4280 			    SATA_IDLE_UNLOAD_SUPPORTED)) {
4281 				sdinfo->satadrv_power_level = SATA_POWER_IDLE;
4282 				break;
4283 			}
4284 			sata_build_generic_cmd(scmd, SATAC_IDLE_IM);
4285 			scmd->satacmd_features_reg = 0x44;
4286 			scmd->satacmd_lba_low_lsb = 0x4c;
4287 			scmd->satacmd_lba_mid_lsb = 0x4e;
4288 			scmd->satacmd_lba_high_lsb = 0x55;
4289 			scmd->satacmd_flags.sata_copy_out_error_reg = B_TRUE;
4290 			if (sata_hba_start(spx, &rval) != 0) {
4291 				mutex_exit(cport_mutex);
4292 				return (rval);
4293 			}
4294 			if (scmd->satacmd_error_reg != 0) {
4295 				goto err_out;
4296 			}
4297 		}
4298 		sdinfo->satadrv_power_level = SATA_POWER_IDLE;
4299 		break;
4300 	case 0x3:
4301 		sata_build_generic_cmd(scmd, SATAC_FLUSH_CACHE);
4302 		scmd->satacmd_flags.sata_copy_out_error_reg = B_TRUE;
4303 		if (!(scsipkt->pkt_cdbp[4] & START_STOP_NOFLUSH_MASK)) {
4304 			if (sata_hba_start(spx, &rval) != 0) {
4305 				mutex_exit(cport_mutex);
4306 				return (rval);
4307 			}
4308 			if (scmd->satacmd_error_reg != 0) {
4309 				goto err_out;
4310 			}
4311 		}
4312 		sata_build_generic_cmd(scmd, SATAC_STANDBY);
4313 		scmd->satacmd_flags.sata_copy_out_error_reg = B_TRUE;
4314 		if (sata_hba_start(spx, &rval) != 0) {
4315 			mutex_exit(cport_mutex);
4316 			return (rval);
4317 		}
4318 		if (scmd->satacmd_error_reg != 0) {
4319 			goto err_out;
4320 		}
4321 		sdinfo->satadrv_power_level = SATA_POWER_STANDBY;
4322 		break;
4323 	case 0x7:
4324 		sata_build_generic_cmd(scmd, SATAC_CHECK_POWER_MODE);
4325 		scmd->satacmd_flags.sata_copy_out_sec_count_lsb = B_TRUE;
4326 		scmd->satacmd_flags.sata_copy_out_error_reg = B_TRUE;
4327 		if (sata_hba_start(spx, &rval) != 0) {
4328 			mutex_exit(cport_mutex);
4329 			return (rval);
4330 		}
4331 		if (scmd->satacmd_error_reg != 0) {
4332 			goto err_out;
4333 		}
4334 		switch (scmd->satacmd_sec_count_lsb) {
4335 		case SATA_PWRMODE_STANDBY:
4336 			sata_build_generic_cmd(scmd, SATAC_STANDBY);
4337 			scmd->satacmd_sec_count_msb = sata_get_standby_timer(
4338 			    sdinfo->satadrv_standby_timer);
4339 			scmd->satacmd_flags.sata_copy_out_error_reg = B_TRUE;
4340 			if (sata_hba_start(spx, &rval) != 0) {
4341 				mutex_exit(cport_mutex);
4342 				return (rval);
4343 			} else {
4344 				if (scmd->satacmd_error_reg != 0) {
4345 					goto err_out;
4346 				}
4347 			}
4348 			break;
4349 		case SATA_PWRMODE_IDLE:
4350 			sata_build_generic_cmd(scmd, SATAC_IDLE);
4351 			scmd->satacmd_sec_count_msb = sata_get_standby_timer(
4352 			    sdinfo->satadrv_standby_timer);
4353 			scmd->satacmd_flags.sata_copy_out_error_reg = B_TRUE;
4354 			if (sata_hba_start(spx, &rval) != 0) {
4355 				mutex_exit(cport_mutex);
4356 				return (rval);
4357 			} else {
4358 				if (scmd->satacmd_error_reg != 0) {
4359 					goto err_out;
4360 				}
4361 			}
4362 			break;
4363 		case SATA_PWRMODE_ACTIVE_SPINDOWN:
4364 		case SATA_PWRMODE_ACTIVE_SPINUP:
4365 		case SATA_PWRMODE_ACTIVE:
4366 			sata_build_generic_cmd(scmd, SATAC_IDLE);
4367 			scmd->satacmd_sec_count_msb = sata_get_standby_timer(
4368 			    sdinfo->satadrv_standby_timer);
4369 			scmd->satacmd_flags.sata_copy_out_error_reg = B_TRUE;
4370 			if (sata_hba_start(spx, &rval) != 0) {
4371 				mutex_exit(cport_mutex);
4372 				return (rval);
4373 			}
4374 			if (scmd->satacmd_error_reg != 0) {
4375 				goto err_out;
4376 			}
4377 			sata_build_read_verify_cmd(scmd, 1, 5);
4378 			scmd->satacmd_flags.sata_copy_out_error_reg = B_TRUE;
4379 			if (sata_hba_start(spx, &rval) != 0) {
4380 				mutex_exit(cport_mutex);
4381 				return (rval);
4382 			}
4383 			if (scmd->satacmd_error_reg != 0) {
4384 				goto err_out;
4385 			}
4386 			break;
4387 		default:
4388 			goto err_out;
4389 		}
4390 		break;
4391 	case 0xb:
4392 		if ((sata_get_standby_timer(sdinfo->satadrv_standby_timer) ==
4393 		    0) || (!(sata_id->ai_cap & SATA_STANDBYTIMER))) {
4394 			mutex_exit(cport_mutex);
4395 			return (sata_txlt_check_condition(spx,
4396 			    KEY_ILLEGAL_REQUEST,
4397 			    SD_SCSI_ASC_INVALID_FIELD_IN_CDB));
4398 		}
4399 		sata_build_generic_cmd(scmd, SATAC_FLUSH_CACHE);
4400 		scmd->satacmd_flags.sata_copy_out_error_reg = B_TRUE;
4401 		if (!(scsipkt->pkt_cdbp[4] & START_STOP_NOFLUSH_MASK)) {
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 			sata_build_generic_cmd(scmd, SATAC_STANDBY_IM);
4410 			scmd->satacmd_flags.sata_copy_out_error_reg = B_TRUE;
4411 			if (sata_hba_start(spx, &rval) != 0) {
4412 				mutex_exit(cport_mutex);
4413 				return (rval);
4414 			}
4415 			if (scmd->satacmd_error_reg != 0) {
4416 				goto err_out;
4417 			}
4418 		}
4419 		bzero(sdinfo->satadrv_standby_timer, sizeof (uchar_t) * 4);
4420 		break;
4421 	default:
4422 err_out:
4423 		mutex_exit(cport_mutex);
4424 		return (sata_txlt_check_condition(spx, KEY_ILLEGAL_REQUEST,
4425 		    SD_SCSI_ASC_INVALID_FIELD_IN_CDB));
4426 	}
4427 
4428 	/*
4429 	 * Since it was a synchronous command,
4430 	 * a callback function will be called directly.
4431 	 */
4432 	mutex_exit(cport_mutex);
4433 	SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst,
4434 	    "synchronous execution status %x\n",
4435 	    spx->txlt_sata_pkt->satapkt_reason);
4436 
4437 	if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0 &&
4438 	    scsipkt->pkt_comp != NULL) {
4439 		sata_set_arq_data(spx->txlt_sata_pkt);
4440 		if (servicing_interrupt()) {
4441 			if (taskq_dispatch(SATA_TXLT_TASKQ(spx),
4442 			    (task_func_t *)spx->txlt_scsi_pkt->pkt_comp,
4443 			    (void *)spx->txlt_scsi_pkt, TQ_NOSLEEP) == NULL) {
4444 				return (TRAN_BUSY);
4445 			}
4446 		} else if (taskq_dispatch(SATA_TXLT_TASKQ(spx),
4447 		    (task_func_t *)spx->txlt_scsi_pkt->pkt_comp,
4448 		    (void *)spx->txlt_scsi_pkt, TQ_SLEEP) == NULL) {
4449 			/* Scheduling the callback failed */
4450 			return (TRAN_BUSY);
4451 		}
4452 	}
4453 	else
4454 
4455 		sata_txlt_nodata_cmd_completion(spx->txlt_sata_pkt);
4456 
4457 	return (TRAN_ACCEPT);
4458 
4459 }
4460 
4461 /*
4462  * SATA translate command:  Read Capacity.
4463  * Emulated command for SATA disks.
4464  * Capacity is retrieved from cached Idenifty Device data.
4465  * Identify Device data shows effective disk capacity, not the native
4466  * capacity, which may be limitted by Set Max Address command.
4467  * This is ATA version for SATA hard disks.
4468  *
4469  * Returns TRAN_ACCEPT and appropriate values in scsi_pkt fields.
4470  */
4471 static int
4472 sata_txlt_read_capacity(sata_pkt_txlate_t *spx)
4473 {
4474 	struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt;
4475 	struct buf *bp = spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp;
4476 	sata_drive_info_t *sdinfo;
4477 	uint64_t val;
4478 	uchar_t *rbuf;
4479 	int rval, reason;
4480 	kmutex_t *cport_mutex = &(SATA_TXLT_CPORT_MUTEX(spx));
4481 
4482 	SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst,
4483 	    "sata_txlt_read_capacity: ", NULL);
4484 
4485 	mutex_enter(cport_mutex);
4486 
4487 	if (((rval = sata_txlt_generic_pkt_info(spx, &reason, 0)) !=
4488 	    TRAN_ACCEPT) || (reason == CMD_DEV_GONE)) {
4489 		mutex_exit(cport_mutex);
4490 		return (rval);
4491 	}
4492 
4493 	scsipkt->pkt_reason = CMD_CMPLT;
4494 	scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET |
4495 	    STATE_SENT_CMD | STATE_GOT_STATUS;
4496 	*scsipkt->pkt_scbp = STATUS_GOOD;
4497 	if (bp != NULL && bp->b_un.b_addr && bp->b_bcount) {
4498 		/*
4499 		 * Because it is fully emulated command storing data
4500 		 * programatically in the specified buffer, release
4501 		 * preallocated DMA resources before storing data in the buffer,
4502 		 * so no unwanted DMA sync would take place.
4503 		 */
4504 		sata_scsi_dmafree(NULL, scsipkt);
4505 
4506 		sdinfo = sata_get_device_info(
4507 		    spx->txlt_sata_hba_inst,
4508 		    &spx->txlt_sata_pkt->satapkt_device);
4509 
4510 		/*
4511 		 * As per SBC-3, the "returned LBA" is either the highest
4512 		 * addressable LBA or 0xffffffff, whichever is smaller.
4513 		 */
4514 		val = MIN(sdinfo->satadrv_capacity - 1, UINT32_MAX);
4515 
4516 		rbuf = (uchar_t *)bp->b_un.b_addr;
4517 		/* Need to swap endians to match scsi format */
4518 		rbuf[0] = (val >> 24) & 0xff;
4519 		rbuf[1] = (val >> 16) & 0xff;
4520 		rbuf[2] = (val >> 8) & 0xff;
4521 		rbuf[3] = val & 0xff;
4522 		/* block size - always 512 bytes, for now */
4523 		rbuf[4] = 0;
4524 		rbuf[5] = 0;
4525 		rbuf[6] = 0x02;
4526 		rbuf[7] = 0;
4527 		scsipkt->pkt_state |= STATE_XFERRED_DATA;
4528 		scsipkt->pkt_resid = 0;
4529 
4530 		SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst, "%d\n",
4531 		    sdinfo->satadrv_capacity -1);
4532 	}
4533 	mutex_exit(cport_mutex);
4534 	/*
4535 	 * If a callback was requested, do it now.
4536 	 */
4537 	SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst,
4538 	    "Scsi_pkt completion reason %x\n", scsipkt->pkt_reason);
4539 
4540 	if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0 &&
4541 	    scsipkt->pkt_comp != NULL) {
4542 		/* scsi callback required */
4543 		if (servicing_interrupt()) {
4544 			if (taskq_dispatch(SATA_TXLT_TASKQ(spx),
4545 			    (task_func_t *)spx->txlt_scsi_pkt->pkt_comp,
4546 			    (void *)spx->txlt_scsi_pkt, TQ_NOSLEEP) == NULL) {
4547 				return (TRAN_BUSY);
4548 			}
4549 		} else if (taskq_dispatch(SATA_TXLT_TASKQ(spx),
4550 		    (task_func_t *)spx->txlt_scsi_pkt->pkt_comp,
4551 		    (void *)spx->txlt_scsi_pkt, TQ_SLEEP) == NULL) {
4552 			/* Scheduling the callback failed */
4553 			return (TRAN_BUSY);
4554 		}
4555 	}
4556 
4557 	return (TRAN_ACCEPT);
4558 }
4559 
4560 /*
4561  * SATA translate command:  Read Capacity (16).
4562  * Emulated command for SATA disks.
4563  * Info is retrieved from cached Identify Device data.
4564  * Implemented to SBC-3 (draft 21) and SAT-2 (final) specifications.
4565  *
4566  * Returns TRAN_ACCEPT and appropriate values in scsi_pkt fields.
4567  */
4568 static int
4569 sata_txlt_read_capacity16(sata_pkt_txlate_t *spx)
4570 {
4571 	struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt;
4572 	struct buf *bp = spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp;
4573 	sata_drive_info_t *sdinfo;
4574 	uint64_t val;
4575 	uint16_t l2p_exp;
4576 	uchar_t *rbuf;
4577 	int rval, reason;
4578 #define	TPE	0x80
4579 #define	TPRZ	0x40
4580 	kmutex_t *cport_mutex = &(SATA_TXLT_CPORT_MUTEX(spx));
4581 
4582 	SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst,
4583 	    "sata_txlt_read_capacity: ", NULL);
4584 
4585 	mutex_enter(cport_mutex);
4586 
4587 	if (((rval = sata_txlt_generic_pkt_info(spx, &reason, 0)) !=
4588 	    TRAN_ACCEPT) || (reason == CMD_DEV_GONE)) {
4589 		mutex_exit(cport_mutex);
4590 		return (rval);
4591 	}
4592 
4593 	scsipkt->pkt_reason = CMD_CMPLT;
4594 	scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET |
4595 	    STATE_SENT_CMD | STATE_GOT_STATUS;
4596 	if (bp != NULL && bp->b_un.b_addr && bp->b_bcount) {
4597 		/*
4598 		 * Because it is fully emulated command storing data
4599 		 * programatically in the specified buffer, release
4600 		 * preallocated DMA resources before storing data in the buffer,
4601 		 * so no unwanted DMA sync would take place.
4602 		 */
4603 		sata_scsi_dmafree(NULL, scsipkt);
4604 
4605 		/* Check SERVICE ACTION field */
4606 		if ((scsipkt->pkt_cdbp[1] & 0x1f) !=
4607 		    SSVC_ACTION_READ_CAPACITY_G4) {
4608 			mutex_exit(cport_mutex);
4609 			return (sata_txlt_check_condition(spx,
4610 			    KEY_ILLEGAL_REQUEST,
4611 			    SD_SCSI_ASC_INVALID_FIELD_IN_CDB));
4612 		}
4613 
4614 		/* Check LBA field */
4615 		if ((scsipkt->pkt_cdbp[2] != 0) ||
4616 		    (scsipkt->pkt_cdbp[3] != 0) ||
4617 		    (scsipkt->pkt_cdbp[4] != 0) ||
4618 		    (scsipkt->pkt_cdbp[5] != 0) ||
4619 		    (scsipkt->pkt_cdbp[6] != 0) ||
4620 		    (scsipkt->pkt_cdbp[7] != 0) ||
4621 		    (scsipkt->pkt_cdbp[8] != 0) ||
4622 		    (scsipkt->pkt_cdbp[9] != 0)) {
4623 			mutex_exit(cport_mutex);
4624 			return (sata_txlt_check_condition(spx,
4625 			    KEY_ILLEGAL_REQUEST,
4626 			    SD_SCSI_ASC_INVALID_FIELD_IN_CDB));
4627 		}
4628 
4629 		/* Check PMI bit */
4630 		if (scsipkt->pkt_cdbp[14] & 0x1) {
4631 			mutex_exit(cport_mutex);
4632 			return (sata_txlt_check_condition(spx,
4633 			    KEY_ILLEGAL_REQUEST,
4634 			    SD_SCSI_ASC_INVALID_FIELD_IN_CDB));
4635 		}
4636 
4637 		*scsipkt->pkt_scbp = STATUS_GOOD;
4638 
4639 		sdinfo = sata_get_device_info(
4640 		    spx->txlt_sata_hba_inst,
4641 		    &spx->txlt_sata_pkt->satapkt_device);
4642 
4643 		/* last logical block address */
4644 		val = MIN(sdinfo->satadrv_capacity - 1,
4645 		    SCSI_READ_CAPACITY16_MAX_LBA);
4646 
4647 		/* logical to physical block size exponent */
4648 		l2p_exp = 0;
4649 		if (sdinfo->satadrv_id.ai_phys_sect_sz & SATA_L2PS_CHECK_BIT) {
4650 			/* physical/logical sector size word is valid */
4651 
4652 			if (sdinfo->satadrv_id.ai_phys_sect_sz &
4653 			    SATA_L2PS_HAS_MULT) {
4654 				/* multiple logical sectors per phys sectors */
4655 				l2p_exp =
4656 				    sdinfo->satadrv_id.ai_phys_sect_sz &
4657 				    SATA_L2PS_EXP_MASK;
4658 			}
4659 		}
4660 
4661 		rbuf = (uchar_t *)bp->b_un.b_addr;
4662 		bzero(rbuf, bp->b_bcount);
4663 
4664 		/* returned logical block address */
4665 		rbuf[0] = (val >> 56) & 0xff;
4666 		rbuf[1] = (val >> 48) & 0xff;
4667 		rbuf[2] = (val >> 40) & 0xff;
4668 		rbuf[3] = (val >> 32) & 0xff;
4669 		rbuf[4] = (val >> 24) & 0xff;
4670 		rbuf[5] = (val >> 16) & 0xff;
4671 		rbuf[6] = (val >> 8) & 0xff;
4672 		rbuf[7] = val & 0xff;
4673 
4674 		/* logical block length in bytes = 512 (for now) */
4675 		/* rbuf[8] = 0; */
4676 		/* rbuf[9] = 0; */
4677 		rbuf[10] = 0x02;
4678 		/* rbuf[11] = 0; */
4679 
4680 		/* p_type, prot_en, unspecified by SAT-2 */
4681 		/* rbuf[12] = 0; */
4682 
4683 		/* p_i_exponent, undefined by SAT-2 */
4684 		/* logical blocks per physical block exponent */
4685 		rbuf[13] = l2p_exp;
4686 
4687 		/* lowest aligned logical block address = 0 (for now) */
4688 		/* tpe and tprz as defined in T10/10-079 r0 */
4689 		if (sdinfo->satadrv_id.ai_addsupported &
4690 		    SATA_DETERMINISTIC_READ) {
4691 			if (sdinfo->satadrv_id.ai_addsupported &
4692 			    SATA_READ_ZERO) {
4693 				rbuf[14] |= TPRZ;
4694 			} else {
4695 				rbuf[14] |= TPE;
4696 			}
4697 		}
4698 		/* rbuf[15] = 0; */
4699 
4700 		scsipkt->pkt_state |= STATE_XFERRED_DATA;
4701 		scsipkt->pkt_resid = 0;
4702 
4703 		SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst, "%llu\n",
4704 		    sdinfo->satadrv_capacity -1);
4705 	}
4706 
4707 	mutex_exit(cport_mutex);
4708 
4709 	/*
4710 	 * If a callback was requested, do it now.
4711 	 */
4712 	SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst,
4713 	    "Scsi_pkt completion reason %x\n", scsipkt->pkt_reason);
4714 
4715 	if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0 &&
4716 	    scsipkt->pkt_comp != NULL) {
4717 		/* scsi callback required */
4718 		if (servicing_interrupt()) {
4719 			if (taskq_dispatch(SATA_TXLT_TASKQ(spx),
4720 			    (task_func_t *)spx->txlt_scsi_pkt->pkt_comp,
4721 			    (void *)spx->txlt_scsi_pkt, TQ_NOSLEEP) == NULL) {
4722 				return (TRAN_BUSY);
4723 			}
4724 		} else if (taskq_dispatch(SATA_TXLT_TASKQ(spx),
4725 		    (task_func_t *)spx->txlt_scsi_pkt->pkt_comp,
4726 		    (void *)spx->txlt_scsi_pkt, TQ_SLEEP) == NULL) {
4727 			/* Scheduling the callback failed */
4728 			return (TRAN_BUSY);
4729 		}
4730 	}
4731 
4732 	return (TRAN_ACCEPT);
4733 }
4734 
4735 /*
4736  * Translate command: UNMAP
4737  *
4738  * The function cannot be called in interrupt context since it may sleep.
4739  */
4740 static int
4741 sata_txlt_unmap(sata_pkt_txlate_t *spx)
4742 {
4743 	struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt;
4744 	sata_cmd_t *scmd = &spx->txlt_sata_pkt->satapkt_cmd;
4745 	struct buf *bp = spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp;
4746 	uint16_t count = 0;
4747 	int synch;
4748 	int rval, reason;
4749 	int i, x;
4750 	int bdlen = 0;
4751 	int ranges = 0;
4752 	int paramlen = 8;
4753 	uint8_t *data, *tmpbd;
4754 	sata_drive_info_t *sdinfo;
4755 	kmutex_t *cport_mutex = &(SATA_TXLT_CPORT_MUTEX(spx));
4756 #define	TRIM	0x1
4757 
4758 	SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst,
4759 	    "sata_txlt_unmap: ", NULL);
4760 
4761 	mutex_enter(cport_mutex);
4762 
4763 	sdinfo = sata_get_device_info(spx->txlt_sata_hba_inst,
4764 	    &spx->txlt_sata_pkt->satapkt_device);
4765 	if (sdinfo != NULL) {
4766 		SATADBG2(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst,
4767 		    "DSM support 0x%x, max number of 512 byte blocks of LBA "
4768 		    "range entries 0x%x\n", sdinfo->satadrv_id.ai_dsm,
4769 		    sdinfo->satadrv_id.ai_maxcount);
4770 	}
4771 
4772 	rval = sata_txlt_generic_pkt_info(spx, &reason, 1);
4773 	if ((rval != TRAN_ACCEPT) || (reason == CMD_DEV_GONE)) {
4774 		mutex_exit(cport_mutex);
4775 		return (rval);
4776 	}
4777 
4778 	/*
4779 	 * Need to modify bp to have TRIM data instead of UNMAP data.
4780 	 * Start by getting the block descriptor data length by subtracting
4781 	 * the 8 byte parameter list header from the parameter list length.
4782 	 * The block descriptor size has to be a multiple of 16 bytes.
4783 	 */
4784 	bdlen = scsipkt->pkt_cdbp[7];
4785 	bdlen = (bdlen << 8) + scsipkt->pkt_cdbp[8] - paramlen;
4786 	if ((bdlen < 0) || ((bdlen % 16) != 0) ||
4787 	    (bdlen > (bp->b_bcount - paramlen))) {
4788 		SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst,
4789 		    "sata_txlt_unmap: invalid block descriptor length", NULL);
4790 		mutex_exit(cport_mutex);
4791 		return ((sata_txlt_check_condition(spx, KEY_ILLEGAL_REQUEST,
4792 		    SD_SCSI_ASC_INVALID_FIELD_IN_CDB)));
4793 	}
4794 	/*
4795 	 * If there are no parameter data or block descriptors, it is not
4796 	 * considered an error so just complete the command without sending
4797 	 * TRIM.
4798 	 */
4799 	if ((bdlen == 0) || (bp == NULL) || (bp->b_un.b_addr == NULL) ||
4800 	    (bp->b_bcount == 0)) {
4801 		SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst,
4802 		    "sata_txlt_unmap: no parameter data or block descriptors",
4803 		    NULL);
4804 		mutex_exit(cport_mutex);
4805 		return (sata_txlt_unmap_nodata_cmd(spx));
4806 	}
4807 	tmpbd = (uint8_t *)bp->b_un.b_addr + paramlen;
4808 	data = kmem_zalloc(bdlen, KM_SLEEP);
4809 
4810 	/*
4811 	 * Loop through all the UNMAP block descriptors and convert the data
4812 	 * into TRIM format.
4813 	 */
4814 	for (i = 0, x = 0; i < bdlen; i += 16, x += 8) {
4815 		/* get range length */
4816 		data[x] = tmpbd[i+7];
4817 		data[x+1] = tmpbd[i+6];
4818 		/* get LBA */
4819 		data[x+2] = tmpbd[i+5];
4820 		data[x+3] = tmpbd[i+4];
4821 		data[x+4] = tmpbd[i+3];
4822 		data[x+5] = tmpbd[i+2];
4823 		data[x+6] = tmpbd[i+11];
4824 		data[x+7] = tmpbd[i+10];
4825 
4826 		ranges++;
4827 	}
4828 
4829 	/*
4830 	 * The TRIM command expects the data buffer to be a multiple of
4831 	 * 512-byte blocks of range entries.  This means that the UNMAP buffer
4832 	 * may be too small.  Free the original DMA resources and create a
4833 	 * local buffer.
4834 	 */
4835 	sata_common_free_dma_rsrcs(spx);
4836 
4837 	/*
4838 	 * Get count of 512-byte blocks of range entries.  The length
4839 	 * of a range entry is 8 bytes which means one count has 64 range
4840 	 * entries.
4841 	 */
4842 	count = (ranges + 63)/64;
4843 
4844 	/* Allocate a buffer that is a multiple of 512 bytes. */
4845 	mutex_exit(cport_mutex);
4846 	bp = sata_alloc_local_buffer(spx, count * 512);
4847 	if (bp == NULL) {
4848 		SATADBG1(SATA_DBG_ATAPI, spx->txlt_sata_hba_inst,
4849 		    "sata_txlt_unmap: "
4850 		    "cannot allocate buffer for TRIM command", NULL);
4851 		kmem_free(data, bdlen);
4852 		return (TRAN_BUSY);
4853 	}
4854 	bp_mapin(bp); /* make data buffer accessible */
4855 	mutex_enter(cport_mutex);
4856 
4857 	bzero(bp->b_un.b_addr, bp->b_bcount);
4858 	bcopy(data, bp->b_un.b_addr, x);
4859 	kmem_free(data, bdlen);
4860 	rval = ddi_dma_sync(spx->txlt_buf_dma_handle, 0, 0,
4861 	    DDI_DMA_SYNC_FORDEV);
4862 	ASSERT(rval == DDI_SUCCESS);
4863 
4864 	scmd->satacmd_flags.sata_data_direction = SATA_DIR_WRITE;
4865 	scmd->satacmd_addr_type = ATA_ADDR_LBA48;
4866 	scmd->satacmd_cmd_reg = SATAC_DSM;
4867 	scmd->satacmd_sec_count_msb = (count >> 8) & 0xff;
4868 	scmd->satacmd_sec_count_lsb = count & 0xff;
4869 	scmd->satacmd_features_reg = TRIM;
4870 	scmd->satacmd_device_reg = SATA_ADH_LBA;
4871 	scmd->satacmd_status_reg = 0;
4872 	scmd->satacmd_error_reg = 0;
4873 
4874 	/* Start processing command */
4875 	if (!(spx->txlt_sata_pkt->satapkt_op_mode & SATA_OPMODE_SYNCH)) {
4876 		spx->txlt_sata_pkt->satapkt_comp =
4877 		    sata_txlt_unmap_completion;
4878 		synch = FALSE;
4879 	} else {
4880 		synch = TRUE;
4881 	}
4882 
4883 	if (sata_hba_start(spx, &rval) != 0) {
4884 		mutex_exit(cport_mutex);
4885 		return (rval);
4886 	}
4887 
4888 	mutex_exit(cport_mutex);
4889 
4890 	if (synch) {
4891 		sata_txlt_unmap_completion(spx->txlt_sata_pkt);
4892 	}
4893 
4894 	return (TRAN_ACCEPT);
4895 }
4896 
4897 /*
4898  * SATA translate command: Mode Sense.
4899  * Translated into appropriate SATA command or emulated.
4900  * Saved Values Page Control (03) are not supported.
4901  *
4902  * NOTE: only caching mode sense page is currently implemented.
4903  *
4904  * Returns TRAN_ACCEPT and appropriate values in scsi_pkt fields.
4905  */
4906 
4907 #define	LLBAA	0x10	/* Long LBA Accepted */
4908 
4909 static int
4910 sata_txlt_mode_sense(sata_pkt_txlate_t *spx)
4911 {
4912 	struct scsi_pkt	*scsipkt = spx->txlt_scsi_pkt;
4913 	struct buf	*bp = spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp;
4914 	sata_drive_info_t *sdinfo;
4915 	sata_id_t *sata_id;
4916 	struct scsi_extended_sense *sense;
4917 	int 		len, bdlen, count, alc_len;
4918 	int		pc;	/* Page Control code */
4919 	uint8_t		*buf;	/* mode sense buffer */
4920 	int		rval, reason;
4921 	kmutex_t	*cport_mutex = &(SATA_TXLT_CPORT_MUTEX(spx));
4922 
4923 	SATADBG2(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst,
4924 	    "sata_txlt_mode_sense, pc %x page code 0x%02x\n",
4925 	    spx->txlt_scsi_pkt->pkt_cdbp[2] >> 6,
4926 	    spx->txlt_scsi_pkt->pkt_cdbp[2] & 0x3f);
4927 
4928 	if (servicing_interrupt()) {
4929 		buf = kmem_zalloc(1024, KM_NOSLEEP);
4930 		if (buf == NULL) {
4931 			return (TRAN_BUSY);
4932 		}
4933 	} else {
4934 		buf = kmem_zalloc(1024, KM_SLEEP);
4935 	}
4936 
4937 	mutex_enter(cport_mutex);
4938 
4939 	if (((rval = sata_txlt_generic_pkt_info(spx, &reason, 0)) !=
4940 	    TRAN_ACCEPT) || (reason == CMD_DEV_GONE)) {
4941 		mutex_exit(cport_mutex);
4942 		kmem_free(buf, 1024);
4943 		return (rval);
4944 	}
4945 
4946 	scsipkt->pkt_reason = CMD_CMPLT;
4947 	scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET |
4948 	    STATE_SENT_CMD | STATE_GOT_STATUS;
4949 
4950 	pc = scsipkt->pkt_cdbp[2] >> 6;
4951 
4952 	if (bp != NULL && bp->b_un.b_addr && bp->b_bcount) {
4953 		/*
4954 		 * Because it is fully emulated command storing data
4955 		 * programatically in the specified buffer, release
4956 		 * preallocated DMA resources before storing data in the buffer,
4957 		 * so no unwanted DMA sync would take place.
4958 		 */
4959 		sata_scsi_dmafree(NULL, scsipkt);
4960 
4961 		len = 0;
4962 		bdlen = 0;
4963 		if (!(scsipkt->pkt_cdbp[1] & 8)) {
4964 			if (scsipkt->pkt_cdbp[0] == SCMD_MODE_SENSE_G1 &&
4965 			    (scsipkt->pkt_cdbp[1] & LLBAA))
4966 				bdlen = 16;
4967 			else
4968 				bdlen = 8;
4969 		}
4970 		/* Build mode parameter header */
4971 		if (spx->txlt_scsi_pkt->pkt_cdbp[0] == SCMD_MODE_SENSE) {
4972 			/* 4-byte mode parameter header */
4973 			buf[len++] = 0;		/* mode data length */
4974 			buf[len++] = 0;		/* medium type */
4975 			buf[len++] = 0;		/* dev-specific param */
4976 			buf[len++] = bdlen;	/* Block Descriptor length */
4977 		} else {
4978 			/* 8-byte mode parameter header */
4979 			buf[len++] = 0;		/* mode data length */
4980 			buf[len++] = 0;
4981 			buf[len++] = 0;		/* medium type */
4982 			buf[len++] = 0;		/* dev-specific param */
4983 			if (bdlen == 16)
4984 				buf[len++] = 1;	/* long lba descriptor */
4985 			else
4986 				buf[len++] = 0;
4987 			buf[len++] = 0;
4988 			buf[len++] = 0;		/* Block Descriptor length */
4989 			buf[len++] = bdlen;
4990 		}
4991 
4992 		sdinfo = sata_get_device_info(
4993 		    spx->txlt_sata_hba_inst,
4994 		    &spx->txlt_sata_pkt->satapkt_device);
4995 
4996 		/* Build block descriptor only if not disabled (DBD) */
4997 		if ((scsipkt->pkt_cdbp[1] & 0x08) == 0) {
4998 			/* Block descriptor - direct-access device format */
4999 			if (bdlen == 8) {
5000 				/* build regular block descriptor */
5001 				buf[len++] =
5002 				    (sdinfo->satadrv_capacity >> 24) & 0xff;
5003 				buf[len++] =
5004 				    (sdinfo->satadrv_capacity >> 16) & 0xff;
5005 				buf[len++] =
5006 				    (sdinfo->satadrv_capacity >> 8) & 0xff;
5007 				buf[len++] = sdinfo->satadrv_capacity & 0xff;
5008 				buf[len++] = 0; /* density code */
5009 				buf[len++] = 0;
5010 				if (sdinfo->satadrv_type ==
5011 				    SATA_DTYPE_ATADISK)
5012 					buf[len++] = 2;
5013 				else
5014 					/* ATAPI */
5015 					buf[len++] = 8;
5016 				buf[len++] = 0;
5017 			} else if (bdlen == 16) {
5018 				/* Long LBA Accepted */
5019 				/* build long lba block descriptor */
5020 #ifndef __lock_lint
5021 				buf[len++] =
5022 				    (sdinfo->satadrv_capacity >> 56) & 0xff;
5023 				buf[len++] =
5024 				    (sdinfo->satadrv_capacity >> 48) & 0xff;
5025 				buf[len++] =
5026 				    (sdinfo->satadrv_capacity >> 40) & 0xff;
5027 				buf[len++] =
5028 				    (sdinfo->satadrv_capacity >> 32) & 0xff;
5029 #endif
5030 				buf[len++] =
5031 				    (sdinfo->satadrv_capacity >> 24) & 0xff;
5032 				buf[len++] =
5033 				    (sdinfo->satadrv_capacity >> 16) & 0xff;
5034 				buf[len++] =
5035 				    (sdinfo->satadrv_capacity >> 8) & 0xff;
5036 				buf[len++] = sdinfo->satadrv_capacity & 0xff;
5037 				buf[len++] = 0;
5038 				buf[len++] = 0; /* density code */
5039 				buf[len++] = 0;
5040 				buf[len++] = 0;
5041 				if (sdinfo->satadrv_type ==
5042 				    SATA_DTYPE_ATADISK)
5043 					buf[len++] = 2;
5044 				else
5045 					/* ATAPI */
5046 					buf[len++] = 8;
5047 				buf[len++] = 0;
5048 			}
5049 		}
5050 
5051 		sata_id = &sdinfo->satadrv_id;
5052 
5053 		/*
5054 		 * Add requested pages.
5055 		 * Page 3 and 4 are obsolete and we are not supporting them.
5056 		 * We deal now with:
5057 		 * caching (read/write cache control).
5058 		 * We should eventually deal with following mode pages:
5059 		 * error recovery  (0x01),
5060 		 * power condition (0x1a),
5061 		 * exception control page (enables SMART) (0x1c),
5062 		 * enclosure management (ses),
5063 		 * protocol-specific port mode (port control).
5064 		 */
5065 		switch (scsipkt->pkt_cdbp[2] & 0x3f) {
5066 		case MODEPAGE_RW_ERRRECOV:
5067 			/* DAD_MODE_ERR_RECOV */
5068 			/* R/W recovery */
5069 			len += sata_build_msense_page_1(sdinfo, pc, buf+len);
5070 			break;
5071 		case MODEPAGE_CACHING:
5072 			/* DAD_MODE_CACHE */
5073 			/* Reject not supported request for saved parameters */
5074 			if (pc == 3) {
5075 				*scsipkt->pkt_scbp = STATUS_CHECK;
5076 				sense = sata_arq_sense(spx);
5077 				sense->es_key = KEY_ILLEGAL_REQUEST;
5078 				sense->es_add_code =
5079 				    SD_SCSI_ASC_SAVING_PARAMS_NOT_SUPPORTED;
5080 				goto done;
5081 			}
5082 
5083 			/* caching */
5084 			len += sata_build_msense_page_8(sdinfo, pc, buf+len);
5085 			break;
5086 		case MODEPAGE_INFO_EXCPT:
5087 			/* exception cntrl */
5088 			if (sata_id->ai_cmdset82 & SATA_SMART_SUPPORTED) {
5089 				len += sata_build_msense_page_1c(sdinfo, pc,
5090 				    buf+len);
5091 			}
5092 			else
5093 				goto err;
5094 			break;
5095 		case MODEPAGE_POWER_COND:
5096 			/* DAD_MODE_POWER_COND */
5097 			/* power condition */
5098 			len += sata_build_msense_page_1a(sdinfo, pc, buf+len);
5099 			break;
5100 
5101 		case MODEPAGE_ACOUSTIC_MANAG:
5102 			/* acoustic management */
5103 			len += sata_build_msense_page_30(sdinfo, pc, buf+len);
5104 			break;
5105 		case MODEPAGE_ALLPAGES:
5106 			/* all pages */
5107 			len += sata_build_msense_page_1(sdinfo, pc, buf+len);
5108 			len += sata_build_msense_page_8(sdinfo, pc, buf+len);
5109 			len += sata_build_msense_page_1a(sdinfo, pc, buf+len);
5110 			if (sata_id->ai_cmdset82 & SATA_SMART_SUPPORTED) {
5111 				len += sata_build_msense_page_1c(sdinfo, pc,
5112 				    buf+len);
5113 			}
5114 			len += sata_build_msense_page_30(sdinfo, pc, buf+len);
5115 			break;
5116 		default:
5117 		err:
5118 			/* Invalid request */
5119 			*scsipkt->pkt_scbp = STATUS_CHECK;
5120 			sense = sata_arq_sense(spx);
5121 			sense->es_key = KEY_ILLEGAL_REQUEST;
5122 			sense->es_add_code = SD_SCSI_ASC_INVALID_FIELD_IN_CDB;
5123 			goto done;
5124 		}
5125 
5126 		/* fix total mode data length */
5127 		if (spx->txlt_scsi_pkt->pkt_cdbp[0] == SCMD_MODE_SENSE) {
5128 			/* 4-byte mode parameter header */
5129 			buf[0] = len - 1;	/* mode data length */
5130 		} else {
5131 			buf[0] = (len -2) >> 8;
5132 			buf[1] = (len -2) & 0xff;
5133 		}
5134 
5135 
5136 		/* Check allocation length */
5137 		if (scsipkt->pkt_cdbp[0] == SCMD_MODE_SENSE) {
5138 			alc_len = scsipkt->pkt_cdbp[4];
5139 		} else {
5140 			alc_len = scsipkt->pkt_cdbp[7];
5141 			alc_len = (len << 8) | scsipkt->pkt_cdbp[8];
5142 		}
5143 		/*
5144 		 * We do not check for possible parameters truncation
5145 		 * (alc_len < len) assuming that the target driver works
5146 		 * correctly. Just avoiding overrun.
5147 		 * Copy no more than requested and possible, buffer-wise.
5148 		 */
5149 		count = MIN(alc_len, len);
5150 		count = MIN(bp->b_bcount, count);
5151 		bcopy(buf, bp->b_un.b_addr, count);
5152 
5153 		scsipkt->pkt_state |= STATE_XFERRED_DATA;
5154 		scsipkt->pkt_resid = alc_len > count ? alc_len - count : 0;
5155 	}
5156 	*scsipkt->pkt_scbp = STATUS_GOOD;
5157 done:
5158 	mutex_exit(cport_mutex);
5159 	(void) kmem_free(buf, 1024);
5160 
5161 	SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst,
5162 	    "Scsi_pkt completion reason %x\n", scsipkt->pkt_reason);
5163 
5164 	if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0 &&
5165 	    scsipkt->pkt_comp != NULL) {
5166 		/* scsi callback required */
5167 		if (servicing_interrupt()) {
5168 			if (taskq_dispatch(SATA_TXLT_TASKQ(spx),
5169 			    (task_func_t *)spx->txlt_scsi_pkt->pkt_comp,
5170 			    (void *)spx->txlt_scsi_pkt, TQ_NOSLEEP) == NULL) {
5171 				return (TRAN_BUSY);
5172 			}
5173 		} else if (taskq_dispatch(SATA_TXLT_TASKQ(spx),
5174 		    (task_func_t *)spx->txlt_scsi_pkt->pkt_comp,
5175 		    (void *)spx->txlt_scsi_pkt, TQ_SLEEP) == NULL) {
5176 			/* Scheduling the callback failed */
5177 			return (TRAN_BUSY);
5178 		}
5179 	}
5180 
5181 	return (TRAN_ACCEPT);
5182 }
5183 
5184 
5185 /*
5186  * SATA translate command: Mode Select.
5187  * Translated into appropriate SATA command or emulated.
5188  * Saving parameters is not supported.
5189  * Changing device capacity is not supported (although theoretically
5190  * possible by executing SET FEATURES/SET MAX ADDRESS)
5191  *
5192  * Assumption is that the target driver is working correctly.
5193  *
5194  * More than one SATA command may be executed to perform operations specified
5195  * by mode select pages. The first error terminates further execution.
5196  * Operations performed successully are not backed-up in such case.
5197  *
5198  * NOTE: Implemented pages:
5199  * - caching page
5200  * - informational exception page
5201  * - acoustic management page
5202  * - power condition page
5203  * Caching setup is remembered so it could be re-stored in case of
5204  * an unexpected device reset.
5205  *
5206  * Returns TRAN_XXXX.
5207  * If TRAN_ACCEPT is returned, appropriate values are set in scsi_pkt fields.
5208  */
5209 
5210 static int
5211 sata_txlt_mode_select(sata_pkt_txlate_t *spx)
5212 {
5213 	struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt;
5214 	struct buf *bp = spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp;
5215 	struct scsi_extended_sense *sense;
5216 	int len, pagelen, count, pllen;
5217 	uint8_t *buf;	/* mode select buffer */
5218 	int rval, stat, reason;
5219 	uint_t nointr_flag;
5220 	int dmod = 0;
5221 	kmutex_t *cport_mutex = &(SATA_TXLT_CPORT_MUTEX(spx));
5222 
5223 	SATADBG2(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst,
5224 	    "sata_txlt_mode_select, pc %x page code 0x%02x\n",
5225 	    spx->txlt_scsi_pkt->pkt_cdbp[2] >> 6,
5226 	    spx->txlt_scsi_pkt->pkt_cdbp[2] & 0x3f);
5227 
5228 	mutex_enter(cport_mutex);
5229 
5230 	if (((rval = sata_txlt_generic_pkt_info(spx, &reason, 1)) !=
5231 	    TRAN_ACCEPT) || (reason == CMD_DEV_GONE)) {
5232 		mutex_exit(cport_mutex);
5233 		return (rval);
5234 	}
5235 
5236 	rval = TRAN_ACCEPT;
5237 
5238 	scsipkt->pkt_reason = CMD_CMPLT;
5239 	scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET |
5240 	    STATE_SENT_CMD | STATE_GOT_STATUS;
5241 	nointr_flag = scsipkt->pkt_flags & FLAG_NOINTR;
5242 
5243 	/* Reject not supported request */
5244 	if (! (scsipkt->pkt_cdbp[1] & 0x10)) { /* No support for PF bit = 0 */
5245 		*scsipkt->pkt_scbp = STATUS_CHECK;
5246 		sense = sata_arq_sense(spx);
5247 		sense->es_key = KEY_ILLEGAL_REQUEST;
5248 		sense->es_add_code = SD_SCSI_ASC_INVALID_FIELD_IN_CDB;
5249 		goto done;
5250 	}
5251 
5252 	if (scsipkt->pkt_cdbp[0] == SCMD_MODE_SELECT) {
5253 		pllen = scsipkt->pkt_cdbp[4];
5254 	} else {
5255 		pllen = scsipkt->pkt_cdbp[7];
5256 		pllen = (pllen << 8) | scsipkt->pkt_cdbp[7];
5257 	}
5258 
5259 	*scsipkt->pkt_scbp = STATUS_GOOD;	/* Presumed outcome */
5260 
5261 	if (bp != NULL && bp->b_un.b_addr && bp->b_bcount && pllen != 0) {
5262 		buf = (uint8_t *)bp->b_un.b_addr;
5263 		count = MIN(bp->b_bcount, pllen);
5264 		scsipkt->pkt_state |= STATE_XFERRED_DATA;
5265 		scsipkt->pkt_resid = 0;
5266 		pllen = count;
5267 
5268 		/*
5269 		 * Check the header to skip the block descriptor(s) - we
5270 		 * do not support setting device capacity.
5271 		 * Existing macros do not recognize long LBA dscriptor,
5272 		 * hence manual calculation.
5273 		 */
5274 		if (scsipkt->pkt_cdbp[0] == SCMD_MODE_SELECT) {
5275 			/* 6-bytes CMD, 4 bytes header */
5276 			if (count <= 4)
5277 				goto done;		/* header only */
5278 			len = buf[3] + 4;
5279 		} else {
5280 			/* 10-bytes CMD, 8 bytes header */
5281 			if (count <= 8)
5282 				goto done;		/* header only */
5283 			len = buf[6];
5284 			len = (len << 8) + buf[7] + 8;
5285 		}
5286 		if (len >= count)
5287 			goto done;	/* header + descriptor(s) only */
5288 
5289 		pllen -= len;		/* remaining data length */
5290 
5291 		/*
5292 		 * We may be executing SATA command and want to execute it
5293 		 * in SYNCH mode, regardless of scsi_pkt setting.
5294 		 * Save scsi_pkt setting and indicate SYNCH mode
5295 		 */
5296 		if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0 &&
5297 		    scsipkt->pkt_comp != NULL) {
5298 			scsipkt->pkt_flags |= FLAG_NOINTR;
5299 		}
5300 		spx->txlt_sata_pkt->satapkt_op_mode = SATA_OPMODE_SYNCH;
5301 
5302 		/*
5303 		 * len is now the offset to a first mode select page
5304 		 * Process all pages
5305 		 */
5306 		while (pllen > 0) {
5307 			switch ((int)buf[len]) {
5308 			case MODEPAGE_CACHING:
5309 				/* No support for SP (saving) */
5310 				if (scsipkt->pkt_cdbp[1] & 0x01) {
5311 					*scsipkt->pkt_scbp = STATUS_CHECK;
5312 					sense = sata_arq_sense(spx);
5313 					sense->es_key = KEY_ILLEGAL_REQUEST;
5314 					sense->es_add_code =
5315 					    SD_SCSI_ASC_INVALID_FIELD_IN_CDB;
5316 					goto done;
5317 				}
5318 				stat = sata_mode_select_page_8(spx,
5319 				    (struct mode_cache_scsi3 *)&buf[len],
5320 				    pllen, &pagelen, &rval, &dmod);
5321 				/*
5322 				 * The pagelen value indicates the number of
5323 				 * parameter bytes already processed.
5324 				 * The rval is the return value from
5325 				 * sata_tran_start().
5326 				 * The stat indicates the overall status of
5327 				 * the operation(s).
5328 				 */
5329 				if (stat != SATA_SUCCESS)
5330 					/*
5331 					 * Page processing did not succeed -
5332 					 * all error info is already set-up,
5333 					 * just return
5334 					 */
5335 					pllen = 0; /* this breaks the loop */
5336 				else {
5337 					len += pagelen;
5338 					pllen -= pagelen;
5339 				}
5340 				break;
5341 
5342 			case MODEPAGE_INFO_EXCPT:
5343 				stat = sata_mode_select_page_1c(spx,
5344 				    (struct mode_info_excpt_page *)&buf[len],
5345 				    pllen, &pagelen, &rval, &dmod);
5346 				/*
5347 				 * The pagelen value indicates the number of
5348 				 * parameter bytes already processed.
5349 				 * The rval is the return value from
5350 				 * sata_tran_start().
5351 				 * The stat indicates the overall status of
5352 				 * the operation(s).
5353 				 */
5354 				if (stat != SATA_SUCCESS)
5355 					/*
5356 					 * Page processing did not succeed -
5357 					 * all error info is already set-up,
5358 					 * just return
5359 					 */
5360 					pllen = 0; /* this breaks the loop */
5361 				else {
5362 					len += pagelen;
5363 					pllen -= pagelen;
5364 				}
5365 				break;
5366 
5367 			case MODEPAGE_ACOUSTIC_MANAG:
5368 				stat = sata_mode_select_page_30(spx,
5369 				    (struct mode_acoustic_management *)
5370 				    &buf[len], pllen, &pagelen, &rval, &dmod);
5371 				/*
5372 				 * The pagelen value indicates the number of
5373 				 * parameter bytes already processed.
5374 				 * The rval is the return value from
5375 				 * sata_tran_start().
5376 				 * The stat indicates the overall status of
5377 				 * the operation(s).
5378 				 */
5379 				if (stat != SATA_SUCCESS)
5380 					/*
5381 					 * Page processing did not succeed -
5382 					 * all error info is already set-up,
5383 					 * just return
5384 					 */
5385 					pllen = 0; /* this breaks the loop */
5386 				else {
5387 					len += pagelen;
5388 					pllen -= pagelen;
5389 				}
5390 
5391 				break;
5392 			case MODEPAGE_POWER_COND:
5393 				stat = sata_mode_select_page_1a(spx,
5394 				    (struct mode_info_power_cond *)&buf[len],
5395 				    pllen, &pagelen, &rval, &dmod);
5396 				/*
5397 				 * The pagelen value indicates the number of
5398 				 * parameter bytes already processed.
5399 				 * The rval is the return value from
5400 				 * sata_tran_start().
5401 				 * The stat indicates the overall status of
5402 				 * the operation(s).
5403 				 */
5404 				if (stat != SATA_SUCCESS)
5405 					/*
5406 					 * Page processing did not succeed -
5407 					 * all error info is already set-up,
5408 					 * just return
5409 					 */
5410 					pllen = 0; /* this breaks the loop */
5411 				else {
5412 					len += pagelen;
5413 					pllen -= pagelen;
5414 				}
5415 				break;
5416 			default:
5417 				*scsipkt->pkt_scbp = STATUS_CHECK;
5418 				sense = sata_arq_sense(spx);
5419 				sense->es_key = KEY_ILLEGAL_REQUEST;
5420 				sense->es_add_code =
5421 				    SD_SCSI_ASC_INVALID_FIELD_IN_PARAMS_LIST;
5422 				goto done;
5423 			}
5424 		}
5425 	}
5426 done:
5427 	mutex_exit(cport_mutex);
5428 	/*
5429 	 * If device parameters were modified, fetch and store the new
5430 	 * Identify Device data. Since port mutex could have been released
5431 	 * for accessing HBA driver, we need to re-check device existence.
5432 	 */
5433 	if (dmod != 0) {
5434 		sata_drive_info_t new_sdinfo, *sdinfo;
5435 		int rv = 0;
5436 
5437 		/*
5438 		 * Following statement has to be changed if this function is
5439 		 * used for devices other than SATA hard disks.
5440 		 */
5441 		new_sdinfo.satadrv_type = SATA_DTYPE_ATADISK;
5442 
5443 		new_sdinfo.satadrv_addr =
5444 		    spx->txlt_sata_pkt->satapkt_device.satadev_addr;
5445 		rv = sata_fetch_device_identify_data(spx->txlt_sata_hba_inst,
5446 		    &new_sdinfo);
5447 
5448 		mutex_enter(cport_mutex);
5449 		/*
5450 		 * Since port mutex could have been released when
5451 		 * accessing HBA driver, we need to re-check that the
5452 		 * framework still holds the device info structure.
5453 		 */
5454 		sdinfo = sata_get_device_info(spx->txlt_sata_hba_inst,
5455 		    &spx->txlt_sata_pkt->satapkt_device);
5456 		if (sdinfo != NULL) {
5457 			/*
5458 			 * Device still has info structure in the
5459 			 * sata framework. Copy newly fetched info
5460 			 */
5461 			if (rv == 0) {
5462 				sdinfo->satadrv_id = new_sdinfo.satadrv_id;
5463 				sata_save_drive_settings(sdinfo);
5464 			} else {
5465 				/*
5466 				 * Could not fetch new data - invalidate
5467 				 * sata_drive_info. That makes device
5468 				 * unusable.
5469 				 */
5470 				sdinfo->satadrv_type = SATA_DTYPE_UNKNOWN;
5471 				sdinfo->satadrv_state = SATA_STATE_UNKNOWN;
5472 			}
5473 		}
5474 		if (rv != 0 || sdinfo == NULL) {
5475 			/*
5476 			 * This changes the overall mode select completion
5477 			 * reason to a failed one !!!!!
5478 			 */
5479 			*scsipkt->pkt_scbp = STATUS_CHECK;
5480 			sense = sata_arq_sense(spx);
5481 			scsipkt->pkt_reason = CMD_INCOMPLETE;
5482 			rval = TRAN_ACCEPT;
5483 		}
5484 		mutex_exit(cport_mutex);
5485 	}
5486 	/* Restore the scsi pkt flags */
5487 	scsipkt->pkt_flags &= ~FLAG_NOINTR;
5488 	scsipkt->pkt_flags |= nointr_flag;
5489 
5490 	SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst,
5491 	    "Scsi_pkt completion reason %x\n", scsipkt->pkt_reason);
5492 
5493 	if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0 &&
5494 	    scsipkt->pkt_comp != NULL) {
5495 		/* scsi callback required */
5496 		if (servicing_interrupt()) {
5497 			if (taskq_dispatch(SATA_TXLT_TASKQ(spx),
5498 			    (task_func_t *)spx->txlt_scsi_pkt->pkt_comp,
5499 			    (void *)spx->txlt_scsi_pkt, TQ_NOSLEEP) == NULL) {
5500 				return (TRAN_BUSY);
5501 			}
5502 		} else if (taskq_dispatch(SATA_TXLT_TASKQ(spx),
5503 		    (task_func_t *)spx->txlt_scsi_pkt->pkt_comp,
5504 		    (void *)spx->txlt_scsi_pkt, TQ_SLEEP) == NULL) {
5505 			/* Scheduling the callback failed */
5506 			return (TRAN_BUSY);
5507 		}
5508 	}
5509 
5510 	return (rval);
5511 }
5512 
5513 /*
5514  * Translate command: ATA Pass Through
5515  * Incomplete implementation.  Only supports No-Data, PIO Data-In, and
5516  * PIO Data-Out protocols.  Also supports CK_COND bit.
5517  *
5518  * Mapping of the incoming CDB bytes to the outgoing satacmd bytes is
5519  * described in Table 111 of SAT-2 (Draft 9).
5520  */
5521 static  int
5522 sata_txlt_ata_pass_thru(sata_pkt_txlate_t *spx)
5523 {
5524 	struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt;
5525 	sata_cmd_t *scmd = &spx->txlt_sata_pkt->satapkt_cmd;
5526 	struct buf *bp = spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp;
5527 	int extend;
5528 	uint64_t lba;
5529 	uint16_t feature, sec_count;
5530 	int t_len, synch;
5531 	int rval, reason;
5532 	kmutex_t *cport_mutex = &(SATA_TXLT_CPORT_MUTEX(spx));
5533 
5534 	mutex_enter(cport_mutex);
5535 
5536 	rval = sata_txlt_generic_pkt_info(spx, &reason, 1);
5537 	if ((rval != TRAN_ACCEPT) || (reason == CMD_DEV_GONE)) {
5538 		mutex_exit(cport_mutex);
5539 		return (rval);
5540 	}
5541 
5542 	/* T_DIR bit */
5543 	if (scsipkt->pkt_cdbp[2] & SATL_APT_BM_T_DIR)
5544 		scmd->satacmd_flags.sata_data_direction = SATA_DIR_READ;
5545 	else
5546 		scmd->satacmd_flags.sata_data_direction = SATA_DIR_WRITE;
5547 
5548 	/* MULTIPLE_COUNT field.  If non-zero, invalid command (for now). */
5549 	if (((scsipkt->pkt_cdbp[1] >> 5) & 0x7) != 0) {
5550 		mutex_exit(cport_mutex);
5551 		return (sata_txlt_ata_pass_thru_illegal_cmd(spx));
5552 	}
5553 
5554 	/* OFFLINE field. If non-zero, invalid command (for now). */
5555 	if (((scsipkt->pkt_cdbp[2] >> 6) & 0x3) != 0) {
5556 		mutex_exit(cport_mutex);
5557 		return (sata_txlt_ata_pass_thru_illegal_cmd(spx));
5558 	}
5559 
5560 	/* PROTOCOL field */
5561 	switch ((scsipkt->pkt_cdbp[1] >> 1) & 0xf) {
5562 	case SATL_APT_P_HW_RESET:
5563 	case SATL_APT_P_SRST:
5564 	case SATL_APT_P_DMA:
5565 	case SATL_APT_P_DMA_QUEUED:
5566 	case SATL_APT_P_DEV_DIAG:
5567 	case SATL_APT_P_DEV_RESET:
5568 	case SATL_APT_P_UDMA_IN:
5569 	case SATL_APT_P_UDMA_OUT:
5570 	case SATL_APT_P_FPDMA:
5571 	case SATL_APT_P_RET_RESP:
5572 		/* Not yet implemented */
5573 	default:
5574 		mutex_exit(cport_mutex);
5575 		return (sata_txlt_ata_pass_thru_illegal_cmd(spx));
5576 
5577 	case SATL_APT_P_NON_DATA:
5578 		scmd->satacmd_flags.sata_data_direction = SATA_DIR_NODATA_XFER;
5579 		break;
5580 
5581 	case SATL_APT_P_PIO_DATA_IN:
5582 		/* If PROTOCOL disagrees with T_DIR, invalid command */
5583 		if (scmd->satacmd_flags.sata_data_direction == SATA_DIR_WRITE) {
5584 			mutex_exit(cport_mutex);
5585 			return (sata_txlt_ata_pass_thru_illegal_cmd(spx));
5586 		}
5587 
5588 		/* if there is a buffer, release its DMA resources */
5589 		if ((bp != NULL) && bp->b_un.b_addr && bp->b_bcount) {
5590 			sata_scsi_dmafree(NULL, scsipkt);
5591 		} else {
5592 			/* if there is no buffer, how do you PIO in? */
5593 			mutex_exit(cport_mutex);
5594 			return (sata_txlt_ata_pass_thru_illegal_cmd(spx));
5595 		}
5596 
5597 		break;
5598 
5599 	case SATL_APT_P_PIO_DATA_OUT:
5600 		/* If PROTOCOL disagrees with T_DIR, invalid command */
5601 		if (scmd->satacmd_flags.sata_data_direction == SATA_DIR_READ) {
5602 			mutex_exit(cport_mutex);
5603 			return (sata_txlt_ata_pass_thru_illegal_cmd(spx));
5604 		}
5605 
5606 		/* if there is a buffer, release its DMA resources */
5607 		if ((bp != NULL) && bp->b_un.b_addr && bp->b_bcount) {
5608 			sata_scsi_dmafree(NULL, scsipkt);
5609 		} else {
5610 			/* if there is no buffer, how do you PIO out? */
5611 			mutex_exit(cport_mutex);
5612 			return (sata_txlt_ata_pass_thru_illegal_cmd(spx));
5613 		}
5614 
5615 		break;
5616 	}
5617 
5618 	/* Parse the ATA cmd fields, transfer some straight to the satacmd */
5619 	switch ((uint_t)scsipkt->pkt_cdbp[0]) {
5620 	case SPC3_CMD_ATA_COMMAND_PASS_THROUGH12:
5621 		feature = scsipkt->pkt_cdbp[3];
5622 
5623 		sec_count = scsipkt->pkt_cdbp[4];
5624 
5625 		lba = scsipkt->pkt_cdbp[8] & 0xf;
5626 		lba = (lba << 8) | scsipkt->pkt_cdbp[7];
5627 		lba = (lba << 8) | scsipkt->pkt_cdbp[6];
5628 		lba = (lba << 8) | scsipkt->pkt_cdbp[5];
5629 
5630 		scmd->satacmd_device_reg = scsipkt->pkt_cdbp[13] & 0xf0;
5631 		scmd->satacmd_cmd_reg = scsipkt->pkt_cdbp[9];
5632 
5633 		break;
5634 
5635 	case SPC3_CMD_ATA_COMMAND_PASS_THROUGH16:
5636 		if (scsipkt->pkt_cdbp[1] & SATL_APT_BM_EXTEND) {
5637 			extend = 1;
5638 
5639 			feature = scsipkt->pkt_cdbp[3];
5640 			feature = (feature << 8) | scsipkt->pkt_cdbp[4];
5641 
5642 			sec_count = scsipkt->pkt_cdbp[5];
5643 			sec_count = (sec_count << 8) | scsipkt->pkt_cdbp[6];
5644 
5645 			lba = scsipkt->pkt_cdbp[11];
5646 			lba = (lba << 8) | scsipkt->pkt_cdbp[12];
5647 			lba = (lba << 8) | scsipkt->pkt_cdbp[9];
5648 			lba = (lba << 8) | scsipkt->pkt_cdbp[10];
5649 			lba = (lba << 8) | scsipkt->pkt_cdbp[7];
5650 			lba = (lba << 8) | scsipkt->pkt_cdbp[8];
5651 
5652 			scmd->satacmd_device_reg = scsipkt->pkt_cdbp[13];
5653 			scmd->satacmd_cmd_reg = scsipkt->pkt_cdbp[14];
5654 		} else {
5655 			feature = scsipkt->pkt_cdbp[3];
5656 
5657 			sec_count = scsipkt->pkt_cdbp[5];
5658 
5659 			lba = scsipkt->pkt_cdbp[13] & 0xf;
5660 			lba = (lba << 8) | scsipkt->pkt_cdbp[12];
5661 			lba = (lba << 8) | scsipkt->pkt_cdbp[10];
5662 			lba = (lba << 8) | scsipkt->pkt_cdbp[8];
5663 
5664 			scmd->satacmd_device_reg = scsipkt->pkt_cdbp[13] &
5665 			    0xf0;
5666 			scmd->satacmd_cmd_reg = scsipkt->pkt_cdbp[14];
5667 		}
5668 
5669 		break;
5670 	}
5671 
5672 	/* CK_COND bit */
5673 	if (scsipkt->pkt_cdbp[2] & SATL_APT_BM_CK_COND) {
5674 		if (extend) {
5675 			scmd->satacmd_flags.sata_copy_out_sec_count_msb = 1;
5676 			scmd->satacmd_flags.sata_copy_out_lba_low_msb = 1;
5677 			scmd->satacmd_flags.sata_copy_out_lba_mid_msb = 1;
5678 			scmd->satacmd_flags.sata_copy_out_lba_high_msb = 1;
5679 		}
5680 
5681 		scmd->satacmd_flags.sata_copy_out_sec_count_lsb = 1;
5682 		scmd->satacmd_flags.sata_copy_out_lba_low_lsb = 1;
5683 		scmd->satacmd_flags.sata_copy_out_lba_mid_lsb = 1;
5684 		scmd->satacmd_flags.sata_copy_out_lba_high_lsb = 1;
5685 		scmd->satacmd_flags.sata_copy_out_device_reg = 1;
5686 		scmd->satacmd_flags.sata_copy_out_error_reg = 1;
5687 	}
5688 
5689 	/* Transfer remaining parsed ATA cmd values to the satacmd */
5690 	if (extend) {
5691 		scmd->satacmd_addr_type = ATA_ADDR_LBA48;
5692 
5693 		scmd->satacmd_features_reg_ext = (feature >> 8) & 0xff;
5694 		scmd->satacmd_sec_count_msb = (sec_count >> 8) & 0xff;
5695 		scmd->satacmd_lba_low_msb = (lba >> 8) & 0xff;
5696 		scmd->satacmd_lba_mid_msb = (lba >> 8) & 0xff;
5697 		scmd->satacmd_lba_high_msb = lba >> 40;
5698 	} else {
5699 		scmd->satacmd_addr_type = ATA_ADDR_LBA28;
5700 
5701 		scmd->satacmd_features_reg_ext = 0;
5702 		scmd->satacmd_sec_count_msb = 0;
5703 		scmd->satacmd_lba_low_msb = 0;
5704 		scmd->satacmd_lba_mid_msb = 0;
5705 		scmd->satacmd_lba_high_msb = 0;
5706 	}
5707 
5708 	scmd->satacmd_features_reg = feature & 0xff;
5709 	scmd->satacmd_sec_count_lsb = sec_count & 0xff;
5710 	scmd->satacmd_lba_low_lsb = lba & 0xff;
5711 	scmd->satacmd_lba_mid_lsb = (lba >> 8) & 0xff;
5712 	scmd->satacmd_lba_high_lsb = (lba >> 16) & 0xff;
5713 
5714 	/* Determine transfer length */
5715 	switch (scsipkt->pkt_cdbp[2] & 0x3) {		/* T_LENGTH field */
5716 	case 1:
5717 		t_len = feature;
5718 		break;
5719 	case 2:
5720 		t_len = sec_count;
5721 		break;
5722 	default:
5723 		t_len = 0;
5724 		break;
5725 	}
5726 
5727 	/* Adjust transfer length for the Byte Block bit */
5728 	if ((scsipkt->pkt_cdbp[2] >> 2) & 1)
5729 		t_len *= SATA_DISK_SECTOR_SIZE;
5730 
5731 	/* Start processing command */
5732 	if (!(spx->txlt_sata_pkt->satapkt_op_mode & SATA_OPMODE_SYNCH)) {
5733 		spx->txlt_sata_pkt->satapkt_comp = sata_txlt_apt_completion;
5734 		synch = FALSE;
5735 	} else {
5736 		synch = TRUE;
5737 	}
5738 
5739 	if (sata_hba_start(spx, &rval) != 0) {
5740 		mutex_exit(cport_mutex);
5741 		return (rval);
5742 	}
5743 
5744 	mutex_exit(cport_mutex);
5745 
5746 	if (synch) {
5747 		sata_txlt_apt_completion(spx->txlt_sata_pkt);
5748 	}
5749 
5750 	return (TRAN_ACCEPT);
5751 }
5752 
5753 /*
5754  * Translate command: Log Sense
5755  */
5756 static 	int
5757 sata_txlt_log_sense(sata_pkt_txlate_t *spx)
5758 {
5759 	struct scsi_pkt	*scsipkt = spx->txlt_scsi_pkt;
5760 	struct buf	*bp = spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp;
5761 	sata_drive_info_t *sdinfo;
5762 	struct scsi_extended_sense *sense;
5763 	int 		len, count, alc_len;
5764 	int		pc;	/* Page Control code */
5765 	int		page_code;	/* Page code */
5766 	uint8_t		*buf;	/* log sense buffer */
5767 	int		rval, reason;
5768 #define	MAX_LOG_SENSE_PAGE_SIZE	512
5769 	kmutex_t	*cport_mutex = &(SATA_TXLT_CPORT_MUTEX(spx));
5770 
5771 	SATADBG2(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst,
5772 	    "sata_txlt_log_sense, pc 0x%x, page code 0x%x\n",
5773 	    spx->txlt_scsi_pkt->pkt_cdbp[2] >> 6,
5774 	    spx->txlt_scsi_pkt->pkt_cdbp[2] & 0x3f);
5775 
5776 	if (servicing_interrupt()) {
5777 		buf = kmem_zalloc(MAX_LOG_SENSE_PAGE_SIZE, KM_NOSLEEP);
5778 		if (buf == NULL) {
5779 			return (TRAN_BUSY);
5780 		}
5781 	} else {
5782 		buf = kmem_zalloc(MAX_LOG_SENSE_PAGE_SIZE, KM_SLEEP);
5783 	}
5784 
5785 	mutex_enter(cport_mutex);
5786 
5787 	if (((rval = sata_txlt_generic_pkt_info(spx, &reason, 1)) !=
5788 	    TRAN_ACCEPT) || (reason == CMD_DEV_GONE)) {
5789 		mutex_exit(cport_mutex);
5790 		kmem_free(buf, MAX_LOG_SENSE_PAGE_SIZE);
5791 		return (rval);
5792 	}
5793 
5794 	scsipkt->pkt_reason = CMD_CMPLT;
5795 	scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET |
5796 	    STATE_SENT_CMD | STATE_GOT_STATUS;
5797 
5798 	pc = scsipkt->pkt_cdbp[2] >> 6;
5799 	page_code = scsipkt->pkt_cdbp[2] & 0x3f;
5800 
5801 	/* Reject not supported request for all but cumulative values */
5802 	switch (pc) {
5803 	case PC_CUMULATIVE_VALUES:
5804 		break;
5805 	default:
5806 		*scsipkt->pkt_scbp = STATUS_CHECK;
5807 		sense = sata_arq_sense(spx);
5808 		sense->es_key = KEY_ILLEGAL_REQUEST;
5809 		sense->es_add_code = SD_SCSI_ASC_INVALID_FIELD_IN_CDB;
5810 		goto done;
5811 	}
5812 
5813 	switch (page_code) {
5814 	case PAGE_CODE_GET_SUPPORTED_LOG_PAGES:
5815 	case PAGE_CODE_SELF_TEST_RESULTS:
5816 	case PAGE_CODE_INFORMATION_EXCEPTIONS:
5817 	case PAGE_CODE_SMART_READ_DATA:
5818 	case PAGE_CODE_START_STOP_CYCLE_COUNTER:
5819 		break;
5820 	default:
5821 		*scsipkt->pkt_scbp = STATUS_CHECK;
5822 		sense = sata_arq_sense(spx);
5823 		sense->es_key = KEY_ILLEGAL_REQUEST;
5824 		sense->es_add_code = SD_SCSI_ASC_INVALID_FIELD_IN_CDB;
5825 		goto done;
5826 	}
5827 
5828 	if (bp != NULL && bp->b_un.b_addr && bp->b_bcount) {
5829 		/*
5830 		 * Because log sense uses local buffers for data retrieval from
5831 		 * the devices and sets the data programatically in the
5832 		 * original specified buffer, release preallocated DMA
5833 		 * resources before storing data in the original buffer,
5834 		 * so no unwanted DMA sync would take place.
5835 		 */
5836 		sata_id_t *sata_id;
5837 
5838 		sata_scsi_dmafree(NULL, scsipkt);
5839 
5840 		len = 0;
5841 
5842 		/* Build log parameter header */
5843 		buf[len++] = page_code;	/* page code as in the CDB */
5844 		buf[len++] = 0;		/* reserved */
5845 		buf[len++] = 0;		/* Zero out page length for now (MSB) */
5846 		buf[len++] = 0;		/* (LSB) */
5847 
5848 		sdinfo = sata_get_device_info(
5849 		    spx->txlt_sata_hba_inst,
5850 		    &spx->txlt_sata_pkt->satapkt_device);
5851 
5852 		/*
5853 		 * Add requested pages.
5854 		 */
5855 		switch (page_code) {
5856 		case PAGE_CODE_GET_SUPPORTED_LOG_PAGES:
5857 			len = sata_build_lsense_page_0(sdinfo, buf + len);
5858 			break;
5859 		case PAGE_CODE_SELF_TEST_RESULTS:
5860 			sata_id = &sdinfo->satadrv_id;
5861 			if ((! (sata_id->ai_cmdset84 &
5862 			    SATA_SMART_SELF_TEST_SUPPORTED)) ||
5863 			    (! (sata_id->ai_features87 &
5864 			    SATA_SMART_SELF_TEST_SUPPORTED))) {
5865 				*scsipkt->pkt_scbp = STATUS_CHECK;
5866 				sense = sata_arq_sense(spx);
5867 				sense->es_key = KEY_ILLEGAL_REQUEST;
5868 				sense->es_add_code =
5869 				    SD_SCSI_ASC_INVALID_FIELD_IN_CDB;
5870 
5871 				goto done;
5872 			}
5873 			len = sata_build_lsense_page_10(sdinfo, buf + len,
5874 			    spx->txlt_sata_hba_inst);
5875 			break;
5876 		case PAGE_CODE_INFORMATION_EXCEPTIONS:
5877 			sata_id = &sdinfo->satadrv_id;
5878 			if (! (sata_id->ai_cmdset82 & SATA_SMART_SUPPORTED)) {
5879 				*scsipkt->pkt_scbp = STATUS_CHECK;
5880 				sense = sata_arq_sense(spx);
5881 				sense->es_key = KEY_ILLEGAL_REQUEST;
5882 				sense->es_add_code =
5883 				    SD_SCSI_ASC_INVALID_FIELD_IN_CDB;
5884 
5885 				goto done;
5886 			}
5887 			if (! (sata_id->ai_features85 & SATA_SMART_ENABLED)) {
5888 				*scsipkt->pkt_scbp = STATUS_CHECK;
5889 				sense = sata_arq_sense(spx);
5890 				sense->es_key = KEY_ABORTED_COMMAND;
5891 				sense->es_add_code =
5892 				    SCSI_ASC_ATA_DEV_FEAT_NOT_ENABLED;
5893 				sense->es_qual_code =
5894 				    SCSI_ASCQ_ATA_DEV_FEAT_NOT_ENABLED;
5895 
5896 				goto done;
5897 			}
5898 
5899 			len = sata_build_lsense_page_2f(sdinfo, buf + len,
5900 			    spx->txlt_sata_hba_inst);
5901 			break;
5902 		case PAGE_CODE_SMART_READ_DATA:
5903 			sata_id = &sdinfo->satadrv_id;
5904 			if (! (sata_id->ai_cmdset82 & SATA_SMART_SUPPORTED)) {
5905 				*scsipkt->pkt_scbp = STATUS_CHECK;
5906 				sense = sata_arq_sense(spx);
5907 				sense->es_key = KEY_ILLEGAL_REQUEST;
5908 				sense->es_add_code =
5909 				    SD_SCSI_ASC_INVALID_FIELD_IN_CDB;
5910 
5911 				goto done;
5912 			}
5913 			if (! (sata_id->ai_features85 & SATA_SMART_ENABLED)) {
5914 				*scsipkt->pkt_scbp = STATUS_CHECK;
5915 				sense = sata_arq_sense(spx);
5916 				sense->es_key = KEY_ABORTED_COMMAND;
5917 				sense->es_add_code =
5918 				    SCSI_ASC_ATA_DEV_FEAT_NOT_ENABLED;
5919 				sense->es_qual_code =
5920 				    SCSI_ASCQ_ATA_DEV_FEAT_NOT_ENABLED;
5921 
5922 				goto done;
5923 			}
5924 
5925 			/* This page doesn't include a page header */
5926 			len = sata_build_lsense_page_30(sdinfo, buf,
5927 			    spx->txlt_sata_hba_inst);
5928 			goto no_header;
5929 		case PAGE_CODE_START_STOP_CYCLE_COUNTER:
5930 			sata_id = &sdinfo->satadrv_id;
5931 			if (! (sata_id->ai_cmdset82 & SATA_SMART_SUPPORTED)) {
5932 				*scsipkt->pkt_scbp = STATUS_CHECK;
5933 				sense = sata_arq_sense(spx);
5934 				sense->es_key = KEY_ILLEGAL_REQUEST;
5935 				sense->es_add_code =
5936 				    SD_SCSI_ASC_INVALID_FIELD_IN_CDB;
5937 
5938 				goto done;
5939 			}
5940 			if (! (sata_id->ai_features85 & SATA_SMART_ENABLED)) {
5941 				*scsipkt->pkt_scbp = STATUS_CHECK;
5942 				sense = sata_arq_sense(spx);
5943 				sense->es_key = KEY_ABORTED_COMMAND;
5944 				sense->es_add_code =
5945 				    SCSI_ASC_ATA_DEV_FEAT_NOT_ENABLED;
5946 				sense->es_qual_code =
5947 				    SCSI_ASCQ_ATA_DEV_FEAT_NOT_ENABLED;
5948 
5949 				goto done;
5950 			}
5951 			len = sata_build_lsense_page_0e(sdinfo, buf, spx);
5952 			goto no_header;
5953 		default:
5954 			/* Invalid request */
5955 			*scsipkt->pkt_scbp = STATUS_CHECK;
5956 			sense = sata_arq_sense(spx);
5957 			sense->es_key = KEY_ILLEGAL_REQUEST;
5958 			sense->es_add_code = SD_SCSI_ASC_INVALID_FIELD_IN_CDB;
5959 			goto done;
5960 		}
5961 
5962 		/* set parameter log sense data length */
5963 		buf[2] = len >> 8;	/* log sense length (MSB) */
5964 		buf[3] = len & 0xff;	/* log sense length (LSB) */
5965 
5966 		len += SCSI_LOG_PAGE_HDR_LEN;
5967 		ASSERT(len <= MAX_LOG_SENSE_PAGE_SIZE);
5968 
5969 no_header:
5970 		/* Check allocation length */
5971 		alc_len = scsipkt->pkt_cdbp[7];
5972 		alc_len = (len << 8) | scsipkt->pkt_cdbp[8];
5973 
5974 		/*
5975 		 * We do not check for possible parameters truncation
5976 		 * (alc_len < len) assuming that the target driver works
5977 		 * correctly. Just avoiding overrun.
5978 		 * Copy no more than requested and possible, buffer-wise.
5979 		 */
5980 		count = MIN(alc_len, len);
5981 		count = MIN(bp->b_bcount, count);
5982 		bcopy(buf, bp->b_un.b_addr, count);
5983 
5984 		scsipkt->pkt_state |= STATE_XFERRED_DATA;
5985 		scsipkt->pkt_resid = alc_len > count ? alc_len - count : 0;
5986 	}
5987 	*scsipkt->pkt_scbp = STATUS_GOOD;
5988 done:
5989 	mutex_exit(cport_mutex);
5990 	(void) kmem_free(buf, MAX_LOG_SENSE_PAGE_SIZE);
5991 
5992 	SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst,
5993 	    "Scsi_pkt completion reason %x\n", scsipkt->pkt_reason);
5994 
5995 	if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0 &&
5996 	    scsipkt->pkt_comp != NULL) {
5997 		/* scsi callback required */
5998 		if (servicing_interrupt()) {
5999 			if (taskq_dispatch(SATA_TXLT_TASKQ(spx),
6000 			    (task_func_t *)spx->txlt_scsi_pkt->pkt_comp,
6001 			    (void *)spx->txlt_scsi_pkt, TQ_NOSLEEP) == NULL) {
6002 				return (TRAN_BUSY);
6003 			}
6004 		} else if (taskq_dispatch(SATA_TXLT_TASKQ(spx),
6005 		    (task_func_t *)spx->txlt_scsi_pkt->pkt_comp,
6006 		    (void *)spx->txlt_scsi_pkt, TQ_SLEEP) == NULL) {
6007 			/* Scheduling the callback failed */
6008 			return (TRAN_BUSY);
6009 		}
6010 	}
6011 
6012 	return (TRAN_ACCEPT);
6013 }
6014 
6015 /*
6016  * Translate command: Log Select
6017  * Not implemented at this time - returns invalid command response.
6018  */
6019 static	int
6020 sata_txlt_log_select(sata_pkt_txlate_t *spx)
6021 {
6022 	SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst,
6023 	    "sata_txlt_log_select\n", NULL);
6024 
6025 	return (sata_txlt_invalid_command(spx));
6026 }
6027 
6028 
6029 /*
6030  * Translate command: Read (various types).
6031  * Translated into appropriate type of ATA READ command
6032  * for SATA hard disks.
6033  * Both the device capabilities and requested operation mode are
6034  * considered.
6035  *
6036  * Following scsi cdb fields are ignored:
6037  * rdprotect, dpo, fua, fua_nv, group_number.
6038  *
6039  * If SATA_ENABLE_QUEUING flag is set (in the global SATA HBA framework
6040  * enable variable sata_func_enable), the capability of the controller and
6041  * capability of a device are checked and if both support queueing, read
6042  * request will be translated to READ_DMA_QUEUEING or READ_DMA_QUEUEING_EXT
6043  * command rather than plain READ_XXX command.
6044  * If SATA_ENABLE_NCQ flag is set in addition to SATA_ENABLE_QUEUING flag and
6045  * both the controller and device suport such functionality, the read
6046  * request will be translated to READ_FPDMA_QUEUED command.
6047  * In both cases the maximum queue depth is derived as minimum of:
6048  * HBA capability,device capability and sata_max_queue_depth variable setting.
6049  * The value passed to HBA driver is decremented by 1, because only 5 bits are
6050  * used to pass max queue depth value, and the maximum possible queue depth
6051  * is 32.
6052  *
6053  * Returns TRAN_ACCEPT or code returned by sata_hba_start() and
6054  * appropriate values in scsi_pkt fields.
6055  */
6056 static int
6057 sata_txlt_read(sata_pkt_txlate_t *spx)
6058 {
6059 	struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt;
6060 	sata_cmd_t *scmd = &spx->txlt_sata_pkt->satapkt_cmd;
6061 	sata_drive_info_t *sdinfo;
6062 	sata_hba_inst_t *shi = SATA_TXLT_HBA_INST(spx);
6063 	kmutex_t *cport_mutex = &(SATA_TXLT_CPORT_MUTEX(spx));
6064 	uint16_t sec_count;
6065 	uint64_t lba;
6066 	int rval, reason;
6067 	int synch;
6068 
6069 	mutex_enter(cport_mutex);
6070 
6071 	if (((rval = sata_txlt_generic_pkt_info(spx, &reason, 0)) !=
6072 	    TRAN_ACCEPT) || (reason == CMD_DEV_GONE)) {
6073 		mutex_exit(cport_mutex);
6074 		return (rval);
6075 	}
6076 
6077 	sdinfo = sata_get_device_info(spx->txlt_sata_hba_inst,
6078 	    &spx->txlt_sata_pkt->satapkt_device);
6079 
6080 	scmd->satacmd_flags.sata_data_direction = SATA_DIR_READ;
6081 	/*
6082 	 * Extract LBA and sector count from scsi CDB.
6083 	 */
6084 	switch ((uint_t)scsipkt->pkt_cdbp[0]) {
6085 	case SCMD_READ:
6086 		/* 6-byte scsi read cmd : 0x08 */
6087 		lba = (scsipkt->pkt_cdbp[1] & 0x1f);
6088 		lba = (lba << 8) | scsipkt->pkt_cdbp[2];
6089 		lba = (lba << 8) | scsipkt->pkt_cdbp[3];
6090 		sec_count = scsipkt->pkt_cdbp[4];
6091 		/* sec_count 0 will be interpreted as 256 by a device */
6092 		break;
6093 	case SCMD_READ_G1:
6094 		/* 10-bytes scsi read command : 0x28 */
6095 		lba = scsipkt->pkt_cdbp[2];
6096 		lba = (lba << 8) | scsipkt->pkt_cdbp[3];
6097 		lba = (lba << 8) | scsipkt->pkt_cdbp[4];
6098 		lba = (lba << 8) | scsipkt->pkt_cdbp[5];
6099 		sec_count = scsipkt->pkt_cdbp[7];
6100 		sec_count = (sec_count << 8) | scsipkt->pkt_cdbp[8];
6101 		break;
6102 	case SCMD_READ_G5:
6103 		/* 12-bytes scsi read command : 0xA8 */
6104 		lba = scsipkt->pkt_cdbp[2];
6105 		lba = (lba << 8) | scsipkt->pkt_cdbp[3];
6106 		lba = (lba << 8) | scsipkt->pkt_cdbp[4];
6107 		lba = (lba << 8) | scsipkt->pkt_cdbp[5];
6108 		sec_count = scsipkt->pkt_cdbp[6];
6109 		sec_count = (sec_count << 8) | scsipkt->pkt_cdbp[7];
6110 		sec_count = (sec_count << 8) | scsipkt->pkt_cdbp[8];
6111 		sec_count = (sec_count << 8) | scsipkt->pkt_cdbp[9];
6112 		break;
6113 	case SCMD_READ_G4:
6114 		/* 16-bytes scsi read command : 0x88 */
6115 		lba = scsipkt->pkt_cdbp[2];
6116 		lba = (lba << 8) | scsipkt->pkt_cdbp[3];
6117 		lba = (lba << 8) | scsipkt->pkt_cdbp[4];
6118 		lba = (lba << 8) | scsipkt->pkt_cdbp[5];
6119 		lba = (lba << 8) | scsipkt->pkt_cdbp[6];
6120 		lba = (lba << 8) | scsipkt->pkt_cdbp[7];
6121 		lba = (lba << 8) | scsipkt->pkt_cdbp[8];
6122 		lba = (lba << 8) | scsipkt->pkt_cdbp[9];
6123 		sec_count = scsipkt->pkt_cdbp[10];
6124 		sec_count = (sec_count << 8) | scsipkt->pkt_cdbp[11];
6125 		sec_count = (sec_count << 8) | scsipkt->pkt_cdbp[12];
6126 		sec_count = (sec_count << 8) | scsipkt->pkt_cdbp[13];
6127 		break;
6128 	default:
6129 		/* Unsupported command */
6130 		mutex_exit(cport_mutex);
6131 		return (sata_txlt_invalid_command(spx));
6132 	}
6133 
6134 	/*
6135 	 * Check if specified address exceeds device capacity
6136 	 */
6137 	if ((lba >= sdinfo->satadrv_capacity) ||
6138 	    ((lba + sec_count) > sdinfo->satadrv_capacity)) {
6139 		/* LBA out of range */
6140 		mutex_exit(cport_mutex);
6141 		return (sata_txlt_lba_out_of_range(spx));
6142 	}
6143 
6144 	/*
6145 	 * For zero-length transfer, emulate good completion of the command
6146 	 * (reasons for rejecting the command were already checked).
6147 	 * No DMA resources were allocated.
6148 	 */
6149 	if (spx->txlt_dma_cookie_list == NULL) {
6150 		mutex_exit(cport_mutex);
6151 		return (sata_emul_rw_completion(spx));
6152 	}
6153 
6154 	/*
6155 	 * Build cmd block depending on the device capability and
6156 	 * requested operation mode.
6157 	 * Do not bother with non-dma mode - we are working only with
6158 	 * devices supporting DMA.
6159 	 */
6160 	scmd->satacmd_addr_type = ATA_ADDR_LBA;
6161 	scmd->satacmd_device_reg = SATA_ADH_LBA;
6162 	scmd->satacmd_cmd_reg = SATAC_READ_DMA;
6163 	if (sdinfo->satadrv_features_support & SATA_DEV_F_LBA48) {
6164 		scmd->satacmd_addr_type = ATA_ADDR_LBA48;
6165 		scmd->satacmd_cmd_reg = SATAC_READ_DMA_EXT;
6166 		scmd->satacmd_sec_count_msb = sec_count >> 8;
6167 #ifndef __lock_lint
6168 		scmd->satacmd_lba_low_msb = (lba >> 24) & 0xff;
6169 		scmd->satacmd_lba_mid_msb = (lba >> 32) & 0xff;
6170 		scmd->satacmd_lba_high_msb = lba >> 40;
6171 #endif
6172 	} else if (sdinfo->satadrv_features_support & SATA_DEV_F_LBA28) {
6173 		scmd->satacmd_addr_type = ATA_ADDR_LBA28;
6174 		scmd->satacmd_device_reg = SATA_ADH_LBA | ((lba >> 24) & 0xf);
6175 	}
6176 	scmd->satacmd_sec_count_lsb = sec_count & 0xff;
6177 	scmd->satacmd_lba_low_lsb = lba & 0xff;
6178 	scmd->satacmd_lba_mid_lsb = (lba >> 8) & 0xff;
6179 	scmd->satacmd_lba_high_lsb = (lba >> 16) & 0xff;
6180 	scmd->satacmd_features_reg = 0;
6181 	scmd->satacmd_status_reg = 0;
6182 	scmd->satacmd_error_reg = 0;
6183 
6184 	/*
6185 	 * Check if queueing commands should be used and switch
6186 	 * to appropriate command if possible
6187 	 */
6188 	if (sata_func_enable & SATA_ENABLE_QUEUING) {
6189 		boolean_t using_queuing;
6190 
6191 		/* Queuing supported by controller and device? */
6192 		if ((sata_func_enable & SATA_ENABLE_NCQ) &&
6193 		    (sdinfo->satadrv_features_support &
6194 		    SATA_DEV_F_NCQ) &&
6195 		    (SATA_FEATURES(spx->txlt_sata_hba_inst) &
6196 		    SATA_CTLF_NCQ)) {
6197 			using_queuing = B_TRUE;
6198 
6199 			/* NCQ supported - use FPDMA READ */
6200 			scmd->satacmd_cmd_reg =
6201 			    SATAC_READ_FPDMA_QUEUED;
6202 			scmd->satacmd_features_reg_ext =
6203 			    scmd->satacmd_sec_count_msb;
6204 			scmd->satacmd_sec_count_msb = 0;
6205 		} else if ((sdinfo->satadrv_features_support &
6206 		    SATA_DEV_F_TCQ) &&
6207 		    (SATA_FEATURES(spx->txlt_sata_hba_inst) &
6208 		    SATA_CTLF_QCMD)) {
6209 			using_queuing = B_TRUE;
6210 
6211 			/* Legacy queueing */
6212 			if (sdinfo->satadrv_features_support &
6213 			    SATA_DEV_F_LBA48) {
6214 				scmd->satacmd_cmd_reg =
6215 				    SATAC_READ_DMA_QUEUED_EXT;
6216 				scmd->satacmd_features_reg_ext =
6217 				    scmd->satacmd_sec_count_msb;
6218 				scmd->satacmd_sec_count_msb = 0;
6219 			} else {
6220 				scmd->satacmd_cmd_reg =
6221 				    SATAC_READ_DMA_QUEUED;
6222 			}
6223 		} else	/* NCQ nor legacy queuing not supported */
6224 			using_queuing = B_FALSE;
6225 
6226 		/*
6227 		 * If queuing, the sector count goes in the features register
6228 		 * and the secount count will contain the tag.
6229 		 */
6230 		if (using_queuing) {
6231 			scmd->satacmd_features_reg =
6232 			    scmd->satacmd_sec_count_lsb;
6233 			scmd->satacmd_sec_count_lsb = 0;
6234 			scmd->satacmd_flags.sata_queued = B_TRUE;
6235 
6236 			/* Set-up maximum queue depth */
6237 			scmd->satacmd_flags.sata_max_queue_depth =
6238 			    sdinfo->satadrv_max_queue_depth - 1;
6239 		} else if (sdinfo->satadrv_features_enabled &
6240 		    SATA_DEV_F_E_UNTAGGED_QING) {
6241 			/*
6242 			 * Although NCQ/TCQ is not enabled, untagged queuing
6243 			 * may be still used.
6244 			 * Set-up the maximum untagged queue depth.
6245 			 * Use controller's queue depth from sata_hba_tran.
6246 			 * SATA HBA drivers may ignore this value and rely on
6247 			 * the internal limits.For drivers that do not
6248 			 * ignore untaged queue depth, limit the value to
6249 			 * SATA_MAX_QUEUE_DEPTH (32), as this is the
6250 			 * largest value that can be passed via
6251 			 * satacmd_flags.sata_max_queue_depth.
6252 			 */
6253 			scmd->satacmd_flags.sata_max_queue_depth =
6254 			    SATA_QDEPTH(shi) <= SATA_MAX_QUEUE_DEPTH ?
6255 			    SATA_QDEPTH(shi) - 1: SATA_MAX_QUEUE_DEPTH - 1;
6256 
6257 		} else {
6258 			scmd->satacmd_flags.sata_max_queue_depth = 0;
6259 		}
6260 	} else
6261 		scmd->satacmd_flags.sata_max_queue_depth = 0;
6262 
6263 	SATADBG3(SATA_DBG_HBA_IF, spx->txlt_sata_hba_inst,
6264 	    "sata_txlt_read cmd 0x%2x, lba %llx, sec count %x\n",
6265 	    scmd->satacmd_cmd_reg, lba, sec_count);
6266 
6267 	if (!(spx->txlt_sata_pkt->satapkt_op_mode & SATA_OPMODE_SYNCH)) {
6268 		/* Need callback function */
6269 		spx->txlt_sata_pkt->satapkt_comp = sata_txlt_rw_completion;
6270 		synch = FALSE;
6271 	} else
6272 		synch = TRUE;
6273 
6274 	/* Transfer command to HBA */
6275 	if (sata_hba_start(spx, &rval) != 0) {
6276 		/* Pkt not accepted for execution */
6277 		mutex_exit(cport_mutex);
6278 		return (rval);
6279 	}
6280 	mutex_exit(cport_mutex);
6281 	/*
6282 	 * If execution is non-synchronous,
6283 	 * a callback function will handle potential errors, translate
6284 	 * the response and will do a callback to a target driver.
6285 	 * If it was synchronous, check execution status using the same
6286 	 * framework callback.
6287 	 */
6288 	if (synch) {
6289 		SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst,
6290 		    "synchronous execution status %x\n",
6291 		    spx->txlt_sata_pkt->satapkt_reason);
6292 		sata_txlt_rw_completion(spx->txlt_sata_pkt);
6293 	}
6294 	return (TRAN_ACCEPT);
6295 }
6296 
6297 
6298 /*
6299  * SATA translate command: Write (various types)
6300  * Translated into appropriate type of ATA WRITE command
6301  * for SATA hard disks.
6302  * Both the device capabilities and requested operation mode are
6303  * considered.
6304  *
6305  * Following scsi cdb fields are ignored:
6306  * rwprotect, dpo, fua, fua_nv, group_number.
6307  *
6308  * If SATA_ENABLE_QUEUING flag is set (in the global SATA HBA framework
6309  * enable variable sata_func_enable), the capability of the controller and
6310  * capability of a device are checked and if both support queueing, write
6311  * request will be translated to WRITE_DMA_QUEUEING or WRITE_DMA_QUEUEING_EXT
6312  * command rather than plain WRITE_XXX command.
6313  * If SATA_ENABLE_NCQ flag is set in addition to SATA_ENABLE_QUEUING flag and
6314  * both the controller and device suport such functionality, the write
6315  * request will be translated to WRITE_FPDMA_QUEUED command.
6316  * In both cases the maximum queue depth is derived as minimum of:
6317  * HBA capability,device capability and sata_max_queue_depth variable setting.
6318  * The value passed to HBA driver is decremented by 1, because only 5 bits are
6319  * used to pass max queue depth value, and the maximum possible queue depth
6320  * is 32.
6321  *
6322  * Returns TRAN_ACCEPT or code returned by sata_hba_start() and
6323  * appropriate values in scsi_pkt fields.
6324  */
6325 static int
6326 sata_txlt_write(sata_pkt_txlate_t *spx)
6327 {
6328 	struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt;
6329 	sata_cmd_t *scmd = &spx->txlt_sata_pkt->satapkt_cmd;
6330 	sata_drive_info_t *sdinfo;
6331 	sata_hba_inst_t *shi = SATA_TXLT_HBA_INST(spx);
6332 	uint16_t sec_count;
6333 	uint64_t lba;
6334 	int rval, reason;
6335 	int synch;
6336 	kmutex_t *cport_mutex = &(SATA_TXLT_CPORT_MUTEX(spx));
6337 
6338 	mutex_enter(cport_mutex);
6339 
6340 	if (((rval = sata_txlt_generic_pkt_info(spx, &reason, 0)) !=
6341 	    TRAN_ACCEPT) || (reason == CMD_DEV_GONE)) {
6342 		mutex_exit(cport_mutex);
6343 		return (rval);
6344 	}
6345 
6346 	sdinfo = sata_get_device_info(spx->txlt_sata_hba_inst,
6347 	    &spx->txlt_sata_pkt->satapkt_device);
6348 
6349 	scmd->satacmd_flags.sata_data_direction = SATA_DIR_WRITE;
6350 	/*
6351 	 * Extract LBA and sector count from scsi CDB
6352 	 */
6353 	switch ((uint_t)scsipkt->pkt_cdbp[0]) {
6354 	case SCMD_WRITE:
6355 		/* 6-byte scsi read cmd : 0x0A */
6356 		lba = (scsipkt->pkt_cdbp[1] & 0x1f);
6357 		lba = (lba << 8) | scsipkt->pkt_cdbp[2];
6358 		lba = (lba << 8) | scsipkt->pkt_cdbp[3];
6359 		sec_count = scsipkt->pkt_cdbp[4];
6360 		/* sec_count 0 will be interpreted as 256 by a device */
6361 		break;
6362 	case SCMD_WRITE_G1:
6363 		/* 10-bytes scsi write command : 0x2A */
6364 		lba = scsipkt->pkt_cdbp[2];
6365 		lba = (lba << 8) | scsipkt->pkt_cdbp[3];
6366 		lba = (lba << 8) | scsipkt->pkt_cdbp[4];
6367 		lba = (lba << 8) | scsipkt->pkt_cdbp[5];
6368 		sec_count = scsipkt->pkt_cdbp[7];
6369 		sec_count = (sec_count << 8) | scsipkt->pkt_cdbp[8];
6370 		break;
6371 	case SCMD_WRITE_G5:
6372 		/* 12-bytes scsi read command : 0xAA */
6373 		lba = scsipkt->pkt_cdbp[2];
6374 		lba = (lba << 8) | scsipkt->pkt_cdbp[3];
6375 		lba = (lba << 8) | scsipkt->pkt_cdbp[4];
6376 		lba = (lba << 8) | scsipkt->pkt_cdbp[5];
6377 		sec_count = scsipkt->pkt_cdbp[6];
6378 		sec_count = (sec_count << 8) | scsipkt->pkt_cdbp[7];
6379 		sec_count = (sec_count << 8) | scsipkt->pkt_cdbp[8];
6380 		sec_count = (sec_count << 8) | scsipkt->pkt_cdbp[9];
6381 		break;
6382 	case SCMD_WRITE_G4:
6383 		/* 16-bytes scsi write command : 0x8A */
6384 		lba = scsipkt->pkt_cdbp[2];
6385 		lba = (lba << 8) | scsipkt->pkt_cdbp[3];
6386 		lba = (lba << 8) | scsipkt->pkt_cdbp[4];
6387 		lba = (lba << 8) | scsipkt->pkt_cdbp[5];
6388 		lba = (lba << 8) | scsipkt->pkt_cdbp[6];
6389 		lba = (lba << 8) | scsipkt->pkt_cdbp[7];
6390 		lba = (lba << 8) | scsipkt->pkt_cdbp[8];
6391 		lba = (lba << 8) | scsipkt->pkt_cdbp[9];
6392 		sec_count = scsipkt->pkt_cdbp[10];
6393 		sec_count = (sec_count << 8) | scsipkt->pkt_cdbp[11];
6394 		sec_count = (sec_count << 8) | scsipkt->pkt_cdbp[12];
6395 		sec_count = (sec_count << 8) | scsipkt->pkt_cdbp[13];
6396 		break;
6397 	default:
6398 		/* Unsupported command */
6399 		mutex_exit(cport_mutex);
6400 		return (sata_txlt_invalid_command(spx));
6401 	}
6402 
6403 	/*
6404 	 * Check if specified address and length exceeds device capacity
6405 	 */
6406 	if ((lba >= sdinfo->satadrv_capacity) ||
6407 	    ((lba + sec_count) > sdinfo->satadrv_capacity)) {
6408 		/* LBA out of range */
6409 		mutex_exit(cport_mutex);
6410 		return (sata_txlt_lba_out_of_range(spx));
6411 	}
6412 
6413 	/*
6414 	 * For zero-length transfer, emulate good completion of the command
6415 	 * (reasons for rejecting the command were already checked).
6416 	 * No DMA resources were allocated.
6417 	 */
6418 	if (spx->txlt_dma_cookie_list == NULL) {
6419 		mutex_exit(cport_mutex);
6420 		return (sata_emul_rw_completion(spx));
6421 	}
6422 
6423 	/*
6424 	 * Build cmd block depending on the device capability and
6425 	 * requested operation mode.
6426 	 * Do not bother with non-dma mode- we are working only with
6427 	 * devices supporting DMA.
6428 	 */
6429 	scmd->satacmd_addr_type = ATA_ADDR_LBA;
6430 	scmd->satacmd_device_reg = SATA_ADH_LBA;
6431 	scmd->satacmd_cmd_reg = SATAC_WRITE_DMA;
6432 	if (sdinfo->satadrv_features_support & SATA_DEV_F_LBA48) {
6433 		scmd->satacmd_addr_type = ATA_ADDR_LBA48;
6434 		scmd->satacmd_cmd_reg = SATAC_WRITE_DMA_EXT;
6435 		scmd->satacmd_sec_count_msb = sec_count >> 8;
6436 		scmd->satacmd_lba_low_msb = (lba >> 24) & 0xff;
6437 #ifndef __lock_lint
6438 		scmd->satacmd_lba_mid_msb = (lba >> 32) & 0xff;
6439 		scmd->satacmd_lba_high_msb = lba >> 40;
6440 #endif
6441 	} else if (sdinfo->satadrv_features_support & SATA_DEV_F_LBA28) {
6442 		scmd->satacmd_addr_type = ATA_ADDR_LBA28;
6443 		scmd->satacmd_device_reg = SATA_ADH_LBA | ((lba >> 24) & 0xf);
6444 	}
6445 	scmd->satacmd_sec_count_lsb = sec_count & 0xff;
6446 	scmd->satacmd_lba_low_lsb = lba & 0xff;
6447 	scmd->satacmd_lba_mid_lsb = (lba >> 8) & 0xff;
6448 	scmd->satacmd_lba_high_lsb = (lba >> 16) & 0xff;
6449 	scmd->satacmd_features_reg = 0;
6450 	scmd->satacmd_status_reg = 0;
6451 	scmd->satacmd_error_reg = 0;
6452 
6453 	/*
6454 	 * Check if queueing commands should be used and switch
6455 	 * to appropriate command if possible
6456 	 */
6457 	if (sata_func_enable & SATA_ENABLE_QUEUING) {
6458 		boolean_t using_queuing;
6459 
6460 		/* Queuing supported by controller and device? */
6461 		if ((sata_func_enable & SATA_ENABLE_NCQ) &&
6462 		    (sdinfo->satadrv_features_support &
6463 		    SATA_DEV_F_NCQ) &&
6464 		    (SATA_FEATURES(spx->txlt_sata_hba_inst) &
6465 		    SATA_CTLF_NCQ)) {
6466 			using_queuing = B_TRUE;
6467 
6468 			/* NCQ supported - use FPDMA WRITE */
6469 			scmd->satacmd_cmd_reg =
6470 			    SATAC_WRITE_FPDMA_QUEUED;
6471 			scmd->satacmd_features_reg_ext =
6472 			    scmd->satacmd_sec_count_msb;
6473 			scmd->satacmd_sec_count_msb = 0;
6474 		} else if ((sdinfo->satadrv_features_support &
6475 		    SATA_DEV_F_TCQ) &&
6476 		    (SATA_FEATURES(spx->txlt_sata_hba_inst) &
6477 		    SATA_CTLF_QCMD)) {
6478 			using_queuing = B_TRUE;
6479 
6480 			/* Legacy queueing */
6481 			if (sdinfo->satadrv_features_support &
6482 			    SATA_DEV_F_LBA48) {
6483 				scmd->satacmd_cmd_reg =
6484 				    SATAC_WRITE_DMA_QUEUED_EXT;
6485 				scmd->satacmd_features_reg_ext =
6486 				    scmd->satacmd_sec_count_msb;
6487 				scmd->satacmd_sec_count_msb = 0;
6488 			} else {
6489 				scmd->satacmd_cmd_reg =
6490 				    SATAC_WRITE_DMA_QUEUED;
6491 			}
6492 		} else	/*  NCQ nor legacy queuing not supported */
6493 			using_queuing = B_FALSE;
6494 
6495 		if (using_queuing) {
6496 			scmd->satacmd_features_reg =
6497 			    scmd->satacmd_sec_count_lsb;
6498 			scmd->satacmd_sec_count_lsb = 0;
6499 			scmd->satacmd_flags.sata_queued = B_TRUE;
6500 			/* Set-up maximum queue depth */
6501 			scmd->satacmd_flags.sata_max_queue_depth =
6502 			    sdinfo->satadrv_max_queue_depth - 1;
6503 		} else if (sdinfo->satadrv_features_enabled &
6504 		    SATA_DEV_F_E_UNTAGGED_QING) {
6505 			/*
6506 			 * Although NCQ/TCQ is not enabled, untagged queuing
6507 			 * may be still used.
6508 			 * Set-up the maximum untagged queue depth.
6509 			 * Use controller's queue depth from sata_hba_tran.
6510 			 * SATA HBA drivers may ignore this value and rely on
6511 			 * the internal limits. For drivera that do not
6512 			 * ignore untaged queue depth, limit the value to
6513 			 * SATA_MAX_QUEUE_DEPTH (32), as this is the
6514 			 * largest value that can be passed via
6515 			 * satacmd_flags.sata_max_queue_depth.
6516 			 */
6517 			scmd->satacmd_flags.sata_max_queue_depth =
6518 			    SATA_QDEPTH(shi) <= SATA_MAX_QUEUE_DEPTH ?
6519 			    SATA_QDEPTH(shi) - 1: SATA_MAX_QUEUE_DEPTH - 1;
6520 
6521 		} else {
6522 			scmd->satacmd_flags.sata_max_queue_depth = 0;
6523 		}
6524 	} else
6525 		scmd->satacmd_flags.sata_max_queue_depth = 0;
6526 
6527 	SATADBG3(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst,
6528 	    "sata_txlt_write cmd 0x%2x, lba %llx, sec count %x\n",
6529 	    scmd->satacmd_cmd_reg, lba, sec_count);
6530 
6531 	if (!(spx->txlt_sata_pkt->satapkt_op_mode & SATA_OPMODE_SYNCH)) {
6532 		/* Need callback function */
6533 		spx->txlt_sata_pkt->satapkt_comp = sata_txlt_rw_completion;
6534 		synch = FALSE;
6535 	} else
6536 		synch = TRUE;
6537 
6538 	/* Transfer command to HBA */
6539 	if (sata_hba_start(spx, &rval) != 0) {
6540 		/* Pkt not accepted for execution */
6541 		mutex_exit(cport_mutex);
6542 		return (rval);
6543 	}
6544 	mutex_exit(cport_mutex);
6545 
6546 	/*
6547 	 * If execution is non-synchronous,
6548 	 * a callback function will handle potential errors, translate
6549 	 * the response and will do a callback to a target driver.
6550 	 * If it was synchronous, check execution status using the same
6551 	 * framework callback.
6552 	 */
6553 	if (synch) {
6554 		SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst,
6555 		    "synchronous execution status %x\n",
6556 		    spx->txlt_sata_pkt->satapkt_reason);
6557 		sata_txlt_rw_completion(spx->txlt_sata_pkt);
6558 	}
6559 	return (TRAN_ACCEPT);
6560 }
6561 
6562 
6563 /*
6564  * Implements SCSI SBC WRITE BUFFER command download microcode option
6565  */
6566 static int
6567 sata_txlt_write_buffer(sata_pkt_txlate_t *spx)
6568 {
6569 #define	WB_DOWNLOAD_MICROCODE_AND_REVERT_MODE			4
6570 #define	WB_DOWNLOAD_MICROCODE_AND_SAVE_MODE			5
6571 
6572 	struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt;
6573 	struct sata_pkt *sata_pkt = spx->txlt_sata_pkt;
6574 	sata_cmd_t *scmd = &spx->txlt_sata_pkt->satapkt_cmd;
6575 
6576 	struct buf *bp = spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp;
6577 	struct scsi_extended_sense *sense;
6578 	int rval, mode, sector_count, reason;
6579 	kmutex_t *cport_mutex = &(SATA_TXLT_CPORT_MUTEX(spx));
6580 
6581 	mode = scsipkt->pkt_cdbp[1] & 0x1f;
6582 
6583 	SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst,
6584 	    "sata_txlt_write_buffer, mode 0x%x\n", mode);
6585 
6586 	mutex_enter(cport_mutex);
6587 
6588 	if ((rval = sata_txlt_generic_pkt_info(spx, &reason, 1)) !=
6589 	    TRAN_ACCEPT) {
6590 		mutex_exit(cport_mutex);
6591 		return (rval);
6592 	}
6593 
6594 	/* Use synchronous mode */
6595 	spx->txlt_sata_pkt->satapkt_op_mode
6596 	    |= SATA_OPMODE_SYNCH | SATA_OPMODE_INTERRUPTS;
6597 
6598 	scmd->satacmd_flags.sata_data_direction = SATA_DIR_WRITE;
6599 
6600 	scsipkt->pkt_reason = CMD_CMPLT;
6601 	scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET |
6602 	    STATE_SENT_CMD | STATE_GOT_STATUS;
6603 
6604 	/*
6605 	 * The SCSI to ATA translation specification only calls
6606 	 * for WB_DOWNLOAD_MICROCODE_AND_SAVE_MODE.
6607 	 * WB_DOWNLOAD_MICROC_AND_REVERT_MODE is implemented, but
6608 	 * ATA 8 (draft) got rid of download microcode for temp
6609 	 * and it is even optional for ATA 7, so it may be aborted.
6610 	 * WB_DOWNLOAD_MICROCODE_WITH_OFFSET is not implemented as
6611 	 * it is not specified and the buffer offset for SCSI is a 16-bit
6612 	 * value in bytes, but for ATA it is a 16-bit offset in 512 byte
6613 	 * sectors.  Thus the offset really doesn't buy us anything.
6614 	 * If and when ATA 8 is stabilized and the SCSI to ATA specification
6615 	 * is revised, this can be revisisted.
6616 	 */
6617 	/* Reject not supported request */
6618 	switch (mode) {
6619 	case WB_DOWNLOAD_MICROCODE_AND_REVERT_MODE:
6620 		scmd->satacmd_features_reg = SATA_DOWNLOAD_MCODE_TEMP;
6621 		break;
6622 	case WB_DOWNLOAD_MICROCODE_AND_SAVE_MODE:
6623 		scmd->satacmd_features_reg = SATA_DOWNLOAD_MCODE_SAVE;
6624 		break;
6625 	default:
6626 		goto bad_param;
6627 	}
6628 
6629 	*scsipkt->pkt_scbp = STATUS_GOOD;	/* Presumed outcome */
6630 
6631 	scmd->satacmd_cmd_reg = SATAC_DOWNLOAD_MICROCODE;
6632 	if ((bp->b_bcount % SATA_DISK_SECTOR_SIZE) != 0)
6633 		goto bad_param;
6634 	sector_count = bp->b_bcount / SATA_DISK_SECTOR_SIZE;
6635 	scmd->satacmd_sec_count_lsb = (uint8_t)sector_count;
6636 	scmd->satacmd_lba_low_lsb = ((uint16_t)sector_count) >> 8;
6637 	scmd->satacmd_lba_mid_lsb = 0;
6638 	scmd->satacmd_lba_high_lsb = 0;
6639 	scmd->satacmd_device_reg = 0;
6640 	spx->txlt_sata_pkt->satapkt_comp = NULL;
6641 	scmd->satacmd_addr_type = 0;
6642 
6643 	/* Transfer command to HBA */
6644 	if (sata_hba_start(spx, &rval) != 0) {
6645 		/* Pkt not accepted for execution */
6646 		mutex_exit(cport_mutex);
6647 		return (rval);
6648 	}
6649 
6650 	mutex_exit(cport_mutex);
6651 
6652 	/* Then we need synchronous check the status of the disk */
6653 	scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET |
6654 	    STATE_SENT_CMD | STATE_XFERRED_DATA | STATE_GOT_STATUS;
6655 	if (sata_pkt->satapkt_reason == SATA_PKT_COMPLETED) {
6656 		scsipkt->pkt_reason = CMD_CMPLT;
6657 
6658 		/* Download commmand succeed, so probe and identify device */
6659 		sata_reidentify_device(spx);
6660 	} else {
6661 		/* Something went wrong, microcode download command failed */
6662 		scsipkt->pkt_reason = CMD_INCOMPLETE;
6663 		*scsipkt->pkt_scbp = STATUS_CHECK;
6664 		sense = sata_arq_sense(spx);
6665 		switch (sata_pkt->satapkt_reason) {
6666 		case SATA_PKT_PORT_ERROR:
6667 			/*
6668 			 * We have no device data. Assume no data transfered.
6669 			 */
6670 			sense->es_key = KEY_HARDWARE_ERROR;
6671 			break;
6672 
6673 		case SATA_PKT_DEV_ERROR:
6674 			if (sata_pkt->satapkt_cmd.satacmd_status_reg &
6675 			    SATA_STATUS_ERR) {
6676 				/*
6677 				 * determine dev error reason from error
6678 				 * reg content
6679 				 */
6680 				sata_decode_device_error(spx, sense);
6681 				break;
6682 			}
6683 			/* No extended sense key - no info available */
6684 			break;
6685 
6686 		case SATA_PKT_TIMEOUT:
6687 			scsipkt->pkt_reason = CMD_TIMEOUT;
6688 			scsipkt->pkt_statistics |=
6689 			    STAT_TIMEOUT | STAT_DEV_RESET;
6690 			/* No extended sense key ? */
6691 			break;
6692 
6693 		case SATA_PKT_ABORTED:
6694 			scsipkt->pkt_reason = CMD_ABORTED;
6695 			scsipkt->pkt_statistics |= STAT_ABORTED;
6696 			/* No extended sense key ? */
6697 			break;
6698 
6699 		case SATA_PKT_RESET:
6700 			/* pkt aborted by an explicit reset from a host */
6701 			scsipkt->pkt_reason = CMD_RESET;
6702 			scsipkt->pkt_statistics |= STAT_DEV_RESET;
6703 			break;
6704 
6705 		default:
6706 			SATA_LOG_D((spx->txlt_sata_hba_inst, CE_WARN,
6707 			    "sata_txlt_nodata_cmd_completion: "
6708 			    "invalid packet completion reason %d",
6709 			    sata_pkt->satapkt_reason));
6710 			scsipkt->pkt_reason = CMD_TRAN_ERR;
6711 			break;
6712 		}
6713 
6714 		SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst,
6715 		    "scsi_pkt completion reason %x\n", scsipkt->pkt_reason);
6716 
6717 		if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0)
6718 			/* scsi callback required */
6719 			scsi_hba_pkt_comp(scsipkt);
6720 	}
6721 	return (TRAN_ACCEPT);
6722 
6723 bad_param:
6724 	mutex_exit(cport_mutex);
6725 	*scsipkt->pkt_scbp = STATUS_CHECK;
6726 	sense = sata_arq_sense(spx);
6727 	sense->es_key = KEY_ILLEGAL_REQUEST;
6728 	sense->es_add_code = SD_SCSI_ASC_INVALID_FIELD_IN_CDB;
6729 	if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0 &&
6730 	    scsipkt->pkt_comp != NULL) {
6731 		/* scsi callback required */
6732 		if (servicing_interrupt()) {
6733 			if (taskq_dispatch(SATA_TXLT_TASKQ(spx),
6734 			    (task_func_t *)spx->txlt_scsi_pkt->pkt_comp,
6735 			    (void *)spx->txlt_scsi_pkt, TQ_NOSLEEP) == NULL) {
6736 				return (TRAN_BUSY);
6737 			}
6738 		} else if (taskq_dispatch(SATA_TXLT_TASKQ(spx),
6739 		    (task_func_t *)spx->txlt_scsi_pkt->pkt_comp,
6740 		    (void *)spx->txlt_scsi_pkt, TQ_SLEEP) == NULL) {
6741 			/* Scheduling the callback failed */
6742 			return (TRAN_BUSY);
6743 		}
6744 	}
6745 	return (rval);
6746 }
6747 
6748 /*
6749  * Re-identify device after doing a firmware download.
6750  */
6751 static void
6752 sata_reidentify_device(sata_pkt_txlate_t *spx)
6753 {
6754 #define	DOWNLOAD_WAIT_TIME_SECS	60
6755 #define	DOWNLOAD_WAIT_INTERVAL_SECS	1
6756 	int rval;
6757 	int retry_cnt;
6758 	struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt;
6759 	sata_hba_inst_t *sata_hba_inst = spx->txlt_sata_hba_inst;
6760 	sata_device_t sata_device = spx->txlt_sata_pkt->satapkt_device;
6761 	sata_drive_info_t *sdinfo;
6762 
6763 	/*
6764 	 * Before returning good status, probe device.
6765 	 * Device probing will get IDENTIFY DEVICE data, if possible.
6766 	 * The assumption is that the new microcode is applied by the
6767 	 * device. It is a caller responsibility to verify this.
6768 	 */
6769 	for (retry_cnt = 0;
6770 	    retry_cnt < DOWNLOAD_WAIT_TIME_SECS / DOWNLOAD_WAIT_INTERVAL_SECS;
6771 	    retry_cnt++) {
6772 		rval = sata_probe_device(sata_hba_inst, &sata_device);
6773 
6774 		if (rval == SATA_SUCCESS) { /* Set default features */
6775 			sdinfo = sata_get_device_info(sata_hba_inst,
6776 			    &sata_device);
6777 			if (sata_initialize_device(sata_hba_inst, sdinfo) !=
6778 			    SATA_SUCCESS) {
6779 				/* retry */
6780 				rval = sata_initialize_device(sata_hba_inst,
6781 				    sdinfo);
6782 				if (rval == SATA_RETRY)
6783 					sata_log(sata_hba_inst, CE_WARN,
6784 					    "SATA device at port %d pmport %d -"
6785 					    " default device features could not"
6786 					    " be set. Device may not operate "
6787 					    "as expected.",
6788 					    sata_device.satadev_addr.cport,
6789 					    sata_device.satadev_addr.pmport);
6790 			}
6791 			if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0)
6792 				scsi_hba_pkt_comp(scsipkt);
6793 			return;
6794 		} else if (rval == SATA_RETRY) {
6795 			delay(drv_usectohz(1000000 *
6796 			    DOWNLOAD_WAIT_INTERVAL_SECS));
6797 			continue;
6798 		} else	/* failed - no reason to retry */
6799 			break;
6800 	}
6801 
6802 	/*
6803 	 * Something went wrong, device probing failed.
6804 	 */
6805 	SATA_LOG_D((sata_hba_inst, CE_WARN,
6806 	    "Cannot probe device after downloading microcode\n"));
6807 
6808 	/* Reset device to force retrying the probe. */
6809 	(void) (*SATA_RESET_DPORT_FUNC(sata_hba_inst))
6810 	    (SATA_DIP(sata_hba_inst), &sata_device);
6811 
6812 	if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0)
6813 		scsi_hba_pkt_comp(scsipkt);
6814 }
6815 
6816 
6817 /*
6818  * Translate command: Synchronize Cache.
6819  * Translates into Flush Cache command for SATA hard disks.
6820  *
6821  * Returns TRAN_ACCEPT or code returned by sata_hba_start() and
6822  * appropriate values in scsi_pkt fields.
6823  */
6824 static 	int
6825 sata_txlt_synchronize_cache(sata_pkt_txlate_t *spx)
6826 {
6827 	sata_cmd_t *scmd = &spx->txlt_sata_pkt->satapkt_cmd;
6828 	kmutex_t *cport_mutex = &(SATA_TXLT_CPORT_MUTEX(spx));
6829 	int rval, reason;
6830 	int synch;
6831 
6832 	mutex_enter(cport_mutex);
6833 
6834 	if (((rval = sata_txlt_generic_pkt_info(spx, &reason, 1)) !=
6835 	    TRAN_ACCEPT) || (reason == CMD_DEV_GONE)) {
6836 		mutex_exit(cport_mutex);
6837 		return (rval);
6838 	}
6839 
6840 	scmd->satacmd_addr_type = 0;
6841 	scmd->satacmd_cmd_reg = SATAC_FLUSH_CACHE;
6842 	scmd->satacmd_device_reg = 0;
6843 	scmd->satacmd_sec_count_lsb = 0;
6844 	scmd->satacmd_lba_low_lsb = 0;
6845 	scmd->satacmd_lba_mid_lsb = 0;
6846 	scmd->satacmd_lba_high_lsb = 0;
6847 	scmd->satacmd_features_reg = 0;
6848 	scmd->satacmd_status_reg = 0;
6849 	scmd->satacmd_error_reg = 0;
6850 
6851 	SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst,
6852 	    "sata_txlt_synchronize_cache\n", NULL);
6853 
6854 	if (!(spx->txlt_sata_pkt->satapkt_op_mode & SATA_OPMODE_SYNCH)) {
6855 		/* Need to set-up a callback function */
6856 		spx->txlt_sata_pkt->satapkt_comp =
6857 		    sata_txlt_nodata_cmd_completion;
6858 		synch = FALSE;
6859 	} else
6860 		synch = TRUE;
6861 
6862 	/* Transfer command to HBA */
6863 	if (sata_hba_start(spx, &rval) != 0) {
6864 		/* Pkt not accepted for execution */
6865 		mutex_exit(cport_mutex);
6866 		return (rval);
6867 	}
6868 	mutex_exit(cport_mutex);
6869 
6870 	/*
6871 	 * If execution non-synchronous, it had to be completed
6872 	 * a callback function will handle potential errors, translate
6873 	 * the response and will do a callback to a target driver.
6874 	 * If it was synchronous, check status, using the same
6875 	 * framework callback.
6876 	 */
6877 	if (synch) {
6878 		SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst,
6879 		    "synchronous execution status %x\n",
6880 		    spx->txlt_sata_pkt->satapkt_reason);
6881 		sata_txlt_nodata_cmd_completion(spx->txlt_sata_pkt);
6882 	}
6883 	return (TRAN_ACCEPT);
6884 }
6885 
6886 
6887 /*
6888  * Send pkt to SATA HBA driver
6889  *
6890  * This function may be called only if the operation is requested by scsi_pkt,
6891  * i.e. scsi_pkt is not NULL.
6892  *
6893  * This function has to be called with cport mutex held. It does release
6894  * the mutex when it calls HBA driver sata_tran_start function and
6895  * re-acquires it afterwards.
6896  *
6897  * If return value is 0, pkt was accepted, -1 otherwise
6898  * rval is set to appropriate sata_scsi_start return value.
6899  *
6900  * Note 1:If HBA driver returns value other than TRAN_ACCEPT, it should not
6901  * have called the sata_pkt callback function for this packet.
6902  *
6903  * The scsi callback has to be performed by the caller of this routine.
6904  */
6905 static int
6906 sata_hba_start(sata_pkt_txlate_t *spx, int *rval)
6907 {
6908 	int stat;
6909 	uint8_t cport = SATA_TXLT_CPORT(spx);
6910 	uint8_t pmport = SATA_TXLT_PMPORT(spx);
6911 	sata_hba_inst_t *sata_hba_inst = spx->txlt_sata_hba_inst;
6912 	sata_drive_info_t *sdinfo;
6913 	sata_pmult_info_t *pminfo;
6914 	sata_pmport_info_t *pmportinfo = NULL;
6915 	sata_device_t *sata_device = NULL;
6916 	uint8_t cmd;
6917 	struct sata_cmd_flags cmd_flags;
6918 
6919 	ASSERT(spx->txlt_sata_pkt != NULL);
6920 
6921 	ASSERT(mutex_owned(&SATA_CPORT_MUTEX(sata_hba_inst, cport)));
6922 
6923 	sdinfo = sata_get_device_info(sata_hba_inst,
6924 	    &spx->txlt_sata_pkt->satapkt_device);
6925 	ASSERT(sdinfo != NULL);
6926 
6927 	/* Clear device reset state? */
6928 	/* qual should be XXX_DPMPORT, but add XXX_PMPORT in case */
6929 	if (sdinfo->satadrv_addr.qual == SATA_ADDR_DPMPORT ||
6930 	    sdinfo->satadrv_addr.qual == SATA_ADDR_PMPORT) {
6931 
6932 		/*
6933 		 * Get the pmult_info of the its parent port multiplier, all
6934 		 * sub-devices share a common device reset flags on in
6935 		 * pmult_info.
6936 		 */
6937 		pminfo = SATA_PMULT_INFO(sata_hba_inst, cport);
6938 		pmportinfo = pminfo->pmult_dev_port[pmport];
6939 		ASSERT(pminfo != NULL);
6940 		if (pminfo->pmult_event_flags & SATA_EVNT_CLEAR_DEVICE_RESET) {
6941 			spx->txlt_sata_pkt->satapkt_cmd.satacmd_flags.
6942 			    sata_clear_dev_reset = B_TRUE;
6943 			pminfo->pmult_event_flags &=
6944 			    ~SATA_EVNT_CLEAR_DEVICE_RESET;
6945 			SATADBG1(SATA_DBG_EVENTS, sata_hba_inst,
6946 			    "sata_hba_start: clearing device reset state"
6947 			    "on pmult.\n", NULL);
6948 		}
6949 	} else {
6950 		if (sdinfo->satadrv_event_flags &
6951 		    SATA_EVNT_CLEAR_DEVICE_RESET) {
6952 			spx->txlt_sata_pkt->satapkt_cmd.satacmd_flags.
6953 			    sata_clear_dev_reset = B_TRUE;
6954 			sdinfo->satadrv_event_flags &=
6955 			    ~SATA_EVNT_CLEAR_DEVICE_RESET;
6956 			SATADBG1(SATA_DBG_EVENTS, sata_hba_inst,
6957 			    "sata_hba_start: clearing device reset state\n",
6958 			    NULL);
6959 		}
6960 	}
6961 
6962 	cmd = spx->txlt_sata_pkt->satapkt_cmd.satacmd_cmd_reg;
6963 	cmd_flags = spx->txlt_sata_pkt->satapkt_cmd.satacmd_flags;
6964 	sata_device = &spx->txlt_sata_pkt->satapkt_device;
6965 
6966 	mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, cport)));
6967 
6968 	SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst,
6969 	    "Sata cmd 0x%2x\n", cmd);
6970 
6971 	stat = (*SATA_START_FUNC(sata_hba_inst))(SATA_DIP(sata_hba_inst),
6972 	    spx->txlt_sata_pkt);
6973 	mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, cport)));
6974 	/*
6975 	 * If sata pkt was accepted and executed in asynchronous mode, i.e.
6976 	 * with the sata callback, the sata_pkt could be already destroyed
6977 	 * by the time we check ther return status from the hba_start()
6978 	 * function, because sata_scsi_destroy_pkt() could have been already
6979 	 * called (perhaps in the interrupt context). So, in such case, there
6980 	 * should be no references to it. In other cases, sata_pkt still
6981 	 * exists.
6982 	 */
6983 	if (stat == SATA_TRAN_ACCEPTED) {
6984 		/*
6985 		 * pkt accepted for execution.
6986 		 * If it was executed synchronously, it is already completed
6987 		 * and pkt completion_reason indicates completion status.
6988 		 */
6989 		*rval = TRAN_ACCEPT;
6990 		return (0);
6991 	}
6992 
6993 	sdinfo = sata_get_device_info(sata_hba_inst, sata_device);
6994 	switch (stat) {
6995 	case SATA_TRAN_QUEUE_FULL:
6996 		/*
6997 		 * Controller detected queue full condition.
6998 		 */
6999 		SATADBG1(SATA_DBG_HBA_IF, sata_hba_inst,
7000 		    "sata_hba_start: queue full\n", NULL);
7001 
7002 		spx->txlt_scsi_pkt->pkt_reason = CMD_INCOMPLETE;
7003 		*spx->txlt_scsi_pkt->pkt_scbp = STATUS_QFULL;
7004 
7005 		*rval = TRAN_BUSY;
7006 		break;
7007 
7008 	case SATA_TRAN_PORT_ERROR:
7009 		/*
7010 		 * Communication/link with device or general port error
7011 		 * detected before pkt execution begun.
7012 		 */
7013 		if (spx->txlt_sata_pkt->satapkt_device.satadev_addr.qual ==
7014 		    SATA_ADDR_CPORT ||
7015 		    spx->txlt_sata_pkt->satapkt_device.satadev_addr.qual ==
7016 		    SATA_ADDR_DCPORT)
7017 			sata_log(sata_hba_inst, CE_CONT,
7018 			    "SATA port %d error",
7019 			    sata_device->satadev_addr.cport);
7020 		else
7021 			sata_log(sata_hba_inst, CE_CONT,
7022 			    "SATA port %d:%d error\n",
7023 			    sata_device->satadev_addr.cport,
7024 			    sata_device->satadev_addr.pmport);
7025 
7026 		/*
7027 		 * Update the port/device structure.
7028 		 * sata_pkt should be still valid. Since port error is
7029 		 * returned, sata_device content should reflect port
7030 		 * state - it means, that sata address have been changed,
7031 		 * because original packet's sata address refered to a device
7032 		 * attached to some port.
7033 		 */
7034 		if (sata_device->satadev_addr.qual == SATA_ADDR_DPMPORT ||
7035 		    sata_device->satadev_addr.qual == SATA_ADDR_PMPORT) {
7036 			mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, cport)));
7037 			mutex_enter(&pmportinfo->pmport_mutex);
7038 			sata_update_pmport_info(sata_hba_inst, sata_device);
7039 			mutex_exit(&pmportinfo->pmport_mutex);
7040 			mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, cport)));
7041 		} else {
7042 			sata_update_port_info(sata_hba_inst, sata_device);
7043 		}
7044 
7045 		spx->txlt_scsi_pkt->pkt_reason = CMD_TRAN_ERR;
7046 		*rval = TRAN_FATAL_ERROR;
7047 		break;
7048 
7049 	case SATA_TRAN_CMD_UNSUPPORTED:
7050 		/*
7051 		 * Command rejected by HBA as unsupported. It was HBA driver
7052 		 * that rejected the command, command was not sent to
7053 		 * an attached device.
7054 		 */
7055 		if ((sdinfo != NULL) &&
7056 		    (sdinfo->satadrv_state & SATA_DSTATE_RESET))
7057 			SATADBG1(SATA_DBG_EVENTS, sata_hba_inst,
7058 			    "sat_hba_start: cmd 0x%2x rejected "
7059 			    "with SATA_TRAN_CMD_UNSUPPORTED status\n", cmd);
7060 
7061 		mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, cport)));
7062 		(void) sata_txlt_invalid_command(spx);
7063 		mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, cport)));
7064 
7065 		*rval = TRAN_ACCEPT;
7066 		break;
7067 
7068 	case SATA_TRAN_BUSY:
7069 		/*
7070 		 * Command rejected by HBA because other operation prevents
7071 		 * accepting the packet, or device is in RESET condition.
7072 		 */
7073 		if (sdinfo != NULL) {
7074 			sdinfo->satadrv_state =
7075 			    spx->txlt_sata_pkt->satapkt_device.satadev_state;
7076 
7077 			if (sdinfo->satadrv_state & SATA_DSTATE_RESET) {
7078 				SATADBG1(SATA_DBG_EVENTS, sata_hba_inst,
7079 				    "sata_hba_start: cmd 0x%2x rejected "
7080 				    "because of device reset condition\n",
7081 				    cmd);
7082 			} else {
7083 				SATADBG1(SATA_DBG_EVENTS, sata_hba_inst,
7084 				    "sata_hba_start: cmd 0x%2x rejected "
7085 				    "with SATA_TRAN_BUSY status\n",
7086 				    cmd);
7087 			}
7088 		}
7089 		spx->txlt_scsi_pkt->pkt_reason = CMD_INCOMPLETE;
7090 		*rval = TRAN_BUSY;
7091 		break;
7092 
7093 	default:
7094 		/* Unrecognized HBA response */
7095 		SATA_LOG_D((sata_hba_inst, CE_WARN,
7096 		    "sata_hba_start: unrecognized HBA response "
7097 		    "to cmd : 0x%2x resp 0x%x", cmd, rval));
7098 		spx->txlt_scsi_pkt->pkt_reason = CMD_TRAN_ERR;
7099 		*rval = TRAN_FATAL_ERROR;
7100 		break;
7101 	}
7102 
7103 	/*
7104 	 * If we got here, the packet was rejected.
7105 	 * Check if we need to remember reset state clearing request
7106 	 */
7107 	if (cmd_flags.sata_clear_dev_reset) {
7108 		/*
7109 		 * Check if device is still configured - it may have
7110 		 * disapeared from the configuration
7111 		 */
7112 		sdinfo = sata_get_device_info(sata_hba_inst, sata_device);
7113 		if (sdinfo != NULL) {
7114 			/*
7115 			 * Restore the flag that requests clearing of
7116 			 * the device reset state,
7117 			 * so the next sata packet may carry it to HBA.
7118 			 */
7119 			if (sdinfo->satadrv_addr.qual == SATA_ADDR_PMPORT ||
7120 			    sdinfo->satadrv_addr.qual == SATA_ADDR_DPMPORT) {
7121 				pminfo->pmult_event_flags |=
7122 				    SATA_EVNT_CLEAR_DEVICE_RESET;
7123 			} else {
7124 				sdinfo->satadrv_event_flags |=
7125 				    SATA_EVNT_CLEAR_DEVICE_RESET;
7126 			}
7127 		}
7128 	}
7129 	return (-1);
7130 }
7131 
7132 /*
7133  * Scsi response setup for invalid LBA
7134  *
7135  * Returns TRAN_ACCEPT and appropriate values in scsi_pkt fields.
7136  */
7137 static int
7138 sata_txlt_lba_out_of_range(sata_pkt_txlate_t *spx)
7139 {
7140 	struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt;
7141 	struct scsi_extended_sense *sense;
7142 
7143 	scsipkt->pkt_reason = CMD_CMPLT;
7144 	scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET |
7145 	    STATE_SENT_CMD | STATE_GOT_STATUS;
7146 	*scsipkt->pkt_scbp = STATUS_CHECK;
7147 
7148 	*scsipkt->pkt_scbp = STATUS_CHECK;
7149 	sense = sata_arq_sense(spx);
7150 	sense->es_key = KEY_ILLEGAL_REQUEST;
7151 	sense->es_add_code = SD_SCSI_ASC_LBA_OUT_OF_RANGE;
7152 
7153 	SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst,
7154 	    "Scsi_pkt completion reason %x\n", scsipkt->pkt_reason);
7155 
7156 	if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0 &&
7157 	    scsipkt->pkt_comp != NULL) {
7158 		/* scsi callback required */
7159 		if (servicing_interrupt()) {
7160 			if (taskq_dispatch(SATA_TXLT_TASKQ(spx),
7161 			    (task_func_t *)spx->txlt_scsi_pkt->pkt_comp,
7162 			    (void *)spx->txlt_scsi_pkt, TQ_NOSLEEP) == NULL) {
7163 				return (TRAN_BUSY);
7164 			}
7165 		} else if (taskq_dispatch(SATA_TXLT_TASKQ(spx),
7166 		    (task_func_t *)spx->txlt_scsi_pkt->pkt_comp,
7167 		    (void *)spx->txlt_scsi_pkt, TQ_SLEEP) == NULL) {
7168 			/* Scheduling the callback failed */
7169 			return (TRAN_BUSY);
7170 		}
7171 	}
7172 	return (TRAN_ACCEPT);
7173 }
7174 
7175 
7176 /*
7177  * Analyze device status and error registers and translate them into
7178  * appropriate scsi sense codes.
7179  * NOTE: non-packet commands only for now
7180  */
7181 static void
7182 sata_decode_device_error(sata_pkt_txlate_t *spx,
7183     struct scsi_extended_sense *sense)
7184 {
7185 	uint8_t err_reg = spx->txlt_sata_pkt->satapkt_cmd.satacmd_error_reg;
7186 
7187 	ASSERT(sense != NULL);
7188 	ASSERT(spx->txlt_sata_pkt->satapkt_cmd.satacmd_status_reg &
7189 	    SATA_STATUS_ERR);
7190 
7191 
7192 	if (err_reg & SATA_ERROR_ICRC) {
7193 		sense->es_key = KEY_ABORTED_COMMAND;
7194 		sense->es_add_code = 0x08; /* Communication failure */
7195 		return;
7196 	}
7197 
7198 	if (err_reg & SATA_ERROR_UNC) {
7199 		sense->es_key = KEY_MEDIUM_ERROR;
7200 		/* Information bytes (LBA) need to be set by a caller */
7201 		return;
7202 	}
7203 
7204 	/* ADD HERE: MC error bit handling for ATAPI CD/DVD */
7205 	if (err_reg & (SATA_ERROR_MCR | SATA_ERROR_NM)) {
7206 		sense->es_key = KEY_UNIT_ATTENTION;
7207 		sense->es_add_code = 0x3a; /* No media present */
7208 		return;
7209 	}
7210 
7211 	if (err_reg & SATA_ERROR_IDNF) {
7212 		if (err_reg & SATA_ERROR_ABORT) {
7213 			sense->es_key = KEY_ABORTED_COMMAND;
7214 		} else {
7215 			sense->es_key = KEY_ILLEGAL_REQUEST;
7216 			sense->es_add_code = 0x21; /* LBA out of range */
7217 		}
7218 		return;
7219 	}
7220 
7221 	if (err_reg & SATA_ERROR_ABORT) {
7222 		ASSERT(spx->txlt_sata_pkt != NULL);
7223 		sense->es_key = KEY_ABORTED_COMMAND;
7224 		return;
7225 	}
7226 }
7227 
7228 /*
7229  * Extract error LBA from sata_pkt.satapkt_cmd register fields
7230  */
7231 static void
7232 sata_extract_error_lba(sata_pkt_txlate_t *spx, uint64_t *lba)
7233 {
7234 	sata_cmd_t *sata_cmd = &spx->txlt_sata_pkt->satapkt_cmd;
7235 
7236 	*lba = 0;
7237 	if (sata_cmd->satacmd_addr_type == ATA_ADDR_LBA48) {
7238 		*lba = sata_cmd->satacmd_lba_high_msb;
7239 		*lba = (*lba << 8) | sata_cmd->satacmd_lba_mid_msb;
7240 		*lba = (*lba << 8) | sata_cmd->satacmd_lba_low_msb;
7241 	} else if (sata_cmd->satacmd_addr_type == ATA_ADDR_LBA28) {
7242 		*lba = sata_cmd->satacmd_device_reg & 0xf;
7243 	}
7244 	*lba = (*lba << 8) | sata_cmd->satacmd_lba_high_lsb;
7245 	*lba = (*lba << 8) | sata_cmd->satacmd_lba_mid_lsb;
7246 	*lba = (*lba << 8) | sata_cmd->satacmd_lba_low_lsb;
7247 }
7248 
7249 /*
7250  * This is fixed sense format - if LBA exceeds the info field size,
7251  * no valid info will be returned (valid bit in extended sense will
7252  * be set to 0).
7253  */
7254 static struct scsi_extended_sense *
7255 sata_arq_sense(sata_pkt_txlate_t *spx)
7256 {
7257 	struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt;
7258 	struct scsi_arq_status *arqs;
7259 	struct scsi_extended_sense *sense;
7260 
7261 	/* Fill ARQ sense data */
7262 	scsipkt->pkt_state |= STATE_ARQ_DONE;
7263 	arqs = (struct scsi_arq_status *)scsipkt->pkt_scbp;
7264 	*(uchar_t *)&arqs->sts_status = STATUS_CHECK;
7265 	*(uchar_t *)&arqs->sts_rqpkt_status = STATUS_GOOD;
7266 	arqs->sts_rqpkt_reason = CMD_CMPLT;
7267 	arqs->sts_rqpkt_state = STATE_GOT_BUS | STATE_GOT_TARGET |
7268 	    STATE_XFERRED_DATA | STATE_SENT_CMD | STATE_GOT_STATUS;
7269 	arqs->sts_rqpkt_resid = 0;
7270 	sense = &arqs->sts_sensedata;
7271 	bzero(sense, sizeof (struct scsi_extended_sense));
7272 	sata_fixed_sense_data_preset(sense);
7273 	return (sense);
7274 }
7275 
7276 /*
7277  * ATA Pass Through support
7278  * Sets flags indicating that an invalid value was found in some
7279  * field in the command.  It could be something illegal according to
7280  * the SAT-2 spec or it could be a feature that is not (yet?)
7281  * supported.
7282  */
7283 static int
7284 sata_txlt_ata_pass_thru_illegal_cmd(sata_pkt_txlate_t *spx)
7285 {
7286 	struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt;
7287 	struct scsi_extended_sense *sense = sata_arq_sense(spx);
7288 
7289 	scsipkt->pkt_reason = CMD_CMPLT;
7290 	*scsipkt->pkt_scbp = STATUS_CHECK;
7291 	scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET |
7292 	    STATE_SENT_CMD | STATE_GOT_STATUS;
7293 
7294 	sense = sata_arq_sense(spx);
7295 	sense->es_key = KEY_ILLEGAL_REQUEST;
7296 	sense->es_add_code = SD_SCSI_ASC_INVALID_FIELD_IN_CDB;
7297 
7298 	if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0 &&
7299 	    scsipkt->pkt_comp != NULL) {
7300 		/* scsi callback required */
7301 		if (servicing_interrupt()) {
7302 			if (taskq_dispatch(SATA_TXLT_TASKQ(spx),
7303 			    (task_func_t *)spx->txlt_scsi_pkt->pkt_comp,
7304 			    (void *)spx->txlt_scsi_pkt, TQ_NOSLEEP) == NULL) {
7305 				return (TRAN_BUSY);
7306 			}
7307 		} else if (taskq_dispatch(SATA_TXLT_TASKQ(spx),
7308 		    (task_func_t *)spx->txlt_scsi_pkt->pkt_comp,
7309 		    (void *)spx->txlt_scsi_pkt, TQ_SLEEP) == NULL) {
7310 			/* Scheduling the callback failed */
7311 			return (TRAN_BUSY);
7312 		}
7313 	}
7314 
7315 	return (TRAN_ACCEPT);
7316 }
7317 
7318 /*
7319  * The UNMAP command considers it not to be an error if the parameter length
7320  * or block descriptor length is 0.  For this case, there is nothing for TRIM
7321  * to do so just complete the command.
7322  */
7323 static int
7324 sata_txlt_unmap_nodata_cmd(sata_pkt_txlate_t *spx)
7325 {
7326 	struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt;
7327 
7328 	scsipkt->pkt_reason = CMD_CMPLT;
7329 	*scsipkt->pkt_scbp = STATUS_GOOD;
7330 	scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET |
7331 	    STATE_SENT_CMD | STATE_GOT_STATUS;
7332 
7333 	if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0 &&
7334 	    scsipkt->pkt_comp != NULL) {
7335 		/* scsi callback required */
7336 		if (taskq_dispatch(SATA_TXLT_TASKQ(spx),
7337 		    (task_func_t *)spx->txlt_scsi_pkt->pkt_comp,
7338 		    (void *)spx->txlt_scsi_pkt, TQ_SLEEP) == NULL) {
7339 			/* Scheduling the callback failed */
7340 			return (TRAN_BUSY);
7341 		}
7342 	}
7343 
7344 	return (TRAN_ACCEPT);
7345 }
7346 
7347 /*
7348  * Emulated SATA Read/Write command completion for zero-length requests.
7349  * This request always succedes, so in synchronous mode it always returns
7350  * TRAN_ACCEPT, and in non-synchronous mode it may return TRAN_BUSY if the
7351  * callback cannot be scheduled.
7352  */
7353 static int
7354 sata_emul_rw_completion(sata_pkt_txlate_t *spx)
7355 {
7356 	struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt;
7357 
7358 	scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET |
7359 	    STATE_SENT_CMD | STATE_GOT_STATUS;
7360 	scsipkt->pkt_reason = CMD_CMPLT;
7361 	*scsipkt->pkt_scbp = STATUS_GOOD;
7362 	if (!(spx->txlt_sata_pkt->satapkt_op_mode & SATA_OPMODE_SYNCH)) {
7363 		/* scsi callback required - have to schedule it */
7364 		if (servicing_interrupt()) {
7365 			if (taskq_dispatch(SATA_TXLT_TASKQ(spx),
7366 			    (task_func_t *)spx->txlt_scsi_pkt->pkt_comp,
7367 			    (void *)spx->txlt_scsi_pkt, TQ_NOSLEEP) == NULL) {
7368 				return (TRAN_BUSY);
7369 			}
7370 		} else if (taskq_dispatch(SATA_TXLT_TASKQ(spx),
7371 		    (task_func_t *)spx->txlt_scsi_pkt->pkt_comp,
7372 		    (void *)spx->txlt_scsi_pkt, TQ_SLEEP) == NULL) {
7373 			/* Scheduling the callback failed */
7374 			return (TRAN_BUSY);
7375 		}
7376 	}
7377 	return (TRAN_ACCEPT);
7378 }
7379 
7380 
7381 /*
7382  * Translate completion status of SATA read/write commands into scsi response.
7383  * pkt completion_reason is checked to determine the completion status.
7384  * Do scsi callback if necessary.
7385  *
7386  * Note: this function may be called also for synchronously executed
7387  * commands.
7388  * This function may be used only if scsi_pkt is non-NULL.
7389  */
7390 static void
7391 sata_txlt_rw_completion(sata_pkt_t *sata_pkt)
7392 {
7393 	sata_pkt_txlate_t *spx =
7394 	    (sata_pkt_txlate_t *)sata_pkt->satapkt_framework_private;
7395 	sata_cmd_t *scmd = &sata_pkt->satapkt_cmd;
7396 	struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt;
7397 	struct scsi_extended_sense *sense;
7398 	uint64_t lba;
7399 	struct buf *bp;
7400 	int rval;
7401 	if (sata_pkt->satapkt_reason == SATA_PKT_COMPLETED) {
7402 		/* Normal completion */
7403 		scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET |
7404 		    STATE_SENT_CMD | STATE_XFERRED_DATA | STATE_GOT_STATUS;
7405 		scsipkt->pkt_reason = CMD_CMPLT;
7406 		*scsipkt->pkt_scbp = STATUS_GOOD;
7407 		if (spx->txlt_tmp_buf != NULL) {
7408 			/* Temporary buffer was used */
7409 			bp = spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp;
7410 			if (bp->b_flags & B_READ) {
7411 				rval = ddi_dma_sync(
7412 				    spx->txlt_buf_dma_handle, 0, 0,
7413 				    DDI_DMA_SYNC_FORCPU);
7414 				ASSERT(rval == DDI_SUCCESS);
7415 				bcopy(spx->txlt_tmp_buf, bp->b_un.b_addr,
7416 				    bp->b_bcount);
7417 			}
7418 		}
7419 	} else {
7420 		/*
7421 		 * Something went wrong - analyze return
7422 		 */
7423 		scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET |
7424 		    STATE_SENT_CMD | STATE_GOT_STATUS;
7425 		scsipkt->pkt_reason = CMD_INCOMPLETE;
7426 		*scsipkt->pkt_scbp = STATUS_CHECK;
7427 		sense = sata_arq_sense(spx);
7428 		ASSERT(sense != NULL);
7429 
7430 		/*
7431 		 * SATA_PKT_DEV_ERROR is the only case where we may be able to
7432 		 * extract from device registers the failing LBA.
7433 		 */
7434 		if (sata_pkt->satapkt_reason == SATA_PKT_DEV_ERROR) {
7435 			if ((scmd->satacmd_addr_type == ATA_ADDR_LBA48) &&
7436 			    (scmd->satacmd_lba_mid_msb != 0 ||
7437 			    scmd->satacmd_lba_high_msb != 0)) {
7438 				/*
7439 				 * We have problem reporting this cmd LBA
7440 				 * in fixed sense data format, because of
7441 				 * the size of the scsi LBA fields.
7442 				 */
7443 				sense->es_valid = 0;
7444 			} else {
7445 				sata_extract_error_lba(spx, &lba);
7446 				sense->es_info_1 = (lba & 0xFF000000) >> 24;
7447 				sense->es_info_2 = (lba & 0xFF0000) >> 16;
7448 				sense->es_info_3 = (lba & 0xFF00) >> 8;
7449 				sense->es_info_4 = lba & 0xFF;
7450 			}
7451 		} else {
7452 			/* Invalid extended sense info */
7453 			sense->es_valid = 0;
7454 		}
7455 
7456 		switch (sata_pkt->satapkt_reason) {
7457 		case SATA_PKT_PORT_ERROR:
7458 			/* We may want to handle DEV GONE state as well */
7459 			/*
7460 			 * We have no device data. Assume no data transfered.
7461 			 */
7462 			sense->es_key = KEY_HARDWARE_ERROR;
7463 			break;
7464 
7465 		case SATA_PKT_DEV_ERROR:
7466 			if (sata_pkt->satapkt_cmd.satacmd_status_reg &
7467 			    SATA_STATUS_ERR) {
7468 				/*
7469 				 * determine dev error reason from error
7470 				 * reg content
7471 				 */
7472 				sata_decode_device_error(spx, sense);
7473 				if (sense->es_key == KEY_MEDIUM_ERROR) {
7474 					switch (scmd->satacmd_cmd_reg) {
7475 					case SATAC_READ_DMA:
7476 					case SATAC_READ_DMA_EXT:
7477 					case SATAC_READ_DMA_QUEUED:
7478 					case SATAC_READ_DMA_QUEUED_EXT:
7479 					case SATAC_READ_FPDMA_QUEUED:
7480 						/* Unrecovered read error */
7481 						sense->es_add_code =
7482 						    SD_SCSI_ASC_UNREC_READ_ERR;
7483 						break;
7484 					case SATAC_WRITE_DMA:
7485 					case SATAC_WRITE_DMA_EXT:
7486 					case SATAC_WRITE_DMA_QUEUED:
7487 					case SATAC_WRITE_DMA_QUEUED_EXT:
7488 					case SATAC_WRITE_FPDMA_QUEUED:
7489 						/* Write error */
7490 						sense->es_add_code =
7491 						    SD_SCSI_ASC_WRITE_ERR;
7492 						break;
7493 					default:
7494 						/* Internal error */
7495 						SATA_LOG_D((
7496 						    spx->txlt_sata_hba_inst,
7497 						    CE_WARN,
7498 						    "sata_txlt_rw_completion :"
7499 						    "internal error - invalid "
7500 						    "command 0x%2x",
7501 						    scmd->satacmd_cmd_reg));
7502 						break;
7503 					}
7504 				}
7505 				break;
7506 			}
7507 			/* No extended sense key - no info available */
7508 			scsipkt->pkt_reason = CMD_INCOMPLETE;
7509 			break;
7510 
7511 		case SATA_PKT_TIMEOUT:
7512 			scsipkt->pkt_reason = CMD_TIMEOUT;
7513 			scsipkt->pkt_statistics |=
7514 			    STAT_TIMEOUT | STAT_DEV_RESET;
7515 			sense->es_key = KEY_ABORTED_COMMAND;
7516 			break;
7517 
7518 		case SATA_PKT_ABORTED:
7519 			scsipkt->pkt_reason = CMD_ABORTED;
7520 			scsipkt->pkt_statistics |= STAT_ABORTED;
7521 			sense->es_key = KEY_ABORTED_COMMAND;
7522 			break;
7523 
7524 		case SATA_PKT_RESET:
7525 			scsipkt->pkt_reason = CMD_RESET;
7526 			scsipkt->pkt_statistics |= STAT_DEV_RESET;
7527 			sense->es_key = KEY_ABORTED_COMMAND;
7528 			break;
7529 
7530 		default:
7531 			SATA_LOG_D((spx->txlt_sata_hba_inst, CE_WARN,
7532 			    "sata_txlt_rw_completion: "
7533 			    "invalid packet completion reason"));
7534 			scsipkt->pkt_reason = CMD_TRAN_ERR;
7535 			break;
7536 		}
7537 	}
7538 	SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst,
7539 	    "Scsi_pkt completion reason %x\n", scsipkt->pkt_reason);
7540 
7541 	if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0)
7542 		/* scsi callback required */
7543 		scsi_hba_pkt_comp(scsipkt);
7544 }
7545 
7546 
7547 /*
7548  * Translate completion status of non-data commands (i.e. commands returning
7549  * no data).
7550  * pkt completion_reason is checked to determine the completion status.
7551  * Do scsi callback if necessary (FLAG_NOINTR == 0)
7552  *
7553  * Note: this function may be called also for synchronously executed
7554  * commands.
7555  * This function may be used only if scsi_pkt is non-NULL.
7556  */
7557 
7558 static	void
7559 sata_txlt_nodata_cmd_completion(sata_pkt_t *sata_pkt)
7560 {
7561 	sata_pkt_txlate_t *spx =
7562 	    (sata_pkt_txlate_t *)sata_pkt->satapkt_framework_private;
7563 	struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt;
7564 
7565 	sata_set_arq_data(sata_pkt);
7566 
7567 	if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0)
7568 		/* scsi callback required */
7569 		scsi_hba_pkt_comp(scsipkt);
7570 }
7571 
7572 /*
7573  * Completion handler for ATA Pass Through command
7574  */
7575 static void
7576 sata_txlt_apt_completion(sata_pkt_t *sata_pkt)
7577 {
7578 	sata_pkt_txlate_t *spx =
7579 	    (sata_pkt_txlate_t *)sata_pkt->satapkt_framework_private;
7580 	sata_cmd_t *scmd = &sata_pkt->satapkt_cmd;
7581 	struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt;
7582 	struct buf *bp;
7583 	uint8_t sense_key = 0, addl_sense_code = 0, addl_sense_qual = 0;
7584 
7585 	if (sata_pkt->satapkt_reason == SATA_PKT_COMPLETED) {
7586 		/* Normal completion */
7587 		scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET |
7588 		    STATE_SENT_CMD | STATE_XFERRED_DATA | STATE_GOT_STATUS;
7589 		scsipkt->pkt_reason = CMD_CMPLT;
7590 		*scsipkt->pkt_scbp = STATUS_GOOD;
7591 
7592 		/*
7593 		 * If the command has CK_COND set
7594 		 */
7595 		if (scsipkt->pkt_cdbp[2] & SATL_APT_BM_CK_COND) {
7596 			*scsipkt->pkt_scbp = STATUS_CHECK;
7597 			sata_fill_ata_return_desc(sata_pkt,
7598 			    KEY_RECOVERABLE_ERROR,
7599 			    SD_SCSI_ASC_APT_INFO_AVAIL, 0x1d);
7600 		}
7601 
7602 		if (spx->txlt_tmp_buf != NULL) {
7603 			/* Temporary buffer was used */
7604 			bp = spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp;
7605 			if (bp->b_flags & B_READ) {
7606 				bcopy(spx->txlt_tmp_buf, bp->b_un.b_addr,
7607 				    bp->b_bcount);
7608 			}
7609 		}
7610 	} else {
7611 		scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET |
7612 		    STATE_SENT_CMD | STATE_GOT_STATUS;
7613 		scsipkt->pkt_reason = CMD_INCOMPLETE;
7614 		*scsipkt->pkt_scbp = STATUS_CHECK;
7615 
7616 		/*
7617 		 * If DF or ERR was set, the HBA should have copied out the
7618 		 * status and error registers to the satacmd structure.
7619 		 */
7620 		if (scmd->satacmd_status_reg & SATA_STATUS_DF) {
7621 			sense_key = KEY_HARDWARE_ERROR;
7622 			addl_sense_code = SD_SCSI_ASC_INTERNAL_TARGET_FAILURE;
7623 			addl_sense_qual = 0;
7624 		} else if (scmd->satacmd_status_reg & SATA_STATUS_ERR) {
7625 			if (scmd->satacmd_error_reg & SATA_ERROR_NM) {
7626 				sense_key = KEY_NOT_READY;
7627 				addl_sense_code =
7628 				    SD_SCSI_ASC_MEDIUM_NOT_PRESENT;
7629 				addl_sense_qual = 0;
7630 			} else if (scmd->satacmd_error_reg & SATA_ERROR_UNC) {
7631 				sense_key = KEY_MEDIUM_ERROR;
7632 				addl_sense_code = SD_SCSI_ASC_UNREC_READ_ERR;
7633 				addl_sense_qual = 0;
7634 			} else if (scmd->satacmd_error_reg & SATA_ERROR_ILI) {
7635 				sense_key = KEY_DATA_PROTECT;
7636 				addl_sense_code = SD_SCSI_ASC_WRITE_PROTECTED;
7637 				addl_sense_qual = 0;
7638 			} else if (scmd->satacmd_error_reg & SATA_ERROR_IDNF) {
7639 				sense_key = KEY_ILLEGAL_REQUEST;
7640 				addl_sense_code = SD_SCSI_ASC_LBA_OUT_OF_RANGE;
7641 				addl_sense_qual = 0;
7642 			} else if (scmd->satacmd_error_reg & SATA_ERROR_ABORT) {
7643 				sense_key = KEY_ABORTED_COMMAND;
7644 				addl_sense_code = SD_SCSI_ASC_NO_ADD_SENSE;
7645 				addl_sense_qual = 0;
7646 			} else if (scmd->satacmd_error_reg & SATA_ERROR_MC) {
7647 				sense_key = KEY_UNIT_ATTENTION;
7648 				addl_sense_code =
7649 				    SD_SCSI_ASC_MEDIUM_MAY_HAVE_CHANGED;
7650 				addl_sense_qual = 0;
7651 			} else if (scmd->satacmd_error_reg & SATA_ERROR_MCR) {
7652 				sense_key = KEY_UNIT_ATTENTION;
7653 				addl_sense_code = SD_SCSI_ASC_OP_MEDIUM_REM_REQ;
7654 				addl_sense_qual = 0;
7655 			} else if (scmd->satacmd_error_reg & SATA_ERROR_ICRC) {
7656 				sense_key = KEY_ABORTED_COMMAND;
7657 				addl_sense_code =
7658 				    SD_SCSI_ASC_INFO_UNIT_IUCRC_ERR;
7659 				addl_sense_qual = 0;
7660 			}
7661 		}
7662 
7663 		sata_fill_ata_return_desc(sata_pkt, sense_key, addl_sense_code,
7664 		    addl_sense_qual);
7665 	}
7666 
7667 	if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0)
7668 		/* scsi callback required */
7669 		scsi_hba_pkt_comp(scsipkt);
7670 }
7671 
7672 /*
7673  * Completion handler for unmap translation command
7674  */
7675 static void
7676 sata_txlt_unmap_completion(sata_pkt_t *sata_pkt)
7677 {
7678 	sata_pkt_txlate_t *spx =
7679 	    (sata_pkt_txlate_t *)sata_pkt->satapkt_framework_private;
7680 	sata_cmd_t *scmd = &sata_pkt->satapkt_cmd;
7681 	struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt;
7682 	struct buf *bp;
7683 	uint8_t sense_key = 0, addl_sense_code = 0, addl_sense_qual = 0;
7684 
7685 	if (sata_pkt->satapkt_reason == SATA_PKT_COMPLETED) {
7686 		/* Normal completion */
7687 		scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET |
7688 		    STATE_SENT_CMD | STATE_XFERRED_DATA | STATE_GOT_STATUS;
7689 		scsipkt->pkt_reason = CMD_CMPLT;
7690 		*scsipkt->pkt_scbp = STATUS_GOOD;
7691 
7692 		if (spx->txlt_tmp_buf != NULL) {
7693 			/* Temporary buffer was used */
7694 			bp = spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp;
7695 			if (bp->b_flags & B_READ) {
7696 				bcopy(spx->txlt_tmp_buf, bp->b_un.b_addr,
7697 				    bp->b_bcount);
7698 			}
7699 		}
7700 	} else {
7701 		scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET |
7702 		    STATE_SENT_CMD | STATE_GOT_STATUS;
7703 		scsipkt->pkt_reason = CMD_INCOMPLETE;
7704 		*scsipkt->pkt_scbp = STATUS_CHECK;
7705 
7706 		/*
7707 		 * If DF or ERR was set, the HBA should have copied out the
7708 		 * status and error registers to the satacmd structure.
7709 		 */
7710 		if (scmd->satacmd_status_reg & SATA_STATUS_DF) {
7711 			sense_key = KEY_HARDWARE_ERROR;
7712 			addl_sense_code = SD_SCSI_ASC_INTERNAL_TARGET_FAILURE;
7713 			addl_sense_qual = 0;
7714 		} else if (scmd->satacmd_status_reg & SATA_STATUS_ERR) {
7715 			if (scmd->satacmd_error_reg & SATA_ERROR_NM) {
7716 				sense_key = KEY_NOT_READY;
7717 				addl_sense_code =
7718 				    SD_SCSI_ASC_MEDIUM_NOT_PRESENT;
7719 				addl_sense_qual = 0;
7720 			} else if (scmd->satacmd_error_reg & SATA_ERROR_UNC) {
7721 				sense_key = KEY_MEDIUM_ERROR;
7722 				addl_sense_code = SD_SCSI_ASC_WRITE_ERR;
7723 				addl_sense_qual = 0;
7724 			} else if (scmd->satacmd_error_reg & SATA_ERROR_ILI) {
7725 				sense_key = KEY_DATA_PROTECT;
7726 				addl_sense_code = SD_SCSI_ASC_WRITE_PROTECTED;
7727 				addl_sense_qual = 0;
7728 			} else if (scmd->satacmd_error_reg & SATA_ERROR_IDNF) {
7729 				sense_key = KEY_ILLEGAL_REQUEST;
7730 				addl_sense_code = SD_SCSI_ASC_LBA_OUT_OF_RANGE;
7731 				addl_sense_qual = 0;
7732 			} else if (scmd->satacmd_error_reg & SATA_ERROR_ABORT) {
7733 				sense_key = KEY_ABORTED_COMMAND;
7734 				addl_sense_code = SD_SCSI_ASC_NO_ADD_SENSE;
7735 				addl_sense_qual = 0;
7736 			} else if (scmd->satacmd_error_reg & SATA_ERROR_MC) {
7737 				sense_key = KEY_UNIT_ATTENTION;
7738 				addl_sense_code =
7739 				    SD_SCSI_ASC_MEDIUM_MAY_HAVE_CHANGED;
7740 				addl_sense_qual = 0;
7741 			} else if (scmd->satacmd_error_reg & SATA_ERROR_MCR) {
7742 				sense_key = KEY_UNIT_ATTENTION;
7743 				addl_sense_code = SD_SCSI_ASC_OP_MEDIUM_REM_REQ;
7744 				addl_sense_qual = 0;
7745 			} else if (scmd->satacmd_error_reg & SATA_ERROR_ICRC) {
7746 				sense_key = KEY_ABORTED_COMMAND;
7747 				addl_sense_code =
7748 				    SD_SCSI_ASC_INFO_UNIT_IUCRC_ERR;
7749 				addl_sense_qual = 0;
7750 			}
7751 		}
7752 
7753 		sata_fill_ata_return_desc(sata_pkt, sense_key, addl_sense_code,
7754 		    addl_sense_qual);
7755 	}
7756 
7757 	sata_free_local_buffer(spx);
7758 
7759 	if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0)
7760 		/* scsi callback required */
7761 		scsi_hba_pkt_comp(scsipkt);
7762 }
7763 
7764 /*
7765  *
7766  */
7767 static void
7768 sata_fill_ata_return_desc(sata_pkt_t *sata_pkt, uint8_t sense_key,
7769     uint8_t addl_sense_code, uint8_t addl_sense_qual)
7770 {
7771 	sata_pkt_txlate_t *spx =
7772 	    (sata_pkt_txlate_t *)sata_pkt->satapkt_framework_private;
7773 	sata_cmd_t *scmd = &sata_pkt->satapkt_cmd;
7774 	struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt;
7775 	struct sata_apt_sense_data *apt_sd =
7776 	    (struct sata_apt_sense_data *)scsipkt->pkt_scbp;
7777 	struct scsi_descr_sense_hdr *sds = &(apt_sd->apt_sd_hdr);
7778 	struct scsi_ata_status_ret_sense_descr *ata_ret_desc =
7779 	    &(apt_sd->apt_sd_sense);
7780 	int extend = 0;
7781 
7782 	if ((scsipkt->pkt_cdbp[0] == SPC3_CMD_ATA_COMMAND_PASS_THROUGH16) &&
7783 	    (scsipkt->pkt_cdbp[2] & SATL_APT_BM_EXTEND))
7784 		extend = 1;
7785 
7786 	scsipkt->pkt_state |= STATE_ARQ_DONE;
7787 
7788 	/* update the residual count */
7789 	*(uchar_t *)&apt_sd->apt_status = STATUS_CHECK;
7790 	*(uchar_t *)&apt_sd->apt_rqpkt_status = STATUS_GOOD;
7791 	apt_sd->apt_rqpkt_reason = CMD_CMPLT;
7792 	apt_sd->apt_rqpkt_state = STATE_GOT_BUS | STATE_GOT_TARGET |
7793 	    STATE_XFERRED_DATA | STATE_SENT_CMD | STATE_GOT_STATUS;
7794 	apt_sd->apt_rqpkt_resid = scsipkt->pkt_scblen -
7795 	    sizeof (struct sata_apt_sense_data);
7796 
7797 	/*
7798 	 * Fill in the Descriptor sense header
7799 	 */
7800 	bzero(sds, sizeof (struct scsi_descr_sense_hdr));
7801 	sds->ds_code = CODE_FMT_DESCR_CURRENT;
7802 	sds->ds_class = CLASS_EXTENDED_SENSE;
7803 	sds->ds_key = sense_key & 0xf;
7804 	sds->ds_add_code = addl_sense_code;
7805 	sds->ds_qual_code = addl_sense_qual;
7806 	sds->ds_addl_sense_length =
7807 	    sizeof (struct scsi_ata_status_ret_sense_descr);
7808 
7809 	/*
7810 	 * Fill in the ATA Return descriptor sense data
7811 	 */
7812 	bzero(ata_ret_desc, sizeof (struct scsi_ata_status_ret_sense_descr));
7813 	ata_ret_desc->ars_descr_type = DESCR_ATA_STATUS_RETURN;
7814 	ata_ret_desc->ars_addl_length = 0xc;
7815 	ata_ret_desc->ars_error = scmd->satacmd_error_reg;
7816 	ata_ret_desc->ars_sec_count_lsb = scmd->satacmd_sec_count_lsb;
7817 	ata_ret_desc->ars_lba_low_lsb = scmd->satacmd_lba_low_lsb;
7818 	ata_ret_desc->ars_lba_mid_lsb = scmd->satacmd_lba_mid_lsb;
7819 	ata_ret_desc->ars_lba_high_lsb = scmd->satacmd_lba_high_lsb;
7820 	ata_ret_desc->ars_device = scmd->satacmd_device_reg;
7821 	ata_ret_desc->ars_status = scmd->satacmd_status_reg;
7822 
7823 	if (extend == 1) {
7824 		ata_ret_desc->ars_extend = 1;
7825 		ata_ret_desc->ars_sec_count_msb = scmd->satacmd_sec_count_msb;
7826 		ata_ret_desc->ars_lba_low_msb = scmd->satacmd_lba_low_msb;
7827 		ata_ret_desc->ars_lba_mid_msb = scmd->satacmd_lba_mid_msb;
7828 		ata_ret_desc->ars_lba_high_msb = scmd->satacmd_lba_high_msb;
7829 	} else {
7830 		ata_ret_desc->ars_extend = 0;
7831 		ata_ret_desc->ars_sec_count_msb = 0;
7832 		ata_ret_desc->ars_lba_low_msb = 0;
7833 		ata_ret_desc->ars_lba_mid_msb = 0;
7834 		ata_ret_desc->ars_lba_high_msb = 0;
7835 	}
7836 }
7837 
7838 static	void
7839 sata_set_arq_data(sata_pkt_t *sata_pkt)
7840 {
7841 	sata_pkt_txlate_t *spx =
7842 	    (sata_pkt_txlate_t *)sata_pkt->satapkt_framework_private;
7843 	struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt;
7844 	struct scsi_extended_sense *sense;
7845 
7846 	scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET |
7847 	    STATE_SENT_CMD | STATE_GOT_STATUS;
7848 	if (sata_pkt->satapkt_reason == SATA_PKT_COMPLETED) {
7849 		/* Normal completion */
7850 		scsipkt->pkt_reason = CMD_CMPLT;
7851 		*scsipkt->pkt_scbp = STATUS_GOOD;
7852 	} else {
7853 		/* Something went wrong */
7854 		scsipkt->pkt_reason = CMD_INCOMPLETE;
7855 		*scsipkt->pkt_scbp = STATUS_CHECK;
7856 		sense = sata_arq_sense(spx);
7857 		switch (sata_pkt->satapkt_reason) {
7858 		case SATA_PKT_PORT_ERROR:
7859 			/*
7860 			 * We have no device data. Assume no data transfered.
7861 			 */
7862 			sense->es_key = KEY_HARDWARE_ERROR;
7863 			break;
7864 
7865 		case SATA_PKT_DEV_ERROR:
7866 			if (sata_pkt->satapkt_cmd.satacmd_status_reg &
7867 			    SATA_STATUS_ERR) {
7868 				/*
7869 				 * determine dev error reason from error
7870 				 * reg content
7871 				 */
7872 				sata_decode_device_error(spx, sense);
7873 				break;
7874 			}
7875 			/* No extended sense key - no info available */
7876 			break;
7877 
7878 		case SATA_PKT_TIMEOUT:
7879 			scsipkt->pkt_reason = CMD_TIMEOUT;
7880 			scsipkt->pkt_statistics |=
7881 			    STAT_TIMEOUT | STAT_DEV_RESET;
7882 			/* No extended sense key ? */
7883 			break;
7884 
7885 		case SATA_PKT_ABORTED:
7886 			scsipkt->pkt_reason = CMD_ABORTED;
7887 			scsipkt->pkt_statistics |= STAT_ABORTED;
7888 			/* No extended sense key ? */
7889 			break;
7890 
7891 		case SATA_PKT_RESET:
7892 			/* pkt aborted by an explicit reset from a host */
7893 			scsipkt->pkt_reason = CMD_RESET;
7894 			scsipkt->pkt_statistics |= STAT_DEV_RESET;
7895 			break;
7896 
7897 		default:
7898 			SATA_LOG_D((spx->txlt_sata_hba_inst, CE_WARN,
7899 			    "sata_txlt_nodata_cmd_completion: "
7900 			    "invalid packet completion reason %d",
7901 			    sata_pkt->satapkt_reason));
7902 			scsipkt->pkt_reason = CMD_TRAN_ERR;
7903 			break;
7904 		}
7905 
7906 	}
7907 	SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst,
7908 	    "Scsi_pkt completion reason %x\n", scsipkt->pkt_reason);
7909 }
7910 
7911 
7912 /*
7913  * Build Mode sense R/W recovery page
7914  * NOT IMPLEMENTED
7915  */
7916 
7917 static int
7918 sata_build_msense_page_1(sata_drive_info_t *sdinfo, int pcntrl, uint8_t *buf)
7919 {
7920 #ifndef __lock_lint
7921 	_NOTE(ARGUNUSED(sdinfo))
7922 	_NOTE(ARGUNUSED(pcntrl))
7923 	_NOTE(ARGUNUSED(buf))
7924 #endif
7925 	return (0);
7926 }
7927 
7928 /*
7929  * Build Mode sense caching page  -  scsi-3 implementation.
7930  * Page length distinguishes previous format from scsi-3 format.
7931  * buf must have space for 0x12 bytes.
7932  * Only DRA (disable read ahead ) and WCE (write cache enable) are changeable.
7933  *
7934  */
7935 static int
7936 sata_build_msense_page_8(sata_drive_info_t *sdinfo, int pcntrl, uint8_t *buf)
7937 {
7938 	struct mode_cache_scsi3 *page = (struct mode_cache_scsi3 *)buf;
7939 	sata_id_t *sata_id = &sdinfo->satadrv_id;
7940 
7941 	/*
7942 	 * Most of the fields are set to 0, being not supported and/or disabled
7943 	 */
7944 	bzero(buf, PAGELENGTH_DAD_MODE_CACHE_SCSI3);
7945 
7946 	/* Saved paramters not supported */
7947 	if (pcntrl == 3)
7948 		return (0);
7949 	if (pcntrl == 0 || pcntrl == 2) {
7950 		/*
7951 		 * For now treat current and default parameters as same
7952 		 * That may have to change, if target driver will complain
7953 		 */
7954 		page->mode_page.code = MODEPAGE_CACHING;	/* PS = 0 */
7955 		page->mode_page.length = PAGELENGTH_DAD_MODE_CACHE_SCSI3;
7956 
7957 		if (SATA_READ_AHEAD_SUPPORTED(*sata_id) &&
7958 		    !SATA_READ_AHEAD_ENABLED(*sata_id)) {
7959 			page->dra = 1;		/* Read Ahead disabled */
7960 			page->rcd = 1;		/* Read Cache disabled */
7961 		}
7962 		if (SATA_WRITE_CACHE_SUPPORTED(*sata_id) &&
7963 		    SATA_WRITE_CACHE_ENABLED(*sata_id))
7964 			page->wce = 1;		/* Write Cache enabled */
7965 	} else {
7966 		/* Changeable parameters */
7967 		page->mode_page.code = MODEPAGE_CACHING;
7968 		page->mode_page.length = PAGELENGTH_DAD_MODE_CACHE_SCSI3;
7969 		if (SATA_READ_AHEAD_SUPPORTED(*sata_id)) {
7970 			page->dra = 1;
7971 			page->rcd = 1;
7972 		}
7973 		if (SATA_WRITE_CACHE_SUPPORTED(*sata_id))
7974 			page->wce = 1;
7975 	}
7976 	return (PAGELENGTH_DAD_MODE_CACHE_SCSI3 +
7977 	    sizeof (struct mode_page));
7978 }
7979 
7980 /*
7981  * Build Mode sense exception cntrl page
7982  */
7983 static int
7984 sata_build_msense_page_1c(sata_drive_info_t *sdinfo, int pcntrl, uint8_t *buf)
7985 {
7986 	struct mode_info_excpt_page *page = (struct mode_info_excpt_page *)buf;
7987 	sata_id_t *sata_id = &sdinfo->satadrv_id;
7988 
7989 	/*
7990 	 * Most of the fields are set to 0, being not supported and/or disabled
7991 	 */
7992 	bzero(buf, PAGELENGTH_INFO_EXCPT);
7993 
7994 	page->mode_page.code = MODEPAGE_INFO_EXCPT;
7995 	page->mode_page.length = PAGELENGTH_INFO_EXCPT;
7996 
7997 	/* Indicate that this is page is saveable */
7998 	page->mode_page.ps = 1;
7999 
8000 	/*
8001 	 * We will return the same data for default, current and saved page.
8002 	 * The only changeable bit is dexcpt and that bit is required
8003 	 * by the ATA specification to be preserved across power cycles.
8004 	 */
8005 	if (pcntrl != 1) {
8006 		page->dexcpt = !(sata_id->ai_features85 & SATA_SMART_SUPPORTED);
8007 		page->mrie = MRIE_ONLY_ON_REQUEST;
8008 	}
8009 	else
8010 		page->dexcpt = 1;	/* Only changeable parameter */
8011 
8012 	return (PAGELENGTH_INFO_EXCPT + sizeof (struct mode_page));
8013 }
8014 
8015 
8016 static int
8017 sata_build_msense_page_30(sata_drive_info_t *sdinfo, int pcntrl, uint8_t *buf)
8018 {
8019 	struct mode_acoustic_management *page =
8020 	    (struct mode_acoustic_management *)buf;
8021 	sata_id_t *sata_id = &sdinfo->satadrv_id;
8022 
8023 	/*
8024 	 * Most of the fields are set to 0, being not supported and/or disabled
8025 	 */
8026 	bzero(buf, PAGELENGTH_DAD_MODE_ACOUSTIC_MANAGEMENT);
8027 
8028 	switch (pcntrl) {
8029 	case P_CNTRL_DEFAULT:
8030 		/*  default paramters not supported */
8031 		return (0);
8032 
8033 	case P_CNTRL_CURRENT:
8034 	case P_CNTRL_SAVED:
8035 		/* Saved and current are supported and are identical */
8036 		page->mode_page.code = MODEPAGE_ACOUSTIC_MANAG;
8037 		page->mode_page.length =
8038 		    PAGELENGTH_DAD_MODE_ACOUSTIC_MANAGEMENT;
8039 		page->mode_page.ps = 1;
8040 
8041 		/* Word 83 indicates if feature is supported */
8042 		/* If feature is not supported */
8043 		if (!(sata_id->ai_cmdset83 & SATA_ACOUSTIC_MGMT)) {
8044 			page->acoustic_manag_enable =
8045 			    ACOUSTIC_DISABLED;
8046 		} else {
8047 			page->acoustic_manag_enable =
8048 			    ((sata_id->ai_features86 & SATA_ACOUSTIC_MGMT)
8049 			    != 0);
8050 			/* Word 94 inidicates the value */
8051 #ifdef	_LITTLE_ENDIAN
8052 			page->acoustic_manag_level =
8053 			    (uchar_t)sata_id->ai_acoustic;
8054 			page->vendor_recommended_value =
8055 			    sata_id->ai_acoustic >> 8;
8056 #else
8057 			page->acoustic_manag_level =
8058 			    sata_id->ai_acoustic >> 8;
8059 			page->vendor_recommended_value =
8060 			    (uchar_t)sata_id->ai_acoustic;
8061 #endif
8062 		}
8063 		break;
8064 
8065 	case P_CNTRL_CHANGEABLE:
8066 		page->mode_page.code = MODEPAGE_ACOUSTIC_MANAG;
8067 		page->mode_page.length =
8068 		    PAGELENGTH_DAD_MODE_ACOUSTIC_MANAGEMENT;
8069 		page->mode_page.ps = 1;
8070 
8071 		/* Word 83 indicates if the feature is supported */
8072 		if (sata_id->ai_cmdset83 & SATA_ACOUSTIC_MGMT) {
8073 			page->acoustic_manag_enable =
8074 			    ACOUSTIC_ENABLED;
8075 			page->acoustic_manag_level = 0xff;
8076 		}
8077 		break;
8078 	}
8079 	return (PAGELENGTH_DAD_MODE_ACOUSTIC_MANAGEMENT +
8080 	    sizeof (struct mode_page));
8081 }
8082 
8083 
8084 /*
8085  * Build Mode sense power condition page.
8086  */
8087 static int
8088 sata_build_msense_page_1a(sata_drive_info_t *sdinfo, int pcntrl, uint8_t *buf)
8089 {
8090 	struct mode_info_power_cond *page = (struct mode_info_power_cond *)buf;
8091 	sata_id_t *sata_id = &sdinfo->satadrv_id;
8092 
8093 	/*
8094 	 * Most of the fields are set to 0, being not supported and/or disabled
8095 	 * power condition page length was 0x0a
8096 	 */
8097 	bzero(buf, sizeof (struct mode_info_power_cond));
8098 
8099 	if (pcntrl == P_CNTRL_DEFAULT) {
8100 		/*  default paramters not supported */
8101 		return (0);
8102 	}
8103 
8104 	page->mode_page.code = MODEPAGE_POWER_COND;
8105 	page->mode_page.length = sizeof (struct mode_info_power_cond);
8106 
8107 	if (sata_id->ai_cap & SATA_STANDBYTIMER) {
8108 		page->standby = 1;
8109 		bcopy(sdinfo->satadrv_standby_timer, page->standby_cond_timer,
8110 		    sizeof (uchar_t) * 4);
8111 	}
8112 
8113 	return (sizeof (struct mode_info_power_cond));
8114 }
8115 
8116 /*
8117  * Process mode select caching page 8 (scsi3 format only).
8118  * Read Ahead (same as read cache) and Write Cache may be turned on and off
8119  * if these features are supported by the device. If these features are not
8120  * supported, the command will be terminated with STATUS_CHECK.
8121  * This function fails only if the SET FEATURE command sent to
8122  * the device fails. The page format is not verified, assuming that the
8123  * target driver operates correctly - if parameters length is too short,
8124  * we just drop the page.
8125  * Two command may be sent if both Read Cache/Read Ahead and Write Cache
8126  * setting have to be changed.
8127  * SET FEATURE command is executed synchronously, i.e. we wait here until
8128  * it is completed, regardless of the scsi pkt directives.
8129  *
8130  * Note: Mode Select Caching page RCD and DRA bits are tied together, i.e.
8131  * changing DRA will change RCD.
8132  *
8133  * More than one SATA command may be executed to perform operations specified
8134  * by mode select pages. The first error terminates further execution.
8135  * Operations performed successully are not backed-up in such case.
8136  *
8137  * Return SATA_SUCCESS if operation succeeded, SATA_FAILURE otherwise.
8138  * If operation resulted in changing device setup, dmod flag should be set to
8139  * one (1). If parameters were not changed, dmod flag should be set to 0.
8140  * Upon return, if operation required sending command to the device, the rval
8141  * should be set to the value returned by sata_hba_start. If operation
8142  * did not require device access, rval should be set to TRAN_ACCEPT.
8143  * The pagelen should be set to the length of the page.
8144  *
8145  * This function has to be called with a port mutex held.
8146  *
8147  * Returns SATA_SUCCESS if operation was successful, SATA_FAILURE otherwise.
8148  */
8149 int
8150 sata_mode_select_page_8(sata_pkt_txlate_t *spx, struct mode_cache_scsi3 *page,
8151     int parmlen, int *pagelen, int *rval, int *dmod)
8152 {
8153 	struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt;
8154 	sata_drive_info_t *sdinfo;
8155 	sata_cmd_t *scmd = &spx->txlt_sata_pkt->satapkt_cmd;
8156 	sata_id_t *sata_id;
8157 	struct scsi_extended_sense *sense;
8158 	int wce, dra;	/* Current settings */
8159 
8160 	sdinfo = sata_get_device_info(spx->txlt_sata_hba_inst,
8161 	    &spx->txlt_sata_pkt->satapkt_device);
8162 	sata_id = &sdinfo->satadrv_id;
8163 	*dmod = 0;
8164 
8165 	/* Verify parameters length. If too short, drop it */
8166 	if ((PAGELENGTH_DAD_MODE_CACHE_SCSI3 +
8167 	    sizeof (struct mode_page)) > parmlen) {
8168 		*scsipkt->pkt_scbp = STATUS_CHECK;
8169 		sense = sata_arq_sense(spx);
8170 		sense->es_key = KEY_ILLEGAL_REQUEST;
8171 		sense->es_add_code = SD_SCSI_ASC_INVALID_FIELD_IN_PARAMS_LIST;
8172 		*pagelen = parmlen;
8173 		*rval = TRAN_ACCEPT;
8174 		return (SATA_FAILURE);
8175 	}
8176 
8177 	*pagelen = PAGELENGTH_DAD_MODE_CACHE_SCSI3 + sizeof (struct mode_page);
8178 
8179 	/* Current setting of Read Ahead (and Read Cache) */
8180 	if (SATA_READ_AHEAD_ENABLED(*sata_id))
8181 		dra = 0;	/* 0 == not disabled */
8182 	else
8183 		dra = 1;
8184 	/* Current setting of Write Cache */
8185 	if (SATA_WRITE_CACHE_ENABLED(*sata_id))
8186 		wce = 1;
8187 	else
8188 		wce = 0;
8189 
8190 	if (page->dra == dra && page->wce == wce && page->rcd == dra) {
8191 		/* nothing to do */
8192 		*rval = TRAN_ACCEPT;
8193 		return (SATA_SUCCESS);
8194 	}
8195 
8196 	/*
8197 	 * Need to flip some setting
8198 	 * Set-up Internal SET FEATURES command(s)
8199 	 */
8200 	scmd->satacmd_flags.sata_data_direction = SATA_DIR_NODATA_XFER;
8201 	scmd->satacmd_addr_type = 0;
8202 	scmd->satacmd_device_reg = 0;
8203 	scmd->satacmd_status_reg = 0;
8204 	scmd->satacmd_error_reg = 0;
8205 	scmd->satacmd_cmd_reg = SATAC_SET_FEATURES;
8206 	if (page->dra != dra || page->rcd != dra) {
8207 		if (SATA_READ_AHEAD_SUPPORTED(*sata_id)) {
8208 			/* Need to flip read ahead setting */
8209 			if (dra == 0)
8210 				/* Disable read ahead / read cache */
8211 				scmd->satacmd_features_reg =
8212 				    SATAC_SF_DISABLE_READ_AHEAD;
8213 			else
8214 				/* Enable read ahead  / read cache */
8215 				scmd->satacmd_features_reg =
8216 				    SATAC_SF_ENABLE_READ_AHEAD;
8217 
8218 			/* Transfer command to HBA */
8219 			if (sata_hba_start(spx, rval) != 0)
8220 				/*
8221 				 * Pkt not accepted for execution.
8222 				 */
8223 				return (SATA_FAILURE);
8224 
8225 			*dmod = 1;
8226 
8227 			/* Now process return */
8228 			if (spx->txlt_sata_pkt->satapkt_reason !=
8229 			    SATA_PKT_COMPLETED) {
8230 				goto failure;	/* Terminate */
8231 			}
8232 		} else {
8233 			*scsipkt->pkt_scbp = STATUS_CHECK;
8234 			sense = sata_arq_sense(spx);
8235 			sense->es_key = KEY_ILLEGAL_REQUEST;
8236 			sense->es_add_code =
8237 			    SD_SCSI_ASC_INVALID_FIELD_IN_PARAMS_LIST;
8238 			*pagelen = parmlen;
8239 			*rval = TRAN_ACCEPT;
8240 			return (SATA_FAILURE);
8241 		}
8242 	}
8243 
8244 	/* Note that the packet is not removed, so it could be re-used */
8245 	if (page->wce != wce) {
8246 		if (SATA_WRITE_CACHE_SUPPORTED(*sata_id)) {
8247 			/* Need to flip Write Cache setting */
8248 			if (page->wce == 1)
8249 				/* Enable write cache */
8250 				scmd->satacmd_features_reg =
8251 				    SATAC_SF_ENABLE_WRITE_CACHE;
8252 			else
8253 				/* Disable write cache */
8254 				scmd->satacmd_features_reg =
8255 				    SATAC_SF_DISABLE_WRITE_CACHE;
8256 
8257 			/* Transfer command to HBA */
8258 			if (sata_hba_start(spx, rval) != 0)
8259 				/*
8260 				 * Pkt not accepted for execution.
8261 				 */
8262 				return (SATA_FAILURE);
8263 
8264 			*dmod = 1;
8265 
8266 			/* Now process return */
8267 			if (spx->txlt_sata_pkt->satapkt_reason !=
8268 			    SATA_PKT_COMPLETED) {
8269 				goto failure;
8270 			}
8271 		} else {
8272 			*scsipkt->pkt_scbp = STATUS_CHECK;
8273 			sense = sata_arq_sense(spx);
8274 			sense->es_key = KEY_ILLEGAL_REQUEST;
8275 			sense->es_add_code =
8276 			    SD_SCSI_ASC_INVALID_FIELD_IN_PARAMS_LIST;
8277 			*pagelen = parmlen;
8278 			*rval = TRAN_ACCEPT;
8279 			return (SATA_FAILURE);
8280 		}
8281 	}
8282 	return (SATA_SUCCESS);
8283 
8284 failure:
8285 	sata_xlate_errors(spx);
8286 
8287 	return (SATA_FAILURE);
8288 }
8289 
8290 /*
8291  * Process mode select informational exceptions control page 0x1c
8292  *
8293  * The only changeable bit is dexcpt (disable exceptions).
8294  * MRIE (method of reporting informational exceptions) must be
8295  * "only on request".
8296  * This page applies to informational exceptions that report
8297  * additional sense codes with the ADDITIONAL SENSE CODE field set to 5Dh
8298  * (e.g.,FAILURE PREDICTION THRESHOLD EXCEEDED) or 0Bh (e.g., WARNING_).
8299  * Informational exception conditions occur as the result of background scan
8300  * errors, background self-test errors, or vendor specific events within a
8301  * logical unit. An informational exception condition may occur asynchronous
8302  * to any commands.
8303  *
8304  * Returns: SATA_SUCCESS if operation succeeded, SATA_FAILURE otherwise.
8305  * If operation resulted in changing device setup, dmod flag should be set to
8306  * one (1). If parameters were not changed, dmod flag should be set to 0.
8307  * Upon return, if operation required sending command to the device, the rval
8308  * should be set to the value returned by sata_hba_start. If operation
8309  * did not require device access, rval should be set to TRAN_ACCEPT.
8310  * The pagelen should be set to the length of the page.
8311  *
8312  * This function has to be called with a port mutex held.
8313  *
8314  * Returns SATA_SUCCESS if operation was successful, SATA_FAILURE otherwise.
8315  *
8316  * Cannot be called in the interrupt context.
8317  */
8318 static	int
8319 sata_mode_select_page_1c(
8320 	sata_pkt_txlate_t *spx,
8321 	struct mode_info_excpt_page *page,
8322 	int parmlen,
8323 	int *pagelen,
8324 	int *rval,
8325 	int *dmod)
8326 {
8327 	struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt;
8328 	sata_cmd_t *scmd = &spx->txlt_sata_pkt->satapkt_cmd;
8329 	sata_drive_info_t *sdinfo;
8330 	sata_id_t *sata_id;
8331 	struct scsi_extended_sense *sense;
8332 
8333 	sdinfo = sata_get_device_info(spx->txlt_sata_hba_inst,
8334 	    &spx->txlt_sata_pkt->satapkt_device);
8335 	sata_id = &sdinfo->satadrv_id;
8336 
8337 	*dmod = 0;
8338 
8339 	/* Verify parameters length. If too short, drop it */
8340 	if (((PAGELENGTH_INFO_EXCPT + sizeof (struct mode_page)) > parmlen) ||
8341 	    page->perf || page->test || (page->mrie != MRIE_ONLY_ON_REQUEST)) {
8342 		*scsipkt->pkt_scbp = STATUS_CHECK;
8343 		sense = sata_arq_sense(spx);
8344 		sense->es_key = KEY_ILLEGAL_REQUEST;
8345 		sense->es_add_code = SD_SCSI_ASC_INVALID_FIELD_IN_PARAMS_LIST;
8346 		*pagelen = parmlen;
8347 		*rval = TRAN_ACCEPT;
8348 		return (SATA_FAILURE);
8349 	}
8350 
8351 	*pagelen = PAGELENGTH_INFO_EXCPT + sizeof (struct mode_page);
8352 
8353 	if (! (sata_id->ai_cmdset82 & SATA_SMART_SUPPORTED)) {
8354 		*scsipkt->pkt_scbp = STATUS_CHECK;
8355 		sense = sata_arq_sense(spx);
8356 		sense->es_key = KEY_ILLEGAL_REQUEST;
8357 		sense->es_add_code = SD_SCSI_ASC_INVALID_FIELD_IN_CDB;
8358 		*pagelen = parmlen;
8359 		*rval = TRAN_ACCEPT;
8360 		return (SATA_FAILURE);
8361 	}
8362 
8363 	/* If already in the state requested, we are done */
8364 	if (page->dexcpt == ! (sata_id->ai_features85 & SATA_SMART_ENABLED)) {
8365 		/* nothing to do */
8366 		*rval = TRAN_ACCEPT;
8367 		return (SATA_SUCCESS);
8368 	}
8369 
8370 	scmd->satacmd_flags.sata_data_direction = SATA_DIR_NODATA_XFER;
8371 
8372 	/* Build SMART_ENABLE or SMART_DISABLE command */
8373 	scmd->satacmd_addr_type = 0;		/* N/A */
8374 	scmd->satacmd_lba_mid_lsb = SMART_MAGIC_VAL_1;
8375 	scmd->satacmd_lba_high_lsb = SMART_MAGIC_VAL_2;
8376 	scmd->satacmd_features_reg = page->dexcpt ?
8377 	    SATA_SMART_DISABLE_OPS : SATA_SMART_ENABLE_OPS;
8378 	scmd->satacmd_device_reg = 0;		/* Always device 0 */
8379 	scmd->satacmd_cmd_reg = SATAC_SMART;
8380 
8381 	/* Transfer command to HBA */
8382 	if (sata_hba_start(spx, rval) != 0)
8383 		/*
8384 		 * Pkt not accepted for execution.
8385 		 */
8386 		return (SATA_FAILURE);
8387 
8388 	*dmod = 1;	/* At least may have been modified */
8389 
8390 	/* Now process return */
8391 	if (spx->txlt_sata_pkt->satapkt_reason == SATA_PKT_COMPLETED)
8392 		return (SATA_SUCCESS);
8393 
8394 	/* Packet did not complete successfully */
8395 	sata_xlate_errors(spx);
8396 
8397 	return (SATA_FAILURE);
8398 }
8399 
8400 /*
8401  * Process mode select acoustic management control page 0x30
8402  *
8403  *
8404  * This function has to be called with a port mutex held.
8405  *
8406  * Returns SATA_SUCCESS if operation was successful, SATA_FAILURE otherwise.
8407  *
8408  * Cannot be called in the interrupt context.
8409  */
8410 int
8411 sata_mode_select_page_30(sata_pkt_txlate_t *spx, struct
8412     mode_acoustic_management *page, int parmlen, int *pagelen,
8413     int *rval, int *dmod)
8414 {
8415 	struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt;
8416 	sata_drive_info_t *sdinfo;
8417 	sata_cmd_t *scmd = &spx->txlt_sata_pkt->satapkt_cmd;
8418 	sata_id_t *sata_id;
8419 	struct scsi_extended_sense *sense;
8420 
8421 	sdinfo = sata_get_device_info(spx->txlt_sata_hba_inst,
8422 	    &spx->txlt_sata_pkt->satapkt_device);
8423 	sata_id = &sdinfo->satadrv_id;
8424 	*dmod = 0;
8425 
8426 	/* If parmlen is too short or the feature is not supported, drop it */
8427 	if (((PAGELENGTH_DAD_MODE_ACOUSTIC_MANAGEMENT +
8428 	    sizeof (struct mode_page)) > parmlen) ||
8429 	    (! (sata_id->ai_cmdset83 & SATA_ACOUSTIC_MGMT))) {
8430 		*scsipkt->pkt_scbp = STATUS_CHECK;
8431 		sense = sata_arq_sense(spx);
8432 		sense->es_key = KEY_ILLEGAL_REQUEST;
8433 		sense->es_add_code = SD_SCSI_ASC_INVALID_FIELD_IN_PARAMS_LIST;
8434 		*pagelen = parmlen;
8435 		*rval = TRAN_ACCEPT;
8436 		return (SATA_FAILURE);
8437 	}
8438 
8439 	*pagelen = PAGELENGTH_DAD_MODE_ACOUSTIC_MANAGEMENT +
8440 	    sizeof (struct mode_page);
8441 
8442 	/*
8443 	 * We can enable and disable acoustice management and
8444 	 * set the acoustic management level.
8445 	 */
8446 
8447 	/*
8448 	 * Set-up Internal SET FEATURES command(s)
8449 	 */
8450 	scmd->satacmd_flags.sata_data_direction = SATA_DIR_NODATA_XFER;
8451 	scmd->satacmd_addr_type = 0;
8452 	scmd->satacmd_device_reg = 0;
8453 	scmd->satacmd_status_reg = 0;
8454 	scmd->satacmd_error_reg = 0;
8455 	scmd->satacmd_cmd_reg = SATAC_SET_FEATURES;
8456 	if (page->acoustic_manag_enable) {
8457 		scmd->satacmd_features_reg = SATAC_SF_ENABLE_ACOUSTIC;
8458 		scmd->satacmd_sec_count_lsb = page->acoustic_manag_level;
8459 	} else {	/* disabling acoustic management */
8460 		scmd->satacmd_features_reg = SATAC_SF_DISABLE_ACOUSTIC;
8461 	}
8462 
8463 	/* Transfer command to HBA */
8464 	if (sata_hba_start(spx, rval) != 0)
8465 		/*
8466 		 * Pkt not accepted for execution.
8467 		 */
8468 		return (SATA_FAILURE);
8469 
8470 	/* Now process return */
8471 	if (spx->txlt_sata_pkt->satapkt_reason != SATA_PKT_COMPLETED) {
8472 		sata_xlate_errors(spx);
8473 		return (SATA_FAILURE);
8474 	}
8475 
8476 	*dmod = 1;
8477 
8478 	return (SATA_SUCCESS);
8479 }
8480 
8481 /*
8482  * Process mode select power condition page 0x1a
8483  *
8484  * This function has to be called with a port mutex held.
8485  *
8486  * Returns SATA_SUCCESS if operation was successful, SATA_FAILURE otherwise.
8487  *
8488  * Cannot be called in the interrupt context.
8489  */
8490 int
8491 sata_mode_select_page_1a(sata_pkt_txlate_t *spx, struct
8492     mode_info_power_cond *page, int parmlen, int *pagelen,
8493     int *rval, int *dmod)
8494 {
8495 	struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt;
8496 	sata_drive_info_t *sdinfo;
8497 	sata_cmd_t *scmd = &spx->txlt_sata_pkt->satapkt_cmd;
8498 	sata_id_t *sata_id;
8499 	struct scsi_extended_sense *sense;
8500 	uint8_t ata_count;
8501 	int i, len;
8502 
8503 	sdinfo = sata_get_device_info(spx->txlt_sata_hba_inst,
8504 	    &spx->txlt_sata_pkt->satapkt_device);
8505 	sata_id = &sdinfo->satadrv_id;
8506 	*dmod = 0;
8507 
8508 	len = sizeof (struct mode_info_power_cond);
8509 	len += sizeof (struct mode_page);
8510 
8511 	/* If parmlen is too short or the feature is not supported, drop it */
8512 	if ((len < parmlen) || (page->idle == 1) ||
8513 	    (!(sata_id->ai_cap & SATA_STANDBYTIMER) && page->standby == 1)) {
8514 		*scsipkt->pkt_scbp = STATUS_CHECK;
8515 		sense = sata_arq_sense(spx);
8516 		sense->es_key = KEY_ILLEGAL_REQUEST;
8517 		sense->es_add_code = SD_SCSI_ASC_INVALID_FIELD_IN_PARAMS_LIST;
8518 		*pagelen = parmlen;
8519 		*rval = TRAN_ACCEPT;
8520 		return (SATA_FAILURE);
8521 	}
8522 
8523 	*pagelen = len;
8524 
8525 	/*
8526 	 * Set-up Internal STANDBY command(s)
8527 	 */
8528 	if (page->standby == 0)
8529 		goto out;
8530 
8531 	ata_count = sata_get_standby_timer(page->standby_cond_timer);
8532 
8533 	scmd->satacmd_addr_type = 0;
8534 	scmd->satacmd_sec_count_lsb = ata_count;
8535 	scmd->satacmd_lba_low_lsb = 0;
8536 	scmd->satacmd_lba_mid_lsb = 0;
8537 	scmd->satacmd_lba_high_lsb = 0;
8538 	scmd->satacmd_features_reg = 0;
8539 	scmd->satacmd_device_reg = 0;
8540 	scmd->satacmd_status_reg = 0;
8541 	scmd->satacmd_cmd_reg = SATAC_STANDBY;
8542 	scmd->satacmd_flags.sata_special_regs = B_TRUE;
8543 	scmd->satacmd_flags.sata_copy_out_error_reg = B_TRUE;
8544 
8545 	/* Transfer command to HBA */
8546 	if (sata_hba_start(spx, rval) != 0) {
8547 		return (SATA_FAILURE);
8548 	} else {
8549 		if ((scmd->satacmd_error_reg != 0) ||
8550 		    (spx->txlt_sata_pkt->satapkt_reason !=
8551 		    SATA_PKT_COMPLETED)) {
8552 			sata_xlate_errors(spx);
8553 			return (SATA_FAILURE);
8554 		}
8555 	}
8556 
8557 	for (i = 0; i < 4; i++) {
8558 		sdinfo->satadrv_standby_timer[i] = page->standby_cond_timer[i];
8559 	}
8560 out:
8561 	*dmod = 1;
8562 	return (SATA_SUCCESS);
8563 }
8564 
8565 /*
8566  * sata_build_lsense_page0() is used to create the
8567  * SCSI LOG SENSE page 0 (supported log pages)
8568  *
8569  * Currently supported pages are 0, 0x10, 0x2f, 0x30 and 0x0e
8570  * (supported log pages, self-test results, informational exceptions
8571  * Sun vendor specific ATA SMART data, and start stop cycle counter).
8572  *
8573  * Takes a sata_drive_info t * and the address of a buffer
8574  * in which to create the page information.
8575  *
8576  * Returns the number of bytes valid in the buffer.
8577  */
8578 static	int
8579 sata_build_lsense_page_0(sata_drive_info_t *sdinfo, uint8_t *buf)
8580 {
8581 	struct log_parameter *lpp = (struct log_parameter *)buf;
8582 	uint8_t *page_ptr = (uint8_t *)lpp->param_values;
8583 	int num_pages_supported = 1; /* Always have GET_SUPPORTED_LOG_PAGES */
8584 	sata_id_t *sata_id = &sdinfo->satadrv_id;
8585 
8586 	lpp->param_code[0] = 0;
8587 	lpp->param_code[1] = 0;
8588 	lpp->param_ctrl_flags = LOG_CTRL_LP | LOG_CTRL_LBIN;
8589 	*page_ptr++ = PAGE_CODE_GET_SUPPORTED_LOG_PAGES;
8590 
8591 	if (sata_id->ai_cmdset82 & SATA_SMART_SUPPORTED) {
8592 		if (sata_id->ai_cmdset84 & SATA_SMART_SELF_TEST_SUPPORTED) {
8593 			*page_ptr++ = PAGE_CODE_SELF_TEST_RESULTS;
8594 			++num_pages_supported;
8595 		}
8596 		*page_ptr++ = PAGE_CODE_INFORMATION_EXCEPTIONS;
8597 		++num_pages_supported;
8598 		*page_ptr++ = PAGE_CODE_SMART_READ_DATA;
8599 		++num_pages_supported;
8600 		*page_ptr++ = PAGE_CODE_START_STOP_CYCLE_COUNTER;
8601 		++num_pages_supported;
8602 	}
8603 
8604 	lpp->param_len = num_pages_supported;
8605 
8606 	return ((&lpp->param_values[0] - (uint8_t *)lpp) +
8607 	    num_pages_supported);
8608 }
8609 
8610 /*
8611  * sata_build_lsense_page_10() is used to create the
8612  * SCSI LOG SENSE page 0x10 (self-test results)
8613  *
8614  * Takes a sata_drive_info t * and the address of a buffer
8615  * in which to create the page information as well as a sata_hba_inst_t *.
8616  *
8617  * Returns the number of bytes valid in the buffer.
8618  *
8619  * Note: Self test and SMART data is accessible in device log pages.
8620  * The log pages can be accessed by SMART READ/WRITE LOG (up to 255 sectors
8621  * of data can be transferred by a single command), or by the General Purpose
8622  * Logging commands (GPL) READ LOG EXT and WRITE LOG EXT (up to 65,535 sectors
8623  * - approximately 33MB - can be transferred by a single command.
8624  * The SCT Command response (either error or command) is the same for both
8625  * the SMART and GPL methods of issuing commands.
8626  * This function uses READ LOG EXT command when drive supports LBA48, and
8627  * SMART READ command otherwise.
8628  *
8629  * Since above commands are executed in a synchronous mode, this function
8630  * should not be called in an interrupt context.
8631  */
8632 static	int
8633 sata_build_lsense_page_10(
8634 	sata_drive_info_t *sdinfo,
8635 	uint8_t *buf,
8636 	sata_hba_inst_t *sata_hba_inst)
8637 {
8638 	struct log_parameter *lpp = (struct log_parameter *)buf;
8639 	int rval;
8640 
8641 	if (sdinfo->satadrv_features_support & SATA_DEV_F_LBA48) {
8642 		struct smart_ext_selftest_log *ext_selftest_log;
8643 
8644 		ext_selftest_log = kmem_zalloc(
8645 		    sizeof (struct smart_ext_selftest_log), KM_SLEEP);
8646 
8647 		rval = sata_ext_smart_selftest_read_log(sata_hba_inst, sdinfo,
8648 		    ext_selftest_log, 0);
8649 		if (rval == 0) {
8650 			int index, start_index;
8651 			struct smart_ext_selftest_log_entry *entry;
8652 			static const struct smart_ext_selftest_log_entry empty =
8653 			    {0};
8654 			uint16_t block_num;
8655 			int count;
8656 			boolean_t only_one_block = B_FALSE;
8657 
8658 			index = ext_selftest_log->
8659 			    smart_ext_selftest_log_index[0];
8660 			index |= ext_selftest_log->
8661 			    smart_ext_selftest_log_index[1] << 8;
8662 			if (index == 0)
8663 				goto out;
8664 
8665 			--index;	/* Correct for 0 origin */
8666 			start_index = index;	/* remember where we started */
8667 			block_num = index / ENTRIES_PER_EXT_SELFTEST_LOG_BLK;
8668 			if (block_num != 0) {
8669 				rval = sata_ext_smart_selftest_read_log(
8670 				    sata_hba_inst, sdinfo, ext_selftest_log,
8671 				    block_num);
8672 				if (rval != 0)
8673 					goto out;
8674 			}
8675 			index %= ENTRIES_PER_EXT_SELFTEST_LOG_BLK;
8676 			entry =
8677 			    &ext_selftest_log->
8678 			    smart_ext_selftest_log_entries[index];
8679 
8680 			for (count = 1;
8681 			    count <= SCSI_ENTRIES_IN_LOG_SENSE_SELFTEST_RESULTS;
8682 			    ++count) {
8683 				uint8_t status;
8684 				uint8_t code;
8685 				uint8_t sense_key;
8686 				uint8_t add_sense_code;
8687 				uint8_t add_sense_code_qual;
8688 
8689 				/* If this is an unused entry, we are done */
8690 				if (bcmp(entry, &empty, sizeof (empty)) == 0) {
8691 					/* Broken firmware on some disks */
8692 					if (index + 1 ==
8693 					    ENTRIES_PER_EXT_SELFTEST_LOG_BLK) {
8694 						--entry;
8695 						--index;
8696 						if (bcmp(entry, &empty,
8697 						    sizeof (empty)) == 0)
8698 							goto out;
8699 					} else
8700 						goto out;
8701 				}
8702 
8703 				if (only_one_block &&
8704 				    start_index == index)
8705 					goto out;
8706 
8707 				lpp->param_code[0] = 0;
8708 				lpp->param_code[1] = count;
8709 				lpp->param_ctrl_flags =
8710 				    LOG_CTRL_LP | LOG_CTRL_LBIN;
8711 				lpp->param_len =
8712 				    SCSI_LOG_SENSE_SELFTEST_PARAM_LEN;
8713 
8714 				status = entry->smart_ext_selftest_log_status;
8715 				status >>= 4;
8716 				switch (status) {
8717 				case 0:
8718 				default:
8719 					sense_key = KEY_NO_SENSE;
8720 					add_sense_code =
8721 					    SD_SCSI_ASC_NO_ADD_SENSE;
8722 					add_sense_code_qual = 0;
8723 					break;
8724 				case 1:
8725 					sense_key = KEY_ABORTED_COMMAND;
8726 					add_sense_code =
8727 					    DIAGNOSTIC_FAILURE_ON_COMPONENT;
8728 					add_sense_code_qual = SCSI_COMPONENT_81;
8729 					break;
8730 				case 2:
8731 					sense_key = KEY_ABORTED_COMMAND;
8732 					add_sense_code =
8733 					    DIAGNOSTIC_FAILURE_ON_COMPONENT;
8734 					add_sense_code_qual = SCSI_COMPONENT_82;
8735 					break;
8736 				case 3:
8737 					sense_key = KEY_ABORTED_COMMAND;
8738 					add_sense_code =
8739 					    DIAGNOSTIC_FAILURE_ON_COMPONENT;
8740 					add_sense_code_qual = SCSI_COMPONENT_83;
8741 					break;
8742 				case 4:
8743 					sense_key = KEY_HARDWARE_ERROR;
8744 					add_sense_code =
8745 					    DIAGNOSTIC_FAILURE_ON_COMPONENT;
8746 					add_sense_code_qual = SCSI_COMPONENT_84;
8747 					break;
8748 				case 5:
8749 					sense_key = KEY_HARDWARE_ERROR;
8750 					add_sense_code =
8751 					    DIAGNOSTIC_FAILURE_ON_COMPONENT;
8752 					add_sense_code_qual = SCSI_COMPONENT_85;
8753 					break;
8754 				case 6:
8755 					sense_key = KEY_HARDWARE_ERROR;
8756 					add_sense_code =
8757 					    DIAGNOSTIC_FAILURE_ON_COMPONENT;
8758 					add_sense_code_qual = SCSI_COMPONENT_86;
8759 					break;
8760 				case 7:
8761 					sense_key = KEY_MEDIUM_ERROR;
8762 					add_sense_code =
8763 					    DIAGNOSTIC_FAILURE_ON_COMPONENT;
8764 					add_sense_code_qual = SCSI_COMPONENT_87;
8765 					break;
8766 				case 8:
8767 					sense_key = KEY_HARDWARE_ERROR;
8768 					add_sense_code =
8769 					    DIAGNOSTIC_FAILURE_ON_COMPONENT;
8770 					add_sense_code_qual = SCSI_COMPONENT_88;
8771 					break;
8772 				}
8773 				code = 0;	/* unspecified */
8774 				status |= (code << 4);
8775 				lpp->param_values[0] = status;
8776 				lpp->param_values[1] = 0; /* unspecified */
8777 				lpp->param_values[2] = entry->
8778 				    smart_ext_selftest_log_timestamp[1];
8779 				lpp->param_values[3] = entry->
8780 				    smart_ext_selftest_log_timestamp[0];
8781 				if (status != 0) {
8782 					lpp->param_values[4] = 0;
8783 					lpp->param_values[5] = 0;
8784 					lpp->param_values[6] = entry->
8785 					    smart_ext_selftest_log_failing_lba
8786 					    [5];
8787 					lpp->param_values[7] = entry->
8788 					    smart_ext_selftest_log_failing_lba
8789 					    [4];
8790 					lpp->param_values[8] = entry->
8791 					    smart_ext_selftest_log_failing_lba
8792 					    [3];
8793 					lpp->param_values[9] = entry->
8794 					    smart_ext_selftest_log_failing_lba
8795 					    [2];
8796 					lpp->param_values[10] = entry->
8797 					    smart_ext_selftest_log_failing_lba
8798 					    [1];
8799 					lpp->param_values[11] = entry->
8800 					    smart_ext_selftest_log_failing_lba
8801 					    [0];
8802 				} else {	/* No bad block address */
8803 					lpp->param_values[4] = 0xff;
8804 					lpp->param_values[5] = 0xff;
8805 					lpp->param_values[6] = 0xff;
8806 					lpp->param_values[7] = 0xff;
8807 					lpp->param_values[8] = 0xff;
8808 					lpp->param_values[9] = 0xff;
8809 					lpp->param_values[10] = 0xff;
8810 					lpp->param_values[11] = 0xff;
8811 				}
8812 
8813 				lpp->param_values[12] = sense_key;
8814 				lpp->param_values[13] = add_sense_code;
8815 				lpp->param_values[14] = add_sense_code_qual;
8816 				lpp->param_values[15] = 0; /* undefined */
8817 
8818 				lpp = (struct log_parameter *)
8819 				    (((uint8_t *)lpp) +
8820 				    SCSI_LOG_PARAM_HDR_LEN +
8821 				    SCSI_LOG_SENSE_SELFTEST_PARAM_LEN);
8822 
8823 				--index;	/* Back up to previous entry */
8824 				if (index < 0) {
8825 					if (block_num > 0) {
8826 						--block_num;
8827 					} else {
8828 						struct read_log_ext_directory
8829 						    logdir;
8830 
8831 						rval =
8832 						    sata_read_log_ext_directory(
8833 						    sata_hba_inst, sdinfo,
8834 						    &logdir);
8835 						if (rval == -1)
8836 							goto out;
8837 						if ((logdir.read_log_ext_vers
8838 						    [0] == 0) &&
8839 						    (logdir.read_log_ext_vers
8840 						    [1] == 0))
8841 							goto out;
8842 						block_num =
8843 						    logdir.read_log_ext_nblks
8844 						    [EXT_SMART_SELFTEST_LOG_PAGE
8845 						    - 1][0];
8846 						block_num |= logdir.
8847 						    read_log_ext_nblks
8848 						    [EXT_SMART_SELFTEST_LOG_PAGE
8849 						    - 1][1] << 8;
8850 						--block_num;
8851 						only_one_block =
8852 						    (block_num == 0);
8853 					}
8854 					rval = sata_ext_smart_selftest_read_log(
8855 					    sata_hba_inst, sdinfo,
8856 					    ext_selftest_log, block_num);
8857 					if (rval != 0)
8858 						goto out;
8859 
8860 					index =
8861 					    ENTRIES_PER_EXT_SELFTEST_LOG_BLK -
8862 					    1;
8863 				}
8864 				index %= ENTRIES_PER_EXT_SELFTEST_LOG_BLK;
8865 				entry = &ext_selftest_log->
8866 				    smart_ext_selftest_log_entries[index];
8867 			}
8868 		}
8869 out:
8870 		kmem_free(ext_selftest_log,
8871 		    sizeof (struct smart_ext_selftest_log));
8872 	} else {
8873 		struct smart_selftest_log *selftest_log;
8874 
8875 		selftest_log = kmem_zalloc(sizeof (struct smart_selftest_log),
8876 		    KM_SLEEP);
8877 
8878 		rval = sata_smart_selftest_log(sata_hba_inst, sdinfo,
8879 		    selftest_log);
8880 
8881 		if (rval == 0) {
8882 			int index;
8883 			int count;
8884 			struct smart_selftest_log_entry *entry;
8885 			static const struct smart_selftest_log_entry empty =
8886 			    { 0 };
8887 
8888 			index = selftest_log->smart_selftest_log_index;
8889 			if (index == 0)
8890 				goto done;
8891 			--index;	/* Correct for 0 origin */
8892 			entry = &selftest_log->
8893 			    smart_selftest_log_entries[index];
8894 			for (count = 1;
8895 			    count <= SCSI_ENTRIES_IN_LOG_SENSE_SELFTEST_RESULTS;
8896 			    ++count) {
8897 				uint8_t status;
8898 				uint8_t code;
8899 				uint8_t sense_key;
8900 				uint8_t add_sense_code;
8901 				uint8_t add_sense_code_qual;
8902 
8903 				if (bcmp(entry, &empty, sizeof (empty)) == 0)
8904 					goto done;
8905 
8906 				lpp->param_code[0] = 0;
8907 				lpp->param_code[1] = count;
8908 				lpp->param_ctrl_flags =
8909 				    LOG_CTRL_LP | LOG_CTRL_LBIN;
8910 				lpp->param_len =
8911 				    SCSI_LOG_SENSE_SELFTEST_PARAM_LEN;
8912 
8913 				status = entry->smart_selftest_log_status;
8914 				status >>= 4;
8915 				switch (status) {
8916 				case 0:
8917 				default:
8918 					sense_key = KEY_NO_SENSE;
8919 					add_sense_code =
8920 					    SD_SCSI_ASC_NO_ADD_SENSE;
8921 					break;
8922 				case 1:
8923 					sense_key = KEY_ABORTED_COMMAND;
8924 					add_sense_code =
8925 					    DIAGNOSTIC_FAILURE_ON_COMPONENT;
8926 					add_sense_code_qual = SCSI_COMPONENT_81;
8927 					break;
8928 				case 2:
8929 					sense_key = KEY_ABORTED_COMMAND;
8930 					add_sense_code =
8931 					    DIAGNOSTIC_FAILURE_ON_COMPONENT;
8932 					add_sense_code_qual = SCSI_COMPONENT_82;
8933 					break;
8934 				case 3:
8935 					sense_key = KEY_ABORTED_COMMAND;
8936 					add_sense_code =
8937 					    DIAGNOSTIC_FAILURE_ON_COMPONENT;
8938 					add_sense_code_qual = SCSI_COMPONENT_83;
8939 					break;
8940 				case 4:
8941 					sense_key = KEY_HARDWARE_ERROR;
8942 					add_sense_code =
8943 					    DIAGNOSTIC_FAILURE_ON_COMPONENT;
8944 					add_sense_code_qual = SCSI_COMPONENT_84;
8945 					break;
8946 				case 5:
8947 					sense_key = KEY_HARDWARE_ERROR;
8948 					add_sense_code =
8949 					    DIAGNOSTIC_FAILURE_ON_COMPONENT;
8950 					add_sense_code_qual = SCSI_COMPONENT_85;
8951 					break;
8952 				case 6:
8953 					sense_key = KEY_HARDWARE_ERROR;
8954 					add_sense_code =
8955 					    DIAGNOSTIC_FAILURE_ON_COMPONENT;
8956 					add_sense_code_qual = SCSI_COMPONENT_86;
8957 					break;
8958 				case 7:
8959 					sense_key = KEY_MEDIUM_ERROR;
8960 					add_sense_code =
8961 					    DIAGNOSTIC_FAILURE_ON_COMPONENT;
8962 					add_sense_code_qual = SCSI_COMPONENT_87;
8963 					break;
8964 				case 8:
8965 					sense_key = KEY_HARDWARE_ERROR;
8966 					add_sense_code =
8967 					    DIAGNOSTIC_FAILURE_ON_COMPONENT;
8968 					add_sense_code_qual = SCSI_COMPONENT_88;
8969 					break;
8970 				}
8971 				code = 0;	/* unspecified */
8972 				status |= (code << 4);
8973 				lpp->param_values[0] = status;
8974 				lpp->param_values[1] = 0; /* unspecified */
8975 				lpp->param_values[2] = entry->
8976 				    smart_selftest_log_timestamp[1];
8977 				lpp->param_values[3] = entry->
8978 				    smart_selftest_log_timestamp[0];
8979 				if (status != 0) {
8980 					lpp->param_values[4] = 0;
8981 					lpp->param_values[5] = 0;
8982 					lpp->param_values[6] = 0;
8983 					lpp->param_values[7] = 0;
8984 					lpp->param_values[8] = entry->
8985 					    smart_selftest_log_failing_lba[3];
8986 					lpp->param_values[9] = entry->
8987 					    smart_selftest_log_failing_lba[2];
8988 					lpp->param_values[10] = entry->
8989 					    smart_selftest_log_failing_lba[1];
8990 					lpp->param_values[11] = entry->
8991 					    smart_selftest_log_failing_lba[0];
8992 				} else {	/* No block address */
8993 					lpp->param_values[4] = 0xff;
8994 					lpp->param_values[5] = 0xff;
8995 					lpp->param_values[6] = 0xff;
8996 					lpp->param_values[7] = 0xff;
8997 					lpp->param_values[8] = 0xff;
8998 					lpp->param_values[9] = 0xff;
8999 					lpp->param_values[10] = 0xff;
9000 					lpp->param_values[11] = 0xff;
9001 				}
9002 				lpp->param_values[12] = sense_key;
9003 				lpp->param_values[13] = add_sense_code;
9004 				lpp->param_values[14] = add_sense_code_qual;
9005 				lpp->param_values[15] = 0; /* undefined */
9006 
9007 				lpp = (struct log_parameter *)
9008 				    (((uint8_t *)lpp) +
9009 				    SCSI_LOG_PARAM_HDR_LEN +
9010 				    SCSI_LOG_SENSE_SELFTEST_PARAM_LEN);
9011 				--index;	/* back up to previous entry */
9012 				if (index < 0) {
9013 					index =
9014 					    NUM_SMART_SELFTEST_LOG_ENTRIES - 1;
9015 				}
9016 				entry = &selftest_log->
9017 				    smart_selftest_log_entries[index];
9018 			}
9019 		}
9020 done:
9021 		kmem_free(selftest_log, sizeof (struct smart_selftest_log));
9022 	}
9023 
9024 	return ((SCSI_LOG_PARAM_HDR_LEN + SCSI_LOG_SENSE_SELFTEST_PARAM_LEN) *
9025 	    SCSI_ENTRIES_IN_LOG_SENSE_SELFTEST_RESULTS);
9026 }
9027 
9028 /*
9029  * sata_build_lsense_page_2f() is used to create the
9030  * SCSI LOG SENSE page 0x2f (informational exceptions)
9031  *
9032  * Takes a sata_drive_info t * and the address of a buffer
9033  * in which to create the page information as well as a sata_hba_inst_t *.
9034  *
9035  * Returns the number of bytes valid in the buffer.
9036  *
9037  * Because it invokes function(s) that send synchronously executed command
9038  * to the HBA, it cannot be called in the interrupt context.
9039  */
9040 static	int
9041 sata_build_lsense_page_2f(
9042 	sata_drive_info_t *sdinfo,
9043 	uint8_t *buf,
9044 	sata_hba_inst_t *sata_hba_inst)
9045 {
9046 	struct log_parameter *lpp = (struct log_parameter *)buf;
9047 	int rval;
9048 	uint8_t *smart_data;
9049 	uint8_t temp;
9050 	sata_id_t *sata_id;
9051 #define	SMART_NO_TEMP	0xff
9052 
9053 	lpp->param_code[0] = 0;
9054 	lpp->param_code[1] = 0;
9055 	lpp->param_ctrl_flags = LOG_CTRL_LP | LOG_CTRL_LBIN;
9056 
9057 	/* Now get the SMART status w.r.t. threshold exceeded */
9058 	rval = sata_fetch_smart_return_status(sata_hba_inst, sdinfo);
9059 	switch (rval) {
9060 	case 1:
9061 		lpp->param_values[0] = SCSI_PREDICTED_FAILURE;
9062 		lpp->param_values[1] = SCSI_GENERAL_HD_FAILURE;
9063 		break;
9064 	case 0:
9065 	case -1:	/* failed to get data */
9066 		lpp->param_values[0] = 0;	/* No failure predicted */
9067 		lpp->param_values[1] = 0;
9068 		break;
9069 #if defined(SATA_DEBUG)
9070 	default:
9071 		cmn_err(CE_PANIC, "sata_build_lsense_page_2f bad return value");
9072 		/* NOTREACHED */
9073 #endif
9074 	}
9075 
9076 	sata_id = &sdinfo->satadrv_id;
9077 	if (! (sata_id->ai_sctsupport & SATA_SCT_CMD_TRANS_SUP))
9078 		temp = SMART_NO_TEMP;
9079 	else {
9080 		/* Now get the temperature */
9081 		smart_data = kmem_zalloc(512, KM_SLEEP);
9082 		rval = sata_smart_read_log(sata_hba_inst, sdinfo, smart_data,
9083 		    SCT_STATUS_LOG_PAGE, 1);
9084 		if (rval == -1)
9085 			temp = SMART_NO_TEMP;
9086 		else {
9087 			temp = smart_data[200];
9088 			if (temp & 0x80) {
9089 				if (temp & 0x7f)
9090 					temp = 0;
9091 				else
9092 					temp = SMART_NO_TEMP;
9093 			}
9094 		}
9095 		kmem_free(smart_data, 512);
9096 	}
9097 
9098 	lpp->param_values[2] = temp;	/* most recent temperature */
9099 	lpp->param_values[3] = 0;	/* required vendor specific byte */
9100 
9101 	lpp->param_len = SCSI_INFO_EXCEPTIONS_PARAM_LEN;
9102 
9103 
9104 	return (SCSI_INFO_EXCEPTIONS_PARAM_LEN + SCSI_LOG_PARAM_HDR_LEN);
9105 }
9106 
9107 /*
9108  * sata_build_lsense_page_30() is used to create the
9109  * SCSI LOG SENSE page 0x30 (Sun's vendor specific page for ATA SMART data).
9110  *
9111  * Takes a sata_drive_info t * and the address of a buffer
9112  * in which to create the page information as well as a sata_hba_inst_t *.
9113  *
9114  * Returns the number of bytes valid in the buffer.
9115  */
9116 static int
9117 sata_build_lsense_page_30(
9118 	sata_drive_info_t *sdinfo,
9119 	uint8_t *buf,
9120 	sata_hba_inst_t *sata_hba_inst)
9121 {
9122 	struct smart_data *smart_data = (struct smart_data *)buf;
9123 	int rval;
9124 
9125 	/* Now do the SMART READ DATA */
9126 	rval = sata_fetch_smart_data(sata_hba_inst, sdinfo, smart_data);
9127 	if (rval == -1)
9128 		return (0);
9129 
9130 	return (sizeof (struct smart_data));
9131 }
9132 
9133 /*
9134  * sata_build_lsense_page_0e() is used to create the
9135  * SCSI LOG SENSE page 0e (start-stop cycle counter page)
9136  *
9137  * Date of Manufacture (0x0001)
9138  *	YEAR = "0000"
9139  *	WEEK = "00"
9140  * Accounting Date (0x0002)
9141  *	6 ASCII space character(20h)
9142  * Specified cycle count over device lifetime
9143  *	VALUE - THRESH - the delta between max and min;
9144  * Accumulated start-stop cycles
9145  *	VALUE - WORST - the accumulated cycles;
9146  *
9147  * ID FLAG THRESH VALUE WORST RAW on start/stop counter attribute
9148  *
9149  * Takes a sata_drive_info t * and the address of a buffer
9150  * in which to create the page information as well as a sata_hba_inst_t *.
9151  *
9152  * Returns the number of bytes valid in the buffer.
9153  */
9154 static	int
9155 sata_build_lsense_page_0e(sata_drive_info_t *sdinfo, uint8_t *buf,
9156 	sata_pkt_txlate_t *spx)
9157 {
9158 	struct start_stop_cycle_counter_log *log_page;
9159 	int i, rval, index;
9160 	uint8_t smart_data[512], id, value, worst, thresh;
9161 	uint32_t max_count, cycles;
9162 
9163 	/* Now do the SMART READ DATA */
9164 	rval = sata_fetch_smart_data(spx->txlt_sata_hba_inst, sdinfo,
9165 	    (struct smart_data *)smart_data);
9166 	if (rval == -1)
9167 		return (0);
9168 	for (i = 0, id = 0; i < SMART_START_STOP_COUNT_ID * 2; i++) {
9169 		index = (i * 12) + 2;
9170 		id = smart_data[index];
9171 		if (id != SMART_START_STOP_COUNT_ID)
9172 			continue;
9173 		else {
9174 			thresh = smart_data[index + 2];
9175 			value = smart_data[index + 3];
9176 			worst = smart_data[index + 4];
9177 			break;
9178 		}
9179 	}
9180 	if (id != SMART_START_STOP_COUNT_ID)
9181 		return (0);
9182 	max_count = value - thresh;
9183 	cycles = value - worst;
9184 
9185 	log_page = (struct start_stop_cycle_counter_log *)buf;
9186 	bzero(log_page, sizeof (struct start_stop_cycle_counter_log));
9187 	log_page->code = 0x0e;
9188 	log_page->page_len_low = 0x24;
9189 
9190 	log_page->manufactor_date_low = 0x1;
9191 	log_page->param_1.fmt_link = 0x1; /* 01b */
9192 	log_page->param_len_1 = 0x06;
9193 	for (i = 0; i < 4; i++) {
9194 		log_page->year_manu[i] = 0x30;
9195 		if (i < 2)
9196 			log_page->week_manu[i] = 0x30;
9197 	}
9198 
9199 	log_page->account_date_low = 0x02;
9200 	log_page->param_2.fmt_link = 0x01; /* 01b */
9201 	log_page->param_len_2 = 0x06;
9202 	for (i = 0; i < 4; i++) {
9203 		log_page->year_account[i] = 0x20;
9204 		if (i < 2)
9205 			log_page->week_account[i] = 0x20;
9206 	}
9207 
9208 	log_page->lifetime_code_low = 0x03;
9209 	log_page->param_3.fmt_link = 0x03; /* 11b */
9210 	log_page->param_len_3 = 0x04;
9211 	/* VALUE - THRESH - the delta between max and min */
9212 	log_page->cycle_code_low = 0x04;
9213 	log_page->param_4.fmt_link = 0x03; /* 11b */
9214 	log_page->param_len_4 = 0x04;
9215 	/* WORST - THRESH - the distance from 'now' to min */
9216 
9217 	for (i = 0; i < 4; i++) {
9218 		log_page->cycle_lifetime[i] =
9219 		    (max_count >> (8 * (3 - i))) & 0xff;
9220 		log_page->cycle_accumulated[i] =
9221 		    (cycles >> (8 * (3 - i))) & 0xff;
9222 	}
9223 
9224 	return (sizeof (struct start_stop_cycle_counter_log));
9225 }
9226 
9227 /*
9228  * This function was used for build a ATA read verify sector command
9229  */
9230 static void
9231 sata_build_read_verify_cmd(sata_cmd_t *scmd, uint16_t sec, uint64_t lba)
9232 {
9233 	scmd->satacmd_cmd_reg = SATAC_RDVER;
9234 	scmd->satacmd_addr_type = ATA_ADDR_LBA28;
9235 	scmd->satacmd_flags.sata_special_regs = B_TRUE;
9236 
9237 	scmd->satacmd_sec_count_lsb = sec & 0xff;
9238 	scmd->satacmd_lba_low_lsb = lba & 0xff;
9239 	scmd->satacmd_lba_mid_lsb = (lba >> 8) & 0xff;
9240 	scmd->satacmd_lba_high_lsb = (lba >> 16) & 0xff;
9241 	scmd->satacmd_device_reg = (SATA_ADH_LBA | (lba >> 24) & 0xf);
9242 	scmd->satacmd_features_reg = 0;
9243 	scmd->satacmd_status_reg = 0;
9244 	scmd->satacmd_error_reg = 0;
9245 }
9246 
9247 /*
9248  * This function was used for building an ATA
9249  * command, and only command register need to
9250  * be defined, other register will be zero or na.
9251  */
9252 static void
9253 sata_build_generic_cmd(sata_cmd_t *scmd, uint8_t cmd)
9254 {
9255 	scmd->satacmd_addr_type = 0;
9256 	scmd->satacmd_cmd_reg = cmd;
9257 	scmd->satacmd_device_reg = 0;
9258 	scmd->satacmd_sec_count_lsb = 0;
9259 	scmd->satacmd_lba_low_lsb = 0;
9260 	scmd->satacmd_lba_mid_lsb = 0;
9261 	scmd->satacmd_lba_high_lsb = 0;
9262 	scmd->satacmd_features_reg = 0;
9263 	scmd->satacmd_status_reg = 0;
9264 	scmd->satacmd_error_reg = 0;
9265 	scmd->satacmd_flags.sata_special_regs = B_TRUE;
9266 }
9267 
9268 /*
9269  * This function was used for changing the standby
9270  * timer format from SCSI to ATA.
9271  */
9272 static uint8_t
9273 sata_get_standby_timer(uint8_t *timer)
9274 {
9275 	uint32_t i = 0, count = 0;
9276 	uint8_t ata_count;
9277 
9278 	for (i = 0; i < 4; i++) {
9279 		count = count << 8 | timer[i];
9280 	}
9281 
9282 	if (count == 0)
9283 		return (0);
9284 
9285 	if (count >= 1 && count <= 12000)
9286 		ata_count = (count -1) / 50 + 1;
9287 	else if (count > 12000 && count <= 12600)
9288 		ata_count = 0xfc;
9289 	else if (count > 12601 && count <= 12750)
9290 		ata_count = 0xff;
9291 	else if (count > 12750 && count <= 17999)
9292 		ata_count = 0xf1;
9293 	else if (count > 18000 && count <= 198000)
9294 		ata_count = count / 18000 + 240;
9295 	else
9296 		ata_count = 0xfd;
9297 	return (ata_count);
9298 }
9299 
9300 /* ************************** ATAPI-SPECIFIC FUNCTIONS ********************** */
9301 
9302 /*
9303  * Start command for ATAPI device.
9304  * This function processes scsi_pkt requests.
9305  * Now CD/DVD, tape and ATAPI disk devices are supported.
9306  * Most commands are packet without any translation into Packet Command.
9307  * Some may be trapped and executed as SATA commands (not clear which one).
9308  *
9309  * Returns TRAN_ACCEPT if command is accepted for execution (or completed
9310  * execution).
9311  * Returns other TRAN_XXXX codes if command is not accepted or completed
9312  * (see return values for sata_hba_start()).
9313  *
9314  * Note:
9315  * Inquiry cdb format differs between transport version 2 and 3.
9316  * However, the transport version 3 devices that were checked did not adhere
9317  * to the specification (ignored MSB of the allocation length). Therefore,
9318  * the transport version is not checked, but Inquiry allocation length is
9319  * truncated to 255 bytes if the original allocation length set-up by the
9320  * target driver is greater than 255 bytes.
9321  */
9322 static int
9323 sata_txlt_atapi(sata_pkt_txlate_t *spx)
9324 {
9325 	struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt;
9326 	sata_cmd_t *scmd = &spx->txlt_sata_pkt->satapkt_cmd;
9327 	struct buf *bp = spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp;
9328 	sata_hba_inst_t *sata_hba = SATA_TXLT_HBA_INST(spx);
9329 	sata_drive_info_t *sdinfo = sata_get_device_info(sata_hba,
9330 	    &spx->txlt_sata_pkt->satapkt_device);
9331 	kmutex_t *cport_mutex = &(SATA_TXLT_CPORT_MUTEX(spx));
9332 	int cdblen;
9333 	int rval, reason;
9334 	int synch;
9335 	union scsi_cdb *cdbp = (union scsi_cdb *)scsipkt->pkt_cdbp;
9336 
9337 	mutex_enter(cport_mutex);
9338 
9339 	if (((rval = sata_txlt_generic_pkt_info(spx, &reason, 0)) !=
9340 	    TRAN_ACCEPT) || (reason == CMD_DEV_GONE)) {
9341 		mutex_exit(cport_mutex);
9342 		return (rval);
9343 	}
9344 
9345 	/*
9346 	 * ATAPI device executes some ATA commands in addition to those
9347 	 * commands sent via PACKET command. These ATA commands may be
9348 	 * executed by the regular SATA translation functions. None needs
9349 	 * to be captured now.
9350 	 *
9351 	 * Commands sent via PACKET command include:
9352 	 *	MMC command set for ATAPI CD/DVD device
9353 	 *	SSC command set for ATAPI TAPE device
9354 	 *	SBC command set for ATAPI disk device
9355 	 *
9356 	 */
9357 
9358 	/* Check the size of cdb */
9359 
9360 	switch (GETGROUP(cdbp)) {
9361 	case CDB_GROUPID_3:   /* Reserved, per SPC-4 */
9362 		/*
9363 		 * opcodes 0x7e and 0x7f identify variable-length CDBs and
9364 		 * therefore require special handling.  Return failure, for now.
9365 		 */
9366 		mutex_exit(cport_mutex);
9367 		return (TRAN_BADPKT);
9368 
9369 	case CDB_GROUPID_6:   /* Vendor-specific, per SPC-4 */
9370 	case CDB_GROUPID_7:   /* Vendor-specific, per SPC-4 */
9371 		/* obtain length from the scsi_pkt */
9372 		cdblen = scsipkt->pkt_cdblen;
9373 		break;
9374 
9375 	default:
9376 		/* CDB's length is statically known, per SPC-4 */
9377 		cdblen = scsi_cdb_size[GETGROUP(cdbp)];
9378 		break;
9379 	}
9380 
9381 	if (cdblen <= 0 || cdblen > sdinfo->satadrv_atapi_cdb_len) {
9382 		sata_log(NULL, CE_WARN,
9383 		    "sata: invalid ATAPI cdb length %d",
9384 		    cdblen);
9385 		mutex_exit(cport_mutex);
9386 		return (TRAN_BADPKT);
9387 	}
9388 
9389 	SATAATAPITRACE(spx, cdblen);
9390 
9391 	/*
9392 	 * For non-read/write commands we need to
9393 	 * map buffer
9394 	 */
9395 	switch ((uint_t)scsipkt->pkt_cdbp[0]) {
9396 	case SCMD_READ:
9397 	case SCMD_READ_G1:
9398 	case SCMD_READ_G5:
9399 	case SCMD_READ_G4:
9400 	case SCMD_WRITE:
9401 	case SCMD_WRITE_G1:
9402 	case SCMD_WRITE_G5:
9403 	case SCMD_WRITE_G4:
9404 		break;
9405 	default:
9406 		if (bp != NULL) {
9407 			if (bp->b_flags & (B_PHYS | B_PAGEIO))
9408 				bp_mapin(bp);
9409 		}
9410 		break;
9411 	}
9412 	/*
9413 	 * scmd->satacmd_flags.sata_data_direction default -
9414 	 * SATA_DIR_NODATA_XFER - is set by
9415 	 * sata_txlt_generic_pkt_info().
9416 	 */
9417 	if (scmd->satacmd_bp) {
9418 		if (scmd->satacmd_bp->b_flags & B_READ) {
9419 			scmd->satacmd_flags.sata_data_direction = SATA_DIR_READ;
9420 		} else {
9421 			scmd->satacmd_flags.sata_data_direction =
9422 			    SATA_DIR_WRITE;
9423 		}
9424 	}
9425 
9426 	/*
9427 	 * Set up ATAPI packet command.
9428 	 */
9429 
9430 	sata_atapi_packet_cmd_setup(scmd, sdinfo);
9431 
9432 	/* Copy cdb into sata_cmd */
9433 	scmd->satacmd_acdb_len = sdinfo->satadrv_atapi_cdb_len;
9434 	bzero(scmd->satacmd_acdb, SATA_ATAPI_MAX_CDB_LEN);
9435 	bcopy(cdbp, scmd->satacmd_acdb, cdblen);
9436 
9437 	/* See note in the command header */
9438 	if (scmd->satacmd_acdb[0] == SCMD_INQUIRY) {
9439 		if (scmd->satacmd_acdb[3] != 0)
9440 			scmd->satacmd_acdb[4] = 255;
9441 	}
9442 
9443 #ifdef SATA_DEBUG
9444 	if (sata_debug_flags & SATA_DBG_ATAPI) {
9445 		uint8_t *p = scmd->satacmd_acdb;
9446 		char buf[3 * SATA_ATAPI_MAX_CDB_LEN];
9447 
9448 		(void) snprintf(buf, SATA_ATAPI_MAX_CDB_LEN,
9449 		    "%02x %02x %02x %02x %02x %02x %02x %02x "
9450 		    "%2x %02x %02x %02x %02x %02x %02x %02x",
9451 		    p[0], p[1], p[2], p[3], p[4], p[5], p[6], p[7],
9452 		    p[8], p[9], p[10], p[11], p[12], p[13], p[14], p[15]);
9453 		buf[(3 * SATA_ATAPI_MAX_CDB_LEN) - 1] = '\0';
9454 		cmn_err(CE_NOTE, "ATAPI cdb: %s\n", buf);
9455 	}
9456 #endif
9457 
9458 	/*
9459 	 * Preset request sense data to NO SENSE.
9460 	 * If there is no way to get error information via Request Sense,
9461 	 * the packet request sense data would not have to be modified by HBA,
9462 	 * but it could be returned as is.
9463 	 */
9464 	bzero(scmd->satacmd_rqsense, SATA_ATAPI_RQSENSE_LEN);
9465 	sata_fixed_sense_data_preset(
9466 	    (struct scsi_extended_sense *)scmd->satacmd_rqsense);
9467 
9468 	if (!(spx->txlt_sata_pkt->satapkt_op_mode & SATA_OPMODE_SYNCH)) {
9469 		/* Need callback function */
9470 		spx->txlt_sata_pkt->satapkt_comp = sata_txlt_atapi_completion;
9471 		synch = FALSE;
9472 	} else
9473 		synch = TRUE;
9474 
9475 	/* Transfer command to HBA */
9476 	if (sata_hba_start(spx, &rval) != 0) {
9477 		/* Pkt not accepted for execution */
9478 		mutex_exit(cport_mutex);
9479 		return (rval);
9480 	}
9481 	mutex_exit(cport_mutex);
9482 	/*
9483 	 * If execution is non-synchronous,
9484 	 * a callback function will handle potential errors, translate
9485 	 * the response and will do a callback to a target driver.
9486 	 * If it was synchronous, use the same framework callback to check
9487 	 * an execution status.
9488 	 */
9489 	if (synch) {
9490 		SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst,
9491 		    "synchronous execution status %x\n",
9492 		    spx->txlt_sata_pkt->satapkt_reason);
9493 		sata_txlt_atapi_completion(spx->txlt_sata_pkt);
9494 	}
9495 	return (TRAN_ACCEPT);
9496 }
9497 
9498 
9499 /*
9500  * ATAPI Packet command completion.
9501  *
9502  * Failure of the command passed via Packet command are considered device
9503  * error. SATA HBA driver would have to retrieve error data (via Request
9504  * Sense command delivered via error retrieval sata packet) and copy it
9505  * to satacmd_rqsense array. From there, it is moved into scsi pkt sense data.
9506  */
9507 static void
9508 sata_txlt_atapi_completion(sata_pkt_t *sata_pkt)
9509 {
9510 	sata_pkt_txlate_t *spx =
9511 	    (sata_pkt_txlate_t *)sata_pkt->satapkt_framework_private;
9512 	struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt;
9513 	struct scsi_extended_sense *sense;
9514 	struct buf *bp;
9515 	int rval;
9516 
9517 #ifdef SATA_DEBUG
9518 	uint8_t *rqsp = sata_pkt->satapkt_cmd.satacmd_rqsense;
9519 #endif
9520 
9521 	scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET |
9522 	    STATE_SENT_CMD | STATE_GOT_STATUS;
9523 
9524 	if (sata_pkt->satapkt_reason == SATA_PKT_COMPLETED) {
9525 		/* Normal completion */
9526 		if (sata_pkt->satapkt_cmd.satacmd_bp != NULL)
9527 			scsipkt->pkt_state |= STATE_XFERRED_DATA;
9528 		scsipkt->pkt_reason = CMD_CMPLT;
9529 		*scsipkt->pkt_scbp = STATUS_GOOD;
9530 		if (spx->txlt_tmp_buf != NULL) {
9531 			/* Temporary buffer was used */
9532 			bp = spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp;
9533 			if (bp->b_flags & B_READ) {
9534 				rval = ddi_dma_sync(
9535 				    spx->txlt_buf_dma_handle, 0, 0,
9536 				    DDI_DMA_SYNC_FORCPU);
9537 				ASSERT(rval == DDI_SUCCESS);
9538 				bcopy(spx->txlt_tmp_buf, bp->b_un.b_addr,
9539 				    bp->b_bcount);
9540 			}
9541 		}
9542 	} else {
9543 		/*
9544 		 * Something went wrong - analyze return
9545 		 */
9546 		*scsipkt->pkt_scbp = STATUS_CHECK;
9547 		sense = sata_arq_sense(spx);
9548 
9549 		if (sata_pkt->satapkt_reason == SATA_PKT_DEV_ERROR) {
9550 			/*
9551 			 * pkt_reason should be CMD_CMPLT for DEVICE ERROR.
9552 			 * Under this condition ERR bit is set for ATA command,
9553 			 * and CHK bit set for ATAPI command.
9554 			 *
9555 			 * Please check st_intr & sdintr about how pkt_reason
9556 			 * is used.
9557 			 */
9558 			scsipkt->pkt_reason = CMD_CMPLT;
9559 
9560 			/*
9561 			 * We may not have ARQ data if there was a double
9562 			 * error. But sense data in sata packet was pre-set
9563 			 * with NO SENSE so it is valid even if HBA could
9564 			 * not retrieve a real sense data.
9565 			 * Just copy this sense data into scsi pkt sense area.
9566 			 */
9567 			bcopy(sata_pkt->satapkt_cmd.satacmd_rqsense, sense,
9568 			    SATA_ATAPI_MIN_RQSENSE_LEN);
9569 #ifdef SATA_DEBUG
9570 			if (sata_debug_flags & SATA_DBG_SCSI_IF) {
9571 				sata_log(spx->txlt_sata_hba_inst, CE_WARN,
9572 				    "sata_txlt_atapi_completion: %02x\n"
9573 				    "RQSENSE:  %02x %02x %02x %02x %02x %02x "
9574 				    "          %02x %02x %02x %02x %02x %02x "
9575 				    "          %02x %02x %02x %02x %02x %02x\n",
9576 				    scsipkt->pkt_reason,
9577 				    rqsp[0], rqsp[1], rqsp[2], rqsp[3],
9578 				    rqsp[4], rqsp[5], rqsp[6], rqsp[7],
9579 				    rqsp[8], rqsp[9], rqsp[10], rqsp[11],
9580 				    rqsp[12], rqsp[13], rqsp[14], rqsp[15],
9581 				    rqsp[16], rqsp[17]);
9582 			}
9583 #endif
9584 		} else {
9585 			switch (sata_pkt->satapkt_reason) {
9586 			case SATA_PKT_PORT_ERROR:
9587 				/*
9588 				 * We have no device data.
9589 				 */
9590 				scsipkt->pkt_reason = CMD_INCOMPLETE;
9591 				scsipkt->pkt_state &= ~(STATE_GOT_BUS |
9592 				    STATE_GOT_TARGET | STATE_SENT_CMD |
9593 				    STATE_GOT_STATUS);
9594 				sense->es_key = KEY_HARDWARE_ERROR;
9595 				break;
9596 
9597 			case SATA_PKT_TIMEOUT:
9598 				scsipkt->pkt_reason = CMD_TIMEOUT;
9599 				scsipkt->pkt_statistics |=
9600 				    STAT_TIMEOUT | STAT_DEV_RESET;
9601 				/*
9602 				 * Need to check if HARDWARE_ERROR/
9603 				 * TIMEOUT_ON_LOGICAL_UNIT 4/3E/2 would be more
9604 				 * appropriate.
9605 				 */
9606 				break;
9607 
9608 			case SATA_PKT_ABORTED:
9609 				scsipkt->pkt_reason = CMD_ABORTED;
9610 				scsipkt->pkt_statistics |= STAT_ABORTED;
9611 				/* Should we set key COMMAND_ABPRTED? */
9612 				break;
9613 
9614 			case SATA_PKT_RESET:
9615 				scsipkt->pkt_reason = CMD_RESET;
9616 				scsipkt->pkt_statistics |= STAT_DEV_RESET;
9617 				/*
9618 				 * May be we should set Unit Attention /
9619 				 * Reset. Perhaps the same should be
9620 				 * returned for disks....
9621 				 */
9622 				sense->es_key = KEY_UNIT_ATTENTION;
9623 				sense->es_add_code = SD_SCSI_ASC_RESET;
9624 				break;
9625 
9626 			default:
9627 				SATA_LOG_D((spx->txlt_sata_hba_inst, CE_WARN,
9628 				    "sata_txlt_atapi_completion: "
9629 				    "invalid packet completion reason"));
9630 				scsipkt->pkt_reason = CMD_TRAN_ERR;
9631 				scsipkt->pkt_state &= ~(STATE_GOT_BUS |
9632 				    STATE_GOT_TARGET | STATE_SENT_CMD |
9633 				    STATE_GOT_STATUS);
9634 				break;
9635 			}
9636 		}
9637 	}
9638 
9639 	SATAATAPITRACE(spx, 0);
9640 
9641 	if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0 &&
9642 	    scsipkt->pkt_comp != NULL) {
9643 		/* scsi callback required */
9644 		(*scsipkt->pkt_comp)(scsipkt);
9645 	}
9646 }
9647 
9648 /*
9649  * Set up error retrieval sata command for ATAPI Packet Command error data
9650  * recovery.
9651  *
9652  * Returns SATA_SUCCESS when data buffer is allocated and packet set-up,
9653  * returns SATA_FAILURE otherwise.
9654  */
9655 
9656 static int
9657 sata_atapi_err_ret_cmd_setup(sata_pkt_txlate_t *spx, sata_drive_info_t *sdinfo)
9658 {
9659 	sata_pkt_t *spkt = spx->txlt_sata_pkt;
9660 	sata_cmd_t *scmd;
9661 	struct buf *bp;
9662 
9663 	/*
9664 	 * Allocate dma-able buffer error data.
9665 	 * Buffer allocation will take care of buffer alignment and other DMA
9666 	 * attributes.
9667 	 */
9668 	bp = sata_alloc_local_buffer(spx, SATA_ATAPI_MIN_RQSENSE_LEN);
9669 	if (bp == NULL) {
9670 		SATADBG1(SATA_DBG_ATAPI, spx->txlt_sata_hba_inst,
9671 		    "sata_get_err_retrieval_pkt: "
9672 		    "cannot allocate buffer for error data", NULL);
9673 		return (SATA_FAILURE);
9674 	}
9675 	bp_mapin(bp); /* make data buffer accessible */
9676 
9677 	/* Operation modes are up to the caller */
9678 	spkt->satapkt_op_mode = SATA_OPMODE_SYNCH | SATA_OPMODE_INTERRUPTS;
9679 
9680 	/* Synchronous mode, no callback - may be changed by the caller */
9681 	spkt->satapkt_comp = NULL;
9682 	spkt->satapkt_time = sata_default_pkt_time;
9683 
9684 	scmd = &spkt->satapkt_cmd;
9685 	scmd->satacmd_flags.sata_data_direction = SATA_DIR_READ;
9686 	scmd->satacmd_flags.sata_ignore_dev_reset = B_TRUE;
9687 
9688 	sata_atapi_packet_cmd_setup(scmd, sdinfo);
9689 
9690 	/*
9691 	 * Set-up acdb. Request Sense CDB (packet command content) is
9692 	 * not in DMA-able buffer. Its handling is HBA-specific (how
9693 	 * it is transfered into packet FIS).
9694 	 */
9695 	scmd->satacmd_acdb_len = sdinfo->satadrv_atapi_cdb_len;
9696 	bcopy(sata_rqsense_cdb, scmd->satacmd_acdb, SATA_ATAPI_RQSENSE_CDB_LEN);
9697 	/* Following zeroing of pad bytes may not be necessary */
9698 	bzero(&scmd->satacmd_acdb[SATA_ATAPI_RQSENSE_CDB_LEN],
9699 	    sdinfo->satadrv_atapi_cdb_len - SATA_ATAPI_RQSENSE_CDB_LEN);
9700 
9701 	/*
9702 	 * Set-up pointer to the buffer handle, so HBA can sync buffer
9703 	 * before accessing it. Handle is in usual place in translate struct.
9704 	 */
9705 	scmd->satacmd_err_ret_buf_handle = &spx->txlt_buf_dma_handle;
9706 
9707 	/*
9708 	 * Preset request sense data to NO SENSE.
9709 	 * Here it is redundant, only for a symetry with scsi-originated
9710 	 * packets. It should not be used for anything but debugging.
9711 	 */
9712 	bzero(scmd->satacmd_rqsense, SATA_ATAPI_RQSENSE_LEN);
9713 	sata_fixed_sense_data_preset(
9714 	    (struct scsi_extended_sense *)scmd->satacmd_rqsense);
9715 
9716 	ASSERT(scmd->satacmd_num_dma_cookies != 0);
9717 	ASSERT(scmd->satacmd_dma_cookie_list != NULL);
9718 
9719 	return (SATA_SUCCESS);
9720 }
9721 
9722 /*
9723  * Set-up ATAPI packet command.
9724  * Data transfer direction has to be set-up in sata_cmd structure prior to
9725  * calling this function.
9726  *
9727  * Returns void
9728  */
9729 
9730 static void
9731 sata_atapi_packet_cmd_setup(sata_cmd_t *scmd, sata_drive_info_t *sdinfo)
9732 {
9733 	scmd->satacmd_addr_type = 0;		/* N/A */
9734 	scmd->satacmd_sec_count_lsb = 0;	/* no tag */
9735 	scmd->satacmd_lba_low_lsb = 0;		/* N/A */
9736 	scmd->satacmd_lba_mid_lsb = (uint8_t)SATA_ATAPI_MAX_BYTES_PER_DRQ;
9737 	scmd->satacmd_lba_high_lsb =
9738 	    (uint8_t)(SATA_ATAPI_MAX_BYTES_PER_DRQ >> 8);
9739 	scmd->satacmd_cmd_reg = SATAC_PACKET;	/* Command */
9740 
9741 	/*
9742 	 * We want all data to be transfered via DMA.
9743 	 * But specify it only if drive supports DMA and DMA mode is
9744 	 * selected - some drives are sensitive about it.
9745 	 * Hopefully it wil work for all drives....
9746 	 */
9747 	if (sdinfo->satadrv_settings & SATA_DEV_DMA)
9748 		scmd->satacmd_features_reg = SATA_ATAPI_F_DMA;
9749 
9750 	/*
9751 	 * Features register requires special care for devices that use
9752 	 * Serial ATA bridge - they need an explicit specification of
9753 	 * the data transfer direction for Packet DMA commands.
9754 	 * Setting this bit is harmless if DMA is not used.
9755 	 *
9756 	 * Many drives do not implement word 80, specifying what ATA/ATAPI
9757 	 * spec they follow.
9758 	 * We are arbitrarily following the latest SerialATA 2.6 spec,
9759 	 * which uses ATA/ATAPI 6 specification for Identify Data, unless
9760 	 * ATA/ATAPI-7 support is explicitly indicated.
9761 	 */
9762 	if (sdinfo->satadrv_id.ai_majorversion != 0 &&
9763 	    sdinfo->satadrv_id.ai_majorversion != 0xffff &&
9764 	    (sdinfo->satadrv_id.ai_majorversion & SATA_MAJVER_7) != 0) {
9765 		/*
9766 		 * Specification of major version is valid and version 7
9767 		 * is supported. It does automatically imply that all
9768 		 * spec features are supported. For now, we assume that
9769 		 * DMADIR setting is valid. ATA/ATAPI7 spec is incomplete.
9770 		 */
9771 		if ((sdinfo->satadrv_id.ai_dirdma &
9772 		    SATA_ATAPI_ID_DMADIR_REQ) != 0) {
9773 			if (scmd->satacmd_flags.sata_data_direction ==
9774 			    SATA_DIR_READ)
9775 			scmd->satacmd_features_reg |=
9776 			    SATA_ATAPI_F_DATA_DIR_READ;
9777 		}
9778 	}
9779 }
9780 
9781 
9782 #ifdef SATA_DEBUG
9783 
9784 /* Display 18 bytes of Inquiry data */
9785 static void
9786 sata_show_inqry_data(uint8_t *buf)
9787 {
9788 	struct scsi_inquiry *inq = (struct scsi_inquiry *)buf;
9789 	uint8_t *p;
9790 
9791 	cmn_err(CE_NOTE, "Inquiry data:");
9792 	cmn_err(CE_NOTE, "device type %x", inq->inq_dtype);
9793 	cmn_err(CE_NOTE, "removable media %x", inq->inq_rmb);
9794 	cmn_err(CE_NOTE, "version %x", inq->inq_ansi);
9795 	cmn_err(CE_NOTE, "ATAPI transport version %d",
9796 	    SATA_ATAPI_TRANS_VERSION(inq));
9797 	cmn_err(CE_NOTE, "response data format %d, aenc %d",
9798 	    inq->inq_rdf, inq->inq_aenc);
9799 	cmn_err(CE_NOTE, " additional length %d", inq->inq_len);
9800 	cmn_err(CE_NOTE, "tpgs %d", inq->inq_tpgs);
9801 	p = (uint8_t *)inq->inq_vid;
9802 	cmn_err(CE_NOTE, "vendor id (binary): %02x %02x %02x %02x "
9803 	    "%02x %02x %02x %02x",
9804 	    p[0], p[1], p[2], p[3], p[4], p[5], p[6], p[7]);
9805 	p = (uint8_t *)inq->inq_vid;
9806 	cmn_err(CE_NOTE, "vendor id: %c %c %c %c %c %c %c %c",
9807 	    p[0], p[1], p[2], p[3], p[4], p[5], p[6], p[7]);
9808 
9809 	p = (uint8_t *)inq->inq_pid;
9810 	cmn_err(CE_NOTE, "product id (binary): %02x %02x %02x %02x "
9811 	    "%02x %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x",
9812 	    p[0], p[1], p[2], p[3], p[4], p[5], p[6], p[7],
9813 	    p[8], p[9], p[10], p[11], p[12], p[13], p[14], p[15]);
9814 	p = (uint8_t *)inq->inq_pid;
9815 	cmn_err(CE_NOTE, "product id: %c %c %c %c %c %c %c %c "
9816 	    "%c %c %c %c %c %c %c %c",
9817 	    p[0], p[1], p[2], p[3], p[4], p[5], p[6], p[7],
9818 	    p[8], p[9], p[10], p[11], p[12], p[13], p[14], p[15]);
9819 
9820 	p = (uint8_t *)inq->inq_revision;
9821 	cmn_err(CE_NOTE, "revision (binary): %02x %02x %02x %02x",
9822 	    p[0], p[1], p[2], p[3]);
9823 	p = (uint8_t *)inq->inq_revision;
9824 	cmn_err(CE_NOTE, "revision: %c %c %c %c",
9825 	    p[0], p[1], p[2], p[3]);
9826 
9827 }
9828 
9829 
9830 static void
9831 sata_save_atapi_trace(sata_pkt_txlate_t *spx, int count)
9832 {
9833 	struct scsi_pkt *scsi_pkt = spx->txlt_scsi_pkt;
9834 
9835 	if (scsi_pkt == NULL)
9836 		return;
9837 	if (count != 0) {
9838 		/* saving cdb */
9839 		bzero(sata_atapi_trace[sata_atapi_trace_index].acdb,
9840 		    SATA_ATAPI_MAX_CDB_LEN);
9841 		bcopy(scsi_pkt->pkt_cdbp,
9842 		    sata_atapi_trace[sata_atapi_trace_index].acdb, count);
9843 	} else {
9844 		bcopy(&((struct scsi_arq_status *)scsi_pkt->pkt_scbp)->
9845 		    sts_sensedata,
9846 		    sata_atapi_trace[sata_atapi_trace_index].arqs,
9847 		    SATA_ATAPI_MIN_RQSENSE_LEN);
9848 		sata_atapi_trace[sata_atapi_trace_index].scsi_pkt_reason =
9849 		    scsi_pkt->pkt_reason;
9850 		sata_atapi_trace[sata_atapi_trace_index].sata_pkt_reason =
9851 		    spx->txlt_sata_pkt->satapkt_reason;
9852 
9853 		if (++sata_atapi_trace_index >= 64)
9854 			sata_atapi_trace_index = 0;
9855 	}
9856 }
9857 
9858 #endif
9859 
9860 /*
9861  * Fetch inquiry data from ATAPI device
9862  * Returns SATA_SUCCESS if operation was successful, SATA_FAILURE otherwise.
9863  *
9864  * Note:
9865  * inqb pointer does not point to a DMA-able buffer. It is a local buffer
9866  * where the caller expects to see the inquiry data.
9867  *
9868  */
9869 
9870 static int
9871 sata_get_atapi_inquiry_data(sata_hba_inst_t *sata_hba,
9872     sata_address_t *saddr, struct scsi_inquiry *inq)
9873 {
9874 	sata_pkt_txlate_t *spx;
9875 	sata_pkt_t *spkt;
9876 	struct buf *bp;
9877 	sata_drive_info_t *sdinfo;
9878 	sata_cmd_t *scmd;
9879 	int rval;
9880 	uint8_t *rqsp;
9881 	dev_info_t *dip = SATA_DIP(sata_hba);
9882 #ifdef SATA_DEBUG
9883 	char msg_buf[MAXPATHLEN];
9884 #endif
9885 	kmutex_t *cport_mutex;
9886 
9887 	ASSERT(sata_hba != NULL);
9888 
9889 	spx = kmem_zalloc(sizeof (sata_pkt_txlate_t), KM_SLEEP);
9890 	spx->txlt_sata_hba_inst = sata_hba;
9891 	spx->txlt_scsi_pkt = NULL;		/* No scsi pkt involved */
9892 	spkt = sata_pkt_alloc(spx, NULL);
9893 	if (spkt == NULL) {
9894 		kmem_free(spx, sizeof (sata_pkt_txlate_t));
9895 		return (SATA_FAILURE);
9896 	}
9897 	/* address is needed now */
9898 	spkt->satapkt_device.satadev_addr = *saddr;
9899 
9900 	/* scsi_inquiry size buffer */
9901 	bp = sata_alloc_local_buffer(spx, sizeof (struct scsi_inquiry));
9902 	if (bp == NULL) {
9903 		sata_pkt_free(spx);
9904 		kmem_free(spx, sizeof (sata_pkt_txlate_t));
9905 		SATA_LOG_D((sata_hba, CE_WARN,
9906 		    "sata_get_atapi_inquiry_data: "
9907 		    "cannot allocate data buffer"));
9908 		return (SATA_FAILURE);
9909 	}
9910 	bp_mapin(bp); /* make data buffer accessible */
9911 
9912 	scmd = &spkt->satapkt_cmd;
9913 	ASSERT(scmd->satacmd_num_dma_cookies != 0);
9914 	ASSERT(scmd->satacmd_dma_cookie_list != NULL);
9915 
9916 	/* Use synchronous mode */
9917 	spkt->satapkt_op_mode = SATA_OPMODE_SYNCH | SATA_OPMODE_INTERRUPTS;
9918 	spkt->satapkt_comp = NULL;
9919 	spkt->satapkt_time = sata_default_pkt_time;
9920 
9921 	/* Issue inquiry command - 6 bytes cdb, data transfer, read */
9922 
9923 	scmd->satacmd_flags.sata_data_direction = SATA_DIR_READ;
9924 	scmd->satacmd_flags.sata_ignore_dev_reset = B_TRUE;
9925 
9926 	cport_mutex = &(SATA_CPORT_MUTEX(sata_hba, saddr->cport));
9927 	mutex_enter(cport_mutex);
9928 	sdinfo = sata_get_device_info(sata_hba,
9929 	    &spx->txlt_sata_pkt->satapkt_device);
9930 	if (sdinfo == NULL) {
9931 		/* we have to be carefull about the disapearing device */
9932 		mutex_exit(cport_mutex);
9933 		rval = SATA_FAILURE;
9934 		goto cleanup;
9935 	}
9936 	sata_atapi_packet_cmd_setup(scmd, sdinfo);
9937 
9938 	/*
9939 	 * Set-up acdb. This works for atapi transport version 2 and later.
9940 	 */
9941 	scmd->satacmd_acdb_len = sdinfo->satadrv_atapi_cdb_len;
9942 	bzero(scmd->satacmd_acdb, SATA_ATAPI_MAX_CDB_LEN);
9943 	scmd->satacmd_acdb[0] = 0x12;	/* Inquiry */
9944 	scmd->satacmd_acdb[1] = 0x00;
9945 	scmd->satacmd_acdb[2] = 0x00;
9946 	scmd->satacmd_acdb[3] = 0x00;
9947 	scmd->satacmd_acdb[4] = sizeof (struct scsi_inquiry);
9948 	scmd->satacmd_acdb[5] = 0x00;
9949 
9950 	sata_fixed_sense_data_preset(
9951 	    (struct scsi_extended_sense *)scmd->satacmd_rqsense);
9952 
9953 	/* Transfer command to HBA */
9954 	if (sata_hba_start(spx, &rval) != 0) {
9955 		/* Pkt not accepted for execution */
9956 		SATADBG1(SATA_DBG_ATAPI, sata_hba,
9957 		    "sata_get_atapi_inquiry_data: "
9958 		    "Packet not accepted for execution - ret: %02x", rval);
9959 		mutex_exit(cport_mutex);
9960 		rval = SATA_FAILURE;
9961 		goto cleanup;
9962 	}
9963 	mutex_exit(cport_mutex);
9964 
9965 	if (spkt->satapkt_reason == SATA_PKT_COMPLETED) {
9966 		SATADBG1(SATA_DBG_ATAPI, sata_hba,
9967 		    "sata_get_atapi_inquiry_data: "
9968 		    "Packet completed successfully - ret: %02x", rval);
9969 		if (spx->txlt_buf_dma_handle != NULL) {
9970 			/*
9971 			 * Sync buffer. Handle is in usual place in translate
9972 			 * struct.
9973 			 */
9974 			rval = ddi_dma_sync(spx->txlt_buf_dma_handle, 0, 0,
9975 			    DDI_DMA_SYNC_FORCPU);
9976 			ASSERT(rval == DDI_SUCCESS);
9977 		}
9978 
9979 		if (sata_check_for_dma_error(dip, spx)) {
9980 			ddi_fm_service_impact(dip, DDI_SERVICE_UNAFFECTED);
9981 			rval = SATA_FAILURE;
9982 		} else {
9983 			/*
9984 			 * Normal completion - copy data into caller's buffer
9985 			 */
9986 			bcopy(bp->b_un.b_addr, (uint8_t *)inq,
9987 			    sizeof (struct scsi_inquiry));
9988 #ifdef SATA_DEBUG
9989 			if (sata_debug_flags & SATA_DBG_ATAPI) {
9990 				sata_show_inqry_data((uint8_t *)inq);
9991 			}
9992 #endif
9993 			rval = SATA_SUCCESS;
9994 		}
9995 	} else {
9996 		/*
9997 		 * Something went wrong - analyze return - check rqsense data
9998 		 */
9999 		rval = SATA_FAILURE;
10000 		if (spkt->satapkt_reason == SATA_PKT_DEV_ERROR) {
10001 			/*
10002 			 * ARQ data hopefull show something other than NO SENSE
10003 			 */
10004 			rqsp = scmd->satacmd_rqsense;
10005 #ifdef SATA_DEBUG
10006 			if (sata_debug_flags & SATA_DBG_ATAPI) {
10007 				msg_buf[0] = '\0';
10008 				(void) snprintf(msg_buf, MAXPATHLEN,
10009 				    "ATAPI packet completion reason: %02x\n"
10010 				    "RQSENSE:  %02x %02x %02x %02x %02x %02x\n"
10011 				    "          %02x %02x %02x %02x %02x %02x\n"
10012 				    "          %02x %02x %02x %02x %02x %02x",
10013 				    spkt->satapkt_reason,
10014 				    rqsp[0], rqsp[1], rqsp[2], rqsp[3],
10015 				    rqsp[4], rqsp[5], rqsp[6], rqsp[7],
10016 				    rqsp[8], rqsp[9], rqsp[10], rqsp[11],
10017 				    rqsp[12], rqsp[13], rqsp[14], rqsp[15],
10018 				    rqsp[16], rqsp[17]);
10019 				sata_log(spx->txlt_sata_hba_inst, CE_WARN,
10020 				    "%s", msg_buf);
10021 			}
10022 #endif
10023 		} else {
10024 			switch (spkt->satapkt_reason) {
10025 			case SATA_PKT_PORT_ERROR:
10026 				SATADBG1(SATA_DBG_ATAPI, sata_hba,
10027 				    "sata_get_atapi_inquiry_data: "
10028 				    "packet reason: port error", NULL);
10029 				break;
10030 
10031 			case SATA_PKT_TIMEOUT:
10032 				SATADBG1(SATA_DBG_ATAPI, sata_hba,
10033 				    "sata_get_atapi_inquiry_data: "
10034 				    "packet reason: timeout", NULL);
10035 				break;
10036 
10037 			case SATA_PKT_ABORTED:
10038 				SATADBG1(SATA_DBG_ATAPI, sata_hba,
10039 				    "sata_get_atapi_inquiry_data: "
10040 				    "packet reason: aborted", NULL);
10041 				break;
10042 
10043 			case SATA_PKT_RESET:
10044 				SATADBG1(SATA_DBG_ATAPI, sata_hba,
10045 				    "sata_get_atapi_inquiry_data: "
10046 				    "packet reason: reset\n", NULL);
10047 				break;
10048 			default:
10049 				SATADBG1(SATA_DBG_ATAPI, sata_hba,
10050 				    "sata_get_atapi_inquiry_data: "
10051 				    "invalid packet reason: %02x\n",
10052 				    spkt->satapkt_reason);
10053 				break;
10054 			}
10055 		}
10056 	}
10057 cleanup:
10058 	sata_free_local_buffer(spx);
10059 	sata_pkt_free(spx);
10060 	kmem_free(spx, sizeof (sata_pkt_txlate_t));
10061 	return (rval);
10062 }
10063 
10064 
10065 
10066 
10067 
10068 #if 0
10069 #ifdef SATA_DEBUG
10070 
10071 /*
10072  * Test ATAPI packet command.
10073  * Single threaded test: send packet command in synch mode, process completion
10074  *
10075  */
10076 static void
10077 sata_test_atapi_packet_command(sata_hba_inst_t *sata_hba_inst, int cport)
10078 {
10079 	sata_pkt_txlate_t *spx;
10080 	sata_pkt_t *spkt;
10081 	struct buf *bp;
10082 	sata_device_t sata_device;
10083 	sata_drive_info_t *sdinfo;
10084 	sata_cmd_t *scmd;
10085 	int rval;
10086 	uint8_t *rqsp;
10087 
10088 	ASSERT(sata_hba_inst != NULL);
10089 	sata_device.satadev_addr.cport = cport;
10090 	sata_device.satadev_addr.pmport = 0;
10091 	sata_device.satadev_addr.qual = SATA_ADDR_DCPORT;
10092 	sata_device.satadev_rev = SATA_DEVICE_REV;
10093 	mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex);
10094 	sdinfo = sata_get_device_info(sata_hba_inst, &sata_device);
10095 	mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex);
10096 	if (sdinfo == NULL) {
10097 		sata_log(sata_hba_inst, CE_WARN,
10098 		    "sata_test_atapi_packet_command: "
10099 		    "no device info for cport %d",
10100 		    sata_device.satadev_addr.cport);
10101 		return;
10102 	}
10103 
10104 	spx = kmem_zalloc(sizeof (sata_pkt_txlate_t), KM_SLEEP);
10105 	spx->txlt_sata_hba_inst = sata_hba_inst;
10106 	spx->txlt_scsi_pkt = NULL;		/* No scsi pkt involved */
10107 	spkt = sata_pkt_alloc(spx, NULL);
10108 	if (spkt == NULL) {
10109 		kmem_free(spx, sizeof (sata_pkt_txlate_t));
10110 		return;
10111 	}
10112 	/* address is needed now */
10113 	spkt->satapkt_device.satadev_addr = sata_device.satadev_addr;
10114 
10115 	/* 1024k buffer */
10116 	bp = sata_alloc_local_buffer(spx, 1024);
10117 	if (bp == NULL) {
10118 		sata_pkt_free(spx);
10119 		kmem_free(spx, sizeof (sata_pkt_txlate_t));
10120 		sata_log(sata_hba_inst, CE_WARN,
10121 		    "sata_test_atapi_packet_command: "
10122 		    "cannot allocate data buffer");
10123 		return;
10124 	}
10125 	bp_mapin(bp); /* make data buffer accessible */
10126 
10127 	scmd = &spkt->satapkt_cmd;
10128 	ASSERT(scmd->satacmd_num_dma_cookies != 0);
10129 	ASSERT(scmd->satacmd_dma_cookie_list != NULL);
10130 
10131 	/* Use synchronous mode */
10132 	spkt->satapkt_op_mode = SATA_OPMODE_SYNCH | SATA_OPMODE_INTERRUPTS;
10133 
10134 	/* Synchronous mode, no callback - may be changed by the caller */
10135 	spkt->satapkt_comp = NULL;
10136 	spkt->satapkt_time = sata_default_pkt_time;
10137 
10138 	/* Issue inquiry command - 6 bytes cdb, data transfer, read */
10139 
10140 	scmd->satacmd_flags.sata_data_direction = SATA_DIR_READ;
10141 	scmd->satacmd_flags.sata_ignore_dev_reset = B_TRUE;
10142 
10143 	sata_atapi_packet_cmd_setup(scmd, sdinfo);
10144 
10145 	/* Set-up acdb. */
10146 	scmd->satacmd_acdb_len = sdinfo->satadrv_atapi_cdb_len;
10147 	bzero(scmd->satacmd_acdb, SATA_ATAPI_MAX_CDB_LEN);
10148 	scmd->satacmd_acdb[0] = 0x12;	/* Inquiry */
10149 	scmd->satacmd_acdb[1] = 0x00;
10150 	scmd->satacmd_acdb[2] = 0x00;
10151 	scmd->satacmd_acdb[3] = 0x00;
10152 	scmd->satacmd_acdb[4] = sizeof (struct scsi_inquiry);
10153 	scmd->satacmd_acdb[5] = 0x00;
10154 
10155 	sata_fixed_sense_data_preset(
10156 	    (struct scsi_extended_sense *)scmd->satacmd_rqsense);
10157 
10158 	/* Transfer command to HBA */
10159 	mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex);
10160 	if (sata_hba_start(spx, &rval) != 0) {
10161 		/* Pkt not accepted for execution */
10162 		sata_log(sata_hba_inst, CE_WARN,
10163 		    "sata_test_atapi_packet_command: "
10164 		    "Packet not accepted for execution - ret: %02x", rval);
10165 		mutex_exit(
10166 		    &SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex);
10167 		goto cleanup;
10168 	}
10169 	mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex);
10170 
10171 	if (spx->txlt_buf_dma_handle != NULL) {
10172 		/*
10173 		 * Sync buffer. Handle is in usual place in translate struct.
10174 		 */
10175 		rval = ddi_dma_sync(spx->txlt_buf_dma_handle, 0, 0,
10176 		    DDI_DMA_SYNC_FORCPU);
10177 		ASSERT(rval == DDI_SUCCESS);
10178 	}
10179 	if (spkt->satapkt_reason == SATA_PKT_COMPLETED) {
10180 		sata_log(sata_hba_inst, CE_WARN,
10181 		    "sata_test_atapi_packet_command: "
10182 		    "Packet completed successfully");
10183 		/*
10184 		 * Normal completion - show inquiry data
10185 		 */
10186 		sata_show_inqry_data((uint8_t *)bp->b_un.b_addr);
10187 	} else {
10188 		/*
10189 		 * Something went wrong - analyze return - check rqsense data
10190 		 */
10191 		if (spkt->satapkt_reason == SATA_PKT_DEV_ERROR) {
10192 			/*
10193 			 * ARQ data hopefull show something other than NO SENSE
10194 			 */
10195 			rqsp = scmd->satacmd_rqsense;
10196 			sata_log(spx->txlt_sata_hba_inst, CE_WARN,
10197 			    "ATAPI packet completion reason: %02x\n"
10198 			    "RQSENSE:  %02x %02x %02x %02x %02x %02x "
10199 			    "          %02x %02x %02x %02x %02x %02x "
10200 			    "          %02x %02x %02x %02x %02x %02x\n",
10201 			    spkt->satapkt_reason,
10202 			    rqsp[0], rqsp[1], rqsp[2], rqsp[3],
10203 			    rqsp[4], rqsp[5], rqsp[6], rqsp[7],
10204 			    rqsp[8], rqsp[9], rqsp[10], rqsp[11],
10205 			    rqsp[12], rqsp[13], rqsp[14], rqsp[15],
10206 			    rqsp[16], rqsp[17]);
10207 		} else {
10208 			switch (spkt->satapkt_reason) {
10209 			case SATA_PKT_PORT_ERROR:
10210 				sata_log(sata_hba_inst, CE_WARN,
10211 				    "sata_test_atapi_packet_command: "
10212 				    "packet reason: port error\n");
10213 				break;
10214 
10215 			case SATA_PKT_TIMEOUT:
10216 				sata_log(sata_hba_inst, CE_WARN,
10217 				    "sata_test_atapi_packet_command: "
10218 				    "packet reason: timeout\n");
10219 				break;
10220 
10221 			case SATA_PKT_ABORTED:
10222 				sata_log(sata_hba_inst, CE_WARN,
10223 				    "sata_test_atapi_packet_command: "
10224 				    "packet reason: aborted\n");
10225 				break;
10226 
10227 			case SATA_PKT_RESET:
10228 				sata_log(sata_hba_inst, CE_WARN,
10229 				    "sata_test_atapi_packet_command: "
10230 				    "packet reason: reset\n");
10231 				break;
10232 			default:
10233 				sata_log(sata_hba_inst, CE_WARN,
10234 				    "sata_test_atapi_packet_command: "
10235 				    "invalid packet reason: %02x\n",
10236 				    spkt->satapkt_reason);
10237 				break;
10238 			}
10239 		}
10240 	}
10241 cleanup:
10242 	sata_free_local_buffer(spx);
10243 	sata_pkt_free(spx);
10244 	kmem_free(spx, sizeof (sata_pkt_txlate_t));
10245 }
10246 
10247 #endif /* SATA_DEBUG */
10248 #endif /* 1 */
10249 
10250 
10251 /* ************************** LOCAL HELPER FUNCTIONS *********************** */
10252 
10253 /*
10254  * Validate sata_tran info
10255  * SATA_FAILURE returns if structure is inconsistent or structure revision
10256  * does not match one used by the framework.
10257  *
10258  * Returns SATA_SUCCESS if sata_hba_tran has matching revision and contains
10259  * required function pointers.
10260  * Returns SATA_FAILURE otherwise.
10261  */
10262 static int
10263 sata_validate_sata_hba_tran(dev_info_t *dip, sata_hba_tran_t *sata_tran)
10264 {
10265 	/*
10266 	 * SATA_TRAN_HBA_REV is the current (highest) revision number
10267 	 * of the SATA interface.
10268 	 */
10269 	if (sata_tran->sata_tran_hba_rev > SATA_TRAN_HBA_REV) {
10270 		sata_log(NULL, CE_WARN,
10271 		    "sata: invalid sata_hba_tran version %d for driver %s",
10272 		    sata_tran->sata_tran_hba_rev, ddi_driver_name(dip));
10273 		return (SATA_FAILURE);
10274 	}
10275 
10276 	if (dip != sata_tran->sata_tran_hba_dip) {
10277 		SATA_LOG_D((NULL, CE_WARN,
10278 		    "sata: inconsistent sata_tran_hba_dip "
10279 		    "%p / %p", sata_tran->sata_tran_hba_dip, dip));
10280 		return (SATA_FAILURE);
10281 	}
10282 
10283 	if (sata_tran->sata_tran_probe_port == NULL ||
10284 	    sata_tran->sata_tran_start == NULL ||
10285 	    sata_tran->sata_tran_abort == NULL ||
10286 	    sata_tran->sata_tran_reset_dport == NULL ||
10287 	    sata_tran->sata_tran_hotplug_ops == NULL ||
10288 	    sata_tran->sata_tran_hotplug_ops->sata_tran_port_activate == NULL ||
10289 	    sata_tran->sata_tran_hotplug_ops->sata_tran_port_deactivate ==
10290 	    NULL) {
10291 		SATA_LOG_D((NULL, CE_WARN, "sata: sata_hba_tran missing "
10292 		    "required functions"));
10293 	}
10294 	return (SATA_SUCCESS);
10295 }
10296 
10297 /*
10298  * Remove HBA instance from sata_hba_list.
10299  */
10300 static void
10301 sata_remove_hba_instance(dev_info_t *dip)
10302 {
10303 	sata_hba_inst_t	*sata_hba_inst;
10304 
10305 	mutex_enter(&sata_mutex);
10306 	for (sata_hba_inst = sata_hba_list;
10307 	    sata_hba_inst != (struct sata_hba_inst *)NULL;
10308 	    sata_hba_inst = sata_hba_inst->satahba_next) {
10309 		if (sata_hba_inst->satahba_dip == dip)
10310 			break;
10311 	}
10312 
10313 	if (sata_hba_inst == (struct sata_hba_inst *)NULL) {
10314 #ifdef SATA_DEBUG
10315 		cmn_err(CE_WARN, "sata_remove_hba_instance: "
10316 		    "unknown HBA instance\n");
10317 #endif
10318 		ASSERT(FALSE);
10319 	}
10320 	if (sata_hba_inst == sata_hba_list) {
10321 		sata_hba_list = sata_hba_inst->satahba_next;
10322 		if (sata_hba_list) {
10323 			sata_hba_list->satahba_prev =
10324 			    (struct sata_hba_inst *)NULL;
10325 		}
10326 		if (sata_hba_inst == sata_hba_list_tail) {
10327 			sata_hba_list_tail = NULL;
10328 		}
10329 	} else if (sata_hba_inst == sata_hba_list_tail) {
10330 		sata_hba_list_tail = sata_hba_inst->satahba_prev;
10331 		if (sata_hba_list_tail) {
10332 			sata_hba_list_tail->satahba_next =
10333 			    (struct sata_hba_inst *)NULL;
10334 		}
10335 	} else {
10336 		sata_hba_inst->satahba_prev->satahba_next =
10337 		    sata_hba_inst->satahba_next;
10338 		sata_hba_inst->satahba_next->satahba_prev =
10339 		    sata_hba_inst->satahba_prev;
10340 	}
10341 	mutex_exit(&sata_mutex);
10342 }
10343 
10344 /*
10345  * Probe all SATA ports of the specified HBA instance.
10346  * The assumption is that there are no target and attachment point minor nodes
10347  * created by the boot subsystems, so we do not need to prune device tree.
10348  *
10349  * This function is called only from sata_hba_attach(). It does not have to
10350  * be protected by controller mutex, because the hba_attached flag is not set
10351  * yet and no one would be touching this HBA instance other than this thread.
10352  * Determines if port is active and what type of the device is attached
10353  * (if any). Allocates necessary structures for each port.
10354  *
10355  * An AP (Attachement Point) node is created for each SATA device port even
10356  * when there is no device attached.
10357  */
10358 
10359 static 	void
10360 sata_probe_ports(sata_hba_inst_t *sata_hba_inst)
10361 {
10362 	dev_info_t		*dip = SATA_DIP(sata_hba_inst);
10363 	int			ncport;
10364 	sata_cport_info_t 	*cportinfo;
10365 	sata_drive_info_t	*drive;
10366 	sata_device_t		sata_device;
10367 	int			rval;
10368 	dev_t			minor_number;
10369 	char			name[16];
10370 	clock_t			start_time, cur_time;
10371 
10372 	/*
10373 	 * Probe controller ports first, to find port status and
10374 	 * any port multiplier attached.
10375 	 */
10376 	for (ncport = 0; ncport < SATA_NUM_CPORTS(sata_hba_inst); ncport++) {
10377 		/* allocate cport structure */
10378 		cportinfo = kmem_zalloc(sizeof (sata_cport_info_t), KM_SLEEP);
10379 		ASSERT(cportinfo != NULL);
10380 		mutex_init(&cportinfo->cport_mutex, NULL, MUTEX_DRIVER, NULL);
10381 
10382 		mutex_enter(&cportinfo->cport_mutex);
10383 
10384 		cportinfo->cport_addr.cport = ncport;
10385 		cportinfo->cport_addr.pmport = 0;
10386 		cportinfo->cport_addr.qual = SATA_ADDR_CPORT;
10387 		cportinfo->cport_state &= ~SATA_PORT_STATE_CLEAR_MASK;
10388 		cportinfo->cport_state |= SATA_STATE_PROBING;
10389 		SATA_CPORT_INFO(sata_hba_inst, ncport) = cportinfo;
10390 
10391 		/*
10392 		 * Regardless if a port is usable or not, create
10393 		 * an attachment point
10394 		 */
10395 		mutex_exit(&cportinfo->cport_mutex);
10396 		minor_number = SATA_MAKE_AP_MINOR(ddi_get_instance(dip),
10397 		    ncport, 0, SATA_ADDR_CPORT);
10398 		(void) sprintf(name, "%d", ncport);
10399 		if (ddi_create_minor_node(dip, name, S_IFCHR,
10400 		    minor_number, DDI_NT_SATA_ATTACHMENT_POINT, 0) !=
10401 		    DDI_SUCCESS) {
10402 			sata_log(sata_hba_inst, CE_WARN, "sata_hba_attach: "
10403 			    "cannot create SATA attachment point for port %d",
10404 			    ncport);
10405 		}
10406 
10407 		/* Probe port */
10408 		start_time = ddi_get_lbolt();
10409 	reprobe_cport:
10410 		sata_device.satadev_addr.cport = ncport;
10411 		sata_device.satadev_addr.pmport = 0;
10412 		sata_device.satadev_addr.qual = SATA_ADDR_CPORT;
10413 		sata_device.satadev_rev = SATA_DEVICE_REV;
10414 
10415 		rval = (*SATA_PROBE_PORT_FUNC(sata_hba_inst))
10416 		    (dip, &sata_device);
10417 
10418 		mutex_enter(&cportinfo->cport_mutex);
10419 		cportinfo->cport_scr = sata_device.satadev_scr;
10420 		if (rval != SATA_SUCCESS) {
10421 			/* Something went wrong? Fail the port */
10422 			cportinfo->cport_state = SATA_PSTATE_FAILED;
10423 			mutex_exit(&cportinfo->cport_mutex);
10424 			continue;
10425 		}
10426 		cportinfo->cport_state &= ~SATA_STATE_PROBING;
10427 		cportinfo->cport_state |= SATA_STATE_PROBED;
10428 		cportinfo->cport_dev_type = sata_device.satadev_type;
10429 
10430 		cportinfo->cport_state |= SATA_STATE_READY;
10431 		if (cportinfo->cport_dev_type == SATA_DTYPE_NONE) {
10432 			mutex_exit(&cportinfo->cport_mutex);
10433 			continue;
10434 		}
10435 		if (cportinfo->cport_dev_type != SATA_DTYPE_PMULT) {
10436 			/*
10437 			 * There is some device attached.
10438 			 * Allocate device info structure
10439 			 */
10440 			if (SATA_CPORTINFO_DRV_INFO(cportinfo) == NULL) {
10441 				mutex_exit(&cportinfo->cport_mutex);
10442 				SATA_CPORTINFO_DRV_INFO(cportinfo) =
10443 				    kmem_zalloc(sizeof (sata_drive_info_t),
10444 				    KM_SLEEP);
10445 				mutex_enter(&cportinfo->cport_mutex);
10446 			}
10447 			drive = SATA_CPORTINFO_DRV_INFO(cportinfo);
10448 			drive->satadrv_addr = cportinfo->cport_addr;
10449 			drive->satadrv_addr.qual = SATA_ADDR_DCPORT;
10450 			drive->satadrv_type = cportinfo->cport_dev_type;
10451 			drive->satadrv_state = SATA_STATE_UNKNOWN;
10452 
10453 			mutex_exit(&cportinfo->cport_mutex);
10454 			if (sata_add_device(dip, sata_hba_inst, &sata_device) !=
10455 			    SATA_SUCCESS) {
10456 				/*
10457 				 * Plugged device was not correctly identified.
10458 				 * Retry, within a SATA_DEV_IDENTIFY_TIMEOUT
10459 				 */
10460 				cur_time = ddi_get_lbolt();
10461 				if ((cur_time - start_time) <
10462 				    drv_usectohz(SATA_DEV_IDENTIFY_TIMEOUT)) {
10463 					/* sleep for a while */
10464 					delay(drv_usectohz(
10465 					    SATA_DEV_RETRY_DLY));
10466 					goto reprobe_cport;
10467 				}
10468 			}
10469 		} else { /* SATA_DTYPE_PMULT */
10470 			mutex_exit(&cportinfo->cport_mutex);
10471 
10472 			/* Allocate sata_pmult_info and sata_pmport_info */
10473 			if (sata_alloc_pmult(sata_hba_inst, &sata_device) !=
10474 			    SATA_SUCCESS)
10475 				continue;
10476 
10477 			/* Log the information of the port multiplier */
10478 			sata_show_pmult_info(sata_hba_inst, &sata_device);
10479 
10480 			/* Probe its pmports */
10481 			sata_probe_pmports(sata_hba_inst, ncport);
10482 		}
10483 	}
10484 }
10485 
10486 /*
10487  * Probe all device ports behind a port multiplier.
10488  *
10489  * PMult-related structure should be allocated before by sata_alloc_pmult().
10490  *
10491  * NOTE1: Only called from sata_probe_ports()
10492  * NOTE2: No mutex should be hold.
10493  */
10494 static void
10495 sata_probe_pmports(sata_hba_inst_t *sata_hba_inst, uint8_t ncport)
10496 {
10497 	dev_info_t		*dip = SATA_DIP(sata_hba_inst);
10498 	sata_pmult_info_t	*pmultinfo = NULL;
10499 	sata_pmport_info_t 	*pmportinfo = NULL;
10500 	sata_drive_info_t	*drive = NULL;
10501 	sata_device_t		sata_device;
10502 
10503 	clock_t			start_time, cur_time;
10504 	int			npmport;
10505 	int			rval;
10506 
10507 	pmultinfo = SATA_PMULT_INFO(sata_hba_inst, ncport);
10508 
10509 	/* Probe Port Multiplier ports */
10510 	for (npmport = 0; npmport < pmultinfo->pmult_num_dev_ports; npmport++) {
10511 		pmportinfo = pmultinfo->pmult_dev_port[npmport];
10512 		start_time = ddi_get_lbolt();
10513 reprobe_pmport:
10514 		sata_device.satadev_addr.cport = ncport;
10515 		sata_device.satadev_addr.pmport = npmport;
10516 		sata_device.satadev_addr.qual = SATA_ADDR_PMPORT;
10517 		sata_device.satadev_rev = SATA_DEVICE_REV;
10518 
10519 		/* Let HBA driver probe it. */
10520 		rval = (*SATA_PROBE_PORT_FUNC(sata_hba_inst))
10521 		    (dip, &sata_device);
10522 		mutex_enter(&pmportinfo->pmport_mutex);
10523 
10524 		pmportinfo->pmport_scr = sata_device.satadev_scr;
10525 
10526 		if (rval != SATA_SUCCESS) {
10527 			pmportinfo->pmport_state =
10528 			    SATA_PSTATE_FAILED;
10529 			mutex_exit(&pmportinfo->pmport_mutex);
10530 			continue;
10531 		}
10532 		pmportinfo->pmport_state &= ~SATA_STATE_PROBING;
10533 		pmportinfo->pmport_state |= SATA_STATE_PROBED;
10534 		pmportinfo->pmport_dev_type = sata_device.satadev_type;
10535 
10536 		pmportinfo->pmport_state |= SATA_STATE_READY;
10537 		if (pmportinfo->pmport_dev_type ==
10538 		    SATA_DTYPE_NONE) {
10539 			SATADBG2(SATA_DBG_PMULT, sata_hba_inst,
10540 			    "no device found at port %d:%d", ncport, npmport);
10541 			mutex_exit(&pmportinfo->pmport_mutex);
10542 			continue;
10543 		}
10544 		/* Port multipliers cannot be chained */
10545 		ASSERT(pmportinfo->pmport_dev_type != SATA_DTYPE_PMULT);
10546 		/*
10547 		 * There is something attached to Port
10548 		 * Multiplier device port
10549 		 * Allocate device info structure
10550 		 */
10551 		if (pmportinfo->pmport_sata_drive == NULL) {
10552 			mutex_exit(&pmportinfo->pmport_mutex);
10553 			pmportinfo->pmport_sata_drive =
10554 			    kmem_zalloc(sizeof (sata_drive_info_t), KM_SLEEP);
10555 			mutex_enter(&pmportinfo->pmport_mutex);
10556 		}
10557 		drive = pmportinfo->pmport_sata_drive;
10558 		drive->satadrv_addr.cport = pmportinfo->pmport_addr.cport;
10559 		drive->satadrv_addr.pmport = npmport;
10560 		drive->satadrv_addr.qual = SATA_ADDR_DPMPORT;
10561 		drive->satadrv_type = pmportinfo-> pmport_dev_type;
10562 		drive->satadrv_state = SATA_STATE_UNKNOWN;
10563 
10564 		mutex_exit(&pmportinfo->pmport_mutex);
10565 		rval = sata_add_device(dip, sata_hba_inst, &sata_device);
10566 
10567 		if (rval != SATA_SUCCESS) {
10568 			/*
10569 			 * Plugged device was not correctly identified.
10570 			 * Retry, within the SATA_DEV_IDENTIFY_TIMEOUT
10571 			 */
10572 			cur_time = ddi_get_lbolt();
10573 			if ((cur_time - start_time) < drv_usectohz(
10574 			    SATA_DEV_IDENTIFY_TIMEOUT)) {
10575 				/* sleep for a while */
10576 				delay(drv_usectohz(SATA_DEV_RETRY_DLY));
10577 				goto reprobe_pmport;
10578 			}
10579 		}
10580 	}
10581 }
10582 
10583 /*
10584  * Add SATA device for specified HBA instance & port (SCSI target
10585  * device nodes).
10586  * This function is called (indirectly) only from sata_hba_attach().
10587  * A target node is created when there is a supported type device attached,
10588  * but may be removed if it cannot be put online.
10589  *
10590  * This function cannot be called from an interrupt context.
10591  *
10592  * Create target nodes for disk, CD/DVD, Tape and ATAPI disk devices
10593  *
10594  * Returns SATA_SUCCESS when port/device was fully processed, SATA_FAILURE when
10595  * device identification failed - adding a device could be retried.
10596  *
10597  */
10598 static 	int
10599 sata_add_device(dev_info_t *pdip, sata_hba_inst_t *sata_hba_inst,
10600     sata_device_t *sata_device)
10601 {
10602 	sata_cport_info_t 	*cportinfo;
10603 	sata_pmult_info_t	*pminfo;
10604 	sata_pmport_info_t	*pmportinfo;
10605 	dev_info_t		*cdip;		/* child dip */
10606 	sata_address_t		*saddr = &sata_device->satadev_addr;
10607 	uint8_t			cport, pmport;
10608 	int			rval;
10609 
10610 	cport = saddr->cport;
10611 	pmport = saddr->pmport;
10612 	cportinfo = SATA_CPORT_INFO(sata_hba_inst, cport);
10613 	ASSERT(cportinfo->cport_dev_type != SATA_DTYPE_NONE);
10614 
10615 	/*
10616 	 * Some device is attached to a controller port.
10617 	 * We rely on controllers distinquishing between no-device,
10618 	 * attached port multiplier and other kind of attached device.
10619 	 * We need to get Identify Device data and determine
10620 	 * positively the dev type before trying to attach
10621 	 * the target driver.
10622 	 */
10623 	sata_device->satadev_rev = SATA_DEVICE_REV;
10624 	switch (saddr->qual) {
10625 	case SATA_ADDR_CPORT:
10626 		/*
10627 		 * Add a non-port-multiplier device at controller port.
10628 		 */
10629 		saddr->qual = SATA_ADDR_DCPORT;
10630 
10631 		rval = sata_probe_device(sata_hba_inst, sata_device);
10632 		if (rval != SATA_SUCCESS ||
10633 		    sata_device->satadev_type == SATA_DTYPE_UNKNOWN)
10634 			return (SATA_FAILURE);
10635 
10636 		mutex_enter(&cportinfo->cport_mutex);
10637 		sata_show_drive_info(sata_hba_inst,
10638 		    SATA_CPORTINFO_DRV_INFO(cportinfo));
10639 
10640 		if ((sata_device->satadev_type & SATA_VALID_DEV_TYPE) == 0) {
10641 			/*
10642 			 * Could not determine device type or
10643 			 * a device is not supported.
10644 			 * Degrade this device to unknown.
10645 			 */
10646 			cportinfo->cport_dev_type = SATA_DTYPE_UNKNOWN;
10647 			mutex_exit(&cportinfo->cport_mutex);
10648 			return (SATA_SUCCESS);
10649 		}
10650 		cportinfo->cport_dev_type = sata_device->satadev_type;
10651 		cportinfo->cport_tgtnode_clean = B_TRUE;
10652 		mutex_exit(&cportinfo->cport_mutex);
10653 
10654 		/*
10655 		 * Initialize device to the desired state. Even if it
10656 		 * fails, the device will still attach but syslog
10657 		 * will show the warning.
10658 		 */
10659 		if (sata_initialize_device(sata_hba_inst,
10660 		    SATA_CPORTINFO_DRV_INFO(cportinfo)) != SATA_SUCCESS) {
10661 			/* Retry */
10662 			rval = sata_initialize_device(sata_hba_inst,
10663 			    SATA_CPORTINFO_DRV_INFO(cportinfo));
10664 
10665 			if (rval == SATA_RETRY)
10666 				sata_log(sata_hba_inst, CE_WARN,
10667 				    "SATA device at port %d - "
10668 				    "default device features could not be set."
10669 				    " Device may not operate as expected.",
10670 				    cport);
10671 		}
10672 
10673 		cdip = sata_create_target_node(pdip, sata_hba_inst, saddr);
10674 		if (cdip == NULL) {
10675 			/*
10676 			 * Attaching target node failed.
10677 			 * We retain sata_drive_info structure...
10678 			 */
10679 			return (SATA_SUCCESS);
10680 		}
10681 
10682 		mutex_enter(&cportinfo->cport_mutex);
10683 		(SATA_CPORTINFO_DRV_INFO(cportinfo))->
10684 		    satadrv_state = SATA_STATE_READY;
10685 		mutex_exit(&cportinfo->cport_mutex);
10686 
10687 		break;
10688 
10689 	case SATA_ADDR_PMPORT:
10690 		saddr->qual = SATA_ADDR_DPMPORT;
10691 
10692 		mutex_enter(&cportinfo->cport_mutex);
10693 		/* It must be a Port Multiplier at the controller port */
10694 		ASSERT(cportinfo->cport_dev_type == SATA_DTYPE_PMULT);
10695 
10696 		pminfo = SATA_CPORTINFO_PMULT_INFO(cportinfo);
10697 		pmportinfo = pminfo->pmult_dev_port[saddr->pmport];
10698 		mutex_exit(&cportinfo->cport_mutex);
10699 
10700 		rval = sata_probe_device(sata_hba_inst, sata_device);
10701 		if (rval != SATA_SUCCESS ||
10702 		    sata_device->satadev_type == SATA_DTYPE_UNKNOWN) {
10703 			return (SATA_FAILURE);
10704 		}
10705 
10706 		mutex_enter(&pmportinfo->pmport_mutex);
10707 		sata_show_drive_info(sata_hba_inst,
10708 		    SATA_PMPORTINFO_DRV_INFO(pmportinfo));
10709 
10710 		if ((sata_device->satadev_type & SATA_VALID_DEV_TYPE) == 0) {
10711 			/*
10712 			 * Could not determine device type.
10713 			 * Degrade this device to unknown.
10714 			 */
10715 			pmportinfo->pmport_dev_type = SATA_DTYPE_UNKNOWN;
10716 			mutex_exit(&pmportinfo->pmport_mutex);
10717 			return (SATA_SUCCESS);
10718 		}
10719 		pmportinfo->pmport_dev_type = sata_device->satadev_type;
10720 		pmportinfo->pmport_tgtnode_clean = B_TRUE;
10721 		mutex_exit(&pmportinfo->pmport_mutex);
10722 
10723 		/*
10724 		 * Initialize device to the desired state.
10725 		 * Even if it fails, the device will still
10726 		 * attach but syslog will show the warning.
10727 		 */
10728 		if (sata_initialize_device(sata_hba_inst,
10729 		    pmportinfo->pmport_sata_drive) != SATA_SUCCESS) {
10730 			/* Retry */
10731 			rval = sata_initialize_device(sata_hba_inst,
10732 			    pmportinfo->pmport_sata_drive);
10733 
10734 			if (rval == SATA_RETRY)
10735 				sata_log(sata_hba_inst, CE_WARN,
10736 				    "SATA device at port %d:%d - "
10737 				    "default device features could not be set."
10738 				    " Device may not operate as expected.",
10739 				    cport, pmport);
10740 		}
10741 
10742 		cdip = sata_create_target_node(pdip, sata_hba_inst, saddr);
10743 		if (cdip == NULL) {
10744 			/*
10745 			 * Attaching target node failed.
10746 			 * We retain sata_drive_info structure...
10747 			 */
10748 			return (SATA_SUCCESS);
10749 		}
10750 		mutex_enter(&pmportinfo->pmport_mutex);
10751 		pmportinfo->pmport_sata_drive->satadrv_state |=
10752 		    SATA_STATE_READY;
10753 		mutex_exit(&pmportinfo->pmport_mutex);
10754 
10755 		break;
10756 
10757 	default:
10758 		return (SATA_FAILURE);
10759 	}
10760 
10761 	return (SATA_SUCCESS);
10762 }
10763 
10764 /*
10765  * Clean up target node at specific address.
10766  *
10767  * NOTE: No Mutex should be hold.
10768  */
10769 static int
10770 sata_offline_device(sata_hba_inst_t *sata_hba_inst,
10771     sata_device_t *sata_device, sata_drive_info_t *sdinfo)
10772 {
10773 	uint8_t cport, pmport, qual;
10774 	dev_info_t *tdip;
10775 
10776 	cport = sata_device->satadev_addr.cport;
10777 	pmport = sata_device->satadev_addr.pmport;
10778 	qual = sata_device->satadev_addr.qual;
10779 
10780 	if (qual == SATA_ADDR_DCPORT) {
10781 		SATA_LOG_D((sata_hba_inst, CE_WARN,
10782 		    "sata_hba_ioctl: disconnect device at port %d", cport));
10783 	} else {
10784 		SATA_LOG_D((sata_hba_inst, CE_WARN,
10785 		    "sata_hba_ioctl: disconnect device at port %d:%d",
10786 		    cport, pmport));
10787 	}
10788 
10789 	/* We are addressing attached device, not a port */
10790 	sata_device->satadev_addr.qual =
10791 	    sdinfo->satadrv_addr.qual;
10792 	tdip = sata_get_scsi_target_dip(SATA_DIP(sata_hba_inst),
10793 	    &sata_device->satadev_addr);
10794 	if (tdip != NULL && ndi_devi_offline(tdip,
10795 	    NDI_DEVI_REMOVE) != NDI_SUCCESS) {
10796 		/*
10797 		 * Problem :
10798 		 * The target node remained attached.
10799 		 * This happens when the device file was open
10800 		 * or a node was waiting for resources.
10801 		 * Cannot do anything about it.
10802 		 */
10803 		if (qual == SATA_ADDR_DCPORT) {
10804 			SATA_LOG_D((sata_hba_inst, CE_WARN,
10805 			    "sata_hba_ioctl: disconnect: could "
10806 			    "not unconfigure device before "
10807 			    "disconnecting the SATA port %d",
10808 			    cport));
10809 		} else {
10810 			SATA_LOG_D((sata_hba_inst, CE_WARN,
10811 			    "sata_hba_ioctl: disconnect: could "
10812 			    "not unconfigure device before "
10813 			    "disconnecting the SATA port %d:%d",
10814 			    cport, pmport));
10815 		}
10816 		/*
10817 		 * Set DEVICE REMOVED state in the target
10818 		 * node. It will prevent access to the device
10819 		 * even when a new device is attached, until
10820 		 * the old target node is released, removed and
10821 		 * recreated for a new  device.
10822 		 */
10823 		sata_set_device_removed(tdip);
10824 
10825 		/*
10826 		 * Instruct event daemon to try the target
10827 		 * node cleanup later.
10828 		 */
10829 		sata_set_target_node_cleanup(
10830 		    sata_hba_inst, &sata_device->satadev_addr);
10831 	}
10832 
10833 
10834 	return (SATA_SUCCESS);
10835 }
10836 
10837 
10838 /*
10839  * Create scsi target node for attached device, create node properties and
10840  * attach the node.
10841  * The node could be removed if the device onlining fails.
10842  *
10843  * A dev_info_t pointer is returned if operation is successful, NULL is
10844  * returned otherwise.
10845  */
10846 
10847 static dev_info_t *
10848 sata_create_target_node(dev_info_t *dip, sata_hba_inst_t *sata_hba_inst,
10849 			sata_address_t *sata_addr)
10850 {
10851 	dev_info_t *cdip = NULL;
10852 	int rval;
10853 	char *nname = NULL;
10854 	char **compatible = NULL;
10855 	int ncompatible;
10856 	struct scsi_inquiry inq;
10857 	sata_device_t sata_device;
10858 	sata_drive_info_t *sdinfo;
10859 	int target;
10860 	int i;
10861 
10862 	sata_device.satadev_rev = SATA_DEVICE_REV;
10863 	sata_device.satadev_addr = *sata_addr;
10864 
10865 	mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, sata_addr->cport)));
10866 
10867 	sdinfo = sata_get_device_info(sata_hba_inst, &sata_device);
10868 
10869 	target = SATA_TO_SCSI_TARGET(sata_addr->cport,
10870 	    sata_addr->pmport, sata_addr->qual);
10871 
10872 	if (sdinfo == NULL) {
10873 		mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst,
10874 		    sata_addr->cport)));
10875 		SATA_LOG_D((sata_hba_inst, CE_WARN,
10876 		    "sata_create_target_node: no sdinfo for target %x",
10877 		    target));
10878 		return (NULL);
10879 	}
10880 
10881 	/*
10882 	 * create or get scsi inquiry data, expected by
10883 	 * scsi_hba_nodename_compatible_get()
10884 	 * SATA hard disks get Identify Data translated into Inguiry Data.
10885 	 * ATAPI devices respond directly to Inquiry request.
10886 	 */
10887 	if (sdinfo->satadrv_type == SATA_DTYPE_ATADISK) {
10888 		sata_identdev_to_inquiry(sata_hba_inst, sdinfo,
10889 		    (uint8_t *)&inq);
10890 		mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst,
10891 		    sata_addr->cport)));
10892 	} else { /* Assume supported ATAPI device */
10893 		mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst,
10894 		    sata_addr->cport)));
10895 		if (sata_get_atapi_inquiry_data(sata_hba_inst, sata_addr,
10896 		    &inq) == SATA_FAILURE)
10897 			return (NULL);
10898 		/*
10899 		 * Save supported ATAPI transport version
10900 		 */
10901 		sdinfo->satadrv_atapi_trans_ver =
10902 		    SATA_ATAPI_TRANS_VERSION(&inq);
10903 	}
10904 
10905 	/* determine the node name and compatible */
10906 	scsi_hba_nodename_compatible_get(&inq, NULL,
10907 	    inq.inq_dtype, NULL, &nname, &compatible, &ncompatible);
10908 
10909 #ifdef SATA_DEBUG
10910 	if (sata_debug_flags & SATA_DBG_NODES) {
10911 		if (nname == NULL) {
10912 			cmn_err(CE_NOTE, "sata_create_target_node: "
10913 			    "cannot determine nodename for target %d\n",
10914 			    target);
10915 		} else {
10916 			cmn_err(CE_WARN, "sata_create_target_node: "
10917 			    "target %d nodename: %s\n", target, nname);
10918 		}
10919 		if (compatible == NULL) {
10920 			cmn_err(CE_WARN,
10921 			    "sata_create_target_node: no compatible name\n");
10922 		} else {
10923 			for (i = 0; i < ncompatible; i++) {
10924 				cmn_err(CE_WARN, "sata_create_target_node: "
10925 				    "compatible name: %s\n", compatible[i]);
10926 			}
10927 		}
10928 	}
10929 #endif
10930 
10931 	/* if nodename can't be determined, log error and exit */
10932 	if (nname == NULL) {
10933 		SATA_LOG_D((sata_hba_inst, CE_WARN,
10934 		    "sata_create_target_node: cannot determine nodename "
10935 		    "for target %d\n", target));
10936 		scsi_hba_nodename_compatible_free(nname, compatible);
10937 		return (NULL);
10938 	}
10939 	/*
10940 	 * Create scsi target node
10941 	 */
10942 	ndi_devi_alloc_sleep(dip, nname, (pnode_t)DEVI_SID_NODEID, &cdip);
10943 	rval = ndi_prop_update_string(DDI_DEV_T_NONE, cdip,
10944 	    "device-type", "scsi");
10945 
10946 	if (rval != DDI_PROP_SUCCESS) {
10947 		SATA_LOG_D((sata_hba_inst, CE_WARN, "sata_create_target_node: "
10948 		    "updating device_type prop failed %d", rval));
10949 		goto fail;
10950 	}
10951 
10952 	/*
10953 	 * Create target node properties: target & lun
10954 	 */
10955 	rval = ndi_prop_update_int(DDI_DEV_T_NONE, cdip, "target", target);
10956 	if (rval != DDI_PROP_SUCCESS) {
10957 		SATA_LOG_D((sata_hba_inst, CE_WARN, "sata_create_target_node: "
10958 		    "updating target prop failed %d", rval));
10959 		goto fail;
10960 	}
10961 	rval = ndi_prop_update_int(DDI_DEV_T_NONE, cdip, "lun", 0);
10962 	if (rval != DDI_PROP_SUCCESS) {
10963 		SATA_LOG_D((sata_hba_inst, CE_WARN, "sata_create_target_node: "
10964 		    "updating target prop failed %d", rval));
10965 		goto fail;
10966 	}
10967 
10968 	if (sdinfo->satadrv_type & SATA_DTYPE_ATAPI) {
10969 		/*
10970 		 * Add "variant" property
10971 		 */
10972 		rval = ndi_prop_update_string(DDI_DEV_T_NONE, cdip,
10973 		    "variant", "atapi");
10974 		if (rval != DDI_PROP_SUCCESS) {
10975 			SATA_LOG_D((sata_hba_inst, CE_WARN,
10976 			    "sata_create_target_node: variant atapi "
10977 			    "property could not be created: %d", rval));
10978 			goto fail;
10979 		}
10980 	}
10981 	/* decorate the node with compatible */
10982 	if (ndi_prop_update_string_array(DDI_DEV_T_NONE, cdip, "compatible",
10983 	    compatible, ncompatible) != DDI_PROP_SUCCESS) {
10984 		SATA_LOG_D((sata_hba_inst, CE_WARN,
10985 		    "sata_create_target_node: FAIL compatible props cdip 0x%p",
10986 		    (void *)cdip));
10987 		goto fail;
10988 	}
10989 
10990 	if (sdinfo->satadrv_type == SATA_DTYPE_ATADISK) {
10991 		/*
10992 		 * Add "sata-phy" property
10993 		 */
10994 		if (ndi_prop_update_int(DDI_DEV_T_NONE, cdip, "sata-phy",
10995 		    (int)sata_addr->cport) != DDI_PROP_SUCCESS) {
10996 			SATA_LOG_D((sata_hba_inst, CE_WARN,
10997 			    "sata_create_target_node: failed to create "
10998 			    "\"sata-phy\" property: port %d",
10999 			    sata_addr->cport));
11000 		}
11001 	}
11002 
11003 
11004 	/*
11005 	 * Now, try to attach the driver. If probing of the device fails,
11006 	 * the target node may be removed
11007 	 */
11008 	rval = ndi_devi_online(cdip, NDI_ONLINE_ATTACH);
11009 
11010 	scsi_hba_nodename_compatible_free(nname, compatible);
11011 
11012 	if (rval == NDI_SUCCESS)
11013 		return (cdip);
11014 
11015 	/* target node was removed - are we sure? */
11016 	return (NULL);
11017 
11018 fail:
11019 	scsi_hba_nodename_compatible_free(nname, compatible);
11020 	ddi_prop_remove_all(cdip);
11021 	rval = ndi_devi_free(cdip);
11022 	if (rval != NDI_SUCCESS) {
11023 		SATA_LOG_D((sata_hba_inst, CE_WARN, "sata_create_target_node: "
11024 		    "node removal failed %d", rval));
11025 	}
11026 	sata_log(sata_hba_inst, CE_WARN, "sata_create_target_node: "
11027 	    "cannot create target node for SATA device at port %d",
11028 	    sata_addr->cport);
11029 	return (NULL);
11030 }
11031 
11032 /*
11033  * Remove a target node.
11034  */
11035 static void
11036 sata_remove_target_node(sata_hba_inst_t *sata_hba_inst,
11037 			sata_address_t *sata_addr)
11038 {
11039 	dev_info_t *tdip;
11040 	uint8_t cport = sata_addr->cport;
11041 	uint8_t pmport = sata_addr->pmport;
11042 	uint8_t qual = sata_addr->qual;
11043 
11044 	/* Note the sata daemon uses the address of the port/pmport */
11045 	ASSERT(qual == SATA_ADDR_CPORT || qual == SATA_ADDR_PMPORT);
11046 
11047 	/* Remove target node */
11048 	tdip = sata_get_target_dip(SATA_DIP(sata_hba_inst), cport, pmport);
11049 	if (tdip != NULL) {
11050 		/*
11051 		 * Target node exists.  Unconfigure device
11052 		 * then remove the target node (one ndi
11053 		 * operation).
11054 		 */
11055 		if (ndi_devi_offline(tdip, NDI_DEVI_REMOVE) != NDI_SUCCESS) {
11056 			/*
11057 			 * PROBLEM - no device, but target node remained. This
11058 			 * happens when the file was open or node was waiting
11059 			 * for resources.
11060 			 */
11061 			SATA_LOG_D((sata_hba_inst, CE_WARN,
11062 			    "sata_remove_target_node: "
11063 			    "Failed to remove target node for "
11064 			    "detached SATA device."));
11065 			/*
11066 			 * Set target node state to DEVI_DEVICE_REMOVED. But
11067 			 * re-check first that the node still exists.
11068 			 */
11069 			tdip = sata_get_target_dip(SATA_DIP(sata_hba_inst),
11070 			    cport, pmport);
11071 			if (tdip != NULL) {
11072 				sata_set_device_removed(tdip);
11073 				/*
11074 				 * Instruct event daemon to retry the cleanup
11075 				 * later.
11076 				 */
11077 				sata_set_target_node_cleanup(sata_hba_inst,
11078 				    sata_addr);
11079 			}
11080 		}
11081 
11082 		if (qual == SATA_ADDR_CPORT)
11083 			sata_log(sata_hba_inst, CE_WARN,
11084 			    "SATA device detached at port %d", cport);
11085 		else
11086 			sata_log(sata_hba_inst, CE_WARN,
11087 			    "SATA device detached at port %d:%d",
11088 			    cport, pmport);
11089 	}
11090 #ifdef SATA_DEBUG
11091 	else {
11092 		if (qual == SATA_ADDR_CPORT)
11093 			sata_log(sata_hba_inst, CE_WARN,
11094 			    "target node not found at port %d", cport);
11095 		else
11096 			sata_log(sata_hba_inst, CE_WARN,
11097 			    "target node not found at port %d:%d",
11098 			    cport, pmport);
11099 	}
11100 #endif
11101 }
11102 
11103 
11104 /*
11105  * Re-probe sata port, check for a device and attach info
11106  * structures when necessary. Identify Device data is fetched, if possible.
11107  * Assumption: sata address is already validated.
11108  * SATA_SUCCESS is returned if port is re-probed sucessfully, regardless of
11109  * the presence of a device and its type.
11110  *
11111  * flag arg specifies that the function should try multiple times to identify
11112  * device type and to initialize it, or it should return immediately on failure.
11113  * SATA_DEV_IDENTIFY_RETRY - retry
11114  * SATA_DEV_IDENTIFY_NORETRY - no retry
11115  *
11116  * SATA_FAILURE is returned if one of the operations failed.
11117  *
11118  * This function cannot be called in interrupt context - it may sleep.
11119  *
11120  * Note: Port multiplier is supported.
11121  */
11122 static int
11123 sata_reprobe_port(sata_hba_inst_t *sata_hba_inst, sata_device_t *sata_device,
11124     int flag)
11125 {
11126 	sata_cport_info_t *cportinfo;
11127 	sata_pmult_info_t *pmultinfo;
11128 	sata_drive_info_t *sdinfo, *osdinfo;
11129 	boolean_t init_device = B_FALSE;
11130 	int prev_device_type = SATA_DTYPE_NONE;
11131 	int prev_device_settings = 0;
11132 	int prev_device_state = 0;
11133 	clock_t start_time;
11134 	int retry = B_FALSE;
11135 	uint8_t cport = sata_device->satadev_addr.cport;
11136 	int rval_probe, rval_init;
11137 
11138 	/*
11139 	 * If target is pmport, sata_reprobe_pmport() will handle it.
11140 	 */
11141 	if (sata_device->satadev_addr.qual == SATA_ADDR_PMPORT ||
11142 	    sata_device->satadev_addr.qual == SATA_ADDR_DPMPORT)
11143 		return (sata_reprobe_pmport(sata_hba_inst, sata_device, flag));
11144 
11145 	/* We only care about host sata cport for now */
11146 	cportinfo = SATA_CPORT_INFO(sata_hba_inst,
11147 	    sata_device->satadev_addr.cport);
11148 
11149 	/*
11150 	 * If a port multiplier was previously attached (we have no idea it
11151 	 * still there or not), sata_reprobe_pmult() will handle it.
11152 	 */
11153 	if (cportinfo->cport_dev_type == SATA_DTYPE_PMULT)
11154 		return (sata_reprobe_pmult(sata_hba_inst, sata_device, flag));
11155 
11156 	/* Store sata_drive_info when a non-pmult device was attached. */
11157 	osdinfo = SATA_CPORTINFO_DRV_INFO(cportinfo);
11158 	if (osdinfo != NULL) {
11159 		/*
11160 		 * We are re-probing port with a previously attached device.
11161 		 * Save previous device type and settings.
11162 		 */
11163 		prev_device_type = cportinfo->cport_dev_type;
11164 		prev_device_settings = osdinfo->satadrv_settings;
11165 		prev_device_state = osdinfo->satadrv_state;
11166 	}
11167 	if (flag == SATA_DEV_IDENTIFY_RETRY) {
11168 		start_time = ddi_get_lbolt();
11169 		retry = B_TRUE;
11170 	}
11171 retry_probe:
11172 
11173 	/* probe port */
11174 	mutex_enter(&cportinfo->cport_mutex);
11175 	cportinfo->cport_state &= ~SATA_PORT_STATE_CLEAR_MASK;
11176 	cportinfo->cport_state |= SATA_STATE_PROBING;
11177 	mutex_exit(&cportinfo->cport_mutex);
11178 
11179 	rval_probe = (*SATA_PROBE_PORT_FUNC(sata_hba_inst))
11180 	    (SATA_DIP(sata_hba_inst), sata_device);
11181 
11182 	mutex_enter(&cportinfo->cport_mutex);
11183 	if (rval_probe != SATA_SUCCESS) {
11184 		cportinfo->cport_state = SATA_PSTATE_FAILED;
11185 		mutex_exit(&cportinfo->cport_mutex);
11186 		SATA_LOG_D((sata_hba_inst, CE_WARN, "sata_reprobe_port: "
11187 		    "SATA port %d probing failed",
11188 		    cportinfo->cport_addr.cport));
11189 		return (SATA_FAILURE);
11190 	}
11191 
11192 	/*
11193 	 * update sata port state and set device type
11194 	 */
11195 	sata_update_port_info(sata_hba_inst, sata_device);
11196 	cportinfo->cport_state &= ~SATA_STATE_PROBING;
11197 
11198 	/*
11199 	 * Sanity check - Port is active? Is the link active?
11200 	 * Is there any device attached?
11201 	 */
11202 	if ((cportinfo->cport_state &
11203 	    (SATA_PSTATE_SHUTDOWN | SATA_PSTATE_FAILED)) ||
11204 	    (cportinfo->cport_scr.sstatus & SATA_PORT_DEVLINK_UP_MASK) !=
11205 	    SATA_PORT_DEVLINK_UP) {
11206 		/*
11207 		 * Port in non-usable state or no link active/no device.
11208 		 * Free info structure if necessary (direct attached drive
11209 		 * only, for now!
11210 		 */
11211 		sdinfo = SATA_CPORTINFO_DRV_INFO(cportinfo);
11212 		SATA_CPORTINFO_DRV_INFO(cportinfo) = NULL;
11213 		/* Add here differentiation for device attached or not */
11214 		cportinfo->cport_dev_type = SATA_DTYPE_NONE;
11215 		mutex_exit(&cportinfo->cport_mutex);
11216 		if (sdinfo != NULL)
11217 			kmem_free(sdinfo, sizeof (sata_drive_info_t));
11218 		return (SATA_SUCCESS);
11219 	}
11220 
11221 	cportinfo->cport_state |= SATA_STATE_READY;
11222 	cportinfo->cport_state |= SATA_STATE_PROBED;
11223 
11224 	cportinfo->cport_dev_type = sata_device->satadev_type;
11225 	sdinfo = SATA_CPORTINFO_DRV_INFO(cportinfo);
11226 
11227 	/*
11228 	 * If we are re-probing the port, there may be
11229 	 * sata_drive_info structure attached
11230 	 */
11231 	if (sata_device->satadev_type == SATA_DTYPE_NONE) {
11232 
11233 		/*
11234 		 * There is no device, so remove device info structure,
11235 		 * if necessary.
11236 		 */
11237 		/* Device change: Drive -> None */
11238 		SATA_CPORTINFO_DRV_INFO(cportinfo) = NULL;
11239 		cportinfo->cport_dev_type = SATA_DTYPE_NONE;
11240 		if (sdinfo != NULL) {
11241 			kmem_free(sdinfo, sizeof (sata_drive_info_t));
11242 			sata_log(sata_hba_inst, CE_WARN,
11243 			    "SATA device detached "
11244 			    "from port %d", cportinfo->cport_addr.cport);
11245 		}
11246 		mutex_exit(&cportinfo->cport_mutex);
11247 		return (SATA_SUCCESS);
11248 
11249 	}
11250 
11251 	if (sata_device->satadev_type != SATA_DTYPE_PMULT) {
11252 
11253 		/* Device (may) change: Drive -> Drive */
11254 		if (sdinfo == NULL) {
11255 			/*
11256 			 * There is some device attached, but there is
11257 			 * no sata_drive_info structure - allocate one
11258 			 */
11259 			mutex_exit(&cportinfo->cport_mutex);
11260 			sdinfo = kmem_zalloc(
11261 			    sizeof (sata_drive_info_t), KM_SLEEP);
11262 			mutex_enter(&cportinfo->cport_mutex);
11263 			/*
11264 			 * Recheck, that the port state did not change when we
11265 			 * released mutex.
11266 			 */
11267 			if (cportinfo->cport_state & SATA_STATE_READY) {
11268 				SATA_CPORTINFO_DRV_INFO(cportinfo) = sdinfo;
11269 				sdinfo->satadrv_addr = cportinfo->cport_addr;
11270 				sdinfo->satadrv_addr.qual = SATA_ADDR_DCPORT;
11271 				sdinfo->satadrv_type = SATA_DTYPE_UNKNOWN;
11272 				sdinfo->satadrv_state = SATA_STATE_UNKNOWN;
11273 			} else {
11274 				/*
11275 				 * Port is not in ready state, we
11276 				 * cannot attach a device.
11277 				 */
11278 				mutex_exit(&cportinfo->cport_mutex);
11279 				kmem_free(sdinfo, sizeof (sata_drive_info_t));
11280 				return (SATA_SUCCESS);
11281 			}
11282 			/*
11283 			 * Since we are adding device, presumably new one,
11284 			 * indicate that it  should be initalized,
11285 			 * as well as some internal framework states).
11286 			 */
11287 			init_device = B_TRUE;
11288 		}
11289 		cportinfo->cport_dev_type = SATA_DTYPE_UNKNOWN;
11290 		sata_device->satadev_addr.qual = sdinfo->satadrv_addr.qual;
11291 	} else {
11292 		/* Device change: Drive -> PMult */
11293 		SATA_CPORTINFO_DRV_INFO(cportinfo) = NULL;
11294 		if (sdinfo != NULL) {
11295 			kmem_free(sdinfo, sizeof (sata_drive_info_t));
11296 			sata_log(sata_hba_inst, CE_WARN,
11297 			    "SATA device detached "
11298 			    "from port %d", cportinfo->cport_addr.cport);
11299 		}
11300 
11301 		sata_log(sata_hba_inst, CE_WARN,
11302 		    "SATA port multiplier detected at port %d",
11303 		    cportinfo->cport_addr.cport);
11304 
11305 		mutex_exit(&cportinfo->cport_mutex);
11306 		if (sata_alloc_pmult(sata_hba_inst, sata_device) !=
11307 		    SATA_SUCCESS)
11308 			return (SATA_FAILURE);
11309 		sata_show_pmult_info(sata_hba_inst, sata_device);
11310 		mutex_enter(&cportinfo->cport_mutex);
11311 
11312 		/*
11313 		 * Mark all the port multiplier port behind the port
11314 		 * multiplier behind with link events, so that the sata daemon
11315 		 * will update their status.
11316 		 */
11317 		pmultinfo = SATA_PMULT_INFO(sata_hba_inst, cport);
11318 		pmultinfo->pmult_event_flags |= SATA_EVNT_DEVICE_RESET;
11319 		mutex_exit(&cportinfo->cport_mutex);
11320 		return (SATA_SUCCESS);
11321 	}
11322 	mutex_exit(&cportinfo->cport_mutex);
11323 
11324 	/*
11325 	 * Figure out what kind of device we are really
11326 	 * dealing with. Failure of identifying device does not fail this
11327 	 * function.
11328 	 */
11329 	rval_probe = sata_probe_device(sata_hba_inst, sata_device);
11330 	rval_init = SATA_FAILURE;
11331 	mutex_enter(&cportinfo->cport_mutex);
11332 	if (rval_probe == SATA_SUCCESS) {
11333 		/*
11334 		 * If we are dealing with the same type of a device as before,
11335 		 * restore its settings flags.
11336 		 */
11337 		if (osdinfo != NULL &&
11338 		    sata_device->satadev_type == prev_device_type)
11339 			sdinfo->satadrv_settings = prev_device_settings;
11340 
11341 		mutex_exit(&cportinfo->cport_mutex);
11342 		rval_init = SATA_SUCCESS;
11343 		/* Set initial device features, if necessary */
11344 		if (init_device == B_TRUE) {
11345 			rval_init = sata_initialize_device(sata_hba_inst,
11346 			    sdinfo);
11347 		}
11348 		if (rval_init == SATA_SUCCESS)
11349 			return (rval_init);
11350 		/* else we will retry if retry was asked for */
11351 
11352 	} else {
11353 		/*
11354 		 * If there was some device info before we probe the device,
11355 		 * restore previous device setting, so we can retry from scratch
11356 		 * later. Providing, of course, that device has not disapear
11357 		 * during probing process.
11358 		 */
11359 		if (sata_device->satadev_type != SATA_DTYPE_NONE) {
11360 			if (osdinfo != NULL) {
11361 				cportinfo->cport_dev_type = prev_device_type;
11362 				sdinfo->satadrv_type = prev_device_type;
11363 				sdinfo->satadrv_state = prev_device_state;
11364 			}
11365 		} else {
11366 			/* device is gone */
11367 			kmem_free(sdinfo, sizeof (sata_drive_info_t));
11368 			cportinfo->cport_dev_type = SATA_DTYPE_NONE;
11369 			SATA_CPORTINFO_DRV_INFO(cportinfo) = NULL;
11370 			mutex_exit(&cportinfo->cport_mutex);
11371 			return (SATA_SUCCESS);
11372 		}
11373 		mutex_exit(&cportinfo->cport_mutex);
11374 	}
11375 
11376 	if (retry) {
11377 		clock_t cur_time = ddi_get_lbolt();
11378 		/*
11379 		 * A device was not successfully identified or initialized.
11380 		 * Track retry time for device identification.
11381 		 */
11382 		if ((cur_time - start_time) <
11383 		    drv_usectohz(SATA_DEV_REPROBE_TIMEOUT)) {
11384 			/* sleep for a while */
11385 			delay(drv_usectohz(SATA_DEV_RETRY_DLY));
11386 			goto retry_probe;
11387 		}
11388 		/* else no more retries */
11389 		mutex_enter(&cportinfo->cport_mutex);
11390 		if (SATA_CPORTINFO_DRV_INFO(cportinfo) != NULL) {
11391 			if (rval_init == SATA_RETRY) {
11392 				/*
11393 				 * Setting drive features have failed, but
11394 				 * because the drive is still accessible,
11395 				 * keep it and emit a warning message.
11396 				 */
11397 				sata_log(sata_hba_inst, CE_WARN,
11398 				    "SATA device at port %d - desired "
11399 				    "drive features could not be set. "
11400 				    "Device may not operate as expected.",
11401 				    cportinfo->cport_addr.cport);
11402 			} else {
11403 				SATA_CPORTINFO_DRV_INFO(cportinfo)->
11404 				    satadrv_state = SATA_DSTATE_FAILED;
11405 			}
11406 		}
11407 		mutex_exit(&cportinfo->cport_mutex);
11408 	}
11409 	return (SATA_SUCCESS);
11410 }
11411 
11412 /*
11413  * Reprobe a controller port that connected to a port multiplier.
11414  *
11415  * NOTE: No Mutex should be hold.
11416  */
11417 static int
11418 sata_reprobe_pmult(sata_hba_inst_t *sata_hba_inst, sata_device_t *sata_device,
11419     int flag)
11420 {
11421 	_NOTE(ARGUNUSED(flag))
11422 	sata_cport_info_t *cportinfo;
11423 	sata_pmult_info_t *pmultinfo;
11424 	uint8_t cport = sata_device->satadev_addr.cport;
11425 	int rval_probe;
11426 
11427 	cportinfo = SATA_CPORT_INFO(sata_hba_inst, cport);
11428 	pmultinfo = SATA_PMULT_INFO(sata_hba_inst, cport);
11429 
11430 	/* probe port */
11431 	mutex_enter(&cportinfo->cport_mutex);
11432 	cportinfo->cport_state &= ~SATA_PORT_STATE_CLEAR_MASK;
11433 	cportinfo->cport_state |= SATA_STATE_PROBING;
11434 	mutex_exit(&cportinfo->cport_mutex);
11435 
11436 	rval_probe = (*SATA_PROBE_PORT_FUNC(sata_hba_inst))
11437 	    (SATA_DIP(sata_hba_inst), sata_device);
11438 
11439 	mutex_enter(&cportinfo->cport_mutex);
11440 	if (rval_probe != SATA_SUCCESS) {
11441 		cportinfo->cport_state = SATA_PSTATE_FAILED;
11442 		SATA_LOG_D((sata_hba_inst, CE_WARN, "sata_reprobe_pmult: "
11443 		    "SATA port %d probing failed", cport));
11444 		sata_log(sata_hba_inst, CE_WARN,
11445 		    "SATA port multiplier detached at port %d", cport);
11446 		mutex_exit(&cportinfo->cport_mutex);
11447 		sata_free_pmult(sata_hba_inst, sata_device);
11448 		return (SATA_FAILURE);
11449 	}
11450 
11451 	/*
11452 	 * update sata port state and set device type
11453 	 */
11454 	sata_update_port_info(sata_hba_inst, sata_device);
11455 	cportinfo->cport_state &= ~SATA_STATE_PROBING;
11456 	cportinfo->cport_state |= SATA_STATE_PROBED;
11457 
11458 	/*
11459 	 * Sanity check - Port is active? Is the link active?
11460 	 * Is there any device attached?
11461 	 */
11462 	if ((cportinfo->cport_state &
11463 	    (SATA_PSTATE_SHUTDOWN | SATA_PSTATE_FAILED)) ||
11464 	    (cportinfo->cport_scr.sstatus & SATA_PORT_DEVLINK_UP_MASK) !=
11465 	    SATA_PORT_DEVLINK_UP ||
11466 	    (sata_device->satadev_type == SATA_DTYPE_NONE)) {
11467 		cportinfo->cport_dev_type = SATA_DTYPE_NONE;
11468 		mutex_exit(&cportinfo->cport_mutex);
11469 		sata_free_pmult(sata_hba_inst, sata_device);
11470 		sata_log(sata_hba_inst, CE_WARN,
11471 		    "SATA port multiplier detached at port %d", cport);
11472 		return (SATA_SUCCESS);
11473 	}
11474 
11475 	/*
11476 	 * Device changed: PMult -> Non-PMult
11477 	 *
11478 	 * This situation is uncommon, most possibly being caused by errors
11479 	 * after which the port multiplier is not correct initialized and
11480 	 * recognized. In that case the new device will be marked as unknown
11481 	 * and will not be automatically probed in this routine. Instead
11482 	 * system administrator could manually restart it via cfgadm(1M).
11483 	 */
11484 	if (sata_device->satadev_type != SATA_DTYPE_PMULT) {
11485 		cportinfo->cport_dev_type = SATA_DTYPE_UNKNOWN;
11486 		mutex_exit(&cportinfo->cport_mutex);
11487 		sata_free_pmult(sata_hba_inst, sata_device);
11488 		sata_log(sata_hba_inst, CE_WARN,
11489 		    "SATA port multiplier detached at port %d", cport);
11490 		return (SATA_FAILURE);
11491 	}
11492 
11493 	/*
11494 	 * Now we know it is a port multiplier. However, if this is not the
11495 	 * previously attached port multiplier - they may have different
11496 	 * pmport numbers - we need to re-allocate data structures for every
11497 	 * pmport and drive.
11498 	 *
11499 	 * Port multipliers of the same model have identical values in these
11500 	 * registers, so it is still necessary to update the information of
11501 	 * all drives attached to the previous port multiplier afterwards.
11502 	 */
11503 	/* Device changed: PMult -> another PMult */
11504 	mutex_exit(&cportinfo->cport_mutex);
11505 	sata_free_pmult(sata_hba_inst, sata_device);
11506 	if (sata_alloc_pmult(sata_hba_inst, sata_device) != SATA_SUCCESS)
11507 		return (SATA_FAILURE);
11508 	mutex_enter(&cportinfo->cport_mutex);
11509 
11510 	SATADBG1(SATA_DBG_PMULT, sata_hba_inst,
11511 	    "SATA port multiplier [changed] at port %d", cport);
11512 	sata_log(sata_hba_inst, CE_WARN,
11513 	    "SATA port multiplier detected at port %d", cport);
11514 
11515 	/*
11516 	 * Mark all the port multiplier port behind the port
11517 	 * multiplier behind with link events, so that the sata daemon
11518 	 * will update their status.
11519 	 */
11520 	pmultinfo->pmult_event_flags |= SATA_EVNT_DEVICE_RESET;
11521 	mutex_exit(&cportinfo->cport_mutex);
11522 
11523 	return (SATA_SUCCESS);
11524 }
11525 
11526 /*
11527  * Re-probe a port multiplier port, check for a device and attach info
11528  * structures when necessary. Identify Device data is fetched, if possible.
11529  * Assumption: sata address is already validated as port multiplier port.
11530  * SATA_SUCCESS is returned if port is re-probed sucessfully, regardless of
11531  * the presence of a device and its type.
11532  *
11533  * flag arg specifies that the function should try multiple times to identify
11534  * device type and to initialize it, or it should return immediately on failure.
11535  * SATA_DEV_IDENTIFY_RETRY - retry
11536  * SATA_DEV_IDENTIFY_NORETRY - no retry
11537  *
11538  * SATA_FAILURE is returned if one of the operations failed.
11539  *
11540  * This function cannot be called in interrupt context - it may sleep.
11541  *
11542  * NOTE: Should be only called by sata_probe_port() in case target port is a
11543  *       port multiplier port.
11544  * NOTE: No Mutex should be hold.
11545  */
11546 static int
11547 sata_reprobe_pmport(sata_hba_inst_t *sata_hba_inst, sata_device_t *sata_device,
11548     int flag)
11549 {
11550 	sata_cport_info_t *cportinfo = NULL;
11551 	sata_pmport_info_t *pmportinfo = NULL;
11552 	sata_drive_info_t *sdinfo, *osdinfo;
11553 	sata_device_t sdevice;
11554 	boolean_t init_device = B_FALSE;
11555 	int prev_device_type = SATA_DTYPE_NONE;
11556 	int prev_device_settings = 0;
11557 	int prev_device_state = 0;
11558 	clock_t start_time;
11559 	uint8_t cport = sata_device->satadev_addr.cport;
11560 	uint8_t pmport = sata_device->satadev_addr.pmport;
11561 	int rval;
11562 
11563 	cportinfo = SATA_CPORT_INFO(sata_hba_inst, cport);
11564 	pmportinfo = SATA_PMPORT_INFO(sata_hba_inst, cport, pmport);
11565 	osdinfo = SATA_PMPORTINFO_DRV_INFO(pmportinfo);
11566 
11567 	if (osdinfo != NULL) {
11568 		/*
11569 		 * We are re-probing port with a previously attached device.
11570 		 * Save previous device type and settings.
11571 		 */
11572 		prev_device_type = pmportinfo->pmport_dev_type;
11573 		prev_device_settings = osdinfo->satadrv_settings;
11574 		prev_device_state = osdinfo->satadrv_state;
11575 	}
11576 
11577 	start_time = ddi_get_lbolt();
11578 
11579 	/* check parent status */
11580 	mutex_enter(&cportinfo->cport_mutex);
11581 	if ((cportinfo->cport_state &
11582 	    (SATA_PSTATE_SHUTDOWN | SATA_PSTATE_FAILED)) ||
11583 	    (cportinfo->cport_scr.sstatus & SATA_PORT_DEVLINK_UP_MASK) !=
11584 	    SATA_PORT_DEVLINK_UP) {
11585 		mutex_exit(&cportinfo->cport_mutex);
11586 		return (SATA_FAILURE);
11587 	}
11588 	mutex_exit(&cportinfo->cport_mutex);
11589 
11590 retry_probe_pmport:
11591 
11592 	/* probe port */
11593 	mutex_enter(&pmportinfo->pmport_mutex);
11594 	pmportinfo->pmport_state &= ~SATA_PORT_STATE_CLEAR_MASK;
11595 	pmportinfo->pmport_state |= SATA_STATE_PROBING;
11596 	mutex_exit(&pmportinfo->pmport_mutex);
11597 
11598 	rval = (*SATA_PROBE_PORT_FUNC(sata_hba_inst))
11599 	    (SATA_DIP(sata_hba_inst), sata_device);
11600 
11601 	/* might need retry because we cannot touch registers. */
11602 	if (rval == SATA_FAILURE) {
11603 		mutex_enter(&pmportinfo->pmport_mutex);
11604 		pmportinfo->pmport_state = SATA_PSTATE_FAILED;
11605 		mutex_exit(&pmportinfo->pmport_mutex);
11606 		SATA_LOG_D((sata_hba_inst, CE_WARN, "sata_reprobe_pmport: "
11607 		    "SATA port %d:%d probing failed",
11608 		    cport, pmport));
11609 		return (SATA_FAILURE);
11610 	} else if (rval == SATA_RETRY) {
11611 		SATA_LOG_D((sata_hba_inst, CE_WARN, "sata_reprobe_pmport: "
11612 		    "SATA port %d:%d probing failed, retrying...",
11613 		    cport, pmport));
11614 		clock_t cur_time = ddi_get_lbolt();
11615 		/*
11616 		 * A device was not successfully identified or initialized.
11617 		 * Track retry time for device identification.
11618 		 */
11619 		if ((cur_time - start_time) <
11620 		    drv_usectohz(SATA_DEV_REPROBE_TIMEOUT)) {
11621 			/* sleep for a while */
11622 			delay(drv_usectohz(SATA_DEV_RETRY_DLY));
11623 			goto retry_probe_pmport;
11624 		} else {
11625 			mutex_enter(&pmportinfo->pmport_mutex);
11626 			if (SATA_PMPORTINFO_DRV_INFO(pmportinfo) != NULL)
11627 				SATA_PMPORTINFO_DRV_INFO(pmportinfo)->
11628 				    satadrv_state = SATA_DSTATE_FAILED;
11629 			mutex_exit(&pmportinfo->pmport_mutex);
11630 			return (SATA_SUCCESS);
11631 		}
11632 	}
11633 
11634 	/*
11635 	 * Sanity check - Controller port is active? Is the link active?
11636 	 * Is it still a port multiplier?
11637 	 */
11638 	if ((cportinfo->cport_state &
11639 	    (SATA_PSTATE_SHUTDOWN | SATA_PSTATE_FAILED)) ||
11640 	    (cportinfo->cport_scr.sstatus & SATA_PORT_DEVLINK_UP_MASK) !=
11641 	    SATA_PORT_DEVLINK_UP ||
11642 	    (cportinfo->cport_dev_type != SATA_DTYPE_PMULT)) {
11643 		/*
11644 		 * Port in non-usable state or no link active/no
11645 		 * device. Free info structure.
11646 		 */
11647 		cportinfo->cport_dev_type = SATA_DTYPE_UNKNOWN;
11648 
11649 		sdevice.satadev_addr.cport = cport;
11650 		sdevice.satadev_addr.pmport = pmport;
11651 		sdevice.satadev_addr.qual = SATA_ADDR_PMULT;
11652 		mutex_exit(&cportinfo->cport_mutex);
11653 
11654 		sata_free_pmult(sata_hba_inst, &sdevice);
11655 		return (SATA_FAILURE);
11656 	}
11657 
11658 	/* SATA_SUCCESS NOW */
11659 	/*
11660 	 * update sata port state and set device type
11661 	 */
11662 	mutex_enter(&pmportinfo->pmport_mutex);
11663 	sata_update_pmport_info(sata_hba_inst, sata_device);
11664 	pmportinfo->pmport_state &= ~SATA_STATE_PROBING;
11665 
11666 	/*
11667 	 * Sanity check - Port is active? Is the link active?
11668 	 * Is there any device attached?
11669 	 */
11670 	if ((pmportinfo->pmport_state &
11671 	    (SATA_PSTATE_SHUTDOWN | SATA_PSTATE_FAILED)) ||
11672 	    (pmportinfo->pmport_scr.sstatus & SATA_PORT_DEVLINK_UP_MASK) !=
11673 	    SATA_PORT_DEVLINK_UP) {
11674 		/*
11675 		 * Port in non-usable state or no link active/no device.
11676 		 * Free info structure if necessary (direct attached drive
11677 		 * only, for now!
11678 		 */
11679 		sdinfo = SATA_PMPORTINFO_DRV_INFO(pmportinfo);
11680 		SATA_PMPORTINFO_DRV_INFO(pmportinfo) = NULL;
11681 		/* Add here differentiation for device attached or not */
11682 		pmportinfo->pmport_dev_type = SATA_DTYPE_NONE;
11683 		mutex_exit(&pmportinfo->pmport_mutex);
11684 		if (sdinfo != NULL)
11685 			kmem_free(sdinfo, sizeof (sata_drive_info_t));
11686 		return (SATA_SUCCESS);
11687 	}
11688 
11689 	pmportinfo->pmport_state |= SATA_STATE_READY;
11690 	pmportinfo->pmport_dev_type = sata_device->satadev_type;
11691 	sdinfo = SATA_PMPORTINFO_DRV_INFO(pmportinfo);
11692 
11693 	/*
11694 	 * If we are re-probing the port, there may be
11695 	 * sata_drive_info structure attached
11696 	 * (or sata_pm_info, if PMult is supported).
11697 	 */
11698 	if (sata_device->satadev_type == SATA_DTYPE_NONE) {
11699 		/*
11700 		 * There is no device, so remove device info structure,
11701 		 * if necessary.
11702 		 */
11703 		SATA_PMPORTINFO_DRV_INFO(pmportinfo) = NULL;
11704 		pmportinfo->pmport_dev_type = SATA_DTYPE_NONE;
11705 		if (sdinfo != NULL) {
11706 			kmem_free(sdinfo, sizeof (sata_drive_info_t));
11707 			sata_log(sata_hba_inst, CE_WARN,
11708 			    "SATA device detached from port %d:%d",
11709 			    cport, pmport);
11710 		}
11711 		mutex_exit(&pmportinfo->pmport_mutex);
11712 		return (SATA_SUCCESS);
11713 	}
11714 
11715 	/* this should not be a pmult */
11716 	ASSERT(sata_device->satadev_type != SATA_DTYPE_PMULT);
11717 	if (sdinfo == NULL) {
11718 		/*
11719 		 * There is some device attached, but there is
11720 		 * no sata_drive_info structure - allocate one
11721 		 */
11722 		mutex_exit(&pmportinfo->pmport_mutex);
11723 		sdinfo = kmem_zalloc(sizeof (sata_drive_info_t),
11724 		    KM_SLEEP);
11725 		mutex_enter(&pmportinfo->pmport_mutex);
11726 		/*
11727 		 * Recheck, that the port state did not change when we
11728 		 * released mutex.
11729 		 */
11730 		if (pmportinfo->pmport_state & SATA_STATE_READY) {
11731 			SATA_PMPORTINFO_DRV_INFO(pmportinfo) = sdinfo;
11732 			sdinfo->satadrv_addr = pmportinfo->pmport_addr;
11733 			sdinfo->satadrv_addr.qual = SATA_ADDR_DPMPORT;
11734 			sdinfo->satadrv_type = SATA_DTYPE_UNKNOWN;
11735 			sdinfo->satadrv_state = SATA_STATE_UNKNOWN;
11736 		} else {
11737 			/*
11738 			 * Port is not in ready state, we
11739 			 * cannot attach a device.
11740 			 */
11741 			mutex_exit(&pmportinfo->pmport_mutex);
11742 			kmem_free(sdinfo, sizeof (sata_drive_info_t));
11743 			return (SATA_SUCCESS);
11744 		}
11745 		/*
11746 		 * Since we are adding device, presumably new one,
11747 		 * indicate that it  should be initalized,
11748 		 * as well as some internal framework states).
11749 		 */
11750 		init_device = B_TRUE;
11751 	}
11752 
11753 	pmportinfo->pmport_dev_type = SATA_DTYPE_UNKNOWN;
11754 	sata_device->satadev_addr.qual = sdinfo->satadrv_addr.qual;
11755 
11756 	mutex_exit(&pmportinfo->pmport_mutex);
11757 	/*
11758 	 * Figure out what kind of device we are really
11759 	 * dealing with.
11760 	 */
11761 	rval = sata_probe_device(sata_hba_inst, sata_device);
11762 
11763 	mutex_enter(&pmportinfo->pmport_mutex);
11764 	if (rval == SATA_SUCCESS) {
11765 		/*
11766 		 * If we are dealing with the same type of a device as before,
11767 		 * restore its settings flags.
11768 		 */
11769 		if (osdinfo != NULL &&
11770 		    sata_device->satadev_type == prev_device_type)
11771 			sdinfo->satadrv_settings = prev_device_settings;
11772 
11773 		mutex_exit(&pmportinfo->pmport_mutex);
11774 		/* Set initial device features, if necessary */
11775 		if (init_device == B_TRUE) {
11776 			rval = sata_initialize_device(sata_hba_inst, sdinfo);
11777 		}
11778 		if (rval == SATA_SUCCESS)
11779 			return (rval);
11780 	} else {
11781 		/*
11782 		 * If there was some device info before we probe the device,
11783 		 * restore previous device setting, so we can retry from scratch
11784 		 * later. Providing, of course, that device has not disappeared
11785 		 * during probing process.
11786 		 */
11787 		if (sata_device->satadev_type != SATA_DTYPE_NONE) {
11788 			if (osdinfo != NULL) {
11789 				pmportinfo->pmport_dev_type = prev_device_type;
11790 				sdinfo->satadrv_type = prev_device_type;
11791 				sdinfo->satadrv_state = prev_device_state;
11792 			}
11793 		} else {
11794 			/* device is gone */
11795 			kmem_free(sdinfo, sizeof (sata_drive_info_t));
11796 			pmportinfo->pmport_dev_type = SATA_DTYPE_NONE;
11797 			SATA_PMPORTINFO_DRV_INFO(pmportinfo) = NULL;
11798 			mutex_exit(&pmportinfo->pmport_mutex);
11799 			return (SATA_SUCCESS);
11800 		}
11801 		mutex_exit(&pmportinfo->pmport_mutex);
11802 	}
11803 
11804 	if (flag == SATA_DEV_IDENTIFY_RETRY) {
11805 		clock_t cur_time = ddi_get_lbolt();
11806 		/*
11807 		 * A device was not successfully identified or initialized.
11808 		 * Track retry time for device identification.
11809 		 */
11810 		if ((cur_time - start_time) <
11811 		    drv_usectohz(SATA_DEV_REPROBE_TIMEOUT)) {
11812 			/* sleep for a while */
11813 			delay(drv_usectohz(SATA_DEV_RETRY_DLY));
11814 			goto retry_probe_pmport;
11815 		} else {
11816 			mutex_enter(&pmportinfo->pmport_mutex);
11817 			if (SATA_PMPORTINFO_DRV_INFO(pmportinfo) != NULL)
11818 				SATA_PMPORTINFO_DRV_INFO(pmportinfo)->
11819 				    satadrv_state = SATA_DSTATE_FAILED;
11820 			mutex_exit(&pmportinfo->pmport_mutex);
11821 		}
11822 	}
11823 	return (SATA_SUCCESS);
11824 }
11825 
11826 /*
11827  * Allocated related structure for a port multiplier and its device ports
11828  *
11829  * Port multiplier should be ready and probed, and related information like
11830  * the number of the device ports should be store in sata_device_t.
11831  *
11832  * NOTE: No Mutex should be hold.
11833  */
11834 static int
11835 sata_alloc_pmult(sata_hba_inst_t *sata_hba_inst, sata_device_t *sata_device)
11836 {
11837 	dev_info_t *dip = SATA_DIP(sata_hba_inst);
11838 	sata_cport_info_t *cportinfo = NULL;
11839 	sata_pmult_info_t *pmultinfo = NULL;
11840 	sata_pmport_info_t *pmportinfo = NULL;
11841 	sata_device_t sd;
11842 	dev_t minor_number;
11843 	char name[16];
11844 	uint8_t cport = sata_device->satadev_addr.cport;
11845 	int rval;
11846 	int npmport;
11847 
11848 	cportinfo = SATA_CPORT_INFO(sata_hba_inst, cport);
11849 
11850 	/* This function might be called while a port-mult is hot-plugged. */
11851 	mutex_enter(&cportinfo->cport_mutex);
11852 
11853 	/* dev_type's not updated when get called from sata_reprobe_port() */
11854 	if (SATA_CPORTINFO_PMULT_INFO(cportinfo) == NULL) {
11855 		/* Create a pmult_info structure */
11856 		SATA_CPORTINFO_PMULT_INFO(cportinfo) =
11857 		    kmem_zalloc(sizeof (sata_pmult_info_t), KM_SLEEP);
11858 	}
11859 	pmultinfo = SATA_CPORTINFO_PMULT_INFO(cportinfo);
11860 
11861 	pmultinfo->pmult_addr = sata_device->satadev_addr;
11862 	pmultinfo->pmult_addr.qual = SATA_ADDR_PMULT;
11863 	pmultinfo->pmult_state = SATA_STATE_PROBING;
11864 
11865 	/*
11866 	 * Probe the port multiplier with qualifier SATA_ADDR_PMULT_SPEC,
11867 	 * The HBA driver should initialize and register the port multiplier,
11868 	 * sata_register_pmult() will fill following fields,
11869 	 *   + sata_pmult_info.pmult_gscr
11870 	 *   + sata_pmult_info.pmult_num_dev_ports
11871 	 */
11872 	sd.satadev_addr = sata_device->satadev_addr;
11873 	sd.satadev_addr.qual = SATA_ADDR_PMULT_SPEC;
11874 	mutex_exit(&cportinfo->cport_mutex);
11875 	rval = (*SATA_PROBE_PORT_FUNC(sata_hba_inst))
11876 	    (SATA_DIP(sata_hba_inst), &sd);
11877 	mutex_enter(&cportinfo->cport_mutex);
11878 
11879 	if (rval != SATA_SUCCESS ||
11880 	    (sd.satadev_type != SATA_DTYPE_PMULT) ||
11881 	    !(sd.satadev_state & SATA_DSTATE_PMULT_INIT)) {
11882 		SATA_CPORTINFO_PMULT_INFO(cportinfo) = NULL;
11883 		kmem_free(pmultinfo, sizeof (sata_pmult_info_t));
11884 		cportinfo->cport_state = SATA_PSTATE_FAILED;
11885 		cportinfo->cport_dev_type = SATA_DTYPE_UNKNOWN;
11886 		mutex_exit(&cportinfo->cport_mutex);
11887 		SATADBG1(SATA_DBG_PMULT, sata_hba_inst,
11888 		    "sata_alloc_pmult: failed to initialize pmult "
11889 		    "at port %d.", cport)
11890 		return (SATA_FAILURE);
11891 	}
11892 
11893 	/* Initialize pmport_info structure */
11894 	for (npmport = 0; npmport < pmultinfo->pmult_num_dev_ports;
11895 	    npmport++) {
11896 
11897 		/* if everything is allocated, skip */
11898 		if (SATA_PMPORT_INFO(sata_hba_inst, cport, npmport) != NULL)
11899 			continue;
11900 
11901 		pmportinfo = kmem_zalloc(sizeof (sata_pmport_info_t), KM_SLEEP);
11902 		mutex_init(&pmportinfo->pmport_mutex, NULL, MUTEX_DRIVER, NULL);
11903 		mutex_exit(&cportinfo->cport_mutex);
11904 
11905 		mutex_enter(&pmportinfo->pmport_mutex);
11906 		pmportinfo->pmport_addr.cport = cport;
11907 		pmportinfo->pmport_addr.pmport = (uint8_t)npmport;
11908 		pmportinfo->pmport_addr.qual = SATA_ADDR_PMPORT;
11909 		pmportinfo->pmport_state &= ~SATA_PORT_STATE_CLEAR_MASK;
11910 		mutex_exit(&pmportinfo->pmport_mutex);
11911 
11912 		mutex_enter(&cportinfo->cport_mutex);
11913 		SATA_PMPORT_INFO(sata_hba_inst, cport, npmport) = pmportinfo;
11914 
11915 		/* Create an attachment point */
11916 		minor_number = SATA_MAKE_AP_MINOR(ddi_get_instance(dip),
11917 		    cport, (uint8_t)npmport, SATA_ADDR_PMPORT);
11918 		(void) sprintf(name, "%d.%d", cport, npmport);
11919 
11920 		if (ddi_create_minor_node(dip, name, S_IFCHR, minor_number,
11921 		    DDI_NT_SATA_ATTACHMENT_POINT, 0) != DDI_SUCCESS) {
11922 			sata_log(sata_hba_inst, CE_WARN, "sata_hba_attach: "
11923 			    "cannot create SATA attachment point for "
11924 			    "port %d:%d", cport, npmport);
11925 		}
11926 	}
11927 
11928 	pmultinfo->pmult_state &= ~SATA_STATE_PROBING;
11929 	pmultinfo->pmult_state |= (SATA_STATE_PROBED|SATA_STATE_READY);
11930 	cportinfo->cport_dev_type = SATA_DTYPE_PMULT;
11931 
11932 	mutex_exit(&cportinfo->cport_mutex);
11933 	return (SATA_SUCCESS);
11934 }
11935 
11936 /*
11937  * Free data structures when a port multiplier is removed.
11938  *
11939  * NOTE: No Mutex should be hold.
11940  */
11941 static void
11942 sata_free_pmult(sata_hba_inst_t *sata_hba_inst, sata_device_t *sata_device)
11943 {
11944 	sata_cport_info_t *cportinfo;
11945 	sata_pmult_info_t *pmultinfo;
11946 	sata_pmport_info_t *pmportinfo;
11947 	sata_device_t pmport_device;
11948 	sata_drive_info_t *sdinfo;
11949 	dev_info_t *tdip;
11950 	char name[16];
11951 	uint8_t cport = sata_device->satadev_addr.cport;
11952 	int npmport;
11953 
11954 	cportinfo = SATA_CPORT_INFO(sata_hba_inst, cport);
11955 
11956 	/* This function might be called while port-mult is hot plugged. */
11957 	mutex_enter(&cportinfo->cport_mutex);
11958 
11959 	cportinfo->cport_dev_type = SATA_DTYPE_NONE;
11960 	pmultinfo = SATA_CPORTINFO_PMULT_INFO(cportinfo);
11961 	ASSERT(pmultinfo != NULL);
11962 
11963 	/* Free pmport_info structure */
11964 	for (npmport = 0; npmport < pmultinfo->pmult_num_dev_ports;
11965 	    npmport++) {
11966 		pmportinfo = SATA_PMPORT_INFO(sata_hba_inst, cport, npmport);
11967 		if (pmportinfo == NULL)
11968 			continue;
11969 		mutex_exit(&cportinfo->cport_mutex);
11970 
11971 		mutex_enter(&pmportinfo->pmport_mutex);
11972 		sdinfo = pmportinfo->pmport_sata_drive;
11973 		SATA_PMPORTINFO_DRV_INFO(pmportinfo) = NULL;
11974 		mutex_exit(&pmportinfo->pmport_mutex);
11975 
11976 		/* Remove attachment point. */
11977 		name[0] = '\0';
11978 		(void) sprintf(name, "%d.%d", cport, npmport);
11979 		ddi_remove_minor_node(SATA_DIP(sata_hba_inst), name);
11980 		sata_log(sata_hba_inst, CE_NOTE,
11981 		    "Remove attachment point of port %d:%d",
11982 		    cport, npmport);
11983 
11984 		/*
11985 		 * Rumove target node
11986 		 */
11987 		bzero(&pmport_device, sizeof (sata_device_t));
11988 		pmport_device.satadev_rev = SATA_DEVICE_REV;
11989 		pmport_device.satadev_addr.cport = cport;
11990 		pmport_device.satadev_addr.pmport = (uint8_t)npmport;
11991 		pmport_device.satadev_addr.qual = SATA_ADDR_DPMPORT;
11992 
11993 		tdip = sata_get_scsi_target_dip(SATA_DIP(sata_hba_inst),
11994 		    &(pmport_device.satadev_addr));
11995 		if (tdip != NULL && ndi_devi_offline(tdip,
11996 		    NDI_DEVI_REMOVE) != NDI_SUCCESS) {
11997 			/*
11998 			 * Problem :
11999 			 * The target node remained attached.
12000 			 * This happens when the device file was open
12001 			 * or a node was waiting for resources.
12002 			 * Cannot do anything about it.
12003 			 */
12004 			SATA_LOG_D((sata_hba_inst, CE_WARN,
12005 			    "sata_free_pmult: could not unconfigure device "
12006 			    "before disconnecting the SATA port %d:%d",
12007 			    cport, npmport));
12008 
12009 			/*
12010 			 * Set DEVICE REMOVED state in the target
12011 			 * node. It will prevent access to the device
12012 			 * even when a new device is attached, until
12013 			 * the old target node is released, removed and
12014 			 * recreated for a new  device.
12015 			 */
12016 			sata_set_device_removed(tdip);
12017 
12018 			/*
12019 			 * Instruct event daemon to try the target
12020 			 * node cleanup later.
12021 			 */
12022 			sata_set_target_node_cleanup(
12023 			    sata_hba_inst, &(pmport_device.satadev_addr));
12024 
12025 		}
12026 		mutex_enter(&cportinfo->cport_mutex);
12027 
12028 		/*
12029 		 * Add here differentiation for device attached or not
12030 		 */
12031 		if (sdinfo != NULL)  {
12032 			sata_log(sata_hba_inst, CE_WARN,
12033 			    "SATA device detached from port %d:%d",
12034 			    cport, npmport);
12035 			kmem_free(sdinfo, sizeof (sata_drive_info_t));
12036 		}
12037 
12038 		mutex_destroy(&pmportinfo->pmport_mutex);
12039 		kmem_free(pmportinfo, sizeof (sata_pmport_info_t));
12040 	}
12041 
12042 	kmem_free(pmultinfo, sizeof (sata_pmult_info_t));
12043 
12044 	cportinfo->cport_devp.cport_sata_pmult = NULL;
12045 
12046 	sata_log(sata_hba_inst, CE_WARN,
12047 	    "SATA port multiplier detached at port %d", cport);
12048 
12049 	mutex_exit(&cportinfo->cport_mutex);
12050 }
12051 
12052 /*
12053  * Initialize device
12054  * Specified device is initialized to a default state.
12055  *
12056  * Returns SATA_SUCCESS if all device features are set successfully,
12057  * SATA_RETRY if device is accessible but device features were not set
12058  * successfully, and SATA_FAILURE otherwise.
12059  */
12060 static int
12061 sata_initialize_device(sata_hba_inst_t *sata_hba_inst,
12062     sata_drive_info_t *sdinfo)
12063 {
12064 	int rval;
12065 
12066 	sata_save_drive_settings(sdinfo);
12067 
12068 	sdinfo->satadrv_settings |= SATA_DEV_READ_AHEAD;
12069 
12070 	sata_init_write_cache_mode(sdinfo);
12071 
12072 	rval = sata_set_drive_features(sata_hba_inst, sdinfo, 0);
12073 
12074 	/* Determine current data transfer mode */
12075 	if ((sdinfo->satadrv_id.ai_cap & SATA_DMA_SUPPORT) == 0) {
12076 		sdinfo->satadrv_settings &= ~SATA_DEV_DMA;
12077 	} else if ((sdinfo->satadrv_id.ai_validinfo &
12078 	    SATA_VALIDINFO_88) != 0 &&
12079 	    (sdinfo->satadrv_id.ai_ultradma & SATA_UDMA_SEL_MASK) != 0) {
12080 		sdinfo->satadrv_settings |= SATA_DEV_DMA;
12081 	} else if ((sdinfo->satadrv_id.ai_dworddma &
12082 	    SATA_MDMA_SEL_MASK) != 0) {
12083 		sdinfo->satadrv_settings |= SATA_DEV_DMA;
12084 	} else
12085 		/* DMA supported, not no DMA transfer mode is selected !? */
12086 		sdinfo->satadrv_settings &= ~SATA_DEV_DMA;
12087 
12088 	if ((sdinfo->satadrv_id.ai_cmdset83 & 0x20) &&
12089 	    (sdinfo->satadrv_id.ai_features86 & 0x20))
12090 		sdinfo->satadrv_power_level = SATA_POWER_STANDBY;
12091 	else
12092 		sdinfo->satadrv_power_level = SATA_POWER_ACTIVE;
12093 
12094 	return (rval);
12095 }
12096 
12097 
12098 /*
12099  * Initialize write cache mode.
12100  *
12101  * The default write cache setting for SATA HDD is provided by sata_write_cache
12102  * static variable. ATAPI CD/DVDs devices have write cache default is
12103  * determined by sata_atapicdvd_write_cache static variable.
12104  * ATAPI tape devices have write cache default is determined by
12105  * sata_atapitape_write_cache static variable.
12106  * ATAPI disk devices have write cache default is determined by
12107  * sata_atapidisk_write_cache static variable.
12108  * 1 - enable
12109  * 0 - disable
12110  * any other value - current drive setting
12111  *
12112  * Although there is not reason to disable write cache on CD/DVD devices,
12113  * tape devices and ATAPI disk devices, the default setting control is provided
12114  * for the maximun flexibility.
12115  *
12116  * In the future, it may be overridden by the
12117  * disk-write-cache-enable property setting, if it is defined.
12118  * Returns SATA_SUCCESS if all device features are set successfully,
12119  * SATA_FAILURE otherwise.
12120  */
12121 static void
12122 sata_init_write_cache_mode(sata_drive_info_t *sdinfo)
12123 {
12124 	switch (sdinfo->satadrv_type) {
12125 	case SATA_DTYPE_ATADISK:
12126 		if (sata_write_cache == 1)
12127 			sdinfo->satadrv_settings |= SATA_DEV_WRITE_CACHE;
12128 		else if (sata_write_cache == 0)
12129 			sdinfo->satadrv_settings &= ~SATA_DEV_WRITE_CACHE;
12130 		/*
12131 		 * When sata_write_cache value is not 0 or 1,
12132 		 * a current setting of the drive's write cache is used.
12133 		 */
12134 		break;
12135 	case SATA_DTYPE_ATAPICD:
12136 		if (sata_atapicdvd_write_cache == 1)
12137 			sdinfo->satadrv_settings |= SATA_DEV_WRITE_CACHE;
12138 		else if (sata_atapicdvd_write_cache == 0)
12139 			sdinfo->satadrv_settings &= ~SATA_DEV_WRITE_CACHE;
12140 		/*
12141 		 * When sata_atapicdvd_write_cache value is not 0 or 1,
12142 		 * a current setting of the drive's write cache is used.
12143 		 */
12144 		break;
12145 	case SATA_DTYPE_ATAPITAPE:
12146 		if (sata_atapitape_write_cache == 1)
12147 			sdinfo->satadrv_settings |= SATA_DEV_WRITE_CACHE;
12148 		else if (sata_atapitape_write_cache == 0)
12149 			sdinfo->satadrv_settings &= ~SATA_DEV_WRITE_CACHE;
12150 		/*
12151 		 * When sata_atapitape_write_cache value is not 0 or 1,
12152 		 * a current setting of the drive's write cache is used.
12153 		 */
12154 		break;
12155 	case SATA_DTYPE_ATAPIDISK:
12156 		if (sata_atapidisk_write_cache == 1)
12157 			sdinfo->satadrv_settings |= SATA_DEV_WRITE_CACHE;
12158 		else if (sata_atapidisk_write_cache == 0)
12159 			sdinfo->satadrv_settings &= ~SATA_DEV_WRITE_CACHE;
12160 		/*
12161 		 * When sata_atapidisk_write_cache value is not 0 or 1,
12162 		 * a current setting of the drive's write cache is used.
12163 		 */
12164 		break;
12165 	}
12166 }
12167 
12168 
12169 /*
12170  * Validate sata address.
12171  * Specified cport, pmport and qualifier has to match
12172  * passed sata_scsi configuration info.
12173  * The presence of an attached device is not verified.
12174  *
12175  * Returns 0 when address is valid, -1 otherwise.
12176  */
12177 static int
12178 sata_validate_sata_address(sata_hba_inst_t *sata_hba_inst, int cport,
12179 	int pmport, int qual)
12180 {
12181 	if (qual == SATA_ADDR_DCPORT && pmport != 0)
12182 		goto invalid_address;
12183 	if (cport >= SATA_NUM_CPORTS(sata_hba_inst))
12184 		goto invalid_address;
12185 	if ((qual == SATA_ADDR_DPMPORT || qual == SATA_ADDR_PMPORT) &&
12186 	    ((SATA_CPORT_DEV_TYPE(sata_hba_inst, cport) != SATA_DTYPE_PMULT) ||
12187 	    (SATA_PMULT_INFO(sata_hba_inst, cport) == NULL) ||
12188 	    (pmport >= SATA_NUM_PMPORTS(sata_hba_inst, cport))))
12189 		goto invalid_address;
12190 
12191 	return (0);
12192 
12193 invalid_address:
12194 	return (-1);
12195 
12196 }
12197 
12198 /*
12199  * Validate scsi address
12200  * SCSI target address is translated into SATA cport/pmport and compared
12201  * with a controller port/device configuration. LUN has to be 0.
12202  * Returns 0 if a scsi target refers to an attached device,
12203  * returns 1 if address is valid but no valid device is attached,
12204  * returns 2 if address is valid but device type is unknown (not valid device),
12205  * returns -1 if bad address or device is of an unsupported type.
12206  * Upon return sata_device argument is set.
12207  *
12208  * Port multiplier is supported now.
12209  */
12210 static int
12211 sata_validate_scsi_address(sata_hba_inst_t *sata_hba_inst,
12212 	struct scsi_address *ap, sata_device_t *sata_device)
12213 {
12214 	int cport, pmport, qual, rval;
12215 
12216 	rval = -1;	/* Invalid address */
12217 	if (ap->a_lun != 0)
12218 		goto out;
12219 
12220 	qual = SCSI_TO_SATA_ADDR_QUAL(ap->a_target);
12221 	cport = SCSI_TO_SATA_CPORT(ap->a_target);
12222 	pmport = SCSI_TO_SATA_PMPORT(ap->a_target);
12223 
12224 	if (qual != SATA_ADDR_DCPORT && qual != SATA_ADDR_DPMPORT)
12225 		goto out;
12226 
12227 	if (sata_validate_sata_address(sata_hba_inst, cport, pmport, qual) ==
12228 	    0) {
12229 
12230 		sata_cport_info_t *cportinfo;
12231 		sata_pmult_info_t *pmultinfo;
12232 		sata_drive_info_t *sdinfo = NULL;
12233 
12234 		sata_device->satadev_addr.qual = qual;
12235 		sata_device->satadev_addr.cport = cport;
12236 		sata_device->satadev_addr.pmport = pmport;
12237 		sata_device->satadev_rev = SATA_DEVICE_REV_1;
12238 
12239 		rval = 1;	/* Valid sata address */
12240 
12241 		cportinfo = SATA_CPORT_INFO(sata_hba_inst, cport);
12242 		if (qual == SATA_ADDR_DCPORT) {
12243 			if (cportinfo == NULL ||
12244 			    cportinfo->cport_dev_type == SATA_DTYPE_NONE)
12245 				goto out;
12246 
12247 			sdinfo = SATA_CPORTINFO_DRV_INFO(cportinfo);
12248 			if (cportinfo->cport_dev_type == SATA_DTYPE_UNKNOWN &&
12249 			    sdinfo != NULL) {
12250 				rval = 2;
12251 				goto out;
12252 			}
12253 
12254 			if ((cportinfo->cport_dev_type &
12255 			    SATA_VALID_DEV_TYPE) == 0) {
12256 				rval = -1;
12257 				goto out;
12258 			}
12259 
12260 		} else if (qual == SATA_ADDR_DPMPORT) {
12261 			pmultinfo = SATA_CPORTINFO_PMULT_INFO(cportinfo);
12262 			if (pmultinfo == NULL) {
12263 				rval = -1;
12264 				goto out;
12265 			}
12266 			if (SATA_PMPORT_INFO(sata_hba_inst, cport, pmport) ==
12267 			    NULL ||
12268 			    SATA_PMPORT_DEV_TYPE(sata_hba_inst, cport,
12269 			    pmport) == SATA_DTYPE_NONE)
12270 				goto out;
12271 
12272 			sdinfo = SATA_PMPORT_DRV_INFO(sata_hba_inst, cport,
12273 			    pmport);
12274 			if (SATA_PMPORT_DEV_TYPE(sata_hba_inst, cport,
12275 			    pmport) == SATA_DTYPE_UNKNOWN && sdinfo != NULL) {
12276 				rval = 2;
12277 				goto out;
12278 			}
12279 
12280 			if ((SATA_PMPORT_DEV_TYPE(sata_hba_inst, cport,
12281 			    pmport) & SATA_VALID_DEV_TYPE) == 0) {
12282 				rval = -1;
12283 				goto out;
12284 			}
12285 
12286 		} else {
12287 			rval = -1;
12288 			goto out;
12289 		}
12290 		if ((sdinfo == NULL) ||
12291 		    (sdinfo->satadrv_type & SATA_VALID_DEV_TYPE) == 0)
12292 			goto out;
12293 
12294 		sata_device->satadev_type = sdinfo->satadrv_type;
12295 
12296 		return (0);
12297 	}
12298 out:
12299 	if (rval > 0) {
12300 		SATADBG2(SATA_DBG_SCSI_IF, sata_hba_inst,
12301 		    "sata_validate_scsi_address: no valid target %x lun %x",
12302 		    ap->a_target, ap->a_lun);
12303 	}
12304 	return (rval);
12305 }
12306 
12307 /*
12308  * Find dip corresponding to passed device number
12309  *
12310  * Returns NULL if invalid device number is passed or device cannot be found,
12311  * Returns dip is device is found.
12312  */
12313 static dev_info_t *
12314 sata_devt_to_devinfo(dev_t dev)
12315 {
12316 	dev_info_t *dip;
12317 #ifndef __lock_lint
12318 	struct devnames *dnp;
12319 	major_t major = getmajor(dev);
12320 	int instance = SATA_MINOR2INSTANCE(getminor(dev));
12321 
12322 	if (major >= devcnt)
12323 		return (NULL);
12324 
12325 	dnp = &devnamesp[major];
12326 	LOCK_DEV_OPS(&(dnp->dn_lock));
12327 	dip = dnp->dn_head;
12328 	while (dip && (ddi_get_instance(dip) != instance)) {
12329 		dip = ddi_get_next(dip);
12330 	}
12331 	UNLOCK_DEV_OPS(&(dnp->dn_lock));
12332 #endif
12333 
12334 	return (dip);
12335 }
12336 
12337 
12338 /*
12339  * Probe device.
12340  * This function issues Identify Device command and initializes local
12341  * sata_drive_info structure if the device can be identified.
12342  * The device type is determined by examining Identify Device
12343  * command response.
12344  * If the sata_hba_inst has linked drive info structure for this
12345  * device address, the Identify Device data is stored into sata_drive_info
12346  * structure linked to the port info structure.
12347  *
12348  * sata_device has to refer to the valid sata port(s) for HBA described
12349  * by sata_hba_inst structure.
12350  *
12351  * Returns:
12352  *	SATA_SUCCESS if device type was successfully probed and port-linked
12353  *		drive info structure was updated;
12354  * 	SATA_FAILURE if there is no device, or device was not probed
12355  *		successully;
12356  *	SATA_RETRY if device probe can be retried later.
12357  * If a device cannot be identified, sata_device's dev_state and dev_type
12358  * fields are set to unknown.
12359  * There are no retries in this function. Any retries should be managed by
12360  * the caller.
12361  */
12362 
12363 
12364 static int
12365 sata_probe_device(sata_hba_inst_t *sata_hba_inst, sata_device_t *sata_device)
12366 {
12367 	sata_pmport_info_t *pmportinfo;
12368 	sata_drive_info_t *sdinfo;
12369 	sata_drive_info_t new_sdinfo;	/* local drive info struct */
12370 	int rval;
12371 
12372 	ASSERT((SATA_CPORT_STATE(sata_hba_inst,
12373 	    sata_device->satadev_addr.cport) &
12374 	    (SATA_STATE_PROBED | SATA_STATE_READY)) != 0);
12375 
12376 	sata_device->satadev_type = SATA_DTYPE_NONE;
12377 
12378 	mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst,
12379 	    sata_device->satadev_addr.cport)));
12380 
12381 	if (sata_device->satadev_addr.qual == SATA_ADDR_DPMPORT) {
12382 		pmportinfo = SATA_PMPORT_INFO(sata_hba_inst,
12383 		    sata_device->satadev_addr.cport,
12384 		    sata_device->satadev_addr.pmport);
12385 		ASSERT(pmportinfo != NULL);
12386 	}
12387 
12388 	/* Get pointer to port-linked sata device info structure */
12389 	sdinfo = sata_get_device_info(sata_hba_inst, sata_device);
12390 	if (sdinfo != NULL) {
12391 		sdinfo->satadrv_state &=
12392 		    ~(SATA_STATE_PROBED | SATA_STATE_READY);
12393 		sdinfo->satadrv_state |= SATA_STATE_PROBING;
12394 	} else {
12395 		/* No device to probe */
12396 		mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst,
12397 		    sata_device->satadev_addr.cport)));
12398 		sata_device->satadev_type = SATA_DTYPE_NONE;
12399 		sata_device->satadev_state = SATA_STATE_UNKNOWN;
12400 		return (SATA_FAILURE);
12401 	}
12402 	/*
12403 	 * Need to issue both types of identify device command and
12404 	 * determine device type by examining retreived data/status.
12405 	 * First, ATA Identify Device.
12406 	 */
12407 	bzero(&new_sdinfo, sizeof (sata_drive_info_t));
12408 	new_sdinfo.satadrv_addr = sata_device->satadev_addr;
12409 	mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst,
12410 	    sata_device->satadev_addr.cport)));
12411 	new_sdinfo.satadrv_type = SATA_DTYPE_ATADISK;
12412 	rval = sata_identify_device(sata_hba_inst, &new_sdinfo);
12413 	if (rval == SATA_RETRY) {
12414 		/* We may try to check for ATAPI device */
12415 		if (SATA_FEATURES(sata_hba_inst) & SATA_CTLF_ATAPI) {
12416 			/*
12417 			 * HBA supports ATAPI - try to issue Identify Packet
12418 			 * Device command.
12419 			 */
12420 			new_sdinfo.satadrv_type = SATA_DTYPE_ATAPI;
12421 			rval = sata_identify_device(sata_hba_inst, &new_sdinfo);
12422 		}
12423 	}
12424 	if (rval == SATA_SUCCESS) {
12425 		/*
12426 		 * Got something responding positively to ATA Identify Device
12427 		 * or to Identify Packet Device cmd.
12428 		 * Save last used device type.
12429 		 */
12430 		sata_device->satadev_type = new_sdinfo.satadrv_type;
12431 
12432 		/* save device info, if possible */
12433 		mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst,
12434 		    sata_device->satadev_addr.cport)));
12435 		sdinfo = sata_get_device_info(sata_hba_inst, sata_device);
12436 		if (sdinfo == NULL) {
12437 			mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst,
12438 			    sata_device->satadev_addr.cport)));
12439 			return (SATA_FAILURE);
12440 		}
12441 		/*
12442 		 * Copy drive info into the port-linked drive info structure.
12443 		 */
12444 		*sdinfo = new_sdinfo;
12445 		sdinfo->satadrv_state &= ~SATA_STATE_PROBING;
12446 		sdinfo->satadrv_state |= SATA_STATE_PROBED;
12447 		if (sata_device->satadev_addr.qual == SATA_ADDR_DCPORT)
12448 			SATA_CPORT_DEV_TYPE(sata_hba_inst,
12449 			    sata_device->satadev_addr.cport) =
12450 			    sdinfo->satadrv_type;
12451 		else { /* SATA_ADDR_DPMPORT */
12452 			mutex_enter(&pmportinfo->pmport_mutex);
12453 			SATA_PMPORT_DEV_TYPE(sata_hba_inst,
12454 			    sata_device->satadev_addr.cport,
12455 			    sata_device->satadev_addr.pmport) =
12456 			    sdinfo->satadrv_type;
12457 			mutex_exit(&pmportinfo->pmport_mutex);
12458 		}
12459 		mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst,
12460 		    sata_device->satadev_addr.cport)));
12461 		return (SATA_SUCCESS);
12462 	}
12463 
12464 	/*
12465 	 * It may be SATA_RETRY or SATA_FAILURE return.
12466 	 * Looks like we cannot determine the device type at this time.
12467 	 */
12468 	mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst,
12469 	    sata_device->satadev_addr.cport)));
12470 	sdinfo = sata_get_device_info(sata_hba_inst, sata_device);
12471 	if (sdinfo != NULL) {
12472 		sata_device->satadev_type = SATA_DTYPE_UNKNOWN;
12473 		sdinfo->satadrv_type = SATA_DTYPE_UNKNOWN;
12474 		sdinfo->satadrv_state &= ~SATA_STATE_PROBING;
12475 		sdinfo->satadrv_state |= SATA_STATE_PROBED;
12476 		if (sata_device->satadev_addr.qual == SATA_ADDR_DCPORT)
12477 			SATA_CPORT_DEV_TYPE(sata_hba_inst,
12478 			    sata_device->satadev_addr.cport) =
12479 			    SATA_DTYPE_UNKNOWN;
12480 		else {
12481 			/* SATA_ADDR_DPMPORT */
12482 			mutex_enter(&pmportinfo->pmport_mutex);
12483 			if ((SATA_PMULT_INFO(sata_hba_inst,
12484 			    sata_device->satadev_addr.cport) != NULL) &&
12485 			    (SATA_PMPORT_INFO(sata_hba_inst,
12486 			    sata_device->satadev_addr.cport,
12487 			    sata_device->satadev_addr.pmport) != NULL))
12488 				SATA_PMPORT_DEV_TYPE(sata_hba_inst,
12489 				    sata_device->satadev_addr.cport,
12490 				    sata_device->satadev_addr.pmport) =
12491 				    SATA_DTYPE_UNKNOWN;
12492 			mutex_exit(&pmportinfo->pmport_mutex);
12493 		}
12494 	}
12495 	mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst,
12496 	    sata_device->satadev_addr.cport)));
12497 	return (rval);
12498 }
12499 
12500 
12501 /*
12502  * Get pointer to sata_drive_info structure.
12503  *
12504  * The sata_device has to contain address (cport, pmport and qualifier) for
12505  * specified sata_scsi structure.
12506  *
12507  * Returns NULL if device address is not valid for this HBA configuration.
12508  * Otherwise, returns a pointer to sata_drive_info structure.
12509  *
12510  * This function should be called with a port mutex held.
12511  */
12512 static sata_drive_info_t *
12513 sata_get_device_info(sata_hba_inst_t *sata_hba_inst,
12514     sata_device_t *sata_device)
12515 {
12516 	uint8_t cport = sata_device->satadev_addr.cport;
12517 	uint8_t pmport = sata_device->satadev_addr.pmport;
12518 	uint8_t qual = sata_device->satadev_addr.qual;
12519 
12520 	if (cport >= SATA_NUM_CPORTS(sata_hba_inst))
12521 		return (NULL);
12522 
12523 	if (!(SATA_CPORT_STATE(sata_hba_inst, cport) &
12524 	    (SATA_STATE_PROBED | SATA_STATE_READY)))
12525 		/* Port not probed yet */
12526 		return (NULL);
12527 
12528 	if (SATA_CPORT_DEV_TYPE(sata_hba_inst, cport) == SATA_DTYPE_NONE)
12529 		return (NULL);
12530 
12531 	if (qual == SATA_ADDR_DCPORT) {
12532 		/* Request for a device on a controller port */
12533 		if (SATA_CPORT_DEV_TYPE(sata_hba_inst, cport) ==
12534 		    SATA_DTYPE_PMULT)
12535 			/* Port multiplier attached */
12536 			return (NULL);
12537 		return (SATA_CPORT_DRV_INFO(sata_hba_inst, cport));
12538 	}
12539 	if (qual == SATA_ADDR_DPMPORT) {
12540 		if (SATA_CPORT_DEV_TYPE(sata_hba_inst, cport) !=
12541 		    SATA_DTYPE_PMULT)
12542 			return (NULL);
12543 
12544 		if (pmport > SATA_NUM_PMPORTS(sata_hba_inst, cport))
12545 			return (NULL);
12546 
12547 		if (!(SATA_PMPORT_STATE(sata_hba_inst, cport, pmport) &
12548 		    (SATA_STATE_PROBED | SATA_STATE_READY)))
12549 			/* Port multiplier port not probed yet */
12550 			return (NULL);
12551 
12552 		return (SATA_PMPORT_DRV_INFO(sata_hba_inst, cport, pmport));
12553 	}
12554 
12555 	/* we should not get here */
12556 	return (NULL);
12557 }
12558 
12559 
12560 /*
12561  * sata_identify_device.
12562  * Send Identify Device command to SATA HBA driver.
12563  * If command executes successfully, update sata_drive_info structure pointed
12564  * to by sdinfo argument, including Identify Device data.
12565  * If command fails, invalidate data in sata_drive_info.
12566  *
12567  * Cannot be called from interrupt level.
12568  *
12569  * Returns:
12570  * SATA_SUCCESS if the device was identified as a supported device,
12571  * SATA_RETRY if the device was not identified but could be retried,
12572  * SATA_FAILURE if the device was not identified and identify attempt
12573  *	should not be retried.
12574  */
12575 static int
12576 sata_identify_device(sata_hba_inst_t *sata_hba_inst,
12577     sata_drive_info_t *sdinfo)
12578 {
12579 	uint16_t cfg_word;
12580 	int rval;
12581 
12582 	/* fetch device identify data */
12583 	if ((rval = sata_fetch_device_identify_data(sata_hba_inst,
12584 	    sdinfo)) != SATA_SUCCESS)
12585 		goto fail_unknown;
12586 
12587 	cfg_word = sdinfo->satadrv_id.ai_config;
12588 
12589 	/* Set the correct device type */
12590 	if ((cfg_word & SATA_ATA_TYPE_MASK) == SATA_ATA_TYPE) {
12591 		sdinfo->satadrv_type = SATA_DTYPE_ATADISK;
12592 	} else if (cfg_word == SATA_CFA_TYPE) {
12593 		/* It's a Compact Flash media via CF-to-SATA HDD adapter */
12594 		sdinfo->satadrv_type = SATA_DTYPE_ATADISK;
12595 	} else if ((cfg_word & SATA_ATAPI_TYPE_MASK) == SATA_ATAPI_TYPE) {
12596 		switch (cfg_word & SATA_ATAPI_ID_DEV_TYPE) {
12597 		case SATA_ATAPI_CDROM_DEV:
12598 			sdinfo->satadrv_type = SATA_DTYPE_ATAPICD;
12599 			break;
12600 		case SATA_ATAPI_SQACC_DEV:
12601 			sdinfo->satadrv_type = SATA_DTYPE_ATAPITAPE;
12602 			break;
12603 		case SATA_ATAPI_DIRACC_DEV:
12604 			sdinfo->satadrv_type = SATA_DTYPE_ATAPIDISK;
12605 			break;
12606 		case SATA_ATAPI_PROC_DEV:
12607 			sdinfo->satadrv_type = SATA_DTYPE_ATAPIPROC;
12608 			break;
12609 		default:
12610 			sdinfo->satadrv_type = SATA_DTYPE_UNKNOWN;
12611 		}
12612 	} else {
12613 			sdinfo->satadrv_type = SATA_DTYPE_UNKNOWN;
12614 	}
12615 
12616 	if (sdinfo->satadrv_type == SATA_DTYPE_ATADISK) {
12617 		if (sdinfo->satadrv_capacity == 0) {
12618 			/* Non-LBA disk. Too bad... */
12619 			sata_log(sata_hba_inst, CE_WARN,
12620 			    "SATA disk device at port %d does not support LBA",
12621 			    sdinfo->satadrv_addr.cport);
12622 			rval = SATA_FAILURE;
12623 			goto fail_unknown;
12624 		}
12625 	}
12626 #if 0
12627 	/* Left for historical reason */
12628 	/*
12629 	 * Some initial version of SATA spec indicated that at least
12630 	 * UDMA mode 4 has to be supported. It is not metioned in
12631 	 * SerialATA 2.6, so this restriction is removed.
12632 	 */
12633 	/* Check for Ultra DMA modes 6 through 0 being supported */
12634 	for (i = 6; i >= 0; --i) {
12635 		if (sdinfo->satadrv_id.ai_ultradma & (1 << i))
12636 			break;
12637 	}
12638 
12639 	/*
12640 	 * At least UDMA 4 mode has to be supported. If mode 4 or
12641 	 * higher are not supported by the device, fail this
12642 	 * device.
12643 	 */
12644 	if (i < 4) {
12645 		/* No required Ultra DMA mode supported */
12646 		sata_log(sata_hba_inst, CE_WARN,
12647 		    "SATA disk device at port %d does not support UDMA "
12648 		    "mode 4 or higher", sdinfo->satadrv_addr.cport);
12649 		SATA_LOG_D((sata_hba_inst, CE_WARN,
12650 		    "mode 4 or higher required, %d supported", i));
12651 		rval = SATA_FAILURE;
12652 		goto fail_unknown;
12653 	}
12654 #endif
12655 
12656 	/*
12657 	 * For Disk devices, if it doesn't support UDMA mode, we would
12658 	 * like to return failure directly.
12659 	 */
12660 	if ((sdinfo->satadrv_type == SATA_DTYPE_ATADISK) &&
12661 	    !((sdinfo->satadrv_id.ai_validinfo & SATA_VALIDINFO_88) != 0 &&
12662 	    (sdinfo->satadrv_id.ai_ultradma & SATA_UDMA_SUP_MASK) != 0)) {
12663 		sata_log(sata_hba_inst, CE_WARN,
12664 		    "SATA disk device at port %d does not support UDMA",
12665 		    sdinfo->satadrv_addr.cport);
12666 		rval = SATA_FAILURE;
12667 		goto fail_unknown;
12668 	}
12669 
12670 	return (SATA_SUCCESS);
12671 
12672 fail_unknown:
12673 	/* Invalidate sata_drive_info ? */
12674 	sdinfo->satadrv_type = SATA_DTYPE_UNKNOWN;
12675 	sdinfo->satadrv_state = SATA_STATE_UNKNOWN;
12676 	return (rval);
12677 }
12678 
12679 /*
12680  * Log/display device information
12681  */
12682 static void
12683 sata_show_drive_info(sata_hba_inst_t *sata_hba_inst,
12684     sata_drive_info_t *sdinfo)
12685 {
12686 	int valid_version;
12687 	char msg_buf[MAXPATHLEN];
12688 	int i;
12689 
12690 	/* Show HBA path */
12691 	(void) ddi_pathname(SATA_DIP(sata_hba_inst), msg_buf);
12692 
12693 	cmn_err(CE_CONT, "?%s :\n", msg_buf);
12694 
12695 	switch (sdinfo->satadrv_type) {
12696 	case SATA_DTYPE_ATADISK:
12697 		(void) sprintf(msg_buf, "SATA disk device at");
12698 		break;
12699 
12700 	case SATA_DTYPE_ATAPICD:
12701 		(void) sprintf(msg_buf, "SATA CD/DVD (ATAPI) device at");
12702 		break;
12703 
12704 	case SATA_DTYPE_ATAPITAPE:
12705 		(void) sprintf(msg_buf, "SATA tape (ATAPI) device at");
12706 		break;
12707 
12708 	case SATA_DTYPE_ATAPIDISK:
12709 		(void) sprintf(msg_buf, "SATA disk (ATAPI) device at");
12710 		break;
12711 
12712 	case SATA_DTYPE_ATAPIPROC:
12713 		(void) sprintf(msg_buf, "SATA processor (ATAPI) device at");
12714 		break;
12715 
12716 	case SATA_DTYPE_UNKNOWN:
12717 		(void) sprintf(msg_buf,
12718 		    "Unsupported SATA device type (cfg 0x%x) at ",
12719 		    sdinfo->satadrv_id.ai_config);
12720 		break;
12721 	}
12722 
12723 	if (sdinfo->satadrv_addr.qual == SATA_ADDR_DCPORT)
12724 		cmn_err(CE_CONT, "?\t%s port %d\n",
12725 		    msg_buf, sdinfo->satadrv_addr.cport);
12726 	else
12727 		cmn_err(CE_CONT, "?\t%s port %d:%d\n",
12728 		    msg_buf, sdinfo->satadrv_addr.cport,
12729 		    sdinfo->satadrv_addr.pmport);
12730 
12731 	bcopy(&sdinfo->satadrv_id.ai_model, msg_buf,
12732 	    sizeof (sdinfo->satadrv_id.ai_model));
12733 	swab(msg_buf, msg_buf, sizeof (sdinfo->satadrv_id.ai_model));
12734 	msg_buf[sizeof (sdinfo->satadrv_id.ai_model)] = '\0';
12735 	cmn_err(CE_CONT, "?\tmodel %s\n", msg_buf);
12736 
12737 	bcopy(&sdinfo->satadrv_id.ai_fw, msg_buf,
12738 	    sizeof (sdinfo->satadrv_id.ai_fw));
12739 	swab(msg_buf, msg_buf, sizeof (sdinfo->satadrv_id.ai_fw));
12740 	msg_buf[sizeof (sdinfo->satadrv_id.ai_fw)] = '\0';
12741 	cmn_err(CE_CONT, "?\tfirmware %s\n", msg_buf);
12742 
12743 	bcopy(&sdinfo->satadrv_id.ai_drvser, msg_buf,
12744 	    sizeof (sdinfo->satadrv_id.ai_drvser));
12745 	swab(msg_buf, msg_buf, sizeof (sdinfo->satadrv_id.ai_drvser));
12746 	msg_buf[sizeof (sdinfo->satadrv_id.ai_drvser)] = '\0';
12747 	if (sdinfo->satadrv_type == SATA_DTYPE_ATADISK) {
12748 		cmn_err(CE_CONT, "?\tserial number %s\n", msg_buf);
12749 	} else {
12750 		/*
12751 		 * Some drives do not implement serial number and may
12752 		 * violate the spec by providing spaces rather than zeros
12753 		 * in serial number field. Scan the buffer to detect it.
12754 		 */
12755 		for (i = 0; i < sizeof (sdinfo->satadrv_id.ai_drvser); i++) {
12756 			if (msg_buf[i] != '\0' && msg_buf[i] != ' ')
12757 				break;
12758 		}
12759 		if (i == sizeof (sdinfo->satadrv_id.ai_drvser)) {
12760 			cmn_err(CE_CONT, "?\tserial number - none\n");
12761 		} else {
12762 			cmn_err(CE_CONT, "?\tserial number %s\n", msg_buf);
12763 		}
12764 	}
12765 
12766 #ifdef SATA_DEBUG
12767 	if (sdinfo->satadrv_id.ai_majorversion != 0 &&
12768 	    sdinfo->satadrv_id.ai_majorversion != 0xffff) {
12769 		int i;
12770 		for (i = 14; i >= 2; i--) {
12771 			if (sdinfo->satadrv_id.ai_majorversion & (1 << i)) {
12772 				valid_version = i;
12773 				break;
12774 			}
12775 		}
12776 		cmn_err(CE_CONT,
12777 		    "?\tATA/ATAPI-%d supported, majver 0x%x minver 0x%x\n",
12778 		    valid_version,
12779 		    sdinfo->satadrv_id.ai_majorversion,
12780 		    sdinfo->satadrv_id.ai_minorversion);
12781 	}
12782 #endif
12783 	/* Log some info */
12784 	cmn_err(CE_CONT, "?\tsupported features:\n");
12785 	msg_buf[0] = '\0';
12786 	if (sdinfo->satadrv_type == SATA_DTYPE_ATADISK) {
12787 		if (sdinfo->satadrv_features_support & SATA_DEV_F_LBA48)
12788 			(void) strlcat(msg_buf, "48-bit LBA, ", MAXPATHLEN);
12789 		else if (sdinfo->satadrv_features_support & SATA_DEV_F_LBA28)
12790 			(void) strlcat(msg_buf, "28-bit LBA, ", MAXPATHLEN);
12791 	}
12792 	if (sdinfo->satadrv_features_support & SATA_DEV_F_DMA)
12793 		(void) strlcat(msg_buf, "DMA", MAXPATHLEN);
12794 	if (sdinfo->satadrv_features_support & SATA_DEV_F_NCQ)
12795 		(void) strlcat(msg_buf, ", Native Command Queueing",
12796 		    MAXPATHLEN);
12797 	if (sdinfo->satadrv_features_support & SATA_DEV_F_TCQ)
12798 		(void) strlcat(msg_buf, ", Legacy Tagged Queuing", MAXPATHLEN);
12799 	if ((sdinfo->satadrv_id.ai_cmdset82 & SATA_SMART_SUPPORTED) &&
12800 	    (sdinfo->satadrv_id.ai_features85 & SATA_SMART_ENABLED))
12801 		(void) strlcat(msg_buf, ", SMART", MAXPATHLEN);
12802 	if ((sdinfo->satadrv_id.ai_cmdset84 & SATA_SMART_SELF_TEST_SUPPORTED) &&
12803 	    (sdinfo->satadrv_id.ai_features87 & SATA_SMART_SELF_TEST_SUPPORTED))
12804 		(void) strlcat(msg_buf, ", SMART self-test", MAXPATHLEN);
12805 	cmn_err(CE_CONT, "?\t %s\n", msg_buf);
12806 	if (sdinfo->satadrv_features_support & SATA_DEV_F_SATA3)
12807 		cmn_err(CE_CONT, "?\tSATA Gen3 signaling speed (6.0Gbps)\n");
12808 	else if (sdinfo->satadrv_features_support & SATA_DEV_F_SATA2)
12809 		cmn_err(CE_CONT, "?\tSATA Gen2 signaling speed (3.0Gbps)\n");
12810 	else if (sdinfo->satadrv_features_support & SATA_DEV_F_SATA1)
12811 		cmn_err(CE_CONT, "?\tSATA Gen1 signaling speed (1.5Gbps)\n");
12812 	if (sdinfo->satadrv_features_support &
12813 	    (SATA_DEV_F_TCQ | SATA_DEV_F_NCQ)) {
12814 		msg_buf[0] = '\0';
12815 		(void) snprintf(msg_buf, MAXPATHLEN,
12816 		    "Supported queue depth %d",
12817 		    sdinfo->satadrv_queue_depth);
12818 		if (!(sata_func_enable &
12819 		    (SATA_ENABLE_QUEUING | SATA_ENABLE_NCQ)))
12820 			(void) strlcat(msg_buf,
12821 			    " - queueing disabled globally", MAXPATHLEN);
12822 		else if (sdinfo->satadrv_queue_depth >
12823 		    sdinfo->satadrv_max_queue_depth) {
12824 			(void) snprintf(&msg_buf[strlen(msg_buf)],
12825 			    MAXPATHLEN - strlen(msg_buf), ", limited to %d",
12826 			    (int)sdinfo->satadrv_max_queue_depth);
12827 		}
12828 		cmn_err(CE_CONT, "?\t%s\n", msg_buf);
12829 	}
12830 
12831 	if (sdinfo->satadrv_type == SATA_DTYPE_ATADISK) {
12832 #ifdef __i386
12833 		(void) sprintf(msg_buf, "\tcapacity = %llu sectors\n",
12834 		    sdinfo->satadrv_capacity);
12835 #else
12836 		(void) sprintf(msg_buf, "\tcapacity = %lu sectors\n",
12837 		    sdinfo->satadrv_capacity);
12838 #endif
12839 		cmn_err(CE_CONT, "?%s", msg_buf);
12840 	}
12841 }
12842 
12843 /*
12844  * Log/display port multiplier information
12845  * No Mutex should be hold.
12846  */
12847 static void
12848 sata_show_pmult_info(sata_hba_inst_t *sata_hba_inst,
12849     sata_device_t *sata_device)
12850 {
12851 	_NOTE(ARGUNUSED(sata_hba_inst))
12852 
12853 	int cport = sata_device->satadev_addr.cport;
12854 	sata_pmult_info_t *pmultinfo;
12855 	char msg_buf[MAXPATHLEN];
12856 	uint32_t gscr0, gscr1, gscr2, gscr64;
12857 
12858 	mutex_enter(&SATA_CPORT_MUTEX(sata_hba_inst, cport));
12859 	pmultinfo = SATA_PMULT_INFO(sata_hba_inst, cport);
12860 	if (pmultinfo == NULL) {
12861 		mutex_exit(&SATA_CPORT_MUTEX(sata_hba_inst, cport));
12862 		return;
12863 	}
12864 
12865 	gscr0 = pmultinfo->pmult_gscr.gscr0;
12866 	gscr1 = pmultinfo->pmult_gscr.gscr1;
12867 	gscr2 = pmultinfo->pmult_gscr.gscr2;
12868 	gscr64 = pmultinfo->pmult_gscr.gscr64;
12869 	mutex_exit(&SATA_CPORT_MUTEX(sata_hba_inst, cport));
12870 
12871 	cmn_err(CE_CONT, "?Port Multiplier %d device-ports found at port %d",
12872 	    sata_device->satadev_add_info, sata_device->satadev_addr.cport);
12873 
12874 	(void) sprintf(msg_buf, "\tVendor_ID 0x%04x, Module_ID 0x%04x",
12875 	    gscr0 & 0xffff, (gscr0 >> 16) & 0xffff);
12876 	cmn_err(CE_CONT, "?%s", msg_buf);
12877 
12878 	(void) strcpy(msg_buf, "\tSupport SATA PMP Spec ");
12879 	if (gscr1 & (1 << 3))
12880 		(void) strlcat(msg_buf, "1.2", MAXPATHLEN);
12881 	else if (gscr1 & (1 << 2))
12882 		(void) strlcat(msg_buf, "1.1", MAXPATHLEN);
12883 	else if (gscr1 & (1 << 1))
12884 		(void) strlcat(msg_buf, "1.0", MAXPATHLEN);
12885 	else
12886 		(void) strlcat(msg_buf, "unknown", MAXPATHLEN);
12887 	cmn_err(CE_CONT, "?%s", msg_buf);
12888 
12889 	(void) strcpy(msg_buf, "\tSupport ");
12890 	if (gscr64 & (1 << 3))
12891 		(void) strlcat(msg_buf, "Asy-Notif, ",
12892 		    MAXPATHLEN);
12893 	if (gscr64 & (1 << 2))
12894 		(void) strlcat(msg_buf, "Dyn-SSC, ", MAXPATHLEN);
12895 	if (gscr64 & (1 << 1))
12896 		(void) strlcat(msg_buf, "Iss-PMREQ, ", MAXPATHLEN);
12897 	if (gscr64 & (1 << 0))
12898 		(void) strlcat(msg_buf, "BIST", MAXPATHLEN);
12899 	if ((gscr64 & 0xf) == 0)
12900 		(void) strlcat(msg_buf, "nothing", MAXPATHLEN);
12901 	cmn_err(CE_CONT, "?%s", msg_buf);
12902 
12903 	(void) sprintf(msg_buf, "\tNumber of exposed device fan-out ports: %d",
12904 	    gscr2 & SATA_PMULT_PORTNUM_MASK);
12905 	cmn_err(CE_CONT, "?%s", msg_buf);
12906 }
12907 
12908 /*
12909  * sata_save_drive_settings extracts current setting of the device and stores
12910  * it for future reference, in case the device setup would need to be restored
12911  * after the device reset.
12912  *
12913  * For all devices read ahead and write cache settings are saved, if the
12914  * device supports these features at all.
12915  * For ATAPI devices the Removable Media Status Notification setting is saved.
12916  */
12917 static void
12918 sata_save_drive_settings(sata_drive_info_t *sdinfo)
12919 {
12920 	if (SATA_READ_AHEAD_SUPPORTED(sdinfo->satadrv_id) ||
12921 	    SATA_WRITE_CACHE_SUPPORTED(sdinfo->satadrv_id)) {
12922 
12923 		/* Current setting of Read Ahead (and Read Cache) */
12924 		if (SATA_READ_AHEAD_ENABLED(sdinfo->satadrv_id))
12925 			sdinfo->satadrv_settings |= SATA_DEV_READ_AHEAD;
12926 		else
12927 			sdinfo->satadrv_settings &= ~SATA_DEV_READ_AHEAD;
12928 
12929 		/* Current setting of Write Cache */
12930 		if (SATA_WRITE_CACHE_ENABLED(sdinfo->satadrv_id))
12931 			sdinfo->satadrv_settings |= SATA_DEV_WRITE_CACHE;
12932 		else
12933 			sdinfo->satadrv_settings &= ~SATA_DEV_WRITE_CACHE;
12934 	}
12935 
12936 	if (sdinfo->satadrv_type == SATA_DTYPE_ATAPICD) {
12937 		if (SATA_RM_NOTIFIC_SUPPORTED(sdinfo->satadrv_id))
12938 			sdinfo->satadrv_settings |= SATA_DEV_RMSN;
12939 		else
12940 			sdinfo->satadrv_settings &= ~SATA_DEV_RMSN;
12941 	}
12942 }
12943 
12944 
12945 /*
12946  * sata_check_capacity function determines a disk capacity
12947  * and addressing mode (LBA28/LBA48) by examining a disk identify device data.
12948  *
12949  * NOTE: CHS mode is not supported! If a device does not support LBA,
12950  * this function is not called.
12951  *
12952  * Returns device capacity in number of blocks, i.e. largest addressable LBA+1
12953  */
12954 static uint64_t
12955 sata_check_capacity(sata_drive_info_t *sdinfo)
12956 {
12957 	uint64_t capacity = 0;
12958 	int i;
12959 
12960 	if (sdinfo->satadrv_type != SATA_DTYPE_ATADISK ||
12961 	    !sdinfo->satadrv_id.ai_cap & SATA_LBA_SUPPORT)
12962 		/* Capacity valid only for LBA-addressable disk devices */
12963 		return (0);
12964 
12965 	if ((sdinfo->satadrv_id.ai_validinfo & SATA_VALIDINFO_88) &&
12966 	    (sdinfo->satadrv_id.ai_cmdset83 & SATA_EXT48) &&
12967 	    (sdinfo->satadrv_id.ai_features86 & SATA_EXT48)) {
12968 		/* LBA48 mode supported and enabled */
12969 		sdinfo->satadrv_features_support |= SATA_DEV_F_LBA48 |
12970 		    SATA_DEV_F_LBA28;
12971 		for (i = 3;  i >= 0;  --i) {
12972 			capacity <<= 16;
12973 			capacity += sdinfo->satadrv_id.ai_addrsecxt[i];
12974 		}
12975 	} else {
12976 		capacity = sdinfo->satadrv_id.ai_addrsec[1];
12977 		capacity <<= 16;
12978 		capacity += sdinfo->satadrv_id.ai_addrsec[0];
12979 		if (capacity >= 0x1000000)
12980 			/* LBA28 mode */
12981 			sdinfo->satadrv_features_support |= SATA_DEV_F_LBA28;
12982 	}
12983 	return (capacity);
12984 }
12985 
12986 
12987 /*
12988  * Allocate consistent buffer for DMA transfer
12989  *
12990  * Cannot be called from interrupt level or with mutex held - it may sleep.
12991  *
12992  * Returns pointer to allocated buffer structure, or NULL if allocation failed.
12993  */
12994 static struct buf *
12995 sata_alloc_local_buffer(sata_pkt_txlate_t *spx, int len)
12996 {
12997 	struct scsi_address ap;
12998 	struct buf *bp;
12999 	ddi_dma_attr_t	cur_dma_attr;
13000 
13001 	ASSERT(spx->txlt_sata_pkt != NULL);
13002 	ap.a_hba_tran = spx->txlt_sata_hba_inst->satahba_scsi_tran;
13003 	ap.a_target = SATA_TO_SCSI_TARGET(
13004 	    spx->txlt_sata_pkt->satapkt_device.satadev_addr.cport,
13005 	    spx->txlt_sata_pkt->satapkt_device.satadev_addr.pmport,
13006 	    spx->txlt_sata_pkt->satapkt_device.satadev_addr.qual);
13007 	ap.a_lun = 0;
13008 
13009 	bp = scsi_alloc_consistent_buf(&ap, NULL, len,
13010 	    B_READ, SLEEP_FUNC, NULL);
13011 
13012 	if (bp != NULL) {
13013 		/* Allocate DMA resources for this buffer */
13014 		spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp = bp;
13015 		/*
13016 		 * We use a local version of the dma_attr, to account
13017 		 * for a device addressing limitations.
13018 		 * sata_adjust_dma_attr() will handle sdinfo == NULL which
13019 		 * will cause dma attributes to be adjusted to a lowest
13020 		 * acceptable level.
13021 		 */
13022 		sata_adjust_dma_attr(NULL,
13023 		    SATA_DMA_ATTR(spx->txlt_sata_hba_inst), &cur_dma_attr);
13024 
13025 		if (sata_dma_buf_setup(spx, PKT_CONSISTENT,
13026 		    SLEEP_FUNC, NULL, &cur_dma_attr) != DDI_SUCCESS) {
13027 			scsi_free_consistent_buf(bp);
13028 			spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp = NULL;
13029 			bp = NULL;
13030 		}
13031 	}
13032 	return (bp);
13033 }
13034 
13035 /*
13036  * Release local buffer (consistent buffer for DMA transfer) allocated
13037  * via sata_alloc_local_buffer().
13038  */
13039 static void
13040 sata_free_local_buffer(sata_pkt_txlate_t *spx)
13041 {
13042 	ASSERT(spx->txlt_sata_pkt != NULL);
13043 	ASSERT(spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp != NULL);
13044 
13045 	spx->txlt_sata_pkt->satapkt_cmd.satacmd_num_dma_cookies = 0;
13046 	spx->txlt_sata_pkt->satapkt_cmd.satacmd_dma_cookie_list = NULL;
13047 
13048 	sata_common_free_dma_rsrcs(spx);
13049 
13050 	/* Free buffer */
13051 	scsi_free_consistent_buf(spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp);
13052 	spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp = NULL;
13053 }
13054 
13055 /*
13056  * Allocate sata_pkt
13057  * Pkt structure version and embedded strcutures version are initialized.
13058  * sata_pkt and sata_pkt_txlate structures are cross-linked.
13059  *
13060  * Since this may be called in interrupt context by sata_scsi_init_pkt,
13061  * callback argument determines if it can sleep or not.
13062  * Hence, it should not be called from interrupt context.
13063  *
13064  * If successful, non-NULL pointer to a sata pkt is returned.
13065  * Upon failure, NULL pointer is returned.
13066  */
13067 static sata_pkt_t *
13068 sata_pkt_alloc(sata_pkt_txlate_t *spx, int (*callback)(caddr_t))
13069 {
13070 	sata_pkt_t *spkt;
13071 	int kmsflag;
13072 
13073 	kmsflag = (callback == SLEEP_FUNC) ? KM_SLEEP : KM_NOSLEEP;
13074 	spkt = kmem_zalloc(sizeof (sata_pkt_t), kmsflag);
13075 	if (spkt == NULL) {
13076 		SATA_LOG_D((spx->txlt_sata_hba_inst, CE_WARN,
13077 		    "sata_pkt_alloc: failed"));
13078 		return (NULL);
13079 	}
13080 	spkt->satapkt_rev = SATA_PKT_REV;
13081 	spkt->satapkt_cmd.satacmd_rev = SATA_CMD_REV;
13082 	spkt->satapkt_device.satadev_rev = SATA_DEVICE_REV;
13083 	spkt->satapkt_framework_private = spx;
13084 	spx->txlt_sata_pkt = spkt;
13085 	return (spkt);
13086 }
13087 
13088 /*
13089  * Free sata pkt allocated via sata_pkt_alloc()
13090  */
13091 static void
13092 sata_pkt_free(sata_pkt_txlate_t *spx)
13093 {
13094 	ASSERT(spx->txlt_sata_pkt != NULL);
13095 	ASSERT(spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp == NULL);
13096 	kmem_free(spx->txlt_sata_pkt, sizeof (sata_pkt_t));
13097 	spx->txlt_sata_pkt = NULL;
13098 }
13099 
13100 
13101 /*
13102  * Adjust DMA attributes.
13103  * SCSI cmds block count is up to 24 bits, SATA cmd block count vary
13104  * from 8 bits to 16 bits, depending on a command being used.
13105  * Limiting max block count arbitrarily to 256 for all read/write
13106  * commands may affects performance, so check both the device and
13107  * controller capability before adjusting dma attributes.
13108  */
13109 void
13110 sata_adjust_dma_attr(sata_drive_info_t *sdinfo, ddi_dma_attr_t *dma_attr,
13111     ddi_dma_attr_t *adj_dma_attr)
13112 {
13113 	uint32_t count_max;
13114 
13115 	/* Copy original attributes */
13116 	*adj_dma_attr = *dma_attr;
13117 	/*
13118 	 * Things to consider: device addressing capability,
13119 	 * "excessive" controller DMA capabilities.
13120 	 * If a device is being probed/initialized, there are
13121 	 * no device info - use default limits then.
13122 	 */
13123 	if (sdinfo == NULL) {
13124 		count_max = dma_attr->dma_attr_granular * 0x100;
13125 		if (dma_attr->dma_attr_count_max > count_max)
13126 			adj_dma_attr->dma_attr_count_max = count_max;
13127 		if (dma_attr->dma_attr_maxxfer > count_max)
13128 			adj_dma_attr->dma_attr_maxxfer = count_max;
13129 		return;
13130 	}
13131 
13132 	if (sdinfo->satadrv_type == SATA_DTYPE_ATADISK) {
13133 		if (sdinfo->satadrv_features_support & (SATA_DEV_F_LBA48)) {
13134 			/*
13135 			 * 16-bit sector count may be used - we rely on
13136 			 * the assumption that only read and write cmds
13137 			 * will request more than 256 sectors worth of data
13138 			 */
13139 			count_max = adj_dma_attr->dma_attr_granular * 0x10000;
13140 		} else {
13141 			/*
13142 			 * 8-bit sector count will be used - default limits
13143 			 * for dma attributes
13144 			 */
13145 			count_max = adj_dma_attr->dma_attr_granular * 0x100;
13146 		}
13147 		/*
13148 		 * Adjust controler dma attributes, if necessary
13149 		 */
13150 		if (dma_attr->dma_attr_count_max > count_max)
13151 			adj_dma_attr->dma_attr_count_max = count_max;
13152 		if (dma_attr->dma_attr_maxxfer > count_max)
13153 			adj_dma_attr->dma_attr_maxxfer = count_max;
13154 	}
13155 }
13156 
13157 
13158 /*
13159  * Allocate DMA resources for the buffer
13160  * This function handles initial DMA resource allocation as well as
13161  * DMA window shift and may be called repeatedly for the same DMA window
13162  * until all DMA cookies in the DMA window are processed.
13163  * To guarantee that there is always a coherent set of cookies to process
13164  * by SATA HBA driver (observing alignment, device granularity, etc.),
13165  * the number of slots for DMA cookies is equal to lesser of  a number of
13166  * cookies in a DMA window and a max number of scatter/gather entries.
13167  *
13168  * Returns DDI_SUCCESS upon successful operation.
13169  * Return failure code of a failing command or DDI_FAILURE when
13170  * internal cleanup failed.
13171  */
13172 static int
13173 sata_dma_buf_setup(sata_pkt_txlate_t *spx, int flags,
13174     int (*callback)(caddr_t), caddr_t arg,
13175     ddi_dma_attr_t *cur_dma_attr)
13176 {
13177 	int	rval;
13178 	off_t	offset;
13179 	size_t	size;
13180 	int	max_sg_len, req_len, i;
13181 	uint_t	dma_flags;
13182 	struct buf	*bp;
13183 	uint64_t	cur_txfer_len;
13184 
13185 
13186 	ASSERT(spx->txlt_sata_pkt != NULL);
13187 	bp = spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp;
13188 	ASSERT(bp != NULL);
13189 
13190 
13191 	if (spx->txlt_buf_dma_handle == NULL) {
13192 		/*
13193 		 * No DMA resources allocated so far - this is a first call
13194 		 * for this sata pkt.
13195 		 */
13196 		rval = ddi_dma_alloc_handle(SATA_DIP(spx->txlt_sata_hba_inst),
13197 		    cur_dma_attr, callback, arg, &spx->txlt_buf_dma_handle);
13198 
13199 		if (rval != DDI_SUCCESS) {
13200 			SATA_LOG_D((spx->txlt_sata_hba_inst, CE_WARN,
13201 			    "sata_dma_buf_setup: no buf DMA resources %x",
13202 			    rval));
13203 			return (rval);
13204 		}
13205 
13206 		if (bp->b_flags & B_READ)
13207 			dma_flags = DDI_DMA_READ;
13208 		else
13209 			dma_flags = DDI_DMA_WRITE;
13210 
13211 		if (flags & PKT_CONSISTENT)
13212 			dma_flags |= DDI_DMA_CONSISTENT;
13213 
13214 		if (flags & PKT_DMA_PARTIAL)
13215 			dma_flags |= DDI_DMA_PARTIAL;
13216 
13217 		/*
13218 		 * Check buffer alignment and size against dma attributes
13219 		 * Consider dma_attr_align only. There may be requests
13220 		 * with the size lower than device granularity, but they
13221 		 * will not read/write from/to the device, so no adjustment
13222 		 * is necessary. The dma_attr_minxfer theoretically should
13223 		 * be considered, but no HBA driver is checking it.
13224 		 */
13225 		if (IS_P2ALIGNED(bp->b_un.b_addr,
13226 		    cur_dma_attr->dma_attr_align)) {
13227 			rval = ddi_dma_buf_bind_handle(
13228 			    spx->txlt_buf_dma_handle,
13229 			    bp, dma_flags, callback, arg,
13230 			    &spx->txlt_dma_cookie,
13231 			    &spx->txlt_curwin_num_dma_cookies);
13232 		} else { /* Buffer is not aligned */
13233 
13234 			int	(*ddicallback)(caddr_t);
13235 			size_t	bufsz;
13236 
13237 			/* Check id sleeping is allowed */
13238 			ddicallback = (callback == NULL_FUNC) ?
13239 			    DDI_DMA_DONTWAIT : DDI_DMA_SLEEP;
13240 
13241 			SATADBG2(SATA_DBG_DMA_SETUP, spx->txlt_sata_hba_inst,
13242 			    "mis-aligned buffer: addr=0x%p, cnt=%lu",
13243 			    (void *)bp->b_un.b_addr, bp->b_bcount);
13244 
13245 			if (bp->b_flags & (B_PAGEIO|B_PHYS))
13246 				/*
13247 				 * CPU will need to access data in the buffer
13248 				 * (for copying) so map it.
13249 				 */
13250 				bp_mapin(bp);
13251 
13252 			ASSERT(spx->txlt_tmp_buf == NULL);
13253 
13254 			/* Buffer may be padded by ddi_dma_mem_alloc()! */
13255 			rval = ddi_dma_mem_alloc(
13256 			    spx->txlt_buf_dma_handle,
13257 			    bp->b_bcount,
13258 			    &sata_acc_attr,
13259 			    DDI_DMA_STREAMING,
13260 			    ddicallback, NULL,
13261 			    &spx->txlt_tmp_buf,
13262 			    &bufsz,
13263 			    &spx->txlt_tmp_buf_handle);
13264 
13265 			if (rval != DDI_SUCCESS) {
13266 				/* DMA mapping failed */
13267 				(void) ddi_dma_free_handle(
13268 				    &spx->txlt_buf_dma_handle);
13269 				spx->txlt_buf_dma_handle = NULL;
13270 #ifdef SATA_DEBUG
13271 				mbuffail_count++;
13272 #endif
13273 				SATADBG1(SATA_DBG_DMA_SETUP,
13274 				    spx->txlt_sata_hba_inst,
13275 				    "sata_dma_buf_setup: "
13276 				    "buf dma mem alloc failed %x\n", rval);
13277 				return (rval);
13278 			}
13279 			ASSERT(IS_P2ALIGNED(spx->txlt_tmp_buf,
13280 			    cur_dma_attr->dma_attr_align));
13281 
13282 #ifdef SATA_DEBUG
13283 			mbuf_count++;
13284 
13285 			if (bp->b_bcount != bufsz)
13286 				/*
13287 				 * This will require special handling, because
13288 				 * DMA cookies will be based on the temporary
13289 				 * buffer size, not the original buffer
13290 				 * b_bcount, so the residue may have to
13291 				 * be counted differently.
13292 				 */
13293 				SATADBG2(SATA_DBG_DMA_SETUP,
13294 				    spx->txlt_sata_hba_inst,
13295 				    "sata_dma_buf_setup: bp size %x != "
13296 				    "bufsz %x\n", bp->b_bcount, bufsz);
13297 #endif
13298 			if (dma_flags & DDI_DMA_WRITE) {
13299 				/*
13300 				 * Write operation - copy data into
13301 				 * an aligned temporary buffer. Buffer will be
13302 				 * synced for device by ddi_dma_addr_bind_handle
13303 				 */
13304 				bcopy(bp->b_un.b_addr, spx->txlt_tmp_buf,
13305 				    bp->b_bcount);
13306 			}
13307 
13308 			rval = ddi_dma_addr_bind_handle(
13309 			    spx->txlt_buf_dma_handle,
13310 			    NULL,
13311 			    spx->txlt_tmp_buf,
13312 			    bufsz, dma_flags, ddicallback, 0,
13313 			    &spx->txlt_dma_cookie,
13314 			    &spx->txlt_curwin_num_dma_cookies);
13315 		}
13316 
13317 		switch (rval) {
13318 		case DDI_DMA_PARTIAL_MAP:
13319 			SATADBG1(SATA_DBG_DMA_SETUP, spx->txlt_sata_hba_inst,
13320 			    "sata_dma_buf_setup: DMA Partial Map\n", NULL);
13321 			/*
13322 			 * Partial DMA mapping.
13323 			 * Retrieve number of DMA windows for this request.
13324 			 */
13325 			if (ddi_dma_numwin(spx->txlt_buf_dma_handle,
13326 			    &spx->txlt_num_dma_win) != DDI_SUCCESS) {
13327 				if (spx->txlt_tmp_buf != NULL) {
13328 					ddi_dma_mem_free(
13329 					    &spx->txlt_tmp_buf_handle);
13330 					spx->txlt_tmp_buf = NULL;
13331 				}
13332 				(void) ddi_dma_unbind_handle(
13333 				    spx->txlt_buf_dma_handle);
13334 				(void) ddi_dma_free_handle(
13335 				    &spx->txlt_buf_dma_handle);
13336 				spx->txlt_buf_dma_handle = NULL;
13337 				SATA_LOG_D((spx->txlt_sata_hba_inst, CE_WARN,
13338 				    "sata_dma_buf_setup: numwin failed\n"));
13339 				return (DDI_FAILURE);
13340 			}
13341 			SATADBG2(SATA_DBG_DMA_SETUP,
13342 			    spx->txlt_sata_hba_inst,
13343 			    "sata_dma_buf_setup: windows: %d, cookies: %d\n",
13344 			    spx->txlt_num_dma_win,
13345 			    spx->txlt_curwin_num_dma_cookies);
13346 			spx->txlt_cur_dma_win = 0;
13347 			break;
13348 
13349 		case DDI_DMA_MAPPED:
13350 			/* DMA fully mapped */
13351 			spx->txlt_num_dma_win = 1;
13352 			spx->txlt_cur_dma_win = 0;
13353 			SATADBG1(SATA_DBG_DMA_SETUP,
13354 			    spx->txlt_sata_hba_inst,
13355 			    "sata_dma_buf_setup: windows: 1 "
13356 			    "cookies: %d\n", spx->txlt_curwin_num_dma_cookies);
13357 			break;
13358 
13359 		default:
13360 			/* DMA mapping failed */
13361 			if (spx->txlt_tmp_buf != NULL) {
13362 				ddi_dma_mem_free(
13363 				    &spx->txlt_tmp_buf_handle);
13364 				spx->txlt_tmp_buf = NULL;
13365 			}
13366 			(void) ddi_dma_free_handle(&spx->txlt_buf_dma_handle);
13367 			spx->txlt_buf_dma_handle = NULL;
13368 			SATA_LOG_D((spx->txlt_sata_hba_inst, CE_WARN,
13369 			    "sata_dma_buf_setup: buf dma handle binding "
13370 			    "failed %x\n", rval));
13371 			return (rval);
13372 		}
13373 		spx->txlt_curwin_processed_dma_cookies = 0;
13374 		spx->txlt_dma_cookie_list = NULL;
13375 	} else {
13376 		/*
13377 		 * DMA setup is reused. Check if we need to process more
13378 		 * cookies in current window, or to get next window, if any.
13379 		 */
13380 
13381 		ASSERT(spx->txlt_curwin_processed_dma_cookies <=
13382 		    spx->txlt_curwin_num_dma_cookies);
13383 
13384 		if (spx->txlt_curwin_processed_dma_cookies ==
13385 		    spx->txlt_curwin_num_dma_cookies) {
13386 			/*
13387 			 * All cookies from current DMA window were processed.
13388 			 * Get next DMA window.
13389 			 */
13390 			spx->txlt_cur_dma_win++;
13391 			if (spx->txlt_cur_dma_win < spx->txlt_num_dma_win) {
13392 				(void) ddi_dma_getwin(spx->txlt_buf_dma_handle,
13393 				    spx->txlt_cur_dma_win, &offset, &size,
13394 				    &spx->txlt_dma_cookie,
13395 				    &spx->txlt_curwin_num_dma_cookies);
13396 				spx->txlt_curwin_processed_dma_cookies = 0;
13397 			} else {
13398 				/* No more windows! End of request! */
13399 				/* What to do? - panic for now */
13400 				ASSERT(spx->txlt_cur_dma_win >=
13401 				    spx->txlt_num_dma_win);
13402 
13403 				spx->txlt_curwin_num_dma_cookies = 0;
13404 				spx->txlt_curwin_processed_dma_cookies = 0;
13405 				spx->txlt_sata_pkt->
13406 				    satapkt_cmd.satacmd_num_dma_cookies = 0;
13407 				return (DDI_SUCCESS);
13408 			}
13409 		}
13410 	}
13411 	/* There better be at least one DMA cookie outstanding */
13412 	ASSERT((spx->txlt_curwin_num_dma_cookies -
13413 	    spx->txlt_curwin_processed_dma_cookies) > 0);
13414 
13415 	if (spx->txlt_dma_cookie_list == &spx->txlt_dma_cookie) {
13416 		/* The default cookie slot was used in previous run */
13417 		ASSERT(spx->txlt_curwin_processed_dma_cookies == 0);
13418 		spx->txlt_dma_cookie_list = NULL;
13419 		spx->txlt_dma_cookie_list_len = 0;
13420 	}
13421 	if (spx->txlt_curwin_processed_dma_cookies == 0) {
13422 		/*
13423 		 * Processing a new DMA window - set-up dma cookies list.
13424 		 * We may reuse previously allocated cookie array if it is
13425 		 * possible.
13426 		 */
13427 		if (spx->txlt_dma_cookie_list != NULL &&
13428 		    spx->txlt_dma_cookie_list_len <
13429 		    spx->txlt_curwin_num_dma_cookies) {
13430 			/*
13431 			 * New DMA window contains more cookies than
13432 			 * the previous one. We need larger cookie list - free
13433 			 * the old one.
13434 			 */
13435 			(void) kmem_free(spx->txlt_dma_cookie_list,
13436 			    spx->txlt_dma_cookie_list_len *
13437 			    sizeof (ddi_dma_cookie_t));
13438 			spx->txlt_dma_cookie_list = NULL;
13439 			spx->txlt_dma_cookie_list_len = 0;
13440 		}
13441 		if (spx->txlt_dma_cookie_list == NULL) {
13442 			/*
13443 			 * Calculate lesser of number of cookies in this
13444 			 * DMA window and number of s/g entries.
13445 			 */
13446 			max_sg_len = cur_dma_attr->dma_attr_sgllen;
13447 			req_len = MIN(max_sg_len,
13448 			    spx->txlt_curwin_num_dma_cookies);
13449 
13450 			/* Allocate new dma cookie array if necessary */
13451 			if (req_len == 1) {
13452 				/* Only one cookie - no need for a list */
13453 				spx->txlt_dma_cookie_list =
13454 				    &spx->txlt_dma_cookie;
13455 				spx->txlt_dma_cookie_list_len = 1;
13456 			} else {
13457 				/*
13458 				 * More than one cookie - try to allocate space.
13459 				 */
13460 				spx->txlt_dma_cookie_list = kmem_zalloc(
13461 				    sizeof (ddi_dma_cookie_t) * req_len,
13462 				    callback == NULL_FUNC ? KM_NOSLEEP :
13463 				    KM_SLEEP);
13464 				if (spx->txlt_dma_cookie_list == NULL) {
13465 					SATADBG1(SATA_DBG_DMA_SETUP,
13466 					    spx->txlt_sata_hba_inst,
13467 					    "sata_dma_buf_setup: cookie list "
13468 					    "allocation failed\n", NULL);
13469 					/*
13470 					 * We could not allocate space for
13471 					 * neccessary number of dma cookies in
13472 					 * this window, so we fail this request.
13473 					 * Next invocation would try again to
13474 					 * allocate space for cookie list.
13475 					 * Note:Packet residue was not modified.
13476 					 */
13477 					return (DDI_DMA_NORESOURCES);
13478 				} else {
13479 					spx->txlt_dma_cookie_list_len = req_len;
13480 				}
13481 			}
13482 		}
13483 		/*
13484 		 * Fetch DMA cookies into cookie list in sata_pkt_txlate.
13485 		 * First cookie was already fetched.
13486 		 */
13487 		*(&spx->txlt_dma_cookie_list[0]) = spx->txlt_dma_cookie;
13488 		cur_txfer_len =
13489 		    (uint64_t)spx->txlt_dma_cookie_list[0].dmac_size;
13490 		spx->txlt_sata_pkt->satapkt_cmd.satacmd_num_dma_cookies = 1;
13491 		spx->txlt_curwin_processed_dma_cookies++;
13492 		for (i = 1; (i < spx->txlt_dma_cookie_list_len) &&
13493 		    (i < spx->txlt_curwin_num_dma_cookies); i++) {
13494 			ddi_dma_nextcookie(spx->txlt_buf_dma_handle,
13495 			    &spx->txlt_dma_cookie_list[i]);
13496 			cur_txfer_len +=
13497 			    (uint64_t)spx->txlt_dma_cookie_list[i].dmac_size;
13498 			spx->txlt_curwin_processed_dma_cookies++;
13499 			spx->txlt_sata_pkt->
13500 			    satapkt_cmd.satacmd_num_dma_cookies += 1;
13501 		}
13502 	} else {
13503 		SATADBG2(SATA_DBG_DMA_SETUP, spx->txlt_sata_hba_inst,
13504 		    "sata_dma_buf_setup: sliding within DMA window, "
13505 		    "cur cookie %d, total cookies %d\n",
13506 		    spx->txlt_curwin_processed_dma_cookies,
13507 		    spx->txlt_curwin_num_dma_cookies);
13508 
13509 		/*
13510 		 * Not all cookies from the current dma window were used because
13511 		 * of s/g limitation.
13512 		 * There is no need to re-size the list - it was set at
13513 		 * optimal size, or only default entry is used (s/g = 1).
13514 		 */
13515 		if (spx->txlt_dma_cookie_list == NULL) {
13516 			spx->txlt_dma_cookie_list = &spx->txlt_dma_cookie;
13517 			spx->txlt_dma_cookie_list_len = 1;
13518 		}
13519 		/*
13520 		 * Since we are processing remaining cookies in a DMA window,
13521 		 * there may be less of them than the number of entries in the
13522 		 * current dma cookie list.
13523 		 */
13524 		req_len = MIN(spx->txlt_dma_cookie_list_len,
13525 		    (spx->txlt_curwin_num_dma_cookies -
13526 		    spx->txlt_curwin_processed_dma_cookies));
13527 
13528 		/* Fetch the next batch of cookies */
13529 		for (i = 0, cur_txfer_len = 0; i < req_len; i++) {
13530 			ddi_dma_nextcookie(spx->txlt_buf_dma_handle,
13531 			    &spx->txlt_dma_cookie_list[i]);
13532 			cur_txfer_len +=
13533 			    (uint64_t)spx->txlt_dma_cookie_list[i].dmac_size;
13534 			spx->txlt_sata_pkt->
13535 			    satapkt_cmd.satacmd_num_dma_cookies++;
13536 			spx->txlt_curwin_processed_dma_cookies++;
13537 		}
13538 	}
13539 
13540 	ASSERT(spx->txlt_sata_pkt->satapkt_cmd.satacmd_num_dma_cookies > 0);
13541 
13542 	/* Point sata_cmd to the cookie list */
13543 	spx->txlt_sata_pkt->satapkt_cmd.satacmd_dma_cookie_list =
13544 	    &spx->txlt_dma_cookie_list[0];
13545 
13546 	/* Remember number of DMA cookies passed in sata packet */
13547 	spx->txlt_num_dma_cookies =
13548 	    spx->txlt_sata_pkt->satapkt_cmd.satacmd_num_dma_cookies;
13549 
13550 	ASSERT(cur_txfer_len != 0);
13551 	if (cur_txfer_len <= bp->b_bcount)
13552 		spx->txlt_total_residue -= cur_txfer_len;
13553 	else {
13554 		/*
13555 		 * Temporary DMA buffer has been padded by
13556 		 * ddi_dma_mem_alloc()!
13557 		 * This requires special handling, because DMA cookies are
13558 		 * based on the temporary buffer size, not the b_bcount,
13559 		 * and we have extra bytes to transfer - but the packet
13560 		 * residue has to stay correct because we will copy only
13561 		 * the requested number of bytes.
13562 		 */
13563 		spx->txlt_total_residue -= bp->b_bcount;
13564 	}
13565 
13566 	return (DDI_SUCCESS);
13567 }
13568 
13569 /*
13570  * Common routine for releasing DMA resources
13571  */
13572 static void
13573 sata_common_free_dma_rsrcs(sata_pkt_txlate_t *spx)
13574 {
13575 	if (spx->txlt_buf_dma_handle != NULL) {
13576 		if (spx->txlt_tmp_buf != NULL)  {
13577 			/*
13578 			 * Intermediate DMA buffer was allocated.
13579 			 * Free allocated buffer and associated access handle.
13580 			 */
13581 			ddi_dma_mem_free(&spx->txlt_tmp_buf_handle);
13582 			spx->txlt_tmp_buf = NULL;
13583 		}
13584 		/*
13585 		 * Free DMA resources - cookies and handles
13586 		 */
13587 		/* ASSERT(spx->txlt_dma_cookie_list != NULL); */
13588 		if (spx->txlt_dma_cookie_list != NULL) {
13589 			if (spx->txlt_dma_cookie_list !=
13590 			    &spx->txlt_dma_cookie) {
13591 				(void) kmem_free(spx->txlt_dma_cookie_list,
13592 				    spx->txlt_dma_cookie_list_len *
13593 				    sizeof (ddi_dma_cookie_t));
13594 				spx->txlt_dma_cookie_list = NULL;
13595 			}
13596 		}
13597 		(void) ddi_dma_unbind_handle(spx->txlt_buf_dma_handle);
13598 		(void) ddi_dma_free_handle(&spx->txlt_buf_dma_handle);
13599 		spx->txlt_buf_dma_handle = NULL;
13600 	}
13601 }
13602 
13603 /*
13604  * Free DMA resources
13605  * Used by the HBA driver to release DMA resources that it does not use.
13606  *
13607  * Returns Void
13608  */
13609 void
13610 sata_free_dma_resources(sata_pkt_t *sata_pkt)
13611 {
13612 	sata_pkt_txlate_t *spx;
13613 
13614 	if (sata_pkt == NULL)
13615 		return;
13616 
13617 	spx = (sata_pkt_txlate_t *)sata_pkt->satapkt_framework_private;
13618 
13619 	sata_common_free_dma_rsrcs(spx);
13620 }
13621 
13622 /*
13623  * Fetch Device Identify data.
13624  * Send DEVICE IDENTIFY or IDENTIFY PACKET DEVICE (depending on a device type)
13625  * command to a device and get the device identify data.
13626  * The device_info structure has to be set to device type (for selecting proper
13627  * device identify command).
13628  *
13629  * Returns:
13630  * SATA_SUCCESS if cmd succeeded
13631  * SATA_RETRY if cmd was rejected and could be retried,
13632  * SATA_FAILURE if cmd failed and should not be retried (port error)
13633  *
13634  * Cannot be called in an interrupt context.
13635  */
13636 
13637 static int
13638 sata_fetch_device_identify_data(sata_hba_inst_t *sata_hba_inst,
13639     sata_drive_info_t *sdinfo)
13640 {
13641 	struct buf *bp;
13642 	sata_pkt_t *spkt;
13643 	sata_cmd_t *scmd;
13644 	sata_pkt_txlate_t *spx;
13645 	int rval;
13646 	dev_info_t *dip = SATA_DIP(sata_hba_inst);
13647 
13648 	spx = kmem_zalloc(sizeof (sata_pkt_txlate_t), KM_SLEEP);
13649 	spx->txlt_sata_hba_inst = sata_hba_inst;
13650 	spx->txlt_scsi_pkt = NULL;		/* No scsi pkt involved */
13651 	spkt = sata_pkt_alloc(spx, SLEEP_FUNC);
13652 	if (spkt == NULL) {
13653 		kmem_free(spx, sizeof (sata_pkt_txlate_t));
13654 		return (SATA_RETRY); /* may retry later */
13655 	}
13656 	/* address is needed now */
13657 	spkt->satapkt_device.satadev_addr = sdinfo->satadrv_addr;
13658 
13659 	/*
13660 	 * Allocate buffer for Identify Data return data
13661 	 */
13662 	bp = sata_alloc_local_buffer(spx, sizeof (sata_id_t));
13663 	if (bp == NULL) {
13664 		sata_pkt_free(spx);
13665 		kmem_free(spx, sizeof (sata_pkt_txlate_t));
13666 		SATA_LOG_D((sata_hba_inst, CE_WARN,
13667 		    "sata_fetch_device_identify_data: "
13668 		    "cannot allocate buffer for ID"));
13669 		return (SATA_RETRY); /* may retry later */
13670 	}
13671 
13672 	/* Fill sata_pkt */
13673 	sdinfo->satadrv_state = SATA_STATE_PROBING;
13674 	spkt->satapkt_device.satadev_addr = sdinfo->satadrv_addr;
13675 	spkt->satapkt_op_mode = SATA_OPMODE_SYNCH | SATA_OPMODE_INTERRUPTS;
13676 	/* Synchronous mode, no callback */
13677 	spkt->satapkt_comp = NULL;
13678 	/* Timeout 30s */
13679 	spkt->satapkt_time = sata_default_pkt_time;
13680 
13681 	scmd = &spkt->satapkt_cmd;
13682 	scmd->satacmd_bp = bp;
13683 	scmd->satacmd_flags.sata_data_direction = SATA_DIR_READ;
13684 	scmd->satacmd_flags.sata_ignore_dev_reset = B_TRUE;
13685 
13686 	/* Build Identify Device cmd in the sata_pkt */
13687 	scmd->satacmd_addr_type = 0;		/* N/A */
13688 	scmd->satacmd_sec_count_lsb = 0;	/* N/A */
13689 	scmd->satacmd_lba_low_lsb = 0;		/* N/A */
13690 	scmd->satacmd_lba_mid_lsb = 0;		/* N/A */
13691 	scmd->satacmd_lba_high_lsb = 0;		/* N/A */
13692 	scmd->satacmd_features_reg = 0;		/* N/A */
13693 	scmd->satacmd_device_reg = 0;		/* Always device 0 */
13694 	if (sdinfo->satadrv_type & SATA_DTYPE_ATAPI) {
13695 		/* Identify Packet Device cmd */
13696 		scmd->satacmd_cmd_reg = SATAC_ID_PACKET_DEVICE;
13697 	} else {
13698 		/* Identify Device cmd - mandatory for all other devices */
13699 		scmd->satacmd_cmd_reg = SATAC_ID_DEVICE;
13700 	}
13701 
13702 	/* Send pkt to SATA HBA driver */
13703 	rval = (*SATA_START_FUNC(sata_hba_inst))(SATA_DIP(sata_hba_inst), spkt);
13704 
13705 #ifdef SATA_INJECT_FAULTS
13706 	sata_inject_pkt_fault(spkt, &rval, sata_fault_type);
13707 #endif
13708 
13709 	if (rval == SATA_TRAN_ACCEPTED &&
13710 	    spkt->satapkt_reason == SATA_PKT_COMPLETED) {
13711 		if (spx->txlt_buf_dma_handle != NULL) {
13712 			rval = ddi_dma_sync(spx->txlt_buf_dma_handle, 0, 0,
13713 			    DDI_DMA_SYNC_FORKERNEL);
13714 			ASSERT(rval == DDI_SUCCESS);
13715 			if (sata_check_for_dma_error(dip, spx)) {
13716 				ddi_fm_service_impact(dip,
13717 				    DDI_SERVICE_UNAFFECTED);
13718 				rval = SATA_RETRY;
13719 				goto fail;
13720 			}
13721 
13722 		}
13723 		if ((((sata_id_t *)(bp->b_un.b_addr))->ai_config &
13724 		    SATA_INCOMPLETE_DATA) == SATA_INCOMPLETE_DATA) {
13725 			SATA_LOG_D((sata_hba_inst, CE_WARN,
13726 			    "SATA disk device at port %d - "
13727 			    "partial Identify Data",
13728 			    sdinfo->satadrv_addr.cport));
13729 			rval = SATA_RETRY; /* may retry later */
13730 			goto fail;
13731 		}
13732 		/* Update sata_drive_info */
13733 		bcopy(bp->b_un.b_addr, &sdinfo->satadrv_id,
13734 		    sizeof (sata_id_t));
13735 
13736 		sdinfo->satadrv_features_support = 0;
13737 		if (sdinfo->satadrv_type == SATA_DTYPE_ATADISK) {
13738 			/*
13739 			 * Retrieve capacity (disks only) and addressing mode
13740 			 */
13741 			sdinfo->satadrv_capacity = sata_check_capacity(sdinfo);
13742 		} else {
13743 			/*
13744 			 * For ATAPI devices one would have to issue
13745 			 * Get Capacity cmd for media capacity. Not here.
13746 			 */
13747 			sdinfo->satadrv_capacity = 0;
13748 			/*
13749 			 * Check what cdb length is supported
13750 			 */
13751 			if ((sdinfo->satadrv_id.ai_config &
13752 			    SATA_ATAPI_ID_PKT_SZ) == SATA_ATAPI_ID_PKT_16B)
13753 				sdinfo->satadrv_atapi_cdb_len = 16;
13754 			else
13755 				sdinfo->satadrv_atapi_cdb_len = 12;
13756 		}
13757 		/* Setup supported features flags */
13758 		if (sdinfo->satadrv_id.ai_cap & SATA_DMA_SUPPORT)
13759 			sdinfo->satadrv_features_support |= SATA_DEV_F_DMA;
13760 
13761 		/* Check for SATA GEN and NCQ support */
13762 		if (sdinfo->satadrv_id.ai_satacap != 0 &&
13763 		    sdinfo->satadrv_id.ai_satacap != 0xffff) {
13764 			/* SATA compliance */
13765 			if (sdinfo->satadrv_id.ai_satacap & SATA_NCQ)
13766 				sdinfo->satadrv_features_support |=
13767 				    SATA_DEV_F_NCQ;
13768 			if (sdinfo->satadrv_id.ai_satacap &
13769 			    (SATA_1_SPEED | SATA_2_SPEED | SATA_3_SPEED)) {
13770 				if (sdinfo->satadrv_id.ai_satacap &
13771 				    SATA_3_SPEED)
13772 					sdinfo->satadrv_features_support |=
13773 					    SATA_DEV_F_SATA3;
13774 				if (sdinfo->satadrv_id.ai_satacap &
13775 				    SATA_2_SPEED)
13776 					sdinfo->satadrv_features_support |=
13777 					    SATA_DEV_F_SATA2;
13778 				if (sdinfo->satadrv_id.ai_satacap &
13779 				    SATA_1_SPEED)
13780 					sdinfo->satadrv_features_support |=
13781 					    SATA_DEV_F_SATA1;
13782 			} else {
13783 				sdinfo->satadrv_features_support |=
13784 				    SATA_DEV_F_SATA1;
13785 			}
13786 		}
13787 		if ((sdinfo->satadrv_id.ai_cmdset83 & SATA_RW_DMA_QUEUED_CMD) &&
13788 		    (sdinfo->satadrv_id.ai_features86 & SATA_RW_DMA_QUEUED_CMD))
13789 			sdinfo->satadrv_features_support |= SATA_DEV_F_TCQ;
13790 
13791 		sdinfo->satadrv_queue_depth = sdinfo->satadrv_id.ai_qdepth;
13792 		if ((sdinfo->satadrv_features_support & SATA_DEV_F_NCQ) ||
13793 		    (sdinfo->satadrv_features_support & SATA_DEV_F_TCQ)) {
13794 			++sdinfo->satadrv_queue_depth;
13795 			/* Adjust according to controller capabilities */
13796 			sdinfo->satadrv_max_queue_depth = MIN(
13797 			    sdinfo->satadrv_queue_depth,
13798 			    SATA_QDEPTH(sata_hba_inst));
13799 			/* Adjust according to global queue depth limit */
13800 			sdinfo->satadrv_max_queue_depth = MIN(
13801 			    sdinfo->satadrv_max_queue_depth,
13802 			    sata_current_max_qdepth);
13803 			if (sdinfo->satadrv_max_queue_depth == 0)
13804 				sdinfo->satadrv_max_queue_depth = 1;
13805 		} else
13806 			sdinfo->satadrv_max_queue_depth = 1;
13807 
13808 		rval = SATA_SUCCESS;
13809 	} else {
13810 		/*
13811 		 * Woops, no Identify Data.
13812 		 */
13813 		if (rval == SATA_TRAN_BUSY || rval == SATA_TRAN_QUEUE_FULL) {
13814 			rval = SATA_RETRY; /* may retry later */
13815 		} else if (rval == SATA_TRAN_ACCEPTED) {
13816 			if (spkt->satapkt_reason == SATA_PKT_DEV_ERROR ||
13817 			    spkt->satapkt_reason == SATA_PKT_ABORTED ||
13818 			    spkt->satapkt_reason == SATA_PKT_TIMEOUT ||
13819 			    spkt->satapkt_reason == SATA_PKT_RESET)
13820 				rval = SATA_RETRY; /* may retry later */
13821 			else
13822 				rval = SATA_FAILURE;
13823 		} else {
13824 			rval = SATA_FAILURE;
13825 		}
13826 	}
13827 fail:
13828 	/* Free allocated resources */
13829 	sata_free_local_buffer(spx);
13830 	sata_pkt_free(spx);
13831 	kmem_free(spx, sizeof (sata_pkt_txlate_t));
13832 
13833 	return (rval);
13834 }
13835 
13836 
13837 /*
13838  * Some devices may not come-up with default DMA mode (UDMA or MWDMA).
13839  * UDMA mode is checked first, followed by MWDMA mode.
13840  * set correctly, so this function is setting it to the highest supported level.
13841  * Older SATA spec required that the device supports at least DMA 4 mode and
13842  * UDMA mode is selected.  It is not mentioned in SerialATA 2.6, so this
13843  * restriction has been removed.
13844  *
13845  * Returns SATA_SUCCESS if proper DMA mode is selected or no DMA is supported.
13846  * Returns SATA_FAILURE if proper DMA mode could not be selected.
13847  *
13848  * NOTE: This function should be called only if DMA mode is supported.
13849  */
13850 static int
13851 sata_set_dma_mode(sata_hba_inst_t *sata_hba_inst, sata_drive_info_t *sdinfo)
13852 {
13853 	sata_pkt_t *spkt;
13854 	sata_cmd_t *scmd;
13855 	sata_pkt_txlate_t *spx;
13856 	int i, mode;
13857 	uint8_t subcmd;
13858 	int rval = SATA_SUCCESS;
13859 
13860 	ASSERT(sdinfo != NULL);
13861 	ASSERT(sata_hba_inst != NULL);
13862 
13863 	if ((sdinfo->satadrv_id.ai_validinfo & SATA_VALIDINFO_88) != 0 &&
13864 	    (sdinfo->satadrv_id.ai_ultradma & SATA_UDMA_SUP_MASK) != 0) {
13865 		/* Find highest Ultra DMA mode supported */
13866 		for (mode = 6; mode >= 0; --mode) {
13867 			if (sdinfo->satadrv_id.ai_ultradma & (1 << mode))
13868 				break;
13869 		}
13870 #if 0
13871 		/* Left for historical reasons */
13872 		/*
13873 		 * Some initial version of SATA spec indicated that at least
13874 		 * UDMA mode 4 has to be supported. It is not mentioned in
13875 		 * SerialATA 2.6, so this restriction is removed.
13876 		 */
13877 		if (mode < 4)
13878 			return (SATA_FAILURE);
13879 #endif
13880 
13881 		/*
13882 		 * For disk, we're still going to set DMA mode whatever is
13883 		 * selected by default
13884 		 *
13885 		 * We saw an old maxtor sata drive will select Ultra DMA and
13886 		 * Multi-Word DMA simultaneouly by default, which is going
13887 		 * to cause DMA command timed out, so we need to select DMA
13888 		 * mode even when it's already done by default
13889 		 */
13890 		if (sdinfo->satadrv_type != SATA_DTYPE_ATADISK) {
13891 
13892 			/* Find UDMA mode currently selected */
13893 			for (i = 6; i >= 0; --i) {
13894 				if (sdinfo->satadrv_id.ai_ultradma &
13895 				    (1 << (i + 8)))
13896 					break;
13897 			}
13898 			if (i >= mode)
13899 				/* Nothing to do */
13900 				return (SATA_SUCCESS);
13901 		}
13902 
13903 		subcmd = SATAC_TRANSFER_MODE_ULTRA_DMA;
13904 
13905 	} else if ((sdinfo->satadrv_id.ai_dworddma & SATA_MDMA_SUP_MASK) != 0) {
13906 		/* Find highest MultiWord DMA mode supported */
13907 		for (mode = 2; mode >= 0; --mode) {
13908 			if (sdinfo->satadrv_id.ai_dworddma & (1 << mode))
13909 				break;
13910 		}
13911 
13912 		/*
13913 		 * For disk, We're still going to set DMA mode whatever is
13914 		 * selected by default
13915 		 *
13916 		 * We saw an old maxtor sata drive will select Ultra DMA and
13917 		 * Multi-Word DMA simultaneouly by default, which is going
13918 		 * to cause DMA command timed out, so we need to select DMA
13919 		 * mode even when it's already done by default
13920 		 */
13921 		if (sdinfo->satadrv_type != SATA_DTYPE_ATADISK) {
13922 
13923 			/* Find highest MultiWord DMA mode selected */
13924 			for (i = 2; i >= 0; --i) {
13925 				if (sdinfo->satadrv_id.ai_dworddma &
13926 				    (1 << (i + 8)))
13927 					break;
13928 			}
13929 			if (i >= mode)
13930 				/* Nothing to do */
13931 				return (SATA_SUCCESS);
13932 		}
13933 
13934 		subcmd = SATAC_TRANSFER_MODE_MULTI_WORD_DMA;
13935 	} else
13936 		return (SATA_SUCCESS);
13937 
13938 	/*
13939 	 * Set DMA mode via SET FEATURES COMMAND.
13940 	 * Prepare packet for SET FEATURES COMMAND.
13941 	 */
13942 	spx = kmem_zalloc(sizeof (sata_pkt_txlate_t), KM_SLEEP);
13943 	spx->txlt_sata_hba_inst = sata_hba_inst;
13944 	spx->txlt_scsi_pkt = NULL;	/* No scsi pkt involved */
13945 	spkt = sata_pkt_alloc(spx, SLEEP_FUNC);
13946 	if (spkt == NULL) {
13947 		SATA_LOG_D((sata_hba_inst, CE_WARN,
13948 		    "sata_set_dma_mode: could not set DMA mode %d", mode));
13949 		rval = SATA_FAILURE;
13950 		goto done;
13951 	}
13952 	/* Fill sata_pkt */
13953 	spkt->satapkt_device.satadev_addr = sdinfo->satadrv_addr;
13954 	/* Timeout 30s */
13955 	spkt->satapkt_time = sata_default_pkt_time;
13956 	/* Synchronous mode, no callback, interrupts */
13957 	spkt->satapkt_op_mode = SATA_OPMODE_SYNCH | SATA_OPMODE_INTERRUPTS;
13958 	spkt->satapkt_comp = NULL;
13959 	scmd = &spkt->satapkt_cmd;
13960 	scmd->satacmd_flags.sata_data_direction = SATA_DIR_NODATA_XFER;
13961 	scmd->satacmd_flags.sata_ignore_dev_reset = B_TRUE;
13962 	scmd->satacmd_addr_type = 0;
13963 	scmd->satacmd_device_reg = 0;
13964 	scmd->satacmd_status_reg = 0;
13965 	scmd->satacmd_error_reg = 0;
13966 	scmd->satacmd_cmd_reg = SATAC_SET_FEATURES;
13967 	scmd->satacmd_features_reg = SATAC_SF_TRANSFER_MODE;
13968 	scmd->satacmd_sec_count_lsb = subcmd | mode;
13969 
13970 	/* Transfer command to HBA */
13971 	if ((*SATA_START_FUNC(sata_hba_inst))(SATA_DIP(sata_hba_inst),
13972 	    spkt) != SATA_TRAN_ACCEPTED ||
13973 	    spkt->satapkt_reason != SATA_PKT_COMPLETED) {
13974 		/* Pkt execution failed */
13975 		rval = SATA_FAILURE;
13976 	}
13977 done:
13978 
13979 	/* Free allocated resources */
13980 	if (spkt != NULL)
13981 		sata_pkt_free(spx);
13982 	(void) kmem_free(spx, sizeof (sata_pkt_txlate_t));
13983 
13984 	return (rval);
13985 }
13986 
13987 
13988 /*
13989  * Set device caching mode.
13990  * One of the following operations should be specified:
13991  * SATAC_SF_ENABLE_READ_AHEAD
13992  * SATAC_SF_DISABLE_READ_AHEAD
13993  * SATAC_SF_ENABLE_WRITE_CACHE
13994  * SATAC_SF_DISABLE_WRITE_CACHE
13995  *
13996  * If operation fails, system log messgage is emitted.
13997  * Returns SATA_SUCCESS when the operation succeeds, SATA_RETRY if
13998  * command was sent but did not succeed, and SATA_FAILURE otherwise.
13999  */
14000 
14001 static int
14002 sata_set_cache_mode(sata_hba_inst_t *sata_hba_inst, sata_drive_info_t *sdinfo,
14003     int cache_op)
14004 {
14005 	sata_pkt_t *spkt;
14006 	sata_cmd_t *scmd;
14007 	sata_pkt_txlate_t *spx;
14008 	int rval = SATA_SUCCESS;
14009 	int hba_rval;
14010 	char *infop;
14011 
14012 	ASSERT(sdinfo != NULL);
14013 	ASSERT(sata_hba_inst != NULL);
14014 	ASSERT(cache_op == SATAC_SF_ENABLE_READ_AHEAD ||
14015 	    cache_op == SATAC_SF_DISABLE_READ_AHEAD ||
14016 	    cache_op == SATAC_SF_ENABLE_WRITE_CACHE ||
14017 	    cache_op == SATAC_SF_DISABLE_WRITE_CACHE);
14018 
14019 
14020 	/* Prepare packet for SET FEATURES COMMAND */
14021 	spx = kmem_zalloc(sizeof (sata_pkt_txlate_t), KM_SLEEP);
14022 	spx->txlt_sata_hba_inst = sata_hba_inst;
14023 	spx->txlt_scsi_pkt = NULL;	/* No scsi pkt involved */
14024 	spkt = sata_pkt_alloc(spx, SLEEP_FUNC);
14025 	if (spkt == NULL) {
14026 		rval = SATA_FAILURE;
14027 		goto failure;
14028 	}
14029 	/* Fill sata_pkt */
14030 	spkt->satapkt_device.satadev_addr = sdinfo->satadrv_addr;
14031 	/* Timeout 30s */
14032 	spkt->satapkt_time = sata_default_pkt_time;
14033 	/* Synchronous mode, no callback, interrupts */
14034 	spkt->satapkt_op_mode =
14035 	    SATA_OPMODE_SYNCH | SATA_OPMODE_INTERRUPTS;
14036 	spkt->satapkt_comp = NULL;
14037 	scmd = &spkt->satapkt_cmd;
14038 	scmd->satacmd_flags.sata_data_direction = SATA_DIR_NODATA_XFER;
14039 	scmd->satacmd_flags.sata_ignore_dev_reset = B_TRUE;
14040 	scmd->satacmd_addr_type = 0;
14041 	scmd->satacmd_device_reg = 0;
14042 	scmd->satacmd_status_reg = 0;
14043 	scmd->satacmd_error_reg = 0;
14044 	scmd->satacmd_cmd_reg = SATAC_SET_FEATURES;
14045 	scmd->satacmd_features_reg = cache_op;
14046 
14047 	/* Transfer command to HBA */
14048 	hba_rval = (*SATA_START_FUNC(sata_hba_inst))(
14049 	    SATA_DIP(sata_hba_inst), spkt);
14050 
14051 #ifdef SATA_INJECT_FAULTS
14052 	sata_inject_pkt_fault(spkt, &rval, sata_fault_type);
14053 #endif
14054 
14055 	if ((hba_rval != SATA_TRAN_ACCEPTED) ||
14056 	    (spkt->satapkt_reason != SATA_PKT_COMPLETED)) {
14057 		/* Pkt execution failed */
14058 		switch (cache_op) {
14059 		case SATAC_SF_ENABLE_READ_AHEAD:
14060 			infop = "enabling read ahead failed";
14061 			break;
14062 		case SATAC_SF_DISABLE_READ_AHEAD:
14063 			infop = "disabling read ahead failed";
14064 			break;
14065 		case SATAC_SF_ENABLE_WRITE_CACHE:
14066 			infop = "enabling write cache failed";
14067 			break;
14068 		case SATAC_SF_DISABLE_WRITE_CACHE:
14069 			infop = "disabling write cache failed";
14070 			break;
14071 		}
14072 		SATA_LOG_D((sata_hba_inst, CE_WARN, "%s", infop));
14073 		rval = SATA_RETRY;
14074 	}
14075 failure:
14076 	/* Free allocated resources */
14077 	if (spkt != NULL)
14078 		sata_pkt_free(spx);
14079 	(void) kmem_free(spx, sizeof (sata_pkt_txlate_t));
14080 	return (rval);
14081 }
14082 
14083 /*
14084  * Set Removable Media Status Notification (enable/disable)
14085  * state == 0 , disable
14086  * state != 0 , enable
14087  *
14088  * If operation fails, system log messgage is emitted.
14089  * Returns SATA_SUCCESS when the operation succeeds, SATA_FAILURE otherwise.
14090  */
14091 
14092 static int
14093 sata_set_rmsn(sata_hba_inst_t *sata_hba_inst, sata_drive_info_t *sdinfo,
14094     int state)
14095 {
14096 	sata_pkt_t *spkt;
14097 	sata_cmd_t *scmd;
14098 	sata_pkt_txlate_t *spx;
14099 	int rval = SATA_SUCCESS;
14100 	char *infop;
14101 
14102 	ASSERT(sdinfo != NULL);
14103 	ASSERT(sata_hba_inst != NULL);
14104 
14105 	/* Prepare packet for SET FEATURES COMMAND */
14106 	spx = kmem_zalloc(sizeof (sata_pkt_txlate_t), KM_SLEEP);
14107 	spx->txlt_sata_hba_inst = sata_hba_inst;
14108 	spx->txlt_scsi_pkt = NULL;	/* No scsi pkt involved */
14109 	spkt = sata_pkt_alloc(spx, SLEEP_FUNC);
14110 	if (spkt == NULL) {
14111 		rval = SATA_FAILURE;
14112 		goto failure;
14113 	}
14114 	/* Fill sata_pkt */
14115 	spkt->satapkt_device.satadev_addr = sdinfo->satadrv_addr;
14116 	/* Timeout 30s */
14117 	spkt->satapkt_time = sata_default_pkt_time;
14118 	/* Synchronous mode, no callback, interrupts */
14119 	spkt->satapkt_op_mode =
14120 	    SATA_OPMODE_SYNCH | SATA_OPMODE_INTERRUPTS;
14121 	spkt->satapkt_comp = NULL;
14122 	scmd = &spkt->satapkt_cmd;
14123 	scmd->satacmd_flags.sata_data_direction = SATA_DIR_NODATA_XFER;
14124 	scmd->satacmd_flags.sata_ignore_dev_reset = B_TRUE;
14125 	scmd->satacmd_addr_type = 0;
14126 	scmd->satacmd_device_reg = 0;
14127 	scmd->satacmd_status_reg = 0;
14128 	scmd->satacmd_error_reg = 0;
14129 	scmd->satacmd_cmd_reg = SATAC_SET_FEATURES;
14130 	if (state == 0)
14131 		scmd->satacmd_features_reg = SATAC_SF_DISABLE_RMSN;
14132 	else
14133 		scmd->satacmd_features_reg = SATAC_SF_ENABLE_RMSN;
14134 
14135 	/* Transfer command to HBA */
14136 	if (((*SATA_START_FUNC(sata_hba_inst))(
14137 	    SATA_DIP(sata_hba_inst), spkt) != SATA_TRAN_ACCEPTED) ||
14138 	    (spkt->satapkt_reason != SATA_PKT_COMPLETED)) {
14139 		/* Pkt execution failed */
14140 		if (state == 0)
14141 			infop = "disabling Removable Media Status "
14142 			    "Notification failed";
14143 		else
14144 			infop = "enabling Removable Media Status "
14145 			    "Notification failed";
14146 
14147 		SATA_LOG_D((sata_hba_inst, CE_WARN, "%s", infop));
14148 		rval = SATA_FAILURE;
14149 	}
14150 failure:
14151 	/* Free allocated resources */
14152 	if (spkt != NULL)
14153 		sata_pkt_free(spx);
14154 	(void) kmem_free(spx, sizeof (sata_pkt_txlate_t));
14155 	return (rval);
14156 }
14157 
14158 
14159 /*
14160  * Update state and copy port ss* values from passed sata_device structure.
14161  * sata_address is validated - if not valid, nothing is changed in sata_scsi
14162  * configuration struct.
14163  *
14164  * SATA_PSTATE_SHUTDOWN in port state is not reset to 0 by this function
14165  * regardless of the state in device argument.
14166  *
14167  * Port mutex should be held while calling this function.
14168  */
14169 static void
14170 sata_update_port_info(sata_hba_inst_t *sata_hba_inst,
14171     sata_device_t *sata_device)
14172 {
14173 	sata_cport_info_t *cportinfo;
14174 
14175 	if (sata_device->satadev_addr.qual == SATA_ADDR_CPORT ||
14176 	    sata_device->satadev_addr.qual == SATA_ADDR_DCPORT) {
14177 		if (SATA_NUM_CPORTS(sata_hba_inst) <=
14178 		    sata_device->satadev_addr.cport)
14179 			return;
14180 
14181 		cportinfo = SATA_CPORT_INFO(sata_hba_inst,
14182 		    sata_device->satadev_addr.cport);
14183 
14184 		ASSERT(mutex_owned(&cportinfo->cport_mutex));
14185 		cportinfo->cport_scr = sata_device->satadev_scr;
14186 
14187 		/* Preserve SATA_PSTATE_SHUTDOWN flag */
14188 		cportinfo->cport_state &= ~(SATA_PSTATE_PWRON |
14189 		    SATA_PSTATE_PWROFF | SATA_PSTATE_FAILED);
14190 		cportinfo->cport_state |=
14191 		    sata_device->satadev_state & SATA_PSTATE_VALID;
14192 	}
14193 }
14194 
14195 void
14196 sata_update_pmport_info(sata_hba_inst_t *sata_hba_inst,
14197     sata_device_t *sata_device)
14198 {
14199 	sata_pmport_info_t *pmportinfo;
14200 
14201 	if ((sata_device->satadev_addr.qual != SATA_ADDR_PMPORT &&
14202 	    sata_device->satadev_addr.qual != SATA_ADDR_DPMPORT) ||
14203 	    SATA_NUM_PMPORTS(sata_hba_inst,
14204 	    sata_device->satadev_addr.cport) <
14205 	    sata_device->satadev_addr.pmport) {
14206 		SATADBG1(SATA_DBG_PMULT, sata_hba_inst,
14207 		    "sata_update_port_info: error address %p.",
14208 		    &sata_device->satadev_addr);
14209 		return;
14210 	}
14211 
14212 	pmportinfo = SATA_PMPORT_INFO(sata_hba_inst,
14213 	    sata_device->satadev_addr.cport,
14214 	    sata_device->satadev_addr.pmport);
14215 
14216 	ASSERT(mutex_owned(&pmportinfo->pmport_mutex));
14217 	pmportinfo->pmport_scr = sata_device->satadev_scr;
14218 
14219 	/* Preserve SATA_PSTATE_SHUTDOWN flag */
14220 	pmportinfo->pmport_state &=
14221 	    ~(SATA_PSTATE_PWRON | SATA_PSTATE_PWROFF | SATA_PSTATE_FAILED);
14222 	pmportinfo->pmport_state |=
14223 	    sata_device->satadev_state & SATA_PSTATE_VALID;
14224 }
14225 
14226 /*
14227  * Extract SATA port specification from an IOCTL argument.
14228  *
14229  * This function return the port the user land send us as is, unless it
14230  * cannot retrieve port spec, then -1 is returned.
14231  *
14232  * Support port multiplier.
14233  */
14234 static int32_t
14235 sata_get_port_num(sata_hba_inst_t *sata_hba_inst, struct devctl_iocdata *dcp)
14236 {
14237 	int32_t port;
14238 
14239 	/* Extract port number from nvpair in dca structure  */
14240 	if (nvlist_lookup_int32(ndi_dc_get_ap_data(dcp), "port", &port) != 0) {
14241 		SATA_LOG_D((sata_hba_inst, CE_NOTE,
14242 		    "sata_get_port_num: invalid port spec 0x%x in ioctl",
14243 		    port));
14244 		port = -1;
14245 	}
14246 
14247 	return (port);
14248 }
14249 
14250 /*
14251  * Get dev_info_t pointer to the device node pointed to by port argument.
14252  * NOTE: target argument is a value used in ioctls to identify
14253  * the AP - it is not a sata_address.
14254  * It is a combination of cport, pmport and address qualifier, encodded same
14255  * way as a scsi target number.
14256  * At this moment it carries only cport number.
14257  *
14258  * PMult hotplug is supported now.
14259  *
14260  * Returns dev_info_t pointer if target device was found, NULL otherwise.
14261  */
14262 
14263 static dev_info_t *
14264 sata_get_target_dip(dev_info_t *dip, uint8_t cport, uint8_t pmport)
14265 {
14266 	dev_info_t	*cdip = NULL;
14267 	int		target, tgt;
14268 	int 		circ;
14269 	uint8_t		qual;
14270 
14271 	sata_hba_inst_t	*sata_hba_inst;
14272 	scsi_hba_tran_t *scsi_hba_tran;
14273 
14274 	/* Get target id */
14275 	scsi_hba_tran = ddi_get_driver_private(dip);
14276 	if (scsi_hba_tran == NULL)
14277 		return (NULL);
14278 
14279 	sata_hba_inst = scsi_hba_tran->tran_hba_private;
14280 
14281 	if (sata_hba_inst == NULL)
14282 		return (NULL);
14283 
14284 	/* Identify a port-mult by cport_info.cport_dev_type */
14285 	if (SATA_CPORT_DEV_TYPE(sata_hba_inst, cport) == SATA_DTYPE_PMULT)
14286 		qual = SATA_ADDR_DPMPORT;
14287 	else
14288 		qual = SATA_ADDR_DCPORT;
14289 
14290 	target = SATA_TO_SCSI_TARGET(cport, pmport, qual);
14291 
14292 	/* Retrieve target dip */
14293 	ndi_devi_enter(dip, &circ);
14294 	for (cdip = ddi_get_child(dip); cdip != NULL; ) {
14295 		dev_info_t *next = ddi_get_next_sibling(cdip);
14296 
14297 		tgt = ddi_prop_get_int(DDI_DEV_T_ANY, cdip,
14298 		    DDI_PROP_DONTPASS, "target", -1);
14299 		if (tgt == -1) {
14300 			/*
14301 			 * This is actually an error condition, but not
14302 			 * a fatal one. Just continue the search.
14303 			 */
14304 			cdip = next;
14305 			continue;
14306 		}
14307 
14308 		if (tgt == target)
14309 			break;
14310 
14311 		cdip = next;
14312 	}
14313 	ndi_devi_exit(dip, circ);
14314 
14315 	return (cdip);
14316 }
14317 
14318 /*
14319  * Get dev_info_t pointer to the device node pointed to by port argument.
14320  * NOTE: target argument is a value used in ioctls to identify
14321  * the AP - it is not a sata_address.
14322  * It is a combination of cport, pmport and address qualifier, encoded same
14323  * way as a scsi target number.
14324  *
14325  * Returns dev_info_t pointer if target device was found, NULL otherwise.
14326  */
14327 
14328 static dev_info_t *
14329 sata_get_scsi_target_dip(dev_info_t *dip, sata_address_t *saddr)
14330 {
14331 	dev_info_t	*cdip = NULL;
14332 	int		target, tgt;
14333 	int 		circ;
14334 
14335 	target = SATA_TO_SCSI_TARGET(saddr->cport, saddr->pmport, saddr->qual);
14336 
14337 	ndi_devi_enter(dip, &circ);
14338 	for (cdip = ddi_get_child(dip); cdip != NULL; ) {
14339 		dev_info_t *next = ddi_get_next_sibling(cdip);
14340 
14341 		tgt = ddi_prop_get_int(DDI_DEV_T_ANY, cdip,
14342 		    DDI_PROP_DONTPASS, "target", -1);
14343 		if (tgt == -1) {
14344 			/*
14345 			 * This is actually an error condition, but not
14346 			 * a fatal one. Just continue the search.
14347 			 */
14348 			cdip = next;
14349 			continue;
14350 		}
14351 
14352 		if (tgt == target)
14353 			break;
14354 
14355 		cdip = next;
14356 	}
14357 	ndi_devi_exit(dip, circ);
14358 
14359 	return (cdip);
14360 }
14361 
14362 /*
14363  * Process sata port disconnect request.
14364  * Normally, cfgadm sata plugin will try to offline (unconfigure) the device
14365  * before this request. Nevertheless, if a device is still configured,
14366  * we need to attempt to offline and unconfigure device.
14367  * Regardless of the unconfigure operation results the port is marked as
14368  * deactivated and no access to the attached device is possible.
14369  * If the target node remains because unconfigure operation failed, its state
14370  * will be set to DEVICE_REMOVED, preventing it to be used again when a device
14371  * is inserted/re-inserted. The event daemon will repeatedly try to unconfigure
14372  * the device and remove old target node.
14373  *
14374  * This function invokes sata_hba_inst->satahba_tran->
14375  * sata_tran_hotplug_ops->sata_tran_port_deactivate().
14376  * If successful, the device structure (if any) attached to the specified port
14377  * is removed and state of the port marked appropriately.
14378  * Failure of the port_deactivate may keep port in the physically active state,
14379  * or may fail the port.
14380  *
14381  * NOTE: Port multiplier is supported.
14382  */
14383 
14384 static int
14385 sata_ioctl_disconnect(sata_hba_inst_t *sata_hba_inst,
14386     sata_device_t *sata_device)
14387 {
14388 	sata_drive_info_t *sdinfo = NULL, *subsdinfo = NULL;
14389 	sata_cport_info_t *cportinfo = NULL;
14390 	sata_pmport_info_t *pmportinfo = NULL;
14391 	sata_pmult_info_t *pmultinfo = NULL;
14392 	sata_device_t subsdevice;
14393 	int cport, pmport, qual;
14394 	int rval = SATA_SUCCESS;
14395 	int npmport = 0;
14396 	int rv = 0;
14397 
14398 	cport = sata_device->satadev_addr.cport;
14399 	pmport = sata_device->satadev_addr.pmport;
14400 	qual = sata_device->satadev_addr.qual;
14401 
14402 	ASSERT(qual == SATA_ADDR_DCPORT || qual == SATA_ADDR_DPMPORT);
14403 	if (qual == SATA_ADDR_DCPORT)
14404 		qual = SATA_ADDR_CPORT;
14405 	else
14406 		qual = SATA_ADDR_PMPORT;
14407 
14408 	/*
14409 	 * DEVCTL_AP_DISCONNECT invokes sata_hba_inst->satahba_tran->
14410 	 * sata_tran_hotplug_ops->sata_tran_port_deactivate().
14411 	 * Do the sanity check.
14412 	 */
14413 	if (SATA_PORT_DEACTIVATE_FUNC(sata_hba_inst) == NULL) {
14414 		/* No physical port deactivation supported. */
14415 		return (EINVAL);
14416 	}
14417 
14418 	/* Check the current state of the port */
14419 	rval = (*SATA_PROBE_PORT_FUNC(sata_hba_inst))
14420 	    (SATA_DIP(sata_hba_inst), sata_device);
14421 
14422 	cportinfo = SATA_CPORT_INFO(sata_hba_inst, cport);
14423 
14424 	/*
14425 	 * Processing port mulitiplier
14426 	 */
14427 	if (qual == SATA_ADDR_CPORT &&
14428 	    SATA_CPORT_DEV_TYPE(sata_hba_inst, cport) == SATA_DTYPE_PMULT) {
14429 		mutex_enter(&cportinfo->cport_mutex);
14430 
14431 		/* Check controller port status */
14432 		sata_update_port_info(sata_hba_inst, sata_device);
14433 		if (rval != SATA_SUCCESS ||
14434 		    (sata_device->satadev_state & SATA_PSTATE_FAILED) != 0) {
14435 			/*
14436 			 * Device port status is unknown or it is in failed
14437 			 * state
14438 			 */
14439 			SATA_CPORT_STATE(sata_hba_inst, cport) =
14440 			    SATA_PSTATE_FAILED;
14441 			SATADBG1(SATA_DBG_IOCTL_IF, sata_hba_inst,
14442 			    "sata_hba_ioctl: connect: failed to deactivate "
14443 			    "SATA port %d", cport);
14444 			mutex_exit(&cportinfo->cport_mutex);
14445 			return (EIO);
14446 		}
14447 
14448 		/* Disconnect all sub-devices. */
14449 		pmultinfo = SATA_CPORTINFO_PMULT_INFO(cportinfo);
14450 		if (pmultinfo != NULL) {
14451 
14452 			for (npmport = 0; npmport < SATA_NUM_PMPORTS(
14453 			    sata_hba_inst, cport); npmport ++) {
14454 				subsdinfo = SATA_PMPORT_DRV_INFO(
14455 				    sata_hba_inst, cport, npmport);
14456 				if (subsdinfo == NULL)
14457 					continue;
14458 
14459 				subsdevice.satadev_addr = subsdinfo->
14460 				    satadrv_addr;
14461 
14462 				mutex_exit(&cportinfo->cport_mutex);
14463 				if (sata_ioctl_disconnect(sata_hba_inst,
14464 				    &subsdevice) == SATA_SUCCESS) {
14465 					SATADBG2(SATA_DBG_PMULT, sata_hba_inst,
14466 					"[Remove] device at port %d:%d "
14467 					"successfully.", cport, npmport);
14468 				}
14469 				mutex_enter(&cportinfo->cport_mutex);
14470 			}
14471 		}
14472 
14473 		/* Disconnect the port multiplier */
14474 		cportinfo->cport_state &= ~SATA_STATE_READY;
14475 		mutex_exit(&cportinfo->cport_mutex);
14476 
14477 		sata_device->satadev_addr.qual = qual;
14478 		rval = (*SATA_PORT_DEACTIVATE_FUNC(sata_hba_inst))
14479 		    (SATA_DIP(sata_hba_inst), sata_device);
14480 
14481 		sata_gen_sysevent(sata_hba_inst, &sata_device->satadev_addr,
14482 		    SE_NO_HINT);
14483 
14484 		mutex_enter(&cportinfo->cport_mutex);
14485 		sata_update_port_info(sata_hba_inst, sata_device);
14486 		if (rval != SATA_SUCCESS &&
14487 		    sata_device->satadev_state & SATA_PSTATE_FAILED) {
14488 			cportinfo->cport_state = SATA_PSTATE_FAILED;
14489 			rv = EIO;
14490 		} else {
14491 			cportinfo->cport_state |= SATA_PSTATE_SHUTDOWN;
14492 		}
14493 		mutex_exit(&cportinfo->cport_mutex);
14494 
14495 		return (rv);
14496 	}
14497 
14498 	/*
14499 	 * Process non-port-multiplier device - it could be a drive connected
14500 	 * to a port multiplier port or a controller port.
14501 	 */
14502 	if (qual == SATA_ADDR_PMPORT) {
14503 		pmportinfo = SATA_PMPORT_INFO(sata_hba_inst, cport, pmport);
14504 		mutex_enter(&pmportinfo->pmport_mutex);
14505 		sata_update_pmport_info(sata_hba_inst, sata_device);
14506 		if (rval != SATA_SUCCESS ||
14507 		    (sata_device->satadev_state & SATA_PSTATE_FAILED) != 0) {
14508 			SATA_PMPORT_STATE(sata_hba_inst, cport, pmport) =
14509 			    SATA_PSTATE_FAILED;
14510 			SATADBG2(SATA_DBG_IOCTL_IF, sata_hba_inst,
14511 			    "sata_hba_ioctl: connect: failed to deactivate "
14512 			    "SATA port %d:%d", cport, pmport);
14513 			mutex_exit(&pmportinfo->pmport_mutex);
14514 			return (EIO);
14515 		}
14516 
14517 		if (pmportinfo->pmport_dev_type != SATA_DTYPE_NONE) {
14518 			sdinfo = pmportinfo->pmport_sata_drive;
14519 			ASSERT(sdinfo != NULL);
14520 		}
14521 
14522 		/*
14523 		 * Set port's dev_state to not ready - this will disable
14524 		 * an access to a potentially attached device.
14525 		 */
14526 		pmportinfo->pmport_state &= ~SATA_STATE_READY;
14527 
14528 		/* Remove and release sata_drive info structure. */
14529 		if (sdinfo != NULL) {
14530 			if ((sdinfo->satadrv_type &
14531 			    SATA_VALID_DEV_TYPE) != 0) {
14532 				/*
14533 				 * If a target node exists, try to offline
14534 				 * a device and remove target node.
14535 				 */
14536 				mutex_exit(&pmportinfo->pmport_mutex);
14537 				(void) sata_offline_device(sata_hba_inst,
14538 				    sata_device, sdinfo);
14539 				mutex_enter(&pmportinfo->pmport_mutex);
14540 			}
14541 
14542 			SATA_PMPORTINFO_DRV_INFO(pmportinfo) = NULL;
14543 			pmportinfo->pmport_dev_type = SATA_DTYPE_NONE;
14544 			(void) kmem_free((void *)sdinfo,
14545 			    sizeof (sata_drive_info_t));
14546 		}
14547 		mutex_exit(&pmportinfo->pmport_mutex);
14548 
14549 	} else if (qual == SATA_ADDR_CPORT) {
14550 		mutex_enter(&cportinfo->cport_mutex);
14551 		sata_update_port_info(sata_hba_inst, sata_device);
14552 		if (rval != SATA_SUCCESS ||
14553 		    (sata_device->satadev_state & SATA_PSTATE_FAILED) != 0) {
14554 			/*
14555 			 * Device port status is unknown or it is in failed
14556 			 * state
14557 			 */
14558 			SATA_CPORT_STATE(sata_hba_inst, cport) =
14559 			    SATA_PSTATE_FAILED;
14560 			SATADBG1(SATA_DBG_IOCTL_IF, sata_hba_inst,
14561 			    "sata_hba_ioctl: connect: failed to deactivate "
14562 			    "SATA port %d", cport);
14563 			mutex_exit(&cportinfo->cport_mutex);
14564 			return (EIO);
14565 		}
14566 
14567 		if (cportinfo->cport_dev_type == SATA_DTYPE_PMULT) {
14568 			pmultinfo = SATA_CPORTINFO_PMULT_INFO(cportinfo);
14569 			ASSERT(pmultinfo != NULL);
14570 		} else if (cportinfo->cport_dev_type != SATA_DTYPE_NONE) {
14571 			sdinfo = SATA_CPORTINFO_DRV_INFO(cportinfo);
14572 			ASSERT(sdinfo != NULL);
14573 		}
14574 		cportinfo->cport_state &= ~SATA_STATE_READY;
14575 
14576 		if (sdinfo != NULL) {
14577 			if ((sdinfo->satadrv_type &
14578 			    SATA_VALID_DEV_TYPE) != 0) {
14579 				/*
14580 				 * If a target node exists, try to offline
14581 				 * a device and remove target node.
14582 				 */
14583 				mutex_exit(&cportinfo->cport_mutex);
14584 				(void) sata_offline_device(sata_hba_inst,
14585 				    sata_device, sdinfo);
14586 				mutex_enter(&cportinfo->cport_mutex);
14587 			}
14588 
14589 			SATA_CPORTINFO_DRV_INFO(cportinfo) = NULL;
14590 			cportinfo->cport_dev_type = SATA_DTYPE_NONE;
14591 			(void) kmem_free((void *)sdinfo,
14592 			    sizeof (sata_drive_info_t));
14593 		}
14594 		mutex_exit(&cportinfo->cport_mutex);
14595 	}
14596 
14597 	/* Just ask HBA driver to deactivate port */
14598 	sata_device->satadev_addr.qual = qual;
14599 
14600 	rval = (*SATA_PORT_DEACTIVATE_FUNC(sata_hba_inst))
14601 	    (SATA_DIP(sata_hba_inst), sata_device);
14602 
14603 	/*
14604 	 * Generate sysevent - EC_DR / ESC_DR_AP_STATE_CHANGE
14605 	 * without the hint (to force listener to investivate the state).
14606 	 */
14607 	sata_gen_sysevent(sata_hba_inst, &sata_device->satadev_addr,
14608 	    SE_NO_HINT);
14609 
14610 	if (qual == SATA_ADDR_PMPORT) {
14611 		mutex_enter(&pmportinfo->pmport_mutex);
14612 		sata_update_pmport_info(sata_hba_inst, sata_device);
14613 
14614 		if (rval != SATA_SUCCESS &&
14615 		    sata_device->satadev_state & SATA_PSTATE_FAILED) {
14616 			/*
14617 			 * Port deactivation failure - do not change port
14618 			 * state unless the state returned by HBA indicates a
14619 			 * port failure.
14620 			 *
14621 			 * NOTE: device structures were released, so devices
14622 			 * now are invisible! Port reset is needed to
14623 			 * re-enumerate devices.
14624 			 */
14625 			pmportinfo->pmport_state = SATA_PSTATE_FAILED;
14626 			rv = EIO;
14627 		} else {
14628 			/*
14629 			 * Deactivation succeded. From now on the sata framework
14630 			 * will not care what is happening to the device, until
14631 			 * the port is activated again.
14632 			 */
14633 			pmportinfo->pmport_state |= SATA_PSTATE_SHUTDOWN;
14634 		}
14635 		mutex_exit(&pmportinfo->pmport_mutex);
14636 	} else if (qual == SATA_ADDR_CPORT) {
14637 		mutex_enter(&cportinfo->cport_mutex);
14638 		sata_update_port_info(sata_hba_inst, sata_device);
14639 
14640 		if (rval != SATA_SUCCESS &&
14641 		    sata_device->satadev_state & SATA_PSTATE_FAILED) {
14642 			cportinfo->cport_state = SATA_PSTATE_FAILED;
14643 			rv = EIO;
14644 		} else {
14645 			cportinfo->cport_state |= SATA_PSTATE_SHUTDOWN;
14646 		}
14647 		mutex_exit(&cportinfo->cport_mutex);
14648 	}
14649 
14650 	return (rv);
14651 }
14652 
14653 
14654 
14655 /*
14656  * Process sata port connect request
14657  * The sata cfgadm pluging will invoke this operation only if port was found
14658  * in the disconnect state (failed state is also treated as the disconnected
14659  * state).
14660  * DEVCTL_AP_CONNECT would invoke  sata_hba_inst->satahba_tran->
14661  * sata_tran_hotplug_ops->sata_tran_port_activate().
14662  * If successful and a device is found attached to the port,
14663  * the initialization sequence is executed to attach a device structure to
14664  * a port structure. The state of the port and a device would be set
14665  * appropriately.
14666  * The device is not set in configured state (system-wise) by this operation.
14667  *
14668  * Note, that activating the port may generate link events,
14669  * so it is important that following processing and the
14670  * event processing does not interfere with each other!
14671  *
14672  * This operation may remove port failed state and will
14673  * try to make port active and in good standing.
14674  *
14675  * NOTE: Port multiplier is supported.
14676  */
14677 
14678 static int
14679 sata_ioctl_connect(sata_hba_inst_t *sata_hba_inst,
14680     sata_device_t *sata_device)
14681 {
14682 	sata_pmport_info_t	*pmportinfo = NULL;
14683 	uint8_t cport, pmport, qual;
14684 	int rv = 0;
14685 
14686 	cport = sata_device->satadev_addr.cport;
14687 	pmport = sata_device->satadev_addr.pmport;
14688 	qual = sata_device->satadev_addr.qual;
14689 
14690 	ASSERT(qual == SATA_ADDR_DCPORT || qual == SATA_ADDR_DPMPORT);
14691 	if (qual == SATA_ADDR_DCPORT)
14692 		qual = SATA_ADDR_CPORT;
14693 	else
14694 		qual = SATA_ADDR_PMPORT;
14695 
14696 	if (qual == SATA_ADDR_PMPORT)
14697 		pmportinfo = SATA_PMPORT_INFO(sata_hba_inst, cport, pmport);
14698 
14699 	/*
14700 	 * DEVCTL_AP_CONNECT would invoke sata_hba_inst->
14701 	 * satahba_tran->sata_tran_hotplug_ops->sata_tran_port_activate().
14702 	 * Perform sanity check now.
14703 	 */
14704 	if (SATA_PORT_ACTIVATE_FUNC(sata_hba_inst) == NULL) {
14705 		/* No physical port activation supported. */
14706 		return (EINVAL);
14707 	}
14708 
14709 	/* Just ask HBA driver to activate port */
14710 	if ((*SATA_PORT_ACTIVATE_FUNC(sata_hba_inst))
14711 	    (SATA_DIP(sata_hba_inst), sata_device) != SATA_SUCCESS) {
14712 		/*
14713 		 * Port activation failure.
14714 		 */
14715 		if (qual == SATA_ADDR_CPORT) {
14716 			mutex_enter(&SATA_CPORT_INFO(sata_hba_inst,
14717 			    cport)->cport_mutex);
14718 			sata_update_port_info(sata_hba_inst, sata_device);
14719 			if (sata_device->satadev_state & SATA_PSTATE_FAILED) {
14720 				SATA_CPORT_STATE(sata_hba_inst, cport) =
14721 				    SATA_PSTATE_FAILED;
14722 				SATADBG1(SATA_DBG_IOCTL_IF, sata_hba_inst,
14723 				    "sata_hba_ioctl: connect: failed to "
14724 				    "activate SATA port %d", cport);
14725 			}
14726 			mutex_exit(&SATA_CPORT_INFO(sata_hba_inst,
14727 			    cport)->cport_mutex);
14728 		} else { /* port multiplier device port */
14729 			mutex_enter(&pmportinfo->pmport_mutex);
14730 			sata_update_pmport_info(sata_hba_inst, sata_device);
14731 			if (sata_device->satadev_state & SATA_PSTATE_FAILED) {
14732 				SATA_PMPORT_STATE(sata_hba_inst, cport,
14733 				    pmport) = SATA_PSTATE_FAILED;
14734 				SATADBG2(SATA_DBG_IOCTL_IF, sata_hba_inst,
14735 				    "sata_hba_ioctl: connect: failed to "
14736 				    "activate SATA port %d:%d", cport, pmport);
14737 			}
14738 			mutex_exit(&pmportinfo->pmport_mutex);
14739 		}
14740 		return (EIO);
14741 	}
14742 
14743 	/* Virgin port state - will be updated by the port re-probe. */
14744 	if (qual == SATA_ADDR_CPORT) {
14745 		mutex_enter(&SATA_CPORT_INFO(sata_hba_inst,
14746 		    cport)->cport_mutex);
14747 		SATA_CPORT_STATE(sata_hba_inst, cport) = 0;
14748 		mutex_exit(&SATA_CPORT_INFO(sata_hba_inst,
14749 		    cport)->cport_mutex);
14750 	} else { /* port multiplier device port */
14751 		mutex_enter(&pmportinfo->pmport_mutex);
14752 		SATA_PMPORT_STATE(sata_hba_inst, cport, pmport) = 0;
14753 		mutex_exit(&pmportinfo->pmport_mutex);
14754 	}
14755 
14756 	/*
14757 	 * Probe the port to find its state and attached device.
14758 	 */
14759 	if (sata_reprobe_port(sata_hba_inst, sata_device,
14760 	    SATA_DEV_IDENTIFY_RETRY) == SATA_FAILURE)
14761 		rv = EIO;
14762 
14763 	/*
14764 	 * Generate sysevent - EC_DR / ESC_DR_AP_STATE_CHANGE
14765 	 * without the hint
14766 	 */
14767 	sata_gen_sysevent(sata_hba_inst, &sata_device->satadev_addr,
14768 	    SE_NO_HINT);
14769 
14770 	/*
14771 	 * If there is a device attached to the port, emit
14772 	 * a message.
14773 	 */
14774 	if (sata_device->satadev_type != SATA_DTYPE_NONE) {
14775 
14776 		if (qual == SATA_ADDR_CPORT) {
14777 			if (sata_device->satadev_type == SATA_DTYPE_PMULT) {
14778 				sata_log(sata_hba_inst, CE_WARN,
14779 				    "SATA port multiplier detected "
14780 				    "at port %d", cport);
14781 			} else {
14782 				sata_log(sata_hba_inst, CE_WARN,
14783 				    "SATA device detected at port %d", cport);
14784 				if (sata_device->satadev_type ==
14785 				    SATA_DTYPE_UNKNOWN) {
14786 				/*
14787 				 * A device was not successfully identified
14788 				 */
14789 				sata_log(sata_hba_inst, CE_WARN,
14790 				    "Could not identify SATA "
14791 				    "device at port %d", cport);
14792 				}
14793 			}
14794 		} else { /* port multiplier device port */
14795 			sata_log(sata_hba_inst, CE_WARN,
14796 			    "SATA device detected at port %d:%d",
14797 			    cport, pmport);
14798 			if (sata_device->satadev_type == SATA_DTYPE_UNKNOWN) {
14799 				/*
14800 				 * A device was not successfully identified
14801 				 */
14802 				sata_log(sata_hba_inst, CE_WARN,
14803 				    "Could not identify SATA "
14804 				    "device at port %d:%d", cport, pmport);
14805 			}
14806 		}
14807 	}
14808 
14809 	return (rv);
14810 }
14811 
14812 
14813 /*
14814  * Process sata device unconfigure request.
14815  * The unconfigure operation uses generic nexus operation to
14816  * offline a device. It leaves a target device node attached.
14817  * and obviously sata_drive_info attached as well, because
14818  * from the hardware point of view nothing has changed.
14819  */
14820 static int
14821 sata_ioctl_unconfigure(sata_hba_inst_t *sata_hba_inst,
14822     sata_device_t *sata_device)
14823 {
14824 	int rv = 0;
14825 	dev_info_t *tdip;
14826 
14827 	/* We are addressing attached device, not a port */
14828 	if (sata_device->satadev_addr.qual == SATA_ADDR_CPORT)
14829 		sata_device->satadev_addr.qual = SATA_ADDR_DCPORT;
14830 	else if (sata_device->satadev_addr.qual == SATA_ADDR_PMPORT)
14831 		sata_device->satadev_addr.qual = SATA_ADDR_DPMPORT;
14832 
14833 	if ((tdip = sata_get_scsi_target_dip(SATA_DIP(sata_hba_inst),
14834 	    &sata_device->satadev_addr)) != NULL) {
14835 
14836 		if (ndi_devi_offline(tdip, NDI_UNCONFIG) != NDI_SUCCESS) {
14837 			SATA_LOG_D((sata_hba_inst, CE_WARN,
14838 			    "sata_hba_ioctl: unconfigure: "
14839 			    "failed to unconfigure device at SATA port %d:%d",
14840 			    sata_device->satadev_addr.cport,
14841 			    sata_device->satadev_addr.pmport));
14842 			rv = EIO;
14843 		}
14844 		/*
14845 		 * The target node devi_state should be marked with
14846 		 * DEVI_DEVICE_OFFLINE by ndi_devi_offline().
14847 		 * This would be the indication for cfgadm that
14848 		 * the AP node occupant state is 'unconfigured'.
14849 		 */
14850 
14851 	} else {
14852 		/*
14853 		 * This would indicate a failure on the part of cfgadm
14854 		 * to detect correct state of the node prior to this
14855 		 * call - one cannot unconfigure non-existing device.
14856 		 */
14857 		SATA_LOG_D((sata_hba_inst, CE_WARN,
14858 		    "sata_hba_ioctl: unconfigure: "
14859 		    "attempt to unconfigure non-existing device "
14860 		    "at SATA port %d:%d",
14861 		    sata_device->satadev_addr.cport,
14862 		    sata_device->satadev_addr.pmport));
14863 		rv = ENXIO;
14864 	}
14865 	return (rv);
14866 }
14867 
14868 /*
14869  * Process sata device configure request
14870  * If port is in a failed state, operation is aborted - one has to use
14871  * an explicit connect or port activate request to try to get a port into
14872  * non-failed mode. Port reset wil also work in such situation.
14873  * If the port is in disconnected (shutdown) state, the connect operation is
14874  * attempted prior to any other action.
14875  * When port is in the active state, there is a device attached and the target
14876  * node exists, a device was most likely offlined.
14877  * If target node does not exist, a new target node is created. In both cases
14878  * an attempt is made to online (configure) the device.
14879  *
14880  * NOTE: Port multiplier is supported.
14881  */
14882 static int
14883 sata_ioctl_configure(sata_hba_inst_t *sata_hba_inst,
14884     sata_device_t *sata_device)
14885 {
14886 	int cport, pmport, qual;
14887 	int rval;
14888 	boolean_t target = B_TRUE;
14889 	sata_cport_info_t *cportinfo;
14890 	sata_pmport_info_t *pmportinfo = NULL;
14891 	dev_info_t *tdip;
14892 	sata_drive_info_t *sdinfo;
14893 
14894 	cport = sata_device->satadev_addr.cport;
14895 	pmport = sata_device->satadev_addr.pmport;
14896 	qual = sata_device->satadev_addr.qual;
14897 
14898 	/* Get current port state */
14899 	rval = (*SATA_PROBE_PORT_FUNC(sata_hba_inst))
14900 	    (SATA_DIP(sata_hba_inst), sata_device);
14901 
14902 	cportinfo = SATA_CPORT_INFO(sata_hba_inst, cport);
14903 	if (qual == SATA_ADDR_DPMPORT) {
14904 		pmportinfo = SATA_PMPORT_INFO(sata_hba_inst, cport, pmport);
14905 		mutex_enter(&pmportinfo->pmport_mutex);
14906 		sata_update_pmport_info(sata_hba_inst, sata_device);
14907 		if (rval != SATA_SUCCESS ||
14908 		    (sata_device->satadev_state & SATA_PSTATE_FAILED) != 0) {
14909 			/*
14910 			 * Obviously, device on a failed port is not visible
14911 			 */
14912 			mutex_exit(&pmportinfo->pmport_mutex);
14913 			return (ENXIO);
14914 		}
14915 		mutex_exit(&pmportinfo->pmport_mutex);
14916 	} else {
14917 		mutex_enter(&SATA_CPORT_INFO(sata_hba_inst,
14918 		    cport)->cport_mutex);
14919 		sata_update_port_info(sata_hba_inst, sata_device);
14920 		if (rval != SATA_SUCCESS ||
14921 		    (sata_device->satadev_state & SATA_PSTATE_FAILED) != 0) {
14922 			/*
14923 			 * Obviously, device on a failed port is not visible
14924 			 */
14925 			mutex_exit(&SATA_CPORT_INFO(sata_hba_inst,
14926 			    cport)->cport_mutex);
14927 			return (ENXIO);
14928 		}
14929 		mutex_exit(&SATA_CPORT_INFO(sata_hba_inst,
14930 		    cport)->cport_mutex);
14931 	}
14932 
14933 	if ((sata_device->satadev_state & SATA_PSTATE_SHUTDOWN) != 0) {
14934 		/* need to activate port */
14935 		target = B_FALSE;
14936 
14937 		/* Sanity check */
14938 		if (SATA_PORT_ACTIVATE_FUNC(sata_hba_inst) == NULL)
14939 			return (ENXIO);
14940 
14941 		/* Just let HBA driver to activate port */
14942 		if ((*SATA_PORT_ACTIVATE_FUNC(sata_hba_inst))
14943 		    (SATA_DIP(sata_hba_inst), sata_device) != SATA_SUCCESS) {
14944 			/*
14945 			 * Port activation failure - do not change port state
14946 			 * unless the state returned by HBA indicates a port
14947 			 * failure.
14948 			 */
14949 			if (qual == SATA_ADDR_DPMPORT) {
14950 				mutex_enter(&pmportinfo->pmport_mutex);
14951 				sata_update_pmport_info(sata_hba_inst,
14952 				    sata_device);
14953 				if (sata_device->satadev_state &
14954 				    SATA_PSTATE_FAILED)
14955 					pmportinfo->pmport_state =
14956 					    SATA_PSTATE_FAILED;
14957 				mutex_exit(&pmportinfo->pmport_mutex);
14958 			} else {
14959 				mutex_enter(&SATA_CPORT_INFO(sata_hba_inst,
14960 				    cport)->cport_mutex);
14961 				sata_update_port_info(sata_hba_inst,
14962 				    sata_device);
14963 				if (sata_device->satadev_state &
14964 				    SATA_PSTATE_FAILED)
14965 					cportinfo->cport_state =
14966 					    SATA_PSTATE_FAILED;
14967 				mutex_exit(&SATA_CPORT_INFO(
14968 				    sata_hba_inst, cport)->cport_mutex);
14969 			}
14970 		}
14971 		SATA_LOG_D((sata_hba_inst, CE_WARN,
14972 		    "sata_hba_ioctl: configure: "
14973 		    "failed to activate SATA port %d:%d",
14974 		    cport, pmport));
14975 		return (EIO);
14976 	}
14977 	/*
14978 	 * Generate sysevent - EC_DR / ESC_DR_AP_STATE_CHANGE
14979 	 * without the hint.
14980 	 */
14981 	sata_gen_sysevent(sata_hba_inst,
14982 	    &sata_device->satadev_addr, SE_NO_HINT);
14983 
14984 	/* Virgin port state */
14985 	if (qual == SATA_ADDR_DPMPORT) {
14986 		mutex_enter(&pmportinfo->pmport_mutex);
14987 		pmportinfo->pmport_state = 0;
14988 		mutex_exit(&pmportinfo->pmport_mutex);
14989 	} else {
14990 		mutex_enter(&SATA_CPORT_INFO(sata_hba_inst,
14991 		    cport)-> cport_mutex);
14992 		cportinfo->cport_state = 0;
14993 		mutex_exit(&SATA_CPORT_INFO(sata_hba_inst,
14994 		    cport)->cport_mutex);
14995 	}
14996 	/*
14997 	 * Always reprobe port, to get current device info.
14998 	 */
14999 	if (sata_reprobe_port(sata_hba_inst, sata_device,
15000 	    SATA_DEV_IDENTIFY_RETRY) != SATA_SUCCESS)
15001 		return (EIO);
15002 
15003 	if (sata_device->satadev_type != SATA_DTYPE_NONE && target == B_FALSE) {
15004 		if (qual == SATA_ADDR_DPMPORT) {
15005 			/*
15006 			 * That's the transition from "inactive" port
15007 			 * to active one with device attached.
15008 			 */
15009 			sata_log(sata_hba_inst, CE_WARN,
15010 			    "SATA device detected at port %d:%d",
15011 			    cport, pmport);
15012 		} else {
15013 			/*
15014 			 * When PM is attached to the cport and cport is
15015 			 * activated, every PM device port needs to be reprobed.
15016 			 * We need to emit message for all devices detected
15017 			 * at port multiplier's device ports.
15018 			 * Add such code here.
15019 			 * For now, just inform about device attached to
15020 			 * cport.
15021 			 */
15022 			sata_log(sata_hba_inst, CE_WARN,
15023 			    "SATA device detected at port %d", cport);
15024 		}
15025 	}
15026 
15027 	/*
15028 	 * This is where real configuration operation starts.
15029 	 *
15030 	 * When PM is attached to the cport and cport is activated,
15031 	 * devices attached PM device ports may have to be configured
15032 	 * explicitly. This may change when port multiplier is supported.
15033 	 * For now, configure only disks and other valid target devices.
15034 	 */
15035 	if (!(sata_device->satadev_type & SATA_VALID_DEV_TYPE)) {
15036 		if (qual == SATA_ADDR_DCPORT) {
15037 			if (sata_device->satadev_type == SATA_DTYPE_UNKNOWN) {
15038 				/*
15039 				 * A device was not successfully identified
15040 				 */
15041 				sata_log(sata_hba_inst, CE_WARN,
15042 				    "Could not identify SATA "
15043 				    "device at port %d", cport);
15044 			}
15045 		} else { /* port multiplier device port */
15046 			if (sata_device->satadev_type == SATA_DTYPE_UNKNOWN) {
15047 				/*
15048 				 * A device was not successfully identified
15049 				 */
15050 				sata_log(sata_hba_inst, CE_WARN,
15051 				    "Could not identify SATA "
15052 				    "device at port %d:%d", cport, pmport);
15053 			}
15054 		}
15055 		return (ENXIO);		/* No device to configure */
15056 	}
15057 
15058 	/*
15059 	 * Here we may have a device in reset condition,
15060 	 * but because we are just configuring it, there is
15061 	 * no need to process the reset other than just
15062 	 * to clear device reset condition in the HBA driver.
15063 	 * Setting the flag SATA_EVNT_CLEAR_DEVICE_RESET will
15064 	 * cause a first command sent the HBA driver with the request
15065 	 * to clear device reset condition.
15066 	 */
15067 	mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex);
15068 	if (qual == SATA_ADDR_DPMPORT)
15069 		sata_device->satadev_addr.qual = SATA_ADDR_DPMPORT;
15070 	else
15071 		sata_device->satadev_addr.qual = SATA_ADDR_DCPORT;
15072 	sdinfo = sata_get_device_info(sata_hba_inst, sata_device);
15073 	if (sdinfo == NULL) {
15074 		mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex);
15075 		return (ENXIO);
15076 	}
15077 	if (sdinfo->satadrv_event_flags &
15078 	    (SATA_EVNT_DEVICE_RESET | SATA_EVNT_INPROC_DEVICE_RESET)) {
15079 		sdinfo->satadrv_event_flags = 0;
15080 	}
15081 	sdinfo->satadrv_event_flags |= SATA_EVNT_CLEAR_DEVICE_RESET;
15082 	mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex);
15083 
15084 	if ((tdip = sata_get_scsi_target_dip(SATA_DIP(sata_hba_inst),
15085 	    &sata_device->satadev_addr)) != NULL) {
15086 		/*
15087 		 * Target node exists. Verify, that it belongs
15088 		 * to existing, attached device and not to
15089 		 * a removed device.
15090 		 */
15091 		if (sata_check_device_removed(tdip) == B_TRUE) {
15092 			if (qual == SATA_ADDR_DPMPORT)
15093 				sata_log(sata_hba_inst, CE_WARN,
15094 				    "SATA device at port %d cannot be "
15095 				    "configured. "
15096 				    "Application(s) accessing "
15097 				    "previously attached device "
15098 				    "have to release it before newly "
15099 				    "inserted device can be made accessible.",
15100 				    cport);
15101 			else
15102 				sata_log(sata_hba_inst, CE_WARN,
15103 				    "SATA device at port %d:%d cannot be"
15104 				    "configured. "
15105 				    "Application(s) accessing "
15106 				    "previously attached device "
15107 				    "have to release it before newly "
15108 				    "inserted device can be made accessible.",
15109 				    cport, pmport);
15110 			return (EIO);
15111 		}
15112 		/*
15113 		 * Device was not removed and re-inserted.
15114 		 * Try to online it.
15115 		 */
15116 		if (ndi_devi_online(tdip, 0) != NDI_SUCCESS) {
15117 			SATA_LOG_D((sata_hba_inst, CE_WARN,
15118 			    "sata_hba_ioctl: configure: "
15119 			    "onlining device at SATA port "
15120 			    "%d:%d failed", cport, pmport));
15121 			return (EIO);
15122 		}
15123 
15124 		if (qual == SATA_ADDR_DPMPORT) {
15125 			mutex_enter(&pmportinfo->pmport_mutex);
15126 			pmportinfo->pmport_tgtnode_clean = B_TRUE;
15127 			mutex_exit(&pmportinfo->pmport_mutex);
15128 		} else {
15129 			mutex_enter(&SATA_CPORT_INFO(sata_hba_inst,
15130 			    cport)->cport_mutex);
15131 			cportinfo-> cport_tgtnode_clean = B_TRUE;
15132 			mutex_exit(&SATA_CPORT_INFO(
15133 			    sata_hba_inst, cport)->cport_mutex);
15134 		}
15135 	} else {
15136 		/*
15137 		 * No target node - need to create a new target node.
15138 		 */
15139 		if (qual == SATA_ADDR_DPMPORT) {
15140 			mutex_enter(&pmportinfo->pmport_mutex);
15141 			pmportinfo->pmport_tgtnode_clean = B_TRUE;
15142 			mutex_exit(&pmportinfo->pmport_mutex);
15143 		} else {
15144 			mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, cport)->
15145 			    cport_mutex);
15146 			cportinfo-> cport_tgtnode_clean = B_TRUE;
15147 			mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)->
15148 			    cport_mutex);
15149 		}
15150 
15151 		tdip = sata_create_target_node(SATA_DIP(sata_hba_inst),
15152 		    sata_hba_inst, &sata_device->satadev_addr);
15153 		if (tdip == NULL) {
15154 			/* Configure operation failed */
15155 			SATA_LOG_D((sata_hba_inst, CE_WARN,
15156 			    "sata_hba_ioctl: configure: "
15157 			    "configuring SATA device at port %d:%d "
15158 			    "failed", cport, pmport));
15159 			return (EIO);
15160 		}
15161 	}
15162 	return (0);
15163 }
15164 
15165 
15166 /*
15167  * Process ioctl deactivate port request.
15168  * Arbitrarily unconfigure attached device, if any.
15169  * Even if the unconfigure fails, proceed with the
15170  * port deactivation.
15171  *
15172  * NOTE: Port Multiplier is supported now.
15173  */
15174 
15175 static int
15176 sata_ioctl_deactivate(sata_hba_inst_t *sata_hba_inst,
15177     sata_device_t *sata_device)
15178 {
15179 	int cport, pmport, qual;
15180 	int rval, rv = 0;
15181 	int npmport;
15182 	sata_cport_info_t *cportinfo;
15183 	sata_pmport_info_t *pmportinfo;
15184 	sata_pmult_info_t *pmultinfo;
15185 	dev_info_t *tdip;
15186 	sata_drive_info_t *sdinfo = NULL;
15187 	sata_device_t subsdevice;
15188 
15189 	/* Sanity check */
15190 	if (SATA_PORT_DEACTIVATE_FUNC(sata_hba_inst) == NULL)
15191 		return (ENOTSUP);
15192 
15193 	cport = sata_device->satadev_addr.cport;
15194 	pmport = sata_device->satadev_addr.pmport;
15195 	qual = sata_device->satadev_addr.qual;
15196 
15197 	/* SCSI_TO_SATA_ADDR_QUAL() translate ap_id into a device qualifier */
15198 	ASSERT(qual == SATA_ADDR_DCPORT || qual == SATA_ADDR_DPMPORT);
15199 	if (qual == SATA_ADDR_DCPORT)
15200 		qual = SATA_ADDR_CPORT;
15201 	else
15202 		qual = SATA_ADDR_PMPORT;
15203 
15204 	cportinfo = SATA_CPORT_INFO(sata_hba_inst, cport);
15205 	if (qual == SATA_ADDR_PMPORT)
15206 		pmportinfo = SATA_PMPORT_INFO(sata_hba_inst, cport, pmport);
15207 
15208 	/*
15209 	 * Processing port multiplier
15210 	 */
15211 	if (qual == SATA_ADDR_CPORT &&
15212 	    SATA_CPORT_DEV_TYPE(sata_hba_inst, cport) == SATA_DTYPE_PMULT) {
15213 		mutex_enter(&cportinfo->cport_mutex);
15214 
15215 		/* Deactivate all sub-deices */
15216 		pmultinfo = SATA_CPORTINFO_PMULT_INFO(cportinfo);
15217 		if (pmultinfo != NULL) {
15218 			for (npmport = 0; npmport < SATA_NUM_PMPORTS(
15219 			    sata_hba_inst, cport); npmport++) {
15220 
15221 				subsdevice.satadev_addr.cport = cport;
15222 				subsdevice.satadev_addr.pmport =
15223 				    (uint8_t)npmport;
15224 				subsdevice.satadev_addr.qual =
15225 				    SATA_ADDR_DPMPORT;
15226 
15227 				SATADBG2(SATA_DBG_PMULT, sata_hba_inst,
15228 				    "sata_hba_ioctl: deactivate: trying to "
15229 				    "deactivate SATA port %d:%d",
15230 				    cport, npmport);
15231 
15232 				mutex_exit(&cportinfo->cport_mutex);
15233 				if (sata_ioctl_deactivate(sata_hba_inst,
15234 				    &subsdevice) == SATA_SUCCESS) {
15235 					SATADBG2(SATA_DBG_PMULT, sata_hba_inst,
15236 					    "[Deactivate] device at port %d:%d "
15237 					    "successfully.", cport, npmport);
15238 				}
15239 				mutex_enter(&cportinfo->cport_mutex);
15240 			}
15241 		}
15242 
15243 		/* Deactivate the port multiplier now. */
15244 		cportinfo->cport_state &= ~SATA_STATE_READY;
15245 		mutex_exit(&cportinfo->cport_mutex);
15246 
15247 		sata_device->satadev_addr.qual = qual;
15248 		rval = (*SATA_PORT_DEACTIVATE_FUNC(sata_hba_inst))
15249 		    (SATA_DIP(sata_hba_inst), sata_device);
15250 
15251 		sata_gen_sysevent(sata_hba_inst, &sata_device->satadev_addr,
15252 		    SE_NO_HINT);
15253 
15254 		mutex_enter(&cportinfo->cport_mutex);
15255 		sata_update_port_info(sata_hba_inst, sata_device);
15256 		if (rval != SATA_SUCCESS) {
15257 			if (sata_device->satadev_state & SATA_PSTATE_FAILED) {
15258 				cportinfo->cport_state = SATA_PSTATE_FAILED;
15259 			}
15260 			rv = EIO;
15261 		} else {
15262 			cportinfo->cport_state |= SATA_PSTATE_SHUTDOWN;
15263 		}
15264 		mutex_exit(&cportinfo->cport_mutex);
15265 
15266 		return (rv);
15267 	}
15268 
15269 	/*
15270 	 * Process non-port-multiplier device - it could be a drive connected
15271 	 * to a port multiplier port or a controller port.
15272 	 */
15273 	mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex);
15274 	if (qual == SATA_ADDR_CPORT) {
15275 		sata_device->satadev_addr.qual = SATA_ADDR_DCPORT;
15276 		if (cportinfo->cport_dev_type != SATA_DTYPE_NONE) {
15277 			/* deal only with valid devices */
15278 			if ((cportinfo->cport_dev_type &
15279 			    SATA_VALID_DEV_TYPE) != 0)
15280 				sdinfo = SATA_CPORTINFO_DRV_INFO(cportinfo);
15281 		}
15282 		cportinfo->cport_state &= ~SATA_STATE_READY;
15283 	} else {
15284 		/* Port multiplier device port */
15285 		mutex_enter(&pmportinfo->pmport_mutex);
15286 		sata_device->satadev_addr.qual = SATA_ADDR_DPMPORT;
15287 		if (pmportinfo->pmport_dev_type != SATA_DTYPE_NONE &&
15288 		    (pmportinfo->pmport_dev_type & SATA_VALID_DEV_TYPE) != 0)
15289 			sdinfo = SATA_PMPORTINFO_DRV_INFO(pmportinfo);
15290 		pmportinfo->pmport_state &= ~SATA_STATE_READY;
15291 		mutex_exit(&pmportinfo->pmport_mutex);
15292 	}
15293 
15294 	if (sdinfo != NULL) {
15295 		/*
15296 		 * If a target node exists, try to offline a device and
15297 		 * to remove a target node.
15298 		 */
15299 		mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)->
15300 		    cport_mutex);
15301 		tdip = sata_get_scsi_target_dip(SATA_DIP(sata_hba_inst),
15302 		    &sata_device->satadev_addr);
15303 		if (tdip != NULL) {
15304 			/* target node exist */
15305 			SATADBG1(SATA_DBG_IOCTL_IF, sata_hba_inst,
15306 			    "sata_hba_ioctl: port deactivate: "
15307 			    "target node exists.", NULL);
15308 
15309 			if (ndi_devi_offline(tdip, NDI_DEVI_REMOVE) !=
15310 			    NDI_SUCCESS) {
15311 				SATA_LOG_D((sata_hba_inst, CE_WARN,
15312 				    "sata_hba_ioctl: port deactivate: "
15313 				    "failed to unconfigure device at port "
15314 				    "%d:%d before deactivating the port",
15315 				    cport, pmport));
15316 				/*
15317 				 * Set DEVICE REMOVED state in the target
15318 				 * node. It will prevent an access to
15319 				 * the device even when a new device is
15320 				 * attached, until the old target node is
15321 				 * released, removed and recreated for a new
15322 				 * device.
15323 				 */
15324 				sata_set_device_removed(tdip);
15325 
15326 				/*
15327 				 * Instruct the event daemon to try the
15328 				 * target node cleanup later.
15329 				 */
15330 				sata_set_target_node_cleanup(sata_hba_inst,
15331 				    &sata_device->satadev_addr);
15332 			}
15333 		}
15334 		mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, cport)->
15335 		    cport_mutex);
15336 		/*
15337 		 * In any case, remove and release sata_drive_info
15338 		 * structure.
15339 		 */
15340 		if (qual == SATA_ADDR_CPORT) {
15341 			SATA_CPORTINFO_DRV_INFO(cportinfo) = NULL;
15342 			cportinfo->cport_dev_type = SATA_DTYPE_NONE;
15343 		} else { /* port multiplier device port */
15344 			mutex_enter(&pmportinfo->pmport_mutex);
15345 			SATA_PMPORTINFO_DRV_INFO(pmportinfo) = NULL;
15346 			pmportinfo->pmport_dev_type = SATA_DTYPE_NONE;
15347 			mutex_exit(&pmportinfo->pmport_mutex);
15348 		}
15349 		(void) kmem_free((void *)sdinfo, sizeof (sata_drive_info_t));
15350 	}
15351 
15352 	if (qual == SATA_ADDR_CPORT) {
15353 		cportinfo->cport_state &= ~(SATA_STATE_PROBED |
15354 		    SATA_STATE_PROBING);
15355 	} else if (qual == SATA_ADDR_PMPORT) {
15356 		mutex_enter(&pmportinfo->pmport_mutex);
15357 		pmportinfo->pmport_state &= ~(SATA_STATE_PROBED |
15358 		    SATA_STATE_PROBING);
15359 		mutex_exit(&pmportinfo->pmport_mutex);
15360 	}
15361 	mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex);
15362 
15363 	/* Just let HBA driver to deactivate port */
15364 	sata_device->satadev_addr.qual = qual;
15365 	rval = (*SATA_PORT_DEACTIVATE_FUNC(sata_hba_inst))
15366 	    (SATA_DIP(sata_hba_inst), sata_device);
15367 
15368 	/*
15369 	 * Generate sysevent - EC_DR / ESC_DR_AP_STATE_CHANGE
15370 	 * without the hint
15371 	 */
15372 	sata_gen_sysevent(sata_hba_inst, &sata_device->satadev_addr,
15373 	    SE_NO_HINT);
15374 
15375 	mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex);
15376 	sata_update_port_info(sata_hba_inst, sata_device);
15377 	if (qual == SATA_ADDR_CPORT) {
15378 		if (rval != SATA_SUCCESS) {
15379 			/*
15380 			 * Port deactivation failure - do not change port state
15381 			 * unless the state returned by HBA indicates a port
15382 			 * failure.
15383 			 */
15384 			if (sata_device->satadev_state & SATA_PSTATE_FAILED) {
15385 				SATA_CPORT_STATE(sata_hba_inst, cport) =
15386 				    SATA_PSTATE_FAILED;
15387 			}
15388 			SATA_LOG_D((sata_hba_inst, CE_WARN,
15389 			    "sata_hba_ioctl: port deactivate: "
15390 			    "cannot deactivate SATA port %d", cport));
15391 			rv = EIO;
15392 		} else {
15393 			cportinfo->cport_state |= SATA_PSTATE_SHUTDOWN;
15394 		}
15395 	} else {
15396 		mutex_enter(&pmportinfo->pmport_mutex);
15397 		if (rval != SATA_SUCCESS) {
15398 			if (sata_device->satadev_state & SATA_PSTATE_FAILED) {
15399 				SATA_PMPORT_STATE(sata_hba_inst, cport,
15400 				    pmport) = SATA_PSTATE_FAILED;
15401 			}
15402 			SATA_LOG_D((sata_hba_inst, CE_WARN,
15403 			    "sata_hba_ioctl: port deactivate: "
15404 			    "cannot deactivate SATA port %d:%d",
15405 			    cport, pmport));
15406 			rv = EIO;
15407 		} else {
15408 			pmportinfo->pmport_state |= SATA_PSTATE_SHUTDOWN;
15409 		}
15410 		mutex_exit(&pmportinfo->pmport_mutex);
15411 	}
15412 
15413 	mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex);
15414 
15415 	return (rv);
15416 }
15417 
15418 /*
15419  * Process ioctl port activate request.
15420  *
15421  * NOTE: Port multiplier is supported now.
15422  */
15423 static int
15424 sata_ioctl_activate(sata_hba_inst_t *sata_hba_inst,
15425     sata_device_t *sata_device)
15426 {
15427 	int cport, pmport, qual;
15428 	sata_cport_info_t *cportinfo;
15429 	sata_pmport_info_t *pmportinfo = NULL;
15430 	boolean_t dev_existed = B_TRUE;
15431 
15432 	/* Sanity check */
15433 	if (SATA_PORT_ACTIVATE_FUNC(sata_hba_inst) == NULL)
15434 		return (ENOTSUP);
15435 
15436 	cport = sata_device->satadev_addr.cport;
15437 	pmport = sata_device->satadev_addr.pmport;
15438 	qual = sata_device->satadev_addr.qual;
15439 
15440 	cportinfo = SATA_CPORT_INFO(sata_hba_inst, cport);
15441 
15442 	/*
15443 	 * The qual translate from ap_id (by SCSI_TO_SATA_ADDR_QUAL())
15444 	 * is a device. But what we are dealing with is port/pmport.
15445 	 */
15446 	ASSERT(qual == SATA_ADDR_DCPORT || qual == SATA_ADDR_DPMPORT);
15447 	if (qual == SATA_ADDR_DCPORT)
15448 		sata_device->satadev_addr.qual = qual = SATA_ADDR_CPORT;
15449 	else
15450 		sata_device->satadev_addr.qual = qual = SATA_ADDR_PMPORT;
15451 
15452 	mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex);
15453 	if (qual == SATA_ADDR_PMPORT) {
15454 		pmportinfo = SATA_PMPORT_INFO(sata_hba_inst, cport, pmport);
15455 		if (pmportinfo->pmport_state & SATA_PSTATE_SHUTDOWN ||
15456 		    pmportinfo->pmport_dev_type == SATA_DTYPE_NONE)
15457 			dev_existed = B_FALSE;
15458 	} else { /* cport */
15459 		if (cportinfo->cport_state & SATA_PSTATE_SHUTDOWN ||
15460 		    cportinfo->cport_dev_type == SATA_DTYPE_NONE)
15461 			dev_existed = B_FALSE;
15462 	}
15463 	mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex);
15464 
15465 	/* Just let HBA driver to activate port, if necessary */
15466 	if ((*SATA_PORT_ACTIVATE_FUNC(sata_hba_inst))
15467 	    (SATA_DIP(sata_hba_inst), sata_device) != SATA_SUCCESS) {
15468 		/*
15469 		 * Port activation failure - do not change port state unless
15470 		 * the state returned by HBA indicates a port failure.
15471 		 */
15472 		mutex_enter(&SATA_CPORT_INFO(sata_hba_inst,
15473 		    cport)->cport_mutex);
15474 		sata_update_port_info(sata_hba_inst, sata_device);
15475 		if (sata_device->satadev_state & SATA_PSTATE_FAILED) {
15476 			if (qual == SATA_ADDR_PMPORT) {
15477 				mutex_enter(&pmportinfo->pmport_mutex);
15478 				pmportinfo->pmport_state = SATA_PSTATE_FAILED;
15479 				mutex_exit(&pmportinfo->pmport_mutex);
15480 			} else
15481 				cportinfo->cport_state = SATA_PSTATE_FAILED;
15482 
15483 			mutex_exit(&SATA_CPORT_INFO(sata_hba_inst,
15484 			    cport)->cport_mutex);
15485 			SATA_LOG_D((sata_hba_inst, CE_WARN,
15486 			    "sata_hba_ioctl: port activate: cannot activate "
15487 			    "SATA port %d:%d", cport, pmport));
15488 			return (EIO);
15489 		}
15490 		mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex);
15491 	}
15492 	mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex);
15493 	if (qual == SATA_ADDR_PMPORT) {
15494 		mutex_enter(&pmportinfo->pmport_mutex);
15495 		pmportinfo->pmport_state &= ~SATA_PSTATE_SHUTDOWN;
15496 		mutex_exit(&pmportinfo->pmport_mutex);
15497 	} else
15498 		cportinfo->cport_state &= ~SATA_PSTATE_SHUTDOWN;
15499 	mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex);
15500 
15501 	/*
15502 	 * Re-probe port to find its current state and possibly attached device.
15503 	 * Port re-probing may change the cportinfo device type if device is
15504 	 * found attached.
15505 	 * If port probing failed, the device type would be set to
15506 	 * SATA_DTYPE_NONE.
15507 	 */
15508 	(void) sata_reprobe_port(sata_hba_inst, sata_device,
15509 	    SATA_DEV_IDENTIFY_RETRY);
15510 
15511 	/*
15512 	 * Generate sysevent - EC_DR / ESC_DR_AP_STATE_CHANGE
15513 	 * without the hint.
15514 	 */
15515 	sata_gen_sysevent(sata_hba_inst, &sata_device->satadev_addr,
15516 	    SE_NO_HINT);
15517 
15518 	if (dev_existed == B_FALSE) {
15519 		if (qual == SATA_ADDR_PMPORT &&
15520 		    pmportinfo->pmport_dev_type != SATA_DTYPE_NONE) {
15521 			/*
15522 			 * That's the transition from the "inactive" port state
15523 			 * or the active port without a device attached to the
15524 			 * active port state with a device attached.
15525 			 */
15526 			sata_log(sata_hba_inst, CE_WARN,
15527 			    "SATA device detected at port %d:%d",
15528 			    cport, pmport);
15529 		} else if (qual == SATA_ADDR_CPORT &&
15530 		    cportinfo->cport_dev_type != SATA_DTYPE_NONE) {
15531 			/*
15532 			 * That's the transition from the "inactive" port state
15533 			 * or the active port without a device attached to the
15534 			 * active port state with a device attached.
15535 			 */
15536 			if (cportinfo->cport_dev_type != SATA_DTYPE_PMULT) {
15537 				sata_log(sata_hba_inst, CE_WARN,
15538 				    "SATA device detected at port %d", cport);
15539 			} else {
15540 				sata_log(sata_hba_inst, CE_WARN,
15541 				    "SATA port multiplier detected at port %d",
15542 				    cport);
15543 			}
15544 		}
15545 	}
15546 	return (0);
15547 }
15548 
15549 
15550 
15551 /*
15552  * Process ioctl reset port request.
15553  *
15554  * NOTE: Port-Multiplier is supported.
15555  */
15556 static int
15557 sata_ioctl_reset_port(sata_hba_inst_t *sata_hba_inst,
15558     sata_device_t *sata_device)
15559 {
15560 	int cport, pmport, qual;
15561 	int rv = 0;
15562 
15563 	cport = sata_device->satadev_addr.cport;
15564 	pmport = sata_device->satadev_addr.pmport;
15565 	qual = sata_device->satadev_addr.qual;
15566 
15567 	/*
15568 	 * The qual translate from ap_id (by SCSI_TO_SATA_ADDR_QUAL())
15569 	 * is a device. But what we are dealing with is port/pmport.
15570 	 */
15571 	if (qual == SATA_ADDR_DCPORT)
15572 		sata_device->satadev_addr.qual = qual = SATA_ADDR_CPORT;
15573 	else
15574 		sata_device->satadev_addr.qual = qual = SATA_ADDR_PMPORT;
15575 	ASSERT(qual == SATA_ADDR_CPORT || qual == SATA_ADDR_PMPORT);
15576 
15577 	/* Sanity check */
15578 	if (SATA_RESET_DPORT_FUNC(sata_hba_inst) == NULL) {
15579 		SATA_LOG_D((sata_hba_inst, CE_WARN,
15580 		    "sata_hba_ioctl: sata_hba_tran missing required "
15581 		    "function sata_tran_reset_dport"));
15582 		return (ENOTSUP);
15583 	}
15584 
15585 	/* Ask HBA to reset port */
15586 	if ((*SATA_RESET_DPORT_FUNC(sata_hba_inst))(SATA_DIP(sata_hba_inst),
15587 	    sata_device) != SATA_SUCCESS) {
15588 		SATA_LOG_D((sata_hba_inst, CE_WARN,
15589 		    "sata_hba_ioctl: reset port: failed %d:%d",
15590 		    cport, pmport));
15591 		mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, cport)->
15592 		    cport_mutex);
15593 		sata_update_port_info(sata_hba_inst, sata_device);
15594 		if (qual == SATA_ADDR_CPORT)
15595 			SATA_CPORT_STATE(sata_hba_inst, cport) =
15596 			    SATA_PSTATE_FAILED;
15597 		else {
15598 			mutex_enter(&SATA_PMPORT_MUTEX(sata_hba_inst, cport,
15599 			    pmport));
15600 			SATA_PMPORT_STATE(sata_hba_inst, cport, pmport) =
15601 			    SATA_PSTATE_FAILED;
15602 			mutex_exit(&SATA_PMPORT_MUTEX(sata_hba_inst, cport,
15603 			    pmport));
15604 		}
15605 		mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)->
15606 		    cport_mutex);
15607 		rv = EIO;
15608 	}
15609 
15610 	return (rv);
15611 }
15612 
15613 /*
15614  * Process ioctl reset device request.
15615  *
15616  * NOTE: Port multiplier is supported.
15617  */
15618 static int
15619 sata_ioctl_reset_device(sata_hba_inst_t *sata_hba_inst,
15620     sata_device_t *sata_device)
15621 {
15622 	sata_drive_info_t *sdinfo = NULL;
15623 	sata_pmult_info_t *pmultinfo = NULL;
15624 	int cport, pmport;
15625 	int rv = 0;
15626 
15627 	/* Sanity check */
15628 	if (SATA_RESET_DPORT_FUNC(sata_hba_inst) == NULL) {
15629 		SATA_LOG_D((sata_hba_inst, CE_WARN,
15630 		    "sata_hba_ioctl: sata_hba_tran missing required "
15631 		    "function sata_tran_reset_dport"));
15632 		return (ENOTSUP);
15633 	}
15634 
15635 	cport = sata_device->satadev_addr.cport;
15636 	pmport = sata_device->satadev_addr.pmport;
15637 
15638 	mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex);
15639 	if (sata_device->satadev_addr.qual == SATA_ADDR_DCPORT) {
15640 		if (SATA_CPORT_DEV_TYPE(sata_hba_inst, cport) ==
15641 		    SATA_DTYPE_PMULT)
15642 			pmultinfo = SATA_CPORT_INFO(sata_hba_inst, cport)->
15643 			    cport_devp.cport_sata_pmult;
15644 		else
15645 			sdinfo = SATA_CPORT_DRV_INFO(sata_hba_inst,
15646 			    sata_device->satadev_addr.cport);
15647 	} else { /* port multiplier */
15648 		sata_device->satadev_addr.qual = SATA_ADDR_DPMPORT;
15649 		sdinfo = SATA_PMPORT_DRV_INFO(sata_hba_inst,
15650 		    sata_device->satadev_addr.cport,
15651 		    sata_device->satadev_addr.pmport);
15652 	}
15653 	if (sdinfo == NULL && pmultinfo == NULL) {
15654 		mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex);
15655 		return (EINVAL);
15656 	}
15657 	mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex);
15658 
15659 	/* Ask HBA to reset device */
15660 	if ((*SATA_RESET_DPORT_FUNC(sata_hba_inst))
15661 	    (SATA_DIP(sata_hba_inst), sata_device) != SATA_SUCCESS) {
15662 		SATA_LOG_D((sata_hba_inst, CE_WARN,
15663 		    "sata_hba_ioctl: reset device: failed at port %d:%d",
15664 		    cport, pmport));
15665 		mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, cport)->
15666 		    cport_mutex);
15667 		sata_update_port_info(sata_hba_inst, sata_device);
15668 		/*
15669 		 * Device info structure remains attached. Another device reset
15670 		 * or port disconnect/connect and re-probing is
15671 		 * needed to change it's state
15672 		 */
15673 		if (sdinfo != NULL) {
15674 			sdinfo->satadrv_state &= ~SATA_STATE_READY;
15675 			sdinfo->satadrv_state |= SATA_DSTATE_FAILED;
15676 		} else if (pmultinfo != NULL) {
15677 			pmultinfo->pmult_state &= ~SATA_STATE_READY;
15678 			pmultinfo->pmult_state |= SATA_DSTATE_FAILED;
15679 		}
15680 
15681 		mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex);
15682 		rv = EIO;
15683 	}
15684 	/*
15685 	 * If attached device was a port multiplier, some extra processing
15686 	 * may be needed to bring it back. SATA specification requies a
15687 	 * mandatory software reset on host port to reliably enumerate a port
15688 	 * multiplier, the HBA driver should handle that after reset
15689 	 * operation.
15690 	 */
15691 	return (rv);
15692 }
15693 
15694 
15695 /*
15696  * Process ioctl reset all request.
15697  */
15698 static int
15699 sata_ioctl_reset_all(sata_hba_inst_t *sata_hba_inst)
15700 {
15701 	sata_device_t sata_device;
15702 	int rv = 0;
15703 	int tcport;
15704 
15705 	sata_device.satadev_rev = SATA_DEVICE_REV;
15706 
15707 	/*
15708 	 * There is no protection here for configured devices.
15709 	 */
15710 	/* Sanity check */
15711 	if (SATA_RESET_DPORT_FUNC(sata_hba_inst) == NULL) {
15712 		SATA_LOG_D((sata_hba_inst, CE_WARN,
15713 		    "sata_hba_ioctl: sata_hba_tran missing required "
15714 		    "function sata_tran_reset_dport"));
15715 		return (ENOTSUP);
15716 	}
15717 
15718 	/*
15719 	 * Need to lock all ports, not just one.
15720 	 * If any port is locked by event processing, fail the whole operation.
15721 	 * One port is already locked, but for simplicity lock it again.
15722 	 */
15723 	for (tcport = 0; tcport < SATA_NUM_CPORTS(sata_hba_inst); tcport++) {
15724 		mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, tcport)->
15725 		    cport_mutex);
15726 		if (((SATA_CPORT_INFO(sata_hba_inst, tcport)->
15727 		    cport_event_flags) & SATA_EVNT_LOCK_PORT_BUSY) != 0) {
15728 			mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, tcport)->
15729 			    cport_mutex);
15730 			rv = EBUSY;
15731 			break;
15732 		} else {
15733 			/*
15734 			 * It is enough to lock cport in command-based
15735 			 * switching mode.
15736 			 */
15737 			SATA_CPORT_INFO(sata_hba_inst, tcport)->
15738 			    cport_event_flags |= SATA_APCTL_LOCK_PORT_BUSY;
15739 		}
15740 		mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, tcport)->
15741 		    cport_mutex);
15742 	}
15743 
15744 	if (rv == 0) {
15745 		/*
15746 		 * All cports were successfully locked.
15747 		 * Reset main SATA controller.
15748 		 * Set the device address to port 0, to have a valid device
15749 		 * address.
15750 		 */
15751 		sata_device.satadev_addr.qual = SATA_ADDR_CNTRL;
15752 		sata_device.satadev_addr.cport = 0;
15753 		sata_device.satadev_addr.pmport = 0;
15754 
15755 		if ((*SATA_RESET_DPORT_FUNC(sata_hba_inst))
15756 		    (SATA_DIP(sata_hba_inst), &sata_device) != SATA_SUCCESS) {
15757 			SATA_LOG_D((sata_hba_inst, CE_WARN,
15758 			    "sata_hba_ioctl: reset controller failed"));
15759 			return (EIO);
15760 		}
15761 	}
15762 	/*
15763 	 * Unlock all ports
15764 	 */
15765 	for (tcport = 0; tcport < SATA_NUM_CPORTS(sata_hba_inst); tcport++) {
15766 		mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, tcport)->
15767 		    cport_mutex);
15768 		SATA_CPORT_INFO(sata_hba_inst, tcport)->
15769 		    cport_event_flags &= ~SATA_APCTL_LOCK_PORT_BUSY;
15770 		mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, tcport)->
15771 		    cport_mutex);
15772 	}
15773 
15774 	/*
15775 	 * This operation returns EFAULT if either reset
15776 	 * controller failed or a re-probing of any port failed.
15777 	 */
15778 	return (rv);
15779 }
15780 
15781 
15782 /*
15783  * Process ioctl port self test request.
15784  *
15785  * NOTE: Port multiplier code is not completed nor tested.
15786  */
15787 static int
15788 sata_ioctl_port_self_test(sata_hba_inst_t *sata_hba_inst,
15789     sata_device_t *sata_device)
15790 {
15791 	int cport, pmport, qual;
15792 	int rv = 0;
15793 
15794 	/* Sanity check */
15795 	if (SATA_SELFTEST_FUNC(sata_hba_inst) == NULL)
15796 		return (ENOTSUP);
15797 
15798 	cport = sata_device->satadev_addr.cport;
15799 	pmport = sata_device->satadev_addr.pmport;
15800 	qual = sata_device->satadev_addr.qual;
15801 
15802 	/*
15803 	 * There is no protection here for a configured
15804 	 * device attached to this port.
15805 	 */
15806 
15807 	if ((*SATA_SELFTEST_FUNC(sata_hba_inst))
15808 	    (SATA_DIP(sata_hba_inst), sata_device) != SATA_SUCCESS) {
15809 		SATA_LOG_D((sata_hba_inst, CE_WARN,
15810 		    "sata_hba_ioctl: port selftest: "
15811 		    "failed port %d:%d", cport, pmport));
15812 		mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, cport)->
15813 		    cport_mutex);
15814 		sata_update_port_info(sata_hba_inst, sata_device);
15815 		if (qual == SATA_ADDR_CPORT)
15816 			SATA_CPORT_STATE(sata_hba_inst, cport) =
15817 			    SATA_PSTATE_FAILED;
15818 		else { /* port multiplier device port */
15819 			mutex_enter(&SATA_PMPORT_MUTEX(sata_hba_inst,
15820 			    cport, pmport));
15821 			SATA_PMPORT_STATE(sata_hba_inst, cport, pmport) =
15822 			    SATA_PSTATE_FAILED;
15823 			mutex_exit(&SATA_PMPORT_MUTEX(sata_hba_inst,
15824 			    cport, pmport));
15825 		}
15826 
15827 		mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)->
15828 		    cport_mutex);
15829 		return (EIO);
15830 	}
15831 	/*
15832 	 * Beacuse the port was reset in the course of testing, it should be
15833 	 * re-probed and attached device state should be restored. At this
15834 	 * point the port state is unknown - it's state is HBA-specific.
15835 	 * Force port re-probing to get it into a known state.
15836 	 */
15837 	if (sata_reprobe_port(sata_hba_inst, sata_device,
15838 	    SATA_DEV_IDENTIFY_RETRY) != SATA_SUCCESS)
15839 		rv = EIO;
15840 	return (rv);
15841 }
15842 
15843 
15844 /*
15845  * sata_cfgadm_state:
15846  * Use the sata port state and state of the target node to figure out
15847  * the cfgadm_state.
15848  *
15849  * The port argument is a value with encoded cport,
15850  * pmport and address qualifier, in the same manner as a scsi target number.
15851  * SCSI_TO_SATA_CPORT macro extracts cport number,
15852  * SCSI_TO_SATA_PMPORT extracts pmport number and
15853  * SCSI_TO_SATA_ADDR_QUAL extracts port mulitplier qualifier flag.
15854  *
15855  * Port multiplier is supported.
15856  */
15857 
15858 static void
15859 sata_cfgadm_state(sata_hba_inst_t *sata_hba_inst, int32_t port,
15860     devctl_ap_state_t *ap_state)
15861 {
15862 	uint8_t		cport, pmport, qual;
15863 	uint32_t	port_state, pmult_state;
15864 	uint32_t	dev_type;
15865 	sata_drive_info_t *sdinfo;
15866 
15867 	cport = SCSI_TO_SATA_CPORT(port);
15868 	pmport = SCSI_TO_SATA_PMPORT(port);
15869 	qual = SCSI_TO_SATA_ADDR_QUAL(port);
15870 
15871 	/* Check cport state */
15872 	port_state = SATA_CPORT_STATE(sata_hba_inst, cport);
15873 	if (port_state & SATA_PSTATE_SHUTDOWN ||
15874 	    port_state & SATA_PSTATE_FAILED) {
15875 		ap_state->ap_rstate = AP_RSTATE_DISCONNECTED;
15876 		ap_state->ap_ostate = AP_OSTATE_UNCONFIGURED;
15877 		if (port_state & SATA_PSTATE_FAILED)
15878 			ap_state->ap_condition = AP_COND_FAILED;
15879 		else
15880 			ap_state->ap_condition = AP_COND_UNKNOWN;
15881 
15882 		return;
15883 	}
15884 
15885 	/* cport state is okay. Now check pmport state */
15886 	if (qual == SATA_ADDR_DPMPORT || qual == SATA_ADDR_PMPORT) {
15887 		/* Sanity check */
15888 		if (SATA_CPORT_DEV_TYPE(sata_hba_inst, cport) !=
15889 		    SATA_DTYPE_PMULT || SATA_PMPORT_INFO(sata_hba_inst,
15890 		    cport, pmport) == NULL)
15891 			return;
15892 		port_state = SATA_PMPORT_STATE(sata_hba_inst, cport, pmport);
15893 		if (port_state & SATA_PSTATE_SHUTDOWN ||
15894 		    port_state & SATA_PSTATE_FAILED) {
15895 			ap_state->ap_rstate = AP_RSTATE_DISCONNECTED;
15896 			ap_state->ap_ostate = AP_OSTATE_UNCONFIGURED;
15897 			if (port_state & SATA_PSTATE_FAILED)
15898 				ap_state->ap_condition = AP_COND_FAILED;
15899 			else
15900 				ap_state->ap_condition = AP_COND_UNKNOWN;
15901 
15902 			return;
15903 		}
15904 	}
15905 
15906 	/* Port is enabled and ready */
15907 	if (qual == SATA_ADDR_DCPORT || qual == SATA_ADDR_CPORT)
15908 		dev_type = SATA_CPORT_DEV_TYPE(sata_hba_inst, cport);
15909 	else
15910 		dev_type = SATA_PMPORT_DEV_TYPE(sata_hba_inst, cport, pmport);
15911 
15912 	switch (dev_type) {
15913 	case SATA_DTYPE_NONE:
15914 	{
15915 		ap_state->ap_ostate = AP_OSTATE_UNCONFIGURED;
15916 		ap_state->ap_condition = AP_COND_OK;
15917 		/* No device attached */
15918 		ap_state->ap_rstate = AP_RSTATE_EMPTY;
15919 		break;
15920 	}
15921 	case SATA_DTYPE_PMULT:
15922 	{
15923 		/* Need to check port multiplier state */
15924 		ASSERT(qual == SATA_ADDR_DCPORT);
15925 		pmult_state = SATA_PMULT_INFO(sata_hba_inst, cport)->
15926 		    pmult_state;
15927 		if (pmult_state & (SATA_PSTATE_SHUTDOWN|SATA_PSTATE_FAILED)) {
15928 			ap_state->ap_rstate = AP_RSTATE_DISCONNECTED;
15929 			ap_state->ap_ostate = AP_OSTATE_UNCONFIGURED;
15930 			if (pmult_state & SATA_PSTATE_FAILED)
15931 				ap_state->ap_condition = AP_COND_FAILED;
15932 			else
15933 				ap_state->ap_condition = AP_COND_UNKNOWN;
15934 
15935 			return;
15936 		}
15937 
15938 		/* Port multiplier is not configurable */
15939 		ap_state->ap_ostate = AP_OSTATE_CONFIGURED;
15940 		ap_state->ap_rstate = AP_RSTATE_CONNECTED;
15941 		ap_state->ap_condition = AP_COND_OK;
15942 		break;
15943 	}
15944 
15945 	case SATA_DTYPE_ATADISK:
15946 	case SATA_DTYPE_ATAPICD:
15947 	case SATA_DTYPE_ATAPITAPE:
15948 	case SATA_DTYPE_ATAPIDISK:
15949 	{
15950 		dev_info_t *tdip = NULL;
15951 		dev_info_t *dip = NULL;
15952 		int circ;
15953 
15954 		dip = SATA_DIP(sata_hba_inst);
15955 		tdip = sata_get_target_dip(dip, cport, pmport);
15956 		ap_state->ap_rstate = AP_RSTATE_CONNECTED;
15957 		if (tdip != NULL) {
15958 			ndi_devi_enter(dip, &circ);
15959 			mutex_enter(&(DEVI(tdip)->devi_lock));
15960 			if (DEVI_IS_DEVICE_REMOVED(tdip)) {
15961 				/*
15962 				 * There could be the case where previously
15963 				 * configured and opened device was removed
15964 				 * and unknown device was plugged.
15965 				 * In such case we want to show a device, and
15966 				 * its configured or unconfigured state but
15967 				 * indicate unusable condition untill the
15968 				 * old target node is released and removed.
15969 				 */
15970 				ap_state->ap_condition = AP_COND_UNUSABLE;
15971 			} else {
15972 				mutex_enter(&SATA_CPORT_MUTEX(sata_hba_inst,
15973 				    cport));
15974 				sdinfo = SATA_CPORT_DRV_INFO(sata_hba_inst,
15975 				    cport);
15976 				if (sdinfo != NULL) {
15977 					if ((sdinfo->satadrv_state &
15978 					    SATA_DSTATE_FAILED) != 0)
15979 						ap_state->ap_condition =
15980 						    AP_COND_FAILED;
15981 					else
15982 						ap_state->ap_condition =
15983 						    AP_COND_OK;
15984 				} else {
15985 					ap_state->ap_condition =
15986 					    AP_COND_UNKNOWN;
15987 				}
15988 				mutex_exit(&SATA_CPORT_MUTEX(sata_hba_inst,
15989 				    cport));
15990 			}
15991 			if ((DEVI_IS_DEVICE_OFFLINE(tdip)) ||
15992 			    (DEVI_IS_DEVICE_DOWN(tdip))) {
15993 				ap_state->ap_ostate =
15994 				    AP_OSTATE_UNCONFIGURED;
15995 			} else {
15996 				ap_state->ap_ostate =
15997 				    AP_OSTATE_CONFIGURED;
15998 			}
15999 			mutex_exit(&(DEVI(tdip)->devi_lock));
16000 			ndi_devi_exit(dip, circ);
16001 		} else {
16002 			ap_state->ap_ostate = AP_OSTATE_UNCONFIGURED;
16003 			ap_state->ap_condition = AP_COND_UNKNOWN;
16004 		}
16005 		break;
16006 	}
16007 	case SATA_DTYPE_ATAPIPROC:
16008 		ap_state->ap_rstate = AP_RSTATE_CONNECTED;
16009 		ap_state->ap_ostate = AP_OSTATE_UNCONFIGURED;
16010 		ap_state->ap_condition = AP_COND_OK;
16011 		break;
16012 	default:
16013 		ap_state->ap_rstate = AP_RSTATE_CONNECTED;
16014 		ap_state->ap_ostate = AP_OSTATE_UNCONFIGURED;
16015 		ap_state->ap_condition = AP_COND_UNKNOWN;
16016 		/*
16017 		 * This is actually internal error condition (non fatal),
16018 		 * because we have already checked all defined device types.
16019 		 */
16020 		SATA_LOG_D((sata_hba_inst, CE_WARN,
16021 		    "sata_cfgadm_state: Internal error: "
16022 		    "unknown device type"));
16023 		break;
16024 	}
16025 }
16026 
16027 
16028 /*
16029  * Process ioctl get device path request.
16030  *
16031  * NOTE: Port multiplier has no target dip. Devices connected to port
16032  * multiplier have target node attached to the HBA node. The only difference
16033  * between them and the directly-attached device node is a target address.
16034  */
16035 static int
16036 sata_ioctl_get_device_path(sata_hba_inst_t *sata_hba_inst,
16037     sata_device_t *sata_device, sata_ioctl_data_t *ioc, int mode)
16038 {
16039 	char path[MAXPATHLEN];
16040 	uint32_t size;
16041 	dev_info_t *tdip;
16042 
16043 	(void) strcpy(path, "/devices");
16044 	if ((tdip = sata_get_scsi_target_dip(SATA_DIP(sata_hba_inst),
16045 	    &sata_device->satadev_addr)) == NULL) {
16046 		/*
16047 		 * No such device. If this is a request for a size, do not
16048 		 * return EINVAL for non-existing target, because cfgadm
16049 		 * will then indicate a meaningless ioctl failure.
16050 		 * If this is a request for a path, indicate invalid
16051 		 * argument.
16052 		 */
16053 		if (ioc->get_size == 0)
16054 			return (EINVAL);
16055 	} else {
16056 		(void) ddi_pathname(tdip, path + strlen(path));
16057 	}
16058 	size = strlen(path) + 1;
16059 
16060 	if (ioc->get_size != 0) {
16061 		if (ddi_copyout((void *)&size, ioc->buf, ioc->bufsiz,
16062 		    mode) != 0)
16063 			return (EFAULT);
16064 	} else {
16065 		if (ioc->bufsiz != size)
16066 			return (EINVAL);
16067 
16068 		else if (ddi_copyout((void *)&path, ioc->buf, ioc->bufsiz,
16069 		    mode) != 0)
16070 			return (EFAULT);
16071 	}
16072 	return (0);
16073 }
16074 
16075 /*
16076  * Process ioctl get attachment point type request.
16077  *
16078  * NOTE: Port multiplier is supported.
16079  */
16080 static	int
16081 sata_ioctl_get_ap_type(sata_hba_inst_t *sata_hba_inst,
16082     sata_device_t *sata_device, sata_ioctl_data_t *ioc, int mode)
16083 {
16084 	uint32_t	type_len;
16085 	const char	*ap_type;
16086 	int		dev_type;
16087 
16088 	if (sata_device->satadev_addr.qual == SATA_ADDR_DCPORT)
16089 		dev_type = SATA_CPORT_DEV_TYPE(sata_hba_inst,
16090 		    sata_device->satadev_addr.cport);
16091 	else /* pmport */
16092 		dev_type = SATA_PMPORT_DEV_TYPE(sata_hba_inst,
16093 		    sata_device->satadev_addr.cport,
16094 		    sata_device->satadev_addr.pmport);
16095 
16096 	switch (dev_type) {
16097 	case SATA_DTYPE_NONE:
16098 		ap_type = "port";
16099 		break;
16100 
16101 	case SATA_DTYPE_ATADISK:
16102 	case SATA_DTYPE_ATAPIDISK:
16103 		ap_type = "disk";
16104 		break;
16105 
16106 	case SATA_DTYPE_ATAPICD:
16107 		ap_type = "cd/dvd";
16108 		break;
16109 
16110 	case SATA_DTYPE_ATAPITAPE:
16111 		ap_type = "tape";
16112 		break;
16113 
16114 	case SATA_DTYPE_ATAPIPROC:
16115 		ap_type = "processor";
16116 		break;
16117 
16118 	case SATA_DTYPE_PMULT:
16119 		ap_type = "sata-pmult";
16120 		break;
16121 
16122 	case SATA_DTYPE_UNKNOWN:
16123 		ap_type = "unknown";
16124 		break;
16125 
16126 	default:
16127 		ap_type = "unsupported";
16128 		break;
16129 
16130 	} /* end of dev_type switch */
16131 
16132 	type_len = strlen(ap_type) + 1;
16133 
16134 	if (ioc->get_size) {
16135 		if (ddi_copyout((void *)&type_len, ioc->buf, ioc->bufsiz,
16136 		    mode) != 0)
16137 			return (EFAULT);
16138 	} else {
16139 		if (ioc->bufsiz != type_len)
16140 			return (EINVAL);
16141 
16142 		if (ddi_copyout((void *)ap_type, ioc->buf,
16143 		    ioc->bufsiz, mode) != 0)
16144 			return (EFAULT);
16145 	}
16146 	return (0);
16147 
16148 }
16149 
16150 /*
16151  * Process ioctl get device model info request.
16152  * This operation should return to cfgadm the device model
16153  * information string
16154  *
16155  * NOTE: Port multiplier is supported.
16156  */
16157 static	int
16158 sata_ioctl_get_model_info(sata_hba_inst_t *sata_hba_inst,
16159     sata_device_t *sata_device, sata_ioctl_data_t *ioc, int mode)
16160 {
16161 	sata_drive_info_t *sdinfo;
16162 	uint32_t info_len;
16163 	char ap_info[SATA_ID_MODEL_LEN + 1];
16164 
16165 	mutex_enter(&SATA_CPORT_INFO(sata_hba_inst,
16166 	    sata_device->satadev_addr.cport)->cport_mutex);
16167 	if (sata_device->satadev_addr.qual == SATA_ADDR_DCPORT)
16168 		sdinfo = SATA_CPORT_DRV_INFO(sata_hba_inst,
16169 		    sata_device->satadev_addr.cport);
16170 	else /* port multiplier */
16171 		sdinfo = SATA_PMPORT_DRV_INFO(sata_hba_inst,
16172 		    sata_device->satadev_addr.cport,
16173 		    sata_device->satadev_addr.pmport);
16174 	if (sdinfo == NULL) {
16175 		mutex_exit(&SATA_CPORT_INFO(sata_hba_inst,
16176 		    sata_device->satadev_addr.cport)->cport_mutex);
16177 		return (EINVAL);
16178 	}
16179 
16180 #ifdef	_LITTLE_ENDIAN
16181 	swab(sdinfo->satadrv_id.ai_model, ap_info, SATA_ID_MODEL_LEN);
16182 #else	/* _LITTLE_ENDIAN */
16183 	bcopy(sdinfo->satadrv_id.ai_model, ap_info, SATA_ID_MODEL_LEN);
16184 #endif	/* _LITTLE_ENDIAN */
16185 
16186 	mutex_exit(&SATA_CPORT_INFO(sata_hba_inst,
16187 	    sata_device->satadev_addr.cport)->cport_mutex);
16188 
16189 	ap_info[SATA_ID_MODEL_LEN] = '\0';
16190 
16191 	info_len = strlen(ap_info) + 1;
16192 
16193 	if (ioc->get_size) {
16194 		if (ddi_copyout((void *)&info_len, ioc->buf, ioc->bufsiz,
16195 		    mode) != 0)
16196 			return (EFAULT);
16197 	} else {
16198 		if (ioc->bufsiz < info_len)
16199 			return (EINVAL);
16200 		if (ddi_copyout((void *)ap_info, ioc->buf, ioc->bufsiz,
16201 		    mode) != 0)
16202 			return (EFAULT);
16203 	}
16204 	return (0);
16205 }
16206 
16207 
16208 /*
16209  * Process ioctl get device firmware revision info request.
16210  * This operation should return to cfgadm the device firmware revision
16211  * information string
16212  *
16213  * Port multiplier is supported.
16214  */
16215 static	int
16216 sata_ioctl_get_revfirmware_info(sata_hba_inst_t *sata_hba_inst,
16217     sata_device_t *sata_device, sata_ioctl_data_t *ioc, int mode)
16218 {
16219 	sata_drive_info_t *sdinfo;
16220 	uint32_t info_len;
16221 	char ap_info[SATA_ID_FW_LEN + 1];
16222 
16223 	mutex_enter(&SATA_CPORT_INFO(sata_hba_inst,
16224 	    sata_device->satadev_addr.cport)->cport_mutex);
16225 	if (sata_device->satadev_addr.qual == SATA_ADDR_DCPORT)
16226 		sdinfo = SATA_CPORT_DRV_INFO(sata_hba_inst,
16227 		    sata_device->satadev_addr.cport);
16228 	else /* port multiplier */
16229 		sdinfo = SATA_PMPORT_DRV_INFO(sata_hba_inst,
16230 		    sata_device->satadev_addr.cport,
16231 		    sata_device->satadev_addr.pmport);
16232 	if (sdinfo == NULL) {
16233 		mutex_exit(&SATA_CPORT_INFO(sata_hba_inst,
16234 		    sata_device->satadev_addr.cport)->cport_mutex);
16235 		return (EINVAL);
16236 	}
16237 
16238 #ifdef	_LITTLE_ENDIAN
16239 	swab(sdinfo->satadrv_id.ai_fw, ap_info, SATA_ID_FW_LEN);
16240 #else	/* _LITTLE_ENDIAN */
16241 	bcopy(sdinfo->satadrv_id.ai_fw, ap_info, SATA_ID_FW_LEN);
16242 #endif	/* _LITTLE_ENDIAN */
16243 
16244 	mutex_exit(&SATA_CPORT_INFO(sata_hba_inst,
16245 	    sata_device->satadev_addr.cport)->cport_mutex);
16246 
16247 	ap_info[SATA_ID_FW_LEN] = '\0';
16248 
16249 	info_len = strlen(ap_info) + 1;
16250 
16251 	if (ioc->get_size) {
16252 		if (ddi_copyout((void *)&info_len, ioc->buf, ioc->bufsiz,
16253 		    mode) != 0)
16254 			return (EFAULT);
16255 	} else {
16256 		if (ioc->bufsiz < info_len)
16257 			return (EINVAL);
16258 		if (ddi_copyout((void *)ap_info, ioc->buf, ioc->bufsiz,
16259 		    mode) != 0)
16260 			return (EFAULT);
16261 	}
16262 	return (0);
16263 }
16264 
16265 
16266 /*
16267  * Process ioctl get device serial number info request.
16268  * This operation should return to cfgadm the device serial number string.
16269  *
16270  * NOTE: Port multiplier is supported.
16271  */
16272 static	int
16273 sata_ioctl_get_serialnumber_info(sata_hba_inst_t *sata_hba_inst,
16274     sata_device_t *sata_device, sata_ioctl_data_t *ioc, int mode)
16275 {
16276 	sata_drive_info_t *sdinfo;
16277 	uint32_t info_len;
16278 	char ap_info[SATA_ID_SERIAL_LEN + 1];
16279 
16280 	mutex_enter(&SATA_CPORT_INFO(sata_hba_inst,
16281 	    sata_device->satadev_addr.cport)->cport_mutex);
16282 	if (sata_device->satadev_addr.qual == SATA_ADDR_DCPORT)
16283 		sdinfo = SATA_CPORT_DRV_INFO(sata_hba_inst,
16284 		    sata_device->satadev_addr.cport);
16285 	else /* port multiplier */
16286 		sdinfo = SATA_PMPORT_DRV_INFO(sata_hba_inst,
16287 		    sata_device->satadev_addr.cport,
16288 		    sata_device->satadev_addr.pmport);
16289 	if (sdinfo == NULL) {
16290 		mutex_exit(&SATA_CPORT_INFO(sata_hba_inst,
16291 		    sata_device->satadev_addr.cport)->cport_mutex);
16292 		return (EINVAL);
16293 	}
16294 
16295 #ifdef	_LITTLE_ENDIAN
16296 	swab(sdinfo->satadrv_id.ai_drvser, ap_info, SATA_ID_SERIAL_LEN);
16297 #else	/* _LITTLE_ENDIAN */
16298 	bcopy(sdinfo->satadrv_id.ai_drvser, ap_info, SATA_ID_SERIAL_LEN);
16299 #endif	/* _LITTLE_ENDIAN */
16300 
16301 	mutex_exit(&SATA_CPORT_INFO(sata_hba_inst,
16302 	    sata_device->satadev_addr.cport)->cport_mutex);
16303 
16304 	ap_info[SATA_ID_SERIAL_LEN] = '\0';
16305 
16306 	info_len = strlen(ap_info) + 1;
16307 
16308 	if (ioc->get_size) {
16309 		if (ddi_copyout((void *)&info_len, ioc->buf, ioc->bufsiz,
16310 		    mode) != 0)
16311 			return (EFAULT);
16312 	} else {
16313 		if (ioc->bufsiz < info_len)
16314 			return (EINVAL);
16315 		if (ddi_copyout((void *)ap_info, ioc->buf, ioc->bufsiz,
16316 		    mode) != 0)
16317 			return (EFAULT);
16318 	}
16319 	return (0);
16320 }
16321 
16322 
16323 /*
16324  * Preset scsi extended sense data (to NO SENSE)
16325  * First 18 bytes of the sense data are preset to current valid sense
16326  * with a key NO SENSE data.
16327  *
16328  * Returns void
16329  */
16330 static void
16331 sata_fixed_sense_data_preset(struct scsi_extended_sense *sense)
16332 {
16333 	sense->es_valid = 1;		/* Valid sense */
16334 	sense->es_class = CLASS_EXTENDED_SENSE;	/* 0x70 - current err */
16335 	sense->es_key = KEY_NO_SENSE;
16336 	sense->es_info_1 = 0;
16337 	sense->es_info_2 = 0;
16338 	sense->es_info_3 = 0;
16339 	sense->es_info_4 = 0;
16340 	sense->es_add_len = 10;	/* Additional length - replace with a def */
16341 	sense->es_cmd_info[0] = 0;
16342 	sense->es_cmd_info[1] = 0;
16343 	sense->es_cmd_info[2] = 0;
16344 	sense->es_cmd_info[3] = 0;
16345 	sense->es_add_code = 0;
16346 	sense->es_qual_code = 0;
16347 }
16348 
16349 /*
16350  * Register a legacy cmdk-style devid for the target (disk) device.
16351  *
16352  * Note: This function is called only when the HBA devinfo node has the
16353  * property "use-cmdk-devid-format" set. This property indicates that
16354  * devid compatible with old cmdk (target) driver is to be generated
16355  * for any target device attached to this controller. This will take
16356  * precedence over the devid generated by sd (target) driver.
16357  * This function is derived from cmdk_devid_setup() function in cmdk.c.
16358  */
16359 static void
16360 sata_target_devid_register(dev_info_t *dip, sata_drive_info_t *sdinfo)
16361 {
16362 	char	*hwid;
16363 	int	modlen;
16364 	int	serlen;
16365 	int	rval;
16366 	ddi_devid_t	devid;
16367 
16368 	/*
16369 	 * device ID is a concatanation of model number, "=", serial number.
16370 	 */
16371 	hwid = kmem_zalloc(LEGACY_HWID_LEN, KM_SLEEP);
16372 	bcopy(&sdinfo->satadrv_id.ai_model, hwid,
16373 	    sizeof (sdinfo->satadrv_id.ai_model));
16374 	swab(hwid, hwid, sizeof (sdinfo->satadrv_id.ai_model));
16375 	modlen = sata_check_modser(hwid, sizeof (sdinfo->satadrv_id.ai_model));
16376 	if (modlen == 0)
16377 		goto err;
16378 	hwid[modlen++] = '=';
16379 	bcopy(&sdinfo->satadrv_id.ai_drvser, &hwid[modlen],
16380 	    sizeof (sdinfo->satadrv_id.ai_drvser));
16381 	swab(&hwid[modlen], &hwid[modlen],
16382 	    sizeof (sdinfo->satadrv_id.ai_drvser));
16383 	serlen = sata_check_modser(&hwid[modlen],
16384 	    sizeof (sdinfo->satadrv_id.ai_drvser));
16385 	if (serlen == 0)
16386 		goto err;
16387 	hwid[modlen + serlen] = 0; /* terminate the hwid string */
16388 
16389 	/* initialize/register devid */
16390 	if ((rval = ddi_devid_init(dip, DEVID_ATA_SERIAL,
16391 	    (ushort_t)(modlen + serlen), hwid, &devid)) == DDI_SUCCESS) {
16392 		rval = ddi_devid_register(dip, devid);
16393 		/*
16394 		 * Free up the allocated devid buffer.
16395 		 * NOTE: This doesn't mean unregistering devid.
16396 		 */
16397 		ddi_devid_free(devid);
16398 	}
16399 
16400 	if (rval != DDI_SUCCESS)
16401 		cmn_err(CE_WARN, "sata: failed to create devid for the disk"
16402 		    " on port %d", sdinfo->satadrv_addr.cport);
16403 err:
16404 	kmem_free(hwid, LEGACY_HWID_LEN);
16405 }
16406 
16407 /*
16408  * valid model/serial string must contain a non-zero non-space characters.
16409  * trim trailing spaces/NULLs.
16410  */
16411 static int
16412 sata_check_modser(char *buf, int buf_len)
16413 {
16414 	boolean_t ret;
16415 	char *s;
16416 	int i;
16417 	int tb;
16418 	char ch;
16419 
16420 	ret = B_FALSE;
16421 	s = buf;
16422 	for (i = 0; i < buf_len; i++) {
16423 		ch = *s++;
16424 		if (ch != ' ' && ch != '\0')
16425 			tb = i + 1;
16426 		if (ch != ' ' && ch != '\0' && ch != '0')
16427 			ret = B_TRUE;
16428 	}
16429 
16430 	if (ret == B_FALSE)
16431 		return (0); /* invalid string */
16432 
16433 	return (tb); /* return length */
16434 }
16435 
16436 /*
16437  * sata_set_drive_features function compares current device features setting
16438  * with the saved device features settings and, if there is a difference,
16439  * it restores device features setting to the previously saved state.
16440  * It also arbitrarily tries to select the highest supported DMA mode.
16441  * Device Identify or Identify Packet Device data has to be current.
16442  * At the moment read ahead and write cache are considered for all devices.
16443  * For atapi devices, Removable Media Status Notification is set in addition
16444  * to common features.
16445  *
16446  * This function cannot be called in the interrupt context (it may sleep).
16447  *
16448  * The input argument sdinfo should point to the drive info structure
16449  * to be updated after features are set. Note, that only
16450  * device (packet) identify data is updated, not the flags indicating the
16451  * supported features.
16452  *
16453  * Returns SATA_SUCCESS if successful or there was nothing to do.
16454  * Device Identify data in the drive info structure pointed to by the sdinfo
16455  * arguments is updated even when no features were set or changed.
16456  *
16457  * Returns SATA_FAILURE if device features could not be set or DMA mode
16458  * for a disk cannot be set and device identify data cannot be fetched.
16459  *
16460  * Returns SATA_RETRY if device features could not be set (other than disk
16461  * DMA mode) but the device identify data was fetched successfully.
16462  *
16463  * Note: This function may fail the port, making it inaccessible.
16464  * In such case the explicit port disconnect/connect or physical device
16465  * detach/attach is required to re-evaluate port state again.
16466  */
16467 
16468 static int
16469 sata_set_drive_features(sata_hba_inst_t *sata_hba_inst,
16470     sata_drive_info_t *sdinfo, int restore)
16471 {
16472 	int rval = SATA_SUCCESS;
16473 	int rval_set;
16474 	sata_drive_info_t new_sdinfo;
16475 	char *finfo = "sata_set_drive_features: cannot";
16476 	char *finfox;
16477 	int cache_op;
16478 
16479 	bzero(&new_sdinfo, sizeof (sata_drive_info_t));
16480 	new_sdinfo.satadrv_addr = sdinfo->satadrv_addr;
16481 	new_sdinfo.satadrv_type = sdinfo->satadrv_type;
16482 	if (sata_fetch_device_identify_data(sata_hba_inst, &new_sdinfo) != 0) {
16483 		/*
16484 		 * Cannot get device identification - caller may retry later
16485 		 */
16486 		SATADBG1(SATA_DBG_DEV_SETTINGS, sata_hba_inst,
16487 		    "%s fetch device identify data\n", finfo);
16488 		return (SATA_FAILURE);
16489 	}
16490 	finfox = (restore != 0) ? " restore device features" :
16491 	    " initialize device features\n";
16492 
16493 	switch (sdinfo->satadrv_type) {
16494 	case SATA_DTYPE_ATADISK:
16495 		/* Arbitrarily set UDMA mode */
16496 		if (sata_set_dma_mode(sata_hba_inst, &new_sdinfo) !=
16497 		    SATA_SUCCESS) {
16498 			SATA_LOG_D((sata_hba_inst, CE_WARN,
16499 			    "%s set UDMA mode\n", finfo));
16500 			return (SATA_FAILURE);
16501 		}
16502 		break;
16503 	case SATA_DTYPE_ATAPICD:
16504 	case SATA_DTYPE_ATAPITAPE:
16505 	case SATA_DTYPE_ATAPIDISK:
16506 		/*  Set Removable Media Status Notification, if necessary */
16507 		if (SATA_RM_NOTIFIC_SUPPORTED(new_sdinfo.satadrv_id) &&
16508 		    restore != 0) {
16509 			if (((sdinfo->satadrv_settings & SATA_DEV_RMSN) &&
16510 			    (!SATA_RM_NOTIFIC_ENABLED(new_sdinfo.satadrv_id)))||
16511 			    ((!(sdinfo->satadrv_settings & SATA_DEV_RMSN)) &&
16512 			    SATA_RM_NOTIFIC_ENABLED(new_sdinfo.satadrv_id))) {
16513 				/* Current setting does not match saved one */
16514 				if (sata_set_rmsn(sata_hba_inst, sdinfo,
16515 				    sdinfo->satadrv_settings &
16516 				    SATA_DEV_RMSN) != SATA_SUCCESS)
16517 					rval = SATA_FAILURE;
16518 			}
16519 		}
16520 		/*
16521 		 * We have to set Multiword DMA or UDMA, if it is supported, as
16522 		 * we want to use DMA transfer mode whenever possible.
16523 		 * Some devices require explicit setting of the DMA mode.
16524 		 */
16525 		if (new_sdinfo.satadrv_id.ai_cap & SATA_DMA_SUPPORT) {
16526 			/* Set highest supported DMA mode */
16527 			if (sata_set_dma_mode(sata_hba_inst, &new_sdinfo) !=
16528 			    SATA_SUCCESS) {
16529 				SATA_LOG_D((sata_hba_inst, CE_WARN,
16530 				    "%s set UDMA mode\n", finfo));
16531 				rval = SATA_FAILURE;
16532 			}
16533 		}
16534 		break;
16535 	}
16536 
16537 	if (!SATA_READ_AHEAD_SUPPORTED(new_sdinfo.satadrv_id) &&
16538 	    !SATA_WRITE_CACHE_SUPPORTED(new_sdinfo.satadrv_id)) {
16539 		/*
16540 		 * neither READ AHEAD nor WRITE CACHE is supported
16541 		 * - do nothing
16542 		 */
16543 		SATADBG1(SATA_DBG_DEV_SETTINGS, sata_hba_inst,
16544 		    "settable features not supported\n", NULL);
16545 		goto update_sdinfo;
16546 	}
16547 
16548 	if ((SATA_READ_AHEAD_ENABLED(new_sdinfo.satadrv_id) &&
16549 	    (sdinfo->satadrv_settings & SATA_DEV_READ_AHEAD)) &&
16550 	    (SATA_WRITE_CACHE_ENABLED(new_sdinfo.satadrv_id) &&
16551 	    (sdinfo->satadrv_settings & SATA_DEV_WRITE_CACHE))) {
16552 		/*
16553 		 * both READ AHEAD and WRITE CACHE are enabled
16554 		 * - Nothing to do
16555 		 */
16556 		SATADBG1(SATA_DBG_DEV_SETTINGS, sata_hba_inst,
16557 		    "no device features to set\n", NULL);
16558 		goto update_sdinfo;
16559 	}
16560 
16561 	cache_op = 0;
16562 
16563 	if (SATA_READ_AHEAD_SUPPORTED(new_sdinfo.satadrv_id)) {
16564 		if ((sdinfo->satadrv_settings & SATA_DEV_READ_AHEAD) &&
16565 		    !SATA_READ_AHEAD_ENABLED(new_sdinfo.satadrv_id)) {
16566 			/* Enable read ahead / read cache */
16567 			cache_op = SATAC_SF_ENABLE_READ_AHEAD;
16568 			SATADBG1(SATA_DBG_DEV_SETTINGS, sata_hba_inst,
16569 			    "enabling read cache\n", NULL);
16570 		} else if (!(sdinfo->satadrv_settings & SATA_DEV_READ_AHEAD) &&
16571 		    SATA_READ_AHEAD_ENABLED(new_sdinfo.satadrv_id)) {
16572 			/* Disable read ahead  / read cache */
16573 			cache_op = SATAC_SF_DISABLE_READ_AHEAD;
16574 			SATADBG1(SATA_DBG_DEV_SETTINGS, sata_hba_inst,
16575 			    "disabling read cache\n", NULL);
16576 		}
16577 
16578 		if (cache_op != 0) {
16579 			/* Try to set read cache mode */
16580 			rval_set = sata_set_cache_mode(sata_hba_inst,
16581 			    &new_sdinfo, cache_op);
16582 			if (rval != SATA_FAILURE && rval_set != SATA_SUCCESS)
16583 				rval = rval_set;
16584 		}
16585 	}
16586 
16587 	cache_op = 0;
16588 
16589 	if (SATA_WRITE_CACHE_SUPPORTED(new_sdinfo.satadrv_id)) {
16590 		if ((sdinfo->satadrv_settings & SATA_DEV_WRITE_CACHE) &&
16591 		    !SATA_WRITE_CACHE_ENABLED(new_sdinfo.satadrv_id)) {
16592 			/* Enable write cache */
16593 			cache_op = SATAC_SF_ENABLE_WRITE_CACHE;
16594 			SATADBG1(SATA_DBG_DEV_SETTINGS, sata_hba_inst,
16595 			    "enabling write cache\n", NULL);
16596 		} else if (!(sdinfo->satadrv_settings & SATA_DEV_WRITE_CACHE) &&
16597 		    SATA_WRITE_CACHE_ENABLED(new_sdinfo.satadrv_id)) {
16598 			/* Disable write cache */
16599 			cache_op = SATAC_SF_DISABLE_WRITE_CACHE;
16600 			SATADBG1(SATA_DBG_DEV_SETTINGS, sata_hba_inst,
16601 			    "disabling write cache\n", NULL);
16602 		}
16603 
16604 		if (cache_op != 0) {
16605 			/* Try to set write cache mode */
16606 			rval_set = sata_set_cache_mode(sata_hba_inst,
16607 			    &new_sdinfo, cache_op);
16608 			if (rval != SATA_FAILURE && rval_set != SATA_SUCCESS)
16609 				rval = rval_set;
16610 		}
16611 	}
16612 	if (rval != SATA_SUCCESS)
16613 		SATA_LOG_D((sata_hba_inst, CE_WARN,
16614 		    "%s %s", finfo, finfox));
16615 
16616 update_sdinfo:
16617 	/*
16618 	 * We need to fetch Device Identify data again
16619 	 */
16620 	if (sata_fetch_device_identify_data(sata_hba_inst, &new_sdinfo) != 0) {
16621 		/*
16622 		 * Cannot get device identification - retry later
16623 		 */
16624 		SATA_LOG_D((sata_hba_inst, CE_WARN,
16625 		    "%s re-fetch device identify data\n", finfo));
16626 		rval = SATA_FAILURE;
16627 	}
16628 	/* Copy device sata info. */
16629 	sdinfo->satadrv_id = new_sdinfo.satadrv_id;
16630 
16631 	return (rval);
16632 }
16633 
16634 
16635 /*
16636  *
16637  * Returns 1 if threshold exceeded, 0 if threshold not exceeded, -1 if
16638  * unable to determine.
16639  *
16640  * Cannot be called in an interrupt context.
16641  *
16642  * Called by sata_build_lsense_page_2f()
16643  */
16644 
16645 static int
16646 sata_fetch_smart_return_status(sata_hba_inst_t *sata_hba_inst,
16647     sata_drive_info_t *sdinfo)
16648 {
16649 	sata_pkt_t *spkt;
16650 	sata_cmd_t *scmd;
16651 	sata_pkt_txlate_t *spx;
16652 	int rval;
16653 
16654 	spx = kmem_zalloc(sizeof (sata_pkt_txlate_t), KM_SLEEP);
16655 	spx->txlt_sata_hba_inst = sata_hba_inst;
16656 	spx->txlt_scsi_pkt = NULL;		/* No scsi pkt involved */
16657 	spkt = sata_pkt_alloc(spx, SLEEP_FUNC);
16658 	if (spkt == NULL) {
16659 		kmem_free(spx, sizeof (sata_pkt_txlate_t));
16660 		return (-1);
16661 	}
16662 	/* address is needed now */
16663 	spkt->satapkt_device.satadev_addr = sdinfo->satadrv_addr;
16664 
16665 
16666 	/* Fill sata_pkt */
16667 	spkt->satapkt_device.satadev_addr = sdinfo->satadrv_addr;
16668 	spkt->satapkt_op_mode = SATA_OPMODE_SYNCH | SATA_OPMODE_INTERRUPTS;
16669 	/* Synchronous mode, no callback */
16670 	spkt->satapkt_comp = NULL;
16671 	/* Timeout 30s */
16672 	spkt->satapkt_time = sata_default_pkt_time;
16673 
16674 	scmd = &spkt->satapkt_cmd;
16675 	scmd->satacmd_flags.sata_special_regs = B_TRUE;
16676 	scmd->satacmd_flags.sata_data_direction = SATA_DIR_NODATA_XFER;
16677 
16678 	/* Set up which registers need to be returned */
16679 	scmd->satacmd_flags.sata_copy_out_lba_mid_lsb = B_TRUE;
16680 	scmd->satacmd_flags.sata_copy_out_lba_high_lsb = B_TRUE;
16681 
16682 	/* Build SMART_RETURN_STATUS cmd in the sata_pkt */
16683 	scmd->satacmd_addr_type = 0;		/* N/A */
16684 	scmd->satacmd_sec_count_lsb = 0;	/* N/A */
16685 	scmd->satacmd_lba_low_lsb = 0;		/* N/A */
16686 	scmd->satacmd_lba_mid_lsb = SMART_MAGIC_VAL_1;
16687 	scmd->satacmd_lba_high_lsb = SMART_MAGIC_VAL_2;
16688 	scmd->satacmd_features_reg = SATA_SMART_RETURN_STATUS;
16689 	scmd->satacmd_device_reg = 0;		/* Always device 0 */
16690 	scmd->satacmd_cmd_reg = SATAC_SMART;
16691 	mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst,
16692 	    sdinfo->satadrv_addr.cport)));
16693 
16694 
16695 	/* Send pkt to SATA HBA driver */
16696 	if ((*SATA_START_FUNC(sata_hba_inst))(SATA_DIP(sata_hba_inst), spkt) !=
16697 	    SATA_TRAN_ACCEPTED ||
16698 	    spkt->satapkt_reason != SATA_PKT_COMPLETED) {
16699 		mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst,
16700 		    sdinfo->satadrv_addr.cport)));
16701 		/*
16702 		 * Whoops, no SMART RETURN STATUS
16703 		 */
16704 		rval = -1;
16705 	} else {
16706 		mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst,
16707 		    sdinfo->satadrv_addr.cport)));
16708 		if (scmd->satacmd_error_reg & SATA_ERROR_ABORT) {
16709 			rval = -1;
16710 			goto fail;
16711 		}
16712 		if (scmd->satacmd_status_reg & SATA_STATUS_ERR) {
16713 			rval = -1;
16714 			goto fail;
16715 		}
16716 		if ((scmd->satacmd_lba_mid_lsb == SMART_MAGIC_VAL_1) &&
16717 		    (scmd->satacmd_lba_high_lsb == SMART_MAGIC_VAL_2))
16718 			rval = 0;
16719 		else if ((scmd->satacmd_lba_mid_lsb == SMART_MAGIC_VAL_3) &&
16720 		    (scmd->satacmd_lba_high_lsb == SMART_MAGIC_VAL_4))
16721 			rval = 1;
16722 		else {
16723 			rval = -1;
16724 			goto fail;
16725 		}
16726 	}
16727 fail:
16728 	/* Free allocated resources */
16729 	sata_pkt_free(spx);
16730 	kmem_free(spx, sizeof (sata_pkt_txlate_t));
16731 
16732 	return (rval);
16733 }
16734 
16735 /*
16736  *
16737  * Returns 0 if succeeded, -1 otherwise
16738  *
16739  * Cannot be called in an interrupt context.
16740  *
16741  */
16742 static int
16743 sata_fetch_smart_data(
16744 	sata_hba_inst_t *sata_hba_inst,
16745 	sata_drive_info_t *sdinfo,
16746 	struct smart_data *smart_data)
16747 {
16748 	sata_pkt_t *spkt;
16749 	sata_cmd_t *scmd;
16750 	sata_pkt_txlate_t *spx;
16751 	int rval;
16752 	dev_info_t *dip = SATA_DIP(sata_hba_inst);
16753 
16754 #if ! defined(lint)
16755 	ASSERT(sizeof (struct smart_data) == 512);
16756 #endif
16757 
16758 	spx = kmem_zalloc(sizeof (sata_pkt_txlate_t), KM_SLEEP);
16759 	spx->txlt_sata_hba_inst = sata_hba_inst;
16760 	spx->txlt_scsi_pkt = NULL;		/* No scsi pkt involved */
16761 	spkt = sata_pkt_alloc(spx, SLEEP_FUNC);
16762 	if (spkt == NULL) {
16763 		kmem_free(spx, sizeof (sata_pkt_txlate_t));
16764 		return (-1);
16765 	}
16766 	/* address is needed now */
16767 	spkt->satapkt_device.satadev_addr = sdinfo->satadrv_addr;
16768 
16769 
16770 	/* Fill sata_pkt */
16771 	spkt->satapkt_device.satadev_addr = sdinfo->satadrv_addr;
16772 	spkt->satapkt_op_mode = SATA_OPMODE_SYNCH | SATA_OPMODE_INTERRUPTS;
16773 	/* Synchronous mode, no callback */
16774 	spkt->satapkt_comp = NULL;
16775 	/* Timeout 30s */
16776 	spkt->satapkt_time = sata_default_pkt_time;
16777 
16778 	scmd = &spkt->satapkt_cmd;
16779 	scmd->satacmd_flags.sata_data_direction = SATA_DIR_READ;
16780 
16781 	/*
16782 	 * Allocate buffer for SMART data
16783 	 */
16784 	scmd->satacmd_bp = sata_alloc_local_buffer(spx,
16785 	    sizeof (struct smart_data));
16786 	if (scmd->satacmd_bp == NULL) {
16787 		sata_pkt_free(spx);
16788 		kmem_free(spx, sizeof (sata_pkt_txlate_t));
16789 		SATA_LOG_D((sata_hba_inst, CE_WARN,
16790 		    "sata_fetch_smart_data: "
16791 		    "cannot allocate buffer"));
16792 		return (-1);
16793 	}
16794 
16795 
16796 	/* Build SMART_READ_DATA cmd in the sata_pkt */
16797 	scmd->satacmd_addr_type = 0;		/* N/A */
16798 	scmd->satacmd_sec_count_lsb = 0;	/* N/A */
16799 	scmd->satacmd_lba_low_lsb = 0;		/* N/A */
16800 	scmd->satacmd_lba_mid_lsb = SMART_MAGIC_VAL_1;
16801 	scmd->satacmd_lba_high_lsb = SMART_MAGIC_VAL_2;
16802 	scmd->satacmd_features_reg = SATA_SMART_READ_DATA;
16803 	scmd->satacmd_device_reg = 0;		/* Always device 0 */
16804 	scmd->satacmd_cmd_reg = SATAC_SMART;
16805 	mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst,
16806 	    sdinfo->satadrv_addr.cport)));
16807 
16808 	/* Send pkt to SATA HBA driver */
16809 	if ((*SATA_START_FUNC(sata_hba_inst))(SATA_DIP(sata_hba_inst), spkt) !=
16810 	    SATA_TRAN_ACCEPTED ||
16811 	    spkt->satapkt_reason != SATA_PKT_COMPLETED) {
16812 		mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst,
16813 		    sdinfo->satadrv_addr.cport)));
16814 		/*
16815 		 * Whoops, no SMART DATA available
16816 		 */
16817 		rval = -1;
16818 		goto fail;
16819 	} else {
16820 		mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst,
16821 		    sdinfo->satadrv_addr.cport)));
16822 		if (spx->txlt_buf_dma_handle != NULL) {
16823 			rval = ddi_dma_sync(spx->txlt_buf_dma_handle, 0, 0,
16824 			    DDI_DMA_SYNC_FORKERNEL);
16825 			ASSERT(rval == DDI_SUCCESS);
16826 			if (sata_check_for_dma_error(dip, spx)) {
16827 				ddi_fm_service_impact(dip,
16828 				    DDI_SERVICE_UNAFFECTED);
16829 				rval = -1;
16830 				goto fail;
16831 			}
16832 		}
16833 		bcopy(scmd->satacmd_bp->b_un.b_addr, (uint8_t *)smart_data,
16834 		    sizeof (struct smart_data));
16835 	}
16836 
16837 fail:
16838 	/* Free allocated resources */
16839 	sata_free_local_buffer(spx);
16840 	sata_pkt_free(spx);
16841 	kmem_free(spx, sizeof (sata_pkt_txlate_t));
16842 
16843 	return (rval);
16844 }
16845 
16846 /*
16847  * Used by LOG SENSE page 0x10
16848  * Reads (in synchronous mode) the self test log data using Read Log Ext cmd.
16849  * Note: cannot be called in the interrupt context.
16850  *
16851  * return 0 for success, -1 otherwise
16852  *
16853  */
16854 static int
16855 sata_ext_smart_selftest_read_log(
16856 	sata_hba_inst_t *sata_hba_inst,
16857 	sata_drive_info_t *sdinfo,
16858 	struct smart_ext_selftest_log *ext_selftest_log,
16859 	uint16_t block_num)
16860 {
16861 	sata_pkt_txlate_t *spx;
16862 	sata_pkt_t *spkt;
16863 	sata_cmd_t *scmd;
16864 	int rval;
16865 	dev_info_t *dip = SATA_DIP(sata_hba_inst);
16866 
16867 #if ! defined(lint)
16868 	ASSERT(sizeof (struct smart_ext_selftest_log) == 512);
16869 #endif
16870 
16871 	spx = kmem_zalloc(sizeof (sata_pkt_txlate_t), KM_SLEEP);
16872 	spx->txlt_sata_hba_inst = sata_hba_inst;
16873 	spx->txlt_scsi_pkt = NULL;		/* No scsi pkt involved */
16874 	spkt = sata_pkt_alloc(spx, SLEEP_FUNC);
16875 	if (spkt == NULL) {
16876 		kmem_free(spx, sizeof (sata_pkt_txlate_t));
16877 		return (-1);
16878 	}
16879 	/* address is needed now */
16880 	spkt->satapkt_device.satadev_addr = sdinfo->satadrv_addr;
16881 
16882 
16883 	/* Fill sata_pkt */
16884 	spkt->satapkt_device.satadev_addr = sdinfo->satadrv_addr;
16885 	spkt->satapkt_op_mode = SATA_OPMODE_SYNCH | SATA_OPMODE_INTERRUPTS;
16886 	/* Synchronous mode, no callback */
16887 	spkt->satapkt_comp = NULL;
16888 	/* Timeout 30s */
16889 	spkt->satapkt_time = sata_default_pkt_time;
16890 
16891 	scmd = &spkt->satapkt_cmd;
16892 	scmd->satacmd_flags.sata_data_direction = SATA_DIR_READ;
16893 
16894 	/*
16895 	 * Allocate buffer for SMART extended self-test log
16896 	 */
16897 	scmd->satacmd_bp = sata_alloc_local_buffer(spx,
16898 	    sizeof (struct smart_ext_selftest_log));
16899 	if (scmd->satacmd_bp == NULL) {
16900 		sata_pkt_free(spx);
16901 		kmem_free(spx, sizeof (sata_pkt_txlate_t));
16902 		SATA_LOG_D((sata_hba_inst, CE_WARN,
16903 		    "sata_ext_smart_selftest_log: "
16904 		    "cannot allocate buffer"));
16905 		return (-1);
16906 	}
16907 
16908 	/* Build READ LOG EXT w/ extended self-test log cmd in the sata_pkt */
16909 	scmd->satacmd_addr_type = ATA_ADDR_LBA48;
16910 	scmd->satacmd_sec_count_lsb = 1;	/* One sector of selftest log */
16911 	scmd->satacmd_sec_count_msb = 0;	/* One sector of selftest log */
16912 	scmd->satacmd_lba_low_lsb = EXT_SMART_SELFTEST_LOG_PAGE;
16913 	scmd->satacmd_lba_low_msb = 0;
16914 	scmd->satacmd_lba_mid_lsb = block_num & 0xff;
16915 	scmd->satacmd_lba_mid_msb = block_num >> 8;
16916 	scmd->satacmd_device_reg = 0;		/* Always device 0 */
16917 	scmd->satacmd_cmd_reg = SATAC_READ_LOG_EXT;
16918 
16919 	mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst,
16920 	    sdinfo->satadrv_addr.cport)));
16921 
16922 	/* Send pkt to SATA HBA driver */
16923 	if ((*SATA_START_FUNC(sata_hba_inst))(SATA_DIP(sata_hba_inst), spkt) !=
16924 	    SATA_TRAN_ACCEPTED ||
16925 	    spkt->satapkt_reason != SATA_PKT_COMPLETED) {
16926 		mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst,
16927 		    sdinfo->satadrv_addr.cport)));
16928 
16929 		/*
16930 		 * Whoops, no SMART selftest log info available
16931 		 */
16932 		rval = -1;
16933 		goto fail;
16934 	} else {
16935 		mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst,
16936 		    sdinfo->satadrv_addr.cport)));
16937 
16938 		if (spx->txlt_buf_dma_handle != NULL) {
16939 			rval = ddi_dma_sync(spx->txlt_buf_dma_handle, 0, 0,
16940 			    DDI_DMA_SYNC_FORKERNEL);
16941 			ASSERT(rval == DDI_SUCCESS);
16942 			if (sata_check_for_dma_error(dip, spx)) {
16943 				ddi_fm_service_impact(dip,
16944 				    DDI_SERVICE_UNAFFECTED);
16945 				rval = -1;
16946 				goto fail;
16947 			}
16948 		}
16949 		bcopy(scmd->satacmd_bp->b_un.b_addr,
16950 		    (uint8_t *)ext_selftest_log,
16951 		    sizeof (struct smart_ext_selftest_log));
16952 		rval = 0;
16953 	}
16954 
16955 fail:
16956 	/* Free allocated resources */
16957 	sata_free_local_buffer(spx);
16958 	sata_pkt_free(spx);
16959 	kmem_free(spx, sizeof (sata_pkt_txlate_t));
16960 
16961 	return (rval);
16962 }
16963 
16964 /*
16965  * Returns 0 for success, -1 otherwise
16966  *
16967  * SMART self-test log data is returned in buffer pointed to by selftest_log
16968  */
16969 static int
16970 sata_smart_selftest_log(
16971 	sata_hba_inst_t *sata_hba_inst,
16972 	sata_drive_info_t *sdinfo,
16973 	struct smart_selftest_log *selftest_log)
16974 {
16975 	sata_pkt_t *spkt;
16976 	sata_cmd_t *scmd;
16977 	sata_pkt_txlate_t *spx;
16978 	int rval;
16979 	dev_info_t *dip = SATA_DIP(sata_hba_inst);
16980 
16981 #if ! defined(lint)
16982 	ASSERT(sizeof (struct smart_selftest_log) == 512);
16983 #endif
16984 
16985 	spx = kmem_zalloc(sizeof (sata_pkt_txlate_t), KM_SLEEP);
16986 	spx->txlt_sata_hba_inst = sata_hba_inst;
16987 	spx->txlt_scsi_pkt = NULL;		/* No scsi pkt involved */
16988 	spkt = sata_pkt_alloc(spx, SLEEP_FUNC);
16989 	if (spkt == NULL) {
16990 		kmem_free(spx, sizeof (sata_pkt_txlate_t));
16991 		return (-1);
16992 	}
16993 	/* address is needed now */
16994 	spkt->satapkt_device.satadev_addr = sdinfo->satadrv_addr;
16995 
16996 
16997 	/* Fill sata_pkt */
16998 	spkt->satapkt_device.satadev_addr = sdinfo->satadrv_addr;
16999 	spkt->satapkt_op_mode = SATA_OPMODE_SYNCH | SATA_OPMODE_INTERRUPTS;
17000 	/* Synchronous mode, no callback */
17001 	spkt->satapkt_comp = NULL;
17002 	/* Timeout 30s */
17003 	spkt->satapkt_time = sata_default_pkt_time;
17004 
17005 	scmd = &spkt->satapkt_cmd;
17006 	scmd->satacmd_flags.sata_data_direction = SATA_DIR_READ;
17007 
17008 	/*
17009 	 * Allocate buffer for SMART SELFTEST LOG
17010 	 */
17011 	scmd->satacmd_bp = sata_alloc_local_buffer(spx,
17012 	    sizeof (struct smart_selftest_log));
17013 	if (scmd->satacmd_bp == NULL) {
17014 		sata_pkt_free(spx);
17015 		kmem_free(spx, sizeof (sata_pkt_txlate_t));
17016 		SATA_LOG_D((sata_hba_inst, CE_WARN,
17017 		    "sata_smart_selftest_log: "
17018 		    "cannot allocate buffer"));
17019 		return (-1);
17020 	}
17021 
17022 	/* Build SMART_READ_LOG cmd in the sata_pkt */
17023 	scmd->satacmd_addr_type = 0;		/* N/A */
17024 	scmd->satacmd_sec_count_lsb = 1;	/* One sector of SMART log */
17025 	scmd->satacmd_lba_low_lsb = SMART_SELFTEST_LOG_PAGE;
17026 	scmd->satacmd_lba_mid_lsb = SMART_MAGIC_VAL_1;
17027 	scmd->satacmd_lba_high_lsb = SMART_MAGIC_VAL_2;
17028 	scmd->satacmd_features_reg = SATA_SMART_READ_LOG;
17029 	scmd->satacmd_device_reg = 0;		/* Always device 0 */
17030 	scmd->satacmd_cmd_reg = SATAC_SMART;
17031 	mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst,
17032 	    sdinfo->satadrv_addr.cport)));
17033 
17034 	/* Send pkt to SATA HBA driver */
17035 	if ((*SATA_START_FUNC(sata_hba_inst))(SATA_DIP(sata_hba_inst), spkt) !=
17036 	    SATA_TRAN_ACCEPTED ||
17037 	    spkt->satapkt_reason != SATA_PKT_COMPLETED) {
17038 		mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst,
17039 		    sdinfo->satadrv_addr.cport)));
17040 		/*
17041 		 * Whoops, no SMART DATA available
17042 		 */
17043 		rval = -1;
17044 		goto fail;
17045 	} else {
17046 		mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst,
17047 		    sdinfo->satadrv_addr.cport)));
17048 		if (spx->txlt_buf_dma_handle != NULL) {
17049 			rval = ddi_dma_sync(spx->txlt_buf_dma_handle, 0, 0,
17050 			    DDI_DMA_SYNC_FORKERNEL);
17051 			ASSERT(rval == DDI_SUCCESS);
17052 			if (sata_check_for_dma_error(dip, spx)) {
17053 				ddi_fm_service_impact(dip,
17054 				    DDI_SERVICE_UNAFFECTED);
17055 				rval = -1;
17056 				goto fail;
17057 			}
17058 		}
17059 		bcopy(scmd->satacmd_bp->b_un.b_addr, (uint8_t *)selftest_log,
17060 		    sizeof (struct smart_selftest_log));
17061 		rval = 0;
17062 	}
17063 
17064 fail:
17065 	/* Free allocated resources */
17066 	sata_free_local_buffer(spx);
17067 	sata_pkt_free(spx);
17068 	kmem_free(spx, sizeof (sata_pkt_txlate_t));
17069 
17070 	return (rval);
17071 }
17072 
17073 
17074 /*
17075  * Returns 0 for success, -1 otherwise
17076  *
17077  * SMART READ LOG data is returned in buffer pointed to by smart_log
17078  */
17079 static int
17080 sata_smart_read_log(
17081 	sata_hba_inst_t *sata_hba_inst,
17082 	sata_drive_info_t *sdinfo,
17083 	uint8_t *smart_log,		/* where the data should be returned */
17084 	uint8_t which_log,		/* which log should be returned */
17085 	uint8_t log_size)		/* # of 512 bytes in log */
17086 {
17087 	sata_pkt_t *spkt;
17088 	sata_cmd_t *scmd;
17089 	sata_pkt_txlate_t *spx;
17090 	int rval;
17091 	dev_info_t *dip = SATA_DIP(sata_hba_inst);
17092 
17093 	spx = kmem_zalloc(sizeof (sata_pkt_txlate_t), KM_SLEEP);
17094 	spx->txlt_sata_hba_inst = sata_hba_inst;
17095 	spx->txlt_scsi_pkt = NULL;		/* No scsi pkt involved */
17096 	spkt = sata_pkt_alloc(spx, SLEEP_FUNC);
17097 	if (spkt == NULL) {
17098 		kmem_free(spx, sizeof (sata_pkt_txlate_t));
17099 		return (-1);
17100 	}
17101 	/* address is needed now */
17102 	spkt->satapkt_device.satadev_addr = sdinfo->satadrv_addr;
17103 
17104 
17105 	/* Fill sata_pkt */
17106 	spkt->satapkt_device.satadev_addr = sdinfo->satadrv_addr;
17107 	spkt->satapkt_op_mode = SATA_OPMODE_SYNCH | SATA_OPMODE_INTERRUPTS;
17108 	/* Synchronous mode, no callback */
17109 	spkt->satapkt_comp = NULL;
17110 	/* Timeout 30s */
17111 	spkt->satapkt_time = sata_default_pkt_time;
17112 
17113 	scmd = &spkt->satapkt_cmd;
17114 	scmd->satacmd_flags.sata_data_direction = SATA_DIR_READ;
17115 
17116 	/*
17117 	 * Allocate buffer for SMART READ LOG
17118 	 */
17119 	scmd->satacmd_bp = sata_alloc_local_buffer(spx, log_size * 512);
17120 	if (scmd->satacmd_bp == NULL) {
17121 		sata_pkt_free(spx);
17122 		kmem_free(spx, sizeof (sata_pkt_txlate_t));
17123 		SATA_LOG_D((sata_hba_inst, CE_WARN,
17124 		    "sata_smart_read_log: " "cannot allocate buffer"));
17125 		return (-1);
17126 	}
17127 
17128 	/* Build SMART_READ_LOG cmd in the sata_pkt */
17129 	scmd->satacmd_addr_type = 0;		/* N/A */
17130 	scmd->satacmd_sec_count_lsb = log_size;	/* what the caller asked for */
17131 	scmd->satacmd_lba_low_lsb = which_log;	/* which log page */
17132 	scmd->satacmd_lba_mid_lsb = SMART_MAGIC_VAL_1;
17133 	scmd->satacmd_lba_high_lsb = SMART_MAGIC_VAL_2;
17134 	scmd->satacmd_features_reg = SATA_SMART_READ_LOG;
17135 	scmd->satacmd_device_reg = 0;		/* Always device 0 */
17136 	scmd->satacmd_cmd_reg = SATAC_SMART;
17137 
17138 	mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst,
17139 	    sdinfo->satadrv_addr.cport)));
17140 
17141 	/* Send pkt to SATA HBA driver */
17142 	if ((*SATA_START_FUNC(sata_hba_inst))(SATA_DIP(sata_hba_inst), spkt) !=
17143 	    SATA_TRAN_ACCEPTED ||
17144 	    spkt->satapkt_reason != SATA_PKT_COMPLETED) {
17145 		mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst,
17146 		    sdinfo->satadrv_addr.cport)));
17147 
17148 		/*
17149 		 * Whoops, no SMART DATA available
17150 		 */
17151 		rval = -1;
17152 		goto fail;
17153 	} else {
17154 		mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst,
17155 		    sdinfo->satadrv_addr.cport)));
17156 
17157 		if (spx->txlt_buf_dma_handle != NULL) {
17158 			rval = ddi_dma_sync(spx->txlt_buf_dma_handle, 0, 0,
17159 			    DDI_DMA_SYNC_FORKERNEL);
17160 			ASSERT(rval == DDI_SUCCESS);
17161 			if (sata_check_for_dma_error(dip, spx)) {
17162 				ddi_fm_service_impact(dip,
17163 				    DDI_SERVICE_UNAFFECTED);
17164 				rval = -1;
17165 				goto fail;
17166 			}
17167 		}
17168 		bcopy(scmd->satacmd_bp->b_un.b_addr, smart_log, log_size * 512);
17169 		rval = 0;
17170 	}
17171 
17172 fail:
17173 	/* Free allocated resources */
17174 	sata_free_local_buffer(spx);
17175 	sata_pkt_free(spx);
17176 	kmem_free(spx, sizeof (sata_pkt_txlate_t));
17177 
17178 	return (rval);
17179 }
17180 
17181 /*
17182  * Used by LOG SENSE page 0x10
17183  *
17184  * return 0 for success, -1 otherwise
17185  *
17186  */
17187 static int
17188 sata_read_log_ext_directory(
17189 	sata_hba_inst_t *sata_hba_inst,
17190 	sata_drive_info_t *sdinfo,
17191 	struct read_log_ext_directory *logdir)
17192 {
17193 	sata_pkt_txlate_t *spx;
17194 	sata_pkt_t *spkt;
17195 	sata_cmd_t *scmd;
17196 	int rval;
17197 	dev_info_t *dip = SATA_DIP(sata_hba_inst);
17198 
17199 #if ! defined(lint)
17200 	ASSERT(sizeof (struct read_log_ext_directory) == 512);
17201 #endif
17202 
17203 	spx = kmem_zalloc(sizeof (sata_pkt_txlate_t), KM_SLEEP);
17204 	spx->txlt_sata_hba_inst = sata_hba_inst;
17205 	spx->txlt_scsi_pkt = NULL;		/* No scsi pkt involved */
17206 	spkt = sata_pkt_alloc(spx, SLEEP_FUNC);
17207 	if (spkt == NULL) {
17208 		kmem_free(spx, sizeof (sata_pkt_txlate_t));
17209 		return (-1);
17210 	}
17211 
17212 	/* Fill sata_pkt */
17213 	spkt->satapkt_device.satadev_addr = sdinfo->satadrv_addr;
17214 	spkt->satapkt_op_mode = SATA_OPMODE_SYNCH | SATA_OPMODE_INTERRUPTS;
17215 	/* Synchronous mode, no callback */
17216 	spkt->satapkt_comp = NULL;
17217 	/* Timeout 30s */
17218 	spkt->satapkt_time = sata_default_pkt_time;
17219 
17220 	scmd = &spkt->satapkt_cmd;
17221 	scmd->satacmd_flags.sata_data_direction = SATA_DIR_READ;
17222 
17223 	/*
17224 	 * Allocate buffer for SMART READ LOG EXTENDED command
17225 	 */
17226 	scmd->satacmd_bp = sata_alloc_local_buffer(spx,
17227 	    sizeof (struct read_log_ext_directory));
17228 	if (scmd->satacmd_bp == NULL) {
17229 		sata_pkt_free(spx);
17230 		kmem_free(spx, sizeof (sata_pkt_txlate_t));
17231 		SATA_LOG_D((sata_hba_inst, CE_WARN,
17232 		    "sata_read_log_ext_directory: "
17233 		    "cannot allocate buffer"));
17234 		return (-1);
17235 	}
17236 
17237 	/* Build READ LOG EXT w/ log directory cmd in the  sata_pkt */
17238 	scmd->satacmd_addr_type = ATA_ADDR_LBA48;
17239 	scmd->satacmd_sec_count_lsb = 1;	/* One sector of directory */
17240 	scmd->satacmd_sec_count_msb = 0;	/* One sector of directory */
17241 	scmd->satacmd_lba_low_lsb = READ_LOG_EXT_LOG_DIRECTORY;
17242 	scmd->satacmd_lba_low_msb = 0;
17243 	scmd->satacmd_lba_mid_lsb = 0;
17244 	scmd->satacmd_lba_mid_msb = 0;
17245 	scmd->satacmd_device_reg = 0;		/* Always device 0 */
17246 	scmd->satacmd_cmd_reg = SATAC_READ_LOG_EXT;
17247 
17248 	mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst,
17249 	    sdinfo->satadrv_addr.cport)));
17250 
17251 	/* Send pkt to SATA HBA driver */
17252 	if ((*SATA_START_FUNC(sata_hba_inst))(SATA_DIP(sata_hba_inst), spkt) !=
17253 	    SATA_TRAN_ACCEPTED ||
17254 	    spkt->satapkt_reason != SATA_PKT_COMPLETED) {
17255 		mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst,
17256 		    sdinfo->satadrv_addr.cport)));
17257 		/*
17258 		 * Whoops, no SMART selftest log info available
17259 		 */
17260 		rval = -1;
17261 		goto fail;
17262 	} else {
17263 		mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst,
17264 		    sdinfo->satadrv_addr.cport)));
17265 		if (spx->txlt_buf_dma_handle != NULL) {
17266 			rval = ddi_dma_sync(spx->txlt_buf_dma_handle, 0, 0,
17267 			    DDI_DMA_SYNC_FORKERNEL);
17268 			ASSERT(rval == DDI_SUCCESS);
17269 			if (sata_check_for_dma_error(dip, spx)) {
17270 				ddi_fm_service_impact(dip,
17271 				    DDI_SERVICE_UNAFFECTED);
17272 				rval = -1;
17273 				goto fail;
17274 			}
17275 		}
17276 		bcopy(scmd->satacmd_bp->b_un.b_addr, (uint8_t *)logdir,
17277 		    sizeof (struct read_log_ext_directory));
17278 		rval = 0;
17279 	}
17280 
17281 fail:
17282 	/* Free allocated resources */
17283 	sata_free_local_buffer(spx);
17284 	sata_pkt_free(spx);
17285 	kmem_free(spx, sizeof (sata_pkt_txlate_t));
17286 
17287 	return (rval);
17288 }
17289 
17290 /*
17291  * Set up error retrieval sata command for NCQ command error data
17292  * recovery.
17293  *
17294  * Returns SATA_SUCCESS when data buffer is allocated and packet set-up,
17295  * returns SATA_FAILURE otherwise.
17296  */
17297 static int
17298 sata_ncq_err_ret_cmd_setup(sata_pkt_txlate_t *spx, sata_drive_info_t *sdinfo)
17299 {
17300 #ifndef __lock_lint
17301 	_NOTE(ARGUNUSED(sdinfo))
17302 #endif
17303 
17304 	sata_pkt_t *spkt = spx->txlt_sata_pkt;
17305 	sata_cmd_t *scmd;
17306 	struct buf *bp;
17307 
17308 	/* Operation modes are up to the caller */
17309 	spkt->satapkt_op_mode = SATA_OPMODE_SYNCH | SATA_OPMODE_INTERRUPTS;
17310 
17311 	/* Synchronous mode, no callback - may be changed by the caller */
17312 	spkt->satapkt_comp = NULL;
17313 	spkt->satapkt_time = sata_default_pkt_time;
17314 
17315 	scmd = &spkt->satapkt_cmd;
17316 	bcopy(&sata_rle_cmd, scmd, sizeof (sata_cmd_t));
17317 	scmd->satacmd_flags.sata_ignore_dev_reset = B_TRUE;
17318 
17319 	/*
17320 	 * Allocate dma_able buffer error data.
17321 	 * Buffer allocation will take care of buffer alignment and other DMA
17322 	 * attributes.
17323 	 */
17324 	bp = sata_alloc_local_buffer(spx,
17325 	    sizeof (struct sata_ncq_error_recovery_page));
17326 	if (bp == NULL)
17327 		return (SATA_FAILURE);
17328 
17329 	bp_mapin(bp); /* make data buffer accessible */
17330 	scmd->satacmd_bp = bp;
17331 
17332 	/*
17333 	 * Set-up pointer to the buffer handle, so HBA can sync buffer
17334 	 * before accessing it. Handle is in usual place in translate struct.
17335 	 */
17336 	scmd->satacmd_err_ret_buf_handle = &spx->txlt_buf_dma_handle;
17337 
17338 	ASSERT(scmd->satacmd_num_dma_cookies != 0);
17339 	ASSERT(scmd->satacmd_dma_cookie_list != NULL);
17340 
17341 	return (SATA_SUCCESS);
17342 }
17343 
17344 /*
17345  * sata_xlate_errors() is used to translate (S)ATA error
17346  * information to SCSI information returned in the SCSI
17347  * packet.
17348  */
17349 static void
17350 sata_xlate_errors(sata_pkt_txlate_t *spx)
17351 {
17352 	struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt;
17353 	struct scsi_extended_sense *sense;
17354 
17355 	scsipkt->pkt_reason = CMD_INCOMPLETE;
17356 	*scsipkt->pkt_scbp = STATUS_CHECK;
17357 	sense = sata_arq_sense(spx);
17358 
17359 	switch (spx->txlt_sata_pkt->satapkt_reason) {
17360 	case SATA_PKT_PORT_ERROR:
17361 		/*
17362 		 * We have no device data. Assume no data transfered.
17363 		 */
17364 		sense->es_key = KEY_HARDWARE_ERROR;
17365 		break;
17366 
17367 	case SATA_PKT_DEV_ERROR:
17368 		if (spx->txlt_sata_pkt->satapkt_cmd.satacmd_status_reg &
17369 		    SATA_STATUS_ERR) {
17370 			/*
17371 			 * determine dev error reason from error
17372 			 * reg content
17373 			 */
17374 			sata_decode_device_error(spx, sense);
17375 			break;
17376 		}
17377 		/* No extended sense key - no info available */
17378 		break;
17379 
17380 	case SATA_PKT_TIMEOUT:
17381 		scsipkt->pkt_reason = CMD_TIMEOUT;
17382 		scsipkt->pkt_statistics |= STAT_TIMEOUT | STAT_DEV_RESET;
17383 		/* No extended sense key */
17384 		break;
17385 
17386 	case SATA_PKT_ABORTED:
17387 		scsipkt->pkt_reason = CMD_ABORTED;
17388 		scsipkt->pkt_statistics |= STAT_ABORTED;
17389 		/* No extended sense key */
17390 		break;
17391 
17392 	case SATA_PKT_RESET:
17393 		/*
17394 		 * pkt aborted either by an explicit reset request from
17395 		 * a host, or due to error recovery
17396 		 */
17397 		scsipkt->pkt_reason = CMD_RESET;
17398 		scsipkt->pkt_statistics |= STAT_DEV_RESET;
17399 		break;
17400 
17401 	default:
17402 		scsipkt->pkt_reason = CMD_TRAN_ERR;
17403 		break;
17404 	}
17405 }
17406 
17407 
17408 
17409 
17410 /*
17411  * Log sata message
17412  * dev pathname msg line preceeds the logged message.
17413  */
17414 
17415 static	void
17416 sata_log(sata_hba_inst_t *sata_hba_inst, uint_t level, char *fmt, ...)
17417 {
17418 	char pathname[128];
17419 	dev_info_t *dip = NULL;
17420 	va_list ap;
17421 
17422 	mutex_enter(&sata_log_mutex);
17423 
17424 	va_start(ap, fmt);
17425 	(void) vsprintf(sata_log_buf, fmt, ap);
17426 	va_end(ap);
17427 
17428 	if (sata_hba_inst != NULL) {
17429 		dip = SATA_DIP(sata_hba_inst);
17430 		(void) ddi_pathname(dip, pathname);
17431 	} else {
17432 		pathname[0] = 0;
17433 	}
17434 	if (level == CE_CONT) {
17435 		if (sata_debug_flags == 0)
17436 			cmn_err(level, "?%s:\n %s\n", pathname, sata_log_buf);
17437 		else
17438 			cmn_err(level, "%s:\n %s\n", pathname, sata_log_buf);
17439 	} else {
17440 		if (level != CE_NOTE) {
17441 			cmn_err(level, "%s:\n %s", pathname, sata_log_buf);
17442 		} else if (sata_msg) {
17443 			cmn_err(level, "%s:\n %s", pathname,
17444 			    sata_log_buf);
17445 		}
17446 	}
17447 
17448 	/* sata trace debug */
17449 	sata_trace_debug(dip, sata_log_buf);
17450 
17451 	mutex_exit(&sata_log_mutex);
17452 }
17453 
17454 
17455 /* ******** Asynchronous HBA events handling & hotplugging support ******** */
17456 
17457 /*
17458  * Start or terminate the thread, depending on flag arg and current state
17459  */
17460 static void
17461 sata_event_thread_control(int startstop)
17462 {
17463 	static 	int sata_event_thread_terminating = 0;
17464 	static 	int sata_event_thread_starting = 0;
17465 	int i;
17466 
17467 	mutex_enter(&sata_event_mutex);
17468 
17469 	if (startstop == 0 && (sata_event_thread_starting == 1 ||
17470 	    sata_event_thread_terminating == 1)) {
17471 		mutex_exit(&sata_event_mutex);
17472 		return;
17473 	}
17474 	if (startstop == 1 && sata_event_thread_starting == 1) {
17475 		mutex_exit(&sata_event_mutex);
17476 		return;
17477 	}
17478 	if (startstop == 1 && sata_event_thread_terminating == 1) {
17479 		sata_event_thread_starting = 1;
17480 		/* wait til terminate operation completes */
17481 		i = SATA_EVNT_DAEMON_TERM_WAIT/SATA_EVNT_DAEMON_TERM_TIMEOUT;
17482 		while (sata_event_thread_terminating == 1) {
17483 			if (i-- <= 0) {
17484 				sata_event_thread_starting = 0;
17485 				mutex_exit(&sata_event_mutex);
17486 #ifdef SATA_DEBUG
17487 				cmn_err(CE_WARN, "sata_event_thread_control: "
17488 				    "timeout waiting for thread to terminate");
17489 #endif
17490 				return;
17491 			}
17492 			mutex_exit(&sata_event_mutex);
17493 			delay(drv_usectohz(SATA_EVNT_DAEMON_TERM_TIMEOUT));
17494 			mutex_enter(&sata_event_mutex);
17495 		}
17496 	}
17497 	if (startstop == 1) {
17498 		if (sata_event_thread == NULL) {
17499 			sata_event_thread = thread_create(NULL, 0,
17500 			    (void (*)())sata_event_daemon,
17501 			    &sata_hba_list, 0, &p0, TS_RUN, minclsyspri);
17502 		}
17503 		sata_event_thread_starting = 0;
17504 		mutex_exit(&sata_event_mutex);
17505 		return;
17506 	}
17507 
17508 	/*
17509 	 * If we got here, thread may need to be terminated
17510 	 */
17511 	if (sata_event_thread != NULL) {
17512 		int i;
17513 		/* Signal event thread to go away */
17514 		sata_event_thread_terminating = 1;
17515 		sata_event_thread_terminate = 1;
17516 		cv_signal(&sata_event_cv);
17517 		/*
17518 		 * Wait til daemon terminates.
17519 		 */
17520 		i = SATA_EVNT_DAEMON_TERM_WAIT/SATA_EVNT_DAEMON_TERM_TIMEOUT;
17521 		while (sata_event_thread_terminate == 1) {
17522 			mutex_exit(&sata_event_mutex);
17523 			if (i-- <= 0) {
17524 				/* Daemon did not go away !!! */
17525 #ifdef SATA_DEBUG
17526 				cmn_err(CE_WARN, "sata_event_thread_control: "
17527 				    "cannot terminate event daemon thread");
17528 #endif
17529 				mutex_enter(&sata_event_mutex);
17530 				break;
17531 			}
17532 			delay(drv_usectohz(SATA_EVNT_DAEMON_TERM_TIMEOUT));
17533 			mutex_enter(&sata_event_mutex);
17534 		}
17535 		sata_event_thread_terminating = 0;
17536 	}
17537 	ASSERT(sata_event_thread_terminating == 0);
17538 	ASSERT(sata_event_thread_starting == 0);
17539 	mutex_exit(&sata_event_mutex);
17540 }
17541 
17542 
17543 /*
17544  * SATA HBA event notification function.
17545  * Events reported by SATA HBA drivers per HBA instance relate to a change in
17546  * a port and/or device state or a controller itself.
17547  * Events for different addresses/addr types cannot be combined.
17548  * A warning message is generated for each event type.
17549  * Events are not processed by this function, so only the
17550  * event flag(s)is set for an affected entity and the event thread is
17551  * waken up. Event daemon thread processes all events.
17552  *
17553  * NOTE: Since more than one event may be reported at the same time, one
17554  * cannot determine a sequence of events when opposite event are reported, eg.
17555  * LINK_LOST and LINK_ESTABLISHED. Actual port status during event processing
17556  * is taking precedence over reported events, i.e. may cause ignoring some
17557  * events.
17558  */
17559 #define	SATA_EVENT_MAX_MSG_LENGTH	79
17560 
17561 void
17562 sata_hba_event_notify(dev_info_t *dip, sata_device_t *sata_device, int event)
17563 {
17564 	sata_hba_inst_t *sata_hba_inst = NULL;
17565 	sata_address_t *saddr;
17566 	sata_pmult_info_t *pmultinfo;
17567 	sata_drive_info_t *sdinfo;
17568 	sata_port_stats_t *pstats;
17569 	sata_cport_info_t *cportinfo;
17570 	sata_pmport_info_t *pmportinfo;
17571 	int cport, pmport;
17572 	char buf1[SATA_EVENT_MAX_MSG_LENGTH + 1];
17573 	char buf2[SATA_EVENT_MAX_MSG_LENGTH + 1];
17574 	char *lcp;
17575 	static char *err_msg_evnt_1 =
17576 	    "sata_hba_event_notify: invalid port event 0x%x ";
17577 	static char *err_msg_evnt_2 =
17578 	    "sata_hba_event_notify: invalid device event 0x%x ";
17579 	int linkevent;
17580 
17581 	/*
17582 	 * There is a possibility that an event will be generated on HBA
17583 	 * that has not completed attachment or is detaching. We still want
17584 	 * to process events until HBA is detached.
17585 	 */
17586 	mutex_enter(&sata_mutex);
17587 	for (sata_hba_inst = sata_hba_list; sata_hba_inst != NULL;
17588 	    sata_hba_inst = sata_hba_inst->satahba_next) {
17589 		if (SATA_DIP(sata_hba_inst) == dip)
17590 			if (sata_hba_inst->satahba_attached == 1)
17591 				break;
17592 	}
17593 	mutex_exit(&sata_mutex);
17594 	if (sata_hba_inst == NULL)
17595 		/* HBA not attached */
17596 		return;
17597 
17598 	ASSERT(sata_device != NULL);
17599 
17600 	/*
17601 	 * Validate address before - do not proceed with invalid address.
17602 	 */
17603 	saddr = &sata_device->satadev_addr;
17604 	if (saddr->cport >= SATA_NUM_CPORTS(sata_hba_inst))
17605 		return;
17606 
17607 	cport = saddr->cport;
17608 	pmport = saddr->pmport;
17609 
17610 	buf1[0] = buf2[0] = '\0';
17611 
17612 	/*
17613 	 * If event relates to port or device, check port state.
17614 	 * Port has to be initialized, or we cannot accept an event.
17615 	 */
17616 	if ((saddr->qual & (SATA_ADDR_CPORT | SATA_ADDR_PMPORT |
17617 	    SATA_ADDR_DCPORT | SATA_ADDR_DPMPORT | SATA_ADDR_PMULT)) != 0) {
17618 		mutex_enter(&sata_hba_inst->satahba_mutex);
17619 		cportinfo = SATA_CPORT_INFO(sata_hba_inst, cport);
17620 		mutex_exit(&sata_hba_inst->satahba_mutex);
17621 		if (cportinfo == NULL || cportinfo->cport_state == 0)
17622 			return;
17623 	}
17624 
17625 	if ((saddr->qual & (SATA_ADDR_PMULT | SATA_ADDR_PMPORT |
17626 	    SATA_ADDR_DPMPORT)) != 0) {
17627 		if (cportinfo->cport_dev_type != SATA_DTYPE_PMULT) {
17628 			SATA_LOG_D((sata_hba_inst, CE_WARN,
17629 			    "sata_hba_event_notify: Non-pmult device (0x%x)"
17630 			    "is attached to port %d, ignore pmult/pmport "
17631 			    "event 0x%x", cportinfo->cport_dev_type,
17632 			    cport, event));
17633 			return;
17634 		}
17635 
17636 		mutex_enter(&cportinfo->cport_mutex);
17637 		pmultinfo = SATA_PMULT_INFO(sata_hba_inst, cport);
17638 		mutex_exit(&cportinfo->cport_mutex);
17639 
17640 		/*
17641 		 * The daemon might be processing attachment of port
17642 		 * multiplier, in that case we should ignore events on its
17643 		 * sub-devices.
17644 		 *
17645 		 * NOTE: Only pmult_state is checked in sata_hba_event_notify.
17646 		 * The pmport_state is checked by sata daemon.
17647 		 */
17648 		if (pmultinfo == NULL ||
17649 		    pmultinfo->pmult_state == SATA_STATE_UNKNOWN) {
17650 			SATA_LOG_D((sata_hba_inst, CE_WARN,
17651 			    "sata_hba_event_notify: pmult is not"
17652 			    "available at port %d:%d, ignore event 0x%x",
17653 			    cport, pmport, event));
17654 			return;
17655 		}
17656 	}
17657 
17658 	if ((saddr->qual &
17659 	    (SATA_ADDR_PMPORT | SATA_ADDR_DPMPORT)) != 0) {
17660 
17661 		mutex_enter(&cportinfo->cport_mutex);
17662 		if (pmport > SATA_NUM_PMPORTS(sata_hba_inst, cport)) {
17663 			SATA_LOG_D((sata_hba_inst, CE_WARN,
17664 			    "sata_hba_event_notify: invalid/"
17665 			    "un-implemented port %d:%d (%d ports), "
17666 			    "ignore event 0x%x", cport, pmport,
17667 			    SATA_NUM_PMPORTS(sata_hba_inst, cport), event));
17668 			mutex_exit(&cportinfo->cport_mutex);
17669 			return;
17670 		}
17671 		mutex_exit(&cportinfo->cport_mutex);
17672 
17673 		mutex_enter(&sata_hba_inst->satahba_mutex);
17674 		pmportinfo = SATA_PMPORT_INFO(sata_hba_inst,
17675 		    cport, pmport);
17676 		mutex_exit(&sata_hba_inst->satahba_mutex);
17677 
17678 		/* pmport is implemented/valid? */
17679 		if (pmportinfo == NULL) {
17680 			SATA_LOG_D((sata_hba_inst, CE_WARN,
17681 			    "sata_hba_event_notify: invalid/"
17682 			    "un-implemented port %d:%d, ignore "
17683 			    "event 0x%x", cport, pmport, event));
17684 			return;
17685 		}
17686 	}
17687 
17688 	/*
17689 	 * Events refer to devices, ports and controllers - each has
17690 	 * unique address. Events for different addresses cannot be combined.
17691 	 */
17692 	if (saddr->qual & (SATA_ADDR_CPORT | SATA_ADDR_PMPORT)) {
17693 
17694 		mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, cport)));
17695 
17696 		/* qualify this event(s) */
17697 		if ((event & SATA_EVNT_PORT_EVENTS) == 0) {
17698 			/* Invalid event for the device port */
17699 			(void) sprintf(buf2, err_msg_evnt_1,
17700 			    event & SATA_EVNT_PORT_EVENTS);
17701 			mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, cport)));
17702 			goto event_info;
17703 		}
17704 		if (saddr->qual == SATA_ADDR_CPORT) {
17705 			/* Controller's device port event */
17706 
17707 			(SATA_CPORT_INFO(sata_hba_inst, cport))->
17708 			    cport_event_flags |=
17709 			    event & SATA_EVNT_PORT_EVENTS;
17710 			pstats =
17711 			    &(SATA_CPORT_INFO(sata_hba_inst, cport))->
17712 			    cport_stats;
17713 		} else {
17714 			mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, cport)));
17715 			mutex_enter(&pmportinfo->pmport_mutex);
17716 			/* Port multiplier's device port event */
17717 			(SATA_PMPORT_INFO(sata_hba_inst, cport, pmport))->
17718 			    pmport_event_flags |=
17719 			    event & SATA_EVNT_PORT_EVENTS;
17720 			pstats =
17721 			    &(SATA_PMPORT_INFO(sata_hba_inst, cport, pmport))->
17722 			    pmport_stats;
17723 			mutex_exit(&pmportinfo->pmport_mutex);
17724 			mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, cport)));
17725 		}
17726 
17727 		/*
17728 		 * Add to statistics and log the message. We have to do it
17729 		 * here rather than in the event daemon, because there may be
17730 		 * multiple events occuring before they are processed.
17731 		 */
17732 		linkevent = event &
17733 		    (SATA_EVNT_LINK_LOST | SATA_EVNT_LINK_ESTABLISHED);
17734 		if (linkevent) {
17735 			if (linkevent == (SATA_EVNT_LINK_LOST |
17736 			    SATA_EVNT_LINK_ESTABLISHED)) {
17737 				/* This is likely event combination */
17738 				(void) strlcat(buf1, "link lost/established, ",
17739 				    SATA_EVENT_MAX_MSG_LENGTH);
17740 
17741 				if (pstats->link_lost < 0xffffffffffffffffULL)
17742 					pstats->link_lost++;
17743 				if (pstats->link_established <
17744 				    0xffffffffffffffffULL)
17745 					pstats->link_established++;
17746 				linkevent = 0;
17747 			} else if (linkevent & SATA_EVNT_LINK_LOST) {
17748 				(void) strlcat(buf1, "link lost, ",
17749 				    SATA_EVENT_MAX_MSG_LENGTH);
17750 
17751 				if (pstats->link_lost < 0xffffffffffffffffULL)
17752 					pstats->link_lost++;
17753 			} else {
17754 				(void) strlcat(buf1, "link established, ",
17755 				    SATA_EVENT_MAX_MSG_LENGTH);
17756 				if (pstats->link_established <
17757 				    0xffffffffffffffffULL)
17758 					pstats->link_established++;
17759 			}
17760 		}
17761 		if (event & SATA_EVNT_DEVICE_ATTACHED) {
17762 			(void) strlcat(buf1, "device attached, ",
17763 			    SATA_EVENT_MAX_MSG_LENGTH);
17764 			if (pstats->device_attached < 0xffffffffffffffffULL)
17765 				pstats->device_attached++;
17766 		}
17767 		if (event & SATA_EVNT_DEVICE_DETACHED) {
17768 			(void) strlcat(buf1, "device detached, ",
17769 			    SATA_EVENT_MAX_MSG_LENGTH);
17770 			if (pstats->device_detached < 0xffffffffffffffffULL)
17771 				pstats->device_detached++;
17772 		}
17773 		if (event & SATA_EVNT_PWR_LEVEL_CHANGED) {
17774 			SATADBG1(SATA_DBG_EVENTS, sata_hba_inst,
17775 			    "port %d power level changed", cport);
17776 			if (pstats->port_pwr_changed < 0xffffffffffffffffULL)
17777 				pstats->port_pwr_changed++;
17778 		}
17779 
17780 		if ((event & ~SATA_EVNT_PORT_EVENTS) != 0) {
17781 			/* There should be no other events for this address */
17782 			(void) sprintf(buf2, err_msg_evnt_1,
17783 			    event & ~SATA_EVNT_PORT_EVENTS);
17784 		}
17785 		mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, cport)));
17786 
17787 	} else if (saddr->qual & (SATA_ADDR_DCPORT | SATA_ADDR_DPMPORT)) {
17788 		mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, cport)));
17789 
17790 		/* qualify this event */
17791 		if ((event & SATA_EVNT_DEVICE_RESET) == 0) {
17792 			/* Invalid event for a device */
17793 			(void) sprintf(buf2, err_msg_evnt_2,
17794 			    event & SATA_EVNT_DEVICE_RESET);
17795 			mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, cport)));
17796 			goto event_info;
17797 		}
17798 		/* drive event */
17799 		sdinfo = sata_get_device_info(sata_hba_inst, sata_device);
17800 		if (sdinfo != NULL) {
17801 			if (event & SATA_EVNT_DEVICE_RESET) {
17802 				(void) strlcat(buf1, "device reset, ",
17803 				    SATA_EVENT_MAX_MSG_LENGTH);
17804 				if (sdinfo->satadrv_stats.drive_reset <
17805 				    0xffffffffffffffffULL)
17806 					sdinfo->satadrv_stats.drive_reset++;
17807 				sdinfo->satadrv_event_flags |=
17808 				    SATA_EVNT_DEVICE_RESET;
17809 			}
17810 		}
17811 		if ((event & ~SATA_EVNT_DEVICE_RESET) != 0) {
17812 			/* Invalid event for a device */
17813 			(void) sprintf(buf2, err_msg_evnt_2,
17814 			    event & ~SATA_EVNT_DRIVE_EVENTS);
17815 		}
17816 		mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, cport)));
17817 	} else if (saddr->qual == SATA_ADDR_PMULT) {
17818 		mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, cport)));
17819 
17820 		/* qualify this event */
17821 		if ((event & (SATA_EVNT_DEVICE_RESET |
17822 		    SATA_EVNT_PMULT_LINK_CHANGED)) == 0) {
17823 			/* Invalid event for a port multiplier */
17824 			(void) sprintf(buf2, err_msg_evnt_2,
17825 			    event & SATA_EVNT_DEVICE_RESET);
17826 			mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, cport)));
17827 			goto event_info;
17828 		}
17829 
17830 		pmultinfo = SATA_PMULT_INFO(sata_hba_inst, cport);
17831 
17832 		if (event & SATA_EVNT_DEVICE_RESET) {
17833 
17834 			SATADBG1(SATA_DBG_PMULT, sata_hba_inst,
17835 			    "[Reset] port-mult on cport %d", cport);
17836 			pmultinfo->pmult_event_flags |=
17837 			    SATA_EVNT_DEVICE_RESET;
17838 			(void) strlcat(buf1, "pmult reset, ",
17839 			    SATA_EVENT_MAX_MSG_LENGTH);
17840 		}
17841 
17842 		if (event & SATA_EVNT_PMULT_LINK_CHANGED) {
17843 
17844 			SATADBG1(SATA_DBG_PMULT, sata_hba_inst,
17845 			    "pmult link changed on cport %d", cport);
17846 			pmultinfo->pmult_event_flags |=
17847 			    SATA_EVNT_PMULT_LINK_CHANGED;
17848 			(void) strlcat(buf1, "pmult link changed, ",
17849 			    SATA_EVENT_MAX_MSG_LENGTH);
17850 		}
17851 		mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, cport)));
17852 
17853 	} else {
17854 		if (saddr->qual != SATA_ADDR_NULL) {
17855 			/* Wrong address qualifier */
17856 			SATA_LOG_D((sata_hba_inst, CE_WARN,
17857 			    "sata_hba_event_notify: invalid address 0x%x",
17858 			    *(uint32_t *)saddr));
17859 			return;
17860 		}
17861 		if ((event & SATA_EVNT_CONTROLLER_EVENTS) == 0 ||
17862 		    (event & ~SATA_EVNT_CONTROLLER_EVENTS) != 0) {
17863 			/* Invalid event for the controller */
17864 			SATA_LOG_D((sata_hba_inst, CE_WARN,
17865 			    "sata_hba_event_notify: invalid event 0x%x for "
17866 			    "controller",
17867 			    event & SATA_EVNT_CONTROLLER_EVENTS));
17868 			return;
17869 		}
17870 		buf1[0] = '\0';
17871 		/* This may be a frequent and not interesting event */
17872 		SATADBG1(SATA_DBG_EVENTS, sata_hba_inst,
17873 		    "controller power level changed\n", NULL);
17874 
17875 		mutex_enter(&sata_hba_inst->satahba_mutex);
17876 		if (sata_hba_inst->satahba_stats.ctrl_pwr_change <
17877 		    0xffffffffffffffffULL)
17878 			sata_hba_inst->satahba_stats.ctrl_pwr_change++;
17879 
17880 		sata_hba_inst->satahba_event_flags |=
17881 		    SATA_EVNT_PWR_LEVEL_CHANGED;
17882 		mutex_exit(&sata_hba_inst->satahba_mutex);
17883 	}
17884 	/*
17885 	 * If we got here, there is something to do with this HBA
17886 	 * instance.
17887 	 */
17888 	mutex_enter(&sata_hba_inst->satahba_mutex);
17889 	sata_hba_inst->satahba_event_flags |= SATA_EVNT_MAIN;
17890 	mutex_exit(&sata_hba_inst->satahba_mutex);
17891 	mutex_enter(&sata_mutex);
17892 	sata_event_pending |= SATA_EVNT_MAIN;	/* global event indicator */
17893 	mutex_exit(&sata_mutex);
17894 
17895 	/* Tickle event thread */
17896 	mutex_enter(&sata_event_mutex);
17897 	if (sata_event_thread_active == 0)
17898 		cv_signal(&sata_event_cv);
17899 	mutex_exit(&sata_event_mutex);
17900 
17901 event_info:
17902 	if (buf1[0] != '\0') {
17903 		lcp = strrchr(buf1, ',');
17904 		if (lcp != NULL)
17905 			*lcp = '\0';
17906 	}
17907 	if (saddr->qual == SATA_ADDR_CPORT ||
17908 	    saddr->qual == SATA_ADDR_DCPORT) {
17909 		if (buf1[0] != '\0') {
17910 			sata_log(sata_hba_inst, CE_NOTE, "port %d: %s\n",
17911 			    cport, buf1);
17912 		}
17913 		if (buf2[0] != '\0') {
17914 			sata_log(sata_hba_inst, CE_NOTE, "port %d: %s\n",
17915 			    cport, buf2);
17916 		}
17917 	} else if (saddr->qual == SATA_ADDR_PMPORT ||
17918 	    saddr->qual == SATA_ADDR_DPMPORT) {
17919 		if (buf1[0] != '\0') {
17920 			sata_log(sata_hba_inst, CE_NOTE,
17921 			    "port %d pmport %d: %s\n", cport, pmport, buf1);
17922 		}
17923 		if (buf2[0] != '\0') {
17924 			sata_log(sata_hba_inst, CE_NOTE,
17925 			    "port %d pmport %d: %s\n", cport, pmport, buf2);
17926 		}
17927 	}
17928 }
17929 
17930 
17931 /*
17932  * Event processing thread.
17933  * Arg is a pointer to the sata_hba_list pointer.
17934  * It is not really needed, because sata_hba_list is global and static
17935  */
17936 static void
17937 sata_event_daemon(void *arg)
17938 {
17939 #ifndef __lock_lint
17940 	_NOTE(ARGUNUSED(arg))
17941 #endif
17942 	sata_hba_inst_t *sata_hba_inst;
17943 	clock_t delta;
17944 
17945 	SATADBG1(SATA_DBG_EVENTS_DAEMON, NULL,
17946 	    "SATA event daemon started\n", NULL);
17947 loop:
17948 	/*
17949 	 * Process events here. Walk through all registered HBAs
17950 	 */
17951 	mutex_enter(&sata_mutex);
17952 	for (sata_hba_inst = sata_hba_list; sata_hba_inst != NULL;
17953 	    sata_hba_inst = sata_hba_inst->satahba_next) {
17954 		ASSERT(sata_hba_inst != NULL);
17955 		mutex_enter(&sata_hba_inst->satahba_mutex);
17956 		if (sata_hba_inst->satahba_attached == 0 ||
17957 		    (sata_hba_inst->satahba_event_flags &
17958 		    SATA_EVNT_SKIP) != 0) {
17959 			mutex_exit(&sata_hba_inst->satahba_mutex);
17960 			continue;
17961 		}
17962 		if (sata_hba_inst->satahba_event_flags & SATA_EVNT_MAIN) {
17963 			sata_hba_inst->satahba_event_flags |= SATA_EVNT_SKIP;
17964 			mutex_exit(&sata_hba_inst->satahba_mutex);
17965 			mutex_exit(&sata_mutex);
17966 			/* Got the controller with pending event */
17967 			sata_process_controller_events(sata_hba_inst);
17968 			/*
17969 			 * Since global mutex was released, there is a
17970 			 * possibility that HBA list has changed, so start
17971 			 * over from the top. Just processed controller
17972 			 * will be passed-over because of the SKIP flag.
17973 			 */
17974 			goto loop;
17975 		}
17976 		mutex_exit(&sata_hba_inst->satahba_mutex);
17977 	}
17978 	/* Clear SKIP flag in all controllers */
17979 	for (sata_hba_inst = sata_hba_list; sata_hba_inst != NULL;
17980 	    sata_hba_inst = sata_hba_inst->satahba_next) {
17981 		mutex_enter(&sata_hba_inst->satahba_mutex);
17982 		sata_hba_inst->satahba_event_flags &= ~SATA_EVNT_SKIP;
17983 		mutex_exit(&sata_hba_inst->satahba_mutex);
17984 	}
17985 	mutex_exit(&sata_mutex);
17986 
17987 	SATADBG1(SATA_DBG_EVENTS_DAEMON, NULL,
17988 	    "SATA EVENT DAEMON suspending itself", NULL);
17989 
17990 #ifdef SATA_DEBUG
17991 	if ((sata_func_enable & SATA_ENABLE_PROCESS_EVENTS) == 0) {
17992 		sata_log(sata_hba_inst, CE_WARN,
17993 		    "SATA EVENTS PROCESSING DISABLED\n");
17994 		thread_exit(); /* Daemon will not run again */
17995 	}
17996 #endif
17997 	mutex_enter(&sata_event_mutex);
17998 	sata_event_thread_active = 0;
17999 	mutex_exit(&sata_event_mutex);
18000 	/*
18001 	 * Go to sleep/suspend itself and wake up either because new event or
18002 	 * wait timeout. Exit if there is a termination request (driver
18003 	 * unload).
18004 	 */
18005 	delta = drv_usectohz(SATA_EVNT_DAEMON_SLEEP_TIME);
18006 	do {
18007 		mutex_enter(&sata_event_mutex);
18008 		(void) cv_reltimedwait(&sata_event_cv, &sata_event_mutex,
18009 		    delta, TR_CLOCK_TICK);
18010 
18011 		if (sata_event_thread_active != 0) {
18012 			mutex_exit(&sata_event_mutex);
18013 			continue;
18014 		}
18015 
18016 		/* Check if it is time to go away */
18017 		if (sata_event_thread_terminate == 1) {
18018 			/*
18019 			 * It is up to the thread setting above flag to make
18020 			 * sure that this thread is not killed prematurely.
18021 			 */
18022 			sata_event_thread_terminate = 0;
18023 			sata_event_thread = NULL;
18024 			mutex_exit(&sata_event_mutex);
18025 			SATADBG1(SATA_DBG_EVENTS_DAEMON, NULL,
18026 			    "SATA_EVENT_DAEMON_TERMINATING", NULL);
18027 			thread_exit();  { _NOTE(NOT_REACHED) }
18028 		}
18029 		mutex_exit(&sata_event_mutex);
18030 	} while (!(sata_event_pending & SATA_EVNT_MAIN));
18031 
18032 	mutex_enter(&sata_event_mutex);
18033 	sata_event_thread_active = 1;
18034 	mutex_exit(&sata_event_mutex);
18035 
18036 	mutex_enter(&sata_mutex);
18037 	sata_event_pending &= ~SATA_EVNT_MAIN;
18038 	mutex_exit(&sata_mutex);
18039 
18040 	SATADBG1(SATA_DBG_EVENTS_DAEMON, NULL,
18041 	    "SATA EVENT DAEMON READY TO PROCESS EVENT", NULL);
18042 
18043 	goto loop;
18044 }
18045 
18046 /*
18047  * Specific HBA instance event processing.
18048  *
18049  * NOTE: At the moment, device event processing is limited to hard disks
18050  * only.
18051  * Port multiplier is supported now.
18052  */
18053 static void
18054 sata_process_controller_events(sata_hba_inst_t *sata_hba_inst)
18055 {
18056 	int ncport;
18057 	uint32_t event_flags;
18058 	sata_address_t *saddr;
18059 	sata_cport_info_t *cportinfo;
18060 	sata_pmult_info_t *pmultinfo;
18061 
18062 	SATADBG1(SATA_DBG_EVENTS_CNTRL, sata_hba_inst,
18063 	    "Processing controller %d event(s)",
18064 	    ddi_get_instance(SATA_DIP(sata_hba_inst)));
18065 
18066 	mutex_enter(&sata_hba_inst->satahba_mutex);
18067 	sata_hba_inst->satahba_event_flags &= ~SATA_EVNT_MAIN;
18068 	event_flags = sata_hba_inst->satahba_event_flags;
18069 	mutex_exit(&sata_hba_inst->satahba_mutex);
18070 	/*
18071 	 * Process controller power change first
18072 	 * HERE
18073 	 */
18074 	if (event_flags & SATA_EVNT_PWR_LEVEL_CHANGED)
18075 		sata_process_cntrl_pwr_level_change(sata_hba_inst);
18076 
18077 	/*
18078 	 * Search through ports/devices to identify affected port/device.
18079 	 * We may have to process events for more than one port/device.
18080 	 */
18081 	for (ncport = 0; ncport < SATA_NUM_CPORTS(sata_hba_inst); ncport++) {
18082 		/*
18083 		 * Not all ports may be processed in attach by the time we
18084 		 * get an event. Check if port info is initialized.
18085 		 */
18086 		mutex_enter(&sata_hba_inst->satahba_mutex);
18087 		cportinfo = SATA_CPORT_INFO(sata_hba_inst, ncport);
18088 		mutex_exit(&sata_hba_inst->satahba_mutex);
18089 		if (cportinfo == NULL || cportinfo->cport_state == NULL)
18090 			continue;
18091 
18092 		/* We have initialized controller port info */
18093 		mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, ncport)));
18094 		event_flags = (SATA_CPORT_INFO(sata_hba_inst, ncport))->
18095 		    cport_event_flags;
18096 		/* Check if port was locked by IOCTL processing */
18097 		if (event_flags & SATA_APCTL_LOCK_PORT_BUSY) {
18098 			/*
18099 			 * We ignore port events because port is busy
18100 			 * with AP control processing. Set again
18101 			 * controller and main event flag, so that
18102 			 * events may be processed by the next daemon
18103 			 * run.
18104 			 */
18105 			mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, ncport)));
18106 			mutex_enter(&sata_hba_inst->satahba_mutex);
18107 			sata_hba_inst->satahba_event_flags |= SATA_EVNT_MAIN;
18108 			mutex_exit(&sata_hba_inst->satahba_mutex);
18109 			mutex_enter(&sata_mutex);
18110 			sata_event_pending |= SATA_EVNT_MAIN;
18111 			mutex_exit(&sata_mutex);
18112 			SATADBG1(SATA_DBG_EVENTS_PROCPST, sata_hba_inst,
18113 			    "Event processing postponed until "
18114 			    "AP control processing completes",
18115 			    NULL);
18116 			/* Check other ports */
18117 			continue;
18118 		} else {
18119 			/*
18120 			 * Set BSY flag so that AP control would not
18121 			 * interfere with events processing for
18122 			 * this port.
18123 			 */
18124 			(SATA_CPORT_INFO(sata_hba_inst, ncport))->
18125 			    cport_event_flags |= SATA_EVNT_LOCK_PORT_BUSY;
18126 		}
18127 		mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, ncport)));
18128 
18129 		saddr = &(SATA_CPORT_INFO(sata_hba_inst, ncport))->cport_addr;
18130 
18131 		if ((event_flags &
18132 		    (SATA_EVNT_PORT_EVENTS | SATA_EVNT_DRIVE_EVENTS)) != 0) {
18133 			/*
18134 			 * Got port event.
18135 			 * We need some hierarchy of event processing as they
18136 			 * are affecting each other:
18137 			 * 1. port failed
18138 			 * 2. device detached/attached
18139 			 * 3. link events - link events may trigger device
18140 			 *    detached or device attached events in some
18141 			 *    circumstances.
18142 			 * 4. port power level changed
18143 			 */
18144 			if (event_flags & SATA_EVNT_PORT_FAILED) {
18145 				sata_process_port_failed_event(sata_hba_inst,
18146 				    saddr);
18147 			}
18148 			if (event_flags & SATA_EVNT_DEVICE_DETACHED) {
18149 				sata_process_device_detached(sata_hba_inst,
18150 				    saddr);
18151 			}
18152 			if (event_flags & SATA_EVNT_DEVICE_ATTACHED) {
18153 				sata_process_device_attached(sata_hba_inst,
18154 				    saddr);
18155 			}
18156 			if (event_flags &
18157 			    (SATA_EVNT_LINK_ESTABLISHED |
18158 			    SATA_EVNT_LINK_LOST)) {
18159 				sata_process_port_link_events(sata_hba_inst,
18160 				    saddr);
18161 			}
18162 			if (event_flags & SATA_EVNT_PWR_LEVEL_CHANGED) {
18163 				sata_process_port_pwr_change(sata_hba_inst,
18164 				    saddr);
18165 			}
18166 			if (event_flags & SATA_EVNT_TARGET_NODE_CLEANUP) {
18167 				sata_process_target_node_cleanup(
18168 				    sata_hba_inst, saddr);
18169 			}
18170 			if (event_flags & SATA_EVNT_AUTOONLINE_DEVICE) {
18171 				sata_process_device_autoonline(
18172 				    sata_hba_inst, saddr);
18173 			}
18174 		}
18175 
18176 
18177 		/*
18178 		 * Scan port multiplier and all its sub-ports event flags.
18179 		 * The events are marked by
18180 		 * (1) sata_pmult_info.pmult_event_flags
18181 		 * (2) sata_pmport_info.pmport_event_flags
18182 		 */
18183 		mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, ncport)));
18184 		if (cportinfo->cport_dev_type == SATA_DTYPE_PMULT) {
18185 			/*
18186 			 * There should be another extra check: this
18187 			 * port multiplier still exists?
18188 			 */
18189 			pmultinfo = SATA_PMULT_INFO(sata_hba_inst,
18190 			    ncport);
18191 
18192 			if (pmultinfo != NULL) {
18193 				mutex_exit(&(SATA_CPORT_MUTEX(
18194 				    sata_hba_inst, ncport)));
18195 				sata_process_pmult_events(
18196 				    sata_hba_inst, ncport);
18197 				mutex_enter(&(SATA_CPORT_MUTEX(
18198 				    sata_hba_inst, ncport)));
18199 			} else {
18200 				SATADBG1(SATA_DBG_PMULT, sata_hba_inst,
18201 				    "Port-multiplier is gone. "
18202 				    "Ignore all sub-device events "
18203 				    "at port %d.", ncport);
18204 			}
18205 		}
18206 
18207 		if ((SATA_CPORT_DEV_TYPE(sata_hba_inst, ncport) !=
18208 		    SATA_DTYPE_NONE) &&
18209 		    (SATA_CPORT_DRV_INFO(sata_hba_inst, ncport) != NULL)) {
18210 			if (SATA_CPORT_DRV_INFO(sata_hba_inst, ncport)->
18211 			    satadrv_event_flags &
18212 			    (SATA_EVNT_DEVICE_RESET |
18213 			    SATA_EVNT_INPROC_DEVICE_RESET)) {
18214 				/* Have device event */
18215 				sata_process_device_reset(sata_hba_inst,
18216 				    saddr);
18217 			}
18218 		}
18219 		/* Release PORT_BUSY flag */
18220 		(SATA_CPORT_INFO(sata_hba_inst, ncport))->
18221 		    cport_event_flags &= ~SATA_EVNT_LOCK_PORT_BUSY;
18222 		mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, ncport)));
18223 
18224 	} /* End of loop through the controller SATA ports */
18225 }
18226 
18227 /*
18228  * Specific port multiplier instance event processing. At the moment, device
18229  * event processing is limited to link/attach event only.
18230  *
18231  * NOTE: power management event is not supported yet.
18232  */
18233 static void
18234 sata_process_pmult_events(sata_hba_inst_t *sata_hba_inst, uint8_t cport)
18235 {
18236 	sata_cport_info_t *cportinfo = SATA_CPORT_INFO(sata_hba_inst, cport);
18237 	sata_pmult_info_t *pmultinfo;
18238 	sata_pmport_info_t *pmportinfo;
18239 	sata_address_t *saddr;
18240 	sata_device_t sata_device;
18241 	uint32_t event_flags;
18242 	int npmport;
18243 	int rval;
18244 
18245 	SATADBG2(SATA_DBG_EVENTS_CNTRL|SATA_DBG_PMULT, sata_hba_inst,
18246 	    "Processing pmult event(s) on cport %d of controller %d",
18247 	    cport, ddi_get_instance(SATA_DIP(sata_hba_inst)));
18248 
18249 	/* First process events on port multiplier */
18250 	mutex_enter(&cportinfo->cport_mutex);
18251 	pmultinfo = SATA_PMULT_INFO(sata_hba_inst, cport);
18252 	event_flags = pmultinfo->pmult_event_flags;
18253 
18254 	/*
18255 	 * Reset event (of port multiplier) has higher priority because the
18256 	 * port multiplier itself might be failed or removed after reset.
18257 	 */
18258 	if (event_flags & SATA_EVNT_DEVICE_RESET) {
18259 		/*
18260 		 * The status of the sub-links are uncertain,
18261 		 * so mark all sub-ports as RESET
18262 		 */
18263 		for (npmport = 0; npmport < SATA_NUM_PMPORTS(
18264 		    sata_hba_inst, cport); npmport ++) {
18265 			pmportinfo = SATA_PMPORT_INFO(sata_hba_inst,
18266 			    cport, npmport);
18267 			if (pmportinfo == NULL) {
18268 				/* That's weird. */
18269 				SATA_LOG_D((sata_hba_inst, CE_WARN,
18270 				    "sata_hba_event_notify: "
18271 				    "invalid/un-implemented "
18272 				    "port %d:%d (%d ports), ",
18273 				    cport, npmport, SATA_NUM_PMPORTS(
18274 				    sata_hba_inst, cport)));
18275 				continue;
18276 			}
18277 
18278 			mutex_enter(&pmportinfo->pmport_mutex);
18279 
18280 			/* Mark all pmport to unknow state. */
18281 			pmportinfo->pmport_state = SATA_STATE_UNKNOWN;
18282 			/* Mark all pmports with link events. */
18283 			pmportinfo->pmport_event_flags =
18284 			    (SATA_EVNT_LINK_ESTABLISHED|SATA_EVNT_LINK_LOST);
18285 			mutex_exit(&pmportinfo->pmport_mutex);
18286 		}
18287 
18288 	} else if (event_flags & SATA_EVNT_PMULT_LINK_CHANGED) {
18289 		/*
18290 		 * We need probe the port multiplier to know what has
18291 		 * happened.
18292 		 */
18293 		bzero(&sata_device, sizeof (sata_device_t));
18294 		sata_device.satadev_rev = SATA_DEVICE_REV;
18295 		sata_device.satadev_addr.cport = cport;
18296 		sata_device.satadev_addr.pmport = SATA_PMULT_HOSTPORT;
18297 		sata_device.satadev_addr.qual = SATA_ADDR_PMULT;
18298 
18299 		mutex_exit(&cportinfo->cport_mutex);
18300 		rval = (*SATA_PROBE_PORT_FUNC(sata_hba_inst))
18301 		    (SATA_DIP(sata_hba_inst), &sata_device);
18302 		mutex_enter(&cportinfo->cport_mutex);
18303 		if (rval != SATA_SUCCESS) {
18304 			/* Something went wrong? Fail the port */
18305 			cportinfo->cport_state = SATA_PSTATE_FAILED;
18306 			mutex_exit(&cportinfo->cport_mutex);
18307 			SATA_LOG_D((sata_hba_inst, CE_WARN,
18308 			    "SATA port %d probing failed", cport));
18309 
18310 			/* PMult structure must be released.  */
18311 			sata_free_pmult(sata_hba_inst, &sata_device);
18312 			return;
18313 		}
18314 
18315 		sata_update_port_info(sata_hba_inst, &sata_device);
18316 
18317 		/*
18318 		 * Sanity check - Port is active? Is the link active?
18319 		 * The device is still a port multiplier?
18320 		 */
18321 		if ((cportinfo->cport_state &
18322 		    (SATA_PSTATE_SHUTDOWN | SATA_PSTATE_FAILED)) ||
18323 		    ((cportinfo->cport_scr.sstatus &
18324 		    SATA_PORT_DEVLINK_UP_MASK) != SATA_PORT_DEVLINK_UP) ||
18325 		    (cportinfo->cport_dev_type != SATA_DTYPE_PMULT)) {
18326 			mutex_exit(&cportinfo->cport_mutex);
18327 
18328 			/* PMult structure must be released.  */
18329 			sata_free_pmult(sata_hba_inst, &sata_device);
18330 			return;
18331 		}
18332 
18333 		/* Probed succeed, set port ready. */
18334 		cportinfo->cport_state |=
18335 		    SATA_STATE_PROBED | SATA_STATE_READY;
18336 	}
18337 
18338 	/* Release port multiplier event flags. */
18339 	pmultinfo->pmult_event_flags &=
18340 	    ~(SATA_EVNT_DEVICE_RESET|SATA_EVNT_PMULT_LINK_CHANGED);
18341 	mutex_exit(&cportinfo->cport_mutex);
18342 
18343 	/*
18344 	 * Check all sub-links.
18345 	 */
18346 	for (npmport = 0; npmport < SATA_NUM_PMPORTS(sata_hba_inst, cport);
18347 	    npmport ++) {
18348 		pmportinfo = SATA_PMPORT_INFO(sata_hba_inst, cport, npmport);
18349 		mutex_enter(&pmportinfo->pmport_mutex);
18350 		event_flags = pmportinfo->pmport_event_flags;
18351 		mutex_exit(&pmportinfo->pmport_mutex);
18352 		saddr = &pmportinfo->pmport_addr;
18353 
18354 		if ((event_flags &
18355 		    (SATA_EVNT_PORT_EVENTS | SATA_EVNT_DRIVE_EVENTS)) != 0) {
18356 			/*
18357 			 * Got port multiplier port event.
18358 			 * We need some hierarchy of event processing as they
18359 			 * are affecting each other:
18360 			 * 1. device detached/attached
18361 			 * 2. link events - link events may trigger device
18362 			 *    detached or device attached events in some
18363 			 *    circumstances.
18364 			 */
18365 			if (event_flags & SATA_EVNT_DEVICE_DETACHED) {
18366 				sata_process_pmdevice_detached(sata_hba_inst,
18367 				    saddr);
18368 			}
18369 			if (event_flags & SATA_EVNT_DEVICE_ATTACHED) {
18370 				sata_process_pmdevice_attached(sata_hba_inst,
18371 				    saddr);
18372 			}
18373 			if (event_flags & SATA_EVNT_LINK_ESTABLISHED ||
18374 			    event_flags & SATA_EVNT_LINK_LOST) {
18375 				sata_process_pmport_link_events(sata_hba_inst,
18376 				    saddr);
18377 			}
18378 			if (event_flags & SATA_EVNT_TARGET_NODE_CLEANUP) {
18379 				sata_process_target_node_cleanup(
18380 				    sata_hba_inst, saddr);
18381 			}
18382 		}
18383 
18384 		/* Checking drive event(s). */
18385 		mutex_enter(&pmportinfo->pmport_mutex);
18386 		if (pmportinfo->pmport_dev_type != SATA_DTYPE_NONE &&
18387 		    pmportinfo->pmport_sata_drive != NULL) {
18388 			event_flags = pmportinfo->pmport_sata_drive->
18389 			    satadrv_event_flags;
18390 			if (event_flags & (SATA_EVNT_DEVICE_RESET |
18391 			    SATA_EVNT_INPROC_DEVICE_RESET)) {
18392 
18393 				/* Have device event */
18394 				sata_process_pmdevice_reset(sata_hba_inst,
18395 				    saddr);
18396 			}
18397 		}
18398 		mutex_exit(&pmportinfo->pmport_mutex);
18399 
18400 		/* Release PORT_BUSY flag */
18401 		mutex_enter(&cportinfo->cport_mutex);
18402 		cportinfo->cport_event_flags &= ~SATA_EVNT_LOCK_PORT_BUSY;
18403 		mutex_exit(&cportinfo->cport_mutex);
18404 	}
18405 
18406 	SATADBG2(SATA_DBG_EVENTS_CNTRL|SATA_DBG_PMULT, sata_hba_inst,
18407 	    "[DONE] pmult event(s) on cport %d of controller %d",
18408 	    cport, ddi_get_instance(SATA_DIP(sata_hba_inst)));
18409 }
18410 
18411 /*
18412  * Process HBA power level change reported by HBA driver.
18413  * Not implemented at this time - event is ignored.
18414  */
18415 static void
18416 sata_process_cntrl_pwr_level_change(sata_hba_inst_t *sata_hba_inst)
18417 {
18418 	SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst,
18419 	    "Processing controller power level change", NULL);
18420 
18421 	/* Ignoring it for now */
18422 	mutex_enter(&sata_hba_inst->satahba_mutex);
18423 	sata_hba_inst->satahba_event_flags &= ~SATA_EVNT_PWR_LEVEL_CHANGED;
18424 	mutex_exit(&sata_hba_inst->satahba_mutex);
18425 }
18426 
18427 /*
18428  * Process port power level change reported by HBA driver.
18429  * Not implemented at this time - event is ignored.
18430  */
18431 static void
18432 sata_process_port_pwr_change(sata_hba_inst_t *sata_hba_inst,
18433     sata_address_t *saddr)
18434 {
18435 	sata_cport_info_t *cportinfo;
18436 
18437 	SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst,
18438 	    "Processing port power level change", NULL);
18439 
18440 	cportinfo = SATA_CPORT_INFO(sata_hba_inst, saddr->cport);
18441 	mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex);
18442 	/* Reset event flag */
18443 	cportinfo->cport_event_flags &= ~SATA_EVNT_PWR_LEVEL_CHANGED;
18444 	mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex);
18445 }
18446 
18447 /*
18448  * Process port failure reported by HBA driver.
18449  * cports support only - no pmports.
18450  */
18451 static void
18452 sata_process_port_failed_event(sata_hba_inst_t *sata_hba_inst,
18453     sata_address_t *saddr)
18454 {
18455 	sata_cport_info_t *cportinfo;
18456 
18457 	cportinfo = SATA_CPORT_INFO(sata_hba_inst, saddr->cport);
18458 	mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex);
18459 	/* Reset event flag first */
18460 	cportinfo->cport_event_flags &= ~SATA_EVNT_PORT_FAILED;
18461 	/* If the port is in SHUTDOWN or FAILED state, ignore this event. */
18462 	if ((cportinfo->cport_state &
18463 	    (SATA_PSTATE_SHUTDOWN | SATA_PSTATE_FAILED)) == 0) {
18464 		mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->
18465 		    cport_mutex);
18466 		return;
18467 	}
18468 	/* Fail the port */
18469 	cportinfo->cport_state = SATA_PSTATE_FAILED;
18470 	mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex);
18471 	sata_log(sata_hba_inst, CE_WARN, "SATA port %d failed", saddr->cport);
18472 }
18473 
18474 /*
18475  * Device Reset Event processing.
18476  * The sequence is managed by 3 stage flags:
18477  * - reset event reported,
18478  * - reset event being processed,
18479  * - request to clear device reset state.
18480  *
18481  * NOTE: This function has to be entered with cport mutex held. It exits with
18482  * mutex held as well, but can release mutex during the processing.
18483  */
18484 static void
18485 sata_process_device_reset(sata_hba_inst_t *sata_hba_inst,
18486     sata_address_t *saddr)
18487 {
18488 	sata_drive_info_t old_sdinfo; /* local copy of the drive info */
18489 	sata_drive_info_t *sdinfo;
18490 	sata_cport_info_t *cportinfo;
18491 	sata_device_t sata_device;
18492 	int rval_probe, rval_set;
18493 
18494 	/* We only care about host sata cport for now */
18495 	cportinfo = SATA_CPORT_INFO(sata_hba_inst, saddr->cport);
18496 	sdinfo = SATA_CPORT_DRV_INFO(sata_hba_inst, saddr->cport);
18497 	/*
18498 	 * If the port is in SHUTDOWN or FAILED state, or device is in FAILED
18499 	 * state, ignore reset event.
18500 	 */
18501 	if (((cportinfo->cport_state &
18502 	    (SATA_PSTATE_SHUTDOWN | SATA_PSTATE_FAILED)) != 0) ||
18503 	    (sdinfo->satadrv_state & SATA_DSTATE_FAILED) != 0) {
18504 		sdinfo->satadrv_event_flags &=
18505 		    ~(SATA_EVNT_DEVICE_RESET | SATA_EVNT_INPROC_DEVICE_RESET);
18506 		return;
18507 	}
18508 
18509 	if ((SATA_CPORT_DEV_TYPE(sata_hba_inst, saddr->cport) ==
18510 	    SATA_DTYPE_PMULT)) {
18511 		/*
18512 		 * Should not happened: this is already handled in
18513 		 * sata_hba_event_notify()
18514 		 */
18515 		mutex_exit(&cportinfo->cport_mutex);
18516 		goto done;
18517 	}
18518 
18519 	if ((SATA_CPORT_DEV_TYPE(sata_hba_inst, saddr->cport) &
18520 	    SATA_VALID_DEV_TYPE) == 0) {
18521 		/*
18522 		 * This should not happen - coding error.
18523 		 * But we can recover, so do not panic, just clean up
18524 		 * and if in debug mode, log the message.
18525 		 */
18526 #ifdef SATA_DEBUG
18527 		sata_log(sata_hba_inst, CE_WARN,
18528 		    "sata_process_device_reset: "
18529 		    "Invalid device type with sdinfo!", NULL);
18530 #endif
18531 		sdinfo->satadrv_event_flags = 0;
18532 		return;
18533 	}
18534 
18535 #ifdef SATA_DEBUG
18536 	if ((sdinfo->satadrv_event_flags &
18537 	    (SATA_EVNT_DEVICE_RESET | SATA_EVNT_INPROC_DEVICE_RESET)) == 0) {
18538 		/* Nothing to do */
18539 		/* Something is weird - why we are processing dev reset? */
18540 		SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst,
18541 		    "No device reset event!!!!", NULL);
18542 
18543 		return;
18544 	}
18545 	if ((sdinfo->satadrv_event_flags &
18546 	    (SATA_EVNT_DEVICE_RESET | SATA_EVNT_INPROC_DEVICE_RESET)) ==
18547 	    (SATA_EVNT_DEVICE_RESET | SATA_EVNT_INPROC_DEVICE_RESET)) {
18548 		/* Something is weird - new device reset event */
18549 		SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst,
18550 		    "Overlapping device reset events!", NULL);
18551 	}
18552 #endif
18553 	SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst,
18554 	    "Processing port %d device reset", saddr->cport);
18555 
18556 	/* Clear event flag */
18557 	sdinfo->satadrv_event_flags &= ~SATA_EVNT_DEVICE_RESET;
18558 
18559 	/* It seems that we always need to check the port state first */
18560 	sata_device.satadev_rev = SATA_DEVICE_REV;
18561 	sata_device.satadev_addr = *saddr;
18562 	/*
18563 	 * We have to exit mutex, because the HBA probe port function may
18564 	 * block on its own mutex.
18565 	 */
18566 	mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex);
18567 	rval_probe = (*SATA_PROBE_PORT_FUNC(sata_hba_inst))
18568 	    (SATA_DIP(sata_hba_inst), &sata_device);
18569 	mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex);
18570 	sata_update_port_info(sata_hba_inst, &sata_device);
18571 	if (rval_probe != SATA_SUCCESS) {
18572 		/* Something went wrong? Fail the port */
18573 		cportinfo->cport_state = SATA_PSTATE_FAILED;
18574 		sdinfo = SATA_CPORT_DRV_INFO(sata_hba_inst, saddr->cport);
18575 		if (sdinfo != NULL)
18576 			sdinfo->satadrv_event_flags = 0;
18577 		mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->
18578 		    cport_mutex);
18579 		SATA_LOG_D((sata_hba_inst, CE_WARN,
18580 		    "SATA port %d probing failed",
18581 		    saddr->cport));
18582 		mutex_enter(&SATA_CPORT_INFO(sata_hba_inst,
18583 		    saddr->cport)->cport_mutex);
18584 		return;
18585 	}
18586 	if ((sata_device.satadev_scr.sstatus  &
18587 	    SATA_PORT_DEVLINK_UP_MASK) !=
18588 	    SATA_PORT_DEVLINK_UP ||
18589 	    sata_device.satadev_type == SATA_DTYPE_NONE) {
18590 		/*
18591 		 * No device to process, anymore. Some other event processing
18592 		 * would or have already performed port info cleanup.
18593 		 * To be safe (HBA may need it), request clearing device
18594 		 * reset condition.
18595 		 */
18596 		sdinfo = SATA_CPORT_DRV_INFO(sata_hba_inst, saddr->cport);
18597 		if (sdinfo != NULL) {
18598 			sdinfo->satadrv_event_flags &=
18599 			    ~SATA_EVNT_INPROC_DEVICE_RESET;
18600 			sdinfo->satadrv_event_flags |=
18601 			    SATA_EVNT_CLEAR_DEVICE_RESET;
18602 		}
18603 		return;
18604 	}
18605 
18606 	sdinfo = SATA_CPORT_DRV_INFO(sata_hba_inst, saddr->cport);
18607 	if (sdinfo == NULL) {
18608 		return;
18609 	}
18610 	if ((sdinfo->satadrv_event_flags &
18611 	    SATA_EVNT_INPROC_DEVICE_RESET) == 0) {
18612 		/*
18613 		 * Start tracking time for device feature restoration and
18614 		 * identification. Save current time (lbolt value).
18615 		 */
18616 		sdinfo->satadrv_reset_time = ddi_get_lbolt();
18617 	}
18618 	/* Mark device reset processing as active */
18619 	sdinfo->satadrv_event_flags |= SATA_EVNT_INPROC_DEVICE_RESET;
18620 
18621 	old_sdinfo = *sdinfo;	/* local copy of the drive info */
18622 	mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex);
18623 
18624 	rval_set = sata_set_drive_features(sata_hba_inst, &old_sdinfo, 1);
18625 
18626 	if (rval_set  != SATA_SUCCESS) {
18627 		/*
18628 		 * Restoring drive setting failed.
18629 		 * Probe the port first, to check if the port state has changed
18630 		 */
18631 		sata_device.satadev_rev = SATA_DEVICE_REV;
18632 		sata_device.satadev_addr = *saddr;
18633 		sata_device.satadev_addr.qual = SATA_ADDR_CPORT;
18634 		/* probe port */
18635 		rval_probe = (*SATA_PROBE_PORT_FUNC(sata_hba_inst))
18636 		    (SATA_DIP(sata_hba_inst), &sata_device);
18637 		mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->
18638 		    cport_mutex);
18639 		if (rval_probe == SATA_SUCCESS &&
18640 		    (sata_device.satadev_state &
18641 		    (SATA_PSTATE_SHUTDOWN | SATA_PSTATE_FAILED)) == 0 &&
18642 		    (sata_device.satadev_scr.sstatus  &
18643 		    SATA_PORT_DEVLINK_UP_MASK) == SATA_PORT_DEVLINK_UP &&
18644 		    sata_device.satadev_type != SATA_DTYPE_NONE) {
18645 			/*
18646 			 * We may retry this a bit later - in-process reset
18647 			 * condition should be already set.
18648 			 * Track retry time for device identification.
18649 			 */
18650 			if ((cportinfo->cport_dev_type &
18651 			    SATA_VALID_DEV_TYPE) != 0 &&
18652 			    SATA_CPORTINFO_DRV_INFO(cportinfo) != NULL &&
18653 			    sdinfo->satadrv_reset_time != 0) {
18654 				clock_t cur_time = ddi_get_lbolt();
18655 				/*
18656 				 * If the retry time limit was not
18657 				 * exceeded, retry.
18658 				 */
18659 				if ((cur_time - sdinfo->satadrv_reset_time) <
18660 				    drv_usectohz(SATA_DEV_REPROBE_TIMEOUT)) {
18661 					mutex_enter(
18662 					    &sata_hba_inst->satahba_mutex);
18663 					sata_hba_inst->satahba_event_flags |=
18664 					    SATA_EVNT_MAIN;
18665 					mutex_exit(
18666 					    &sata_hba_inst->satahba_mutex);
18667 					mutex_enter(&sata_mutex);
18668 					sata_event_pending |= SATA_EVNT_MAIN;
18669 					mutex_exit(&sata_mutex);
18670 					return;
18671 				}
18672 				if (rval_set == SATA_RETRY) {
18673 					/*
18674 					 * Setting drive features failed, but
18675 					 * the drive is still accessible,
18676 					 * so emit a warning message before
18677 					 * return.
18678 					 */
18679 					mutex_exit(&SATA_CPORT_INFO(
18680 					    sata_hba_inst,
18681 					    saddr->cport)->cport_mutex);
18682 					goto done;
18683 				}
18684 			}
18685 			/* Fail the drive */
18686 			sdinfo->satadrv_state = SATA_DSTATE_FAILED;
18687 
18688 			sata_log(sata_hba_inst, CE_WARN,
18689 			    "SATA device at port %d - device failed",
18690 			    saddr->cport);
18691 
18692 			DTRACE_PROBE(port_failed_f);
18693 		}
18694 		/*
18695 		 * No point of retrying - device failed or some other event
18696 		 * processing or already did or will do port info cleanup.
18697 		 * To be safe (HBA may need it),
18698 		 * request clearing device reset condition.
18699 		 */
18700 		sdinfo->satadrv_event_flags |= SATA_EVNT_CLEAR_DEVICE_RESET;
18701 		sdinfo->satadrv_event_flags &= ~SATA_EVNT_INPROC_DEVICE_RESET;
18702 		sdinfo->satadrv_reset_time = 0;
18703 		return;
18704 	}
18705 done:
18706 	/*
18707 	 * If setting of drive features failed, but the drive is still
18708 	 * accessible, emit a warning message.
18709 	 */
18710 	if (rval_set == SATA_RETRY) {
18711 		sata_log(sata_hba_inst, CE_WARN,
18712 		    "SATA device at port %d - desired setting could not be "
18713 		    "restored after reset. Device may not operate as expected.",
18714 		    saddr->cport);
18715 	}
18716 	/*
18717 	 * Raise the flag indicating that the next sata command could
18718 	 * be sent with SATA_CLEAR_DEV_RESET_STATE flag, if no new device
18719 	 * reset is reported.
18720 	 */
18721 	mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex);
18722 	if (SATA_CPORTINFO_DRV_INFO(cportinfo) != NULL) {
18723 		sdinfo->satadrv_reset_time = 0;
18724 		if ((cportinfo->cport_dev_type & SATA_VALID_DEV_TYPE) != 0) {
18725 			sdinfo = SATA_CPORTINFO_DRV_INFO(cportinfo);
18726 			sdinfo->satadrv_event_flags &=
18727 			    ~SATA_EVNT_INPROC_DEVICE_RESET;
18728 			sdinfo->satadrv_event_flags |=
18729 			    SATA_EVNT_CLEAR_DEVICE_RESET;
18730 		}
18731 	}
18732 }
18733 
18734 
18735 /*
18736  * Port Multiplier Port Device Reset Event processing.
18737  *
18738  * NOTE: This function has to be entered with pmport mutex held. It exits with
18739  * mutex held as well, but can release mutex during the processing.
18740  */
18741 static void
18742 sata_process_pmdevice_reset(sata_hba_inst_t *sata_hba_inst,
18743     sata_address_t *saddr)
18744 {
18745 	sata_drive_info_t old_sdinfo; /* local copy of the drive info */
18746 	sata_drive_info_t *sdinfo = NULL;
18747 	sata_cport_info_t *cportinfo = NULL;
18748 	sata_pmport_info_t *pmportinfo = NULL;
18749 	sata_pmult_info_t *pminfo = NULL;
18750 	sata_device_t sata_device;
18751 	uint8_t cport = saddr->cport;
18752 	uint8_t pmport = saddr->pmport;
18753 	int rval;
18754 
18755 	SATADBG2(SATA_DBG_EVENTS_PROC, sata_hba_inst,
18756 	    "Processing drive reset at port %d:%d", cport, pmport);
18757 
18758 	cportinfo = SATA_CPORT_INFO(sata_hba_inst, cport);
18759 	pmportinfo = SATA_PMPORT_INFO(sata_hba_inst, cport, pmport);
18760 	sdinfo = SATA_PMPORT_DRV_INFO(sata_hba_inst, cport, pmport);
18761 
18762 	/*
18763 	 * If the port is in SHUTDOWN or FAILED state, or device is in FAILED
18764 	 * state, ignore reset event.
18765 	 */
18766 	if (((cportinfo->cport_state &
18767 	    (SATA_PSTATE_SHUTDOWN | SATA_PSTATE_FAILED)) != 0) ||
18768 	    (sdinfo->satadrv_state & SATA_DSTATE_FAILED) != 0) {
18769 		sdinfo->satadrv_event_flags &=
18770 		    ~(SATA_EVNT_DEVICE_RESET | SATA_EVNT_INPROC_DEVICE_RESET);
18771 		return;
18772 	}
18773 
18774 	if ((pmportinfo->pmport_dev_type & SATA_VALID_DEV_TYPE) == 0) {
18775 		/*
18776 		 * This should not happen - coding error.
18777 		 * But we can recover, so do not panic, just clean up
18778 		 * and if in debug mode, log the message.
18779 		 */
18780 #ifdef SATA_DEBUG
18781 		sata_log(sata_hba_inst, CE_WARN,
18782 		    "sata_process_pmdevice_reset: "
18783 		    "Invalid device type with sdinfo!", NULL);
18784 #endif
18785 		sdinfo->satadrv_event_flags = 0;
18786 		return;
18787 	}
18788 
18789 #ifdef SATA_DEBUG
18790 	if ((sdinfo->satadrv_event_flags &
18791 	    (SATA_EVNT_DEVICE_RESET | SATA_EVNT_INPROC_DEVICE_RESET)) == 0) {
18792 		/* Nothing to do */
18793 		/* Something is weird - why we are processing dev reset? */
18794 		SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst,
18795 		    "No device reset event!!!!", NULL);
18796 
18797 		return;
18798 	}
18799 	if ((sdinfo->satadrv_event_flags &
18800 	    (SATA_EVNT_DEVICE_RESET | SATA_EVNT_INPROC_DEVICE_RESET)) ==
18801 	    (SATA_EVNT_DEVICE_RESET | SATA_EVNT_INPROC_DEVICE_RESET)) {
18802 		/* Something is weird - new device reset event */
18803 		SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst,
18804 		    "Overlapping device reset events!", NULL);
18805 	}
18806 #endif
18807 	SATADBG2(SATA_DBG_EVENTS_PROC, sata_hba_inst,
18808 	    "Processing port %d:%d device reset", cport, pmport);
18809 
18810 	/* Clear event flag */
18811 	sdinfo->satadrv_event_flags &= ~SATA_EVNT_DEVICE_RESET;
18812 
18813 	/* It seems that we always need to check the port state first */
18814 	sata_device.satadev_rev = SATA_DEVICE_REV;
18815 	sata_device.satadev_addr = *saddr;
18816 	/*
18817 	 * We have to exit mutex, because the HBA probe port function may
18818 	 * block on its own mutex.
18819 	 */
18820 	mutex_exit(&pmportinfo->pmport_mutex);
18821 	rval = (*SATA_PROBE_PORT_FUNC(sata_hba_inst))
18822 	    (SATA_DIP(sata_hba_inst), &sata_device);
18823 	mutex_enter(&pmportinfo->pmport_mutex);
18824 
18825 	sata_update_pmport_info(sata_hba_inst, &sata_device);
18826 	if (rval != SATA_SUCCESS) {
18827 		/* Something went wrong? Fail the port */
18828 		pmportinfo->pmport_state = SATA_PSTATE_FAILED;
18829 		sdinfo = SATA_PMPORT_DRV_INFO(sata_hba_inst, saddr->cport,
18830 		    saddr->pmport);
18831 		if (sdinfo != NULL)
18832 			sdinfo->satadrv_event_flags = 0;
18833 		mutex_exit(&pmportinfo->pmport_mutex);
18834 		SATA_LOG_D((sata_hba_inst, CE_WARN,
18835 		    "SATA port %d:%d probing failed",
18836 		    saddr->cport, saddr->pmport));
18837 		mutex_enter(&pmportinfo->pmport_mutex);
18838 		return;
18839 	}
18840 	if ((sata_device.satadev_scr.sstatus  &
18841 	    SATA_PORT_DEVLINK_UP_MASK) !=
18842 	    SATA_PORT_DEVLINK_UP ||
18843 	    sata_device.satadev_type == SATA_DTYPE_NONE) {
18844 		/*
18845 		 * No device to process, anymore. Some other event processing
18846 		 * would or have already performed port info cleanup.
18847 		 * To be safe (HBA may need it), request clearing device
18848 		 * reset condition.
18849 		 */
18850 		sdinfo = SATA_PMPORT_DRV_INFO(sata_hba_inst, saddr->cport,
18851 		    saddr->pmport);
18852 		if (sdinfo != NULL) {
18853 			sdinfo->satadrv_event_flags &=
18854 			    ~SATA_EVNT_INPROC_DEVICE_RESET;
18855 			/* must clear flags on cport */
18856 			pminfo = SATA_PMULT_INFO(sata_hba_inst,
18857 			    saddr->cport);
18858 			pminfo->pmult_event_flags |=
18859 			    SATA_EVNT_CLEAR_DEVICE_RESET;
18860 		}
18861 		return;
18862 	}
18863 
18864 	sdinfo = SATA_PMPORT_DRV_INFO(sata_hba_inst, saddr->cport,
18865 	    saddr->pmport);
18866 	if (sdinfo == NULL) {
18867 		return;
18868 	}
18869 	if ((sdinfo->satadrv_event_flags &
18870 	    SATA_EVNT_INPROC_DEVICE_RESET) == 0) {
18871 		/*
18872 		 * Start tracking time for device feature restoration and
18873 		 * identification. Save current time (lbolt value).
18874 		 */
18875 		sdinfo->satadrv_reset_time = ddi_get_lbolt();
18876 	}
18877 	/* Mark device reset processing as active */
18878 	sdinfo->satadrv_event_flags |= SATA_EVNT_INPROC_DEVICE_RESET;
18879 
18880 	old_sdinfo = *sdinfo;	/* local copy of the drive info */
18881 	mutex_exit(&pmportinfo->pmport_mutex);
18882 
18883 	if (sata_set_drive_features(sata_hba_inst, &old_sdinfo, 1) ==
18884 	    SATA_FAILURE) {
18885 		/*
18886 		 * Restoring drive setting failed.
18887 		 * Probe the port first, to check if the port state has changed
18888 		 */
18889 		sata_device.satadev_rev = SATA_DEVICE_REV;
18890 		sata_device.satadev_addr = *saddr;
18891 		sata_device.satadev_addr.qual = SATA_ADDR_PMPORT;
18892 
18893 		/* probe port */
18894 		rval = (*SATA_PROBE_PORT_FUNC(sata_hba_inst))
18895 		    (SATA_DIP(sata_hba_inst), &sata_device);
18896 		mutex_enter(&pmportinfo->pmport_mutex);
18897 		if (rval == SATA_SUCCESS &&
18898 		    (sata_device.satadev_state &
18899 		    (SATA_PSTATE_SHUTDOWN | SATA_PSTATE_FAILED)) == 0 &&
18900 		    (sata_device.satadev_scr.sstatus  &
18901 		    SATA_PORT_DEVLINK_UP_MASK) == SATA_PORT_DEVLINK_UP &&
18902 		    sata_device.satadev_type != SATA_DTYPE_NONE) {
18903 			/*
18904 			 * We may retry this a bit later - in-process reset
18905 			 * condition should be already set.
18906 			 * Track retry time for device identification.
18907 			 */
18908 			if ((pmportinfo->pmport_dev_type &
18909 			    SATA_VALID_DEV_TYPE) != 0 &&
18910 			    SATA_PMPORTINFO_DRV_INFO(pmportinfo) != NULL &&
18911 			    sdinfo->satadrv_reset_time != 0) {
18912 				clock_t cur_time = ddi_get_lbolt();
18913 				/*
18914 				 * If the retry time limit was not
18915 				 * exceeded, retry.
18916 				 */
18917 				if ((cur_time - sdinfo->satadrv_reset_time) <
18918 				    drv_usectohz(SATA_DEV_REPROBE_TIMEOUT)) {
18919 					mutex_enter(
18920 					    &sata_hba_inst->satahba_mutex);
18921 					sata_hba_inst->satahba_event_flags |=
18922 					    SATA_EVNT_MAIN;
18923 					mutex_exit(
18924 					    &sata_hba_inst->satahba_mutex);
18925 					mutex_enter(&sata_mutex);
18926 					sata_event_pending |= SATA_EVNT_MAIN;
18927 					mutex_exit(&sata_mutex);
18928 					return;
18929 				}
18930 			}
18931 			/* Fail the drive */
18932 			sdinfo->satadrv_state = SATA_DSTATE_FAILED;
18933 
18934 			sata_log(sata_hba_inst, CE_WARN,
18935 			    "SATA device at port %d:%d - device failed",
18936 			    saddr->cport, saddr->pmport);
18937 		} else {
18938 			/*
18939 			 * No point of retrying - some other event processing
18940 			 * would or already did port info cleanup.
18941 			 * To be safe (HBA may need it),
18942 			 * request clearing device reset condition.
18943 			 */
18944 			sdinfo->satadrv_event_flags |=
18945 			    SATA_EVNT_CLEAR_DEVICE_RESET;
18946 		}
18947 		sdinfo->satadrv_event_flags &= ~SATA_EVNT_INPROC_DEVICE_RESET;
18948 		sdinfo->satadrv_reset_time = 0;
18949 		return;
18950 	}
18951 	/*
18952 	 * Raise the flag indicating that the next sata command could
18953 	 * be sent with SATA_CLEAR_DEV_RESET_STATE flag, if no new device
18954 	 * reset is reported.
18955 	 */
18956 	mutex_enter(&pmportinfo->pmport_mutex);
18957 	if (SATA_PMPORTINFO_DRV_INFO(pmportinfo) != NULL) {
18958 		sdinfo->satadrv_reset_time = 0;
18959 		if (pmportinfo->pmport_dev_type & SATA_VALID_DEV_TYPE) {
18960 			sdinfo = SATA_PMPORTINFO_DRV_INFO(pmportinfo);
18961 			sdinfo->satadrv_event_flags &=
18962 			    ~SATA_EVNT_INPROC_DEVICE_RESET;
18963 			/* must clear flags on cport */
18964 			pminfo = SATA_PMULT_INFO(sata_hba_inst,
18965 			    saddr->cport);
18966 			pminfo->pmult_event_flags |=
18967 			    SATA_EVNT_CLEAR_DEVICE_RESET;
18968 		}
18969 	}
18970 }
18971 
18972 /*
18973  * Port Link Events processing.
18974  * Every link established event may involve device reset (due to
18975  * COMRESET signal, equivalent of the hard reset) so arbitrarily
18976  * set device reset event for an attached device (if any).
18977  * If the port is in SHUTDOWN or FAILED state, ignore link events.
18978  *
18979  * The link established event processing varies, depending on the state
18980  * of the target node, HBA hotplugging capabilities, state of the port.
18981  * If the link is not active, the link established event is ignored.
18982  * If HBA cannot detect device attachment and there is no target node,
18983  * the link established event triggers device attach event processing.
18984  * Else, link established event triggers device reset event processing.
18985  *
18986  * The link lost event processing varies, depending on a HBA hotplugging
18987  * capability and the state of the port (link active or not active).
18988  * If the link is active, the lost link event is ignored.
18989  * If HBA cannot detect device removal, the lost link event triggers
18990  * device detached event processing after link lost timeout.
18991  * Else, the event is ignored.
18992  *
18993  * NOTE: Port multiplier ports events are handled by
18994  * sata_process_pmport_link_events();
18995  */
18996 static void
18997 sata_process_port_link_events(sata_hba_inst_t *sata_hba_inst,
18998     sata_address_t *saddr)
18999 {
19000 	sata_device_t sata_device;
19001 	sata_cport_info_t *cportinfo;
19002 	sata_drive_info_t *sdinfo;
19003 	uint32_t event_flags;
19004 	int rval;
19005 
19006 	SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst,
19007 	    "Processing port %d link event(s)", saddr->cport);
19008 
19009 	cportinfo = SATA_CPORT_INFO(sata_hba_inst, saddr->cport);
19010 	mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex);
19011 	event_flags = cportinfo->cport_event_flags;
19012 
19013 	/* Reset event flags first */
19014 	cportinfo->cport_event_flags &=
19015 	    ~(SATA_EVNT_LINK_ESTABLISHED | SATA_EVNT_LINK_LOST);
19016 
19017 	/* If the port is in SHUTDOWN or FAILED state, ignore link events. */
19018 	if ((cportinfo->cport_state &
19019 	    (SATA_PSTATE_SHUTDOWN | SATA_PSTATE_FAILED)) != 0) {
19020 		mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->
19021 		    cport_mutex);
19022 		return;
19023 	}
19024 
19025 	/*
19026 	 * For the sanity sake get current port state.
19027 	 * Set device address only. Other sata_device fields should be
19028 	 * set by HBA driver.
19029 	 */
19030 	sata_device.satadev_rev = SATA_DEVICE_REV;
19031 	sata_device.satadev_addr = *saddr;
19032 	/*
19033 	 * We have to exit mutex, because the HBA probe port function may
19034 	 * block on its own mutex.
19035 	 */
19036 	mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex);
19037 	rval = (*SATA_PROBE_PORT_FUNC(sata_hba_inst))
19038 	    (SATA_DIP(sata_hba_inst), &sata_device);
19039 	mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex);
19040 	sata_update_port_info(sata_hba_inst, &sata_device);
19041 	if (rval != SATA_SUCCESS) {
19042 		/* Something went wrong? Fail the port */
19043 		cportinfo->cport_state = SATA_PSTATE_FAILED;
19044 		mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->
19045 		    cport_mutex);
19046 		SATA_LOG_D((sata_hba_inst, CE_WARN,
19047 		    "SATA port %d probing failed",
19048 		    saddr->cport));
19049 		/*
19050 		 * We may want to release device info structure, but
19051 		 * it is not necessary.
19052 		 */
19053 		return;
19054 	} else {
19055 		/* port probed successfully */
19056 		cportinfo->cport_state |= SATA_STATE_PROBED | SATA_STATE_READY;
19057 	}
19058 	if (event_flags & SATA_EVNT_LINK_ESTABLISHED) {
19059 
19060 		if ((sata_device.satadev_scr.sstatus &
19061 		    SATA_PORT_DEVLINK_UP_MASK) != SATA_PORT_DEVLINK_UP) {
19062 			/* Ignore event */
19063 			SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst,
19064 			    "Ignoring port %d link established event - "
19065 			    "link down",
19066 			    saddr->cport);
19067 			goto linklost;
19068 		}
19069 
19070 		SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst,
19071 		    "Processing port %d link established event",
19072 		    saddr->cport);
19073 
19074 		/*
19075 		 * For the sanity sake check if a device is attached - check
19076 		 * return state of a port probing.
19077 		 */
19078 		if (sata_device.satadev_type != SATA_DTYPE_NONE) {
19079 			/*
19080 			 * HBA port probe indicated that there is a device
19081 			 * attached. Check if the framework had device info
19082 			 * structure attached for this device.
19083 			 */
19084 			if (cportinfo->cport_dev_type != SATA_DTYPE_NONE) {
19085 				ASSERT(SATA_CPORTINFO_DRV_INFO(cportinfo) !=
19086 				    NULL);
19087 
19088 				sdinfo = SATA_CPORTINFO_DRV_INFO(cportinfo);
19089 				if ((sdinfo->satadrv_type &
19090 				    SATA_VALID_DEV_TYPE) != 0) {
19091 					/*
19092 					 * Dev info structure is present.
19093 					 * If dev_type is set to known type in
19094 					 * the framework's drive info struct
19095 					 * then the device existed before and
19096 					 * the link was probably lost
19097 					 * momentarily - in such case
19098 					 * we may want to check device
19099 					 * identity.
19100 					 * Identity check is not supported now.
19101 					 *
19102 					 * Link established event
19103 					 * triggers device reset event.
19104 					 */
19105 					(SATA_CPORTINFO_DRV_INFO(cportinfo))->
19106 					    satadrv_event_flags |=
19107 					    SATA_EVNT_DEVICE_RESET;
19108 				}
19109 			} else if (cportinfo->cport_dev_type ==
19110 			    SATA_DTYPE_NONE) {
19111 				/*
19112 				 * We got new device attached! If HBA does not
19113 				 * generate device attached events, trigger it
19114 				 * here.
19115 				 */
19116 				if (!(SATA_FEATURES(sata_hba_inst) &
19117 				    SATA_CTLF_HOTPLUG)) {
19118 					cportinfo->cport_event_flags |=
19119 					    SATA_EVNT_DEVICE_ATTACHED;
19120 				}
19121 			}
19122 			/* Reset link lost timeout */
19123 			cportinfo->cport_link_lost_time = 0;
19124 		}
19125 	}
19126 linklost:
19127 	if (event_flags & SATA_EVNT_LINK_LOST) {
19128 		if ((sata_device.satadev_scr.sstatus &
19129 		    SATA_PORT_DEVLINK_UP_MASK) == SATA_PORT_DEVLINK_UP) {
19130 			/* Ignore event */
19131 			SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst,
19132 			    "Ignoring port %d link lost event - link is up",
19133 			    saddr->cport);
19134 			goto done;
19135 		}
19136 #ifdef SATA_DEBUG
19137 		if (cportinfo->cport_link_lost_time == 0) {
19138 			SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst,
19139 			    "Processing port %d link lost event",
19140 			    saddr->cport);
19141 		}
19142 #endif
19143 		/*
19144 		 * When HBA cannot generate device attached/detached events,
19145 		 * we need to track link lost time and eventually generate
19146 		 * device detach event.
19147 		 */
19148 		if (!(SATA_FEATURES(sata_hba_inst) & SATA_CTLF_HOTPLUG)) {
19149 			/* We are tracking link lost time */
19150 			if (cportinfo->cport_link_lost_time == 0) {
19151 				/* save current time (lbolt value) */
19152 				cportinfo->cport_link_lost_time =
19153 				    ddi_get_lbolt();
19154 				/* just keep link lost event */
19155 				cportinfo->cport_event_flags |=
19156 				    SATA_EVNT_LINK_LOST;
19157 			} else {
19158 				clock_t cur_time = ddi_get_lbolt();
19159 				if ((cur_time -
19160 				    cportinfo->cport_link_lost_time) >=
19161 				    drv_usectohz(
19162 				    SATA_EVNT_LINK_LOST_TIMEOUT)) {
19163 					/* trigger device detach event */
19164 					cportinfo->cport_event_flags |=
19165 					    SATA_EVNT_DEVICE_DETACHED;
19166 					cportinfo->cport_link_lost_time = 0;
19167 					SATADBG1(SATA_DBG_EVENTS,
19168 					    sata_hba_inst,
19169 					    "Triggering port %d "
19170 					    "device detached event",
19171 					    saddr->cport);
19172 				} else {
19173 					/* keep link lost event */
19174 					cportinfo->cport_event_flags |=
19175 					    SATA_EVNT_LINK_LOST;
19176 				}
19177 			}
19178 		}
19179 		/*
19180 		 * We could change port state to disable/delay access to
19181 		 * the attached device until the link is recovered.
19182 		 */
19183 	}
19184 done:
19185 	event_flags = cportinfo->cport_event_flags;
19186 	mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex);
19187 	if (event_flags != 0) {
19188 		mutex_enter(&sata_hba_inst->satahba_mutex);
19189 		sata_hba_inst->satahba_event_flags |= SATA_EVNT_MAIN;
19190 		mutex_exit(&sata_hba_inst->satahba_mutex);
19191 		mutex_enter(&sata_mutex);
19192 		sata_event_pending |= SATA_EVNT_MAIN;
19193 		mutex_exit(&sata_mutex);
19194 	}
19195 }
19196 
19197 /*
19198  * Port Multiplier Port Link Events processing.
19199  */
19200 static void
19201 sata_process_pmport_link_events(sata_hba_inst_t *sata_hba_inst,
19202     sata_address_t *saddr)
19203 {
19204 	sata_device_t sata_device;
19205 	sata_pmport_info_t *pmportinfo = NULL;
19206 	sata_drive_info_t *sdinfo = NULL;
19207 	uint32_t event_flags;
19208 	uint8_t cport = saddr->cport;
19209 	uint8_t pmport = saddr->pmport;
19210 	int rval;
19211 
19212 	SATADBG2(SATA_DBG_EVENTS_PROC, sata_hba_inst,
19213 	    "Processing port %d:%d link event(s)",
19214 	    cport, pmport);
19215 
19216 	pmportinfo = SATA_PMPORT_INFO(sata_hba_inst, cport, pmport);
19217 	mutex_enter(&pmportinfo->pmport_mutex);
19218 	event_flags = pmportinfo->pmport_event_flags;
19219 
19220 	/* Reset event flags first */
19221 	pmportinfo->pmport_event_flags &=
19222 	    ~(SATA_EVNT_LINK_ESTABLISHED | SATA_EVNT_LINK_LOST);
19223 
19224 	/* If the port is in SHUTDOWN or FAILED state, ignore link events. */
19225 	if ((pmportinfo->pmport_state &
19226 	    (SATA_PSTATE_SHUTDOWN | SATA_PSTATE_FAILED)) != 0) {
19227 		mutex_exit(&pmportinfo->pmport_mutex);
19228 		return;
19229 	}
19230 
19231 	/*
19232 	 * For the sanity sake get current port state.
19233 	 * Set device address only. Other sata_device fields should be
19234 	 * set by HBA driver.
19235 	 */
19236 	sata_device.satadev_rev = SATA_DEVICE_REV;
19237 	sata_device.satadev_addr = *saddr;
19238 	/*
19239 	 * We have to exit mutex, because the HBA probe port function may
19240 	 * block on its own mutex.
19241 	 */
19242 	mutex_exit(&SATA_PMPORT_MUTEX(sata_hba_inst, saddr->cport,
19243 	    saddr->pmport));
19244 	rval = (*SATA_PROBE_PORT_FUNC(sata_hba_inst))
19245 	    (SATA_DIP(sata_hba_inst), &sata_device);
19246 	mutex_enter(&SATA_PMPORT_MUTEX(sata_hba_inst, saddr->cport,
19247 	    saddr->pmport));
19248 	sata_update_pmport_info(sata_hba_inst, &sata_device);
19249 	if (rval != SATA_SUCCESS) {
19250 		/* Something went wrong? Fail the port */
19251 		pmportinfo->pmport_state = SATA_PSTATE_FAILED;
19252 		mutex_exit(&SATA_PMPORT_MUTEX(sata_hba_inst, saddr->cport,
19253 		    saddr->pmport));
19254 		SATA_LOG_D((sata_hba_inst, CE_WARN,
19255 		    "SATA port %d:%d probing failed",
19256 		    saddr->cport, saddr->pmport));
19257 		/*
19258 		 * We may want to release device info structure, but
19259 		 * it is not necessary.
19260 		 */
19261 		return;
19262 	} else {
19263 		/* port probed successfully */
19264 		pmportinfo->pmport_state |=
19265 		    SATA_STATE_PROBED | SATA_STATE_READY;
19266 	}
19267 	mutex_exit(&SATA_PMPORT_MUTEX(sata_hba_inst,
19268 	    saddr->cport, saddr->pmport));
19269 	mutex_enter(&SATA_PMPORT_MUTEX(sata_hba_inst,
19270 	    saddr->cport, saddr->pmport));
19271 	if (event_flags & SATA_EVNT_LINK_ESTABLISHED) {
19272 
19273 		if ((sata_device.satadev_scr.sstatus &
19274 		    SATA_PORT_DEVLINK_UP_MASK) != SATA_PORT_DEVLINK_UP) {
19275 			/* Ignore event */
19276 			SATADBG2(SATA_DBG_EVENTS_PROC, sata_hba_inst,
19277 			    "Ignoring port %d:%d link established event - "
19278 			    "link down",
19279 			    saddr->cport, saddr->pmport);
19280 			goto linklost;
19281 		}
19282 
19283 		SATADBG2(SATA_DBG_EVENTS_PROC, sata_hba_inst,
19284 		    "Processing port %d:%d link established event",
19285 		    cport, pmport);
19286 
19287 		/*
19288 		 * For the sanity sake check if a device is attached - check
19289 		 * return state of a port probing.
19290 		 */
19291 		if (sata_device.satadev_type != SATA_DTYPE_NONE &&
19292 		    sata_device.satadev_type != SATA_DTYPE_PMULT) {
19293 			/*
19294 			 * HBA port probe indicated that there is a device
19295 			 * attached. Check if the framework had device info
19296 			 * structure attached for this device.
19297 			 */
19298 			if (pmportinfo->pmport_dev_type != SATA_DTYPE_NONE) {
19299 				ASSERT(SATA_PMPORTINFO_DRV_INFO(pmportinfo) !=
19300 				    NULL);
19301 
19302 				sdinfo = SATA_PMPORTINFO_DRV_INFO(pmportinfo);
19303 				if ((sdinfo->satadrv_type &
19304 				    SATA_VALID_DEV_TYPE) != 0) {
19305 					/*
19306 					 * Dev info structure is present.
19307 					 * If dev_type is set to known type in
19308 					 * the framework's drive info struct
19309 					 * then the device existed before and
19310 					 * the link was probably lost
19311 					 * momentarily - in such case
19312 					 * we may want to check device
19313 					 * identity.
19314 					 * Identity check is not supported now.
19315 					 *
19316 					 * Link established event
19317 					 * triggers device reset event.
19318 					 */
19319 					(SATA_PMPORTINFO_DRV_INFO(pmportinfo))->
19320 					    satadrv_event_flags |=
19321 					    SATA_EVNT_DEVICE_RESET;
19322 				}
19323 			} else if (pmportinfo->pmport_dev_type ==
19324 			    SATA_DTYPE_NONE) {
19325 				/*
19326 				 * We got new device attached! If HBA does not
19327 				 * generate device attached events, trigger it
19328 				 * here.
19329 				 */
19330 				if (!(SATA_FEATURES(sata_hba_inst) &
19331 				    SATA_CTLF_HOTPLUG)) {
19332 					pmportinfo->pmport_event_flags |=
19333 					    SATA_EVNT_DEVICE_ATTACHED;
19334 				}
19335 			}
19336 			/* Reset link lost timeout */
19337 			pmportinfo->pmport_link_lost_time = 0;
19338 		}
19339 	}
19340 linklost:
19341 	if (event_flags & SATA_EVNT_LINK_LOST) {
19342 #ifdef SATA_DEBUG
19343 		if (pmportinfo->pmport_link_lost_time == 0) {
19344 			SATADBG2(SATA_DBG_EVENTS_PROC, sata_hba_inst,
19345 			    "Processing port %d:%d link lost event",
19346 			    saddr->cport, saddr->pmport);
19347 		}
19348 #endif
19349 		if ((sata_device.satadev_scr.sstatus &
19350 		    SATA_PORT_DEVLINK_UP_MASK) == SATA_PORT_DEVLINK_UP) {
19351 			/* Ignore event */
19352 			SATADBG2(SATA_DBG_EVENTS_PROC, sata_hba_inst,
19353 			    "Ignoring port %d:%d link lost event - link is up",
19354 			    saddr->cport, saddr->pmport);
19355 			goto done;
19356 		}
19357 		/*
19358 		 * When HBA cannot generate device attached/detached events,
19359 		 * we need to track link lost time and eventually generate
19360 		 * device detach event.
19361 		 */
19362 		if (!(SATA_FEATURES(sata_hba_inst) & SATA_CTLF_HOTPLUG)) {
19363 			/* We are tracking link lost time */
19364 			if (pmportinfo->pmport_link_lost_time == 0) {
19365 				/* save current time (lbolt value) */
19366 				pmportinfo->pmport_link_lost_time =
19367 				    ddi_get_lbolt();
19368 				/* just keep link lost event */
19369 				pmportinfo->pmport_event_flags |=
19370 				    SATA_EVNT_LINK_LOST;
19371 			} else {
19372 				clock_t cur_time = ddi_get_lbolt();
19373 				if ((cur_time -
19374 				    pmportinfo->pmport_link_lost_time) >=
19375 				    drv_usectohz(
19376 				    SATA_EVNT_LINK_LOST_TIMEOUT)) {
19377 					/* trigger device detach event */
19378 					pmportinfo->pmport_event_flags |=
19379 					    SATA_EVNT_DEVICE_DETACHED;
19380 					pmportinfo->pmport_link_lost_time = 0;
19381 					SATADBG2(SATA_DBG_EVENTS,
19382 					    sata_hba_inst,
19383 					    "Triggering port %d:%d "
19384 					    "device detached event",
19385 					    saddr->cport, saddr->pmport);
19386 				} else {
19387 					/* keep link lost event */
19388 					pmportinfo->pmport_event_flags |=
19389 					    SATA_EVNT_LINK_LOST;
19390 				}
19391 			}
19392 		}
19393 		/*
19394 		 * We could change port state to disable/delay access to
19395 		 * the attached device until the link is recovered.
19396 		 */
19397 	}
19398 done:
19399 	event_flags = pmportinfo->pmport_event_flags;
19400 	mutex_exit(&SATA_PMPORT_MUTEX(sata_hba_inst, saddr->cport,
19401 	    saddr->pmport));
19402 	if (event_flags != 0) {
19403 		mutex_enter(&sata_hba_inst->satahba_mutex);
19404 		sata_hba_inst->satahba_event_flags |= SATA_EVNT_MAIN;
19405 		mutex_exit(&sata_hba_inst->satahba_mutex);
19406 		mutex_enter(&sata_mutex);
19407 		sata_event_pending |= SATA_EVNT_MAIN;
19408 		mutex_exit(&sata_mutex);
19409 	}
19410 }
19411 
19412 /*
19413  * Device Detached Event processing.
19414  * Port is probed to find if a device is really gone. If so,
19415  * the device info structure is detached from the SATA port info structure
19416  * and released.
19417  * Port status is updated.
19418  *
19419  * NOTE: Port multiplier ports events are handled by
19420  * sata_process_pmdevice_detached()
19421  */
19422 static void
19423 sata_process_device_detached(sata_hba_inst_t *sata_hba_inst,
19424     sata_address_t *saddr)
19425 {
19426 	sata_cport_info_t *cportinfo;
19427 	sata_pmport_info_t *pmportinfo;
19428 	sata_drive_info_t *sdevinfo;
19429 	sata_device_t sata_device;
19430 	sata_address_t pmport_addr;
19431 	char name[16];
19432 	uint8_t cport = saddr->cport;
19433 	int npmport;
19434 	int rval;
19435 
19436 	SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst,
19437 	    "Processing port %d device detached", saddr->cport);
19438 
19439 	cportinfo = SATA_CPORT_INFO(sata_hba_inst, saddr->cport);
19440 	mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex);
19441 	/* Clear event flag */
19442 	cportinfo->cport_event_flags &= ~SATA_EVNT_DEVICE_DETACHED;
19443 
19444 	/* If the port is in SHUTDOWN or FAILED state, ignore detach event. */
19445 	if ((cportinfo->cport_state &
19446 	    (SATA_PSTATE_SHUTDOWN | SATA_PSTATE_FAILED)) != 0) {
19447 		mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->
19448 		    cport_mutex);
19449 		return;
19450 	}
19451 	/* For sanity, re-probe the port */
19452 	sata_device.satadev_rev = SATA_DEVICE_REV;
19453 	sata_device.satadev_addr = *saddr;
19454 
19455 	/*
19456 	 * We have to exit mutex, because the HBA probe port function may
19457 	 * block on its own mutex.
19458 	 */
19459 	mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex);
19460 	rval = (*SATA_PROBE_PORT_FUNC(sata_hba_inst))
19461 	    (SATA_DIP(sata_hba_inst), &sata_device);
19462 	mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex);
19463 	sata_update_port_info(sata_hba_inst, &sata_device);
19464 	if (rval != SATA_SUCCESS) {
19465 		/* Something went wrong? Fail the port */
19466 		cportinfo->cport_state = SATA_PSTATE_FAILED;
19467 		mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->
19468 		    cport_mutex);
19469 		SATA_LOG_D((sata_hba_inst, CE_WARN,
19470 		    "SATA port %d probing failed",
19471 		    saddr->cport));
19472 		/*
19473 		 * We may want to release device info structure, but
19474 		 * it is not necessary.
19475 		 */
19476 		return;
19477 	} else {
19478 		/* port probed successfully */
19479 		cportinfo->cport_state |= SATA_STATE_PROBED | SATA_STATE_READY;
19480 	}
19481 	/*
19482 	 * Check if a device is still attached. For sanity, check also
19483 	 * link status - if no link, there is no device.
19484 	 */
19485 	if ((sata_device.satadev_scr.sstatus & SATA_PORT_DEVLINK_UP_MASK) ==
19486 	    SATA_PORT_DEVLINK_UP && sata_device.satadev_type !=
19487 	    SATA_DTYPE_NONE) {
19488 		/*
19489 		 * Device is still attached - ignore detach event.
19490 		 */
19491 		mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->
19492 		    cport_mutex);
19493 		SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst,
19494 		    "Ignoring detach - device still attached to port %d",
19495 		    sata_device.satadev_addr.cport);
19496 		return;
19497 	}
19498 	/*
19499 	 * We need to detach and release device info structure here
19500 	 */
19501 	if (cportinfo->cport_dev_type == SATA_DTYPE_PMULT) {
19502 		/*
19503 		 * A port-multiplier is removed.
19504 		 *
19505 		 * Calling sata_process_pmdevice_detached() does not work
19506 		 * here. The port multiplier is gone, so we cannot probe
19507 		 * sub-port any more and all pmult-related data structure must
19508 		 * be de-allocated immediately. Following structure of every
19509 		 * implemented sub-port behind the pmult are required to
19510 		 * released.
19511 		 *
19512 		 *   - attachment point
19513 		 *   - target node
19514 		 *   - sata_drive_info
19515 		 *   - sata_pmport_info
19516 		 */
19517 		for (npmport = 0; npmport < SATA_NUM_PMPORTS(sata_hba_inst,
19518 		    cport); npmport ++) {
19519 			SATADBG2(SATA_DBG_PMULT|SATA_DBG_EVENTS_PROC,
19520 			    sata_hba_inst,
19521 			    "Detaching target node at port %d:%d",
19522 			    cport, npmport);
19523 
19524 			mutex_exit(&SATA_CPORT_MUTEX(sata_hba_inst, cport));
19525 
19526 			/* Remove attachment point. */
19527 			name[0] = '\0';
19528 			(void) sprintf(name, "%d.%d", cport, npmport);
19529 			ddi_remove_minor_node(SATA_DIP(sata_hba_inst), name);
19530 			sata_log(sata_hba_inst, CE_NOTE,
19531 			    "Remove attachment point of port %d:%d",
19532 			    cport, npmport);
19533 
19534 			/* Remove target node */
19535 			pmport_addr.cport = cport;
19536 			pmport_addr.pmport = (uint8_t)npmport;
19537 			pmport_addr.qual = SATA_ADDR_PMPORT;
19538 			sata_remove_target_node(sata_hba_inst, &pmport_addr);
19539 
19540 			mutex_enter(&SATA_CPORT_MUTEX(sata_hba_inst, cport));
19541 
19542 			/* Release sata_pmport_info & sata_drive_info. */
19543 			pmportinfo = SATA_PMPORT_INFO(sata_hba_inst,
19544 			    cport, npmport);
19545 			ASSERT(pmportinfo != NULL);
19546 
19547 			sdevinfo = SATA_PMPORTINFO_DRV_INFO(pmportinfo);
19548 			if (sdevinfo != NULL) {
19549 				(void) kmem_free((void *) sdevinfo,
19550 				    sizeof (sata_drive_info_t));
19551 			}
19552 
19553 			/* Release sata_pmport_info at last */
19554 			(void) kmem_free((void *) pmportinfo,
19555 			    sizeof (sata_pmport_info_t));
19556 		}
19557 
19558 		/* Finally, release sata_pmult_info */
19559 		(void) kmem_free((void *)
19560 		    SATA_CPORTINFO_PMULT_INFO(cportinfo),
19561 		    sizeof (sata_pmult_info_t));
19562 		SATA_CPORTINFO_PMULT_INFO(cportinfo) = NULL;
19563 
19564 		sata_log(sata_hba_inst, CE_WARN,
19565 		    "SATA port-multiplier detached at port %d", cport);
19566 
19567 		cportinfo->cport_dev_type = SATA_DTYPE_NONE;
19568 		mutex_exit(&SATA_CPORT_INFO(sata_hba_inst,
19569 		    saddr->cport)->cport_mutex);
19570 	} else {
19571 		if (SATA_CPORTINFO_DRV_INFO(cportinfo) != NULL) {
19572 			sdevinfo = SATA_CPORTINFO_DRV_INFO(cportinfo);
19573 			SATA_CPORTINFO_DRV_INFO(cportinfo) = NULL;
19574 			(void) kmem_free((void *)sdevinfo,
19575 			    sizeof (sata_drive_info_t));
19576 		}
19577 		sata_log(sata_hba_inst, CE_WARN,
19578 		    "SATA device detached at port %d", cport);
19579 
19580 		cportinfo->cport_dev_type = SATA_DTYPE_NONE;
19581 		mutex_exit(&SATA_CPORT_INFO(sata_hba_inst,
19582 		    saddr->cport)->cport_mutex);
19583 
19584 		/*
19585 		 * Try to offline a device and remove target node
19586 		 * if it still exists
19587 		 */
19588 		sata_remove_target_node(sata_hba_inst, saddr);
19589 	}
19590 
19591 
19592 	/*
19593 	 * Generate sysevent - EC_DR / ESC_DR_AP_STATE_CHANGE
19594 	 * with the hint: SE_HINT_REMOVE
19595 	 */
19596 	sata_gen_sysevent(sata_hba_inst, saddr, SE_HINT_REMOVE);
19597 }
19598 
19599 /*
19600  * Port Multiplier Port Device Deattached Event processing.
19601  *
19602  * NOTE: No Mutex should be hold.
19603  */
19604 static void
19605 sata_process_pmdevice_detached(sata_hba_inst_t *sata_hba_inst,
19606     sata_address_t *saddr)
19607 {
19608 	sata_pmport_info_t *pmportinfo;
19609 	sata_drive_info_t *sdevinfo;
19610 	sata_device_t sata_device;
19611 	int rval;
19612 	uint8_t cport, pmport;
19613 
19614 	cport = saddr->cport;
19615 	pmport = saddr->pmport;
19616 
19617 	SATADBG2(SATA_DBG_EVENTS_PROC, sata_hba_inst,
19618 	    "Processing port %d:%d device detached",
19619 	    cport, pmport);
19620 
19621 	pmportinfo = SATA_PMPORT_INFO(sata_hba_inst, cport, pmport);
19622 	mutex_enter(&SATA_PMPORT_MUTEX(sata_hba_inst, cport, pmport));
19623 
19624 	/* Clear event flag */
19625 	pmportinfo->pmport_event_flags &= ~SATA_EVNT_DEVICE_DETACHED;
19626 
19627 	/* If the port is in SHUTDOWN or FAILED state, ignore detach event. */
19628 	if ((pmportinfo->pmport_state &
19629 	    (SATA_PSTATE_SHUTDOWN | SATA_PSTATE_FAILED)) != 0) {
19630 		mutex_exit(&SATA_PMPORT_MUTEX(sata_hba_inst, cport, pmport));
19631 		return;
19632 	}
19633 	/* For sanity, re-probe the port */
19634 	sata_device.satadev_rev = SATA_DEVICE_REV;
19635 	sata_device.satadev_addr = *saddr;
19636 
19637 	/*
19638 	 * We have to exit mutex, because the HBA probe port function may
19639 	 * block on its own mutex.
19640 	 */
19641 	mutex_exit(&SATA_PMPORT_MUTEX(sata_hba_inst, cport, pmport));
19642 	rval = (*SATA_PROBE_PORT_FUNC(sata_hba_inst))
19643 	    (SATA_DIP(sata_hba_inst), &sata_device);
19644 	mutex_enter(&SATA_PMPORT_MUTEX(sata_hba_inst, cport, pmport));
19645 	sata_update_pmport_info(sata_hba_inst, &sata_device);
19646 	if (rval != SATA_SUCCESS) {
19647 		/* Something went wrong? Fail the port */
19648 		pmportinfo->pmport_state = SATA_PSTATE_FAILED;
19649 		mutex_exit(&SATA_PMPORT_MUTEX(sata_hba_inst, cport, pmport));
19650 		SATA_LOG_D((sata_hba_inst, CE_WARN,
19651 		    "SATA port %d:%d probing failed",
19652 		    saddr->pmport));
19653 		/*
19654 		 * We may want to release device info structure, but
19655 		 * it is not necessary.
19656 		 */
19657 		return;
19658 	} else {
19659 		/* port probed successfully */
19660 		pmportinfo->pmport_state |=
19661 		    SATA_STATE_PROBED | SATA_STATE_READY;
19662 	}
19663 	/*
19664 	 * Check if a device is still attached. For sanity, check also
19665 	 * link status - if no link, there is no device.
19666 	 */
19667 	if ((sata_device.satadev_scr.sstatus & SATA_PORT_DEVLINK_UP_MASK) ==
19668 	    SATA_PORT_DEVLINK_UP && sata_device.satadev_type !=
19669 	    SATA_DTYPE_NONE) {
19670 		/*
19671 		 * Device is still attached - ignore detach event.
19672 		 */
19673 		mutex_exit(&SATA_PMPORT_MUTEX(sata_hba_inst, cport, pmport));
19674 		SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst,
19675 		    "Ignoring detach - device still attached to port %d",
19676 		    sata_device.satadev_addr.pmport);
19677 		return;
19678 	}
19679 	/*
19680 	 * We need to detach and release device info structure here
19681 	 */
19682 	if (SATA_PMPORTINFO_DRV_INFO(pmportinfo) != NULL) {
19683 		sdevinfo = SATA_PMPORTINFO_DRV_INFO(pmportinfo);
19684 		SATA_PMPORTINFO_DRV_INFO(pmportinfo) = NULL;
19685 		(void) kmem_free((void *)sdevinfo,
19686 		    sizeof (sata_drive_info_t));
19687 	}
19688 	pmportinfo->pmport_dev_type = SATA_DTYPE_NONE;
19689 	/*
19690 	 * Device cannot be reached anymore, even if the target node may be
19691 	 * still present.
19692 	 */
19693 	mutex_exit(&SATA_PMPORT_MUTEX(sata_hba_inst, cport, pmport));
19694 
19695 	/*
19696 	 * Try to offline a device and remove target node if it still exists
19697 	 */
19698 	sata_remove_target_node(sata_hba_inst, saddr);
19699 
19700 	/*
19701 	 * Generate sysevent - EC_DR / ESC_DR_AP_STATE_CHANGE
19702 	 * with the hint: SE_HINT_REMOVE
19703 	 */
19704 	sata_gen_sysevent(sata_hba_inst, saddr, SE_HINT_REMOVE);
19705 }
19706 
19707 
19708 /*
19709  * Device Attached Event processing.
19710  * Port state is checked to verify that a device is really attached. If so,
19711  * the device info structure is created and attached to the SATA port info
19712  * structure.
19713  *
19714  * If attached device cannot be identified or set-up, the retry for the
19715  * attach processing is set-up. Subsequent daemon run would try again to
19716  * identify the device, until the time limit is reached
19717  * (SATA_DEV_IDENTIFY_TIMEOUT).
19718  *
19719  * This function cannot be called in interrupt context (it may sleep).
19720  *
19721  * NOTE: Port multiplier ports events are handled by
19722  * sata_process_pmdevice_attached()
19723  */
19724 static void
19725 sata_process_device_attached(sata_hba_inst_t *sata_hba_inst,
19726     sata_address_t *saddr)
19727 {
19728 	sata_cport_info_t *cportinfo = NULL;
19729 	sata_drive_info_t *sdevinfo = NULL;
19730 	sata_pmult_info_t *pmultinfo = NULL;
19731 	sata_pmport_info_t *pmportinfo = NULL;
19732 	sata_device_t sata_device;
19733 	dev_info_t *tdip;
19734 	uint32_t event_flags = 0, pmult_event_flags = 0;
19735 	int rval;
19736 	int npmport;
19737 
19738 	SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst,
19739 	    "Processing port %d device attached", saddr->cport);
19740 
19741 	cportinfo = SATA_CPORT_INFO(sata_hba_inst, saddr->cport);
19742 	mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex);
19743 
19744 	/* Clear attach event flag first */
19745 	cportinfo->cport_event_flags &= ~SATA_EVNT_DEVICE_ATTACHED;
19746 
19747 	/* If the port is in SHUTDOWN or FAILED state, ignore event. */
19748 	if ((cportinfo->cport_state &
19749 	    (SATA_PSTATE_SHUTDOWN | SATA_PSTATE_FAILED)) != 0) {
19750 		cportinfo->cport_dev_attach_time = 0;
19751 		mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->
19752 		    cport_mutex);
19753 		return;
19754 	}
19755 
19756 	/*
19757 	 * If the sata_drive_info structure is found attached to the port info,
19758 	 * despite the fact the device was removed and now it is re-attached,
19759 	 * the old drive info structure was not removed.
19760 	 * Arbitrarily release device info structure.
19761 	 */
19762 	if (SATA_CPORTINFO_DRV_INFO(cportinfo) != NULL) {
19763 		sdevinfo = SATA_CPORTINFO_DRV_INFO(cportinfo);
19764 		SATA_CPORTINFO_DRV_INFO(cportinfo) = NULL;
19765 		(void) kmem_free((void *)sdevinfo,
19766 		    sizeof (sata_drive_info_t));
19767 		SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst,
19768 		    "Arbitrarily detaching old device info.", NULL);
19769 	}
19770 	cportinfo->cport_dev_type = SATA_DTYPE_NONE;
19771 
19772 	/* For sanity, re-probe the port */
19773 	sata_device.satadev_rev = SATA_DEVICE_REV;
19774 	sata_device.satadev_addr = *saddr;
19775 
19776 	/*
19777 	 * We have to exit mutex, because the HBA probe port function may
19778 	 * block on its own mutex.
19779 	 */
19780 	mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex);
19781 	rval = (*SATA_PROBE_PORT_FUNC(sata_hba_inst))
19782 	    (SATA_DIP(sata_hba_inst), &sata_device);
19783 	mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex);
19784 	sata_update_port_info(sata_hba_inst, &sata_device);
19785 	if (rval != SATA_SUCCESS) {
19786 		/* Something went wrong? Fail the port */
19787 		cportinfo->cport_state = SATA_PSTATE_FAILED;
19788 		cportinfo->cport_dev_attach_time = 0;
19789 		mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->
19790 		    cport_mutex);
19791 		SATA_LOG_D((sata_hba_inst, CE_WARN,
19792 		    "SATA port %d probing failed",
19793 		    saddr->cport));
19794 		return;
19795 	} else {
19796 		/* port probed successfully */
19797 		cportinfo->cport_state |= SATA_STATE_PROBED | SATA_STATE_READY;
19798 	}
19799 	/*
19800 	 * Check if a device is still attached. For sanity, check also
19801 	 * link status - if no link, there is no device.
19802 	 */
19803 	if ((sata_device.satadev_scr.sstatus & SATA_PORT_DEVLINK_UP_MASK) !=
19804 	    SATA_PORT_DEVLINK_UP || sata_device.satadev_type ==
19805 	    SATA_DTYPE_NONE) {
19806 		/*
19807 		 * No device - ignore attach event.
19808 		 */
19809 		cportinfo->cport_dev_attach_time = 0;
19810 		mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->
19811 		    cport_mutex);
19812 		SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst,
19813 		    "Ignoring attach - no device connected to port %d",
19814 		    sata_device.satadev_addr.cport);
19815 		return;
19816 	}
19817 
19818 	mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex);
19819 	/*
19820 	 * Generate sysevent - EC_DR / ESC_DR_AP_STATE_CHANGE
19821 	 * with the hint: SE_HINT_INSERT
19822 	 */
19823 	sata_gen_sysevent(sata_hba_inst, saddr, SE_HINT_INSERT);
19824 
19825 	/*
19826 	 * Port reprobing will take care of the creation of the device
19827 	 * info structure and determination of the device type.
19828 	 */
19829 	sata_device.satadev_addr = *saddr;
19830 	(void) sata_reprobe_port(sata_hba_inst, &sata_device,
19831 	    SATA_DEV_IDENTIFY_NORETRY);
19832 
19833 	mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->
19834 	    cport_mutex);
19835 	if ((cportinfo->cport_state & SATA_STATE_READY) &&
19836 	    (cportinfo->cport_dev_type != SATA_DTYPE_NONE)) {
19837 		/* Some device is attached to the port */
19838 		if (cportinfo->cport_dev_type == SATA_DTYPE_UNKNOWN) {
19839 			/*
19840 			 * A device was not successfully attached.
19841 			 * Track retry time for device identification.
19842 			 */
19843 			if (cportinfo->cport_dev_attach_time != 0) {
19844 				clock_t cur_time = ddi_get_lbolt();
19845 				/*
19846 				 * If the retry time limit was not exceeded,
19847 				 * reinstate attach event.
19848 				 */
19849 				if ((cur_time -
19850 				    cportinfo->cport_dev_attach_time) <
19851 				    drv_usectohz(
19852 				    SATA_DEV_IDENTIFY_TIMEOUT)) {
19853 					/* OK, restore attach event */
19854 					cportinfo->cport_event_flags |=
19855 					    SATA_EVNT_DEVICE_ATTACHED;
19856 				} else {
19857 					/* Timeout - cannot identify device */
19858 					cportinfo->cport_dev_attach_time = 0;
19859 					sata_log(sata_hba_inst,
19860 					    CE_WARN,
19861 					    "Could not identify SATA device "
19862 					    "at port %d",
19863 					    saddr->cport);
19864 				}
19865 			} else {
19866 				/*
19867 				 * Start tracking time for device
19868 				 * identification.
19869 				 * Save current time (lbolt value).
19870 				 */
19871 				cportinfo->cport_dev_attach_time =
19872 				    ddi_get_lbolt();
19873 				/* Restore attach event */
19874 				cportinfo->cport_event_flags |=
19875 				    SATA_EVNT_DEVICE_ATTACHED;
19876 			}
19877 		} else if (cportinfo->cport_dev_type == SATA_DTYPE_PMULT) {
19878 			cportinfo->cport_dev_attach_time = 0;
19879 			sata_log(sata_hba_inst, CE_NOTE,
19880 			    "SATA port-multiplier detected at port %d",
19881 			    saddr->cport);
19882 
19883 			if (SATA_CPORTINFO_PMULT_INFO(cportinfo) != NULL) {
19884 				/* Log the info of new port multiplier */
19885 				mutex_exit(&SATA_CPORT_INFO(sata_hba_inst,
19886 				    saddr->cport)->cport_mutex);
19887 				sata_show_pmult_info(sata_hba_inst,
19888 				    &sata_device);
19889 				mutex_enter(&SATA_CPORT_INFO(sata_hba_inst,
19890 				    saddr->cport)->cport_mutex);
19891 			}
19892 
19893 			ASSERT(SATA_CPORTINFO_PMULT_INFO(cportinfo) != NULL);
19894 			pmultinfo = SATA_CPORTINFO_PMULT_INFO(cportinfo);
19895 			for (npmport = 0; npmport <
19896 			    pmultinfo->pmult_num_dev_ports; npmport++) {
19897 				pmportinfo = SATA_PMPORT_INFO(sata_hba_inst,
19898 				    saddr->cport, npmport);
19899 				ASSERT(pmportinfo != NULL);
19900 
19901 				mutex_exit(&SATA_CPORT_INFO(sata_hba_inst,
19902 				    saddr->cport)->cport_mutex);
19903 				mutex_enter(&pmportinfo->pmport_mutex);
19904 				/* Marked all pmports with link events. */
19905 				pmportinfo->pmport_event_flags =
19906 				    SATA_EVNT_LINK_ESTABLISHED;
19907 				pmult_event_flags |=
19908 				    pmportinfo->pmport_event_flags;
19909 				mutex_exit(&pmportinfo->pmport_mutex);
19910 				mutex_enter(&SATA_CPORT_INFO(sata_hba_inst,
19911 				    saddr->cport)->cport_mutex);
19912 			}
19913 			/* Auto-online is not available for PMult now. */
19914 
19915 		} else {
19916 			/*
19917 			 * If device was successfully attached, the subsequent
19918 			 * action depends on a state of the
19919 			 * sata_auto_online variable. If it is set to zero.
19920 			 * an explicit 'configure' command will be needed to
19921 			 * configure it. If its value is non-zero, we will
19922 			 * attempt to online (configure) the device.
19923 			 * First, log the message indicating that a device
19924 			 * was attached.
19925 			 */
19926 			cportinfo->cport_dev_attach_time = 0;
19927 			sata_log(sata_hba_inst, CE_WARN,
19928 			    "SATA device detected at port %d", saddr->cport);
19929 
19930 			if (SATA_CPORTINFO_DRV_INFO(cportinfo) != NULL) {
19931 				sata_drive_info_t new_sdinfo;
19932 
19933 				/* Log device info data */
19934 				new_sdinfo = *(SATA_CPORTINFO_DRV_INFO(
19935 				    cportinfo));
19936 				sata_show_drive_info(sata_hba_inst,
19937 				    &new_sdinfo);
19938 			}
19939 
19940 			mutex_exit(&SATA_CPORT_INFO(sata_hba_inst,
19941 			    saddr->cport)->cport_mutex);
19942 
19943 			/*
19944 			 * Make sure that there is no target node for that
19945 			 * device. If so, release it. It should not happen,
19946 			 * unless we had problem removing the node when
19947 			 * device was detached.
19948 			 */
19949 			tdip = sata_get_target_dip(SATA_DIP(sata_hba_inst),
19950 			    saddr->cport, saddr->pmport);
19951 			mutex_enter(&SATA_CPORT_INFO(sata_hba_inst,
19952 			    saddr->cport)->cport_mutex);
19953 			if (tdip != NULL) {
19954 
19955 #ifdef SATA_DEBUG
19956 				if ((cportinfo->cport_event_flags &
19957 				    SATA_EVNT_TARGET_NODE_CLEANUP) == 0)
19958 					sata_log(sata_hba_inst, CE_WARN,
19959 					    "sata_process_device_attached: "
19960 					    "old device target node exists!");
19961 #endif
19962 				/*
19963 				 * target node exists - try to unconfigure
19964 				 * device and remove the node.
19965 				 */
19966 				mutex_exit(&SATA_CPORT_INFO(sata_hba_inst,
19967 				    saddr->cport)->cport_mutex);
19968 				rval = ndi_devi_offline(tdip,
19969 				    NDI_DEVI_REMOVE);
19970 				mutex_enter(&SATA_CPORT_INFO(sata_hba_inst,
19971 				    saddr->cport)->cport_mutex);
19972 
19973 				if (rval == NDI_SUCCESS) {
19974 					cportinfo->cport_event_flags &=
19975 					    ~SATA_EVNT_TARGET_NODE_CLEANUP;
19976 					cportinfo->cport_tgtnode_clean = B_TRUE;
19977 				} else {
19978 					/*
19979 					 * PROBLEM - the target node remained
19980 					 * and it belongs to a previously
19981 					 * attached device.
19982 					 * This happens when the file was open
19983 					 * or the node was waiting for
19984 					 * resources at the time the
19985 					 * associated device was removed.
19986 					 * Instruct event daemon to retry the
19987 					 * cleanup later.
19988 					 */
19989 					sata_log(sata_hba_inst,
19990 					    CE_WARN,
19991 					    "Application(s) accessing "
19992 					    "previously attached SATA "
19993 					    "device have to release "
19994 					    "it before newly inserted "
19995 					    "device can be made accessible.",
19996 					    saddr->cport);
19997 					cportinfo->cport_event_flags |=
19998 					    SATA_EVNT_TARGET_NODE_CLEANUP;
19999 					cportinfo->cport_tgtnode_clean =
20000 					    B_FALSE;
20001 				}
20002 			}
20003 			if (sata_auto_online != 0) {
20004 				cportinfo->cport_event_flags |=
20005 				    SATA_EVNT_AUTOONLINE_DEVICE;
20006 			}
20007 
20008 		}
20009 	} else {
20010 		cportinfo->cport_dev_attach_time = 0;
20011 	}
20012 
20013 	event_flags = cportinfo->cport_event_flags;
20014 	mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex);
20015 	if (event_flags != 0 || pmult_event_flags != 0) {
20016 		mutex_enter(&sata_hba_inst->satahba_mutex);
20017 		sata_hba_inst->satahba_event_flags |= SATA_EVNT_MAIN;
20018 		mutex_exit(&sata_hba_inst->satahba_mutex);
20019 		mutex_enter(&sata_mutex);
20020 		sata_event_pending |= SATA_EVNT_MAIN;
20021 		mutex_exit(&sata_mutex);
20022 	}
20023 }
20024 
20025 /*
20026  * Port Multiplier Port Device Attached Event processing.
20027  *
20028  * NOTE: No Mutex should be hold.
20029  */
20030 static void
20031 sata_process_pmdevice_attached(sata_hba_inst_t *sata_hba_inst,
20032     sata_address_t *saddr)
20033 {
20034 	sata_pmport_info_t *pmportinfo;
20035 	sata_drive_info_t *sdinfo;
20036 	sata_device_t sata_device;
20037 	dev_info_t *tdip;
20038 	uint32_t event_flags;
20039 	uint8_t cport = saddr->cport;
20040 	uint8_t pmport = saddr->pmport;
20041 	int rval;
20042 
20043 	SATADBG2(SATA_DBG_EVENTS_PROC, sata_hba_inst,
20044 	    "Processing port %d:%d device attached", cport, pmport);
20045 
20046 	pmportinfo = SATA_PMPORT_INFO(sata_hba_inst, cport, pmport);
20047 
20048 	mutex_enter(&pmportinfo->pmport_mutex);
20049 
20050 	/* Clear attach event flag first */
20051 	pmportinfo->pmport_event_flags &= ~SATA_EVNT_DEVICE_ATTACHED;
20052 
20053 	/* If the port is in SHUTDOWN or FAILED state, ignore event. */
20054 	if ((pmportinfo->pmport_state &
20055 	    (SATA_PSTATE_SHUTDOWN | SATA_PSTATE_FAILED)) != 0) {
20056 		pmportinfo->pmport_dev_attach_time = 0;
20057 		mutex_exit(&pmportinfo->pmport_mutex);
20058 		return;
20059 	}
20060 
20061 	/*
20062 	 * If the sata_drive_info structure is found attached to the port info,
20063 	 * despite the fact the device was removed and now it is re-attached,
20064 	 * the old drive info structure was not removed.
20065 	 * Arbitrarily release device info structure.
20066 	 */
20067 	if (SATA_PMPORTINFO_DRV_INFO(pmportinfo) != NULL) {
20068 		sdinfo = SATA_PMPORTINFO_DRV_INFO(pmportinfo);
20069 		SATA_PMPORTINFO_DRV_INFO(pmportinfo) = NULL;
20070 		(void) kmem_free((void *)sdinfo,
20071 		    sizeof (sata_drive_info_t));
20072 		SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst,
20073 		    "Arbitrarily detaching old device info.", NULL);
20074 	}
20075 	pmportinfo->pmport_dev_type = SATA_DTYPE_NONE;
20076 
20077 	/* For sanity, re-probe the port */
20078 	sata_device.satadev_rev = SATA_DEVICE_REV;
20079 	sata_device.satadev_addr = *saddr;
20080 
20081 	/*
20082 	 * We have to exit mutex, because the HBA probe port function may
20083 	 * block on its own mutex.
20084 	 */
20085 	mutex_exit(&pmportinfo->pmport_mutex);
20086 	rval = (*SATA_PROBE_PORT_FUNC(sata_hba_inst))
20087 	    (SATA_DIP(sata_hba_inst), &sata_device);
20088 	mutex_enter(&pmportinfo->pmport_mutex);
20089 
20090 	sata_update_pmport_info(sata_hba_inst, &sata_device);
20091 	if (rval != SATA_SUCCESS) {
20092 		/* Something went wrong? Fail the port */
20093 		pmportinfo->pmport_state = SATA_PSTATE_FAILED;
20094 		pmportinfo->pmport_dev_attach_time = 0;
20095 		mutex_exit(&pmportinfo->pmport_mutex);
20096 		SATA_LOG_D((sata_hba_inst, CE_WARN,
20097 		    "SATA port %d:%d probing failed", cport, pmport));
20098 		return;
20099 	} else {
20100 		/* pmport probed successfully */
20101 		pmportinfo->pmport_state |=
20102 		    SATA_STATE_PROBED | SATA_STATE_READY;
20103 	}
20104 	/*
20105 	 * Check if a device is still attached. For sanity, check also
20106 	 * link status - if no link, there is no device.
20107 	 */
20108 	if ((sata_device.satadev_scr.sstatus & SATA_PORT_DEVLINK_UP_MASK) !=
20109 	    SATA_PORT_DEVLINK_UP || sata_device.satadev_type ==
20110 	    SATA_DTYPE_NONE) {
20111 		/*
20112 		 * No device - ignore attach event.
20113 		 */
20114 		pmportinfo->pmport_dev_attach_time = 0;
20115 		mutex_exit(&pmportinfo->pmport_mutex);
20116 		SATADBG2(SATA_DBG_EVENTS_PROC, sata_hba_inst,
20117 		    "Ignoring attach - no device connected to port %d:%d",
20118 		    cport, pmport);
20119 		return;
20120 	}
20121 
20122 	mutex_exit(&pmportinfo->pmport_mutex);
20123 	/*
20124 	 * Generate sysevent - EC_DR / ESC_DR_AP_STATE_CHANGE
20125 	 * with the hint: SE_HINT_INSERT
20126 	 */
20127 	sata_gen_sysevent(sata_hba_inst, saddr, SE_HINT_INSERT);
20128 
20129 	/*
20130 	 * Port reprobing will take care of the creation of the device
20131 	 * info structure and determination of the device type.
20132 	 */
20133 	sata_device.satadev_addr = *saddr;
20134 	(void) sata_reprobe_port(sata_hba_inst, &sata_device,
20135 	    SATA_DEV_IDENTIFY_NORETRY);
20136 
20137 	mutex_enter(&pmportinfo->pmport_mutex);
20138 	if ((pmportinfo->pmport_state & SATA_STATE_READY) &&
20139 	    (pmportinfo->pmport_dev_type != SATA_DTYPE_NONE)) {
20140 		/* Some device is attached to the port */
20141 		if (pmportinfo->pmport_dev_type == SATA_DTYPE_UNKNOWN) {
20142 			/*
20143 			 * A device was not successfully attached.
20144 			 * Track retry time for device identification.
20145 			 */
20146 			if (pmportinfo->pmport_dev_attach_time != 0) {
20147 				clock_t cur_time = ddi_get_lbolt();
20148 				/*
20149 				 * If the retry time limit was not exceeded,
20150 				 * reinstate attach event.
20151 				 */
20152 				if ((cur_time -
20153 				    pmportinfo->pmport_dev_attach_time) <
20154 				    drv_usectohz(
20155 				    SATA_DEV_IDENTIFY_TIMEOUT)) {
20156 					/* OK, restore attach event */
20157 					pmportinfo->pmport_event_flags |=
20158 					    SATA_EVNT_DEVICE_ATTACHED;
20159 				} else {
20160 					/* Timeout - cannot identify device */
20161 					pmportinfo->pmport_dev_attach_time = 0;
20162 					sata_log(sata_hba_inst, CE_WARN,
20163 					    "Could not identify SATA device "
20164 					    "at port %d:%d",
20165 					    cport, pmport);
20166 				}
20167 			} else {
20168 				/*
20169 				 * Start tracking time for device
20170 				 * identification.
20171 				 * Save current time (lbolt value).
20172 				 */
20173 				pmportinfo->pmport_dev_attach_time =
20174 				    ddi_get_lbolt();
20175 				/* Restore attach event */
20176 				pmportinfo->pmport_event_flags |=
20177 				    SATA_EVNT_DEVICE_ATTACHED;
20178 			}
20179 		} else {
20180 			/*
20181 			 * If device was successfully attached, the subsequent
20182 			 * action depends on a state of the
20183 			 * sata_auto_online variable. If it is set to zero.
20184 			 * an explicit 'configure' command will be needed to
20185 			 * configure it. If its value is non-zero, we will
20186 			 * attempt to online (configure) the device.
20187 			 * First, log the message indicating that a device
20188 			 * was attached.
20189 			 */
20190 			pmportinfo->pmport_dev_attach_time = 0;
20191 			sata_log(sata_hba_inst, CE_WARN,
20192 			    "SATA device detected at port %d:%d",
20193 			    cport, pmport);
20194 
20195 			if (SATA_PMPORTINFO_DRV_INFO(pmportinfo) != NULL) {
20196 				sata_drive_info_t new_sdinfo;
20197 
20198 				/* Log device info data */
20199 				new_sdinfo = *(SATA_PMPORTINFO_DRV_INFO(
20200 				    pmportinfo));
20201 				sata_show_drive_info(sata_hba_inst,
20202 				    &new_sdinfo);
20203 			}
20204 
20205 			mutex_exit(&pmportinfo->pmport_mutex);
20206 
20207 			/*
20208 			 * Make sure that there is no target node for that
20209 			 * device. If so, release it. It should not happen,
20210 			 * unless we had problem removing the node when
20211 			 * device was detached.
20212 			 */
20213 			tdip = sata_get_target_dip(SATA_DIP(sata_hba_inst),
20214 			    saddr->cport, saddr->pmport);
20215 			mutex_enter(&pmportinfo->pmport_mutex);
20216 			if (tdip != NULL) {
20217 
20218 #ifdef SATA_DEBUG
20219 				if ((pmportinfo->pmport_event_flags &
20220 				    SATA_EVNT_TARGET_NODE_CLEANUP) == 0)
20221 					sata_log(sata_hba_inst, CE_WARN,
20222 					    "sata_process_device_attached: "
20223 					    "old device target node exists!");
20224 #endif
20225 				/*
20226 				 * target node exists - try to unconfigure
20227 				 * device and remove the node.
20228 				 */
20229 				mutex_exit(&pmportinfo->pmport_mutex);
20230 				rval = ndi_devi_offline(tdip,
20231 				    NDI_DEVI_REMOVE);
20232 				mutex_enter(&pmportinfo->pmport_mutex);
20233 
20234 				if (rval == NDI_SUCCESS) {
20235 					pmportinfo->pmport_event_flags &=
20236 					    ~SATA_EVNT_TARGET_NODE_CLEANUP;
20237 					pmportinfo->pmport_tgtnode_clean =
20238 					    B_TRUE;
20239 				} else {
20240 					/*
20241 					 * PROBLEM - the target node remained
20242 					 * and it belongs to a previously
20243 					 * attached device.
20244 					 * This happens when the file was open
20245 					 * or the node was waiting for
20246 					 * resources at the time the
20247 					 * associated device was removed.
20248 					 * Instruct event daemon to retry the
20249 					 * cleanup later.
20250 					 */
20251 					sata_log(sata_hba_inst,
20252 					    CE_WARN,
20253 					    "Application(s) accessing "
20254 					    "previously attached SATA "
20255 					    "device have to release "
20256 					    "it before newly inserted "
20257 					    "device can be made accessible."
20258 					    "at port %d:%d",
20259 					    cport, pmport);
20260 					pmportinfo->pmport_event_flags |=
20261 					    SATA_EVNT_TARGET_NODE_CLEANUP;
20262 					pmportinfo->pmport_tgtnode_clean =
20263 					    B_FALSE;
20264 				}
20265 			}
20266 			if (sata_auto_online != 0) {
20267 				pmportinfo->pmport_event_flags |=
20268 				    SATA_EVNT_AUTOONLINE_DEVICE;
20269 			}
20270 
20271 		}
20272 	} else {
20273 		pmportinfo->pmport_dev_attach_time = 0;
20274 	}
20275 
20276 	event_flags = pmportinfo->pmport_event_flags;
20277 	mutex_exit(&pmportinfo->pmport_mutex);
20278 	if (event_flags != 0) {
20279 		mutex_enter(&sata_hba_inst->satahba_mutex);
20280 		sata_hba_inst->satahba_event_flags |= SATA_EVNT_MAIN;
20281 		mutex_exit(&sata_hba_inst->satahba_mutex);
20282 		mutex_enter(&sata_mutex);
20283 		sata_event_pending |= SATA_EVNT_MAIN;
20284 		mutex_exit(&sata_mutex);
20285 	}
20286 
20287 	/* clear the reset_in_progress events */
20288 	if (SATA_PMPORTINFO_DRV_INFO(pmportinfo) != NULL) {
20289 		if (pmportinfo->pmport_dev_type & SATA_VALID_DEV_TYPE) {
20290 			/* must clear flags on cport */
20291 			sata_pmult_info_t *pminfo =
20292 			    SATA_PMULT_INFO(sata_hba_inst,
20293 			    saddr->cport);
20294 			pminfo->pmult_event_flags |=
20295 			    SATA_EVNT_CLEAR_DEVICE_RESET;
20296 		}
20297 	}
20298 }
20299 
20300 /*
20301  * Device Target Node Cleanup Event processing.
20302  * If the target node associated with a sata port device is in
20303  * DEVI_DEVICE_REMOVED state, an attempt is made to remove it.
20304  * If the target node cannot be removed, the event flag is left intact,
20305  * so that event daemon may re-run this function later.
20306  *
20307  * This function cannot be called in interrupt context (it may sleep).
20308  *
20309  * NOTE: Processes cport events only, not port multiplier ports.
20310  */
20311 static void
20312 sata_process_target_node_cleanup(sata_hba_inst_t *sata_hba_inst,
20313     sata_address_t *saddr)
20314 {
20315 	sata_cport_info_t *cportinfo;
20316 	dev_info_t *tdip;
20317 
20318 	SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst,
20319 	    "Processing port %d device target node cleanup", saddr->cport);
20320 
20321 	cportinfo = SATA_CPORT_INFO(sata_hba_inst, saddr->cport);
20322 
20323 	/*
20324 	 * Check if there is target node for that device and it is in the
20325 	 * DEVI_DEVICE_REMOVED state. If so, release it.
20326 	 */
20327 	tdip = sata_get_target_dip(SATA_DIP(sata_hba_inst), saddr->cport,
20328 	    saddr->pmport);
20329 	if (tdip != NULL) {
20330 		/*
20331 		 * target node exists - check if it is target node of
20332 		 * a removed device.
20333 		 */
20334 		if (sata_check_device_removed(tdip) == B_TRUE) {
20335 			SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst,
20336 			    "sata_process_target_node_cleanup: "
20337 			    "old device target node exists!", NULL);
20338 			/*
20339 			 * Unconfigure and remove the target node
20340 			 */
20341 			if (ndi_devi_offline(tdip, NDI_DEVI_REMOVE) ==
20342 			    NDI_SUCCESS) {
20343 				mutex_enter(&SATA_CPORT_INFO(sata_hba_inst,
20344 				    saddr->cport)->cport_mutex);
20345 				cportinfo->cport_event_flags &=
20346 				    ~SATA_EVNT_TARGET_NODE_CLEANUP;
20347 				mutex_exit(&SATA_CPORT_INFO(sata_hba_inst,
20348 				    saddr->cport)->cport_mutex);
20349 				return;
20350 			}
20351 			/*
20352 			 * Event daemon will retry the cleanup later.
20353 			 */
20354 			mutex_enter(&sata_hba_inst->satahba_mutex);
20355 			sata_hba_inst->satahba_event_flags |= SATA_EVNT_MAIN;
20356 			mutex_exit(&sata_hba_inst->satahba_mutex);
20357 			mutex_enter(&sata_mutex);
20358 			sata_event_pending |= SATA_EVNT_MAIN;
20359 			mutex_exit(&sata_mutex);
20360 		}
20361 	} else {
20362 		if (saddr->qual == SATA_ADDR_CPORT ||
20363 		    saddr->qual == SATA_ADDR_DCPORT) {
20364 			mutex_enter(&SATA_CPORT_INFO(sata_hba_inst,
20365 			    saddr->cport)->cport_mutex);
20366 			cportinfo->cport_event_flags &=
20367 			    ~SATA_EVNT_TARGET_NODE_CLEANUP;
20368 			mutex_exit(&SATA_CPORT_INFO(sata_hba_inst,
20369 			    saddr->cport)->cport_mutex);
20370 		} else {
20371 			/* sanity check */
20372 			if (SATA_CPORT_DEV_TYPE(sata_hba_inst, saddr->cport) !=
20373 			    SATA_DTYPE_PMULT || SATA_PMULT_INFO(sata_hba_inst,
20374 			    saddr->cport) == NULL)
20375 				return;
20376 			if (SATA_PMPORT_INFO(sata_hba_inst, saddr->cport,
20377 			    saddr->pmport) == NULL)
20378 				return;
20379 
20380 			mutex_enter(&SATA_PMPORT_INFO(sata_hba_inst,
20381 			    saddr->cport, saddr->pmport)->pmport_mutex);
20382 			SATA_PMPORT_INFO(sata_hba_inst, saddr->cport,
20383 			    saddr->pmport)->pmport_event_flags &=
20384 			    ~SATA_EVNT_TARGET_NODE_CLEANUP;
20385 			mutex_exit(&SATA_PMPORT_INFO(sata_hba_inst,
20386 			    saddr->cport, saddr->pmport)->pmport_mutex);
20387 		}
20388 	}
20389 }
20390 
20391 /*
20392  * Device AutoOnline Event processing.
20393  * If attached device is to be onlined, an attempt is made to online this
20394  * device, but only if there is no lingering (old) target node present.
20395  * If the device cannot be onlined, the event flag is left intact,
20396  * so that event daemon may re-run this function later.
20397  *
20398  * This function cannot be called in interrupt context (it may sleep).
20399  *
20400  * NOTE: Processes cport events only, not port multiplier ports.
20401  */
20402 static void
20403 sata_process_device_autoonline(sata_hba_inst_t *sata_hba_inst,
20404     sata_address_t *saddr)
20405 {
20406 	sata_cport_info_t *cportinfo;
20407 	sata_drive_info_t *sdinfo;
20408 	sata_device_t sata_device;
20409 	dev_info_t *tdip;
20410 
20411 	SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst,
20412 	    "Processing port %d attached device auto-onlining", saddr->cport);
20413 
20414 	cportinfo = SATA_CPORT_INFO(sata_hba_inst, saddr->cport);
20415 
20416 	/*
20417 	 * Check if device is present and recognized. If not, reset event.
20418 	 */
20419 	mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex);
20420 	if ((cportinfo->cport_dev_type & SATA_VALID_DEV_TYPE) == 0) {
20421 		/* Nothing to online */
20422 		cportinfo->cport_event_flags &= ~SATA_EVNT_AUTOONLINE_DEVICE;
20423 		mutex_exit(&SATA_CPORT_INFO(sata_hba_inst,
20424 		    saddr->cport)->cport_mutex);
20425 		return;
20426 	}
20427 	mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex);
20428 
20429 	/*
20430 	 * Check if there is target node for this device and if it is in the
20431 	 * DEVI_DEVICE_REMOVED state. If so, abort onlining but keep
20432 	 * the event for later processing.
20433 	 */
20434 	tdip = sata_get_target_dip(SATA_DIP(sata_hba_inst), saddr->cport,
20435 	    saddr->pmport);
20436 	if (tdip != NULL) {
20437 		/*
20438 		 * target node exists - check if it is target node of
20439 		 * a removed device.
20440 		 */
20441 		if (sata_check_device_removed(tdip) == B_TRUE) {
20442 			SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst,
20443 			    "sata_process_device_autoonline: "
20444 			    "old device target node exists!", NULL);
20445 			/*
20446 			 * Event daemon will retry device onlining later.
20447 			 */
20448 			mutex_enter(&sata_hba_inst->satahba_mutex);
20449 			sata_hba_inst->satahba_event_flags |= SATA_EVNT_MAIN;
20450 			mutex_exit(&sata_hba_inst->satahba_mutex);
20451 			mutex_enter(&sata_mutex);
20452 			sata_event_pending |= SATA_EVNT_MAIN;
20453 			mutex_exit(&sata_mutex);
20454 			return;
20455 		}
20456 		/*
20457 		 * If the target node is not in the 'removed" state, assume
20458 		 * that it belongs to this device. There is nothing more to do,
20459 		 * but reset the event.
20460 		 */
20461 	} else {
20462 
20463 		/*
20464 		 * Try to online the device
20465 		 * If there is any reset-related event, remove it. We are
20466 		 * configuring the device and no state restoring is needed.
20467 		 */
20468 		mutex_enter(&SATA_CPORT_INFO(sata_hba_inst,
20469 		    saddr->cport)->cport_mutex);
20470 		sata_device.satadev_addr = *saddr;
20471 		if (saddr->qual == SATA_ADDR_CPORT)
20472 			sata_device.satadev_addr.qual = SATA_ADDR_DCPORT;
20473 		else
20474 			sata_device.satadev_addr.qual = SATA_ADDR_DPMPORT;
20475 		sdinfo = sata_get_device_info(sata_hba_inst, &sata_device);
20476 		if (sdinfo != NULL) {
20477 			if (sdinfo->satadrv_event_flags &
20478 			    (SATA_EVNT_DEVICE_RESET |
20479 			    SATA_EVNT_INPROC_DEVICE_RESET))
20480 				sdinfo->satadrv_event_flags = 0;
20481 			sdinfo->satadrv_event_flags |=
20482 			    SATA_EVNT_CLEAR_DEVICE_RESET;
20483 
20484 			/* Need to create a new target node. */
20485 			cportinfo->cport_tgtnode_clean = B_TRUE;
20486 			mutex_exit(&SATA_CPORT_INFO(sata_hba_inst,
20487 			    saddr->cport)->cport_mutex);
20488 			tdip = sata_create_target_node(SATA_DIP(sata_hba_inst),
20489 			    sata_hba_inst, &sata_device.satadev_addr);
20490 			if (tdip == NULL) {
20491 				/*
20492 				 * Configure (onlining) failed.
20493 				 * We will NOT retry
20494 				 */
20495 				SATA_LOG_D((sata_hba_inst, CE_WARN,
20496 				    "sata_process_device_autoonline: "
20497 				    "configuring SATA device at port %d failed",
20498 				    saddr->cport));
20499 			}
20500 		} else {
20501 			mutex_exit(&SATA_CPORT_INFO(sata_hba_inst,
20502 			    saddr->cport)->cport_mutex);
20503 		}
20504 
20505 	}
20506 	mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex);
20507 	cportinfo->cport_event_flags &= ~SATA_EVNT_AUTOONLINE_DEVICE;
20508 	mutex_exit(&SATA_CPORT_INFO(sata_hba_inst,
20509 	    saddr->cport)->cport_mutex);
20510 }
20511 
20512 
20513 static void
20514 sata_gen_sysevent(sata_hba_inst_t *sata_hba_inst, sata_address_t *saddr,
20515     int hint)
20516 {
20517 	char ap[MAXPATHLEN];
20518 	nvlist_t *ev_attr_list = NULL;
20519 	int err;
20520 
20521 	/* Allocate and build sysevent attribute list */
20522 	err = nvlist_alloc(&ev_attr_list, NV_UNIQUE_NAME_TYPE, DDI_NOSLEEP);
20523 	if (err != 0) {
20524 		SATA_LOG_D((sata_hba_inst, CE_WARN,
20525 		    "sata_gen_sysevent: "
20526 		    "cannot allocate memory for sysevent attributes\n"));
20527 		return;
20528 	}
20529 	/* Add hint attribute */
20530 	err = nvlist_add_string(ev_attr_list, DR_HINT, SE_HINT2STR(hint));
20531 	if (err != 0) {
20532 		SATA_LOG_D((sata_hba_inst, CE_WARN,
20533 		    "sata_gen_sysevent: "
20534 		    "failed to add DR_HINT attr for sysevent"));
20535 		nvlist_free(ev_attr_list);
20536 		return;
20537 	}
20538 	/*
20539 	 * Add AP attribute.
20540 	 * Get controller pathname and convert it into AP pathname by adding
20541 	 * a target number.
20542 	 */
20543 	(void) snprintf(ap, MAXPATHLEN, "/devices");
20544 	(void) ddi_pathname(SATA_DIP(sata_hba_inst), ap + strlen(ap));
20545 	(void) snprintf(ap + strlen(ap), MAXPATHLEN - strlen(ap), ":%d",
20546 	    SATA_MAKE_AP_NUMBER(saddr->cport, saddr->pmport, saddr->qual));
20547 
20548 	err = nvlist_add_string(ev_attr_list, DR_AP_ID, ap);
20549 	if (err != 0) {
20550 		SATA_LOG_D((sata_hba_inst, CE_WARN,
20551 		    "sata_gen_sysevent: "
20552 		    "failed to add DR_AP_ID attr for sysevent"));
20553 		nvlist_free(ev_attr_list);
20554 		return;
20555 	}
20556 
20557 	/* Generate/log sysevent */
20558 	err = ddi_log_sysevent(SATA_DIP(sata_hba_inst), DDI_VENDOR_SUNW, EC_DR,
20559 	    ESC_DR_AP_STATE_CHANGE, ev_attr_list, NULL, DDI_NOSLEEP);
20560 	if (err != DDI_SUCCESS) {
20561 		SATA_LOG_D((sata_hba_inst, CE_WARN,
20562 		    "sata_gen_sysevent: "
20563 		    "cannot log sysevent, err code %x\n", err));
20564 	}
20565 
20566 	nvlist_free(ev_attr_list);
20567 }
20568 
20569 
20570 
20571 
20572 /*
20573  * Set DEVI_DEVICE_REMOVED state in the SATA device target node.
20574  */
20575 static void
20576 sata_set_device_removed(dev_info_t *tdip)
20577 {
20578 	int circ;
20579 
20580 	ASSERT(tdip != NULL);
20581 
20582 	ndi_devi_enter(tdip, &circ);
20583 	mutex_enter(&DEVI(tdip)->devi_lock);
20584 	DEVI_SET_DEVICE_REMOVED(tdip);
20585 	mutex_exit(&DEVI(tdip)->devi_lock);
20586 	ndi_devi_exit(tdip, circ);
20587 }
20588 
20589 
20590 /*
20591  * Set internal event instructing event daemon to try
20592  * to perform the target node cleanup.
20593  */
20594 static void
20595 sata_set_target_node_cleanup(sata_hba_inst_t *sata_hba_inst,
20596     sata_address_t *saddr)
20597 {
20598 	if (saddr->qual == SATA_ADDR_CPORT ||
20599 	    saddr->qual == SATA_ADDR_DCPORT) {
20600 		mutex_enter(&SATA_CPORT_INFO(sata_hba_inst,
20601 		    saddr->cport)->cport_mutex);
20602 		SATA_CPORT_EVENT_FLAGS(sata_hba_inst, saddr->cport) |=
20603 		    SATA_EVNT_TARGET_NODE_CLEANUP;
20604 		SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->
20605 		    cport_tgtnode_clean = B_FALSE;
20606 		mutex_exit(&SATA_CPORT_INFO(sata_hba_inst,
20607 		    saddr->cport)->cport_mutex);
20608 	} else {
20609 		mutex_enter(&SATA_PMPORT_INFO(sata_hba_inst,
20610 		    saddr->cport, saddr->pmport)->pmport_mutex);
20611 		SATA_PMPORT_EVENT_FLAGS(sata_hba_inst, saddr->cport,
20612 		    saddr->pmport) |= SATA_EVNT_TARGET_NODE_CLEANUP;
20613 		SATA_PMPORT_INFO(sata_hba_inst, saddr->cport, saddr->pmport)->
20614 		    pmport_tgtnode_clean = B_FALSE;
20615 		mutex_exit(&SATA_PMPORT_INFO(sata_hba_inst,
20616 		    saddr->cport, saddr->pmport)->pmport_mutex);
20617 	}
20618 	mutex_enter(&sata_hba_inst->satahba_mutex);
20619 	sata_hba_inst->satahba_event_flags |= SATA_EVNT_MAIN;
20620 	mutex_exit(&sata_hba_inst->satahba_mutex);
20621 	mutex_enter(&sata_mutex);
20622 	sata_event_pending |= SATA_EVNT_MAIN;
20623 	mutex_exit(&sata_mutex);
20624 }
20625 
20626 
20627 /*
20628  * Check if the SATA device target node is in DEVI_DEVICE_REMOVED state,
20629  * i.e. check if the target node state indicates that it belongs to a removed
20630  * device.
20631  *
20632  * Returns B_TRUE if the target node is in DEVI_DEVICE_REMOVED state,
20633  * B_FALSE otherwise.
20634  */
20635 static boolean_t
20636 sata_check_device_removed(dev_info_t *tdip)
20637 {
20638 	ASSERT(tdip != NULL);
20639 
20640 	if (DEVI_IS_DEVICE_REMOVED(tdip))
20641 		return (B_TRUE);
20642 	else
20643 		return (B_FALSE);
20644 }
20645 
20646 
20647 /*
20648  * Check for DMA error. Return B_TRUE if error, B_FALSE otherwise.
20649  */
20650 static boolean_t
20651 sata_check_for_dma_error(dev_info_t *dip, sata_pkt_txlate_t *spx)
20652 {
20653 	int fm_capability = ddi_fm_capable(dip);
20654 	ddi_fm_error_t de;
20655 
20656 	if (fm_capability & DDI_FM_DMACHK_CAPABLE) {
20657 		if (spx->txlt_buf_dma_handle != NULL) {
20658 			ddi_fm_dma_err_get(spx->txlt_buf_dma_handle, &de,
20659 			    DDI_FME_VERSION);
20660 			if (de.fme_status != DDI_SUCCESS)
20661 				return (B_TRUE);
20662 		}
20663 	}
20664 	return (B_FALSE);
20665 }
20666 
20667 
20668 /* ************************ FAULT INJECTTION **************************** */
20669 
20670 #ifdef SATA_INJECT_FAULTS
20671 
20672 static	uint32_t sata_fault_count = 0;
20673 static	uint32_t sata_fault_suspend_count = 0;
20674 
20675 /*
20676  * Inject sata pkt fault
20677  * It modifies returned values of the sata packet.
20678  * It returns immediately if:
20679  * pkt fault injection is not enabled (via sata_inject_fault,
20680  * sata_inject_fault_count), or invalid fault is specified (sata_fault_type),
20681  * or pkt does not contain command to be faulted (set in sata_fault_cmd), or
20682  * pkt is not directed to specified fault controller/device
20683  * (sata_fault_ctrl_dev and sata_fault_device).
20684  * If fault controller is not specified, fault injection applies to all
20685  * controllers and devices.
20686  *
20687  * First argument is the pointer to the executed sata packet.
20688  * Second argument is a pointer to a value returned by the HBA tran_start
20689  * function.
20690  * Third argument specifies injected error. Injected sata packet faults
20691  * are the satapkt_reason values.
20692  * SATA_PKT_BUSY		-1	Not completed, busy
20693  * SATA_PKT_DEV_ERROR		1	Device reported error
20694  * SATA_PKT_QUEUE_FULL		2	Not accepted, queue full
20695  * SATA_PKT_PORT_ERROR		3	Not completed, port error
20696  * SATA_PKT_CMD_UNSUPPORTED	4	Cmd unsupported
20697  * SATA_PKT_ABORTED		5	Aborted by request
20698  * SATA_PKT_TIMEOUT		6	Operation timeut
20699  * SATA_PKT_RESET		7	Aborted by reset request
20700  *
20701  * Additional global variables affecting the execution:
20702  *
20703  * sata_inject_fault_count variable specifies number of times in row the
20704  * error is injected. Value of -1 specifies permanent fault, ie. every time
20705  * the fault injection point is reached, the fault is injected and a pause
20706  * between fault injection specified by sata_inject_fault_pause_count is
20707  * ignored). Fault injection routine decrements sata_inject_fault_count
20708  * (if greater than zero) until it reaches 0. No fault is injected when
20709  * sata_inject_fault_count is 0 (zero).
20710  *
20711  * sata_inject_fault_pause_count variable specifies number of times a fault
20712  * injection is bypassed (pause between fault injections).
20713  * If set to 0, a fault is injected only a number of times specified by
20714  * sata_inject_fault_count.
20715  *
20716  * The fault counts are static, so for periodic errors they have to be manually
20717  * reset to start repetition sequence from scratch.
20718  * If the original value returned by the HBA tran_start function is not
20719  * SATA_TRAN_ACCEPTED and pkt reason is not SATA_PKT_COMPLETED, no error
20720  * is injected (to avoid masking real problems);
20721  *
20722  * NOTE: In its current incarnation, this function should be invoked only for
20723  * commands executed in SYNCHRONOUS mode.
20724  */
20725 
20726 
20727 static void
20728 sata_inject_pkt_fault(sata_pkt_t *spkt, int *rval, int fault)
20729 {
20730 
20731 	if (sata_inject_fault != SATA_INJECT_PKT_FAULT)
20732 		return;
20733 
20734 	if (sata_inject_fault_count == 0)
20735 		return;
20736 
20737 	if (fault == 0)
20738 		return;
20739 
20740 	if (sata_fault_cmd != spkt->satapkt_cmd.satacmd_cmd_reg)
20741 		return;
20742 
20743 	if (sata_fault_ctrl != NULL) {
20744 		sata_pkt_txlate_t *spx =
20745 		    (sata_pkt_txlate_t *)spkt->satapkt_framework_private;
20746 
20747 		if (sata_fault_ctrl != NULL && sata_fault_ctrl !=
20748 		    spx->txlt_sata_hba_inst->satahba_dip)
20749 			return;
20750 
20751 		if (sata_fault_device.satadev_addr.cport !=
20752 		    spkt->satapkt_device.satadev_addr.cport ||
20753 		    sata_fault_device.satadev_addr.pmport !=
20754 		    spkt->satapkt_device.satadev_addr.pmport ||
20755 		    sata_fault_device.satadev_addr.qual !=
20756 		    spkt->satapkt_device.satadev_addr.qual)
20757 			return;
20758 	}
20759 
20760 	/* Modify pkt return parameters */
20761 	if (*rval != SATA_TRAN_ACCEPTED ||
20762 	    spkt->satapkt_reason != SATA_PKT_COMPLETED) {
20763 		sata_fault_count = 0;
20764 		sata_fault_suspend_count = 0;
20765 		return;
20766 	}
20767 	if (sata_fault_count == 0 && sata_fault_suspend_count != 0) {
20768 		/* Pause in the injection */
20769 		sata_fault_suspend_count -= 1;
20770 		return;
20771 	}
20772 
20773 	if (sata_fault_count == 0 && sata_fault_suspend_count == 0) {
20774 		/*
20775 		 * Init inject fault cycle. If fault count is set to -1,
20776 		 * it is a permanent fault.
20777 		 */
20778 		if (sata_inject_fault_count != -1) {
20779 			sata_fault_count = sata_inject_fault_count;
20780 			sata_fault_suspend_count =
20781 			    sata_inject_fault_pause_count;
20782 			if (sata_fault_suspend_count == 0)
20783 				sata_inject_fault_count = 0;
20784 		}
20785 	}
20786 
20787 	if (sata_fault_count != 0)
20788 		sata_fault_count -= 1;
20789 
20790 	switch (fault) {
20791 	case SATA_PKT_BUSY:
20792 		*rval = SATA_TRAN_BUSY;
20793 		spkt->satapkt_reason = SATA_PKT_BUSY;
20794 		break;
20795 
20796 	case SATA_PKT_QUEUE_FULL:
20797 		*rval = SATA_TRAN_QUEUE_FULL;
20798 		spkt->satapkt_reason = SATA_PKT_QUEUE_FULL;
20799 		break;
20800 
20801 	case SATA_PKT_CMD_UNSUPPORTED:
20802 		*rval = SATA_TRAN_CMD_UNSUPPORTED;
20803 		spkt->satapkt_reason = SATA_PKT_CMD_UNSUPPORTED;
20804 		break;
20805 
20806 	case SATA_PKT_PORT_ERROR:
20807 		/* This is "rejected" command */
20808 		*rval = SATA_TRAN_PORT_ERROR;
20809 		spkt->satapkt_reason = SATA_PKT_PORT_ERROR;
20810 		/* Additional error setup could be done here - port state */
20811 		break;
20812 
20813 	case SATA_PKT_DEV_ERROR:
20814 		spkt->satapkt_reason = SATA_PKT_DEV_ERROR;
20815 		/*
20816 		 * Additional error setup could be done here
20817 		 */
20818 		break;
20819 
20820 	case SATA_PKT_ABORTED:
20821 		spkt->satapkt_reason = SATA_PKT_ABORTED;
20822 		break;
20823 
20824 	case SATA_PKT_TIMEOUT:
20825 		spkt->satapkt_reason = SATA_PKT_TIMEOUT;
20826 		/* Additional error setup could be done here */
20827 		break;
20828 
20829 	case SATA_PKT_RESET:
20830 		spkt->satapkt_reason = SATA_PKT_RESET;
20831 		/*
20832 		 * Additional error setup could be done here - device reset
20833 		 */
20834 		break;
20835 
20836 	default:
20837 		break;
20838 	}
20839 }
20840 
20841 #endif
20842 
20843 /*
20844  * SATA Trace Ring Buffer
20845  * ----------------------
20846  *
20847  * Overview
20848  *
20849  * The SATA trace ring buffer is a ring buffer created and managed by
20850  * the SATA framework module that can be used by any module or driver
20851  * within the SATA framework to store debug messages.
20852  *
20853  * Ring Buffer Interfaces:
20854  *
20855  *	sata_vtrace_debug()	<-- Adds debug message to ring buffer
20856  *	sata_trace_debug()	<-- Wraps varargs into sata_vtrace_debug()
20857  *
20858  *	Note that the sata_trace_debug() interface was created to give
20859  *	consumers the flexibilty of sending debug messages to ring buffer
20860  *	as variable arguments.  Consumers can send type va_list debug
20861  *	messages directly to sata_vtrace_debug(). The sata_trace_debug()
20862  *	and sata_vtrace_debug() relationship is similar to that of
20863  *	cmn_err(9F) and vcmn_err(9F).
20864  *
20865  * Below is a diagram of the SATA trace ring buffer interfaces and
20866  * sample consumers:
20867  *
20868  * +---------------------------------+
20869  * |    o  o  SATA Framework Module  |
20870  * | o  SATA  o     +------------------+      +------------------+
20871  * |o   Trace  o <--|sata_vtrace_debug/|<-----|SATA HBA Driver #1|
20872  * |o   R-Buf  o    |sata_trace_debug  |<--+  +------------------+
20873  * | o        o     +------------------+   |  +------------------+
20874  * |    o  o                ^        |     +--|SATA HBA Driver #2|
20875  * |                        |        |        +------------------+
20876  * |           +------------------+  |
20877  * |           |SATA Debug Message|  |
20878  * |           +------------------+  |
20879  * +---------------------------------+
20880  *
20881  * Supporting Routines:
20882  *
20883  *	sata_trace_rbuf_alloc()	<-- Initializes ring buffer
20884  *	sata_trace_rbuf_free()	<-- Destroys ring buffer
20885  *	sata_trace_dmsg_alloc() <-- Creates or reuses buffer in ring buffer
20886  *	sata_trace_dmsg_free()	<-- Destroys content of ring buffer
20887  *
20888  * The default SATA trace ring buffer size is defined by DMSG_RING_SIZE.
20889  * The ring buffer size can be adjusted by setting dmsg_ring_size in
20890  * /etc/system to desired size in unit of bytes.
20891  *
20892  * The individual debug message size in the ring buffer is restricted
20893  * to DMSG_BUF_SIZE.
20894  */
20895 void
20896 sata_vtrace_debug(dev_info_t *dip, const char *fmt, va_list ap)
20897 {
20898 	sata_trace_dmsg_t *dmsg;
20899 
20900 	if (sata_debug_rbuf == NULL) {
20901 		return;
20902 	}
20903 
20904 	/*
20905 	 * If max size of ring buffer is smaller than size
20906 	 * required for one debug message then just return
20907 	 * since we have no room for the debug message.
20908 	 */
20909 	if (sata_debug_rbuf->maxsize < (sizeof (sata_trace_dmsg_t))) {
20910 		return;
20911 	}
20912 
20913 	mutex_enter(&sata_debug_rbuf->lock);
20914 
20915 	/* alloc or reuse on ring buffer */
20916 	dmsg = sata_trace_dmsg_alloc();
20917 
20918 	if (dmsg == NULL) {
20919 		/* resource allocation failed */
20920 		mutex_exit(&sata_debug_rbuf->lock);
20921 		return;
20922 	}
20923 
20924 	dmsg->dip = dip;
20925 	gethrestime(&dmsg->timestamp);
20926 
20927 	(void) vsnprintf(dmsg->buf, sizeof (dmsg->buf), fmt, ap);
20928 
20929 	mutex_exit(&sata_debug_rbuf->lock);
20930 }
20931 
20932 void
20933 sata_trace_debug(dev_info_t *dip, const char *fmt, ...)
20934 {
20935 	va_list ap;
20936 
20937 	va_start(ap, fmt);
20938 	sata_vtrace_debug(dip, fmt, ap);
20939 	va_end(ap);
20940 }
20941 
20942 /*
20943  * This routine is used to manage debug messages
20944  * on ring buffer.
20945  */
20946 static sata_trace_dmsg_t *
20947 sata_trace_dmsg_alloc(void)
20948 {
20949 	sata_trace_dmsg_t *dmsg_alloc, *dmsg = sata_debug_rbuf->dmsgp;
20950 
20951 	if (sata_debug_rbuf->looped == TRUE) {
20952 		sata_debug_rbuf->dmsgp = dmsg->next;
20953 		return (sata_debug_rbuf->dmsgp);
20954 	}
20955 
20956 	/*
20957 	 * If we're looping for the first time,
20958 	 * connect the ring.
20959 	 */
20960 	if (((sata_debug_rbuf->size + (sizeof (sata_trace_dmsg_t))) >
20961 	    sata_debug_rbuf->maxsize) && (sata_debug_rbuf->dmsgh != NULL)) {
20962 		dmsg->next = sata_debug_rbuf->dmsgh;
20963 		sata_debug_rbuf->dmsgp = sata_debug_rbuf->dmsgh;
20964 		sata_debug_rbuf->looped = TRUE;
20965 		return (sata_debug_rbuf->dmsgp);
20966 	}
20967 
20968 	/* If we've gotten this far then memory allocation is needed */
20969 	dmsg_alloc = kmem_zalloc(sizeof (sata_trace_dmsg_t), KM_NOSLEEP);
20970 	if (dmsg_alloc == NULL) {
20971 		sata_debug_rbuf->allocfailed++;
20972 		return (dmsg_alloc);
20973 	} else {
20974 		sata_debug_rbuf->size += sizeof (sata_trace_dmsg_t);
20975 	}
20976 
20977 	if (sata_debug_rbuf->dmsgp != NULL) {
20978 		dmsg->next = dmsg_alloc;
20979 		sata_debug_rbuf->dmsgp = dmsg->next;
20980 		return (sata_debug_rbuf->dmsgp);
20981 	} else {
20982 		/*
20983 		 * We should only be here if we're initializing
20984 		 * the ring buffer.
20985 		 */
20986 		if (sata_debug_rbuf->dmsgh == NULL) {
20987 			sata_debug_rbuf->dmsgh = dmsg_alloc;
20988 		} else {
20989 			/* Something is wrong */
20990 			kmem_free(dmsg_alloc, sizeof (sata_trace_dmsg_t));
20991 			return (NULL);
20992 		}
20993 
20994 		sata_debug_rbuf->dmsgp = dmsg_alloc;
20995 		return (sata_debug_rbuf->dmsgp);
20996 	}
20997 }
20998 
20999 
21000 /*
21001  * Free all messages on debug ring buffer.
21002  */
21003 static void
21004 sata_trace_dmsg_free(void)
21005 {
21006 	sata_trace_dmsg_t *dmsg_next, *dmsg = sata_debug_rbuf->dmsgh;
21007 
21008 	while (dmsg != NULL) {
21009 		dmsg_next = dmsg->next;
21010 		kmem_free(dmsg, sizeof (sata_trace_dmsg_t));
21011 
21012 		/*
21013 		 * If we've looped around the ring than we're done.
21014 		 */
21015 		if (dmsg_next == sata_debug_rbuf->dmsgh) {
21016 			break;
21017 		} else {
21018 			dmsg = dmsg_next;
21019 		}
21020 	}
21021 }
21022 
21023 
21024 /*
21025  * This function can block
21026  */
21027 static void
21028 sata_trace_rbuf_alloc(void)
21029 {
21030 	sata_debug_rbuf = kmem_zalloc(sizeof (sata_trace_rbuf_t), KM_SLEEP);
21031 
21032 	mutex_init(&sata_debug_rbuf->lock, NULL, MUTEX_DRIVER, NULL);
21033 
21034 	if (dmsg_ring_size > 0) {
21035 		sata_debug_rbuf->maxsize = (size_t)dmsg_ring_size;
21036 	}
21037 }
21038 
21039 
21040 static void
21041 sata_trace_rbuf_free(void)
21042 {
21043 	sata_trace_dmsg_free();
21044 	mutex_destroy(&sata_debug_rbuf->lock);
21045 	kmem_free(sata_debug_rbuf, sizeof (sata_trace_rbuf_t));
21046 }
21047 
21048 /*
21049  * If SATA_DEBUG is not defined then this routine is called instead
21050  * of sata_log() via the SATA_LOG_D macro.
21051  */
21052 static void
21053 sata_trace_log(sata_hba_inst_t *sata_hba_inst, uint_t level,
21054     const char *fmt, ...)
21055 {
21056 #ifndef __lock_lint
21057 	_NOTE(ARGUNUSED(level))
21058 #endif
21059 
21060 	dev_info_t *dip = NULL;
21061 	va_list ap;
21062 
21063 	if (sata_hba_inst != NULL) {
21064 		dip = SATA_DIP(sata_hba_inst);
21065 	}
21066 
21067 	va_start(ap, fmt);
21068 	sata_vtrace_debug(dip, fmt, ap);
21069 	va_end(ap);
21070 }
21071