xref: /titanic_50/usr/src/uts/common/io/sata/impl/sata.c (revision 7b2cbac6bdd0f33171865b3ab8e08e8528c60d2c) 
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 2008 Sun Microsystems, Inc.  All rights reserved.
24  * Use is subject to license terms.
25  */
26 
27 #pragma ident	"%Z%%M%	%I%	%E% SMI"
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 
49 #include <sys/sata/impl/sata.h>
50 #include <sys/sata/sata_hba.h>
51 #include <sys/sata/sata_defs.h>
52 #include <sys/sata/sata_cfgadm.h>
53 
54 /* Debug flags - defined in sata.h */
55 int	sata_debug_flags = 0;
56 int	sata_msg = 0;
57 
58 /*
59  * Flags enabling selected SATA HBA framework functionality
60  */
61 #define	SATA_ENABLE_QUEUING		1
62 #define	SATA_ENABLE_NCQ			2
63 #define	SATA_ENABLE_PROCESS_EVENTS	4
64 int sata_func_enable =
65 	SATA_ENABLE_PROCESS_EVENTS | SATA_ENABLE_QUEUING | SATA_ENABLE_NCQ;
66 
67 /*
68  * Global variable setting default maximum queue depth (NCQ or TCQ)
69  * Note:minimum queue depth is 1
70  */
71 int sata_max_queue_depth = SATA_MAX_QUEUE_DEPTH; /* max NCQ/TCQ queue depth */
72 
73 /*
74  * Currently used default NCQ/TCQ queue depth. It is set-up during the driver
75  * initialization, using value from sata_max_queue_depth
76  * It is adjusted to minimum supported by the controller and by the device,
77  * if queueing is enabled.
78  */
79 static	int sata_current_max_qdepth;
80 
81 /*
82  * Global variable determining the default behavior after device hotpluggin.
83  * If non-zero, the hotplugged device is onlined (if possible) without explicit
84  * IOCTL request (AP_CONFIGURE).
85  * If zero, hotplugged device is identified, but not onlined.
86  * Enabling (AP_CONNECT) device port with an attached device does not result
87  * in device onlining regardless of the flag setting
88  */
89 int sata_auto_online = 0;
90 
91 #ifdef SATA_DEBUG
92 
93 #define	SATA_LOG_D(args)	sata_log args
94 uint64_t mbuf_count = 0;
95 uint64_t mbuffail_count = 0;
96 
97 sata_atapi_cmd_t sata_atapi_trace[64];
98 uint32_t sata_atapi_trace_index = 0;
99 int sata_atapi_trace_save = 1;
100 static	void sata_save_atapi_trace(sata_pkt_txlate_t *, int);
101 #define	SATAATAPITRACE(spx, count)	if (sata_atapi_trace_save) \
102     sata_save_atapi_trace(spx, count);
103 
104 #else
105 #define	SATA_LOG_D(arg)
106 #define	SATAATAPITRACE(spx, count)
107 #endif
108 
109 #if 0
110 static void
111 sata_test_atapi_packet_command(sata_hba_inst_t *, int);
112 #endif
113 #define	LEGACY_HWID_LEN	64	/* Model (40) + Serial (20) + pad */
114 
115 
116 /*
117  * SATA cb_ops functions
118  */
119 static 	int sata_hba_open(dev_t *, int, int, cred_t *);
120 static 	int sata_hba_close(dev_t, int, int, cred_t *);
121 static 	int sata_hba_ioctl(dev_t, int, intptr_t, int, cred_t *,	int *);
122 
123 /*
124  * SCSA required entry points
125  */
126 static	int sata_scsi_tgt_init(dev_info_t *, dev_info_t *,
127     scsi_hba_tran_t *, struct scsi_device *);
128 static	int sata_scsi_tgt_probe(struct scsi_device *,
129     int (*callback)(void));
130 static void sata_scsi_tgt_free(dev_info_t *, dev_info_t *,
131     scsi_hba_tran_t *, struct scsi_device *);
132 static 	int sata_scsi_start(struct scsi_address *, struct scsi_pkt *);
133 static 	int sata_scsi_abort(struct scsi_address *, struct scsi_pkt *);
134 static 	int sata_scsi_reset(struct scsi_address *, int);
135 static 	int sata_scsi_getcap(struct scsi_address *, char *, int);
136 static 	int sata_scsi_setcap(struct scsi_address *, char *, int, int);
137 static 	struct scsi_pkt *sata_scsi_init_pkt(struct scsi_address *,
138     struct scsi_pkt *, struct buf *, int, int, int, int, int (*)(caddr_t),
139     caddr_t);
140 static 	void sata_scsi_destroy_pkt(struct scsi_address *, struct scsi_pkt *);
141 static 	void sata_scsi_dmafree(struct scsi_address *, struct scsi_pkt *);
142 static 	void sata_scsi_sync_pkt(struct scsi_address *, struct scsi_pkt *);
143 
144 /*
145  * SATA HBA interface functions are defined in sata_hba.h header file
146  */
147 
148 /* Event processing functions */
149 static	void sata_event_daemon(void *);
150 static	void sata_event_thread_control(int);
151 static	void sata_process_controller_events(sata_hba_inst_t *sata_hba_inst);
152 static	void sata_process_device_reset(sata_hba_inst_t *, sata_address_t *);
153 static	void sata_process_port_failed_event(sata_hba_inst_t *,
154     sata_address_t *);
155 static	void sata_process_port_link_events(sata_hba_inst_t *,
156     sata_address_t *);
157 static	void sata_process_device_detached(sata_hba_inst_t *, sata_address_t *);
158 static	void sata_process_device_attached(sata_hba_inst_t *, sata_address_t *);
159 static	void sata_process_port_pwr_change(sata_hba_inst_t *, sata_address_t *);
160 static	void sata_process_cntrl_pwr_level_change(sata_hba_inst_t *);
161 static	void sata_process_target_node_cleanup(sata_hba_inst_t *,
162     sata_address_t *);
163 static	void sata_process_device_autoonline(sata_hba_inst_t *,
164     sata_address_t *saddr);
165 
166 /*
167  * Local translation functions
168  */
169 static	int sata_txlt_inquiry(sata_pkt_txlate_t *);
170 static	int sata_txlt_test_unit_ready(sata_pkt_txlate_t *);
171 static	int sata_txlt_start_stop_unit(sata_pkt_txlate_t *);
172 static	int sata_txlt_read_capacity(sata_pkt_txlate_t *);
173 static	int sata_txlt_request_sense(sata_pkt_txlate_t *);
174 static 	int sata_txlt_read(sata_pkt_txlate_t *);
175 static 	int sata_txlt_write(sata_pkt_txlate_t *);
176 static 	int sata_txlt_log_sense(sata_pkt_txlate_t *);
177 static 	int sata_txlt_log_select(sata_pkt_txlate_t *);
178 static 	int sata_txlt_mode_sense(sata_pkt_txlate_t *);
179 static 	int sata_txlt_mode_select(sata_pkt_txlate_t *);
180 static 	int sata_txlt_synchronize_cache(sata_pkt_txlate_t *);
181 static 	int sata_txlt_write_buffer(sata_pkt_txlate_t *);
182 static 	int sata_txlt_nodata_cmd_immediate(sata_pkt_txlate_t *);
183 
184 static 	int sata_hba_start(sata_pkt_txlate_t *, int *);
185 static	int sata_txlt_invalid_command(sata_pkt_txlate_t *);
186 static	int sata_txlt_lba_out_of_range(sata_pkt_txlate_t *);
187 static 	void sata_txlt_rw_completion(sata_pkt_t *);
188 static 	void sata_txlt_nodata_cmd_completion(sata_pkt_t *);
189 static 	void sata_txlt_download_mcode_cmd_completion(sata_pkt_t *);
190 static 	int sata_emul_rw_completion(sata_pkt_txlate_t *);
191 static 	struct scsi_extended_sense *sata_immediate_error_response(
192     sata_pkt_txlate_t *, int);
193 static	struct scsi_extended_sense *sata_arq_sense(sata_pkt_txlate_t *);
194 
195 static 	int sata_txlt_atapi(sata_pkt_txlate_t *);
196 static 	void sata_txlt_atapi_completion(sata_pkt_t *);
197 
198 /*
199  * Local functions for ioctl
200  */
201 static	int32_t sata_get_port_num(sata_hba_inst_t *,  struct devctl_iocdata *);
202 static	void sata_cfgadm_state(sata_hba_inst_t *, int32_t,
203     devctl_ap_state_t *);
204 static	dev_info_t *sata_get_target_dip(dev_info_t *, int32_t);
205 static	dev_info_t *sata_get_scsi_target_dip(dev_info_t *, sata_address_t *);
206 static	dev_info_t *sata_devt_to_devinfo(dev_t);
207 static	int sata_ioctl_connect(sata_hba_inst_t *, sata_device_t *);
208 static	int sata_ioctl_disconnect(sata_hba_inst_t *, sata_device_t *);
209 static	int sata_ioctl_configure(sata_hba_inst_t *, sata_device_t *);
210 static	int sata_ioctl_unconfigure(sata_hba_inst_t *, sata_device_t *);
211 static	int sata_ioctl_activate(sata_hba_inst_t *, sata_device_t *);
212 static	int sata_ioctl_deactivate(sata_hba_inst_t *, sata_device_t *);
213 static	int sata_ioctl_reset_port(sata_hba_inst_t *, sata_device_t *);
214 static	int sata_ioctl_reset_device(sata_hba_inst_t *, sata_device_t *);
215 static	int sata_ioctl_reset_all(sata_hba_inst_t *);
216 static	int sata_ioctl_port_self_test(sata_hba_inst_t *, sata_device_t *);
217 static	int sata_ioctl_get_device_path(sata_hba_inst_t *, sata_device_t *,
218     sata_ioctl_data_t *, int mode);
219 static	int sata_ioctl_get_ap_type(sata_hba_inst_t *, sata_device_t *,
220     sata_ioctl_data_t *, int mode);
221 static	int sata_ioctl_get_model_info(sata_hba_inst_t *, sata_device_t *,
222     sata_ioctl_data_t *, int mode);
223 static	int sata_ioctl_get_revfirmware_info(sata_hba_inst_t *, sata_device_t *,
224     sata_ioctl_data_t *, int mode);
225 static	int sata_ioctl_get_serialnumber_info(sata_hba_inst_t *,
226     sata_device_t *, sata_ioctl_data_t *, int mode);
227 
228 /*
229  * Local functions
230  */
231 static 	void sata_remove_hba_instance(dev_info_t *);
232 static 	int sata_validate_sata_hba_tran(dev_info_t *, sata_hba_tran_t *);
233 static 	void sata_probe_ports(sata_hba_inst_t *);
234 static 	int sata_reprobe_port(sata_hba_inst_t *, sata_device_t *, int);
235 static 	int sata_add_device(dev_info_t *, sata_hba_inst_t *, int cport,
236     int pmport);
237 static 	dev_info_t *sata_create_target_node(dev_info_t *, sata_hba_inst_t *,
238     sata_address_t *);
239 static 	int sata_validate_scsi_address(sata_hba_inst_t *,
240     struct scsi_address *, sata_device_t *);
241 static 	int sata_validate_sata_address(sata_hba_inst_t *, int, int, int);
242 static	sata_pkt_t *sata_pkt_alloc(sata_pkt_txlate_t *, int (*)(caddr_t));
243 static	void sata_pkt_free(sata_pkt_txlate_t *);
244 static	int sata_dma_buf_setup(sata_pkt_txlate_t *, int, int (*)(caddr_t),
245     caddr_t, ddi_dma_attr_t *);
246 static	int sata_probe_device(sata_hba_inst_t *, sata_device_t *);
247 static	sata_drive_info_t *sata_get_device_info(sata_hba_inst_t *,
248     sata_device_t *);
249 static 	int sata_identify_device(sata_hba_inst_t *, sata_drive_info_t *);
250 static	struct buf *sata_alloc_local_buffer(sata_pkt_txlate_t *, int);
251 static 	void sata_free_local_buffer(sata_pkt_txlate_t *);
252 static 	uint64_t sata_check_capacity(sata_drive_info_t *);
253 void 	sata_adjust_dma_attr(sata_drive_info_t *, ddi_dma_attr_t *,
254     ddi_dma_attr_t *);
255 static 	int sata_fetch_device_identify_data(sata_hba_inst_t *,
256     sata_drive_info_t *);
257 static	void sata_update_port_info(sata_hba_inst_t *, sata_device_t *);
258 static	void sata_update_port_scr(sata_port_scr_t *, sata_device_t *);
259 static	int sata_set_dma_mode(sata_hba_inst_t *, sata_drive_info_t *);
260 static	int sata_set_cache_mode(sata_hba_inst_t *, sata_drive_info_t *, int);
261 static	int sata_set_rmsn(sata_hba_inst_t *, sata_drive_info_t *, int);
262 static	int sata_set_drive_features(sata_hba_inst_t *,
263     sata_drive_info_t *, int flag);
264 static	void sata_init_write_cache_mode(sata_drive_info_t *sdinfo);
265 static	int sata_initialize_device(sata_hba_inst_t *, sata_drive_info_t *);
266 static	void sata_identdev_to_inquiry(sata_hba_inst_t *, sata_drive_info_t *,
267     uint8_t *);
268 static	int sata_get_atapi_inquiry_data(sata_hba_inst_t *, sata_address_t *,
269     struct scsi_inquiry *);
270 static	int sata_build_msense_page_1(sata_drive_info_t *, int, uint8_t *);
271 static	int sata_build_msense_page_8(sata_drive_info_t *, int, uint8_t *);
272 static	int sata_build_msense_page_1a(sata_drive_info_t *, int, uint8_t *);
273 static	int sata_build_msense_page_1c(sata_drive_info_t *, int, uint8_t *);
274 static	int sata_mode_select_page_8(sata_pkt_txlate_t *,
275     struct mode_cache_scsi3 *, int, int *, int *, int *);
276 static	int sata_mode_select_page_1c(sata_pkt_txlate_t *,
277     struct mode_info_excpt_page *, int, int *, int *, int *);
278 static	int sata_build_msense_page_30(sata_drive_info_t *, int, uint8_t *);
279 static	int sata_mode_select_page_30(sata_pkt_txlate_t *,
280     struct mode_acoustic_management *, int, int *, int *, int *);
281 
282 static	int sata_build_lsense_page_0(sata_drive_info_t *, uint8_t *);
283 static	int sata_build_lsense_page_10(sata_drive_info_t *, uint8_t *,
284     sata_hba_inst_t *);
285 static	int sata_build_lsense_page_2f(sata_drive_info_t *, uint8_t *,
286     sata_hba_inst_t *);
287 static	int sata_build_lsense_page_30(sata_drive_info_t *, uint8_t *,
288     sata_hba_inst_t *);
289 static	void sata_save_drive_settings(sata_drive_info_t *);
290 static	void sata_show_drive_info(sata_hba_inst_t *, sata_drive_info_t *);
291 static	void sata_log(sata_hba_inst_t *, uint_t, char *fmt, ...);
292 static	int sata_fetch_smart_return_status(sata_hba_inst_t *,
293     sata_drive_info_t *);
294 static	int sata_fetch_smart_data(sata_hba_inst_t *, sata_drive_info_t *,
295     struct smart_data *);
296 static	int sata_smart_selftest_log(sata_hba_inst_t *,
297     sata_drive_info_t *,
298     struct smart_selftest_log *);
299 static	int sata_ext_smart_selftest_read_log(sata_hba_inst_t *,
300     sata_drive_info_t *, struct smart_ext_selftest_log *, uint16_t);
301 static	int sata_smart_read_log(sata_hba_inst_t *, sata_drive_info_t *,
302     uint8_t *, uint8_t, uint8_t);
303 static	int sata_read_log_ext_directory(sata_hba_inst_t *, sata_drive_info_t *,
304     struct read_log_ext_directory *);
305 static	void sata_gen_sysevent(sata_hba_inst_t *, sata_address_t *, int);
306 static	void sata_xlate_errors(sata_pkt_txlate_t *);
307 static	void sata_decode_device_error(sata_pkt_txlate_t *,
308     struct scsi_extended_sense *);
309 static	void sata_set_device_removed(dev_info_t *);
310 static	boolean_t sata_check_device_removed(dev_info_t *);
311 static	void sata_set_target_node_cleanup(sata_hba_inst_t *, sata_address_t *);
312 static	int sata_ncq_err_ret_cmd_setup(sata_pkt_txlate_t *,
313     sata_drive_info_t *);
314 static	int sata_atapi_err_ret_cmd_setup(sata_pkt_txlate_t *,
315     sata_drive_info_t *);
316 static	void sata_atapi_packet_cmd_setup(sata_cmd_t *, sata_drive_info_t *);
317 static	void sata_fixed_sense_data_preset(struct scsi_extended_sense *);
318 static  void sata_target_devid_register(dev_info_t *, sata_drive_info_t *);
319 static  int sata_check_modser(char *, int);
320 
321 
322 
323 /*
324  * SATA Framework will ignore SATA HBA driver cb_ops structure and
325  * register following one with SCSA framework.
326  * Open & close are provided, so scsi framework will not use its own
327  */
328 static struct cb_ops sata_cb_ops = {
329 	sata_hba_open,			/* open */
330 	sata_hba_close,			/* close */
331 	nodev,				/* strategy */
332 	nodev,				/* print */
333 	nodev,				/* dump */
334 	nodev,				/* read */
335 	nodev,				/* write */
336 	sata_hba_ioctl,			/* ioctl */
337 	nodev,				/* devmap */
338 	nodev,				/* mmap */
339 	nodev,				/* segmap */
340 	nochpoll,			/* chpoll */
341 	ddi_prop_op,			/* cb_prop_op */
342 	0,				/* streamtab */
343 	D_NEW | D_MP,			/* cb_flag */
344 	CB_REV,				/* rev */
345 	nodev,				/* aread */
346 	nodev				/* awrite */
347 };
348 
349 
350 extern struct mod_ops mod_miscops;
351 extern uchar_t	scsi_cdb_size[];
352 
353 static struct modlmisc modlmisc = {
354 	&mod_miscops,			/* Type of module */
355 	"SATA Module v%I%"		/* module name */
356 };
357 
358 
359 static struct modlinkage modlinkage = {
360 	MODREV_1,
361 	(void *)&modlmisc,
362 	NULL
363 };
364 
365 /*
366  * Default sata pkt timeout. Used when a target driver scsi_pkt time is zero,
367  * i.e. when scsi_pkt has not timeout specified.
368  */
369 static int sata_default_pkt_time = 60;	/* 60 seconds */
370 
371 /*
372  * Intermediate buffer device access attributes - they are required,
373  * but not necessarily used.
374  */
375 static ddi_device_acc_attr_t sata_acc_attr = {
376 	DDI_DEVICE_ATTR_V0,
377 	DDI_STRUCTURE_LE_ACC,
378 	DDI_STRICTORDER_ACC
379 };
380 
381 
382 /*
383  * Mutexes protecting structures in multithreaded operations.
384  * Because events are relatively rare, a single global mutex protecting
385  * data structures should be sufficient. To increase performance, add
386  * separate mutex per each sata port and use global mutex only to protect
387  * common data structures.
388  */
389 static	kmutex_t sata_mutex;		/* protects sata_hba_list */
390 static	kmutex_t sata_log_mutex;	/* protects log */
391 
392 static 	char sata_log_buf[256];
393 
394 /* Default write cache setting for SATA hard disks */
395 int	sata_write_cache = 1;		/* enabled */
396 
397 /* Default write cache setting for SATA ATAPI CD/DVD */
398 int 	sata_atapicdvd_write_cache = 1; /* enabled */
399 
400 /*
401  * Linked list of HBA instances
402  */
403 static 	sata_hba_inst_t *sata_hba_list = NULL;
404 static 	sata_hba_inst_t *sata_hba_list_tail = NULL;
405 /*
406  * Pointer to per-instance SATA HBA soft structure is stored in sata_hba_tran
407  * structure and in sata soft state.
408  */
409 
410 /*
411  * Event daemon related variables
412  */
413 static 	kmutex_t sata_event_mutex;
414 static 	kcondvar_t sata_event_cv;
415 static 	kthread_t *sata_event_thread = NULL;
416 static 	int sata_event_thread_terminate = 0;
417 static 	int sata_event_pending = 0;
418 static 	int sata_event_thread_active = 0;
419 extern 	pri_t minclsyspri;
420 
421 /*
422  * NCQ error recovery command
423  */
424 static const sata_cmd_t sata_rle_cmd = {
425 	SATA_CMD_REV,
426 	NULL,
427 	{
428 		SATA_DIR_READ
429 	},
430 	ATA_ADDR_LBA48,
431 	0,
432 	0,
433 	0,
434 	0,
435 	0,
436 	1,
437 	READ_LOG_EXT_NCQ_ERROR_RECOVERY,
438 	0,
439 	0,
440 	0,
441 	SATAC_READ_LOG_EXT,
442 	0,
443 	0,
444 	0,
445 };
446 
447 /*
448  * ATAPI error recovery CDB
449  */
450 static const uint8_t sata_rqsense_cdb[SATA_ATAPI_RQSENSE_CDB_LEN] = {
451 	SCMD_REQUEST_SENSE,
452 	0,			/* Only fixed RQ format is supported */
453 	0,
454 	0,
455 	SATA_ATAPI_MIN_RQSENSE_LEN, /* Less data may be returned */
456 	0
457 };
458 
459 
460 /* Warlock directives */
461 
462 _NOTE(SCHEME_PROTECTS_DATA("No Mutex Needed", scsi_hba_tran))
463 _NOTE(SCHEME_PROTECTS_DATA("No Mutex Needed", scsi_device))
464 _NOTE(SCHEME_PROTECTS_DATA("No Mutex Needed", dev_ops))
465 _NOTE(SCHEME_PROTECTS_DATA("No Mutex Needed", scsi_extended_sense))
466 _NOTE(SCHEME_PROTECTS_DATA("No Mutex Needed", scsi_arq_status))
467 _NOTE(SCHEME_PROTECTS_DATA("No Mutex Needed", ddi_dma_attr))
468 _NOTE(SCHEME_PROTECTS_DATA("No Mutex Needed", ddi_dma_cookie_t))
469 _NOTE(SCHEME_PROTECTS_DATA("No Mutex Needed", devctl_ap_state))
470 _NOTE(SCHEME_PROTECTS_DATA("No Mutex Needed", dev_info::devi_state))
471 _NOTE(MUTEX_PROTECTS_DATA(sata_mutex, sata_hba_list))
472 _NOTE(DATA_READABLE_WITHOUT_LOCK(sata_hba_list))
473 _NOTE(MUTEX_PROTECTS_DATA(sata_mutex, sata_hba_inst::satahba_next))
474 _NOTE(MUTEX_PROTECTS_DATA(sata_mutex, sata_hba_inst::satahba_prev))
475 _NOTE(SCHEME_PROTECTS_DATA("No Mutex Needed", \
476     sata_hba_inst::satahba_scsi_tran))
477 _NOTE(SCHEME_PROTECTS_DATA("No Mutex Needed", sata_hba_inst::satahba_tran))
478 _NOTE(SCHEME_PROTECTS_DATA("No Mutex Needed", sata_hba_inst::satahba_dip))
479 _NOTE(SCHEME_PROTECTS_DATA("Scheme", sata_hba_inst::satahba_attached))
480 _NOTE(DATA_READABLE_WITHOUT_LOCK(sata_hba_inst::satahba_dev_port))
481 _NOTE(MUTEX_PROTECTS_DATA(sata_hba_inst::satahba_mutex,
482     sata_hba_inst::satahba_event_flags))
483 _NOTE(MUTEX_PROTECTS_DATA(sata_cport_info::cport_mutex, \
484     sata_cport_info::cport_devp))
485 _NOTE(DATA_READABLE_WITHOUT_LOCK(sata_cport_info::cport_devp))
486 _NOTE(SCHEME_PROTECTS_DATA("Scheme", sata_cport_info::cport_addr))
487 _NOTE(MUTEX_PROTECTS_DATA(sata_cport_info::cport_mutex, \
488     sata_cport_info::cport_dev_type))
489 _NOTE(DATA_READABLE_WITHOUT_LOCK(sata_cport_info::cport_dev_type))
490 _NOTE(MUTEX_PROTECTS_DATA(sata_cport_info::cport_mutex, \
491     sata_cport_info::cport_state))
492 _NOTE(DATA_READABLE_WITHOUT_LOCK(sata_cport_info::cport_state))
493 _NOTE(MUTEX_PROTECTS_DATA(sata_cport_info::cport_mutex, \
494     sata_pmport_info::pmport_state))
495 _NOTE(DATA_READABLE_WITHOUT_LOCK(sata_pmport_info::pmport_state))
496 _NOTE(DATA_READABLE_WITHOUT_LOCK(sata_pmport_info::pmport_dev_type))
497 _NOTE(DATA_READABLE_WITHOUT_LOCK(sata_pmport_info::pmport_sata_drive))
498 _NOTE(DATA_READABLE_WITHOUT_LOCK(sata_pmult_info::pmult_dev_port))
499 _NOTE(DATA_READABLE_WITHOUT_LOCK(sata_pmult_info::pmult_num_dev_ports))
500 #ifdef SATA_DEBUG
501 _NOTE(SCHEME_PROTECTS_DATA("No Mutex Needed", mbuf_count))
502 _NOTE(SCHEME_PROTECTS_DATA("No Mutex Needed", mbuffail_count))
503 _NOTE(SCHEME_PROTECTS_DATA("No Mutex Needed", sata_atapi_trace))
504 _NOTE(SCHEME_PROTECTS_DATA("No Mutex Needed", sata_atapi_trace_index))
505 #endif
506 
507 /* End of warlock directives */
508 
509 /* ************** loadable module configuration functions ************** */
510 
511 int
512 _init()
513 {
514 	int rval;
515 
516 	mutex_init(&sata_mutex, NULL, MUTEX_DRIVER, NULL);
517 	mutex_init(&sata_event_mutex, NULL, MUTEX_DRIVER, NULL);
518 	mutex_init(&sata_log_mutex, NULL, MUTEX_DRIVER, NULL);
519 	cv_init(&sata_event_cv, NULL, CV_DRIVER, NULL);
520 	if ((rval = mod_install(&modlinkage)) != 0) {
521 #ifdef SATA_DEBUG
522 		cmn_err(CE_WARN, "sata: _init: mod_install failed\n");
523 #endif
524 		mutex_destroy(&sata_log_mutex);
525 		cv_destroy(&sata_event_cv);
526 		mutex_destroy(&sata_event_mutex);
527 		mutex_destroy(&sata_mutex);
528 	}
529 	return (rval);
530 }
531 
532 int
533 _fini()
534 {
535 	int rval;
536 
537 	if ((rval = mod_remove(&modlinkage)) != 0)
538 		return (rval);
539 
540 	mutex_destroy(&sata_log_mutex);
541 	cv_destroy(&sata_event_cv);
542 	mutex_destroy(&sata_event_mutex);
543 	mutex_destroy(&sata_mutex);
544 	return (rval);
545 }
546 
547 int
548 _info(struct modinfo *modinfop)
549 {
550 	return (mod_info(&modlinkage, modinfop));
551 }
552 
553 
554 
555 /* ********************* SATA HBA entry points ********************* */
556 
557 
558 /*
559  * Called by SATA HBA from _init().
560  * Registers HBA driver instance/sata framework pair with scsi framework, by
561  * calling scsi_hba_init().
562  *
563  * SATA HBA driver cb_ops are ignored - SATA HBA framework cb_ops are used
564  * instead. SATA HBA framework cb_ops pointer overwrites SATA HBA driver
565  * cb_ops pointer in SATA HBA driver dev_ops structure.
566  * SATA HBA framework cb_ops supplies cb_open cb_close and cb_ioctl vectors.
567  *
568  * Return status of the scsi_hba_init() is returned to a calling SATA HBA
569  * driver.
570  */
571 int
572 sata_hba_init(struct modlinkage *modlp)
573 {
574 	int rval;
575 	struct dev_ops *hba_ops;
576 
577 	SATADBG1(SATA_DBG_HBA_IF, NULL,
578 	    "sata_hba_init: name %s \n",
579 	    ((struct modldrv *)(modlp->ml_linkage[0]))->drv_linkinfo);
580 	/*
581 	 * Fill-up cb_ops and dev_ops when necessary
582 	 */
583 	hba_ops = ((struct modldrv *)(modlp->ml_linkage[0]))->drv_dev_ops;
584 	/*
585 	 * Provide pointer to SATA dev_ops
586 	 */
587 	hba_ops->devo_cb_ops = &sata_cb_ops;
588 
589 	/*
590 	 * Register SATA HBA with SCSI framework
591 	 */
592 	if ((rval = scsi_hba_init(modlp)) != 0) {
593 		SATADBG1(SATA_DBG_HBA_IF, NULL,
594 		    "sata_hba_init: scsi hba init failed\n", NULL);
595 		return (rval);
596 	}
597 
598 	return (0);
599 }
600 
601 
602 /* HBA attach stages */
603 #define	HBA_ATTACH_STAGE_SATA_HBA_INST	1
604 #define	HBA_ATTACH_STAGE_SCSI_ATTACHED	2
605 #define	HBA_ATTACH_STAGE_SETUP		4
606 #define	HBA_ATTACH_STAGE_LINKED		8
607 
608 
609 /*
610  *
611  * Called from SATA HBA driver's attach routine to attach an instance of
612  * the HBA.
613  *
614  * For DDI_ATTACH command:
615  * sata_hba_inst structure is allocated here and initialized with pointers to
616  * SATA framework implementation of required scsi tran functions.
617  * The scsi_tran's tran_hba_private field is used by SATA Framework to point
618  * to the soft structure (sata_hba_inst) allocated by SATA framework for
619  * SATA HBA instance related data.
620  * The scsi_tran's tran_hba_private field is used by SATA framework to
621  * store a pointer to per-HBA-instance of sata_hba_inst structure.
622  * The sata_hba_inst structure is cross-linked to scsi tran structure.
623  * Among other info, a pointer to sata_hba_tran structure is stored in
624  * sata_hba_inst. The sata_hba_inst structures for different HBA instances are
625  * linked together into the list, pointed to by sata_hba_list.
626  * On the first HBA instance attach the sata event thread is initialized.
627  * Attachment points are created for all SATA ports of the HBA being attached.
628  * All HBA instance's SATA ports are probed and type of plugged devices is
629  * determined. For each device of a supported type, a target node is created.
630  *
631  * DDI_SUCCESS is returned when attachment process is successful,
632  * DDI_FAILURE is returned otherwise.
633  *
634  * For DDI_RESUME command:
635  * Not implemented at this time (postponed until phase 2 of the development).
636  */
637 int
638 sata_hba_attach(dev_info_t *dip, sata_hba_tran_t *sata_tran,
639     ddi_attach_cmd_t cmd)
640 {
641 	sata_hba_inst_t	*sata_hba_inst;
642 	scsi_hba_tran_t *scsi_tran = NULL;
643 	int hba_attach_state = 0;
644 	char taskq_name[MAXPATHLEN];
645 
646 	SATADBG3(SATA_DBG_HBA_IF, NULL,
647 	    "sata_hba_attach: node %s (%s%d)\n",
648 	    ddi_node_name(dip), ddi_driver_name(dip),
649 	    ddi_get_instance(dip));
650 
651 	if (cmd == DDI_RESUME) {
652 		/*
653 		 * Postponed until phase 2 of the development
654 		 */
655 		return (DDI_FAILURE);
656 	}
657 
658 	if (cmd != DDI_ATTACH) {
659 		return (DDI_FAILURE);
660 	}
661 
662 	/* cmd == DDI_ATTACH */
663 
664 	if (sata_validate_sata_hba_tran(dip, sata_tran) != SATA_SUCCESS) {
665 		SATA_LOG_D((NULL, CE_WARN,
666 		    "sata_hba_attach: invalid sata_hba_tran"));
667 		return (DDI_FAILURE);
668 	}
669 	/*
670 	 * Allocate and initialize SCSI tran structure.
671 	 * SATA copy of tran_bus_config is provided to create port nodes.
672 	 */
673 	scsi_tran = scsi_hba_tran_alloc(dip, SCSI_HBA_CANSLEEP);
674 	if (scsi_tran == NULL)
675 		return (DDI_FAILURE);
676 	/*
677 	 * Allocate soft structure for SATA HBA instance.
678 	 * There is a separate softstate for each HBA instance.
679 	 */
680 	sata_hba_inst = kmem_zalloc(sizeof (struct sata_hba_inst), KM_SLEEP);
681 	ASSERT(sata_hba_inst != NULL); /* this should not fail */
682 	mutex_init(&sata_hba_inst->satahba_mutex, NULL, MUTEX_DRIVER, NULL);
683 	hba_attach_state |= HBA_ATTACH_STAGE_SATA_HBA_INST;
684 
685 	/*
686 	 * scsi_trans's tran_hba_private is used by SATA Framework to point to
687 	 * soft structure allocated by SATA framework for
688 	 * SATA HBA instance related data.
689 	 */
690 	scsi_tran->tran_hba_private	= sata_hba_inst;
691 	scsi_tran->tran_tgt_private	= NULL;
692 
693 	scsi_tran->tran_tgt_init	= sata_scsi_tgt_init;
694 	scsi_tran->tran_tgt_probe	= sata_scsi_tgt_probe;
695 	scsi_tran->tran_tgt_free	= sata_scsi_tgt_free;
696 
697 	scsi_tran->tran_start		= sata_scsi_start;
698 	scsi_tran->tran_reset		= sata_scsi_reset;
699 	scsi_tran->tran_abort		= sata_scsi_abort;
700 	scsi_tran->tran_getcap		= sata_scsi_getcap;
701 	scsi_tran->tran_setcap		= sata_scsi_setcap;
702 	scsi_tran->tran_init_pkt	= sata_scsi_init_pkt;
703 	scsi_tran->tran_destroy_pkt	= sata_scsi_destroy_pkt;
704 
705 	scsi_tran->tran_dmafree		= sata_scsi_dmafree;
706 	scsi_tran->tran_sync_pkt	= sata_scsi_sync_pkt;
707 
708 	scsi_tran->tran_reset_notify	= NULL;
709 	scsi_tran->tran_get_bus_addr	= NULL;
710 	scsi_tran->tran_quiesce		= NULL;
711 	scsi_tran->tran_unquiesce	= NULL;
712 	scsi_tran->tran_bus_reset	= NULL;
713 
714 	if (scsi_hba_attach_setup(dip, sata_tran->sata_tran_hba_dma_attr,
715 	    scsi_tran, 0) != DDI_SUCCESS) {
716 #ifdef SATA_DEBUG
717 		cmn_err(CE_WARN, "?SATA: %s%d hba scsi attach failed",
718 		    ddi_driver_name(dip), ddi_get_instance(dip));
719 #endif
720 		goto fail;
721 	}
722 	hba_attach_state |= HBA_ATTACH_STAGE_SCSI_ATTACHED;
723 
724 	if (!ddi_prop_exists(DDI_DEV_T_ANY, dip, DDI_PROP_DONTPASS, "sata")) {
725 		if (ddi_prop_update_int(DDI_DEV_T_NONE, dip,
726 		    "sata", 1) != DDI_PROP_SUCCESS) {
727 			SATA_LOG_D((NULL, CE_WARN, "sata_hba_attach: "
728 			    "failed to create hba sata prop"));
729 			goto fail;
730 		}
731 	}
732 
733 	/*
734 	 * Save pointers in hba instance soft state.
735 	 */
736 	sata_hba_inst->satahba_scsi_tran = scsi_tran;
737 	sata_hba_inst->satahba_tran = sata_tran;
738 	sata_hba_inst->satahba_dip = dip;
739 
740 	/*
741 	 * Create a task queue to handle emulated commands completion
742 	 * Use node name, dash, instance number as the queue name.
743 	 */
744 	taskq_name[0] = '\0';
745 	(void) strlcat(taskq_name, DEVI(dip)->devi_node_name,
746 	    sizeof (taskq_name));
747 	(void) snprintf(taskq_name + strlen(taskq_name),
748 	    sizeof (taskq_name) - strlen(taskq_name),
749 	    "-%d", DEVI(dip)->devi_instance);
750 	sata_hba_inst->satahba_taskq = taskq_create(taskq_name, 1,
751 	    minclsyspri, 1, sata_tran->sata_tran_hba_num_cports,
752 	    TASKQ_DYNAMIC);
753 
754 	hba_attach_state |= HBA_ATTACH_STAGE_SETUP;
755 
756 	/*
757 	 * Create events thread if not created yet.
758 	 */
759 	sata_event_thread_control(1);
760 
761 	/*
762 	 * Link this hba instance into the list.
763 	 */
764 	mutex_enter(&sata_mutex);
765 
766 	if (sata_hba_list == NULL) {
767 		/*
768 		 * The first instance of HBA is attached.
769 		 * Set current/active default maximum NCQ/TCQ queue depth for
770 		 * all SATA devices. It is done here and now, to eliminate the
771 		 * possibility of the dynamic, programatic modification of the
772 		 * queue depth via global (and public) sata_max_queue_depth
773 		 * variable (this would require special handling in HBA drivers)
774 		 */
775 		sata_current_max_qdepth = sata_max_queue_depth;
776 		if (sata_current_max_qdepth > 32)
777 			sata_current_max_qdepth = 32;
778 		else if (sata_current_max_qdepth < 1)
779 			sata_current_max_qdepth = 1;
780 	}
781 
782 	sata_hba_inst->satahba_next = NULL;
783 	sata_hba_inst->satahba_prev = sata_hba_list_tail;
784 	if (sata_hba_list == NULL) {
785 		sata_hba_list = sata_hba_inst;
786 	}
787 	if (sata_hba_list_tail != NULL) {
788 		sata_hba_list_tail->satahba_next = sata_hba_inst;
789 	}
790 	sata_hba_list_tail = sata_hba_inst;
791 	mutex_exit(&sata_mutex);
792 	hba_attach_state |= HBA_ATTACH_STAGE_LINKED;
793 
794 	/*
795 	 * Create SATA HBA devctl minor node for sata_hba_open, close, ioctl
796 	 * SATA HBA driver should not use its own open/close entry points.
797 	 *
798 	 * Make sure that instance number doesn't overflow
799 	 * when forming minor numbers.
800 	 */
801 	ASSERT(ddi_get_instance(dip) <= (L_MAXMIN >> INST_MINOR_SHIFT));
802 	if (ddi_create_minor_node(dip, "devctl", S_IFCHR,
803 	    INST2DEVCTL(ddi_get_instance(dip)),
804 	    DDI_NT_SATA_NEXUS, 0) != DDI_SUCCESS) {
805 #ifdef SATA_DEBUG
806 		cmn_err(CE_WARN, "sata_hba_attach: "
807 		    "cannot create devctl minor node");
808 #endif
809 		goto fail;
810 	}
811 
812 
813 	/*
814 	 * Set-up kstats here, if necessary.
815 	 * (postponed until phase 2 of the development).
816 	 */
817 
818 
819 	/*
820 	 * Probe controller ports. This operation will describe a current
821 	 * controller/port/multipliers/device configuration and will create
822 	 * attachment points.
823 	 * We may end-up with just a controller with no devices attached.
824 	 * For the ports with a supported device attached, device target nodes
825 	 * are created and devices are initialized.
826 	 */
827 	sata_probe_ports(sata_hba_inst);
828 
829 	sata_hba_inst->satahba_attached = 1;
830 	return (DDI_SUCCESS);
831 
832 fail:
833 	if (hba_attach_state & HBA_ATTACH_STAGE_LINKED) {
834 		(void) sata_remove_hba_instance(dip);
835 		if (sata_hba_list == NULL)
836 			sata_event_thread_control(0);
837 	}
838 
839 	if (hba_attach_state & HBA_ATTACH_STAGE_SETUP) {
840 		(void) ddi_prop_remove(DDI_DEV_T_ANY, dip, "sata");
841 		taskq_destroy(sata_hba_inst->satahba_taskq);
842 	}
843 
844 	if (hba_attach_state & HBA_ATTACH_STAGE_SCSI_ATTACHED)
845 		(void) scsi_hba_detach(dip);
846 
847 	if (hba_attach_state & HBA_ATTACH_STAGE_SATA_HBA_INST) {
848 		mutex_destroy(&sata_hba_inst->satahba_mutex);
849 		kmem_free((void *)sata_hba_inst,
850 		    sizeof (struct sata_hba_inst));
851 		scsi_hba_tran_free(scsi_tran);
852 	}
853 
854 	sata_log(NULL, CE_WARN, "?SATA: %s%d hba attach failed",
855 	    ddi_driver_name(dip), ddi_get_instance(dip));
856 
857 	return (DDI_FAILURE);
858 }
859 
860 
861 /*
862  * Called by SATA HBA from to detach an instance of the driver.
863  *
864  * For DDI_DETACH command:
865  * Free local structures allocated for SATA HBA instance during
866  * sata_hba_attach processing.
867  *
868  * Returns DDI_SUCCESS when HBA was detached, DDI_FAILURE otherwise.
869  *
870  * For DDI_SUSPEND command:
871  * Not implemented at this time (postponed until phase 2 of the development)
872  * Returnd DDI_SUCCESS.
873  *
874  * When the last HBA instance is detached, the event daemon is terminated.
875  *
876  * NOTE: cport support only, no port multiplier support.
877  */
878 int
879 sata_hba_detach(dev_info_t *dip, ddi_detach_cmd_t cmd)
880 {
881 	dev_info_t	*tdip;
882 	sata_hba_inst_t	*sata_hba_inst;
883 	scsi_hba_tran_t *scsi_hba_tran;
884 	sata_cport_info_t *cportinfo;
885 	sata_drive_info_t *sdinfo;
886 	int ncport;
887 
888 	SATADBG3(SATA_DBG_HBA_IF, NULL, "sata_hba_detach: node %s (%s%d)\n",
889 	    ddi_node_name(dip), ddi_driver_name(dip), ddi_get_instance(dip));
890 
891 	switch (cmd) {
892 	case DDI_DETACH:
893 
894 		if ((scsi_hba_tran = ddi_get_driver_private(dip)) == NULL)
895 			return (DDI_FAILURE);
896 
897 		sata_hba_inst = scsi_hba_tran->tran_hba_private;
898 		if (sata_hba_inst == NULL)
899 			return (DDI_FAILURE);
900 
901 		if (scsi_hba_detach(dip) == DDI_FAILURE) {
902 			sata_hba_inst->satahba_attached = 1;
903 			return (DDI_FAILURE);
904 		}
905 
906 		/*
907 		 * Free all target nodes - at this point
908 		 * devices should be at least offlined
909 		 * otherwise scsi_hba_detach() should not be called.
910 		 */
911 		for (ncport = 0; ncport < SATA_NUM_CPORTS(sata_hba_inst);
912 		    ncport++) {
913 			cportinfo = SATA_CPORT_INFO(sata_hba_inst, ncport);
914 			if (cportinfo->cport_dev_type != SATA_DTYPE_PMULT) {
915 				sdinfo = SATA_CPORTINFO_DRV_INFO(cportinfo);
916 				if (sdinfo != NULL) {
917 					tdip = sata_get_target_dip(dip,
918 					    ncport);
919 					if (tdip != NULL) {
920 						if (ndi_devi_offline(tdip,
921 						    NDI_DEVI_REMOVE) !=
922 						    NDI_SUCCESS) {
923 							SATA_LOG_D((
924 							    sata_hba_inst,
925 							    CE_WARN,
926 							    "sata_hba_detach: "
927 							    "Target node not "
928 							    "removed !"));
929 							return (DDI_FAILURE);
930 						}
931 					}
932 				}
933 			}
934 		}
935 		/*
936 		 * Disable sata event daemon processing for this HBA
937 		 */
938 		sata_hba_inst->satahba_attached = 0;
939 
940 		/*
941 		 * Remove event daemon thread, if it is last HBA instance.
942 		 */
943 
944 		mutex_enter(&sata_mutex);
945 		if (sata_hba_list->satahba_next == NULL) {
946 			mutex_exit(&sata_mutex);
947 			sata_event_thread_control(0);
948 			mutex_enter(&sata_mutex);
949 		}
950 		mutex_exit(&sata_mutex);
951 
952 		/* Remove this HBA instance from the HBA list */
953 		sata_remove_hba_instance(dip);
954 
955 		/*
956 		 * At this point there should be no target nodes attached.
957 		 * Detach and destroy device and port info structures.
958 		 */
959 		for (ncport = 0; ncport < SATA_NUM_CPORTS(sata_hba_inst);
960 		    ncport++) {
961 			cportinfo = SATA_CPORT_INFO(sata_hba_inst, ncport);
962 			if (cportinfo->cport_dev_type != SATA_DTYPE_PMULT) {
963 				sdinfo =
964 				    cportinfo->cport_devp.cport_sata_drive;
965 				if (sdinfo != NULL) {
966 					/* Release device structure */
967 					kmem_free(sdinfo,
968 					    sizeof (sata_drive_info_t));
969 				}
970 				/* Release cport info */
971 				mutex_destroy(&cportinfo->cport_mutex);
972 				kmem_free(cportinfo,
973 				    sizeof (sata_cport_info_t));
974 			}
975 		}
976 
977 		scsi_hba_tran_free(sata_hba_inst->satahba_scsi_tran);
978 
979 		(void) ddi_prop_remove(DDI_DEV_T_ANY, dip, "sata");
980 
981 		taskq_destroy(sata_hba_inst->satahba_taskq);
982 
983 		mutex_destroy(&sata_hba_inst->satahba_mutex);
984 		kmem_free((void *)sata_hba_inst,
985 		    sizeof (struct sata_hba_inst));
986 
987 		return (DDI_SUCCESS);
988 
989 	case DDI_SUSPEND:
990 		/*
991 		 * Postponed until phase 2
992 		 */
993 		return (DDI_FAILURE);
994 
995 	default:
996 		return (DDI_FAILURE);
997 	}
998 }
999 
1000 
1001 /*
1002  * Called by an HBA drive from _fini() routine.
1003  * Unregisters SATA HBA instance/SATA framework pair from the scsi framework.
1004  */
1005 void
1006 sata_hba_fini(struct modlinkage *modlp)
1007 {
1008 	SATADBG1(SATA_DBG_HBA_IF, NULL,
1009 	    "sata_hba_fini: name %s\n",
1010 	    ((struct modldrv *)(modlp->ml_linkage[0]))->drv_linkinfo);
1011 
1012 	scsi_hba_fini(modlp);
1013 }
1014 
1015 
1016 /*
1017  * Default open and close routine for sata_hba framework.
1018  *
1019  */
1020 /*
1021  * Open devctl node.
1022  *
1023  * Returns:
1024  * 0 if node was open successfully, error code otherwise.
1025  *
1026  *
1027  */
1028 
1029 static int
1030 sata_hba_open(dev_t *devp, int flags, int otyp, cred_t *credp)
1031 {
1032 #ifndef __lock_lint
1033 	_NOTE(ARGUNUSED(credp))
1034 #endif
1035 	int rv = 0;
1036 	dev_info_t *dip;
1037 	scsi_hba_tran_t *scsi_hba_tran;
1038 	sata_hba_inst_t	*sata_hba_inst;
1039 
1040 	SATADBG1(SATA_DBG_IOCTL_IF, NULL, "sata_hba_open: entered", NULL);
1041 
1042 	if (otyp != OTYP_CHR)
1043 		return (EINVAL);
1044 
1045 	dip = sata_devt_to_devinfo(*devp);
1046 	if (dip == NULL)
1047 		return (ENXIO);
1048 
1049 	if ((scsi_hba_tran = ddi_get_driver_private(dip)) == NULL)
1050 		return (ENXIO);
1051 
1052 	sata_hba_inst = scsi_hba_tran->tran_hba_private;
1053 	if (sata_hba_inst == NULL || sata_hba_inst->satahba_attached == 0)
1054 		return (ENXIO);
1055 
1056 	mutex_enter(&sata_mutex);
1057 	if (flags & FEXCL) {
1058 		if (sata_hba_inst->satahba_open_flag != 0) {
1059 			rv = EBUSY;
1060 		} else {
1061 			sata_hba_inst->satahba_open_flag =
1062 			    SATA_DEVCTL_EXOPENED;
1063 		}
1064 	} else {
1065 		if (sata_hba_inst->satahba_open_flag == SATA_DEVCTL_EXOPENED) {
1066 			rv = EBUSY;
1067 		} else {
1068 			sata_hba_inst->satahba_open_flag =
1069 			    SATA_DEVCTL_SOPENED;
1070 		}
1071 	}
1072 	mutex_exit(&sata_mutex);
1073 
1074 	return (rv);
1075 }
1076 
1077 
1078 /*
1079  * Close devctl node.
1080  * Returns:
1081  * 0 if node was closed successfully, error code otherwise.
1082  *
1083  */
1084 
1085 static int
1086 sata_hba_close(dev_t dev, int flag, int otyp, cred_t *credp)
1087 {
1088 #ifndef __lock_lint
1089 	_NOTE(ARGUNUSED(credp))
1090 	_NOTE(ARGUNUSED(flag))
1091 #endif
1092 	dev_info_t *dip;
1093 	scsi_hba_tran_t *scsi_hba_tran;
1094 	sata_hba_inst_t	*sata_hba_inst;
1095 
1096 	SATADBG1(SATA_DBG_IOCTL_IF, NULL, "sata_hba_close: entered", NULL);
1097 
1098 	if (otyp != OTYP_CHR)
1099 		return (EINVAL);
1100 
1101 	dip = sata_devt_to_devinfo(dev);
1102 	if (dip == NULL)
1103 		return (ENXIO);
1104 
1105 	if ((scsi_hba_tran = ddi_get_driver_private(dip)) == NULL)
1106 		return (ENXIO);
1107 
1108 	sata_hba_inst = scsi_hba_tran->tran_hba_private;
1109 	if (sata_hba_inst == NULL || sata_hba_inst->satahba_attached == 0)
1110 		return (ENXIO);
1111 
1112 	mutex_enter(&sata_mutex);
1113 	sata_hba_inst->satahba_open_flag = 0;
1114 	mutex_exit(&sata_mutex);
1115 	return (0);
1116 }
1117 
1118 
1119 
1120 /*
1121  * Standard IOCTL commands for SATA hotplugging.
1122  * Implemented DEVCTL_AP commands:
1123  * DEVCTL_AP_CONNECT
1124  * DEVCTL_AP_DISCONNECT
1125  * DEVCTL_AP_CONFIGURE
1126  * DEVCTL_UNCONFIGURE
1127  * DEVCTL_AP_CONTROL
1128  *
1129  * Commands passed to default ndi ioctl handler:
1130  * DEVCTL_DEVICE_GETSTATE
1131  * DEVCTL_DEVICE_ONLINE
1132  * DEVCTL_DEVICE_OFFLINE
1133  * DEVCTL_DEVICE_REMOVE
1134  * DEVCTL_DEVICE_INSERT
1135  * DEVCTL_BUS_GETSTATE
1136  *
1137  * All other cmds are passed to HBA if it provide ioctl handler, or failed
1138  * if not.
1139  *
1140  * Returns:
1141  * 0 if successful,
1142  * error code if operation failed.
1143  *
1144  * NOTE: Port Multiplier is not supported.
1145  *
1146  */
1147 
1148 static int
1149 sata_hba_ioctl(dev_t dev, int cmd, intptr_t arg, int mode, cred_t *credp,
1150     int *rvalp)
1151 {
1152 #ifndef __lock_lint
1153 	_NOTE(ARGUNUSED(credp))
1154 	_NOTE(ARGUNUSED(rvalp))
1155 #endif
1156 	int rv = 0;
1157 	int32_t	comp_port = -1;
1158 	dev_info_t *dip;
1159 	devctl_ap_state_t ap_state;
1160 	struct devctl_iocdata *dcp = NULL;
1161 	scsi_hba_tran_t *scsi_hba_tran;
1162 	sata_hba_inst_t *sata_hba_inst;
1163 	sata_device_t sata_device;
1164 	sata_cport_info_t *cportinfo;
1165 	int cport, pmport, qual;
1166 	int rval = SATA_SUCCESS;
1167 
1168 	dip = sata_devt_to_devinfo(dev);
1169 	if (dip == NULL)
1170 		return (ENXIO);
1171 
1172 	if ((scsi_hba_tran = ddi_get_driver_private(dip)) == NULL)
1173 		return (ENXIO);
1174 
1175 	sata_hba_inst = scsi_hba_tran->tran_hba_private;
1176 	if (sata_hba_inst == NULL)
1177 		return (ENXIO);
1178 
1179 	if (sata_hba_inst->satahba_tran == NULL)
1180 		return (ENXIO);
1181 
1182 	switch (cmd) {
1183 
1184 	case DEVCTL_DEVICE_GETSTATE:
1185 	case DEVCTL_DEVICE_ONLINE:
1186 	case DEVCTL_DEVICE_OFFLINE:
1187 	case DEVCTL_DEVICE_REMOVE:
1188 	case DEVCTL_BUS_GETSTATE:
1189 		/*
1190 		 * There may be more cases that we want to pass to default
1191 		 * handler rather than fail them.
1192 		 */
1193 		return (ndi_devctl_ioctl(dip, cmd, arg, mode, 0));
1194 	}
1195 
1196 	/* read devctl ioctl data */
1197 	if (cmd != DEVCTL_AP_CONTROL) {
1198 		if (ndi_dc_allochdl((void *)arg, &dcp) != NDI_SUCCESS)
1199 			return (EFAULT);
1200 
1201 		if ((comp_port = sata_get_port_num(sata_hba_inst, dcp)) ==
1202 		    -1) {
1203 			if (dcp)
1204 				ndi_dc_freehdl(dcp);
1205 			return (EINVAL);
1206 		}
1207 
1208 		cport = SCSI_TO_SATA_CPORT(comp_port);
1209 		pmport = SCSI_TO_SATA_PMPORT(comp_port);
1210 		/* Only cport is considered now, i.e. SATA_ADDR_CPORT */
1211 		qual = SATA_ADDR_CPORT;
1212 		if (sata_validate_sata_address(sata_hba_inst, cport, pmport,
1213 		    qual) != 0) {
1214 			ndi_dc_freehdl(dcp);
1215 			return (EINVAL);
1216 		}
1217 
1218 		cportinfo = SATA_CPORT_INFO(sata_hba_inst, cport);
1219 		mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, cport)->
1220 		    cport_mutex);
1221 		if (cportinfo->cport_event_flags & SATA_EVNT_LOCK_PORT_BUSY) {
1222 			/*
1223 			 * Cannot process ioctl request now. Come back later.
1224 			 */
1225 			mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)->
1226 			    cport_mutex);
1227 			ndi_dc_freehdl(dcp);
1228 			return (EBUSY);
1229 		}
1230 		/* Block event processing for this port */
1231 		cportinfo->cport_event_flags |= SATA_APCTL_LOCK_PORT_BUSY;
1232 		mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex);
1233 
1234 		sata_device.satadev_addr.cport = cport;
1235 		sata_device.satadev_addr.pmport = pmport;
1236 		sata_device.satadev_addr.qual = qual;
1237 		sata_device.satadev_rev = SATA_DEVICE_REV;
1238 	}
1239 
1240 	switch (cmd) {
1241 
1242 	case DEVCTL_AP_DISCONNECT:
1243 
1244 		/*
1245 		 * Normally, cfgadm sata plugin will try to offline
1246 		 * (unconfigure) device before this request. Nevertheless,
1247 		 * if a device is still configured, we need to
1248 		 * attempt to offline and unconfigure device first, and we will
1249 		 * deactivate the port regardless of the unconfigure
1250 		 * operation results.
1251 		 *
1252 		 */
1253 		rv = sata_ioctl_disconnect(sata_hba_inst, &sata_device);
1254 
1255 		break;
1256 
1257 	case DEVCTL_AP_UNCONFIGURE:
1258 
1259 		/*
1260 		 * The unconfigure operation uses generic nexus operation to
1261 		 * offline a device. It leaves a target device node attached.
1262 		 * and obviously sata_drive_info attached as well, because
1263 		 * from the hardware point of view nothing has changed.
1264 		 */
1265 		rv = sata_ioctl_unconfigure(sata_hba_inst, &sata_device);
1266 		break;
1267 
1268 	case DEVCTL_AP_CONNECT:
1269 	{
1270 		/*
1271 		 * The sata cfgadm pluging will invoke this operation only if
1272 		 * port was found in the disconnect state (failed state
1273 		 * is also treated as the disconnected state).
1274 		 * If port activation is successful and a device is found
1275 		 * attached to the port, the initialization sequence is
1276 		 * executed to probe the port and attach
1277 		 * a device structure to a port structure. The device is not
1278 		 * set in configured state (system-wise) by this operation.
1279 		 */
1280 
1281 		rv = sata_ioctl_connect(sata_hba_inst, &sata_device);
1282 
1283 		break;
1284 	}
1285 
1286 	case DEVCTL_AP_CONFIGURE:
1287 	{
1288 		/*
1289 		 * A port may be in an active or shutdown state.
1290 		 * If port is in a failed state, operation is aborted.
1291 		 * If a port is in a shutdown state, sata_tran_port_activate()
1292 		 * is invoked prior to any other operation.
1293 		 *
1294 		 * Onlining the device involves creating a new target node.
1295 		 * If there is an old target node present (belonging to
1296 		 * previously removed device), the operation is aborted - the
1297 		 * old node has to be released and removed before configure
1298 		 * operation is attempted.
1299 		 */
1300 
1301 		rv = sata_ioctl_configure(sata_hba_inst, &sata_device);
1302 
1303 		break;
1304 	}
1305 
1306 	case DEVCTL_AP_GETSTATE:
1307 
1308 		sata_cfgadm_state(sata_hba_inst, comp_port, &ap_state);
1309 
1310 		ap_state.ap_last_change = (time_t)-1;
1311 		ap_state.ap_error_code = 0;
1312 		ap_state.ap_in_transition = 0;
1313 
1314 		/* Copy the return AP-state information to the user space */
1315 		if (ndi_dc_return_ap_state(&ap_state, dcp) != NDI_SUCCESS) {
1316 			rv = EFAULT;
1317 		}
1318 		break;
1319 
1320 	case DEVCTL_AP_CONTROL:
1321 	{
1322 		/*
1323 		 * Generic devctl for hardware specific functionality
1324 		 */
1325 		sata_ioctl_data_t	ioc;
1326 
1327 		ASSERT(dcp == NULL);
1328 
1329 		/* Copy in user ioctl data first */
1330 #ifdef _MULTI_DATAMODEL
1331 		if (ddi_model_convert_from(mode & FMODELS) ==
1332 		    DDI_MODEL_ILP32) {
1333 
1334 			sata_ioctl_data_32_t	ioc32;
1335 
1336 			if (ddi_copyin((void *)arg, (void *)&ioc32,
1337 			    sizeof (ioc32), mode) != 0) {
1338 				rv = EFAULT;
1339 				break;
1340 			}
1341 			ioc.cmd 	= (uint_t)ioc32.cmd;
1342 			ioc.port	= (uint_t)ioc32.port;
1343 			ioc.get_size	= (uint_t)ioc32.get_size;
1344 			ioc.buf		= (caddr_t)(uintptr_t)ioc32.buf;
1345 			ioc.bufsiz	= (uint_t)ioc32.bufsiz;
1346 			ioc.misc_arg	= (uint_t)ioc32.misc_arg;
1347 		} else
1348 #endif /* _MULTI_DATAMODEL */
1349 		if (ddi_copyin((void *)arg, (void *)&ioc, sizeof (ioc),
1350 		    mode) != 0) {
1351 			return (EFAULT);
1352 		}
1353 
1354 		SATADBG2(SATA_DBG_IOCTL_IF, sata_hba_inst,
1355 		    "sata_hba_ioctl: DEVCTL_AP_CONTROL "
1356 		    "cmd 0x%x, port 0x%x", ioc.cmd, ioc.port);
1357 
1358 		/*
1359 		 * To avoid BE/LE and 32/64 issues, a get_size always returns
1360 		 * a 32-bit number.
1361 		 */
1362 		if (ioc.get_size != 0 && ioc.bufsiz != (sizeof (uint32_t))) {
1363 			return (EINVAL);
1364 		}
1365 		/* validate address */
1366 		cport = SCSI_TO_SATA_CPORT(ioc.port);
1367 		pmport = SCSI_TO_SATA_PMPORT(ioc.port);
1368 		qual = SCSI_TO_SATA_ADDR_QUAL(ioc.port);
1369 
1370 		/* Override address qualifier - handle cport only for now */
1371 		qual = SATA_ADDR_CPORT;
1372 
1373 		if (sata_validate_sata_address(sata_hba_inst, cport,
1374 		    pmport, qual) != 0)
1375 			return (EINVAL);
1376 
1377 		cportinfo = SATA_CPORT_INFO(sata_hba_inst, cport);
1378 		mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, cport)->
1379 		    cport_mutex);
1380 		/* Is the port locked by event processing daemon ? */
1381 		if (cportinfo->cport_event_flags & SATA_EVNT_LOCK_PORT_BUSY) {
1382 			/*
1383 			 * Cannot process ioctl request now. Come back later
1384 			 */
1385 			mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)->
1386 			    cport_mutex);
1387 			return (EBUSY);
1388 		}
1389 		/* Block event processing for this port */
1390 		cportinfo->cport_event_flags |= SATA_APCTL_LOCK_PORT_BUSY;
1391 		mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex);
1392 
1393 
1394 		sata_device.satadev_addr.cport = cport;
1395 		sata_device.satadev_addr.pmport = pmport;
1396 		sata_device.satadev_addr.qual = qual;
1397 		sata_device.satadev_rev = SATA_DEVICE_REV;
1398 
1399 		switch (ioc.cmd) {
1400 
1401 		case SATA_CFGA_RESET_PORT:
1402 			/*
1403 			 * There is no protection for configured device.
1404 			 */
1405 			rv = sata_ioctl_reset_port(sata_hba_inst, &sata_device);
1406 			break;
1407 
1408 		case SATA_CFGA_RESET_DEVICE:
1409 			/*
1410 			 * There is no protection for configured device.
1411 			 */
1412 			rv = sata_ioctl_reset_device(sata_hba_inst,
1413 			    &sata_device);
1414 			break;
1415 
1416 		case SATA_CFGA_RESET_ALL:
1417 			/*
1418 			 * There is no protection for configured devices.
1419 			 */
1420 			rv = sata_ioctl_reset_all(sata_hba_inst);
1421 			/*
1422 			 * We return here, because common return is for
1423 			 * a single port operation - we have already unlocked
1424 			 * all ports and no dc handle was allocated.
1425 			 */
1426 			return (rv);
1427 
1428 		case SATA_CFGA_PORT_DEACTIVATE:
1429 			/*
1430 			 * Arbitrarily unconfigure attached device, if any.
1431 			 * Even if the unconfigure fails, proceed with the
1432 			 * port deactivation.
1433 			 */
1434 			rv = sata_ioctl_deactivate(sata_hba_inst, &sata_device);
1435 
1436 			break;
1437 
1438 		case SATA_CFGA_PORT_ACTIVATE:
1439 
1440 			rv = sata_ioctl_activate(sata_hba_inst, &sata_device);
1441 			break;
1442 
1443 		case SATA_CFGA_PORT_SELF_TEST:
1444 
1445 			rv = sata_ioctl_port_self_test(sata_hba_inst,
1446 			    &sata_device);
1447 			break;
1448 
1449 		case SATA_CFGA_GET_DEVICE_PATH:
1450 			if (qual == SATA_ADDR_CPORT)
1451 				sata_device.satadev_addr.qual =
1452 				    SATA_ADDR_DCPORT;
1453 			else
1454 				sata_device.satadev_addr.qual =
1455 				    SATA_ADDR_DPMPORT;
1456 			rv = sata_ioctl_get_device_path(sata_hba_inst,
1457 			    &sata_device, &ioc, mode);
1458 			break;
1459 
1460 		case SATA_CFGA_GET_AP_TYPE:
1461 
1462 			rv = sata_ioctl_get_ap_type(sata_hba_inst,
1463 			    &sata_device, &ioc, mode);
1464 			break;
1465 
1466 		case SATA_CFGA_GET_MODEL_INFO:
1467 
1468 			rv = sata_ioctl_get_model_info(sata_hba_inst,
1469 			    &sata_device, &ioc, mode);
1470 			break;
1471 
1472 		case SATA_CFGA_GET_REVFIRMWARE_INFO:
1473 
1474 			rv = sata_ioctl_get_revfirmware_info(sata_hba_inst,
1475 			    &sata_device, &ioc, mode);
1476 			break;
1477 
1478 		case SATA_CFGA_GET_SERIALNUMBER_INFO:
1479 
1480 			rv = sata_ioctl_get_serialnumber_info(sata_hba_inst,
1481 			    &sata_device, &ioc, mode);
1482 			break;
1483 
1484 		default:
1485 			rv = EINVAL;
1486 			break;
1487 
1488 		} /* End of DEVCTL_AP_CONTROL cmd switch */
1489 
1490 		break;
1491 	}
1492 
1493 	default:
1494 	{
1495 		/*
1496 		 * If we got here, we got an IOCTL that SATA HBA Framework
1497 		 * does not recognize. Pass ioctl to HBA driver, in case
1498 		 * it could process it.
1499 		 */
1500 		sata_hba_tran_t *sata_tran = sata_hba_inst->satahba_tran;
1501 		dev_info_t	*mydip = SATA_DIP(sata_hba_inst);
1502 
1503 		SATADBG1(SATA_DBG_IOCTL_IF, sata_hba_inst,
1504 		    "IOCTL 0x%2x not supported in SATA framework, "
1505 		    "passthrough to HBA", cmd);
1506 
1507 		if (sata_tran->sata_tran_ioctl == NULL) {
1508 			rv = EINVAL;
1509 			break;
1510 		}
1511 		rval = (*sata_tran->sata_tran_ioctl)(mydip, cmd, arg);
1512 		if (rval != 0) {
1513 			SATADBG1(SATA_DBG_IOCTL_IF, sata_hba_inst,
1514 			    "IOCTL 0x%2x failed in HBA", cmd);
1515 			rv = rval;
1516 		}
1517 		break;
1518 	}
1519 
1520 	} /* End of main IOCTL switch */
1521 
1522 	if (dcp) {
1523 		ndi_dc_freehdl(dcp);
1524 	}
1525 	mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex);
1526 	cportinfo->cport_event_flags &= ~SATA_APCTL_LOCK_PORT_BUSY;
1527 	mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex);
1528 
1529 	return (rv);
1530 }
1531 
1532 
1533 /*
1534  * Create error retrieval sata packet
1535  *
1536  * A sata packet is allocated and set-up to contain specified error retrieval
1537  * command and appropriate dma-able data buffer.
1538  * No association with any scsi packet is made and no callback routine is
1539  * specified.
1540  *
1541  * Returns a pointer to sata packet upon successfull packet creation.
1542  * Returns NULL, if packet cannot be created.
1543  */
1544 sata_pkt_t *
1545 sata_get_error_retrieval_pkt(dev_info_t *dip, sata_device_t *sata_device,
1546     int pkt_type)
1547 {
1548 	sata_hba_inst_t	*sata_hba_inst;
1549 	sata_pkt_txlate_t *spx;
1550 	sata_pkt_t *spkt;
1551 	sata_drive_info_t *sdinfo;
1552 
1553 	mutex_enter(&sata_mutex);
1554 	for (sata_hba_inst = sata_hba_list; sata_hba_inst != NULL;
1555 	    sata_hba_inst = sata_hba_inst->satahba_next) {
1556 		if (SATA_DIP(sata_hba_inst) == dip)
1557 			break;
1558 	}
1559 	mutex_exit(&sata_mutex);
1560 	ASSERT(sata_hba_inst != NULL);
1561 
1562 	sdinfo = sata_get_device_info(sata_hba_inst, sata_device);
1563 	if (sdinfo == NULL) {
1564 		sata_log(sata_hba_inst, CE_WARN,
1565 		    "sata: error recovery request for non-attached device at "
1566 		    "cport %d", sata_device->satadev_addr.cport);
1567 		return (NULL);
1568 	}
1569 
1570 	spx = kmem_zalloc(sizeof (sata_pkt_txlate_t), KM_SLEEP);
1571 	spx->txlt_sata_hba_inst = sata_hba_inst;
1572 	spx->txlt_scsi_pkt = NULL;		/* No scsi pkt involved */
1573 	spkt = sata_pkt_alloc(spx, NULL);
1574 	if (spkt == NULL) {
1575 		kmem_free(spx, sizeof (sata_pkt_txlate_t));
1576 		return (NULL);
1577 	}
1578 	/* address is needed now */
1579 	spkt->satapkt_device.satadev_addr = sata_device->satadev_addr;
1580 
1581 	switch (pkt_type) {
1582 	case SATA_ERR_RETR_PKT_TYPE_NCQ:
1583 		if (sata_ncq_err_ret_cmd_setup(spx, sdinfo) == SATA_SUCCESS)
1584 			return (spkt);
1585 		break;
1586 
1587 	case SATA_ERR_RETR_PKT_TYPE_ATAPI:
1588 		if (sata_atapi_err_ret_cmd_setup(spx, sdinfo) == SATA_SUCCESS)
1589 			return (spkt);
1590 		break;
1591 
1592 	default:
1593 		break;
1594 	}
1595 
1596 	sata_pkt_free(spx);
1597 	kmem_free(spx, sizeof (sata_pkt_txlate_t));
1598 	return (NULL);
1599 
1600 }
1601 
1602 
1603 /*
1604  * Free error retrieval sata packet
1605  *
1606  * Free sata packet and any associated resources allocated previously by
1607  * sata_get_error_retrieval_pkt().
1608  *
1609  * Void return.
1610  */
1611 void
1612 sata_free_error_retrieval_pkt(sata_pkt_t *sata_pkt)
1613 {
1614 	sata_pkt_txlate_t *spx =
1615 	    (sata_pkt_txlate_t *)sata_pkt->satapkt_framework_private;
1616 
1617 	ASSERT(sata_pkt != NULL);
1618 
1619 	sata_free_local_buffer(spx);
1620 	sata_pkt_free(spx);
1621 	kmem_free(spx, sizeof (sata_pkt_txlate_t));
1622 
1623 }
1624 
1625 
1626 /* ****************** SCSA required entry points *********************** */
1627 
1628 /*
1629  * Implementation of scsi tran_tgt_init.
1630  * sata_scsi_tgt_init() initializes scsi_device structure
1631  *
1632  * If successful, DDI_SUCCESS is returned.
1633  * DDI_FAILURE is returned if addressed device does not exist
1634  */
1635 
1636 static int
1637 sata_scsi_tgt_init(dev_info_t *hba_dip, dev_info_t *tgt_dip,
1638     scsi_hba_tran_t *hba_tran, struct scsi_device *sd)
1639 {
1640 #ifndef __lock_lint
1641 	_NOTE(ARGUNUSED(hba_dip))
1642 	_NOTE(ARGUNUSED(tgt_dip))
1643 #endif
1644 	sata_device_t		sata_device;
1645 	sata_drive_info_t	*sdinfo;
1646 	struct sata_id		*sid;
1647 	sata_hba_inst_t		*sata_hba_inst;
1648 	char			model[SATA_ID_MODEL_LEN + 1];
1649 	char			fw[SATA_ID_FW_LEN + 1];
1650 	char			*vid, *pid;
1651 	int			i;
1652 
1653 	sata_hba_inst = (sata_hba_inst_t *)(hba_tran->tran_hba_private);
1654 
1655 	/* Validate scsi device address */
1656 	if (sata_validate_scsi_address(sata_hba_inst, &sd->sd_address,
1657 	    &sata_device) != 0)
1658 		return (DDI_FAILURE);
1659 
1660 	mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst,
1661 	    sata_device.satadev_addr.cport)));
1662 
1663 	/* sata_device now contains a valid sata address */
1664 	sdinfo = sata_get_device_info(sata_hba_inst, &sata_device);
1665 	if (sdinfo == NULL) {
1666 		mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst,
1667 		    sata_device.satadev_addr.cport)));
1668 		return (DDI_FAILURE);
1669 	}
1670 	mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst,
1671 	    sata_device.satadev_addr.cport)));
1672 
1673 	/*
1674 	 * Check if we need to create a legacy devid (i.e cmdk style) for
1675 	 * the target disks.
1676 	 *
1677 	 * HBA devinfo node will have the property "use-cmdk-devid-format"
1678 	 * if we need to create cmdk-style devid for all the disk devices
1679 	 * attached to this controller. This property may have been set
1680 	 * from HBA driver's .conf file or by the HBA driver in its
1681 	 * attach(9F) function.
1682 	 */
1683 	if ((sdinfo->satadrv_type == SATA_DTYPE_ATADISK) &&
1684 	    (ddi_getprop(DDI_DEV_T_ANY, hba_dip, DDI_PROP_DONTPASS,
1685 	    "use-cmdk-devid-format", 0) == 1)) {
1686 		/* register a legacy devid for this target node */
1687 		sata_target_devid_register(tgt_dip, sdinfo);
1688 	}
1689 
1690 
1691 	/*
1692 	 * 'Identify Device Data' does not always fit in standard SCSI
1693 	 * INQUIRY data, so establish INQUIRY_* properties with full-form
1694 	 * of information.
1695 	 */
1696 	sid = &sdinfo->satadrv_id;
1697 #ifdef	_LITTLE_ENDIAN
1698 	swab(sid->ai_model, model, SATA_ID_MODEL_LEN);
1699 	swab(sid->ai_fw, fw, SATA_ID_FW_LEN);
1700 #else	/* _LITTLE_ENDIAN */
1701 	bcopy(sid->ai_model, model, SATA_ID_MODEL_LEN);
1702 	bcopy(sid->ai_fw, fw, SATA_ID_FW_LEN);
1703 #endif	/* _LITTLE_ENDIAN */
1704 	model[SATA_ID_MODEL_LEN] = 0;
1705 	fw[SATA_ID_FW_LEN] = 0;
1706 
1707 	/* split model into into vid/pid */
1708 	for (i = 0, pid = model; i < SATA_ID_MODEL_LEN; i++, pid++)
1709 		if ((*pid == ' ') || (*pid == '\t'))
1710 			break;
1711 	if (i < SATA_ID_MODEL_LEN) {
1712 		vid = model;
1713 		*pid++ = 0;		/* terminate vid, establish pid */
1714 	} else {
1715 		vid = NULL;		/* vid will stay "ATA     " */
1716 		pid = model;		/* model is all pid */
1717 	}
1718 
1719 	if (vid)
1720 		(void) scsi_hba_prop_update_inqstring(sd, INQUIRY_VENDOR_ID,
1721 		    vid, strlen(vid));
1722 	if (pid)
1723 		(void) scsi_hba_prop_update_inqstring(sd, INQUIRY_PRODUCT_ID,
1724 		    pid, strlen(pid));
1725 	(void) scsi_hba_prop_update_inqstring(sd, INQUIRY_REVISION_ID,
1726 	    fw, strlen(fw));
1727 
1728 	return (DDI_SUCCESS);
1729 }
1730 
1731 /*
1732  * Implementation of scsi tran_tgt_probe.
1733  * Probe target, by calling default scsi routine scsi_hba_probe()
1734  */
1735 static int
1736 sata_scsi_tgt_probe(struct scsi_device *sd, int (*callback)(void))
1737 {
1738 	sata_hba_inst_t *sata_hba_inst =
1739 	    (sata_hba_inst_t *)(sd->sd_address.a_hba_tran->tran_hba_private);
1740 	int rval;
1741 
1742 	rval = scsi_hba_probe(sd, callback);
1743 
1744 	if (rval == SCSIPROBE_EXISTS) {
1745 		/*
1746 		 * Set property "pm-capable" on the target device node, so that
1747 		 * the target driver will not try to fetch scsi cycle counters
1748 		 * before enabling device power-management.
1749 		 */
1750 		if ((ddi_prop_update_int(DDI_DEV_T_NONE, sd->sd_dev,
1751 		    "pm-capable", 1)) != DDI_PROP_SUCCESS) {
1752 			sata_log(sata_hba_inst, CE_WARN,
1753 			    "SATA device at port %d: "
1754 			    "will not be power-managed ",
1755 			    SCSI_TO_SATA_CPORT(sd->sd_address.a_target));
1756 			SATA_LOG_D((sata_hba_inst, CE_WARN,
1757 			    "failure updating pm-capable property"));
1758 		}
1759 	}
1760 	return (rval);
1761 }
1762 
1763 /*
1764  * Implementation of scsi tran_tgt_free.
1765  * Release all resources allocated for scsi_device
1766  */
1767 static void
1768 sata_scsi_tgt_free(dev_info_t *hba_dip, dev_info_t *tgt_dip,
1769     scsi_hba_tran_t *hba_tran, struct scsi_device *sd)
1770 {
1771 #ifndef __lock_lint
1772 	_NOTE(ARGUNUSED(hba_dip))
1773 #endif
1774 	sata_device_t		sata_device;
1775 	sata_drive_info_t	*sdinfo;
1776 	sata_hba_inst_t		*sata_hba_inst;
1777 	ddi_devid_t		devid;
1778 
1779 	sata_hba_inst = (sata_hba_inst_t *)(hba_tran->tran_hba_private);
1780 
1781 	/* Validate scsi device address */
1782 	if (sata_validate_scsi_address(sata_hba_inst, &sd->sd_address,
1783 	    &sata_device) != 0)
1784 		return;
1785 
1786 	mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst,
1787 	    sata_device.satadev_addr.cport)));
1788 
1789 	/* sata_device now should contain a valid sata address */
1790 	sdinfo = sata_get_device_info(sata_hba_inst, &sata_device);
1791 	if (sdinfo == NULL) {
1792 		mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst,
1793 		    sata_device.satadev_addr.cport)));
1794 		return;
1795 	}
1796 	/*
1797 	 * We did not allocate any resources in sata_scsi_tgt_init()
1798 	 * other than few properties.
1799 	 * Free them.
1800 	 */
1801 	mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst,
1802 	    sata_device.satadev_addr.cport)));
1803 	(void) ndi_prop_remove(DDI_DEV_T_NONE, tgt_dip, "pm-capable");
1804 
1805 	/*
1806 	 * If devid was previously created but not freed up from
1807 	 * sd(7D) driver (i.e during detach(9F)) then do it here.
1808 	 */
1809 	if ((sdinfo->satadrv_type == SATA_DTYPE_ATADISK) &&
1810 	    (ddi_getprop(DDI_DEV_T_ANY, hba_dip, DDI_PROP_DONTPASS,
1811 	    "use-cmdk-devid-format", 0) == 1) &&
1812 	    (ddi_devid_get(tgt_dip, &devid) == DDI_SUCCESS)) {
1813 		ddi_devid_unregister(tgt_dip);
1814 		ddi_devid_free(devid);
1815 	}
1816 }
1817 
1818 /*
1819  * Implementation of scsi tran_init_pkt
1820  * Upon successful return, scsi pkt buffer has DMA resources allocated.
1821  *
1822  * It seems that we should always allocate pkt, even if the address is
1823  * for non-existing device - just use some default for dma_attr.
1824  * The reason is that there is no way to communicate this to a caller here.
1825  * Subsequent call to sata_scsi_start may fail appropriately.
1826  * Simply returning NULL does not seem to discourage a target driver...
1827  *
1828  * Returns a pointer to initialized scsi_pkt, or NULL otherwise.
1829  */
1830 static struct scsi_pkt *
1831 sata_scsi_init_pkt(struct scsi_address *ap, struct scsi_pkt *pkt,
1832     struct buf *bp, int cmdlen, int statuslen, int tgtlen, int flags,
1833     int (*callback)(caddr_t), caddr_t arg)
1834 {
1835 	sata_hba_inst_t *sata_hba_inst =
1836 	    (sata_hba_inst_t *)(ap->a_hba_tran->tran_hba_private);
1837 	dev_info_t *dip = SATA_DIP(sata_hba_inst);
1838 	sata_device_t sata_device;
1839 	sata_drive_info_t *sdinfo;
1840 	sata_pkt_txlate_t *spx;
1841 	ddi_dma_attr_t cur_dma_attr;
1842 	int rval;
1843 	boolean_t new_pkt = TRUE;
1844 
1845 	ASSERT(ap->a_hba_tran->tran_hba_dip == dip);
1846 
1847 	/*
1848 	 * We need to translate the address, even if it could be
1849 	 * a bogus one, for a non-existing device
1850 	 */
1851 	sata_device.satadev_addr.qual = SCSI_TO_SATA_ADDR_QUAL(ap->a_target);
1852 	sata_device.satadev_addr.cport = SCSI_TO_SATA_CPORT(ap->a_target);
1853 	sata_device.satadev_addr.pmport = SCSI_TO_SATA_PMPORT(ap->a_target);
1854 	sata_device.satadev_rev = SATA_DEVICE_REV;
1855 
1856 	if (pkt == NULL) {
1857 		/*
1858 		 * Have to allocate a brand new scsi packet.
1859 		 * We need to operate with auto request sense enabled.
1860 		 */
1861 		pkt = scsi_hba_pkt_alloc(dip, ap, cmdlen,
1862 		    MAX(statuslen, sizeof (struct scsi_arq_status)),
1863 		    tgtlen, sizeof (sata_pkt_txlate_t), callback, arg);
1864 
1865 		if (pkt == NULL)
1866 			return (NULL);
1867 
1868 		/* Fill scsi packet structure */
1869 		pkt->pkt_comp		= (void (*)())NULL;
1870 		pkt->pkt_time		= 0;
1871 		pkt->pkt_resid		= 0;
1872 		pkt->pkt_statistics	= 0;
1873 		pkt->pkt_reason		= 0;
1874 
1875 		/*
1876 		 * pkt_hba_private will point to sata pkt txlate structure
1877 		 */
1878 		spx = (sata_pkt_txlate_t *)pkt->pkt_ha_private;
1879 		bzero(spx, sizeof (sata_pkt_txlate_t));
1880 
1881 		spx->txlt_scsi_pkt = pkt;
1882 		spx->txlt_sata_hba_inst = sata_hba_inst;
1883 
1884 		/* Allocate sata_pkt */
1885 		spx->txlt_sata_pkt = sata_pkt_alloc(spx, callback);
1886 		if (spx->txlt_sata_pkt == NULL) {
1887 			/* Could not allocate sata pkt */
1888 			scsi_hba_pkt_free(ap, pkt);
1889 			return (NULL);
1890 		}
1891 		/* Set sata address */
1892 		spx->txlt_sata_pkt->satapkt_device.satadev_addr =
1893 		    sata_device.satadev_addr;
1894 		spx->txlt_sata_pkt->satapkt_device.satadev_rev =
1895 		    sata_device.satadev_rev;
1896 
1897 		if ((bp == NULL) || (bp->b_bcount == 0))
1898 			return (pkt);
1899 
1900 		spx->txlt_total_residue = bp->b_bcount;
1901 	} else {
1902 		new_pkt = FALSE;
1903 		/*
1904 		 * Packet was preallocated/initialized by previous call
1905 		 */
1906 		spx = (sata_pkt_txlate_t *)pkt->pkt_ha_private;
1907 
1908 		if ((bp == NULL) || (bp->b_bcount == 0)) {
1909 			return (pkt);
1910 		}
1911 		ASSERT(spx->txlt_buf_dma_handle != NULL);
1912 
1913 		/* Pkt is available already: spx->txlt_scsi_pkt == pkt; */
1914 	}
1915 
1916 	spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp = bp;
1917 
1918 	/*
1919 	 * We use an adjusted version of the dma_attr, to account
1920 	 * for device addressing limitations.
1921 	 * sata_adjust_dma_attr() will handle sdinfo == NULL which may
1922 	 * happen when a device is not yet configured.
1923 	 */
1924 	mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst,
1925 	    sata_device.satadev_addr.cport)));
1926 	sdinfo = sata_get_device_info(spx->txlt_sata_hba_inst,
1927 	    &spx->txlt_sata_pkt->satapkt_device);
1928 	/* NULL sdinfo may be passsed to sata_adjust_dma_attr() */
1929 	sata_adjust_dma_attr(sdinfo,
1930 	    SATA_DMA_ATTR(spx->txlt_sata_hba_inst), &cur_dma_attr);
1931 	mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst,
1932 	    sata_device.satadev_addr.cport)));
1933 	/*
1934 	 * Allocate necessary DMA resources for the packet's data buffer
1935 	 * NOTE:
1936 	 * In case of read/write commands, DMA resource allocation here is
1937 	 * based on the premise that the transfer length specified in
1938 	 * the read/write scsi cdb will match exactly DMA resources -
1939 	 * returning correct packet residue is crucial.
1940 	 */
1941 	if ((rval = sata_dma_buf_setup(spx, flags, callback, arg,
1942 	    &cur_dma_attr)) != DDI_SUCCESS) {
1943 		spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp = NULL;
1944 		sata_pkt_free(spx);
1945 		/*
1946 		 * If a DMA allocation request fails with
1947 		 * DDI_DMA_NOMAPPING, indicate the error by calling
1948 		 * bioerror(9F) with bp and an error code of EFAULT.
1949 		 * If a DMA allocation request fails with
1950 		 * DDI_DMA_TOOBIG, indicate the error by calling
1951 		 * bioerror(9F) with bp and an error code of EINVAL.
1952 		 */
1953 		switch (rval) {
1954 		case DDI_DMA_NORESOURCES:
1955 			bioerror(bp, 0);
1956 			break;
1957 		case DDI_DMA_NOMAPPING:
1958 		case DDI_DMA_BADATTR:
1959 			bioerror(bp, EFAULT);
1960 			break;
1961 		case DDI_DMA_TOOBIG:
1962 		default:
1963 			bioerror(bp, EINVAL);
1964 			break;
1965 		}
1966 		if (new_pkt == TRUE)
1967 			scsi_hba_pkt_free(ap, pkt);
1968 		return (NULL);
1969 	}
1970 	/* Set number of bytes that are not yet accounted for */
1971 	pkt->pkt_resid = spx->txlt_total_residue;
1972 	ASSERT(pkt->pkt_resid >= 0);
1973 
1974 	return (pkt);
1975 }
1976 
1977 /*
1978  * Implementation of scsi tran_start.
1979  * Translate scsi cmd into sata operation and return status.
1980  * ATAPI CDBs are passed to ATAPI devices - the device determines what commands
1981  * are supported.
1982  * For SATA hard disks, supported scsi commands:
1983  * SCMD_INQUIRY
1984  * SCMD_TEST_UNIT_READY
1985  * SCMD_START_STOP
1986  * SCMD_READ_CAPACITY
1987  * SCMD_REQUEST_SENSE
1988  * SCMD_LOG_SENSE_G1
1989  * SCMD_LOG_SELECT_G1
1990  * SCMD_MODE_SENSE	(specific pages)
1991  * SCMD_MODE_SENSE_G1	(specific pages)
1992  * SCMD_MODE_SELECT	(specific pages)
1993  * SCMD_MODE_SELECT_G1	(specific pages)
1994  * SCMD_SYNCHRONIZE_CACHE
1995  * SCMD_SYNCHRONIZE_CACHE_G1
1996  * SCMD_READ
1997  * SCMD_READ_G1
1998  * SCMD_READ_G4
1999  * SCMD_READ_G5
2000  * SCMD_WRITE
2001  * SCMD_WRITE_BUFFER
2002  * SCMD_WRITE_G1
2003  * SCMD_WRITE_G4
2004  * SCMD_WRITE_G5
2005  * SCMD_SEEK		(noop)
2006  * SCMD_SDIAG
2007  *
2008  * All other commands are rejected as unsupported.
2009  *
2010  * Returns:
2011  * TRAN_ACCEPT if command was executed successfully or accepted by HBA driver
2012  * for execution. TRAN_ACCEPT may be returned also if device was removed but
2013  * a callback could be scheduled.
2014  * TRAN_BADPKT if cmd was directed to invalid address.
2015  * TRAN_FATAL_ERROR is command was rejected due to hardware error, including
2016  * some unspecified error. TRAN_FATAL_ERROR may be also returned if a device
2017  * was removed and there was no callback specified in scsi pkt.
2018  * TRAN_BUSY if command could not be executed becasue HBA driver or SATA
2019  * framework was busy performing some other operation(s).
2020  *
2021  */
2022 static int
2023 sata_scsi_start(struct scsi_address *ap, struct scsi_pkt *pkt)
2024 {
2025 	sata_hba_inst_t *sata_hba_inst =
2026 	    (sata_hba_inst_t *)(ap->a_hba_tran->tran_hba_private);
2027 	sata_pkt_txlate_t *spx = (sata_pkt_txlate_t *)pkt->pkt_ha_private;
2028 	sata_drive_info_t *sdinfo;
2029 	struct buf *bp;
2030 	int cport;
2031 	int rval;
2032 
2033 	SATADBG1(SATA_DBG_SCSI_IF, sata_hba_inst,
2034 	    "sata_scsi_start: cmd 0x%02x\n", pkt->pkt_cdbp[0]);
2035 
2036 	ASSERT(spx != NULL &&
2037 	    spx->txlt_scsi_pkt == pkt && spx->txlt_sata_pkt != NULL);
2038 
2039 	cport = SCSI_TO_SATA_CPORT(ap->a_target);
2040 
2041 	mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, cport)));
2042 	sdinfo = sata_get_device_info(sata_hba_inst,
2043 	    &spx->txlt_sata_pkt->satapkt_device);
2044 	if (sdinfo == NULL ||
2045 	    SATA_CPORT_INFO(sata_hba_inst, cport)->cport_tgtnode_clean ==
2046 	    B_FALSE) {
2047 		mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, cport)));
2048 		pkt->pkt_reason = CMD_DEV_GONE;
2049 		/*
2050 		 * The sd target driver is checking CMD_DEV_GONE pkt_reason
2051 		 * only in callback function (for normal requests) and
2052 		 * in the dump code path.
2053 		 * So, if the callback is available, we need to do
2054 		 * the callback rather than returning TRAN_FATAL_ERROR here.
2055 		 */
2056 		if (pkt->pkt_comp != NULL) {
2057 			/* scsi callback required */
2058 			if (taskq_dispatch(SATA_TXLT_TASKQ(spx),
2059 			    (task_func_t *)pkt->pkt_comp,
2060 			    (void *)pkt, TQ_SLEEP) == NULL)
2061 				/* Scheduling the callback failed */
2062 				return (TRAN_BUSY);
2063 			return (TRAN_ACCEPT);
2064 		}
2065 		/* No callback available */
2066 		return (TRAN_FATAL_ERROR);
2067 	}
2068 
2069 	if (sdinfo->satadrv_type == SATA_DTYPE_ATAPICD) {
2070 		mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, cport)));
2071 		rval = sata_txlt_atapi(spx);
2072 		SATADBG1(SATA_DBG_SCSI_IF, sata_hba_inst,
2073 		    "sata_scsi_start atapi: rval %d\n", rval);
2074 		return (rval);
2075 	}
2076 	mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, cport)));
2077 
2078 	/* ATA Disk commands processing starts here */
2079 
2080 	bp = spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp;
2081 
2082 	switch (pkt->pkt_cdbp[0]) {
2083 
2084 	case SCMD_INQUIRY:
2085 		/* Mapped to identify device */
2086 		if (bp != NULL && (bp->b_flags & (B_PHYS | B_PAGEIO)))
2087 			bp_mapin(bp);
2088 		rval = sata_txlt_inquiry(spx);
2089 		break;
2090 
2091 	case SCMD_TEST_UNIT_READY:
2092 		/*
2093 		 * SAT "SATA to ATA Translation" doc specifies translation
2094 		 * to ATA CHECK POWER MODE.
2095 		 */
2096 		rval = sata_txlt_test_unit_ready(spx);
2097 		break;
2098 
2099 	case SCMD_START_STOP:
2100 		/* Mapping depends on the command */
2101 		rval = sata_txlt_start_stop_unit(spx);
2102 		break;
2103 
2104 	case SCMD_READ_CAPACITY:
2105 		if (bp != NULL && (bp->b_flags & (B_PHYS | B_PAGEIO)))
2106 			bp_mapin(bp);
2107 		rval = sata_txlt_read_capacity(spx);
2108 		break;
2109 
2110 	case SCMD_REQUEST_SENSE:
2111 		/*
2112 		 * Always No Sense, since we force ARQ
2113 		 */
2114 		if (bp != NULL && (bp->b_flags & (B_PHYS | B_PAGEIO)))
2115 			bp_mapin(bp);
2116 		rval = sata_txlt_request_sense(spx);
2117 		break;
2118 
2119 	case SCMD_LOG_SENSE_G1:
2120 		if (bp != NULL && (bp->b_flags & (B_PHYS | B_PAGEIO)))
2121 			bp_mapin(bp);
2122 		rval = sata_txlt_log_sense(spx);
2123 		break;
2124 
2125 	case SCMD_LOG_SELECT_G1:
2126 		if (bp != NULL && (bp->b_flags & (B_PHYS | B_PAGEIO)))
2127 			bp_mapin(bp);
2128 		rval = sata_txlt_log_select(spx);
2129 		break;
2130 
2131 	case SCMD_MODE_SENSE:
2132 	case SCMD_MODE_SENSE_G1:
2133 		if (bp != NULL && (bp->b_flags & (B_PHYS | B_PAGEIO)))
2134 			bp_mapin(bp);
2135 		rval = sata_txlt_mode_sense(spx);
2136 		break;
2137 
2138 
2139 	case SCMD_MODE_SELECT:
2140 	case SCMD_MODE_SELECT_G1:
2141 		if (bp != NULL && (bp->b_flags & (B_PHYS | B_PAGEIO)))
2142 			bp_mapin(bp);
2143 		rval = sata_txlt_mode_select(spx);
2144 		break;
2145 
2146 	case SCMD_SYNCHRONIZE_CACHE:
2147 	case SCMD_SYNCHRONIZE_CACHE_G1:
2148 		rval = sata_txlt_synchronize_cache(spx);
2149 		break;
2150 
2151 	case SCMD_READ:
2152 	case SCMD_READ_G1:
2153 	case SCMD_READ_G4:
2154 	case SCMD_READ_G5:
2155 		rval = sata_txlt_read(spx);
2156 		break;
2157 	case SCMD_WRITE_BUFFER:
2158 		if (bp != NULL && (bp->b_flags & (B_PHYS | B_PAGEIO)))
2159 			bp_mapin(bp);
2160 		rval = sata_txlt_write_buffer(spx);
2161 		break;
2162 
2163 	case SCMD_WRITE:
2164 	case SCMD_WRITE_G1:
2165 	case SCMD_WRITE_G4:
2166 	case SCMD_WRITE_G5:
2167 		rval = sata_txlt_write(spx);
2168 		break;
2169 
2170 	case SCMD_SEEK:
2171 		rval = sata_txlt_nodata_cmd_immediate(spx);
2172 		break;
2173 
2174 		/* Other cases will be filed later */
2175 		/* postponed until phase 2 of the development */
2176 	default:
2177 		rval = sata_txlt_invalid_command(spx);
2178 		break;
2179 	}
2180 
2181 	SATADBG1(SATA_DBG_SCSI_IF, sata_hba_inst,
2182 	    "sata_scsi_start: rval %d\n", rval);
2183 
2184 	return (rval);
2185 }
2186 
2187 /*
2188  * Implementation of scsi tran_abort.
2189  * Abort specific pkt or all packets.
2190  *
2191  * Returns 1 if one or more packets were aborted, returns 0 otherwise
2192  *
2193  * May be called from an interrupt level.
2194  */
2195 static int
2196 sata_scsi_abort(struct scsi_address *ap, struct scsi_pkt *scsi_pkt)
2197 {
2198 	sata_hba_inst_t *sata_hba_inst =
2199 	    (sata_hba_inst_t *)(ap->a_hba_tran->tran_hba_private);
2200 	sata_device_t	sata_device;
2201 	sata_pkt_t	*sata_pkt;
2202 
2203 	SATADBG2(SATA_DBG_SCSI_IF, sata_hba_inst,
2204 	    "sata_scsi_abort: %s at target: 0x%x\n",
2205 	    scsi_pkt == NULL ? "all packets" : "one pkt", ap->a_target);
2206 
2207 	/* Validate address */
2208 	if (sata_validate_scsi_address(sata_hba_inst, ap, &sata_device) != 0)
2209 		/* Invalid address */
2210 		return (0);
2211 
2212 	mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst,
2213 	    sata_device.satadev_addr.cport)));
2214 	if (sata_get_device_info(sata_hba_inst, &sata_device) == NULL) {
2215 		/* invalid address */
2216 		mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst,
2217 		    sata_device.satadev_addr.cport)));
2218 		return (0);
2219 	}
2220 	if (scsi_pkt == NULL) {
2221 		/*
2222 		 * Abort all packets.
2223 		 * Although we do not have specific packet, we still need
2224 		 * dummy packet structure to pass device address to HBA.
2225 		 * Allocate one, without sleeping. Fail if pkt cannot be
2226 		 * allocated.
2227 		 */
2228 		sata_pkt = kmem_zalloc(sizeof (sata_pkt_t), KM_NOSLEEP);
2229 		if (sata_pkt == NULL) {
2230 			mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst,
2231 			    sata_device.satadev_addr.cport)));
2232 			SATA_LOG_D((sata_hba_inst, CE_WARN, "sata_pkt_abort: "
2233 			    "could not allocate sata_pkt"));
2234 			return (0);
2235 		}
2236 		sata_pkt->satapkt_rev = SATA_PKT_REV;
2237 		sata_pkt->satapkt_device = sata_device;
2238 		sata_pkt->satapkt_device.satadev_rev = SATA_DEVICE_REV;
2239 	} else {
2240 		if (scsi_pkt->pkt_ha_private == NULL) {
2241 			mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst,
2242 			    sata_device.satadev_addr.cport)));
2243 			return (0); /* Bad scsi pkt */
2244 		}
2245 		/* extract pointer to sata pkt */
2246 		sata_pkt = ((sata_pkt_txlate_t *)scsi_pkt->pkt_ha_private)->
2247 		    txlt_sata_pkt;
2248 	}
2249 
2250 	mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst,
2251 	    sata_device.satadev_addr.cport)));
2252 	/* Send abort request to HBA */
2253 	if ((*SATA_ABORT_FUNC(sata_hba_inst))
2254 	    (SATA_DIP(sata_hba_inst), sata_pkt,
2255 	    scsi_pkt == NULL ? SATA_ABORT_ALL_PACKETS : SATA_ABORT_PACKET) ==
2256 	    SATA_SUCCESS) {
2257 		if (scsi_pkt == NULL)
2258 			kmem_free(sata_pkt, sizeof (sata_pkt_t));
2259 		/* Success */
2260 		return (1);
2261 	}
2262 	/* Else, something did not go right */
2263 	if (scsi_pkt == NULL)
2264 		kmem_free(sata_pkt, sizeof (sata_pkt_t));
2265 	/* Failure */
2266 	return (0);
2267 }
2268 
2269 
2270 /*
2271  * Implementation of scsi tran_reset.
2272  * RESET_ALL request is translated into port reset.
2273  * RESET_TARGET requests is translated into a device reset,
2274  * RESET_LUN request is accepted only for LUN 0 and translated into
2275  * device reset.
2276  * The target reset should cause all HBA active and queued packets to
2277  * be terminated and returned with pkt reason SATA_PKT_RESET prior to
2278  * the return. HBA should report reset event for the device.
2279  *
2280  * Returns 1 upon success, 0 upon failure.
2281  */
2282 static int
2283 sata_scsi_reset(struct scsi_address *ap, int level)
2284 {
2285 	sata_hba_inst_t	*sata_hba_inst =
2286 	    (sata_hba_inst_t *)(ap->a_hba_tran->tran_hba_private);
2287 	sata_device_t	sata_device;
2288 	int		val;
2289 
2290 	SATADBG2(SATA_DBG_SCSI_IF, sata_hba_inst,
2291 	    "sata_scsi_reset: level %d target: 0x%x\n",
2292 	    level, ap->a_target);
2293 
2294 	/* Validate address */
2295 	val = sata_validate_scsi_address(sata_hba_inst, ap, &sata_device);
2296 	if (val == -1)
2297 		/* Invalid address */
2298 		return (0);
2299 
2300 	mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst,
2301 	    sata_device.satadev_addr.cport)));
2302 	if (sata_get_device_info(sata_hba_inst, &sata_device) == NULL) {
2303 		/* invalid address */
2304 		mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst,
2305 		    sata_device.satadev_addr.cport)));
2306 		return (0);
2307 	}
2308 	mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst,
2309 	    sata_device.satadev_addr.cport)));
2310 	if (level == RESET_ALL) {
2311 		/* port reset - cport only */
2312 		sata_device.satadev_addr.qual = SATA_ADDR_CPORT;
2313 		if ((*SATA_RESET_DPORT_FUNC(sata_hba_inst))
2314 		    (SATA_DIP(sata_hba_inst), &sata_device) == SATA_SUCCESS)
2315 			return (1);
2316 		else
2317 			return (0);
2318 
2319 	} else if (val == 0 &&
2320 	    (level == RESET_TARGET || level == RESET_LUN)) {
2321 		/* reset device (device attached) */
2322 		if ((*SATA_RESET_DPORT_FUNC(sata_hba_inst))
2323 		    (SATA_DIP(sata_hba_inst), &sata_device) == SATA_SUCCESS)
2324 			return (1);
2325 		else
2326 			return (0);
2327 	}
2328 	return (0);
2329 }
2330 
2331 
2332 /*
2333  * Implementation of scsi tran_getcap (get transport/device capabilities).
2334  * Supported capabilities for SATA hard disks:
2335  * auto-rqsense		(always supported)
2336  * tagged-qing		(supported if HBA supports it)
2337  * untagged-qing	(could be supported if disk supports it, but because
2338  *			 caching behavior allowing untagged queuing actually
2339  *			 results in reduced performance.  sd tries to throttle
2340  *			 back to only 3 outstanding commands, which may
2341  *			 work for real SCSI disks, but with read ahead
2342  *			 caching, having more than 1 outstanding command
2343  *			 results in cache thrashing.)
2344  * sector_size
2345  * dma_max
2346  * interconnect-type	(INTERCONNECT_SATA)
2347  *
2348  * Supported capabilities for ATAPI devices (CD/DVD):
2349  * auto-rqsense		(always supported)
2350  * sector_size
2351  * dma_max
2352  * interconnect-type	(INTERCONNECT_SATA)
2353  *
2354  * Request for other capabilities is rejected as unsupported.
2355  *
2356  * Returns supported capability value, or -1 if capability is unsuppported or
2357  * the address is invalid - no device.
2358  */
2359 
2360 static int
2361 sata_scsi_getcap(struct scsi_address *ap, char *cap, int whom)
2362 {
2363 
2364 	sata_hba_inst_t 	*sata_hba_inst =
2365 	    (sata_hba_inst_t *)(ap->a_hba_tran->tran_hba_private);
2366 	sata_device_t		sata_device;
2367 	sata_drive_info_t	*sdinfo;
2368 	ddi_dma_attr_t		adj_dma_attr;
2369 	int 			rval;
2370 
2371 	SATADBG2(SATA_DBG_SCSI_IF, sata_hba_inst,
2372 	    "sata_scsi_getcap: target: 0x%x, cap: %s\n",
2373 	    ap->a_target, cap);
2374 
2375 	/*
2376 	 * We want to process the capabilities on per port granularity.
2377 	 * So, we are specifically restricting ourselves to whom != 0
2378 	 * to exclude the controller wide handling.
2379 	 */
2380 	if (cap == NULL || whom == 0)
2381 		return (-1);
2382 
2383 	if (sata_validate_scsi_address(sata_hba_inst, ap, &sata_device) != 0) {
2384 		/* Invalid address */
2385 		return (-1);
2386 	}
2387 	mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst,
2388 	    sata_device.satadev_addr.cport)));
2389 	if ((sdinfo = sata_get_device_info(sata_hba_inst, &sata_device)) ==
2390 	    NULL) {
2391 		/* invalid address */
2392 		mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst,
2393 		    sata_device.satadev_addr.cport)));
2394 		return (-1);
2395 	}
2396 
2397 	switch (scsi_hba_lookup_capstr(cap)) {
2398 	case SCSI_CAP_ARQ:
2399 		rval = 1;		/* ARQ supported, turned on */
2400 		break;
2401 
2402 	case SCSI_CAP_SECTOR_SIZE:
2403 		if (sdinfo->satadrv_type == SATA_DTYPE_ATADISK)
2404 			rval = SATA_DISK_SECTOR_SIZE;	/* fixed size */
2405 		else if (sdinfo->satadrv_type == SATA_DTYPE_ATAPICD)
2406 			rval = SATA_ATAPI_SECTOR_SIZE;
2407 		else rval = -1;
2408 		break;
2409 
2410 	/*
2411 	 * untagged queuing cause a performance inversion because of
2412 	 * the way sd operates.  Because of this reason we do not
2413 	 * use it when available.
2414 	 */
2415 	case SCSI_CAP_UNTAGGED_QING:
2416 		if (sdinfo->satadrv_features_enabled &
2417 		    SATA_DEV_F_E_UNTAGGED_QING)
2418 			rval = 1;	/* Untagged queuing available */
2419 		else
2420 			rval = -1;	/* Untagged queuing not available */
2421 		break;
2422 
2423 	case SCSI_CAP_TAGGED_QING:
2424 		if ((sdinfo->satadrv_features_enabled &
2425 		    SATA_DEV_F_E_TAGGED_QING) &&
2426 		    (sdinfo->satadrv_max_queue_depth > 1))
2427 			rval = 1;	/* Tagged queuing available */
2428 		else
2429 			rval = -1;	/* Tagged queuing not available */
2430 		break;
2431 
2432 	case SCSI_CAP_DMA_MAX:
2433 		sata_adjust_dma_attr(sdinfo, SATA_DMA_ATTR(sata_hba_inst),
2434 		    &adj_dma_attr);
2435 		rval = (int)adj_dma_attr.dma_attr_maxxfer;
2436 		/* We rely on the fact that dma_attr_maxxfer < 0x80000000 */
2437 		break;
2438 
2439 	case SCSI_CAP_INTERCONNECT_TYPE:
2440 		rval = INTERCONNECT_SATA;	/* SATA interconnect type */
2441 		break;
2442 
2443 	default:
2444 		rval = -1;
2445 		break;
2446 	}
2447 	mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst,
2448 	    sata_device.satadev_addr.cport)));
2449 	return (rval);
2450 }
2451 
2452 /*
2453  * Implementation of scsi tran_setcap
2454  *
2455  * Only SCSI_CAP_UNTAGGED_QING and  SCSI_CAP_TAGGED_QING are changeable.
2456  *
2457  */
2458 static int
2459 sata_scsi_setcap(struct scsi_address *ap, char *cap, int value, int whom)
2460 {
2461 	sata_hba_inst_t	*sata_hba_inst =
2462 	    (sata_hba_inst_t *)(ap->a_hba_tran->tran_hba_private);
2463 	sata_device_t	sata_device;
2464 	sata_drive_info_t	*sdinfo;
2465 	int		rval;
2466 
2467 	SATADBG2(SATA_DBG_SCSI_IF, sata_hba_inst,
2468 	    "sata_scsi_setcap: target: 0x%x, cap: %s\n", ap->a_target, cap);
2469 
2470 	/*
2471 	 * We want to process the capabilities on per port granularity.
2472 	 * So, we are specifically restricting ourselves to whom != 0
2473 	 * to exclude the controller wide handling.
2474 	 */
2475 	if (cap == NULL || whom == 0) {
2476 		return (-1);
2477 	}
2478 
2479 	if (sata_validate_scsi_address(sata_hba_inst, ap, &sata_device) != 0) {
2480 		/* Invalid address */
2481 		return (-1);
2482 	}
2483 	mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst,
2484 	    sata_device.satadev_addr.cport)));
2485 	if ((sdinfo = sata_get_device_info(sata_hba_inst,
2486 	    &sata_device)) == NULL) {
2487 		/* invalid address */
2488 		mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst,
2489 		    sata_device.satadev_addr.cport)));
2490 		return (-1);
2491 	}
2492 	mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst,
2493 	    sata_device.satadev_addr.cport)));
2494 
2495 	switch (scsi_hba_lookup_capstr(cap)) {
2496 	case SCSI_CAP_ARQ:
2497 	case SCSI_CAP_SECTOR_SIZE:
2498 	case SCSI_CAP_DMA_MAX:
2499 	case SCSI_CAP_INTERCONNECT_TYPE:
2500 		rval = 0;
2501 		break;
2502 	case SCSI_CAP_UNTAGGED_QING:
2503 		if (SATA_QDEPTH(sata_hba_inst) > 1) {
2504 			rval = 1;
2505 			if (value == 1) {
2506 				sdinfo->satadrv_features_enabled |=
2507 				    SATA_DEV_F_E_UNTAGGED_QING;
2508 			} else if (value == 0) {
2509 				sdinfo->satadrv_features_enabled &=
2510 				    ~SATA_DEV_F_E_UNTAGGED_QING;
2511 			} else {
2512 				rval = -1;
2513 			}
2514 		} else {
2515 			rval = 0;
2516 		}
2517 		break;
2518 	case SCSI_CAP_TAGGED_QING:
2519 		/* This can TCQ or NCQ */
2520 		if (sata_func_enable & SATA_ENABLE_QUEUING &&
2521 		    ((sdinfo->satadrv_features_support & SATA_DEV_F_TCQ &&
2522 		    SATA_FEATURES(sata_hba_inst) & SATA_CTLF_QCMD) ||
2523 		    (sata_func_enable & SATA_ENABLE_NCQ &&
2524 		    sdinfo->satadrv_features_support & SATA_DEV_F_NCQ &&
2525 		    SATA_FEATURES(sata_hba_inst) & SATA_CTLF_NCQ)) &&
2526 		    (sdinfo->satadrv_max_queue_depth > 1)) {
2527 			rval = 1;
2528 			if (value == 1) {
2529 				sdinfo->satadrv_features_enabled |=
2530 				    SATA_DEV_F_E_TAGGED_QING;
2531 			} else if (value == 0) {
2532 				sdinfo->satadrv_features_enabled &=
2533 				    ~SATA_DEV_F_E_TAGGED_QING;
2534 			} else {
2535 				rval = -1;
2536 			}
2537 		} else {
2538 			rval = 0;
2539 		}
2540 		break;
2541 	default:
2542 		rval = -1;
2543 		break;
2544 	}
2545 	return (rval);
2546 }
2547 
2548 /*
2549  * Implementations of scsi tran_destroy_pkt.
2550  * Free resources allocated by sata_scsi_init_pkt()
2551  */
2552 static void
2553 sata_scsi_destroy_pkt(struct scsi_address *ap, struct scsi_pkt *pkt)
2554 {
2555 	sata_pkt_txlate_t *spx;
2556 
2557 	spx = (sata_pkt_txlate_t *)pkt->pkt_ha_private;
2558 
2559 	if (spx->txlt_buf_dma_handle != NULL) {
2560 		if (spx->txlt_tmp_buf != NULL)  {
2561 			ASSERT(spx->txlt_tmp_buf_handle != 0);
2562 			/*
2563 			 * Intermediate DMA buffer was allocated.
2564 			 * Free allocated buffer and associated access handle.
2565 			 */
2566 			ddi_dma_mem_free(&spx->txlt_tmp_buf_handle);
2567 			spx->txlt_tmp_buf = NULL;
2568 		}
2569 		/*
2570 		 * Free DMA resources - cookies and handles
2571 		 */
2572 		if (spx->txlt_dma_cookie_list != NULL) {
2573 			if (spx->txlt_dma_cookie_list !=
2574 			    &spx->txlt_dma_cookie) {
2575 				(void) kmem_free(spx->txlt_dma_cookie_list,
2576 				    spx->txlt_dma_cookie_list_len *
2577 				    sizeof (ddi_dma_cookie_t));
2578 				spx->txlt_dma_cookie_list = NULL;
2579 			}
2580 		}
2581 		(void) ddi_dma_unbind_handle(spx->txlt_buf_dma_handle);
2582 		(void) ddi_dma_free_handle(&spx->txlt_buf_dma_handle);
2583 	}
2584 	spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp = NULL;
2585 	sata_pkt_free(spx);
2586 
2587 	scsi_hba_pkt_free(ap, pkt);
2588 }
2589 
2590 /*
2591  * Implementation of scsi tran_dmafree.
2592  * Free DMA resources allocated by sata_scsi_init_pkt()
2593  */
2594 
2595 static void
2596 sata_scsi_dmafree(struct scsi_address *ap, struct scsi_pkt *pkt)
2597 {
2598 #ifndef __lock_lint
2599 	_NOTE(ARGUNUSED(ap))
2600 #endif
2601 	sata_pkt_txlate_t *spx;
2602 
2603 	ASSERT(pkt != NULL);
2604 	spx = (sata_pkt_txlate_t *)pkt->pkt_ha_private;
2605 
2606 	if (spx->txlt_buf_dma_handle != NULL) {
2607 		if (spx->txlt_tmp_buf != NULL)  {
2608 			/*
2609 			 * Intermediate DMA buffer was allocated.
2610 			 * Free allocated buffer and associated access handle.
2611 			 */
2612 			ddi_dma_mem_free(&spx->txlt_tmp_buf_handle);
2613 			spx->txlt_tmp_buf = NULL;
2614 		}
2615 		/*
2616 		 * Free DMA resources - cookies and handles
2617 		 */
2618 		/* ASSERT(spx->txlt_dma_cookie_list != NULL); */
2619 		if (spx->txlt_dma_cookie_list != NULL) {
2620 			if (spx->txlt_dma_cookie_list !=
2621 			    &spx->txlt_dma_cookie) {
2622 				(void) kmem_free(spx->txlt_dma_cookie_list,
2623 				    spx->txlt_dma_cookie_list_len *
2624 				    sizeof (ddi_dma_cookie_t));
2625 				spx->txlt_dma_cookie_list = NULL;
2626 			}
2627 		}
2628 		(void) ddi_dma_unbind_handle(spx->txlt_buf_dma_handle);
2629 		(void) ddi_dma_free_handle(&spx->txlt_buf_dma_handle);
2630 		spx->txlt_buf_dma_handle = NULL;
2631 	}
2632 }
2633 
2634 /*
2635  * Implementation of scsi tran_sync_pkt.
2636  *
2637  * The assumption below is that pkt is unique - there is no need to check ap
2638  *
2639  * Synchronize DMA buffer and, if the intermediate buffer is used, copy data
2640  * into/from the real buffer.
2641  */
2642 static void
2643 sata_scsi_sync_pkt(struct scsi_address *ap, struct scsi_pkt *pkt)
2644 {
2645 #ifndef __lock_lint
2646 	_NOTE(ARGUNUSED(ap))
2647 #endif
2648 	int rval;
2649 	sata_pkt_txlate_t *spx = (sata_pkt_txlate_t *)pkt->pkt_ha_private;
2650 	struct buf *bp;
2651 	int direction;
2652 
2653 	ASSERT(spx != NULL);
2654 	if (spx->txlt_buf_dma_handle != NULL) {
2655 		direction = spx->txlt_sata_pkt->
2656 		    satapkt_cmd.satacmd_flags.sata_data_direction;
2657 		if (spx->txlt_sata_pkt != NULL &&
2658 		    direction != SATA_DIR_NODATA_XFER) {
2659 			if (spx->txlt_tmp_buf != NULL) {
2660 				/* Intermediate DMA buffer used */
2661 				bp = spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp;
2662 
2663 				if (direction & SATA_DIR_WRITE) {
2664 					bcopy(bp->b_un.b_addr,
2665 					    spx->txlt_tmp_buf, bp->b_bcount);
2666 				}
2667 			}
2668 			/* Sync the buffer for device or for CPU */
2669 			rval = ddi_dma_sync(spx->txlt_buf_dma_handle,   0, 0,
2670 			    (direction & SATA_DIR_WRITE) ?
2671 			    DDI_DMA_SYNC_FORDEV :  DDI_DMA_SYNC_FORCPU);
2672 			ASSERT(rval == DDI_SUCCESS);
2673 			if (spx->txlt_tmp_buf != NULL &&
2674 			    !(direction & SATA_DIR_WRITE)) {
2675 				/* Intermediate DMA buffer used for read */
2676 				bcopy(spx->txlt_tmp_buf,
2677 				    bp->b_un.b_addr, bp->b_bcount);
2678 			}
2679 
2680 		}
2681 	}
2682 }
2683 
2684 
2685 
2686 /* *******************  SATA - SCSI Translation functions **************** */
2687 /*
2688  * SCSI to SATA pkt and command translation and SATA to SCSI status/error
2689  * translation.
2690  */
2691 
2692 /*
2693  * Checks if a device exists and can be access and translates common
2694  * scsi_pkt data to sata_pkt data.
2695  *
2696  * Returns TRAN_ACCEPT and scsi pkt_reason CMD_CMPLT if device exists and
2697  * sata_pkt was set-up.
2698  * Returns TRAN_ACCEPT and scsi pkt_reason CMD_DEV_GONE if device does not
2699  * exist and pkt_comp callback was scheduled.
2700  * Returns other TRAN_XXXXX values when error occured and command should be
2701  * rejected with the returned TRAN_XXXXX value.
2702  *
2703  * This function should be called with port mutex held.
2704  */
2705 static int
2706 sata_txlt_generic_pkt_info(sata_pkt_txlate_t *spx)
2707 {
2708 	sata_drive_info_t *sdinfo;
2709 	sata_device_t sata_device;
2710 	const struct sata_cmd_flags sata_initial_cmd_flags = {
2711 		SATA_DIR_NODATA_XFER,
2712 		/* all other values to 0/FALSE */
2713 	};
2714 	/*
2715 	 * Pkt_reason has to be set if the pkt_comp callback is invoked,
2716 	 * and that implies TRAN_ACCEPT return value. Any other returned value
2717 	 * indicates that the scsi packet was not accepted (the reason will not
2718 	 * be checked by the scsi traget driver).
2719 	 * To make debugging easier, we set pkt_reason to know value here.
2720 	 * It may be changed later when different completion reason is
2721 	 * determined.
2722 	 */
2723 	spx->txlt_scsi_pkt->pkt_reason = CMD_TRAN_ERR;
2724 
2725 	/* Validate address */
2726 	switch (sata_validate_scsi_address(spx->txlt_sata_hba_inst,
2727 	    &spx->txlt_scsi_pkt->pkt_address, &sata_device)) {
2728 
2729 	case -1:
2730 		/* Invalid address or invalid device type */
2731 		return (TRAN_BADPKT);
2732 	case 1:
2733 		/* valid address but no device - it has disappeared ? */
2734 		spx->txlt_scsi_pkt->pkt_reason = CMD_DEV_GONE;
2735 		/*
2736 		 * The sd target driver is checking CMD_DEV_GONE pkt_reason
2737 		 * only in callback function (for normal requests) and
2738 		 * in the dump code path.
2739 		 * So, if the callback is available, we need to do
2740 		 * the callback rather than returning TRAN_FATAL_ERROR here.
2741 		 */
2742 		if (spx->txlt_scsi_pkt->pkt_comp != NULL) {
2743 			/* scsi callback required */
2744 			if (taskq_dispatch(SATA_TXLT_TASKQ(spx),
2745 			    (task_func_t *)spx->txlt_scsi_pkt->pkt_comp,
2746 			    (void *)spx->txlt_scsi_pkt,
2747 			    TQ_SLEEP) == NULL)
2748 				/* Scheduling the callback failed */
2749 				return (TRAN_BUSY);
2750 
2751 			return (TRAN_ACCEPT);
2752 		}
2753 		return (TRAN_FATAL_ERROR);
2754 	default:
2755 		/* all OK */
2756 		break;
2757 	}
2758 	sdinfo = sata_get_device_info(spx->txlt_sata_hba_inst,
2759 	    &spx->txlt_sata_pkt->satapkt_device);
2760 
2761 	/*
2762 	 * If device is in reset condition, reject the packet with
2763 	 * TRAN_BUSY, unless:
2764 	 * 1. system is panicking (dumping)
2765 	 * In such case only one thread is running and there is no way to
2766 	 * process reset.
2767 	 * 2. cfgadm operation is is progress (internal APCTL lock is set)
2768 	 * Some cfgadm operations involve drive commands, so reset condition
2769 	 * needs to be ignored for IOCTL operations.
2770 	 */
2771 	if ((sdinfo->satadrv_event_flags &
2772 	    (SATA_EVNT_DEVICE_RESET | SATA_EVNT_INPROC_DEVICE_RESET)) != 0) {
2773 
2774 		if (!ddi_in_panic() &&
2775 		    ((SATA_CPORT_EVENT_FLAGS(spx->txlt_sata_hba_inst,
2776 		    sata_device.satadev_addr.cport) &
2777 		    SATA_APCTL_LOCK_PORT_BUSY) == 0)) {
2778 			spx->txlt_scsi_pkt->pkt_reason = CMD_INCOMPLETE;
2779 			SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst,
2780 			    "sata_scsi_start: rejecting command because "
2781 			    "of device reset state\n", NULL);
2782 			return (TRAN_BUSY);
2783 		}
2784 	}
2785 
2786 	/*
2787 	 * Fix the dev_type in the sata_pkt->satapkt_device. It was not set by
2788 	 * sata_scsi_pkt_init() because pkt init had to work also with
2789 	 * non-existing devices.
2790 	 * Now we know that the packet was set-up for a real device, so its
2791 	 * type is known.
2792 	 */
2793 	spx->txlt_sata_pkt->satapkt_device.satadev_type = sdinfo->satadrv_type;
2794 
2795 	spx->txlt_sata_pkt->satapkt_cmd.satacmd_flags = sata_initial_cmd_flags;
2796 	if ((SATA_CPORT_INFO(spx->txlt_sata_hba_inst,
2797 	    sata_device.satadev_addr.cport)->cport_event_flags &
2798 	    SATA_APCTL_LOCK_PORT_BUSY) != 0) {
2799 		spx->txlt_sata_pkt->satapkt_cmd.satacmd_flags.
2800 		    sata_ignore_dev_reset = B_TRUE;
2801 	}
2802 	/*
2803 	 * At this point the generic translation routine determined that the
2804 	 * scsi packet should be accepted. Packet completion reason may be
2805 	 * changed later when a different completion reason is determined.
2806 	 */
2807 	spx->txlt_scsi_pkt->pkt_reason = CMD_CMPLT;
2808 
2809 	if ((spx->txlt_scsi_pkt->pkt_flags & FLAG_NOINTR) != 0) {
2810 		/* Synchronous execution */
2811 		spx->txlt_sata_pkt->satapkt_op_mode = SATA_OPMODE_SYNCH |
2812 		    SATA_OPMODE_POLLING;
2813 		spx->txlt_sata_pkt->satapkt_cmd.satacmd_flags.
2814 		    sata_ignore_dev_reset = ddi_in_panic();
2815 	} else {
2816 		/* Asynchronous execution */
2817 		spx->txlt_sata_pkt->satapkt_op_mode = SATA_OPMODE_ASYNCH |
2818 		    SATA_OPMODE_INTERRUPTS;
2819 	}
2820 	/* Convert queuing information */
2821 	if (spx->txlt_scsi_pkt->pkt_flags & FLAG_STAG)
2822 		spx->txlt_sata_pkt->satapkt_cmd.satacmd_flags.sata_queue_stag =
2823 		    B_TRUE;
2824 	else if (spx->txlt_scsi_pkt->pkt_flags &
2825 	    (FLAG_OTAG | FLAG_HTAG | FLAG_HEAD))
2826 		spx->txlt_sata_pkt->satapkt_cmd.satacmd_flags.sata_queue_otag =
2827 		    B_TRUE;
2828 
2829 	/* Always limit pkt time */
2830 	if (spx->txlt_scsi_pkt->pkt_time == 0)
2831 		spx->txlt_sata_pkt->satapkt_time = sata_default_pkt_time;
2832 	else
2833 		/* Pass on scsi_pkt time */
2834 		spx->txlt_sata_pkt->satapkt_time =
2835 		    spx->txlt_scsi_pkt->pkt_time;
2836 
2837 	return (TRAN_ACCEPT);
2838 }
2839 
2840 
2841 /*
2842  * Translate ATA Identify Device data to SCSI Inquiry data.
2843  * This function may be called only for ATA devices.
2844  * This function should not be called for ATAPI devices - they
2845  * respond directly to SCSI Inquiry command.
2846  *
2847  * SATA Identify Device data has to be valid in sata_rive_info.
2848  * Buffer has to accomodate the inquiry length (36 bytes).
2849  *
2850  * This function should be called with a port mutex held.
2851  */
2852 static	void
2853 sata_identdev_to_inquiry(sata_hba_inst_t *sata_hba_inst,
2854     sata_drive_info_t *sdinfo, uint8_t *buf)
2855 {
2856 
2857 	struct scsi_inquiry *inq = (struct scsi_inquiry *)buf;
2858 	struct sata_id *sid = &sdinfo->satadrv_id;
2859 
2860 	/* Start with a nice clean slate */
2861 	bzero((void *)inq, sizeof (struct scsi_inquiry));
2862 
2863 	/*
2864 	 * Rely on the dev_type for setting paripheral qualifier.
2865 	 * Assume that  DTYPE_RODIRECT applies to CD/DVD R/W devices.
2866 	 * It could be that DTYPE_OPTICAL could also qualify in the future.
2867 	 * ATAPI Inquiry may provide more data to the target driver.
2868 	 */
2869 	inq->inq_dtype = sdinfo->satadrv_type == SATA_DTYPE_ATADISK ?
2870 	    DTYPE_DIRECT : DTYPE_RODIRECT; /* DTYPE_UNKNOWN; */
2871 
2872 	inq->inq_rmb = sid->ai_config & SATA_REM_MEDIA ? 1 : 0;
2873 	inq->inq_qual = 0;	/* Device type qualifier (obsolete in SCSI3? */
2874 	inq->inq_iso = 0;	/* ISO version */
2875 	inq->inq_ecma = 0;	/* ECMA version */
2876 	inq->inq_ansi = 3;	/* ANSI version - SCSI 3 */
2877 	inq->inq_aenc = 0;	/* Async event notification cap. */
2878 	inq->inq_trmiop = 0;	/* Supports TERMINATE I/O PROC msg - NO */
2879 	inq->inq_normaca = 0;	/* setting NACA bit supported - NO */
2880 	inq->inq_rdf = RDF_SCSI2; /* Response data format- SPC-3 */
2881 	inq->inq_len = 31;	/* Additional length */
2882 	inq->inq_dualp = 0;	/* dual port device - NO */
2883 	inq->inq_reladdr = 0;	/* Supports relative addressing - NO */
2884 	inq->inq_sync = 0;	/* Supports synchronous data xfers - NO */
2885 	inq->inq_linked = 0;	/* Supports linked commands - NO */
2886 				/*
2887 				 * Queuing support - controller has to
2888 				 * support some sort of command queuing.
2889 				 */
2890 	if (SATA_QDEPTH(sata_hba_inst) > 1)
2891 		inq->inq_cmdque = 1; /* Supports command queueing - YES */
2892 	else
2893 		inq->inq_cmdque = 0; /* Supports command queueing - NO */
2894 	inq->inq_sftre = 0;	/* Supports Soft Reset option - NO ??? */
2895 	inq->inq_wbus32 = 0;	/* Supports 32 bit wide data xfers - NO */
2896 	inq->inq_wbus16 = 0;	/* Supports 16 bit wide data xfers - NO */
2897 
2898 #ifdef	_LITTLE_ENDIAN
2899 	/* Swap text fields to match SCSI format */
2900 	bcopy("ATA     ", inq->inq_vid, 8);		/* Vendor ID */
2901 	swab(sid->ai_model, inq->inq_pid, 16);		/* Product ID */
2902 	if (strncmp(&sid->ai_fw[4], "    ", 4) == 0)
2903 		swab(sid->ai_fw, inq->inq_revision, 4);	/* Revision level */
2904 	else
2905 		swab(&sid->ai_fw[4], inq->inq_revision, 4);	/* Rev. level */
2906 #else	/* _LITTLE_ENDIAN */
2907 	bcopy("ATA     ", inq->inq_vid, 8);		/* Vendor ID */
2908 	bcopy(sid->ai_model, inq->inq_pid, 16);		/* Product ID */
2909 	if (strncmp(&sid->ai_fw[4], "    ", 4) == 0)
2910 		bcopy(sid->ai_fw, inq->inq_revision, 4); /* Revision level */
2911 	else
2912 		bcopy(&sid->ai_fw[4], inq->inq_revision, 4); /* Rev. level */
2913 #endif	/* _LITTLE_ENDIAN */
2914 }
2915 
2916 
2917 /*
2918  * Scsi response set up for invalid command (command not supported)
2919  *
2920  * Returns TRAN_ACCEPT and appropriate values in scsi_pkt fields.
2921  */
2922 static int
2923 sata_txlt_invalid_command(sata_pkt_txlate_t *spx)
2924 {
2925 	struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt;
2926 	struct scsi_extended_sense *sense;
2927 
2928 	scsipkt->pkt_reason = CMD_CMPLT;
2929 	scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET |
2930 	    STATE_SENT_CMD | STATE_GOT_STATUS;
2931 
2932 	*scsipkt->pkt_scbp = STATUS_CHECK;
2933 
2934 	sense = sata_arq_sense(spx);
2935 	sense->es_key = KEY_ILLEGAL_REQUEST;
2936 	sense->es_add_code = SD_SCSI_ASC_INVALID_COMMAND_CODE;
2937 
2938 	SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst,
2939 	    "Scsi_pkt completion reason %x\n", scsipkt->pkt_reason);
2940 
2941 	if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0 &&
2942 	    scsipkt->pkt_comp != NULL)
2943 		/* scsi callback required */
2944 		if (taskq_dispatch(SATA_TXLT_TASKQ(spx),
2945 		    (task_func_t *)spx->txlt_scsi_pkt->pkt_comp,
2946 		    (void *)spx->txlt_scsi_pkt,
2947 		    TQ_SLEEP) == NULL)
2948 			/* Scheduling the callback failed */
2949 			return (TRAN_BUSY);
2950 	return (TRAN_ACCEPT);
2951 }
2952 
2953 /*
2954  * Scsi response setup for
2955  * emulated non-data command that requires no action/return data
2956  *
2957  * Returns TRAN_ACCEPT and appropriate values in scsi_pkt fields.
2958  */
2959 static 	int
2960 sata_txlt_nodata_cmd_immediate(sata_pkt_txlate_t *spx)
2961 {
2962 	int rval;
2963 
2964 	mutex_enter(&(SATA_TXLT_CPORT_MUTEX(spx)));
2965 
2966 	if (((rval = sata_txlt_generic_pkt_info(spx)) != TRAN_ACCEPT) ||
2967 	    (spx->txlt_scsi_pkt->pkt_reason == CMD_DEV_GONE)) {
2968 		mutex_exit(&(SATA_TXLT_CPORT_MUTEX(spx)));
2969 		return (rval);
2970 	}
2971 	mutex_exit(&(SATA_TXLT_CPORT_MUTEX(spx)));
2972 
2973 	spx->txlt_scsi_pkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET |
2974 	    STATE_SENT_CMD | STATE_GOT_STATUS;
2975 	spx->txlt_scsi_pkt->pkt_reason = CMD_CMPLT;
2976 	*(spx->txlt_scsi_pkt->pkt_scbp) = STATUS_GOOD;
2977 
2978 	SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst,
2979 	    "Scsi_pkt completion reason %x\n",
2980 	    spx->txlt_scsi_pkt->pkt_reason);
2981 
2982 	if ((spx->txlt_scsi_pkt->pkt_flags & FLAG_NOINTR) == 0 &&
2983 	    spx->txlt_scsi_pkt->pkt_comp != NULL)
2984 		/* scsi callback required */
2985 		if (taskq_dispatch(SATA_TXLT_TASKQ(spx),
2986 		    (task_func_t *)spx->txlt_scsi_pkt->pkt_comp,
2987 		    (void *)spx->txlt_scsi_pkt,
2988 		    TQ_SLEEP) == NULL)
2989 			/* Scheduling the callback failed */
2990 			return (TRAN_BUSY);
2991 	return (TRAN_ACCEPT);
2992 }
2993 
2994 
2995 /*
2996  * SATA translate command: Inquiry / Identify Device
2997  * Use cached Identify Device data for now, rather than issuing actual
2998  * Device Identify cmd request. If device is detached and re-attached,
2999  * asynchromous event processing should fetch and refresh Identify Device
3000  * data.
3001  * Two VPD pages are supported now:
3002  * Vital Product Data page
3003  * Unit Serial Number page
3004  *
3005  * Returns TRAN_ACCEPT and appropriate values in scsi_pkt fields.
3006  */
3007 
3008 #define	EVPD			1	/* Extended Vital Product Data flag */
3009 #define	CMDDT			2	/* Command Support Data - Obsolete */
3010 #define	INQUIRY_SUP_VPD_PAGE	0	/* Supported VDP Pages Page COde */
3011 #define	INQUIRY_USN_PAGE	0x80	/* Unit Serial Number Page Code */
3012 #define	INQUIRY_DEV_IDENTIFICATION_PAGE 0x83 /* Not needed yet */
3013 
3014 static int
3015 sata_txlt_inquiry(sata_pkt_txlate_t *spx)
3016 {
3017 	struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt;
3018 	struct buf *bp = spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp;
3019 	sata_drive_info_t *sdinfo;
3020 	struct scsi_extended_sense *sense;
3021 	int count;
3022 	uint8_t *p;
3023 	int i, j;
3024 	uint8_t page_buf[0xff]; /* Max length */
3025 	int rval;
3026 
3027 	mutex_enter(&(SATA_TXLT_CPORT_MUTEX(spx)));
3028 
3029 	if (((rval = sata_txlt_generic_pkt_info(spx)) != TRAN_ACCEPT) ||
3030 	    (spx->txlt_scsi_pkt->pkt_reason == CMD_DEV_GONE)) {
3031 		mutex_exit(&(SATA_TXLT_CPORT_MUTEX(spx)));
3032 		return (rval);
3033 	}
3034 
3035 	sdinfo = sata_get_device_info(spx->txlt_sata_hba_inst,
3036 	    &spx->txlt_sata_pkt->satapkt_device);
3037 
3038 	ASSERT(sdinfo != NULL);
3039 
3040 	scsipkt->pkt_reason = CMD_CMPLT;
3041 	scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET |
3042 	    STATE_SENT_CMD | STATE_GOT_STATUS;
3043 
3044 	/* Reject not supported request */
3045 	if (scsipkt->pkt_cdbp[1] & CMDDT) { /* No support for this bit */
3046 		*scsipkt->pkt_scbp = STATUS_CHECK;
3047 		sense = sata_arq_sense(spx);
3048 		sense->es_key = KEY_ILLEGAL_REQUEST;
3049 		sense->es_add_code = SD_SCSI_ASC_INVALID_FIELD_IN_CDB;
3050 		goto done;
3051 	}
3052 
3053 	/* Valid Inquiry request */
3054 	*scsipkt->pkt_scbp = STATUS_GOOD;
3055 
3056 	if (bp != NULL && bp->b_un.b_addr && bp->b_bcount) {
3057 
3058 		/*
3059 		 * Because it is fully emulated command storing data
3060 		 * programatically in the specified buffer, release
3061 		 * preallocated DMA resources before storing data in the buffer,
3062 		 * so no unwanted DMA sync would take place.
3063 		 */
3064 		sata_scsi_dmafree(NULL, scsipkt);
3065 
3066 		if (!(scsipkt->pkt_cdbp[1] & EVPD)) {
3067 			/* Standard Inquiry Data request */
3068 			struct scsi_inquiry inq;
3069 			unsigned int bufsize;
3070 
3071 			sata_identdev_to_inquiry(spx->txlt_sata_hba_inst,
3072 			    sdinfo, (uint8_t *)&inq);
3073 			/* Copy no more than requested */
3074 			count = MIN(bp->b_bcount,
3075 			    sizeof (struct scsi_inquiry));
3076 			bufsize = scsipkt->pkt_cdbp[4];
3077 			bufsize |= scsipkt->pkt_cdbp[3] << 8;
3078 			count = MIN(count, bufsize);
3079 			bcopy(&inq, bp->b_un.b_addr, count);
3080 
3081 			scsipkt->pkt_state |= STATE_XFERRED_DATA;
3082 			scsipkt->pkt_resid = scsipkt->pkt_cdbp[4] > count ?
3083 			    bufsize - count : 0;
3084 		} else {
3085 			/*
3086 			 * peripheral_qualifier = 0;
3087 			 *
3088 			 * We are dealing only with HD and will be
3089 			 * dealing with CD/DVD devices soon
3090 			 */
3091 			uint8_t peripheral_device_type =
3092 			    sdinfo->satadrv_type == SATA_DTYPE_ATADISK ?
3093 			    DTYPE_DIRECT : DTYPE_RODIRECT;
3094 
3095 			switch ((uint_t)scsipkt->pkt_cdbp[2]) {
3096 			case INQUIRY_SUP_VPD_PAGE:
3097 				/*
3098 				 * Request for suported Vital Product Data
3099 				 * pages - assuming only 2 page codes
3100 				 * supported
3101 				 */
3102 				page_buf[0] = peripheral_device_type;
3103 				page_buf[1] = INQUIRY_SUP_VPD_PAGE;
3104 				page_buf[2] = 0;
3105 				page_buf[3] = 2; /* page length */
3106 				page_buf[4] = INQUIRY_SUP_VPD_PAGE;
3107 				page_buf[5] = INQUIRY_USN_PAGE;
3108 				/* Copy no more than requested */
3109 				count = MIN(bp->b_bcount, 6);
3110 				bcopy(page_buf, bp->b_un.b_addr, count);
3111 				break;
3112 			case INQUIRY_USN_PAGE:
3113 				/*
3114 				 * Request for Unit Serial Number page
3115 				 */
3116 				page_buf[0] = peripheral_device_type;
3117 				page_buf[1] = INQUIRY_USN_PAGE;
3118 				page_buf[2] = 0;
3119 				page_buf[3] = 20; /* remaining page length */
3120 				p = (uint8_t *)(sdinfo->satadrv_id.ai_drvser);
3121 #ifdef	_LITTLE_ENDIAN
3122 				swab(p, &page_buf[4], 20);
3123 #else
3124 				bcopy(p, &page_buf[4], 20);
3125 #endif
3126 				for (i = 0; i < 20; i++) {
3127 					if (page_buf[4 + i] == '\0' ||
3128 					    page_buf[4 + i] == '\040') {
3129 						break;
3130 					}
3131 				}
3132 				/*
3133 				 * 'i' contains string length.
3134 				 *
3135 				 * Least significant character of the serial
3136 				 * number shall appear as the last byte,
3137 				 * according to SBC-3 spec.
3138 				 */
3139 				p = &page_buf[20 + 4 - 1];
3140 				for (j = i; j > 0; j--, p--) {
3141 					*p = *(p - 20 + i);
3142 				}
3143 				p = &page_buf[4];
3144 				for (j = 20 - i; j > 0; j--) {
3145 					*p++ = '\040';
3146 				}
3147 				count = MIN(bp->b_bcount, 24);
3148 				bcopy(page_buf, bp->b_un.b_addr, count);
3149 				break;
3150 
3151 			case INQUIRY_DEV_IDENTIFICATION_PAGE:
3152 				/*
3153 				 * We may want to implement this page, when
3154 				 * identifiers are common for SATA devices
3155 				 * But not now.
3156 				 */
3157 				/*FALLTHROUGH*/
3158 
3159 			default:
3160 				/* Request for unsupported VPD page */
3161 				*scsipkt->pkt_scbp = STATUS_CHECK;
3162 				sense = sata_arq_sense(spx);
3163 				sense->es_key = KEY_ILLEGAL_REQUEST;
3164 				sense->es_add_code =
3165 				    SD_SCSI_ASC_INVALID_FIELD_IN_CDB;
3166 				goto done;
3167 			}
3168 		}
3169 		scsipkt->pkt_state |= STATE_XFERRED_DATA;
3170 		scsipkt->pkt_resid = scsipkt->pkt_cdbp[4] > count ?
3171 		    scsipkt->pkt_cdbp[4] - count : 0;
3172 	}
3173 done:
3174 	mutex_exit(&(SATA_TXLT_CPORT_MUTEX(spx)));
3175 
3176 	SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst,
3177 	    "Scsi_pkt completion reason %x\n",
3178 	    scsipkt->pkt_reason);
3179 
3180 	if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0 &&
3181 	    scsipkt->pkt_comp != NULL) {
3182 		/* scsi callback required */
3183 		if (taskq_dispatch(SATA_TXLT_TASKQ(spx),
3184 		    (task_func_t *)scsipkt->pkt_comp, (void *) scsipkt,
3185 		    TQ_SLEEP) == NULL)
3186 			/* Scheduling the callback failed */
3187 			return (TRAN_BUSY);
3188 	}
3189 	return (TRAN_ACCEPT);
3190 }
3191 
3192 /*
3193  * SATA translate command: Request Sense.
3194  * Emulated command (ATA version for SATA hard disks)
3195  * Always NO SENSE, because any sense data should be reported by ARQ sense.
3196  *
3197  * Returns TRAN_ACCEPT and appropriate values in scsi_pkt fields.
3198  */
3199 static int
3200 sata_txlt_request_sense(sata_pkt_txlate_t *spx)
3201 {
3202 	struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt;
3203 	struct scsi_extended_sense sense;
3204 	struct buf *bp = spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp;
3205 	int rval;
3206 
3207 	mutex_enter(&(SATA_TXLT_CPORT_MUTEX(spx)));
3208 
3209 	if (((rval = sata_txlt_generic_pkt_info(spx)) != TRAN_ACCEPT) ||
3210 	    (spx->txlt_scsi_pkt->pkt_reason == CMD_DEV_GONE)) {
3211 		mutex_exit(&(SATA_TXLT_CPORT_MUTEX(spx)));
3212 		return (rval);
3213 	}
3214 	mutex_exit(&(SATA_TXLT_CPORT_MUTEX(spx)));
3215 
3216 
3217 	scsipkt->pkt_reason = CMD_CMPLT;
3218 	scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET |
3219 	    STATE_SENT_CMD | STATE_GOT_STATUS;
3220 	*scsipkt->pkt_scbp = STATUS_GOOD;
3221 
3222 	if (bp != NULL && bp->b_un.b_addr && bp->b_bcount) {
3223 		/*
3224 		 * Because it is fully emulated command storing data
3225 		 * programatically in the specified buffer, release
3226 		 * preallocated DMA resources before storing data in the buffer,
3227 		 * so no unwanted DMA sync would take place.
3228 		 */
3229 		int count = MIN(bp->b_bcount,
3230 		    sizeof (struct scsi_extended_sense));
3231 		sata_scsi_dmafree(NULL, scsipkt);
3232 		bzero(&sense, sizeof (struct scsi_extended_sense));
3233 		sense.es_valid = 0;	/* Valid LBA */
3234 		sense.es_class = 7;	/* Response code 0x70 - current err */
3235 		sense.es_key = KEY_NO_SENSE;
3236 		sense.es_add_len = 6;	/* Additional length */
3237 		/* Copy no more than requested */
3238 		bcopy(&sense, bp->b_un.b_addr, count);
3239 		scsipkt->pkt_state |= STATE_XFERRED_DATA;
3240 		scsipkt->pkt_resid = 0;
3241 	}
3242 
3243 	SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst,
3244 	    "Scsi_pkt completion reason %x\n",
3245 	    scsipkt->pkt_reason);
3246 
3247 	if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0 &&
3248 	    scsipkt->pkt_comp != NULL)
3249 		/* scsi callback required */
3250 		if (taskq_dispatch(SATA_TXLT_TASKQ(spx),
3251 		    (task_func_t *)scsipkt->pkt_comp, (void *) scsipkt,
3252 		    TQ_SLEEP) == NULL)
3253 			/* Scheduling the callback failed */
3254 			return (TRAN_BUSY);
3255 	return (TRAN_ACCEPT);
3256 }
3257 
3258 /*
3259  * SATA translate command: Test Unit Ready
3260  * At the moment this is an emulated command (ATA version for SATA hard disks).
3261  * May be translated into Check Power Mode command in the future
3262  *
3263  * Returns TRAN_ACCEPT and appropriate values in scsi_pkt fields.
3264  */
3265 static int
3266 sata_txlt_test_unit_ready(sata_pkt_txlate_t *spx)
3267 {
3268 	struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt;
3269 	struct scsi_extended_sense *sense;
3270 	int power_state;
3271 	int rval;
3272 
3273 	mutex_enter(&(SATA_TXLT_CPORT_MUTEX(spx)));
3274 
3275 	if (((rval = sata_txlt_generic_pkt_info(spx)) != TRAN_ACCEPT) ||
3276 	    (spx->txlt_scsi_pkt->pkt_reason == CMD_DEV_GONE)) {
3277 		mutex_exit(&(SATA_TXLT_CPORT_MUTEX(spx)));
3278 		return (rval);
3279 	}
3280 	mutex_exit(&(SATA_TXLT_CPORT_MUTEX(spx)));
3281 
3282 	/* At this moment, emulate it rather than execute anything */
3283 	power_state = SATA_PWRMODE_ACTIVE;
3284 
3285 	scsipkt->pkt_reason = CMD_CMPLT;
3286 	scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET |
3287 	    STATE_SENT_CMD | STATE_GOT_STATUS;
3288 
3289 	switch (power_state) {
3290 	case SATA_PWRMODE_ACTIVE:
3291 	case SATA_PWRMODE_IDLE:
3292 		*scsipkt->pkt_scbp = STATUS_GOOD;
3293 		break;
3294 	default:
3295 		/* PWR mode standby */
3296 		*scsipkt->pkt_scbp = STATUS_CHECK;
3297 		sense = sata_arq_sense(spx);
3298 		sense->es_key = KEY_NOT_READY;
3299 		sense->es_add_code = SD_SCSI_ASC_LU_NOT_READY;
3300 		break;
3301 	}
3302 
3303 	SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst,
3304 	    "Scsi_pkt completion reason %x\n", scsipkt->pkt_reason);
3305 
3306 	if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0 &&
3307 	    scsipkt->pkt_comp != NULL)
3308 		/* scsi callback required */
3309 		if (taskq_dispatch(SATA_TXLT_TASKQ(spx),
3310 		    (task_func_t *)scsipkt->pkt_comp, (void *) scsipkt,
3311 		    TQ_SLEEP) == NULL)
3312 			/* Scheduling the callback failed */
3313 			return (TRAN_BUSY);
3314 
3315 	return (TRAN_ACCEPT);
3316 }
3317 
3318 
3319 /*
3320  * SATA translate command: Start Stop Unit
3321  * Translation depends on a command:
3322  *	Start Unit translated into Idle Immediate
3323  *	Stop Unit translated into Standby Immediate
3324  *	Unload Media / NOT SUPPORTED YET
3325  *	Load Media / NOT SUPPROTED YET
3326  * Power condition bits are ignored, so is Immediate bit
3327  * Requesting synchronous execution.
3328  *
3329  * Returns TRAN_ACCEPT or code returned by sata_hba_start() and
3330  * appropriate values in scsi_pkt fields.
3331  */
3332 static int
3333 sata_txlt_start_stop_unit(sata_pkt_txlate_t *spx)
3334 {
3335 	struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt;
3336 	sata_cmd_t *scmd = &spx->txlt_sata_pkt->satapkt_cmd;
3337 	struct scsi_extended_sense *sense;
3338 	sata_hba_inst_t *shi = SATA_TXLT_HBA_INST(spx);
3339 	int cport = SATA_TXLT_CPORT(spx);
3340 	int rval;
3341 	int synch;
3342 
3343 	SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst,
3344 	    "sata_txlt_start_stop_unit: %d\n", scsipkt->pkt_scbp[4] & 1);
3345 
3346 	mutex_enter(&SATA_CPORT_MUTEX(shi, cport));
3347 
3348 	if (((rval = sata_txlt_generic_pkt_info(spx)) != TRAN_ACCEPT) ||
3349 	    (spx->txlt_scsi_pkt->pkt_reason == CMD_DEV_GONE)) {
3350 		mutex_exit(&(SATA_TXLT_CPORT_MUTEX(spx)));
3351 		return (rval);
3352 	}
3353 
3354 	if (scsipkt->pkt_cdbp[4] & 2) {
3355 		/* Load/Unload Media - invalid request */
3356 		*scsipkt->pkt_scbp = STATUS_CHECK;
3357 		sense = sata_arq_sense(spx);
3358 		sense->es_key = KEY_ILLEGAL_REQUEST;
3359 		sense->es_add_code = SD_SCSI_ASC_INVALID_FIELD_IN_CDB;
3360 		mutex_exit(&(SATA_TXLT_CPORT_MUTEX(spx)));
3361 
3362 		SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst,
3363 		    "Scsi_pkt completion reason %x\n", scsipkt->pkt_reason);
3364 
3365 		if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0 &&
3366 		    scsipkt->pkt_comp != NULL)
3367 			/* scsi callback required */
3368 			if (taskq_dispatch(SATA_TXLT_TASKQ(spx),
3369 			    (task_func_t *)scsipkt->pkt_comp, (void *) scsipkt,
3370 			    TQ_SLEEP) == NULL)
3371 				/* Scheduling the callback failed */
3372 				return (TRAN_BUSY);
3373 
3374 		return (TRAN_ACCEPT);
3375 	}
3376 	scmd->satacmd_addr_type = 0;
3377 	scmd->satacmd_sec_count_lsb = 0;
3378 	scmd->satacmd_lba_low_lsb = 0;
3379 	scmd->satacmd_lba_mid_lsb = 0;
3380 	scmd->satacmd_lba_high_lsb = 0;
3381 	scmd->satacmd_features_reg = 0;
3382 	scmd->satacmd_device_reg = 0;
3383 	scmd->satacmd_status_reg = 0;
3384 	if (scsipkt->pkt_cdbp[4] & 1) {
3385 		/* Start Unit */
3386 		scmd->satacmd_cmd_reg = SATAC_IDLE_IM;
3387 	} else {
3388 		/* Stop Unit */
3389 		scmd->satacmd_cmd_reg = SATAC_STANDBY_IM;
3390 	}
3391 
3392 	if (!(spx->txlt_sata_pkt->satapkt_op_mode & SATA_OPMODE_SYNCH)) {
3393 		/* Need to set-up a callback function */
3394 		spx->txlt_sata_pkt->satapkt_comp =
3395 		    sata_txlt_nodata_cmd_completion;
3396 		synch = FALSE;
3397 	} else {
3398 		spx->txlt_sata_pkt->satapkt_op_mode = SATA_OPMODE_SYNCH;
3399 		synch = TRUE;
3400 	}
3401 
3402 	/* Transfer command to HBA */
3403 	if (sata_hba_start(spx, &rval) != 0) {
3404 		/* Pkt not accepted for execution */
3405 		mutex_exit(&SATA_CPORT_MUTEX(shi, cport));
3406 		return (rval);
3407 	}
3408 
3409 	/*
3410 	 * If execution is non-synchronous,
3411 	 * a callback function will handle potential errors, translate
3412 	 * the response and will do a callback to a target driver.
3413 	 * If it was synchronous, check execution status using the same
3414 	 * framework callback.
3415 	 */
3416 	mutex_exit(&SATA_CPORT_MUTEX(shi, cport));
3417 	if (synch) {
3418 		SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst,
3419 		    "synchronous execution status %x\n",
3420 		    spx->txlt_sata_pkt->satapkt_reason);
3421 
3422 		sata_txlt_nodata_cmd_completion(spx->txlt_sata_pkt);
3423 	}
3424 	return (TRAN_ACCEPT);
3425 
3426 }
3427 
3428 
3429 /*
3430  * SATA translate command:  Read Capacity.
3431  * Emulated command for SATA disks.
3432  * Capacity is retrieved from cached Idenifty Device data.
3433  * Identify Device data shows effective disk capacity, not the native
3434  * capacity, which may be limitted by Set Max Address command.
3435  * This is ATA version for SATA hard disks.
3436  *
3437  * Returns TRAN_ACCEPT and appropriate values in scsi_pkt fields.
3438  */
3439 static int
3440 sata_txlt_read_capacity(sata_pkt_txlate_t *spx)
3441 {
3442 	struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt;
3443 	struct buf *bp = spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp;
3444 	sata_drive_info_t *sdinfo;
3445 	uint64_t val;
3446 	uchar_t *rbuf;
3447 	int rval;
3448 
3449 	SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst,
3450 	    "sata_txlt_read_capacity: ", NULL);
3451 
3452 	mutex_enter(&(SATA_TXLT_CPORT_MUTEX(spx)));
3453 
3454 	if (((rval = sata_txlt_generic_pkt_info(spx)) != TRAN_ACCEPT) ||
3455 	    (spx->txlt_scsi_pkt->pkt_reason == CMD_DEV_GONE)) {
3456 		mutex_exit(&(SATA_TXLT_CPORT_MUTEX(spx)));
3457 		return (rval);
3458 	}
3459 
3460 	scsipkt->pkt_reason = CMD_CMPLT;
3461 	scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET |
3462 	    STATE_SENT_CMD | STATE_GOT_STATUS;
3463 	*scsipkt->pkt_scbp = STATUS_GOOD;
3464 	if (bp != NULL && bp->b_un.b_addr && bp->b_bcount) {
3465 		/*
3466 		 * Because it is fully emulated command storing data
3467 		 * programatically in the specified buffer, release
3468 		 * preallocated DMA resources before storing data in the buffer,
3469 		 * so no unwanted DMA sync would take place.
3470 		 */
3471 		sata_scsi_dmafree(NULL, scsipkt);
3472 
3473 		sdinfo = sata_get_device_info(
3474 		    spx->txlt_sata_hba_inst,
3475 		    &spx->txlt_sata_pkt->satapkt_device);
3476 		/* Last logical block address */
3477 		val = sdinfo->satadrv_capacity - 1;
3478 		rbuf = (uchar_t *)bp->b_un.b_addr;
3479 		/* Need to swap endians to match scsi format */
3480 		rbuf[0] = (val >> 24) & 0xff;
3481 		rbuf[1] = (val >> 16) & 0xff;
3482 		rbuf[2] = (val >> 8) & 0xff;
3483 		rbuf[3] = val & 0xff;
3484 		/* block size - always 512 bytes, for now */
3485 		rbuf[4] = 0;
3486 		rbuf[5] = 0;
3487 		rbuf[6] = 0x02;
3488 		rbuf[7] = 0;
3489 		scsipkt->pkt_state |= STATE_XFERRED_DATA;
3490 		scsipkt->pkt_resid = 0;
3491 
3492 		SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst, "%d\n",
3493 		    sdinfo->satadrv_capacity -1);
3494 	}
3495 	mutex_exit(&(SATA_TXLT_CPORT_MUTEX(spx)));
3496 	/*
3497 	 * If a callback was requested, do it now.
3498 	 */
3499 	SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst,
3500 	    "Scsi_pkt completion reason %x\n", scsipkt->pkt_reason);
3501 
3502 	if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0 &&
3503 	    scsipkt->pkt_comp != NULL)
3504 		/* scsi callback required */
3505 		if (taskq_dispatch(SATA_TXLT_TASKQ(spx),
3506 		    (task_func_t *)scsipkt->pkt_comp, (void *) scsipkt,
3507 		    TQ_SLEEP) == NULL)
3508 			/* Scheduling the callback failed */
3509 			return (TRAN_BUSY);
3510 
3511 	return (TRAN_ACCEPT);
3512 }
3513 
3514 /*
3515  * SATA translate command: Mode Sense.
3516  * Translated into appropriate SATA command or emulated.
3517  * Saved Values Page Control (03) are not supported.
3518  *
3519  * NOTE: only caching mode sense page is currently implemented.
3520  *
3521  * Returns TRAN_ACCEPT and appropriate values in scsi_pkt fields.
3522  */
3523 
3524 static int
3525 sata_txlt_mode_sense(sata_pkt_txlate_t *spx)
3526 {
3527 	struct scsi_pkt	*scsipkt = spx->txlt_scsi_pkt;
3528 	struct buf	*bp = spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp;
3529 	sata_drive_info_t *sdinfo;
3530 	sata_id_t *sata_id;
3531 	struct scsi_extended_sense *sense;
3532 	int 		len, bdlen, count, alc_len;
3533 	int		pc;	/* Page Control code */
3534 	uint8_t		*buf;	/* mode sense buffer */
3535 	int		rval;
3536 
3537 	SATADBG2(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst,
3538 	    "sata_txlt_mode_sense, pc %x page code 0x%02x\n",
3539 	    spx->txlt_scsi_pkt->pkt_cdbp[2] >> 6,
3540 	    spx->txlt_scsi_pkt->pkt_cdbp[2] & 0x3f);
3541 
3542 	buf = kmem_zalloc(1024, KM_SLEEP);
3543 
3544 	mutex_enter(&(SATA_TXLT_CPORT_MUTEX(spx)));
3545 
3546 	if (((rval = sata_txlt_generic_pkt_info(spx)) != TRAN_ACCEPT) ||
3547 	    (spx->txlt_scsi_pkt->pkt_reason == CMD_DEV_GONE)) {
3548 		mutex_exit(&(SATA_TXLT_CPORT_MUTEX(spx)));
3549 		kmem_free(buf, 1024);
3550 		return (rval);
3551 	}
3552 
3553 	scsipkt->pkt_reason = CMD_CMPLT;
3554 	scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET |
3555 	    STATE_SENT_CMD | STATE_GOT_STATUS;
3556 
3557 	pc = scsipkt->pkt_cdbp[2] >> 6;
3558 
3559 	if (bp != NULL && bp->b_un.b_addr && bp->b_bcount) {
3560 		/*
3561 		 * Because it is fully emulated command storing data
3562 		 * programatically in the specified buffer, release
3563 		 * preallocated DMA resources before storing data in the buffer,
3564 		 * so no unwanted DMA sync would take place.
3565 		 */
3566 		sata_scsi_dmafree(NULL, scsipkt);
3567 
3568 		len = 0;
3569 		bdlen = 0;
3570 		if (!(scsipkt->pkt_cdbp[1] & 8)) {
3571 			if (scsipkt->pkt_cdbp[0] == SCMD_MODE_SENSE_G1 &&
3572 			    (scsipkt->pkt_cdbp[0] & 0x10))
3573 				bdlen = 16;
3574 			else
3575 				bdlen = 8;
3576 		}
3577 		/* Build mode parameter header */
3578 		if (spx->txlt_scsi_pkt->pkt_cdbp[0] == SCMD_MODE_SENSE) {
3579 			/* 4-byte mode parameter header */
3580 			buf[len++] = 0;   	/* mode data length */
3581 			buf[len++] = 0;		/* medium type */
3582 			buf[len++] = 0;		/* dev-specific param */
3583 			buf[len++] = bdlen;	/* Block Descriptor length */
3584 		} else {
3585 			/* 8-byte mode parameter header */
3586 			buf[len++] = 0;		/* mode data length */
3587 			buf[len++] = 0;
3588 			buf[len++] = 0;		/* medium type */
3589 			buf[len++] = 0;		/* dev-specific param */
3590 			if (bdlen == 16)
3591 				buf[len++] = 1;	/* long lba descriptor */
3592 			else
3593 				buf[len++] = 0;
3594 			buf[len++] = 0;
3595 			buf[len++] = 0;		/* Block Descriptor length */
3596 			buf[len++] = bdlen;
3597 		}
3598 
3599 		sdinfo = sata_get_device_info(
3600 		    spx->txlt_sata_hba_inst,
3601 		    &spx->txlt_sata_pkt->satapkt_device);
3602 
3603 		/* Build block descriptor only if not disabled (DBD) */
3604 		if ((scsipkt->pkt_cdbp[1] & 0x08) == 0) {
3605 			/* Block descriptor - direct-access device format */
3606 			if (bdlen == 8) {
3607 				/* build regular block descriptor */
3608 				buf[len++] =
3609 				    (sdinfo->satadrv_capacity >> 24) & 0xff;
3610 				buf[len++] =
3611 				    (sdinfo->satadrv_capacity >> 16) & 0xff;
3612 				buf[len++] =
3613 				    (sdinfo->satadrv_capacity >> 8) & 0xff;
3614 				buf[len++] = sdinfo->satadrv_capacity & 0xff;
3615 				buf[len++] = 0; /* density code */
3616 				buf[len++] = 0;
3617 				if (sdinfo->satadrv_type ==
3618 				    SATA_DTYPE_ATADISK)
3619 					buf[len++] = 2;
3620 				else
3621 					/* ATAPI */
3622 					buf[len++] = 8;
3623 				buf[len++] = 0;
3624 			} else if (bdlen == 16) {
3625 				/* Long LBA Accepted */
3626 				/* build long lba block descriptor */
3627 #ifndef __lock_lint
3628 				buf[len++] =
3629 				    (sdinfo->satadrv_capacity >> 56) & 0xff;
3630 				buf[len++] =
3631 				    (sdinfo->satadrv_capacity >> 48) & 0xff;
3632 				buf[len++] =
3633 				    (sdinfo->satadrv_capacity >> 40) & 0xff;
3634 				buf[len++] =
3635 				    (sdinfo->satadrv_capacity >> 32) & 0xff;
3636 #endif
3637 				buf[len++] =
3638 				    (sdinfo->satadrv_capacity >> 24) & 0xff;
3639 				buf[len++] =
3640 				    (sdinfo->satadrv_capacity >> 16) & 0xff;
3641 				buf[len++] =
3642 				    (sdinfo->satadrv_capacity >> 8) & 0xff;
3643 				buf[len++] = sdinfo->satadrv_capacity & 0xff;
3644 				buf[len++] = 0;
3645 				buf[len++] = 0; /* density code */
3646 				buf[len++] = 0;
3647 				buf[len++] = 0;
3648 				if (sdinfo->satadrv_type ==
3649 				    SATA_DTYPE_ATADISK)
3650 					buf[len++] = 2;
3651 				else
3652 					/* ATAPI */
3653 					buf[len++] = 8;
3654 				buf[len++] = 0;
3655 			}
3656 		}
3657 
3658 		sata_id = &sdinfo->satadrv_id;
3659 
3660 		/*
3661 		 * Add requested pages.
3662 		 * Page 3 and 4 are obsolete and we are not supporting them.
3663 		 * We deal now with:
3664 		 * caching (read/write cache control).
3665 		 * We should eventually deal with following mode pages:
3666 		 * error recovery  (0x01),
3667 		 * power condition (0x1a),
3668 		 * exception control page (enables SMART) (0x1c),
3669 		 * enclosure management (ses),
3670 		 * protocol-specific port mode (port control).
3671 		 */
3672 		switch (scsipkt->pkt_cdbp[2] & 0x3f) {
3673 		case MODEPAGE_RW_ERRRECOV:
3674 			/* DAD_MODE_ERR_RECOV */
3675 			/* R/W recovery */
3676 			len += sata_build_msense_page_1(sdinfo, pc, buf+len);
3677 			break;
3678 		case MODEPAGE_CACHING:
3679 			/* DAD_MODE_CACHE */
3680 			/* Reject not supported request for saved parameters */
3681 			if (pc == 3) {
3682 				*scsipkt->pkt_scbp = STATUS_CHECK;
3683 				sense = sata_arq_sense(spx);
3684 				sense->es_key = KEY_ILLEGAL_REQUEST;
3685 				sense->es_add_code =
3686 				    SD_SCSI_ASC_SAVING_PARAMS_NOT_SUPPORTED;
3687 				goto done;
3688 			}
3689 
3690 			/* caching */
3691 			len += sata_build_msense_page_8(sdinfo, pc, buf+len);
3692 			break;
3693 		case MODEPAGE_INFO_EXCPT:
3694 			/* exception cntrl */
3695 			if (sata_id->ai_cmdset82 & SATA_SMART_SUPPORTED) {
3696 				len += sata_build_msense_page_1c(sdinfo, pc,
3697 				    buf+len);
3698 			}
3699 			else
3700 				goto err;
3701 			break;
3702 		case MODEPAGE_POWER_COND:
3703 			/* DAD_MODE_POWER_COND */
3704 			/* power condition */
3705 			len += sata_build_msense_page_1a(sdinfo, pc, buf+len);
3706 			break;
3707 
3708 		case MODEPAGE_ACOUSTIC_MANAG:
3709 			/* acoustic management */
3710 			len += sata_build_msense_page_30(sdinfo, pc, buf+len);
3711 			break;
3712 		case MODEPAGE_ALLPAGES:
3713 			/* all pages */
3714 			len += sata_build_msense_page_1(sdinfo, pc, buf+len);
3715 			len += sata_build_msense_page_8(sdinfo, pc, buf+len);
3716 			len += sata_build_msense_page_1a(sdinfo, pc, buf+len);
3717 			if (sata_id->ai_cmdset82 & SATA_SMART_SUPPORTED) {
3718 				len += sata_build_msense_page_1c(sdinfo, pc,
3719 				    buf+len);
3720 			}
3721 			len += sata_build_msense_page_30(sdinfo, pc, buf+len);
3722 			break;
3723 		default:
3724 		err:
3725 			/* Invalid request */
3726 			*scsipkt->pkt_scbp = STATUS_CHECK;
3727 			sense = sata_arq_sense(spx);
3728 			sense->es_key = KEY_ILLEGAL_REQUEST;
3729 			sense->es_add_code = SD_SCSI_ASC_INVALID_FIELD_IN_CDB;
3730 			goto done;
3731 		}
3732 
3733 		/* fix total mode data length */
3734 		if (spx->txlt_scsi_pkt->pkt_cdbp[0] == SCMD_MODE_SENSE) {
3735 			/* 4-byte mode parameter header */
3736 			buf[0] = len - 1;   	/* mode data length */
3737 		} else {
3738 			buf[0] = (len -2) >> 8;
3739 			buf[1] = (len -2) & 0xff;
3740 		}
3741 
3742 
3743 		/* Check allocation length */
3744 		if (scsipkt->pkt_cdbp[0] == SCMD_MODE_SENSE) {
3745 			alc_len = scsipkt->pkt_cdbp[4];
3746 		} else {
3747 			alc_len = scsipkt->pkt_cdbp[7];
3748 			alc_len = (len << 8) | scsipkt->pkt_cdbp[8];
3749 		}
3750 		/*
3751 		 * We do not check for possible parameters truncation
3752 		 * (alc_len < len) assuming that the target driver works
3753 		 * correctly. Just avoiding overrun.
3754 		 * Copy no more than requested and possible, buffer-wise.
3755 		 */
3756 		count = MIN(alc_len, len);
3757 		count = MIN(bp->b_bcount, count);
3758 		bcopy(buf, bp->b_un.b_addr, count);
3759 
3760 		scsipkt->pkt_state |= STATE_XFERRED_DATA;
3761 		scsipkt->pkt_resid = alc_len > count ? alc_len - count : 0;
3762 	}
3763 	*scsipkt->pkt_scbp = STATUS_GOOD;
3764 done:
3765 	mutex_exit(&(SATA_TXLT_CPORT_MUTEX(spx)));
3766 	(void) kmem_free(buf, 1024);
3767 
3768 	SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst,
3769 	    "Scsi_pkt completion reason %x\n", scsipkt->pkt_reason);
3770 
3771 	if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0 &&
3772 	    scsipkt->pkt_comp != NULL)
3773 		/* scsi callback required */
3774 		if (taskq_dispatch(SATA_TXLT_TASKQ(spx),
3775 		    (task_func_t *)scsipkt->pkt_comp, (void *) scsipkt,
3776 		    TQ_SLEEP) == NULL)
3777 			/* Scheduling the callback failed */
3778 			return (TRAN_BUSY);
3779 
3780 	return (TRAN_ACCEPT);
3781 }
3782 
3783 
3784 /*
3785  * SATA translate command: Mode Select.
3786  * Translated into appropriate SATA command or emulated.
3787  * Saving parameters is not supported.
3788  * Changing device capacity is not supported (although theoretically
3789  * possible by executing SET FEATURES/SET MAX ADDRESS)
3790  *
3791  * Assumption is that the target driver is working correctly.
3792  *
3793  * More than one SATA command may be executed to perform operations specified
3794  * by mode select pages. The first error terminates further execution.
3795  * Operations performed successully are not backed-up in such case.
3796  *
3797  * NOTE: only caching mode select page is implemented.
3798  * Caching setup is remembered so it could be re-stored in case of
3799  * an unexpected device reset.
3800  *
3801  * Returns TRAN_ACCEPT and appropriate values in scsi_pkt fields.
3802  */
3803 
3804 static int
3805 sata_txlt_mode_select(sata_pkt_txlate_t *spx)
3806 {
3807 	struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt;
3808 	struct buf *bp = spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp;
3809 	struct scsi_extended_sense *sense;
3810 	int len, pagelen, count, pllen;
3811 	uint8_t *buf;	/* mode select buffer */
3812 	int rval, stat;
3813 	uint_t nointr_flag;
3814 	int dmod = 0;
3815 
3816 	SATADBG2(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst,
3817 	    "sata_txlt_mode_select, pc %x page code 0x%02x\n",
3818 	    spx->txlt_scsi_pkt->pkt_cdbp[2] >> 6,
3819 	    spx->txlt_scsi_pkt->pkt_cdbp[2] & 0x3f);
3820 
3821 	mutex_enter(&(SATA_TXLT_CPORT_MUTEX(spx)));
3822 
3823 	if (((rval = sata_txlt_generic_pkt_info(spx)) != TRAN_ACCEPT) ||
3824 	    (spx->txlt_scsi_pkt->pkt_reason == CMD_DEV_GONE)) {
3825 		mutex_exit(&(SATA_TXLT_CPORT_MUTEX(spx)));
3826 		return (rval);
3827 	}
3828 
3829 	rval = TRAN_ACCEPT;
3830 
3831 	scsipkt->pkt_reason = CMD_CMPLT;
3832 	scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET |
3833 	    STATE_SENT_CMD | STATE_GOT_STATUS;
3834 
3835 	/* Reject not supported request */
3836 	if (! (scsipkt->pkt_cdbp[1] & 0x10)) { /* No support for PF bit = 0 */
3837 		*scsipkt->pkt_scbp = STATUS_CHECK;
3838 		sense = sata_arq_sense(spx);
3839 		sense->es_key = KEY_ILLEGAL_REQUEST;
3840 		sense->es_add_code = SD_SCSI_ASC_INVALID_FIELD_IN_CDB;
3841 		goto done;
3842 	}
3843 
3844 	if (scsipkt->pkt_cdbp[0] == SCMD_MODE_SELECT) {
3845 		pllen = scsipkt->pkt_cdbp[4];
3846 	} else {
3847 		pllen = scsipkt->pkt_cdbp[7];
3848 		pllen = (pllen << 8) | scsipkt->pkt_cdbp[7];
3849 	}
3850 
3851 	*scsipkt->pkt_scbp = STATUS_GOOD;	/* Presumed outcome */
3852 
3853 	if (bp != NULL && bp->b_un.b_addr && bp->b_bcount && pllen != 0) {
3854 		buf = (uint8_t *)bp->b_un.b_addr;
3855 		count = MIN(bp->b_bcount, pllen);
3856 		scsipkt->pkt_state |= STATE_XFERRED_DATA;
3857 		scsipkt->pkt_resid = 0;
3858 		pllen = count;
3859 
3860 		/*
3861 		 * Check the header to skip the block descriptor(s) - we
3862 		 * do not support setting device capacity.
3863 		 * Existing macros do not recognize long LBA dscriptor,
3864 		 * hence manual calculation.
3865 		 */
3866 		if (scsipkt->pkt_cdbp[0] == SCMD_MODE_SELECT) {
3867 			/* 6-bytes CMD, 4 bytes header */
3868 			if (count <= 4)
3869 				goto done;		/* header only */
3870 			len = buf[3] + 4;
3871 		} else {
3872 			/* 10-bytes CMD, 8 bytes header */
3873 			if (count <= 8)
3874 				goto done;		/* header only */
3875 			len = buf[6];
3876 			len = (len << 8) + buf[7] + 8;
3877 		}
3878 		if (len >= count)
3879 			goto done;	/* header + descriptor(s) only */
3880 
3881 		pllen -= len;		/* remaining data length */
3882 
3883 		/*
3884 		 * We may be executing SATA command and want to execute it
3885 		 * in SYNCH mode, regardless of scsi_pkt setting.
3886 		 * Save scsi_pkt setting and indicate SYNCH mode
3887 		 */
3888 		nointr_flag = scsipkt->pkt_flags & FLAG_NOINTR;
3889 		if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0 &&
3890 		    scsipkt->pkt_comp != NULL) {
3891 			scsipkt->pkt_flags |= FLAG_NOINTR;
3892 		}
3893 		spx->txlt_sata_pkt->satapkt_op_mode = SATA_OPMODE_SYNCH;
3894 
3895 		/*
3896 		 * len is now the offset to a first mode select page
3897 		 * Process all pages
3898 		 */
3899 		while (pllen > 0) {
3900 			switch ((int)buf[len]) {
3901 			case MODEPAGE_CACHING:
3902 				/* No support for SP (saving) */
3903 				if (scsipkt->pkt_cdbp[1] & 0x01) {
3904 					*scsipkt->pkt_scbp = STATUS_CHECK;
3905 					sense = sata_arq_sense(spx);
3906 					sense->es_key = KEY_ILLEGAL_REQUEST;
3907 					sense->es_add_code =
3908 					    SD_SCSI_ASC_INVALID_FIELD_IN_CDB;
3909 					goto done;
3910 				}
3911 				stat = sata_mode_select_page_8(spx,
3912 				    (struct mode_cache_scsi3 *)&buf[len],
3913 				    pllen, &pagelen, &rval, &dmod);
3914 				/*
3915 				 * The pagelen value indicates the number of
3916 				 * parameter bytes already processed.
3917 				 * The rval is the return value from
3918 				 * sata_tran_start().
3919 				 * The stat indicates the overall status of
3920 				 * the operation(s).
3921 				 */
3922 				if (stat != SATA_SUCCESS)
3923 					/*
3924 					 * Page processing did not succeed -
3925 					 * all error info is already set-up,
3926 					 * just return
3927 					 */
3928 					pllen = 0; /* this breaks the loop */
3929 				else {
3930 					len += pagelen;
3931 					pllen -= pagelen;
3932 				}
3933 				break;
3934 
3935 			case MODEPAGE_INFO_EXCPT:
3936 				stat = sata_mode_select_page_1c(spx,
3937 				    (struct mode_info_excpt_page *)&buf[len],
3938 				    pllen, &pagelen, &rval, &dmod);
3939 				/*
3940 				 * The pagelen value indicates the number of
3941 				 * parameter bytes already processed.
3942 				 * The rval is the return value from
3943 				 * sata_tran_start().
3944 				 * The stat indicates the overall status of
3945 				 * the operation(s).
3946 				 */
3947 				if (stat != SATA_SUCCESS)
3948 					/*
3949 					 * Page processing did not succeed -
3950 					 * all error info is already set-up,
3951 					 * just return
3952 					 */
3953 					pllen = 0; /* this breaks the loop */
3954 				else {
3955 					len += pagelen;
3956 					pllen -= pagelen;
3957 				}
3958 				break;
3959 
3960 			case MODEPAGE_ACOUSTIC_MANAG:
3961 				stat = sata_mode_select_page_30(spx,
3962 				    (struct mode_acoustic_management *)
3963 				    &buf[len], pllen, &pagelen, &rval, &dmod);
3964 				/*
3965 				 * The pagelen value indicates the number of
3966 				 * parameter bytes already processed.
3967 				 * The rval is the return value from
3968 				 * sata_tran_start().
3969 				 * The stat indicates the overall status of
3970 				 * the operation(s).
3971 				 */
3972 				if (stat != SATA_SUCCESS)
3973 					/*
3974 					 * Page processing did not succeed -
3975 					 * all error info is already set-up,
3976 					 * just return
3977 					 */
3978 					pllen = 0; /* this breaks the loop */
3979 				else {
3980 					len += pagelen;
3981 					pllen -= pagelen;
3982 				}
3983 
3984 				break;
3985 			default:
3986 				*scsipkt->pkt_scbp = STATUS_CHECK;
3987 				sense = sata_arq_sense(spx);
3988 				sense->es_key = KEY_ILLEGAL_REQUEST;
3989 				sense->es_add_code =
3990 				    SD_SCSI_ASC_INVALID_FIELD_IN_PARAMS_LIST;
3991 				goto done;
3992 			}
3993 		}
3994 	}
3995 done:
3996 	mutex_exit(&(SATA_TXLT_CPORT_MUTEX(spx)));
3997 	/*
3998 	 * If device parameters were modified, fetch and store the new
3999 	 * Identify Device data. Since port mutex could have been released
4000 	 * for accessing HBA driver, we need to re-check device existence.
4001 	 */
4002 	if (dmod != 0) {
4003 		sata_drive_info_t new_sdinfo, *sdinfo;
4004 		int rv = 0;
4005 
4006 		/*
4007 		 * Following statement has to be changed if this function is
4008 		 * used for devices other than SATA hard disks.
4009 		 */
4010 		new_sdinfo.satadrv_type = SATA_DTYPE_ATADISK;
4011 
4012 		new_sdinfo.satadrv_addr =
4013 		    spx->txlt_sata_pkt->satapkt_device.satadev_addr;
4014 		rv = sata_fetch_device_identify_data(spx->txlt_sata_hba_inst,
4015 		    &new_sdinfo);
4016 
4017 		mutex_enter(&(SATA_TXLT_CPORT_MUTEX(spx)));
4018 		/*
4019 		 * Since port mutex could have been released when
4020 		 * accessing HBA driver, we need to re-check that the
4021 		 * framework still holds the device info structure.
4022 		 */
4023 		sdinfo = sata_get_device_info(spx->txlt_sata_hba_inst,
4024 		    &spx->txlt_sata_pkt->satapkt_device);
4025 		if (sdinfo != NULL) {
4026 			/*
4027 			 * Device still has info structure in the
4028 			 * sata framework. Copy newly fetched info
4029 			 */
4030 			if (rv == 0) {
4031 				sdinfo->satadrv_id = new_sdinfo.satadrv_id;
4032 				sata_save_drive_settings(sdinfo);
4033 			} else {
4034 				/*
4035 				 * Could not fetch new data - invalidate
4036 				 * sata_drive_info. That makes device
4037 				 * unusable.
4038 				 */
4039 				sdinfo->satadrv_type = SATA_DTYPE_UNKNOWN;
4040 				sdinfo->satadrv_state = SATA_STATE_UNKNOWN;
4041 			}
4042 		}
4043 		if (rv != 0 || sdinfo == NULL) {
4044 			/*
4045 			 * This changes the overall mode select completion
4046 			 * reason to a failed one !!!!!
4047 			 */
4048 			*scsipkt->pkt_scbp = STATUS_CHECK;
4049 			sense = sata_arq_sense(spx);
4050 			scsipkt->pkt_reason = CMD_INCOMPLETE;
4051 			rval = TRAN_ACCEPT;
4052 		}
4053 		mutex_exit(&(SATA_TXLT_CPORT_MUTEX(spx)));
4054 	}
4055 	/* Restore the scsi pkt flags */
4056 	scsipkt->pkt_flags &= ~FLAG_NOINTR;
4057 	scsipkt->pkt_flags |= nointr_flag;
4058 
4059 	SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst,
4060 	    "Scsi_pkt completion reason %x\n", scsipkt->pkt_reason);
4061 
4062 	if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0 &&
4063 	    scsipkt->pkt_comp != NULL)
4064 		/* scsi callback required */
4065 		if (taskq_dispatch(SATA_TXLT_TASKQ(spx),
4066 		    (task_func_t *)scsipkt->pkt_comp, (void *) scsipkt,
4067 		    TQ_SLEEP) == NULL)
4068 			/* Scheduling the callback failed */
4069 			return (TRAN_BUSY);
4070 
4071 	return (rval);
4072 }
4073 
4074 
4075 
4076 /*
4077  * Translate command: Log Sense
4078  */
4079 static 	int
4080 sata_txlt_log_sense(sata_pkt_txlate_t *spx)
4081 {
4082 	struct scsi_pkt	*scsipkt = spx->txlt_scsi_pkt;
4083 	struct buf	*bp = spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp;
4084 	sata_drive_info_t *sdinfo;
4085 	struct scsi_extended_sense *sense;
4086 	int 		len, count, alc_len;
4087 	int		pc;	/* Page Control code */
4088 	int		page_code;	/* Page code */
4089 	uint8_t		*buf;	/* log sense buffer */
4090 	int		rval;
4091 #define	MAX_LOG_SENSE_PAGE_SIZE	512
4092 
4093 	SATADBG2(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst,
4094 	    "sata_txlt_log_sense, pc 0x%x, page code 0x%x\n",
4095 	    spx->txlt_scsi_pkt->pkt_cdbp[2] >> 6,
4096 	    spx->txlt_scsi_pkt->pkt_cdbp[2] & 0x3f);
4097 
4098 	buf = kmem_zalloc(MAX_LOG_SENSE_PAGE_SIZE, KM_SLEEP);
4099 
4100 	mutex_enter(&(SATA_TXLT_CPORT_MUTEX(spx)));
4101 
4102 	if (((rval = sata_txlt_generic_pkt_info(spx)) != TRAN_ACCEPT) ||
4103 	    (spx->txlt_scsi_pkt->pkt_reason == CMD_DEV_GONE)) {
4104 		mutex_exit(&(SATA_TXLT_CPORT_MUTEX(spx)));
4105 		kmem_free(buf, MAX_LOG_SENSE_PAGE_SIZE);
4106 		return (rval);
4107 	}
4108 
4109 	scsipkt->pkt_reason = CMD_CMPLT;
4110 	scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET |
4111 	    STATE_SENT_CMD | STATE_GOT_STATUS;
4112 
4113 	pc = scsipkt->pkt_cdbp[2] >> 6;
4114 	page_code = scsipkt->pkt_cdbp[2] & 0x3f;
4115 
4116 	/* Reject not supported request for all but cumulative values */
4117 	switch (pc) {
4118 	case PC_CUMULATIVE_VALUES:
4119 		break;
4120 	default:
4121 		*scsipkt->pkt_scbp = STATUS_CHECK;
4122 		sense = sata_arq_sense(spx);
4123 		sense->es_key = KEY_ILLEGAL_REQUEST;
4124 		sense->es_add_code = SD_SCSI_ASC_INVALID_FIELD_IN_CDB;
4125 		goto done;
4126 	}
4127 
4128 	switch (page_code) {
4129 	case PAGE_CODE_GET_SUPPORTED_LOG_PAGES:
4130 	case PAGE_CODE_SELF_TEST_RESULTS:
4131 	case PAGE_CODE_INFORMATION_EXCEPTIONS:
4132 	case PAGE_CODE_SMART_READ_DATA:
4133 		break;
4134 	default:
4135 		*scsipkt->pkt_scbp = STATUS_CHECK;
4136 		sense = sata_arq_sense(spx);
4137 		sense->es_key = KEY_ILLEGAL_REQUEST;
4138 		sense->es_add_code = SD_SCSI_ASC_INVALID_FIELD_IN_CDB;
4139 		goto done;
4140 	}
4141 
4142 	if (bp != NULL && bp->b_un.b_addr && bp->b_bcount) {
4143 		/*
4144 		 * Because log sense uses local buffers for data retrieval from
4145 		 * the devices and sets the data programatically in the
4146 		 * original specified buffer, release preallocated DMA
4147 		 * resources before storing data in the original buffer,
4148 		 * so no unwanted DMA sync would take place.
4149 		 */
4150 		sata_id_t *sata_id;
4151 
4152 		sata_scsi_dmafree(NULL, scsipkt);
4153 
4154 		len = 0;
4155 
4156 		/* Build log parameter header */
4157 		buf[len++] = page_code;	/* page code as in the CDB */
4158 		buf[len++] = 0;		/* reserved */
4159 		buf[len++] = 0;		/* Zero out page length for now (MSB) */
4160 		buf[len++] = 0;		/* (LSB) */
4161 
4162 		sdinfo = sata_get_device_info(
4163 		    spx->txlt_sata_hba_inst,
4164 		    &spx->txlt_sata_pkt->satapkt_device);
4165 
4166 
4167 		/*
4168 		 * Add requested pages.
4169 		 */
4170 		switch (page_code) {
4171 		case PAGE_CODE_GET_SUPPORTED_LOG_PAGES:
4172 			len = sata_build_lsense_page_0(sdinfo, buf + len);
4173 			break;
4174 		case PAGE_CODE_SELF_TEST_RESULTS:
4175 			sata_id = &sdinfo->satadrv_id;
4176 			if ((! (sata_id->ai_cmdset84 &
4177 			    SATA_SMART_SELF_TEST_SUPPORTED)) ||
4178 			    (! (sata_id->ai_features87 &
4179 			    SATA_SMART_SELF_TEST_SUPPORTED))) {
4180 				*scsipkt->pkt_scbp = STATUS_CHECK;
4181 				sense = sata_arq_sense(spx);
4182 				sense->es_key = KEY_ILLEGAL_REQUEST;
4183 				sense->es_add_code =
4184 				    SD_SCSI_ASC_INVALID_FIELD_IN_CDB;
4185 
4186 				goto done;
4187 			}
4188 			len = sata_build_lsense_page_10(sdinfo, buf + len,
4189 			    spx->txlt_sata_hba_inst);
4190 			break;
4191 		case PAGE_CODE_INFORMATION_EXCEPTIONS:
4192 			sata_id = &sdinfo->satadrv_id;
4193 			if (! (sata_id->ai_cmdset82 & SATA_SMART_SUPPORTED)) {
4194 				*scsipkt->pkt_scbp = STATUS_CHECK;
4195 				sense = sata_arq_sense(spx);
4196 				sense->es_key = KEY_ILLEGAL_REQUEST;
4197 				sense->es_add_code =
4198 				    SD_SCSI_ASC_INVALID_FIELD_IN_CDB;
4199 
4200 				goto done;
4201 			}
4202 			if (! (sata_id->ai_features85 & SATA_SMART_ENABLED)) {
4203 				*scsipkt->pkt_scbp = STATUS_CHECK;
4204 				sense = sata_arq_sense(spx);
4205 				sense->es_key = KEY_ABORTED_COMMAND;
4206 				sense->es_add_code =
4207 				    SCSI_ASC_ATA_DEV_FEAT_NOT_ENABLED;
4208 				sense->es_qual_code =
4209 				    SCSI_ASCQ_ATA_DEV_FEAT_NOT_ENABLED;
4210 
4211 				goto done;
4212 			}
4213 
4214 			len = sata_build_lsense_page_2f(sdinfo, buf + len,
4215 			    spx->txlt_sata_hba_inst);
4216 			break;
4217 		case PAGE_CODE_SMART_READ_DATA:
4218 			sata_id = &sdinfo->satadrv_id;
4219 			if (! (sata_id->ai_cmdset82 & SATA_SMART_SUPPORTED)) {
4220 				*scsipkt->pkt_scbp = STATUS_CHECK;
4221 				sense = sata_arq_sense(spx);
4222 				sense->es_key = KEY_ILLEGAL_REQUEST;
4223 				sense->es_add_code =
4224 				    SD_SCSI_ASC_INVALID_FIELD_IN_CDB;
4225 
4226 				goto done;
4227 			}
4228 			if (! (sata_id->ai_features85 & SATA_SMART_ENABLED)) {
4229 				*scsipkt->pkt_scbp = STATUS_CHECK;
4230 				sense = sata_arq_sense(spx);
4231 				sense->es_key = KEY_ABORTED_COMMAND;
4232 				sense->es_add_code =
4233 				    SCSI_ASC_ATA_DEV_FEAT_NOT_ENABLED;
4234 				sense->es_qual_code =
4235 				    SCSI_ASCQ_ATA_DEV_FEAT_NOT_ENABLED;
4236 
4237 				goto done;
4238 			}
4239 
4240 			/* This page doesn't include a page header */
4241 			len = sata_build_lsense_page_30(sdinfo, buf,
4242 			    spx->txlt_sata_hba_inst);
4243 			goto no_header;
4244 		default:
4245 			/* Invalid request */
4246 			*scsipkt->pkt_scbp = STATUS_CHECK;
4247 			sense = sata_arq_sense(spx);
4248 			sense->es_key = KEY_ILLEGAL_REQUEST;
4249 			sense->es_add_code = SD_SCSI_ASC_INVALID_FIELD_IN_CDB;
4250 			goto done;
4251 		}
4252 
4253 		/* set parameter log sense data length */
4254 		buf[2] = len >> 8;	/* log sense length (MSB) */
4255 		buf[3] = len & 0xff;	/* log sense length (LSB) */
4256 
4257 		len += SCSI_LOG_PAGE_HDR_LEN;
4258 		ASSERT(len <= MAX_LOG_SENSE_PAGE_SIZE);
4259 
4260 no_header:
4261 		/* Check allocation length */
4262 		alc_len = scsipkt->pkt_cdbp[7];
4263 		alc_len = (len << 8) | scsipkt->pkt_cdbp[8];
4264 
4265 		/*
4266 		 * We do not check for possible parameters truncation
4267 		 * (alc_len < len) assuming that the target driver works
4268 		 * correctly. Just avoiding overrun.
4269 		 * Copy no more than requested and possible, buffer-wise.
4270 		 */
4271 		count = MIN(alc_len, len);
4272 		count = MIN(bp->b_bcount, count);
4273 		bcopy(buf, bp->b_un.b_addr, count);
4274 
4275 		scsipkt->pkt_state |= STATE_XFERRED_DATA;
4276 		scsipkt->pkt_resid = alc_len > count ? alc_len - count : 0;
4277 	}
4278 	*scsipkt->pkt_scbp = STATUS_GOOD;
4279 done:
4280 	mutex_exit(&(SATA_TXLT_CPORT_MUTEX(spx)));
4281 	(void) kmem_free(buf, MAX_LOG_SENSE_PAGE_SIZE);
4282 
4283 	SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst,
4284 	    "Scsi_pkt completion reason %x\n", scsipkt->pkt_reason);
4285 
4286 	if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0 &&
4287 	    scsipkt->pkt_comp != NULL)
4288 		/* scsi callback required */
4289 		if (taskq_dispatch(SATA_TXLT_TASKQ(spx),
4290 		    (task_func_t *)scsipkt->pkt_comp, (void *) scsipkt,
4291 		    TQ_SLEEP) == NULL)
4292 			/* Scheduling the callback failed */
4293 			return (TRAN_BUSY);
4294 
4295 	return (TRAN_ACCEPT);
4296 }
4297 
4298 /*
4299  * Translate command: Log Select
4300  * Not implemented at this time - returns invalid command response.
4301  */
4302 static 	int
4303 sata_txlt_log_select(sata_pkt_txlate_t *spx)
4304 {
4305 	SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst,
4306 	    "sata_txlt_log_select\n", NULL);
4307 
4308 	return (sata_txlt_invalid_command(spx));
4309 }
4310 
4311 
4312 /*
4313  * Translate command: Read (various types).
4314  * Translated into appropriate type of ATA READ command
4315  * for SATA hard disks.
4316  * Both the device capabilities and requested operation mode are
4317  * considered.
4318  *
4319  * Following scsi cdb fields are ignored:
4320  * rdprotect, dpo, fua, fua_nv, group_number.
4321  *
4322  * If SATA_ENABLE_QUEUING flag is set (in the global SATA HBA framework
4323  * enable variable sata_func_enable), the capability of the controller and
4324  * capability of a device are checked and if both support queueing, read
4325  * request will be translated to READ_DMA_QUEUEING or READ_DMA_QUEUEING_EXT
4326  * command rather than plain READ_XXX command.
4327  * If SATA_ENABLE_NCQ flag is set in addition to SATA_ENABLE_QUEUING flag and
4328  * both the controller and device suport such functionality, the read
4329  * request will be translated to READ_FPDMA_QUEUED command.
4330  * In both cases the maximum queue depth is derived as minimum of:
4331  * HBA capability,device capability and sata_max_queue_depth variable setting.
4332  * The value passed to HBA driver is decremented by 1, because only 5 bits are
4333  * used to pass max queue depth value, and the maximum possible queue depth
4334  * is 32.
4335  *
4336  * Returns TRAN_ACCEPT or code returned by sata_hba_start() and
4337  * appropriate values in scsi_pkt fields.
4338  */
4339 static int
4340 sata_txlt_read(sata_pkt_txlate_t *spx)
4341 {
4342 	struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt;
4343 	sata_cmd_t *scmd = &spx->txlt_sata_pkt->satapkt_cmd;
4344 	sata_drive_info_t *sdinfo;
4345 	sata_hba_inst_t *shi = SATA_TXLT_HBA_INST(spx);
4346 	int cport = SATA_TXLT_CPORT(spx);
4347 	uint16_t sec_count;
4348 	uint64_t lba;
4349 	int rval;
4350 	int synch;
4351 
4352 	mutex_enter(&(SATA_TXLT_CPORT_MUTEX(spx)));
4353 
4354 	if (((rval = sata_txlt_generic_pkt_info(spx)) != TRAN_ACCEPT) ||
4355 	    (spx->txlt_scsi_pkt->pkt_reason == CMD_DEV_GONE)) {
4356 		mutex_exit(&(SATA_TXLT_CPORT_MUTEX(spx)));
4357 		return (rval);
4358 	}
4359 
4360 	sdinfo = sata_get_device_info(spx->txlt_sata_hba_inst,
4361 	    &spx->txlt_sata_pkt->satapkt_device);
4362 
4363 	scmd->satacmd_flags.sata_data_direction = SATA_DIR_READ;
4364 	/*
4365 	 * Extract LBA and sector count from scsi CDB.
4366 	 */
4367 	switch ((uint_t)scsipkt->pkt_cdbp[0]) {
4368 	case SCMD_READ:
4369 		/* 6-byte scsi read cmd : 0x08 */
4370 		lba = (scsipkt->pkt_cdbp[1] & 0x1f);
4371 		lba = (lba << 8) | scsipkt->pkt_cdbp[2];
4372 		lba = (lba << 8) | scsipkt->pkt_cdbp[3];
4373 		sec_count = scsipkt->pkt_cdbp[4];
4374 		/* sec_count 0 will be interpreted as 256 by a device */
4375 		break;
4376 	case SCMD_READ_G1:
4377 		/* 10-bytes scsi read command : 0x28 */
4378 		lba = scsipkt->pkt_cdbp[2];
4379 		lba = (lba << 8) | scsipkt->pkt_cdbp[3];
4380 		lba = (lba << 8) | scsipkt->pkt_cdbp[4];
4381 		lba = (lba << 8) | scsipkt->pkt_cdbp[5];
4382 		sec_count = scsipkt->pkt_cdbp[7];
4383 		sec_count = (sec_count << 8) | scsipkt->pkt_cdbp[8];
4384 		break;
4385 	case SCMD_READ_G5:
4386 		/* 12-bytes scsi read command : 0xA8 */
4387 		lba = scsipkt->pkt_cdbp[2];
4388 		lba = (lba << 8) | scsipkt->pkt_cdbp[3];
4389 		lba = (lba << 8) | scsipkt->pkt_cdbp[4];
4390 		lba = (lba << 8) | scsipkt->pkt_cdbp[5];
4391 		sec_count = scsipkt->pkt_cdbp[6];
4392 		sec_count = (sec_count << 8) | scsipkt->pkt_cdbp[7];
4393 		sec_count = (sec_count << 8) | scsipkt->pkt_cdbp[8];
4394 		sec_count = (sec_count << 8) | scsipkt->pkt_cdbp[9];
4395 		break;
4396 	case SCMD_READ_G4:
4397 		/* 16-bytes scsi read command : 0x88 */
4398 		lba = scsipkt->pkt_cdbp[2];
4399 		lba = (lba << 8) | scsipkt->pkt_cdbp[3];
4400 		lba = (lba << 8) | scsipkt->pkt_cdbp[4];
4401 		lba = (lba << 8) | scsipkt->pkt_cdbp[5];
4402 		lba = (lba << 8) | scsipkt->pkt_cdbp[6];
4403 		lba = (lba << 8) | scsipkt->pkt_cdbp[7];
4404 		lba = (lba << 8) | scsipkt->pkt_cdbp[8];
4405 		lba = (lba << 8) | scsipkt->pkt_cdbp[9];
4406 		sec_count = scsipkt->pkt_cdbp[10];
4407 		sec_count = (sec_count << 8) | scsipkt->pkt_cdbp[11];
4408 		sec_count = (sec_count << 8) | scsipkt->pkt_cdbp[12];
4409 		sec_count = (sec_count << 8) | scsipkt->pkt_cdbp[13];
4410 		break;
4411 	default:
4412 		/* Unsupported command */
4413 		mutex_exit(&(SATA_TXLT_CPORT_MUTEX(spx)));
4414 		return (sata_txlt_invalid_command(spx));
4415 	}
4416 
4417 	/*
4418 	 * Check if specified address exceeds device capacity
4419 	 */
4420 	if ((lba >= sdinfo->satadrv_capacity) ||
4421 	    ((lba + sec_count) > sdinfo->satadrv_capacity)) {
4422 		/* LBA out of range */
4423 		mutex_exit(&(SATA_TXLT_CPORT_MUTEX(spx)));
4424 		return (sata_txlt_lba_out_of_range(spx));
4425 	}
4426 
4427 	/*
4428 	 * For zero-length transfer, emulate good completion of the command
4429 	 * (reasons for rejecting the command were already checked).
4430 	 * No DMA resources were allocated.
4431 	 */
4432 	if (spx->txlt_dma_cookie_list == NULL) {
4433 		mutex_exit(&(SATA_TXLT_CPORT_MUTEX(spx)));
4434 		return (sata_emul_rw_completion(spx));
4435 	}
4436 
4437 	/*
4438 	 * Build cmd block depending on the device capability and
4439 	 * requested operation mode.
4440 	 * Do not bother with non-dma mode - we are working only with
4441 	 * devices supporting DMA.
4442 	 */
4443 	scmd->satacmd_addr_type = ATA_ADDR_LBA;
4444 	scmd->satacmd_device_reg = SATA_ADH_LBA;
4445 	scmd->satacmd_cmd_reg = SATAC_READ_DMA;
4446 	if (sdinfo->satadrv_features_support & SATA_DEV_F_LBA48) {
4447 		scmd->satacmd_addr_type = ATA_ADDR_LBA48;
4448 		scmd->satacmd_cmd_reg = SATAC_READ_DMA_EXT;
4449 		scmd->satacmd_sec_count_msb = sec_count >> 8;
4450 #ifndef __lock_lint
4451 		scmd->satacmd_lba_low_msb = (lba >> 24) & 0xff;
4452 		scmd->satacmd_lba_mid_msb = (lba >> 32) & 0xff;
4453 		scmd->satacmd_lba_high_msb = lba >> 40;
4454 #endif
4455 	} else if (sdinfo->satadrv_features_support & SATA_DEV_F_LBA28) {
4456 		scmd->satacmd_addr_type = ATA_ADDR_LBA28;
4457 		scmd->satacmd_device_reg = SATA_ADH_LBA | ((lba >> 24) & 0xf);
4458 	}
4459 	scmd->satacmd_sec_count_lsb = sec_count & 0xff;
4460 	scmd->satacmd_lba_low_lsb = lba & 0xff;
4461 	scmd->satacmd_lba_mid_lsb = (lba >> 8) & 0xff;
4462 	scmd->satacmd_lba_high_lsb = (lba >> 16) & 0xff;
4463 	scmd->satacmd_features_reg = 0;
4464 	scmd->satacmd_status_reg = 0;
4465 	scmd->satacmd_error_reg = 0;
4466 
4467 	/*
4468 	 * Check if queueing commands should be used and switch
4469 	 * to appropriate command if possible
4470 	 */
4471 	if (sata_func_enable & SATA_ENABLE_QUEUING) {
4472 		boolean_t using_queuing;
4473 
4474 		/* Queuing supported by controller and device? */
4475 		if ((sata_func_enable & SATA_ENABLE_NCQ) &&
4476 		    (sdinfo->satadrv_features_support &
4477 		    SATA_DEV_F_NCQ) &&
4478 		    (SATA_FEATURES(spx->txlt_sata_hba_inst) &
4479 		    SATA_CTLF_NCQ)) {
4480 			using_queuing = B_TRUE;
4481 
4482 			/* NCQ supported - use FPDMA READ */
4483 			scmd->satacmd_cmd_reg =
4484 			    SATAC_READ_FPDMA_QUEUED;
4485 			scmd->satacmd_features_reg_ext =
4486 			    scmd->satacmd_sec_count_msb;
4487 			scmd->satacmd_sec_count_msb = 0;
4488 		} else if ((sdinfo->satadrv_features_support &
4489 		    SATA_DEV_F_TCQ) &&
4490 		    (SATA_FEATURES(spx->txlt_sata_hba_inst) &
4491 		    SATA_CTLF_QCMD)) {
4492 			using_queuing = B_TRUE;
4493 
4494 			/* Legacy queueing */
4495 			if (sdinfo->satadrv_features_support &
4496 			    SATA_DEV_F_LBA48) {
4497 				scmd->satacmd_cmd_reg =
4498 				    SATAC_READ_DMA_QUEUED_EXT;
4499 				scmd->satacmd_features_reg_ext =
4500 				    scmd->satacmd_sec_count_msb;
4501 				scmd->satacmd_sec_count_msb = 0;
4502 			} else {
4503 				scmd->satacmd_cmd_reg =
4504 				    SATAC_READ_DMA_QUEUED;
4505 			}
4506 		} else	/* NCQ nor legacy queuing not supported */
4507 			using_queuing = B_FALSE;
4508 
4509 		/*
4510 		 * If queuing, the sector count goes in the features register
4511 		 * and the secount count will contain the tag.
4512 		 */
4513 		if (using_queuing) {
4514 			scmd->satacmd_features_reg =
4515 			    scmd->satacmd_sec_count_lsb;
4516 			scmd->satacmd_sec_count_lsb = 0;
4517 			scmd->satacmd_flags.sata_queued = B_TRUE;
4518 
4519 			/* Set-up maximum queue depth */
4520 			scmd->satacmd_flags.sata_max_queue_depth =
4521 			    sdinfo->satadrv_max_queue_depth - 1;
4522 		} else if (sdinfo->satadrv_features_enabled &
4523 		    SATA_DEV_F_E_UNTAGGED_QING) {
4524 			/*
4525 			 * Although NCQ/TCQ is not enabled, untagged queuing
4526 			 * may be still used.
4527 			 * Set-up the maximum untagged queue depth.
4528 			 * Use controller's queue depth from sata_hba_tran.
4529 			 * SATA HBA drivers may ignore this value and rely on
4530 			 * the internal limits.For drivers that do not
4531 			 * ignore untaged queue depth, limit the value to
4532 			 * SATA_MAX_QUEUE_DEPTH (32), as this is the
4533 			 * largest value that can be passed via
4534 			 * satacmd_flags.sata_max_queue_depth.
4535 			 */
4536 			scmd->satacmd_flags.sata_max_queue_depth =
4537 			    SATA_QDEPTH(shi) <= SATA_MAX_QUEUE_DEPTH ?
4538 			    SATA_QDEPTH(shi) - 1: SATA_MAX_QUEUE_DEPTH - 1;
4539 
4540 		} else {
4541 			scmd->satacmd_flags.sata_max_queue_depth = 0;
4542 		}
4543 	} else
4544 		scmd->satacmd_flags.sata_max_queue_depth = 0;
4545 
4546 	SATADBG3(SATA_DBG_HBA_IF, spx->txlt_sata_hba_inst,
4547 	    "sata_txlt_read cmd 0x%2x, lba %llx, sec count %x\n",
4548 	    scmd->satacmd_cmd_reg, lba, sec_count);
4549 
4550 	if (!(spx->txlt_sata_pkt->satapkt_op_mode & SATA_OPMODE_SYNCH)) {
4551 		/* Need callback function */
4552 		spx->txlt_sata_pkt->satapkt_comp = sata_txlt_rw_completion;
4553 		synch = FALSE;
4554 	} else
4555 		synch = TRUE;
4556 
4557 	/* Transfer command to HBA */
4558 	if (sata_hba_start(spx, &rval) != 0) {
4559 		/* Pkt not accepted for execution */
4560 		mutex_exit(&SATA_CPORT_MUTEX(shi, cport));
4561 		return (rval);
4562 	}
4563 	mutex_exit(&SATA_CPORT_MUTEX(shi, cport));
4564 	/*
4565 	 * If execution is non-synchronous,
4566 	 * a callback function will handle potential errors, translate
4567 	 * the response and will do a callback to a target driver.
4568 	 * If it was synchronous, check execution status using the same
4569 	 * framework callback.
4570 	 */
4571 	if (synch) {
4572 		SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst,
4573 		    "synchronous execution status %x\n",
4574 		    spx->txlt_sata_pkt->satapkt_reason);
4575 		sata_txlt_rw_completion(spx->txlt_sata_pkt);
4576 	}
4577 	return (TRAN_ACCEPT);
4578 }
4579 
4580 
4581 /*
4582  * SATA translate command: Write (various types)
4583  * Translated into appropriate type of ATA WRITE command
4584  * for SATA hard disks.
4585  * Both the device capabilities and requested operation mode are
4586  * considered.
4587  *
4588  * Following scsi cdb fields are ignored:
4589  * rwprotect, dpo, fua, fua_nv, group_number.
4590  *
4591  * If SATA_ENABLE_QUEUING flag is set (in the global SATA HBA framework
4592  * enable variable sata_func_enable), the capability of the controller and
4593  * capability of a device are checked and if both support queueing, write
4594  * request will be translated to WRITE_DMA_QUEUEING or WRITE_DMA_QUEUEING_EXT
4595  * command rather than plain WRITE_XXX command.
4596  * If SATA_ENABLE_NCQ flag is set in addition to SATA_ENABLE_QUEUING flag and
4597  * both the controller and device suport such functionality, the write
4598  * request will be translated to WRITE_FPDMA_QUEUED command.
4599  * In both cases the maximum queue depth is derived as minimum of:
4600  * HBA capability,device capability and sata_max_queue_depth variable setting.
4601  * The value passed to HBA driver is decremented by 1, because only 5 bits are
4602  * used to pass max queue depth value, and the maximum possible queue depth
4603  * is 32.
4604  *
4605  * Returns TRAN_ACCEPT or code returned by sata_hba_start() and
4606  * appropriate values in scsi_pkt fields.
4607  */
4608 static int
4609 sata_txlt_write(sata_pkt_txlate_t *spx)
4610 {
4611 	struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt;
4612 	sata_cmd_t *scmd = &spx->txlt_sata_pkt->satapkt_cmd;
4613 	sata_drive_info_t *sdinfo;
4614 	sata_hba_inst_t *shi = SATA_TXLT_HBA_INST(spx);
4615 	int cport = SATA_TXLT_CPORT(spx);
4616 	uint16_t sec_count;
4617 	uint64_t lba;
4618 	int rval;
4619 	int synch;
4620 
4621 	mutex_enter(&(SATA_TXLT_CPORT_MUTEX(spx)));
4622 
4623 	if (((rval = sata_txlt_generic_pkt_info(spx)) != TRAN_ACCEPT) ||
4624 	    (spx->txlt_scsi_pkt->pkt_reason == CMD_DEV_GONE)) {
4625 		mutex_exit(&(SATA_TXLT_CPORT_MUTEX(spx)));
4626 		return (rval);
4627 	}
4628 
4629 	sdinfo = sata_get_device_info(spx->txlt_sata_hba_inst,
4630 	    &spx->txlt_sata_pkt->satapkt_device);
4631 
4632 	scmd->satacmd_flags.sata_data_direction = SATA_DIR_WRITE;
4633 	/*
4634 	 * Extract LBA and sector count from scsi CDB
4635 	 */
4636 	switch ((uint_t)scsipkt->pkt_cdbp[0]) {
4637 	case SCMD_WRITE:
4638 		/* 6-byte scsi read cmd : 0x0A */
4639 		lba = (scsipkt->pkt_cdbp[1] & 0x1f);
4640 		lba = (lba << 8) | scsipkt->pkt_cdbp[2];
4641 		lba = (lba << 8) | scsipkt->pkt_cdbp[3];
4642 		sec_count = scsipkt->pkt_cdbp[4];
4643 		/* sec_count 0 will be interpreted as 256 by a device */
4644 		break;
4645 	case SCMD_WRITE_G1:
4646 		/* 10-bytes scsi write command : 0x2A */
4647 		lba = scsipkt->pkt_cdbp[2];
4648 		lba = (lba << 8) | scsipkt->pkt_cdbp[3];
4649 		lba = (lba << 8) | scsipkt->pkt_cdbp[4];
4650 		lba = (lba << 8) | scsipkt->pkt_cdbp[5];
4651 		sec_count = scsipkt->pkt_cdbp[7];
4652 		sec_count = (sec_count << 8) | scsipkt->pkt_cdbp[8];
4653 		break;
4654 	case SCMD_WRITE_G5:
4655 		/* 12-bytes scsi read command : 0xAA */
4656 		lba = scsipkt->pkt_cdbp[2];
4657 		lba = (lba << 8) | scsipkt->pkt_cdbp[3];
4658 		lba = (lba << 8) | scsipkt->pkt_cdbp[4];
4659 		lba = (lba << 8) | scsipkt->pkt_cdbp[5];
4660 		sec_count = scsipkt->pkt_cdbp[6];
4661 		sec_count = (sec_count << 8) | scsipkt->pkt_cdbp[7];
4662 		sec_count = (sec_count << 8) | scsipkt->pkt_cdbp[8];
4663 		sec_count = (sec_count << 8) | scsipkt->pkt_cdbp[9];
4664 		break;
4665 	case SCMD_WRITE_G4:
4666 		/* 16-bytes scsi write command : 0x8A */
4667 		lba = scsipkt->pkt_cdbp[2];
4668 		lba = (lba << 8) | scsipkt->pkt_cdbp[3];
4669 		lba = (lba << 8) | scsipkt->pkt_cdbp[4];
4670 		lba = (lba << 8) | scsipkt->pkt_cdbp[5];
4671 		lba = (lba << 8) | scsipkt->pkt_cdbp[6];
4672 		lba = (lba << 8) | scsipkt->pkt_cdbp[7];
4673 		lba = (lba << 8) | scsipkt->pkt_cdbp[8];
4674 		lba = (lba << 8) | scsipkt->pkt_cdbp[9];
4675 		sec_count = scsipkt->pkt_cdbp[10];
4676 		sec_count = (sec_count << 8) | scsipkt->pkt_cdbp[11];
4677 		sec_count = (sec_count << 8) | scsipkt->pkt_cdbp[12];
4678 		sec_count = (sec_count << 8) | scsipkt->pkt_cdbp[13];
4679 		break;
4680 	default:
4681 		/* Unsupported command */
4682 		mutex_exit(&(SATA_TXLT_CPORT_MUTEX(spx)));
4683 		return (sata_txlt_invalid_command(spx));
4684 	}
4685 
4686 	/*
4687 	 * Check if specified address and length exceeds device capacity
4688 	 */
4689 	if ((lba >= sdinfo->satadrv_capacity) ||
4690 	    ((lba + sec_count) > sdinfo->satadrv_capacity)) {
4691 		/* LBA out of range */
4692 		mutex_exit(&(SATA_TXLT_CPORT_MUTEX(spx)));
4693 		return (sata_txlt_lba_out_of_range(spx));
4694 	}
4695 
4696 	/*
4697 	 * For zero-length transfer, emulate good completion of the command
4698 	 * (reasons for rejecting the command were already checked).
4699 	 * No DMA resources were allocated.
4700 	 */
4701 	if (spx->txlt_dma_cookie_list == NULL) {
4702 		mutex_exit(&(SATA_TXLT_CPORT_MUTEX(spx)));
4703 		return (sata_emul_rw_completion(spx));
4704 	}
4705 
4706 	/*
4707 	 * Build cmd block depending on the device capability and
4708 	 * requested operation mode.
4709 	 * Do not bother with non-dma mode- we are working only with
4710 	 * devices supporting DMA.
4711 	 */
4712 	scmd->satacmd_addr_type = ATA_ADDR_LBA;
4713 	scmd->satacmd_device_reg = SATA_ADH_LBA;
4714 	scmd->satacmd_cmd_reg = SATAC_WRITE_DMA;
4715 	if (sdinfo->satadrv_features_support & SATA_DEV_F_LBA48) {
4716 		scmd->satacmd_addr_type = ATA_ADDR_LBA48;
4717 		scmd->satacmd_cmd_reg = SATAC_WRITE_DMA_EXT;
4718 		scmd->satacmd_sec_count_msb = sec_count >> 8;
4719 		scmd->satacmd_lba_low_msb = (lba >> 24) & 0xff;
4720 #ifndef __lock_lint
4721 		scmd->satacmd_lba_mid_msb = (lba >> 32) & 0xff;
4722 		scmd->satacmd_lba_high_msb = lba >> 40;
4723 #endif
4724 	} else if (sdinfo->satadrv_features_support & SATA_DEV_F_LBA28) {
4725 		scmd->satacmd_addr_type = ATA_ADDR_LBA28;
4726 		scmd->satacmd_device_reg = SATA_ADH_LBA | ((lba >> 24) & 0xf);
4727 	}
4728 	scmd->satacmd_sec_count_lsb = sec_count & 0xff;
4729 	scmd->satacmd_lba_low_lsb = lba & 0xff;
4730 	scmd->satacmd_lba_mid_lsb = (lba >> 8) & 0xff;
4731 	scmd->satacmd_lba_high_lsb = (lba >> 16) & 0xff;
4732 	scmd->satacmd_features_reg = 0;
4733 	scmd->satacmd_status_reg = 0;
4734 	scmd->satacmd_error_reg = 0;
4735 
4736 	/*
4737 	 * Check if queueing commands should be used and switch
4738 	 * to appropriate command if possible
4739 	 */
4740 	if (sata_func_enable & SATA_ENABLE_QUEUING) {
4741 		boolean_t using_queuing;
4742 
4743 		/* Queuing supported by controller and device? */
4744 		if ((sata_func_enable & SATA_ENABLE_NCQ) &&
4745 		    (sdinfo->satadrv_features_support &
4746 		    SATA_DEV_F_NCQ) &&
4747 		    (SATA_FEATURES(spx->txlt_sata_hba_inst) &
4748 		    SATA_CTLF_NCQ)) {
4749 			using_queuing = B_TRUE;
4750 
4751 			/* NCQ supported - use FPDMA WRITE */
4752 			scmd->satacmd_cmd_reg =
4753 			    SATAC_WRITE_FPDMA_QUEUED;
4754 			scmd->satacmd_features_reg_ext =
4755 			    scmd->satacmd_sec_count_msb;
4756 			scmd->satacmd_sec_count_msb = 0;
4757 		} else if ((sdinfo->satadrv_features_support &
4758 		    SATA_DEV_F_TCQ) &&
4759 		    (SATA_FEATURES(spx->txlt_sata_hba_inst) &
4760 		    SATA_CTLF_QCMD)) {
4761 			using_queuing = B_TRUE;
4762 
4763 			/* Legacy queueing */
4764 			if (sdinfo->satadrv_features_support &
4765 			    SATA_DEV_F_LBA48) {
4766 				scmd->satacmd_cmd_reg =
4767 				    SATAC_WRITE_DMA_QUEUED_EXT;
4768 				scmd->satacmd_features_reg_ext =
4769 				    scmd->satacmd_sec_count_msb;
4770 				scmd->satacmd_sec_count_msb = 0;
4771 			} else {
4772 				scmd->satacmd_cmd_reg =
4773 				    SATAC_WRITE_DMA_QUEUED;
4774 			}
4775 		} else	/*  NCQ nor legacy queuing not supported */
4776 			using_queuing = B_FALSE;
4777 
4778 		if (using_queuing) {
4779 			scmd->satacmd_features_reg =
4780 			    scmd->satacmd_sec_count_lsb;
4781 			scmd->satacmd_sec_count_lsb = 0;
4782 			scmd->satacmd_flags.sata_queued = B_TRUE;
4783 			/* Set-up maximum queue depth */
4784 			scmd->satacmd_flags.sata_max_queue_depth =
4785 			    sdinfo->satadrv_max_queue_depth - 1;
4786 		} else if (sdinfo->satadrv_features_enabled &
4787 		    SATA_DEV_F_E_UNTAGGED_QING) {
4788 			/*
4789 			 * Although NCQ/TCQ is not enabled, untagged queuing
4790 			 * may be still used.
4791 			 * Set-up the maximum untagged queue depth.
4792 			 * Use controller's queue depth from sata_hba_tran.
4793 			 * SATA HBA drivers may ignore this value and rely on
4794 			 * the internal limits. For drivera that do not
4795 			 * ignore untaged queue depth, limit the value to
4796 			 * SATA_MAX_QUEUE_DEPTH (32), as this is the
4797 			 * largest value that can be passed via
4798 			 * satacmd_flags.sata_max_queue_depth.
4799 			 */
4800 			scmd->satacmd_flags.sata_max_queue_depth =
4801 			    SATA_QDEPTH(shi) <= SATA_MAX_QUEUE_DEPTH ?
4802 			    SATA_QDEPTH(shi) - 1: SATA_MAX_QUEUE_DEPTH - 1;
4803 
4804 		} else {
4805 			scmd->satacmd_flags.sata_max_queue_depth = 0;
4806 		}
4807 	} else
4808 		scmd->satacmd_flags.sata_max_queue_depth = 0;
4809 
4810 	SATADBG3(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst,
4811 	    "sata_txlt_write cmd 0x%2x, lba %llx, sec count %x\n",
4812 	    scmd->satacmd_cmd_reg, lba, sec_count);
4813 
4814 	if (!(spx->txlt_sata_pkt->satapkt_op_mode & SATA_OPMODE_SYNCH)) {
4815 		/* Need callback function */
4816 		spx->txlt_sata_pkt->satapkt_comp = sata_txlt_rw_completion;
4817 		synch = FALSE;
4818 	} else
4819 		synch = TRUE;
4820 
4821 	/* Transfer command to HBA */
4822 	if (sata_hba_start(spx, &rval) != 0) {
4823 		/* Pkt not accepted for execution */
4824 		mutex_exit(&SATA_CPORT_MUTEX(shi, cport));
4825 		return (rval);
4826 	}
4827 	mutex_exit(&SATA_CPORT_MUTEX(shi, cport));
4828 
4829 	/*
4830 	 * If execution is non-synchronous,
4831 	 * a callback function will handle potential errors, translate
4832 	 * the response and will do a callback to a target driver.
4833 	 * If it was synchronous, check execution status using the same
4834 	 * framework callback.
4835 	 */
4836 	if (synch) {
4837 		SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst,
4838 		    "synchronous execution status %x\n",
4839 		    spx->txlt_sata_pkt->satapkt_reason);
4840 		sata_txlt_rw_completion(spx->txlt_sata_pkt);
4841 	}
4842 	return (TRAN_ACCEPT);
4843 }
4844 
4845 
4846 /*
4847  * Implements SCSI SBC WRITE BUFFER command download microcode option
4848  */
4849 static int
4850 sata_txlt_write_buffer(sata_pkt_txlate_t *spx)
4851 {
4852 #define	WB_DOWNLOAD_MICROCODE_AND_REVERT_MODE			4
4853 #define	WB_DOWNLOAD_MICROCODE_AND_SAVE_MODE			5
4854 
4855 	struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt;
4856 	sata_cmd_t *scmd = &spx->txlt_sata_pkt->satapkt_cmd;
4857 	struct buf *bp = spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp;
4858 	struct scsi_extended_sense *sense;
4859 	int rval, mode, sector_count;
4860 	sata_hba_inst_t *shi = SATA_TXLT_HBA_INST(spx);
4861 	int cport = SATA_TXLT_CPORT(spx);
4862 	boolean_t synch;
4863 
4864 	synch = (spx->txlt_sata_pkt->satapkt_op_mode & SATA_OPMODE_SYNCH) != 0;
4865 	mode = scsipkt->pkt_cdbp[1] & 0x1f;
4866 
4867 	SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst,
4868 	    "sata_txlt_write_buffer, mode 0x%x\n", mode);
4869 
4870 	mutex_enter(&(SATA_TXLT_CPORT_MUTEX(spx)));
4871 
4872 	if ((rval = sata_txlt_generic_pkt_info(spx)) != TRAN_ACCEPT) {
4873 		mutex_exit(&(SATA_TXLT_CPORT_MUTEX(spx)));
4874 		return (rval);
4875 	}
4876 
4877 	scmd->satacmd_flags.sata_data_direction = SATA_DIR_WRITE;
4878 
4879 	scsipkt->pkt_reason = CMD_CMPLT;
4880 	scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET |
4881 	    STATE_SENT_CMD | STATE_GOT_STATUS;
4882 
4883 	/*
4884 	 * The SCSI to ATA translation specification only calls
4885 	 * for WB_DOWNLOAD_MICROCODE_AND_SAVE_MODE.
4886 	 * WB_DOWNLOAD_MICROC_AND_REVERT_MODE is implemented, but
4887 	 * ATA 8 (draft) got rid of download microcode for temp
4888 	 * and it is even optional for ATA 7, so it may be aborted.
4889 	 * WB_DOWNLOAD_MICROCODE_WITH_OFFSET is not implemented as
4890 	 * it is not specified and the buffer offset for SCSI is a 16-bit
4891 	 * value in bytes, but for ATA it is a 16-bit offset in 512 byte
4892 	 * sectors.  Thus the offset really doesn't buy us anything.
4893 	 * If and when ATA 8 is stabilized and the SCSI to ATA specification
4894 	 * is revised, this can be revisisted.
4895 	 */
4896 	/* Reject not supported request */
4897 	switch (mode) {
4898 	case WB_DOWNLOAD_MICROCODE_AND_REVERT_MODE:
4899 		scmd->satacmd_features_reg = SATA_DOWNLOAD_MCODE_TEMP;
4900 		break;
4901 	case WB_DOWNLOAD_MICROCODE_AND_SAVE_MODE:
4902 		scmd->satacmd_features_reg = SATA_DOWNLOAD_MCODE_SAVE;
4903 		break;
4904 	default:
4905 		goto bad_param;
4906 	}
4907 
4908 	*scsipkt->pkt_scbp = STATUS_GOOD;	/* Presumed outcome */
4909 
4910 	scmd->satacmd_cmd_reg = SATAC_DOWNLOAD_MICROCODE;
4911 	if ((bp->b_bcount % SATA_DISK_SECTOR_SIZE) != 0)
4912 		goto bad_param;
4913 	sector_count = bp->b_bcount / SATA_DISK_SECTOR_SIZE;
4914 	scmd->satacmd_sec_count_lsb = (uint8_t)sector_count;
4915 	scmd->satacmd_lba_low_lsb = ((uint16_t)sector_count) >> 8;
4916 	scmd->satacmd_lba_mid_lsb = 0;
4917 	scmd->satacmd_lba_high_lsb = 0;
4918 	scmd->satacmd_device_reg = 0;
4919 	spx->txlt_sata_pkt->satapkt_comp =
4920 	    sata_txlt_download_mcode_cmd_completion;
4921 	scmd->satacmd_addr_type = 0;
4922 
4923 	/* Transfer command to HBA */
4924 	if (sata_hba_start(spx, &rval) != 0) {
4925 		/* Pkt not accepted for execution */
4926 		mutex_exit(&SATA_CPORT_MUTEX(shi, cport));
4927 		return (rval);
4928 	}
4929 
4930 	mutex_exit(&SATA_CPORT_MUTEX(shi, cport));
4931 	/*
4932 	 * If execution is non-synchronous,
4933 	 * a callback function will handle potential errors, translate
4934 	 * the response and will do a callback to a target driver.
4935 	 * If it was synchronous, check execution status using the same
4936 	 * framework callback.
4937 	 */
4938 	if (synch) {
4939 		SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst,
4940 		    "synchronous execution\n", NULL);
4941 		/* Calling pre-set completion routine */
4942 		(*spx->txlt_sata_pkt->satapkt_comp)(spx->txlt_sata_pkt);
4943 	}
4944 	return (TRAN_ACCEPT);
4945 
4946 bad_param:
4947 	mutex_exit(&(SATA_TXLT_CPORT_MUTEX(spx)));
4948 	*scsipkt->pkt_scbp = STATUS_CHECK;
4949 	sense = sata_arq_sense(spx);
4950 	sense->es_key = KEY_ILLEGAL_REQUEST;
4951 	sense->es_add_code = SD_SCSI_ASC_INVALID_FIELD_IN_CDB;
4952 	if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0 &&
4953 	    scsipkt->pkt_comp != NULL) {
4954 		/* scsi callback required */
4955 		if (taskq_dispatch(SATA_TXLT_TASKQ(spx),
4956 		    (task_func_t *)scsipkt->pkt_comp, (void *) scsipkt,
4957 		    TQ_SLEEP) == 0) {
4958 			/* Scheduling the callback failed */
4959 			rval = TRAN_BUSY;
4960 		}
4961 	}
4962 	return (rval);
4963 }
4964 
4965 
4966 /*
4967  * Retry identify device when command returns SATA_INCOMPLETE_DATA
4968  * after doing a firmware download.
4969  */
4970 static void
4971 sata_retry_identify_device(void *arg)
4972 {
4973 #define	DOWNLOAD_WAIT_TIME_SECS	60
4974 #define	DOWNLOAD_WAIT_INTERVAL_SECS	1
4975 	int rval;
4976 	int retry_cnt;
4977 	sata_pkt_t *sata_pkt = (sata_pkt_t *)arg;
4978 	sata_pkt_txlate_t *spx =
4979 	    (sata_pkt_txlate_t *)sata_pkt->satapkt_framework_private;
4980 	struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt;
4981 	sata_hba_inst_t *sata_hba_inst = spx->txlt_sata_hba_inst;
4982 	sata_device_t sata_device = spx->txlt_sata_pkt->satapkt_device;
4983 	sata_drive_info_t *sdinfo;
4984 
4985 	/*
4986 	 * Before returning good status, probe device.
4987 	 * Device probing will get IDENTIFY DEVICE data, if possible.
4988 	 * The assumption is that the new microcode is applied by the
4989 	 * device. It is a caller responsibility to verify this.
4990 	 */
4991 	for (retry_cnt = 0;
4992 	    retry_cnt < DOWNLOAD_WAIT_TIME_SECS / DOWNLOAD_WAIT_INTERVAL_SECS;
4993 	    retry_cnt++) {
4994 		rval = sata_probe_device(sata_hba_inst, &sata_device);
4995 
4996 		if (rval == SATA_SUCCESS) { /* Set default features */
4997 			sdinfo = sata_get_device_info(sata_hba_inst,
4998 			    &sata_device);
4999 			if (sata_initialize_device(sata_hba_inst, sdinfo) !=
5000 			    SATA_SUCCESS) {
5001 				/* retry */
5002 				(void) sata_initialize_device(sata_hba_inst,
5003 				    sdinfo);
5004 			}
5005 			if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0 &&
5006 			    scsipkt->pkt_comp != NULL)
5007 				(*scsipkt->pkt_comp)(scsipkt);
5008 			return;
5009 		} else if (rval == SATA_RETRY) {
5010 			delay(drv_usectohz(1000000 *
5011 			    DOWNLOAD_WAIT_INTERVAL_SECS));
5012 			continue;
5013 		} else	/* failed - no reason to retry */
5014 			break;
5015 	}
5016 
5017 	/*
5018 	 * Something went wrong, device probing failed.
5019 	 */
5020 	SATA_LOG_D((sata_hba_inst, CE_WARN,
5021 	    "Cannot probe device after downloading microcode\n"));
5022 
5023 	/* Reset device to force retrying the probe. */
5024 	(void) (*SATA_RESET_DPORT_FUNC(sata_hba_inst))
5025 	    (SATA_DIP(sata_hba_inst), &sata_device);
5026 
5027 	if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0 &&
5028 	    scsipkt->pkt_comp != NULL)
5029 		(*scsipkt->pkt_comp)(scsipkt);
5030 }
5031 
5032 /*
5033  * Translate completion status of download microcode command.
5034  * pkt completion_reason is checked to determine the completion status.
5035  * Do scsi callback if necessary (FLAG_NOINTR == 0)
5036  *
5037  * Note: this function may be called also for synchronously executed
5038  * command.
5039  * This function may be used only if scsi_pkt is non-NULL.
5040  */
5041 static void
5042 sata_txlt_download_mcode_cmd_completion(sata_pkt_t *sata_pkt)
5043 {
5044 	sata_pkt_txlate_t *spx =
5045 	    (sata_pkt_txlate_t *)sata_pkt->satapkt_framework_private;
5046 	struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt;
5047 	struct scsi_extended_sense *sense;
5048 	sata_drive_info_t *sdinfo;
5049 	sata_hba_inst_t *sata_hba_inst = spx->txlt_sata_hba_inst;
5050 	sata_device_t sata_device = spx->txlt_sata_pkt->satapkt_device;
5051 	int rval;
5052 
5053 	scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET |
5054 	    STATE_SENT_CMD | STATE_XFERRED_DATA | STATE_GOT_STATUS;
5055 	if (sata_pkt->satapkt_reason == SATA_PKT_COMPLETED) {
5056 		scsipkt->pkt_reason = CMD_CMPLT;
5057 
5058 		rval = sata_probe_device(sata_hba_inst, &sata_device);
5059 
5060 		if (rval == SATA_SUCCESS) { /* Set default features */
5061 			sdinfo = sata_get_device_info(sata_hba_inst,
5062 			    &sata_device);
5063 			if (sata_initialize_device(sata_hba_inst, sdinfo) !=
5064 			    SATA_SUCCESS) {
5065 				/* retry */
5066 				(void) sata_initialize_device(sata_hba_inst,
5067 				    sdinfo);
5068 			}
5069 			if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0 &&
5070 			    scsipkt->pkt_comp != NULL)
5071 				(*scsipkt->pkt_comp)(scsipkt);
5072 		} else {
5073 			(void) ddi_taskq_dispatch(
5074 			    (ddi_taskq_t *)SATA_TXLT_TASKQ(spx),
5075 			    sata_retry_identify_device,
5076 			    (void *)sata_pkt, TQ_NOSLEEP);
5077 		}
5078 
5079 
5080 	} else {
5081 		/* Something went wrong, microcode download command failed */
5082 		scsipkt->pkt_reason = CMD_INCOMPLETE;
5083 		*scsipkt->pkt_scbp = STATUS_CHECK;
5084 		sense = sata_arq_sense(spx);
5085 		switch (sata_pkt->satapkt_reason) {
5086 		case SATA_PKT_PORT_ERROR:
5087 			/*
5088 			 * We have no device data. Assume no data transfered.
5089 			 */
5090 			sense->es_key = KEY_HARDWARE_ERROR;
5091 			break;
5092 
5093 		case SATA_PKT_DEV_ERROR:
5094 			if (sata_pkt->satapkt_cmd.satacmd_status_reg &
5095 			    SATA_STATUS_ERR) {
5096 				/*
5097 				 * determine dev error reason from error
5098 				 * reg content
5099 				 */
5100 				sata_decode_device_error(spx, sense);
5101 				break;
5102 			}
5103 			/* No extended sense key - no info available */
5104 			break;
5105 
5106 		case SATA_PKT_TIMEOUT:
5107 			scsipkt->pkt_reason = CMD_TIMEOUT;
5108 			scsipkt->pkt_statistics |=
5109 			    STAT_TIMEOUT | STAT_DEV_RESET;
5110 			/* No extended sense key ? */
5111 			break;
5112 
5113 		case SATA_PKT_ABORTED:
5114 			scsipkt->pkt_reason = CMD_ABORTED;
5115 			scsipkt->pkt_statistics |= STAT_ABORTED;
5116 			/* No extended sense key ? */
5117 			break;
5118 
5119 		case SATA_PKT_RESET:
5120 			/* pkt aborted by an explicit reset from a host */
5121 			scsipkt->pkt_reason = CMD_RESET;
5122 			scsipkt->pkt_statistics |= STAT_DEV_RESET;
5123 			break;
5124 
5125 		default:
5126 			SATA_LOG_D((spx->txlt_sata_hba_inst, CE_WARN,
5127 			    "sata_txlt_nodata_cmd_completion: "
5128 			    "invalid packet completion reason %d",
5129 			    sata_pkt->satapkt_reason));
5130 			scsipkt->pkt_reason = CMD_TRAN_ERR;
5131 			break;
5132 		}
5133 
5134 		SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst,
5135 		    "scsi_pkt completion reason %x\n", scsipkt->pkt_reason);
5136 
5137 		if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0 &&
5138 		    scsipkt->pkt_comp != NULL)
5139 			/* scsi callback required */
5140 			(*scsipkt->pkt_comp)(scsipkt);
5141 	}
5142 }
5143 
5144 
5145 
5146 
5147 /*
5148  * Translate command: Synchronize Cache.
5149  * Translates into Flush Cache command for SATA hard disks.
5150  *
5151  * Returns TRAN_ACCEPT or code returned by sata_hba_start() and
5152  * appropriate values in scsi_pkt fields.
5153  */
5154 static 	int
5155 sata_txlt_synchronize_cache(sata_pkt_txlate_t *spx)
5156 {
5157 	sata_cmd_t *scmd = &spx->txlt_sata_pkt->satapkt_cmd;
5158 	sata_hba_inst_t *shi = SATA_TXLT_HBA_INST(spx);
5159 	int cport = SATA_TXLT_CPORT(spx);
5160 	int rval;
5161 	int synch;
5162 
5163 	mutex_enter(&(SATA_TXLT_CPORT_MUTEX(spx)));
5164 
5165 	if (((rval = sata_txlt_generic_pkt_info(spx)) != TRAN_ACCEPT) ||
5166 	    (spx->txlt_scsi_pkt->pkt_reason == CMD_DEV_GONE)) {
5167 		mutex_exit(&(SATA_TXLT_CPORT_MUTEX(spx)));
5168 		return (rval);
5169 	}
5170 
5171 	scmd->satacmd_addr_type = 0;
5172 	scmd->satacmd_cmd_reg = SATAC_FLUSH_CACHE;
5173 	scmd->satacmd_device_reg = 0;
5174 	scmd->satacmd_sec_count_lsb = 0;
5175 	scmd->satacmd_lba_low_lsb = 0;
5176 	scmd->satacmd_lba_mid_lsb = 0;
5177 	scmd->satacmd_lba_high_lsb = 0;
5178 	scmd->satacmd_features_reg = 0;
5179 	scmd->satacmd_status_reg = 0;
5180 	scmd->satacmd_error_reg = 0;
5181 
5182 	SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst,
5183 	    "sata_txlt_synchronize_cache\n", NULL);
5184 
5185 	if (!(spx->txlt_sata_pkt->satapkt_op_mode & SATA_OPMODE_SYNCH)) {
5186 		/* Need to set-up a callback function */
5187 		spx->txlt_sata_pkt->satapkt_comp =
5188 		    sata_txlt_nodata_cmd_completion;
5189 		synch = FALSE;
5190 	} else
5191 		synch = TRUE;
5192 
5193 	/* Transfer command to HBA */
5194 	if (sata_hba_start(spx, &rval) != 0) {
5195 		/* Pkt not accepted for execution */
5196 		mutex_exit(&SATA_CPORT_MUTEX(shi, cport));
5197 		return (rval);
5198 	}
5199 	mutex_exit(&SATA_CPORT_MUTEX(shi, cport));
5200 
5201 	/*
5202 	 * If execution non-synchronous, it had to be completed
5203 	 * a callback function will handle potential errors, translate
5204 	 * the response and will do a callback to a target driver.
5205 	 * If it was synchronous, check status, using the same
5206 	 * framework callback.
5207 	 */
5208 	if (synch) {
5209 		SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst,
5210 		    "synchronous execution status %x\n",
5211 		    spx->txlt_sata_pkt->satapkt_reason);
5212 		sata_txlt_nodata_cmd_completion(spx->txlt_sata_pkt);
5213 	}
5214 	return (TRAN_ACCEPT);
5215 }
5216 
5217 
5218 /*
5219  * Send pkt to SATA HBA driver
5220  *
5221  * This function may be called only if the operation is requested by scsi_pkt,
5222  * i.e. scsi_pkt is not NULL.
5223  *
5224  * This function has to be called with cport mutex held. It does release
5225  * the mutex when it calls HBA driver sata_tran_start function and
5226  * re-acquires it afterwards.
5227  *
5228  * If return value is 0, pkt was accepted, -1 otherwise
5229  * rval is set to appropriate sata_scsi_start return value.
5230  *
5231  * Note 1:If HBA driver returns value other than TRAN_ACCEPT, it should not
5232  * have called the sata_pkt callback function for this packet.
5233  *
5234  * The scsi callback has to be performed by the caller of this routine.
5235  *
5236  * Note 2: No port multiplier support for now.
5237  */
5238 static int
5239 sata_hba_start(sata_pkt_txlate_t *spx, int *rval)
5240 {
5241 	int stat, cport;
5242 	sata_hba_inst_t *sata_hba_inst = spx->txlt_sata_hba_inst;
5243 	sata_drive_info_t *sdinfo;
5244 	sata_device_t *sata_device;
5245 	uint8_t cmd;
5246 	struct sata_cmd_flags cmd_flags;
5247 
5248 	ASSERT(spx->txlt_sata_pkt != NULL);
5249 
5250 	cport = SATA_TXLT_CPORT(spx);
5251 	ASSERT(mutex_owned(&SATA_CPORT_MUTEX(sata_hba_inst, cport)));
5252 
5253 	sdinfo = sata_get_device_info(sata_hba_inst,
5254 	    &spx->txlt_sata_pkt->satapkt_device);
5255 	ASSERT(sdinfo != NULL);
5256 
5257 	/* Clear device reset state? */
5258 	if (sdinfo->satadrv_event_flags & SATA_EVNT_CLEAR_DEVICE_RESET) {
5259 		spx->txlt_sata_pkt->satapkt_cmd.satacmd_flags.
5260 		    sata_clear_dev_reset = B_TRUE;
5261 		sdinfo->satadrv_event_flags &= ~SATA_EVNT_CLEAR_DEVICE_RESET;
5262 		SATADBG1(SATA_DBG_EVENTS, sata_hba_inst,
5263 		    "sata_hba_start: clearing device reset state\n", NULL);
5264 	}
5265 	cmd = spx->txlt_sata_pkt->satapkt_cmd.satacmd_cmd_reg;
5266 	cmd_flags = spx->txlt_sata_pkt->satapkt_cmd.satacmd_flags;
5267 	sata_device = &spx->txlt_sata_pkt->satapkt_device;
5268 
5269 	mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, cport)));
5270 
5271 	SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst,
5272 	    "Sata cmd 0x%2x\n", cmd);
5273 
5274 	stat = (*SATA_START_FUNC(sata_hba_inst))(SATA_DIP(sata_hba_inst),
5275 	    spx->txlt_sata_pkt);
5276 
5277 	mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, cport)));
5278 	sdinfo = sata_get_device_info(sata_hba_inst, sata_device);
5279 	/*
5280 	 * If sata pkt was accepted and executed in asynchronous mode, i.e.
5281 	 * with the sata callback, the sata_pkt could be already destroyed
5282 	 * by the time we check ther return status from the hba_start()
5283 	 * function, because sata_scsi_destroy_pkt() could have been already
5284 	 * called (perhaps in the interrupt context). So, in such case, there
5285 	 * should be no references to it. In other cases, sata_pkt still
5286 	 * exists.
5287 	 */
5288 	switch (stat) {
5289 	case SATA_TRAN_ACCEPTED:
5290 		/*
5291 		 * pkt accepted for execution.
5292 		 * If it was executed synchronously, it is already completed
5293 		 * and pkt completion_reason indicates completion status.
5294 		 */
5295 		*rval = TRAN_ACCEPT;
5296 		return (0);
5297 
5298 	case SATA_TRAN_QUEUE_FULL:
5299 		/*
5300 		 * Controller detected queue full condition.
5301 		 */
5302 		SATADBG1(SATA_DBG_HBA_IF, sata_hba_inst,
5303 		    "sata_hba_start: queue full\n", NULL);
5304 
5305 		spx->txlt_scsi_pkt->pkt_reason = CMD_INCOMPLETE;
5306 		*spx->txlt_scsi_pkt->pkt_scbp = STATUS_QFULL;
5307 
5308 		*rval = TRAN_BUSY;
5309 		break;
5310 
5311 	case SATA_TRAN_PORT_ERROR:
5312 		/*
5313 		 * Communication/link with device or general port error
5314 		 * detected before pkt execution begun.
5315 		 */
5316 		if (spx->txlt_sata_pkt->satapkt_device.satadev_addr.qual ==
5317 		    SATA_ADDR_CPORT ||
5318 		    spx->txlt_sata_pkt->satapkt_device.satadev_addr.qual ==
5319 		    SATA_ADDR_DCPORT)
5320 			sata_log(sata_hba_inst, CE_CONT,
5321 			    "SATA port %d error",
5322 			    sata_device->satadev_addr.cport);
5323 		else
5324 			sata_log(sata_hba_inst, CE_CONT,
5325 			    "SATA port %d pmport %d error\n",
5326 			    sata_device->satadev_addr.cport,
5327 			    sata_device->satadev_addr.pmport);
5328 
5329 		/*
5330 		 * Update the port/device structure.
5331 		 * sata_pkt should be still valid. Since port error is
5332 		 * returned, sata_device content should reflect port
5333 		 * state - it means, that sata address have been changed,
5334 		 * because original packet's sata address refered to a device
5335 		 * attached to some port.
5336 		 */
5337 		sata_update_port_info(sata_hba_inst, sata_device);
5338 		spx->txlt_scsi_pkt->pkt_reason = CMD_TRAN_ERR;
5339 		*rval = TRAN_FATAL_ERROR;
5340 		break;
5341 
5342 	case SATA_TRAN_CMD_UNSUPPORTED:
5343 		/*
5344 		 * Command rejected by HBA as unsupported. It was HBA driver
5345 		 * that rejected the command, command was not sent to
5346 		 * an attached device.
5347 		 */
5348 		if ((sdinfo != NULL) &&
5349 		    (sdinfo->satadrv_state & SATA_DSTATE_RESET))
5350 			SATADBG1(SATA_DBG_EVENTS, sata_hba_inst,
5351 			    "sat_hba_start: cmd 0x%2x rejected "
5352 			    "with SATA_TRAN_CMD_UNSUPPORTED status\n", cmd);
5353 
5354 		mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, cport)));
5355 		(void) sata_txlt_invalid_command(spx);
5356 		mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, cport)));
5357 
5358 		*rval = TRAN_ACCEPT;
5359 		break;
5360 
5361 	case SATA_TRAN_BUSY:
5362 		/*
5363 		 * Command rejected by HBA because other operation prevents
5364 		 * accepting the packet, or device is in RESET condition.
5365 		 */
5366 		if (sdinfo != NULL) {
5367 			sdinfo->satadrv_state =
5368 			    spx->txlt_sata_pkt->satapkt_device.satadev_state;
5369 
5370 			if (sdinfo->satadrv_state & SATA_DSTATE_RESET) {
5371 				SATADBG1(SATA_DBG_EVENTS, sata_hba_inst,
5372 				    "sata_hba_start: cmd 0x%2x rejected "
5373 				    "because of device reset condition\n",
5374 				    cmd);
5375 			} else {
5376 				SATADBG1(SATA_DBG_EVENTS, sata_hba_inst,
5377 				    "sata_hba_start: cmd 0x%2x rejected "
5378 				    "with SATA_TRAN_BUSY status\n",
5379 				    cmd);
5380 			}
5381 		}
5382 		spx->txlt_scsi_pkt->pkt_reason = CMD_INCOMPLETE;
5383 		*rval = TRAN_BUSY;
5384 		break;
5385 
5386 	default:
5387 		/* Unrecognized HBA response */
5388 		SATA_LOG_D((sata_hba_inst, CE_WARN,
5389 		    "sata_hba_start: unrecognized HBA response "
5390 		    "to cmd : 0x%2x resp 0x%x", cmd, rval));
5391 		spx->txlt_scsi_pkt->pkt_reason = CMD_TRAN_ERR;
5392 		*rval = TRAN_FATAL_ERROR;
5393 		break;
5394 	}
5395 
5396 	/*
5397 	 * If we got here, the packet was rejected.
5398 	 * Check if we need to remember reset state clearing request
5399 	 */
5400 	if (cmd_flags.sata_clear_dev_reset) {
5401 		/*
5402 		 * Check if device is still configured - it may have
5403 		 * disapeared from the configuration
5404 		 */
5405 		sdinfo = sata_get_device_info(sata_hba_inst, sata_device);
5406 		if (sdinfo != NULL) {
5407 			/*
5408 			 * Restore the flag that requests clearing of
5409 			 * the device reset state,
5410 			 * so the next sata packet may carry it to HBA.
5411 			 */
5412 			sdinfo->satadrv_event_flags |=
5413 			    SATA_EVNT_CLEAR_DEVICE_RESET;
5414 		}
5415 	}
5416 	return (-1);
5417 }
5418 
5419 /*
5420  * Scsi response setup for invalid LBA
5421  *
5422  * Returns TRAN_ACCEPT and appropriate values in scsi_pkt fields.
5423  */
5424 static int
5425 sata_txlt_lba_out_of_range(sata_pkt_txlate_t *spx)
5426 {
5427 	struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt;
5428 	struct scsi_extended_sense *sense;
5429 
5430 	scsipkt->pkt_reason = CMD_CMPLT;
5431 	scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET |
5432 	    STATE_SENT_CMD | STATE_GOT_STATUS;
5433 	*scsipkt->pkt_scbp = STATUS_CHECK;
5434 
5435 	*scsipkt->pkt_scbp = STATUS_CHECK;
5436 	sense = sata_arq_sense(spx);
5437 	sense->es_key = KEY_ILLEGAL_REQUEST;
5438 	sense->es_add_code = SD_SCSI_ASC_LBA_OUT_OF_RANGE;
5439 
5440 	SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst,
5441 	    "Scsi_pkt completion reason %x\n", scsipkt->pkt_reason);
5442 
5443 	if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0 &&
5444 	    scsipkt->pkt_comp != NULL)
5445 		/* scsi callback required */
5446 		if (taskq_dispatch(SATA_TXLT_TASKQ(spx),
5447 		    (task_func_t *)scsipkt->pkt_comp, (void *) scsipkt,
5448 		    TQ_SLEEP) == NULL)
5449 			/* Scheduling the callback failed */
5450 			return (TRAN_BUSY);
5451 	return (TRAN_ACCEPT);
5452 }
5453 
5454 
5455 /*
5456  * Analyze device status and error registers and translate them into
5457  * appropriate scsi sense codes.
5458  * NOTE: non-packet commands only for now
5459  */
5460 static void
5461 sata_decode_device_error(sata_pkt_txlate_t *spx,
5462     struct scsi_extended_sense *sense)
5463 {
5464 	uint8_t err_reg = spx->txlt_sata_pkt->satapkt_cmd.satacmd_error_reg;
5465 
5466 	ASSERT(sense != NULL);
5467 	ASSERT(spx->txlt_sata_pkt->satapkt_cmd.satacmd_status_reg &
5468 	    SATA_STATUS_ERR);
5469 
5470 
5471 	if (err_reg & SATA_ERROR_ICRC) {
5472 		sense->es_key = KEY_ABORTED_COMMAND;
5473 		sense->es_add_code = 0x08; /* Communication failure */
5474 		return;
5475 	}
5476 
5477 	if (err_reg & SATA_ERROR_UNC) {
5478 		sense->es_key = KEY_MEDIUM_ERROR;
5479 		/* Information bytes (LBA) need to be set by a caller */
5480 		return;
5481 	}
5482 
5483 	/* ADD HERE: MC error bit handling for ATAPI CD/DVD */
5484 	if (err_reg & (SATA_ERROR_MCR | SATA_ERROR_NM)) {
5485 		sense->es_key = KEY_UNIT_ATTENTION;
5486 		sense->es_add_code = 0x3a; /* No media present */
5487 		return;
5488 	}
5489 
5490 	if (err_reg & SATA_ERROR_IDNF) {
5491 		if (err_reg & SATA_ERROR_ABORT) {
5492 			sense->es_key = KEY_ABORTED_COMMAND;
5493 		} else {
5494 			sense->es_key = KEY_ILLEGAL_REQUEST;
5495 			sense->es_add_code = 0x21; /* LBA out of range */
5496 		}
5497 		return;
5498 	}
5499 
5500 	if (err_reg & SATA_ERROR_ABORT) {
5501 		ASSERT(spx->txlt_sata_pkt != NULL);
5502 		sense->es_key = KEY_ABORTED_COMMAND;
5503 		return;
5504 	}
5505 }
5506 
5507 /*
5508  * Extract error LBA from sata_pkt.satapkt_cmd register fields
5509  */
5510 static void
5511 sata_extract_error_lba(sata_pkt_txlate_t *spx, uint64_t *lba)
5512 {
5513 	sata_cmd_t *sata_cmd = &spx->txlt_sata_pkt->satapkt_cmd;
5514 
5515 	*lba = 0;
5516 	if (sata_cmd->satacmd_addr_type == ATA_ADDR_LBA48) {
5517 		*lba = sata_cmd->satacmd_lba_high_msb;
5518 		*lba = (*lba << 8) | sata_cmd->satacmd_lba_mid_msb;
5519 		*lba = (*lba << 8) | sata_cmd->satacmd_lba_low_msb;
5520 	} else if (sata_cmd->satacmd_addr_type == ATA_ADDR_LBA28) {
5521 		*lba = sata_cmd->satacmd_device_reg & 0xf;
5522 	}
5523 	*lba = (*lba << 8) | sata_cmd->satacmd_lba_high_lsb;
5524 	*lba = (*lba << 8) | sata_cmd->satacmd_lba_mid_lsb;
5525 	*lba = (*lba << 8) | sata_cmd->satacmd_lba_low_lsb;
5526 }
5527 
5528 /*
5529  * This is fixed sense format - if LBA exceeds the info field size,
5530  * no valid info will be returned (valid bit in extended sense will
5531  * be set to 0).
5532  */
5533 static struct scsi_extended_sense *
5534 sata_arq_sense(sata_pkt_txlate_t *spx)
5535 {
5536 	struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt;
5537 	struct scsi_arq_status *arqs;
5538 	struct scsi_extended_sense *sense;
5539 
5540 	/* Fill ARQ sense data */
5541 	scsipkt->pkt_state |= STATE_ARQ_DONE;
5542 	arqs = (struct scsi_arq_status *)scsipkt->pkt_scbp;
5543 	*(uchar_t *)&arqs->sts_status = STATUS_CHECK;
5544 	*(uchar_t *)&arqs->sts_rqpkt_status = STATUS_GOOD;
5545 	arqs->sts_rqpkt_reason = CMD_CMPLT;
5546 	arqs->sts_rqpkt_state = STATE_GOT_BUS | STATE_GOT_TARGET |
5547 	    STATE_XFERRED_DATA | STATE_SENT_CMD | STATE_GOT_STATUS;
5548 	arqs->sts_rqpkt_resid = 0;
5549 	sense = &arqs->sts_sensedata;
5550 	bzero(sense, sizeof (struct scsi_extended_sense));
5551 	sata_fixed_sense_data_preset(sense);
5552 	return (sense);
5553 }
5554 
5555 
5556 /*
5557  * Emulated SATA Read/Write command completion for zero-length requests.
5558  * This request always succedes, so in synchronous mode it always returns
5559  * TRAN_ACCEPT, and in non-synchronous mode it may return TRAN_BUSY if the
5560  * callback cannot be scheduled.
5561  */
5562 static int
5563 sata_emul_rw_completion(sata_pkt_txlate_t *spx)
5564 {
5565 	struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt;
5566 
5567 	scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET |
5568 	    STATE_SENT_CMD | STATE_GOT_STATUS;
5569 	scsipkt->pkt_reason = CMD_CMPLT;
5570 	*scsipkt->pkt_scbp = STATUS_GOOD;
5571 	if (!(spx->txlt_sata_pkt->satapkt_op_mode & SATA_OPMODE_SYNCH)) {
5572 		/* scsi callback required - have to schedule it */
5573 		if (taskq_dispatch(SATA_TXLT_TASKQ(spx),
5574 		    (task_func_t *)scsipkt->pkt_comp,
5575 		    (void *)scsipkt, TQ_SLEEP) == NULL)
5576 			/* Scheduling the callback failed */
5577 			return (TRAN_BUSY);
5578 	}
5579 	return (TRAN_ACCEPT);
5580 }
5581 
5582 
5583 /*
5584  * Translate completion status of SATA read/write commands into scsi response.
5585  * pkt completion_reason is checked to determine the completion status.
5586  * Do scsi callback if necessary.
5587  *
5588  * Note: this function may be called also for synchronously executed
5589  * commands.
5590  * This function may be used only if scsi_pkt is non-NULL.
5591  */
5592 static void
5593 sata_txlt_rw_completion(sata_pkt_t *sata_pkt)
5594 {
5595 	sata_pkt_txlate_t *spx =
5596 	    (sata_pkt_txlate_t *)sata_pkt->satapkt_framework_private;
5597 	sata_cmd_t *scmd = &sata_pkt->satapkt_cmd;
5598 	struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt;
5599 	struct scsi_extended_sense *sense;
5600 	uint64_t lba;
5601 	struct buf *bp;
5602 	int rval;
5603 	if (sata_pkt->satapkt_reason == SATA_PKT_COMPLETED) {
5604 		/* Normal completion */
5605 		scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET |
5606 		    STATE_SENT_CMD | STATE_XFERRED_DATA | STATE_GOT_STATUS;
5607 		scsipkt->pkt_reason = CMD_CMPLT;
5608 		*scsipkt->pkt_scbp = STATUS_GOOD;
5609 		if (spx->txlt_tmp_buf != NULL) {
5610 			/* Temporary buffer was used */
5611 			bp = spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp;
5612 			if (bp->b_flags & B_READ) {
5613 				rval = ddi_dma_sync(
5614 				    spx->txlt_buf_dma_handle, 0, 0,
5615 				    DDI_DMA_SYNC_FORCPU);
5616 				ASSERT(rval == DDI_SUCCESS);
5617 				bcopy(spx->txlt_tmp_buf, bp->b_un.b_addr,
5618 				    bp->b_bcount);
5619 			}
5620 		}
5621 	} else {
5622 		/*
5623 		 * Something went wrong - analyze return
5624 		 */
5625 		scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET |
5626 		    STATE_SENT_CMD | STATE_GOT_STATUS;
5627 		scsipkt->pkt_reason = CMD_INCOMPLETE;
5628 		*scsipkt->pkt_scbp = STATUS_CHECK;
5629 		sense = sata_arq_sense(spx);
5630 		ASSERT(sense != NULL);
5631 
5632 		/*
5633 		 * SATA_PKT_DEV_ERROR is the only case where we may be able to
5634 		 * extract from device registers the failing LBA.
5635 		 */
5636 		if (sata_pkt->satapkt_reason == SATA_PKT_DEV_ERROR) {
5637 			if ((scmd->satacmd_addr_type == ATA_ADDR_LBA48) &&
5638 			    (scmd->satacmd_lba_mid_msb != 0 ||
5639 			    scmd->satacmd_lba_high_msb != 0)) {
5640 				/*
5641 				 * We have problem reporting this cmd LBA
5642 				 * in fixed sense data format, because of
5643 				 * the size of the scsi LBA fields.
5644 				 */
5645 				sense->es_valid = 0;
5646 			} else {
5647 				sata_extract_error_lba(spx, &lba);
5648 				sense->es_info_1 = (lba & 0xFF000000) >> 24;
5649 				sense->es_info_2 = (lba & 0xFF0000) >> 16;
5650 				sense->es_info_3 = (lba & 0xFF00) >> 8;
5651 				sense->es_info_4 = lba & 0xFF;
5652 			}
5653 		} else {
5654 			/* Invalid extended sense info */
5655 			sense->es_valid = 0;
5656 		}
5657 
5658 		switch (sata_pkt->satapkt_reason) {
5659 		case SATA_PKT_PORT_ERROR:
5660 			/* We may want to handle DEV GONE state as well */
5661 			/*
5662 			 * We have no device data. Assume no data transfered.
5663 			 */
5664 			sense->es_key = KEY_HARDWARE_ERROR;
5665 			break;
5666 
5667 		case SATA_PKT_DEV_ERROR:
5668 			if (sata_pkt->satapkt_cmd.satacmd_status_reg &
5669 			    SATA_STATUS_ERR) {
5670 				/*
5671 				 * determine dev error reason from error
5672 				 * reg content
5673 				 */
5674 				sata_decode_device_error(spx, sense);
5675 				if (sense->es_key == KEY_MEDIUM_ERROR) {
5676 					switch (scmd->satacmd_cmd_reg) {
5677 					case SATAC_READ_DMA:
5678 					case SATAC_READ_DMA_EXT:
5679 					case SATAC_READ_DMA_QUEUED:
5680 					case SATAC_READ_DMA_QUEUED_EXT:
5681 					case SATAC_READ_FPDMA_QUEUED:
5682 						/* Unrecovered read error */
5683 						sense->es_add_code =
5684 						    SD_SCSI_ASC_UNREC_READ_ERR;
5685 						break;
5686 					case SATAC_WRITE_DMA:
5687 					case SATAC_WRITE_DMA_EXT:
5688 					case SATAC_WRITE_DMA_QUEUED:
5689 					case SATAC_WRITE_DMA_QUEUED_EXT:
5690 					case SATAC_WRITE_FPDMA_QUEUED:
5691 						/* Write error */
5692 						sense->es_add_code =
5693 						    SD_SCSI_ASC_WRITE_ERR;
5694 						break;
5695 					default:
5696 						/* Internal error */
5697 						SATA_LOG_D((
5698 						    spx->txlt_sata_hba_inst,
5699 						    CE_WARN,
5700 						    "sata_txlt_rw_completion :"
5701 						    "internal error - invalid "
5702 						    "command 0x%2x",
5703 						    scmd->satacmd_cmd_reg));
5704 						break;
5705 					}
5706 				}
5707 				break;
5708 			}
5709 			/* No extended sense key - no info available */
5710 			scsipkt->pkt_reason = CMD_INCOMPLETE;
5711 			break;
5712 
5713 		case SATA_PKT_TIMEOUT:
5714 			scsipkt->pkt_reason = CMD_TIMEOUT;
5715 			scsipkt->pkt_statistics |=
5716 			    STAT_TIMEOUT | STAT_DEV_RESET;
5717 			sense->es_key = KEY_ABORTED_COMMAND;
5718 			break;
5719 
5720 		case SATA_PKT_ABORTED:
5721 			scsipkt->pkt_reason = CMD_ABORTED;
5722 			scsipkt->pkt_statistics |= STAT_ABORTED;
5723 			sense->es_key = KEY_ABORTED_COMMAND;
5724 			break;
5725 
5726 		case SATA_PKT_RESET:
5727 			scsipkt->pkt_reason = CMD_RESET;
5728 			scsipkt->pkt_statistics |= STAT_DEV_RESET;
5729 			sense->es_key = KEY_ABORTED_COMMAND;
5730 			break;
5731 
5732 		default:
5733 			SATA_LOG_D((spx->txlt_sata_hba_inst, CE_WARN,
5734 			    "sata_txlt_rw_completion: "
5735 			    "invalid packet completion reason"));
5736 			scsipkt->pkt_reason = CMD_TRAN_ERR;
5737 			break;
5738 		}
5739 	}
5740 	SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst,
5741 	    "Scsi_pkt completion reason %x\n", scsipkt->pkt_reason);
5742 
5743 	if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0 &&
5744 	    scsipkt->pkt_comp != NULL)
5745 		/* scsi callback required */
5746 		(*scsipkt->pkt_comp)(scsipkt);
5747 }
5748 
5749 
5750 /*
5751  * Translate completion status of non-data commands (i.e. commands returning
5752  * no data).
5753  * pkt completion_reason is checked to determine the completion status.
5754  * Do scsi callback if necessary (FLAG_NOINTR == 0)
5755  *
5756  * Note: this function may be called also for synchronously executed
5757  * commands.
5758  * This function may be used only if scsi_pkt is non-NULL.
5759  */
5760 
5761 static 	void
5762 sata_txlt_nodata_cmd_completion(sata_pkt_t *sata_pkt)
5763 {
5764 	sata_pkt_txlate_t *spx =
5765 	    (sata_pkt_txlate_t *)sata_pkt->satapkt_framework_private;
5766 	struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt;
5767 	struct scsi_extended_sense *sense;
5768 
5769 	scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET |
5770 	    STATE_SENT_CMD | STATE_GOT_STATUS;
5771 	if (sata_pkt->satapkt_reason == SATA_PKT_COMPLETED) {
5772 		/* Normal completion */
5773 		scsipkt->pkt_reason = CMD_CMPLT;
5774 		*scsipkt->pkt_scbp = STATUS_GOOD;
5775 	} else {
5776 		/* Something went wrong */
5777 		scsipkt->pkt_reason = CMD_INCOMPLETE;
5778 		*scsipkt->pkt_scbp = STATUS_CHECK;
5779 		sense = sata_arq_sense(spx);
5780 		switch (sata_pkt->satapkt_reason) {
5781 		case SATA_PKT_PORT_ERROR:
5782 			/*
5783 			 * We have no device data. Assume no data transfered.
5784 			 */
5785 			sense->es_key = KEY_HARDWARE_ERROR;
5786 			break;
5787 
5788 		case SATA_PKT_DEV_ERROR:
5789 			if (sata_pkt->satapkt_cmd.satacmd_status_reg &
5790 			    SATA_STATUS_ERR) {
5791 				/*
5792 				 * determine dev error reason from error
5793 				 * reg content
5794 				 */
5795 				sata_decode_device_error(spx, sense);
5796 				break;
5797 			}
5798 			/* No extended sense key - no info available */
5799 			break;
5800 
5801 		case SATA_PKT_TIMEOUT:
5802 			scsipkt->pkt_reason = CMD_TIMEOUT;
5803 			scsipkt->pkt_statistics |=
5804 			    STAT_TIMEOUT | STAT_DEV_RESET;
5805 			/* No extended sense key ? */
5806 			break;
5807 
5808 		case SATA_PKT_ABORTED:
5809 			scsipkt->pkt_reason = CMD_ABORTED;
5810 			scsipkt->pkt_statistics |= STAT_ABORTED;
5811 			/* No extended sense key ? */
5812 			break;
5813 
5814 		case SATA_PKT_RESET:
5815 			/* pkt aborted by an explicit reset from a host */
5816 			scsipkt->pkt_reason = CMD_RESET;
5817 			scsipkt->pkt_statistics |= STAT_DEV_RESET;
5818 			break;
5819 
5820 		default:
5821 			SATA_LOG_D((spx->txlt_sata_hba_inst, CE_WARN,
5822 			    "sata_txlt_nodata_cmd_completion: "
5823 			    "invalid packet completion reason %d",
5824 			    sata_pkt->satapkt_reason));
5825 			scsipkt->pkt_reason = CMD_TRAN_ERR;
5826 			break;
5827 		}
5828 
5829 	}
5830 	SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst,
5831 	    "Scsi_pkt completion reason %x\n", scsipkt->pkt_reason);
5832 
5833 	if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0 &&
5834 	    scsipkt->pkt_comp != NULL)
5835 		/* scsi callback required */
5836 		(*scsipkt->pkt_comp)(scsipkt);
5837 }
5838 
5839 
5840 /*
5841  * Build Mode sense R/W recovery page
5842  * NOT IMPLEMENTED
5843  */
5844 
5845 static int
5846 sata_build_msense_page_1(sata_drive_info_t *sdinfo, int pcntrl, uint8_t *buf)
5847 {
5848 #ifndef __lock_lint
5849 	_NOTE(ARGUNUSED(sdinfo))
5850 	_NOTE(ARGUNUSED(pcntrl))
5851 	_NOTE(ARGUNUSED(buf))
5852 #endif
5853 	return (0);
5854 }
5855 
5856 /*
5857  * Build Mode sense caching page  -  scsi-3 implementation.
5858  * Page length distinguishes previous format from scsi-3 format.
5859  * buf must have space for 0x12 bytes.
5860  * Only DRA (disable read ahead ) and WCE (write cache enable) are changeable.
5861  *
5862  */
5863 static int
5864 sata_build_msense_page_8(sata_drive_info_t *sdinfo, int pcntrl, uint8_t *buf)
5865 {
5866 	struct mode_cache_scsi3 *page = (struct mode_cache_scsi3 *)buf;
5867 	sata_id_t *sata_id = &sdinfo->satadrv_id;
5868 
5869 	/*
5870 	 * Most of the fields are set to 0, being not supported and/or disabled
5871 	 */
5872 	bzero(buf, PAGELENGTH_DAD_MODE_CACHE_SCSI3);
5873 
5874 	/* Saved paramters not supported */
5875 	if (pcntrl == 3)
5876 		return (0);
5877 	if (pcntrl == 0 || pcntrl == 2) {
5878 		/*
5879 		 * For now treat current and default parameters as same
5880 		 * That may have to change, if target driver will complain
5881 		 */
5882 		page->mode_page.code = MODEPAGE_CACHING;	/* PS = 0 */
5883 		page->mode_page.length = PAGELENGTH_DAD_MODE_CACHE_SCSI3;
5884 
5885 		if ((sata_id->ai_cmdset82 & SATA_LOOK_AHEAD) &&
5886 		    !(sata_id->ai_features85 & SATA_LOOK_AHEAD)) {
5887 			page->dra = 1;		/* Read Ahead disabled */
5888 			page->rcd = 1;		/* Read Cache disabled */
5889 		}
5890 		if ((sata_id->ai_cmdset82 & SATA_WRITE_CACHE) &&
5891 		    (sata_id->ai_features85 & SATA_WRITE_CACHE))
5892 			page->wce = 1;		/* Write Cache enabled */
5893 	} else {
5894 		/* Changeable parameters */
5895 		page->mode_page.code = MODEPAGE_CACHING;
5896 		page->mode_page.length = PAGELENGTH_DAD_MODE_CACHE_SCSI3;
5897 		if (sata_id->ai_cmdset82 & SATA_LOOK_AHEAD) {
5898 			page->dra = 1;
5899 			page->rcd = 1;
5900 		}
5901 		if (sata_id->ai_cmdset82 & SATA_WRITE_CACHE)
5902 			page->wce = 1;
5903 	}
5904 	return (PAGELENGTH_DAD_MODE_CACHE_SCSI3 +
5905 	    sizeof (struct mode_page));
5906 }
5907 
5908 /*
5909  * Build Mode sense exception cntrl page
5910  */
5911 static int
5912 sata_build_msense_page_1c(sata_drive_info_t *sdinfo, int pcntrl, uint8_t *buf)
5913 {
5914 	struct mode_info_excpt_page *page = (struct mode_info_excpt_page *)buf;
5915 	sata_id_t *sata_id = &sdinfo->satadrv_id;
5916 
5917 	/*
5918 	 * Most of the fields are set to 0, being not supported and/or disabled
5919 	 */
5920 	bzero(buf, PAGELENGTH_INFO_EXCPT);
5921 
5922 	page->mode_page.code = MODEPAGE_INFO_EXCPT;
5923 	page->mode_page.length = PAGELENGTH_INFO_EXCPT;
5924 
5925 	/* Indicate that this is page is saveable */
5926 	page->mode_page.ps = 1;
5927 
5928 	/*
5929 	 * We will return the same data for default, current and saved page.
5930 	 * The only changeable bit is dexcpt and that bit is required
5931 	 * by the ATA specification to be preserved across power cycles.
5932 	 */
5933 	if (pcntrl != 1) {
5934 		page->dexcpt = !(sata_id->ai_features85 & SATA_SMART_SUPPORTED);
5935 		page->mrie = MRIE_ONLY_ON_REQUEST;
5936 	}
5937 	else
5938 		page->dexcpt = 1;	/* Only changeable parameter */
5939 
5940 	return (PAGELENGTH_INFO_EXCPT + sizeof (struct mode_info_excpt_page));
5941 }
5942 
5943 
5944 static int
5945 sata_build_msense_page_30(sata_drive_info_t *sdinfo, int pcntrl, uint8_t *buf)
5946 {
5947 	struct mode_acoustic_management *page =
5948 	    (struct mode_acoustic_management *)buf;
5949 	sata_id_t *sata_id = &sdinfo->satadrv_id;
5950 
5951 	/*
5952 	 * Most of the fields are set to 0, being not supported and/or disabled
5953 	 */
5954 	bzero(buf, PAGELENGTH_DAD_MODE_ACOUSTIC_MANAGEMENT);
5955 
5956 	switch (pcntrl) {
5957 	case P_CNTRL_DEFAULT:
5958 		/*  default paramters not supported */
5959 		return (0);
5960 
5961 	case P_CNTRL_CURRENT:
5962 	case P_CNTRL_SAVED:
5963 		/* Saved and current are supported and are identical */
5964 		page->mode_page.code = MODEPAGE_ACOUSTIC_MANAG;
5965 		page->mode_page.length =
5966 		    PAGELENGTH_DAD_MODE_ACOUSTIC_MANAGEMENT;
5967 		page->mode_page.ps = 1;
5968 
5969 		/* Word 83 indicates if feature is supported */
5970 		/* If feature is not supported */
5971 		if (!(sata_id->ai_cmdset83 & SATA_ACOUSTIC_MGMT)) {
5972 			page->acoustic_manag_enable =
5973 			    ACOUSTIC_DISABLED;
5974 		} else {
5975 			page->acoustic_manag_enable =
5976 			    ((sata_id->ai_features86 & SATA_ACOUSTIC_MGMT)
5977 			    != 0);
5978 			/* Word 94 inidicates the value */
5979 #ifdef	_LITTLE_ENDIAN
5980 			page->acoustic_manag_level =
5981 			    (uchar_t)sata_id->ai_acoustic;
5982 			page->vendor_recommended_value =
5983 			    sata_id->ai_acoustic >> 8;
5984 #else
5985 			page->acoustic_manag_level =
5986 			    sata_id->ai_acoustic >> 8;
5987 			page->vendor_recommended_value =
5988 			    (uchar_t)sata_id->ai_acoustic;
5989 #endif
5990 		}
5991 		break;
5992 
5993 	case P_CNTRL_CHANGEABLE:
5994 		page->mode_page.code = MODEPAGE_ACOUSTIC_MANAG;
5995 		page->mode_page.length =
5996 		    PAGELENGTH_DAD_MODE_ACOUSTIC_MANAGEMENT;
5997 		page->mode_page.ps = 1;
5998 
5999 		/* Word 83 indicates if the feature is supported */
6000 		if (sata_id->ai_cmdset83 & SATA_ACOUSTIC_MGMT) {
6001 			page->acoustic_manag_enable =
6002 			    ACOUSTIC_ENABLED;
6003 			page->acoustic_manag_level = 0xff;
6004 		}
6005 		break;
6006 	}
6007 	return (PAGELENGTH_DAD_MODE_ACOUSTIC_MANAGEMENT +
6008 	    sizeof (struct mode_page));
6009 }
6010 
6011 
6012 /*
6013  * Build Mode sense power condition page
6014  * NOT IMPLEMENTED.
6015  */
6016 static int
6017 sata_build_msense_page_1a(sata_drive_info_t *sdinfo, int pcntrl, uint8_t *buf)
6018 {
6019 #ifndef __lock_lint
6020 	_NOTE(ARGUNUSED(sdinfo))
6021 	_NOTE(ARGUNUSED(pcntrl))
6022 	_NOTE(ARGUNUSED(buf))
6023 #endif
6024 	return (0);
6025 }
6026 
6027 
6028 /*
6029  * Process mode select caching page 8 (scsi3 format only).
6030  * Read Ahead (same as read cache) and Write Cache may be turned on and off
6031  * if these features are supported by the device. If these features are not
6032  * supported, quietly ignore them.
6033  * This function fails only if the SET FEATURE command sent to
6034  * the device fails. The page format is not varified, assuming that the
6035  * target driver operates correctly - if parameters length is too short,
6036  * we just drop the page.
6037  * Two command may be sent if both Read Cache/Read Ahead and Write Cache
6038  * setting have to be changed.
6039  * SET FEATURE command is executed synchronously, i.e. we wait here until
6040  * it is completed, regardless of the scsi pkt directives.
6041  *
6042  * Note: Mode Select Caching page RCD and DRA bits are tied together, i.e.
6043  * changing DRA will change RCD.
6044  *
6045  * More than one SATA command may be executed to perform operations specified
6046  * by mode select pages. The first error terminates further execution.
6047  * Operations performed successully are not backed-up in such case.
6048  *
6049  * Return SATA_SUCCESS if operation succeeded, SATA_FAILURE otherwise.
6050  * If operation resulted in changing device setup, dmod flag should be set to
6051  * one (1). If parameters were not changed, dmod flag should be set to 0.
6052  * Upon return, if operation required sending command to the device, the rval
6053  * should be set to the value returned by sata_hba_start. If operation
6054  * did not require device access, rval should be set to TRAN_ACCEPT.
6055  * The pagelen should be set to the length of the page.
6056  *
6057  * This function has to be called with a port mutex held.
6058  *
6059  * Returns SATA_SUCCESS if operation was successful, SATA_FAILURE otherwise.
6060  */
6061 int
6062 sata_mode_select_page_8(sata_pkt_txlate_t *spx, struct mode_cache_scsi3 *page,
6063     int parmlen, int *pagelen, int *rval, int *dmod)
6064 {
6065 	struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt;
6066 	sata_drive_info_t *sdinfo;
6067 	sata_cmd_t *scmd = &spx->txlt_sata_pkt->satapkt_cmd;
6068 	sata_id_t *sata_id;
6069 	struct scsi_extended_sense *sense;
6070 	int wce, dra;	/* Current settings */
6071 
6072 	sdinfo = sata_get_device_info(spx->txlt_sata_hba_inst,
6073 	    &spx->txlt_sata_pkt->satapkt_device);
6074 	sata_id = &sdinfo->satadrv_id;
6075 	*dmod = 0;
6076 
6077 	/* Verify parameters length. If too short, drop it */
6078 	if (PAGELENGTH_DAD_MODE_CACHE_SCSI3 +
6079 	    sizeof (struct mode_page) < parmlen) {
6080 		*scsipkt->pkt_scbp = STATUS_CHECK;
6081 		sense = sata_arq_sense(spx);
6082 		sense->es_key = KEY_ILLEGAL_REQUEST;
6083 		sense->es_add_code = SD_SCSI_ASC_INVALID_FIELD_IN_PARAMS_LIST;
6084 		*pagelen = parmlen;
6085 		*rval = TRAN_ACCEPT;
6086 		return (SATA_FAILURE);
6087 	}
6088 
6089 	*pagelen = PAGELENGTH_DAD_MODE_CACHE_SCSI3 + sizeof (struct mode_page);
6090 
6091 	/*
6092 	 * We can manipulate only write cache and read ahead
6093 	 * (read cache) setting.
6094 	 */
6095 	if (!(sata_id->ai_cmdset82 & SATA_LOOK_AHEAD) &&
6096 	    !(sata_id->ai_cmdset82 & SATA_WRITE_CACHE)) {
6097 		/*
6098 		 * None of the features is supported - ignore
6099 		 */
6100 		*rval = TRAN_ACCEPT;
6101 		return (SATA_SUCCESS);
6102 	}
6103 
6104 	/* Current setting of Read Ahead (and Read Cache) */
6105 	if (sata_id->ai_features85 & SATA_LOOK_AHEAD)
6106 		dra = 0;	/* 0 == not disabled */
6107 	else
6108 		dra = 1;
6109 	/* Current setting of Write Cache */
6110 	if (sata_id->ai_features85 & SATA_WRITE_CACHE)
6111 		wce = 1;
6112 	else
6113 		wce = 0;
6114 
6115 	if (page->dra == dra && page->wce == wce && page->rcd == dra) {
6116 		/* nothing to do */
6117 		*rval = TRAN_ACCEPT;
6118 		return (SATA_SUCCESS);
6119 	}
6120 	/*
6121 	 * Need to flip some setting
6122 	 * Set-up Internal SET FEATURES command(s)
6123 	 */
6124 	scmd->satacmd_flags.sata_data_direction = SATA_DIR_NODATA_XFER;
6125 	scmd->satacmd_addr_type = 0;
6126 	scmd->satacmd_device_reg = 0;
6127 	scmd->satacmd_status_reg = 0;
6128 	scmd->satacmd_error_reg = 0;
6129 	scmd->satacmd_cmd_reg = SATAC_SET_FEATURES;
6130 	if (page->dra != dra || page->rcd != dra) {
6131 		/* Need to flip read ahead setting */
6132 		if (dra == 0)
6133 			/* Disable read ahead / read cache */
6134 			scmd->satacmd_features_reg =
6135 			    SATAC_SF_DISABLE_READ_AHEAD;
6136 		else
6137 			/* Enable read ahead  / read cache */
6138 			scmd->satacmd_features_reg =
6139 			    SATAC_SF_ENABLE_READ_AHEAD;
6140 
6141 		/* Transfer command to HBA */
6142 		if (sata_hba_start(spx, rval) != 0)
6143 			/*
6144 			 * Pkt not accepted for execution.
6145 			 */
6146 			return (SATA_FAILURE);
6147 
6148 		*dmod = 1;
6149 
6150 		/* Now process return */
6151 		if (spx->txlt_sata_pkt->satapkt_reason !=
6152 		    SATA_PKT_COMPLETED) {
6153 			goto failure;	/* Terminate */
6154 		}
6155 	}
6156 
6157 	/* Note that the packet is not removed, so it could be re-used */
6158 	if (page->wce != wce) {
6159 		/* Need to flip Write Cache setting */
6160 		if (page->wce == 1)
6161 			/* Enable write cache */
6162 			scmd->satacmd_features_reg =
6163 			    SATAC_SF_ENABLE_WRITE_CACHE;
6164 		else
6165 			/* Disable write cache */
6166 			scmd->satacmd_features_reg =
6167 			    SATAC_SF_DISABLE_WRITE_CACHE;
6168 
6169 		/* Transfer command to HBA */
6170 		if (sata_hba_start(spx, rval) != 0)
6171 			/*
6172 			 * Pkt not accepted for execution.
6173 			 */
6174 			return (SATA_FAILURE);
6175 
6176 		*dmod = 1;
6177 
6178 		/* Now process return */
6179 		if (spx->txlt_sata_pkt->satapkt_reason !=
6180 		    SATA_PKT_COMPLETED) {
6181 			goto failure;
6182 		}
6183 	}
6184 	return (SATA_SUCCESS);
6185 
6186 failure:
6187 	sata_xlate_errors(spx);
6188 
6189 	return (SATA_FAILURE);
6190 }
6191 
6192 /*
6193  * Process mode select informational exceptions control page 0x1c
6194  *
6195  * The only changeable bit is dexcpt (disable exceptions).
6196  * MRIE (method of reporting informational exceptions) must be
6197  * "only on request".
6198  *
6199  * Return SATA_SUCCESS if operation succeeded, SATA_FAILURE otherwise.
6200  * If operation resulted in changing device setup, dmod flag should be set to
6201  * one (1). If parameters were not changed, dmod flag should be set to 0.
6202  * Upon return, if operation required sending command to the device, the rval
6203  * should be set to the value returned by sata_hba_start. If operation
6204  * did not require device access, rval should be set to TRAN_ACCEPT.
6205  * The pagelen should be set to the length of the page.
6206  *
6207  * This function has to be called with a port mutex held.
6208  *
6209  * Returns SATA_SUCCESS if operation was successful, SATA_FAILURE otherwise.
6210  */
6211 static	int
6212 sata_mode_select_page_1c(
6213 	sata_pkt_txlate_t *spx,
6214 	struct mode_info_excpt_page *page,
6215 	int parmlen,
6216 	int *pagelen,
6217 	int *rval,
6218 	int *dmod)
6219 {
6220 	struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt;
6221 	sata_cmd_t *scmd = &spx->txlt_sata_pkt->satapkt_cmd;
6222 	sata_drive_info_t *sdinfo;
6223 	sata_id_t *sata_id;
6224 	struct scsi_extended_sense *sense;
6225 
6226 	sdinfo = sata_get_device_info(spx->txlt_sata_hba_inst,
6227 	    &spx->txlt_sata_pkt->satapkt_device);
6228 	sata_id = &sdinfo->satadrv_id;
6229 
6230 	*dmod = 0;
6231 
6232 	/* Verify parameters length. If too short, drop it */
6233 	if (((PAGELENGTH_INFO_EXCPT + sizeof (struct mode_page)) < parmlen) ||
6234 	    page->perf || page->test || (page->mrie != MRIE_ONLY_ON_REQUEST)) {
6235 		*scsipkt->pkt_scbp = STATUS_CHECK;
6236 		sense = sata_arq_sense(spx);
6237 		sense->es_key = KEY_ILLEGAL_REQUEST;
6238 		sense->es_add_code = SD_SCSI_ASC_INVALID_FIELD_IN_PARAMS_LIST;
6239 		*pagelen = parmlen;
6240 		*rval = TRAN_ACCEPT;
6241 		return (SATA_FAILURE);
6242 	}
6243 
6244 	*pagelen = PAGELENGTH_INFO_EXCPT + sizeof (struct mode_page);
6245 
6246 	if (! (sata_id->ai_cmdset82 & SATA_SMART_SUPPORTED)) {
6247 		*scsipkt->pkt_scbp = STATUS_CHECK;
6248 		sense = sata_arq_sense(spx);
6249 		sense->es_key = KEY_ILLEGAL_REQUEST;
6250 		sense->es_add_code = SD_SCSI_ASC_INVALID_FIELD_IN_CDB;
6251 		*pagelen = parmlen;
6252 		*rval = TRAN_ACCEPT;
6253 		return (SATA_FAILURE);
6254 	}
6255 
6256 	/* If already in the state requested, we are done */
6257 	if (page->dexcpt == ! (sata_id->ai_features85 & SATA_SMART_ENABLED)) {
6258 		/* nothing to do */
6259 		*rval = TRAN_ACCEPT;
6260 		return (SATA_SUCCESS);
6261 	}
6262 
6263 	scmd->satacmd_flags.sata_data_direction = SATA_DIR_NODATA_XFER;
6264 
6265 	/* Build SMART_ENABLE or SMART_DISABLE command */
6266 	scmd->satacmd_addr_type = 0;		/* N/A */
6267 	scmd->satacmd_lba_mid_lsb = SMART_MAGIC_VAL_1;
6268 	scmd->satacmd_lba_high_lsb = SMART_MAGIC_VAL_2;
6269 	scmd->satacmd_features_reg = page->dexcpt ?
6270 	    SATA_SMART_DISABLE_OPS : SATA_SMART_ENABLE_OPS;
6271 	scmd->satacmd_device_reg = 0;		/* Always device 0 */
6272 	scmd->satacmd_cmd_reg = SATAC_SMART;
6273 
6274 	/* Transfer command to HBA */
6275 	if (sata_hba_start(spx, rval) != 0)
6276 		/*
6277 		 * Pkt not accepted for execution.
6278 		 */
6279 		return (SATA_FAILURE);
6280 
6281 	*dmod = 1;	/* At least may have been modified */
6282 
6283 	/* Now process return */
6284 	if (spx->txlt_sata_pkt->satapkt_reason == SATA_PKT_COMPLETED)
6285 		return (SATA_SUCCESS);
6286 
6287 	/* Packet did not complete successfully */
6288 	sata_xlate_errors(spx);
6289 
6290 	return (SATA_FAILURE);
6291 }
6292 
6293 int
6294 sata_mode_select_page_30(sata_pkt_txlate_t *spx, struct
6295     mode_acoustic_management *page, int parmlen, int *pagelen,
6296     int *rval, int *dmod)
6297 {
6298 	struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt;
6299 	sata_drive_info_t *sdinfo;
6300 	sata_cmd_t *scmd = &spx->txlt_sata_pkt->satapkt_cmd;
6301 	sata_id_t *sata_id;
6302 	struct scsi_extended_sense *sense;
6303 
6304 	sdinfo = sata_get_device_info(spx->txlt_sata_hba_inst,
6305 	    &spx->txlt_sata_pkt->satapkt_device);
6306 	sata_id = &sdinfo->satadrv_id;
6307 	*dmod = 0;
6308 
6309 	/* If parmlen is too short or the feature is not supported, drop it */
6310 	if (((PAGELENGTH_DAD_MODE_ACOUSTIC_MANAGEMENT +
6311 	    sizeof (struct mode_page)) < parmlen) ||
6312 	    (! (sata_id->ai_cmdset83 & SATA_ACOUSTIC_MGMT))) {
6313 		*scsipkt->pkt_scbp = STATUS_CHECK;
6314 		sense = sata_arq_sense(spx);
6315 		sense->es_key = KEY_ILLEGAL_REQUEST;
6316 		sense->es_add_code = SD_SCSI_ASC_INVALID_FIELD_IN_PARAMS_LIST;
6317 		*pagelen = parmlen;
6318 		*rval = TRAN_ACCEPT;
6319 		return (SATA_FAILURE);
6320 	}
6321 
6322 	*pagelen = PAGELENGTH_DAD_MODE_ACOUSTIC_MANAGEMENT +
6323 	    sizeof (struct mode_page);
6324 
6325 	/*
6326 	 * We can enable and disable acoustice management and
6327 	 * set the acoustic management level.
6328 	 */
6329 
6330 	/*
6331 	 * Set-up Internal SET FEATURES command(s)
6332 	 */
6333 	scmd->satacmd_flags.sata_data_direction = SATA_DIR_NODATA_XFER;
6334 	scmd->satacmd_addr_type = 0;
6335 	scmd->satacmd_device_reg = 0;
6336 	scmd->satacmd_status_reg = 0;
6337 	scmd->satacmd_error_reg = 0;
6338 	scmd->satacmd_cmd_reg = SATAC_SET_FEATURES;
6339 	if (page->acoustic_manag_enable) {
6340 		scmd->satacmd_features_reg = SATAC_SF_ENABLE_ACOUSTIC;
6341 		scmd->satacmd_sec_count_lsb = page->acoustic_manag_level;
6342 	} else {	/* disabling acoustic management */
6343 		scmd->satacmd_features_reg = SATAC_SF_DISABLE_ACOUSTIC;
6344 	}
6345 
6346 	/* Transfer command to HBA */
6347 	if (sata_hba_start(spx, rval) != 0)
6348 		/*
6349 		 * Pkt not accepted for execution.
6350 		 */
6351 		return (SATA_FAILURE);
6352 
6353 	/* Now process return */
6354 	if (spx->txlt_sata_pkt->satapkt_reason != SATA_PKT_COMPLETED) {
6355 		sata_xlate_errors(spx);
6356 		return (SATA_FAILURE);
6357 	}
6358 
6359 	*dmod = 1;
6360 
6361 	return (SATA_SUCCESS);
6362 }
6363 
6364 
6365 
6366 
6367 /*
6368  * sata_build_lsense_page0() is used to create the
6369  * SCSI LOG SENSE page 0 (supported log pages)
6370  *
6371  * Currently supported pages are 0, 0x10, 0x2f and 0x30
6372  * (supported log pages, self-test results, informational exceptions
6373  *  and Sun vendor specific ATA SMART data).
6374  *
6375  * Takes a sata_drive_info t * and the address of a buffer
6376  * in which to create the page information.
6377  *
6378  * Returns the number of bytes valid in the buffer.
6379  */
6380 static	int
6381 sata_build_lsense_page_0(sata_drive_info_t *sdinfo, uint8_t *buf)
6382 {
6383 	struct log_parameter *lpp = (struct log_parameter *)buf;
6384 	uint8_t *page_ptr = (uint8_t *)lpp->param_values;
6385 	int num_pages_supported = 1; /* Always have GET_SUPPORTED_LOG_PAGES */
6386 	sata_id_t *sata_id = &sdinfo->satadrv_id;
6387 
6388 	lpp->param_code[0] = 0;
6389 	lpp->param_code[1] = 0;
6390 	lpp->param_ctrl_flags = LOG_CTRL_LP | LOG_CTRL_LBIN;
6391 	*page_ptr++ = PAGE_CODE_GET_SUPPORTED_LOG_PAGES;
6392 
6393 	if (sata_id->ai_cmdset82 & SATA_SMART_SUPPORTED) {
6394 		if (sata_id->ai_cmdset84 & SATA_SMART_SELF_TEST_SUPPORTED) {
6395 			*page_ptr++ = PAGE_CODE_SELF_TEST_RESULTS;
6396 			++num_pages_supported;
6397 		}
6398 		*page_ptr++ = PAGE_CODE_INFORMATION_EXCEPTIONS;
6399 		++num_pages_supported;
6400 		*page_ptr++ = PAGE_CODE_SMART_READ_DATA;
6401 		++num_pages_supported;
6402 	}
6403 
6404 	lpp->param_len = num_pages_supported;
6405 
6406 	return ((&lpp->param_values[0] - (uint8_t *)lpp) +
6407 	    num_pages_supported);
6408 }
6409 
6410 /*
6411  * sata_build_lsense_page_10() is used to create the
6412  * SCSI LOG SENSE page 0x10 (self-test results)
6413  *
6414  * Takes a sata_drive_info t * and the address of a buffer
6415  * in which to create the page information as well as a sata_hba_inst_t *.
6416  *
6417  * Returns the number of bytes valid in the buffer.
6418  */
6419 static	int
6420 sata_build_lsense_page_10(
6421 	sata_drive_info_t *sdinfo,
6422 	uint8_t *buf,
6423 	sata_hba_inst_t *sata_hba_inst)
6424 {
6425 	struct log_parameter *lpp = (struct log_parameter *)buf;
6426 	int rval;
6427 
6428 	if (sdinfo->satadrv_features_support & SATA_DEV_F_LBA48) {
6429 		struct smart_ext_selftest_log *ext_selftest_log;
6430 
6431 		ext_selftest_log = kmem_zalloc(
6432 		    sizeof (struct smart_ext_selftest_log), KM_SLEEP);
6433 
6434 		rval = sata_ext_smart_selftest_read_log(sata_hba_inst, sdinfo,
6435 		    ext_selftest_log, 0);
6436 		if (rval == 0) {
6437 			int index, start_index;
6438 			struct smart_ext_selftest_log_entry *entry;
6439 			static const struct smart_ext_selftest_log_entry empty =
6440 			    {0};
6441 			uint16_t block_num;
6442 			int count;
6443 			boolean_t only_one_block = B_FALSE;
6444 
6445 			index = ext_selftest_log->
6446 			    smart_ext_selftest_log_index[0];
6447 			index |= ext_selftest_log->
6448 			    smart_ext_selftest_log_index[1] << 8;
6449 			if (index == 0)
6450 				goto out;
6451 
6452 			--index;	/* Correct for 0 origin */
6453 			start_index = index;	/* remember where we started */
6454 			block_num = index / ENTRIES_PER_EXT_SELFTEST_LOG_BLK;
6455 			if (block_num != 0) {
6456 				rval = sata_ext_smart_selftest_read_log(
6457 				    sata_hba_inst, sdinfo, ext_selftest_log,
6458 				    block_num);
6459 				if (rval != 0)
6460 					goto out;
6461 			}
6462 			index %= ENTRIES_PER_EXT_SELFTEST_LOG_BLK;
6463 			entry =
6464 			    &ext_selftest_log->
6465 			    smart_ext_selftest_log_entries[index];
6466 
6467 			for (count = 1;
6468 			    count <= SCSI_ENTRIES_IN_LOG_SENSE_SELFTEST_RESULTS;
6469 			    ++count) {
6470 				uint8_t status;
6471 				uint8_t code;
6472 				uint8_t sense_key;
6473 				uint8_t add_sense_code;
6474 				uint8_t add_sense_code_qual;
6475 
6476 				/* If this is an unused entry, we are done */
6477 				if (bcmp(entry, &empty, sizeof (empty)) == 0) {
6478 					/* Broken firmware on some disks */
6479 					if (index + 1 ==
6480 					    ENTRIES_PER_EXT_SELFTEST_LOG_BLK) {
6481 						--entry;
6482 						--index;
6483 						if (bcmp(entry, &empty,
6484 						    sizeof (empty)) == 0)
6485 							goto out;
6486 					} else
6487 						goto out;
6488 				}
6489 
6490 				if (only_one_block &&
6491 				    start_index == index)
6492 					goto out;
6493 
6494 				lpp->param_code[0] = 0;
6495 				lpp->param_code[1] = count;
6496 				lpp->param_ctrl_flags =
6497 				    LOG_CTRL_LP | LOG_CTRL_LBIN;
6498 				lpp->param_len =
6499 				    SCSI_LOG_SENSE_SELFTEST_PARAM_LEN;
6500 
6501 				status = entry->smart_ext_selftest_log_status;
6502 				status >>= 4;
6503 				switch (status) {
6504 				case 0:
6505 				default:
6506 					sense_key = KEY_NO_SENSE;
6507 					add_sense_code =
6508 					    SD_SCSI_ASC_NO_ADD_SENSE;
6509 					add_sense_code_qual = 0;
6510 					break;
6511 				case 1:
6512 					sense_key = KEY_ABORTED_COMMAND;
6513 					add_sense_code =
6514 					    DIAGNOSTIC_FAILURE_ON_COMPONENT;
6515 					add_sense_code_qual = SCSI_COMPONENT_81;
6516 					break;
6517 				case 2:
6518 					sense_key = KEY_ABORTED_COMMAND;
6519 					add_sense_code =
6520 					    DIAGNOSTIC_FAILURE_ON_COMPONENT;
6521 					add_sense_code_qual = SCSI_COMPONENT_82;
6522 					break;
6523 				case 3:
6524 					sense_key = KEY_ABORTED_COMMAND;
6525 					add_sense_code =
6526 					    DIAGNOSTIC_FAILURE_ON_COMPONENT;
6527 					add_sense_code_qual = SCSI_COMPONENT_83;
6528 					break;
6529 				case 4:
6530 					sense_key = KEY_HARDWARE_ERROR;
6531 					add_sense_code =
6532 					    DIAGNOSTIC_FAILURE_ON_COMPONENT;
6533 					add_sense_code_qual = SCSI_COMPONENT_84;
6534 					break;
6535 				case 5:
6536 					sense_key = KEY_HARDWARE_ERROR;
6537 					add_sense_code =
6538 					    DIAGNOSTIC_FAILURE_ON_COMPONENT;
6539 					add_sense_code_qual = SCSI_COMPONENT_85;
6540 					break;
6541 				case 6:
6542 					sense_key = KEY_HARDWARE_ERROR;
6543 					add_sense_code =
6544 					    DIAGNOSTIC_FAILURE_ON_COMPONENT;
6545 					add_sense_code_qual = SCSI_COMPONENT_86;
6546 					break;
6547 				case 7:
6548 					sense_key = KEY_MEDIUM_ERROR;
6549 					add_sense_code =
6550 					    DIAGNOSTIC_FAILURE_ON_COMPONENT;
6551 					add_sense_code_qual = SCSI_COMPONENT_87;
6552 					break;
6553 				case 8:
6554 					sense_key = KEY_HARDWARE_ERROR;
6555 					add_sense_code =
6556 					    DIAGNOSTIC_FAILURE_ON_COMPONENT;
6557 					add_sense_code_qual = SCSI_COMPONENT_88;
6558 					break;
6559 				}
6560 				code = 0;	/* unspecified */
6561 				status |= (code << 4);
6562 				lpp->param_values[0] = status;
6563 				lpp->param_values[1] = 0; /* unspecified */
6564 				lpp->param_values[2] = entry->
6565 				    smart_ext_selftest_log_timestamp[1];
6566 				lpp->param_values[3] = entry->
6567 				    smart_ext_selftest_log_timestamp[0];
6568 				if (status != 0) {
6569 					lpp->param_values[4] = 0;
6570 					lpp->param_values[5] = 0;
6571 					lpp->param_values[6] = entry->
6572 					    smart_ext_selftest_log_failing_lba
6573 					    [5];
6574 					lpp->param_values[7] = entry->
6575 					    smart_ext_selftest_log_failing_lba
6576 					    [4];
6577 					lpp->param_values[8] = entry->
6578 					    smart_ext_selftest_log_failing_lba
6579 					    [3];
6580 					lpp->param_values[9] = entry->
6581 					    smart_ext_selftest_log_failing_lba
6582 					    [2];
6583 					lpp->param_values[10] = entry->
6584 					    smart_ext_selftest_log_failing_lba
6585 					    [1];
6586 					lpp->param_values[11] = entry->
6587 					    smart_ext_selftest_log_failing_lba
6588 					    [0];
6589 				} else {	/* No bad block address */
6590 					lpp->param_values[4] = 0xff;
6591 					lpp->param_values[5] = 0xff;
6592 					lpp->param_values[6] = 0xff;
6593 					lpp->param_values[7] = 0xff;
6594 					lpp->param_values[8] = 0xff;
6595 					lpp->param_values[9] = 0xff;
6596 					lpp->param_values[10] = 0xff;
6597 					lpp->param_values[11] = 0xff;
6598 				}
6599 
6600 				lpp->param_values[12] = sense_key;
6601 				lpp->param_values[13] = add_sense_code;
6602 				lpp->param_values[14] = add_sense_code_qual;
6603 				lpp->param_values[15] = 0; /* undefined */
6604 
6605 				lpp = (struct log_parameter *)
6606 				    (((uint8_t *)lpp) +
6607 				    SCSI_LOG_PARAM_HDR_LEN +
6608 				    SCSI_LOG_SENSE_SELFTEST_PARAM_LEN);
6609 
6610 				--index;	/* Back up to previous entry */
6611 				if (index < 0) {
6612 					if (block_num > 0) {
6613 						--block_num;
6614 					} else {
6615 						struct read_log_ext_directory
6616 						    logdir;
6617 
6618 						rval =
6619 						    sata_read_log_ext_directory(
6620 						    sata_hba_inst, sdinfo,
6621 						    &logdir);
6622 						if (rval == -1)
6623 							goto out;
6624 						if ((logdir.read_log_ext_vers
6625 						    [0] == 0) &&
6626 						    (logdir.read_log_ext_vers
6627 						    [1] == 0))
6628 							goto out;
6629 						block_num =
6630 						    logdir.read_log_ext_nblks
6631 						    [EXT_SMART_SELFTEST_LOG_PAGE
6632 						    - 1][0];
6633 						block_num |= logdir.
6634 						    read_log_ext_nblks
6635 						    [EXT_SMART_SELFTEST_LOG_PAGE
6636 						    - 1][1] << 8;
6637 						--block_num;
6638 						only_one_block =
6639 						    (block_num == 0);
6640 					}
6641 					rval = sata_ext_smart_selftest_read_log(
6642 					    sata_hba_inst, sdinfo,
6643 					    ext_selftest_log, block_num);
6644 					if (rval != 0)
6645 						goto out;
6646 
6647 					index =
6648 					    ENTRIES_PER_EXT_SELFTEST_LOG_BLK -
6649 					    1;
6650 				}
6651 				index %= ENTRIES_PER_EXT_SELFTEST_LOG_BLK;
6652 				entry = &ext_selftest_log->
6653 				    smart_ext_selftest_log_entries[index];
6654 			}
6655 		}
6656 out:
6657 		kmem_free(ext_selftest_log,
6658 		    sizeof (struct smart_ext_selftest_log));
6659 	} else {
6660 		struct smart_selftest_log *selftest_log;
6661 
6662 		selftest_log = kmem_zalloc(sizeof (struct smart_selftest_log),
6663 		    KM_SLEEP);
6664 
6665 		rval = sata_smart_selftest_log(sata_hba_inst, sdinfo,
6666 		    selftest_log);
6667 
6668 		if (rval == 0) {
6669 			int index;
6670 			int count;
6671 			struct smart_selftest_log_entry *entry;
6672 			static const struct smart_selftest_log_entry empty =
6673 			    { 0 };
6674 
6675 			index = selftest_log->smart_selftest_log_index;
6676 			if (index == 0)
6677 				goto done;
6678 			--index;	/* Correct for 0 origin */
6679 			entry = &selftest_log->
6680 			    smart_selftest_log_entries[index];
6681 			for (count = 1;
6682 			    count <= SCSI_ENTRIES_IN_LOG_SENSE_SELFTEST_RESULTS;
6683 			    ++count) {
6684 				uint8_t status;
6685 				uint8_t code;
6686 				uint8_t sense_key;
6687 				uint8_t add_sense_code;
6688 				uint8_t add_sense_code_qual;
6689 
6690 				if (bcmp(entry, &empty, sizeof (empty)) == 0)
6691 					goto done;
6692 
6693 				lpp->param_code[0] = 0;
6694 				lpp->param_code[1] = count;
6695 				lpp->param_ctrl_flags =
6696 				    LOG_CTRL_LP | LOG_CTRL_LBIN;
6697 				lpp->param_len =
6698 				    SCSI_LOG_SENSE_SELFTEST_PARAM_LEN;
6699 
6700 				status = entry->smart_selftest_log_status;
6701 				status >>= 4;
6702 				switch (status) {
6703 				case 0:
6704 				default:
6705 					sense_key = KEY_NO_SENSE;
6706 					add_sense_code =
6707 					    SD_SCSI_ASC_NO_ADD_SENSE;
6708 					break;
6709 				case 1:
6710 					sense_key = KEY_ABORTED_COMMAND;
6711 					add_sense_code =
6712 					    DIAGNOSTIC_FAILURE_ON_COMPONENT;
6713 					add_sense_code_qual = SCSI_COMPONENT_81;
6714 					break;
6715 				case 2:
6716 					sense_key = KEY_ABORTED_COMMAND;
6717 					add_sense_code =
6718 					    DIAGNOSTIC_FAILURE_ON_COMPONENT;
6719 					add_sense_code_qual = SCSI_COMPONENT_82;
6720 					break;
6721 				case 3:
6722 					sense_key = KEY_ABORTED_COMMAND;
6723 					add_sense_code =
6724 					    DIAGNOSTIC_FAILURE_ON_COMPONENT;
6725 					add_sense_code_qual = SCSI_COMPONENT_83;
6726 					break;
6727 				case 4:
6728 					sense_key = KEY_HARDWARE_ERROR;
6729 					add_sense_code =
6730 					    DIAGNOSTIC_FAILURE_ON_COMPONENT;
6731 					add_sense_code_qual = SCSI_COMPONENT_84;
6732 					break;
6733 				case 5:
6734 					sense_key = KEY_HARDWARE_ERROR;
6735 					add_sense_code =
6736 					    DIAGNOSTIC_FAILURE_ON_COMPONENT;
6737 					add_sense_code_qual = SCSI_COMPONENT_85;
6738 					break;
6739 				case 6:
6740 					sense_key = KEY_HARDWARE_ERROR;
6741 					add_sense_code =
6742 					    DIAGNOSTIC_FAILURE_ON_COMPONENT;
6743 					add_sense_code_qual = SCSI_COMPONENT_86;
6744 					break;
6745 				case 7:
6746 					sense_key = KEY_MEDIUM_ERROR;
6747 					add_sense_code =
6748 					    DIAGNOSTIC_FAILURE_ON_COMPONENT;
6749 					add_sense_code_qual = SCSI_COMPONENT_87;
6750 					break;
6751 				case 8:
6752 					sense_key = KEY_HARDWARE_ERROR;
6753 					add_sense_code =
6754 					    DIAGNOSTIC_FAILURE_ON_COMPONENT;
6755 					add_sense_code_qual = SCSI_COMPONENT_88;
6756 					break;
6757 				}
6758 				code = 0;	/* unspecified */
6759 				status |= (code << 4);
6760 				lpp->param_values[0] = status;
6761 				lpp->param_values[1] = 0; /* unspecified */
6762 				lpp->param_values[2] = entry->
6763 				    smart_selftest_log_timestamp[1];
6764 				lpp->param_values[3] = entry->
6765 				    smart_selftest_log_timestamp[0];
6766 				if (status != 0) {
6767 					lpp->param_values[4] = 0;
6768 					lpp->param_values[5] = 0;
6769 					lpp->param_values[6] = 0;
6770 					lpp->param_values[7] = 0;
6771 					lpp->param_values[8] = entry->
6772 					    smart_selftest_log_failing_lba[3];
6773 					lpp->param_values[9] = entry->
6774 					    smart_selftest_log_failing_lba[2];
6775 					lpp->param_values[10] = entry->
6776 					    smart_selftest_log_failing_lba[1];
6777 					lpp->param_values[11] = entry->
6778 					    smart_selftest_log_failing_lba[0];
6779 				} else {	/* No block address */
6780 					lpp->param_values[4] = 0xff;
6781 					lpp->param_values[5] = 0xff;
6782 					lpp->param_values[6] = 0xff;
6783 					lpp->param_values[7] = 0xff;
6784 					lpp->param_values[8] = 0xff;
6785 					lpp->param_values[9] = 0xff;
6786 					lpp->param_values[10] = 0xff;
6787 					lpp->param_values[11] = 0xff;
6788 				}
6789 				lpp->param_values[12] = sense_key;
6790 				lpp->param_values[13] = add_sense_code;
6791 				lpp->param_values[14] = add_sense_code_qual;
6792 				lpp->param_values[15] = 0; /* undefined */
6793 
6794 				lpp = (struct log_parameter *)
6795 				    (((uint8_t *)lpp) +
6796 				    SCSI_LOG_PARAM_HDR_LEN +
6797 				    SCSI_LOG_SENSE_SELFTEST_PARAM_LEN);
6798 				--index;	/* back up to previous entry */
6799 				if (index < 0) {
6800 					index =
6801 					    NUM_SMART_SELFTEST_LOG_ENTRIES - 1;
6802 				}
6803 				entry = &selftest_log->
6804 				    smart_selftest_log_entries[index];
6805 			}
6806 		}
6807 done:
6808 		kmem_free(selftest_log, sizeof (struct smart_selftest_log));
6809 	}
6810 
6811 	return ((SCSI_LOG_PARAM_HDR_LEN + SCSI_LOG_SENSE_SELFTEST_PARAM_LEN) *
6812 	    SCSI_ENTRIES_IN_LOG_SENSE_SELFTEST_RESULTS);
6813 }
6814 
6815 /*
6816  * sata_build_lsense_page_2f() is used to create the
6817  * SCSI LOG SENSE page 0x10 (informational exceptions)
6818  *
6819  * Takes a sata_drive_info t * and the address of a buffer
6820  * in which to create the page information as well as a sata_hba_inst_t *.
6821  *
6822  * Returns the number of bytes valid in the buffer.
6823  */
6824 static	int
6825 sata_build_lsense_page_2f(
6826 	sata_drive_info_t *sdinfo,
6827 	uint8_t *buf,
6828 	sata_hba_inst_t *sata_hba_inst)
6829 {
6830 	struct log_parameter *lpp = (struct log_parameter *)buf;
6831 	int rval;
6832 	uint8_t *smart_data;
6833 	uint8_t temp;
6834 	sata_id_t *sata_id;
6835 #define	SMART_NO_TEMP	0xff
6836 
6837 	lpp->param_code[0] = 0;
6838 	lpp->param_code[1] = 0;
6839 	lpp->param_ctrl_flags = LOG_CTRL_LP | LOG_CTRL_LBIN;
6840 
6841 	/* Now get the SMART status w.r.t. threshold exceeded */
6842 	rval = sata_fetch_smart_return_status(sata_hba_inst, sdinfo);
6843 	switch (rval) {
6844 	case 1:
6845 		lpp->param_values[0] = SCSI_PREDICTED_FAILURE;
6846 		lpp->param_values[1] = SCSI_GENERAL_HD_FAILURE;
6847 		break;
6848 	case 0:
6849 	case -1:	/* failed to get data */
6850 		lpp->param_values[0] = 0;	/* No failure predicted */
6851 		lpp->param_values[1] = 0;
6852 		break;
6853 #if defined(SATA_DEBUG)
6854 	default:
6855 		cmn_err(CE_PANIC, "sata_build_lsense_page_2f bad return value");
6856 		/* NOTREACHED */
6857 #endif
6858 	}
6859 
6860 	sata_id = &sdinfo->satadrv_id;
6861 	if (! (sata_id->ai_sctsupport & SATA_SCT_CMD_TRANS_SUP))
6862 		temp = SMART_NO_TEMP;
6863 	else {
6864 		/* Now get the temperature */
6865 		smart_data = kmem_zalloc(512, KM_SLEEP);
6866 		rval = sata_smart_read_log(sata_hba_inst, sdinfo, smart_data,
6867 		    SCT_STATUS_LOG_PAGE, 1);
6868 		if (rval == -1)
6869 			temp = SMART_NO_TEMP;
6870 		else {
6871 			temp = smart_data[200];
6872 			if (temp & 0x80) {
6873 				if (temp & 0x7f)
6874 					temp = 0;
6875 				else
6876 					temp = SMART_NO_TEMP;
6877 			}
6878 		}
6879 		kmem_free(smart_data, 512);
6880 	}
6881 
6882 	lpp->param_values[2] = temp;	/* most recent temperature */
6883 	lpp->param_values[3] = 0;	/* required vendor specific byte */
6884 
6885 	lpp->param_len = SCSI_INFO_EXCEPTIONS_PARAM_LEN;
6886 
6887 
6888 	return (SCSI_INFO_EXCEPTIONS_PARAM_LEN + SCSI_LOG_PARAM_HDR_LEN);
6889 }
6890 
6891 /*
6892  * sata_build_lsense_page_30() is used to create the
6893  * SCSI LOG SENSE page 0x30 (Sun's vendor specific page for ATA SMART data).
6894  *
6895  * Takes a sata_drive_info t * and the address of a buffer
6896  * in which to create the page information as well as a sata_hba_inst_t *.
6897  *
6898  * Returns the number of bytes valid in the buffer.
6899  */
6900 static int
6901 sata_build_lsense_page_30(
6902 	sata_drive_info_t *sdinfo,
6903 	uint8_t *buf,
6904 	sata_hba_inst_t *sata_hba_inst)
6905 {
6906 	struct smart_data *smart_data = (struct smart_data *)buf;
6907 	int rval;
6908 
6909 	/* Now do the SMART READ DATA */
6910 	rval = sata_fetch_smart_data(sata_hba_inst, sdinfo, smart_data);
6911 	if (rval == -1)
6912 		return (0);
6913 
6914 	return (sizeof (struct smart_data));
6915 }
6916 
6917 /* ************************** ATAPI-SPECIFIC FUNCTIONS ********************** */
6918 
6919 /*
6920  * Start command for ATAPI device.
6921  * This function processes scsi_pkt requests.
6922  * Only CD/DVD devices are supported.
6923  * Most commands are packet without any translation into Packet Command.
6924  * Some may be trapped and executed as SATA commands (not clear which one).
6925  *
6926  * Returns TRAN_ACCEPT if command is accepted for execution (or completed
6927  * execution).
6928  * Returns other TRAN_XXXX codes if command is not accepted or completed
6929  * (see return values for sata_hba_start()).
6930  *
6931  * Note:
6932  * Inquiry cdb format differs between transport version 2 and 3.
6933  * However, the transport version 3 devices that were checked did not adhere
6934  * to the specification (ignored MSB of the allocation length). Therefore,
6935  * the transport version is not checked, but Inquiry allocation length is
6936  * truncated to 255 bytes if the original allocation length set-up by the
6937  * target driver is greater than 255 bytes.
6938  */
6939 static int
6940 sata_txlt_atapi(sata_pkt_txlate_t *spx)
6941 {
6942 	struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt;
6943 	sata_cmd_t *scmd = &spx->txlt_sata_pkt->satapkt_cmd;
6944 	struct buf *bp = spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp;
6945 	sata_hba_inst_t *sata_hba = SATA_TXLT_HBA_INST(spx);
6946 	sata_drive_info_t *sdinfo = sata_get_device_info(sata_hba,
6947 	    &spx->txlt_sata_pkt->satapkt_device);
6948 	int cport = SATA_TXLT_CPORT(spx);
6949 	int cdblen;
6950 	int rval;
6951 	int synch;
6952 	union scsi_cdb *cdbp = (union scsi_cdb *)scsipkt->pkt_cdbp;
6953 
6954 	mutex_enter(&(SATA_TXLT_CPORT_MUTEX(spx)));
6955 
6956 	if (((rval = sata_txlt_generic_pkt_info(spx)) != TRAN_ACCEPT) ||
6957 	    (spx->txlt_scsi_pkt->pkt_reason == CMD_DEV_GONE)) {
6958 		mutex_exit(&(SATA_TXLT_CPORT_MUTEX(spx)));
6959 		return (rval);
6960 	}
6961 
6962 	/*
6963 	 * ATAPI device executes some ATA commands in addition to MMC command
6964 	 * set. These ATA commands may be executed by the regular SATA
6965 	 * translation functions. None needs to be captured now.
6966 	 * Other commands belong to MMC command set and are delivered
6967 	 * to ATAPI device via Packet Command.
6968 	 */
6969 
6970 	/* Check the size of cdb */
6971 	cdblen = scsi_cdb_size[GETGROUP(cdbp)];
6972 	if (cdblen > sdinfo->satadrv_atapi_cdb_len) {
6973 		sata_log(NULL, CE_WARN,
6974 		    "sata: invalid ATAPI cdb length %d",
6975 		    scsipkt->pkt_cdblen);
6976 		mutex_exit(&(SATA_TXLT_CPORT_MUTEX(spx)));
6977 		return (TRAN_BADPKT);
6978 	}
6979 
6980 	SATAATAPITRACE(spx, cdblen);
6981 
6982 	/*
6983 	 * For non-read/write commands we need to
6984 	 * map buffer
6985 	 */
6986 	switch ((uint_t)scsipkt->pkt_cdbp[0]) {
6987 	case SCMD_READ:
6988 	case SCMD_READ_G1:
6989 	case SCMD_READ_G5:
6990 	case SCMD_READ_G4:
6991 	case SCMD_WRITE:
6992 	case SCMD_WRITE_G1:
6993 	case SCMD_WRITE_G5:
6994 	case SCMD_WRITE_G4:
6995 		break;
6996 	default:
6997 		if (bp != NULL) {
6998 			if (bp->b_flags & (B_PHYS | B_PAGEIO))
6999 				bp_mapin(bp);
7000 		}
7001 		break;
7002 	}
7003 	/*
7004 	 * scmd->satacmd_flags.sata_data_direction default -
7005 	 * SATA_DIR_NODATA_XFER - is set by
7006 	 * sata_txlt_generic_pkt_info().
7007 	 */
7008 	if (scmd->satacmd_bp) {
7009 		if (scmd->satacmd_bp->b_flags & B_READ) {
7010 			scmd->satacmd_flags.sata_data_direction = SATA_DIR_READ;
7011 		} else {
7012 			scmd->satacmd_flags.sata_data_direction =
7013 			    SATA_DIR_WRITE;
7014 		}
7015 	}
7016 
7017 	/*
7018 	 * Set up ATAPI packet command.
7019 	 */
7020 
7021 	sata_atapi_packet_cmd_setup(scmd, sdinfo);
7022 
7023 	/* Copy cdb into sata_cmd */
7024 	scmd->satacmd_acdb_len = sdinfo->satadrv_atapi_cdb_len;
7025 	bzero(scmd->satacmd_acdb, SATA_ATAPI_MAX_CDB_LEN);
7026 	bcopy(cdbp, scmd->satacmd_acdb, cdblen);
7027 
7028 	/* See note in the command header */
7029 	if (scmd->satacmd_acdb[0] == SCMD_INQUIRY) {
7030 		if (scmd->satacmd_acdb[3] != 0)
7031 			scmd->satacmd_acdb[4] = 255;
7032 	}
7033 
7034 #ifdef SATA_DEBUG
7035 	if (sata_debug_flags & SATA_DBG_ATAPI) {
7036 		uint8_t *p = scmd->satacmd_acdb;
7037 		char buf[3 * SATA_ATAPI_MAX_CDB_LEN];
7038 
7039 		(void) snprintf(buf, SATA_ATAPI_MAX_CDB_LEN,
7040 		    "%02x %02x %02x %02x %02x %02x %02x %02x "
7041 		    "%2x %02x %02x %02x %02x %02x %02x %02x",
7042 		    p[0], p[1], p[2], p[3], p[4], p[5], p[6], p[7],
7043 		    p[8], p[9], p[10], p[11], p[12], p[13], p[14], p[15]);
7044 		buf[(3 * SATA_ATAPI_MAX_CDB_LEN) - 1] = '\0';
7045 		cmn_err(CE_NOTE, "ATAPI cdb: %s\n", buf);
7046 	}
7047 #endif
7048 
7049 	/*
7050 	 * Preset request sense data to NO SENSE.
7051 	 * If there is no way to get error information via Request Sense,
7052 	 * the packet request sense data would not have to be modified by HBA,
7053 	 * but it could be returned as is.
7054 	 */
7055 	bzero(scmd->satacmd_rqsense, SATA_ATAPI_RQSENSE_LEN);
7056 	sata_fixed_sense_data_preset(
7057 	    (struct scsi_extended_sense *)scmd->satacmd_rqsense);
7058 
7059 	if (!(spx->txlt_sata_pkt->satapkt_op_mode & SATA_OPMODE_SYNCH)) {
7060 		/* Need callback function */
7061 		spx->txlt_sata_pkt->satapkt_comp = sata_txlt_atapi_completion;
7062 		synch = FALSE;
7063 	} else
7064 		synch = TRUE;
7065 
7066 	/* Transfer command to HBA */
7067 	if (sata_hba_start(spx, &rval) != 0) {
7068 		/* Pkt not accepted for execution */
7069 		mutex_exit(&SATA_CPORT_MUTEX(sata_hba, cport));
7070 		return (rval);
7071 	}
7072 	mutex_exit(&SATA_CPORT_MUTEX(sata_hba, cport));
7073 	/*
7074 	 * If execution is non-synchronous,
7075 	 * a callback function will handle potential errors, translate
7076 	 * the response and will do a callback to a target driver.
7077 	 * If it was synchronous, use the same framework callback to check
7078 	 * an execution status.
7079 	 */
7080 	if (synch) {
7081 		SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst,
7082 		    "synchronous execution status %x\n",
7083 		    spx->txlt_sata_pkt->satapkt_reason);
7084 		sata_txlt_atapi_completion(spx->txlt_sata_pkt);
7085 	}
7086 	return (TRAN_ACCEPT);
7087 }
7088 
7089 
7090 /*
7091  * ATAPI Packet command completion.
7092  *
7093  * Failure of the command passed via Packet command are considered device
7094  * error. SATA HBA driver would have to retrieve error data (via Request
7095  * Sense command delivered via error retrieval sata packet) and copy it
7096  * to satacmd_rqsense array. From there, it is moved into scsi pkt sense data.
7097  */
7098 static void
7099 sata_txlt_atapi_completion(sata_pkt_t *sata_pkt)
7100 {
7101 	sata_pkt_txlate_t *spx =
7102 	    (sata_pkt_txlate_t *)sata_pkt->satapkt_framework_private;
7103 	struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt;
7104 	struct scsi_extended_sense *sense;
7105 	struct buf *bp;
7106 	int rval;
7107 
7108 #ifdef SATA_DEBUG
7109 	uint8_t *rqsp = sata_pkt->satapkt_cmd.satacmd_rqsense;
7110 #endif
7111 
7112 	scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET |
7113 	    STATE_SENT_CMD | STATE_GOT_STATUS;
7114 
7115 	if (sata_pkt->satapkt_reason == SATA_PKT_COMPLETED) {
7116 		/* Normal completion */
7117 		if (sata_pkt->satapkt_cmd.satacmd_bp != NULL)
7118 			scsipkt->pkt_state |= STATE_XFERRED_DATA;
7119 		scsipkt->pkt_reason = CMD_CMPLT;
7120 		*scsipkt->pkt_scbp = STATUS_GOOD;
7121 		if (spx->txlt_tmp_buf != NULL) {
7122 			/* Temporary buffer was used */
7123 			bp = spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp;
7124 			if (bp->b_flags & B_READ) {
7125 				rval = ddi_dma_sync(
7126 				    spx->txlt_buf_dma_handle, 0, 0,
7127 				    DDI_DMA_SYNC_FORCPU);
7128 				ASSERT(rval == DDI_SUCCESS);
7129 				bcopy(spx->txlt_tmp_buf, bp->b_un.b_addr,
7130 				    bp->b_bcount);
7131 			}
7132 		}
7133 	} else {
7134 		/*
7135 		 * Something went wrong - analyze return
7136 		 */
7137 		*scsipkt->pkt_scbp = STATUS_CHECK;
7138 		sense = sata_arq_sense(spx);
7139 
7140 		if (sata_pkt->satapkt_reason == SATA_PKT_DEV_ERROR) {
7141 			scsipkt->pkt_reason = CMD_INCOMPLETE;
7142 			/*
7143 			 * We may not have ARQ data if there was a double
7144 			 * error. But sense data in sata packet was pre-set
7145 			 * with NO SENSE so it is valid even if HBA could
7146 			 * not retrieve a real sense data.
7147 			 * Just copy this sense data into scsi pkt sense area.
7148 			 */
7149 			bcopy(sata_pkt->satapkt_cmd.satacmd_rqsense, sense,
7150 			    SATA_ATAPI_MIN_RQSENSE_LEN);
7151 #ifdef SATA_DEBUG
7152 			if (sata_debug_flags & SATA_DBG_SCSI_IF) {
7153 				sata_log(spx->txlt_sata_hba_inst, CE_WARN,
7154 				    "sata_txlt_atapi_completion: %02x\n"
7155 				    "RQSENSE:  %02x %02x %02x %02x %02x %02x "
7156 				    "          %02x %02x %02x %02x %02x %02x "
7157 				    "          %02x %02x %02x %02x %02x %02x\n",
7158 				    scsipkt->pkt_reason,
7159 				    rqsp[0], rqsp[1], rqsp[2], rqsp[3],
7160 				    rqsp[4], rqsp[5], rqsp[6], rqsp[7],
7161 				    rqsp[8], rqsp[9], rqsp[10], rqsp[11],
7162 				    rqsp[12], rqsp[13], rqsp[14], rqsp[15],
7163 				    rqsp[16], rqsp[17]);
7164 			}
7165 #endif
7166 		} else {
7167 			switch (sata_pkt->satapkt_reason) {
7168 			case SATA_PKT_PORT_ERROR:
7169 				/*
7170 				 * We have no device data.
7171 				 */
7172 				scsipkt->pkt_reason = CMD_INCOMPLETE;
7173 				scsipkt->pkt_state &= ~(STATE_GOT_BUS |
7174 				    STATE_GOT_TARGET | STATE_SENT_CMD |
7175 				    STATE_GOT_STATUS);
7176 				sense->es_key = KEY_HARDWARE_ERROR;
7177 				break;
7178 
7179 			case SATA_PKT_TIMEOUT:
7180 				scsipkt->pkt_reason = CMD_TIMEOUT;
7181 				scsipkt->pkt_statistics |=
7182 				    STAT_TIMEOUT | STAT_DEV_RESET;
7183 				/*
7184 				 * Need to check if HARDWARE_ERROR/
7185 				 * TIMEOUT_ON_LOGICAL_UNIT 4/3E/2 would be more
7186 				 * appropriate.
7187 				 */
7188 				break;
7189 
7190 			case SATA_PKT_ABORTED:
7191 				scsipkt->pkt_reason = CMD_ABORTED;
7192 				scsipkt->pkt_statistics |= STAT_ABORTED;
7193 				/* Should we set key COMMAND_ABPRTED? */
7194 				break;
7195 
7196 			case SATA_PKT_RESET:
7197 				scsipkt->pkt_reason = CMD_RESET;
7198 				scsipkt->pkt_statistics |= STAT_DEV_RESET;
7199 				/*
7200 				 * May be we should set Unit Attention /
7201 				 * Reset. Perhaps the same should be
7202 				 * returned for disks....
7203 				 */
7204 				sense->es_key = KEY_UNIT_ATTENTION;
7205 				sense->es_add_code = SD_SCSI_ASC_RESET;
7206 				break;
7207 
7208 			default:
7209 				SATA_LOG_D((spx->txlt_sata_hba_inst, CE_WARN,
7210 				    "sata_txlt_atapi_completion: "
7211 				    "invalid packet completion reason"));
7212 				scsipkt->pkt_reason = CMD_TRAN_ERR;
7213 				scsipkt->pkt_state &= ~(STATE_GOT_BUS |
7214 				    STATE_GOT_TARGET | STATE_SENT_CMD |
7215 				    STATE_GOT_STATUS);
7216 				break;
7217 			}
7218 		}
7219 	}
7220 
7221 	SATAATAPITRACE(spx, 0);
7222 
7223 	if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0 &&
7224 	    scsipkt->pkt_comp != NULL) {
7225 		/* scsi callback required */
7226 		(*scsipkt->pkt_comp)(scsipkt);
7227 	}
7228 }
7229 
7230 /*
7231  * Set up error retrieval sata command for ATAPI Packet Command error data
7232  * recovery.
7233  *
7234  * Returns SATA_SUCCESS when data buffer is allocated and packet set-up,
7235  * returns SATA_FAILURE otherwise.
7236  */
7237 
7238 static int
7239 sata_atapi_err_ret_cmd_setup(sata_pkt_txlate_t *spx, sata_drive_info_t *sdinfo)
7240 {
7241 	sata_pkt_t *spkt = spx->txlt_sata_pkt;
7242 	sata_cmd_t *scmd;
7243 	struct buf *bp;
7244 
7245 	/*
7246 	 * Allocate dma-able buffer error data.
7247 	 * Buffer allocation will take care of buffer alignment and other DMA
7248 	 * attributes.
7249 	 */
7250 	bp = sata_alloc_local_buffer(spx, SATA_ATAPI_MIN_RQSENSE_LEN);
7251 	if (bp == NULL) {
7252 		SATADBG1(SATA_DBG_ATAPI, spx->txlt_sata_hba_inst,
7253 		    "sata_get_err_retrieval_pkt: "
7254 		    "cannot allocate buffer for error data", NULL);
7255 		return (SATA_FAILURE);
7256 	}
7257 	bp_mapin(bp); /* make data buffer accessible */
7258 
7259 	/* Operation modes are up to the caller */
7260 	spkt->satapkt_op_mode = SATA_OPMODE_SYNCH | SATA_OPMODE_INTERRUPTS;
7261 
7262 	/* Synchronous mode, no callback - may be changed by the caller */
7263 	spkt->satapkt_comp = NULL;
7264 	spkt->satapkt_time = sata_default_pkt_time;
7265 
7266 	scmd = &spkt->satapkt_cmd;
7267 	scmd->satacmd_flags.sata_data_direction = SATA_DIR_READ;
7268 	scmd->satacmd_flags.sata_ignore_dev_reset = B_TRUE;
7269 
7270 	sata_atapi_packet_cmd_setup(scmd, sdinfo);
7271 
7272 	/*
7273 	 * Set-up acdb. Request Sense CDB (packet command content) is
7274 	 * not in DMA-able buffer. Its handling is HBA-specific (how
7275 	 * it is transfered into packet FIS).
7276 	 */
7277 	scmd->satacmd_acdb_len = sdinfo->satadrv_atapi_cdb_len;
7278 	bcopy(sata_rqsense_cdb, scmd->satacmd_acdb, SATA_ATAPI_RQSENSE_CDB_LEN);
7279 	/* Following zeroing of pad bytes may not be necessary */
7280 	bzero(&scmd->satacmd_acdb[SATA_ATAPI_RQSENSE_CDB_LEN],
7281 	    sdinfo->satadrv_atapi_cdb_len - SATA_ATAPI_RQSENSE_CDB_LEN);
7282 
7283 	/*
7284 	 * Set-up pointer to the buffer handle, so HBA can sync buffer
7285 	 * before accessing it. Handle is in usual place in translate struct.
7286 	 */
7287 	scmd->satacmd_err_ret_buf_handle = &spx->txlt_buf_dma_handle;
7288 
7289 	/*
7290 	 * Preset request sense data to NO SENSE.
7291 	 * Here it is redundant, only for a symetry with scsi-originated
7292 	 * packets. It should not be used for anything but debugging.
7293 	 */
7294 	bzero(scmd->satacmd_rqsense, SATA_ATAPI_RQSENSE_LEN);
7295 	sata_fixed_sense_data_preset(
7296 	    (struct scsi_extended_sense *)scmd->satacmd_rqsense);
7297 
7298 	ASSERT(scmd->satacmd_num_dma_cookies != 0);
7299 	ASSERT(scmd->satacmd_dma_cookie_list != NULL);
7300 
7301 	return (SATA_SUCCESS);
7302 }
7303 
7304 /*
7305  * Set-up ATAPI packet command.
7306  * Data transfer direction has to be set-up in sata_cmd structure prior to
7307  * calling this function.
7308  *
7309  * Returns void
7310  */
7311 
7312 static void
7313 sata_atapi_packet_cmd_setup(sata_cmd_t *scmd, sata_drive_info_t *sdinfo)
7314 {
7315 	scmd->satacmd_addr_type = 0;		/* N/A */
7316 	scmd->satacmd_sec_count_lsb = 0;	/* no tag */
7317 	scmd->satacmd_lba_low_lsb = 0;		/* N/A */
7318 	scmd->satacmd_lba_mid_lsb = (uint8_t)SATA_ATAPI_MAX_BYTES_PER_DRQ;
7319 	scmd->satacmd_lba_high_lsb =
7320 	    (uint8_t)(SATA_ATAPI_MAX_BYTES_PER_DRQ >> 8);
7321 	scmd->satacmd_cmd_reg = SATAC_PACKET;	/* Command */
7322 
7323 	/*
7324 	 * We want all data to be transfered via DMA.
7325 	 * But specify it only if drive supports DMA and DMA mode is
7326 	 * selected - some drives are sensitive about it.
7327 	 * Hopefully it wil work for all drives....
7328 	 */
7329 	if (sdinfo->satadrv_settings & SATA_DEV_DMA)
7330 		scmd->satacmd_features_reg = SATA_ATAPI_F_DMA;
7331 
7332 	/*
7333 	 * Features register requires special care for devices that use
7334 	 * Serial ATA bridge - they need an explicit specification of
7335 	 * the data transfer direction for Packet DMA commands.
7336 	 * Setting this bit is harmless if DMA is not used.
7337 	 *
7338 	 * Many drives do not implement word 80, specifying what ATA/ATAPI
7339 	 * spec they follow.
7340 	 * We are arbitrarily following the latest SerialATA 2.6 spec,
7341 	 * which uses ATA/ATAPI 6 specification for Identify Data, unless
7342 	 * ATA/ATAPI-7 support is explicitly indicated.
7343 	 */
7344 	if (sdinfo->satadrv_id.ai_majorversion != 0 &&
7345 	    sdinfo->satadrv_id.ai_majorversion != 0xffff &&
7346 	    (sdinfo->satadrv_id.ai_majorversion & SATA_MAJVER_7) != 0) {
7347 		/*
7348 		 * Specification of major version is valid and version 7
7349 		 * is supported. It does automatically imply that all
7350 		 * spec features are supported. For now, we assume that
7351 		 * DMADIR setting is valid. ATA/ATAPI7 spec is incomplete.
7352 		 */
7353 		if ((sdinfo->satadrv_id.ai_dirdma &
7354 		    SATA_ATAPI_ID_DMADIR_REQ) != 0) {
7355 			if (scmd->satacmd_flags.sata_data_direction ==
7356 			    SATA_DIR_READ)
7357 			scmd->satacmd_features_reg |=
7358 			    SATA_ATAPI_F_DATA_DIR_READ;
7359 		}
7360 	}
7361 }
7362 
7363 
7364 #ifdef SATA_DEBUG
7365 
7366 /* Display 18 bytes of Inquiry data */
7367 static void
7368 sata_show_inqry_data(uint8_t *buf)
7369 {
7370 	struct scsi_inquiry *inq = (struct scsi_inquiry *)buf;
7371 	uint8_t *p;
7372 
7373 	cmn_err(CE_NOTE, "Inquiry data:");
7374 	cmn_err(CE_NOTE, "device type %x", inq->inq_dtype);
7375 	cmn_err(CE_NOTE, "removable media %x", inq->inq_rmb);
7376 	cmn_err(CE_NOTE, "version %x", inq->inq_ansi);
7377 	cmn_err(CE_NOTE, "ATAPI transport version %d",
7378 	    SATA_ATAPI_TRANS_VERSION(inq));
7379 	cmn_err(CE_NOTE, "response data format %d, aenc %d",
7380 	    inq->inq_rdf, inq->inq_aenc);
7381 	cmn_err(CE_NOTE, " additional length %d", inq->inq_len);
7382 	cmn_err(CE_NOTE, "tpgs %d", inq->inq_tpgs);
7383 	p = (uint8_t *)inq->inq_vid;
7384 	cmn_err(CE_NOTE, "vendor id (binary): %02x %02x %02x %02x "
7385 	    "%02x %02x %02x %02x",
7386 	    p[0], p[1], p[2], p[3], p[4], p[5], p[6], p[7]);
7387 	p = (uint8_t *)inq->inq_vid;
7388 	cmn_err(CE_NOTE, "vendor id: %c %c %c %c %c %c %c %c",
7389 	    p[0], p[1], p[2], p[3], p[4], p[5], p[6], p[7]);
7390 
7391 	p = (uint8_t *)inq->inq_pid;
7392 	cmn_err(CE_NOTE, "product id (binary): %02x %02x %02x %02x "
7393 	    "%02x %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x",
7394 	    p[0], p[1], p[2], p[3], p[4], p[5], p[6], p[7],
7395 	    p[8], p[9], p[10], p[11], p[12], p[13], p[14], p[15]);
7396 	p = (uint8_t *)inq->inq_pid;
7397 	cmn_err(CE_NOTE, "product id: %c %c %c %c %c %c %c %c "
7398 	    "%c %c %c %c %c %c %c %c",
7399 	    p[0], p[1], p[2], p[3], p[4], p[5], p[6], p[7],
7400 	    p[8], p[9], p[10], p[11], p[12], p[13], p[14], p[15]);
7401 
7402 	p = (uint8_t *)inq->inq_revision;
7403 	cmn_err(CE_NOTE, "revision (binary): %02x %02x %02x %02x",
7404 	    p[0], p[1], p[2], p[3]);
7405 	p = (uint8_t *)inq->inq_revision;
7406 	cmn_err(CE_NOTE, "revision: %c %c %c %c",
7407 	    p[0], p[1], p[2], p[3]);
7408 
7409 }
7410 
7411 
7412 static void
7413 sata_save_atapi_trace(sata_pkt_txlate_t *spx, int count)
7414 {
7415 	struct scsi_pkt *scsi_pkt = spx->txlt_scsi_pkt;
7416 
7417 	if (scsi_pkt == NULL)
7418 		return;
7419 	if (count != 0) {
7420 		/* saving cdb */
7421 		bzero(sata_atapi_trace[sata_atapi_trace_index].acdb,
7422 		    SATA_ATAPI_MAX_CDB_LEN);
7423 		bcopy(scsi_pkt->pkt_cdbp,
7424 		    sata_atapi_trace[sata_atapi_trace_index].acdb, count);
7425 	} else {
7426 		bcopy(&((struct scsi_arq_status *)scsi_pkt->pkt_scbp)->
7427 		    sts_sensedata,
7428 		    sata_atapi_trace[sata_atapi_trace_index].arqs,
7429 		    SATA_ATAPI_MIN_RQSENSE_LEN);
7430 		sata_atapi_trace[sata_atapi_trace_index].scsi_pkt_reason =
7431 		    scsi_pkt->pkt_reason;
7432 		sata_atapi_trace[sata_atapi_trace_index].sata_pkt_reason =
7433 		    spx->txlt_sata_pkt->satapkt_reason;
7434 
7435 		if (++sata_atapi_trace_index >= 64)
7436 			sata_atapi_trace_index = 0;
7437 	}
7438 }
7439 
7440 #endif
7441 
7442 /*
7443  * Fetch inquiry data from ATAPI device
7444  * Returns SATA_SUCCESS if operation was successfull, SATA_FAILURE otherwise.
7445  *
7446  * Note:
7447  * inqb pointer does not point to a DMA-able buffer. It is a local buffer
7448  * where the caller expects to see the inquiry data.
7449  *
7450  */
7451 
7452 static int
7453 sata_get_atapi_inquiry_data(sata_hba_inst_t *sata_hba,
7454     sata_address_t *saddr, struct scsi_inquiry *inq)
7455 {
7456 	sata_pkt_txlate_t *spx;
7457 	sata_pkt_t *spkt;
7458 	struct buf *bp;
7459 	sata_drive_info_t *sdinfo;
7460 	sata_cmd_t *scmd;
7461 	int rval;
7462 	uint8_t *rqsp;
7463 #ifdef SATA_DEBUG
7464 	char msg_buf[MAXPATHLEN];
7465 #endif
7466 
7467 	ASSERT(sata_hba != NULL);
7468 
7469 	spx = kmem_zalloc(sizeof (sata_pkt_txlate_t), KM_SLEEP);
7470 	spx->txlt_sata_hba_inst = sata_hba;
7471 	spx->txlt_scsi_pkt = NULL;		/* No scsi pkt involved */
7472 	spkt = sata_pkt_alloc(spx, NULL);
7473 	if (spkt == NULL) {
7474 		kmem_free(spx, sizeof (sata_pkt_txlate_t));
7475 		return (SATA_FAILURE);
7476 	}
7477 	/* address is needed now */
7478 	spkt->satapkt_device.satadev_addr = *saddr;
7479 
7480 	/* scsi_inquiry size buffer */
7481 	bp = sata_alloc_local_buffer(spx, sizeof (struct scsi_inquiry));
7482 	if (bp == NULL) {
7483 		sata_pkt_free(spx);
7484 		kmem_free(spx, sizeof (sata_pkt_txlate_t));
7485 		SATA_LOG_D((sata_hba, CE_WARN,
7486 		    "sata_get_atapi_inquiry_data: "
7487 		    "cannot allocate data buffer"));
7488 		return (SATA_FAILURE);
7489 	}
7490 	bp_mapin(bp); /* make data buffer accessible */
7491 
7492 	scmd = &spkt->satapkt_cmd;
7493 	ASSERT(scmd->satacmd_num_dma_cookies != 0);
7494 	ASSERT(scmd->satacmd_dma_cookie_list != NULL);
7495 
7496 	/* Use synchronous mode */
7497 	spkt->satapkt_op_mode = SATA_OPMODE_SYNCH | SATA_OPMODE_INTERRUPTS;
7498 	spkt->satapkt_comp = NULL;
7499 	spkt->satapkt_time = sata_default_pkt_time;
7500 
7501 	/* Issue inquiry command - 6 bytes cdb, data transfer, read */
7502 
7503 	scmd->satacmd_flags.sata_data_direction = SATA_DIR_READ;
7504 	scmd->satacmd_flags.sata_ignore_dev_reset = B_TRUE;
7505 
7506 	mutex_enter(&(SATA_TXLT_CPORT_MUTEX(spx)));
7507 	sdinfo = sata_get_device_info(sata_hba,
7508 	    &spx->txlt_sata_pkt->satapkt_device);
7509 	if (sdinfo == NULL) {
7510 		/* we have to be carefull about the disapearing device */
7511 		mutex_exit(&(SATA_TXLT_CPORT_MUTEX(spx)));
7512 		rval = SATA_FAILURE;
7513 		goto cleanup;
7514 	}
7515 	sata_atapi_packet_cmd_setup(scmd, sdinfo);
7516 
7517 	/*
7518 	 * Set-up acdb. This works for atapi transport version 2 and later.
7519 	 */
7520 	scmd->satacmd_acdb_len = sdinfo->satadrv_atapi_cdb_len;
7521 	bzero(scmd->satacmd_acdb, SATA_ATAPI_MAX_CDB_LEN);
7522 	scmd->satacmd_acdb[0] = 0x12;	/* Inquiry */
7523 	scmd->satacmd_acdb[1] = 0x00;
7524 	scmd->satacmd_acdb[2] = 0x00;
7525 	scmd->satacmd_acdb[3] = 0x00;
7526 	scmd->satacmd_acdb[4] = sizeof (struct scsi_inquiry);
7527 	scmd->satacmd_acdb[5] = 0x00;
7528 
7529 	sata_fixed_sense_data_preset(
7530 	    (struct scsi_extended_sense *)scmd->satacmd_rqsense);
7531 
7532 	/* Transfer command to HBA */
7533 	if (sata_hba_start(spx, &rval) != 0) {
7534 		/* Pkt not accepted for execution */
7535 		SATADBG1(SATA_DBG_ATAPI, sata_hba,
7536 		    "sata_get_atapi_inquiry_data: "
7537 		    "Packet not accepted for execution - ret: %02x", rval);
7538 		mutex_exit(&(SATA_TXLT_CPORT_MUTEX(spx)));
7539 		rval = SATA_FAILURE;
7540 		goto cleanup;
7541 	}
7542 	mutex_exit(&(SATA_TXLT_CPORT_MUTEX(spx)));
7543 
7544 	if (spkt->satapkt_reason == SATA_PKT_COMPLETED) {
7545 		SATADBG1(SATA_DBG_ATAPI, sata_hba,
7546 		    "sata_get_atapi_inquiry_data: "
7547 		    "Packet completed successfully - ret: %02x", rval);
7548 		/*
7549 		 * Sync buffer. Handle is in usual place in translate struct.
7550 		 * Normal completion - copy data into caller's buffer
7551 		 */
7552 		rval = ddi_dma_sync(spx->txlt_buf_dma_handle, 0, 0,
7553 		    DDI_DMA_SYNC_FORCPU);
7554 		ASSERT(rval == DDI_SUCCESS);
7555 		bcopy(bp->b_un.b_addr, (uint8_t *)inq,
7556 		    sizeof (struct scsi_inquiry));
7557 #ifdef SATA_DEBUG
7558 		if (sata_debug_flags & SATA_DBG_ATAPI) {
7559 			sata_show_inqry_data((uint8_t *)inq);
7560 		}
7561 #endif
7562 		rval = SATA_SUCCESS;
7563 	} else {
7564 		/*
7565 		 * Something went wrong - analyze return - check rqsense data
7566 		 */
7567 		rval = SATA_FAILURE;
7568 		if (spkt->satapkt_reason == SATA_PKT_DEV_ERROR) {
7569 			/*
7570 			 * ARQ data hopefull show something other than NO SENSE
7571 			 */
7572 			rqsp = scmd->satacmd_rqsense;
7573 #ifdef SATA_DEBUG
7574 			if (sata_debug_flags & SATA_DBG_ATAPI) {
7575 				msg_buf[0] = '\0';
7576 				(void) snprintf(msg_buf, MAXPATHLEN,
7577 				    "ATAPI packet completion reason: %02x\n"
7578 				    "RQSENSE:  %02x %02x %02x %02x %02x %02x\n"
7579 				    "          %02x %02x %02x %02x %02x %02x\n"
7580 				    "          %02x %02x %02x %02x %02x %02x",
7581 				    spkt->satapkt_reason,
7582 				    rqsp[0], rqsp[1], rqsp[2], rqsp[3],
7583 				    rqsp[4], rqsp[5], rqsp[6], rqsp[7],
7584 				    rqsp[8], rqsp[9], rqsp[10], rqsp[11],
7585 				    rqsp[12], rqsp[13], rqsp[14], rqsp[15],
7586 				    rqsp[16], rqsp[17]);
7587 				sata_log(spx->txlt_sata_hba_inst, CE_WARN,
7588 				    "%s", msg_buf);
7589 			}
7590 #endif
7591 		} else {
7592 			switch (spkt->satapkt_reason) {
7593 			case SATA_PKT_PORT_ERROR:
7594 				SATADBG1(SATA_DBG_ATAPI, sata_hba,
7595 				    "sata_get_atapi_inquiry_data: "
7596 				    "packet reason: port error", NULL);
7597 				break;
7598 
7599 			case SATA_PKT_TIMEOUT:
7600 				SATADBG1(SATA_DBG_ATAPI, sata_hba,
7601 				    "sata_get_atapi_inquiry_data: "
7602 				    "packet reason: timeout", NULL);
7603 				break;
7604 
7605 			case SATA_PKT_ABORTED:
7606 				SATADBG1(SATA_DBG_ATAPI, sata_hba,
7607 				    "sata_get_atapi_inquiry_data: "
7608 				    "packet reason: aborted", NULL);
7609 				break;
7610 
7611 			case SATA_PKT_RESET:
7612 				SATADBG1(SATA_DBG_ATAPI, sata_hba,
7613 				    "sata_get_atapi_inquiry_data: "
7614 				    "packet reason: reset\n", NULL);
7615 				break;
7616 			default:
7617 				SATADBG1(SATA_DBG_ATAPI, sata_hba,
7618 				    "sata_get_atapi_inquiry_data: "
7619 				    "invalid packet reason: %02x\n",
7620 				    spkt->satapkt_reason);
7621 				break;
7622 			}
7623 		}
7624 	}
7625 cleanup:
7626 	sata_free_local_buffer(spx);
7627 	sata_pkt_free(spx);
7628 	kmem_free(spx, sizeof (sata_pkt_txlate_t));
7629 	return (rval);
7630 }
7631 
7632 
7633 
7634 
7635 
7636 #if 0
7637 #ifdef SATA_DEBUG
7638 
7639 /*
7640  * Test ATAPI packet command.
7641  * Single threaded test: send packet command in synch mode, process completion
7642  *
7643  */
7644 static void
7645 sata_test_atapi_packet_command(sata_hba_inst_t *sata_hba_inst, int cport)
7646 {
7647 	sata_pkt_txlate_t *spx;
7648 	sata_pkt_t *spkt;
7649 	struct buf *bp;
7650 	sata_device_t sata_device;
7651 	sata_drive_info_t *sdinfo;
7652 	sata_cmd_t *scmd;
7653 	int rval;
7654 	uint8_t *rqsp;
7655 
7656 	ASSERT(sata_hba_inst != NULL);
7657 	sata_device.satadev_addr.cport = cport;
7658 	sata_device.satadev_addr.pmport = 0;
7659 	sata_device.satadev_addr.qual = SATA_ADDR_DCPORT;
7660 	sata_device.satadev_rev = SATA_DEVICE_REV;
7661 	mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex);
7662 	sdinfo = sata_get_device_info(sata_hba_inst, &sata_device);
7663 	mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex);
7664 	if (sdinfo == NULL) {
7665 		sata_log(sata_hba_inst, CE_WARN,
7666 		    "sata_test_atapi_packet_command: "
7667 		    "no device info for cport %d",
7668 		    sata_device.satadev_addr.cport);
7669 		return;
7670 	}
7671 
7672 	spx = kmem_zalloc(sizeof (sata_pkt_txlate_t), KM_SLEEP);
7673 	spx->txlt_sata_hba_inst = sata_hba_inst;
7674 	spx->txlt_scsi_pkt = NULL;		/* No scsi pkt involved */
7675 	spkt = sata_pkt_alloc(spx, NULL);
7676 	if (spkt == NULL) {
7677 		kmem_free(spx, sizeof (sata_pkt_txlate_t));
7678 		return;
7679 	}
7680 	/* address is needed now */
7681 	spkt->satapkt_device.satadev_addr = sata_device.satadev_addr;
7682 
7683 	/* 1024k buffer */
7684 	bp = sata_alloc_local_buffer(spx, 1024);
7685 	if (bp == NULL) {
7686 		sata_pkt_free(spx);
7687 		kmem_free(spx, sizeof (sata_pkt_txlate_t));
7688 		sata_log(sata_hba_inst, CE_WARN,
7689 		    "sata_test_atapi_packet_command: "
7690 		    "cannot allocate data buffer");
7691 		return;
7692 	}
7693 	bp_mapin(bp); /* make data buffer accessible */
7694 
7695 	scmd = &spkt->satapkt_cmd;
7696 	ASSERT(scmd->satacmd_num_dma_cookies != 0);
7697 	ASSERT(scmd->satacmd_dma_cookie_list != NULL);
7698 
7699 	/* Use synchronous mode */
7700 	spkt->satapkt_op_mode = SATA_OPMODE_SYNCH | SATA_OPMODE_INTERRUPTS;
7701 
7702 	/* Synchronous mode, no callback - may be changed by the caller */
7703 	spkt->satapkt_comp = NULL;
7704 	spkt->satapkt_time = sata_default_pkt_time;
7705 
7706 	/* Issue inquiry command - 6 bytes cdb, data transfer, read */
7707 
7708 	scmd->satacmd_flags.sata_data_direction = SATA_DIR_READ;
7709 	scmd->satacmd_flags.sata_ignore_dev_reset = B_TRUE;
7710 
7711 	sata_atapi_packet_cmd_setup(scmd, sdinfo);
7712 
7713 	/* Set-up acdb. */
7714 	scmd->satacmd_acdb_len = sdinfo->satadrv_atapi_cdb_len;
7715 	bzero(scmd->satacmd_acdb, SATA_ATAPI_MAX_CDB_LEN);
7716 	scmd->satacmd_acdb[0] = 0x12;	/* Inquiry */
7717 	scmd->satacmd_acdb[1] = 0x00;
7718 	scmd->satacmd_acdb[2] = 0x00;
7719 	scmd->satacmd_acdb[3] = 0x00;
7720 	scmd->satacmd_acdb[4] = sizeof (struct scsi_inquiry);
7721 	scmd->satacmd_acdb[5] = 0x00;
7722 
7723 	sata_fixed_sense_data_preset(
7724 	    (struct scsi_extended_sense *)scmd->satacmd_rqsense);
7725 
7726 	/* Transfer command to HBA */
7727 	mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex);
7728 	if (sata_hba_start(spx, &rval) != 0) {
7729 		/* Pkt not accepted for execution */
7730 		sata_log(sata_hba_inst, CE_WARN,
7731 		    "sata_test_atapi_packet_command: "
7732 		    "Packet not accepted for execution - ret: %02x", rval);
7733 		mutex_exit(
7734 		    &SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex);
7735 		goto cleanup;
7736 	}
7737 	mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex);
7738 
7739 	/*
7740 	 * Sync buffer. Handle is in usual place in translate struct.
7741 	 */
7742 	rval = ddi_dma_sync(spx->txlt_buf_dma_handle, 0, 0,
7743 	    DDI_DMA_SYNC_FORCPU);
7744 	ASSERT(rval == DDI_SUCCESS);
7745 	if (spkt->satapkt_reason == SATA_PKT_COMPLETED) {
7746 		sata_log(sata_hba_inst, CE_WARN,
7747 		    "sata_test_atapi_packet_command: "
7748 		    "Packet completed successfully");
7749 		/*
7750 		 * Normal completion - show inquiry data
7751 		 */
7752 		sata_show_inqry_data((uint8_t *)bp->b_un.b_addr);
7753 	} else {
7754 		/*
7755 		 * Something went wrong - analyze return - check rqsense data
7756 		 */
7757 		if (spkt->satapkt_reason == SATA_PKT_DEV_ERROR) {
7758 			/*
7759 			 * ARQ data hopefull show something other than NO SENSE
7760 			 */
7761 			rqsp = scmd->satacmd_rqsense;
7762 			sata_log(spx->txlt_sata_hba_inst, CE_WARN,
7763 			    "ATAPI packet completion reason: %02x\n"
7764 			    "RQSENSE:  %02x %02x %02x %02x %02x %02x "
7765 			    "          %02x %02x %02x %02x %02x %02x "
7766 			    "          %02x %02x %02x %02x %02x %02x\n",
7767 			    spkt->satapkt_reason,
7768 			    rqsp[0], rqsp[1], rqsp[2], rqsp[3],
7769 			    rqsp[4], rqsp[5], rqsp[6], rqsp[7],
7770 			    rqsp[8], rqsp[9], rqsp[10], rqsp[11],
7771 			    rqsp[12], rqsp[13], rqsp[14], rqsp[15],
7772 			    rqsp[16], rqsp[17]);
7773 		} else {
7774 			switch (spkt->satapkt_reason) {
7775 			case SATA_PKT_PORT_ERROR:
7776 				sata_log(sata_hba_inst, CE_WARN,
7777 				    "sata_test_atapi_packet_command: "
7778 				    "packet reason: port error\n");
7779 				break;
7780 
7781 			case SATA_PKT_TIMEOUT:
7782 				sata_log(sata_hba_inst, CE_WARN,
7783 				    "sata_test_atapi_packet_command: "
7784 				    "packet reason: timeout\n");
7785 				break;
7786 
7787 			case SATA_PKT_ABORTED:
7788 				sata_log(sata_hba_inst, CE_WARN,
7789 				    "sata_test_atapi_packet_command: "
7790 				    "packet reason: aborted\n");
7791 				break;
7792 
7793 			case SATA_PKT_RESET:
7794 				sata_log(sata_hba_inst, CE_WARN,
7795 				    "sata_test_atapi_packet_command: "
7796 				    "packet reason: reset\n");
7797 				break;
7798 			default:
7799 				sata_log(sata_hba_inst, CE_WARN,
7800 				    "sata_test_atapi_packet_command: "
7801 				    "invalid packet reason: %02x\n",
7802 				    spkt->satapkt_reason);
7803 				break;
7804 			}
7805 		}
7806 	}
7807 cleanup:
7808 	sata_free_local_buffer(spx);
7809 	sata_pkt_free(spx);
7810 	kmem_free(spx, sizeof (sata_pkt_txlate_t));
7811 }
7812 
7813 #endif /* SATA_DEBUG */
7814 #endif /* 1 */
7815 
7816 
7817 /* ************************** LOCAL HELPER FUNCTIONS *********************** */
7818 
7819 /*
7820  * Validate sata_tran info
7821  * SATA_FAILURE returns if structure is inconsistent or structure revision
7822  * does not match one used by the framework.
7823  *
7824  * Returns SATA_SUCCESS if sata_hba_tran has matching revision and contains
7825  * required function pointers.
7826  * Returns SATA_FAILURE otherwise.
7827  */
7828 static int
7829 sata_validate_sata_hba_tran(dev_info_t *dip, sata_hba_tran_t *sata_tran)
7830 {
7831 	/*
7832 	 * SATA_TRAN_HBA_REV is the current (highest) revision number
7833 	 * of the SATA interface.
7834 	 */
7835 	if (sata_tran->sata_tran_hba_rev > SATA_TRAN_HBA_REV) {
7836 		sata_log(NULL, CE_WARN,
7837 		    "sata: invalid sata_hba_tran version %d for driver %s",
7838 		    sata_tran->sata_tran_hba_rev, ddi_driver_name(dip));
7839 		return (SATA_FAILURE);
7840 	}
7841 
7842 	if (dip != sata_tran->sata_tran_hba_dip) {
7843 		SATA_LOG_D((NULL, CE_WARN,
7844 		    "sata: inconsistent sata_tran_hba_dip "
7845 		    "%p / %p", sata_tran->sata_tran_hba_dip, dip));
7846 		return (SATA_FAILURE);
7847 	}
7848 
7849 	if (sata_tran->sata_tran_probe_port == NULL ||
7850 	    sata_tran->sata_tran_start == NULL ||
7851 	    sata_tran->sata_tran_abort == NULL ||
7852 	    sata_tran->sata_tran_reset_dport == NULL ||
7853 	    sata_tran->sata_tran_hotplug_ops == NULL ||
7854 	    sata_tran->sata_tran_hotplug_ops->sata_tran_port_activate == NULL ||
7855 	    sata_tran->sata_tran_hotplug_ops->sata_tran_port_deactivate ==
7856 	    NULL) {
7857 		SATA_LOG_D((NULL, CE_WARN, "sata: sata_hba_tran missing "
7858 		    "required functions"));
7859 	}
7860 	return (SATA_SUCCESS);
7861 }
7862 
7863 /*
7864  * Remove HBA instance from sata_hba_list.
7865  */
7866 static void
7867 sata_remove_hba_instance(dev_info_t *dip)
7868 {
7869 	sata_hba_inst_t	*sata_hba_inst;
7870 
7871 	mutex_enter(&sata_mutex);
7872 	for (sata_hba_inst = sata_hba_list;
7873 	    sata_hba_inst != (struct sata_hba_inst *)NULL;
7874 	    sata_hba_inst = sata_hba_inst->satahba_next) {
7875 		if (sata_hba_inst->satahba_dip == dip)
7876 			break;
7877 	}
7878 
7879 	if (sata_hba_inst == (struct sata_hba_inst *)NULL) {
7880 #ifdef SATA_DEBUG
7881 		cmn_err(CE_WARN, "sata_remove_hba_instance: "
7882 		    "unknown HBA instance\n");
7883 #endif
7884 		ASSERT(FALSE);
7885 	}
7886 	if (sata_hba_inst == sata_hba_list) {
7887 		sata_hba_list = sata_hba_inst->satahba_next;
7888 		if (sata_hba_list) {
7889 			sata_hba_list->satahba_prev =
7890 			    (struct sata_hba_inst *)NULL;
7891 		}
7892 		if (sata_hba_inst == sata_hba_list_tail) {
7893 			sata_hba_list_tail = NULL;
7894 		}
7895 	} else if (sata_hba_inst == sata_hba_list_tail) {
7896 		sata_hba_list_tail = sata_hba_inst->satahba_prev;
7897 		if (sata_hba_list_tail) {
7898 			sata_hba_list_tail->satahba_next =
7899 			    (struct sata_hba_inst *)NULL;
7900 		}
7901 	} else {
7902 		sata_hba_inst->satahba_prev->satahba_next =
7903 		    sata_hba_inst->satahba_next;
7904 		sata_hba_inst->satahba_next->satahba_prev =
7905 		    sata_hba_inst->satahba_prev;
7906 	}
7907 	mutex_exit(&sata_mutex);
7908 }
7909 
7910 
7911 
7912 
7913 
7914 /*
7915  * Probe all SATA ports of the specified HBA instance.
7916  * The assumption is that there are no target and attachment point minor nodes
7917  * created by the boot subsystems, so we do not need to prune device tree.
7918  *
7919  * This function is called only from sata_hba_attach(). It does not have to
7920  * be protected by controller mutex, because the hba_attached flag is not set
7921  * yet and no one would be touching this HBA instance other than this thread.
7922  * Determines if port is active and what type of the device is attached
7923  * (if any). Allocates necessary structures for each port.
7924  *
7925  * An AP (Attachement Point) node is created for each SATA device port even
7926  * when there is no device attached.
7927  */
7928 
7929 static 	void
7930 sata_probe_ports(sata_hba_inst_t *sata_hba_inst)
7931 {
7932 	dev_info_t		*dip = SATA_DIP(sata_hba_inst);
7933 	int			ncport, npmport;
7934 	sata_cport_info_t 	*cportinfo;
7935 	sata_drive_info_t	*drive;
7936 	sata_pmult_info_t	*pminfo;
7937 	sata_pmport_info_t 	*pmportinfo;
7938 	sata_device_t		sata_device;
7939 	int			rval;
7940 	dev_t			minor_number;
7941 	char			name[16];
7942 	clock_t			start_time, cur_time;
7943 
7944 	/*
7945 	 * Probe controller ports first, to find port status and
7946 	 * any port multiplier attached.
7947 	 */
7948 	for (ncport = 0; ncport < SATA_NUM_CPORTS(sata_hba_inst); ncport++) {
7949 		/* allocate cport structure */
7950 		cportinfo = kmem_zalloc(sizeof (sata_cport_info_t), KM_SLEEP);
7951 		ASSERT(cportinfo != NULL);
7952 		mutex_init(&cportinfo->cport_mutex, NULL, MUTEX_DRIVER, NULL);
7953 
7954 		mutex_enter(&cportinfo->cport_mutex);
7955 
7956 		cportinfo->cport_addr.cport = ncport;
7957 		cportinfo->cport_addr.pmport = 0;
7958 		cportinfo->cport_addr.qual = SATA_ADDR_CPORT;
7959 		cportinfo->cport_state &= ~SATA_PORT_STATE_CLEAR_MASK;
7960 		cportinfo->cport_state |= SATA_STATE_PROBING;
7961 		SATA_CPORT_INFO(sata_hba_inst, ncport) = cportinfo;
7962 
7963 		/*
7964 		 * Regardless if a port is usable or not, create
7965 		 * an attachment point
7966 		 */
7967 		mutex_exit(&cportinfo->cport_mutex);
7968 		minor_number =
7969 		    SATA_MAKE_AP_MINOR(ddi_get_instance(dip), ncport, 0, 0);
7970 		(void) sprintf(name, "%d", ncport);
7971 		if (ddi_create_minor_node(dip, name, S_IFCHR,
7972 		    minor_number, DDI_NT_SATA_ATTACHMENT_POINT, 0) !=
7973 		    DDI_SUCCESS) {
7974 			sata_log(sata_hba_inst, CE_WARN, "sata_hba_attach: "
7975 			    "cannot create SATA attachment point for port %d",
7976 			    ncport);
7977 		}
7978 
7979 		/* Probe port */
7980 		start_time = ddi_get_lbolt();
7981 	reprobe_cport:
7982 		sata_device.satadev_addr.cport = ncport;
7983 		sata_device.satadev_addr.pmport = 0;
7984 		sata_device.satadev_addr.qual = SATA_ADDR_CPORT;
7985 		sata_device.satadev_rev = SATA_DEVICE_REV;
7986 
7987 		rval = (*SATA_PROBE_PORT_FUNC(sata_hba_inst))
7988 		    (dip, &sata_device);
7989 
7990 		mutex_enter(&cportinfo->cport_mutex);
7991 		sata_update_port_scr(&cportinfo->cport_scr, &sata_device);
7992 		if (rval != SATA_SUCCESS) {
7993 			/* Something went wrong? Fail the port */
7994 			cportinfo->cport_state = SATA_PSTATE_FAILED;
7995 			mutex_exit(&cportinfo->cport_mutex);
7996 			continue;
7997 		}
7998 		cportinfo->cport_state &= ~SATA_STATE_PROBING;
7999 		cportinfo->cport_state |= SATA_STATE_PROBED;
8000 		cportinfo->cport_dev_type = sata_device.satadev_type;
8001 
8002 		cportinfo->cport_state |= SATA_STATE_READY;
8003 		if (cportinfo->cport_dev_type == SATA_DTYPE_NONE) {
8004 			mutex_exit(&cportinfo->cport_mutex);
8005 			continue;
8006 		}
8007 		if (cportinfo->cport_dev_type != SATA_DTYPE_PMULT) {
8008 			/*
8009 			 * There is some device attached.
8010 			 * Allocate device info structure
8011 			 */
8012 			if (SATA_CPORTINFO_DRV_INFO(cportinfo) == NULL) {
8013 				mutex_exit(&cportinfo->cport_mutex);
8014 				SATA_CPORTINFO_DRV_INFO(cportinfo) =
8015 				    kmem_zalloc(sizeof (sata_drive_info_t),
8016 				    KM_SLEEP);
8017 				mutex_enter(&cportinfo->cport_mutex);
8018 			}
8019 			drive = SATA_CPORTINFO_DRV_INFO(cportinfo);
8020 			drive->satadrv_addr = cportinfo->cport_addr;
8021 			drive->satadrv_addr.qual = SATA_ADDR_DCPORT;
8022 			drive->satadrv_type = cportinfo->cport_dev_type;
8023 			drive->satadrv_state = SATA_STATE_UNKNOWN;
8024 
8025 			mutex_exit(&cportinfo->cport_mutex);
8026 			if (sata_add_device(dip, sata_hba_inst, ncport, 0) !=
8027 			    SATA_SUCCESS) {
8028 				/*
8029 				 * Plugged device was not correctly identified.
8030 				 * Retry, within a SATA_DEV_IDENTIFY_TIMEOUT
8031 				 */
8032 				cur_time = ddi_get_lbolt();
8033 				if ((cur_time - start_time) <
8034 				    drv_usectohz(SATA_DEV_IDENTIFY_TIMEOUT)) {
8035 					/* sleep for a while */
8036 					delay(drv_usectohz(
8037 					    SATA_DEV_IDENTIFY_RTR_DLY));
8038 					goto reprobe_cport;
8039 				}
8040 			}
8041 		} else {
8042 			mutex_exit(&cportinfo->cport_mutex);
8043 			ASSERT(cportinfo->cport_dev_type == SATA_DTYPE_PMULT);
8044 			pminfo = kmem_zalloc(sizeof (sata_pmult_info_t),
8045 			    KM_SLEEP);
8046 			mutex_enter(&cportinfo->cport_mutex);
8047 			ASSERT(pminfo != NULL);
8048 			SATA_CPORTINFO_PMULT_INFO(cportinfo) = pminfo;
8049 			pminfo->pmult_addr.cport = cportinfo->cport_addr.cport;
8050 			pminfo->pmult_addr.pmport = SATA_PMULT_HOSTPORT;
8051 			pminfo->pmult_addr.qual = SATA_ADDR_PMPORT;
8052 			pminfo->pmult_num_dev_ports =
8053 			    sata_device.satadev_add_info;
8054 			mutex_init(&pminfo->pmult_mutex, NULL, MUTEX_DRIVER,
8055 			    NULL);
8056 			pminfo->pmult_state = SATA_STATE_PROBING;
8057 			mutex_exit(&cportinfo->cport_mutex);
8058 
8059 			/* Probe Port Multiplier ports */
8060 			for (npmport = 0;
8061 			    npmport < pminfo->pmult_num_dev_ports;
8062 			    npmport++) {
8063 				pmportinfo = kmem_zalloc(
8064 				    sizeof (sata_pmport_info_t), KM_SLEEP);
8065 				mutex_enter(&cportinfo->cport_mutex);
8066 				ASSERT(pmportinfo != NULL);
8067 				pmportinfo->pmport_addr.cport = ncport;
8068 				pmportinfo->pmport_addr.pmport = npmport;
8069 				pmportinfo->pmport_addr.qual =
8070 				    SATA_ADDR_PMPORT;
8071 				pminfo->pmult_dev_port[npmport] = pmportinfo;
8072 
8073 				mutex_init(&pmportinfo->pmport_mutex, NULL,
8074 				    MUTEX_DRIVER, NULL);
8075 
8076 				mutex_exit(&cportinfo->cport_mutex);
8077 
8078 				/* Create an attachment point */
8079 				minor_number = SATA_MAKE_AP_MINOR(
8080 				    ddi_get_instance(dip), ncport, npmport, 1);
8081 				(void) sprintf(name, "%d.%d", ncport, npmport);
8082 				if (ddi_create_minor_node(dip, name, S_IFCHR,
8083 				    minor_number, DDI_NT_SATA_ATTACHMENT_POINT,
8084 				    0) != DDI_SUCCESS) {
8085 					sata_log(sata_hba_inst, CE_WARN,
8086 					    "sata_hba_attach: "
8087 					    "cannot create SATA attachment "
8088 					    "point for port %d pmult port %d",
8089 					    ncport, npmport);
8090 				}
8091 
8092 				start_time = ddi_get_lbolt();
8093 			reprobe_pmport:
8094 				sata_device.satadev_addr.pmport = npmport;
8095 				sata_device.satadev_addr.qual =
8096 				    SATA_ADDR_PMPORT;
8097 
8098 				rval = (*SATA_PROBE_PORT_FUNC(sata_hba_inst))
8099 				    (dip, &sata_device);
8100 				mutex_enter(&cportinfo->cport_mutex);
8101 
8102 				/* sata_update_port_info() */
8103 				sata_update_port_scr(&pmportinfo->pmport_scr,
8104 				    &sata_device);
8105 
8106 				if (rval != SATA_SUCCESS) {
8107 					pmportinfo->pmport_state =
8108 					    SATA_PSTATE_FAILED;
8109 					mutex_exit(&cportinfo->cport_mutex);
8110 					continue;
8111 				}
8112 				pmportinfo->pmport_state &=
8113 				    ~SATA_STATE_PROBING;
8114 				pmportinfo->pmport_state |= SATA_STATE_PROBED;
8115 				pmportinfo->pmport_dev_type =
8116 				    sata_device.satadev_type;
8117 
8118 				pmportinfo->pmport_state |= SATA_STATE_READY;
8119 				if (pmportinfo->pmport_dev_type ==
8120 				    SATA_DTYPE_NONE) {
8121 					mutex_exit(&cportinfo->cport_mutex);
8122 					continue;
8123 				}
8124 				/* Port multipliers cannot be chained */
8125 				ASSERT(pmportinfo->pmport_dev_type !=
8126 				    SATA_DTYPE_PMULT);
8127 				/*
8128 				 * There is something attached to Port
8129 				 * Multiplier device port
8130 				 * Allocate device info structure
8131 				 */
8132 				if (pmportinfo->pmport_sata_drive == NULL) {
8133 					mutex_exit(&cportinfo->cport_mutex);
8134 					pmportinfo->pmport_sata_drive =
8135 					    kmem_zalloc(
8136 					    sizeof (sata_drive_info_t),
8137 					    KM_SLEEP);
8138 					mutex_enter(&cportinfo->cport_mutex);
8139 				}
8140 				drive = pmportinfo->pmport_sata_drive;
8141 				drive->satadrv_addr.cport =
8142 				    pmportinfo->pmport_addr.cport;
8143 				drive->satadrv_addr.pmport = npmport;
8144 				drive->satadrv_addr.qual = SATA_ADDR_DPMPORT;
8145 				drive->satadrv_type = pmportinfo->
8146 				    pmport_dev_type;
8147 				drive->satadrv_state = SATA_STATE_UNKNOWN;
8148 
8149 				mutex_exit(&cportinfo->cport_mutex);
8150 				if (sata_add_device(dip, sata_hba_inst, ncport,
8151 				    npmport) != SATA_SUCCESS) {
8152 					/*
8153 					 * Plugged device was not correctly
8154 					 * identified. Retry, within the
8155 					 * SATA_DEV_IDENTIFY_TIMEOUT
8156 					 */
8157 					cur_time = ddi_get_lbolt();
8158 					if ((cur_time - start_time) <
8159 					    drv_usectohz(
8160 					    SATA_DEV_IDENTIFY_TIMEOUT)) {
8161 						/* sleep for a while */
8162 						delay(drv_usectohz(
8163 						    SATA_DEV_IDENTIFY_RTR_DLY));
8164 						goto reprobe_pmport;
8165 					}
8166 				}
8167 			}
8168 			pmportinfo->pmport_state =
8169 			    SATA_STATE_PROBED | SATA_STATE_READY;
8170 		}
8171 	}
8172 }
8173 
8174 /*
8175  * Add SATA device for specified HBA instance & port (SCSI target
8176  * device nodes).
8177  * This function is called (indirectly) only from sata_hba_attach().
8178  * A target node is created when there is a supported type device attached,
8179  * but may be removed if it cannot be put online.
8180  *
8181  * This function cannot be called from an interrupt context.
8182  *
8183  * ONLY DISK TARGET NODES ARE CREATED NOW
8184  *
8185  * Returns SATA_SUCCESS when port/device was fully processed, SATA_FAILURE when
8186  * device identification failed - adding a device could be retried.
8187  *
8188  */
8189 static 	int
8190 sata_add_device(dev_info_t *pdip, sata_hba_inst_t *sata_hba_inst, int cport,
8191     int pmport)
8192 {
8193 	sata_cport_info_t 	*cportinfo;
8194 	sata_pmult_info_t	*pminfo;
8195 	sata_pmport_info_t	*pmportinfo;
8196 	dev_info_t		*cdip;		/* child dip */
8197 	sata_device_t		sata_device;
8198 	int			rval;
8199 
8200 
8201 
8202 	cportinfo = SATA_CPORT_INFO(sata_hba_inst, cport);
8203 	ASSERT(cportinfo->cport_dev_type != SATA_DTYPE_NONE);
8204 	mutex_enter(&cportinfo->cport_mutex);
8205 	/*
8206 	 * Some device is attached to a controller port.
8207 	 * We rely on controllers distinquishing between no-device,
8208 	 * attached port multiplier and other kind of attached device.
8209 	 * We need to get Identify Device data and determine
8210 	 * positively the dev type before trying to attach
8211 	 * the target driver.
8212 	 */
8213 	sata_device.satadev_rev = SATA_DEVICE_REV;
8214 	if (cportinfo->cport_dev_type != SATA_DTYPE_PMULT) {
8215 		/*
8216 		 * Not port multiplier.
8217 		 */
8218 		sata_device.satadev_addr = cportinfo->cport_addr;
8219 		sata_device.satadev_addr.qual = SATA_ADDR_DCPORT;
8220 		mutex_exit(&cportinfo->cport_mutex);
8221 
8222 		rval = sata_probe_device(sata_hba_inst, &sata_device);
8223 		if (rval != SATA_SUCCESS ||
8224 		    sata_device.satadev_type == SATA_DTYPE_UNKNOWN)
8225 			return (SATA_FAILURE);
8226 
8227 		mutex_enter(&cportinfo->cport_mutex);
8228 		sata_show_drive_info(sata_hba_inst,
8229 		    SATA_CPORTINFO_DRV_INFO(cportinfo));
8230 
8231 		if ((sata_device.satadev_type & SATA_VALID_DEV_TYPE) == 0) {
8232 			/*
8233 			 * Could not determine device type or
8234 			 * a device is not supported.
8235 			 * Degrade this device to unknown.
8236 			 */
8237 			cportinfo->cport_dev_type = SATA_DTYPE_UNKNOWN;
8238 			mutex_exit(&cportinfo->cport_mutex);
8239 			return (SATA_SUCCESS);
8240 		}
8241 		cportinfo->cport_dev_type = sata_device.satadev_type;
8242 		cportinfo->cport_tgtnode_clean = B_TRUE;
8243 		mutex_exit(&cportinfo->cport_mutex);
8244 
8245 		/*
8246 		 * Initialize device to the desired state. Even if it
8247 		 * fails, the device will still attach but syslog
8248 		 * will show the warning.
8249 		 */
8250 		if (sata_initialize_device(sata_hba_inst,
8251 		    SATA_CPORTINFO_DRV_INFO(cportinfo)) != SATA_SUCCESS)
8252 			/* Retry */
8253 			(void) sata_initialize_device(sata_hba_inst,
8254 			    SATA_CPORTINFO_DRV_INFO(cportinfo));
8255 
8256 		cdip = sata_create_target_node(pdip, sata_hba_inst,
8257 		    &sata_device.satadev_addr);
8258 		mutex_enter(&cportinfo->cport_mutex);
8259 		if (cdip == NULL) {
8260 			/*
8261 			 * Attaching target node failed.
8262 			 * We retain sata_drive_info structure...
8263 			 */
8264 			mutex_exit(&cportinfo->cport_mutex);
8265 			return (SATA_SUCCESS);
8266 		}
8267 		(SATA_CPORTINFO_DRV_INFO(cportinfo))->
8268 		    satadrv_state = SATA_STATE_READY;
8269 	} else {
8270 		/* This must be Port Multiplier type */
8271 		if (cportinfo->cport_dev_type != SATA_DTYPE_PMULT) {
8272 			SATA_LOG_D((sata_hba_inst, CE_WARN,
8273 			    "sata_add_device: "
8274 			    "unrecognized dev type %x",
8275 			    cportinfo->cport_dev_type));
8276 			mutex_exit(&cportinfo->cport_mutex);
8277 			return (SATA_SUCCESS);
8278 		}
8279 		pminfo = SATA_CPORTINFO_PMULT_INFO(cportinfo);
8280 		pmportinfo = pminfo->pmult_dev_port[pmport];
8281 		sata_device.satadev_addr = pmportinfo->pmport_addr;
8282 		sata_device.satadev_addr.qual = SATA_ADDR_DPMPORT;
8283 		mutex_exit(&cportinfo->cport_mutex);
8284 
8285 		rval = sata_probe_device(sata_hba_inst, &sata_device);
8286 		if (rval != SATA_SUCCESS ||
8287 		    sata_device.satadev_type == SATA_DTYPE_UNKNOWN) {
8288 			return (SATA_FAILURE);
8289 		}
8290 		mutex_enter(&cportinfo->cport_mutex);
8291 		sata_show_drive_info(sata_hba_inst,
8292 		    SATA_CPORTINFO_DRV_INFO(cportinfo));
8293 
8294 		if ((sata_device.satadev_type & SATA_VALID_DEV_TYPE) == 0) {
8295 			/*
8296 			 * Could not determine device type.
8297 			 * Degrade this device to unknown.
8298 			 */
8299 			pmportinfo->pmport_dev_type = SATA_DTYPE_UNKNOWN;
8300 			mutex_exit(&cportinfo->cport_mutex);
8301 			return (SATA_SUCCESS);
8302 		}
8303 		pmportinfo->pmport_dev_type = sata_device.satadev_type;
8304 		pmportinfo->pmport_tgtnode_clean = B_TRUE;
8305 		mutex_exit(&cportinfo->cport_mutex);
8306 
8307 		/*
8308 		 * Initialize device to the desired state.
8309 		 * Even if it fails, the device will still
8310 		 * attach but syslog will show the warning.
8311 		 */
8312 		if (sata_initialize_device(sata_hba_inst,
8313 		    pmportinfo->pmport_sata_drive) != SATA_SUCCESS)
8314 			/* Retry */
8315 			(void) sata_initialize_device(sata_hba_inst,
8316 			    pmportinfo->pmport_sata_drive);
8317 
8318 		cdip = sata_create_target_node(pdip, sata_hba_inst,
8319 		    &sata_device.satadev_addr);
8320 		mutex_enter(&cportinfo->cport_mutex);
8321 		if (cdip == NULL) {
8322 			/*
8323 			 * Attaching target node failed.
8324 			 * We retain sata_drive_info structure...
8325 			 */
8326 			mutex_exit(&cportinfo->cport_mutex);
8327 			return (SATA_SUCCESS);
8328 		}
8329 		pmportinfo->pmport_sata_drive->satadrv_state |=
8330 		    SATA_STATE_READY;
8331 	}
8332 	mutex_exit(&cportinfo->cport_mutex);
8333 	return (SATA_SUCCESS);
8334 }
8335 
8336 
8337 
8338 /*
8339  * Create scsi target node for attached device, create node properties and
8340  * attach the node.
8341  * The node could be removed if the device onlining fails.
8342  *
8343  * A dev_info_t pointer is returned if operation is successful, NULL is
8344  * returned otherwise.
8345  *
8346  * No port multiplier support.
8347  */
8348 
8349 static dev_info_t *
8350 sata_create_target_node(dev_info_t *dip, sata_hba_inst_t *sata_hba_inst,
8351 			sata_address_t *sata_addr)
8352 {
8353 	dev_info_t *cdip = NULL;
8354 	int rval;
8355 	char *nname = NULL;
8356 	char **compatible = NULL;
8357 	int ncompatible;
8358 	struct scsi_inquiry inq;
8359 	sata_device_t sata_device;
8360 	sata_drive_info_t *sdinfo;
8361 	int target;
8362 	int i;
8363 
8364 	sata_device.satadev_rev = SATA_DEVICE_REV;
8365 	sata_device.satadev_addr = *sata_addr;
8366 
8367 	mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, sata_addr->cport)));
8368 
8369 	sdinfo = sata_get_device_info(sata_hba_inst, &sata_device);
8370 
8371 	target = SATA_TO_SCSI_TARGET(sata_addr->cport,
8372 	    sata_addr->pmport, sata_addr->qual);
8373 
8374 	if (sdinfo == NULL) {
8375 		mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst,
8376 		    sata_addr->cport)));
8377 		SATA_LOG_D((sata_hba_inst, CE_WARN,
8378 		    "sata_create_target_node: no sdinfo for target %x",
8379 		    target));
8380 		return (NULL);
8381 	}
8382 
8383 	/*
8384 	 * create or get scsi inquiry data, expected by
8385 	 * scsi_hba_nodename_compatible_get()
8386 	 * SATA hard disks get Identify Data translated into Inguiry Data.
8387 	 * ATAPI devices respond directly to Inquiry request.
8388 	 */
8389 	if (sdinfo->satadrv_type == SATA_DTYPE_ATADISK) {
8390 		sata_identdev_to_inquiry(sata_hba_inst, sdinfo,
8391 		    (uint8_t *)&inq);
8392 		mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst,
8393 		    sata_addr->cport)));
8394 	} else { /* Assume supported ATAPI device */
8395 		mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst,
8396 		    sata_addr->cport)));
8397 		if (sata_get_atapi_inquiry_data(sata_hba_inst, sata_addr,
8398 		    &inq) == SATA_FAILURE)
8399 			return (NULL);
8400 		/*
8401 		 * Save supported ATAPI transport version
8402 		 */
8403 		sdinfo->satadrv_atapi_trans_ver =
8404 		    SATA_ATAPI_TRANS_VERSION(&inq);
8405 	}
8406 
8407 	/* determine the node name and compatible */
8408 	scsi_hba_nodename_compatible_get(&inq, NULL,
8409 	    inq.inq_dtype, NULL, &nname, &compatible, &ncompatible);
8410 
8411 #ifdef SATA_DEBUG
8412 	if (sata_debug_flags & SATA_DBG_NODES) {
8413 		if (nname == NULL) {
8414 			cmn_err(CE_NOTE, "sata_create_target_node: "
8415 			    "cannot determine nodename for target %d\n",
8416 			    target);
8417 		} else {
8418 			cmn_err(CE_WARN, "sata_create_target_node: "
8419 			    "target %d nodename: %s\n", target, nname);
8420 		}
8421 		if (compatible == NULL) {
8422 			cmn_err(CE_WARN,
8423 			    "sata_create_target_node: no compatible name\n");
8424 		} else {
8425 			for (i = 0; i < ncompatible; i++) {
8426 				cmn_err(CE_WARN, "sata_create_target_node: "
8427 				    "compatible name: %s\n", compatible[i]);
8428 			}
8429 		}
8430 	}
8431 #endif
8432 
8433 	/* if nodename can't be determined, log error and exit */
8434 	if (nname == NULL) {
8435 		SATA_LOG_D((sata_hba_inst, CE_WARN,
8436 		    "sata_create_target_node: cannot determine nodename "
8437 		    "for target %d\n", target));
8438 		scsi_hba_nodename_compatible_free(nname, compatible);
8439 		return (NULL);
8440 	}
8441 	/*
8442 	 * Create scsi target node
8443 	 */
8444 	ndi_devi_alloc_sleep(dip, nname, (pnode_t)DEVI_SID_NODEID, &cdip);
8445 	rval = ndi_prop_update_string(DDI_DEV_T_NONE, cdip,
8446 	    "device-type", "scsi");
8447 
8448 	if (rval != DDI_PROP_SUCCESS) {
8449 		SATA_LOG_D((sata_hba_inst, CE_WARN, "sata_create_target_node: "
8450 		    "updating device_type prop failed %d", rval));
8451 		goto fail;
8452 	}
8453 
8454 	/*
8455 	 * Create target node properties: target & lun
8456 	 */
8457 	rval = ndi_prop_update_int(DDI_DEV_T_NONE, cdip, "target", target);
8458 	if (rval != DDI_PROP_SUCCESS) {
8459 		SATA_LOG_D((sata_hba_inst, CE_WARN, "sata_create_target_node: "
8460 		    "updating target prop failed %d", rval));
8461 		goto fail;
8462 	}
8463 	rval = ndi_prop_update_int(DDI_DEV_T_NONE, cdip, "lun", 0);
8464 	if (rval != DDI_PROP_SUCCESS) {
8465 		SATA_LOG_D((sata_hba_inst, CE_WARN, "sata_create_target_node: "
8466 		    "updating target prop failed %d", rval));
8467 		goto fail;
8468 	}
8469 
8470 	if (sdinfo->satadrv_type == SATA_DTYPE_ATAPICD) {
8471 		/*
8472 		 * Add "variant" property
8473 		 */
8474 		rval = ndi_prop_update_string(DDI_DEV_T_NONE, cdip,
8475 		    "variant", "atapi");
8476 		if (rval != DDI_PROP_SUCCESS) {
8477 			SATA_LOG_D((sata_hba_inst, CE_WARN,
8478 			    "sata_create_target_node: variant atapi "
8479 			    "property could not be created: %d", rval));
8480 			goto fail;
8481 		}
8482 	}
8483 	/* decorate the node with compatible */
8484 	if (ndi_prop_update_string_array(DDI_DEV_T_NONE, cdip, "compatible",
8485 	    compatible, ncompatible) != DDI_PROP_SUCCESS) {
8486 		SATA_LOG_D((sata_hba_inst, CE_WARN,
8487 		    "sata_create_target_node: FAIL compatible props cdip 0x%p",
8488 		    (void *)cdip));
8489 		goto fail;
8490 	}
8491 
8492 
8493 	/*
8494 	 * Now, try to attach the driver. If probing of the device fails,
8495 	 * the target node may be removed
8496 	 */
8497 	rval = ndi_devi_online(cdip, NDI_ONLINE_ATTACH);
8498 
8499 	scsi_hba_nodename_compatible_free(nname, compatible);
8500 
8501 	if (rval == NDI_SUCCESS)
8502 		return (cdip);
8503 
8504 	/* target node was removed - are we sure? */
8505 	return (NULL);
8506 
8507 fail:
8508 	scsi_hba_nodename_compatible_free(nname, compatible);
8509 	ddi_prop_remove_all(cdip);
8510 	rval = ndi_devi_free(cdip);
8511 	if (rval != NDI_SUCCESS) {
8512 		SATA_LOG_D((sata_hba_inst, CE_WARN, "sata_create_target_node: "
8513 		    "node removal failed %d", rval));
8514 	}
8515 	sata_log(sata_hba_inst, CE_WARN, "sata_create_target_node: "
8516 	    "cannot create target node for SATA device at port %d",
8517 	    sata_addr->cport);
8518 	return (NULL);
8519 }
8520 
8521 
8522 
8523 /*
8524  * Re-probe sata port, check for a device and attach info
8525  * structures when necessary. Identify Device data is fetched, if possible.
8526  * Assumption: sata address is already validated.
8527  * SATA_SUCCESS is returned if port is re-probed sucessfully, regardless of
8528  * the presence of a device and its type.
8529  *
8530  * flag arg specifies that the function should try multiple times to identify
8531  * device type and to initialize it, or it should return immediately on failure.
8532  * SATA_DEV_IDENTIFY_RETRY - retry
8533  * SATA_DEV_IDENTIFY_NORETRY - no retry
8534  *
8535  * SATA_FAILURE is returned if one of the operations failed.
8536  *
8537  * This function cannot be called in interrupt context - it may sleep.
8538  */
8539 static int
8540 sata_reprobe_port(sata_hba_inst_t *sata_hba_inst, sata_device_t *sata_device,
8541     int flag)
8542 {
8543 	sata_cport_info_t *cportinfo;
8544 	sata_drive_info_t *sdinfo;
8545 	boolean_t init_device = B_FALSE;
8546 	int prev_device_type = SATA_DTYPE_NONE;
8547 	int prev_device_settings = 0;
8548 	clock_t start_time;
8549 	int retry = B_FALSE;
8550 	int rval;
8551 
8552 	/* We only care about host sata cport for now */
8553 	cportinfo = SATA_CPORT_INFO(sata_hba_inst,
8554 	    sata_device->satadev_addr.cport);
8555 	sdinfo = SATA_CPORTINFO_DRV_INFO(cportinfo);
8556 	if (sdinfo != NULL) {
8557 		/*
8558 		 * We are re-probing port with a previously attached device.
8559 		 * Save previous device type and settings
8560 		 */
8561 		prev_device_type = cportinfo->cport_dev_type;
8562 		prev_device_settings = sdinfo->satadrv_settings;
8563 	}
8564 	if (flag == SATA_DEV_IDENTIFY_RETRY) {
8565 		start_time = ddi_get_lbolt();
8566 		retry = B_TRUE;
8567 	}
8568 retry_probe:
8569 
8570 	/* probe port */
8571 	mutex_enter(&cportinfo->cport_mutex);
8572 	cportinfo->cport_state &= ~SATA_PORT_STATE_CLEAR_MASK;
8573 	cportinfo->cport_state |= SATA_STATE_PROBING;
8574 	mutex_exit(&cportinfo->cport_mutex);
8575 
8576 	rval = (*SATA_PROBE_PORT_FUNC(sata_hba_inst))
8577 	    (SATA_DIP(sata_hba_inst), sata_device);
8578 
8579 	mutex_enter(&cportinfo->cport_mutex);
8580 	if (rval != SATA_SUCCESS) {
8581 		cportinfo->cport_state = SATA_PSTATE_FAILED;
8582 		mutex_exit(&cportinfo->cport_mutex);
8583 		SATA_LOG_D((sata_hba_inst, CE_WARN, "sata_reprobe_port: "
8584 		    "SATA port %d probing failed",
8585 		    cportinfo->cport_addr.cport));
8586 		return (SATA_FAILURE);
8587 	}
8588 
8589 	/*
8590 	 * update sata port state and set device type
8591 	 */
8592 	sata_update_port_info(sata_hba_inst, sata_device);
8593 	cportinfo->cport_state &= ~SATA_STATE_PROBING;
8594 
8595 	/*
8596 	 * Sanity check - Port is active? Is the link active?
8597 	 * Is there any device attached?
8598 	 */
8599 	if ((cportinfo->cport_state &
8600 	    (SATA_PSTATE_SHUTDOWN | SATA_PSTATE_FAILED)) ||
8601 	    (cportinfo->cport_scr.sstatus & SATA_PORT_DEVLINK_UP_MASK) !=
8602 	    SATA_PORT_DEVLINK_UP) {
8603 		/*
8604 		 * Port in non-usable state or no link active/no device.
8605 		 * Free info structure if necessary (direct attached drive
8606 		 * only, for now!
8607 		 */
8608 		sdinfo = SATA_CPORTINFO_DRV_INFO(cportinfo);
8609 		SATA_CPORTINFO_DRV_INFO(cportinfo) = NULL;
8610 		/* Add here differentiation for device attached or not */
8611 		cportinfo->cport_dev_type = SATA_DTYPE_NONE;
8612 		mutex_exit(&cportinfo->cport_mutex);
8613 		if (sdinfo != NULL)
8614 			kmem_free(sdinfo, sizeof (sata_drive_info_t));
8615 		return (SATA_SUCCESS);
8616 	}
8617 
8618 	cportinfo->cport_state |= SATA_STATE_READY;
8619 	cportinfo->cport_dev_type = sata_device->satadev_type;
8620 	sdinfo = SATA_CPORTINFO_DRV_INFO(cportinfo);
8621 
8622 	/*
8623 	 * If we are re-probing the port, there may be
8624 	 * sata_drive_info structure attached
8625 	 * (or sata_pm_info, if PMult is supported).
8626 	 */
8627 	if (sata_device->satadev_type == SATA_DTYPE_NONE) {
8628 		/*
8629 		 * There is no device, so remove device info structure,
8630 		 * if necessary. Direct attached drive only!
8631 		 */
8632 		SATA_CPORTINFO_DRV_INFO(cportinfo) = NULL;
8633 		cportinfo->cport_dev_type = SATA_DTYPE_NONE;
8634 		if (sdinfo != NULL) {
8635 			kmem_free(sdinfo, sizeof (sata_drive_info_t));
8636 			sata_log(sata_hba_inst, CE_WARN,
8637 			    "SATA device detached "
8638 			    "from port %d", cportinfo->cport_addr.cport);
8639 		}
8640 		mutex_exit(&cportinfo->cport_mutex);
8641 		return (SATA_SUCCESS);
8642 	}
8643 
8644 	if (sata_device->satadev_type != SATA_DTYPE_PMULT) {
8645 		if (sdinfo == NULL) {
8646 			/*
8647 			 * There is some device attached, but there is
8648 			 * no sata_drive_info structure - allocate one
8649 			 */
8650 			mutex_exit(&cportinfo->cport_mutex);
8651 			sdinfo = kmem_zalloc(
8652 			    sizeof (sata_drive_info_t), KM_SLEEP);
8653 			mutex_enter(&cportinfo->cport_mutex);
8654 			/*
8655 			 * Recheck, that the port state did not change when we
8656 			 * released mutex.
8657 			 */
8658 			if (cportinfo->cport_state & SATA_STATE_READY) {
8659 				SATA_CPORTINFO_DRV_INFO(cportinfo) = sdinfo;
8660 				sdinfo->satadrv_addr = cportinfo->cport_addr;
8661 				sdinfo->satadrv_addr.qual = SATA_ADDR_DCPORT;
8662 				sdinfo->satadrv_type = SATA_DTYPE_UNKNOWN;
8663 				sdinfo->satadrv_state = SATA_STATE_UNKNOWN;
8664 			} else {
8665 				/*
8666 				 * Port is not in ready state, we
8667 				 * cannot attach a device.
8668 				 */
8669 				mutex_exit(&cportinfo->cport_mutex);
8670 				kmem_free(sdinfo, sizeof (sata_drive_info_t));
8671 				return (SATA_SUCCESS);
8672 			}
8673 			/*
8674 			 * Since we are adding device, presumably new one,
8675 			 * indicate that it  should be initalized,
8676 			 * as well as some internal framework states).
8677 			 */
8678 			init_device = B_TRUE;
8679 		}
8680 		cportinfo->cport_dev_type = SATA_DTYPE_UNKNOWN;
8681 		sata_device->satadev_addr.qual = sdinfo->satadrv_addr.qual;
8682 	} else {
8683 		/*
8684 		 * The device is a port multiplier - not handled now.
8685 		 */
8686 		cportinfo->cport_dev_type = SATA_DTYPE_UNKNOWN;
8687 		mutex_exit(&cportinfo->cport_mutex);
8688 		return (SATA_SUCCESS);
8689 	}
8690 	mutex_exit(&cportinfo->cport_mutex);
8691 	/*
8692 	 * Figure out what kind of device we are really
8693 	 * dealing with.
8694 	 */
8695 	rval = sata_probe_device(sata_hba_inst, sata_device);
8696 
8697 	if (rval == SATA_SUCCESS) {
8698 		/*
8699 		 * If we are dealing with the same type of a device as before,
8700 		 * restore its settings flags.
8701 		 */
8702 		if (sata_device->satadev_type == prev_device_type)
8703 			sdinfo->satadrv_settings = prev_device_settings;
8704 
8705 		/* Set initial device features, if necessary */
8706 		if (init_device == B_TRUE) {
8707 			rval = sata_initialize_device(sata_hba_inst, sdinfo);
8708 		}
8709 		if (rval == SATA_SUCCESS)
8710 			return (rval);
8711 	}
8712 
8713 	if (retry) {
8714 		clock_t cur_time = ddi_get_lbolt();
8715 		/*
8716 		 * A device was not successfully identified or initialized.
8717 		 * Track retry time for device identification.
8718 		 */
8719 		if ((cur_time - start_time) <
8720 		    drv_usectohz(SATA_DEV_IDENTIFY_TIMEOUT)) {
8721 			/* sleep for a while */
8722 			delay(drv_usectohz(SATA_DEV_IDENTIFY_RTR_DLY));
8723 			goto retry_probe;
8724 		}
8725 	}
8726 	return (rval);
8727 }
8728 
8729 /*
8730  * Initialize device
8731  * Specified device is initialized to a default state.
8732  *
8733  * Returns SATA_SUCCESS if all device features are set successfully,
8734  * SATA_FAILURE otherwise
8735  */
8736 static int
8737 sata_initialize_device(sata_hba_inst_t *sata_hba_inst,
8738     sata_drive_info_t *sdinfo)
8739 {
8740 	int rval;
8741 
8742 	sata_save_drive_settings(sdinfo);
8743 
8744 	sdinfo->satadrv_settings |= SATA_DEV_READ_AHEAD;
8745 
8746 	sata_init_write_cache_mode(sdinfo);
8747 
8748 	rval = sata_set_drive_features(sata_hba_inst, sdinfo, 0);
8749 
8750 	/* Determine current data transfer mode */
8751 	if ((sdinfo->satadrv_id.ai_cap & SATA_DMA_SUPPORT) == 0) {
8752 		sdinfo->satadrv_settings &= ~SATA_DEV_DMA;
8753 	} else if ((sdinfo->satadrv_id.ai_validinfo &
8754 	    SATA_VALIDINFO_88) != 0 &&
8755 	    (sdinfo->satadrv_id.ai_ultradma & SATA_UDMA_SEL_MASK) != 0) {
8756 		sdinfo->satadrv_settings |= SATA_DEV_DMA;
8757 	} else if ((sdinfo->satadrv_id.ai_dworddma &
8758 	    SATA_MDMA_SEL_MASK) != 0) {
8759 		sdinfo->satadrv_settings |= SATA_DEV_DMA;
8760 	} else
8761 		/* DMA supported, not no DMA transfer mode is selected !? */
8762 		sdinfo->satadrv_settings &= ~SATA_DEV_DMA;
8763 
8764 	return (rval);
8765 }
8766 
8767 
8768 /*
8769  * Initialize write cache mode.
8770  *
8771  * The default write cache setting for SATA HDD is provided by sata_write_cache
8772  * static variable. ATAPI CD/DVDs devices have write cache default is
8773  * determined by sata_atapicdvd_write_cache static variable.
8774  * 1 - enable
8775  * 0 - disable
8776  * any other value - current drive setting
8777  *
8778  * Although there is not reason to disable write cache on CD/DVD devices,
8779  * the default setting control is provided for the maximun flexibility.
8780  *
8781  * In the future, it may be overridden by the
8782  * disk-write-cache-enable property setting, if it is defined.
8783  * Returns SATA_SUCCESS if all device features are set successfully,
8784  * SATA_FAILURE otherwise.
8785  */
8786 static void
8787 sata_init_write_cache_mode(sata_drive_info_t *sdinfo)
8788 {
8789 	if (sdinfo->satadrv_type == SATA_DTYPE_ATADISK) {
8790 		if (sata_write_cache == 1)
8791 			sdinfo->satadrv_settings |= SATA_DEV_WRITE_CACHE;
8792 		else if (sata_write_cache == 0)
8793 			sdinfo->satadrv_settings &= ~SATA_DEV_WRITE_CACHE;
8794 		/*
8795 		 * When sata_write_cache value is not 0 or 1,
8796 		 * a current setting of the drive's write cache is used.
8797 		 */
8798 	} else { /* Assume ATAPI CD/DVD device */
8799 		if (sata_atapicdvd_write_cache == 1)
8800 			sdinfo->satadrv_settings |= SATA_DEV_WRITE_CACHE;
8801 		else if (sata_atapicdvd_write_cache == 0)
8802 			sdinfo->satadrv_settings &= ~SATA_DEV_WRITE_CACHE;
8803 		/*
8804 		 * When sata_write_cache value is not 0 or 1,
8805 		 * a current setting of the drive's write cache is used.
8806 		 */
8807 	}
8808 }
8809 
8810 
8811 /*
8812  * Validate sata address.
8813  * Specified cport, pmport and qualifier has to match
8814  * passed sata_scsi configuration info.
8815  * The presence of an attached device is not verified.
8816  *
8817  * Returns 0 when address is valid, -1 otherwise.
8818  */
8819 static int
8820 sata_validate_sata_address(sata_hba_inst_t *sata_hba_inst, int cport,
8821 	int pmport, int qual)
8822 {
8823 	if (qual == SATA_ADDR_DCPORT && pmport != 0)
8824 		goto invalid_address;
8825 	if (cport >= SATA_NUM_CPORTS(sata_hba_inst))
8826 		goto invalid_address;
8827 	if ((qual == SATA_ADDR_DPMPORT || qual == SATA_ADDR_PMPORT) &&
8828 	    ((SATA_CPORT_DEV_TYPE(sata_hba_inst, cport) != SATA_DTYPE_PMULT) ||
8829 	    (SATA_PMULT_INFO(sata_hba_inst, cport) == NULL) ||
8830 	    (pmport >= SATA_NUM_PMPORTS(sata_hba_inst, cport))))
8831 		goto invalid_address;
8832 
8833 	return (0);
8834 
8835 invalid_address:
8836 	return (-1);
8837 
8838 }
8839 
8840 /*
8841  * Validate scsi address
8842  * SCSI target address is translated into SATA cport/pmport and compared
8843  * with a controller port/device configuration. LUN has to be 0.
8844  * Returns 0 if a scsi target refers to an attached device,
8845  * returns 1 if address is valid but device is not attached,
8846  * returns -1 if bad address or device is of an unsupported type.
8847  * Upon return sata_device argument is set.
8848  */
8849 static int
8850 sata_validate_scsi_address(sata_hba_inst_t *sata_hba_inst,
8851 	struct scsi_address *ap, sata_device_t *sata_device)
8852 {
8853 	int cport, pmport, qual, rval;
8854 
8855 	rval = -1;	/* Invalid address */
8856 	if (ap->a_lun != 0)
8857 		goto out;
8858 
8859 	qual = SCSI_TO_SATA_ADDR_QUAL(ap->a_target);
8860 	cport = SCSI_TO_SATA_CPORT(ap->a_target);
8861 	pmport = SCSI_TO_SATA_PMPORT(ap->a_target);
8862 
8863 	if (qual != SATA_ADDR_DCPORT && qual != SATA_ADDR_DPMPORT)
8864 		goto out;
8865 
8866 	if (sata_validate_sata_address(sata_hba_inst, cport, pmport, qual) ==
8867 	    0) {
8868 
8869 		sata_cport_info_t *cportinfo;
8870 		sata_pmult_info_t *pmultinfo;
8871 		sata_drive_info_t *sdinfo = NULL;
8872 
8873 		rval = 1;	/* Valid sata address */
8874 
8875 		cportinfo = SATA_CPORT_INFO(sata_hba_inst, cport);
8876 		if (qual == SATA_ADDR_DCPORT) {
8877 			if (cportinfo == NULL ||
8878 			    cportinfo->cport_dev_type == SATA_DTYPE_NONE)
8879 				goto out;
8880 
8881 			if (cportinfo->cport_dev_type == SATA_DTYPE_PMULT ||
8882 			    (cportinfo->cport_dev_type &
8883 			    SATA_VALID_DEV_TYPE) == 0) {
8884 				rval = -1;
8885 				goto out;
8886 			}
8887 			sdinfo = SATA_CPORTINFO_DRV_INFO(cportinfo);
8888 
8889 		} else if (qual == SATA_ADDR_DPMPORT) {
8890 			pmultinfo = SATA_CPORTINFO_PMULT_INFO(cportinfo);
8891 			if (pmultinfo == NULL) {
8892 				rval = -1;
8893 				goto out;
8894 			}
8895 			if (SATA_PMPORT_INFO(sata_hba_inst, cport, pmport) ==
8896 			    NULL ||
8897 			    SATA_PMPORT_DEV_TYPE(sata_hba_inst, cport,
8898 			    pmport) == SATA_DTYPE_NONE)
8899 				goto out;
8900 
8901 			sdinfo = SATA_PMPORT_DRV_INFO(sata_hba_inst, cport,
8902 			    pmport);
8903 		} else {
8904 			rval = -1;
8905 			goto out;
8906 		}
8907 		if ((sdinfo == NULL) ||
8908 		    (sdinfo->satadrv_type & SATA_VALID_DEV_TYPE) == 0)
8909 			goto out;
8910 
8911 		sata_device->satadev_type = sdinfo->satadrv_type;
8912 		sata_device->satadev_addr.qual = qual;
8913 		sata_device->satadev_addr.cport = cport;
8914 		sata_device->satadev_addr.pmport = pmport;
8915 		sata_device->satadev_rev = SATA_DEVICE_REV_1;
8916 		return (0);
8917 	}
8918 out:
8919 	if (rval == 1) {
8920 		SATADBG2(SATA_DBG_SCSI_IF, sata_hba_inst,
8921 		    "sata_validate_scsi_address: no valid target %x lun %x",
8922 		    ap->a_target, ap->a_lun);
8923 	}
8924 	return (rval);
8925 }
8926 
8927 /*
8928  * Find dip corresponding to passed device number
8929  *
8930  * Returns NULL if invalid device number is passed or device cannot be found,
8931  * Returns dip is device is found.
8932  */
8933 static dev_info_t *
8934 sata_devt_to_devinfo(dev_t dev)
8935 {
8936 	dev_info_t *dip;
8937 #ifndef __lock_lint
8938 	struct devnames *dnp;
8939 	major_t major = getmajor(dev);
8940 	int instance = SATA_MINOR2INSTANCE(getminor(dev));
8941 
8942 	if (major >= devcnt)
8943 		return (NULL);
8944 
8945 	dnp = &devnamesp[major];
8946 	LOCK_DEV_OPS(&(dnp->dn_lock));
8947 	dip = dnp->dn_head;
8948 	while (dip && (ddi_get_instance(dip) != instance)) {
8949 		dip = ddi_get_next(dip);
8950 	}
8951 	UNLOCK_DEV_OPS(&(dnp->dn_lock));
8952 #endif
8953 
8954 	return (dip);
8955 }
8956 
8957 
8958 /*
8959  * Probe device.
8960  * This function issues Identify Device command and initializes local
8961  * sata_drive_info structure if the device can be identified.
8962  * The device type is determined by examining Identify Device
8963  * command response.
8964  * If the sata_hba_inst has linked drive info structure for this
8965  * device address, the Identify Device data is stored into sata_drive_info
8966  * structure linked to the port info structure.
8967  *
8968  * sata_device has to refer to the valid sata port(s) for HBA described
8969  * by sata_hba_inst structure.
8970  *
8971  * Returns:
8972  *	SATA_SUCCESS if device type was successfully probed and port-linked
8973  *		drive info structure was updated;
8974  * 	SATA_FAILURE if there is no device, or device was not probed
8975  *		successully;
8976  *	SATA_RETRY if device probe can be retried later.
8977  * If a device cannot be identified, sata_device's dev_state and dev_type
8978  * fields are set to unknown.
8979  * There are no retries in this function. Any retries should be managed by
8980  * the caller.
8981  */
8982 
8983 
8984 static int
8985 sata_probe_device(sata_hba_inst_t *sata_hba_inst, sata_device_t *sata_device)
8986 {
8987 	sata_drive_info_t *sdinfo;
8988 	sata_drive_info_t new_sdinfo;	/* local drive info struct */
8989 	int rval;
8990 
8991 	ASSERT((SATA_CPORT_STATE(sata_hba_inst,
8992 	    sata_device->satadev_addr.cport) &
8993 	    (SATA_STATE_PROBED | SATA_STATE_READY)) != 0);
8994 
8995 	sata_device->satadev_type = SATA_DTYPE_NONE;
8996 
8997 	mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst,
8998 	    sata_device->satadev_addr.cport)));
8999 
9000 	/* Get pointer to port-linked sata device info structure */
9001 	sdinfo = sata_get_device_info(sata_hba_inst, sata_device);
9002 	if (sdinfo != NULL) {
9003 		sdinfo->satadrv_state &=
9004 		    ~(SATA_STATE_PROBED | SATA_STATE_READY);
9005 		sdinfo->satadrv_state |= SATA_STATE_PROBING;
9006 	} else {
9007 		/* No device to probe */
9008 		mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst,
9009 		    sata_device->satadev_addr.cport)));
9010 		sata_device->satadev_type = SATA_DTYPE_NONE;
9011 		sata_device->satadev_state = SATA_STATE_UNKNOWN;
9012 		return (SATA_FAILURE);
9013 	}
9014 	/*
9015 	 * Need to issue both types of identify device command and
9016 	 * determine device type by examining retreived data/status.
9017 	 * First, ATA Identify Device.
9018 	 */
9019 	bzero(&new_sdinfo, sizeof (sata_drive_info_t));
9020 	new_sdinfo.satadrv_addr = sata_device->satadev_addr;
9021 	mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst,
9022 	    sata_device->satadev_addr.cport)));
9023 	new_sdinfo.satadrv_type = SATA_DTYPE_ATADISK;
9024 	rval = sata_identify_device(sata_hba_inst, &new_sdinfo);
9025 	if (rval == SATA_RETRY) {
9026 		/* We may try to check for ATAPI device */
9027 		if (SATA_FEATURES(sata_hba_inst) & SATA_CTLF_ATAPI) {
9028 			/*
9029 			 * HBA supports ATAPI - try to issue Identify Packet
9030 			 * Device command.
9031 			 */
9032 			new_sdinfo.satadrv_type = SATA_DTYPE_ATAPICD;
9033 			rval = sata_identify_device(sata_hba_inst, &new_sdinfo);
9034 		}
9035 	}
9036 	if (rval == SATA_SUCCESS) {
9037 		/*
9038 		 * Got something responding positively to ATA Identify Device
9039 		 * or to Identify Packet Device cmd.
9040 		 * Save last used device type.
9041 		 */
9042 		sata_device->satadev_type = new_sdinfo.satadrv_type;
9043 
9044 		/* save device info, if possible */
9045 		mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst,
9046 		    sata_device->satadev_addr.cport)));
9047 		sdinfo = sata_get_device_info(sata_hba_inst, sata_device);
9048 		if (sdinfo == NULL) {
9049 			mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst,
9050 			    sata_device->satadev_addr.cport)));
9051 			return (SATA_FAILURE);
9052 		}
9053 		/*
9054 		 * Copy drive info into the port-linked drive info structure.
9055 		 */
9056 		*sdinfo = new_sdinfo;
9057 		sdinfo->satadrv_state &= ~SATA_STATE_PROBING;
9058 		sdinfo->satadrv_state |= SATA_STATE_PROBED;
9059 		if (sata_device->satadev_addr.qual == SATA_ADDR_DCPORT)
9060 			SATA_CPORT_DEV_TYPE(sata_hba_inst,
9061 			    sata_device->satadev_addr.cport) =
9062 			    sdinfo->satadrv_type;
9063 		else /* SATA_ADDR_DPMPORT */
9064 			SATA_PMPORT_DEV_TYPE(sata_hba_inst,
9065 			    sata_device->satadev_addr.cport,
9066 			    sata_device->satadev_addr.pmport) =
9067 			    sdinfo->satadrv_type;
9068 		mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst,
9069 		    sata_device->satadev_addr.cport)));
9070 		return (SATA_SUCCESS);
9071 	}
9072 
9073 	/*
9074 	 * It may be SATA_RETRY or SATA_FAILURE return.
9075 	 * Looks like we cannot determine the device type at this time.
9076 	 */
9077 	mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst,
9078 	    sata_device->satadev_addr.cport)));
9079 	sdinfo = sata_get_device_info(sata_hba_inst, sata_device);
9080 	if (sdinfo != NULL) {
9081 		sata_device->satadev_type = SATA_DTYPE_UNKNOWN;
9082 		sdinfo->satadrv_type = SATA_DTYPE_UNKNOWN;
9083 		sdinfo->satadrv_state &= ~SATA_STATE_PROBING;
9084 		sdinfo->satadrv_state = SATA_STATE_PROBED;
9085 		if (sata_device->satadev_addr.qual == SATA_ADDR_DCPORT)
9086 			SATA_CPORT_DEV_TYPE(sata_hba_inst,
9087 			    sata_device->satadev_addr.cport) =
9088 			    SATA_DTYPE_UNKNOWN;
9089 		else {
9090 			/* SATA_ADDR_DPMPORT */
9091 			if ((SATA_PMULT_INFO(sata_hba_inst,
9092 			    sata_device->satadev_addr.cport) != NULL) &&
9093 			    (SATA_PMPORT_INFO(sata_hba_inst,
9094 			    sata_device->satadev_addr.cport,
9095 			    sata_device->satadev_addr.pmport) != NULL))
9096 				SATA_PMPORT_DEV_TYPE(sata_hba_inst,
9097 				    sata_device->satadev_addr.cport,
9098 				    sata_device->satadev_addr.pmport) =
9099 				    SATA_DTYPE_UNKNOWN;
9100 		}
9101 	}
9102 	mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst,
9103 	    sata_device->satadev_addr.cport)));
9104 	return (rval);
9105 }
9106 
9107 
9108 /*
9109  * Get pointer to sata_drive_info structure.
9110  *
9111  * The sata_device has to contain address (cport, pmport and qualifier) for
9112  * specified sata_scsi structure.
9113  *
9114  * Returns NULL if device address is not valid for this HBA configuration.
9115  * Otherwise, returns a pointer to sata_drive_info structure.
9116  *
9117  * This function should be called with a port mutex held.
9118  */
9119 static sata_drive_info_t *
9120 sata_get_device_info(sata_hba_inst_t *sata_hba_inst,
9121     sata_device_t *sata_device)
9122 {
9123 	uint8_t cport = sata_device->satadev_addr.cport;
9124 	uint8_t pmport = sata_device->satadev_addr.pmport;
9125 	uint8_t qual = sata_device->satadev_addr.qual;
9126 
9127 	if (cport >= SATA_NUM_CPORTS(sata_hba_inst))
9128 		return (NULL);
9129 
9130 	if (!(SATA_CPORT_STATE(sata_hba_inst, cport) &
9131 	    (SATA_STATE_PROBED | SATA_STATE_READY)))
9132 		/* Port not probed yet */
9133 		return (NULL);
9134 
9135 	if (SATA_CPORT_DEV_TYPE(sata_hba_inst, cport) == SATA_DTYPE_NONE)
9136 		return (NULL);
9137 
9138 	if (qual == SATA_ADDR_DCPORT) {
9139 		/* Request for a device on a controller port */
9140 		if (SATA_CPORT_DEV_TYPE(sata_hba_inst, cport) ==
9141 		    SATA_DTYPE_PMULT)
9142 			/* Port multiplier attached */
9143 			return (NULL);
9144 		return (SATA_CPORT_DRV_INFO(sata_hba_inst, cport));
9145 	}
9146 	if (qual == SATA_ADDR_DPMPORT) {
9147 		if (SATA_CPORT_DEV_TYPE(sata_hba_inst, cport) !=
9148 		    SATA_DTYPE_PMULT)
9149 			return (NULL);
9150 
9151 		if (pmport > SATA_NUM_PMPORTS(sata_hba_inst, cport))
9152 			return (NULL);
9153 
9154 		return (SATA_PMPORT_DRV_INFO(sata_hba_inst, cport, pmport));
9155 	}
9156 
9157 	/* we should not get here */
9158 	return (NULL);
9159 }
9160 
9161 
9162 /*
9163  * sata_identify_device.
9164  * Send Identify Device command to SATA HBA driver.
9165  * If command executes successfully, update sata_drive_info structure pointed
9166  * to by sdinfo argument, including Identify Device data.
9167  * If command fails, invalidate data in sata_drive_info.
9168  *
9169  * Cannot be called from interrupt level.
9170  *
9171  * Returns:
9172  * SATA_SUCCESS if the device was identified as a supported device,
9173  * SATA_RETRY if the device was not identified but could be retried,
9174  * SATA_FAILURE if the device was not identified and identify attempt
9175  *	should not be retried.
9176  */
9177 static int
9178 sata_identify_device(sata_hba_inst_t *sata_hba_inst,
9179     sata_drive_info_t *sdinfo)
9180 {
9181 	uint16_t cfg_word;
9182 	int rval;
9183 
9184 	/* fetch device identify data */
9185 	if ((rval = sata_fetch_device_identify_data(sata_hba_inst,
9186 	    sdinfo)) != 0)
9187 		goto fail_unknown;
9188 
9189 	cfg_word = sdinfo->satadrv_id.ai_config;
9190 	if (sdinfo->satadrv_type == SATA_DTYPE_ATADISK &&
9191 	    (cfg_word & SATA_ATA_TYPE_MASK) != SATA_ATA_TYPE) {
9192 		/* Change device type to reflect Identify Device data */
9193 		if (((cfg_word & SATA_ATAPI_TYPE_MASK) ==
9194 		    SATA_ATAPI_TYPE) &&
9195 		    ((cfg_word & SATA_ATAPI_ID_DEV_TYPE) ==
9196 		    SATA_ATAPI_CDROM_DEV)) {
9197 			sdinfo->satadrv_type = SATA_DTYPE_ATAPICD;
9198 		} else {
9199 			sdinfo->satadrv_type = SATA_DTYPE_UNKNOWN;
9200 		}
9201 	} else if (sdinfo->satadrv_type == SATA_DTYPE_ATAPICD &&
9202 	    (((cfg_word & SATA_ATAPI_TYPE_MASK) != SATA_ATAPI_TYPE) ||
9203 	    ((cfg_word & SATA_ATAPI_ID_DEV_TYPE) != SATA_ATAPI_CDROM_DEV))) {
9204 		/* Change device type to reflect Identify Device data ! */
9205 		if ((sdinfo->satadrv_id.ai_config & SATA_ATA_TYPE_MASK) ==
9206 		    SATA_ATA_TYPE) {
9207 			sdinfo->satadrv_type = SATA_DTYPE_ATADISK;
9208 		} else {
9209 			sdinfo->satadrv_type = SATA_DTYPE_UNKNOWN;
9210 		}
9211 	}
9212 	if (sdinfo->satadrv_type == SATA_DTYPE_ATADISK) {
9213 		if (sdinfo->satadrv_capacity == 0) {
9214 			/* Non-LBA disk. Too bad... */
9215 			sata_log(sata_hba_inst, CE_WARN,
9216 			    "SATA disk device at port %d does not support LBA",
9217 			    sdinfo->satadrv_addr.cport);
9218 			rval = SATA_FAILURE;
9219 			goto fail_unknown;
9220 		}
9221 	}
9222 #if 0
9223 	/* Left for historical reason */
9224 	/*
9225 	 * Some initial version of SATA spec indicated that at least
9226 	 * UDMA mode 4 has to be supported. It is not metioned in
9227 	 * SerialATA 2.6, so this restriction is removed.
9228 	 */
9229 	/* Check for Ultra DMA modes 6 through 0 being supported */
9230 	for (i = 6; i >= 0; --i) {
9231 		if (sdinfo->satadrv_id.ai_ultradma & (1 << i))
9232 			break;
9233 	}
9234 
9235 	/*
9236 	 * At least UDMA 4 mode has to be supported. If mode 4 or
9237 	 * higher are not supported by the device, fail this
9238 	 * device.
9239 	 */
9240 	if (i < 4) {
9241 		/* No required Ultra DMA mode supported */
9242 		sata_log(sata_hba_inst, CE_WARN,
9243 		    "SATA disk device at port %d does not support UDMA "
9244 		    "mode 4 or higher", sdinfo->satadrv_addr.cport);
9245 		SATA_LOG_D((sata_hba_inst, CE_WARN,
9246 		    "mode 4 or higher required, %d supported", i));
9247 		rval = SATA_FAILURE;
9248 		goto fail_unknown;
9249 	}
9250 #endif
9251 
9252 	return (SATA_SUCCESS);
9253 
9254 fail_unknown:
9255 	/* Invalidate sata_drive_info ? */
9256 	sdinfo->satadrv_type = SATA_DTYPE_UNKNOWN;
9257 	sdinfo->satadrv_state = SATA_STATE_UNKNOWN;
9258 	return (rval);
9259 }
9260 
9261 /*
9262  * Log/display device information
9263  */
9264 static void
9265 sata_show_drive_info(sata_hba_inst_t *sata_hba_inst,
9266     sata_drive_info_t *sdinfo)
9267 {
9268 	int valid_version;
9269 	char msg_buf[MAXPATHLEN];
9270 	int i;
9271 
9272 	/* Show HBA path */
9273 	(void) ddi_pathname(SATA_DIP(sata_hba_inst), msg_buf);
9274 
9275 	cmn_err(CE_CONT, "?%s :\n", msg_buf);
9276 
9277 	if (sdinfo->satadrv_type == SATA_DTYPE_UNKNOWN) {
9278 		(void) sprintf(msg_buf,
9279 		    "Unsupported SATA device type (cfg 0x%x) at ",
9280 		    sdinfo->satadrv_id.ai_config);
9281 	} else {
9282 		(void) sprintf(msg_buf, "SATA %s device at",
9283 		    sdinfo->satadrv_type == SATA_DTYPE_ATADISK ?
9284 		    "disk":"CD/DVD (ATAPI)");
9285 	}
9286 	if (sdinfo->satadrv_addr.qual == SATA_ADDR_DCPORT)
9287 		cmn_err(CE_CONT, "?\t%s port %d\n",
9288 		    msg_buf, sdinfo->satadrv_addr.cport);
9289 	else
9290 		cmn_err(CE_CONT, "?\t%s port %d pmport %d\n",
9291 		    msg_buf, sdinfo->satadrv_addr.cport,
9292 		    sdinfo->satadrv_addr.pmport);
9293 
9294 	bcopy(&sdinfo->satadrv_id.ai_model, msg_buf,
9295 	    sizeof (sdinfo->satadrv_id.ai_model));
9296 	swab(msg_buf, msg_buf, sizeof (sdinfo->satadrv_id.ai_model));
9297 	msg_buf[sizeof (sdinfo->satadrv_id.ai_model)] = '\0';
9298 	cmn_err(CE_CONT, "?\tmodel %s\n", msg_buf);
9299 
9300 	bcopy(&sdinfo->satadrv_id.ai_fw, msg_buf,
9301 	    sizeof (sdinfo->satadrv_id.ai_fw));
9302 	swab(msg_buf, msg_buf, sizeof (sdinfo->satadrv_id.ai_fw));
9303 	msg_buf[sizeof (sdinfo->satadrv_id.ai_fw)] = '\0';
9304 	cmn_err(CE_CONT, "?\tfirmware %s\n", msg_buf);
9305 
9306 	bcopy(&sdinfo->satadrv_id.ai_drvser, msg_buf,
9307 	    sizeof (sdinfo->satadrv_id.ai_drvser));
9308 	swab(msg_buf, msg_buf, sizeof (sdinfo->satadrv_id.ai_drvser));
9309 	msg_buf[sizeof (sdinfo->satadrv_id.ai_drvser)] = '\0';
9310 	if (sdinfo->satadrv_type == SATA_DTYPE_ATADISK) {
9311 		cmn_err(CE_CONT, "?\tserial number %s\n", msg_buf);
9312 	} else {
9313 		/* Assuming ATAPI CD/DVD */
9314 		/*
9315 		 * SOme drives do not implement serial number and may
9316 		 * violate the spec by provinding spaces rather than zeros
9317 		 * in serial number field. Scan the buffer to detect it.
9318 		 */
9319 		for (i = 0; i < sizeof (sdinfo->satadrv_id.ai_drvser); i++) {
9320 			if (msg_buf[i] != '\0' && msg_buf[i] != ' ')
9321 				break;
9322 		}
9323 		if (i == sizeof (sdinfo->satadrv_id.ai_drvser)) {
9324 			cmn_err(CE_CONT, "?\tserial number - none\n");
9325 		} else {
9326 			cmn_err(CE_CONT, "?\tserial number %s\n", msg_buf);
9327 		}
9328 	}
9329 
9330 #ifdef SATA_DEBUG
9331 	if (sdinfo->satadrv_id.ai_majorversion != 0 &&
9332 	    sdinfo->satadrv_id.ai_majorversion != 0xffff) {
9333 		int i;
9334 		for (i = 14; i >= 2; i--) {
9335 			if (sdinfo->satadrv_id.ai_majorversion & (1 << i)) {
9336 				valid_version = i;
9337 				break;
9338 			}
9339 		}
9340 		cmn_err(CE_CONT,
9341 		    "?\tATA/ATAPI-%d supported, majver 0x%x minver 0x%x\n",
9342 		    valid_version,
9343 		    sdinfo->satadrv_id.ai_majorversion,
9344 		    sdinfo->satadrv_id.ai_minorversion);
9345 	}
9346 #endif
9347 	/* Log some info */
9348 	cmn_err(CE_CONT, "?\tsupported features:\n");
9349 	msg_buf[0] = '\0';
9350 	if (sdinfo->satadrv_type == SATA_DTYPE_ATADISK) {
9351 		if (sdinfo->satadrv_features_support & SATA_DEV_F_LBA48)
9352 			(void) strlcat(msg_buf, "48-bit LBA, ", MAXPATHLEN);
9353 		else if (sdinfo->satadrv_features_support & SATA_DEV_F_LBA28)
9354 			(void) strlcat(msg_buf, "28-bit LBA, ", MAXPATHLEN);
9355 	}
9356 	if (sdinfo->satadrv_features_support & SATA_DEV_F_DMA)
9357 		(void) strlcat(msg_buf, "DMA", MAXPATHLEN);
9358 	if (sdinfo->satadrv_features_support & SATA_DEV_F_NCQ)
9359 		(void) strlcat(msg_buf, ", Native Command Queueing",
9360 		    MAXPATHLEN);
9361 	if (sdinfo->satadrv_features_support & SATA_DEV_F_TCQ)
9362 		(void) strlcat(msg_buf, ", Legacy Tagged Queuing", MAXPATHLEN);
9363 	if ((sdinfo->satadrv_id.ai_cmdset82 & SATA_SMART_SUPPORTED) &&
9364 	    (sdinfo->satadrv_id.ai_features85 & SATA_SMART_ENABLED))
9365 		(void) strlcat(msg_buf, ", SMART", MAXPATHLEN);
9366 	if ((sdinfo->satadrv_id.ai_cmdset84 & SATA_SMART_SELF_TEST_SUPPORTED) &&
9367 	    (sdinfo->satadrv_id.ai_features87 & SATA_SMART_SELF_TEST_SUPPORTED))
9368 		(void) strlcat(msg_buf, ", SMART self-test", MAXPATHLEN);
9369 	cmn_err(CE_CONT, "?\t %s\n", msg_buf);
9370 	if (sdinfo->satadrv_features_support & SATA_DEV_F_SATA2)
9371 		cmn_err(CE_CONT, "?\tSATA Gen2 signaling speed (3.0Gbps)\n");
9372 	else if (sdinfo->satadrv_features_support & SATA_DEV_F_SATA1)
9373 		cmn_err(CE_CONT, "?\tSATA Gen1 signaling speed (1.5Gbps)\n");
9374 	if (sdinfo->satadrv_features_support &
9375 	    (SATA_DEV_F_TCQ | SATA_DEV_F_NCQ)) {
9376 		msg_buf[0] = '\0';
9377 		(void) snprintf(msg_buf, MAXPATHLEN,
9378 		    "Supported queue depth %d",
9379 		    sdinfo->satadrv_queue_depth);
9380 		if (!(sata_func_enable &
9381 		    (SATA_ENABLE_QUEUING | SATA_ENABLE_NCQ)))
9382 			(void) strlcat(msg_buf,
9383 			    " - queueing disabled globally", MAXPATHLEN);
9384 		else if (sdinfo->satadrv_queue_depth >
9385 		    sdinfo->satadrv_max_queue_depth) {
9386 			(void) snprintf(&msg_buf[strlen(msg_buf)],
9387 			    MAXPATHLEN - strlen(msg_buf), ", limited to %d",
9388 			    (int)sdinfo->satadrv_max_queue_depth);
9389 		}
9390 		cmn_err(CE_CONT, "?\t%s\n", msg_buf);
9391 	}
9392 
9393 	if (sdinfo->satadrv_type == SATA_DTYPE_ATADISK) {
9394 #ifdef __i386
9395 		(void) sprintf(msg_buf, "\tcapacity = %llu sectors\n",
9396 		    sdinfo->satadrv_capacity);
9397 #else
9398 		(void) sprintf(msg_buf, "\tcapacity = %lu sectors\n",
9399 		    sdinfo->satadrv_capacity);
9400 #endif
9401 		cmn_err(CE_CONT, "?%s", msg_buf);
9402 	}
9403 }
9404 
9405 
9406 /*
9407  * sata_save_drive_settings extracts current setting of the device and stores
9408  * it for future reference, in case the device setup would need to be restored
9409  * after the device reset.
9410  *
9411  * For all devices read ahead and write cache settings are saved, if the
9412  * device supports these features at all.
9413  * For ATAPI devices the Removable Media Status Notification setting is saved.
9414  */
9415 static void
9416 sata_save_drive_settings(sata_drive_info_t *sdinfo)
9417 {
9418 	if ((sdinfo->satadrv_id.ai_cmdset82 & SATA_LOOK_AHEAD) ||
9419 	    (sdinfo->satadrv_id.ai_cmdset82 & SATA_WRITE_CACHE)) {
9420 
9421 		/* Current setting of Read Ahead (and Read Cache) */
9422 		if (sdinfo->satadrv_id.ai_features85 & SATA_LOOK_AHEAD)
9423 			sdinfo->satadrv_settings |= SATA_DEV_READ_AHEAD;
9424 		else
9425 			sdinfo->satadrv_settings &= ~SATA_DEV_READ_AHEAD;
9426 
9427 		/* Current setting of Write Cache */
9428 		if (sdinfo->satadrv_id.ai_features85 & SATA_WRITE_CACHE)
9429 			sdinfo->satadrv_settings |= SATA_DEV_WRITE_CACHE;
9430 		else
9431 			sdinfo->satadrv_settings &= ~SATA_DEV_WRITE_CACHE;
9432 	}
9433 
9434 	if (sdinfo->satadrv_type == SATA_DTYPE_ATAPICD) {
9435 		if (sdinfo->satadrv_id.ai_cmdset83 & SATA_RM_STATUS_NOTIFIC)
9436 			sdinfo->satadrv_settings |= SATA_DEV_RMSN;
9437 		else
9438 			sdinfo->satadrv_settings &= ~SATA_DEV_RMSN;
9439 	}
9440 }
9441 
9442 
9443 /*
9444  * sata_check_capacity function determines a disk capacity
9445  * and addressing mode (LBA28/LBA48) by examining a disk identify device data.
9446  *
9447  * NOTE: CHS mode is not supported! If a device does not support LBA,
9448  * this function is not called.
9449  *
9450  * Returns device capacity in number of blocks, i.e. largest addressable LBA+1
9451  */
9452 static uint64_t
9453 sata_check_capacity(sata_drive_info_t *sdinfo)
9454 {
9455 	uint64_t capacity = 0;
9456 	int i;
9457 
9458 	if (sdinfo->satadrv_type != SATA_DTYPE_ATADISK ||
9459 	    !sdinfo->satadrv_id.ai_cap & SATA_LBA_SUPPORT)
9460 		/* Capacity valid only for LBA-addressable disk devices */
9461 		return (0);
9462 
9463 	if ((sdinfo->satadrv_id.ai_validinfo & SATA_VALIDINFO_88) &&
9464 	    (sdinfo->satadrv_id.ai_cmdset83 & SATA_EXT48) &&
9465 	    (sdinfo->satadrv_id.ai_features86 & SATA_EXT48)) {
9466 		/* LBA48 mode supported and enabled */
9467 		sdinfo->satadrv_features_support |= SATA_DEV_F_LBA48 |
9468 		    SATA_DEV_F_LBA28;
9469 		for (i = 3;  i >= 0;  --i) {
9470 			capacity <<= 16;
9471 			capacity += sdinfo->satadrv_id.ai_addrsecxt[i];
9472 		}
9473 	} else {
9474 		capacity = sdinfo->satadrv_id.ai_addrsec[1];
9475 		capacity <<= 16;
9476 		capacity += sdinfo->satadrv_id.ai_addrsec[0];
9477 		if (capacity >= 0x1000000)
9478 			/* LBA28 mode */
9479 			sdinfo->satadrv_features_support |= SATA_DEV_F_LBA28;
9480 	}
9481 	return (capacity);
9482 }
9483 
9484 
9485 /*
9486  * Allocate consistent buffer for DMA transfer
9487  *
9488  * Cannot be called from interrupt level or with mutex held - it may sleep.
9489  *
9490  * Returns pointer to allocated buffer structure, or NULL if allocation failed.
9491  */
9492 static struct buf *
9493 sata_alloc_local_buffer(sata_pkt_txlate_t *spx, int len)
9494 {
9495 	struct scsi_address ap;
9496 	struct buf *bp;
9497 	ddi_dma_attr_t	cur_dma_attr;
9498 
9499 	ASSERT(spx->txlt_sata_pkt != NULL);
9500 	ap.a_hba_tran = spx->txlt_sata_hba_inst->satahba_scsi_tran;
9501 	ap.a_target = SATA_TO_SCSI_TARGET(
9502 	    spx->txlt_sata_pkt->satapkt_device.satadev_addr.cport,
9503 	    spx->txlt_sata_pkt->satapkt_device.satadev_addr.pmport,
9504 	    spx->txlt_sata_pkt->satapkt_device.satadev_addr.qual);
9505 	ap.a_lun = 0;
9506 
9507 	bp = scsi_alloc_consistent_buf(&ap, NULL, len,
9508 	    B_READ, SLEEP_FUNC, NULL);
9509 
9510 	if (bp != NULL) {
9511 		/* Allocate DMA resources for this buffer */
9512 		spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp = bp;
9513 		/*
9514 		 * We use a local version of the dma_attr, to account
9515 		 * for a device addressing limitations.
9516 		 * sata_adjust_dma_attr() will handle sdinfo == NULL which
9517 		 * will cause dma attributes to be adjusted to a lowest
9518 		 * acceptable level.
9519 		 */
9520 		sata_adjust_dma_attr(NULL,
9521 		    SATA_DMA_ATTR(spx->txlt_sata_hba_inst), &cur_dma_attr);
9522 
9523 		if (sata_dma_buf_setup(spx, PKT_CONSISTENT,
9524 		    SLEEP_FUNC, NULL, &cur_dma_attr) != DDI_SUCCESS) {
9525 			scsi_free_consistent_buf(bp);
9526 			spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp = NULL;
9527 			bp = NULL;
9528 		}
9529 	}
9530 	return (bp);
9531 }
9532 
9533 /*
9534  * Release local buffer (consistent buffer for DMA transfer) allocated
9535  * via sata_alloc_local_buffer().
9536  */
9537 static void
9538 sata_free_local_buffer(sata_pkt_txlate_t *spx)
9539 {
9540 	ASSERT(spx->txlt_sata_pkt != NULL);
9541 	ASSERT(spx->txlt_dma_cookie_list != NULL);
9542 	ASSERT(spx->txlt_dma_cookie_list_len != 0);
9543 	ASSERT(spx->txlt_buf_dma_handle != NULL);
9544 	ASSERT(spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp != NULL);
9545 
9546 	spx->txlt_sata_pkt->satapkt_cmd.satacmd_num_dma_cookies = 0;
9547 	spx->txlt_sata_pkt->satapkt_cmd.satacmd_dma_cookie_list = NULL;
9548 
9549 	/* Free DMA resources */
9550 	(void) ddi_dma_unbind_handle(spx->txlt_buf_dma_handle);
9551 	ddi_dma_free_handle(&spx->txlt_buf_dma_handle);
9552 	spx->txlt_buf_dma_handle = 0;
9553 
9554 	if (spx->txlt_dma_cookie_list != &spx->txlt_dma_cookie) {
9555 		kmem_free(spx->txlt_dma_cookie_list,
9556 		    spx->txlt_dma_cookie_list_len * sizeof (ddi_dma_cookie_t));
9557 		spx->txlt_dma_cookie_list = NULL;
9558 		spx->txlt_dma_cookie_list_len = 0;
9559 	}
9560 	/* Free buffer */
9561 	scsi_free_consistent_buf(spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp);
9562 	spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp = NULL;
9563 }
9564 
9565 
9566 
9567 
9568 /*
9569  * Allocate sata_pkt
9570  * Pkt structure version and embedded strcutures version are initialized.
9571  * sata_pkt and sata_pkt_txlate structures are cross-linked.
9572  *
9573  * Since this may be called in interrupt context by sata_scsi_init_pkt,
9574  * callback argument determines if it can sleep or not.
9575  * Hence, it should not be called from interrupt context.
9576  *
9577  * If successful, non-NULL pointer to a sata pkt is returned.
9578  * Upon failure, NULL pointer is returned.
9579  */
9580 static sata_pkt_t *
9581 sata_pkt_alloc(sata_pkt_txlate_t *spx, int (*callback)(caddr_t))
9582 {
9583 	sata_pkt_t *spkt;
9584 	int kmsflag;
9585 
9586 	kmsflag = (callback == SLEEP_FUNC) ? KM_SLEEP : KM_NOSLEEP;
9587 	spkt = kmem_zalloc(sizeof (sata_pkt_t), kmsflag);
9588 	if (spkt == NULL) {
9589 		SATA_LOG_D((spx->txlt_sata_hba_inst, CE_WARN,
9590 		    "sata_pkt_alloc: failed"));
9591 		return (NULL);
9592 	}
9593 	spkt->satapkt_rev = SATA_PKT_REV;
9594 	spkt->satapkt_cmd.satacmd_rev = SATA_CMD_REV;
9595 	spkt->satapkt_device.satadev_rev = SATA_DEVICE_REV;
9596 	spkt->satapkt_framework_private = spx;
9597 	spx->txlt_sata_pkt = spkt;
9598 	return (spkt);
9599 }
9600 
9601 /*
9602  * Free sata pkt allocated via sata_pkt_alloc()
9603  */
9604 static void
9605 sata_pkt_free(sata_pkt_txlate_t *spx)
9606 {
9607 	ASSERT(spx->txlt_sata_pkt != NULL);
9608 	ASSERT(spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp == NULL);
9609 	kmem_free(spx->txlt_sata_pkt, sizeof (sata_pkt_t));
9610 	spx->txlt_sata_pkt = NULL;
9611 }
9612 
9613 
9614 /*
9615  * Adjust DMA attributes.
9616  * SCSI cmds block count is up to 24 bits, SATA cmd block count vary
9617  * from 8 bits to 16 bits, depending on a command being used.
9618  * Limiting max block count arbitrarily to 256 for all read/write
9619  * commands may affects performance, so check both the device and
9620  * controller capability before adjusting dma attributes.
9621  */
9622 void
9623 sata_adjust_dma_attr(sata_drive_info_t *sdinfo, ddi_dma_attr_t *dma_attr,
9624     ddi_dma_attr_t *adj_dma_attr)
9625 {
9626 	uint32_t count_max;
9627 
9628 	/* Copy original attributes */
9629 	*adj_dma_attr = *dma_attr;
9630 	/*
9631 	 * Things to consider: device addressing capability,
9632 	 * "excessive" controller DMA capabilities.
9633 	 * If a device is being probed/initialized, there are
9634 	 * no device info - use default limits then.
9635 	 */
9636 	if (sdinfo == NULL) {
9637 		count_max = dma_attr->dma_attr_granular * 0x100;
9638 		if (dma_attr->dma_attr_count_max > count_max)
9639 			adj_dma_attr->dma_attr_count_max = count_max;
9640 		if (dma_attr->dma_attr_maxxfer > count_max)
9641 			adj_dma_attr->dma_attr_maxxfer = count_max;
9642 		return;
9643 	}
9644 
9645 	if (sdinfo->satadrv_type == SATA_DTYPE_ATADISK) {
9646 		if (sdinfo->satadrv_features_support & (SATA_DEV_F_LBA48)) {
9647 			/*
9648 			 * 16-bit sector count may be used - we rely on
9649 			 * the assumption that only read and write cmds
9650 			 * will request more than 256 sectors worth of data
9651 			 */
9652 			count_max = adj_dma_attr->dma_attr_granular * 0x10000;
9653 		} else {
9654 			/*
9655 			 * 8-bit sector count will be used - default limits
9656 			 * for dma attributes
9657 			 */
9658 			count_max = adj_dma_attr->dma_attr_granular * 0x100;
9659 		}
9660 		/*
9661 		 * Adjust controler dma attributes, if necessary
9662 		 */
9663 		if (dma_attr->dma_attr_count_max > count_max)
9664 			adj_dma_attr->dma_attr_count_max = count_max;
9665 		if (dma_attr->dma_attr_maxxfer > count_max)
9666 			adj_dma_attr->dma_attr_maxxfer = count_max;
9667 	}
9668 }
9669 
9670 
9671 /*
9672  * Allocate DMA resources for the buffer
9673  * This function handles initial DMA resource allocation as well as
9674  * DMA window shift and may be called repeatedly for the same DMA window
9675  * until all DMA cookies in the DMA window are processed.
9676  * To guarantee that there is always a coherent set of cookies to process
9677  * by SATA HBA driver (observing alignment, device granularity, etc.),
9678  * the number of slots for DMA cookies is equal to lesser of  a number of
9679  * cookies in a DMA window and a max number of scatter/gather entries.
9680  *
9681  * Returns DDI_SUCCESS upon successful operation.
9682  * Return failure code of a failing command or DDI_FAILURE when
9683  * internal cleanup failed.
9684  */
9685 static int
9686 sata_dma_buf_setup(sata_pkt_txlate_t *spx, int flags,
9687     int (*callback)(caddr_t), caddr_t arg,
9688     ddi_dma_attr_t *cur_dma_attr)
9689 {
9690 	int	rval;
9691 	off_t	offset;
9692 	size_t	size;
9693 	int	max_sg_len, req_len, i;
9694 	uint_t	dma_flags;
9695 	struct buf	*bp;
9696 	uint64_t	cur_txfer_len;
9697 
9698 
9699 	ASSERT(spx->txlt_sata_pkt != NULL);
9700 	bp = spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp;
9701 	ASSERT(bp != NULL);
9702 
9703 
9704 	if (spx->txlt_buf_dma_handle == NULL) {
9705 		/*
9706 		 * No DMA resources allocated so far - this is a first call
9707 		 * for this sata pkt.
9708 		 */
9709 		rval = ddi_dma_alloc_handle(SATA_DIP(spx->txlt_sata_hba_inst),
9710 		    cur_dma_attr, callback, arg, &spx->txlt_buf_dma_handle);
9711 
9712 		if (rval != DDI_SUCCESS) {
9713 			SATA_LOG_D((spx->txlt_sata_hba_inst, CE_WARN,
9714 			    "sata_dma_buf_setup: no buf DMA resources %x",
9715 			    rval));
9716 			return (rval);
9717 		}
9718 
9719 		if (bp->b_flags & B_READ)
9720 			dma_flags = DDI_DMA_READ;
9721 		else
9722 			dma_flags = DDI_DMA_WRITE;
9723 
9724 		if (flags & PKT_CONSISTENT)
9725 			dma_flags |= DDI_DMA_CONSISTENT;
9726 
9727 		if (flags & PKT_DMA_PARTIAL)
9728 			dma_flags |= DDI_DMA_PARTIAL;
9729 
9730 		/*
9731 		 * Check buffer alignment and size against dma attributes
9732 		 * Consider dma_attr_align only. There may be requests
9733 		 * with the size lower than device granularity, but they
9734 		 * will not read/write from/to the device, so no adjustment
9735 		 * is necessary. The dma_attr_minxfer theoretically should
9736 		 * be considered, but no HBA driver is checking it.
9737 		 */
9738 		if (IS_P2ALIGNED(bp->b_un.b_addr,
9739 		    cur_dma_attr->dma_attr_align)) {
9740 			rval = ddi_dma_buf_bind_handle(
9741 			    spx->txlt_buf_dma_handle,
9742 			    bp, dma_flags, callback, arg,
9743 			    &spx->txlt_dma_cookie,
9744 			    &spx->txlt_curwin_num_dma_cookies);
9745 		} else { /* Buffer is not aligned */
9746 
9747 			int	(*ddicallback)(caddr_t);
9748 			size_t	bufsz;
9749 
9750 			/* Check id sleeping is allowed */
9751 			ddicallback = (callback == NULL_FUNC) ?
9752 			    DDI_DMA_DONTWAIT : DDI_DMA_SLEEP;
9753 
9754 			SATADBG2(SATA_DBG_DMA_SETUP, spx->txlt_sata_hba_inst,
9755 			    "mis-aligned buffer: addr=0x%p, cnt=%lu",
9756 			    (void *)bp->b_un.b_addr, bp->b_bcount);
9757 
9758 			if (bp->b_flags & (B_PAGEIO|B_PHYS))
9759 				/*
9760 				 * CPU will need to access data in the buffer
9761 				 * (for copying) so map it.
9762 				 */
9763 				bp_mapin(bp);
9764 
9765 			ASSERT(spx->txlt_tmp_buf == NULL);
9766 
9767 			/* Buffer may be padded by ddi_dma_mem_alloc()! */
9768 			rval = ddi_dma_mem_alloc(
9769 			    spx->txlt_buf_dma_handle,
9770 			    bp->b_bcount,
9771 			    &sata_acc_attr,
9772 			    DDI_DMA_STREAMING,
9773 			    ddicallback, NULL,
9774 			    &spx->txlt_tmp_buf,
9775 			    &bufsz,
9776 			    &spx->txlt_tmp_buf_handle);
9777 
9778 			if (rval != DDI_SUCCESS) {
9779 				/* DMA mapping failed */
9780 				(void) ddi_dma_free_handle(
9781 				    &spx->txlt_buf_dma_handle);
9782 				spx->txlt_buf_dma_handle = NULL;
9783 #ifdef SATA_DEBUG
9784 				mbuffail_count++;
9785 #endif
9786 				SATADBG1(SATA_DBG_DMA_SETUP,
9787 				    spx->txlt_sata_hba_inst,
9788 				    "sata_dma_buf_setup: "
9789 				    "buf dma mem alloc failed %x\n", rval);
9790 				return (rval);
9791 			}
9792 			ASSERT(IS_P2ALIGNED(spx->txlt_tmp_buf,
9793 			    cur_dma_attr->dma_attr_align));
9794 
9795 #ifdef SATA_DEBUG
9796 			mbuf_count++;
9797 
9798 			if (bp->b_bcount != bufsz)
9799 				/*
9800 				 * This will require special handling, because
9801 				 * DMA cookies will be based on the temporary
9802 				 * buffer size, not the original buffer
9803 				 * b_bcount, so the residue may have to
9804 				 * be counted differently.
9805 				 */
9806 				SATADBG2(SATA_DBG_DMA_SETUP,
9807 				    spx->txlt_sata_hba_inst,
9808 				    "sata_dma_buf_setup: bp size %x != "
9809 				    "bufsz %x\n", bp->b_bcount, bufsz);
9810 #endif
9811 			if (dma_flags & DDI_DMA_WRITE) {
9812 				/*
9813 				 * Write operation - copy data into
9814 				 * an aligned temporary buffer. Buffer will be
9815 				 * synced for device by ddi_dma_addr_bind_handle
9816 				 */
9817 				bcopy(bp->b_un.b_addr, spx->txlt_tmp_buf,
9818 				    bp->b_bcount);
9819 			}
9820 
9821 			rval = ddi_dma_addr_bind_handle(
9822 			    spx->txlt_buf_dma_handle,
9823 			    NULL,
9824 			    spx->txlt_tmp_buf,
9825 			    bufsz, dma_flags, ddicallback, 0,
9826 			    &spx->txlt_dma_cookie,
9827 			    &spx->txlt_curwin_num_dma_cookies);
9828 		}
9829 
9830 		switch (rval) {
9831 		case DDI_DMA_PARTIAL_MAP:
9832 			SATADBG1(SATA_DBG_DMA_SETUP, spx->txlt_sata_hba_inst,
9833 			    "sata_dma_buf_setup: DMA Partial Map\n", NULL);
9834 			/*
9835 			 * Partial DMA mapping.
9836 			 * Retrieve number of DMA windows for this request.
9837 			 */
9838 			if (ddi_dma_numwin(spx->txlt_buf_dma_handle,
9839 			    &spx->txlt_num_dma_win) != DDI_SUCCESS) {
9840 				if (spx->txlt_tmp_buf != NULL) {
9841 					ddi_dma_mem_free(
9842 					    &spx->txlt_tmp_buf_handle);
9843 					spx->txlt_tmp_buf = NULL;
9844 				}
9845 				(void) ddi_dma_unbind_handle(
9846 				    spx->txlt_buf_dma_handle);
9847 				(void) ddi_dma_free_handle(
9848 				    &spx->txlt_buf_dma_handle);
9849 				spx->txlt_buf_dma_handle = NULL;
9850 				SATA_LOG_D((spx->txlt_sata_hba_inst, CE_WARN,
9851 				    "sata_dma_buf_setup: numwin failed\n"));
9852 				return (DDI_FAILURE);
9853 			}
9854 			SATADBG2(SATA_DBG_DMA_SETUP,
9855 			    spx->txlt_sata_hba_inst,
9856 			    "sata_dma_buf_setup: windows: %d, cookies: %d\n",
9857 			    spx->txlt_num_dma_win,
9858 			    spx->txlt_curwin_num_dma_cookies);
9859 			spx->txlt_cur_dma_win = 0;
9860 			break;
9861 
9862 		case DDI_DMA_MAPPED:
9863 			/* DMA fully mapped */
9864 			spx->txlt_num_dma_win = 1;
9865 			spx->txlt_cur_dma_win = 0;
9866 			SATADBG1(SATA_DBG_DMA_SETUP,
9867 			    spx->txlt_sata_hba_inst,
9868 			    "sata_dma_buf_setup: windows: 1 "
9869 			    "cookies: %d\n", spx->txlt_curwin_num_dma_cookies);
9870 			break;
9871 
9872 		default:
9873 			/* DMA mapping failed */
9874 			if (spx->txlt_tmp_buf != NULL) {
9875 				ddi_dma_mem_free(
9876 				    &spx->txlt_tmp_buf_handle);
9877 				spx->txlt_tmp_buf = NULL;
9878 			}
9879 			(void) ddi_dma_free_handle(&spx->txlt_buf_dma_handle);
9880 			spx->txlt_buf_dma_handle = NULL;
9881 			SATA_LOG_D((spx->txlt_sata_hba_inst, CE_WARN,
9882 			    "sata_dma_buf_setup: buf dma handle binding "
9883 			    "failed %x\n", rval));
9884 			return (rval);
9885 		}
9886 		spx->txlt_curwin_processed_dma_cookies = 0;
9887 		spx->txlt_dma_cookie_list = NULL;
9888 	} else {
9889 		/*
9890 		 * DMA setup is reused. Check if we need to process more
9891 		 * cookies in current window, or to get next window, if any.
9892 		 */
9893 
9894 		ASSERT(spx->txlt_curwin_processed_dma_cookies <=
9895 		    spx->txlt_curwin_num_dma_cookies);
9896 
9897 		if (spx->txlt_curwin_processed_dma_cookies ==
9898 		    spx->txlt_curwin_num_dma_cookies) {
9899 			/*
9900 			 * All cookies from current DMA window were processed.
9901 			 * Get next DMA window.
9902 			 */
9903 			spx->txlt_cur_dma_win++;
9904 			if (spx->txlt_cur_dma_win < spx->txlt_num_dma_win) {
9905 				(void) ddi_dma_getwin(spx->txlt_buf_dma_handle,
9906 				    spx->txlt_cur_dma_win, &offset, &size,
9907 				    &spx->txlt_dma_cookie,
9908 				    &spx->txlt_curwin_num_dma_cookies);
9909 				spx->txlt_curwin_processed_dma_cookies = 0;
9910 			} else {
9911 				/* No more windows! End of request! */
9912 				/* What to do? - panic for now */
9913 				ASSERT(spx->txlt_cur_dma_win >=
9914 				    spx->txlt_num_dma_win);
9915 
9916 				spx->txlt_curwin_num_dma_cookies = 0;
9917 				spx->txlt_curwin_processed_dma_cookies = 0;
9918 				spx->txlt_sata_pkt->
9919 				    satapkt_cmd.satacmd_num_dma_cookies = 0;
9920 				return (DDI_SUCCESS);
9921 			}
9922 		}
9923 	}
9924 	/* There better be at least one DMA cookie outstanding */
9925 	ASSERT((spx->txlt_curwin_num_dma_cookies -
9926 	    spx->txlt_curwin_processed_dma_cookies) > 0);
9927 
9928 	if (spx->txlt_dma_cookie_list == &spx->txlt_dma_cookie) {
9929 		/* The default cookie slot was used in previous run */
9930 		ASSERT(spx->txlt_curwin_processed_dma_cookies == 0);
9931 		spx->txlt_dma_cookie_list = NULL;
9932 		spx->txlt_dma_cookie_list_len = 0;
9933 	}
9934 	if (spx->txlt_curwin_processed_dma_cookies == 0) {
9935 		/*
9936 		 * Processing a new DMA window - set-up dma cookies list.
9937 		 * We may reuse previously allocated cookie array if it is
9938 		 * possible.
9939 		 */
9940 		if (spx->txlt_dma_cookie_list != NULL &&
9941 		    spx->txlt_dma_cookie_list_len <
9942 		    spx->txlt_curwin_num_dma_cookies) {
9943 			/*
9944 			 * New DMA window contains more cookies than
9945 			 * the previous one. We need larger cookie list - free
9946 			 * the old one.
9947 			 */
9948 			(void) kmem_free(spx->txlt_dma_cookie_list,
9949 			    spx->txlt_dma_cookie_list_len *
9950 			    sizeof (ddi_dma_cookie_t));
9951 			spx->txlt_dma_cookie_list = NULL;
9952 			spx->txlt_dma_cookie_list_len = 0;
9953 		}
9954 		if (spx->txlt_dma_cookie_list == NULL) {
9955 			/*
9956 			 * Calculate lesser of number of cookies in this
9957 			 * DMA window and number of s/g entries.
9958 			 */
9959 			max_sg_len = cur_dma_attr->dma_attr_sgllen;
9960 			req_len = MIN(max_sg_len,
9961 			    spx->txlt_curwin_num_dma_cookies);
9962 
9963 			/* Allocate new dma cookie array if necessary */
9964 			if (req_len == 1) {
9965 				/* Only one cookie - no need for a list */
9966 				spx->txlt_dma_cookie_list =
9967 				    &spx->txlt_dma_cookie;
9968 				spx->txlt_dma_cookie_list_len = 1;
9969 			} else {
9970 				/*
9971 				 * More than one cookie - try to allocate space.
9972 				 */
9973 				spx->txlt_dma_cookie_list = kmem_zalloc(
9974 				    sizeof (ddi_dma_cookie_t) * req_len,
9975 				    callback == NULL_FUNC ? KM_NOSLEEP :
9976 				    KM_SLEEP);
9977 				if (spx->txlt_dma_cookie_list == NULL) {
9978 					SATADBG1(SATA_DBG_DMA_SETUP,
9979 					    spx->txlt_sata_hba_inst,
9980 					    "sata_dma_buf_setup: cookie list "
9981 					    "allocation failed\n", NULL);
9982 					/*
9983 					 * We could not allocate space for
9984 					 * neccessary number of dma cookies in
9985 					 * this window, so we fail this request.
9986 					 * Next invocation would try again to
9987 					 * allocate space for cookie list.
9988 					 * Note:Packet residue was not modified.
9989 					 */
9990 					return (DDI_DMA_NORESOURCES);
9991 				} else {
9992 					spx->txlt_dma_cookie_list_len = req_len;
9993 				}
9994 			}
9995 		}
9996 		/*
9997 		 * Fetch DMA cookies into cookie list in sata_pkt_txlate.
9998 		 * First cookie was already fetched.
9999 		 */
10000 		*(&spx->txlt_dma_cookie_list[0]) = spx->txlt_dma_cookie;
10001 		cur_txfer_len =
10002 		    (uint64_t)spx->txlt_dma_cookie_list[0].dmac_size;
10003 		spx->txlt_sata_pkt->satapkt_cmd.satacmd_num_dma_cookies = 1;
10004 		spx->txlt_curwin_processed_dma_cookies++;
10005 		for (i = 1; (i < spx->txlt_dma_cookie_list_len) &&
10006 		    (i < spx->txlt_curwin_num_dma_cookies); i++) {
10007 			ddi_dma_nextcookie(spx->txlt_buf_dma_handle,
10008 			    &spx->txlt_dma_cookie_list[i]);
10009 			cur_txfer_len +=
10010 			    (uint64_t)spx->txlt_dma_cookie_list[i].dmac_size;
10011 			spx->txlt_curwin_processed_dma_cookies++;
10012 			spx->txlt_sata_pkt->
10013 			    satapkt_cmd.satacmd_num_dma_cookies += 1;
10014 		}
10015 	} else {
10016 		SATADBG2(SATA_DBG_DMA_SETUP, spx->txlt_sata_hba_inst,
10017 		    "sata_dma_buf_setup: sliding within DMA window, "
10018 		    "cur cookie %d, total cookies %d\n",
10019 		    spx->txlt_curwin_processed_dma_cookies,
10020 		    spx->txlt_curwin_num_dma_cookies);
10021 
10022 		/*
10023 		 * Not all cookies from the current dma window were used because
10024 		 * of s/g limitation.
10025 		 * There is no need to re-size the list - it was set at
10026 		 * optimal size, or only default entry is used (s/g = 1).
10027 		 */
10028 		if (spx->txlt_dma_cookie_list == NULL) {
10029 			spx->txlt_dma_cookie_list = &spx->txlt_dma_cookie;
10030 			spx->txlt_dma_cookie_list_len = 1;
10031 		}
10032 		/*
10033 		 * Since we are processing remaining cookies in a DMA window,
10034 		 * there may be less of them than the number of entries in the
10035 		 * current dma cookie list.
10036 		 */
10037 		req_len = MIN(spx->txlt_dma_cookie_list_len,
10038 		    (spx->txlt_curwin_num_dma_cookies -
10039 		    spx->txlt_curwin_processed_dma_cookies));
10040 
10041 		/* Fetch the next batch of cookies */
10042 		for (i = 0, cur_txfer_len = 0; i < req_len; i++) {
10043 			ddi_dma_nextcookie(spx->txlt_buf_dma_handle,
10044 			    &spx->txlt_dma_cookie_list[i]);
10045 			cur_txfer_len +=
10046 			    (uint64_t)spx->txlt_dma_cookie_list[i].dmac_size;
10047 			spx->txlt_sata_pkt->
10048 			    satapkt_cmd.satacmd_num_dma_cookies++;
10049 			spx->txlt_curwin_processed_dma_cookies++;
10050 		}
10051 	}
10052 
10053 	ASSERT(spx->txlt_sata_pkt->satapkt_cmd.satacmd_num_dma_cookies > 0);
10054 
10055 	/* Point sata_cmd to the cookie list */
10056 	spx->txlt_sata_pkt->satapkt_cmd.satacmd_dma_cookie_list =
10057 	    &spx->txlt_dma_cookie_list[0];
10058 
10059 	/* Remember number of DMA cookies passed in sata packet */
10060 	spx->txlt_num_dma_cookies =
10061 	    spx->txlt_sata_pkt->satapkt_cmd.satacmd_num_dma_cookies;
10062 
10063 	ASSERT(cur_txfer_len != 0);
10064 	if (cur_txfer_len <= bp->b_bcount)
10065 		spx->txlt_total_residue -= cur_txfer_len;
10066 	else {
10067 		/*
10068 		 * Temporary DMA buffer has been padded by
10069 		 * ddi_dma_mem_alloc()!
10070 		 * This requires special handling, because DMA cookies are
10071 		 * based on the temporary buffer size, not the b_bcount,
10072 		 * and we have extra bytes to transfer - but the packet
10073 		 * residue has to stay correct because we will copy only
10074 		 * the requested number of bytes.
10075 		 */
10076 		spx->txlt_total_residue -= bp->b_bcount;
10077 	}
10078 
10079 	return (DDI_SUCCESS);
10080 }
10081 
10082 
10083 /*
10084  * Fetch Device Identify data.
10085  * Send DEVICE IDENTIFY or IDENTIFY PACKET DEVICE (depending on a device type)
10086  * command to a device and get the device identify data.
10087  * The device_info structure has to be set to device type (for selecting proper
10088  * device identify command).
10089  *
10090  * Returns:
10091  * SATA_SUCCESS if cmd succeeded
10092  * SATA_RETRY if cmd was rejected and could be retried,
10093  * SATA_FAILURE if cmd failed and should not be retried (port error)
10094  *
10095  * Cannot be called in an interrupt context.
10096  */
10097 
10098 static int
10099 sata_fetch_device_identify_data(sata_hba_inst_t *sata_hba_inst,
10100     sata_drive_info_t *sdinfo)
10101 {
10102 	struct buf *bp;
10103 	sata_pkt_t *spkt;
10104 	sata_cmd_t *scmd;
10105 	sata_pkt_txlate_t *spx;
10106 	int rval;
10107 
10108 	spx = kmem_zalloc(sizeof (sata_pkt_txlate_t), KM_SLEEP);
10109 	spx->txlt_sata_hba_inst = sata_hba_inst;
10110 	spx->txlt_scsi_pkt = NULL;		/* No scsi pkt involved */
10111 	spkt = sata_pkt_alloc(spx, SLEEP_FUNC);
10112 	if (spkt == NULL) {
10113 		kmem_free(spx, sizeof (sata_pkt_txlate_t));
10114 		return (SATA_RETRY); /* may retry later */
10115 	}
10116 	/* address is needed now */
10117 	spkt->satapkt_device.satadev_addr = sdinfo->satadrv_addr;
10118 
10119 	/*
10120 	 * Allocate buffer for Identify Data return data
10121 	 */
10122 	bp = sata_alloc_local_buffer(spx, sizeof (sata_id_t));
10123 	if (bp == NULL) {
10124 		sata_pkt_free(spx);
10125 		kmem_free(spx, sizeof (sata_pkt_txlate_t));
10126 		SATA_LOG_D((sata_hba_inst, CE_WARN,
10127 		    "sata_fetch_device_identify_data: "
10128 		    "cannot allocate buffer for ID"));
10129 		return (SATA_RETRY); /* may retry later */
10130 	}
10131 
10132 	/* Fill sata_pkt */
10133 	sdinfo->satadrv_state = SATA_STATE_PROBING;
10134 	spkt->satapkt_device.satadev_addr = sdinfo->satadrv_addr;
10135 	spkt->satapkt_op_mode = SATA_OPMODE_SYNCH | SATA_OPMODE_INTERRUPTS;
10136 	/* Synchronous mode, no callback */
10137 	spkt->satapkt_comp = NULL;
10138 	/* Timeout 30s */
10139 	spkt->satapkt_time = sata_default_pkt_time;
10140 
10141 	scmd = &spkt->satapkt_cmd;
10142 	scmd->satacmd_bp = bp;
10143 	scmd->satacmd_flags.sata_data_direction = SATA_DIR_READ;
10144 	scmd->satacmd_flags.sata_ignore_dev_reset = B_TRUE;
10145 
10146 	/* Build Identify Device cmd in the sata_pkt */
10147 	scmd->satacmd_addr_type = 0;		/* N/A */
10148 	scmd->satacmd_sec_count_lsb = 0;	/* N/A */
10149 	scmd->satacmd_lba_low_lsb = 0;		/* N/A */
10150 	scmd->satacmd_lba_mid_lsb = 0;		/* N/A */
10151 	scmd->satacmd_lba_high_lsb = 0;		/* N/A */
10152 	scmd->satacmd_features_reg = 0;		/* N/A */
10153 	scmd->satacmd_device_reg = 0;		/* Always device 0 */
10154 	if (sdinfo->satadrv_type == SATA_DTYPE_ATAPICD) {
10155 		/* Identify Packet Device cmd */
10156 		scmd->satacmd_cmd_reg = SATAC_ID_PACKET_DEVICE;
10157 	} else {
10158 		/* Identify Device cmd - mandatory for all other devices */
10159 		scmd->satacmd_cmd_reg = SATAC_ID_DEVICE;
10160 	}
10161 
10162 	/* Send pkt to SATA HBA driver */
10163 	rval = (*SATA_START_FUNC(sata_hba_inst))(SATA_DIP(sata_hba_inst), spkt);
10164 	if (rval == SATA_TRAN_ACCEPTED &&
10165 	    spkt->satapkt_reason == SATA_PKT_COMPLETED) {
10166 		rval = ddi_dma_sync(spx->txlt_buf_dma_handle, 0, 0,
10167 		    DDI_DMA_SYNC_FORKERNEL);
10168 		ASSERT(rval == DDI_SUCCESS);
10169 		if ((((sata_id_t *)(bp->b_un.b_addr))->ai_config &
10170 		    SATA_INCOMPLETE_DATA) == SATA_INCOMPLETE_DATA) {
10171 			SATA_LOG_D((sata_hba_inst, CE_WARN,
10172 			    "SATA disk device at port %d - "
10173 			    "partial Identify Data",
10174 			    sdinfo->satadrv_addr.cport));
10175 			rval = SATA_RETRY; /* may retry later */
10176 			goto fail;
10177 		}
10178 		/* Update sata_drive_info */
10179 		bcopy(bp->b_un.b_addr, &sdinfo->satadrv_id,
10180 		    sizeof (sata_id_t));
10181 
10182 		sdinfo->satadrv_features_support = 0;
10183 		if (sdinfo->satadrv_type == SATA_DTYPE_ATADISK) {
10184 			/*
10185 			 * Retrieve capacity (disks only) and addressing mode
10186 			 */
10187 			sdinfo->satadrv_capacity = sata_check_capacity(sdinfo);
10188 		} else {
10189 			/*
10190 			 * For ATAPI devices one would have to issue
10191 			 * Get Capacity cmd for media capacity. Not here.
10192 			 */
10193 			sdinfo->satadrv_capacity = 0;
10194 			/*
10195 			 * Check what cdb length is supported
10196 			 */
10197 			if ((sdinfo->satadrv_id.ai_config &
10198 			    SATA_ATAPI_ID_PKT_SZ) == SATA_ATAPI_ID_PKT_16B)
10199 				sdinfo->satadrv_atapi_cdb_len = 16;
10200 			else
10201 				sdinfo->satadrv_atapi_cdb_len = 12;
10202 		}
10203 		/* Setup supported features flags */
10204 		if (sdinfo->satadrv_id.ai_cap & SATA_DMA_SUPPORT)
10205 			sdinfo->satadrv_features_support |= SATA_DEV_F_DMA;
10206 
10207 		/* Check for SATA GEN and NCQ support */
10208 		if (sdinfo->satadrv_id.ai_satacap != 0 &&
10209 		    sdinfo->satadrv_id.ai_satacap != 0xffff) {
10210 			/* SATA compliance */
10211 			if (sdinfo->satadrv_id.ai_satacap & SATA_NCQ)
10212 				sdinfo->satadrv_features_support |=
10213 				    SATA_DEV_F_NCQ;
10214 			if (sdinfo->satadrv_id.ai_satacap &
10215 			    (SATA_1_SPEED | SATA_2_SPEED)) {
10216 				if (sdinfo->satadrv_id.ai_satacap &
10217 				    SATA_2_SPEED)
10218 					sdinfo->satadrv_features_support |=
10219 					    SATA_DEV_F_SATA2;
10220 				if (sdinfo->satadrv_id.ai_satacap &
10221 				    SATA_1_SPEED)
10222 					sdinfo->satadrv_features_support |=
10223 					    SATA_DEV_F_SATA1;
10224 			} else {
10225 				sdinfo->satadrv_features_support |=
10226 				    SATA_DEV_F_SATA1;
10227 			}
10228 		}
10229 		if ((sdinfo->satadrv_id.ai_cmdset83 & SATA_RW_DMA_QUEUED_CMD) &&
10230 		    (sdinfo->satadrv_id.ai_features86 & SATA_RW_DMA_QUEUED_CMD))
10231 			sdinfo->satadrv_features_support |= SATA_DEV_F_TCQ;
10232 
10233 		sdinfo->satadrv_queue_depth = sdinfo->satadrv_id.ai_qdepth;
10234 		if ((sdinfo->satadrv_features_support & SATA_DEV_F_NCQ) ||
10235 		    (sdinfo->satadrv_features_support & SATA_DEV_F_TCQ)) {
10236 			++sdinfo->satadrv_queue_depth;
10237 			/* Adjust according to controller capabilities */
10238 			sdinfo->satadrv_max_queue_depth = MIN(
10239 			    sdinfo->satadrv_queue_depth,
10240 			    SATA_QDEPTH(sata_hba_inst));
10241 			/* Adjust according to global queue depth limit */
10242 			sdinfo->satadrv_max_queue_depth = MIN(
10243 			    sdinfo->satadrv_max_queue_depth,
10244 			    sata_current_max_qdepth);
10245 			if (sdinfo->satadrv_max_queue_depth == 0)
10246 				sdinfo->satadrv_max_queue_depth = 1;
10247 		} else
10248 			sdinfo->satadrv_max_queue_depth = 1;
10249 
10250 		rval = SATA_SUCCESS;
10251 	} else {
10252 		/*
10253 		 * Woops, no Identify Data.
10254 		 */
10255 		if (rval == SATA_TRAN_BUSY || rval == SATA_TRAN_QUEUE_FULL) {
10256 			rval = SATA_RETRY; /* may retry later */
10257 		} else if (rval == SATA_TRAN_ACCEPTED) {
10258 			if (spkt->satapkt_reason == SATA_PKT_DEV_ERROR ||
10259 			    spkt->satapkt_reason == SATA_PKT_ABORTED ||
10260 			    spkt->satapkt_reason == SATA_PKT_TIMEOUT ||
10261 			    spkt->satapkt_reason == SATA_PKT_RESET)
10262 				rval = SATA_RETRY; /* may retry later */
10263 			else
10264 				rval = SATA_FAILURE;
10265 		} else {
10266 			rval = SATA_FAILURE;
10267 		}
10268 	}
10269 fail:
10270 	/* Free allocated resources */
10271 	sata_free_local_buffer(spx);
10272 	sata_pkt_free(spx);
10273 	kmem_free(spx, sizeof (sata_pkt_txlate_t));
10274 
10275 	return (rval);
10276 }
10277 
10278 
10279 /*
10280  * Some devices may not come-up with default DMA mode (UDMA or MWDMA).
10281  * UDMA mode is checked first, followed by MWDMA mode.
10282  * set correctly, so this function is setting it to the highest supported level.
10283  * Older SATA spec required that the device supports at least DMA 4 mode and
10284  * UDMA mode is selected.  It is not mentioned in SerialATA 2.6, so this
10285  * restriction has been removed.
10286  *
10287  * Returns SATA_SUCCESS if proper DMA mode is selected or no DMA is supported.
10288  * Returns SATA_FAILURE if proper DMA mode could not be selected.
10289  *
10290  * NOTE: This function should be called only if DMA mode is supported.
10291  */
10292 static int
10293 sata_set_dma_mode(sata_hba_inst_t *sata_hba_inst, sata_drive_info_t *sdinfo)
10294 {
10295 	sata_pkt_t *spkt;
10296 	sata_cmd_t *scmd;
10297 	sata_pkt_txlate_t *spx;
10298 	int i, mode;
10299 	uint8_t subcmd;
10300 	int rval = SATA_SUCCESS;
10301 
10302 	ASSERT(sdinfo != NULL);
10303 	ASSERT(sata_hba_inst != NULL);
10304 
10305 	if ((sdinfo->satadrv_id.ai_validinfo & SATA_VALIDINFO_88) != 0 &&
10306 	    (sdinfo->satadrv_id.ai_ultradma & SATA_UDMA_SUP_MASK) != 0) {
10307 		/* Find highest Ultra DMA mode supported */
10308 		for (mode = 6; mode >= 0; --mode) {
10309 			if (sdinfo->satadrv_id.ai_ultradma & (1 << mode))
10310 				break;
10311 		}
10312 #if 0
10313 		/* Left for historical reasons */
10314 		/*
10315 		 * Some initial version of SATA spec indicated that at least
10316 		 * UDMA mode 4 has to be supported. It is not mentioned in
10317 		 * SerialATA 2.6, so this restriction is removed.
10318 		 */
10319 		if (mode < 4)
10320 			return (SATA_FAILURE);
10321 #endif
10322 		/* Find UDMA mode currently selected */
10323 		for (i = 6; i >= 0; --i) {
10324 			if (sdinfo->satadrv_id.ai_ultradma & (1 << (i + 8)))
10325 				break;
10326 		}
10327 		if (i >= mode)
10328 			/* Nothing to do */
10329 			return (SATA_SUCCESS);
10330 
10331 		subcmd = SATAC_TRANSFER_MODE_ULTRA_DMA;
10332 
10333 	} else if ((sdinfo->satadrv_id.ai_dworddma & SATA_MDMA_SUP_MASK) != 0) {
10334 		/* Find highest MultiWord DMA mode supported */
10335 		for (mode = 2; mode >= 0; --mode) {
10336 			if (sdinfo->satadrv_id.ai_dworddma & (1 << mode))
10337 				break;
10338 		}
10339 		/* Find highest MultiWord DMA mode selected */
10340 		for (i = 2; i >= 0; --i) {
10341 			if (sdinfo->satadrv_id.ai_dworddma & (1 << (i + 8)))
10342 				break;
10343 		}
10344 		if (i >= mode)
10345 			/* Nothing to do */
10346 			return (SATA_SUCCESS);
10347 
10348 		subcmd = SATAC_TRANSFER_MODE_MULTI_WORD_DMA;
10349 	} else
10350 		return (SATA_SUCCESS);
10351 
10352 	/*
10353 	 * Set DMA mode via SET FEATURES COMMAND.
10354 	 * Prepare packet for SET FEATURES COMMAND.
10355 	 */
10356 	spx = kmem_zalloc(sizeof (sata_pkt_txlate_t), KM_SLEEP);
10357 	spx->txlt_sata_hba_inst = sata_hba_inst;
10358 	spx->txlt_scsi_pkt = NULL;	/* No scsi pkt involved */
10359 	spkt = sata_pkt_alloc(spx, SLEEP_FUNC);
10360 	if (spkt == NULL) {
10361 		SATA_LOG_D((sata_hba_inst, CE_WARN,
10362 		    "sata_set_dma_mode: could not set DMA mode %", mode));
10363 		rval = SATA_FAILURE;
10364 		goto done;
10365 	}
10366 	/* Fill sata_pkt */
10367 	spkt->satapkt_device.satadev_addr = sdinfo->satadrv_addr;
10368 	/* Timeout 30s */
10369 	spkt->satapkt_time = sata_default_pkt_time;
10370 	/* Synchronous mode, no callback, interrupts */
10371 	spkt->satapkt_op_mode = SATA_OPMODE_SYNCH | SATA_OPMODE_INTERRUPTS;
10372 	spkt->satapkt_comp = NULL;
10373 	scmd = &spkt->satapkt_cmd;
10374 	scmd->satacmd_flags.sata_data_direction = SATA_DIR_NODATA_XFER;
10375 	scmd->satacmd_flags.sata_ignore_dev_reset = B_TRUE;
10376 	scmd->satacmd_addr_type = 0;
10377 	scmd->satacmd_device_reg = 0;
10378 	scmd->satacmd_status_reg = 0;
10379 	scmd->satacmd_error_reg = 0;
10380 	scmd->satacmd_cmd_reg = SATAC_SET_FEATURES;
10381 	scmd->satacmd_features_reg = SATAC_SF_TRANSFER_MODE;
10382 	scmd->satacmd_sec_count_lsb = subcmd | mode;
10383 
10384 	/* Transfer command to HBA */
10385 	if ((*SATA_START_FUNC(sata_hba_inst))(SATA_DIP(sata_hba_inst),
10386 	    spkt) != SATA_TRAN_ACCEPTED ||
10387 	    spkt->satapkt_reason != SATA_PKT_COMPLETED) {
10388 		/* Pkt execution failed */
10389 		rval = SATA_FAILURE;
10390 	}
10391 done:
10392 
10393 	/* Free allocated resources */
10394 	if (spkt != NULL)
10395 		sata_pkt_free(spx);
10396 	(void) kmem_free(spx, sizeof (sata_pkt_txlate_t));
10397 
10398 	return (rval);
10399 }
10400 
10401 
10402 /*
10403  * Set device caching mode.
10404  * One of the following operations should be specified:
10405  * SATAC_SF_ENABLE_READ_AHEAD
10406  * SATAC_SF_DISABLE_READ_AHEAD
10407  * SATAC_SF_ENABLE_WRITE_CACHE
10408  * SATAC_SF_DISABLE_WRITE_CACHE
10409  *
10410  * If operation fails, system log messgage is emitted.
10411  * Returns SATA_SUCCESS when the operation succeeds, SATA_FAILURE otherwise.
10412  */
10413 
10414 static int
10415 sata_set_cache_mode(sata_hba_inst_t *sata_hba_inst, sata_drive_info_t *sdinfo,
10416     int cache_op)
10417 {
10418 	sata_pkt_t *spkt;
10419 	sata_cmd_t *scmd;
10420 	sata_pkt_txlate_t *spx;
10421 	int rval = SATA_SUCCESS;
10422 	char *infop;
10423 
10424 	ASSERT(sdinfo != NULL);
10425 	ASSERT(sata_hba_inst != NULL);
10426 	ASSERT(cache_op == SATAC_SF_ENABLE_READ_AHEAD ||
10427 	    cache_op == SATAC_SF_DISABLE_READ_AHEAD ||
10428 	    cache_op == SATAC_SF_ENABLE_WRITE_CACHE ||
10429 	    cache_op == SATAC_SF_DISABLE_WRITE_CACHE);
10430 
10431 
10432 	/* Prepare packet for SET FEATURES COMMAND */
10433 	spx = kmem_zalloc(sizeof (sata_pkt_txlate_t), KM_SLEEP);
10434 	spx->txlt_sata_hba_inst = sata_hba_inst;
10435 	spx->txlt_scsi_pkt = NULL;	/* No scsi pkt involved */
10436 	spkt = sata_pkt_alloc(spx, SLEEP_FUNC);
10437 	if (spkt == NULL) {
10438 		rval = SATA_FAILURE;
10439 		goto failure;
10440 	}
10441 	/* Fill sata_pkt */
10442 	spkt->satapkt_device.satadev_addr = sdinfo->satadrv_addr;
10443 	/* Timeout 30s */
10444 	spkt->satapkt_time = sata_default_pkt_time;
10445 	/* Synchronous mode, no callback, interrupts */
10446 	spkt->satapkt_op_mode =
10447 	    SATA_OPMODE_SYNCH | SATA_OPMODE_INTERRUPTS;
10448 	spkt->satapkt_comp = NULL;
10449 	scmd = &spkt->satapkt_cmd;
10450 	scmd->satacmd_flags.sata_data_direction = SATA_DIR_NODATA_XFER;
10451 	scmd->satacmd_flags.sata_ignore_dev_reset = B_TRUE;
10452 	scmd->satacmd_addr_type = 0;
10453 	scmd->satacmd_device_reg = 0;
10454 	scmd->satacmd_status_reg = 0;
10455 	scmd->satacmd_error_reg = 0;
10456 	scmd->satacmd_cmd_reg = SATAC_SET_FEATURES;
10457 	scmd->satacmd_features_reg = cache_op;
10458 
10459 	/* Transfer command to HBA */
10460 	if (((*SATA_START_FUNC(sata_hba_inst))(
10461 	    SATA_DIP(sata_hba_inst), spkt) != SATA_TRAN_ACCEPTED) ||
10462 	    (spkt->satapkt_reason != SATA_PKT_COMPLETED)) {
10463 		/* Pkt execution failed */
10464 		switch (cache_op) {
10465 		case SATAC_SF_ENABLE_READ_AHEAD:
10466 			infop = "enabling read ahead failed";
10467 			break;
10468 		case SATAC_SF_DISABLE_READ_AHEAD:
10469 			infop = "disabling read ahead failed";
10470 			break;
10471 		case SATAC_SF_ENABLE_WRITE_CACHE:
10472 			infop = "enabling write cache failed";
10473 			break;
10474 		case SATAC_SF_DISABLE_WRITE_CACHE:
10475 			infop = "disabling write cache failed";
10476 			break;
10477 		}
10478 		SATA_LOG_D((sata_hba_inst, CE_WARN, "%s", infop));
10479 		rval = SATA_FAILURE;
10480 	}
10481 failure:
10482 	/* Free allocated resources */
10483 	if (spkt != NULL)
10484 		sata_pkt_free(spx);
10485 	(void) kmem_free(spx, sizeof (sata_pkt_txlate_t));
10486 	return (rval);
10487 }
10488 
10489 /*
10490  * Set Removable Media Status Notification (enable/disable)
10491  * state == 0 , disable
10492  * state != 0 , enable
10493  *
10494  * If operation fails, system log messgage is emitted.
10495  * Returns SATA_SUCCESS when the operation succeeds, SATA_FAILURE otherwise.
10496  */
10497 
10498 static int
10499 sata_set_rmsn(sata_hba_inst_t *sata_hba_inst, sata_drive_info_t *sdinfo,
10500     int state)
10501 {
10502 	sata_pkt_t *spkt;
10503 	sata_cmd_t *scmd;
10504 	sata_pkt_txlate_t *spx;
10505 	int rval = SATA_SUCCESS;
10506 	char *infop;
10507 
10508 	ASSERT(sdinfo != NULL);
10509 	ASSERT(sata_hba_inst != NULL);
10510 
10511 	/* Prepare packet for SET FEATURES COMMAND */
10512 	spx = kmem_zalloc(sizeof (sata_pkt_txlate_t), KM_SLEEP);
10513 	spx->txlt_sata_hba_inst = sata_hba_inst;
10514 	spx->txlt_scsi_pkt = NULL;	/* No scsi pkt involved */
10515 	spkt = sata_pkt_alloc(spx, SLEEP_FUNC);
10516 	if (spkt == NULL) {
10517 		rval = SATA_FAILURE;
10518 		goto failure;
10519 	}
10520 	/* Fill sata_pkt */
10521 	spkt->satapkt_device.satadev_addr = sdinfo->satadrv_addr;
10522 	/* Timeout 30s */
10523 	spkt->satapkt_time = sata_default_pkt_time;
10524 	/* Synchronous mode, no callback, interrupts */
10525 	spkt->satapkt_op_mode =
10526 	    SATA_OPMODE_SYNCH | SATA_OPMODE_INTERRUPTS;
10527 	spkt->satapkt_comp = NULL;
10528 	scmd = &spkt->satapkt_cmd;
10529 	scmd->satacmd_flags.sata_data_direction = SATA_DIR_NODATA_XFER;
10530 	scmd->satacmd_flags.sata_ignore_dev_reset = B_TRUE;
10531 	scmd->satacmd_addr_type = 0;
10532 	scmd->satacmd_device_reg = 0;
10533 	scmd->satacmd_status_reg = 0;
10534 	scmd->satacmd_error_reg = 0;
10535 	scmd->satacmd_cmd_reg = SATAC_SET_FEATURES;
10536 	if (state == 0)
10537 		scmd->satacmd_features_reg = SATAC_SF_DISABLE_RMSN;
10538 	else
10539 		scmd->satacmd_features_reg = SATAC_SF_ENABLE_RMSN;
10540 
10541 	/* Transfer command to HBA */
10542 	if (((*SATA_START_FUNC(sata_hba_inst))(
10543 	    SATA_DIP(sata_hba_inst), spkt) != SATA_TRAN_ACCEPTED) ||
10544 	    (spkt->satapkt_reason != SATA_PKT_COMPLETED)) {
10545 		/* Pkt execution failed */
10546 		if (state == 0)
10547 			infop = "disabling Removable Media Status "
10548 			    "Notification failed";
10549 		else
10550 			infop = "enabling Removable Media Status "
10551 			    "Notification failed";
10552 
10553 		SATA_LOG_D((sata_hba_inst, CE_WARN, "%s", infop));
10554 		rval = SATA_FAILURE;
10555 	}
10556 failure:
10557 	/* Free allocated resources */
10558 	if (spkt != NULL)
10559 		sata_pkt_free(spx);
10560 	(void) kmem_free(spx, sizeof (sata_pkt_txlate_t));
10561 	return (rval);
10562 }
10563 
10564 
10565 /*
10566  * Update port SCR block
10567  */
10568 static void
10569 sata_update_port_scr(sata_port_scr_t *port_scr, sata_device_t *device)
10570 {
10571 	port_scr->sstatus = device->satadev_scr.sstatus;
10572 	port_scr->serror = device->satadev_scr.serror;
10573 	port_scr->scontrol = device->satadev_scr.scontrol;
10574 	port_scr->sactive = device->satadev_scr.sactive;
10575 	port_scr->snotific = device->satadev_scr.snotific;
10576 }
10577 
10578 /*
10579  * Update state and copy port ss* values from passed sata_device structure.
10580  * sata_address is validated - if not valid, nothing is changed in sata_scsi
10581  * configuration struct.
10582  *
10583  * SATA_PSTATE_SHUTDOWN in port state is not reset to 0 by this function
10584  * regardless of the state in device argument.
10585  *
10586  * Port mutex should be held while calling this function.
10587  */
10588 static void
10589 sata_update_port_info(sata_hba_inst_t *sata_hba_inst,
10590 	sata_device_t *sata_device)
10591 {
10592 	ASSERT(mutex_owned(&SATA_CPORT_MUTEX(sata_hba_inst,
10593 	    sata_device->satadev_addr.cport)));
10594 
10595 	if (sata_device->satadev_addr.qual == SATA_ADDR_CPORT ||
10596 	    sata_device->satadev_addr.qual == SATA_ADDR_DCPORT) {
10597 
10598 		sata_cport_info_t *cportinfo;
10599 
10600 		if (SATA_NUM_CPORTS(sata_hba_inst) <=
10601 		    sata_device->satadev_addr.cport)
10602 			return;
10603 
10604 		cportinfo = SATA_CPORT_INFO(sata_hba_inst,
10605 		    sata_device->satadev_addr.cport);
10606 		sata_update_port_scr(&cportinfo->cport_scr, sata_device);
10607 
10608 		/* Preserve SATA_PSTATE_SHUTDOWN flag */
10609 		cportinfo->cport_state &= ~(SATA_PSTATE_PWRON |
10610 		    SATA_PSTATE_PWROFF | SATA_PSTATE_FAILED);
10611 		cportinfo->cport_state |=
10612 		    sata_device->satadev_state & SATA_PSTATE_VALID;
10613 	} else {
10614 		sata_pmport_info_t *pmportinfo;
10615 
10616 		if ((sata_device->satadev_addr.qual != SATA_ADDR_PMPORT) ||
10617 		    (sata_device->satadev_addr.qual != SATA_ADDR_DPMPORT) ||
10618 		    SATA_NUM_PMPORTS(sata_hba_inst,
10619 		    sata_device->satadev_addr.cport) <
10620 		    sata_device->satadev_addr.pmport)
10621 			return;
10622 
10623 		pmportinfo = SATA_PMPORT_INFO(sata_hba_inst,
10624 		    sata_device->satadev_addr.cport,
10625 		    sata_device->satadev_addr.pmport);
10626 		sata_update_port_scr(&pmportinfo->pmport_scr, sata_device);
10627 
10628 		/* Preserve SATA_PSTATE_SHUTDOWN flag */
10629 		pmportinfo->pmport_state &=
10630 		    ~(SATA_PSTATE_PWRON | SATA_PSTATE_PWROFF |
10631 		    SATA_PSTATE_FAILED);
10632 		pmportinfo->pmport_state |=
10633 		    sata_device->satadev_state & SATA_PSTATE_VALID;
10634 	}
10635 }
10636 
10637 
10638 
10639 /*
10640  * Extract SATA port specification from an IOCTL argument.
10641  *
10642  * This function return the port the user land send us as is, unless it
10643  * cannot retrieve port spec, then -1 is returned.
10644  *
10645  * Note: Only cport  - no port multiplier port.
10646  */
10647 static int32_t
10648 sata_get_port_num(sata_hba_inst_t *sata_hba_inst, struct devctl_iocdata *dcp)
10649 {
10650 	int32_t port;
10651 
10652 	/* Extract port number from nvpair in dca structure  */
10653 	if (nvlist_lookup_int32(ndi_dc_get_ap_data(dcp), "port", &port) != 0) {
10654 		SATA_LOG_D((sata_hba_inst, CE_NOTE,
10655 		    "sata_get_port_num: invalid port spec 0x%x in ioctl",
10656 		    port));
10657 		port = -1;
10658 	}
10659 
10660 	return (port);
10661 }
10662 
10663 /*
10664  * Get dev_info_t pointer to the device node pointed to by port argument.
10665  * NOTE: target argument is a value used in ioctls to identify
10666  * the AP - it is not a sata_address.
10667  * It is a combination of cport, pmport and address qualifier, encodded same
10668  * way as a scsi target number.
10669  * At this moment it carries only cport number.
10670  *
10671  * No PMult hotplug support.
10672  *
10673  * Returns dev_info_t pointer if target device was found, NULL otherwise.
10674  */
10675 
10676 static dev_info_t *
10677 sata_get_target_dip(dev_info_t *dip, int32_t port)
10678 {
10679 	dev_info_t	*cdip = NULL;
10680 	int		target, tgt;
10681 	int		ncport;
10682 	int 		circ;
10683 
10684 	ncport = port & SATA_CFGA_CPORT_MASK;
10685 	target = SATA_TO_SCSI_TARGET(ncport, 0, SATA_ADDR_DCPORT);
10686 
10687 	ndi_devi_enter(dip, &circ);
10688 	for (cdip = ddi_get_child(dip); cdip != NULL; ) {
10689 		dev_info_t *next = ddi_get_next_sibling(cdip);
10690 
10691 		tgt = ddi_prop_get_int(DDI_DEV_T_ANY, cdip,
10692 		    DDI_PROP_DONTPASS, "target", -1);
10693 		if (tgt == -1) {
10694 			/*
10695 			 * This is actually an error condition, but not
10696 			 * a fatal one. Just continue the search.
10697 			 */
10698 			cdip = next;
10699 			continue;
10700 		}
10701 
10702 		if (tgt == target)
10703 			break;
10704 
10705 		cdip = next;
10706 	}
10707 	ndi_devi_exit(dip, circ);
10708 
10709 	return (cdip);
10710 }
10711 
10712 /*
10713  * Get dev_info_t pointer to the device node pointed to by port argument.
10714  * NOTE: target argument is a value used in ioctls to identify
10715  * the AP - it is not a sata_address.
10716  * It is a combination of cport, pmport and address qualifier, encoded same
10717  * way as a scsi target number.
10718  * At this moment it carries only cport number.
10719  *
10720  * No PMult hotplug support.
10721  *
10722  * Returns dev_info_t pointer if target device was found, NULL otherwise.
10723  */
10724 
10725 static dev_info_t *
10726 sata_get_scsi_target_dip(dev_info_t *dip, sata_address_t *saddr)
10727 {
10728 	dev_info_t	*cdip = NULL;
10729 	int		target, tgt;
10730 	int 		circ;
10731 
10732 	target = SATA_TO_SCSI_TARGET(saddr->cport, saddr->pmport, saddr->qual);
10733 
10734 	ndi_devi_enter(dip, &circ);
10735 	for (cdip = ddi_get_child(dip); cdip != NULL; ) {
10736 		dev_info_t *next = ddi_get_next_sibling(cdip);
10737 
10738 		tgt = ddi_prop_get_int(DDI_DEV_T_ANY, cdip,
10739 		    DDI_PROP_DONTPASS, "target", -1);
10740 		if (tgt == -1) {
10741 			/*
10742 			 * This is actually an error condition, but not
10743 			 * a fatal one. Just continue the search.
10744 			 */
10745 			cdip = next;
10746 			continue;
10747 		}
10748 
10749 		if (tgt == target)
10750 			break;
10751 
10752 		cdip = next;
10753 	}
10754 	ndi_devi_exit(dip, circ);
10755 
10756 	return (cdip);
10757 }
10758 
10759 /*
10760  * Process sata port disconnect request.
10761  * Normally, cfgadm sata plugin will try to offline (unconfigure) the device
10762  * before this request. Nevertheless, if a device is still configured,
10763  * we need to attempt to offline and unconfigure device.
10764  * Regardless of the unconfigure operation results the port is marked as
10765  * deactivated and no access to the attached device is possible.
10766  * If the target node remains because unconfigure operation failed, its state
10767  * will be set to DEVICE_REMOVED, preventing it to be used again when a device
10768  * is inserted/re-inserted. The event daemon will repeatedly try to unconfigure
10769  * the device and remove old target node.
10770  *
10771  * This function invokes sata_hba_inst->satahba_tran->
10772  * sata_tran_hotplug_ops->sata_tran_port_deactivate().
10773  * If successful, the device structure (if any) attached to the specified port
10774  * is removed and state of the port marked appropriately.
10775  * Failure of the port_deactivate may keep port in the physically active state,
10776  * or may fail the port.
10777  *
10778  * NOTE: Port multiplier code is not completed nor tested.
10779  */
10780 
10781 static int
10782 sata_ioctl_disconnect(sata_hba_inst_t *sata_hba_inst,
10783     sata_device_t *sata_device)
10784 {
10785 	sata_drive_info_t *sdinfo = NULL;
10786 	sata_cport_info_t *cportinfo = NULL;
10787 	sata_pmport_info_t *pmportinfo = NULL;
10788 	sata_pmult_info_t *pmultinfo = NULL;
10789 	dev_info_t *tdip;
10790 	int cport, pmport, qual;
10791 	int rval = SATA_SUCCESS;
10792 	int rv = 0;
10793 
10794 	cport = sata_device->satadev_addr.cport;
10795 	pmport = sata_device->satadev_addr.pmport;
10796 	qual = sata_device->satadev_addr.qual;
10797 
10798 	ASSERT(qual == SATA_ADDR_CPORT || qual == SATA_ADDR_PMPORT);
10799 
10800 	/*
10801 	 * DEVCTL_AP_DISCONNECT invokes sata_hba_inst->satahba_tran->
10802 	 * sata_tran_hotplug_ops->sata_tran_port_deactivate().
10803 	 * Do the sanity check.
10804 	 */
10805 	if (SATA_PORT_DEACTIVATE_FUNC(sata_hba_inst) == NULL) {
10806 		/* No physical port deactivation supported. */
10807 		return (EINVAL);
10808 	}
10809 
10810 	/* Check the current state of the port */
10811 	rval = (*SATA_PROBE_PORT_FUNC(sata_hba_inst))
10812 	    (SATA_DIP(sata_hba_inst), sata_device);
10813 	mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex);
10814 	sata_update_port_info(sata_hba_inst, sata_device);
10815 	if (rval != SATA_SUCCESS ||
10816 	    (sata_device->satadev_state & SATA_PSTATE_FAILED) != 0) {
10817 		/* Device port status is unknown or it is in failed state */
10818 		if (qual == SATA_ADDR_PMPORT) {
10819 			SATA_PMPORT_STATE(sata_hba_inst, cport, pmport) =
10820 			    SATA_PSTATE_FAILED;
10821 			SATADBG1(SATA_DBG_IOCTL_IF, sata_hba_inst,
10822 			    "sata_hba_ioctl: connect: failed to deactivate "
10823 			    "SATA port %d", cport);
10824 		} else {
10825 			SATA_CPORT_STATE(sata_hba_inst, cport) =
10826 			    SATA_PSTATE_FAILED;
10827 			SATADBG2(SATA_DBG_IOCTL_IF, sata_hba_inst,
10828 			    "sata_hba_ioctl: connect: failed to deactivate "
10829 			    "SATA port %d:%d", cport, pmport);
10830 		}
10831 		mutex_exit(&SATA_CPORT_INFO(sata_hba_inst,
10832 		    cport)->cport_mutex);
10833 		return (EIO);
10834 	}
10835 	/*
10836 	 * Set port's dev_state to not ready - this will disable
10837 	 * an access to a potentially attached device.
10838 	 */
10839 	cportinfo = SATA_CPORT_INFO(sata_hba_inst, cport);
10840 	if (qual == SATA_ADDR_PMPORT) {
10841 		pmportinfo = SATA_PMPORT_INFO(sata_hba_inst, cport, pmport);
10842 		if (pmportinfo->pmport_dev_type != SATA_DTYPE_NONE) {
10843 			sdinfo = pmportinfo->pmport_sata_drive;
10844 			ASSERT(sdinfo != NULL);
10845 		}
10846 		pmportinfo->pmport_state &= ~SATA_STATE_READY;
10847 	} else {
10848 		/* Assuming cport */
10849 
10850 		if (cportinfo->cport_dev_type != SATA_DTYPE_NONE) {
10851 			if (cportinfo->cport_dev_type == SATA_DTYPE_PMULT) {
10852 				pmultinfo =
10853 				    cportinfo->cport_devp.cport_sata_pmult;
10854 				ASSERT(pmultinfo != NULL);
10855 			} else if (cportinfo->cport_dev_type &
10856 			    SATA_VALID_DEV_TYPE) {
10857 				sdinfo = cportinfo->cport_devp.cport_sata_drive;
10858 				ASSERT(sdinfo != NULL);
10859 			}
10860 		}
10861 		cportinfo->cport_state &= ~SATA_STATE_READY;
10862 	}
10863 	if (sdinfo != NULL) {
10864 		if ((sdinfo->satadrv_type & (SATA_VALID_DEV_TYPE)) != 0) {
10865 			/*
10866 			 * If a target node exists, try to offline
10867 			 * a device and remove target node.
10868 			 */
10869 			mutex_exit(&SATA_CPORT_INFO(sata_hba_inst,
10870 			    cport)->cport_mutex);
10871 			/* We are addressing attached device, not a port */
10872 			sata_device->satadev_addr.qual =
10873 			    sdinfo->satadrv_addr.qual;
10874 			tdip = sata_get_scsi_target_dip(SATA_DIP(sata_hba_inst),
10875 			    &sata_device->satadev_addr);
10876 			if (tdip != NULL && ndi_devi_offline(tdip,
10877 			    NDI_DEVI_REMOVE) != NDI_SUCCESS) {
10878 				/*
10879 				 * Problem
10880 				 * The target node remained attached.
10881 				 * This happens when the device file was open
10882 				 * or a node was waiting for resources.
10883 				 * Cannot do anything about it.
10884 				 */
10885 				if (qual == SATA_ADDR_CPORT) {
10886 					SATA_LOG_D((sata_hba_inst, CE_WARN,
10887 					    "sata_hba_ioctl: disconnect: could "
10888 					    "not unconfigure device before "
10889 					    "disconnecting the SATA port %d",
10890 					    cport));
10891 				} else {
10892 					SATA_LOG_D((sata_hba_inst, CE_WARN,
10893 					    "sata_hba_ioctl: disconnect: could "
10894 					    "not unconfigure device before "
10895 					    "disconnecting the SATA port %d:%d",
10896 					    cport, pmport));
10897 				}
10898 				/*
10899 				 * Set DEVICE REMOVED state in the target
10900 				 * node. It will prevent access to the device
10901 				 * even when a new device is attached, until
10902 				 * the old target node is released, removed and
10903 				 * recreated for a new  device.
10904 				 */
10905 				sata_set_device_removed(tdip);
10906 
10907 				/*
10908 				 * Instruct event daemon to try the target
10909 				 * node cleanup later.
10910 				 */
10911 				sata_set_target_node_cleanup(
10912 				    sata_hba_inst, &sata_device->satadev_addr);
10913 			}
10914 			mutex_enter(&SATA_CPORT_INFO(sata_hba_inst,
10915 			    cport)->cport_mutex);
10916 		}
10917 
10918 		/* Remove and release sata_drive info structure. */
10919 		if (pmportinfo != NULL) {
10920 			SATA_PMPORT_DRV_INFO(sata_hba_inst, cport, pmport) =
10921 			    NULL;
10922 			pmportinfo->pmport_dev_type = SATA_DTYPE_NONE;
10923 		} else {
10924 			SATA_CPORTINFO_DRV_INFO(cportinfo) = NULL;
10925 			cportinfo->cport_dev_type = SATA_DTYPE_NONE;
10926 		}
10927 		(void) kmem_free((void *)sdinfo, sizeof (sata_drive_info_t));
10928 	}
10929 #if 0
10930 	else if (pmultinfo != NULL) {
10931 		/*
10932 		 * Port Multiplier itself needs special handling.
10933 		 * All device ports need to be processed here!
10934 		 */
10935 	}
10936 #endif
10937 	mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex);
10938 	/* Just ask HBA driver to deactivate port */
10939 	/*	sata_device->satadev_addr.qual = SATA_ADDR_DCPORT; */
10940 
10941 	rval = (*SATA_PORT_DEACTIVATE_FUNC(sata_hba_inst))
10942 	    (SATA_DIP(sata_hba_inst), sata_device);
10943 
10944 	/*
10945 	 * Generate sysevent - EC_DR / ESC_DR_AP_STATE_CHANGE
10946 	 * without the hint (to force listener to investivate the state).
10947 	 */
10948 	sata_gen_sysevent(sata_hba_inst, &sata_device->satadev_addr,
10949 	    SE_NO_HINT);
10950 
10951 	mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex);
10952 	sata_update_port_info(sata_hba_inst, sata_device);
10953 
10954 	if (rval != SATA_SUCCESS) {
10955 		/*
10956 		 * Port deactivation failure - do not
10957 		 * change port state unless the state
10958 		 * returned by HBA indicates a port failure.
10959 		 * NOTE: device structures were released, so devices now are
10960 		 * invisible! Port reset is needed to re-enumerate devices.
10961 		 */
10962 		if (sata_device->satadev_state & SATA_PSTATE_FAILED) {
10963 			if (pmportinfo != NULL)
10964 				pmportinfo->pmport_state = SATA_PSTATE_FAILED;
10965 			else
10966 				cportinfo->cport_state = SATA_PSTATE_FAILED;
10967 			rv = EIO;
10968 		}
10969 	} else {
10970 		/*
10971 		 * Deactivation succeded. From now on the sata framework
10972 		 * will not care what is happening to the device, until
10973 		 * the port is activated again.
10974 		 */
10975 		cportinfo->cport_state |= SATA_PSTATE_SHUTDOWN;
10976 	}
10977 	mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex);
10978 	return (rv);
10979 }
10980 
10981 
10982 
10983 /*
10984  * Process sata port connect request
10985  * The sata cfgadm pluging will invoke this operation only if port was found
10986  * in the disconnect state (failed state is also treated as the disconnected
10987  * state).
10988  * DEVCTL_AP_CONNECT would invoke  sata_hba_inst->satahba_tran->
10989  * sata_tran_hotplug_ops->sata_tran_port_activate().
10990  * If successful and a device is found attached to the port,
10991  * the initialization sequence is executed to attach a device structure to
10992  * a port structure. The state of the port and a device would be set
10993  * appropriately.
10994  * The device is not set in configured state (system-wise) by this operation.
10995  *
10996  * Note, that activating the port may generate link events,
10997  * so it is important that following processing and the
10998  * event processing does not interfere with each other!
10999  *
11000  * This operation may remove port failed state and will
11001  * try to make port active and in good standing.
11002  *
11003  * NOTE: Port multiplier code is not completed nor tested.
11004  */
11005 
11006 static int
11007 sata_ioctl_connect(sata_hba_inst_t *sata_hba_inst,
11008     sata_device_t *sata_device)
11009 {
11010 	int cport, pmport, qual;
11011 	int rv = 0;
11012 
11013 	cport = sata_device->satadev_addr.cport;
11014 	pmport = sata_device->satadev_addr.pmport;
11015 	qual = sata_device->satadev_addr.qual;
11016 
11017 	ASSERT(qual == SATA_ADDR_CPORT || qual == SATA_ADDR_PMPORT);
11018 
11019 	/*
11020 	 * DEVCTL_AP_CONNECT would invoke sata_hba_inst->
11021 	 * satahba_tran->sata_tran_hotplug_ops->sata_tran_port_activate().
11022 	 * Perform sanity check now.
11023 	 */
11024 	if (SATA_PORT_ACTIVATE_FUNC(sata_hba_inst) == NULL) {
11025 		/* No physical port activation supported. */
11026 		return (EINVAL);
11027 	}
11028 
11029 	/* Just ask HBA driver to activate port */
11030 	if ((*SATA_PORT_ACTIVATE_FUNC(sata_hba_inst))
11031 	    (SATA_DIP(sata_hba_inst), sata_device) != SATA_SUCCESS) {
11032 		/*
11033 		 * Port activation failure.
11034 		 */
11035 		mutex_enter(&SATA_CPORT_INFO(sata_hba_inst,
11036 		    cport)->cport_mutex);
11037 		sata_update_port_info(sata_hba_inst, sata_device);
11038 		if (sata_device->satadev_state & SATA_PSTATE_FAILED) {
11039 			if (qual == SATA_ADDR_DCPORT) {
11040 				SATA_CPORT_STATE(sata_hba_inst, cport) =
11041 				    SATA_PSTATE_FAILED;
11042 				SATADBG1(SATA_DBG_IOCTL_IF, sata_hba_inst,
11043 				    "sata_hba_ioctl: connect: failed to "
11044 				    "activate SATA port %d", cport);
11045 			} else { /* port multiplier device port */
11046 				SATA_PMPORT_STATE(sata_hba_inst, cport,
11047 				    pmport) = SATA_PSTATE_FAILED;
11048 				SATADBG2(SATA_DBG_IOCTL_IF, sata_hba_inst,
11049 				    "sata_hba_ioctl: connect: failed to "
11050 				    "activate SATA port %d:%d", cport, pmport);
11051 
11052 			}
11053 		}
11054 		mutex_exit(&SATA_CPORT_INFO(sata_hba_inst,
11055 		    cport)->cport_mutex);
11056 		SATADBG2(SATA_DBG_IOCTL_IF, sata_hba_inst,
11057 		    "sata_hba_ioctl: connect: failed to activate SATA "
11058 		    "port %d:%d", cport, pmport);
11059 		return (EIO);
11060 	}
11061 
11062 	/* Virgin port state - will be updated by the port re-probe. */
11063 	mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex);
11064 	if (qual == SATA_ADDR_CPORT)
11065 		SATA_CPORT_STATE(sata_hba_inst, cport) = 0;
11066 	else /* port multiplier device port */
11067 		SATA_PMPORT_STATE(sata_hba_inst, cport, pmport) = 0;
11068 	mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex);
11069 
11070 	/*
11071 	 * Probe the port to find its state and attached device.
11072 	 */
11073 	if (sata_reprobe_port(sata_hba_inst, sata_device,
11074 	    SATA_DEV_IDENTIFY_RETRY) == SATA_FAILURE)
11075 		rv = EIO;
11076 
11077 	/*
11078 	 * Generate sysevent - EC_DR / ESC_DR_AP_STATE_CHANGE
11079 	 * without the hint
11080 	 */
11081 	sata_gen_sysevent(sata_hba_inst, &sata_device->satadev_addr,
11082 	    SE_NO_HINT);
11083 
11084 	/*
11085 	 * If there is a device attached to the port, emit
11086 	 * a message.
11087 	 */
11088 	if (qual == SATA_ADDR_CPORT) {
11089 		if (SATA_CPORT_DEV_TYPE(sata_hba_inst, cport) !=
11090 		    SATA_DTYPE_NONE)
11091 			sata_log(sata_hba_inst, CE_WARN,
11092 			    "SATA device detected at port %d", cport);
11093 	} else { /* port multiplier device port */
11094 		if (SATA_PMPORT_STATE(sata_hba_inst, cport, pmport) !=
11095 		    SATA_DTYPE_NONE)
11096 			sata_log(sata_hba_inst, CE_WARN,
11097 			    "SATA device detected at port %d:%d",
11098 			    cport, pmport);
11099 	}
11100 
11101 	return (rv);
11102 }
11103 
11104 
11105 /*
11106  * Process sata device unconfigure request.
11107  * The unconfigure operation uses generic nexus operation to
11108  * offline a device. It leaves a target device node attached.
11109  * and obviously sata_drive_info attached as well, because
11110  * from the hardware point of view nothing has changed.
11111  */
11112 static int
11113 sata_ioctl_unconfigure(sata_hba_inst_t *sata_hba_inst,
11114     sata_device_t *sata_device)
11115 {
11116 	int rv = 0;
11117 	dev_info_t *tdip;
11118 
11119 	/* We are addressing attached device, not a port */
11120 	if (sata_device->satadev_addr.qual == SATA_ADDR_CPORT)
11121 		sata_device->satadev_addr.qual = SATA_ADDR_DCPORT;
11122 	else if (sata_device->satadev_addr.qual == SATA_ADDR_PMPORT)
11123 		sata_device->satadev_addr.qual = SATA_ADDR_DPMPORT;
11124 
11125 	if ((tdip = sata_get_scsi_target_dip(SATA_DIP(sata_hba_inst),
11126 	    &sata_device->satadev_addr)) != NULL) {
11127 
11128 		if (ndi_devi_offline(tdip, NDI_UNCONFIG) != NDI_SUCCESS) {
11129 			SATA_LOG_D((sata_hba_inst, CE_WARN,
11130 			    "sata_hba_ioctl: unconfigure: "
11131 			    "failed to unconfigure device at SATA port %d:%d",
11132 			    sata_device->satadev_addr.cport,
11133 			    sata_device->satadev_addr.pmport));
11134 			rv = EIO;
11135 		}
11136 		/*
11137 		 * The target node devi_state should be marked with
11138 		 * DEVI_DEVICE_OFFLINE by ndi_devi_offline().
11139 		 * This would be the indication for cfgadm that
11140 		 * the AP node occupant state is 'unconfigured'.
11141 		 */
11142 
11143 	} else {
11144 		/*
11145 		 * This would indicate a failure on the part of cfgadm
11146 		 * to detect correct state of the node prior to this
11147 		 * call - one cannot unconfigure non-existing device.
11148 		 */
11149 		SATA_LOG_D((sata_hba_inst, CE_WARN,
11150 		    "sata_hba_ioctl: unconfigure: "
11151 		    "attempt to unconfigure non-existing device "
11152 		    "at SATA port %d:%d",
11153 		    sata_device->satadev_addr.cport,
11154 		    sata_device->satadev_addr.pmport));
11155 		rv = ENXIO;
11156 	}
11157 	return (rv);
11158 }
11159 
11160 /*
11161  * Process sata device configure request
11162  * If port is in a failed state, operation is aborted - one has to use
11163  * an explicit connect or port activate request to try to get a port into
11164  * non-failed mode. Port reset wil also work in such situation.
11165  * If the port is in disconnected (shutdown) state, the connect operation is
11166  * attempted prior to any other action.
11167  * When port is in the active state, there is a device attached and the target
11168  * node exists, a device was most likely offlined.
11169  * If target node does not exist, a new target node is created. In both cases
11170  * an attempt is made to online (configure) the device.
11171  *
11172  * NOTE: Port multiplier code is not completed nor tested.
11173  */
11174 static int
11175 sata_ioctl_configure(sata_hba_inst_t *sata_hba_inst,
11176     sata_device_t *sata_device)
11177 {
11178 	int cport, pmport, qual;
11179 	int rval;
11180 	boolean_t target = TRUE;
11181 	sata_cport_info_t *cportinfo;
11182 	sata_pmport_info_t *pmportinfo = NULL;
11183 	dev_info_t *tdip;
11184 	sata_drive_info_t *sdinfo;
11185 
11186 	cport = sata_device->satadev_addr.cport;
11187 	pmport = sata_device->satadev_addr.pmport;
11188 	qual = sata_device->satadev_addr.qual;
11189 
11190 	/* Get current port state */
11191 	rval = (*SATA_PROBE_PORT_FUNC(sata_hba_inst))
11192 	    (SATA_DIP(sata_hba_inst), sata_device);
11193 	mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex);
11194 	sata_update_port_info(sata_hba_inst, sata_device);
11195 
11196 	if (rval != SATA_SUCCESS ||
11197 	    (sata_device->satadev_state & SATA_PSTATE_FAILED) != 0) {
11198 		/* Obviously, device on a failed port is not visible */
11199 		mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex);
11200 		return (ENXIO);
11201 	}
11202 
11203 	cportinfo = SATA_CPORT_INFO(sata_hba_inst, cport);
11204 	if (qual == SATA_ADDR_PMPORT)
11205 		pmportinfo = SATA_PMPORT_INFO(sata_hba_inst, cport, pmport);
11206 	mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex);
11207 
11208 	if ((sata_device->satadev_state & SATA_PSTATE_SHUTDOWN) != 0) {
11209 		/* need to activate port */
11210 		target = FALSE;
11211 
11212 		/* Sanity check */
11213 		if (SATA_PORT_ACTIVATE_FUNC(sata_hba_inst) == NULL)
11214 			return (ENXIO);
11215 
11216 		/* Just let HBA driver to activate port */
11217 		if ((*SATA_PORT_ACTIVATE_FUNC(sata_hba_inst))
11218 		    (SATA_DIP(sata_hba_inst), sata_device) != SATA_SUCCESS) {
11219 			/*
11220 			 * Port activation failure - do not change port state
11221 			 * unless the state returned by HBA indicates a port
11222 			 * failure.
11223 			 */
11224 			mutex_enter(&SATA_CPORT_INFO(sata_hba_inst,
11225 			    cport)->cport_mutex);
11226 			sata_update_port_info(sata_hba_inst, sata_device);
11227 			if (sata_device->satadev_state & SATA_PSTATE_FAILED) {
11228 				if (qual == SATA_ADDR_PMPORT)
11229 					pmportinfo->pmport_state =
11230 					    SATA_PSTATE_FAILED;
11231 				else
11232 					cportinfo->cport_state =
11233 					    SATA_PSTATE_FAILED;
11234 			}
11235 			mutex_exit(&SATA_CPORT_INFO(
11236 			    sata_hba_inst, cport)->cport_mutex);
11237 			SATA_LOG_D((sata_hba_inst, CE_WARN,
11238 			    "sata_hba_ioctl: configure: "
11239 			    "failed to activate SATA port %d:%d",
11240 			    cport, pmport));
11241 			return (EIO);
11242 		}
11243 		/*
11244 		 * Generate sysevent - EC_DR / ESC_DR_AP_STATE_CHANGE
11245 		 * without the hint.
11246 		 */
11247 		sata_gen_sysevent(sata_hba_inst,
11248 		    &sata_device->satadev_addr, SE_NO_HINT);
11249 
11250 		mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, cport)->
11251 		    cport_mutex);
11252 		/* Virgin port state */
11253 		if (qual == SATA_ADDR_PMPORT)
11254 			pmportinfo->pmport_state = 0;
11255 		else
11256 			cportinfo->cport_state = 0;
11257 		mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex);
11258 	}
11259 	/*
11260 	 * Always reprobe port, to get current device info.
11261 	 */
11262 	if (sata_reprobe_port(sata_hba_inst, sata_device,
11263 	    SATA_DEV_IDENTIFY_RETRY) != SATA_SUCCESS)
11264 		return (EIO);
11265 
11266 	if (qual == SATA_ADDR_PMPORT) {
11267 		if (pmportinfo->pmport_dev_type != SATA_DTYPE_NONE &&
11268 		    target == FALSE) {
11269 			/*
11270 			 * That's the transition from "inactive" port
11271 			 * to active one with device attached.
11272 			 */
11273 			sata_log(sata_hba_inst, CE_WARN,
11274 			    "SATA device detected at port %d:%d",
11275 			    cport, pmport);
11276 		}
11277 	} else {
11278 		if (cportinfo->cport_dev_type != SATA_DTYPE_NONE &&
11279 		    target == FALSE) {
11280 			/*
11281 			 * When PM is attached to the cport and cport is
11282 			 * activated, every PM device port needs to be reprobed.
11283 			 * We need to emit message for all devices detected
11284 			 * at port multiplier's device ports.
11285 			 * Add such code here.
11286 			 * For now, just inform about device attached to
11287 			 * cport.
11288 			 */
11289 			sata_log(sata_hba_inst, CE_WARN,
11290 			    "SATA device detected at port %d", cport);
11291 		}
11292 	}
11293 
11294 	/*
11295 	 * This is where real configuration operation starts.
11296 	 *
11297 	 * When PM is attached to the cport and cport is activated,
11298 	 * devices attached PM device ports may have to be configured
11299 	 * explicitly. This may change when port multiplier is supported.
11300 	 * For now, configure only disks and other valid target devices.
11301 	 */
11302 	if (!(sata_device->satadev_type & SATA_VALID_DEV_TYPE)) {
11303 		return (ENXIO);		/* No device to configure */
11304 	}
11305 
11306 	/*
11307 	 * Here we may have a device in reset condition,
11308 	 * but because we are just configuring it, there is
11309 	 * no need to process the reset other than just
11310 	 * to clear device reset condition in the HBA driver.
11311 	 * Setting the flag SATA_EVNT_CLEAR_DEVICE_RESET will
11312 	 * cause a first command sent the HBA driver with the request
11313 	 * to clear device reset condition.
11314 	 */
11315 	mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex);
11316 	if (qual == SATA_ADDR_PMPORT)
11317 		sata_device->satadev_addr.qual = SATA_ADDR_DPMPORT;
11318 	else
11319 		sata_device->satadev_addr.qual = SATA_ADDR_DCPORT;
11320 	sdinfo = sata_get_device_info(sata_hba_inst, sata_device);
11321 	if (sdinfo == NULL) {
11322 		mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex);
11323 		return (ENXIO);
11324 	}
11325 	if (sdinfo->satadrv_event_flags &
11326 	    (SATA_EVNT_DEVICE_RESET | SATA_EVNT_INPROC_DEVICE_RESET)) {
11327 		sdinfo->satadrv_event_flags = 0;
11328 		sdinfo->satadrv_event_flags |= SATA_EVNT_CLEAR_DEVICE_RESET;
11329 	}
11330 	mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex);
11331 
11332 	if ((tdip = sata_get_scsi_target_dip(SATA_DIP(sata_hba_inst),
11333 	    &sata_device->satadev_addr)) != NULL) {
11334 		/*
11335 		 * Target node exists. Verify, that it belongs
11336 		 * to existing, attached device and not to
11337 		 * a removed device.
11338 		 */
11339 		if (sata_check_device_removed(tdip) == B_TRUE) {
11340 			if (qual == SATA_ADDR_DPMPORT)
11341 				sata_log(sata_hba_inst, CE_WARN,
11342 				    "SATA device at port %d cannot be "
11343 				    "configured. "
11344 				    "Application(s) accessing "
11345 				    "previously attached device "
11346 				    "have to release it before newly "
11347 				    "inserted device can be made accessible.",
11348 				    cport);
11349 			else
11350 				sata_log(sata_hba_inst, CE_WARN,
11351 				    "SATA device at port %d:%d cannot be"
11352 				    "configured. "
11353 				    "Application(s) accessing "
11354 				    "previously attached device "
11355 				    "have to release it before newly "
11356 				    "inserted device can be made accessible.",
11357 				    cport, pmport);
11358 			return (EIO);
11359 		}
11360 		/*
11361 		 * Device was not removed and re-inserted.
11362 		 * Try to online it.
11363 		 */
11364 		if (ndi_devi_online(tdip, 0) != NDI_SUCCESS) {
11365 			SATA_LOG_D((sata_hba_inst, CE_WARN,
11366 			    "sata_hba_ioctl: configure: "
11367 			    "onlining device at SATA port "
11368 			    "%d:%d failed", cport, pmport));
11369 			return (EIO);
11370 		}
11371 		mutex_enter(&SATA_CPORT_INFO(sata_hba_inst,
11372 		    cport)->cport_mutex);
11373 
11374 		if (qual == SATA_ADDR_DPMPORT)
11375 			pmportinfo->pmport_tgtnode_clean = B_TRUE;
11376 		else
11377 			cportinfo-> cport_tgtnode_clean = B_TRUE;
11378 
11379 		mutex_exit(&SATA_CPORT_INFO(
11380 		    sata_hba_inst, cport)->cport_mutex);
11381 	} else {
11382 		/*
11383 		 * No target node - need to create a new target node.
11384 		 */
11385 		mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, cport)->
11386 		    cport_mutex);
11387 		if (qual == SATA_ADDR_DPMPORT)
11388 			pmportinfo->pmport_tgtnode_clean = B_TRUE;
11389 		else
11390 			cportinfo-> cport_tgtnode_clean = B_TRUE;
11391 
11392 		mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)->
11393 		    cport_mutex);
11394 		tdip = sata_create_target_node(SATA_DIP(sata_hba_inst),
11395 		    sata_hba_inst, &sata_device->satadev_addr);
11396 		if (tdip == NULL) {
11397 			/* Configure operation failed */
11398 			SATA_LOG_D((sata_hba_inst, CE_WARN,
11399 			    "sata_hba_ioctl: configure: "
11400 			    "configuring SATA device at port %d:%d "
11401 			    "failed", cport, pmport));
11402 			return (EIO);
11403 		}
11404 	}
11405 	return (0);
11406 }
11407 
11408 
11409 /*
11410  * Process ioctl deactivate port request.
11411  * Arbitrarily unconfigure attached device, if any.
11412  * Even if the unconfigure fails, proceed with the
11413  * port deactivation.
11414  *
11415  * NOTE: Port Multiplier code is not completed and tested.
11416  */
11417 
11418 static int
11419 sata_ioctl_deactivate(sata_hba_inst_t *sata_hba_inst,
11420     sata_device_t *sata_device)
11421 {
11422 	int cport, pmport, qual;
11423 	int rval, rv = 0;
11424 	sata_cport_info_t *cportinfo;
11425 	sata_pmport_info_t *pmportinfo = NULL;
11426 	dev_info_t *tdip;
11427 	sata_drive_info_t *sdinfo = NULL;
11428 
11429 	/* Sanity check */
11430 	if (SATA_PORT_DEACTIVATE_FUNC(sata_hba_inst) == NULL)
11431 		return (ENOTSUP);
11432 
11433 	cport = sata_device->satadev_addr.cport;
11434 	pmport = sata_device->satadev_addr.pmport;
11435 	qual = sata_device->satadev_addr.qual;
11436 
11437 	mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex);
11438 	cportinfo = SATA_CPORT_INFO(sata_hba_inst, cport);
11439 	if (qual == SATA_ADDR_CPORT) {
11440 		sata_device->satadev_addr.qual = SATA_ADDR_DCPORT;
11441 		if (cportinfo->cport_dev_type != SATA_DTYPE_NONE) {
11442 			/*
11443 			 * For now, assume that port multiplier is not
11444 			 * supported, i.e. deal only with valid devices
11445 			 */
11446 			if ((cportinfo->cport_dev_type &
11447 			    SATA_VALID_DEV_TYPE) != 0)
11448 				sdinfo = sata_get_device_info(sata_hba_inst,
11449 				    sata_device);
11450 			/*
11451 			 * If attached device is a port multiplier, we will
11452 			 * have to unconfigure all devices attached to the
11453 			 * port multiplier. Add this code here.
11454 			 */
11455 		}
11456 		cportinfo->cport_state &= ~SATA_STATE_READY;
11457 	} else {
11458 		/* Port multiplier device port */
11459 		pmportinfo = SATA_PMPORT_INFO(sata_hba_inst, cport, pmport);
11460 		sata_device->satadev_addr.qual = SATA_ADDR_DPMPORT;
11461 		if (pmportinfo->pmport_dev_type != SATA_DTYPE_NONE &&
11462 		    (pmportinfo->pmport_dev_type & SATA_VALID_DEV_TYPE) != 0)
11463 			sdinfo = sata_get_device_info(sata_hba_inst,
11464 			    sata_device);
11465 		pmportinfo->pmport_state &= ~SATA_STATE_READY;
11466 	}
11467 
11468 	if (sdinfo != NULL) {
11469 		/*
11470 		 * If a target node exists, try to offline a device and
11471 		 * to remove a target node.
11472 		 */
11473 		mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)->
11474 		    cport_mutex);
11475 		tdip = sata_get_scsi_target_dip(SATA_DIP(sata_hba_inst),
11476 		    &sata_device->satadev_addr);
11477 		if (tdip != NULL) {
11478 			/* target node exist */
11479 			SATADBG1(SATA_DBG_IOCTL_IF, sata_hba_inst,
11480 			    "sata_hba_ioctl: port deactivate: "
11481 			    "target node exists.", NULL);
11482 
11483 			if (ndi_devi_offline(tdip, NDI_DEVI_REMOVE) !=
11484 			    NDI_SUCCESS) {
11485 				SATA_LOG_D((sata_hba_inst, CE_WARN,
11486 				    "sata_hba_ioctl: port deactivate: "
11487 				    "failed to unconfigure device at port "
11488 				    "%d:%d before deactivating the port",
11489 				    cport, pmport));
11490 				/*
11491 				 * Set DEVICE REMOVED state in the target
11492 				 * node. It will prevent an access to
11493 				 * the device even when a new device is
11494 				 * attached, until the old target node is
11495 				 * released, removed and recreated for a new
11496 				 * device.
11497 				 */
11498 				sata_set_device_removed(tdip);
11499 
11500 				/*
11501 				 * Instruct the event daemon to try the
11502 				 * target node cleanup later.
11503 				 */
11504 				sata_set_target_node_cleanup(sata_hba_inst,
11505 				    &sata_device->satadev_addr);
11506 			}
11507 		}
11508 		mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, cport)->
11509 		    cport_mutex);
11510 		/*
11511 		 * In any case, remove and release sata_drive_info
11512 		 * structure.
11513 		 */
11514 		if (qual == SATA_ADDR_CPORT) {
11515 			SATA_CPORTINFO_DRV_INFO(cportinfo) = NULL;
11516 			cportinfo->cport_dev_type = SATA_DTYPE_NONE;
11517 		} else { /* port multiplier device port */
11518 			SATA_PMPORTINFO_DRV_INFO(pmportinfo) = NULL;
11519 			pmportinfo->pmport_dev_type = SATA_DTYPE_NONE;
11520 		}
11521 		(void) kmem_free((void *)sdinfo, sizeof (sata_drive_info_t));
11522 	}
11523 	if (qual == SATA_ADDR_CPORT) {
11524 		cportinfo->cport_state &= ~(SATA_STATE_PROBED |
11525 		    SATA_STATE_PROBING);
11526 	} else { /* port multiplier device port */
11527 		pmportinfo->pmport_state &= ~(SATA_STATE_PROBED |
11528 		    SATA_STATE_PROBING);
11529 	}
11530 	mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex);
11531 
11532 	/* Just let HBA driver to deactivate port */
11533 	sata_device->satadev_addr.qual = qual;
11534 	rval = (*SATA_PORT_DEACTIVATE_FUNC(sata_hba_inst))
11535 	    (SATA_DIP(sata_hba_inst), sata_device);
11536 
11537 	/*
11538 	 * Generate sysevent - EC_DR / ESC_DR_AP_STATE_CHANGE
11539 	 * without the hint
11540 	 */
11541 	sata_gen_sysevent(sata_hba_inst, &sata_device->satadev_addr,
11542 	    SE_NO_HINT);
11543 
11544 	mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex);
11545 	sata_update_port_info(sata_hba_inst, sata_device);
11546 	if (qual == SATA_ADDR_CPORT) {
11547 		if (rval != SATA_SUCCESS) {
11548 			/*
11549 			 * Port deactivation failure - do not change port state
11550 			 * unless the state returned by HBA indicates a port
11551 			 * failure.
11552 			 */
11553 			if (sata_device->satadev_state & SATA_PSTATE_FAILED) {
11554 				SATA_CPORT_STATE(sata_hba_inst, cport) =
11555 				    SATA_PSTATE_FAILED;
11556 			}
11557 			SATA_LOG_D((sata_hba_inst, CE_WARN,
11558 			    "sata_hba_ioctl: port deactivate: "
11559 			    "cannot deactivate SATA port %d", cport));
11560 			rv = EIO;
11561 		} else {
11562 			cportinfo->cport_state |= SATA_PSTATE_SHUTDOWN;
11563 		}
11564 	} else {
11565 		if (rval != SATA_SUCCESS) {
11566 			if (sata_device->satadev_state & SATA_PSTATE_FAILED) {
11567 				SATA_PMPORT_STATE(sata_hba_inst, cport,
11568 				    pmport) = SATA_PSTATE_FAILED;
11569 			}
11570 			SATA_LOG_D((sata_hba_inst, CE_WARN,
11571 			    "sata_hba_ioctl: port deactivate: "
11572 			    "cannot deactivate SATA port %d:%d",
11573 			    cport, pmport));
11574 			rv = EIO;
11575 		} else {
11576 			pmportinfo->pmport_state |= SATA_PSTATE_SHUTDOWN;
11577 		}
11578 	}
11579 
11580 	mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex);
11581 
11582 	return (rv);
11583 }
11584 
11585 /*
11586  * Process ioctl port activate request.
11587  *
11588  * NOTE: Port multiplier code is not completed nor tested.
11589  */
11590 static int
11591 sata_ioctl_activate(sata_hba_inst_t *sata_hba_inst,
11592     sata_device_t *sata_device)
11593 {
11594 	int cport, pmport, qual;
11595 	sata_cport_info_t *cportinfo;
11596 	sata_pmport_info_t *pmportinfo = NULL;
11597 	boolean_t dev_existed = TRUE;
11598 
11599 	/* Sanity check */
11600 	if (SATA_PORT_ACTIVATE_FUNC(sata_hba_inst) == NULL)
11601 		return (ENOTSUP);
11602 
11603 	cport = sata_device->satadev_addr.cport;
11604 	pmport = sata_device->satadev_addr.pmport;
11605 	qual = sata_device->satadev_addr.qual;
11606 
11607 	mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex);
11608 	cportinfo = SATA_CPORT_INFO(sata_hba_inst, cport);
11609 	if (qual == SATA_ADDR_PMPORT) {
11610 		pmportinfo = SATA_PMPORT_INFO(sata_hba_inst, cport, pmport);
11611 		if (pmportinfo->pmport_state & SATA_PSTATE_SHUTDOWN ||
11612 		    pmportinfo->pmport_dev_type == SATA_DTYPE_NONE)
11613 			dev_existed = FALSE;
11614 	} else { /* cport */
11615 		if (cportinfo->cport_state & SATA_PSTATE_SHUTDOWN ||
11616 		    cportinfo->cport_dev_type == SATA_DTYPE_NONE)
11617 			dev_existed = FALSE;
11618 	}
11619 	mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex);
11620 
11621 	/* Just let HBA driver to activate port, if necessary */
11622 	if ((*SATA_PORT_ACTIVATE_FUNC(sata_hba_inst))
11623 	    (SATA_DIP(sata_hba_inst), sata_device) != SATA_SUCCESS) {
11624 		/*
11625 		 * Port activation failure - do not change port state unless
11626 		 * the state returned by HBA indicates a port failure.
11627 		 */
11628 		mutex_enter(&SATA_CPORT_INFO(sata_hba_inst,
11629 		    cport)->cport_mutex);
11630 		sata_update_port_info(sata_hba_inst, sata_device);
11631 		if (sata_device->satadev_state & SATA_PSTATE_FAILED) {
11632 			if (qual == SATA_ADDR_PMPORT)
11633 				pmportinfo->pmport_state = SATA_PSTATE_FAILED;
11634 			else
11635 				cportinfo->cport_state = SATA_PSTATE_FAILED;
11636 
11637 			mutex_exit(&SATA_CPORT_INFO(sata_hba_inst,
11638 			    cport)->cport_mutex);
11639 			SATA_LOG_D((sata_hba_inst, CE_WARN,
11640 			    "sata_hba_ioctl: port activate: cannot activate "
11641 			    "SATA port %d:%d", cport, pmport));
11642 			return (EIO);
11643 		}
11644 		mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex);
11645 	}
11646 	mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex);
11647 	if (qual == SATA_ADDR_PMPORT)
11648 		pmportinfo->pmport_state &= ~SATA_PSTATE_SHUTDOWN;
11649 	else
11650 		cportinfo->cport_state &= ~SATA_PSTATE_SHUTDOWN;
11651 	mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex);
11652 
11653 	/*
11654 	 * Re-probe port to find its current state and possibly attached device.
11655 	 * Port re-probing may change the cportinfo device type if device is
11656 	 * found attached.
11657 	 * If port probing failed, the device type would be set to
11658 	 * SATA_DTYPE_NONE.
11659 	 */
11660 	(void) sata_reprobe_port(sata_hba_inst, sata_device,
11661 	    SATA_DEV_IDENTIFY_RETRY);
11662 
11663 	/*
11664 	 * Generate sysevent - EC_DR / ESC_DR_AP_STATE_CHANGE
11665 	 * without the hint.
11666 	 */
11667 	sata_gen_sysevent(sata_hba_inst, &sata_device->satadev_addr,
11668 	    SE_NO_HINT);
11669 
11670 	if (dev_existed == FALSE) {
11671 		if (qual == SATA_ADDR_PMPORT &&
11672 		    pmportinfo->pmport_dev_type != SATA_DTYPE_NONE) {
11673 			/*
11674 			 * That's the transition from the "inactive" port state
11675 			 * or the active port without a device attached to the
11676 			 * active port state with a device attached.
11677 			 */
11678 			sata_log(sata_hba_inst, CE_WARN,
11679 			    "SATA device detected at port %d:%d",
11680 			    cport, pmport);
11681 		} else if (qual == SATA_ADDR_CPORT &&
11682 		    cportinfo->cport_dev_type != SATA_DTYPE_NONE) {
11683 			/*
11684 			 * That's the transition from the "inactive" port state
11685 			 * or the active port without a device attached to the
11686 			 * active port state with a device attached.
11687 			 */
11688 			if (cportinfo->cport_dev_type != SATA_DTYPE_PMULT) {
11689 				sata_log(sata_hba_inst, CE_WARN,
11690 				    "SATA device detected at port %d", cport);
11691 			} else {
11692 				sata_log(sata_hba_inst, CE_WARN,
11693 				    "SATA port multiplier detected at port %d",
11694 				    cport);
11695 				/*
11696 				 * Because the detected device is a port
11697 				 * multiplier, we need to reprobe every device
11698 				 * port on the port multiplier and show every
11699 				 * device found attached.
11700 				 * Add this code here.
11701 				 */
11702 			}
11703 		}
11704 	}
11705 	return (0);
11706 }
11707 
11708 
11709 
11710 /*
11711  * Process ioctl reset port request.
11712  *
11713  * NOTE: Port multiplier code is not completed nor tested.
11714  */
11715 static int
11716 sata_ioctl_reset_port(sata_hba_inst_t *sata_hba_inst,
11717     sata_device_t *sata_device)
11718 {
11719 	int cport, pmport, qual;
11720 	int rv = 0;
11721 
11722 	cport = sata_device->satadev_addr.cport;
11723 	pmport = sata_device->satadev_addr.pmport;
11724 	qual = sata_device->satadev_addr.qual;
11725 
11726 	/* Sanity check */
11727 	if (SATA_RESET_DPORT_FUNC(sata_hba_inst) == NULL) {
11728 		SATA_LOG_D((sata_hba_inst, CE_WARN,
11729 		    "sata_hba_ioctl: sata_hba_tran missing required "
11730 		    "function sata_tran_reset_dport"));
11731 		return (ENOTSUP);
11732 	}
11733 
11734 	/* Ask HBA to reset port */
11735 	if ((*SATA_RESET_DPORT_FUNC(sata_hba_inst))(SATA_DIP(sata_hba_inst),
11736 	    sata_device) != SATA_SUCCESS) {
11737 		SATA_LOG_D((sata_hba_inst, CE_WARN,
11738 		    "sata_hba_ioctl: reset port: failed %d:%d",
11739 		    cport, pmport));
11740 		mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, cport)->
11741 		    cport_mutex);
11742 		sata_update_port_info(sata_hba_inst, sata_device);
11743 		if (qual == SATA_ADDR_CPORT)
11744 			SATA_CPORT_STATE(sata_hba_inst, cport) =
11745 			    SATA_PSTATE_FAILED;
11746 		else
11747 			SATA_PMPORT_STATE(sata_hba_inst, cport, pmport) =
11748 			    SATA_PSTATE_FAILED;
11749 		mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)->
11750 		    cport_mutex);
11751 		rv = EIO;
11752 	}
11753 	/*
11754 	 * Beacuse the port was reset, it should be probed and
11755 	 * attached device reinitialized. At this point the
11756 	 * port state is unknown - it's state is HBA-specific.
11757 	 * Re-probe port to get its state.
11758 	 */
11759 	if (sata_reprobe_port(sata_hba_inst, sata_device,
11760 	    SATA_DEV_IDENTIFY_RETRY) != SATA_SUCCESS) {
11761 		rv = EIO;
11762 	}
11763 	return (rv);
11764 }
11765 
11766 /*
11767  * Process ioctl reset device request.
11768  *
11769  * NOTE: Port multiplier code is not completed nor tested.
11770  */
11771 static int
11772 sata_ioctl_reset_device(sata_hba_inst_t *sata_hba_inst,
11773     sata_device_t *sata_device)
11774 {
11775 	sata_drive_info_t *sdinfo;
11776 	int cport, pmport, qual;
11777 	int rv = 0;
11778 
11779 	/* Sanity check */
11780 	if (SATA_RESET_DPORT_FUNC(sata_hba_inst) == NULL) {
11781 		SATA_LOG_D((sata_hba_inst, CE_WARN,
11782 		    "sata_hba_ioctl: sata_hba_tran missing required "
11783 		    "function sata_tran_reset_dport"));
11784 		return (ENOTSUP);
11785 	}
11786 
11787 	cport = sata_device->satadev_addr.cport;
11788 	pmport = sata_device->satadev_addr.pmport;
11789 	qual = sata_device->satadev_addr.qual;
11790 
11791 	if (qual == SATA_ADDR_CPORT)
11792 		sata_device->satadev_addr.qual = SATA_ADDR_DCPORT;
11793 	else
11794 		sata_device->satadev_addr.qual = SATA_ADDR_DPMPORT;
11795 
11796 	mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex);
11797 	sdinfo = sata_get_device_info(sata_hba_inst, sata_device);
11798 	if (sdinfo == NULL) {
11799 		mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex);
11800 		return (EINVAL);
11801 	}
11802 	mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex);
11803 
11804 	/* Ask HBA to reset device */
11805 	if ((*SATA_RESET_DPORT_FUNC(sata_hba_inst))
11806 	    (SATA_DIP(sata_hba_inst), sata_device) != SATA_SUCCESS) {
11807 		SATA_LOG_D((sata_hba_inst, CE_WARN,
11808 		    "sata_hba_ioctl: reset device: failed at port %d:%d",
11809 		    cport, pmport));
11810 		mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, cport)->
11811 		    cport_mutex);
11812 		sata_update_port_info(sata_hba_inst, sata_device);
11813 		/*
11814 		 * Device info structure remains attached. Another device reset
11815 		 * or port disconnect/connect and re-probing is
11816 		 * needed to change it's state
11817 		 */
11818 		sdinfo->satadrv_state &= ~SATA_STATE_READY;
11819 		sdinfo->satadrv_state |= SATA_DSTATE_FAILED;
11820 		mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex);
11821 		rv = EIO;
11822 	}
11823 	/*
11824 	 * If attached device was a port multiplier, some extra processing
11825 	 * may be needed, to bring it back (if port re-probing did not handle
11826 	 * it). Add such code here.
11827 	 */
11828 	return (rv);
11829 }
11830 
11831 
11832 /*
11833  * Process ioctl reset all request.
11834  *
11835  * NOTE: Port multiplier code is not completed nor tested.
11836  */
11837 static int
11838 sata_ioctl_reset_all(sata_hba_inst_t *sata_hba_inst)
11839 {
11840 	sata_device_t sata_device;
11841 	int rv = 0;
11842 	int tcport;
11843 	int tpmport = 0;
11844 
11845 	sata_device.satadev_rev = SATA_DEVICE_REV;
11846 
11847 	/*
11848 	 * There is no protection here for configured devices.
11849 	 */
11850 	/* Sanity check */
11851 	if (SATA_RESET_DPORT_FUNC(sata_hba_inst) == NULL) {
11852 		SATA_LOG_D((sata_hba_inst, CE_WARN,
11853 		    "sata_hba_ioctl: sata_hba_tran missing required "
11854 		    "function sata_tran_reset_dport"));
11855 		return (ENOTSUP);
11856 	}
11857 
11858 	/*
11859 	 * Need to lock all ports, not just one.
11860 	 * If any port is locked by event processing, fail the whole operation.
11861 	 * One port is already locked, but for simplicity lock it again.
11862 	 */
11863 	for (tcport = 0; tcport < SATA_NUM_CPORTS(sata_hba_inst); tcport++) {
11864 		mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, tcport)->
11865 		    cport_mutex);
11866 		if (((SATA_CPORT_INFO(sata_hba_inst, tcport)->
11867 		    cport_event_flags) & SATA_EVNT_LOCK_PORT_BUSY) != 0) {
11868 			mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, tcport)->
11869 			    cport_mutex);
11870 			rv = EBUSY;
11871 			break;
11872 		} else {
11873 			SATA_CPORT_INFO(sata_hba_inst, tcport)->
11874 			    cport_event_flags |= SATA_APCTL_LOCK_PORT_BUSY;
11875 			/*
11876 			 * If there is a port multiplier attached, we may need
11877 			 * to lock its port as well. If so, add such code here.
11878 			 */
11879 		}
11880 		mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, tcport)->
11881 		    cport_mutex);
11882 	}
11883 
11884 	if (rv == 0) {
11885 		/*
11886 		 * All cports were successfully locked.
11887 		 * Reset main SATA controller only for now - no PMult.
11888 		 */
11889 		sata_device.satadev_addr.qual = SATA_ADDR_CNTRL;
11890 
11891 		if ((*SATA_RESET_DPORT_FUNC(sata_hba_inst))
11892 		    (SATA_DIP(sata_hba_inst), &sata_device) != SATA_SUCCESS) {
11893 			SATA_LOG_D((sata_hba_inst, CE_WARN,
11894 			    "sata_hba_ioctl: reset controller failed"));
11895 			return (EIO);
11896 		}
11897 		/*
11898 		 * Because ports were reset, port states are unknown.
11899 		 * They should be re-probed to get their state and
11900 		 * attached devices should be reinitialized.
11901 		 * Add code here to re-probe port multiplier device ports.
11902 		 */
11903 		for (tcport = 0; tcport < SATA_NUM_CPORTS(sata_hba_inst);
11904 		    tcport++) {
11905 			sata_device.satadev_addr.cport = tcport;
11906 			sata_device.satadev_addr.pmport = tpmport;
11907 			sata_device.satadev_addr.qual = SATA_ADDR_CPORT;
11908 
11909 			if (sata_reprobe_port(sata_hba_inst, &sata_device,
11910 			    SATA_DEV_IDENTIFY_RETRY) != SATA_SUCCESS)
11911 				rv = EIO;
11912 		}
11913 	}
11914 	/*
11915 	 * Unlock all ports
11916 	 */
11917 	for (tcport = 0; tcport < SATA_NUM_CPORTS(sata_hba_inst); tcport++) {
11918 		mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, tcport)->
11919 		    cport_mutex);
11920 		SATA_CPORT_INFO(sata_hba_inst, tcport)->
11921 		    cport_event_flags &= ~SATA_APCTL_LOCK_PORT_BUSY;
11922 		mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, tcport)->
11923 		    cport_mutex);
11924 	}
11925 
11926 	/*
11927 	 * This operation returns EFAULT if either reset
11928 	 * controller failed or a re-probing of any ports failed.
11929 	 */
11930 	return (rv);
11931 }
11932 
11933 
11934 /*
11935  * Process ioctl port self test request.
11936  *
11937  * NOTE: Port multiplier code is not completed nor tested.
11938  */
11939 static int
11940 sata_ioctl_port_self_test(sata_hba_inst_t *sata_hba_inst,
11941     sata_device_t *sata_device)
11942 {
11943 	int cport, pmport, qual;
11944 	int rv = 0;
11945 
11946 	/* Sanity check */
11947 	if (SATA_SELFTEST_FUNC(sata_hba_inst) == NULL)
11948 		return (ENOTSUP);
11949 
11950 	cport = sata_device->satadev_addr.cport;
11951 	pmport = sata_device->satadev_addr.pmport;
11952 	qual = sata_device->satadev_addr.qual;
11953 
11954 	/*
11955 	 * There is no protection here for a configured
11956 	 * device attached to this port.
11957 	 */
11958 
11959 	if ((*SATA_SELFTEST_FUNC(sata_hba_inst))
11960 	    (SATA_DIP(sata_hba_inst), sata_device) != SATA_SUCCESS) {
11961 		SATA_LOG_D((sata_hba_inst, CE_WARN,
11962 		    "sata_hba_ioctl: port selftest: "
11963 		    "failed port %d:%d", cport, pmport));
11964 		mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, cport)->
11965 		    cport_mutex);
11966 		sata_update_port_info(sata_hba_inst, sata_device);
11967 		if (qual == SATA_ADDR_CPORT)
11968 			SATA_CPORT_STATE(sata_hba_inst, cport) =
11969 			    SATA_PSTATE_FAILED;
11970 		else /* port ultiplier device port */
11971 			SATA_PMPORT_STATE(sata_hba_inst, cport, pmport) =
11972 			    SATA_PSTATE_FAILED;
11973 
11974 		mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)->
11975 		    cport_mutex);
11976 		return (EIO);
11977 	}
11978 	/*
11979 	 * Beacuse the port was reset in the course of testing, it should be
11980 	 * re-probed and attached device state should be restored. At this
11981 	 * point the port state is unknown - it's state is HBA-specific.
11982 	 * Force port re-probing to get it into a known state.
11983 	 */
11984 	if (sata_reprobe_port(sata_hba_inst, sata_device,
11985 	    SATA_DEV_IDENTIFY_RETRY) != SATA_SUCCESS)
11986 		rv = EIO;
11987 	return (rv);
11988 }
11989 
11990 
11991 /*
11992  * sata_cfgadm_state:
11993  * Use the sata port state and state of the target node to figure out
11994  * the cfgadm_state.
11995  *
11996  * The port argument is a value with encoded cport,
11997  * pmport and address qualifier, in the same manner as a scsi target number.
11998  * SCSI_TO_SATA_CPORT macro extracts cport number,
11999  * SCSI_TO_SATA_PMPORT extracts pmport number and
12000  * SCSI_TO_SATA_ADDR_QUAL extracts port mulitplier qualifier flag.
12001  *
12002  * For now, support is for cports only - no port multiplier device ports.
12003  */
12004 
12005 static void
12006 sata_cfgadm_state(sata_hba_inst_t *sata_hba_inst, int32_t port,
12007     devctl_ap_state_t *ap_state)
12008 {
12009 	uint16_t	cport;
12010 	int		port_state;
12011 
12012 	/* Cport only */
12013 	cport = SCSI_TO_SATA_CPORT(port);
12014 
12015 	port_state = SATA_CPORT_STATE(sata_hba_inst, cport);
12016 	if (port_state & SATA_PSTATE_SHUTDOWN ||
12017 	    port_state & SATA_PSTATE_FAILED) {
12018 		ap_state->ap_rstate = AP_RSTATE_DISCONNECTED;
12019 		ap_state->ap_ostate = AP_OSTATE_UNCONFIGURED;
12020 		if (port_state & SATA_PSTATE_FAILED)
12021 			ap_state->ap_condition = AP_COND_FAILED;
12022 		else
12023 			ap_state->ap_condition = AP_COND_UNKNOWN;
12024 
12025 		return;
12026 	}
12027 
12028 	/* Need to check pmult device port here as well, when supported */
12029 
12030 	/* Port is enabled and ready */
12031 
12032 	switch (SATA_CPORT_DEV_TYPE(sata_hba_inst, cport)) {
12033 	case SATA_DTYPE_NONE:
12034 	{
12035 		ap_state->ap_ostate = AP_OSTATE_UNCONFIGURED;
12036 		ap_state->ap_condition = AP_COND_OK;
12037 		/* No device attached */
12038 		ap_state->ap_rstate = AP_RSTATE_EMPTY;
12039 		break;
12040 	}
12041 	case SATA_DTYPE_UNKNOWN:
12042 	case SATA_DTYPE_ATAPINONCD:
12043 	case SATA_DTYPE_PMULT:	/* Until PMult is supported */
12044 	case SATA_DTYPE_ATADISK:
12045 	case SATA_DTYPE_ATAPICD:
12046 	{
12047 		dev_info_t *tdip = NULL;
12048 		dev_info_t *dip = NULL;
12049 		int circ;
12050 
12051 		dip = SATA_DIP(sata_hba_inst);
12052 		tdip = sata_get_target_dip(dip, port);
12053 		ap_state->ap_rstate = AP_RSTATE_CONNECTED;
12054 		if (tdip != NULL) {
12055 			ndi_devi_enter(dip, &circ);
12056 			mutex_enter(&(DEVI(tdip)->devi_lock));
12057 			if (DEVI_IS_DEVICE_REMOVED(tdip)) {
12058 				/*
12059 				 * There could be the case where previously
12060 				 * configured and opened device was removed
12061 				 * and unknown device was plugged.
12062 				 * In such case we want to show a device, and
12063 				 * its configured or unconfigured state but
12064 				 * indicate unusable condition untill the
12065 				 * old target node is released and removed.
12066 				 */
12067 				ap_state->ap_condition = AP_COND_UNUSABLE;
12068 			} else {
12069 				ap_state->ap_condition = AP_COND_OK;
12070 			}
12071 			if ((DEVI_IS_DEVICE_OFFLINE(tdip)) ||
12072 			    (DEVI_IS_DEVICE_DOWN(tdip))) {
12073 				ap_state->ap_ostate =
12074 				    AP_OSTATE_UNCONFIGURED;
12075 			} else {
12076 				ap_state->ap_ostate =
12077 				    AP_OSTATE_CONFIGURED;
12078 			}
12079 			mutex_exit(&(DEVI(tdip)->devi_lock));
12080 			ndi_devi_exit(dip, circ);
12081 		} else {
12082 			ap_state->ap_ostate = AP_OSTATE_UNCONFIGURED;
12083 			ap_state->ap_condition = AP_COND_UNKNOWN;
12084 		}
12085 		break;
12086 	}
12087 	default:
12088 		ap_state->ap_rstate = AP_RSTATE_CONNECTED;
12089 		ap_state->ap_ostate = AP_OSTATE_UNCONFIGURED;
12090 		ap_state->ap_condition = AP_COND_UNKNOWN;
12091 		/*
12092 		 * This is actually internal error condition (non fatal),
12093 		 * because we have already checked all defined device types.
12094 		 */
12095 		SATA_LOG_D((sata_hba_inst, CE_WARN,
12096 		    "sata_cfgadm_state: Internal error: "
12097 		    "unknown device type"));
12098 		break;
12099 	}
12100 }
12101 
12102 
12103 /*
12104  * Process ioctl get device path request.
12105  *
12106  * NOTE: Port multiplier code is not completed nor tested.
12107  */
12108 static int
12109 sata_ioctl_get_device_path(sata_hba_inst_t *sata_hba_inst,
12110     sata_device_t *sata_device, sata_ioctl_data_t *ioc, int mode)
12111 {
12112 	char path[MAXPATHLEN];
12113 	uint32_t size;
12114 	dev_info_t *tdip;
12115 
12116 	(void) strcpy(path, "/devices");
12117 	if ((tdip = sata_get_scsi_target_dip(SATA_DIP(sata_hba_inst),
12118 	    &sata_device->satadev_addr)) == NULL) {
12119 		/*
12120 		 * No such device. If this is a request for a size, do not
12121 		 * return EINVAL for non-existing target, because cfgadm
12122 		 * will then indicate a meaningless ioctl failure.
12123 		 * If this is a request for a path, indicate invalid
12124 		 * argument.
12125 		 */
12126 		if (ioc->get_size == 0)
12127 			return (EINVAL);
12128 	} else {
12129 		(void) ddi_pathname(tdip, path + strlen(path));
12130 	}
12131 	size = strlen(path) + 1;
12132 
12133 	if (ioc->get_size != 0) {
12134 		if (ddi_copyout((void *)&size, ioc->buf, ioc->bufsiz,
12135 		    mode) != 0)
12136 			return (EFAULT);
12137 	} else {
12138 		if (ioc->bufsiz != size)
12139 			return (EINVAL);
12140 
12141 		else if (ddi_copyout((void *)&path, ioc->buf, ioc->bufsiz,
12142 		    mode) != 0)
12143 			return (EFAULT);
12144 	}
12145 	return (0);
12146 }
12147 
12148 /*
12149  * Process ioctl get attachment point type request.
12150  *
12151  * NOTE: Port multiplier code is not completed nor tested.
12152  */
12153 static	int
12154 sata_ioctl_get_ap_type(sata_hba_inst_t *sata_hba_inst,
12155     sata_device_t *sata_device, sata_ioctl_data_t *ioc, int mode)
12156 {
12157 	uint32_t	type_len;
12158 	const char	*ap_type;
12159 	int		dev_type;
12160 
12161 	if (sata_device->satadev_addr.qual == SATA_ADDR_CPORT)
12162 		dev_type = SATA_CPORT_DEV_TYPE(sata_hba_inst,
12163 		    sata_device->satadev_addr.cport);
12164 	else /* pmport */
12165 		dev_type = SATA_PMPORT_DEV_TYPE(sata_hba_inst,
12166 		    sata_device->satadev_addr.cport,
12167 		    sata_device->satadev_addr.pmport);
12168 
12169 	switch (dev_type) {
12170 	case SATA_DTYPE_NONE:
12171 		ap_type = "port";
12172 		break;
12173 
12174 	case SATA_DTYPE_ATADISK:
12175 		ap_type = "disk";
12176 		break;
12177 
12178 	case SATA_DTYPE_ATAPICD:
12179 		ap_type = "cd/dvd";
12180 		break;
12181 
12182 	case SATA_DTYPE_PMULT:
12183 		ap_type = "pmult";
12184 		break;
12185 
12186 	case SATA_DTYPE_UNKNOWN:
12187 		ap_type = "unknown";
12188 		break;
12189 
12190 	default:
12191 		ap_type = "unsupported";
12192 		break;
12193 
12194 	} /* end of dev_type switch */
12195 
12196 	type_len = strlen(ap_type) + 1;
12197 
12198 	if (ioc->get_size) {
12199 		if (ddi_copyout((void *)&type_len, ioc->buf, ioc->bufsiz,
12200 		    mode) != 0)
12201 			return (EFAULT);
12202 	} else {
12203 		if (ioc->bufsiz != type_len)
12204 			return (EINVAL);
12205 
12206 		if (ddi_copyout((void *)ap_type, ioc->buf,
12207 		    ioc->bufsiz, mode) != 0)
12208 			return (EFAULT);
12209 	}
12210 	return (0);
12211 
12212 }
12213 
12214 /*
12215  * Process ioctl get device model info request.
12216  * This operation should return to cfgadm the device model
12217  * information string
12218  *
12219  * NOTE: Port multiplier code is not completed nor tested.
12220  */
12221 static	int
12222 sata_ioctl_get_model_info(sata_hba_inst_t *sata_hba_inst,
12223     sata_device_t *sata_device, sata_ioctl_data_t *ioc, int mode)
12224 {
12225 	sata_drive_info_t *sdinfo;
12226 	uint32_t info_len;
12227 	char ap_info[SATA_ID_MODEL_LEN + 1];
12228 
12229 	mutex_enter(&SATA_CPORT_INFO(sata_hba_inst,
12230 	    sata_device->satadev_addr.cport)->cport_mutex);
12231 	if (sata_device->satadev_addr.qual == SATA_ADDR_CPORT)
12232 		sata_device->satadev_addr.qual = SATA_ADDR_DCPORT;
12233 	else /* port multiplier */
12234 		sata_device->satadev_addr.qual = SATA_ADDR_DPMPORT;
12235 
12236 	sdinfo = sata_get_device_info(sata_hba_inst, sata_device);
12237 	if (sdinfo == NULL) {
12238 		mutex_exit(&SATA_CPORT_INFO(sata_hba_inst,
12239 		    sata_device->satadev_addr.cport)->cport_mutex);
12240 		return (EINVAL);
12241 	}
12242 
12243 #ifdef	_LITTLE_ENDIAN
12244 	swab(sdinfo->satadrv_id.ai_model, ap_info, SATA_ID_MODEL_LEN);
12245 #else	/* _LITTLE_ENDIAN */
12246 	bcopy(sdinfo->satadrv_id.ai_model, ap_info, SATA_ID_MODEL_LEN);
12247 #endif	/* _LITTLE_ENDIAN */
12248 
12249 	mutex_exit(&SATA_CPORT_INFO(sata_hba_inst,
12250 	    sata_device->satadev_addr.cport)->cport_mutex);
12251 
12252 	ap_info[SATA_ID_MODEL_LEN] = '\0';
12253 
12254 	info_len = strlen(ap_info) + 1;
12255 
12256 	if (ioc->get_size) {
12257 		if (ddi_copyout((void *)&info_len, ioc->buf, ioc->bufsiz,
12258 		    mode) != 0)
12259 			return (EFAULT);
12260 	} else {
12261 		if (ioc->bufsiz < info_len)
12262 			return (EINVAL);
12263 		if (ddi_copyout((void *)ap_info, ioc->buf, ioc->bufsiz,
12264 		    mode) != 0)
12265 			return (EFAULT);
12266 	}
12267 	return (0);
12268 }
12269 
12270 
12271 /*
12272  * Process ioctl get device firmware revision info request.
12273  * This operation should return to cfgadm the device firmware revision
12274  * information string
12275  *
12276  * NOTE: Port multiplier code is not completed nor tested.
12277  */
12278 static	int
12279 sata_ioctl_get_revfirmware_info(sata_hba_inst_t *sata_hba_inst,
12280     sata_device_t *sata_device, sata_ioctl_data_t *ioc, int mode)
12281 {
12282 	sata_drive_info_t *sdinfo;
12283 	uint32_t info_len;
12284 	char ap_info[SATA_ID_FW_LEN + 1];
12285 
12286 	mutex_enter(&SATA_CPORT_INFO(sata_hba_inst,
12287 	    sata_device->satadev_addr.cport)->cport_mutex);
12288 	if (sata_device->satadev_addr.qual == SATA_ADDR_CPORT)
12289 		sata_device->satadev_addr.qual = SATA_ADDR_DCPORT;
12290 	else /* port multiplier */
12291 		sata_device->satadev_addr.qual = SATA_ADDR_DPMPORT;
12292 
12293 	sdinfo = sata_get_device_info(sata_hba_inst, sata_device);
12294 	if (sdinfo == NULL) {
12295 		mutex_exit(&SATA_CPORT_INFO(sata_hba_inst,
12296 		    sata_device->satadev_addr.cport)->cport_mutex);
12297 		return (EINVAL);
12298 	}
12299 
12300 #ifdef	_LITTLE_ENDIAN
12301 	swab(sdinfo->satadrv_id.ai_fw, ap_info, SATA_ID_FW_LEN);
12302 #else	/* _LITTLE_ENDIAN */
12303 	bcopy(sdinfo->satadrv_id.ai_fw, ap_info, SATA_ID_FW_LEN);
12304 #endif	/* _LITTLE_ENDIAN */
12305 
12306 	mutex_exit(&SATA_CPORT_INFO(sata_hba_inst,
12307 	    sata_device->satadev_addr.cport)->cport_mutex);
12308 
12309 	ap_info[SATA_ID_FW_LEN] = '\0';
12310 
12311 	info_len = strlen(ap_info) + 1;
12312 
12313 	if (ioc->get_size) {
12314 		if (ddi_copyout((void *)&info_len, ioc->buf, ioc->bufsiz,
12315 		    mode) != 0)
12316 			return (EFAULT);
12317 	} else {
12318 		if (ioc->bufsiz < info_len)
12319 			return (EINVAL);
12320 		if (ddi_copyout((void *)ap_info, ioc->buf, ioc->bufsiz,
12321 		    mode) != 0)
12322 			return (EFAULT);
12323 	}
12324 	return (0);
12325 }
12326 
12327 
12328 /*
12329  * Process ioctl get device serial number info request.
12330  * This operation should return to cfgadm the device serial number string.
12331  *
12332  * NOTE: Port multiplier code is not completed nor tested.
12333  */
12334 static	int
12335 sata_ioctl_get_serialnumber_info(sata_hba_inst_t *sata_hba_inst,
12336     sata_device_t *sata_device, sata_ioctl_data_t *ioc, int mode)
12337 {
12338 	sata_drive_info_t *sdinfo;
12339 	uint32_t info_len;
12340 	char ap_info[SATA_ID_SERIAL_LEN + 1];
12341 
12342 	mutex_enter(&SATA_CPORT_INFO(sata_hba_inst,
12343 	    sata_device->satadev_addr.cport)->cport_mutex);
12344 	if (sata_device->satadev_addr.qual == SATA_ADDR_CPORT)
12345 		sata_device->satadev_addr.qual = SATA_ADDR_DCPORT;
12346 	else /* port multiplier */
12347 		sata_device->satadev_addr.qual = SATA_ADDR_DPMPORT;
12348 
12349 	sdinfo = sata_get_device_info(sata_hba_inst, sata_device);
12350 	if (sdinfo == NULL) {
12351 		mutex_exit(&SATA_CPORT_INFO(sata_hba_inst,
12352 		    sata_device->satadev_addr.cport)->cport_mutex);
12353 		return (EINVAL);
12354 	}
12355 
12356 #ifdef	_LITTLE_ENDIAN
12357 	swab(sdinfo->satadrv_id.ai_drvser, ap_info, SATA_ID_SERIAL_LEN);
12358 #else	/* _LITTLE_ENDIAN */
12359 	bcopy(sdinfo->satadrv_id.ai_drvser, ap_info, SATA_ID_SERIAL_LEN);
12360 #endif	/* _LITTLE_ENDIAN */
12361 
12362 	mutex_exit(&SATA_CPORT_INFO(sata_hba_inst,
12363 	    sata_device->satadev_addr.cport)->cport_mutex);
12364 
12365 	ap_info[SATA_ID_SERIAL_LEN] = '\0';
12366 
12367 	info_len = strlen(ap_info) + 1;
12368 
12369 	if (ioc->get_size) {
12370 		if (ddi_copyout((void *)&info_len, ioc->buf, ioc->bufsiz,
12371 		    mode) != 0)
12372 			return (EFAULT);
12373 	} else {
12374 		if (ioc->bufsiz < info_len)
12375 			return (EINVAL);
12376 		if (ddi_copyout((void *)ap_info, ioc->buf, ioc->bufsiz,
12377 		    mode) != 0)
12378 			return (EFAULT);
12379 	}
12380 	return (0);
12381 }
12382 
12383 
12384 /*
12385  * Preset scsi extended sense data (to NO SENSE)
12386  * First 18 bytes of the sense data are preset to current valid sense
12387  * with a key NO SENSE data.
12388  *
12389  * Returns void
12390  */
12391 static void
12392 sata_fixed_sense_data_preset(struct scsi_extended_sense *sense)
12393 {
12394 	sense->es_valid = 1;		/* Valid sense */
12395 	sense->es_class = CLASS_EXTENDED_SENSE;	/* 0x70 - current err */
12396 	sense->es_key = KEY_NO_SENSE;
12397 	sense->es_info_1 = 0;
12398 	sense->es_info_2 = 0;
12399 	sense->es_info_3 = 0;
12400 	sense->es_info_4 = 0;
12401 	sense->es_add_len = 10;	/* Additional length - replace with a def */
12402 	sense->es_cmd_info[0] = 0;
12403 	sense->es_cmd_info[1] = 0;
12404 	sense->es_cmd_info[2] = 0;
12405 	sense->es_cmd_info[3] = 0;
12406 	sense->es_add_code = 0;
12407 	sense->es_qual_code = 0;
12408 }
12409 
12410 /*
12411  * Register a legacy cmdk-style devid for the target (disk) device.
12412  *
12413  * Note: This function is called only when the HBA devinfo node has the
12414  * property "use-cmdk-devid-format" set. This property indicates that
12415  * devid compatible with old cmdk (target) driver is to be generated
12416  * for any target device attached to this controller. This will take
12417  * precedence over the devid generated by sd (target) driver.
12418  * This function is derived from cmdk_devid_setup() function in cmdk.c.
12419  */
12420 static void
12421 sata_target_devid_register(dev_info_t *dip, sata_drive_info_t *sdinfo)
12422 {
12423 	char	*hwid;
12424 	int	modlen;
12425 	int	serlen;
12426 	int	rval;
12427 	ddi_devid_t	devid;
12428 
12429 	/*
12430 	 * device ID is a concatanation of model number, "=", serial number.
12431 	 */
12432 	hwid = kmem_zalloc(LEGACY_HWID_LEN, KM_SLEEP);
12433 	bcopy(&sdinfo->satadrv_id.ai_model, hwid,
12434 	    sizeof (sdinfo->satadrv_id.ai_model));
12435 	swab(hwid, hwid, sizeof (sdinfo->satadrv_id.ai_model));
12436 	modlen = sata_check_modser(hwid, sizeof (sdinfo->satadrv_id.ai_model));
12437 	if (modlen == 0)
12438 		goto err;
12439 	hwid[modlen++] = '=';
12440 	bcopy(&sdinfo->satadrv_id.ai_drvser, &hwid[modlen],
12441 	    sizeof (sdinfo->satadrv_id.ai_drvser));
12442 	swab(&hwid[modlen], &hwid[modlen],
12443 	    sizeof (sdinfo->satadrv_id.ai_drvser));
12444 	serlen = sata_check_modser(&hwid[modlen],
12445 	    sizeof (sdinfo->satadrv_id.ai_drvser));
12446 	if (serlen == 0)
12447 		goto err;
12448 	hwid[modlen + serlen] = 0; /* terminate the hwid string */
12449 
12450 	/* initialize/register devid */
12451 	if ((rval = ddi_devid_init(dip, DEVID_ATA_SERIAL,
12452 	    (ushort_t)(modlen + serlen), hwid, &devid)) == DDI_SUCCESS)
12453 		rval = ddi_devid_register(dip, devid);
12454 
12455 	if (rval != DDI_SUCCESS)
12456 		cmn_err(CE_WARN, "sata: failed to create devid for the disk"
12457 		    " on port %d", sdinfo->satadrv_addr.cport);
12458 err:
12459 	kmem_free(hwid, LEGACY_HWID_LEN);
12460 }
12461 
12462 /*
12463  * valid model/serial string must contain a non-zero non-space characters.
12464  * trim trailing spaces/NULLs.
12465  */
12466 static int
12467 sata_check_modser(char *buf, int buf_len)
12468 {
12469 	boolean_t ret;
12470 	char *s;
12471 	int i;
12472 	int tb;
12473 	char ch;
12474 
12475 	ret = B_FALSE;
12476 	s = buf;
12477 	for (i = 0; i < buf_len; i++) {
12478 		ch = *s++;
12479 		if (ch != ' ' && ch != '\0')
12480 			tb = i + 1;
12481 		if (ch != ' ' && ch != '\0' && ch != '0')
12482 			ret = B_TRUE;
12483 	}
12484 
12485 	if (ret == B_FALSE)
12486 		return (0); /* invalid string */
12487 
12488 	return (tb); /* return length */
12489 }
12490 
12491 /*
12492  * sata_set_drive_features function compares current device features setting
12493  * with the saved device features settings and, if there is a difference,
12494  * it restores device features setting to the previously saved state.
12495  * It also arbitrarily tries to select the highest supported DMA mode.
12496  * Device Identify or Identify Packet Device data has to be current.
12497  * At the moment read ahead and write cache are considered for all devices.
12498  * For atapi devices, Removable Media Status Notification is set in addition
12499  * to common features.
12500  *
12501  * This function cannot be called in the interrupt context (it may sleep).
12502  *
12503  * The input argument sdinfo should point to the drive info structure
12504  * to be updated after features are set. Note, that only
12505  * device (packet) identify data is updated, not the flags indicating the
12506  * supported features.
12507  *
12508  * Returns TRUE if successful or there was nothing to do. Device Identify data
12509  * in the drive info structure pointed to by the sdinfo argumens is updated
12510  * even when no features were set or changed.
12511  *
12512  * Returns FALSE if device features could not be set.
12513  *
12514  * Note: This function may fail the port, making it inaccessible.
12515  * In such case the explicit port disconnect/connect or physical device
12516  * detach/attach is required to re-evaluate port state again.
12517  */
12518 
12519 static int
12520 sata_set_drive_features(sata_hba_inst_t *sata_hba_inst,
12521     sata_drive_info_t *sdinfo, int restore)
12522 {
12523 	int rval = SATA_SUCCESS;
12524 	sata_drive_info_t new_sdinfo;
12525 	char *finfo = "sata_set_drive_features: cannot";
12526 	char *finfox;
12527 	int cache_op;
12528 
12529 	bzero(&new_sdinfo, sizeof (sata_drive_info_t));
12530 	new_sdinfo.satadrv_addr = sdinfo->satadrv_addr;
12531 	new_sdinfo.satadrv_type = sdinfo->satadrv_type;
12532 	if (sata_fetch_device_identify_data(sata_hba_inst, &new_sdinfo) != 0) {
12533 		/*
12534 		 * Cannot get device identification - retry later
12535 		 */
12536 		SATA_LOG_D((sata_hba_inst, CE_WARN,
12537 		    "%s fetch device identify data\n", finfo));
12538 		return (SATA_FAILURE);
12539 	}
12540 	finfox = (restore != 0) ? " restore device features" :
12541 	    " initialize device features\n";
12542 
12543 	if (sdinfo->satadrv_type == SATA_DTYPE_ATADISK) {
12544 		/* Arbitrarily set UDMA mode */
12545 		if (sata_set_dma_mode(sata_hba_inst, &new_sdinfo) !=
12546 		    SATA_SUCCESS) {
12547 			SATA_LOG_D((sata_hba_inst, CE_WARN,
12548 			    "%s set UDMA mode\n", finfo));
12549 			return (SATA_FAILURE);
12550 		}
12551 	} else { /* Assume SATA ATAPI CD/DVD */
12552 		/*  Set Removable Media Status Notification, if necessary */
12553 		if ((new_sdinfo.satadrv_id.ai_cmdset83 &
12554 		    SATA_RM_STATUS_NOTIFIC) != 0 && restore != 0) {
12555 			if (((sdinfo->satadrv_settings & SATA_DEV_RMSN) &&
12556 			    (!(new_sdinfo.satadrv_id.ai_features86 &
12557 			    SATA_RM_STATUS_NOTIFIC))) ||
12558 			    ((!(sdinfo->satadrv_settings & SATA_DEV_RMSN)) &&
12559 			    (new_sdinfo.satadrv_id.ai_features86 &
12560 			    SATA_RM_STATUS_NOTIFIC))) {
12561 				/* Current setting does not match saved one */
12562 				if (sata_set_rmsn(sata_hba_inst, sdinfo,
12563 				    sdinfo->satadrv_settings &
12564 				    SATA_DEV_RMSN) != SATA_SUCCESS)
12565 					rval = SATA_FAILURE;
12566 			}
12567 		}
12568 		/*
12569 		 * We have to set Multiword DMA or UDMA, if it is supported, as
12570 		 * we want to use DMA transfer mode whenever possible.
12571 		 * Some devices require explicit setting of the DMA mode.
12572 		 */
12573 		if (new_sdinfo.satadrv_id.ai_cap & SATA_DMA_SUPPORT) {
12574 			/* Set highest supported DMA mode */
12575 			if (sata_set_dma_mode(sata_hba_inst, &new_sdinfo) !=
12576 			    SATA_SUCCESS) {
12577 				SATA_LOG_D((sata_hba_inst, CE_WARN,
12578 				    "%s set UDMA mode\n", finfo));
12579 				rval = SATA_FAILURE;
12580 			}
12581 		}
12582 	}
12583 
12584 	if (!(new_sdinfo.satadrv_id.ai_cmdset82 & SATA_LOOK_AHEAD) &&
12585 	    !(new_sdinfo.satadrv_id.ai_cmdset82 & SATA_WRITE_CACHE)) {
12586 		/* None of the features is supported - do nothing */
12587 		SATADBG1(SATA_DBG_DEV_SETTINGS, sata_hba_inst,
12588 		    "settable features not supported\n", NULL);
12589 		goto update_sdinfo;
12590 	}
12591 
12592 	if (((new_sdinfo.satadrv_id.ai_features85 & SATA_LOOK_AHEAD) &&
12593 	    (sdinfo->satadrv_settings & SATA_DEV_READ_AHEAD)) &&
12594 	    ((new_sdinfo.satadrv_id.ai_features85 & SATA_WRITE_CACHE) &&
12595 	    (sdinfo->satadrv_settings & SATA_DEV_WRITE_CACHE))) {
12596 		/* Nothing to do */
12597 		SATADBG1(SATA_DBG_DEV_SETTINGS, sata_hba_inst,
12598 		    "no device features to set\n", NULL);
12599 		goto update_sdinfo;
12600 	}
12601 
12602 	if (!((new_sdinfo.satadrv_id.ai_features85 & SATA_LOOK_AHEAD) &&
12603 	    (sdinfo->satadrv_settings & SATA_DEV_READ_AHEAD))) {
12604 		if (sdinfo->satadrv_settings & SATA_DEV_READ_AHEAD) {
12605 			/* Enable read ahead / read cache */
12606 			cache_op = SATAC_SF_ENABLE_READ_AHEAD;
12607 			SATADBG1(SATA_DBG_DEV_SETTINGS, sata_hba_inst,
12608 			    "enabling read cache\n", NULL);
12609 		} else {
12610 			/* Disable read ahead  / read cache */
12611 			cache_op = SATAC_SF_DISABLE_READ_AHEAD;
12612 			SATADBG1(SATA_DBG_DEV_SETTINGS, sata_hba_inst,
12613 			    "disabling read cache\n", NULL);
12614 		}
12615 
12616 		/* Try to set read cache mode */
12617 		if (sata_set_cache_mode(sata_hba_inst, &new_sdinfo,
12618 		    cache_op) != SATA_SUCCESS) {
12619 			/* Pkt execution failed */
12620 			rval = SATA_FAILURE;
12621 		}
12622 	}
12623 
12624 	if (!((new_sdinfo.satadrv_id.ai_features85 & SATA_WRITE_CACHE) &&
12625 	    (sdinfo->satadrv_settings & SATA_DEV_WRITE_CACHE))) {
12626 		if (sdinfo->satadrv_settings & SATA_DEV_WRITE_CACHE) {
12627 			/* Enable write cache */
12628 			cache_op = SATAC_SF_ENABLE_WRITE_CACHE;
12629 			SATADBG1(SATA_DBG_DEV_SETTINGS, sata_hba_inst,
12630 			    "enabling write cache\n", NULL);
12631 		} else {
12632 			/* Disable write cache */
12633 			cache_op = SATAC_SF_DISABLE_WRITE_CACHE;
12634 			SATADBG1(SATA_DBG_DEV_SETTINGS, sata_hba_inst,
12635 			    "disabling write cache\n", NULL);
12636 		}
12637 		/* Try to set write cache mode */
12638 		if (sata_set_cache_mode(sata_hba_inst, &new_sdinfo,
12639 		    cache_op) != SATA_SUCCESS) {
12640 			/* Pkt execution failed */
12641 			rval = SATA_FAILURE;
12642 		}
12643 	}
12644 
12645 	if (rval == SATA_FAILURE)
12646 		SATA_LOG_D((sata_hba_inst, CE_WARN,
12647 		    "%s %s", finfo, finfox));
12648 update_sdinfo:
12649 	/*
12650 	 * We need to fetch Device Identify data again
12651 	 */
12652 	if (sata_fetch_device_identify_data(sata_hba_inst, &new_sdinfo) != 0) {
12653 		/*
12654 		 * Cannot get device identification - retry later
12655 		 */
12656 		SATA_LOG_D((sata_hba_inst, CE_WARN,
12657 		    "%s re-fetch device identify data\n", finfo));
12658 		rval = SATA_FAILURE;
12659 	}
12660 	/* Copy device sata info. */
12661 	sdinfo->satadrv_id = new_sdinfo.satadrv_id;
12662 
12663 	return (rval);
12664 }
12665 
12666 
12667 /*
12668  *
12669  * Returns 1 if threshold exceeded, 0 if threshold not exceeded, -1 if
12670  * unable to determine.
12671  *
12672  * Cannot be called in an interrupt context.
12673  *
12674  * Called by sata_build_lsense_page_2f()
12675  */
12676 
12677 static int
12678 sata_fetch_smart_return_status(sata_hba_inst_t *sata_hba_inst,
12679     sata_drive_info_t *sdinfo)
12680 {
12681 	sata_pkt_t *spkt;
12682 	sata_cmd_t *scmd;
12683 	sata_pkt_txlate_t *spx;
12684 	int rval;
12685 
12686 	spx = kmem_zalloc(sizeof (sata_pkt_txlate_t), KM_SLEEP);
12687 	spx->txlt_sata_hba_inst = sata_hba_inst;
12688 	spx->txlt_scsi_pkt = NULL;		/* No scsi pkt involved */
12689 	spkt = sata_pkt_alloc(spx, SLEEP_FUNC);
12690 	if (spkt == NULL) {
12691 		kmem_free(spx, sizeof (sata_pkt_txlate_t));
12692 		return (-1);
12693 	}
12694 	/* address is needed now */
12695 	spkt->satapkt_device.satadev_addr = sdinfo->satadrv_addr;
12696 
12697 
12698 	/* Fill sata_pkt */
12699 	spkt->satapkt_device.satadev_addr = sdinfo->satadrv_addr;
12700 	spkt->satapkt_op_mode = SATA_OPMODE_SYNCH | SATA_OPMODE_INTERRUPTS;
12701 	/* Synchronous mode, no callback */
12702 	spkt->satapkt_comp = NULL;
12703 	/* Timeout 30s */
12704 	spkt->satapkt_time = sata_default_pkt_time;
12705 
12706 	scmd = &spkt->satapkt_cmd;
12707 	scmd->satacmd_flags.sata_special_regs = B_TRUE;
12708 	scmd->satacmd_flags.sata_data_direction = SATA_DIR_NODATA_XFER;
12709 
12710 	/* Set up which registers need to be returned */
12711 	scmd->satacmd_flags.sata_copy_out_lba_mid_lsb = B_TRUE;
12712 	scmd->satacmd_flags.sata_copy_out_lba_high_lsb = B_TRUE;
12713 
12714 	/* Build SMART_RETURN_STATUS cmd in the sata_pkt */
12715 	scmd->satacmd_addr_type = 0;		/* N/A */
12716 	scmd->satacmd_sec_count_lsb = 0;	/* N/A */
12717 	scmd->satacmd_lba_low_lsb = 0;		/* N/A */
12718 	scmd->satacmd_lba_mid_lsb = SMART_MAGIC_VAL_1;
12719 	scmd->satacmd_lba_high_lsb = SMART_MAGIC_VAL_2;
12720 	scmd->satacmd_features_reg = SATA_SMART_RETURN_STATUS;
12721 	scmd->satacmd_device_reg = 0;		/* Always device 0 */
12722 	scmd->satacmd_cmd_reg = SATAC_SMART;
12723 	mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst,
12724 	    sdinfo->satadrv_addr.cport)));
12725 
12726 
12727 	/* Send pkt to SATA HBA driver */
12728 	if ((*SATA_START_FUNC(sata_hba_inst))(SATA_DIP(sata_hba_inst), spkt) !=
12729 	    SATA_TRAN_ACCEPTED ||
12730 	    spkt->satapkt_reason != SATA_PKT_COMPLETED) {
12731 		mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst,
12732 		    sdinfo->satadrv_addr.cport)));
12733 		/*
12734 		 * Whoops, no SMART RETURN STATUS
12735 		 */
12736 		rval = -1;
12737 	} else {
12738 		mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst,
12739 		    sdinfo->satadrv_addr.cport)));
12740 		if (scmd->satacmd_error_reg & SATA_ERROR_ABORT) {
12741 			rval = -1;
12742 			goto fail;
12743 		}
12744 		if (scmd->satacmd_status_reg & SATA_STATUS_ERR) {
12745 			rval = -1;
12746 			goto fail;
12747 		}
12748 		if ((scmd->satacmd_lba_mid_lsb == SMART_MAGIC_VAL_1) &&
12749 		    (scmd->satacmd_lba_high_lsb == SMART_MAGIC_VAL_2))
12750 			rval = 0;
12751 		else if ((scmd->satacmd_lba_mid_lsb == SMART_MAGIC_VAL_3) &&
12752 		    (scmd->satacmd_lba_high_lsb == SMART_MAGIC_VAL_4))
12753 			rval = 1;
12754 		else {
12755 			rval = -1;
12756 			goto fail;
12757 		}
12758 	}
12759 fail:
12760 	/* Free allocated resources */
12761 	sata_pkt_free(spx);
12762 	kmem_free(spx, sizeof (sata_pkt_txlate_t));
12763 
12764 	return (rval);
12765 }
12766 
12767 /*
12768  *
12769  * Returns 0 if succeeded, -1 otherwise
12770  *
12771  * Cannot be called in an interrupt context.
12772  *
12773  */
12774 static int
12775 sata_fetch_smart_data(
12776 	sata_hba_inst_t *sata_hba_inst,
12777 	sata_drive_info_t *sdinfo,
12778 	struct smart_data *smart_data)
12779 {
12780 	sata_pkt_t *spkt;
12781 	sata_cmd_t *scmd;
12782 	sata_pkt_txlate_t *spx;
12783 	int rval;
12784 
12785 #if ! defined(lint)
12786 	ASSERT(sizeof (struct smart_data) == 512);
12787 #endif
12788 
12789 	spx = kmem_zalloc(sizeof (sata_pkt_txlate_t), KM_SLEEP);
12790 	spx->txlt_sata_hba_inst = sata_hba_inst;
12791 	spx->txlt_scsi_pkt = NULL;		/* No scsi pkt involved */
12792 	spkt = sata_pkt_alloc(spx, SLEEP_FUNC);
12793 	if (spkt == NULL) {
12794 		kmem_free(spx, sizeof (sata_pkt_txlate_t));
12795 		return (-1);
12796 	}
12797 	/* address is needed now */
12798 	spkt->satapkt_device.satadev_addr = sdinfo->satadrv_addr;
12799 
12800 
12801 	/* Fill sata_pkt */
12802 	spkt->satapkt_device.satadev_addr = sdinfo->satadrv_addr;
12803 	spkt->satapkt_op_mode = SATA_OPMODE_SYNCH | SATA_OPMODE_INTERRUPTS;
12804 	/* Synchronous mode, no callback */
12805 	spkt->satapkt_comp = NULL;
12806 	/* Timeout 30s */
12807 	spkt->satapkt_time = sata_default_pkt_time;
12808 
12809 	scmd = &spkt->satapkt_cmd;
12810 	scmd->satacmd_flags.sata_data_direction = SATA_DIR_READ;
12811 
12812 	/*
12813 	 * Allocate buffer for SMART data
12814 	 */
12815 	scmd->satacmd_bp = sata_alloc_local_buffer(spx,
12816 	    sizeof (struct smart_data));
12817 	if (scmd->satacmd_bp == NULL) {
12818 		sata_pkt_free(spx);
12819 		kmem_free(spx, sizeof (sata_pkt_txlate_t));
12820 		SATA_LOG_D((sata_hba_inst, CE_WARN,
12821 		    "sata_fetch_smart_data: "
12822 		    "cannot allocate buffer"));
12823 		return (-1);
12824 	}
12825 
12826 
12827 	/* Build SMART_READ_DATA cmd in the sata_pkt */
12828 	scmd->satacmd_addr_type = 0;		/* N/A */
12829 	scmd->satacmd_sec_count_lsb = 0;	/* N/A */
12830 	scmd->satacmd_lba_low_lsb = 0;		/* N/A */
12831 	scmd->satacmd_lba_mid_lsb = SMART_MAGIC_VAL_1;
12832 	scmd->satacmd_lba_high_lsb = SMART_MAGIC_VAL_2;
12833 	scmd->satacmd_features_reg = SATA_SMART_READ_DATA;
12834 	scmd->satacmd_device_reg = 0;		/* Always device 0 */
12835 	scmd->satacmd_cmd_reg = SATAC_SMART;
12836 	mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst,
12837 	    sdinfo->satadrv_addr.cport)));
12838 
12839 	/* Send pkt to SATA HBA driver */
12840 	if ((*SATA_START_FUNC(sata_hba_inst))(SATA_DIP(sata_hba_inst), spkt) !=
12841 	    SATA_TRAN_ACCEPTED ||
12842 	    spkt->satapkt_reason != SATA_PKT_COMPLETED) {
12843 		mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst,
12844 		    sdinfo->satadrv_addr.cport)));
12845 		/*
12846 		 * Whoops, no SMART DATA available
12847 		 */
12848 		rval = -1;
12849 		goto fail;
12850 	} else {
12851 		mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst,
12852 		    sdinfo->satadrv_addr.cport)));
12853 		rval = ddi_dma_sync(spx->txlt_buf_dma_handle, 0, 0,
12854 		    DDI_DMA_SYNC_FORKERNEL);
12855 		ASSERT(rval == DDI_SUCCESS);
12856 		bcopy(scmd->satacmd_bp->b_un.b_addr, (uint8_t *)smart_data,
12857 		    sizeof (struct smart_data));
12858 	}
12859 
12860 fail:
12861 	/* Free allocated resources */
12862 	sata_free_local_buffer(spx);
12863 	sata_pkt_free(spx);
12864 	kmem_free(spx, sizeof (sata_pkt_txlate_t));
12865 
12866 	return (rval);
12867 }
12868 
12869 /*
12870  * Used by LOG SENSE page 0x10
12871  *
12872  * return 0 for success, -1 otherwise
12873  *
12874  */
12875 static int
12876 sata_ext_smart_selftest_read_log(
12877 	sata_hba_inst_t *sata_hba_inst,
12878 	sata_drive_info_t *sdinfo,
12879 	struct smart_ext_selftest_log *ext_selftest_log,
12880 	uint16_t block_num)
12881 {
12882 	sata_pkt_txlate_t *spx;
12883 	sata_pkt_t *spkt;
12884 	sata_cmd_t *scmd;
12885 	int rval;
12886 
12887 #if ! defined(lint)
12888 	ASSERT(sizeof (struct smart_ext_selftest_log) == 512);
12889 #endif
12890 
12891 	spx = kmem_zalloc(sizeof (sata_pkt_txlate_t), KM_SLEEP);
12892 	spx->txlt_sata_hba_inst = sata_hba_inst;
12893 	spx->txlt_scsi_pkt = NULL;		/* No scsi pkt involved */
12894 	spkt = sata_pkt_alloc(spx, SLEEP_FUNC);
12895 	if (spkt == NULL) {
12896 		kmem_free(spx, sizeof (sata_pkt_txlate_t));
12897 		return (-1);
12898 	}
12899 	/* address is needed now */
12900 	spkt->satapkt_device.satadev_addr = sdinfo->satadrv_addr;
12901 
12902 
12903 	/* Fill sata_pkt */
12904 	spkt->satapkt_device.satadev_addr = sdinfo->satadrv_addr;
12905 	spkt->satapkt_op_mode = SATA_OPMODE_SYNCH | SATA_OPMODE_INTERRUPTS;
12906 	/* Synchronous mode, no callback */
12907 	spkt->satapkt_comp = NULL;
12908 	/* Timeout 30s */
12909 	spkt->satapkt_time = sata_default_pkt_time;
12910 
12911 	scmd = &spkt->satapkt_cmd;
12912 	scmd->satacmd_flags.sata_data_direction = SATA_DIR_READ;
12913 
12914 	/*
12915 	 * Allocate buffer for SMART extended self-test log
12916 	 */
12917 	scmd->satacmd_bp = sata_alloc_local_buffer(spx,
12918 	    sizeof (struct smart_ext_selftest_log));
12919 	if (scmd->satacmd_bp == NULL) {
12920 		sata_pkt_free(spx);
12921 		kmem_free(spx, sizeof (sata_pkt_txlate_t));
12922 		SATA_LOG_D((sata_hba_inst, CE_WARN,
12923 		    "sata_ext_smart_selftest_log: "
12924 		    "cannot allocate buffer"));
12925 		return (-1);
12926 	}
12927 
12928 	/* Build READ LOG EXT w/ extended self-test log cmd in the sata_pkt */
12929 	scmd->satacmd_addr_type = ATA_ADDR_LBA48;
12930 	scmd->satacmd_sec_count_lsb = 1;	/* One sector of selftest log */
12931 	scmd->satacmd_sec_count_msb = 0;	/* One sector of selftest log */
12932 	scmd->satacmd_lba_low_lsb = EXT_SMART_SELFTEST_LOG_PAGE;
12933 	scmd->satacmd_lba_low_msb = 0;
12934 	scmd->satacmd_lba_mid_lsb = block_num & 0xff;
12935 	scmd->satacmd_lba_mid_msb = block_num >> 8;
12936 	scmd->satacmd_device_reg = 0;		/* Always device 0 */
12937 	scmd->satacmd_cmd_reg = SATAC_READ_LOG_EXT;
12938 
12939 	mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst,
12940 	    sdinfo->satadrv_addr.cport)));
12941 
12942 	/* Send pkt to SATA HBA driver */
12943 	if ((*SATA_START_FUNC(sata_hba_inst))(SATA_DIP(sata_hba_inst), spkt) !=
12944 	    SATA_TRAN_ACCEPTED ||
12945 	    spkt->satapkt_reason != SATA_PKT_COMPLETED) {
12946 		mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst,
12947 		    sdinfo->satadrv_addr.cport)));
12948 
12949 		/*
12950 		 * Whoops, no SMART selftest log info available
12951 		 */
12952 		rval = -1;
12953 		goto fail;
12954 	} else {
12955 		mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst,
12956 		    sdinfo->satadrv_addr.cport)));
12957 
12958 		rval = ddi_dma_sync(spx->txlt_buf_dma_handle, 0, 0,
12959 		    DDI_DMA_SYNC_FORKERNEL);
12960 		ASSERT(rval == DDI_SUCCESS);
12961 		bcopy(scmd->satacmd_bp->b_un.b_addr,
12962 		    (uint8_t *)ext_selftest_log,
12963 		    sizeof (struct smart_ext_selftest_log));
12964 		rval = 0;
12965 	}
12966 
12967 fail:
12968 	/* Free allocated resources */
12969 	sata_free_local_buffer(spx);
12970 	sata_pkt_free(spx);
12971 	kmem_free(spx, sizeof (sata_pkt_txlate_t));
12972 
12973 	return (rval);
12974 }
12975 
12976 /*
12977  * Returns 0 for success, -1 otherwise
12978  *
12979  * SMART self-test log data is returned in buffer pointed to by selftest_log
12980  */
12981 static int
12982 sata_smart_selftest_log(
12983 	sata_hba_inst_t *sata_hba_inst,
12984 	sata_drive_info_t *sdinfo,
12985 	struct smart_selftest_log *selftest_log)
12986 {
12987 	sata_pkt_t *spkt;
12988 	sata_cmd_t *scmd;
12989 	sata_pkt_txlate_t *spx;
12990 	int rval;
12991 
12992 #if ! defined(lint)
12993 	ASSERT(sizeof (struct smart_selftest_log) == 512);
12994 #endif
12995 
12996 	spx = kmem_zalloc(sizeof (sata_pkt_txlate_t), KM_SLEEP);
12997 	spx->txlt_sata_hba_inst = sata_hba_inst;
12998 	spx->txlt_scsi_pkt = NULL;		/* No scsi pkt involved */
12999 	spkt = sata_pkt_alloc(spx, SLEEP_FUNC);
13000 	if (spkt == NULL) {
13001 		kmem_free(spx, sizeof (sata_pkt_txlate_t));
13002 		return (-1);
13003 	}
13004 	/* address is needed now */
13005 	spkt->satapkt_device.satadev_addr = sdinfo->satadrv_addr;
13006 
13007 
13008 	/* Fill sata_pkt */
13009 	spkt->satapkt_device.satadev_addr = sdinfo->satadrv_addr;
13010 	spkt->satapkt_op_mode = SATA_OPMODE_SYNCH | SATA_OPMODE_INTERRUPTS;
13011 	/* Synchronous mode, no callback */
13012 	spkt->satapkt_comp = NULL;
13013 	/* Timeout 30s */
13014 	spkt->satapkt_time = sata_default_pkt_time;
13015 
13016 	scmd = &spkt->satapkt_cmd;
13017 	scmd->satacmd_flags.sata_data_direction = SATA_DIR_READ;
13018 
13019 	/*
13020 	 * Allocate buffer for SMART SELFTEST LOG
13021 	 */
13022 	scmd->satacmd_bp = sata_alloc_local_buffer(spx,
13023 	    sizeof (struct smart_selftest_log));
13024 	if (scmd->satacmd_bp == NULL) {
13025 		sata_pkt_free(spx);
13026 		kmem_free(spx, sizeof (sata_pkt_txlate_t));
13027 		SATA_LOG_D((sata_hba_inst, CE_WARN,
13028 		    "sata_smart_selftest_log: "
13029 		    "cannot allocate buffer"));
13030 		return (-1);
13031 	}
13032 
13033 	/* Build SMART_READ_LOG cmd in the sata_pkt */
13034 	scmd->satacmd_addr_type = 0;		/* N/A */
13035 	scmd->satacmd_sec_count_lsb = 1;	/* One sector of SMART log */
13036 	scmd->satacmd_lba_low_lsb = SMART_SELFTEST_LOG_PAGE;
13037 	scmd->satacmd_lba_mid_lsb = SMART_MAGIC_VAL_1;
13038 	scmd->satacmd_lba_high_lsb = SMART_MAGIC_VAL_2;
13039 	scmd->satacmd_features_reg = SATA_SMART_READ_LOG;
13040 	scmd->satacmd_device_reg = 0;		/* Always device 0 */
13041 	scmd->satacmd_cmd_reg = SATAC_SMART;
13042 	mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst,
13043 	    sdinfo->satadrv_addr.cport)));
13044 
13045 	/* Send pkt to SATA HBA driver */
13046 	if ((*SATA_START_FUNC(sata_hba_inst))(SATA_DIP(sata_hba_inst), spkt) !=
13047 	    SATA_TRAN_ACCEPTED ||
13048 	    spkt->satapkt_reason != SATA_PKT_COMPLETED) {
13049 		mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst,
13050 		    sdinfo->satadrv_addr.cport)));
13051 		/*
13052 		 * Whoops, no SMART DATA available
13053 		 */
13054 		rval = -1;
13055 		goto fail;
13056 	} else {
13057 		mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst,
13058 		    sdinfo->satadrv_addr.cport)));
13059 		rval = ddi_dma_sync(spx->txlt_buf_dma_handle, 0, 0,
13060 		    DDI_DMA_SYNC_FORKERNEL);
13061 		ASSERT(rval == DDI_SUCCESS);
13062 		bcopy(scmd->satacmd_bp->b_un.b_addr, (uint8_t *)selftest_log,
13063 		    sizeof (struct smart_selftest_log));
13064 		rval = 0;
13065 	}
13066 
13067 fail:
13068 	/* Free allocated resources */
13069 	sata_free_local_buffer(spx);
13070 	sata_pkt_free(spx);
13071 	kmem_free(spx, sizeof (sata_pkt_txlate_t));
13072 
13073 	return (rval);
13074 }
13075 
13076 
13077 /*
13078  * Returns 0 for success, -1 otherwise
13079  *
13080  * SMART READ LOG data is returned in buffer pointed to by smart_log
13081  */
13082 static int
13083 sata_smart_read_log(
13084 	sata_hba_inst_t *sata_hba_inst,
13085 	sata_drive_info_t *sdinfo,
13086 	uint8_t *smart_log,		/* where the data should be returned */
13087 	uint8_t which_log,		/* which log should be returned */
13088 	uint8_t log_size)		/* # of 512 bytes in log */
13089 {
13090 	sata_pkt_t *spkt;
13091 	sata_cmd_t *scmd;
13092 	sata_pkt_txlate_t *spx;
13093 	int rval;
13094 
13095 	spx = kmem_zalloc(sizeof (sata_pkt_txlate_t), KM_SLEEP);
13096 	spx->txlt_sata_hba_inst = sata_hba_inst;
13097 	spx->txlt_scsi_pkt = NULL;		/* No scsi pkt involved */
13098 	spkt = sata_pkt_alloc(spx, SLEEP_FUNC);
13099 	if (spkt == NULL) {
13100 		kmem_free(spx, sizeof (sata_pkt_txlate_t));
13101 		return (-1);
13102 	}
13103 	/* address is needed now */
13104 	spkt->satapkt_device.satadev_addr = sdinfo->satadrv_addr;
13105 
13106 
13107 	/* Fill sata_pkt */
13108 	spkt->satapkt_device.satadev_addr = sdinfo->satadrv_addr;
13109 	spkt->satapkt_op_mode = SATA_OPMODE_SYNCH | SATA_OPMODE_INTERRUPTS;
13110 	/* Synchronous mode, no callback */
13111 	spkt->satapkt_comp = NULL;
13112 	/* Timeout 30s */
13113 	spkt->satapkt_time = sata_default_pkt_time;
13114 
13115 	scmd = &spkt->satapkt_cmd;
13116 	scmd->satacmd_flags.sata_data_direction = SATA_DIR_READ;
13117 
13118 	/*
13119 	 * Allocate buffer for SMART READ LOG
13120 	 */
13121 	scmd->satacmd_bp = sata_alloc_local_buffer(spx, log_size * 512);
13122 	if (scmd->satacmd_bp == NULL) {
13123 		sata_pkt_free(spx);
13124 		kmem_free(spx, sizeof (sata_pkt_txlate_t));
13125 		SATA_LOG_D((sata_hba_inst, CE_WARN,
13126 		    "sata_smart_read_log: " "cannot allocate buffer"));
13127 		return (-1);
13128 	}
13129 
13130 	/* Build SMART_READ_LOG cmd in the sata_pkt */
13131 	scmd->satacmd_addr_type = 0;		/* N/A */
13132 	scmd->satacmd_sec_count_lsb = log_size;	/* what the caller asked for */
13133 	scmd->satacmd_lba_low_lsb = which_log;	/* which log page */
13134 	scmd->satacmd_lba_mid_lsb = SMART_MAGIC_VAL_1;
13135 	scmd->satacmd_lba_high_lsb = SMART_MAGIC_VAL_2;
13136 	scmd->satacmd_features_reg = SATA_SMART_READ_LOG;
13137 	scmd->satacmd_device_reg = 0;		/* Always device 0 */
13138 	scmd->satacmd_cmd_reg = SATAC_SMART;
13139 
13140 	mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst,
13141 	    sdinfo->satadrv_addr.cport)));
13142 
13143 	/* Send pkt to SATA HBA driver */
13144 	if ((*SATA_START_FUNC(sata_hba_inst))(SATA_DIP(sata_hba_inst), spkt) !=
13145 	    SATA_TRAN_ACCEPTED ||
13146 	    spkt->satapkt_reason != SATA_PKT_COMPLETED) {
13147 		mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst,
13148 		    sdinfo->satadrv_addr.cport)));
13149 
13150 		/*
13151 		 * Whoops, no SMART DATA available
13152 		 */
13153 		rval = -1;
13154 		goto fail;
13155 	} else {
13156 		mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst,
13157 		    sdinfo->satadrv_addr.cport)));
13158 
13159 		rval = ddi_dma_sync(spx->txlt_buf_dma_handle, 0, 0,
13160 		    DDI_DMA_SYNC_FORKERNEL);
13161 		ASSERT(rval == DDI_SUCCESS);
13162 		bcopy(scmd->satacmd_bp->b_un.b_addr, smart_log, log_size * 512);
13163 		rval = 0;
13164 	}
13165 
13166 fail:
13167 	/* Free allocated resources */
13168 	sata_free_local_buffer(spx);
13169 	sata_pkt_free(spx);
13170 	kmem_free(spx, sizeof (sata_pkt_txlate_t));
13171 
13172 	return (rval);
13173 }
13174 
13175 /*
13176  * Used by LOG SENSE page 0x10
13177  *
13178  * return 0 for success, -1 otherwise
13179  *
13180  */
13181 static int
13182 sata_read_log_ext_directory(
13183 	sata_hba_inst_t *sata_hba_inst,
13184 	sata_drive_info_t *sdinfo,
13185 	struct read_log_ext_directory *logdir)
13186 {
13187 	sata_pkt_txlate_t *spx;
13188 	sata_pkt_t *spkt;
13189 	sata_cmd_t *scmd;
13190 	int rval;
13191 
13192 #if ! defined(lint)
13193 	ASSERT(sizeof (struct read_log_ext_directory) == 512);
13194 #endif
13195 
13196 	spx = kmem_zalloc(sizeof (sata_pkt_txlate_t), KM_SLEEP);
13197 	spx->txlt_sata_hba_inst = sata_hba_inst;
13198 	spx->txlt_scsi_pkt = NULL;		/* No scsi pkt involved */
13199 	spkt = sata_pkt_alloc(spx, SLEEP_FUNC);
13200 	if (spkt == NULL) {
13201 		kmem_free(spx, sizeof (sata_pkt_txlate_t));
13202 		return (-1);
13203 	}
13204 
13205 	/* Fill sata_pkt */
13206 	spkt->satapkt_device.satadev_addr = sdinfo->satadrv_addr;
13207 	spkt->satapkt_op_mode = SATA_OPMODE_SYNCH | SATA_OPMODE_INTERRUPTS;
13208 	/* Synchronous mode, no callback */
13209 	spkt->satapkt_comp = NULL;
13210 	/* Timeout 30s */
13211 	spkt->satapkt_time = sata_default_pkt_time;
13212 
13213 	scmd = &spkt->satapkt_cmd;
13214 	scmd->satacmd_flags.sata_data_direction = SATA_DIR_READ;
13215 
13216 	/*
13217 	 * Allocate buffer for SMART READ LOG EXTENDED command
13218 	 */
13219 	scmd->satacmd_bp = sata_alloc_local_buffer(spx,
13220 	    sizeof (struct read_log_ext_directory));
13221 	if (scmd->satacmd_bp == NULL) {
13222 		sata_pkt_free(spx);
13223 		kmem_free(spx, sizeof (sata_pkt_txlate_t));
13224 		SATA_LOG_D((sata_hba_inst, CE_WARN,
13225 		    "sata_read_log_ext_directory: "
13226 		    "cannot allocate buffer"));
13227 		return (-1);
13228 	}
13229 
13230 	/* Build READ LOG EXT w/ log directory cmd in the  sata_pkt */
13231 	scmd->satacmd_addr_type = ATA_ADDR_LBA48;
13232 	scmd->satacmd_sec_count_lsb = 1;	/* One sector of directory */
13233 	scmd->satacmd_sec_count_msb = 0;	/* One sector of directory */
13234 	scmd->satacmd_lba_low_lsb = READ_LOG_EXT_LOG_DIRECTORY;
13235 	scmd->satacmd_lba_low_msb = 0;
13236 	scmd->satacmd_lba_mid_lsb = 0;
13237 	scmd->satacmd_lba_mid_msb = 0;
13238 	scmd->satacmd_device_reg = 0;		/* Always device 0 */
13239 	scmd->satacmd_cmd_reg = SATAC_READ_LOG_EXT;
13240 
13241 	mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst,
13242 	    sdinfo->satadrv_addr.cport)));
13243 
13244 	/* Send pkt to SATA HBA driver */
13245 	if ((*SATA_START_FUNC(sata_hba_inst))(SATA_DIP(sata_hba_inst), spkt) !=
13246 	    SATA_TRAN_ACCEPTED ||
13247 	    spkt->satapkt_reason != SATA_PKT_COMPLETED) {
13248 		mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst,
13249 		    sdinfo->satadrv_addr.cport)));
13250 		/*
13251 		 * Whoops, no SMART selftest log info available
13252 		 */
13253 		rval = -1;
13254 		goto fail;
13255 	} else {
13256 		mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst,
13257 		    sdinfo->satadrv_addr.cport)));
13258 		rval = ddi_dma_sync(spx->txlt_buf_dma_handle, 0, 0,
13259 		    DDI_DMA_SYNC_FORKERNEL);
13260 		ASSERT(rval == DDI_SUCCESS);
13261 		bcopy(scmd->satacmd_bp->b_un.b_addr, (uint8_t *)logdir,
13262 		    sizeof (struct read_log_ext_directory));
13263 		rval = 0;
13264 	}
13265 
13266 fail:
13267 	/* Free allocated resources */
13268 	sata_free_local_buffer(spx);
13269 	sata_pkt_free(spx);
13270 	kmem_free(spx, sizeof (sata_pkt_txlate_t));
13271 
13272 	return (rval);
13273 }
13274 
13275 /*
13276  * Set up error retrieval sata command for NCQ command error data
13277  * recovery.
13278  *
13279  * Returns SATA_SUCCESS when data buffer is allocated and packet set-up,
13280  * returns SATA_FAILURE otherwise.
13281  */
13282 static int
13283 sata_ncq_err_ret_cmd_setup(sata_pkt_txlate_t *spx, sata_drive_info_t *sdinfo)
13284 {
13285 #ifndef __lock_lint
13286 	_NOTE(ARGUNUSED(sdinfo))
13287 #endif
13288 
13289 	sata_pkt_t *spkt = spx->txlt_sata_pkt;
13290 	sata_cmd_t *scmd;
13291 	struct buf *bp;
13292 
13293 	/* Operation modes are up to the caller */
13294 	spkt->satapkt_op_mode = SATA_OPMODE_SYNCH | SATA_OPMODE_INTERRUPTS;
13295 
13296 	/* Synchronous mode, no callback - may be changed by the caller */
13297 	spkt->satapkt_comp = NULL;
13298 	spkt->satapkt_time = sata_default_pkt_time;
13299 
13300 	scmd = &spkt->satapkt_cmd;
13301 	bcopy(&sata_rle_cmd, scmd, sizeof (sata_cmd_t));
13302 	scmd->satacmd_flags.sata_ignore_dev_reset = B_TRUE;
13303 
13304 	/*
13305 	 * Allocate dma_able buffer error data.
13306 	 * Buffer allocation will take care of buffer alignment and other DMA
13307 	 * attributes.
13308 	 */
13309 	bp = sata_alloc_local_buffer(spx,
13310 	    sizeof (struct sata_ncq_error_recovery_page));
13311 	if (bp == NULL)
13312 		return (SATA_FAILURE);
13313 
13314 	bp_mapin(bp); /* make data buffer accessible */
13315 	scmd->satacmd_bp = bp;
13316 
13317 	/*
13318 	 * Set-up pointer to the buffer handle, so HBA can sync buffer
13319 	 * before accessing it. Handle is in usual place in translate struct.
13320 	 */
13321 	scmd->satacmd_err_ret_buf_handle = &spx->txlt_buf_dma_handle;
13322 
13323 	ASSERT(scmd->satacmd_num_dma_cookies != 0);
13324 	ASSERT(scmd->satacmd_dma_cookie_list != NULL);
13325 
13326 	return (SATA_SUCCESS);
13327 }
13328 
13329 /*
13330  * sata_xlate_errors() is used to translate (S)ATA error
13331  * information to SCSI information returned in the SCSI
13332  * packet.
13333  */
13334 static void
13335 sata_xlate_errors(sata_pkt_txlate_t *spx)
13336 {
13337 	struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt;
13338 	struct scsi_extended_sense *sense;
13339 
13340 	scsipkt->pkt_reason = CMD_INCOMPLETE;
13341 	*scsipkt->pkt_scbp = STATUS_CHECK;
13342 	sense = sata_arq_sense(spx);
13343 
13344 	switch (spx->txlt_sata_pkt->satapkt_reason) {
13345 	case SATA_PKT_PORT_ERROR:
13346 		/*
13347 		 * We have no device data. Assume no data transfered.
13348 		 */
13349 		sense->es_key = KEY_HARDWARE_ERROR;
13350 		break;
13351 
13352 	case SATA_PKT_DEV_ERROR:
13353 		if (spx->txlt_sata_pkt->satapkt_cmd.satacmd_status_reg &
13354 		    SATA_STATUS_ERR) {
13355 			/*
13356 			 * determine dev error reason from error
13357 			 * reg content
13358 			 */
13359 			sata_decode_device_error(spx, sense);
13360 			break;
13361 		}
13362 		/* No extended sense key - no info available */
13363 		break;
13364 
13365 	case SATA_PKT_TIMEOUT:
13366 		scsipkt->pkt_reason = CMD_TIMEOUT;
13367 		scsipkt->pkt_statistics |= STAT_TIMEOUT | STAT_DEV_RESET;
13368 		/* No extended sense key */
13369 		break;
13370 
13371 	case SATA_PKT_ABORTED:
13372 		scsipkt->pkt_reason = CMD_ABORTED;
13373 		scsipkt->pkt_statistics |= STAT_ABORTED;
13374 		/* No extended sense key */
13375 		break;
13376 
13377 	case SATA_PKT_RESET:
13378 		/*
13379 		 * pkt aborted either by an explicit reset request from
13380 		 * a host, or due to error recovery
13381 		 */
13382 		scsipkt->pkt_reason = CMD_RESET;
13383 		scsipkt->pkt_statistics |= STAT_DEV_RESET;
13384 		break;
13385 
13386 	default:
13387 		scsipkt->pkt_reason = CMD_TRAN_ERR;
13388 		break;
13389 	}
13390 }
13391 
13392 
13393 
13394 
13395 /*
13396  * Log sata message
13397  * dev pathname msg line preceeds the logged message.
13398  */
13399 
13400 static	void
13401 sata_log(sata_hba_inst_t *sata_hba_inst, uint_t level, char *fmt, ...)
13402 {
13403 	char pathname[128];
13404 	dev_info_t *dip;
13405 	va_list ap;
13406 
13407 	mutex_enter(&sata_log_mutex);
13408 
13409 	va_start(ap, fmt);
13410 	(void) vsprintf(sata_log_buf, fmt, ap);
13411 	va_end(ap);
13412 
13413 	if (sata_hba_inst != NULL) {
13414 		dip = SATA_DIP(sata_hba_inst);
13415 		(void) ddi_pathname(dip, pathname);
13416 	} else {
13417 		pathname[0] = 0;
13418 	}
13419 	if (level == CE_CONT) {
13420 		if (sata_debug_flags == 0)
13421 			cmn_err(level, "?%s:\n %s\n", pathname, sata_log_buf);
13422 		else
13423 			cmn_err(level, "%s:\n %s\n", pathname, sata_log_buf);
13424 	} else {
13425 		if (level != CE_NOTE) {
13426 			cmn_err(level, "%s:\n %s", pathname, sata_log_buf);
13427 		} else if (sata_msg) {
13428 			cmn_err(level, "%s:\n %s", pathname,
13429 			    sata_log_buf);
13430 		}
13431 	}
13432 
13433 	mutex_exit(&sata_log_mutex);
13434 }
13435 
13436 
13437 /* ******** Asynchronous HBA events handling & hotplugging support ******** */
13438 
13439 /*
13440  * Start or terminate the thread, depending on flag arg and current state
13441  */
13442 static void
13443 sata_event_thread_control(int startstop)
13444 {
13445 	static 	int sata_event_thread_terminating = 0;
13446 	static 	int sata_event_thread_starting = 0;
13447 	int i;
13448 
13449 	mutex_enter(&sata_event_mutex);
13450 
13451 	if (startstop == 0 && (sata_event_thread_starting == 1 ||
13452 	    sata_event_thread_terminating == 1)) {
13453 		mutex_exit(&sata_event_mutex);
13454 		return;
13455 	}
13456 	if (startstop == 1 && sata_event_thread_starting == 1) {
13457 		mutex_exit(&sata_event_mutex);
13458 		return;
13459 	}
13460 	if (startstop == 1 && sata_event_thread_terminating == 1) {
13461 		sata_event_thread_starting = 1;
13462 		/* wait til terminate operation completes */
13463 		i = SATA_EVNT_DAEMON_TERM_WAIT/SATA_EVNT_DAEMON_TERM_TIMEOUT;
13464 		while (sata_event_thread_terminating == 1) {
13465 			if (i-- <= 0) {
13466 				sata_event_thread_starting = 0;
13467 				mutex_exit(&sata_event_mutex);
13468 #ifdef SATA_DEBUG
13469 				cmn_err(CE_WARN, "sata_event_thread_control: "
13470 				    "timeout waiting for thread to terminate");
13471 #endif
13472 				return;
13473 			}
13474 			mutex_exit(&sata_event_mutex);
13475 			delay(drv_usectohz(SATA_EVNT_DAEMON_TERM_TIMEOUT));
13476 			mutex_enter(&sata_event_mutex);
13477 		}
13478 	}
13479 	if (startstop == 1) {
13480 		if (sata_event_thread == NULL) {
13481 			sata_event_thread = thread_create(NULL, 0,
13482 			    (void (*)())sata_event_daemon,
13483 			    &sata_hba_list, 0, &p0, TS_RUN, minclsyspri);
13484 		}
13485 		sata_event_thread_starting = 0;
13486 		mutex_exit(&sata_event_mutex);
13487 		return;
13488 	}
13489 
13490 	/*
13491 	 * If we got here, thread may need to be terminated
13492 	 */
13493 	if (sata_event_thread != NULL) {
13494 		int i;
13495 		/* Signal event thread to go away */
13496 		sata_event_thread_terminating = 1;
13497 		sata_event_thread_terminate = 1;
13498 		cv_signal(&sata_event_cv);
13499 		/*
13500 		 * Wait til daemon terminates.
13501 		 */
13502 		i = SATA_EVNT_DAEMON_TERM_WAIT/SATA_EVNT_DAEMON_TERM_TIMEOUT;
13503 		while (sata_event_thread_terminate == 1) {
13504 			mutex_exit(&sata_event_mutex);
13505 			if (i-- <= 0) {
13506 				/* Daemon did not go away !!! */
13507 #ifdef SATA_DEBUG
13508 				cmn_err(CE_WARN, "sata_event_thread_control: "
13509 				    "cannot terminate event daemon thread");
13510 #endif
13511 				mutex_enter(&sata_event_mutex);
13512 				break;
13513 			}
13514 			delay(drv_usectohz(SATA_EVNT_DAEMON_TERM_TIMEOUT));
13515 			mutex_enter(&sata_event_mutex);
13516 		}
13517 		sata_event_thread_terminating = 0;
13518 	}
13519 	ASSERT(sata_event_thread_terminating == 0);
13520 	ASSERT(sata_event_thread_starting == 0);
13521 	mutex_exit(&sata_event_mutex);
13522 }
13523 
13524 
13525 /*
13526  * SATA HBA event notification function.
13527  * Events reported by SATA HBA drivers per HBA instance relate to a change in
13528  * a port and/or device state or a controller itself.
13529  * Events for different addresses/addr types cannot be combined.
13530  * A warning message is generated for each event type.
13531  * Events are not processed by this function, so only the
13532  * event flag(s)is set for an affected entity and the event thread is
13533  * waken up. Event daemon thread processes all events.
13534  *
13535  * NOTE: Since more than one event may be reported at the same time, one
13536  * cannot determine a sequence of events when opposite event are reported, eg.
13537  * LINK_LOST and LINK_ESTABLISHED. Actual port status during event processing
13538  * is taking precedence over reported events, i.e. may cause ignoring some
13539  * events.
13540  */
13541 #define	SATA_EVENT_MAX_MSG_LENGTH	79
13542 
13543 void
13544 sata_hba_event_notify(dev_info_t *dip, sata_device_t *sata_device, int event)
13545 {
13546 	sata_hba_inst_t *sata_hba_inst = NULL;
13547 	sata_address_t *saddr;
13548 	sata_drive_info_t *sdinfo;
13549 	sata_port_stats_t *pstats;
13550 	int cport, pmport;
13551 	char buf1[SATA_EVENT_MAX_MSG_LENGTH + 1];
13552 	char buf2[SATA_EVENT_MAX_MSG_LENGTH + 1];
13553 	char *lcp;
13554 	static char *err_msg_evnt_1 =
13555 	    "sata_hba_event_notify: invalid port event 0x%x ";
13556 	static char *err_msg_evnt_2 =
13557 	    "sata_hba_event_notify: invalid device event 0x%x ";
13558 	int linkevent;
13559 
13560 	/*
13561 	 * There is a possibility that an event will be generated on HBA
13562 	 * that has not completed attachment or is detaching.
13563 	 * HBA driver should prevent this, but just in case it does not,
13564 	 * we need to ignore events for such HBA.
13565 	 */
13566 	mutex_enter(&sata_mutex);
13567 	for (sata_hba_inst = sata_hba_list; sata_hba_inst != NULL;
13568 	    sata_hba_inst = sata_hba_inst->satahba_next) {
13569 		if (SATA_DIP(sata_hba_inst) == dip)
13570 			if (sata_hba_inst->satahba_attached == 1)
13571 				break;
13572 	}
13573 	mutex_exit(&sata_mutex);
13574 	if (sata_hba_inst == NULL)
13575 		/* HBA not attached */
13576 		return;
13577 
13578 	ASSERT(sata_device != NULL);
13579 
13580 	/*
13581 	 * Validate address before - do not proceed with invalid address.
13582 	 */
13583 	saddr = &sata_device->satadev_addr;
13584 	if (saddr->cport >= SATA_NUM_CPORTS(sata_hba_inst))
13585 		return;
13586 	if (saddr->qual == SATA_ADDR_PMPORT ||
13587 	    saddr->qual == SATA_ADDR_DPMPORT)
13588 		/* Port Multiplier not supported yet */
13589 		return;
13590 
13591 	cport = saddr->cport;
13592 	pmport = saddr->pmport;
13593 
13594 	buf1[0] = buf2[0] = '\0';
13595 
13596 	/*
13597 	 * Events refer to devices, ports and controllers - each has
13598 	 * unique address. Events for different addresses cannot be combined.
13599 	 */
13600 	if (saddr->qual & (SATA_ADDR_CPORT | SATA_ADDR_PMPORT)) {
13601 
13602 		mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, cport)));
13603 
13604 		/* qualify this event(s) */
13605 		if ((event & SATA_EVNT_PORT_EVENTS) == 0) {
13606 			/* Invalid event for the device port */
13607 			(void) sprintf(buf2, err_msg_evnt_1,
13608 			    event & SATA_EVNT_PORT_EVENTS);
13609 			mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, cport)));
13610 			goto event_info;
13611 		}
13612 		if (saddr->qual == SATA_ADDR_CPORT) {
13613 			/* Controller's device port event */
13614 
13615 			(SATA_CPORT_INFO(sata_hba_inst, cport))->
13616 			    cport_event_flags |=
13617 			    event & SATA_EVNT_PORT_EVENTS;
13618 			pstats =
13619 			    &(SATA_CPORT_INFO(sata_hba_inst, cport))->
13620 			    cport_stats;
13621 		} else {
13622 			/* Port multiplier's device port event */
13623 			(SATA_PMPORT_INFO(sata_hba_inst, cport, pmport))->
13624 			    pmport_event_flags |=
13625 			    event & SATA_EVNT_PORT_EVENTS;
13626 			pstats =
13627 			    &(SATA_PMPORT_INFO(sata_hba_inst, cport, pmport))->
13628 			    pmport_stats;
13629 		}
13630 
13631 		/*
13632 		 * Add to statistics and log the message. We have to do it
13633 		 * here rather than in the event daemon, because there may be
13634 		 * multiple events occuring before they are processed.
13635 		 */
13636 		linkevent = event &
13637 		    (SATA_EVNT_LINK_LOST | SATA_EVNT_LINK_ESTABLISHED);
13638 		if (linkevent) {
13639 			if (linkevent == (SATA_EVNT_LINK_LOST |
13640 			    SATA_EVNT_LINK_ESTABLISHED)) {
13641 				/* This is likely event combination */
13642 				(void) strlcat(buf1, "link lost/established, ",
13643 				    SATA_EVENT_MAX_MSG_LENGTH);
13644 
13645 				if (pstats->link_lost < 0xffffffffffffffffULL)
13646 					pstats->link_lost++;
13647 				if (pstats->link_established <
13648 				    0xffffffffffffffffULL)
13649 					pstats->link_established++;
13650 				linkevent = 0;
13651 			} else if (linkevent & SATA_EVNT_LINK_LOST) {
13652 				(void) strlcat(buf1, "link lost, ",
13653 				    SATA_EVENT_MAX_MSG_LENGTH);
13654 
13655 				if (pstats->link_lost < 0xffffffffffffffffULL)
13656 					pstats->link_lost++;
13657 			} else {
13658 				(void) strlcat(buf1, "link established, ",
13659 				    SATA_EVENT_MAX_MSG_LENGTH);
13660 				if (pstats->link_established <
13661 				    0xffffffffffffffffULL)
13662 					pstats->link_established++;
13663 			}
13664 		}
13665 		if (event & SATA_EVNT_DEVICE_ATTACHED) {
13666 			(void) strlcat(buf1, "device attached, ",
13667 			    SATA_EVENT_MAX_MSG_LENGTH);
13668 			if (pstats->device_attached < 0xffffffffffffffffULL)
13669 				pstats->device_attached++;
13670 		}
13671 		if (event & SATA_EVNT_DEVICE_DETACHED) {
13672 			(void) strlcat(buf1, "device detached, ",
13673 			    SATA_EVENT_MAX_MSG_LENGTH);
13674 			if (pstats->device_detached < 0xffffffffffffffffULL)
13675 				pstats->device_detached++;
13676 		}
13677 		if (event & SATA_EVNT_PWR_LEVEL_CHANGED) {
13678 			SATADBG1(SATA_DBG_EVENTS, sata_hba_inst,
13679 			    "port %d power level changed", cport);
13680 			if (pstats->port_pwr_changed < 0xffffffffffffffffULL)
13681 				pstats->port_pwr_changed++;
13682 		}
13683 
13684 		if ((event & ~SATA_EVNT_PORT_EVENTS) != 0) {
13685 			/* There should be no other events for this address */
13686 			(void) sprintf(buf2, err_msg_evnt_1,
13687 			    event & ~SATA_EVNT_PORT_EVENTS);
13688 		}
13689 		mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, cport)));
13690 
13691 	} else if (saddr->qual & (SATA_ADDR_DCPORT | SATA_ADDR_DPMPORT)) {
13692 		mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, cport)));
13693 
13694 		/* qualify this event */
13695 		if ((event & SATA_EVNT_DEVICE_RESET) == 0) {
13696 			/* Invalid event for a device */
13697 			(void) sprintf(buf2, err_msg_evnt_2,
13698 			    event & SATA_EVNT_DEVICE_RESET);
13699 			mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, cport)));
13700 			goto event_info;
13701 		}
13702 		/* drive event */
13703 		sdinfo = sata_get_device_info(sata_hba_inst, sata_device);
13704 		if (sdinfo != NULL) {
13705 			if (event & SATA_EVNT_DEVICE_RESET) {
13706 				(void) strlcat(buf1, "device reset, ",
13707 				    SATA_EVENT_MAX_MSG_LENGTH);
13708 				if (sdinfo->satadrv_stats.drive_reset <
13709 				    0xffffffffffffffffULL)
13710 					sdinfo->satadrv_stats.drive_reset++;
13711 				sdinfo->satadrv_event_flags |=
13712 				    SATA_EVNT_DEVICE_RESET;
13713 			}
13714 		}
13715 		if ((event & ~SATA_EVNT_DEVICE_RESET) != 0) {
13716 			/* Invalid event for a device */
13717 			(void) sprintf(buf2, err_msg_evnt_2,
13718 			    event & ~SATA_EVNT_DRIVE_EVENTS);
13719 		}
13720 		mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, cport)));
13721 	} else {
13722 		if (saddr->qual != SATA_ADDR_NULL) {
13723 			/* Wrong address qualifier */
13724 			SATA_LOG_D((sata_hba_inst, CE_WARN,
13725 			    "sata_hba_event_notify: invalid address 0x%x",
13726 			    *(uint32_t *)saddr));
13727 			return;
13728 		}
13729 		if ((event & SATA_EVNT_CONTROLLER_EVENTS) == 0 ||
13730 		    (event & ~SATA_EVNT_CONTROLLER_EVENTS) != 0) {
13731 			/* Invalid event for the controller */
13732 			SATA_LOG_D((sata_hba_inst, CE_WARN,
13733 			    "sata_hba_event_notify: invalid event 0x%x for "
13734 			    "controller",
13735 			    event & SATA_EVNT_CONTROLLER_EVENTS));
13736 			return;
13737 		}
13738 		buf1[0] = '\0';
13739 		/* This may be a frequent and not interesting event */
13740 		SATADBG1(SATA_DBG_EVENTS, sata_hba_inst,
13741 		    "controller power level changed\n", NULL);
13742 
13743 		mutex_enter(&sata_hba_inst->satahba_mutex);
13744 		if (sata_hba_inst->satahba_stats.ctrl_pwr_change <
13745 		    0xffffffffffffffffULL)
13746 			sata_hba_inst->satahba_stats.ctrl_pwr_change++;
13747 
13748 		sata_hba_inst->satahba_event_flags |=
13749 		    SATA_EVNT_PWR_LEVEL_CHANGED;
13750 		mutex_exit(&sata_hba_inst->satahba_mutex);
13751 	}
13752 	/*
13753 	 * If we got here, there is something to do with this HBA
13754 	 * instance.
13755 	 */
13756 	mutex_enter(&sata_hba_inst->satahba_mutex);
13757 	sata_hba_inst->satahba_event_flags |= SATA_EVNT_MAIN;
13758 	mutex_exit(&sata_hba_inst->satahba_mutex);
13759 	mutex_enter(&sata_mutex);
13760 	sata_event_pending |= SATA_EVNT_MAIN;	/* global event indicator */
13761 	mutex_exit(&sata_mutex);
13762 
13763 	/* Tickle event thread */
13764 	mutex_enter(&sata_event_mutex);
13765 	if (sata_event_thread_active == 0)
13766 		cv_signal(&sata_event_cv);
13767 	mutex_exit(&sata_event_mutex);
13768 
13769 event_info:
13770 	if (buf1[0] != '\0') {
13771 		lcp = strrchr(buf1, ',');
13772 		if (lcp != NULL)
13773 			*lcp = '\0';
13774 	}
13775 	if (saddr->qual == SATA_ADDR_CPORT ||
13776 	    saddr->qual == SATA_ADDR_DCPORT) {
13777 		if (buf1[0] != '\0') {
13778 			sata_log(sata_hba_inst, CE_NOTE, "port %d: %s\n",
13779 			    cport, buf1);
13780 		}
13781 		if (buf2[0] != '\0') {
13782 			sata_log(sata_hba_inst, CE_NOTE, "port %d: %s\n",
13783 			    cport, buf2);
13784 		}
13785 	} else if (saddr->qual == SATA_ADDR_PMPORT ||
13786 	    saddr->qual == SATA_ADDR_DPMPORT) {
13787 		if (buf1[0] != '\0') {
13788 			sata_log(sata_hba_inst, CE_NOTE,
13789 			    "port %d pmport %d: %s\n", cport, pmport, buf1);
13790 		}
13791 		if (buf2[0] != '\0') {
13792 			sata_log(sata_hba_inst, CE_NOTE,
13793 			    "port %d pmport %d: %s\n", cport, pmport, buf2);
13794 		}
13795 	}
13796 }
13797 
13798 
13799 /*
13800  * Event processing thread.
13801  * Arg is a pointer to the sata_hba_list pointer.
13802  * It is not really needed, because sata_hba_list is global and static
13803  */
13804 static void
13805 sata_event_daemon(void *arg)
13806 {
13807 #ifndef __lock_lint
13808 	_NOTE(ARGUNUSED(arg))
13809 #endif
13810 	sata_hba_inst_t *sata_hba_inst;
13811 	clock_t lbolt;
13812 
13813 	SATADBG1(SATA_DBG_EVENTS_DAEMON, NULL,
13814 	    "SATA event daemon started\n", NULL);
13815 loop:
13816 	/*
13817 	 * Process events here. Walk through all registered HBAs
13818 	 */
13819 	mutex_enter(&sata_mutex);
13820 	for (sata_hba_inst = sata_hba_list; sata_hba_inst != NULL;
13821 	    sata_hba_inst = sata_hba_inst->satahba_next) {
13822 		ASSERT(sata_hba_inst != NULL);
13823 		mutex_enter(&sata_hba_inst->satahba_mutex);
13824 		if (sata_hba_inst->satahba_attached != 1 ||
13825 		    (sata_hba_inst->satahba_event_flags &
13826 		    SATA_EVNT_SKIP) != 0) {
13827 			mutex_exit(&sata_hba_inst->satahba_mutex);
13828 			continue;
13829 		}
13830 		if (sata_hba_inst->satahba_event_flags & SATA_EVNT_MAIN) {
13831 			sata_hba_inst->satahba_event_flags |= SATA_EVNT_SKIP;
13832 			mutex_exit(&sata_hba_inst->satahba_mutex);
13833 			mutex_exit(&sata_mutex);
13834 			/* Got the controller with pending event */
13835 			sata_process_controller_events(sata_hba_inst);
13836 			/*
13837 			 * Since global mutex was released, there is a
13838 			 * possibility that HBA list has changed, so start
13839 			 * over from the top. Just processed controller
13840 			 * will be passed-over because of the SKIP flag.
13841 			 */
13842 			goto loop;
13843 		}
13844 		mutex_exit(&sata_hba_inst->satahba_mutex);
13845 	}
13846 	/* Clear SKIP flag in all controllers */
13847 	for (sata_hba_inst = sata_hba_list; sata_hba_inst != NULL;
13848 	    sata_hba_inst = sata_hba_inst->satahba_next) {
13849 		mutex_enter(&sata_hba_inst->satahba_mutex);
13850 		sata_hba_inst->satahba_event_flags &= ~SATA_EVNT_SKIP;
13851 		mutex_exit(&sata_hba_inst->satahba_mutex);
13852 	}
13853 	mutex_exit(&sata_mutex);
13854 
13855 	SATADBG1(SATA_DBG_EVENTS_DAEMON, NULL,
13856 	    "SATA EVENT DAEMON suspending itself", NULL);
13857 
13858 #ifdef SATA_DEBUG
13859 	if ((sata_func_enable & SATA_ENABLE_PROCESS_EVENTS) == 0) {
13860 		sata_log(sata_hba_inst, CE_WARN,
13861 		    "SATA EVENTS PROCESSING DISABLED\n");
13862 		thread_exit(); /* Daemon will not run again */
13863 	}
13864 #endif
13865 	mutex_enter(&sata_event_mutex);
13866 	sata_event_thread_active = 0;
13867 	mutex_exit(&sata_event_mutex);
13868 	/*
13869 	 * Go to sleep/suspend itself and wake up either because new event or
13870 	 * wait timeout. Exit if there is a termination request (driver
13871 	 * unload).
13872 	 */
13873 	do {
13874 		lbolt = ddi_get_lbolt();
13875 		lbolt += drv_usectohz(SATA_EVNT_DAEMON_SLEEP_TIME);
13876 		mutex_enter(&sata_event_mutex);
13877 		(void) cv_timedwait(&sata_event_cv, &sata_event_mutex, lbolt);
13878 
13879 		if (sata_event_thread_active != 0) {
13880 			mutex_exit(&sata_event_mutex);
13881 			continue;
13882 		}
13883 
13884 		/* Check if it is time to go away */
13885 		if (sata_event_thread_terminate == 1) {
13886 			/*
13887 			 * It is up to the thread setting above flag to make
13888 			 * sure that this thread is not killed prematurely.
13889 			 */
13890 			sata_event_thread_terminate = 0;
13891 			sata_event_thread = NULL;
13892 			mutex_exit(&sata_event_mutex);
13893 			SATADBG1(SATA_DBG_EVENTS_DAEMON, NULL,
13894 			    "SATA_EVENT_DAEMON_TERMINATING", NULL);
13895 			thread_exit();  { _NOTE(NOT_REACHED) }
13896 		}
13897 		mutex_exit(&sata_event_mutex);
13898 	} while (!(sata_event_pending & SATA_EVNT_MAIN));
13899 
13900 	mutex_enter(&sata_event_mutex);
13901 	sata_event_thread_active = 1;
13902 	mutex_exit(&sata_event_mutex);
13903 
13904 	mutex_enter(&sata_mutex);
13905 	sata_event_pending &= ~SATA_EVNT_MAIN;
13906 	mutex_exit(&sata_mutex);
13907 
13908 	SATADBG1(SATA_DBG_EVENTS_DAEMON, NULL,
13909 	    "SATA EVENT DAEMON READY TO PROCESS EVENT", NULL);
13910 
13911 	goto loop;
13912 }
13913 
13914 /*
13915  * Specific HBA instance event processing.
13916  *
13917  * NOTE: At the moment, device event processing is limited to hard disks
13918  * only.
13919  * cports only are supported - no pmports.
13920  */
13921 static void
13922 sata_process_controller_events(sata_hba_inst_t *sata_hba_inst)
13923 {
13924 	int ncport;
13925 	uint32_t event_flags;
13926 	sata_address_t *saddr;
13927 
13928 	SATADBG1(SATA_DBG_EVENTS_CNTRL, sata_hba_inst,
13929 	    "Processing controller %d event(s)",
13930 	    ddi_get_instance(SATA_DIP(sata_hba_inst)));
13931 
13932 	mutex_enter(&sata_hba_inst->satahba_mutex);
13933 	sata_hba_inst->satahba_event_flags &= ~SATA_EVNT_MAIN;
13934 	event_flags = sata_hba_inst->satahba_event_flags;
13935 	mutex_exit(&sata_hba_inst->satahba_mutex);
13936 	/*
13937 	 * Process controller power change first
13938 	 * HERE
13939 	 */
13940 	if (event_flags & SATA_EVNT_PWR_LEVEL_CHANGED)
13941 		sata_process_cntrl_pwr_level_change(sata_hba_inst);
13942 
13943 	/*
13944 	 * Search through ports/devices to identify affected port/device.
13945 	 * We may have to process events for more than one port/device.
13946 	 */
13947 	for (ncport = 0; ncport < SATA_NUM_CPORTS(sata_hba_inst); ncport++) {
13948 		mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, ncport)));
13949 		event_flags = (SATA_CPORT_INFO(sata_hba_inst, ncport))->
13950 		    cport_event_flags;
13951 		/* Check if port was locked by IOCTL processing */
13952 		if (event_flags & SATA_APCTL_LOCK_PORT_BUSY) {
13953 			/*
13954 			 * We ignore port events because port is busy
13955 			 * with AP control processing. Set again
13956 			 * controller and main event flag, so that
13957 			 * events may be processed by the next daemon
13958 			 * run.
13959 			 */
13960 			mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, ncport)));
13961 			mutex_enter(&sata_hba_inst->satahba_mutex);
13962 			sata_hba_inst->satahba_event_flags |= SATA_EVNT_MAIN;
13963 			mutex_exit(&sata_hba_inst->satahba_mutex);
13964 			mutex_enter(&sata_mutex);
13965 			sata_event_pending |= SATA_EVNT_MAIN;
13966 			mutex_exit(&sata_mutex);
13967 			SATADBG1(SATA_DBG_EVENTS_PROCPST, sata_hba_inst,
13968 			    "Event processing postponed until "
13969 			    "AP control processing completes",
13970 			    NULL);
13971 			/* Check other ports */
13972 			continue;
13973 		} else {
13974 			/*
13975 			 * Set BSY flag so that AP control would not
13976 			 * interfere with events processing for
13977 			 * this port.
13978 			 */
13979 			(SATA_CPORT_INFO(sata_hba_inst, ncport))->
13980 			    cport_event_flags |= SATA_EVNT_LOCK_PORT_BUSY;
13981 		}
13982 		mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, ncport)));
13983 
13984 		saddr = &(SATA_CPORT_INFO(sata_hba_inst, ncport))->cport_addr;
13985 
13986 		if ((event_flags &
13987 		    (SATA_EVNT_PORT_EVENTS | SATA_EVNT_DRIVE_EVENTS)) != 0) {
13988 			/*
13989 			 * Got port event.
13990 			 * We need some hierarchy of event processing as they
13991 			 * are affecting each other:
13992 			 * 1. port failed
13993 			 * 2. device detached/attached
13994 			 * 3. link events - link events may trigger device
13995 			 *    detached or device attached events in some
13996 			 *    circumstances.
13997 			 * 4. port power level changed
13998 			 */
13999 			if (event_flags & SATA_EVNT_PORT_FAILED) {
14000 				sata_process_port_failed_event(sata_hba_inst,
14001 				    saddr);
14002 			}
14003 			if (event_flags & SATA_EVNT_DEVICE_DETACHED) {
14004 				sata_process_device_detached(sata_hba_inst,
14005 				    saddr);
14006 			}
14007 			if (event_flags & SATA_EVNT_DEVICE_ATTACHED) {
14008 				sata_process_device_attached(sata_hba_inst,
14009 				    saddr);
14010 			}
14011 			if (event_flags &
14012 			    (SATA_EVNT_LINK_ESTABLISHED |
14013 			    SATA_EVNT_LINK_LOST)) {
14014 				sata_process_port_link_events(sata_hba_inst,
14015 				    saddr);
14016 			}
14017 			if (event_flags & SATA_EVNT_PWR_LEVEL_CHANGED) {
14018 				sata_process_port_pwr_change(sata_hba_inst,
14019 				    saddr);
14020 			}
14021 			if (event_flags & SATA_EVNT_TARGET_NODE_CLEANUP) {
14022 				sata_process_target_node_cleanup(
14023 				    sata_hba_inst, saddr);
14024 			}
14025 			if (event_flags & SATA_EVNT_AUTOONLINE_DEVICE) {
14026 				sata_process_device_autoonline(
14027 				    sata_hba_inst, saddr);
14028 			}
14029 		}
14030 		if (SATA_CPORT_DEV_TYPE(sata_hba_inst, ncport) !=
14031 		    SATA_DTYPE_NONE) {
14032 			/* May have device event */
14033 			sata_process_device_reset(sata_hba_inst, saddr);
14034 		}
14035 		mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, ncport)));
14036 		/* Release PORT_BUSY flag */
14037 		(SATA_CPORT_INFO(sata_hba_inst, ncport))->
14038 		    cport_event_flags &= ~SATA_EVNT_LOCK_PORT_BUSY;
14039 		mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, ncport)));
14040 
14041 	} /* End of loop through the controller SATA ports */
14042 }
14043 
14044 /*
14045  * Process HBA power level change reported by HBA driver.
14046  * Not implemented at this time - event is ignored.
14047  */
14048 static void
14049 sata_process_cntrl_pwr_level_change(sata_hba_inst_t *sata_hba_inst)
14050 {
14051 	SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst,
14052 	    "Processing controller power level change", NULL);
14053 
14054 	/* Ignoring it for now */
14055 	mutex_enter(&sata_hba_inst->satahba_mutex);
14056 	sata_hba_inst->satahba_event_flags &= ~SATA_EVNT_PWR_LEVEL_CHANGED;
14057 	mutex_exit(&sata_hba_inst->satahba_mutex);
14058 }
14059 
14060 /*
14061  * Process port power level change reported by HBA driver.
14062  * Not implemented at this time - event is ignored.
14063  */
14064 static void
14065 sata_process_port_pwr_change(sata_hba_inst_t *sata_hba_inst,
14066     sata_address_t *saddr)
14067 {
14068 	sata_cport_info_t *cportinfo;
14069 
14070 	SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst,
14071 	    "Processing port power level change", NULL);
14072 
14073 	cportinfo = SATA_CPORT_INFO(sata_hba_inst, saddr->cport);
14074 	mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex);
14075 	/* Reset event flag */
14076 	cportinfo->cport_event_flags &= ~SATA_EVNT_PWR_LEVEL_CHANGED;
14077 	mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex);
14078 }
14079 
14080 /*
14081  * Process port failure reported by HBA driver.
14082  * cports support only - no pmports.
14083  */
14084 static void
14085 sata_process_port_failed_event(sata_hba_inst_t *sata_hba_inst,
14086     sata_address_t *saddr)
14087 {
14088 	sata_cport_info_t *cportinfo;
14089 
14090 	cportinfo = SATA_CPORT_INFO(sata_hba_inst, saddr->cport);
14091 	mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex);
14092 	/* Reset event flag first */
14093 	cportinfo->cport_event_flags &= ~SATA_EVNT_PORT_FAILED;
14094 	/* If the port is in SHUTDOWN or FAILED state, ignore this event. */
14095 	if ((cportinfo->cport_state &
14096 	    (SATA_PSTATE_SHUTDOWN | SATA_PSTATE_FAILED)) == 0) {
14097 		mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->
14098 		    cport_mutex);
14099 		return;
14100 	}
14101 	/* Fail the port */
14102 	cportinfo->cport_state = SATA_PSTATE_FAILED;
14103 	mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex);
14104 	sata_log(sata_hba_inst, CE_WARN, "SATA port %d failed", saddr->cport);
14105 }
14106 
14107 /*
14108  * Device Reset Event processing.
14109  * The seqeunce is managed by 3 stage flags:
14110  * - reset event reported,
14111  * - reset event being processed,
14112  * - request to clear device reset state.
14113  */
14114 static void
14115 sata_process_device_reset(sata_hba_inst_t *sata_hba_inst,
14116     sata_address_t *saddr)
14117 {
14118 	sata_drive_info_t old_sdinfo; /* local copy of the drive info */
14119 	sata_drive_info_t *sdinfo;
14120 	sata_cport_info_t *cportinfo;
14121 	sata_device_t sata_device;
14122 	int rval;
14123 
14124 	/* We only care about host sata cport for now */
14125 	cportinfo = SATA_CPORT_INFO(sata_hba_inst, saddr->cport);
14126 
14127 	mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex);
14128 
14129 	/* If the port is in SHUTDOWN or FAILED state, ignore reset event. */
14130 	if ((cportinfo->cport_state &
14131 	    (SATA_PSTATE_SHUTDOWN | SATA_PSTATE_FAILED)) != 0) {
14132 		mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->
14133 		    cport_mutex);
14134 		return;
14135 	}
14136 
14137 	if ((SATA_CPORT_DEV_TYPE(sata_hba_inst, saddr->cport) &
14138 	    SATA_VALID_DEV_TYPE) == 0) {
14139 		mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->
14140 		    cport_mutex);
14141 		return;
14142 	}
14143 	sdinfo = SATA_CPORT_DRV_INFO(sata_hba_inst, saddr->cport);
14144 	if (sdinfo == NULL) {
14145 		mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->
14146 		    cport_mutex);
14147 		return;
14148 	}
14149 
14150 	if ((sdinfo->satadrv_event_flags &
14151 	    (SATA_EVNT_DEVICE_RESET | SATA_EVNT_INPROC_DEVICE_RESET)) == 0) {
14152 		/* Nothing to do */
14153 		mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->
14154 		    cport_mutex);
14155 		return;
14156 	}
14157 #ifdef SATA_DEBUG
14158 	if ((sdinfo->satadrv_event_flags &
14159 	    (SATA_EVNT_DEVICE_RESET | SATA_EVNT_INPROC_DEVICE_RESET)) ==
14160 	    (SATA_EVNT_DEVICE_RESET | SATA_EVNT_INPROC_DEVICE_RESET)) {
14161 		/* Something is weird - new device reset event */
14162 		SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst,
14163 		    "Overlapping device reset events!", NULL);
14164 	}
14165 #endif
14166 	SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst,
14167 	    "Processing port %d device reset", saddr->cport);
14168 
14169 	/* Clear event flag */
14170 	sdinfo->satadrv_event_flags &= ~SATA_EVNT_DEVICE_RESET;
14171 
14172 	/* It seems that we always need to check the port state first */
14173 	sata_device.satadev_rev = SATA_DEVICE_REV;
14174 	sata_device.satadev_addr = *saddr;
14175 	/*
14176 	 * We have to exit mutex, because the HBA probe port function may
14177 	 * block on its own mutex.
14178 	 */
14179 	mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex);
14180 	rval = (*SATA_PROBE_PORT_FUNC(sata_hba_inst))
14181 	    (SATA_DIP(sata_hba_inst), &sata_device);
14182 	mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex);
14183 	sata_update_port_info(sata_hba_inst, &sata_device);
14184 	if (rval != SATA_SUCCESS) {
14185 		/* Something went wrong? Fail the port */
14186 		cportinfo->cport_state = SATA_PSTATE_FAILED;
14187 		mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->
14188 		    cport_mutex);
14189 		SATA_LOG_D((sata_hba_inst, CE_WARN,
14190 		    "SATA port %d probing failed",
14191 		    saddr->cport));
14192 		return;
14193 	}
14194 	if ((sata_device.satadev_scr.sstatus  &
14195 	    SATA_PORT_DEVLINK_UP_MASK) !=
14196 	    SATA_PORT_DEVLINK_UP ||
14197 	    sata_device.satadev_type == SATA_DTYPE_NONE) {
14198 		/*
14199 		 * No device to process, anymore. Some other event processing
14200 		 * would or have already performed port info cleanup.
14201 		 * To be safe (HBA may need it), request clearing device
14202 		 * reset condition.
14203 		 */
14204 		sdinfo->satadrv_event_flags = 0;
14205 		sdinfo->satadrv_event_flags |= SATA_EVNT_CLEAR_DEVICE_RESET;
14206 		mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->
14207 		    cport_mutex);
14208 		return;
14209 	}
14210 
14211 	/* Mark device reset processing as active */
14212 	sdinfo->satadrv_event_flags |= SATA_EVNT_INPROC_DEVICE_RESET;
14213 
14214 	old_sdinfo = *sdinfo;	/* local copy of the drive info */
14215 	mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex);
14216 
14217 	if (sata_set_drive_features(sata_hba_inst, &old_sdinfo, 1) ==
14218 	    SATA_FAILURE) {
14219 		/*
14220 		 * Restoring drive setting failed.
14221 		 * Probe the port first, to check if the port state has changed
14222 		 */
14223 		sata_device.satadev_rev = SATA_DEVICE_REV;
14224 		sata_device.satadev_addr = *saddr;
14225 		sata_device.satadev_addr.qual = SATA_ADDR_CPORT;
14226 		/* probe port */
14227 		rval = (*SATA_PROBE_PORT_FUNC(sata_hba_inst))
14228 		    (SATA_DIP(sata_hba_inst), &sata_device);
14229 		mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->
14230 		    cport_mutex);
14231 		if (rval == SATA_SUCCESS &&
14232 		    (sata_device.satadev_state &
14233 		    (SATA_PSTATE_SHUTDOWN | SATA_PSTATE_FAILED)) == 0 &&
14234 		    (sata_device.satadev_scr.sstatus  &
14235 		    SATA_PORT_DEVLINK_UP_MASK) == SATA_PORT_DEVLINK_UP &&
14236 		    sata_device.satadev_type != SATA_DTYPE_NONE) {
14237 			/*
14238 			 * We may retry this a bit later - in-process reset
14239 			 * condition should be already set.
14240 			 */
14241 			if ((cportinfo->cport_dev_type &
14242 			    SATA_VALID_DEV_TYPE) != 0 &&
14243 			    SATA_CPORTINFO_DRV_INFO(cportinfo) != NULL) {
14244 				sdinfo = SATA_CPORTINFO_DRV_INFO(cportinfo);
14245 				mutex_exit(&SATA_CPORT_INFO(sata_hba_inst,
14246 				    saddr->cport)->cport_mutex);
14247 				mutex_enter(&sata_hba_inst->satahba_mutex);
14248 				sata_hba_inst->satahba_event_flags |=
14249 				    SATA_EVNT_MAIN;
14250 				mutex_exit(&sata_hba_inst->satahba_mutex);
14251 				mutex_enter(&sata_mutex);
14252 				sata_event_pending |= SATA_EVNT_MAIN;
14253 				mutex_exit(&sata_mutex);
14254 				return;
14255 			}
14256 		} else {
14257 			/*
14258 			 * No point of retrying - some other event processing
14259 			 * would or already did port info cleanup.
14260 			 * To be safe (HBA may need it),
14261 			 * request clearing device reset condition.
14262 			 */
14263 			sdinfo->satadrv_event_flags = 0;
14264 			sdinfo->satadrv_event_flags |=
14265 			    SATA_EVNT_CLEAR_DEVICE_RESET;
14266 		}
14267 		mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->
14268 		    cport_mutex);
14269 		return;
14270 	}
14271 
14272 	/*
14273 	 * Raise the flag indicating that the next sata command could
14274 	 * be sent with SATA_CLEAR_DEV_RESET_STATE flag, if no new device
14275 	 * reset is reported.
14276 	 */
14277 	mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex);
14278 	if ((cportinfo->cport_dev_type & SATA_VALID_DEV_TYPE) != 0 &&
14279 	    SATA_CPORTINFO_DRV_INFO(cportinfo) != NULL) {
14280 		sdinfo = SATA_CPORTINFO_DRV_INFO(cportinfo);
14281 		sdinfo->satadrv_event_flags &= ~SATA_EVNT_INPROC_DEVICE_RESET;
14282 		sdinfo->satadrv_event_flags |= SATA_EVNT_CLEAR_DEVICE_RESET;
14283 	}
14284 	mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex);
14285 }
14286 
14287 
14288 /*
14289  * Port Link Events processing.
14290  * Every link established event may involve device reset (due to
14291  * COMRESET signal, equivalent of the hard reset) so arbitrarily
14292  * set device reset event for an attached device (if any).
14293  * If the port is in SHUTDOWN or FAILED state, ignore link events.
14294  *
14295  * The link established event processing varies, depending on the state
14296  * of the target node, HBA hotplugging capabilities, state of the port.
14297  * If the link is not active, the link established event is ignored.
14298  * If HBA cannot detect device attachment and there is no target node,
14299  * the link established event triggers device attach event processing.
14300  * Else, link established event triggers device reset event processing.
14301  *
14302  * The link lost event processing varies, depending on a HBA hotplugging
14303  * capability and the state of the port (link active or not active).
14304  * If the link is active, the lost link event is ignored.
14305  * If HBA cannot detect device removal, the lost link event triggers
14306  * device detached event processing after link lost timeout.
14307  * Else, the event is ignored.
14308  *
14309  * NOTE: Only cports are processed for now, i.e. no port multiplier ports
14310  */
14311 static void
14312 sata_process_port_link_events(sata_hba_inst_t *sata_hba_inst,
14313     sata_address_t *saddr)
14314 {
14315 	sata_device_t sata_device;
14316 	sata_cport_info_t *cportinfo;
14317 	sata_drive_info_t *sdinfo;
14318 	uint32_t event_flags;
14319 	int rval;
14320 
14321 	SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst,
14322 	    "Processing port %d link event(s)", saddr->cport);
14323 
14324 	cportinfo = SATA_CPORT_INFO(sata_hba_inst, saddr->cport);
14325 	mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex);
14326 	event_flags = cportinfo->cport_event_flags;
14327 
14328 	/* Reset event flags first */
14329 	cportinfo->cport_event_flags &=
14330 	    ~(SATA_EVNT_LINK_ESTABLISHED | SATA_EVNT_LINK_LOST);
14331 
14332 	/* If the port is in SHUTDOWN or FAILED state, ignore link events. */
14333 	if ((cportinfo->cport_state &
14334 	    (SATA_PSTATE_SHUTDOWN | SATA_PSTATE_FAILED)) != 0) {
14335 		mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->
14336 		    cport_mutex);
14337 		return;
14338 	}
14339 
14340 	/*
14341 	 * For the sanity sake get current port state.
14342 	 * Set device address only. Other sata_device fields should be
14343 	 * set by HBA driver.
14344 	 */
14345 	sata_device.satadev_rev = SATA_DEVICE_REV;
14346 	sata_device.satadev_addr = *saddr;
14347 	/*
14348 	 * We have to exit mutex, because the HBA probe port function may
14349 	 * block on its own mutex.
14350 	 */
14351 	mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex);
14352 	rval = (*SATA_PROBE_PORT_FUNC(sata_hba_inst))
14353 	    (SATA_DIP(sata_hba_inst), &sata_device);
14354 	mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex);
14355 	sata_update_port_info(sata_hba_inst, &sata_device);
14356 	if (rval != SATA_SUCCESS) {
14357 		/* Something went wrong? Fail the port */
14358 		cportinfo->cport_state = SATA_PSTATE_FAILED;
14359 		mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->
14360 		    cport_mutex);
14361 		SATA_LOG_D((sata_hba_inst, CE_WARN,
14362 		    "SATA port %d probing failed",
14363 		    saddr->cport));
14364 		/*
14365 		 * We may want to release device info structure, but
14366 		 * it is not necessary.
14367 		 */
14368 		return;
14369 	} else {
14370 		/* port probed successfully */
14371 		cportinfo->cport_state |= SATA_STATE_PROBED | SATA_STATE_READY;
14372 	}
14373 	if (event_flags & SATA_EVNT_LINK_ESTABLISHED) {
14374 
14375 		if ((sata_device.satadev_scr.sstatus &
14376 		    SATA_PORT_DEVLINK_UP_MASK) != SATA_PORT_DEVLINK_UP) {
14377 			/* Ignore event */
14378 			SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst,
14379 			    "Ignoring port %d link established event - "
14380 			    "link down",
14381 			    saddr->cport);
14382 			goto linklost;
14383 		}
14384 
14385 		SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst,
14386 		    "Processing port %d link established event",
14387 		    saddr->cport);
14388 
14389 		/*
14390 		 * For the sanity sake check if a device is attached - check
14391 		 * return state of a port probing.
14392 		 */
14393 		if (sata_device.satadev_type != SATA_DTYPE_NONE &&
14394 		    sata_device.satadev_type != SATA_DTYPE_PMULT) {
14395 			/*
14396 			 * HBA port probe indicated that there is a device
14397 			 * attached. Check if the framework had device info
14398 			 * structure attached for this device.
14399 			 */
14400 			if (cportinfo->cport_dev_type != SATA_DTYPE_NONE) {
14401 				ASSERT(SATA_CPORTINFO_DRV_INFO(cportinfo) !=
14402 				    NULL);
14403 
14404 				sdinfo = SATA_CPORTINFO_DRV_INFO(cportinfo);
14405 				if ((sdinfo->satadrv_type &
14406 				    SATA_VALID_DEV_TYPE) != 0) {
14407 					/*
14408 					 * Dev info structure is present.
14409 					 * If dev_type is set to known type in
14410 					 * the framework's drive info struct
14411 					 * then the device existed before and
14412 					 * the link was probably lost
14413 					 * momentarily - in such case
14414 					 * we may want to check device
14415 					 * identity.
14416 					 * Identity check is not supported now.
14417 					 *
14418 					 * Link established event
14419 					 * triggers device reset event.
14420 					 */
14421 					(SATA_CPORTINFO_DRV_INFO(cportinfo))->
14422 					    satadrv_event_flags |=
14423 					    SATA_EVNT_DEVICE_RESET;
14424 				}
14425 			} else if (cportinfo->cport_dev_type ==
14426 			    SATA_DTYPE_NONE) {
14427 				/*
14428 				 * We got new device attached! If HBA does not
14429 				 * generate device attached events, trigger it
14430 				 * here.
14431 				 */
14432 				if (!(SATA_FEATURES(sata_hba_inst) &
14433 				    SATA_CTLF_HOTPLUG)) {
14434 					cportinfo->cport_event_flags |=
14435 					    SATA_EVNT_DEVICE_ATTACHED;
14436 				}
14437 			}
14438 			/* Reset link lost timeout */
14439 			cportinfo->cport_link_lost_time = 0;
14440 		}
14441 	}
14442 linklost:
14443 	if (event_flags & SATA_EVNT_LINK_LOST) {
14444 		if ((sata_device.satadev_scr.sstatus &
14445 		    SATA_PORT_DEVLINK_UP_MASK) == SATA_PORT_DEVLINK_UP) {
14446 			/* Ignore event */
14447 			SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst,
14448 			    "Ignoring port %d link lost event - link is up",
14449 			    saddr->cport);
14450 			goto done;
14451 		}
14452 #ifdef SATA_DEBUG
14453 		if (cportinfo->cport_link_lost_time == 0) {
14454 			SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst,
14455 			    "Processing port %d link lost event",
14456 			    saddr->cport);
14457 		}
14458 #endif
14459 		/*
14460 		 * When HBA cannot generate device attached/detached events,
14461 		 * we need to track link lost time and eventually generate
14462 		 * device detach event.
14463 		 */
14464 		if (!(SATA_FEATURES(sata_hba_inst) & SATA_CTLF_HOTPLUG)) {
14465 			/* We are tracking link lost time */
14466 			if (cportinfo->cport_link_lost_time == 0) {
14467 				/* save current time (lbolt value) */
14468 				cportinfo->cport_link_lost_time =
14469 				    ddi_get_lbolt();
14470 				/* just keep link lost event */
14471 				cportinfo->cport_event_flags |=
14472 				    SATA_EVNT_LINK_LOST;
14473 			} else {
14474 				clock_t cur_time = ddi_get_lbolt();
14475 				if ((cur_time -
14476 				    cportinfo->cport_link_lost_time) >=
14477 				    drv_usectohz(
14478 				    SATA_EVNT_LINK_LOST_TIMEOUT)) {
14479 					/* trigger device detach event */
14480 					cportinfo->cport_event_flags |=
14481 					    SATA_EVNT_DEVICE_DETACHED;
14482 					cportinfo->cport_link_lost_time = 0;
14483 					SATADBG1(SATA_DBG_EVENTS,
14484 					    sata_hba_inst,
14485 					    "Triggering port %d "
14486 					    "device detached event",
14487 					    saddr->cport);
14488 				} else {
14489 					/* keep link lost event */
14490 					cportinfo->cport_event_flags |=
14491 					    SATA_EVNT_LINK_LOST;
14492 				}
14493 			}
14494 		}
14495 		/*
14496 		 * We could change port state to disable/delay access to
14497 		 * the attached device until the link is recovered.
14498 		 */
14499 	}
14500 done:
14501 	event_flags = cportinfo->cport_event_flags;
14502 	mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex);
14503 	if (event_flags != 0) {
14504 		mutex_enter(&sata_hba_inst->satahba_mutex);
14505 		sata_hba_inst->satahba_event_flags |= SATA_EVNT_MAIN;
14506 		mutex_exit(&sata_hba_inst->satahba_mutex);
14507 		mutex_enter(&sata_mutex);
14508 		sata_event_pending |= SATA_EVNT_MAIN;
14509 		mutex_exit(&sata_mutex);
14510 	}
14511 }
14512 
14513 /*
14514  * Device Detached Event processing.
14515  * Port is probed to find if a device is really gone. If so,
14516  * the device info structure is detached from the SATA port info structure
14517  * and released.
14518  * Port status is updated.
14519  *
14520  * NOTE: Process cports event only, no port multiplier ports.
14521  */
14522 static void
14523 sata_process_device_detached(sata_hba_inst_t *sata_hba_inst,
14524     sata_address_t *saddr)
14525 {
14526 	sata_cport_info_t *cportinfo;
14527 	sata_drive_info_t *sdevinfo;
14528 	sata_device_t sata_device;
14529 	dev_info_t *tdip;
14530 	int rval;
14531 
14532 	SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst,
14533 	    "Processing port %d device detached", saddr->cport);
14534 
14535 	cportinfo = SATA_CPORT_INFO(sata_hba_inst, saddr->cport);
14536 	mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex);
14537 	/* Clear event flag */
14538 	cportinfo->cport_event_flags &= ~SATA_EVNT_DEVICE_DETACHED;
14539 
14540 	/* If the port is in SHUTDOWN or FAILED state, ignore detach event. */
14541 	if ((cportinfo->cport_state &
14542 	    (SATA_PSTATE_SHUTDOWN | SATA_PSTATE_FAILED)) != 0) {
14543 		mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->
14544 		    cport_mutex);
14545 		return;
14546 	}
14547 	/* For sanity, re-probe the port */
14548 	sata_device.satadev_rev = SATA_DEVICE_REV;
14549 	sata_device.satadev_addr = *saddr;
14550 
14551 	/*
14552 	 * We have to exit mutex, because the HBA probe port function may
14553 	 * block on its own mutex.
14554 	 */
14555 	mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex);
14556 	rval = (*SATA_PROBE_PORT_FUNC(sata_hba_inst))
14557 	    (SATA_DIP(sata_hba_inst), &sata_device);
14558 	mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex);
14559 	sata_update_port_info(sata_hba_inst, &sata_device);
14560 	if (rval != SATA_SUCCESS) {
14561 		/* Something went wrong? Fail the port */
14562 		cportinfo->cport_state = SATA_PSTATE_FAILED;
14563 		mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->
14564 		    cport_mutex);
14565 		SATA_LOG_D((sata_hba_inst, CE_WARN,
14566 		    "SATA port %d probing failed",
14567 		    saddr->cport));
14568 		/*
14569 		 * We may want to release device info structure, but
14570 		 * it is not necessary.
14571 		 */
14572 		return;
14573 	} else {
14574 		/* port probed successfully */
14575 		cportinfo->cport_state |= SATA_STATE_PROBED | SATA_STATE_READY;
14576 	}
14577 	/*
14578 	 * Check if a device is still attached. For sanity, check also
14579 	 * link status - if no link, there is no device.
14580 	 */
14581 	if ((sata_device.satadev_scr.sstatus & SATA_PORT_DEVLINK_UP_MASK) ==
14582 	    SATA_PORT_DEVLINK_UP && sata_device.satadev_type !=
14583 	    SATA_DTYPE_NONE) {
14584 		/*
14585 		 * Device is still attached - ignore detach event.
14586 		 */
14587 		mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->
14588 		    cport_mutex);
14589 		SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst,
14590 		    "Ignoring detach - device still attached to port %d",
14591 		    sata_device.satadev_addr.cport);
14592 		return;
14593 	}
14594 	/*
14595 	 * We need to detach and release device info structure here
14596 	 */
14597 	if (SATA_CPORTINFO_DRV_INFO(cportinfo) != NULL) {
14598 		sdevinfo = SATA_CPORTINFO_DRV_INFO(cportinfo);
14599 		SATA_CPORTINFO_DRV_INFO(cportinfo) = NULL;
14600 		(void) kmem_free((void *)sdevinfo,
14601 		    sizeof (sata_drive_info_t));
14602 	}
14603 	cportinfo->cport_dev_type = SATA_DTYPE_NONE;
14604 	/*
14605 	 * Device cannot be reached anymore, even if the target node may be
14606 	 * still present.
14607 	 */
14608 
14609 	mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex);
14610 	sata_log(sata_hba_inst, CE_WARN, "SATA device detached at port %d",
14611 	    sata_device.satadev_addr.cport);
14612 
14613 	/*
14614 	 * Try to offline a device and remove target node if it still exists
14615 	 */
14616 	tdip = sata_get_target_dip(SATA_DIP(sata_hba_inst), saddr->cport);
14617 	if (tdip != NULL) {
14618 		/*
14619 		 * Target node exists.  Unconfigure device then remove
14620 		 * the target node (one ndi operation).
14621 		 */
14622 		if (ndi_devi_offline(tdip, NDI_DEVI_REMOVE) != NDI_SUCCESS) {
14623 			/*
14624 			 * PROBLEM - no device, but target node remained
14625 			 * This happens when the file was open or node was
14626 			 * waiting for resources.
14627 			 */
14628 			SATA_LOG_D((sata_hba_inst, CE_WARN,
14629 			    "sata_process_device_detached: "
14630 			    "Failed to remove target node for "
14631 			    "detached SATA device."));
14632 			/*
14633 			 * Set target node state to DEVI_DEVICE_REMOVED.
14634 			 * But re-check first that the node still exists.
14635 			 */
14636 			tdip = sata_get_target_dip(SATA_DIP(sata_hba_inst),
14637 			    saddr->cport);
14638 			if (tdip != NULL) {
14639 				sata_set_device_removed(tdip);
14640 				/*
14641 				 * Instruct event daemon to retry the
14642 				 * cleanup later.
14643 				 */
14644 				sata_set_target_node_cleanup(sata_hba_inst,
14645 				    &sata_device.satadev_addr);
14646 			}
14647 		}
14648 	}
14649 	/*
14650 	 * Generate sysevent - EC_DR / ESC_DR_AP_STATE_CHANGE
14651 	 * with the hint: SE_HINT_REMOVE
14652 	 */
14653 	sata_gen_sysevent(sata_hba_inst, saddr, SE_HINT_REMOVE);
14654 }
14655 
14656 
14657 /*
14658  * Device Attached Event processing.
14659  * Port state is checked to verify that a device is really attached. If so,
14660  * the device info structure is created and attached to the SATA port info
14661  * structure.
14662  *
14663  * If attached device cannot be identified or set-up, the retry for the
14664  * attach processing is set-up. Subsequent daemon run would try again to
14665  * identify the device, until the time limit is reached
14666  * (SATA_DEV_IDENTIFY_TIMEOUT).
14667  *
14668  * This function cannot be called in interrupt context (it may sleep).
14669  *
14670  * NOTE: Process cports event only, no port multiplier ports.
14671  */
14672 static void
14673 sata_process_device_attached(sata_hba_inst_t *sata_hba_inst,
14674     sata_address_t *saddr)
14675 {
14676 	sata_cport_info_t *cportinfo;
14677 	sata_drive_info_t *sdevinfo;
14678 	sata_device_t sata_device;
14679 	dev_info_t *tdip;
14680 	uint32_t event_flags;
14681 	int rval;
14682 
14683 	SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst,
14684 	    "Processing port %d device attached", saddr->cport);
14685 
14686 	cportinfo = SATA_CPORT_INFO(sata_hba_inst, saddr->cport);
14687 	mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex);
14688 
14689 	/* Clear attach event flag first */
14690 	cportinfo->cport_event_flags &= ~SATA_EVNT_DEVICE_ATTACHED;
14691 
14692 	/* If the port is in SHUTDOWN or FAILED state, ignore event. */
14693 	if ((cportinfo->cport_state &
14694 	    (SATA_PSTATE_SHUTDOWN | SATA_PSTATE_FAILED)) != 0) {
14695 		cportinfo->cport_dev_attach_time = 0;
14696 		mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->
14697 		    cport_mutex);
14698 		return;
14699 	}
14700 
14701 	/*
14702 	 * If the sata_drive_info structure is found attached to the port info,
14703 	 * despite the fact the device was removed and now it is re-attached,
14704 	 * the old drive info structure was not removed.
14705 	 * Arbitrarily release device info structure.
14706 	 */
14707 	if (SATA_CPORTINFO_DRV_INFO(cportinfo) != NULL) {
14708 		sdevinfo = SATA_CPORTINFO_DRV_INFO(cportinfo);
14709 		SATA_CPORTINFO_DRV_INFO(cportinfo) = NULL;
14710 		(void) kmem_free((void *)sdevinfo,
14711 		    sizeof (sata_drive_info_t));
14712 		SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst,
14713 		    "Arbitrarily detaching old device info.", NULL);
14714 	}
14715 	cportinfo->cport_dev_type = SATA_DTYPE_NONE;
14716 
14717 	/* For sanity, re-probe the port */
14718 	sata_device.satadev_rev = SATA_DEVICE_REV;
14719 	sata_device.satadev_addr = *saddr;
14720 
14721 	/*
14722 	 * We have to exit mutex, because the HBA probe port function may
14723 	 * block on its own mutex.
14724 	 */
14725 	mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex);
14726 	rval = (*SATA_PROBE_PORT_FUNC(sata_hba_inst))
14727 	    (SATA_DIP(sata_hba_inst), &sata_device);
14728 	mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex);
14729 	sata_update_port_info(sata_hba_inst, &sata_device);
14730 	if (rval != SATA_SUCCESS) {
14731 		/* Something went wrong? Fail the port */
14732 		cportinfo->cport_state = SATA_PSTATE_FAILED;
14733 		cportinfo->cport_dev_attach_time = 0;
14734 		mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->
14735 		    cport_mutex);
14736 		SATA_LOG_D((sata_hba_inst, CE_WARN,
14737 		    "SATA port %d probing failed",
14738 		    saddr->cport));
14739 		return;
14740 	} else {
14741 		/* port probed successfully */
14742 		cportinfo->cport_state |= SATA_STATE_PROBED | SATA_STATE_READY;
14743 	}
14744 	/*
14745 	 * Check if a device is still attached. For sanity, check also
14746 	 * link status - if no link, there is no device.
14747 	 */
14748 	if ((sata_device.satadev_scr.sstatus & SATA_PORT_DEVLINK_UP_MASK) !=
14749 	    SATA_PORT_DEVLINK_UP || sata_device.satadev_type ==
14750 	    SATA_DTYPE_NONE) {
14751 		/*
14752 		 * No device - ignore attach event.
14753 		 */
14754 		cportinfo->cport_dev_attach_time = 0;
14755 		mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->
14756 		    cport_mutex);
14757 		SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst,
14758 		    "Ignoring attach - no device connected to port %d",
14759 		    sata_device.satadev_addr.cport);
14760 		return;
14761 	}
14762 
14763 	mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex);
14764 	/*
14765 	 * Generate sysevent - EC_DR / ESC_DR_AP_STATE_CHANGE
14766 	 * with the hint: SE_HINT_INSERT
14767 	 */
14768 	sata_gen_sysevent(sata_hba_inst, saddr, SE_HINT_INSERT);
14769 
14770 	/*
14771 	 * Port reprobing will take care of the creation of the device
14772 	 * info structure and determination of the device type.
14773 	 */
14774 	sata_device.satadev_addr = *saddr;
14775 	(void) sata_reprobe_port(sata_hba_inst, &sata_device,
14776 	    SATA_DEV_IDENTIFY_NORETRY);
14777 
14778 	mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->
14779 	    cport_mutex);
14780 	if ((cportinfo->cport_state & SATA_STATE_READY) &&
14781 	    (cportinfo->cport_dev_type != SATA_DTYPE_NONE)) {
14782 		/* Some device is attached to the port */
14783 		if (cportinfo->cport_dev_type == SATA_DTYPE_UNKNOWN) {
14784 			/*
14785 			 * A device was not successfully attached.
14786 			 * Track retry time for device identification.
14787 			 */
14788 			if (cportinfo->cport_dev_attach_time != 0) {
14789 				clock_t cur_time = ddi_get_lbolt();
14790 				/*
14791 				 * If the retry time limit was not exceeded,
14792 				 * reinstate attach event.
14793 				 */
14794 				if ((cur_time -
14795 				    cportinfo->cport_dev_attach_time) <
14796 				    drv_usectohz(
14797 				    SATA_DEV_IDENTIFY_TIMEOUT)) {
14798 					/* OK, restore attach event */
14799 					cportinfo->cport_event_flags |=
14800 					    SATA_EVNT_DEVICE_ATTACHED;
14801 				} else {
14802 					/* Timeout - cannot identify device */
14803 					cportinfo->cport_dev_attach_time = 0;
14804 					sata_log(sata_hba_inst,
14805 					    CE_WARN,
14806 					    "Cannot identify SATA device "
14807 					    "at port %d - device will not be "
14808 					    "attached.",
14809 					    saddr->cport);
14810 				}
14811 			} else {
14812 				/*
14813 				 * Start tracking time for device
14814 				 * identification.
14815 				 * Save current time (lbolt value).
14816 				 */
14817 				cportinfo->cport_dev_attach_time =
14818 				    ddi_get_lbolt();
14819 				/* Restore attach event */
14820 				cportinfo->cport_event_flags |=
14821 				    SATA_EVNT_DEVICE_ATTACHED;
14822 			}
14823 		} else {
14824 			/*
14825 			 * If device was successfully attached, the subsequent
14826 			 * action depends on a state of the
14827 			 * sata_auto_online variable. If it is set to zero.
14828 			 * an explicit 'configure' command will be needed to
14829 			 * configure it. If its value is non-zero, we will
14830 			 * attempt to online (configure) the device.
14831 			 * First, log the message indicating that a device
14832 			 * was attached.
14833 			 */
14834 			cportinfo->cport_dev_attach_time = 0;
14835 			sata_log(sata_hba_inst, CE_WARN,
14836 			    "SATA device detected at port %d", saddr->cport);
14837 
14838 			if (SATA_CPORTINFO_DRV_INFO(cportinfo) != NULL) {
14839 				sata_drive_info_t new_sdinfo;
14840 
14841 				/* Log device info data */
14842 				new_sdinfo = *(SATA_CPORTINFO_DRV_INFO(
14843 				    cportinfo));
14844 				sata_show_drive_info(sata_hba_inst,
14845 				    &new_sdinfo);
14846 			}
14847 
14848 			mutex_exit(&SATA_CPORT_INFO(sata_hba_inst,
14849 			    saddr->cport)->cport_mutex);
14850 
14851 			/*
14852 			 * Make sure that there is no target node for that
14853 			 * device. If so, release it. It should not happen,
14854 			 * unless we had problem removing the node when
14855 			 * device was detached.
14856 			 */
14857 			tdip = sata_get_target_dip(SATA_DIP(sata_hba_inst),
14858 			    saddr->cport);
14859 			mutex_enter(&SATA_CPORT_INFO(sata_hba_inst,
14860 			    saddr->cport)->cport_mutex);
14861 			if (tdip != NULL) {
14862 
14863 #ifdef SATA_DEBUG
14864 				if ((cportinfo->cport_event_flags &
14865 				    SATA_EVNT_TARGET_NODE_CLEANUP) == 0)
14866 					sata_log(sata_hba_inst, CE_WARN,
14867 					    "sata_process_device_attached: "
14868 					    "old device target node exists!");
14869 #endif
14870 				/*
14871 				 * target node exists - try to unconfigure
14872 				 * device and remove the node.
14873 				 */
14874 				mutex_exit(&SATA_CPORT_INFO(sata_hba_inst,
14875 				    saddr->cport)->cport_mutex);
14876 				rval = ndi_devi_offline(tdip,
14877 				    NDI_DEVI_REMOVE);
14878 				mutex_enter(&SATA_CPORT_INFO(sata_hba_inst,
14879 				    saddr->cport)->cport_mutex);
14880 
14881 				if (rval == NDI_SUCCESS) {
14882 					cportinfo->cport_event_flags &=
14883 					    ~SATA_EVNT_TARGET_NODE_CLEANUP;
14884 					cportinfo->cport_tgtnode_clean = B_TRUE;
14885 				} else {
14886 					/*
14887 					 * PROBLEM - the target node remained
14888 					 * and it belongs to a previously
14889 					 * attached device.
14890 					 * This happens when the file was open
14891 					 * or the node was waiting for
14892 					 * resources at the time the
14893 					 * associated device was removed.
14894 					 * Instruct event daemon to retry the
14895 					 * cleanup later.
14896 					 */
14897 					sata_log(sata_hba_inst,
14898 					    CE_WARN,
14899 					    "Application(s) accessing "
14900 					    "previously attached SATA "
14901 					    "device have to release "
14902 					    "it before newly inserted "
14903 					    "device can be made accessible.",
14904 					    saddr->cport);
14905 					cportinfo->cport_event_flags |=
14906 					    SATA_EVNT_TARGET_NODE_CLEANUP;
14907 					cportinfo->cport_tgtnode_clean =
14908 					    B_FALSE;
14909 				}
14910 			}
14911 			if (sata_auto_online != 0) {
14912 				cportinfo->cport_event_flags |=
14913 				    SATA_EVNT_AUTOONLINE_DEVICE;
14914 			}
14915 
14916 		}
14917 	} else {
14918 		cportinfo->cport_dev_attach_time = 0;
14919 	}
14920 
14921 	event_flags = cportinfo->cport_event_flags;
14922 	mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex);
14923 	if (event_flags != 0) {
14924 		mutex_enter(&sata_hba_inst->satahba_mutex);
14925 		sata_hba_inst->satahba_event_flags |= SATA_EVNT_MAIN;
14926 		mutex_exit(&sata_hba_inst->satahba_mutex);
14927 		mutex_enter(&sata_mutex);
14928 		sata_event_pending |= SATA_EVNT_MAIN;
14929 		mutex_exit(&sata_mutex);
14930 	}
14931 }
14932 
14933 
14934 /*
14935  * Device Target Node Cleanup Event processing.
14936  * If the target node associated with a sata port device is in
14937  * DEVI_DEVICE_REMOVED state, an attempt is made to remove it.
14938  * If the target node cannot be removed, the event flag is left intact,
14939  * so that event daemon may re-run this function later.
14940  *
14941  * This function cannot be called in interrupt context (it may sleep).
14942  *
14943  * NOTE: Processes cport events only, not port multiplier ports.
14944  */
14945 static void
14946 sata_process_target_node_cleanup(sata_hba_inst_t *sata_hba_inst,
14947     sata_address_t *saddr)
14948 {
14949 	sata_cport_info_t *cportinfo;
14950 	dev_info_t *tdip;
14951 
14952 	SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst,
14953 	    "Processing port %d device target node cleanup", saddr->cport);
14954 
14955 	cportinfo = SATA_CPORT_INFO(sata_hba_inst, saddr->cport);
14956 
14957 	/*
14958 	 * Check if there is target node for that device and it is in the
14959 	 * DEVI_DEVICE_REMOVED state. If so, release it.
14960 	 */
14961 	tdip = sata_get_target_dip(SATA_DIP(sata_hba_inst), saddr->cport);
14962 	if (tdip != NULL) {
14963 		/*
14964 		 * target node exists - check if it is target node of
14965 		 * a removed device.
14966 		 */
14967 		if (sata_check_device_removed(tdip) == B_TRUE) {
14968 			SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst,
14969 			    "sata_process_target_node_cleanup: "
14970 			    "old device target node exists!", NULL);
14971 			/*
14972 			 * Unconfigure and remove the target node
14973 			 */
14974 			if (ndi_devi_offline(tdip, NDI_DEVI_REMOVE) ==
14975 			    NDI_SUCCESS) {
14976 				mutex_enter(&SATA_CPORT_INFO(sata_hba_inst,
14977 				    saddr->cport)->cport_mutex);
14978 				cportinfo->cport_event_flags &=
14979 				    ~SATA_EVNT_TARGET_NODE_CLEANUP;
14980 				mutex_exit(&SATA_CPORT_INFO(sata_hba_inst,
14981 				    saddr->cport)->cport_mutex);
14982 				return;
14983 			}
14984 			/*
14985 			 * Event daemon will retry the cleanup later.
14986 			 */
14987 			mutex_enter(&sata_hba_inst->satahba_mutex);
14988 			sata_hba_inst->satahba_event_flags |= SATA_EVNT_MAIN;
14989 			mutex_exit(&sata_hba_inst->satahba_mutex);
14990 			mutex_enter(&sata_mutex);
14991 			sata_event_pending |= SATA_EVNT_MAIN;
14992 			mutex_exit(&sata_mutex);
14993 		}
14994 	} else {
14995 		mutex_enter(&SATA_CPORT_INFO(sata_hba_inst,
14996 		    saddr->cport)->cport_mutex);
14997 		cportinfo->cport_event_flags &=
14998 		    ~SATA_EVNT_TARGET_NODE_CLEANUP;
14999 		mutex_exit(&SATA_CPORT_INFO(sata_hba_inst,
15000 		    saddr->cport)->cport_mutex);
15001 	}
15002 }
15003 
15004 /*
15005  * Device AutoOnline Event processing.
15006  * If attached device is to be onlined, an attempt is made to online this
15007  * device, but only if there is no lingering (old) target node present.
15008  * If the device cannot be onlined, the event flag is left intact,
15009  * so that event daemon may re-run this function later.
15010  *
15011  * This function cannot be called in interrupt context (it may sleep).
15012  *
15013  * NOTE: Processes cport events only, not port multiplier ports.
15014  */
15015 static void
15016 sata_process_device_autoonline(sata_hba_inst_t *sata_hba_inst,
15017     sata_address_t *saddr)
15018 {
15019 	sata_cport_info_t *cportinfo;
15020 	sata_drive_info_t *sdinfo;
15021 	sata_device_t sata_device;
15022 	dev_info_t *tdip;
15023 
15024 	SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst,
15025 	    "Processing port %d attached device auto-onlining", saddr->cport);
15026 
15027 	cportinfo = SATA_CPORT_INFO(sata_hba_inst, saddr->cport);
15028 
15029 	/*
15030 	 * Check if device is present and recognized. If not, reset event.
15031 	 */
15032 	mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex);
15033 	if ((cportinfo->cport_dev_type & SATA_VALID_DEV_TYPE) == 0) {
15034 		/* Nothing to online */
15035 		cportinfo->cport_event_flags &= ~SATA_EVNT_AUTOONLINE_DEVICE;
15036 		mutex_exit(&SATA_CPORT_INFO(sata_hba_inst,
15037 		    saddr->cport)->cport_mutex);
15038 		return;
15039 	}
15040 	mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex);
15041 
15042 	/*
15043 	 * Check if there is target node for this device and if it is in the
15044 	 * DEVI_DEVICE_REMOVED state. If so, abort onlining but keep
15045 	 * the event for later processing.
15046 	 */
15047 	tdip = sata_get_target_dip(SATA_DIP(sata_hba_inst), saddr->cport);
15048 	if (tdip != NULL) {
15049 		/*
15050 		 * target node exists - check if it is target node of
15051 		 * a removed device.
15052 		 */
15053 		if (sata_check_device_removed(tdip) == B_TRUE) {
15054 			SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst,
15055 			    "sata_process_device_autoonline: "
15056 			    "old device target node exists!", NULL);
15057 			/*
15058 			 * Event daemon will retry device onlining later.
15059 			 */
15060 			mutex_enter(&sata_hba_inst->satahba_mutex);
15061 			sata_hba_inst->satahba_event_flags |= SATA_EVNT_MAIN;
15062 			mutex_exit(&sata_hba_inst->satahba_mutex);
15063 			mutex_enter(&sata_mutex);
15064 			sata_event_pending |= SATA_EVNT_MAIN;
15065 			mutex_exit(&sata_mutex);
15066 			return;
15067 		}
15068 		/*
15069 		 * If the target node is not in the 'removed" state, assume
15070 		 * that it belongs to this device. There is nothing more to do,
15071 		 * but reset the event.
15072 		 */
15073 	} else {
15074 
15075 		/*
15076 		 * Try to online the device
15077 		 * If there is any reset-related event, remove it. We are
15078 		 * configuring the device and no state restoring is needed.
15079 		 */
15080 		mutex_enter(&SATA_CPORT_INFO(sata_hba_inst,
15081 		    saddr->cport)->cport_mutex);
15082 		sata_device.satadev_addr = *saddr;
15083 		if (saddr->qual == SATA_ADDR_CPORT)
15084 			sata_device.satadev_addr.qual = SATA_ADDR_DCPORT;
15085 		else
15086 			sata_device.satadev_addr.qual = SATA_ADDR_DPMPORT;
15087 		sdinfo = sata_get_device_info(sata_hba_inst, &sata_device);
15088 		if (sdinfo != NULL) {
15089 			if (sdinfo->satadrv_event_flags &
15090 			    (SATA_EVNT_DEVICE_RESET |
15091 			    SATA_EVNT_INPROC_DEVICE_RESET))
15092 				sdinfo->satadrv_event_flags = 0;
15093 			sdinfo->satadrv_event_flags |=
15094 			    SATA_EVNT_CLEAR_DEVICE_RESET;
15095 
15096 			/* Need to create a new target node. */
15097 			cportinfo->cport_tgtnode_clean = B_TRUE;
15098 			mutex_exit(&SATA_CPORT_INFO(sata_hba_inst,
15099 			    saddr->cport)->cport_mutex);
15100 			tdip = sata_create_target_node(SATA_DIP(sata_hba_inst),
15101 			    sata_hba_inst, &sata_device.satadev_addr);
15102 			if (tdip == NULL) {
15103 				/*
15104 				 * Configure (onlining) failed.
15105 				 * We will NOT retry
15106 				 */
15107 				SATA_LOG_D((sata_hba_inst, CE_WARN,
15108 				    "sata_process_device_autoonline: "
15109 				    "configuring SATA device at port %d failed",
15110 				    saddr->cport));
15111 			}
15112 		} else {
15113 			mutex_exit(&SATA_CPORT_INFO(sata_hba_inst,
15114 			    saddr->cport)->cport_mutex);
15115 		}
15116 
15117 	}
15118 	mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex);
15119 	cportinfo->cport_event_flags &= ~SATA_EVNT_AUTOONLINE_DEVICE;
15120 	mutex_exit(&SATA_CPORT_INFO(sata_hba_inst,
15121 	    saddr->cport)->cport_mutex);
15122 }
15123 
15124 
15125 static void
15126 sata_gen_sysevent(sata_hba_inst_t *sata_hba_inst, sata_address_t *saddr,
15127     int hint)
15128 {
15129 	char ap[MAXPATHLEN];
15130 	nvlist_t *ev_attr_list = NULL;
15131 	int err;
15132 
15133 	/* Allocate and build sysevent attribute list */
15134 	err = nvlist_alloc(&ev_attr_list, NV_UNIQUE_NAME_TYPE, DDI_NOSLEEP);
15135 	if (err != 0) {
15136 		SATA_LOG_D((sata_hba_inst, CE_WARN,
15137 		    "sata_gen_sysevent: "
15138 		    "cannot allocate memory for sysevent attributes\n"));
15139 		return;
15140 	}
15141 	/* Add hint attribute */
15142 	err = nvlist_add_string(ev_attr_list, DR_HINT, SE_HINT2STR(hint));
15143 	if (err != 0) {
15144 		SATA_LOG_D((sata_hba_inst, CE_WARN,
15145 		    "sata_gen_sysevent: "
15146 		    "failed to add DR_HINT attr for sysevent"));
15147 		nvlist_free(ev_attr_list);
15148 		return;
15149 	}
15150 	/*
15151 	 * Add AP attribute.
15152 	 * Get controller pathname and convert it into AP pathname by adding
15153 	 * a target number.
15154 	 */
15155 	(void) snprintf(ap, MAXPATHLEN, "/devices");
15156 	(void) ddi_pathname(SATA_DIP(sata_hba_inst), ap + strlen(ap));
15157 	(void) snprintf(ap + strlen(ap), MAXPATHLEN - strlen(ap), ":%d",
15158 	    SATA_MAKE_AP_NUMBER(saddr->cport, saddr->pmport, saddr->qual));
15159 
15160 	err = nvlist_add_string(ev_attr_list, DR_AP_ID, ap);
15161 	if (err != 0) {
15162 		SATA_LOG_D((sata_hba_inst, CE_WARN,
15163 		    "sata_gen_sysevent: "
15164 		    "failed to add DR_AP_ID attr for sysevent"));
15165 		nvlist_free(ev_attr_list);
15166 		return;
15167 	}
15168 
15169 	/* Generate/log sysevent */
15170 	err = ddi_log_sysevent(SATA_DIP(sata_hba_inst), DDI_VENDOR_SUNW, EC_DR,
15171 	    ESC_DR_AP_STATE_CHANGE, ev_attr_list, NULL, DDI_NOSLEEP);
15172 	if (err != DDI_SUCCESS) {
15173 		SATA_LOG_D((sata_hba_inst, CE_WARN,
15174 		    "sata_gen_sysevent: "
15175 		    "cannot log sysevent, err code %x\n", err));
15176 	}
15177 
15178 	nvlist_free(ev_attr_list);
15179 }
15180 
15181 
15182 
15183 
15184 /*
15185  * Set DEVI_DEVICE_REMOVED state in the SATA device target node.
15186  */
15187 static void
15188 sata_set_device_removed(dev_info_t *tdip)
15189 {
15190 	int circ;
15191 
15192 	ASSERT(tdip != NULL);
15193 
15194 	ndi_devi_enter(tdip, &circ);
15195 	mutex_enter(&DEVI(tdip)->devi_lock);
15196 	DEVI_SET_DEVICE_REMOVED(tdip);
15197 	mutex_exit(&DEVI(tdip)->devi_lock);
15198 	ndi_devi_exit(tdip, circ);
15199 }
15200 
15201 
15202 /*
15203  * Set internal event instructing event daemon to try
15204  * to perform the target node cleanup.
15205  */
15206 static void
15207 sata_set_target_node_cleanup(sata_hba_inst_t *sata_hba_inst,
15208     sata_address_t *saddr)
15209 {
15210 	mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex);
15211 	SATA_CPORT_EVENT_FLAGS(sata_hba_inst, saddr->cport) |=
15212 	    SATA_EVNT_TARGET_NODE_CLEANUP;
15213 	SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_tgtnode_clean =
15214 	    B_FALSE;
15215 	mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex);
15216 	mutex_enter(&sata_hba_inst->satahba_mutex);
15217 	sata_hba_inst->satahba_event_flags |= SATA_EVNT_MAIN;
15218 	mutex_exit(&sata_hba_inst->satahba_mutex);
15219 	mutex_enter(&sata_mutex);
15220 	sata_event_pending |= SATA_EVNT_MAIN;
15221 	mutex_exit(&sata_mutex);
15222 }
15223 
15224 
15225 /*
15226  * Check if the SATA device target node is in DEVI_DEVICE_REMOVED state,
15227  * i.e. check if the target node state indicates that it belongs to a removed
15228  * device.
15229  *
15230  * Returns B_TRUE if the target node is in DEVI_DEVICE_REMOVED state,
15231  * B_FALSE otherwise.
15232  *
15233  * NOTE: No port multiplier support.
15234  */
15235 static boolean_t
15236 sata_check_device_removed(dev_info_t *tdip)
15237 {
15238 	ASSERT(tdip != NULL);
15239 
15240 	if (DEVI_IS_DEVICE_REMOVED(tdip))
15241 		return (B_TRUE);
15242 	else
15243 		return (B_FALSE);
15244 }
15245