xref: /titanic_51/usr/src/uts/common/io/sata/impl/sata.c (revision b423da26b867ead68b8fda8497cf4e5bb7ed1631)
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 2007 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  * NOTE: THIS VERSION DOES NOT SUPPORT ATAPI DEVICES,
34  * although there is some code related to these devices.
35  *
36  */
37 #include <sys/conf.h>
38 #include <sys/file.h>
39 #include <sys/ddi.h>
40 #include <sys/sunddi.h>
41 #include <sys/modctl.h>
42 #include <sys/cmn_err.h>
43 #include <sys/errno.h>
44 #include <sys/thread.h>
45 #include <sys/kstat.h>
46 #include <sys/note.h>
47 #include <sys/sysevent.h>
48 #include <sys/sysevent/eventdefs.h>
49 #include <sys/sysevent/dr.h>
50 #include <sys/taskq.h>
51 
52 #include <sys/sata/impl/sata.h>
53 #include <sys/sata/sata_hba.h>
54 #include <sys/sata/sata_defs.h>
55 #include <sys/sata/sata_cfgadm.h>
56 
57 
58 /* Debug flags - defined in sata.h */
59 int	sata_debug_flags = 0;
60 /*
61  * Flags enabling selected SATA HBA framework functionality
62  */
63 #define	SATA_ENABLE_QUEUING		1
64 #define	SATA_ENABLE_NCQ			2
65 #define	SATA_ENABLE_PROCESS_EVENTS	4
66 int sata_func_enable =
67 	SATA_ENABLE_PROCESS_EVENTS | SATA_ENABLE_QUEUING | SATA_ENABLE_NCQ;
68 
69 #ifdef SATA_DEBUG
70 #define	SATA_LOG_D(args)	sata_log args
71 uint64_t mbuf_count = 0;
72 uint64_t mbuffail_count = 0;
73 #else
74 #define	SATA_LOG_D(arg)
75 #endif
76 
77 
78 /*
79  * SATA cb_ops functions
80  */
81 static 	int sata_hba_open(dev_t *, int, int, cred_t *);
82 static 	int sata_hba_close(dev_t, int, int, cred_t *);
83 static 	int sata_hba_ioctl(dev_t, int, intptr_t, int, cred_t *,	int *);
84 
85 /*
86  * SCSA required entry points
87  */
88 static	int sata_scsi_tgt_init(dev_info_t *, dev_info_t *,
89     scsi_hba_tran_t *, struct scsi_device *);
90 static	int sata_scsi_tgt_probe(struct scsi_device *,
91     int (*callback)(void));
92 static void sata_scsi_tgt_free(dev_info_t *, dev_info_t *,
93     scsi_hba_tran_t *, struct scsi_device *);
94 static 	int sata_scsi_start(struct scsi_address *, struct scsi_pkt *);
95 static 	int sata_scsi_abort(struct scsi_address *, struct scsi_pkt *);
96 static 	int sata_scsi_reset(struct scsi_address *, int);
97 static 	int sata_scsi_getcap(struct scsi_address *, char *, int);
98 static 	int sata_scsi_setcap(struct scsi_address *, char *, int, int);
99 static 	struct scsi_pkt *sata_scsi_init_pkt(struct scsi_address *,
100     struct scsi_pkt *, struct buf *, int, int, int, int, int (*)(caddr_t),
101     caddr_t);
102 static 	void sata_scsi_destroy_pkt(struct scsi_address *, struct scsi_pkt *);
103 static 	void sata_scsi_dmafree(struct scsi_address *, struct scsi_pkt *);
104 static 	void sata_scsi_sync_pkt(struct scsi_address *, struct scsi_pkt *);
105 
106 
107 /*
108  * Local functions
109  */
110 static 	void sata_remove_hba_instance(dev_info_t *);
111 static 	int sata_validate_sata_hba_tran(dev_info_t *, sata_hba_tran_t *);
112 static 	void sata_probe_ports(sata_hba_inst_t *);
113 static 	int sata_reprobe_port(sata_hba_inst_t *, sata_device_t *, int);
114 static 	int sata_add_device(dev_info_t *, sata_hba_inst_t *, int cport,
115     int pmport);
116 static 	dev_info_t *sata_create_target_node(dev_info_t *, sata_hba_inst_t *,
117     sata_address_t *);
118 static 	int sata_validate_scsi_address(sata_hba_inst_t *,
119     struct scsi_address *, sata_device_t *);
120 static 	int sata_validate_sata_address(sata_hba_inst_t *, int, int, int);
121 static	sata_pkt_t *sata_pkt_alloc(sata_pkt_txlate_t *, int (*)(caddr_t));
122 static	void sata_pkt_free(sata_pkt_txlate_t *);
123 static	int sata_dma_buf_setup(sata_pkt_txlate_t *, int, int (*)(caddr_t),
124     caddr_t, ddi_dma_attr_t *);
125 static	int sata_probe_device(sata_hba_inst_t *, sata_device_t *);
126 static	sata_drive_info_t *sata_get_device_info(sata_hba_inst_t *,
127     sata_device_t *);
128 static 	int sata_identify_device(sata_hba_inst_t *, sata_drive_info_t *);
129 static	struct buf *sata_alloc_local_buffer(sata_pkt_txlate_t *, int);
130 static 	void sata_free_local_buffer(sata_pkt_txlate_t *);
131 static 	uint64_t sata_check_capacity(sata_drive_info_t *);
132 void 	sata_adjust_dma_attr(sata_drive_info_t *, ddi_dma_attr_t *,
133     ddi_dma_attr_t *);
134 static 	int sata_fetch_device_identify_data(sata_hba_inst_t *,
135     sata_drive_info_t *);
136 static	void sata_update_port_info(sata_hba_inst_t *, sata_device_t *);
137 static	void sata_update_port_scr(sata_port_scr_t *, sata_device_t *);
138 static	int sata_set_udma_mode(sata_hba_inst_t *, sata_drive_info_t *);
139 static	int sata_set_cache_mode(sata_hba_inst_t *, sata_drive_info_t *, int);
140 static	int sata_set_drive_features(sata_hba_inst_t *,
141     sata_drive_info_t *, int flag);
142 static	void sata_init_write_cache_mode(sata_drive_info_t *sdinfo);
143 static	int sata_initialize_device(sata_hba_inst_t *, sata_drive_info_t *);
144 
145 /* Event processing functions */
146 static	void sata_event_daemon(void *);
147 static	void sata_event_thread_control(int);
148 static	void sata_process_controller_events(sata_hba_inst_t *sata_hba_inst);
149 static	void sata_process_device_reset(sata_hba_inst_t *, sata_address_t *);
150 static	void sata_process_port_failed_event(sata_hba_inst_t *,
151     sata_address_t *);
152 static	void sata_process_port_link_events(sata_hba_inst_t *,
153     sata_address_t *);
154 static	void sata_process_device_detached(sata_hba_inst_t *, sata_address_t *);
155 static	void sata_process_device_attached(sata_hba_inst_t *, sata_address_t *);
156 static	void sata_process_port_pwr_change(sata_hba_inst_t *, sata_address_t *);
157 static	void sata_process_cntrl_pwr_level_change(sata_hba_inst_t *);
158 static	void sata_process_target_node_cleanup(sata_hba_inst_t *,
159     sata_address_t *);
160 
161 /* Local functions for ioctl */
162 static	int32_t sata_get_port_num(sata_hba_inst_t *,  struct devctl_iocdata *);
163 static	void sata_cfgadm_state(sata_hba_inst_t *, int32_t,
164     devctl_ap_state_t *);
165 static	dev_info_t *sata_get_target_dip(dev_info_t *, int32_t);
166 static	dev_info_t *sata_devt_to_devinfo(dev_t);
167 
168 /* Local translation functions */
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_atapi(sata_pkt_txlate_t *);
177 static 	int sata_txlt_log_sense(sata_pkt_txlate_t *);
178 static 	int sata_txlt_log_select(sata_pkt_txlate_t *);
179 static 	int sata_txlt_mode_sense(sata_pkt_txlate_t *);
180 static 	int sata_txlt_mode_select(sata_pkt_txlate_t *);
181 static 	int sata_txlt_synchronize_cache(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_atapi_completion(sata_pkt_t *);
189 static 	void sata_txlt_nodata_cmd_completion(sata_pkt_t *);
190 static 	int sata_emul_rw_completion(sata_pkt_txlate_t *);
191 
192 static 	struct scsi_extended_sense *sata_immediate_error_response(
193     sata_pkt_txlate_t *, int);
194 static	struct scsi_extended_sense *sata_arq_sense(sata_pkt_txlate_t *);
195 
196 /* Local functions */
197 static	void sata_identdev_to_inquiry(sata_hba_inst_t *, sata_drive_info_t *,
198     uint8_t *);
199 static	int sata_build_msense_page_1(sata_drive_info_t *, int, uint8_t *);
200 static	int sata_build_msense_page_8(sata_drive_info_t *, int, uint8_t *);
201 static	int sata_build_msense_page_1a(sata_drive_info_t *, int, uint8_t *);
202 static	int sata_build_msense_page_1c(sata_drive_info_t *, int, uint8_t *);
203 static	int sata_mode_select_page_8(sata_pkt_txlate_t *,
204     struct mode_cache_scsi3 *, int, int *, int *, int *);
205 static	int sata_mode_select_page_1c(sata_pkt_txlate_t *,
206     struct mode_info_excpt_page *, int, int *, int *, int *);
207 static	int sata_build_lsense_page_0(sata_drive_info_t *, uint8_t *);
208 static	int sata_build_lsense_page_10(sata_drive_info_t *, uint8_t *,
209     sata_hba_inst_t *);
210 static	int sata_build_lsense_page_2f(sata_drive_info_t *, uint8_t *,
211     sata_hba_inst_t *);
212 static	int sata_build_lsense_page_30(sata_drive_info_t *, uint8_t *,
213     sata_hba_inst_t *);
214 static	void sata_save_drive_settings(sata_drive_info_t *);
215 static	void sata_show_drive_info(sata_hba_inst_t *, sata_drive_info_t *);
216 static	void sata_log(sata_hba_inst_t *, uint_t, char *fmt, ...);
217 static	int sata_fetch_smart_return_status(sata_hba_inst_t *,
218     sata_drive_info_t *);
219 static	int sata_fetch_smart_data(sata_hba_inst_t *, sata_drive_info_t *,
220     struct smart_data *);
221 static	int sata_smart_selftest_log(sata_hba_inst_t *,
222     sata_drive_info_t *,
223     struct smart_selftest_log *);
224 static	int sata_ext_smart_selftest_read_log(sata_hba_inst_t *,
225     sata_drive_info_t *, struct smart_ext_selftest_log *, uint16_t);
226 static	int sata_smart_read_log(sata_hba_inst_t *, sata_drive_info_t *,
227     uint8_t *, uint8_t, uint8_t);
228 static	int sata_read_log_ext_directory(sata_hba_inst_t *, sata_drive_info_t *,
229     struct read_log_ext_directory *);
230 static	void sata_gen_sysevent(sata_hba_inst_t *, sata_address_t *, int);
231 static	void sata_xlate_errors(sata_pkt_txlate_t *);
232 static	void sata_set_device_removed(dev_info_t *);
233 static	boolean_t sata_check_device_removed(dev_info_t *);
234 static	void sata_set_target_node_cleanup(sata_hba_inst_t *, int cport);
235 
236 
237 /*
238  * SATA Framework will ignore SATA HBA driver cb_ops structure and
239  * register following one with SCSA framework.
240  * Open & close are provided, so scsi framework will not use its own
241  */
242 static struct cb_ops sata_cb_ops = {
243 	sata_hba_open,			/* open */
244 	sata_hba_close,			/* close */
245 	nodev,				/* strategy */
246 	nodev,				/* print */
247 	nodev,				/* dump */
248 	nodev,				/* read */
249 	nodev,				/* write */
250 	sata_hba_ioctl,			/* ioctl */
251 	nodev,				/* devmap */
252 	nodev,				/* mmap */
253 	nodev,				/* segmap */
254 	nochpoll,			/* chpoll */
255 	ddi_prop_op,			/* cb_prop_op */
256 	0,				/* streamtab */
257 	D_NEW | D_MP,			/* cb_flag */
258 	CB_REV,				/* rev */
259 	nodev,				/* aread */
260 	nodev				/* awrite */
261 };
262 
263 
264 extern struct mod_ops mod_miscops;
265 extern uchar_t	scsi_cdb_size[];
266 
267 static struct modlmisc modlmisc = {
268 	&mod_miscops,			/* Type of module */
269 	"SATA Module v%I%"		/* module name */
270 };
271 
272 
273 static struct modlinkage modlinkage = {
274 	MODREV_1,
275 	(void *)&modlmisc,
276 	NULL
277 };
278 
279 /*
280  * Default sata pkt timeout. Used when a target driver scsi_pkt time is zero,
281  * i.e. when scsi_pkt has not timeout specified.
282  */
283 static int sata_default_pkt_time = 60;	/* 60 seconds */
284 
285 /*
286  * Intermediate buffer device access attributes - they are required,
287  * but not necessarily used.
288  */
289 static ddi_device_acc_attr_t sata_acc_attr = {
290 	DDI_DEVICE_ATTR_V0,
291 	DDI_STRUCTURE_LE_ACC,
292 	DDI_STRICTORDER_ACC
293 };
294 
295 
296 /*
297  * Mutexes protecting structures in multithreaded operations.
298  * Because events are relatively rare, a single global mutex protecting
299  * data structures should be sufficient. To increase performance, add
300  * separate mutex per each sata port and use global mutex only to protect
301  * common data structures.
302  */
303 static	kmutex_t sata_mutex;		/* protects sata_hba_list */
304 static	kmutex_t sata_log_mutex;	/* protects log */
305 
306 static 	char sata_log_buf[256];
307 
308 /* Default write cache setting */
309 int sata_write_cache = 1;
310 
311 /*
312  * Linked list of HBA instances
313  */
314 static 	sata_hba_inst_t *sata_hba_list = NULL;
315 static 	sata_hba_inst_t *sata_hba_list_tail = NULL;
316 /*
317  * Pointer to per-instance SATA HBA soft structure is stored in sata_hba_tran
318  * structure and in sata soft state.
319  */
320 
321 /*
322  * Event daemon related variables
323  */
324 static 	kmutex_t sata_event_mutex;
325 static 	kcondvar_t sata_event_cv;
326 static 	kthread_t *sata_event_thread = NULL;
327 static 	int sata_event_thread_terminate = 0;
328 static 	int sata_event_pending = 0;
329 static 	int sata_event_thread_active = 0;
330 extern 	pri_t minclsyspri;
331 
332 /*
333  * NCQ specific data
334  */
335 static const sata_cmd_t sata_rle_cmd = {
336 	SATA_CMD_REV,
337 	NULL,
338 	{
339 		SATA_DIR_READ
340 	},
341 	ATA_ADDR_LBA48,
342 	0,
343 	0,
344 	0,
345 	0,
346 	0,
347 	1,
348 	READ_LOG_EXT_NCQ_ERROR_RECOVERY,
349 	0,
350 	0,
351 	0,
352 	SATAC_READ_LOG_EXT,
353 	0,
354 	0,
355 	0,
356 };
357 
358 /* Warlock directives */
359 
360 _NOTE(SCHEME_PROTECTS_DATA("No Mutex Needed", scsi_hba_tran))
361 _NOTE(SCHEME_PROTECTS_DATA("No Mutex Needed", scsi_device))
362 _NOTE(SCHEME_PROTECTS_DATA("No Mutex Needed", dev_ops))
363 _NOTE(SCHEME_PROTECTS_DATA("No Mutex Needed", scsi_extended_sense))
364 _NOTE(SCHEME_PROTECTS_DATA("No Mutex Needed", scsi_arq_status))
365 _NOTE(SCHEME_PROTECTS_DATA("No Mutex Needed", ddi_dma_attr))
366 _NOTE(SCHEME_PROTECTS_DATA("No Mutex Needed", ddi_dma_cookie_t))
367 _NOTE(SCHEME_PROTECTS_DATA("No Mutex Needed", devctl_ap_state))
368 _NOTE(MUTEX_PROTECTS_DATA(sata_mutex, sata_hba_list))
369 _NOTE(DATA_READABLE_WITHOUT_LOCK(sata_hba_list))
370 _NOTE(MUTEX_PROTECTS_DATA(sata_mutex, sata_hba_inst::satahba_next))
371 _NOTE(MUTEX_PROTECTS_DATA(sata_mutex, sata_hba_inst::satahba_prev))
372 _NOTE(SCHEME_PROTECTS_DATA("No Mutex Needed", \
373     sata_hba_inst::satahba_scsi_tran))
374 _NOTE(SCHEME_PROTECTS_DATA("No Mutex Needed", sata_hba_inst::satahba_tran))
375 _NOTE(SCHEME_PROTECTS_DATA("No Mutex Needed", sata_hba_inst::satahba_dip))
376 _NOTE(SCHEME_PROTECTS_DATA("Scheme", sata_hba_inst::satahba_attached))
377 _NOTE(DATA_READABLE_WITHOUT_LOCK(sata_hba_inst::satahba_dev_port))
378 _NOTE(MUTEX_PROTECTS_DATA(sata_hba_inst::satahba_mutex,
379     sata_hba_inst::satahba_event_flags))
380 _NOTE(MUTEX_PROTECTS_DATA(sata_cport_info::cport_mutex, \
381     sata_cport_info::cport_devp))
382 _NOTE(DATA_READABLE_WITHOUT_LOCK(sata_cport_info::cport_devp))
383 _NOTE(SCHEME_PROTECTS_DATA("Scheme", sata_cport_info::cport_addr))
384 _NOTE(MUTEX_PROTECTS_DATA(sata_cport_info::cport_mutex, \
385     sata_cport_info::cport_dev_type))
386 _NOTE(DATA_READABLE_WITHOUT_LOCK(sata_cport_info::cport_dev_type))
387 _NOTE(MUTEX_PROTECTS_DATA(sata_cport_info::cport_mutex, \
388     sata_cport_info::cport_state))
389 _NOTE(DATA_READABLE_WITHOUT_LOCK(sata_cport_info::cport_state))
390 _NOTE(DATA_READABLE_WITHOUT_LOCK(sata_pmport_info::pmport_dev_type))
391 _NOTE(DATA_READABLE_WITHOUT_LOCK(sata_pmport_info::pmport_sata_drive))
392 _NOTE(DATA_READABLE_WITHOUT_LOCK(sata_pmult_info::pmult_dev_port))
393 _NOTE(DATA_READABLE_WITHOUT_LOCK(sata_pmult_info::pmult_num_dev_ports))
394 #ifdef SATA_DEBUG
395 _NOTE(SCHEME_PROTECTS_DATA("No Mutex Needed", mbuf_count))
396 _NOTE(SCHEME_PROTECTS_DATA("No Mutex Needed", mbuffail_count))
397 #endif
398 
399 /* End of warlock directives */
400 
401 /* ************** loadable module configuration functions ************** */
402 
403 int
404 _init()
405 {
406 	int rval;
407 
408 	mutex_init(&sata_mutex, NULL, MUTEX_DRIVER, NULL);
409 	mutex_init(&sata_event_mutex, NULL, MUTEX_DRIVER, NULL);
410 	mutex_init(&sata_log_mutex, NULL, MUTEX_DRIVER, NULL);
411 	cv_init(&sata_event_cv, NULL, CV_DRIVER, NULL);
412 	if ((rval = mod_install(&modlinkage)) != 0) {
413 #ifdef SATA_DEBUG
414 		cmn_err(CE_WARN, "sata: _init: mod_install failed\n");
415 #endif
416 		mutex_destroy(&sata_log_mutex);
417 		cv_destroy(&sata_event_cv);
418 		mutex_destroy(&sata_event_mutex);
419 		mutex_destroy(&sata_mutex);
420 	}
421 	return (rval);
422 }
423 
424 int
425 _fini()
426 {
427 	int rval;
428 
429 	if ((rval = mod_remove(&modlinkage)) != 0)
430 		return (rval);
431 
432 	mutex_destroy(&sata_log_mutex);
433 	cv_destroy(&sata_event_cv);
434 	mutex_destroy(&sata_event_mutex);
435 	mutex_destroy(&sata_mutex);
436 	return (rval);
437 }
438 
439 int
440 _info(struct modinfo *modinfop)
441 {
442 	return (mod_info(&modlinkage, modinfop));
443 }
444 
445 
446 
447 /* ********************* SATA HBA entry points ********************* */
448 
449 
450 /*
451  * Called by SATA HBA from _init().
452  * Registers HBA driver instance/sata framework pair with scsi framework, by
453  * calling scsi_hba_init().
454  *
455  * SATA HBA driver cb_ops are ignored - SATA HBA framework cb_ops are used
456  * instead. SATA HBA framework cb_ops pointer overwrites SATA HBA driver
457  * cb_ops pointer in SATA HBA driver dev_ops structure.
458  * SATA HBA framework cb_ops supplies cb_open cb_close and cb_ioctl vectors.
459  *
460  * Return status of the scsi_hba_init() is returned to a calling SATA HBA
461  * driver.
462  */
463 int
464 sata_hba_init(struct modlinkage *modlp)
465 {
466 	int rval;
467 	struct dev_ops *hba_ops;
468 
469 	SATADBG1(SATA_DBG_HBA_IF, NULL,
470 	    "sata_hba_init: name %s \n",
471 	    ((struct modldrv *)(modlp->ml_linkage[0]))->drv_linkinfo);
472 	/*
473 	 * Fill-up cb_ops and dev_ops when necessary
474 	 */
475 	hba_ops = ((struct modldrv *)(modlp->ml_linkage[0]))->drv_dev_ops;
476 	/*
477 	 * Provide pointer to SATA dev_ops
478 	 */
479 	hba_ops->devo_cb_ops = &sata_cb_ops;
480 
481 	/*
482 	 * Register SATA HBA with SCSI framework
483 	 */
484 	if ((rval = scsi_hba_init(modlp)) != 0) {
485 		SATADBG1(SATA_DBG_HBA_IF, NULL,
486 		    "sata_hba_init: scsi hba init failed\n", NULL);
487 		return (rval);
488 	}
489 
490 	return (0);
491 }
492 
493 
494 /* HBA attach stages */
495 #define	HBA_ATTACH_STAGE_SATA_HBA_INST	1
496 #define	HBA_ATTACH_STAGE_SCSI_ATTACHED	2
497 #define	HBA_ATTACH_STAGE_SETUP		4
498 #define	HBA_ATTACH_STAGE_LINKED		8
499 
500 
501 /*
502  *
503  * Called from SATA HBA driver's attach routine to attach an instance of
504  * the HBA.
505  *
506  * For DDI_ATTACH command:
507  * sata_hba_inst structure is allocated here and initialized with pointers to
508  * SATA framework implementation of required scsi tran functions.
509  * The scsi_tran's tran_hba_private field is used by SATA Framework to point
510  * to the soft structure (sata_hba_inst) allocated by SATA framework for
511  * SATA HBA instance related data.
512  * The scsi_tran's tran_hba_private field is used by SATA framework to
513  * store a pointer to per-HBA-instance of sata_hba_inst structure.
514  * The sata_hba_inst structure is cross-linked to scsi tran structure.
515  * Among other info, a pointer to sata_hba_tran structure is stored in
516  * sata_hba_inst. The sata_hba_inst structures for different HBA instances are
517  * linked together into the list, pointed to by sata_hba_list.
518  * On the first HBA instance attach the sata event thread is initialized.
519  * Attachment points are created for all SATA ports of the HBA being attached.
520  * All HBA instance's SATA ports are probed and type of plugged devices is
521  * determined. For each device of a supported type, a target node is created.
522  *
523  * DDI_SUCCESS is returned when attachment process is successful,
524  * DDI_FAILURE is returned otherwise.
525  *
526  * For DDI_RESUME command:
527  * Not implemented at this time (postponed until phase 2 of the development).
528  */
529 int
530 sata_hba_attach(dev_info_t *dip, sata_hba_tran_t *sata_tran,
531     ddi_attach_cmd_t cmd)
532 {
533 	sata_hba_inst_t	*sata_hba_inst;
534 	scsi_hba_tran_t *scsi_tran = NULL;
535 	int hba_attach_state = 0;
536 	char taskq_name[MAXPATHLEN];
537 
538 	SATADBG3(SATA_DBG_HBA_IF, NULL,
539 	    "sata_hba_attach: node %s (%s%d)\n",
540 	    ddi_node_name(dip), ddi_driver_name(dip),
541 	    ddi_get_instance(dip));
542 
543 	if (cmd == DDI_RESUME) {
544 		/*
545 		 * Postponed until phase 2 of the development
546 		 */
547 		return (DDI_FAILURE);
548 	}
549 
550 	if (cmd != DDI_ATTACH) {
551 		return (DDI_FAILURE);
552 	}
553 
554 	/* cmd == DDI_ATTACH */
555 
556 	if (sata_validate_sata_hba_tran(dip, sata_tran) != SATA_SUCCESS) {
557 		SATA_LOG_D((NULL, CE_WARN,
558 		    "sata_hba_attach: invalid sata_hba_tran"));
559 		return (DDI_FAILURE);
560 	}
561 	/*
562 	 * Allocate and initialize SCSI tran structure.
563 	 * SATA copy of tran_bus_config is provided to create port nodes.
564 	 */
565 	scsi_tran = scsi_hba_tran_alloc(dip, SCSI_HBA_CANSLEEP);
566 	if (scsi_tran == NULL)
567 		return (DDI_FAILURE);
568 	/*
569 	 * Allocate soft structure for SATA HBA instance.
570 	 * There is a separate softstate for each HBA instance.
571 	 */
572 	sata_hba_inst = kmem_zalloc(sizeof (struct sata_hba_inst), KM_SLEEP);
573 	ASSERT(sata_hba_inst != NULL); /* this should not fail */
574 	mutex_init(&sata_hba_inst->satahba_mutex, NULL, MUTEX_DRIVER, NULL);
575 	hba_attach_state |= HBA_ATTACH_STAGE_SATA_HBA_INST;
576 
577 	/*
578 	 * scsi_trans's tran_hba_private is used by SATA Framework to point to
579 	 * soft structure allocated by SATA framework for
580 	 * SATA HBA instance related data.
581 	 */
582 	scsi_tran->tran_hba_private	= sata_hba_inst;
583 	scsi_tran->tran_tgt_private	= NULL;
584 
585 	scsi_tran->tran_tgt_init	= sata_scsi_tgt_init;
586 	scsi_tran->tran_tgt_probe	= sata_scsi_tgt_probe;
587 	scsi_tran->tran_tgt_free	= sata_scsi_tgt_free;
588 
589 	scsi_tran->tran_start		= sata_scsi_start;
590 	scsi_tran->tran_reset		= sata_scsi_reset;
591 	scsi_tran->tran_abort		= sata_scsi_abort;
592 	scsi_tran->tran_getcap		= sata_scsi_getcap;
593 	scsi_tran->tran_setcap		= sata_scsi_setcap;
594 	scsi_tran->tran_init_pkt	= sata_scsi_init_pkt;
595 	scsi_tran->tran_destroy_pkt	= sata_scsi_destroy_pkt;
596 
597 	scsi_tran->tran_dmafree		= sata_scsi_dmafree;
598 	scsi_tran->tran_sync_pkt	= sata_scsi_sync_pkt;
599 
600 	scsi_tran->tran_reset_notify	= NULL;
601 	scsi_tran->tran_get_bus_addr	= NULL;
602 	scsi_tran->tran_quiesce		= NULL;
603 	scsi_tran->tran_unquiesce	= NULL;
604 	scsi_tran->tran_bus_reset	= NULL;
605 
606 	if (scsi_hba_attach_setup(dip, sata_tran->sata_tran_hba_dma_attr,
607 	    scsi_tran, 0) != DDI_SUCCESS) {
608 #ifdef SATA_DEBUG
609 		cmn_err(CE_WARN, "?SATA: %s%d hba scsi attach failed",
610 		    ddi_driver_name(dip), ddi_get_instance(dip));
611 #endif
612 		goto fail;
613 	}
614 	hba_attach_state |= HBA_ATTACH_STAGE_SCSI_ATTACHED;
615 
616 	if (!ddi_prop_exists(DDI_DEV_T_ANY, dip, DDI_PROP_DONTPASS, "sata")) {
617 		if (ddi_prop_update_int(DDI_DEV_T_NONE, dip,
618 		    "sata", 1) != DDI_PROP_SUCCESS) {
619 			SATA_LOG_D((NULL, CE_WARN, "sata_hba_attach: "
620 			    "failed to create hba sata prop"));
621 			goto fail;
622 		}
623 	}
624 
625 	/*
626 	 * Save pointers in hba instance soft state.
627 	 */
628 	sata_hba_inst->satahba_scsi_tran = scsi_tran;
629 	sata_hba_inst->satahba_tran = sata_tran;
630 	sata_hba_inst->satahba_dip = dip;
631 
632 	/*
633 	 * Create a task queue to handle emulated commands completion
634 	 * Use node name, dash, instance number as the queue name.
635 	 */
636 	taskq_name[0] = '\0';
637 	(void) strlcat(taskq_name, DEVI(dip)->devi_node_name,
638 	    sizeof (taskq_name));
639 	(void) snprintf(taskq_name + strlen(taskq_name),
640 	    sizeof (taskq_name) - strlen(taskq_name),
641 	    "-%d", DEVI(dip)->devi_instance);
642 	sata_hba_inst->satahba_taskq = taskq_create(taskq_name, 1,
643 	    minclsyspri, 1, sata_tran->sata_tran_hba_num_cports,
644 	    TASKQ_DYNAMIC);
645 
646 	hba_attach_state |= HBA_ATTACH_STAGE_SETUP;
647 
648 	/*
649 	 * Create events thread if not created yet.
650 	 */
651 	sata_event_thread_control(1);
652 
653 	/*
654 	 * Link this hba instance into the list.
655 	 */
656 	mutex_enter(&sata_mutex);
657 
658 
659 	sata_hba_inst->satahba_next = NULL;
660 	sata_hba_inst->satahba_prev = sata_hba_list_tail;
661 	if (sata_hba_list == NULL) {
662 		sata_hba_list = sata_hba_inst;
663 	}
664 	if (sata_hba_list_tail != NULL) {
665 		sata_hba_list_tail->satahba_next = sata_hba_inst;
666 	}
667 	sata_hba_list_tail = sata_hba_inst;
668 	mutex_exit(&sata_mutex);
669 	hba_attach_state |= HBA_ATTACH_STAGE_LINKED;
670 
671 	/*
672 	 * Create SATA HBA devctl minor node for sata_hba_open, close, ioctl
673 	 * SATA HBA driver should not use its own open/close entry points.
674 	 *
675 	 * Make sure that instance number doesn't overflow
676 	 * when forming minor numbers.
677 	 */
678 	ASSERT(ddi_get_instance(dip) <= (L_MAXMIN >> INST_MINOR_SHIFT));
679 	if (ddi_create_minor_node(dip, "devctl", S_IFCHR,
680 	    INST2DEVCTL(ddi_get_instance(dip)),
681 	    DDI_NT_SATA_NEXUS, 0) != DDI_SUCCESS) {
682 #ifdef SATA_DEBUG
683 		cmn_err(CE_WARN, "sata_hba_attach: "
684 		    "cannot create devctl minor node");
685 #endif
686 		goto fail;
687 	}
688 
689 
690 	/*
691 	 * Set-up kstats here, if necessary.
692 	 * (postponed until phase 2 of the development).
693 	 */
694 
695 
696 	/*
697 	 * Probe controller ports. This operation will describe a current
698 	 * controller/port/multipliers/device configuration and will create
699 	 * attachment points.
700 	 * We may end-up with just a controller with no devices attached.
701 	 * For the ports with a supported device attached, device target nodes
702 	 * are created and devices are initialized.
703 	 */
704 	sata_probe_ports(sata_hba_inst);
705 
706 	sata_hba_inst->satahba_attached = 1;
707 	return (DDI_SUCCESS);
708 
709 fail:
710 	if (hba_attach_state & HBA_ATTACH_STAGE_LINKED) {
711 		(void) sata_remove_hba_instance(dip);
712 		if (sata_hba_list == NULL)
713 			sata_event_thread_control(0);
714 	}
715 
716 	if (hba_attach_state & HBA_ATTACH_STAGE_SETUP) {
717 		(void) ddi_prop_remove(DDI_DEV_T_ANY, dip, "sata");
718 		taskq_destroy(sata_hba_inst->satahba_taskq);
719 	}
720 
721 	if (hba_attach_state & HBA_ATTACH_STAGE_SCSI_ATTACHED)
722 		(void) scsi_hba_detach(dip);
723 
724 	if (hba_attach_state & HBA_ATTACH_STAGE_SATA_HBA_INST) {
725 		mutex_destroy(&sata_hba_inst->satahba_mutex);
726 		kmem_free((void *)sata_hba_inst,
727 		    sizeof (struct sata_hba_inst));
728 		scsi_hba_tran_free(scsi_tran);
729 	}
730 
731 	sata_log(NULL, CE_WARN, "?SATA: %s%d hba attach failed",
732 	    ddi_driver_name(dip), ddi_get_instance(dip));
733 
734 	return (DDI_FAILURE);
735 }
736 
737 
738 /*
739  * Called by SATA HBA from to detach an instance of the driver.
740  *
741  * For DDI_DETACH command:
742  * Free local structures allocated for SATA HBA instance during
743  * sata_hba_attach processing.
744  *
745  * Returns DDI_SUCCESS when HBA was detached, DDI_FAILURE otherwise.
746  *
747  * For DDI_SUSPEND command:
748  * Not implemented at this time (postponed until phase 2 of the development)
749  * Returnd DDI_SUCCESS.
750  *
751  * When the last HBA instance is detached, the event daemon is terminated.
752  *
753  * NOTE: cport support only, no port multiplier support.
754  */
755 int
756 sata_hba_detach(dev_info_t *dip, ddi_detach_cmd_t cmd)
757 {
758 	dev_info_t	*tdip;
759 	sata_hba_inst_t	*sata_hba_inst;
760 	scsi_hba_tran_t *scsi_hba_tran;
761 	sata_cport_info_t *cportinfo;
762 	sata_drive_info_t *sdinfo;
763 	int ncport;
764 
765 	SATADBG3(SATA_DBG_HBA_IF, NULL, "sata_hba_detach: node %s (%s%d)\n",
766 	    ddi_node_name(dip), ddi_driver_name(dip), ddi_get_instance(dip));
767 
768 	switch (cmd) {
769 	case DDI_DETACH:
770 
771 		if ((scsi_hba_tran = ddi_get_driver_private(dip)) == NULL)
772 			return (DDI_FAILURE);
773 
774 		sata_hba_inst = scsi_hba_tran->tran_hba_private;
775 		if (sata_hba_inst == NULL)
776 			return (DDI_FAILURE);
777 
778 		if (scsi_hba_detach(dip) == DDI_FAILURE) {
779 			sata_hba_inst->satahba_attached = 1;
780 			return (DDI_FAILURE);
781 		}
782 
783 		/*
784 		 * Free all target nodes - at this point
785 		 * devices should be at least offlined
786 		 * otherwise scsi_hba_detach() should not be called.
787 		 */
788 		for (ncport = 0; ncport < SATA_NUM_CPORTS(sata_hba_inst);
789 		    ncport++) {
790 			cportinfo = SATA_CPORT_INFO(sata_hba_inst, ncport);
791 			if (cportinfo->cport_dev_type != SATA_DTYPE_PMULT) {
792 				sdinfo = SATA_CPORTINFO_DRV_INFO(cportinfo);
793 				if (sdinfo != NULL) {
794 					tdip = sata_get_target_dip(dip,
795 					    ncport);
796 					if (tdip != NULL) {
797 						if (ndi_devi_offline(tdip,
798 						    NDI_DEVI_REMOVE) !=
799 						    NDI_SUCCESS) {
800 							SATA_LOG_D((
801 							    sata_hba_inst,
802 							    CE_WARN,
803 							    "sata_hba_detach: "
804 							    "Target node not "
805 							    "removed !"));
806 							return (DDI_FAILURE);
807 						}
808 					}
809 				}
810 			}
811 		}
812 		/*
813 		 * Disable sata event daemon processing for this HBA
814 		 */
815 		sata_hba_inst->satahba_attached = 0;
816 
817 		/*
818 		 * Remove event daemon thread, if it is last HBA instance.
819 		 */
820 
821 		mutex_enter(&sata_mutex);
822 		if (sata_hba_list->satahba_next == NULL) {
823 			mutex_exit(&sata_mutex);
824 			sata_event_thread_control(0);
825 			mutex_enter(&sata_mutex);
826 		}
827 		mutex_exit(&sata_mutex);
828 
829 		/* Remove this HBA instance from the HBA list */
830 		sata_remove_hba_instance(dip);
831 
832 		/*
833 		 * At this point there should be no target nodes attached.
834 		 * Detach and destroy device and port info structures.
835 		 */
836 		for (ncport = 0; ncport < SATA_NUM_CPORTS(sata_hba_inst);
837 		    ncport++) {
838 			cportinfo = SATA_CPORT_INFO(sata_hba_inst, ncport);
839 			if (cportinfo->cport_dev_type != SATA_DTYPE_PMULT) {
840 				sdinfo =
841 				    cportinfo->cport_devp.cport_sata_drive;
842 				if (sdinfo != NULL) {
843 					/* Release device structure */
844 					kmem_free(sdinfo,
845 					    sizeof (sata_drive_info_t));
846 				}
847 				/* Release cport info */
848 				mutex_destroy(&cportinfo->cport_mutex);
849 				kmem_free(cportinfo,
850 				    sizeof (sata_cport_info_t));
851 			}
852 		}
853 
854 		scsi_hba_tran_free(sata_hba_inst->satahba_scsi_tran);
855 
856 		(void) ddi_prop_remove(DDI_DEV_T_ANY, dip, "sata");
857 
858 		taskq_destroy(sata_hba_inst->satahba_taskq);
859 
860 		mutex_destroy(&sata_hba_inst->satahba_mutex);
861 		kmem_free((void *)sata_hba_inst,
862 		    sizeof (struct sata_hba_inst));
863 
864 		return (DDI_SUCCESS);
865 
866 	case DDI_SUSPEND:
867 		/*
868 		 * Postponed until phase 2
869 		 */
870 		return (DDI_FAILURE);
871 
872 	default:
873 		return (DDI_FAILURE);
874 	}
875 }
876 
877 
878 /*
879  * Called by an HBA drive from _fini() routine.
880  * Unregisters SATA HBA instance/SATA framework pair from the scsi framework.
881  */
882 void
883 sata_hba_fini(struct modlinkage *modlp)
884 {
885 	SATADBG1(SATA_DBG_HBA_IF, NULL,
886 	    "sata_hba_fini: name %s\n",
887 	    ((struct modldrv *)(modlp->ml_linkage[0]))->drv_linkinfo);
888 
889 	scsi_hba_fini(modlp);
890 }
891 
892 
893 /*
894  * Default open and close routine for sata_hba framework.
895  *
896  */
897 /*
898  * Open devctl node.
899  *
900  * Returns:
901  * 0 if node was open successfully, error code otherwise.
902  *
903  *
904  */
905 
906 static int
907 sata_hba_open(dev_t *devp, int flags, int otyp, cred_t *credp)
908 {
909 #ifndef __lock_lint
910 	_NOTE(ARGUNUSED(credp))
911 #endif
912 	int rv = 0;
913 	dev_info_t *dip;
914 	scsi_hba_tran_t *scsi_hba_tran;
915 	sata_hba_inst_t	*sata_hba_inst;
916 
917 	SATADBG1(SATA_DBG_IOCTL_IF, NULL, "sata_hba_open: entered", NULL);
918 
919 	if (otyp != OTYP_CHR)
920 		return (EINVAL);
921 
922 	dip = sata_devt_to_devinfo(*devp);
923 	if (dip == NULL)
924 		return (ENXIO);
925 
926 	if ((scsi_hba_tran = ddi_get_driver_private(dip)) == NULL)
927 		return (ENXIO);
928 
929 	sata_hba_inst = scsi_hba_tran->tran_hba_private;
930 	if (sata_hba_inst == NULL || sata_hba_inst->satahba_attached == 0)
931 		return (ENXIO);
932 
933 	mutex_enter(&sata_mutex);
934 	if (flags & FEXCL) {
935 		if (sata_hba_inst->satahba_open_flag != 0) {
936 			rv = EBUSY;
937 		} else {
938 			sata_hba_inst->satahba_open_flag =
939 			    SATA_DEVCTL_EXOPENED;
940 		}
941 	} else {
942 		if (sata_hba_inst->satahba_open_flag == SATA_DEVCTL_EXOPENED) {
943 			rv = EBUSY;
944 		} else {
945 			sata_hba_inst->satahba_open_flag =
946 			    SATA_DEVCTL_SOPENED;
947 		}
948 	}
949 	mutex_exit(&sata_mutex);
950 
951 	return (rv);
952 }
953 
954 
955 /*
956  * Close devctl node.
957  * Returns:
958  * 0 if node was closed successfully, error code otherwise.
959  *
960  */
961 
962 static int
963 sata_hba_close(dev_t dev, int flag, int otyp, cred_t *credp)
964 {
965 #ifndef __lock_lint
966 	_NOTE(ARGUNUSED(credp))
967 	_NOTE(ARGUNUSED(flag))
968 #endif
969 	dev_info_t *dip;
970 	scsi_hba_tran_t *scsi_hba_tran;
971 	sata_hba_inst_t	*sata_hba_inst;
972 
973 	SATADBG1(SATA_DBG_IOCTL_IF, NULL, "sata_hba_close: entered", NULL);
974 
975 	if (otyp != OTYP_CHR)
976 		return (EINVAL);
977 
978 	dip = sata_devt_to_devinfo(dev);
979 	if (dip == NULL)
980 		return (ENXIO);
981 
982 	if ((scsi_hba_tran = ddi_get_driver_private(dip)) == NULL)
983 		return (ENXIO);
984 
985 	sata_hba_inst = scsi_hba_tran->tran_hba_private;
986 	if (sata_hba_inst == NULL || sata_hba_inst->satahba_attached == 0)
987 		return (ENXIO);
988 
989 	mutex_enter(&sata_mutex);
990 	sata_hba_inst->satahba_open_flag = 0;
991 	mutex_exit(&sata_mutex);
992 	return (0);
993 }
994 
995 
996 
997 /*
998  * Standard IOCTL commands for SATA hotplugging.
999  * Implemented DEVCTL_AP commands:
1000  * DEVCTL_AP_CONNECT
1001  * DEVCTL_AP_DISCONNECT
1002  * DEVCTL_AP_CONFIGURE
1003  * DEVCTL_UNCONFIGURE
1004  * DEVCTL_AP_CONTROL
1005  *
1006  * Commands passed to default ndi ioctl handler:
1007  * DEVCTL_DEVICE_GETSTATE
1008  * DEVCTL_DEVICE_ONLINE
1009  * DEVCTL_DEVICE_OFFLINE
1010  * DEVCTL_DEVICE_REMOVE
1011  * DEVCTL_DEVICE_INSERT
1012  * DEVCTL_BUS_GETSTATE
1013  *
1014  * All other cmds are passed to HBA if it provide ioctl handler, or failed
1015  * if not.
1016  *
1017  * Returns:
1018  * 0 if successful,
1019  * error code if operation failed.
1020  *
1021  * NOTE: Port Multiplier is not supported.
1022  *
1023  */
1024 
1025 static int
1026 sata_hba_ioctl(dev_t dev, int cmd, intptr_t arg, int mode, cred_t *credp,
1027     int *rvalp)
1028 {
1029 #ifndef __lock_lint
1030 	_NOTE(ARGUNUSED(credp))
1031 	_NOTE(ARGUNUSED(rvalp))
1032 #endif
1033 	int rv = 0;
1034 	int32_t	comp_port = -1;
1035 	dev_info_t *dip, *tdip;
1036 	devctl_ap_state_t ap_state;
1037 	struct devctl_iocdata *dcp = NULL;
1038 	scsi_hba_tran_t *scsi_hba_tran;
1039 	sata_hba_inst_t *sata_hba_inst;
1040 	sata_device_t sata_device;
1041 	sata_drive_info_t *sdinfo;
1042 	sata_cport_info_t *cportinfo;
1043 	int cport, pmport, qual;
1044 	int rval = SATA_SUCCESS;
1045 
1046 	dip = sata_devt_to_devinfo(dev);
1047 	if (dip == NULL)
1048 		return (ENXIO);
1049 
1050 	if ((scsi_hba_tran = ddi_get_driver_private(dip)) == NULL)
1051 		return (ENXIO);
1052 
1053 	sata_hba_inst = scsi_hba_tran->tran_hba_private;
1054 	if (sata_hba_inst == NULL)
1055 		return (ENXIO);
1056 
1057 	if (sata_hba_inst->satahba_tran == NULL)
1058 		return (ENXIO);
1059 
1060 	switch (cmd) {
1061 
1062 	case DEVCTL_DEVICE_GETSTATE:
1063 	case DEVCTL_DEVICE_ONLINE:
1064 	case DEVCTL_DEVICE_OFFLINE:
1065 	case DEVCTL_DEVICE_REMOVE:
1066 	case DEVCTL_BUS_GETSTATE:
1067 		/*
1068 		 * There may be more cases that we want to pass to default
1069 		 * handler rather then fail them.
1070 		 */
1071 		return (ndi_devctl_ioctl(dip, cmd, arg, mode, 0));
1072 	}
1073 
1074 	/* read devctl ioctl data */
1075 	if (cmd != DEVCTL_AP_CONTROL) {
1076 		if (ndi_dc_allochdl((void *)arg, &dcp) != NDI_SUCCESS)
1077 			return (EFAULT);
1078 
1079 		if ((comp_port = sata_get_port_num(sata_hba_inst, dcp)) ==
1080 		    -1) {
1081 			if (dcp)
1082 				ndi_dc_freehdl(dcp);
1083 			return (EINVAL);
1084 		}
1085 
1086 		cport = SCSI_TO_SATA_CPORT(comp_port);
1087 		pmport = SCSI_TO_SATA_PMPORT(comp_port);
1088 		/* Only cport is considered now, i.e. SATA_ADDR_CPORT */
1089 		qual = SATA_ADDR_CPORT;
1090 		if (sata_validate_sata_address(sata_hba_inst, cport, pmport,
1091 		    qual) != 0) {
1092 			ndi_dc_freehdl(dcp);
1093 			return (EINVAL);
1094 		}
1095 
1096 		cportinfo = SATA_CPORT_INFO(sata_hba_inst, cport);
1097 		mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, cport)->
1098 		    cport_mutex);
1099 		if (cportinfo->cport_event_flags & SATA_EVNT_LOCK_PORT_BUSY) {
1100 			/*
1101 			 * Cannot process ioctl request now. Come back later.
1102 			 */
1103 			mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)->
1104 			    cport_mutex);
1105 			ndi_dc_freehdl(dcp);
1106 			return (EBUSY);
1107 		}
1108 		/* Block event processing for this port */
1109 		cportinfo->cport_event_flags |= SATA_APCTL_LOCK_PORT_BUSY;
1110 		mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex);
1111 
1112 		sata_device.satadev_addr.cport = cport;
1113 		sata_device.satadev_addr.pmport = pmport;
1114 		sata_device.satadev_addr.qual = SATA_ADDR_CPORT;
1115 		sata_device.satadev_rev = SATA_DEVICE_REV;
1116 	}
1117 
1118 	switch (cmd) {
1119 
1120 	case DEVCTL_AP_DISCONNECT:
1121 		/*
1122 		 * Normally, cfgadm sata plugin will try to offline
1123 		 * (unconfigure) device before this request. Nevertheless,
1124 		 * if a device is still configured, we need to
1125 		 * attempt to offline and unconfigure device first, and we will
1126 		 * deactivate the port regardless of the unconfigure
1127 		 * operation results.
1128 		 *
1129 		 * DEVCTL_AP_DISCONNECT invokes
1130 		 * sata_hba_inst->satahba_tran->
1131 		 * sata_tran_hotplug_ops->sata_tran_port_deactivate().
1132 		 * If successful, the device structure (if any) attached
1133 		 * to a port is removed and state of the port marked
1134 		 * appropriately.
1135 		 * Failure of the port_deactivate may keep port in
1136 		 * the active state, or may fail the port.
1137 		 */
1138 
1139 		/* Check the current state of the port */
1140 		rval = (*SATA_PROBE_PORT_FUNC(sata_hba_inst))
1141 		    (dip, &sata_device);
1142 		mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, cport)->
1143 		    cport_mutex);
1144 		sata_update_port_info(sata_hba_inst, &sata_device);
1145 		if (rval != SATA_SUCCESS ||
1146 		    (sata_device.satadev_state & SATA_PSTATE_FAILED)) {
1147 			cportinfo->cport_state = SATA_PSTATE_FAILED;
1148 			mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)->
1149 			    cport_mutex);
1150 			rv = EIO;
1151 			break;
1152 		}
1153 		/* Sanity check */
1154 		if (SATA_PORT_DEACTIVATE_FUNC(sata_hba_inst) == NULL) {
1155 			mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)->
1156 			    cport_mutex);
1157 			/* No physical port deactivation supported. */
1158 			break;
1159 		}
1160 
1161 		/*
1162 		 * set port's dev_state to not ready - this will disable
1163 		 * an access to an attached device.
1164 		 */
1165 		cportinfo->cport_state &= ~SATA_STATE_READY;
1166 
1167 		if (cportinfo->cport_dev_type != SATA_DTYPE_NONE) {
1168 			sdinfo = cportinfo->cport_devp.cport_sata_drive;
1169 			ASSERT(sdinfo != NULL);
1170 			if ((sdinfo->satadrv_type &
1171 			    (SATA_VALID_DEV_TYPE))) {
1172 				/*
1173 				 * If a target node exists, try to offline
1174 				 * a device and remove target node.
1175 				 */
1176 				mutex_exit(&SATA_CPORT_INFO(sata_hba_inst,
1177 				    cport)->cport_mutex);
1178 				tdip = sata_get_target_dip(dip, comp_port);
1179 				if (tdip != NULL && ndi_devi_offline(tdip,
1180 				    NDI_DEVI_REMOVE) != NDI_SUCCESS) {
1181 					/*
1182 					 * Problem
1183 					 * A target node remained
1184 					 * attached. This happens when
1185 					 * the file was open or a node
1186 					 * was waiting for resources.
1187 					 * Cannot do anything about it.
1188 					 */
1189 					SATA_LOG_D((sata_hba_inst, CE_WARN,
1190 					    "sata_hba_ioctl: "
1191 					    "disconnect: could not "
1192 					    "unconfigure device before "
1193 					    "disconnecting the SATA "
1194 					    "port %d", cport));
1195 
1196 					/*
1197 					 * Set DEVICE REMOVED state
1198 					 * in the target node. It
1199 					 * will prevent access to
1200 					 * the device even when a
1201 					 * new device is attached,
1202 					 * until the old target node
1203 					 * is released, removed and
1204 					 * recreated for a new
1205 					 * device.
1206 					 */
1207 					sata_set_device_removed(tdip);
1208 					/*
1209 					 * Instruct event daemon to
1210 					 * try the target node cleanup
1211 					 * later.
1212 					 */
1213 					sata_set_target_node_cleanup(
1214 					    sata_hba_inst, cport);
1215 				}
1216 				mutex_enter(&SATA_CPORT_INFO(sata_hba_inst,
1217 				    cport)->cport_mutex);
1218 				/*
1219 				 * Remove and release sata_drive_info
1220 				 * structure.
1221 				 */
1222 				if (SATA_CPORTINFO_DRV_INFO(cportinfo) !=
1223 				    NULL) {
1224 					SATA_CPORTINFO_DRV_INFO(cportinfo) =
1225 					    NULL;
1226 					(void) kmem_free((void *)sdinfo,
1227 					    sizeof (sata_drive_info_t));
1228 					cportinfo->cport_dev_type =
1229 					    SATA_DTYPE_NONE;
1230 				}
1231 			}
1232 			/*
1233 			 * Note: PMult info requires different handling.
1234 			 * Put PMult handling code here, when PMult is
1235 			 * supported.
1236 			 */
1237 
1238 		}
1239 		mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex);
1240 		/* Just ask HBA driver to deactivate port */
1241 		sata_device.satadev_addr.qual = SATA_ADDR_DCPORT;
1242 
1243 		rval = (*SATA_PORT_DEACTIVATE_FUNC(sata_hba_inst))
1244 		    (dip, &sata_device);
1245 
1246 		/*
1247 		 * Generate sysevent - EC_DR / ESC_DR_AP_STATE_CHANGE
1248 		 * without the hint.
1249 		 */
1250 		sata_gen_sysevent(sata_hba_inst,
1251 		    &sata_device.satadev_addr, SE_NO_HINT);
1252 
1253 		mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, cport)->
1254 		    cport_mutex);
1255 		sata_update_port_info(sata_hba_inst, &sata_device);
1256 
1257 		if (rval != SATA_SUCCESS) {
1258 			/*
1259 			 * Port deactivation failure - do not
1260 			 * change port state unless the state
1261 			 * returned by HBA indicates a port failure.
1262 			 */
1263 			if (sata_device.satadev_state & SATA_PSTATE_FAILED)
1264 				cportinfo->cport_state = SATA_PSTATE_FAILED;
1265 			rv = EIO;
1266 		} else {
1267 			/*
1268 			 * Deactivation succeded. From now on the framework
1269 			 * will not know what is happening to the device, until
1270 			 * the port is activated again.
1271 			 */
1272 			cportinfo->cport_state |= SATA_PSTATE_SHUTDOWN;
1273 		}
1274 		mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex);
1275 		break;
1276 
1277 	case DEVCTL_AP_UNCONFIGURE:
1278 
1279 		/*
1280 		 * The unconfigure operation uses generic nexus operation to
1281 		 * offline a device. It leaves a target device node attached.
1282 		 * and obviously sata_drive_info attached as well, because
1283 		 * from the hardware point of view nothing has changed.
1284 		 */
1285 		if ((tdip = sata_get_target_dip(dip, comp_port)) != NULL) {
1286 
1287 			if (ndi_devi_offline(tdip, NDI_UNCONFIG) !=
1288 			    NDI_SUCCESS) {
1289 				SATA_LOG_D((sata_hba_inst, CE_WARN,
1290 				    "sata_hba_ioctl: unconfigure: "
1291 				    "failed to unconfigure "
1292 				    "device at SATA port %d", cport));
1293 				rv = EIO;
1294 			}
1295 			/*
1296 			 * The target node devi_state should be marked with
1297 			 * DEVI_DEVICE_OFFLINE by ndi_devi_offline().
1298 			 * This would be the indication for cfgadm that
1299 			 * the AP node occupant state is 'unconfigured'.
1300 			 */
1301 
1302 		} else {
1303 			/*
1304 			 * This would indicate a failure on the part of cfgadm
1305 			 * to detect correct state of the node prior to this
1306 			 * call - one cannot unconfigure non-existing device.
1307 			 */
1308 			SATA_LOG_D((sata_hba_inst, CE_WARN,
1309 			    "sata_hba_ioctl: unconfigure: "
1310 			    "attempt to unconfigure non-existing device "
1311 			    "at SATA port %d", cport));
1312 			rv = ENXIO;
1313 		}
1314 
1315 		break;
1316 
1317 	case DEVCTL_AP_CONNECT:
1318 	{
1319 		/*
1320 		 * The sata cfgadm pluging will invoke this operation only if
1321 		 * port was found in the disconnect state (failed state
1322 		 * is also treated as the disconnected state).
1323 		 * DEVCTL_AP_CONNECT would invoke
1324 		 * sata_hba_inst->satahba_tran->
1325 		 * sata_tran_hotplug_ops->sata_tran_port_activate().
1326 		 * If successful and a device is found attached to the port,
1327 		 * the initialization sequence is executed to attach
1328 		 * a device structure to a port structure. The device is not
1329 		 * set in configured state (system-wise) by this operation.
1330 		 * The state of the port and a device would be set
1331 		 * appropriately.
1332 		 *
1333 		 * Note, that activating the port may generate link events,
1334 		 * so is is important that following processing and the
1335 		 * event processing does not interfere with each other!
1336 		 *
1337 		 * This operation may remove port failed state and will
1338 		 * try to make port active and in good standing.
1339 		 */
1340 
1341 		/* We only care about host sata cport for now */
1342 
1343 		if (SATA_PORT_ACTIVATE_FUNC(sata_hba_inst) != NULL) {
1344 			/* Just let HBA driver to activate port */
1345 
1346 			if ((*SATA_PORT_ACTIVATE_FUNC(sata_hba_inst))
1347 			    (dip, &sata_device) != SATA_SUCCESS) {
1348 				/*
1349 				 * Port activation failure.
1350 				 */
1351 				mutex_enter(&SATA_CPORT_INFO(sata_hba_inst,
1352 				    cport)->cport_mutex);
1353 				sata_update_port_info(sata_hba_inst,
1354 				    &sata_device);
1355 				if (sata_device.satadev_state &
1356 				    SATA_PSTATE_FAILED) {
1357 					cportinfo->cport_state =
1358 					    SATA_PSTATE_FAILED;
1359 				}
1360 				mutex_exit(&SATA_CPORT_INFO(sata_hba_inst,
1361 				    cport)->cport_mutex);
1362 				SATA_LOG_D((sata_hba_inst, CE_WARN,
1363 				    "sata_hba_ioctl: connect: "
1364 				    "failed to activate SATA port %d",
1365 				    cport));
1366 				rv = EIO;
1367 				break;
1368 			}
1369 		}
1370 		/* Virgin port state - will be updated by the port re-probe. */
1371 		mutex_enter(&SATA_CPORT_INFO(sata_hba_inst,
1372 		    cport)->cport_mutex);
1373 		cportinfo->cport_state = 0;
1374 		mutex_exit(&SATA_CPORT_INFO(sata_hba_inst,
1375 		    cport)->cport_mutex);
1376 
1377 		/*
1378 		 * Probe the port to find its state and attached device.
1379 		 */
1380 		if (sata_reprobe_port(sata_hba_inst, &sata_device,
1381 		    SATA_DEV_IDENTIFY_RETRY) == SATA_FAILURE)
1382 			rv = EIO;
1383 		/*
1384 		 * Generate sysevent - EC_DR / ESC_DR_AP_STATE_CHANGE
1385 		 * without the hint
1386 		 */
1387 		sata_gen_sysevent(sata_hba_inst,
1388 		    &sata_device.satadev_addr, SE_NO_HINT);
1389 		/*
1390 		 * If there is a device attached to the port, emit
1391 		 * a message.
1392 		 */
1393 		if (cportinfo->cport_dev_type != SATA_DTYPE_NONE) {
1394 			sata_log(sata_hba_inst, CE_WARN,
1395 			    "SATA device detected at port %d", cport);
1396 		}
1397 		break;
1398 	}
1399 
1400 	case DEVCTL_AP_CONFIGURE:
1401 	{
1402 		boolean_t target = TRUE;
1403 
1404 		/*
1405 		 * A port may be in an active or shutdown state.
1406 		 * If port is in a failed state, operation is aborted - one
1407 		 * has to use explicit connect or port activate request
1408 		 * to try to get a port into non-failed mode.
1409 		 *
1410 		 * If a port is in a shutdown state, arbitrarily invoke
1411 		 * sata_tran_port_activate() prior to any other operation.
1412 		 *
1413 		 * Verify that port state is READY and there is a device
1414 		 * of a supported type attached to this port.
1415 		 * If target node exists, a device was most likely offlined.
1416 		 * If target node does not exist, create a target node an
1417 		 * attempt to online it.
1418 		 *		 *
1419 		 * NO PMult or devices beyond PMult are supported yet.
1420 		 */
1421 
1422 		/* We only care about host controller's sata cport for now. */
1423 		if (cportinfo->cport_state & SATA_PSTATE_FAILED) {
1424 			rv = ENXIO;
1425 			break;
1426 		}
1427 		/* Check the current state of the port */
1428 		sata_device.satadev_addr.qual = SATA_ADDR_CPORT;
1429 
1430 		rval = (*SATA_PROBE_PORT_FUNC(sata_hba_inst))
1431 		    (dip, &sata_device);
1432 		mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, cport)->
1433 		    cport_mutex);
1434 		sata_update_port_info(sata_hba_inst, &sata_device);
1435 		if (rval != SATA_SUCCESS ||
1436 		    (sata_device.satadev_state & SATA_PSTATE_FAILED)) {
1437 			cportinfo->cport_state = SATA_PSTATE_FAILED;
1438 			mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)->
1439 			    cport_mutex);
1440 			rv = EIO;
1441 			break;
1442 		}
1443 		if (cportinfo->cport_state & SATA_PSTATE_SHUTDOWN) {
1444 			target = FALSE;
1445 			mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)->
1446 			    cport_mutex);
1447 
1448 			if (SATA_PORT_ACTIVATE_FUNC(sata_hba_inst) != NULL) {
1449 				/* Just let HBA driver to activate port */
1450 				if ((*SATA_PORT_ACTIVATE_FUNC(sata_hba_inst))
1451 				    (dip, &sata_device) != SATA_SUCCESS) {
1452 					/*
1453 					 * Port activation failure - do not
1454 					 * change port state unless the state
1455 					 * returned by HBA indicates a port
1456 					 * failure.
1457 					 */
1458 					mutex_enter(&SATA_CPORT_INFO(
1459 					    sata_hba_inst, cport)->cport_mutex);
1460 					sata_update_port_info(sata_hba_inst,
1461 					    &sata_device);
1462 					if (sata_device.satadev_state &
1463 					    SATA_PSTATE_FAILED) {
1464 						cportinfo->cport_state =
1465 						    SATA_PSTATE_FAILED;
1466 					}
1467 					mutex_exit(&SATA_CPORT_INFO(
1468 					    sata_hba_inst, cport)->cport_mutex);
1469 					SATA_LOG_D((sata_hba_inst, CE_WARN,
1470 					    "sata_hba_ioctl: configure: "
1471 					    "failed to activate SATA port %d",
1472 					    cport));
1473 					rv = EIO;
1474 					break;
1475 				}
1476 			}
1477 			/*
1478 			 * Generate sysevent - EC_DR / ESC_DR_AP_STATE_CHANGE
1479 			 * without the hint.
1480 			 */
1481 			sata_gen_sysevent(sata_hba_inst,
1482 			    &sata_device.satadev_addr, SE_NO_HINT);
1483 
1484 			mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, cport)->
1485 			    cport_mutex);
1486 			/* Virgin port state */
1487 			cportinfo->cport_state = 0;
1488 		}
1489 		/*
1490 		 * Always reprobe port, to get current device info.
1491 		 */
1492 		mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex);
1493 		if (sata_reprobe_port(sata_hba_inst, &sata_device,
1494 		    SATA_DEV_IDENTIFY_RETRY) != SATA_SUCCESS) {
1495 			rv = EIO;
1496 			break;
1497 		}
1498 		if (target == FALSE &&
1499 		    cportinfo->cport_dev_type != SATA_DTYPE_NONE) {
1500 			/*
1501 			 * That's the transition from "inactive" port
1502 			 * to active one with device attached.
1503 			 */
1504 			sata_log(sata_hba_inst, CE_WARN,
1505 			    "SATA device detected at port %d",
1506 			    cport);
1507 		}
1508 
1509 		/*
1510 		 * This is where real configure starts.
1511 		 * Change following check for PMult support.
1512 		 */
1513 		if (!(sata_device.satadev_type & SATA_VALID_DEV_TYPE)) {
1514 			/* No device to configure */
1515 			rv = ENXIO; /* No device to configure */
1516 			break;
1517 		}
1518 
1519 		/*
1520 		 * Here we may have a device in reset condition,
1521 		 * but because we are just configuring it, there is
1522 		 * no need to process the reset other than just
1523 		 * to clear device reset condition in the HBA driver.
1524 		 * Setting the flag SATA_EVNT_CLEAR_DEVICE_RESET will
1525 		 * cause a first command sent the HBA driver with the request
1526 		 * to clear device reset condition.
1527 		 */
1528 		mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, cport)->
1529 		    cport_mutex);
1530 		sdinfo = sata_get_device_info(sata_hba_inst, &sata_device);
1531 		if (sdinfo == NULL) {
1532 			rv = ENXIO;
1533 			mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)->
1534 			    cport_mutex);
1535 			break;
1536 		}
1537 		if (sdinfo->satadrv_event_flags &
1538 		    (SATA_EVNT_DEVICE_RESET | SATA_EVNT_INPROC_DEVICE_RESET))
1539 			sdinfo->satadrv_event_flags = 0;
1540 		sdinfo->satadrv_event_flags |= SATA_EVNT_CLEAR_DEVICE_RESET;
1541 		mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex);
1542 
1543 		if ((tdip = sata_get_target_dip(dip, comp_port)) != NULL) {
1544 			/*
1545 			 * Target node exists. Verify, that it belongs
1546 			 * to existing, attached device and not to
1547 			 * a removed device.
1548 			 */
1549 			if (sata_check_device_removed(tdip) == B_FALSE) {
1550 				if (ndi_devi_online(tdip, 0) != NDI_SUCCESS) {
1551 					SATA_LOG_D((sata_hba_inst, CE_WARN,
1552 					    "sata_hba_ioctl: configure: "
1553 					    "onlining device at SATA port %d "
1554 					    "failed", cport));
1555 					rv = EIO;
1556 					break;
1557 				} else {
1558 					mutex_enter(&SATA_CPORT_INFO(
1559 					    sata_hba_inst, cport)->cport_mutex);
1560 					SATA_CPORT_INFO(sata_hba_inst, cport)->
1561 					    cport_tgtnode_clean = B_TRUE;
1562 					mutex_exit(&SATA_CPORT_INFO(
1563 					    sata_hba_inst, cport)->cport_mutex);
1564 				}
1565 			} else {
1566 				sata_log(sata_hba_inst, CE_WARN,
1567 				    "SATA device at port %d cannot be "
1568 				    "configured. "
1569 				    "Application(s) accessing previously "
1570 				    "attached device "
1571 				    "have to release it before newly inserted "
1572 				    "device can be made accessible.",
1573 				    cport);
1574 				break;
1575 			}
1576 		} else {
1577 			/*
1578 			 * No target node - need to create a new target node.
1579 			 */
1580 			mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, cport)->
1581 			    cport_mutex);
1582 			SATA_CPORT_INFO(sata_hba_inst, cport)->
1583 			    cport_tgtnode_clean = B_TRUE;
1584 			mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)->
1585 			    cport_mutex);
1586 			tdip = sata_create_target_node(dip, sata_hba_inst,
1587 			    &sata_device.satadev_addr);
1588 			if (tdip == NULL) {
1589 				/* configure failed */
1590 				SATA_LOG_D((sata_hba_inst, CE_WARN,
1591 				    "sata_hba_ioctl: configure: "
1592 				    "configuring SATA device at port %d "
1593 				    "failed", cport));
1594 				rv = EIO;
1595 				break;
1596 			}
1597 		}
1598 
1599 		break;
1600 	}
1601 
1602 	case DEVCTL_AP_GETSTATE:
1603 
1604 		sata_cfgadm_state(sata_hba_inst, comp_port, &ap_state);
1605 
1606 		ap_state.ap_last_change = (time_t)-1;
1607 		ap_state.ap_error_code = 0;
1608 		ap_state.ap_in_transition = 0;
1609 
1610 		/* Copy the return AP-state information to the user space */
1611 		if (ndi_dc_return_ap_state(&ap_state, dcp) != NDI_SUCCESS) {
1612 			rv = EFAULT;
1613 		}
1614 		break;
1615 
1616 	case DEVCTL_AP_CONTROL:
1617 	{
1618 		/*
1619 		 * Generic devctl for hardware specific functionality
1620 		 */
1621 		sata_ioctl_data_t	ioc;
1622 
1623 		ASSERT(dcp == NULL);
1624 
1625 		/* Copy in user ioctl data first */
1626 #ifdef _MULTI_DATAMODEL
1627 		if (ddi_model_convert_from(mode & FMODELS) ==
1628 		    DDI_MODEL_ILP32) {
1629 
1630 			sata_ioctl_data_32_t	ioc32;
1631 
1632 			if (ddi_copyin((void *)arg, (void *)&ioc32,
1633 			    sizeof (ioc32), mode) != 0) {
1634 				rv = EFAULT;
1635 				break;
1636 			}
1637 			ioc.cmd 	= (uint_t)ioc32.cmd;
1638 			ioc.port	= (uint_t)ioc32.port;
1639 			ioc.get_size	= (uint_t)ioc32.get_size;
1640 			ioc.buf		= (caddr_t)(uintptr_t)ioc32.buf;
1641 			ioc.bufsiz	= (uint_t)ioc32.bufsiz;
1642 			ioc.misc_arg	= (uint_t)ioc32.misc_arg;
1643 		} else
1644 #endif /* _MULTI_DATAMODEL */
1645 		if (ddi_copyin((void *)arg, (void *)&ioc, sizeof (ioc),
1646 		    mode) != 0) {
1647 			return (EFAULT);
1648 		}
1649 
1650 		SATADBG2(SATA_DBG_IOCTL_IF, sata_hba_inst,
1651 		    "sata_hba_ioctl: DEVCTL_AP_CONTROL "
1652 		    "cmd 0x%x, port 0x%x", ioc.cmd, ioc.port);
1653 
1654 		/*
1655 		 * To avoid BE/LE and 32/64 issues, a get_size always returns
1656 		 * a 32-bit number.
1657 		 */
1658 		if (ioc.get_size != 0 && ioc.bufsiz != (sizeof (uint32_t))) {
1659 			return (EINVAL);
1660 		}
1661 		/* validate address */
1662 		cport = SCSI_TO_SATA_CPORT(ioc.port);
1663 		pmport = SCSI_TO_SATA_PMPORT(ioc.port);
1664 		qual = SCSI_TO_SATA_ADDR_QUAL(ioc.port);
1665 
1666 		/* Override address qualifier - handle cport only for now */
1667 		qual = SATA_ADDR_CPORT;
1668 
1669 		if (sata_validate_sata_address(sata_hba_inst, cport,
1670 		    pmport, qual) != 0)
1671 			return (EINVAL);
1672 
1673 		cportinfo = SATA_CPORT_INFO(sata_hba_inst, cport);
1674 		mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, cport)->
1675 		    cport_mutex);
1676 		/* Is the port locked by event processing daemon ? */
1677 		if (cportinfo->cport_event_flags & SATA_EVNT_LOCK_PORT_BUSY) {
1678 			/*
1679 			 * Cannot process ioctl request now. Come back later
1680 			 */
1681 			mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)->
1682 			    cport_mutex);
1683 			return (EBUSY);
1684 		}
1685 		/* Block event processing for this port */
1686 		cportinfo->cport_event_flags |= SATA_APCTL_LOCK_PORT_BUSY;
1687 		mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex);
1688 
1689 
1690 		sata_device.satadev_addr.cport = cport;
1691 		sata_device.satadev_addr.pmport = pmport;
1692 		sata_device.satadev_rev = SATA_DEVICE_REV;
1693 
1694 		switch (ioc.cmd) {
1695 
1696 		case SATA_CFGA_RESET_PORT:
1697 			/*
1698 			 * There is no protection here for configured
1699 			 * device.
1700 			 */
1701 
1702 			/* Sanity check */
1703 			if (SATA_RESET_DPORT_FUNC(sata_hba_inst) == NULL) {
1704 				SATA_LOG_D((sata_hba_inst, CE_WARN,
1705 				    "sata_hba_ioctl: "
1706 				    "sata_hba_tran missing required "
1707 				    "function sata_tran_reset_dport"));
1708 				rv = EINVAL;
1709 				break;
1710 			}
1711 
1712 			/* handle cport only for now */
1713 			sata_device.satadev_addr.qual = SATA_ADDR_CPORT;
1714 			if ((*SATA_RESET_DPORT_FUNC(sata_hba_inst))
1715 			    (dip, &sata_device) != SATA_SUCCESS) {
1716 				SATA_LOG_D((sata_hba_inst, CE_WARN,
1717 				    "sata_hba_ioctl: reset port: "
1718 				    "failed cport %d pmport %d",
1719 				    cport, pmport));
1720 				mutex_enter(&SATA_CPORT_INFO(sata_hba_inst,
1721 				    cport)->cport_mutex);
1722 				sata_update_port_info(sata_hba_inst,
1723 				    &sata_device);
1724 				SATA_CPORT_STATE(sata_hba_inst, cport) =
1725 				    SATA_PSTATE_FAILED;
1726 				mutex_exit(&SATA_CPORT_INFO(sata_hba_inst,
1727 				    cport)->cport_mutex);
1728 				rv = EIO;
1729 			}
1730 			/*
1731 			 * Since the port was reset, it should be probed and
1732 			 * attached device reinitialized. At this point the
1733 			 * port state is unknown - it's state is HBA-specific.
1734 			 * Re-probe port to get its state.
1735 			 */
1736 			if (sata_reprobe_port(sata_hba_inst, &sata_device,
1737 			    SATA_DEV_IDENTIFY_RETRY) != SATA_SUCCESS) {
1738 				rv = EIO;
1739 				break;
1740 			}
1741 			break;
1742 
1743 		case SATA_CFGA_RESET_DEVICE:
1744 			/*
1745 			 * There is no protection here for configured
1746 			 * device.
1747 			 */
1748 
1749 			/* Sanity check */
1750 			if (SATA_RESET_DPORT_FUNC(sata_hba_inst) == NULL) {
1751 				SATA_LOG_D((sata_hba_inst, CE_WARN,
1752 				    "sata_hba_ioctl: "
1753 				    "sata_hba_tran missing required "
1754 				    "function sata_tran_reset_dport"));
1755 				rv = EINVAL;
1756 				break;
1757 			}
1758 
1759 			/* handle only device attached to cports, for now */
1760 			sata_device.satadev_addr.qual = SATA_ADDR_DCPORT;
1761 
1762 			mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, cport)->
1763 			    cport_mutex);
1764 			sdinfo = sata_get_device_info(sata_hba_inst,
1765 			    &sata_device);
1766 			if (sdinfo == NULL) {
1767 				mutex_exit(&SATA_CPORT_INFO(sata_hba_inst,
1768 				    cport)->cport_mutex);
1769 				rv = EINVAL;
1770 				break;
1771 			}
1772 			mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)->
1773 			    cport_mutex);
1774 
1775 			/* only handle cport for now */
1776 			sata_device.satadev_addr.qual = SATA_ADDR_DCPORT;
1777 			if ((*SATA_RESET_DPORT_FUNC(sata_hba_inst))
1778 			    (dip, &sata_device) != SATA_SUCCESS) {
1779 				SATA_LOG_D((sata_hba_inst, CE_WARN,
1780 				    "sata_hba_ioctl: reset device: failed "
1781 				    "cport %d pmport %d", cport, pmport));
1782 				mutex_enter(&SATA_CPORT_INFO(sata_hba_inst,
1783 				    cport)->cport_mutex);
1784 				sata_update_port_info(sata_hba_inst,
1785 				    &sata_device);
1786 				/*
1787 				 * Device info structure remains
1788 				 * attached. Another device reset or
1789 				 * port disconnect/connect and re-probing is
1790 				 * needed to change it's state
1791 				 */
1792 				sdinfo->satadrv_state &= ~SATA_STATE_READY;
1793 				sdinfo->satadrv_state |=
1794 				    SATA_DSTATE_FAILED;
1795 				mutex_exit(&SATA_CPORT_INFO(sata_hba_inst,
1796 				    cport)->cport_mutex);
1797 				rv = EIO;
1798 			}
1799 			/*
1800 			 * Since the device was reset, we expect reset event
1801 			 * to be reported and processed.
1802 			 */
1803 			break;
1804 
1805 		case SATA_CFGA_RESET_ALL:
1806 		{
1807 			int tcport;
1808 
1809 			/*
1810 			 * There is no protection here for configured
1811 			 * devices.
1812 			 */
1813 			/* Sanity check */
1814 			if (SATA_RESET_DPORT_FUNC(sata_hba_inst) == NULL) {
1815 				SATA_LOG_D((sata_hba_inst, CE_WARN,
1816 				    "sata_hba_ioctl: "
1817 				    "sata_hba_tran missing required "
1818 				    "function sata_tran_reset_dport"));
1819 				rv = EINVAL;
1820 				break;
1821 			}
1822 
1823 			/*
1824 			 * Need to lock all ports, not just one.
1825 			 * If any port is locked by event processing, fail
1826 			 * the whole operation.
1827 			 * One port is already locked, but for simplicity
1828 			 * lock it again.
1829 			 */
1830 			for (tcport = 0;
1831 			    tcport < SATA_NUM_CPORTS(sata_hba_inst);
1832 			    tcport++) {
1833 				mutex_enter(&SATA_CPORT_INFO(sata_hba_inst,
1834 				    tcport)->cport_mutex);
1835 				if (((SATA_CPORT_INFO(sata_hba_inst, tcport)->
1836 				    cport_event_flags) &
1837 				    SATA_EVNT_LOCK_PORT_BUSY) != 0) {
1838 					rv = EBUSY;
1839 					mutex_exit(
1840 					    &SATA_CPORT_INFO(sata_hba_inst,
1841 					    tcport)->cport_mutex);
1842 					break;
1843 				} else {
1844 					SATA_CPORT_INFO(sata_hba_inst,
1845 					    tcport)->cport_event_flags |=
1846 					    SATA_APCTL_LOCK_PORT_BUSY;
1847 				}
1848 				mutex_exit(&SATA_CPORT_INFO(sata_hba_inst,
1849 				    tcport)->cport_mutex);
1850 			}
1851 
1852 			if (rv == 0) {
1853 				/*
1854 				 * All cports successfully locked.
1855 				 * Reset main SATA controller only for now -
1856 				 * no PMult.
1857 				 */
1858 				sata_device.satadev_addr.qual =
1859 				    SATA_ADDR_CNTRL;
1860 
1861 				if ((*SATA_RESET_DPORT_FUNC(sata_hba_inst))
1862 				    (dip, &sata_device) != SATA_SUCCESS) {
1863 					SATA_LOG_D((sata_hba_inst, CE_WARN,
1864 					    "sata_hba_ioctl: reset controller "
1865 					    "failed"));
1866 					rv = EIO;
1867 				}
1868 
1869 				/*
1870 				 * Since ports were reset, they should be
1871 				 * re-probed and attached devices
1872 				 * reinitialized.
1873 				 * At this point port states are unknown,
1874 				 * Re-probe ports to get their state -
1875 				 * cports only for now.
1876 				 */
1877 				for (tcport = 0;
1878 				    tcport < SATA_NUM_CPORTS(sata_hba_inst);
1879 				    tcport++) {
1880 					sata_device.satadev_addr.cport =
1881 					    tcport;
1882 					sata_device.satadev_addr.qual =
1883 					    SATA_ADDR_CPORT;
1884 
1885 					if (sata_reprobe_port(sata_hba_inst,
1886 					    &sata_device,
1887 					    SATA_DEV_IDENTIFY_RETRY) !=
1888 					    SATA_SUCCESS)
1889 						rv = EIO;
1890 
1891 				}
1892 			}
1893 			/*
1894 			 * Unlock all ports
1895 			 */
1896 			for (tcport = 0;
1897 			    tcport < SATA_NUM_CPORTS(sata_hba_inst);
1898 			    tcport++) {
1899 				mutex_enter(&SATA_CPORT_INFO(sata_hba_inst,
1900 				    tcport)->cport_mutex);
1901 				SATA_CPORT_INFO(sata_hba_inst, tcport)->
1902 				    cport_event_flags &=
1903 				    ~SATA_APCTL_LOCK_PORT_BUSY;
1904 				mutex_exit(&SATA_CPORT_INFO(sata_hba_inst,
1905 				    tcport)->cport_mutex);
1906 			}
1907 
1908 			/*
1909 			 * This operation returns EFAULT if either reset
1910 			 * controller failed or a re-probing of any ports
1911 			 * failed.
1912 			 * We return here, because common return is for
1913 			 * a single cport operation.
1914 			 */
1915 			return (rv);
1916 		}
1917 
1918 		case SATA_CFGA_PORT_DEACTIVATE:
1919 			/* Sanity check */
1920 			if (SATA_PORT_DEACTIVATE_FUNC(sata_hba_inst) == NULL) {
1921 				rv = ENOTSUP;
1922 				break;
1923 			}
1924 			/*
1925 			 * Arbitrarily unconfigure attached device, if any.
1926 			 * Even if the unconfigure fails, proceed with the
1927 			 * port deactivation.
1928 			 */
1929 
1930 			/* Handle only device attached to cports, for now */
1931 			sata_device.satadev_addr.qual = SATA_ADDR_DCPORT;
1932 
1933 			mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, cport)->
1934 			    cport_mutex);
1935 			cportinfo->cport_state &= ~SATA_STATE_READY;
1936 			if (cportinfo->cport_dev_type != SATA_DTYPE_NONE) {
1937 				/*
1938 				 * Handle only device attached to cports,
1939 				 * for now
1940 				 */
1941 				sata_device.satadev_addr.qual =
1942 				    SATA_ADDR_DCPORT;
1943 				sdinfo = sata_get_device_info(sata_hba_inst,
1944 				    &sata_device);
1945 				if (sdinfo != NULL &&
1946 				    (sdinfo->satadrv_type &
1947 				    SATA_VALID_DEV_TYPE)) {
1948 					/*
1949 					 * If a target node exists, try to
1950 					 * offline a device and remove target
1951 					 * node.
1952 					 */
1953 					mutex_exit(&SATA_CPORT_INFO(
1954 					    sata_hba_inst, cport)->cport_mutex);
1955 					tdip = sata_get_target_dip(dip, cport);
1956 					if (tdip != NULL) {
1957 						/* target node exist */
1958 						SATADBG1(SATA_DBG_IOCTL_IF,
1959 						    sata_hba_inst,
1960 						    "sata_hba_ioctl: "
1961 						    "port deactivate: "
1962 						    "target node exists.",
1963 						    NULL);
1964 
1965 						if (ndi_devi_offline(tdip,
1966 						    NDI_DEVI_REMOVE) !=
1967 						    NDI_SUCCESS) {
1968 							SATA_LOG_D((
1969 							    sata_hba_inst,
1970 							    CE_WARN,
1971 							    "sata_hba_ioctl:"
1972 							    "port deactivate: "
1973 							    "failed to "
1974 							    "unconfigure "
1975 							    "device at port "
1976 							    "%d before "
1977 							    "deactivating "
1978 							    "the port", cport));
1979 						}
1980 
1981 
1982 						/*
1983 						 * Set DEVICE REMOVED state
1984 						 * in the target node. It
1985 						 * will prevent access to
1986 						 * the device even when a
1987 						 * new device is attached,
1988 						 * until the old target node
1989 						 * is released, removed and
1990 						 * recreated for a new
1991 						 * device.
1992 						 */
1993 						sata_set_device_removed(tdip);
1994 						/*
1995 						 * Instruct event daemon to
1996 						 * try the target node cleanup
1997 						 * later.
1998 						 */
1999 						sata_set_target_node_cleanup(
2000 						    sata_hba_inst, cport);
2001 					}
2002 					mutex_enter(&SATA_CPORT_INFO(
2003 					    sata_hba_inst, cport)->cport_mutex);
2004 					/*
2005 					 * In any case,
2006 					 * remove and release sata_drive_info
2007 					 * structure.
2008 					 * (cport attached device ony, for now)
2009 					 */
2010 					SATA_CPORTINFO_DRV_INFO(cportinfo) =
2011 					    NULL;
2012 					(void) kmem_free((void *)sdinfo,
2013 					    sizeof (sata_drive_info_t));
2014 					cportinfo->cport_dev_type =
2015 					    SATA_DTYPE_NONE;
2016 				}
2017 				/*
2018 				 * Note: PMult info requires different
2019 				 * handling. This comment is a placeholder for
2020 				 * a code handling PMult, to be implemented
2021 				 * in phase 2.
2022 				 */
2023 			}
2024 			cportinfo->cport_state &= ~(SATA_STATE_PROBED |
2025 			    SATA_STATE_PROBING);
2026 			mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)->
2027 			    cport_mutex);
2028 			/* handle cport only for now */
2029 			sata_device.satadev_addr.qual = SATA_ADDR_CPORT;
2030 			/* Just let HBA driver to deactivate port */
2031 			rval = (*SATA_PORT_DEACTIVATE_FUNC(sata_hba_inst))
2032 			    (dip, &sata_device);
2033 			/*
2034 			 * Generate sysevent -
2035 			 * EC_DR / ESC_DR_AP_STATE_CHANGE
2036 			 * without the hint
2037 			 */
2038 			sata_gen_sysevent(sata_hba_inst,
2039 			    &sata_device.satadev_addr, SE_NO_HINT);
2040 
2041 			mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, cport)->
2042 			    cport_mutex);
2043 			sata_update_port_info(sata_hba_inst, &sata_device);
2044 			if (rval != SATA_SUCCESS) {
2045 				/*
2046 				 * Port deactivation failure - do not
2047 				 * change port state unless the state
2048 				 * returned by HBA indicates a port failure.
2049 				 */
2050 				if (sata_device.satadev_state &
2051 				    SATA_PSTATE_FAILED) {
2052 					SATA_CPORT_STATE(sata_hba_inst,
2053 					    cport) = SATA_PSTATE_FAILED;
2054 				}
2055 				SATA_LOG_D((sata_hba_inst, CE_WARN,
2056 				    "sata_hba_ioctl: port deactivate: "
2057 				    "cannot deactivate SATA port %d",
2058 				    cport));
2059 				rv = EIO;
2060 			} else {
2061 				cportinfo->cport_state |= SATA_PSTATE_SHUTDOWN;
2062 			}
2063 			mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)->
2064 			    cport_mutex);
2065 
2066 			break;
2067 
2068 		case SATA_CFGA_PORT_ACTIVATE:
2069 		{
2070 			boolean_t dev_existed = TRUE;
2071 
2072 			/* Sanity check */
2073 			if (SATA_PORT_ACTIVATE_FUNC(sata_hba_inst) == NULL) {
2074 				rv = ENOTSUP;
2075 				break;
2076 			}
2077 			/* handle cport only for now */
2078 			if (cportinfo->cport_state & SATA_PSTATE_SHUTDOWN ||
2079 			    cportinfo->cport_dev_type == SATA_DTYPE_NONE)
2080 				dev_existed = FALSE;
2081 
2082 			sata_device.satadev_addr.qual = SATA_ADDR_CPORT;
2083 			/* Just let HBA driver to activate port */
2084 			if ((*SATA_PORT_ACTIVATE_FUNC(sata_hba_inst))
2085 			    (dip, &sata_device) != SATA_SUCCESS) {
2086 				/*
2087 				 * Port activation failure - do not
2088 				 * change port state unless the state
2089 				 * returned by HBA indicates a port failure.
2090 				 */
2091 				mutex_enter(&SATA_CPORT_INFO(sata_hba_inst,
2092 				    cport)->cport_mutex);
2093 				sata_update_port_info(sata_hba_inst,
2094 				    &sata_device);
2095 				if (sata_device.satadev_state &
2096 				    SATA_PSTATE_FAILED) {
2097 					SATA_CPORT_STATE(sata_hba_inst,
2098 					    cport) = SATA_PSTATE_FAILED;
2099 				}
2100 				mutex_exit(&SATA_CPORT_INFO(sata_hba_inst,
2101 				    cport)->cport_mutex);
2102 				SATA_LOG_D((sata_hba_inst, CE_WARN,
2103 				    "sata_hba_ioctl: port activate: "
2104 				    "cannot activate SATA port %d",
2105 				    cport));
2106 				rv = EIO;
2107 				break;
2108 			}
2109 			mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, cport)->
2110 			    cport_mutex);
2111 			cportinfo->cport_state &= ~SATA_PSTATE_SHUTDOWN;
2112 			mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)->
2113 			    cport_mutex);
2114 
2115 			/*
2116 			 * Re-probe port to find its current state and
2117 			 * possibly attached device.
2118 			 * Port re-probing may change the cportinfo device
2119 			 * type if device is found attached.
2120 			 * If port probing failed, the device type would be
2121 			 * set to SATA_DTYPE_NONE.
2122 			 */
2123 			(void) sata_reprobe_port(sata_hba_inst, &sata_device,
2124 			    SATA_DEV_IDENTIFY_RETRY);
2125 
2126 			/*
2127 			 * Generate sysevent -
2128 			 * EC_DR / ESC_DR_AP_STATE_CHANGE
2129 			 * without the hint.
2130 			 */
2131 			sata_gen_sysevent(sata_hba_inst,
2132 			    &sata_device.satadev_addr, SE_NO_HINT);
2133 
2134 			if (dev_existed == FALSE &&
2135 			    cportinfo->cport_dev_type != SATA_DTYPE_NONE) {
2136 				/*
2137 				 * That's the transition from "inactive" port
2138 				 * state or active port without a device
2139 				 * attached to the active port state with
2140 				 * a device attached.
2141 				 */
2142 				sata_log(sata_hba_inst, CE_WARN,
2143 				    "SATA device detected at port %d", cport);
2144 			}
2145 
2146 			break;
2147 		}
2148 
2149 		case SATA_CFGA_PORT_SELF_TEST:
2150 
2151 			/* Sanity check */
2152 			if (SATA_SELFTEST_FUNC(sata_hba_inst) == NULL) {
2153 				rv = ENOTSUP;
2154 				break;
2155 			}
2156 			/*
2157 			 * There is no protection here for a configured
2158 			 * device attached to this port.
2159 			 */
2160 
2161 			/* only handle cport for now */
2162 			sata_device.satadev_addr.qual = SATA_ADDR_CPORT;
2163 
2164 			if ((*SATA_SELFTEST_FUNC(sata_hba_inst))
2165 			    (dip, &sata_device) != SATA_SUCCESS) {
2166 				SATA_LOG_D((sata_hba_inst, CE_WARN,
2167 				    "sata_hba_ioctl: port selftest: "
2168 				    "failed cport %d pmport %d",
2169 				    cport, pmport));
2170 				mutex_enter(&SATA_CPORT_INFO(sata_hba_inst,
2171 				    cport)->cport_mutex);
2172 				sata_update_port_info(sata_hba_inst,
2173 				    &sata_device);
2174 				SATA_CPORT_STATE(sata_hba_inst, cport) =
2175 				    SATA_PSTATE_FAILED;
2176 				mutex_exit(&SATA_CPORT_INFO(sata_hba_inst,
2177 				    cport)->cport_mutex);
2178 				rv = EIO;
2179 				break;
2180 			}
2181 			/*
2182 			 * Since the port was reset, it should be probed and
2183 			 * attached device reinitialized. At this point the
2184 			 * port state is unknown - it's state is HBA-specific.
2185 			 * Force port re-probing to get it into a known state.
2186 			 */
2187 			if (sata_reprobe_port(sata_hba_inst, &sata_device,
2188 			    SATA_DEV_IDENTIFY_RETRY) != SATA_SUCCESS) {
2189 				rv = EIO;
2190 				break;
2191 			}
2192 			break;
2193 
2194 		case SATA_CFGA_GET_DEVICE_PATH:
2195 		{
2196 			char		path[MAXPATHLEN];
2197 			uint32_t	size;
2198 
2199 			(void) strcpy(path, "/devices");
2200 			if ((tdip = sata_get_target_dip(dip, ioc.port)) ==
2201 			    NULL) {
2202 
2203 				/*
2204 				 * No such device.
2205 				 * If this is a request for a size, do not
2206 				 * return EINVAL for non-exisiting target,
2207 				 * because cfgadm will indicate a meaningless
2208 				 * ioctl failure.
2209 				 * If this is a real request for a path,
2210 				 * indicate invalid argument.
2211 				 */
2212 				if (!ioc.get_size) {
2213 					rv = EINVAL;
2214 					break;
2215 				}
2216 			} else {
2217 				(void) ddi_pathname(tdip, path + strlen(path));
2218 			}
2219 			size = strlen(path) + 1;
2220 
2221 			if (ioc.get_size) {
2222 				if (ddi_copyout((void *)&size,
2223 				    ioc.buf, ioc.bufsiz, mode) != 0) {
2224 					rv = EFAULT;
2225 				}
2226 			} else {
2227 				if (ioc.bufsiz != size) {
2228 					rv = EINVAL;
2229 				} else if (ddi_copyout((void *)&path,
2230 				    ioc.buf, ioc.bufsiz, mode) != 0) {
2231 					rv = EFAULT;
2232 				}
2233 			}
2234 			break;
2235 		}
2236 
2237 		case SATA_CFGA_GET_AP_TYPE:
2238 		{
2239 			uint32_t	type_len;
2240 			const char	*ap_type;
2241 
2242 			/* cport only, no port multiplier support */
2243 			switch (SATA_CPORT_DEV_TYPE(sata_hba_inst, cport)) {
2244 			case SATA_DTYPE_NONE:
2245 				ap_type = "port";
2246 				break;
2247 
2248 			case SATA_DTYPE_ATADISK:
2249 				ap_type = "disk";
2250 				break;
2251 
2252 			case SATA_DTYPE_ATAPICD:
2253 				ap_type = "cd/dvd";
2254 				break;
2255 
2256 			case SATA_DTYPE_PMULT:
2257 				ap_type = "pmult";
2258 				break;
2259 
2260 			case SATA_DTYPE_UNKNOWN:
2261 				ap_type = "unknown";
2262 				break;
2263 
2264 			default:
2265 				ap_type = "unsupported";
2266 				break;
2267 
2268 			} /* end of dev_type switch */
2269 
2270 			type_len = strlen(ap_type) + 1;
2271 
2272 			if (ioc.get_size) {
2273 				if (ddi_copyout((void *)&type_len,
2274 				    ioc.buf, ioc.bufsiz, mode) != 0) {
2275 					rv = EFAULT;
2276 					break;
2277 				}
2278 			} else {
2279 				if (ioc.bufsiz != type_len) {
2280 					rv = EINVAL;
2281 					break;
2282 				}
2283 				if (ddi_copyout((void *)ap_type, ioc.buf,
2284 				    ioc.bufsiz, mode) != 0) {
2285 					rv = EFAULT;
2286 					break;
2287 				}
2288 			}
2289 
2290 			break;
2291 		}
2292 
2293 		case SATA_CFGA_GET_MODEL_INFO:
2294 		{
2295 			uint32_t info_len;
2296 			char ap_info[sizeof (sdinfo->satadrv_id.ai_model) + 1];
2297 
2298 			/*
2299 			 * This operation should return to cfgadm the
2300 			 * device model information string
2301 			 */
2302 			mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, cport)->
2303 			    cport_mutex);
2304 			/* only handle device connected to cport for now */
2305 			sata_device.satadev_addr.qual = SATA_ADDR_DCPORT;
2306 			sdinfo = sata_get_device_info(sata_hba_inst,
2307 			    &sata_device);
2308 			if (sdinfo == NULL) {
2309 				rv = EINVAL;
2310 				mutex_exit(&SATA_CPORT_INFO(sata_hba_inst,
2311 				    cport)->cport_mutex);
2312 				break;
2313 			}
2314 			bcopy(sdinfo->satadrv_id.ai_model, ap_info,
2315 			    sizeof (sdinfo->satadrv_id.ai_model));
2316 			swab(ap_info, ap_info,
2317 			    sizeof (sdinfo->satadrv_id.ai_model));
2318 			ap_info[sizeof (sdinfo->satadrv_id.ai_model)] = '\0';
2319 
2320 			mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)->
2321 			    cport_mutex);
2322 
2323 			info_len = strlen(ap_info) + 1;
2324 
2325 			if (ioc.get_size) {
2326 				if (ddi_copyout((void *)&info_len,
2327 				    ioc.buf, ioc.bufsiz, mode) != 0) {
2328 					rv = EFAULT;
2329 					break;
2330 				}
2331 			} else {
2332 				if (ioc.bufsiz < info_len) {
2333 					rv = EINVAL;
2334 					break;
2335 				}
2336 				if (ddi_copyout((void *)ap_info, ioc.buf,
2337 				    ioc.bufsiz, mode) != 0) {
2338 					rv = EFAULT;
2339 					break;
2340 				}
2341 			}
2342 
2343 			break;
2344 		}
2345 
2346 		case SATA_CFGA_GET_REVFIRMWARE_INFO:
2347 		{
2348 			uint32_t info_len;
2349 			char ap_info[
2350 			    sizeof (sdinfo->satadrv_id.ai_fw) + 1];
2351 
2352 			/*
2353 			 * This operation should return to cfgadm the
2354 			 * device firmware revision information string
2355 			 */
2356 			mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, cport)->
2357 			    cport_mutex);
2358 			/* only handle device connected to cport for now */
2359 			sata_device.satadev_addr.qual = SATA_ADDR_DCPORT;
2360 
2361 			sdinfo = sata_get_device_info(sata_hba_inst,
2362 			    &sata_device);
2363 			if (sdinfo == NULL) {
2364 				mutex_exit(&SATA_CPORT_INFO(sata_hba_inst,
2365 				    cport)->cport_mutex);
2366 				rv = EINVAL;
2367 				break;
2368 			}
2369 			bcopy(sdinfo->satadrv_id.ai_fw, ap_info,
2370 			    sizeof (sdinfo->satadrv_id.ai_fw));
2371 			swab(ap_info, ap_info,
2372 			    sizeof (sdinfo->satadrv_id.ai_fw));
2373 			ap_info[sizeof (sdinfo->satadrv_id.ai_fw)] = '\0';
2374 
2375 			mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)->
2376 			    cport_mutex);
2377 
2378 			info_len = strlen(ap_info) + 1;
2379 
2380 			if (ioc.get_size) {
2381 				if (ddi_copyout((void *)&info_len,
2382 				    ioc.buf, ioc.bufsiz, mode) != 0) {
2383 					rv = EFAULT;
2384 					break;
2385 				}
2386 			} else {
2387 				if (ioc.bufsiz < info_len) {
2388 					rv = EINVAL;
2389 					break;
2390 				}
2391 				if (ddi_copyout((void *)ap_info, ioc.buf,
2392 				    ioc.bufsiz, mode) != 0) {
2393 					rv = EFAULT;
2394 					break;
2395 				}
2396 			}
2397 
2398 			break;
2399 		}
2400 
2401 		case SATA_CFGA_GET_SERIALNUMBER_INFO:
2402 		{
2403 			uint32_t info_len;
2404 			char ap_info[
2405 			    sizeof (sdinfo->satadrv_id.ai_drvser) + 1];
2406 
2407 			/*
2408 			 * This operation should return to cfgadm the
2409 			 * device serial number information string
2410 			 */
2411 			mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, cport)->
2412 			    cport_mutex);
2413 			/* only handle device connected to cport for now */
2414 			sata_device.satadev_addr.qual = SATA_ADDR_DCPORT;
2415 
2416 			sdinfo = sata_get_device_info(sata_hba_inst,
2417 			    &sata_device);
2418 			if (sdinfo == NULL) {
2419 				mutex_exit(&SATA_CPORT_INFO(sata_hba_inst,
2420 				    cport)->cport_mutex);
2421 				rv = EINVAL;
2422 				break;
2423 			}
2424 			bcopy(sdinfo->satadrv_id.ai_drvser, ap_info,
2425 			    sizeof (sdinfo->satadrv_id.ai_drvser));
2426 			swab(ap_info, ap_info,
2427 			    sizeof (sdinfo->satadrv_id.ai_drvser));
2428 			ap_info[sizeof (sdinfo->satadrv_id.ai_drvser)] = '\0';
2429 
2430 			mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)->
2431 			    cport_mutex);
2432 
2433 			info_len = strlen(ap_info) + 1;
2434 
2435 			if (ioc.get_size) {
2436 				if (ddi_copyout((void *)&info_len,
2437 				    ioc.buf, ioc.bufsiz, mode) != 0) {
2438 					rv = EFAULT;
2439 					break;
2440 				}
2441 			} else {
2442 				if (ioc.bufsiz < info_len) {
2443 					rv = EINVAL;
2444 					break;
2445 				}
2446 				if (ddi_copyout((void *)ap_info, ioc.buf,
2447 				    ioc.bufsiz, mode) != 0) {
2448 					rv = EFAULT;
2449 					break;
2450 				}
2451 			}
2452 
2453 			break;
2454 		}
2455 
2456 		default:
2457 			rv = EINVAL;
2458 			break;
2459 
2460 		} /* End of DEVCTL_AP_CONTROL cmd switch */
2461 
2462 		break;
2463 	}
2464 
2465 	default:
2466 	{
2467 		/*
2468 		 * If we got here, we got an IOCTL that SATA HBA Framework
2469 		 * does not recognize. Pass ioctl to HBA driver, in case
2470 		 * it could process it.
2471 		 */
2472 		sata_hba_tran_t *sata_tran = sata_hba_inst->satahba_tran;
2473 		dev_info_t	*mydip = SATA_DIP(sata_hba_inst);
2474 
2475 		SATADBG1(SATA_DBG_IOCTL_IF, sata_hba_inst,
2476 		    "IOCTL 0x%2x not supported in SATA framework, "
2477 		    "passthrough to HBA", cmd);
2478 
2479 		if (sata_tran->sata_tran_ioctl == NULL) {
2480 			rv = EINVAL;
2481 			break;
2482 		}
2483 		rval = (*sata_tran->sata_tran_ioctl)(mydip, cmd, arg);
2484 		if (rval != 0) {
2485 			SATADBG1(SATA_DBG_IOCTL_IF, sata_hba_inst,
2486 			    "IOCTL 0x%2x failed in HBA", cmd);
2487 			rv = rval;
2488 		}
2489 		break;
2490 	}
2491 
2492 	} /* End of main IOCTL switch */
2493 
2494 	if (dcp) {
2495 		ndi_dc_freehdl(dcp);
2496 	}
2497 	mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex);
2498 	cportinfo->cport_event_flags &= ~SATA_APCTL_LOCK_PORT_BUSY;
2499 	mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex);
2500 
2501 	return (rv);
2502 }
2503 
2504 
2505 
2506 
2507 /* ****************** SCSA required entry points *********************** */
2508 
2509 /*
2510  * Implementation of scsi tran_tgt_init.
2511  * sata_scsi_tgt_init() initializes scsi_device structure
2512  *
2513  * If successful, DDI_SUCCESS is returned.
2514  * DDI_FAILURE is returned if addressed device does not exist
2515  */
2516 
2517 static int
2518 sata_scsi_tgt_init(dev_info_t *hba_dip, dev_info_t *tgt_dip,
2519     scsi_hba_tran_t *hba_tran, struct scsi_device *sd)
2520 {
2521 #ifndef __lock_lint
2522 	_NOTE(ARGUNUSED(hba_dip))
2523 #endif
2524 	sata_device_t		sata_device;
2525 	sata_drive_info_t	*sdinfo;
2526 	sata_hba_inst_t		*sata_hba_inst;
2527 
2528 	sata_hba_inst = (sata_hba_inst_t *)(hba_tran->tran_hba_private);
2529 
2530 	/* Validate scsi device address */
2531 	if (sata_validate_scsi_address(sata_hba_inst, &sd->sd_address,
2532 	    &sata_device) != 0)
2533 		return (DDI_FAILURE);
2534 
2535 	mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst,
2536 	    sata_device.satadev_addr.cport)));
2537 
2538 	/* sata_device now contains a valid sata address */
2539 	sdinfo = sata_get_device_info(sata_hba_inst, &sata_device);
2540 	if (sdinfo == NULL) {
2541 		mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst,
2542 		    sata_device.satadev_addr.cport)));
2543 		return (DDI_FAILURE);
2544 	}
2545 	if (sata_device.satadev_type == SATA_DTYPE_ATAPICD) {
2546 		mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst,
2547 		    sata_device.satadev_addr.cport)));
2548 		if (ndi_prop_update_string(DDI_DEV_T_NONE, tgt_dip,
2549 		    "variant", "atapi") != DDI_PROP_SUCCESS) {
2550 			SATA_LOG_D((sata_hba_inst, CE_WARN,
2551 			    "sata_scsi_tgt_init: variant atapi "
2552 			    "property could not be created"));
2553 			return (DDI_FAILURE);
2554 		}
2555 		return (DDI_SUCCESS);
2556 	}
2557 	mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst,
2558 	    sata_device.satadev_addr.cport)));
2559 	return (DDI_SUCCESS);
2560 }
2561 
2562 /*
2563  * Implementation of scsi tran_tgt_probe.
2564  * Probe target, by calling default scsi routine scsi_hba_probe()
2565  */
2566 static int
2567 sata_scsi_tgt_probe(struct scsi_device *sd, int (*callback)(void))
2568 {
2569 	sata_hba_inst_t *sata_hba_inst =
2570 	    (sata_hba_inst_t *)(sd->sd_address.a_hba_tran->tran_hba_private);
2571 	int rval;
2572 
2573 	rval = scsi_hba_probe(sd, callback);
2574 
2575 	if (rval == SCSIPROBE_EXISTS) {
2576 		/*
2577 		 * Set property "pm-capable" on the target device node, so that
2578 		 * the target driver will not try to fetch scsi cycle counters
2579 		 * before enabling device power-management.
2580 		 */
2581 		if ((ddi_prop_update_int(DDI_DEV_T_NONE, sd->sd_dev,
2582 		    "pm-capable", 1)) != DDI_PROP_SUCCESS) {
2583 			sata_log(sata_hba_inst, CE_WARN,
2584 			"SATA device at port %d: will not be power-managed ",
2585 			SCSI_TO_SATA_CPORT(sd->sd_address.a_target));
2586 			SATA_LOG_D((sata_hba_inst, CE_WARN,
2587 			"failure updating pm-capable property"));
2588 		}
2589 	}
2590 	return (rval);
2591 }
2592 
2593 /*
2594  * Implementation of scsi tran_tgt_free.
2595  * Release all resources allocated for scsi_device
2596  */
2597 static void
2598 sata_scsi_tgt_free(dev_info_t *hba_dip, dev_info_t *tgt_dip,
2599     scsi_hba_tran_t *hba_tran, struct scsi_device *sd)
2600 {
2601 #ifndef __lock_lint
2602 	_NOTE(ARGUNUSED(hba_dip))
2603 #endif
2604 	sata_device_t		sata_device;
2605 	sata_drive_info_t	*sdinfo;
2606 	sata_hba_inst_t		*sata_hba_inst;
2607 
2608 	sata_hba_inst = (sata_hba_inst_t *)(hba_tran->tran_hba_private);
2609 
2610 	/* Validate scsi device address */
2611 	if (sata_validate_scsi_address(sata_hba_inst, &sd->sd_address,
2612 	    &sata_device) != 0)
2613 		return;
2614 
2615 	mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst,
2616 	    sata_device.satadev_addr.cport)));
2617 
2618 	/* sata_device now should contain a valid sata address */
2619 	sdinfo = sata_get_device_info(sata_hba_inst, &sata_device);
2620 	if (sdinfo == NULL) {
2621 		mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst,
2622 		    sata_device.satadev_addr.cport)));
2623 		return;
2624 	}
2625 	/*
2626 	 * We did not allocate any resources in sata_scsi_tgt_init()
2627 	 * other than property for ATAPI device, if any
2628 	 */
2629 	if (sata_device.satadev_type == SATA_DTYPE_ATAPICD) {
2630 		mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst,
2631 		    sata_device.satadev_addr.cport)));
2632 		if (ndi_prop_remove(DDI_DEV_T_NONE, tgt_dip, "variant") !=
2633 		    DDI_PROP_SUCCESS)
2634 			SATA_LOG_D((sata_hba_inst, CE_WARN,
2635 			    "sata_scsi_tgt_free: variant atapi "
2636 			    "property could not be removed"));
2637 	} else {
2638 		mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst,
2639 		    sata_device.satadev_addr.cport)));
2640 	}
2641 }
2642 
2643 /*
2644  * Implementation of scsi tran_init_pkt
2645  * Upon successful return, scsi pkt buffer has DMA resources allocated.
2646  *
2647  * It seems that we should always allocate pkt, even if the address is
2648  * for non-existing device - just use some default for dma_attr.
2649  * The reason is that there is no way to communicate this to a caller here.
2650  * Subsequent call to sata_scsi_start may fail appropriately.
2651  * Simply returning NULL does not seem to discourage a target driver...
2652  *
2653  * Returns a pointer to initialized scsi_pkt, or NULL otherwise.
2654  */
2655 static struct scsi_pkt *
2656 sata_scsi_init_pkt(struct scsi_address *ap, struct scsi_pkt *pkt,
2657     struct buf *bp, int cmdlen, int statuslen, int tgtlen, int flags,
2658     int (*callback)(caddr_t), caddr_t arg)
2659 {
2660 	sata_hba_inst_t *sata_hba_inst =
2661 	    (sata_hba_inst_t *)(ap->a_hba_tran->tran_hba_private);
2662 	dev_info_t *dip = SATA_DIP(sata_hba_inst);
2663 	sata_device_t sata_device;
2664 	sata_drive_info_t *sdinfo;
2665 	sata_pkt_txlate_t *spx;
2666 	ddi_dma_attr_t cur_dma_attr;
2667 	int rval;
2668 	boolean_t new_pkt = TRUE;
2669 
2670 	ASSERT(ap->a_hba_tran->tran_hba_dip == dip);
2671 
2672 	/*
2673 	 * We need to translate the address, even if it could be
2674 	 * a bogus one, for a non-existing device
2675 	 */
2676 	sata_device.satadev_addr.qual = SCSI_TO_SATA_ADDR_QUAL(ap->a_target);
2677 	sata_device.satadev_addr.cport = SCSI_TO_SATA_CPORT(ap->a_target);
2678 	sata_device.satadev_addr.pmport = SCSI_TO_SATA_PMPORT(ap->a_target);
2679 	sata_device.satadev_rev = SATA_DEVICE_REV;
2680 
2681 	if (pkt == NULL) {
2682 		/*
2683 		 * Have to allocate a brand new scsi packet.
2684 		 * We need to operate with auto request sense enabled.
2685 		 */
2686 		pkt = scsi_hba_pkt_alloc(dip, ap, cmdlen,
2687 		    MAX(statuslen, sizeof (struct scsi_arq_status)),
2688 		    tgtlen, sizeof (sata_pkt_txlate_t), callback, arg);
2689 
2690 		if (pkt == NULL)
2691 			return (NULL);
2692 
2693 		/* Fill scsi packet structure */
2694 		pkt->pkt_comp		= (void (*)())NULL;
2695 		pkt->pkt_time		= 0;
2696 		pkt->pkt_resid		= 0;
2697 		pkt->pkt_statistics	= 0;
2698 		pkt->pkt_reason		= 0;
2699 
2700 		/*
2701 		 * pkt_hba_private will point to sata pkt txlate structure
2702 		 */
2703 		spx = (sata_pkt_txlate_t *)pkt->pkt_ha_private;
2704 		bzero(spx, sizeof (sata_pkt_txlate_t));
2705 
2706 		spx->txlt_scsi_pkt = pkt;
2707 		spx->txlt_sata_hba_inst = sata_hba_inst;
2708 
2709 		/* Allocate sata_pkt */
2710 		spx->txlt_sata_pkt = sata_pkt_alloc(spx, callback);
2711 		if (spx->txlt_sata_pkt == NULL) {
2712 			/* Could not allocate sata pkt */
2713 			scsi_hba_pkt_free(ap, pkt);
2714 			return (NULL);
2715 		}
2716 		/* Set sata address */
2717 		spx->txlt_sata_pkt->satapkt_device.satadev_addr =
2718 		    sata_device.satadev_addr;
2719 		spx->txlt_sata_pkt->satapkt_device.satadev_rev =
2720 		    sata_device.satadev_rev;
2721 
2722 		if ((bp == NULL) || (bp->b_bcount == 0))
2723 			return (pkt);
2724 
2725 		spx->txlt_total_residue = bp->b_bcount;
2726 	} else {
2727 		new_pkt = FALSE;
2728 		/*
2729 		 * Packet was preallocated/initialized by previous call
2730 		 */
2731 		spx = (sata_pkt_txlate_t *)pkt->pkt_ha_private;
2732 
2733 		if ((bp == NULL) || (bp->b_bcount == 0)) {
2734 			return (pkt);
2735 		}
2736 		ASSERT(spx->txlt_buf_dma_handle != NULL);
2737 
2738 		/* Pkt is available already: spx->txlt_scsi_pkt == pkt; */
2739 	}
2740 
2741 	spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp = bp;
2742 
2743 	/*
2744 	 * We use an adjusted version of the dma_attr, to account
2745 	 * for device addressing limitations.
2746 	 * sata_adjust_dma_attr() will handle sdinfo == NULL which may
2747 	 * happen when a device is not yet configured.
2748 	 */
2749 	mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst,
2750 	    sata_device.satadev_addr.cport)));
2751 	sdinfo = sata_get_device_info(spx->txlt_sata_hba_inst,
2752 	    &spx->txlt_sata_pkt->satapkt_device);
2753 	/* NULL sdinfo may be passsed to sata_adjust_dma_attr() */
2754 	sata_adjust_dma_attr(sdinfo,
2755 	    SATA_DMA_ATTR(spx->txlt_sata_hba_inst), &cur_dma_attr);
2756 	mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst,
2757 	    sata_device.satadev_addr.cport)));
2758 	/*
2759 	 * Allocate necessary DMA resources for the packet's data buffer
2760 	 * NOTE:
2761 	 * In case of read/write commands, DMA resource allocation here is
2762 	 * based on the premise that the transfer length specified in
2763 	 * the read/write scsi cdb will match exactly DMA resources -
2764 	 * returning correct packet residue is crucial.
2765 	 */
2766 	if ((rval = sata_dma_buf_setup(spx, flags, callback, arg,
2767 	    &cur_dma_attr)) != DDI_SUCCESS) {
2768 		spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp = NULL;
2769 		sata_pkt_free(spx);
2770 		/*
2771 		 * If a DMA allocation request fails with
2772 		 * DDI_DMA_NOMAPPING, indicate the error by calling
2773 		 * bioerror(9F) with bp and an error code of EFAULT.
2774 		 * If a DMA allocation request fails with
2775 		 * DDI_DMA_TOOBIG, indicate the error by calling
2776 		 * bioerror(9F) with bp and an error code of EINVAL.
2777 		 */
2778 		switch (rval) {
2779 		case DDI_DMA_NORESOURCES:
2780 			bioerror(bp, 0);
2781 			break;
2782 		case DDI_DMA_NOMAPPING:
2783 		case DDI_DMA_BADATTR:
2784 			bioerror(bp, EFAULT);
2785 			break;
2786 		case DDI_DMA_TOOBIG:
2787 		default:
2788 			bioerror(bp, EINVAL);
2789 			break;
2790 		}
2791 		if (new_pkt == TRUE)
2792 			scsi_hba_pkt_free(ap, pkt);
2793 		return (NULL);
2794 	}
2795 	/* Set number of bytes that are not yet accounted for */
2796 	pkt->pkt_resid = spx->txlt_total_residue;
2797 	ASSERT(pkt->pkt_resid >= 0);
2798 
2799 	return (pkt);
2800 }
2801 
2802 /*
2803  * Implementation of scsi tran_start.
2804  * Translate scsi cmd into sata operation and return status.
2805  * Supported scsi commands:
2806  * SCMD_INQUIRY
2807  * SCMD_TEST_UNIT_READY
2808  * SCMD_START_STOP
2809  * SCMD_READ_CAPACITY
2810  * SCMD_REQUEST_SENSE
2811  * SCMD_LOG_SENSE_G1
2812  * SCMD_LOG_SELECT_G1
2813  * SCMD_MODE_SENSE	(specific pages)
2814  * SCMD_MODE_SENSE_G1	(specific pages)
2815  * SCMD_MODE_SELECT	(specific pages)
2816  * SCMD_MODE_SELECT_G1	(specific pages)
2817  * SCMD_SYNCHRONIZE_CACHE
2818  * SCMD_SYNCHRONIZE_CACHE_G1
2819  * SCMD_READ
2820  * SCMD_READ_G1
2821  * SCMD_READ_G4
2822  * SCMD_READ_G5
2823  * SCMD_WRITE
2824  * SCMD_WRITE_G1
2825  * SCMD_WRITE_G4
2826  * SCMD_WRITE_G5
2827  * SCMD_SEEK		(noop)
2828  * SCMD_SDIAG
2829  *
2830  * All other commands are rejected as unsupported.
2831  *
2832  * Returns:
2833  * TRAN_ACCEPT if command was executed successfully or accepted by HBA driver
2834  * for execution.
2835  * TRAN_BADPKT if cmd was directed to invalid address.
2836  * TRAN_FATAL_ERROR is command was rejected due to hardware error, including
2837  * unexpected removal of a device or some other unspecified error.
2838  * TRAN_BUSY if command could not be executed becasue HBA driver or SATA
2839  * framework was busy performing some other operation(s).
2840  *
2841  */
2842 static int
2843 sata_scsi_start(struct scsi_address *ap, struct scsi_pkt *pkt)
2844 {
2845 	sata_hba_inst_t *sata_hba_inst =
2846 	    (sata_hba_inst_t *)(ap->a_hba_tran->tran_hba_private);
2847 	sata_pkt_txlate_t *spx = (sata_pkt_txlate_t *)pkt->pkt_ha_private;
2848 	sata_drive_info_t *sdinfo;
2849 	struct buf *bp;
2850 	int cport;
2851 	int rval;
2852 
2853 	SATADBG1(SATA_DBG_SCSI_IF, sata_hba_inst,
2854 	    "sata_scsi_start: cmd 0x%02x\n", pkt->pkt_cdbp[0]);
2855 
2856 	ASSERT(spx != NULL &&
2857 	    spx->txlt_scsi_pkt == pkt && spx->txlt_sata_pkt != NULL);
2858 
2859 	cport = SCSI_TO_SATA_CPORT(ap->a_target);
2860 
2861 	mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, cport)));
2862 	sdinfo = sata_get_device_info(sata_hba_inst,
2863 	    &spx->txlt_sata_pkt->satapkt_device);
2864 	if (sdinfo == NULL ||
2865 	    SATA_CPORT_INFO(sata_hba_inst, cport)->cport_tgtnode_clean ==
2866 	    B_FALSE) {
2867 		mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, cport)));
2868 		pkt->pkt_reason = CMD_DEV_GONE;
2869 		/*
2870 		 * The sd target driver is checking CMD_DEV_GONE pkt_reason
2871 		 * only in callback function (for normal requests) and
2872 		 * in the dump code path.
2873 		 * So, if the callback is available, we need to do
2874 		 * the callback rather than returning TRAN_FATAL_ERROR here.
2875 		 */
2876 		if (pkt->pkt_comp != NULL) {
2877 			/* scsi callback required */
2878 			if (taskq_dispatch(SATA_TXLT_TASKQ(spx),
2879 			    (task_func_t *)pkt->pkt_comp,
2880 			    (void *)pkt, TQ_SLEEP) == NULL)
2881 				/* Scheduling the callback failed */
2882 				return (TRAN_BUSY);
2883 			return (TRAN_ACCEPT);
2884 		}
2885 		/* No callback available */
2886 		return (TRAN_FATAL_ERROR);
2887 	}
2888 
2889 	if (sdinfo->satadrv_type == SATA_DTYPE_ATAPICD) {
2890 		mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, cport)));
2891 		rval = sata_txlt_atapi(spx);
2892 		SATADBG1(SATA_DBG_SCSI_IF, sata_hba_inst,
2893 		    "sata_scsi_start atapi: rval %d\n", rval);
2894 		return (rval);
2895 	}
2896 	mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, cport)));
2897 
2898 	/* ATA Disk commands processing starts here */
2899 
2900 	bp = spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp;
2901 
2902 	switch (pkt->pkt_cdbp[0]) {
2903 
2904 	case SCMD_INQUIRY:
2905 		/* Mapped to identify device */
2906 		if (bp != NULL && (bp->b_flags & (B_PHYS | B_PAGEIO)))
2907 			bp_mapin(bp);
2908 		rval = sata_txlt_inquiry(spx);
2909 		break;
2910 
2911 	case SCMD_TEST_UNIT_READY:
2912 		/*
2913 		 * SAT "SATA to ATA Translation" doc specifies translation
2914 		 * to ATA CHECK POWER MODE.
2915 		 */
2916 		rval = sata_txlt_test_unit_ready(spx);
2917 		break;
2918 
2919 	case SCMD_START_STOP:
2920 		/* Mapping depends on the command */
2921 		rval = sata_txlt_start_stop_unit(spx);
2922 		break;
2923 
2924 	case SCMD_READ_CAPACITY:
2925 		if (bp != NULL && (bp->b_flags & (B_PHYS | B_PAGEIO)))
2926 			bp_mapin(bp);
2927 		rval = sata_txlt_read_capacity(spx);
2928 		break;
2929 
2930 	case SCMD_REQUEST_SENSE:
2931 		/*
2932 		 * Always No Sense, since we force ARQ
2933 		 */
2934 		if (bp != NULL && (bp->b_flags & (B_PHYS | B_PAGEIO)))
2935 			bp_mapin(bp);
2936 		rval = sata_txlt_request_sense(spx);
2937 		break;
2938 
2939 	case SCMD_LOG_SENSE_G1:
2940 		if (bp != NULL && (bp->b_flags & (B_PHYS | B_PAGEIO)))
2941 			bp_mapin(bp);
2942 		rval = sata_txlt_log_sense(spx);
2943 		break;
2944 
2945 	case SCMD_LOG_SELECT_G1:
2946 		if (bp != NULL && (bp->b_flags & (B_PHYS | B_PAGEIO)))
2947 			bp_mapin(bp);
2948 		rval = sata_txlt_log_select(spx);
2949 		break;
2950 
2951 	case SCMD_MODE_SENSE:
2952 	case SCMD_MODE_SENSE_G1:
2953 		if (bp != NULL && (bp->b_flags & (B_PHYS | B_PAGEIO)))
2954 			bp_mapin(bp);
2955 		rval = sata_txlt_mode_sense(spx);
2956 		break;
2957 
2958 
2959 	case SCMD_MODE_SELECT:
2960 	case SCMD_MODE_SELECT_G1:
2961 		if (bp != NULL && (bp->b_flags & (B_PHYS | B_PAGEIO)))
2962 			bp_mapin(bp);
2963 		rval = sata_txlt_mode_select(spx);
2964 		break;
2965 
2966 	case SCMD_SYNCHRONIZE_CACHE:
2967 	case SCMD_SYNCHRONIZE_CACHE_G1:
2968 		rval = sata_txlt_synchronize_cache(spx);
2969 		break;
2970 
2971 	case SCMD_READ:
2972 	case SCMD_READ_G1:
2973 	case SCMD_READ_G4:
2974 	case SCMD_READ_G5:
2975 		rval = sata_txlt_read(spx);
2976 		break;
2977 
2978 	case SCMD_WRITE:
2979 	case SCMD_WRITE_G1:
2980 	case SCMD_WRITE_G4:
2981 	case SCMD_WRITE_G5:
2982 		rval = sata_txlt_write(spx);
2983 		break;
2984 
2985 	case SCMD_SEEK:
2986 		rval = sata_txlt_nodata_cmd_immediate(spx);
2987 		break;
2988 
2989 		/* Other cases will be filed later */
2990 		/* postponed until phase 2 of the development */
2991 	default:
2992 		rval = sata_txlt_invalid_command(spx);
2993 		break;
2994 	}
2995 
2996 	SATADBG1(SATA_DBG_SCSI_IF, sata_hba_inst,
2997 	    "sata_scsi_start: rval %d\n", rval);
2998 
2999 	return (rval);
3000 }
3001 
3002 /*
3003  * Implementation of scsi tran_abort.
3004  * Abort specific pkt or all packets.
3005  *
3006  * Returns 1 if one or more packets were aborted, returns 0 otherwise
3007  *
3008  * May be called from an interrupt level.
3009  */
3010 static int
3011 sata_scsi_abort(struct scsi_address *ap, struct scsi_pkt *scsi_pkt)
3012 {
3013 	sata_hba_inst_t *sata_hba_inst =
3014 	    (sata_hba_inst_t *)(ap->a_hba_tran->tran_hba_private);
3015 	sata_device_t	sata_device;
3016 	sata_pkt_t	*sata_pkt;
3017 
3018 	SATADBG2(SATA_DBG_SCSI_IF, sata_hba_inst,
3019 	    "sata_scsi_abort: %s at target: 0x%x\n",
3020 	    scsi_pkt == NULL ? "all packets" : "one pkt", ap->a_target);
3021 
3022 	/* Validate address */
3023 	if (sata_validate_scsi_address(sata_hba_inst, ap, &sata_device) != 0)
3024 		/* Invalid address */
3025 		return (0);
3026 
3027 	mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst,
3028 	    sata_device.satadev_addr.cport)));
3029 	if (sata_get_device_info(sata_hba_inst, &sata_device) == NULL) {
3030 		/* invalid address */
3031 		mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst,
3032 		    sata_device.satadev_addr.cport)));
3033 		return (0);
3034 	}
3035 	if (scsi_pkt == NULL) {
3036 		/*
3037 		 * Abort all packets.
3038 		 * Although we do not have specific packet, we still need
3039 		 * dummy packet structure to pass device address to HBA.
3040 		 * Allocate one, without sleeping. Fail if pkt cannot be
3041 		 * allocated.
3042 		 */
3043 		sata_pkt = kmem_zalloc(sizeof (sata_pkt_t), KM_NOSLEEP);
3044 		if (sata_pkt == NULL) {
3045 			mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst,
3046 			    sata_device.satadev_addr.cport)));
3047 			SATA_LOG_D((sata_hba_inst, CE_WARN, "sata_pkt_abort: "
3048 			    "could not allocate sata_pkt"));
3049 			return (0);
3050 		}
3051 		sata_pkt->satapkt_rev = SATA_PKT_REV;
3052 		sata_pkt->satapkt_device = sata_device;
3053 		sata_pkt->satapkt_device.satadev_rev = SATA_DEVICE_REV;
3054 	} else {
3055 		if (scsi_pkt->pkt_ha_private == NULL) {
3056 			mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst,
3057 			    sata_device.satadev_addr.cport)));
3058 			return (0); /* Bad scsi pkt */
3059 		}
3060 		/* extract pointer to sata pkt */
3061 		sata_pkt = ((sata_pkt_txlate_t *)scsi_pkt->pkt_ha_private)->
3062 		    txlt_sata_pkt;
3063 	}
3064 
3065 	mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst,
3066 	    sata_device.satadev_addr.cport)));
3067 	/* Send abort request to HBA */
3068 	if ((*SATA_ABORT_FUNC(sata_hba_inst))
3069 	    (SATA_DIP(sata_hba_inst), sata_pkt,
3070 	    scsi_pkt == NULL ? SATA_ABORT_ALL_PACKETS : SATA_ABORT_PACKET) ==
3071 	    SATA_SUCCESS) {
3072 		if (scsi_pkt == NULL)
3073 			kmem_free(sata_pkt, sizeof (sata_pkt_t));
3074 		/* Success */
3075 		return (1);
3076 	}
3077 	/* Else, something did not go right */
3078 	if (scsi_pkt == NULL)
3079 		kmem_free(sata_pkt, sizeof (sata_pkt_t));
3080 	/* Failure */
3081 	return (0);
3082 }
3083 
3084 
3085 /*
3086  * Implementation os scsi tran_reset.
3087  * RESET_ALL request is translated into port reset.
3088  * RESET_TARGET requests is translated into a device reset,
3089  * RESET_LUN request is accepted only for LUN 0 and translated into
3090  * device reset.
3091  * The target reset should cause all HBA active and queued packets to
3092  * be terminated and returned with pkt reason SATA_PKT_RESET prior to
3093  * the return. HBA should report reset event for the device.
3094  *
3095  * Returns 1 upon success, 0 upon failure.
3096  */
3097 static int
3098 sata_scsi_reset(struct scsi_address *ap, int level)
3099 {
3100 	sata_hba_inst_t	*sata_hba_inst =
3101 	    (sata_hba_inst_t *)(ap->a_hba_tran->tran_hba_private);
3102 	sata_device_t	sata_device;
3103 	int		val;
3104 
3105 	SATADBG2(SATA_DBG_SCSI_IF, sata_hba_inst,
3106 	    "sata_scsi_reset: level %d target: 0x%x\n",
3107 	    level, ap->a_target);
3108 
3109 	/* Validate address */
3110 	val = sata_validate_scsi_address(sata_hba_inst, ap, &sata_device);
3111 	if (val == -1)
3112 		/* Invalid address */
3113 		return (0);
3114 
3115 	mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst,
3116 	    sata_device.satadev_addr.cport)));
3117 	if (sata_get_device_info(sata_hba_inst, &sata_device) == NULL) {
3118 		/* invalid address */
3119 		mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst,
3120 		    sata_device.satadev_addr.cport)));
3121 		return (0);
3122 	}
3123 	mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst,
3124 	    sata_device.satadev_addr.cport)));
3125 	if (level == RESET_ALL) {
3126 		/* port reset - cport only */
3127 		sata_device.satadev_addr.qual = SATA_ADDR_CPORT;
3128 		if ((*SATA_RESET_DPORT_FUNC(sata_hba_inst))
3129 		    (SATA_DIP(sata_hba_inst), &sata_device) == SATA_SUCCESS)
3130 			return (1);
3131 		else
3132 			return (0);
3133 
3134 	} else if (val == 0 &&
3135 	    (level == RESET_TARGET || level == RESET_LUN)) {
3136 		/* reset device (device attached) */
3137 		if ((*SATA_RESET_DPORT_FUNC(sata_hba_inst))
3138 		    (SATA_DIP(sata_hba_inst), &sata_device) == SATA_SUCCESS)
3139 			return (1);
3140 		else
3141 			return (0);
3142 	}
3143 	return (0);
3144 }
3145 
3146 
3147 /*
3148  * Implementation of scsi tran_getcap (get transport/device capabilities).
3149  * Supported capabilities:
3150  * auto-rqsense		(always supported)
3151  * tagged-qing		(supported if HBA supports it)
3152  * untagged-qing	(could be supported if disk supports it, but because
3153  *			 caching behavior allowing untagged queuing actually
3154  *			 results in reduced performance.  sd tries to throttle
3155  *			 back to only 3 outstanding commands, which may
3156  *			 work for real SCSI disks, but with read ahead
3157  *			 caching, having more than 1 outstanding command
3158  *			 results in cache thrashing.)
3159  * dma_max
3160  * interconnect-type	(INTERCONNECT_SATA)
3161  *
3162  * Request for other capabilities is rejected as unsupported.
3163  *
3164  * Returns supported capability value, or -1 if capability is unsuppported or
3165  * the address is invalid (no device).
3166  */
3167 
3168 static int
3169 sata_scsi_getcap(struct scsi_address *ap, char *cap, int whom)
3170 {
3171 
3172 	sata_hba_inst_t 	*sata_hba_inst =
3173 	    (sata_hba_inst_t *)(ap->a_hba_tran->tran_hba_private);
3174 	sata_device_t		sata_device;
3175 	sata_drive_info_t	*sdinfo;
3176 	ddi_dma_attr_t		adj_dma_attr;
3177 	int 			rval;
3178 
3179 	SATADBG2(SATA_DBG_SCSI_IF, sata_hba_inst,
3180 	    "sata_scsi_getcap: target: 0x%x, cap: %s\n",
3181 	    ap->a_target, cap);
3182 
3183 	/*
3184 	 * We want to process the capabilities on per port granularity.
3185 	 * So, we are specifically restricting ourselves to whom != 0
3186 	 * to exclude the controller wide handling.
3187 	 */
3188 	if (cap == NULL || whom == 0)
3189 		return (-1);
3190 
3191 	if (sata_validate_scsi_address(sata_hba_inst, ap, &sata_device) != 0) {
3192 		/* Invalid address */
3193 		return (-1);
3194 	}
3195 	mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst,
3196 	    sata_device.satadev_addr.cport)));
3197 	if ((sdinfo = sata_get_device_info(sata_hba_inst, &sata_device)) ==
3198 	    NULL) {
3199 		/* invalid address */
3200 		mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst,
3201 		    sata_device.satadev_addr.cport)));
3202 		return (-1);
3203 	}
3204 
3205 	switch (scsi_hba_lookup_capstr(cap)) {
3206 	case SCSI_CAP_ARQ:
3207 		rval = 1;		/* ARQ supported, turned on */
3208 		break;
3209 
3210 	case SCSI_CAP_SECTOR_SIZE:
3211 		if (sdinfo->satadrv_type == SATA_DTYPE_ATADISK)
3212 			rval = SATA_DISK_SECTOR_SIZE;	/* fixed size */
3213 		else if (sdinfo->satadrv_type == SATA_DTYPE_ATAPICD)
3214 			rval = SATA_ATAPI_SECTOR_SIZE;
3215 		else rval = -1;
3216 		break;
3217 
3218 	/*
3219 	 * untagged queuing cause a performance inversion because of
3220 	 * the way sd operates.  Because of this reason we do not
3221 	 * use it when available.
3222 	 */
3223 	case SCSI_CAP_UNTAGGED_QING:
3224 		if (sdinfo->satadrv_features_enabled &
3225 		    SATA_DEV_F_E_UNTAGGED_QING)
3226 			rval = 1;	/* Untagged queuing available */
3227 		else
3228 			rval = -1;	/* Untagged queuing not available */
3229 		break;
3230 
3231 	case SCSI_CAP_TAGGED_QING:
3232 		if (sdinfo->satadrv_features_enabled & SATA_DEV_F_E_TAGGED_QING)
3233 			rval = 1;	/* Tagged queuing available */
3234 		else
3235 			rval = -1;	/* Tagged queuing not available */
3236 		break;
3237 
3238 	case SCSI_CAP_DMA_MAX:
3239 		sata_adjust_dma_attr(sdinfo, SATA_DMA_ATTR(sata_hba_inst),
3240 		    &adj_dma_attr);
3241 		rval = (int)adj_dma_attr.dma_attr_maxxfer;
3242 		/* We rely on the fact that dma_attr_maxxfer < 0x80000000 */
3243 		break;
3244 
3245 	case SCSI_CAP_INTERCONNECT_TYPE:
3246 		rval = INTERCONNECT_SATA;	/* SATA interconnect type */
3247 		break;
3248 
3249 	default:
3250 		rval = -1;
3251 		break;
3252 	}
3253 	mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst,
3254 	    sata_device.satadev_addr.cport)));
3255 	return (rval);
3256 }
3257 
3258 /*
3259  * Implementation of scsi tran_setcap
3260  */
3261 static int
3262 sata_scsi_setcap(struct scsi_address *ap, char *cap, int value, int whom)
3263 {
3264 	sata_hba_inst_t	*sata_hba_inst =
3265 	    (sata_hba_inst_t *)(ap->a_hba_tran->tran_hba_private);
3266 	sata_device_t	sata_device;
3267 	sata_drive_info_t	*sdinfo;
3268 	int		rval;
3269 
3270 	SATADBG2(SATA_DBG_SCSI_IF, sata_hba_inst,
3271 	    "sata_scsi_setcap: target: 0x%x, cap: %s\n", ap->a_target, cap);
3272 
3273 	/*
3274 	 * We want to process the capabilities on per port granularity.
3275 	 * So, we are specifically restricting ourselves to whom != 0
3276 	 * to exclude the controller wide handling.
3277 	 */
3278 	if (cap == NULL || whom == 0) {
3279 		return (-1);
3280 	}
3281 
3282 	if (sata_validate_scsi_address(sata_hba_inst, ap, &sata_device) != 0) {
3283 		/* Invalid address */
3284 		return (-1);
3285 	}
3286 	mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst,
3287 	    sata_device.satadev_addr.cport)));
3288 	if ((sdinfo = sata_get_device_info(sata_hba_inst, &sata_device))
3289 		== NULL) {
3290 		/* invalid address */
3291 		mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst,
3292 		    sata_device.satadev_addr.cport)));
3293 		return (-1);
3294 	}
3295 	mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst,
3296 	    sata_device.satadev_addr.cport)));
3297 
3298 	switch (scsi_hba_lookup_capstr(cap)) {
3299 	case SCSI_CAP_ARQ:
3300 	case SCSI_CAP_SECTOR_SIZE:
3301 	case SCSI_CAP_DMA_MAX:
3302 	case SCSI_CAP_INTERCONNECT_TYPE:
3303 		rval = 0;
3304 		break;
3305 	case SCSI_CAP_UNTAGGED_QING:
3306 		if (SATA_QDEPTH(sata_hba_inst) > 1) {
3307 			rval = 1;
3308 			if (value == 1) {
3309 				sdinfo->satadrv_features_enabled |=
3310 					SATA_DEV_F_E_UNTAGGED_QING;
3311 			} else if (value == 0) {
3312 				sdinfo->satadrv_features_enabled &=
3313 					~SATA_DEV_F_E_UNTAGGED_QING;
3314 			} else {
3315 				rval = -1;
3316 			}
3317 		} else {
3318 			rval = 0;
3319 		}
3320 		break;
3321 	case SCSI_CAP_TAGGED_QING:
3322 		/* This can TCQ or NCQ */
3323 		if (sata_func_enable & SATA_ENABLE_QUEUING &&
3324 		    ((sdinfo->satadrv_features_support & SATA_DEV_F_TCQ &&
3325 		    SATA_FEATURES(sata_hba_inst) & SATA_CTLF_QCMD) ||
3326 		    (sata_func_enable & SATA_ENABLE_NCQ &&
3327 		    sdinfo->satadrv_features_support & SATA_DEV_F_NCQ &&
3328 		    SATA_FEATURES(sata_hba_inst) & SATA_CTLF_NCQ))) {
3329 			rval = 1;
3330 			if (value == 1) {
3331 				sdinfo->satadrv_features_enabled |=
3332 					SATA_DEV_F_E_TAGGED_QING;
3333 			} else if (value == 0) {
3334 				sdinfo->satadrv_features_enabled &=
3335 					~SATA_DEV_F_E_TAGGED_QING;
3336 			} else {
3337 				rval = -1;
3338 			}
3339 		} else {
3340 			rval = 0;
3341 		}
3342 		break;
3343 	default:
3344 		rval = -1;
3345 		break;
3346 	}
3347 	return (rval);
3348 }
3349 
3350 /*
3351  * Implementations of scsi tran_destroy_pkt.
3352  * Free resources allocated by sata_scsi_init_pkt()
3353  */
3354 static void
3355 sata_scsi_destroy_pkt(struct scsi_address *ap, struct scsi_pkt *pkt)
3356 {
3357 	sata_pkt_txlate_t *spx;
3358 
3359 	ASSERT(pkt != NULL);
3360 	spx = (sata_pkt_txlate_t *)pkt->pkt_ha_private;
3361 
3362 	if (spx->txlt_buf_dma_handle != NULL) {
3363 		if (spx->txlt_tmp_buf != NULL)  {
3364 		    ASSERT(spx->txlt_tmp_buf_handle != 0);
3365 			/*
3366 			 * Intermediate DMA buffer was allocated.
3367 			 * Free allocated buffer and associated access handle.
3368 			 */
3369 			ddi_dma_mem_free(&spx->txlt_tmp_buf_handle);
3370 			spx->txlt_tmp_buf = NULL;
3371 		}
3372 		/*
3373 		 * Free DMA resources - cookies and handles
3374 		 */
3375 		ASSERT(spx->txlt_dma_cookie_list != NULL);
3376 		if (spx->txlt_dma_cookie_list != &spx->txlt_dma_cookie) {
3377 			(void) kmem_free(spx->txlt_dma_cookie_list,
3378 			    spx->txlt_dma_cookie_list_len *
3379 			    sizeof (ddi_dma_cookie_t));
3380 			spx->txlt_dma_cookie_list = NULL;
3381 		}
3382 		(void) ddi_dma_unbind_handle(spx->txlt_buf_dma_handle);
3383 		(void) ddi_dma_free_handle(&spx->txlt_buf_dma_handle);
3384 	}
3385 	spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp = NULL;
3386 	sata_pkt_free(spx);
3387 
3388 	scsi_hba_pkt_free(ap, pkt);
3389 }
3390 
3391 /*
3392  * Implementation of scsi tran_dmafree.
3393  * Free DMA resources allocated by sata_scsi_init_pkt()
3394  */
3395 
3396 static void
3397 sata_scsi_dmafree(struct scsi_address *ap, struct scsi_pkt *pkt)
3398 {
3399 #ifndef __lock_lint
3400 	_NOTE(ARGUNUSED(ap))
3401 #endif
3402 	sata_pkt_txlate_t *spx;
3403 
3404 	ASSERT(pkt != NULL);
3405 	spx = (sata_pkt_txlate_t *)pkt->pkt_ha_private;
3406 
3407 	if (spx->txlt_buf_dma_handle != NULL) {
3408 		/*
3409 		 * Free DMA resources - cookies and handles
3410 		 */
3411 		ASSERT(spx->txlt_dma_cookie_list != NULL);
3412 		if (spx->txlt_dma_cookie_list != &spx->txlt_dma_cookie) {
3413 			(void) kmem_free(spx->txlt_dma_cookie_list,
3414 			    spx->txlt_dma_cookie_list_len *
3415 			    sizeof (ddi_dma_cookie_t));
3416 			spx->txlt_dma_cookie_list = NULL;
3417 		}
3418 		(void) ddi_dma_unbind_handle(spx->txlt_buf_dma_handle);
3419 		(void) ddi_dma_free_handle(&spx->txlt_buf_dma_handle);
3420 	}
3421 }
3422 
3423 /*
3424  * Implementation of scsi tran_sync_pkt.
3425  *
3426  * The assumption below is that pkt is unique - there is no need to check ap
3427  *
3428  * Synchronize DMA buffer and, if the intermediate buffer is used, copy data
3429  * into/from the real buffer.
3430  */
3431 static void
3432 sata_scsi_sync_pkt(struct scsi_address *ap, struct scsi_pkt *pkt)
3433 {
3434 #ifndef __lock_lint
3435 	_NOTE(ARGUNUSED(ap))
3436 #endif
3437 	int rval;
3438 	sata_pkt_txlate_t *spx = (sata_pkt_txlate_t *)pkt->pkt_ha_private;
3439 	struct buf *bp;
3440 	int direction;
3441 
3442 	ASSERT(spx != NULL);
3443 	if (spx->txlt_buf_dma_handle != NULL) {
3444 		direction = spx->txlt_sata_pkt->
3445 		    satapkt_cmd.satacmd_flags.sata_data_direction;
3446 		if (spx->txlt_sata_pkt != NULL &&
3447 		    direction != SATA_DIR_NODATA_XFER) {
3448 			if (spx->txlt_tmp_buf != NULL) {
3449 				/* Intermediate DMA buffer used */
3450 				bp = spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp;
3451 
3452 				if (direction & SATA_DIR_WRITE) {
3453 					bcopy(bp->b_un.b_addr,
3454 					    spx->txlt_tmp_buf, bp->b_bcount);
3455 				}
3456 			}
3457 			/* Sync the buffer for device or for CPU */
3458 			rval = ddi_dma_sync(spx->txlt_buf_dma_handle,   0, 0,
3459 			    (direction & SATA_DIR_WRITE) ?
3460 			    DDI_DMA_SYNC_FORDEV :  DDI_DMA_SYNC_FORCPU);
3461 			ASSERT(rval == DDI_SUCCESS);
3462 			if (spx->txlt_tmp_buf != NULL &&
3463 			    !(direction & SATA_DIR_WRITE)) {
3464 				/* Intermediate DMA buffer used for read */
3465 				bcopy(spx->txlt_tmp_buf,
3466 				    bp->b_un.b_addr, bp->b_bcount);
3467 			}
3468 
3469 		}
3470 	}
3471 }
3472 
3473 
3474 
3475 /* *******************  SATA - SCSI Translation functions **************** */
3476 /*
3477  * SCSI to SATA pkt and command translation and SATA to SCSI status/error
3478  * translation.
3479  */
3480 
3481 /*
3482  * Checks if a device exists and can be access and translates common
3483  * scsi_pkt data to sata_pkt data.
3484  *
3485  * Returns TRAN_ACCEPT and scsi pkt_reason CMD_CMPLT if device exists and
3486  * sata_pkt was set-up.
3487  * Returns TRAN_ACCEPT and scsi pkt_reason CMD_DEV_GONE if device does not
3488  * exist and pkt_comp callback was scheduled.
3489 
3490  * Returns other TRAN_XXXXX values when error occured and command should be
3491  * rejected with the returned TRAN_XXXXX value.
3492  *
3493  * This function should be called with port mutex held.
3494  */
3495 static int
3496 sata_txlt_generic_pkt_info(sata_pkt_txlate_t *spx)
3497 {
3498 	sata_drive_info_t *sdinfo;
3499 	sata_device_t sata_device;
3500 	const struct sata_cmd_flags sata_initial_cmd_flags = {
3501 		SATA_DIR_NODATA_XFER,
3502 		/* all other values to 0/FALSE */
3503 	};
3504 	/*
3505 	 * Pkt_reason has to be set if the pkt_comp callback is invoked,
3506 	 * and that implies TRAN_ACCEPT return value. Any other returned value
3507 	 * indicates that the scsi packet was not accepted (the reason will not
3508 	 * be checked by the scsi traget driver).
3509 	 * To make debugging easier, we set pkt_reason to know value here.
3510 	 * It may be changed later when different completion reason is
3511 	 * determined.
3512 	 */
3513 	spx->txlt_scsi_pkt->pkt_reason = CMD_TRAN_ERR;
3514 
3515 	/* Validate address */
3516 	switch (sata_validate_scsi_address(spx->txlt_sata_hba_inst,
3517 	    &spx->txlt_scsi_pkt->pkt_address, &sata_device)) {
3518 
3519 	case -1:
3520 		/* Invalid address or invalid device type */
3521 		return (TRAN_BADPKT);
3522 	case 1:
3523 		/* valid address but no device - it has disappeared ? */
3524 		spx->txlt_scsi_pkt->pkt_reason = CMD_DEV_GONE;
3525 		/*
3526 		 * The sd target driver is checking CMD_DEV_GONE pkt_reason
3527 		 * only in callback function (for normal requests) and
3528 		 * in the dump code path.
3529 		 * So, if the callback is available, we need to do
3530 		 * the callback rather than returning TRAN_FATAL_ERROR here.
3531 		 */
3532 		if (spx->txlt_scsi_pkt->pkt_comp != NULL) {
3533 			/* scsi callback required */
3534 			if (taskq_dispatch(SATA_TXLT_TASKQ(spx),
3535 			    (task_func_t *)spx->txlt_scsi_pkt->pkt_comp,
3536 			    (void *)spx->txlt_scsi_pkt,
3537 			    TQ_SLEEP) == NULL)
3538 				/* Scheduling the callback failed */
3539 				return (TRAN_BUSY);
3540 
3541 			return (TRAN_ACCEPT);
3542 		}
3543 		return (TRAN_FATAL_ERROR);
3544 	default:
3545 		/* all OK */
3546 		break;
3547 	}
3548 	sdinfo = sata_get_device_info(spx->txlt_sata_hba_inst,
3549 	    &spx->txlt_sata_pkt->satapkt_device);
3550 
3551 	/*
3552 	 * If device is in reset condition, reject the packet with
3553 	 * TRAN_BUSY, unless:
3554 	 * 1. system is panicking (dumping)
3555 	 * In such case only one thread is running and there is no way to
3556 	 * process reset.
3557 	 * 2. cfgadm operation is is progress (internal APCTL lock is set)
3558 	 * Some cfgadm operations involve drive commands, so reset condition
3559 	 * needs to be ignored for IOCTL operations.
3560 	 */
3561 	if ((sdinfo->satadrv_event_flags &
3562 	    (SATA_EVNT_DEVICE_RESET | SATA_EVNT_INPROC_DEVICE_RESET)) != 0) {
3563 
3564 		if (!ddi_in_panic() &&
3565 		    ((SATA_CPORT_EVENT_FLAGS(spx->txlt_sata_hba_inst,
3566 		    sata_device.satadev_addr.cport) &
3567 		    SATA_APCTL_LOCK_PORT_BUSY) == 0)) {
3568 			spx->txlt_scsi_pkt->pkt_reason = CMD_INCOMPLETE;
3569 			SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst,
3570 			    "sata_scsi_start: rejecting command because "
3571 			    "of device reset state\n", NULL);
3572 			return (TRAN_BUSY);
3573 		}
3574 	}
3575 
3576 	/*
3577 	 * Fix the dev_type in the sata_pkt->satapkt_device. It was not set by
3578 	 * sata_scsi_pkt_init() because pkt init had to work also with
3579 	 * non-existing devices.
3580 	 * Now we know that the packet was set-up for a real device, so its
3581 	 * type is known.
3582 	 */
3583 	spx->txlt_sata_pkt->satapkt_device.satadev_type = sdinfo->satadrv_type;
3584 
3585 	spx->txlt_sata_pkt->satapkt_cmd.satacmd_flags = sata_initial_cmd_flags;
3586 	if ((SATA_CPORT_INFO(spx->txlt_sata_hba_inst,
3587 	    sata_device.satadev_addr.cport)->cport_event_flags &
3588 	    SATA_APCTL_LOCK_PORT_BUSY) != 0) {
3589 		spx->txlt_sata_pkt->satapkt_cmd.satacmd_flags.
3590 		    sata_ignore_dev_reset = B_TRUE;
3591 	}
3592 	/*
3593 	 * At this point the generic translation routine determined that the
3594 	 * scsi packet should be accepted. Packet completion reason may be
3595 	 * changed later when a different completion reason is determined.
3596 	 */
3597 	spx->txlt_scsi_pkt->pkt_reason = CMD_CMPLT;
3598 
3599 	if ((spx->txlt_scsi_pkt->pkt_flags & FLAG_NOINTR) != 0) {
3600 		/* Synchronous execution */
3601 		spx->txlt_sata_pkt->satapkt_op_mode = SATA_OPMODE_SYNCH |
3602 		    SATA_OPMODE_POLLING;
3603 		spx->txlt_sata_pkt->satapkt_cmd.satacmd_flags.
3604 		    sata_ignore_dev_reset = ddi_in_panic();
3605 	} else {
3606 		/* Asynchronous execution */
3607 		spx->txlt_sata_pkt->satapkt_op_mode = SATA_OPMODE_ASYNCH |
3608 		    SATA_OPMODE_INTERRUPTS;
3609 	}
3610 	/* Convert queuing information */
3611 	if (spx->txlt_scsi_pkt->pkt_flags & FLAG_STAG)
3612 		spx->txlt_sata_pkt->satapkt_cmd.satacmd_flags.sata_queue_stag =
3613 		    B_TRUE;
3614 	else if (spx->txlt_scsi_pkt->pkt_flags &
3615 	    (FLAG_OTAG | FLAG_HTAG | FLAG_HEAD))
3616 		spx->txlt_sata_pkt->satapkt_cmd.satacmd_flags.sata_queue_otag =
3617 		    B_TRUE;
3618 
3619 	/* Always limit pkt time */
3620 	if (spx->txlt_scsi_pkt->pkt_time == 0)
3621 		spx->txlt_sata_pkt->satapkt_time = sata_default_pkt_time;
3622 	else
3623 		/* Pass on scsi_pkt time */
3624 		spx->txlt_sata_pkt->satapkt_time =
3625 		    spx->txlt_scsi_pkt->pkt_time;
3626 
3627 	return (TRAN_ACCEPT);
3628 }
3629 
3630 
3631 /*
3632  * Translate ATA(ATAPI) Identify (Packet) Device data to SCSI Inquiry data.
3633  * SATA Identify Device data has to be valid in sata_rive_info.
3634  * Buffer has to accomodate the inquiry length (36 bytes).
3635  *
3636  * This function should be called with a port mutex held.
3637  */
3638 static	void
3639 sata_identdev_to_inquiry(sata_hba_inst_t *sata_hba_inst,
3640     sata_drive_info_t *sdinfo, uint8_t *buf)
3641 {
3642 
3643 	struct scsi_inquiry *inq = (struct scsi_inquiry *)buf;
3644 	struct sata_id *sid = &sdinfo->satadrv_id;
3645 
3646 	/* Start with a nice clean slate */
3647 	bzero((void *)inq, sizeof (struct scsi_inquiry));
3648 
3649 	/* Rely on the dev_type for setting paripheral qualifier */
3650 	/* Does DTYPE_RODIRECT apply to CD/DVD R/W devices ? */
3651 	inq->inq_dtype = sdinfo->satadrv_type == SATA_DTYPE_ATADISK ?
3652 	    DTYPE_DIRECT : DTYPE_RODIRECT;
3653 
3654 	inq->inq_rmb = sid->ai_config & SATA_REM_MEDIA ? 1 : 0;
3655 	inq->inq_qual = 0;	/* Device type qualifier (obsolete in SCSI3? */
3656 	inq->inq_iso = 0;	/* ISO version */
3657 	inq->inq_ecma = 0;	/* ECMA version */
3658 	inq->inq_ansi = 3;	/* ANSI version - SCSI 3 */
3659 	inq->inq_aenc = 0;	/* Async event notification cap. */
3660 	inq->inq_trmiop = 0;	/* Supports TERMINATE I/O PROC msg ??? */
3661 	inq->inq_normaca = 0;	/* setting NACA bit supported - NO */
3662 	inq->inq_rdf = RDF_SCSI2; /* Response data format- SPC-3 */
3663 	inq->inq_len = 31;	/* Additional length */
3664 	inq->inq_dualp = 0;	/* dual port device - NO */
3665 	inq->inq_reladdr = 0;	/* Supports relative addressing - NO */
3666 	inq->inq_sync = 0;	/* Supports synchronous data xfers - NO */
3667 	inq->inq_linked = 0;	/* Supports linked commands - NO */
3668 				/*
3669 				 * Queuing support - controller has to
3670 				 * support some sort of command queuing.
3671 				 */
3672 	if (SATA_QDEPTH(sata_hba_inst) > 1)
3673 		inq->inq_cmdque = 1; /* Supports command queueing - YES */
3674 	else
3675 		inq->inq_cmdque = 0; /* Supports command queueing - NO */
3676 	inq->inq_sftre = 0;	/* Supports Soft Reset option - NO ??? */
3677 	inq->inq_wbus32 = 0;	/* Supports 32 bit wide data xfers - NO */
3678 	inq->inq_wbus16 = 0;	/* Supports 16 bit wide data xfers - NO */
3679 
3680 #ifdef _LITTLE_ENDIAN
3681 	/* Swap text fields to match SCSI format */
3682 	bcopy("ATA     ", inq->inq_vid, 8);		/* Vendor ID */
3683 	swab(sid->ai_model, inq->inq_pid, 16);		/* Product ID */
3684 	if (strncmp(&sid->ai_fw[4], "    ", 4) == 0)
3685 		swab(sid->ai_fw, inq->inq_revision, 4);	/* Revision level */
3686 	else
3687 		swab(&sid->ai_fw[4], inq->inq_revision, 4);	/* Rev. level */
3688 #else
3689 	bcopy(sid->ai_model, inq->inq_vid, 8);		/* Vendor ID */
3690 	bcopy(&sid->ai_model[8], inq->inq_pid, 16);	/* Product ID */
3691 	if (strncmp(&sid->ai_fw[4], "    ", 4) == 0)
3692 		bcopy(sid->ai_fw, inq->inq_revision, 4); /* Revision level */
3693 	else
3694 		bcopy(&sid->ai_fw[4], inq->inq_revision, 4); /* Rev. level */
3695 #endif
3696 }
3697 
3698 
3699 /*
3700  * Scsi response set up for invalid command (command not supported)
3701  *
3702  * Returns TRAN_ACCEPT and appropriate values in scsi_pkt fields.
3703  */
3704 static int
3705 sata_txlt_invalid_command(sata_pkt_txlate_t *spx)
3706 {
3707 	struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt;
3708 	struct scsi_extended_sense *sense;
3709 
3710 	scsipkt->pkt_reason = CMD_CMPLT;
3711 	scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET |
3712 	    STATE_SENT_CMD | STATE_GOT_STATUS;
3713 
3714 	*scsipkt->pkt_scbp = STATUS_CHECK;
3715 
3716 	sense = sata_arq_sense(spx);
3717 	sense->es_key = KEY_ILLEGAL_REQUEST;
3718 	sense->es_add_code = SD_SCSI_INVALID_COMMAND_CODE;
3719 
3720 	SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst,
3721 	    "Scsi_pkt completion reason %x\n", scsipkt->pkt_reason);
3722 
3723 	if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0 &&
3724 	    scsipkt->pkt_comp != NULL)
3725 		/* scsi callback required */
3726 		if (taskq_dispatch(SATA_TXLT_TASKQ(spx),
3727 		    (task_func_t *)spx->txlt_scsi_pkt->pkt_comp,
3728 		    (void *)spx->txlt_scsi_pkt,
3729 		    TQ_SLEEP) == NULL)
3730 			/* Scheduling the callback failed */
3731 			return (TRAN_BUSY);
3732 	return (TRAN_ACCEPT);
3733 }
3734 
3735 /*
3736  * Scsi response setup for
3737  * emulated non-data command that requires no action/return data
3738  *
3739  * Returns TRAN_ACCEPT and appropriate values in scsi_pkt fields.
3740  */
3741 static 	int
3742 sata_txlt_nodata_cmd_immediate(sata_pkt_txlate_t *spx)
3743 {
3744 	int rval;
3745 
3746 	mutex_enter(&(SATA_TXLT_CPORT_MUTEX(spx)));
3747 
3748 	if (((rval = sata_txlt_generic_pkt_info(spx)) != TRAN_ACCEPT) ||
3749 	    (spx->txlt_scsi_pkt->pkt_reason == CMD_DEV_GONE)) {
3750 		mutex_exit(&(SATA_TXLT_CPORT_MUTEX(spx)));
3751 		return (rval);
3752 	}
3753 	mutex_exit(&(SATA_TXLT_CPORT_MUTEX(spx)));
3754 
3755 	spx->txlt_scsi_pkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET |
3756 	    STATE_SENT_CMD | STATE_GOT_STATUS;
3757 	spx->txlt_scsi_pkt->pkt_reason = CMD_CMPLT;
3758 	*(spx->txlt_scsi_pkt->pkt_scbp) = STATUS_GOOD;
3759 
3760 	SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst,
3761 	    "Scsi_pkt completion reason %x\n",
3762 	    spx->txlt_scsi_pkt->pkt_reason);
3763 
3764 	if ((spx->txlt_scsi_pkt->pkt_flags & FLAG_NOINTR) == 0 &&
3765 	    spx->txlt_scsi_pkt->pkt_comp != NULL)
3766 		/* scsi callback required */
3767 		if (taskq_dispatch(SATA_TXLT_TASKQ(spx),
3768 		    (task_func_t *)spx->txlt_scsi_pkt->pkt_comp,
3769 		    (void *)spx->txlt_scsi_pkt,
3770 		    TQ_SLEEP) == NULL)
3771 			/* Scheduling the callback failed */
3772 			return (TRAN_BUSY);
3773 	return (TRAN_ACCEPT);
3774 }
3775 
3776 
3777 /*
3778  * SATA translate command: Inquiry / Identify Device
3779  * Use cached Identify Device data for now, rather then issuing actual
3780  * Device Identify cmd request. If device is detached and re-attached,
3781  * asynchromous event processing should fetch and refresh Identify Device
3782  * data.
3783  * Two VPD pages are supported now:
3784  * Vital Product Data page
3785  * Unit Serial Number page
3786  *
3787  * Returns TRAN_ACCEPT and appropriate values in scsi_pkt fields.
3788  */
3789 
3790 #define	EVPD			1	/* Extended Vital Product Data flag */
3791 #define	CMDDT			2	/* Command Support Data - Obsolete */
3792 #define	INQUIRY_SUP_VPD_PAGE	0	/* Supported VDP Pages Page COde */
3793 #define	INQUIRY_USN_PAGE	0x80	/* Unit Serial Number Page Code */
3794 #define	INQUIRY_DEV_IDENTIFICATION_PAGE 0x83 /* Not needed yet */
3795 
3796 static int
3797 sata_txlt_inquiry(sata_pkt_txlate_t *spx)
3798 {
3799 	struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt;
3800 	struct buf *bp = spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp;
3801 	sata_drive_info_t *sdinfo;
3802 	struct scsi_extended_sense *sense;
3803 	int count;
3804 	uint8_t *p;
3805 	int i, j;
3806 	uint8_t page_buf[0xff]; /* Max length */
3807 	int rval;
3808 
3809 	mutex_enter(&(SATA_TXLT_CPORT_MUTEX(spx)));
3810 
3811 	if (((rval = sata_txlt_generic_pkt_info(spx)) != TRAN_ACCEPT) ||
3812 	    (spx->txlt_scsi_pkt->pkt_reason == CMD_DEV_GONE)) {
3813 		mutex_exit(&(SATA_TXLT_CPORT_MUTEX(spx)));
3814 		return (rval);
3815 	}
3816 
3817 	sdinfo = sata_get_device_info(spx->txlt_sata_hba_inst,
3818 	    &spx->txlt_sata_pkt->satapkt_device);
3819 
3820 	ASSERT(sdinfo != NULL);
3821 
3822 	scsipkt->pkt_reason = CMD_CMPLT;
3823 	scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET |
3824 		STATE_SENT_CMD | STATE_GOT_STATUS;
3825 
3826 	/* Reject not supported request */
3827 	if (scsipkt->pkt_cdbp[1] & CMDDT) { /* No support for this bit */
3828 		*scsipkt->pkt_scbp = STATUS_CHECK;
3829 		sense = sata_arq_sense(spx);
3830 		sense->es_key = KEY_ILLEGAL_REQUEST;
3831 		sense->es_add_code = SD_SCSI_INVALID_FIELD_IN_CDB;
3832 		goto done;
3833 	}
3834 
3835 	/* Valid Inquiry request */
3836 	*scsipkt->pkt_scbp = STATUS_GOOD;
3837 
3838 	if (bp != NULL && bp->b_un.b_addr && bp->b_bcount) {
3839 
3840 		if (!(scsipkt->pkt_cdbp[1] & EVPD)) {
3841 		/* Standard Inquiry Data request */
3842 			struct scsi_inquiry inq;
3843 			unsigned int bufsize;
3844 
3845 			sata_identdev_to_inquiry(spx->txlt_sata_hba_inst,
3846 			    sdinfo, (uint8_t *)&inq);
3847 			/* Copy no more than requested */
3848 			count = MIN(bp->b_bcount,
3849 			    sizeof (struct scsi_inquiry));
3850 			bufsize = scsipkt->pkt_cdbp[4];
3851 			bufsize |= scsipkt->pkt_cdbp[3] << 8;
3852 			count = MIN(count, bufsize);
3853 			bcopy(&inq, bp->b_un.b_addr, count);
3854 
3855 			scsipkt->pkt_state |= STATE_XFERRED_DATA;
3856 			scsipkt->pkt_resid = scsipkt->pkt_cdbp[4] > count ?
3857 			    bufsize - count : 0;
3858 		} else {
3859 			/*
3860 			 * peripheral_qualifier = 0;
3861 			 *
3862 			 * We are dealing only with HD and will be
3863 			 * dealing with CD/DVD devices soon
3864 			 */
3865 			uint8_t peripheral_device_type =
3866 			    sdinfo->satadrv_type == SATA_DTYPE_ATADISK ?
3867 				DTYPE_DIRECT : DTYPE_RODIRECT;
3868 
3869 			switch ((uint_t)scsipkt->pkt_cdbp[2]) {
3870 			case INQUIRY_SUP_VPD_PAGE:
3871 				/*
3872 				 * Request for suported Vital Product Data
3873 				 * pages - assuming only 2 page codes
3874 				 * supported
3875 				 */
3876 				page_buf[0] = peripheral_device_type;
3877 				page_buf[1] = INQUIRY_SUP_VPD_PAGE;
3878 				page_buf[2] = 0;
3879 				page_buf[3] = 2; /* page length */
3880 				page_buf[4] = INQUIRY_SUP_VPD_PAGE;
3881 				page_buf[5] = INQUIRY_USN_PAGE;
3882 				/* Copy no more than requested */
3883 				count = MIN(bp->b_bcount, 6);
3884 				bcopy(page_buf, bp->b_un.b_addr, count);
3885 				break;
3886 			case INQUIRY_USN_PAGE:
3887 				/*
3888 				 * Request for Unit Serial Number page
3889 				 */
3890 				page_buf[0] = peripheral_device_type;
3891 				page_buf[1] = INQUIRY_USN_PAGE;
3892 				page_buf[2] = 0;
3893 				page_buf[3] = 20; /* remaining page length */
3894 				p = (uint8_t *)(sdinfo->satadrv_id.ai_drvser);
3895 #ifdef	_LITTLE_ENDIAN
3896 				swab(p, &page_buf[4], 20);
3897 #else
3898 				bcopy(p, &page_buf[4], 20);
3899 #endif
3900 				for (i = 0; i < 20; i++) {
3901 					if (page_buf[4 + i] == '\0' ||
3902 					    page_buf[4 + i] == '\040') {
3903 						break;
3904 					}
3905 				}
3906 				/*
3907 				 * 'i' contains string length.
3908 				 *
3909 				 * Least significant character of the serial
3910 				 * number shall appear as the last byte,
3911 				 * according to SBC-3 spec.
3912 				 */
3913 				p = &page_buf[20 + 4 - 1];
3914 				for (j = i; j > 0; j--, p--) {
3915 					*p = *(p - 20 + i);
3916 				}
3917 				p = &page_buf[4];
3918 				for (j = 20 - i; j > 0; j--) {
3919 					*p++ = '\040';
3920 				}
3921 				count = MIN(bp->b_bcount, 24);
3922 				bcopy(page_buf, bp->b_un.b_addr, count);
3923 				break;
3924 
3925 			case INQUIRY_DEV_IDENTIFICATION_PAGE:
3926 				/*
3927 				 * We may want to implement this page, when
3928 				 * identifiers are common for SATA devices
3929 				 * But not now.
3930 				 */
3931 				/*FALLTHROUGH*/
3932 
3933 			default:
3934 				/* Request for unsupported VPD page */
3935 				*scsipkt->pkt_scbp = STATUS_CHECK;
3936 				sense = sata_arq_sense(spx);
3937 				sense->es_key = KEY_ILLEGAL_REQUEST;
3938 				sense->es_add_code =
3939 				    SD_SCSI_INVALID_FIELD_IN_CDB;
3940 				goto done;
3941 			}
3942 		}
3943 		scsipkt->pkt_state |= STATE_XFERRED_DATA;
3944 		scsipkt->pkt_resid = scsipkt->pkt_cdbp[4] > count ?
3945 		    scsipkt->pkt_cdbp[4] - count : 0;
3946 	}
3947 done:
3948 	mutex_exit(&(SATA_TXLT_CPORT_MUTEX(spx)));
3949 
3950 	SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst,
3951 	    "Scsi_pkt completion reason %x\n",
3952 	    scsipkt->pkt_reason);
3953 
3954 	if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0 &&
3955 	    scsipkt->pkt_comp != NULL) {
3956 		/* scsi callback required */
3957 		if (taskq_dispatch(SATA_TXLT_TASKQ(spx),
3958 		    (task_func_t *)scsipkt->pkt_comp, (void *) scsipkt,
3959 		    TQ_SLEEP) == NULL)
3960 			/* Scheduling the callback failed */
3961 			return (TRAN_BUSY);
3962 	}
3963 	return (TRAN_ACCEPT);
3964 }
3965 
3966 /*
3967  * SATA translate command: Request Sense
3968  * emulated command (ATA version so far, no ATAPI)
3969  * Always NO SENSE, because any sense data should be reported by ARQ sense.
3970  *
3971  * Returns TRAN_ACCEPT and appropriate values in scsi_pkt fields.
3972  */
3973 static int
3974 sata_txlt_request_sense(sata_pkt_txlate_t *spx)
3975 {
3976 	struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt;
3977 	struct scsi_extended_sense sense;
3978 	struct buf *bp = spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp;
3979 	int rval;
3980 
3981 	mutex_enter(&(SATA_TXLT_CPORT_MUTEX(spx)));
3982 
3983 	if (((rval = sata_txlt_generic_pkt_info(spx)) != TRAN_ACCEPT) ||
3984 	    (spx->txlt_scsi_pkt->pkt_reason == CMD_DEV_GONE)) {
3985 		mutex_exit(&(SATA_TXLT_CPORT_MUTEX(spx)));
3986 		return (rval);
3987 	}
3988 	mutex_exit(&(SATA_TXLT_CPORT_MUTEX(spx)));
3989 
3990 
3991 	scsipkt->pkt_reason = CMD_CMPLT;
3992 	scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET |
3993 	    STATE_SENT_CMD | STATE_GOT_STATUS;
3994 	*scsipkt->pkt_scbp = STATUS_GOOD;
3995 
3996 	if (bp != NULL && bp->b_un.b_addr && bp->b_bcount) {
3997 		int count = MIN(bp->b_bcount,
3998 		    sizeof (struct scsi_extended_sense));
3999 		bzero(&sense, sizeof (struct scsi_extended_sense));
4000 		sense.es_valid = 0;	/* Valid LBA */
4001 		sense.es_class = 7;	/* Response code 0x70 - current err */
4002 		sense.es_key = KEY_NO_SENSE;
4003 		sense.es_add_len = 6;	/* Additional length */
4004 		/* Copy no more than requested */
4005 		bcopy(&sense, bp->b_un.b_addr, count);
4006 		scsipkt->pkt_state |= STATE_XFERRED_DATA;
4007 		scsipkt->pkt_resid = 0;
4008 	}
4009 
4010 	SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst,
4011 	    "Scsi_pkt completion reason %x\n",
4012 	    scsipkt->pkt_reason);
4013 
4014 	if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0 &&
4015 	    scsipkt->pkt_comp != NULL)
4016 		/* scsi callback required */
4017 		if (taskq_dispatch(SATA_TXLT_TASKQ(spx),
4018 		    (task_func_t *)scsipkt->pkt_comp, (void *) scsipkt,
4019 		    TQ_SLEEP) == NULL)
4020 			/* Scheduling the callback failed */
4021 			return (TRAN_BUSY);
4022 	return (TRAN_ACCEPT);
4023 }
4024 
4025 /*
4026  * SATA translate command: Test Unit Ready
4027  * At the moment this is an emulated command (ATA version so far, no ATAPI).
4028  * May be translated into Check Power Mode command in the future
4029  *
4030  * Returns TRAN_ACCEPT and appropriate values in scsi_pkt fields.
4031  */
4032 static int
4033 sata_txlt_test_unit_ready(sata_pkt_txlate_t *spx)
4034 {
4035 	struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt;
4036 	struct scsi_extended_sense *sense;
4037 	int power_state;
4038 	int rval;
4039 
4040 	mutex_enter(&(SATA_TXLT_CPORT_MUTEX(spx)));
4041 
4042 	if (((rval = sata_txlt_generic_pkt_info(spx)) != TRAN_ACCEPT) ||
4043 	    (spx->txlt_scsi_pkt->pkt_reason == CMD_DEV_GONE)) {
4044 		mutex_exit(&(SATA_TXLT_CPORT_MUTEX(spx)));
4045 		return (rval);
4046 	}
4047 	mutex_exit(&(SATA_TXLT_CPORT_MUTEX(spx)));
4048 
4049 	/* At this moment, emulate it rather than execute anything */
4050 	power_state = SATA_PWRMODE_ACTIVE;
4051 
4052 	scsipkt->pkt_reason = CMD_CMPLT;
4053 	scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET |
4054 	    STATE_SENT_CMD | STATE_GOT_STATUS;
4055 
4056 	switch (power_state) {
4057 	case SATA_PWRMODE_ACTIVE:
4058 	case SATA_PWRMODE_IDLE:
4059 		*scsipkt->pkt_scbp = STATUS_GOOD;
4060 		break;
4061 	default:
4062 		/* PWR mode standby */
4063 		*scsipkt->pkt_scbp = STATUS_CHECK;
4064 		sense = sata_arq_sense(spx);
4065 		sense->es_key = KEY_NOT_READY;
4066 		sense->es_add_code = SD_SCSI_LU_NOT_READY;
4067 		break;
4068 	}
4069 
4070 	SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst,
4071 	    "Scsi_pkt completion reason %x\n", scsipkt->pkt_reason);
4072 
4073 	if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0 &&
4074 	    scsipkt->pkt_comp != NULL)
4075 		/* scsi callback required */
4076 		if (taskq_dispatch(SATA_TXLT_TASKQ(spx),
4077 		    (task_func_t *)scsipkt->pkt_comp, (void *) scsipkt,
4078 		    TQ_SLEEP) == NULL)
4079 			/* Scheduling the callback failed */
4080 			return (TRAN_BUSY);
4081 
4082 	return (TRAN_ACCEPT);
4083 }
4084 
4085 
4086 /*
4087  * SATA translate command: Start Stop Unit
4088  * Translation depends on a command:
4089  *	Start Unit translated into Idle Immediate
4090  *	Stop Unit translated into Standby Immediate
4091  *	Unload Media / NOT SUPPORTED YET
4092  *	Load Media / NOT SUPPROTED YET
4093  * Power condition bits are ignored, so is Immediate bit
4094  * Requesting synchronous execution.
4095  *
4096  * Returns TRAN_ACCEPT or code returned by sata_hba_start() and
4097  * appropriate values in scsi_pkt fields.
4098  */
4099 static int
4100 sata_txlt_start_stop_unit(sata_pkt_txlate_t *spx)
4101 {
4102 	struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt;
4103 	sata_cmd_t *scmd = &spx->txlt_sata_pkt->satapkt_cmd;
4104 	struct scsi_extended_sense *sense;
4105 	sata_hba_inst_t *shi = SATA_TXLT_HBA_INST(spx);
4106 	int cport = SATA_TXLT_CPORT(spx);
4107 	int rval;
4108 	int synch;
4109 
4110 	SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst,
4111 	    "sata_txlt_start_stop_unit: %d\n", scsipkt->pkt_scbp[4] & 1);
4112 
4113 	mutex_enter(&SATA_CPORT_MUTEX(shi, cport));
4114 
4115 	if (((rval = sata_txlt_generic_pkt_info(spx)) != TRAN_ACCEPT) ||
4116 	    (spx->txlt_scsi_pkt->pkt_reason == CMD_DEV_GONE)) {
4117 		mutex_exit(&(SATA_TXLT_CPORT_MUTEX(spx)));
4118 		return (rval);
4119 	}
4120 
4121 	if (scsipkt->pkt_cdbp[4] & 2) {
4122 		/* Load/Unload Media - invalid request */
4123 		*scsipkt->pkt_scbp = STATUS_CHECK;
4124 		sense = sata_arq_sense(spx);
4125 		sense->es_key = KEY_ILLEGAL_REQUEST;
4126 		sense->es_add_code = SD_SCSI_INVALID_FIELD_IN_CDB;
4127 		mutex_exit(&(SATA_TXLT_CPORT_MUTEX(spx)));
4128 
4129 		SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst,
4130 		    "Scsi_pkt completion reason %x\n", scsipkt->pkt_reason);
4131 
4132 		if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0 &&
4133 		    scsipkt->pkt_comp != NULL)
4134 			/* scsi callback required */
4135 			if (taskq_dispatch(SATA_TXLT_TASKQ(spx),
4136 			    (task_func_t *)scsipkt->pkt_comp, (void *) scsipkt,
4137 			    TQ_SLEEP) == NULL)
4138 				/* Scheduling the callback failed */
4139 				return (TRAN_BUSY);
4140 
4141 		return (TRAN_ACCEPT);
4142 	}
4143 	scmd->satacmd_addr_type = 0;
4144 	scmd->satacmd_sec_count_lsb = 0;
4145 	scmd->satacmd_lba_low_lsb = 0;
4146 	scmd->satacmd_lba_mid_lsb = 0;
4147 	scmd->satacmd_lba_high_lsb = 0;
4148 	scmd->satacmd_features_reg = 0;
4149 	scmd->satacmd_device_reg = 0;
4150 	scmd->satacmd_status_reg = 0;
4151 	if (scsipkt->pkt_cdbp[4] & 1) {
4152 		/* Start Unit */
4153 		scmd->satacmd_cmd_reg = SATAC_IDLE_IM;
4154 	} else {
4155 		/* Stop Unit */
4156 		scmd->satacmd_cmd_reg = SATAC_STANDBY_IM;
4157 	}
4158 
4159 	if (!(spx->txlt_sata_pkt->satapkt_op_mode & SATA_OPMODE_SYNCH)) {
4160 		/* Need to set-up a callback function */
4161 		spx->txlt_sata_pkt->satapkt_comp =
4162 		    sata_txlt_nodata_cmd_completion;
4163 		synch = FALSE;
4164 	} else {
4165 		spx->txlt_sata_pkt->satapkt_op_mode = SATA_OPMODE_SYNCH;
4166 		synch = TRUE;
4167 	}
4168 
4169 	/* Transfer command to HBA */
4170 	if (sata_hba_start(spx, &rval) != 0) {
4171 		/* Pkt not accepted for execution */
4172 		mutex_exit(&SATA_CPORT_MUTEX(shi, cport));
4173 		return (rval);
4174 	}
4175 
4176 	/*
4177 	 * If execution is non-synchronous,
4178 	 * a callback function will handle potential errors, translate
4179 	 * the response and will do a callback to a target driver.
4180 	 * If it was synchronous, check execution status using the same
4181 	 * framework callback.
4182 	 */
4183 	mutex_exit(&SATA_CPORT_MUTEX(shi, cport));
4184 	if (synch) {
4185 		SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst,
4186 		    "synchronous execution status %x\n",
4187 		    spx->txlt_sata_pkt->satapkt_reason);
4188 
4189 		sata_txlt_nodata_cmd_completion(spx->txlt_sata_pkt);
4190 	}
4191 	return (TRAN_ACCEPT);
4192 
4193 }
4194 
4195 
4196 /*
4197  * SATA translate command:  Read Capacity.
4198  * Emulated command for SATA disks.
4199  * Capacity is retrieved from cached Idenifty Device data.
4200  * Identify Device data shows effective disk capacity, not the native
4201  * capacity, which may be limitted by Set Max Address command.
4202  * This is ATA version (non-ATAPI).
4203  *
4204  * Returns TRAN_ACCEPT and appropriate values in scsi_pkt fields.
4205  */
4206 static int
4207 sata_txlt_read_capacity(sata_pkt_txlate_t *spx)
4208 {
4209 	struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt;
4210 	struct buf *bp = spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp;
4211 	sata_drive_info_t *sdinfo;
4212 	uint64_t val;
4213 	uchar_t *rbuf;
4214 	int rval;
4215 
4216 	SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst,
4217 	    "sata_txlt_read_capacity: ", NULL);
4218 
4219 	mutex_enter(&(SATA_TXLT_CPORT_MUTEX(spx)));
4220 
4221 	if (((rval = sata_txlt_generic_pkt_info(spx)) != TRAN_ACCEPT) ||
4222 	    (spx->txlt_scsi_pkt->pkt_reason == CMD_DEV_GONE)) {
4223 		mutex_exit(&(SATA_TXLT_CPORT_MUTEX(spx)));
4224 		return (rval);
4225 	}
4226 
4227 	scsipkt->pkt_reason = CMD_CMPLT;
4228 	scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET |
4229 	    STATE_SENT_CMD | STATE_GOT_STATUS;
4230 	*scsipkt->pkt_scbp = STATUS_GOOD;
4231 	if (bp != NULL && bp->b_un.b_addr && bp->b_bcount) {
4232 		sdinfo = sata_get_device_info(
4233 		    spx->txlt_sata_hba_inst,
4234 		    &spx->txlt_sata_pkt->satapkt_device);
4235 		/* Last logical block address */
4236 		val = sdinfo->satadrv_capacity - 1;
4237 		rbuf = (uchar_t *)bp->b_un.b_addr;
4238 		/* Need to swap endians to match scsi format */
4239 		rbuf[0] = (val >> 24) & 0xff;
4240 		rbuf[1] = (val >> 16) & 0xff;
4241 		rbuf[2] = (val >> 8) & 0xff;
4242 		rbuf[3] = val & 0xff;
4243 		/* block size - always 512 bytes, for now */
4244 		rbuf[4] = 0;
4245 		rbuf[5] = 0;
4246 		rbuf[6] = 0x02;
4247 		rbuf[7] = 0;
4248 		scsipkt->pkt_state |= STATE_XFERRED_DATA;
4249 		scsipkt->pkt_resid = 0;
4250 
4251 		SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst, "%d\n",
4252 		    sdinfo->satadrv_capacity -1);
4253 	}
4254 	mutex_exit(&(SATA_TXLT_CPORT_MUTEX(spx)));
4255 	/*
4256 	 * If a callback was requested, do it now.
4257 	 */
4258 	SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst,
4259 	    "Scsi_pkt completion reason %x\n", scsipkt->pkt_reason);
4260 
4261 	if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0 &&
4262 	    scsipkt->pkt_comp != NULL)
4263 		/* scsi callback required */
4264 		if (taskq_dispatch(SATA_TXLT_TASKQ(spx),
4265 		    (task_func_t *)scsipkt->pkt_comp, (void *) scsipkt,
4266 		    TQ_SLEEP) == NULL)
4267 			/* Scheduling the callback failed */
4268 			return (TRAN_BUSY);
4269 
4270 	return (TRAN_ACCEPT);
4271 }
4272 
4273 /*
4274  * SATA translate command: Mode Sense.
4275  * Translated into appropriate SATA command or emulated.
4276  * Saved Values Page Control (03) are not supported.
4277  *
4278  * NOTE: only caching mode sense page is currently implemented.
4279  *
4280  * Returns TRAN_ACCEPT and appropriate values in scsi_pkt fields.
4281  */
4282 
4283 static int
4284 sata_txlt_mode_sense(sata_pkt_txlate_t *spx)
4285 {
4286 	struct scsi_pkt	*scsipkt = spx->txlt_scsi_pkt;
4287 	struct buf	*bp = spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp;
4288 	sata_drive_info_t *sdinfo;
4289 	sata_id_t *sata_id;
4290 	struct scsi_extended_sense *sense;
4291 	int 		len, bdlen, count, alc_len;
4292 	int		pc;	/* Page Control code */
4293 	uint8_t		*buf;	/* mode sense buffer */
4294 	int		rval;
4295 
4296 	SATADBG2(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst,
4297 	    "sata_txlt_mode_sense, pc %x page code 0x%02x\n",
4298 	    spx->txlt_scsi_pkt->pkt_cdbp[2] >> 6,
4299 	    spx->txlt_scsi_pkt->pkt_cdbp[2] & 0x3f);
4300 
4301 	buf = kmem_zalloc(1024, KM_SLEEP);
4302 
4303 	mutex_enter(&(SATA_TXLT_CPORT_MUTEX(spx)));
4304 
4305 	if (((rval = sata_txlt_generic_pkt_info(spx)) != TRAN_ACCEPT) ||
4306 	    (spx->txlt_scsi_pkt->pkt_reason == CMD_DEV_GONE)) {
4307 		mutex_exit(&(SATA_TXLT_CPORT_MUTEX(spx)));
4308 		kmem_free(buf, 1024);
4309 		return (rval);
4310 	}
4311 
4312 	scsipkt->pkt_reason = CMD_CMPLT;
4313 	scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET |
4314 	    STATE_SENT_CMD | STATE_GOT_STATUS;
4315 
4316 	pc = scsipkt->pkt_cdbp[2] >> 6;
4317 
4318 	if (bp != NULL && bp->b_un.b_addr && bp->b_bcount) {
4319 		len = 0;
4320 		bdlen = 0;
4321 		if (!(scsipkt->pkt_cdbp[1] & 8)) {
4322 			if (scsipkt->pkt_cdbp[0] == SCMD_MODE_SENSE_G1 &&
4323 			    (scsipkt->pkt_cdbp[0] & 0x10))
4324 				bdlen = 16;
4325 			else
4326 				bdlen = 8;
4327 		}
4328 		/* Build mode parameter header */
4329 		if (spx->txlt_scsi_pkt->pkt_cdbp[0] == SCMD_MODE_SENSE) {
4330 			/* 4-byte mode parameter header */
4331 			buf[len++] = 0;   	/* mode data length */
4332 			buf[len++] = 0;		/* medium type */
4333 			buf[len++] = 0;		/* dev-specific param */
4334 			buf[len++] = bdlen;	/* Block Descriptor length */
4335 		} else {
4336 			/* 8-byte mode parameter header */
4337 			buf[len++] = 0;		/* mode data length */
4338 			buf[len++] = 0;
4339 			buf[len++] = 0;		/* medium type */
4340 			buf[len++] = 0;		/* dev-specific param */
4341 			if (bdlen == 16)
4342 				buf[len++] = 1;	/* long lba descriptor */
4343 			else
4344 				buf[len++] = 0;
4345 			buf[len++] = 0;
4346 			buf[len++] = 0;		/* Block Descriptor length */
4347 			buf[len++] = bdlen;
4348 		}
4349 
4350 		sdinfo = sata_get_device_info(
4351 		    spx->txlt_sata_hba_inst,
4352 		    &spx->txlt_sata_pkt->satapkt_device);
4353 
4354 		/* Build block descriptor only if not disabled (DBD) */
4355 		if ((scsipkt->pkt_cdbp[1] & 0x08) == 0) {
4356 			/* Block descriptor - direct-access device format */
4357 			if (bdlen == 8) {
4358 				/* build regular block descriptor */
4359 				buf[len++] =
4360 				    (sdinfo->satadrv_capacity >> 24) & 0xff;
4361 				buf[len++] =
4362 				    (sdinfo->satadrv_capacity >> 16) & 0xff;
4363 				buf[len++] =
4364 				    (sdinfo->satadrv_capacity >> 8) & 0xff;
4365 				buf[len++] = sdinfo->satadrv_capacity & 0xff;
4366 				buf[len++] = 0; /* density code */
4367 				buf[len++] = 0;
4368 				if (sdinfo->satadrv_type ==
4369 				    SATA_DTYPE_ATADISK)
4370 					buf[len++] = 2;
4371 				else
4372 					/* ATAPI */
4373 					buf[len++] = 8;
4374 				buf[len++] = 0;
4375 			} else if (bdlen == 16) {
4376 				/* Long LBA Accepted */
4377 				/* build long lba block descriptor */
4378 #ifndef __lock_lint
4379 				buf[len++] =
4380 				    (sdinfo->satadrv_capacity >> 56) & 0xff;
4381 				buf[len++] =
4382 				    (sdinfo->satadrv_capacity >> 48) & 0xff;
4383 				buf[len++] =
4384 				    (sdinfo->satadrv_capacity >> 40) & 0xff;
4385 				buf[len++] =
4386 				    (sdinfo->satadrv_capacity >> 32) & 0xff;
4387 #endif
4388 				buf[len++] =
4389 				    (sdinfo->satadrv_capacity >> 24) & 0xff;
4390 				buf[len++] =
4391 				    (sdinfo->satadrv_capacity >> 16) & 0xff;
4392 				buf[len++] =
4393 				    (sdinfo->satadrv_capacity >> 8) & 0xff;
4394 				buf[len++] = sdinfo->satadrv_capacity & 0xff;
4395 				buf[len++] = 0;
4396 				buf[len++] = 0; /* density code */
4397 				buf[len++] = 0;
4398 				buf[len++] = 0;
4399 				if (sdinfo->satadrv_type ==
4400 				    SATA_DTYPE_ATADISK)
4401 					buf[len++] = 2;
4402 				else
4403 					/* ATAPI */
4404 					buf[len++] = 8;
4405 				buf[len++] = 0;
4406 			}
4407 		}
4408 
4409 		sata_id = &sdinfo->satadrv_id;
4410 
4411 		/*
4412 		 * Add requested pages.
4413 		 * Page 3 and 4 are obsolete and we are not supporting them.
4414 		 * We deal now with:
4415 		 * caching (read/write cache control).
4416 		 * We should eventually deal with following mode pages:
4417 		 * error recovery  (0x01),
4418 		 * power condition (0x1a),
4419 		 * exception control page (enables SMART) (0x1c),
4420 		 * enclosure management (ses),
4421 		 * protocol-specific port mode (port control).
4422 		 */
4423 		switch (scsipkt->pkt_cdbp[2] & 0x3f) {
4424 		case MODEPAGE_RW_ERRRECOV:
4425 			/* DAD_MODE_ERR_RECOV */
4426 			/* R/W recovery */
4427 			len += sata_build_msense_page_1(sdinfo, pc, buf+len);
4428 			break;
4429 		case MODEPAGE_CACHING:
4430 			/* DAD_MODE_CACHE */
4431 			/* Reject not supported request for saved parameters */
4432 			if (pc == 3) {
4433 				*scsipkt->pkt_scbp = STATUS_CHECK;
4434 				sense = sata_arq_sense(spx);
4435 				sense->es_key = KEY_ILLEGAL_REQUEST;
4436 				sense->es_add_code =
4437 				    SD_SCSI_SAVING_PARAMS_NOT_SUP;
4438 				goto done;
4439 			}
4440 
4441 			/* caching */
4442 			len += sata_build_msense_page_8(sdinfo, pc, buf+len);
4443 			break;
4444 		case MODEPAGE_INFO_EXCPT:
4445 			/* exception cntrl */
4446 			if (sata_id->ai_cmdset82 & SATA_SMART_SUPPORTED) {
4447 				len += sata_build_msense_page_1c(sdinfo, pc,
4448 				    buf+len);
4449 			}
4450 			else
4451 				goto err;
4452 			break;
4453 		case MODEPAGE_POWER_COND:
4454 			/* DAD_MODE_POWER_COND */
4455 			/* power condition */
4456 			len += sata_build_msense_page_1a(sdinfo, pc, buf+len);
4457 			break;
4458 		case MODEPAGE_ALLPAGES:
4459 			/* all pages */
4460 			len += sata_build_msense_page_1(sdinfo, pc, buf+len);
4461 			len += sata_build_msense_page_8(sdinfo, pc, buf+len);
4462 			len += sata_build_msense_page_1a(sdinfo, pc, buf+len);
4463 			if (sata_id->ai_cmdset82 & SATA_SMART_SUPPORTED) {
4464 				len += sata_build_msense_page_1c(sdinfo, pc,
4465 				    buf+len);
4466 			}
4467 			break;
4468 		default:
4469 		err:
4470 			/* Invalid request */
4471 			*scsipkt->pkt_scbp = STATUS_CHECK;
4472 			sense = sata_arq_sense(spx);
4473 			sense->es_key = KEY_ILLEGAL_REQUEST;
4474 			sense->es_add_code = SD_SCSI_INVALID_FIELD_IN_CDB;
4475 			goto done;
4476 		}
4477 
4478 		/* fix total mode data length */
4479 		if (spx->txlt_scsi_pkt->pkt_cdbp[0] == SCMD_MODE_SENSE) {
4480 			/* 4-byte mode parameter header */
4481 			buf[0] = len - 1;   	/* mode data length */
4482 		} else {
4483 			buf[0] = (len -2) >> 8;
4484 			buf[1] = (len -2) & 0xff;
4485 		}
4486 
4487 
4488 		/* Check allocation length */
4489 		if (scsipkt->pkt_cdbp[0] == SCMD_MODE_SENSE) {
4490 			alc_len = scsipkt->pkt_cdbp[4];
4491 		} else {
4492 			alc_len = scsipkt->pkt_cdbp[7];
4493 			alc_len = (len << 8) | scsipkt->pkt_cdbp[8];
4494 		}
4495 		/*
4496 		 * We do not check for possible parameters truncation
4497 		 * (alc_len < len) assuming that the target driver works
4498 		 * correctly. Just avoiding overrun.
4499 		 * Copy no more than requested and possible, buffer-wise.
4500 		 */
4501 		count = MIN(alc_len, len);
4502 		count = MIN(bp->b_bcount, count);
4503 		bcopy(buf, bp->b_un.b_addr, count);
4504 
4505 		scsipkt->pkt_state |= STATE_XFERRED_DATA;
4506 		scsipkt->pkt_resid = alc_len > count ? alc_len - count : 0;
4507 	}
4508 	*scsipkt->pkt_scbp = STATUS_GOOD;
4509 done:
4510 	mutex_exit(&(SATA_TXLT_CPORT_MUTEX(spx)));
4511 	(void) kmem_free(buf, 1024);
4512 
4513 	SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst,
4514 	    "Scsi_pkt completion reason %x\n", scsipkt->pkt_reason);
4515 
4516 	if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0 &&
4517 	    scsipkt->pkt_comp != NULL)
4518 		/* scsi callback required */
4519 		if (taskq_dispatch(SATA_TXLT_TASKQ(spx),
4520 		    (task_func_t *)scsipkt->pkt_comp, (void *) scsipkt,
4521 		    TQ_SLEEP) == NULL)
4522 			/* Scheduling the callback failed */
4523 			return (TRAN_BUSY);
4524 
4525 	return (TRAN_ACCEPT);
4526 }
4527 
4528 
4529 /*
4530  * SATA translate command: Mode Select.
4531  * Translated into appropriate SATA command or emulated.
4532  * Saving parameters is not supported.
4533  * Changing device capacity is not supported (although theoretically
4534  * possible by executing SET FEATURES/SET MAX ADDRESS)
4535  *
4536  * Assumption is that the target driver is working correctly.
4537  *
4538  * More than one SATA command may be executed to perform operations specified
4539  * by mode select pages. The first error terminates further execution.
4540  * Operations performed successully are not backed-up in such case.
4541  *
4542  * NOTE: only caching mode select page is implemented.
4543  * Caching setup is remembered so it could be re-stored in case of
4544  * an unexpected device reset.
4545  *
4546  * Returns TRAN_ACCEPT and appropriate values in scsi_pkt fields.
4547  */
4548 
4549 static int
4550 sata_txlt_mode_select(sata_pkt_txlate_t *spx)
4551 {
4552 	struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt;
4553 	struct buf *bp = spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp;
4554 	struct scsi_extended_sense *sense;
4555 	int len, pagelen, count, pllen;
4556 	uint8_t *buf;	/* mode select buffer */
4557 	int rval, stat;
4558 	uint_t nointr_flag;
4559 	int dmod = 0;
4560 
4561 	SATADBG2(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst,
4562 	    "sata_txlt_mode_select, pc %x page code 0x%02x\n",
4563 	    spx->txlt_scsi_pkt->pkt_cdbp[2] >> 6,
4564 	    spx->txlt_scsi_pkt->pkt_cdbp[2] & 0x3f);
4565 
4566 	mutex_enter(&(SATA_TXLT_CPORT_MUTEX(spx)));
4567 
4568 	if (((rval = sata_txlt_generic_pkt_info(spx)) != TRAN_ACCEPT) ||
4569 	    (spx->txlt_scsi_pkt->pkt_reason == CMD_DEV_GONE)) {
4570 		mutex_exit(&(SATA_TXLT_CPORT_MUTEX(spx)));
4571 		return (rval);
4572 	}
4573 
4574 	rval = TRAN_ACCEPT;
4575 
4576 	scsipkt->pkt_reason = CMD_CMPLT;
4577 	scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET |
4578 	    STATE_SENT_CMD | STATE_GOT_STATUS;
4579 
4580 	/* Reject not supported request */
4581 	if (! (scsipkt->pkt_cdbp[1] & 0x10)) { /* No support for PF bit = 0 */
4582 		*scsipkt->pkt_scbp = STATUS_CHECK;
4583 		sense = sata_arq_sense(spx);
4584 		sense->es_key = KEY_ILLEGAL_REQUEST;
4585 		sense->es_add_code = SD_SCSI_INVALID_FIELD_IN_CDB;
4586 		goto done;
4587 	}
4588 
4589 	if (scsipkt->pkt_cdbp[0] == SCMD_MODE_SELECT) {
4590 		pllen = scsipkt->pkt_cdbp[4];
4591 	} else {
4592 		pllen = scsipkt->pkt_cdbp[7];
4593 		pllen = (pllen << 8) | scsipkt->pkt_cdbp[7];
4594 	}
4595 
4596 	*scsipkt->pkt_scbp = STATUS_GOOD;	/* Presumed outcome */
4597 
4598 	if (bp != NULL && bp->b_un.b_addr && bp->b_bcount && pllen != 0) {
4599 		buf = (uint8_t *)bp->b_un.b_addr;
4600 		count = MIN(bp->b_bcount, pllen);
4601 		scsipkt->pkt_state |= STATE_XFERRED_DATA;
4602 		scsipkt->pkt_resid = 0;
4603 		pllen = count;
4604 
4605 		/*
4606 		 * Check the header to skip the block descriptor(s) - we
4607 		 * do not support setting device capacity.
4608 		 * Existing macros do not recognize long LBA dscriptor,
4609 		 * hence manual calculation.
4610 		 */
4611 		if (scsipkt->pkt_cdbp[0] == SCMD_MODE_SELECT) {
4612 			/* 6-bytes CMD, 4 bytes header */
4613 			if (count <= 4)
4614 				goto done;		/* header only */
4615 			len = buf[3] + 4;
4616 		} else {
4617 			/* 10-bytes CMD, 8 bytes header */
4618 			if (count <= 8)
4619 				goto done;		/* header only */
4620 			len = buf[6];
4621 			len = (len << 8) + buf[7] + 8;
4622 		}
4623 		if (len >= count)
4624 			goto done;	/* header + descriptor(s) only */
4625 
4626 		pllen -= len;		/* remaining data length */
4627 
4628 		/*
4629 		 * We may be executing SATA command and want to execute it
4630 		 * in SYNCH mode, regardless of scsi_pkt setting.
4631 		 * Save scsi_pkt setting and indicate SYNCH mode
4632 		 */
4633 		nointr_flag = scsipkt->pkt_flags & FLAG_NOINTR;
4634 		if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0 &&
4635 		    scsipkt->pkt_comp != NULL) {
4636 			scsipkt->pkt_flags |= FLAG_NOINTR;
4637 		}
4638 		spx->txlt_sata_pkt->satapkt_op_mode = SATA_OPMODE_SYNCH;
4639 
4640 		/*
4641 		 * len is now the offset to a first mode select page
4642 		 * Process all pages
4643 		 */
4644 		while (pllen > 0) {
4645 			switch ((int)buf[len]) {
4646 			case MODEPAGE_CACHING:
4647 				/* No support for SP (saving) */
4648 				if (scsipkt->pkt_cdbp[1] & 0x01) {
4649 					*scsipkt->pkt_scbp = STATUS_CHECK;
4650 					sense = sata_arq_sense(spx);
4651 					sense->es_key = KEY_ILLEGAL_REQUEST;
4652 					sense->es_add_code =
4653 					    SD_SCSI_INVALID_FIELD_IN_CDB;
4654 					goto done;
4655 				}
4656 				stat = sata_mode_select_page_8(spx,
4657 				    (struct mode_cache_scsi3 *)&buf[len],
4658 				    pllen, &pagelen, &rval, &dmod);
4659 				/*
4660 				 * The pagelen value indicates the number of
4661 				 * parameter bytes already processed.
4662 				 * The rval is the return value from
4663 				 * sata_tran_start().
4664 				 * The stat indicates the overall status of
4665 				 * the operation(s).
4666 				 */
4667 				if (stat != SATA_SUCCESS)
4668 					/*
4669 					 * Page processing did not succeed -
4670 					 * all error info is already set-up,
4671 					 * just return
4672 					 */
4673 					pllen = 0; /* this breaks the loop */
4674 				else {
4675 					len += pagelen;
4676 					pllen -= pagelen;
4677 				}
4678 				break;
4679 
4680 			case MODEPAGE_INFO_EXCPT:
4681 				stat = sata_mode_select_page_1c(spx,
4682 				    (struct mode_info_excpt_page *)&buf[len],
4683 				    pllen, &pagelen, &rval, &dmod);
4684 				/*
4685 				 * The pagelen value indicates the number of
4686 				 * parameter bytes already processed.
4687 				 * The rval is the return value from
4688 				 * sata_tran_start().
4689 				 * The stat indicates the overall status of
4690 				 * the operation(s).
4691 				 */
4692 				if (stat != SATA_SUCCESS)
4693 					/*
4694 					 * Page processing did not succeed -
4695 					 * all error info is already set-up,
4696 					 * just return
4697 					 */
4698 					pllen = 0; /* this breaks the loop */
4699 				else {
4700 					len += pagelen;
4701 					pllen -= pagelen;
4702 				}
4703 				break;
4704 
4705 			default:
4706 				*scsipkt->pkt_scbp = STATUS_CHECK;
4707 				sense = sata_arq_sense(spx);
4708 				sense->es_key = KEY_ILLEGAL_REQUEST;
4709 				sense->es_add_code =
4710 				    SD_SCSI_INVALID_FIELD_IN_PARAMETER_LIST;
4711 				goto done;
4712 			}
4713 		}
4714 	}
4715 done:
4716 	mutex_exit(&(SATA_TXLT_CPORT_MUTEX(spx)));
4717 	/*
4718 	 * If device parameters were modified, fetch and store the new
4719 	 * Identify Device data. Since port mutex could have been released
4720 	 * for accessing HBA driver, we need to re-check device existence.
4721 	 */
4722 	if (dmod != 0) {
4723 		sata_drive_info_t new_sdinfo, *sdinfo;
4724 		int rv;
4725 
4726 		new_sdinfo.satadrv_addr =
4727 		    spx->txlt_sata_pkt->satapkt_device.satadev_addr;
4728 		rv = sata_fetch_device_identify_data(spx->txlt_sata_hba_inst,
4729 		    &new_sdinfo);
4730 
4731 		mutex_enter(&(SATA_TXLT_CPORT_MUTEX(spx)));
4732 		/*
4733 		 * Since port mutex could have been released when
4734 		 * accessing HBA driver, we need to re-check that the
4735 		 * framework still holds the device info structure.
4736 		 */
4737 		sdinfo = sata_get_device_info(spx->txlt_sata_hba_inst,
4738 		    &spx->txlt_sata_pkt->satapkt_device);
4739 		if (sdinfo != NULL) {
4740 			/*
4741 			 * Device still has info structure in the
4742 			 * sata framework. Copy newly fetched info
4743 			 */
4744 			if (rv == 0) {
4745 				sdinfo->satadrv_id = new_sdinfo.satadrv_id;
4746 				sata_save_drive_settings(sdinfo);
4747 			} else {
4748 				/*
4749 				 * Could not fetch new data - invalidate
4750 				 * sata_drive_info. That makes device
4751 				 * unusable.
4752 				 */
4753 				sdinfo->satadrv_type = SATA_DTYPE_UNKNOWN;
4754 				sdinfo->satadrv_state = SATA_STATE_UNKNOWN;
4755 			}
4756 		}
4757 		if (rv != 0 || sdinfo == NULL) {
4758 			/*
4759 			 * This changes the overall mode select completion
4760 			 * reason to a failed one !!!!!
4761 			 */
4762 			*scsipkt->pkt_scbp = STATUS_CHECK;
4763 			sense = sata_arq_sense(spx);
4764 			scsipkt->pkt_reason = CMD_INCOMPLETE;
4765 			rval = TRAN_ACCEPT;
4766 		}
4767 		mutex_exit(&(SATA_TXLT_CPORT_MUTEX(spx)));
4768 	}
4769 	/* Restore the scsi pkt flags */
4770 	scsipkt->pkt_flags &= ~FLAG_NOINTR;
4771 	scsipkt->pkt_flags |= nointr_flag;
4772 
4773 	SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst,
4774 	    "Scsi_pkt completion reason %x\n", scsipkt->pkt_reason);
4775 
4776 	if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0 &&
4777 	    scsipkt->pkt_comp != NULL)
4778 		/* scsi callback required */
4779 		if (taskq_dispatch(SATA_TXLT_TASKQ(spx),
4780 		    (task_func_t *)scsipkt->pkt_comp, (void *) scsipkt,
4781 		    TQ_SLEEP) == NULL)
4782 			/* Scheduling the callback failed */
4783 			return (TRAN_BUSY);
4784 
4785 	return (rval);
4786 }
4787 
4788 
4789 
4790 /*
4791  * Translate command: Log Sense
4792  */
4793 static 	int
4794 sata_txlt_log_sense(sata_pkt_txlate_t *spx)
4795 {
4796 	struct scsi_pkt	*scsipkt = spx->txlt_scsi_pkt;
4797 	struct buf	*bp = spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp;
4798 	sata_drive_info_t *sdinfo;
4799 	struct scsi_extended_sense *sense;
4800 	int 		len, count, alc_len;
4801 	int		pc;	/* Page Control code */
4802 	int		page_code;	/* Page code */
4803 	uint8_t		*buf;	/* log sense buffer */
4804 	int		rval;
4805 #define	MAX_LOG_SENSE_PAGE_SIZE	512
4806 
4807 	SATADBG2(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst,
4808 	    "sata_txlt_log_sense, pc 0x%x, page code 0x%x\n",
4809 	    spx->txlt_scsi_pkt->pkt_cdbp[2] >> 6,
4810 	    spx->txlt_scsi_pkt->pkt_cdbp[2] & 0x3f);
4811 
4812 	buf = kmem_zalloc(MAX_LOG_SENSE_PAGE_SIZE, KM_SLEEP);
4813 
4814 	mutex_enter(&(SATA_TXLT_CPORT_MUTEX(spx)));
4815 
4816 	if (((rval = sata_txlt_generic_pkt_info(spx)) != TRAN_ACCEPT) ||
4817 	    (spx->txlt_scsi_pkt->pkt_reason == CMD_DEV_GONE)) {
4818 		mutex_exit(&(SATA_TXLT_CPORT_MUTEX(spx)));
4819 		kmem_free(buf, MAX_LOG_SENSE_PAGE_SIZE);
4820 		return (rval);
4821 	}
4822 
4823 	scsipkt->pkt_reason = CMD_CMPLT;
4824 	scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET |
4825 	    STATE_SENT_CMD | STATE_GOT_STATUS;
4826 
4827 	pc = scsipkt->pkt_cdbp[2] >> 6;
4828 	page_code = scsipkt->pkt_cdbp[2] & 0x3f;
4829 
4830 	/* Reject not supported request for all but cumulative values */
4831 	switch (pc) {
4832 	case PC_CUMULATIVE_VALUES:
4833 		break;
4834 	default:
4835 		*scsipkt->pkt_scbp = STATUS_CHECK;
4836 		sense = sata_arq_sense(spx);
4837 		sense->es_key = KEY_ILLEGAL_REQUEST;
4838 		sense->es_add_code = SD_SCSI_INVALID_FIELD_IN_CDB;
4839 		goto done;
4840 	}
4841 
4842 	switch (page_code) {
4843 	case PAGE_CODE_GET_SUPPORTED_LOG_PAGES:
4844 	case PAGE_CODE_SELF_TEST_RESULTS:
4845 	case PAGE_CODE_INFORMATION_EXCEPTIONS:
4846 	case PAGE_CODE_SMART_READ_DATA:
4847 		break;
4848 	default:
4849 		*scsipkt->pkt_scbp = STATUS_CHECK;
4850 		sense = sata_arq_sense(spx);
4851 		sense->es_key = KEY_ILLEGAL_REQUEST;
4852 		sense->es_add_code = SD_SCSI_INVALID_FIELD_IN_CDB;
4853 		goto done;
4854 	}
4855 
4856 	if (bp != NULL && bp->b_un.b_addr && bp->b_bcount) {
4857 		sata_id_t *sata_id;
4858 		len = 0;
4859 
4860 		/* Build log parameter header */
4861 		buf[len++] = page_code;	/* page code as in the CDB */
4862 		buf[len++] = 0;		/* reserved */
4863 		buf[len++] = 0;		/* Zero out page length for now (MSB) */
4864 		buf[len++] = 0;		/* (LSB) */
4865 
4866 		sdinfo = sata_get_device_info(
4867 		    spx->txlt_sata_hba_inst,
4868 		    &spx->txlt_sata_pkt->satapkt_device);
4869 
4870 
4871 		/*
4872 		 * Add requested pages.
4873 		 */
4874 		switch (page_code) {
4875 		case PAGE_CODE_GET_SUPPORTED_LOG_PAGES:
4876 			len = sata_build_lsense_page_0(sdinfo, buf + len);
4877 			break;
4878 		case PAGE_CODE_SELF_TEST_RESULTS:
4879 			sata_id = &sdinfo->satadrv_id;
4880 			if ((! (sata_id->ai_cmdset84 &
4881 			    SATA_SMART_SELF_TEST_SUPPORTED)) ||
4882 			    (! (sata_id->ai_features87 &
4883 			    SATA_SMART_SELF_TEST_SUPPORTED))) {
4884 				*scsipkt->pkt_scbp = STATUS_CHECK;
4885 				sense = sata_arq_sense(spx);
4886 				sense->es_key = KEY_ILLEGAL_REQUEST;
4887 				sense->es_add_code =
4888 				    SD_SCSI_INVALID_FIELD_IN_CDB;
4889 
4890 				goto done;
4891 			}
4892 			len = sata_build_lsense_page_10(sdinfo, buf + len,
4893 			    spx->txlt_sata_hba_inst);
4894 			break;
4895 		case PAGE_CODE_INFORMATION_EXCEPTIONS:
4896 			sata_id = &sdinfo->satadrv_id;
4897 			if (! (sata_id->ai_cmdset82 & SATA_SMART_SUPPORTED)) {
4898 				*scsipkt->pkt_scbp = STATUS_CHECK;
4899 				sense = sata_arq_sense(spx);
4900 				sense->es_key = KEY_ILLEGAL_REQUEST;
4901 				sense->es_add_code =
4902 				    SD_SCSI_INVALID_FIELD_IN_CDB;
4903 
4904 				goto done;
4905 			}
4906 			if (! (sata_id->ai_features85 & SATA_SMART_ENABLED)) {
4907 				*scsipkt->pkt_scbp = STATUS_CHECK;
4908 				sense = sata_arq_sense(spx);
4909 				sense->es_key = KEY_ABORTED_COMMAND;
4910 				sense->es_add_code =
4911 				    SCSI_ASC_ATA_DEV_FEAT_NOT_ENABLED;
4912 				sense->es_qual_code =
4913 				    SCSI_ASCQ_ATA_DEV_FEAT_NOT_ENABLED;
4914 
4915 				goto done;
4916 			}
4917 
4918 			len = sata_build_lsense_page_2f(sdinfo, buf + len,
4919 			    spx->txlt_sata_hba_inst);
4920 			break;
4921 		case PAGE_CODE_SMART_READ_DATA:
4922 			sata_id = &sdinfo->satadrv_id;
4923 			if (! (sata_id->ai_cmdset82 & SATA_SMART_SUPPORTED)) {
4924 				*scsipkt->pkt_scbp = STATUS_CHECK;
4925 				sense = sata_arq_sense(spx);
4926 				sense->es_key = KEY_ILLEGAL_REQUEST;
4927 				sense->es_add_code =
4928 				    SD_SCSI_INVALID_FIELD_IN_CDB;
4929 
4930 				goto done;
4931 			}
4932 			if (! (sata_id->ai_features85 & SATA_SMART_ENABLED)) {
4933 				*scsipkt->pkt_scbp = STATUS_CHECK;
4934 				sense = sata_arq_sense(spx);
4935 				sense->es_key = KEY_ABORTED_COMMAND;
4936 				sense->es_add_code =
4937 				    SCSI_ASC_ATA_DEV_FEAT_NOT_ENABLED;
4938 				sense->es_qual_code =
4939 				    SCSI_ASCQ_ATA_DEV_FEAT_NOT_ENABLED;
4940 
4941 				goto done;
4942 			}
4943 
4944 			/* This page doesn't include a page header */
4945 			len = sata_build_lsense_page_30(sdinfo, buf,
4946 			    spx->txlt_sata_hba_inst);
4947 			goto no_header;
4948 		default:
4949 			/* Invalid request */
4950 			*scsipkt->pkt_scbp = STATUS_CHECK;
4951 			sense = sata_arq_sense(spx);
4952 			sense->es_key = KEY_ILLEGAL_REQUEST;
4953 			sense->es_add_code = SD_SCSI_INVALID_FIELD_IN_CDB;
4954 			goto done;
4955 		}
4956 
4957 		/* set parameter log sense data length */
4958 		buf[2] = len >> 8;	/* log sense length (MSB) */
4959 		buf[3] = len & 0xff;	/* log sense length (LSB) */
4960 
4961 		len += SCSI_LOG_PAGE_HDR_LEN;
4962 		ASSERT(len <= MAX_LOG_SENSE_PAGE_SIZE);
4963 
4964 no_header:
4965 		/* Check allocation length */
4966 		alc_len = scsipkt->pkt_cdbp[7];
4967 		alc_len = (len << 8) | scsipkt->pkt_cdbp[8];
4968 
4969 		/*
4970 		 * We do not check for possible parameters truncation
4971 		 * (alc_len < len) assuming that the target driver works
4972 		 * correctly. Just avoiding overrun.
4973 		 * Copy no more than requested and possible, buffer-wise.
4974 		 */
4975 		count = MIN(alc_len, len);
4976 		count = MIN(bp->b_bcount, count);
4977 		bcopy(buf, bp->b_un.b_addr, count);
4978 
4979 		scsipkt->pkt_state |= STATE_XFERRED_DATA;
4980 		scsipkt->pkt_resid = alc_len > count ? alc_len - count : 0;
4981 	}
4982 	*scsipkt->pkt_scbp = STATUS_GOOD;
4983 done:
4984 	mutex_exit(&(SATA_TXLT_CPORT_MUTEX(spx)));
4985 	(void) kmem_free(buf, MAX_LOG_SENSE_PAGE_SIZE);
4986 
4987 	SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst,
4988 	    "Scsi_pkt completion reason %x\n", scsipkt->pkt_reason);
4989 
4990 	if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0 &&
4991 	    scsipkt->pkt_comp != NULL)
4992 		/* scsi callback required */
4993 		if (taskq_dispatch(SATA_TXLT_TASKQ(spx),
4994 		    (task_func_t *)scsipkt->pkt_comp, (void *) scsipkt,
4995 		    TQ_SLEEP) == NULL)
4996 			/* Scheduling the callback failed */
4997 			return (TRAN_BUSY);
4998 
4999 	return (TRAN_ACCEPT);
5000 }
5001 
5002 /*
5003  * Translate command: Log Select
5004  * Not implemented at this time - returns invalid command response.
5005  */
5006 static 	int
5007 sata_txlt_log_select(sata_pkt_txlate_t *spx)
5008 {
5009 	SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst,
5010 	    "sata_txlt_log_select\n", NULL);
5011 
5012 	return (sata_txlt_invalid_command(spx));
5013 }
5014 
5015 
5016 /*
5017  * Translate command: Read (various types).
5018  * Translated into appropriate type of ATA READ command
5019  * (NO ATAPI implementation yet).
5020  * Both the device capabilities and requested operation mode are
5021  * considered.
5022  *
5023  * Following scsi cdb fields are ignored:
5024  * rdprotect, dpo, fua, fua_nv, group_number.
5025  *
5026  * If SATA_ENABLE_QUEUING flag is set (in the global SATA HBA framework
5027  * enable variable sata_func_enable), the capability of the controller and
5028  * capability of a device are checked and if both support queueing, read
5029  * request will be translated to READ_DMA_QUEUEING or READ_DMA_QUEUEING_EXT
5030  * command rather than plain READ_XXX command.
5031  * If SATA_ENABLE_NCQ flag is set in addition to SATA_ENABLE_QUEUING flag and
5032  * both the controller and device suport such functionality, the read
5033  * request will be translated to READ_FPDMA_QUEUED command.
5034  *
5035  * Returns TRAN_ACCEPT or code returned by sata_hba_start() and
5036  * appropriate values in scsi_pkt fields.
5037  */
5038 static int
5039 sata_txlt_read(sata_pkt_txlate_t *spx)
5040 {
5041 	struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt;
5042 	sata_cmd_t *scmd = &spx->txlt_sata_pkt->satapkt_cmd;
5043 	sata_drive_info_t *sdinfo;
5044 	sata_hba_inst_t *shi = SATA_TXLT_HBA_INST(spx);
5045 	int cport = SATA_TXLT_CPORT(spx);
5046 	uint16_t sec_count;
5047 	uint64_t lba;
5048 	int rval;
5049 	int synch;
5050 
5051 	mutex_enter(&(SATA_TXLT_CPORT_MUTEX(spx)));
5052 
5053 	if (((rval = sata_txlt_generic_pkt_info(spx)) != TRAN_ACCEPT) ||
5054 	    (spx->txlt_scsi_pkt->pkt_reason == CMD_DEV_GONE)) {
5055 		mutex_exit(&(SATA_TXLT_CPORT_MUTEX(spx)));
5056 		return (rval);
5057 	}
5058 
5059 	sdinfo = sata_get_device_info(spx->txlt_sata_hba_inst,
5060 	    &spx->txlt_sata_pkt->satapkt_device);
5061 
5062 	scmd->satacmd_flags.sata_data_direction = SATA_DIR_READ;
5063 	/*
5064 	 * Extract LBA and sector count from scsi CDB.
5065 	 */
5066 	switch ((uint_t)scsipkt->pkt_cdbp[0]) {
5067 	case SCMD_READ:
5068 		/* 6-byte scsi read cmd : 0x08 */
5069 		lba = (scsipkt->pkt_cdbp[1] & 0x1f);
5070 		lba = (lba << 8) | scsipkt->pkt_cdbp[2];
5071 		lba = (lba << 8) | scsipkt->pkt_cdbp[3];
5072 		sec_count = scsipkt->pkt_cdbp[4];
5073 		/* sec_count 0 will be interpreted as 256 by a device */
5074 		break;
5075 	case SCMD_READ_G1:
5076 		/* 10-bytes scsi read command : 0x28 */
5077 		lba = scsipkt->pkt_cdbp[2];
5078 		lba = (lba << 8) | scsipkt->pkt_cdbp[3];
5079 		lba = (lba << 8) | scsipkt->pkt_cdbp[4];
5080 		lba = (lba << 8) | scsipkt->pkt_cdbp[5];
5081 		sec_count = scsipkt->pkt_cdbp[7];
5082 		sec_count = (sec_count << 8) | scsipkt->pkt_cdbp[8];
5083 		break;
5084 	case SCMD_READ_G5:
5085 		/* 12-bytes scsi read command : 0xA8 */
5086 		lba = scsipkt->pkt_cdbp[2];
5087 		lba = (lba << 8) | scsipkt->pkt_cdbp[3];
5088 		lba = (lba << 8) | scsipkt->pkt_cdbp[4];
5089 		lba = (lba << 8) | scsipkt->pkt_cdbp[5];
5090 		sec_count = scsipkt->pkt_cdbp[6];
5091 		sec_count = (sec_count << 8) | scsipkt->pkt_cdbp[7];
5092 		sec_count = (sec_count << 8) | scsipkt->pkt_cdbp[8];
5093 		sec_count = (sec_count << 8) | scsipkt->pkt_cdbp[9];
5094 		break;
5095 	case SCMD_READ_G4:
5096 		/* 16-bytes scsi read command : 0x88 */
5097 		lba = scsipkt->pkt_cdbp[2];
5098 		lba = (lba << 8) | scsipkt->pkt_cdbp[3];
5099 		lba = (lba << 8) | scsipkt->pkt_cdbp[4];
5100 		lba = (lba << 8) | scsipkt->pkt_cdbp[5];
5101 		lba = (lba << 8) | scsipkt->pkt_cdbp[6];
5102 		lba = (lba << 8) | scsipkt->pkt_cdbp[7];
5103 		lba = (lba << 8) | scsipkt->pkt_cdbp[8];
5104 		lba = (lba << 8) | scsipkt->pkt_cdbp[9];
5105 		sec_count = scsipkt->pkt_cdbp[10];
5106 		sec_count = (sec_count << 8) | scsipkt->pkt_cdbp[11];
5107 		sec_count = (sec_count << 8) | scsipkt->pkt_cdbp[12];
5108 		sec_count = (sec_count << 8) | scsipkt->pkt_cdbp[13];
5109 		break;
5110 	default:
5111 		/* Unsupported command */
5112 		mutex_exit(&(SATA_TXLT_CPORT_MUTEX(spx)));
5113 		return (sata_txlt_invalid_command(spx));
5114 	}
5115 
5116 	/*
5117 	 * Check if specified address exceeds device capacity
5118 	 */
5119 	if ((lba >= sdinfo->satadrv_capacity) ||
5120 	    ((lba + sec_count) > sdinfo->satadrv_capacity)) {
5121 		/* LBA out of range */
5122 		mutex_exit(&(SATA_TXLT_CPORT_MUTEX(spx)));
5123 		return (sata_txlt_lba_out_of_range(spx));
5124 	}
5125 
5126 	/*
5127 	 * For zero-length transfer, emulate good completion of the command
5128 	 * (reasons for rejecting the command were already checked).
5129 	 * No DMA resources were allocated.
5130 	 */
5131 	if (spx->txlt_dma_cookie_list == NULL) {
5132 		mutex_exit(&(SATA_TXLT_CPORT_MUTEX(spx)));
5133 		return (sata_emul_rw_completion(spx));
5134 	}
5135 
5136 	/*
5137 	 * Build cmd block depending on the device capability and
5138 	 * requested operation mode.
5139 	 * Do not bother with non-dma mode - we are working only with
5140 	 * devices supporting DMA.
5141 	 */
5142 	scmd->satacmd_addr_type = ATA_ADDR_LBA;
5143 	scmd->satacmd_device_reg = SATA_ADH_LBA;
5144 	scmd->satacmd_cmd_reg = SATAC_READ_DMA;
5145 	if (sdinfo->satadrv_features_support & SATA_DEV_F_LBA48) {
5146 		scmd->satacmd_addr_type = ATA_ADDR_LBA48;
5147 		scmd->satacmd_cmd_reg = SATAC_READ_DMA_EXT;
5148 		scmd->satacmd_sec_count_msb = sec_count >> 8;
5149 #ifndef __lock_lint
5150 		scmd->satacmd_lba_low_msb = (lba >> 24) & 0xff;
5151 		scmd->satacmd_lba_mid_msb = (lba >> 32) & 0xff;
5152 		scmd->satacmd_lba_high_msb = lba >> 40;
5153 #endif
5154 	} else if (sdinfo->satadrv_features_support & SATA_DEV_F_LBA28) {
5155 		scmd->satacmd_addr_type = ATA_ADDR_LBA28;
5156 		scmd->satacmd_device_reg = SATA_ADH_LBA | ((lba >> 24) & 0xf);
5157 	}
5158 	scmd->satacmd_sec_count_lsb = sec_count & 0xff;
5159 	scmd->satacmd_lba_low_lsb = lba & 0xff;
5160 	scmd->satacmd_lba_mid_lsb = (lba >> 8) & 0xff;
5161 	scmd->satacmd_lba_high_lsb = (lba >> 16) & 0xff;
5162 	scmd->satacmd_features_reg = 0;
5163 	scmd->satacmd_status_reg = 0;
5164 	scmd->satacmd_error_reg = 0;
5165 
5166 	/*
5167 	 * Check if queueing commands should be used and switch
5168 	 * to appropriate command if possible
5169 	 */
5170 	if (sata_func_enable & SATA_ENABLE_QUEUING) {
5171 		boolean_t using_queuing;
5172 
5173 		/* Queuing supported by controller and device? */
5174 		if ((sata_func_enable & SATA_ENABLE_NCQ) &&
5175 		    (sdinfo->satadrv_features_support &
5176 		    SATA_DEV_F_NCQ) &&
5177 		    (SATA_FEATURES(spx->txlt_sata_hba_inst) &
5178 		    SATA_CTLF_NCQ)) {
5179 			using_queuing = B_TRUE;
5180 
5181 			/* NCQ supported - use FPDMA READ */
5182 			scmd->satacmd_cmd_reg =
5183 			    SATAC_READ_FPDMA_QUEUED;
5184 			scmd->satacmd_features_reg_ext =
5185 			    scmd->satacmd_sec_count_msb;
5186 			scmd->satacmd_sec_count_msb = 0;
5187 			scmd->satacmd_rle_sata_cmd = &sata_rle_cmd;
5188 		} else if ((sdinfo->satadrv_features_support &
5189 		    SATA_DEV_F_TCQ) &&
5190 		    (SATA_FEATURES(spx->txlt_sata_hba_inst) &
5191 		    SATA_CTLF_QCMD)) {
5192 			using_queuing = B_TRUE;
5193 
5194 			/* Legacy queueing */
5195 			if (sdinfo->satadrv_features_support &
5196 			    SATA_DEV_F_LBA48) {
5197 				scmd->satacmd_cmd_reg =
5198 				    SATAC_READ_DMA_QUEUED_EXT;
5199 				scmd->satacmd_features_reg_ext =
5200 				    scmd->satacmd_sec_count_msb;
5201 				scmd->satacmd_sec_count_msb = 0;
5202 			} else {
5203 				scmd->satacmd_cmd_reg =
5204 				    SATAC_READ_DMA_QUEUED;
5205 			}
5206 		} else	/* Queuing not supported */
5207 			using_queuing = B_FALSE;
5208 
5209 		/*
5210 		 * If queuing, the sector count goes in the features register
5211 		 * and the secount count will contain the tag.
5212 		 */
5213 		if (using_queuing) {
5214 			scmd->satacmd_features_reg =
5215 			    scmd->satacmd_sec_count_lsb;
5216 			scmd->satacmd_sec_count_lsb = 0;
5217 			scmd->satacmd_flags.sata_queued = B_TRUE;
5218 		}
5219 	}
5220 
5221 	SATADBG3(SATA_DBG_HBA_IF, spx->txlt_sata_hba_inst,
5222 	    "sata_txlt_read cmd 0x%2x, lba %llx, sec count %x\n",
5223 	    scmd->satacmd_cmd_reg, lba, sec_count);
5224 
5225 	if (!(spx->txlt_sata_pkt->satapkt_op_mode & SATA_OPMODE_SYNCH)) {
5226 		/* Need callback function */
5227 		spx->txlt_sata_pkt->satapkt_comp = sata_txlt_rw_completion;
5228 		synch = FALSE;
5229 	} else
5230 		synch = TRUE;
5231 
5232 	/* Transfer command to HBA */
5233 	if (sata_hba_start(spx, &rval) != 0) {
5234 		/* Pkt not accepted for execution */
5235 		mutex_exit(&SATA_CPORT_MUTEX(shi, cport));
5236 		return (rval);
5237 	}
5238 	mutex_exit(&SATA_CPORT_MUTEX(shi, cport));
5239 	/*
5240 	 * If execution is non-synchronous,
5241 	 * a callback function will handle potential errors, translate
5242 	 * the response and will do a callback to a target driver.
5243 	 * If it was synchronous, check execution status using the same
5244 	 * framework callback.
5245 	 */
5246 	if (synch) {
5247 		SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst,
5248 		    "synchronous execution status %x\n",
5249 		    spx->txlt_sata_pkt->satapkt_reason);
5250 		sata_txlt_rw_completion(spx->txlt_sata_pkt);
5251 	}
5252 	return (TRAN_ACCEPT);
5253 }
5254 
5255 
5256 /*
5257  * SATA translate command: Write (various types)
5258  * Translated into appropriate type of ATA WRITE command
5259  * (NO ATAPI implementation yet).
5260  * Both the device capabilities and requested operation mode are
5261  * considered.
5262  *
5263  * Following scsi cdb fields are ignored:
5264  * rwprotect, dpo, fua, fua_nv, group_number.
5265  *
5266  * Returns TRAN_ACCEPT or code returned by sata_hba_start() and
5267  * appropriate values in scsi_pkt fields.
5268  */
5269 static int
5270 sata_txlt_write(sata_pkt_txlate_t *spx)
5271 {
5272 	struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt;
5273 	sata_cmd_t *scmd = &spx->txlt_sata_pkt->satapkt_cmd;
5274 	sata_drive_info_t *sdinfo;
5275 	sata_hba_inst_t *shi = SATA_TXLT_HBA_INST(spx);
5276 	int cport = SATA_TXLT_CPORT(spx);
5277 	uint16_t sec_count;
5278 	uint64_t lba;
5279 	int rval;
5280 	int synch;
5281 
5282 	mutex_enter(&(SATA_TXLT_CPORT_MUTEX(spx)));
5283 
5284 	if (((rval = sata_txlt_generic_pkt_info(spx)) != TRAN_ACCEPT) ||
5285 	    (spx->txlt_scsi_pkt->pkt_reason == CMD_DEV_GONE)) {
5286 		mutex_exit(&(SATA_TXLT_CPORT_MUTEX(spx)));
5287 		return (rval);
5288 	}
5289 
5290 	sdinfo = sata_get_device_info(spx->txlt_sata_hba_inst,
5291 	    &spx->txlt_sata_pkt->satapkt_device);
5292 
5293 	scmd->satacmd_flags.sata_data_direction = SATA_DIR_WRITE;
5294 	/*
5295 	 * Extract LBA and sector count from scsi CDB
5296 	 */
5297 	switch ((uint_t)scsipkt->pkt_cdbp[0]) {
5298 	case SCMD_WRITE:
5299 		/* 6-byte scsi read cmd : 0x0A */
5300 		lba = (scsipkt->pkt_cdbp[1] & 0x1f);
5301 		lba = (lba << 8) | scsipkt->pkt_cdbp[2];
5302 		lba = (lba << 8) | scsipkt->pkt_cdbp[3];
5303 		sec_count = scsipkt->pkt_cdbp[4];
5304 		/* sec_count 0 will be interpreted as 256 by a device */
5305 		break;
5306 	case SCMD_WRITE_G1:
5307 		/* 10-bytes scsi write command : 0x2A */
5308 		lba = scsipkt->pkt_cdbp[2];
5309 		lba = (lba << 8) | scsipkt->pkt_cdbp[3];
5310 		lba = (lba << 8) | scsipkt->pkt_cdbp[4];
5311 		lba = (lba << 8) | scsipkt->pkt_cdbp[5];
5312 		sec_count = scsipkt->pkt_cdbp[7];
5313 		sec_count = (sec_count << 8) | scsipkt->pkt_cdbp[8];
5314 		break;
5315 	case SCMD_WRITE_G5:
5316 		/* 12-bytes scsi read command : 0xAA */
5317 		lba = scsipkt->pkt_cdbp[2];
5318 		lba = (lba << 8) | scsipkt->pkt_cdbp[3];
5319 		lba = (lba << 8) | scsipkt->pkt_cdbp[4];
5320 		lba = (lba << 8) | scsipkt->pkt_cdbp[5];
5321 		sec_count = scsipkt->pkt_cdbp[6];
5322 		sec_count = (sec_count << 8) | scsipkt->pkt_cdbp[7];
5323 		sec_count = (sec_count << 8) | scsipkt->pkt_cdbp[8];
5324 		sec_count = (sec_count << 8) | scsipkt->pkt_cdbp[9];
5325 		break;
5326 	case SCMD_WRITE_G4:
5327 		/* 16-bytes scsi write command : 0x8A */
5328 		lba = scsipkt->pkt_cdbp[2];
5329 		lba = (lba << 8) | scsipkt->pkt_cdbp[3];
5330 		lba = (lba << 8) | scsipkt->pkt_cdbp[4];
5331 		lba = (lba << 8) | scsipkt->pkt_cdbp[5];
5332 		lba = (lba << 8) | scsipkt->pkt_cdbp[6];
5333 		lba = (lba << 8) | scsipkt->pkt_cdbp[7];
5334 		lba = (lba << 8) | scsipkt->pkt_cdbp[8];
5335 		lba = (lba << 8) | scsipkt->pkt_cdbp[9];
5336 		sec_count = scsipkt->pkt_cdbp[10];
5337 		sec_count = (sec_count << 8) | scsipkt->pkt_cdbp[11];
5338 		sec_count = (sec_count << 8) | scsipkt->pkt_cdbp[12];
5339 		sec_count = (sec_count << 8) | scsipkt->pkt_cdbp[13];
5340 		break;
5341 	default:
5342 		/* Unsupported command */
5343 		mutex_exit(&(SATA_TXLT_CPORT_MUTEX(spx)));
5344 		return (sata_txlt_invalid_command(spx));
5345 	}
5346 
5347 	/*
5348 	 * Check if specified address and length exceeds device capacity
5349 	 */
5350 	if ((lba >= sdinfo->satadrv_capacity) ||
5351 	    ((lba + sec_count) > sdinfo->satadrv_capacity)) {
5352 		/* LBA out of range */
5353 		mutex_exit(&(SATA_TXLT_CPORT_MUTEX(spx)));
5354 		return (sata_txlt_lba_out_of_range(spx));
5355 	}
5356 
5357 	/*
5358 	 * For zero-length transfer, emulate good completion of the command
5359 	 * (reasons for rejecting the command were already checked).
5360 	 * No DMA resources were allocated.
5361 	 */
5362 	if (spx->txlt_dma_cookie_list == NULL) {
5363 		mutex_exit(&(SATA_TXLT_CPORT_MUTEX(spx)));
5364 		return (sata_emul_rw_completion(spx));
5365 	}
5366 
5367 	/*
5368 	 * Build cmd block depending on the device capability and
5369 	 * requested operation mode.
5370 	 * Do not bother with non-dma mode- we are working only with
5371 	 * devices supporting DMA.
5372 	 */
5373 	scmd->satacmd_addr_type = ATA_ADDR_LBA;
5374 	scmd->satacmd_device_reg = SATA_ADH_LBA;
5375 	scmd->satacmd_cmd_reg = SATAC_WRITE_DMA;
5376 	if (sdinfo->satadrv_features_support & SATA_DEV_F_LBA48) {
5377 		scmd->satacmd_addr_type = ATA_ADDR_LBA48;
5378 		scmd->satacmd_cmd_reg = SATAC_WRITE_DMA_EXT;
5379 		scmd->satacmd_sec_count_msb = sec_count >> 8;
5380 		scmd->satacmd_lba_low_msb = (lba >> 24) & 0xff;
5381 #ifndef __lock_lint
5382 		scmd->satacmd_lba_mid_msb = (lba >> 32) & 0xff;
5383 		scmd->satacmd_lba_high_msb = lba >> 40;
5384 #endif
5385 	} else if (sdinfo->satadrv_features_support & SATA_DEV_F_LBA28) {
5386 		scmd->satacmd_addr_type = ATA_ADDR_LBA28;
5387 		scmd->satacmd_device_reg = SATA_ADH_LBA | ((lba >> 24) & 0xf);
5388 	}
5389 	scmd->satacmd_sec_count_lsb = sec_count & 0xff;
5390 	scmd->satacmd_lba_low_lsb = lba & 0xff;
5391 	scmd->satacmd_lba_mid_lsb = (lba >> 8) & 0xff;
5392 	scmd->satacmd_lba_high_lsb = (lba >> 16) & 0xff;
5393 	scmd->satacmd_features_reg = 0;
5394 	scmd->satacmd_status_reg = 0;
5395 	scmd->satacmd_error_reg = 0;
5396 
5397 	/*
5398 	 * Check if queueing commands should be used and switch
5399 	 * to appropriate command if possible
5400 	 */
5401 	if (sata_func_enable & SATA_ENABLE_QUEUING) {
5402 		boolean_t using_queuing;
5403 
5404 		/* Queuing supported by controller and device? */
5405 		if ((sata_func_enable & SATA_ENABLE_NCQ) &&
5406 		    (sdinfo->satadrv_features_support &
5407 		    SATA_DEV_F_NCQ) &&
5408 		    (SATA_FEATURES(spx->txlt_sata_hba_inst) &
5409 		    SATA_CTLF_NCQ)) {
5410 			using_queuing = B_TRUE;
5411 
5412 			/* NCQ supported - use FPDMA WRITE */
5413 			scmd->satacmd_cmd_reg =
5414 			    SATAC_WRITE_FPDMA_QUEUED;
5415 			scmd->satacmd_features_reg_ext =
5416 			    scmd->satacmd_sec_count_msb;
5417 			scmd->satacmd_sec_count_msb = 0;
5418 			scmd->satacmd_rle_sata_cmd = &sata_rle_cmd;
5419 		} else if ((sdinfo->satadrv_features_support &
5420 		    SATA_DEV_F_TCQ) &&
5421 		    (SATA_FEATURES(spx->txlt_sata_hba_inst) &
5422 		    SATA_CTLF_QCMD)) {
5423 			using_queuing = B_TRUE;
5424 
5425 			/* Legacy queueing */
5426 			if (sdinfo->satadrv_features_support &
5427 			    SATA_DEV_F_LBA48) {
5428 				scmd->satacmd_cmd_reg =
5429 				    SATAC_WRITE_DMA_QUEUED_EXT;
5430 				scmd->satacmd_features_reg_ext =
5431 				    scmd->satacmd_sec_count_msb;
5432 				scmd->satacmd_sec_count_msb = 0;
5433 			} else {
5434 				scmd->satacmd_cmd_reg =
5435 				    SATAC_WRITE_DMA_QUEUED;
5436 			}
5437 		} else	/* Queuing not supported */
5438 			using_queuing = B_FALSE;
5439 
5440 		if (using_queuing) {
5441 			scmd->satacmd_features_reg =
5442 			    scmd->satacmd_sec_count_lsb;
5443 			scmd->satacmd_sec_count_lsb = 0;
5444 			scmd->satacmd_flags.sata_queued = B_TRUE;
5445 		}
5446 	}
5447 
5448 	SATADBG3(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst,
5449 	    "sata_txlt_write cmd 0x%2x, lba %llx, sec count %x\n",
5450 	    scmd->satacmd_cmd_reg, lba, sec_count);
5451 
5452 	if (!(spx->txlt_sata_pkt->satapkt_op_mode & SATA_OPMODE_SYNCH)) {
5453 		/* Need callback function */
5454 		spx->txlt_sata_pkt->satapkt_comp = sata_txlt_rw_completion;
5455 		synch = FALSE;
5456 	} else
5457 		synch = TRUE;
5458 
5459 	/* Transfer command to HBA */
5460 	if (sata_hba_start(spx, &rval) != 0) {
5461 		/* Pkt not accepted for execution */
5462 		mutex_exit(&SATA_CPORT_MUTEX(shi, cport));
5463 		return (rval);
5464 	}
5465 	mutex_exit(&SATA_CPORT_MUTEX(shi, cport));
5466 
5467 	/*
5468 	 * If execution is non-synchronous,
5469 	 * a callback function will handle potential errors, translate
5470 	 * the response and will do a callback to a target driver.
5471 	 * If it was synchronous, check execution status using the same
5472 	 * framework callback.
5473 	 */
5474 	if (synch) {
5475 		SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst,
5476 		    "synchronous execution status %x\n",
5477 		    spx->txlt_sata_pkt->satapkt_reason);
5478 		sata_txlt_rw_completion(spx->txlt_sata_pkt);
5479 	}
5480 	return (TRAN_ACCEPT);
5481 }
5482 
5483 
5484 /*
5485  * NOTE: NOT FUNCTIONAL IMPLEMENTATION. THIS IS A PLACEHOLDER for the function
5486  * that will be fixed in phase 2 of the development.
5487  * Currently ATAPI is not supported. ATAPI devices are threated as not-valid
5488  * devices.
5489  * This function is not called, since scsi_sata_start() will bail-out prior
5490  * to calling it.
5491  */
5492 static int
5493 sata_txlt_atapi(sata_pkt_txlate_t *spx)
5494 {
5495 	struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt;
5496 	sata_cmd_t *scmd = &spx->txlt_sata_pkt->satapkt_cmd;
5497 	struct buf *bp = spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp;
5498 	sata_hba_inst_t *shi = SATA_TXLT_HBA_INST(spx);
5499 	int cport = SATA_TXLT_CPORT(spx);
5500 	int rval;
5501 	int synch;
5502 	union scsi_cdb *cdbp = (union scsi_cdb *)scsipkt->pkt_cdbp;
5503 
5504 	mutex_enter(&(SATA_TXLT_CPORT_MUTEX(spx)));
5505 
5506 	if (((rval = sata_txlt_generic_pkt_info(spx)) != TRAN_ACCEPT) ||
5507 	    (spx->txlt_scsi_pkt->pkt_reason == CMD_DEV_GONE)) {
5508 		mutex_exit(&(SATA_TXLT_CPORT_MUTEX(spx)));
5509 		return (rval);
5510 	}
5511 
5512 	/*
5513 	 * scmd->satacmd_flags.sata_data_direction default -
5514 	 * SATA_DIR_NODATA_XFER - is set by
5515 	 * sata_txlt_generic_pkt_info().
5516 	 */
5517 	if (scmd->satacmd_bp) {
5518 		if (scmd->satacmd_bp->b_flags & B_READ) {
5519 			scmd->satacmd_flags.sata_data_direction = SATA_DIR_READ;
5520 		} else {
5521 			scmd->satacmd_flags.sata_data_direction =
5522 			    SATA_DIR_WRITE;
5523 		}
5524 	}
5525 
5526 	scmd->satacmd_acdb_len = scsi_cdb_size[GETGROUP(cdbp)];
5527 	scmd->satacmd_cmd_reg = SATAC_PACKET;
5528 	bcopy(cdbp, scmd->satacmd_acdb,  16);
5529 
5530 	/*
5531 	 * For non-read/write commands we need to
5532 	 * map buffer
5533 	 */
5534 	switch ((uint_t)scsipkt->pkt_cdbp[0]) {
5535 	case SCMD_READ:
5536 	case SCMD_READ_G1:
5537 	case SCMD_READ_G5:
5538 	case SCMD_READ_G4:
5539 	case SCMD_WRITE:
5540 	case SCMD_WRITE_G1:
5541 	case SCMD_WRITE_G5:
5542 	case SCMD_WRITE_G4:
5543 		break;
5544 	default:
5545 		if (bp->b_flags & (B_PHYS | B_PAGEIO))
5546 			bp_mapin(bp);
5547 		break;
5548 	}
5549 
5550 	if (!(spx->txlt_sata_pkt->satapkt_op_mode & SATA_OPMODE_SYNCH)) {
5551 		/* Need callback function */
5552 		spx->txlt_sata_pkt->satapkt_comp = sata_txlt_atapi_completion;
5553 		synch = FALSE;
5554 	} else
5555 		synch = TRUE;
5556 
5557 	/* Transfer command to HBA */
5558 	if (sata_hba_start(spx, &rval) != 0) {
5559 		/* Pkt not accepted for execution */
5560 		mutex_exit(&SATA_CPORT_MUTEX(shi, cport));
5561 		return (rval);
5562 	}
5563 	mutex_exit(&SATA_CPORT_MUTEX(shi, cport));
5564 	/*
5565 	 * If execution is non-synchronous,
5566 	 * a callback function will handle potential errors, translate
5567 	 * the response and will do a callback to a target driver.
5568 	 * If it was synchronous, check execution status using the same
5569 	 * framework callback.
5570 	 */
5571 	if (synch) {
5572 		SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst,
5573 		    "synchronous execution status %x\n",
5574 		    spx->txlt_sata_pkt->satapkt_reason);
5575 		sata_txlt_atapi_completion(spx->txlt_sata_pkt);
5576 	}
5577 	return (TRAN_ACCEPT);
5578 }
5579 
5580 /*
5581  * Translate command: Synchronize Cache.
5582  * Translates into Flush Cache command.
5583  * (NO ATAPI implementation yet).
5584  *
5585  * NOTE: We should check if Flush Cache is supported by the device (ATAPI
5586  * devices)
5587  *
5588  * Returns TRAN_ACCEPT or code returned by sata_hba_start() and
5589  * appropriate values in scsi_pkt fields.
5590  */
5591 static 	int
5592 sata_txlt_synchronize_cache(sata_pkt_txlate_t *spx)
5593 {
5594 	sata_cmd_t *scmd = &spx->txlt_sata_pkt->satapkt_cmd;
5595 	sata_hba_inst_t *shi = SATA_TXLT_HBA_INST(spx);
5596 	int cport = SATA_TXLT_CPORT(spx);
5597 	int rval;
5598 	int synch;
5599 
5600 	mutex_enter(&(SATA_TXLT_CPORT_MUTEX(spx)));
5601 
5602 	if (((rval = sata_txlt_generic_pkt_info(spx)) != TRAN_ACCEPT) ||
5603 	    (spx->txlt_scsi_pkt->pkt_reason == CMD_DEV_GONE)) {
5604 		mutex_exit(&(SATA_TXLT_CPORT_MUTEX(spx)));
5605 		return (rval);
5606 	}
5607 
5608 	scmd->satacmd_addr_type = 0;
5609 	scmd->satacmd_cmd_reg = SATAC_FLUSH_CACHE;
5610 	scmd->satacmd_device_reg = 0;
5611 	scmd->satacmd_sec_count_lsb = 0;
5612 	scmd->satacmd_lba_low_lsb = 0;
5613 	scmd->satacmd_lba_mid_lsb = 0;
5614 	scmd->satacmd_lba_high_lsb = 0;
5615 	scmd->satacmd_features_reg = 0;
5616 	scmd->satacmd_status_reg = 0;
5617 	scmd->satacmd_error_reg = 0;
5618 
5619 	SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst,
5620 	    "sata_txlt_synchronize_cache\n", NULL);
5621 
5622 	if (!(spx->txlt_sata_pkt->satapkt_op_mode & SATA_OPMODE_SYNCH)) {
5623 		/* Need to set-up a callback function */
5624 		spx->txlt_sata_pkt->satapkt_comp =
5625 		    sata_txlt_nodata_cmd_completion;
5626 		synch = FALSE;
5627 	} else
5628 		synch = TRUE;
5629 
5630 	/* Transfer command to HBA */
5631 	if (sata_hba_start(spx, &rval) != 0) {
5632 		/* Pkt not accepted for execution */
5633 		mutex_exit(&SATA_CPORT_MUTEX(shi, cport));
5634 		return (rval);
5635 	}
5636 	mutex_exit(&SATA_CPORT_MUTEX(shi, cport));
5637 
5638 	/*
5639 	 * If execution non-synchronous, it had to be completed
5640 	 * a callback function will handle potential errors, translate
5641 	 * the response and will do a callback to a target driver.
5642 	 * If it was synchronous, check status, using the same
5643 	 * framework callback.
5644 	 */
5645 	if (synch) {
5646 		SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst,
5647 		    "synchronous execution status %x\n",
5648 		    spx->txlt_sata_pkt->satapkt_reason);
5649 		sata_txlt_nodata_cmd_completion(spx->txlt_sata_pkt);
5650 	}
5651 	return (TRAN_ACCEPT);
5652 }
5653 
5654 /*
5655  * Send pkt to SATA HBA driver
5656  *
5657  * This function may be called only if the operation is requested by scsi_pkt,
5658  * i.e. scsi_pkt is not NULL.
5659  *
5660  * This function has to be called with cport mutex held. It does release
5661  * the mutex when it calls HBA driver sata_tran_start function and
5662  * re-acquires it afterwards.
5663  *
5664  * If return value is 0, pkt was accepted, -1 otherwise
5665  * rval is set to appropriate sata_scsi_start return value.
5666  *
5667  * Note 1:If HBA driver returns value other than TRAN_ACCEPT, it should not
5668  * have called the sata_pkt callback function for this packet.
5669  *
5670  * The scsi callback has to be performed by the caller of this routine.
5671  *
5672  * Note 2: No port multiplier support for now.
5673  */
5674 static int
5675 sata_hba_start(sata_pkt_txlate_t *spx, int *rval)
5676 {
5677 	int stat, cport;
5678 	sata_hba_inst_t *sata_hba_inst = spx->txlt_sata_hba_inst;
5679 	sata_drive_info_t *sdinfo;
5680 	sata_device_t *sata_device;
5681 	uint8_t cmd;
5682 	struct sata_cmd_flags cmd_flags;
5683 
5684 	ASSERT(spx->txlt_sata_pkt != NULL);
5685 
5686 	cport = SATA_TXLT_CPORT(spx);
5687 	ASSERT(mutex_owned(&SATA_CPORT_MUTEX(sata_hba_inst, cport)));
5688 
5689 	sdinfo = sata_get_device_info(sata_hba_inst,
5690 	    &spx->txlt_sata_pkt->satapkt_device);
5691 	ASSERT(sdinfo != NULL);
5692 
5693 	/* Clear device reset state? */
5694 	if (sdinfo->satadrv_event_flags & SATA_EVNT_CLEAR_DEVICE_RESET) {
5695 		spx->txlt_sata_pkt->satapkt_cmd.satacmd_flags.
5696 		    sata_clear_dev_reset = B_TRUE;
5697 		sdinfo->satadrv_event_flags &= ~SATA_EVNT_CLEAR_DEVICE_RESET;
5698 		SATADBG1(SATA_DBG_EVENTS, sata_hba_inst,
5699 		    "sata_hba_start: clearing device reset state\n", NULL);
5700 	}
5701 	cmd = spx->txlt_sata_pkt->satapkt_cmd.satacmd_cmd_reg;
5702 	cmd_flags = spx->txlt_sata_pkt->satapkt_cmd.satacmd_flags;
5703 	sata_device = &spx->txlt_sata_pkt->satapkt_device;
5704 
5705 	mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, cport)));
5706 
5707 	SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst,
5708 	    "Sata cmd 0x%2x\n", cmd);
5709 
5710 	stat = (*SATA_START_FUNC(sata_hba_inst))(SATA_DIP(sata_hba_inst),
5711 	    spx->txlt_sata_pkt);
5712 
5713 	mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, cport)));
5714 	sdinfo = sata_get_device_info(sata_hba_inst, sata_device);
5715 	/*
5716 	 * If sata pkt was accepted and executed in asynchronous mode, i.e.
5717 	 * with the sata callback, the sata_pkt could be already destroyed
5718 	 * by the time we check ther return status from the hba_start()
5719 	 * function, because sata_scsi_destroy_pkt() could have been already
5720 	 * called (perhaps in the interrupt context). So, in such case, there
5721 	 * should be no references to it. In other cases, sata_pkt still
5722 	 * exists.
5723 	 */
5724 	switch (stat) {
5725 	case SATA_TRAN_ACCEPTED:
5726 		/*
5727 		 * pkt accepted for execution.
5728 		 * If it was executed synchronously, it is already completed
5729 		 * and pkt completion_reason indicates completion status.
5730 		 */
5731 		*rval = TRAN_ACCEPT;
5732 		return (0);
5733 
5734 	case SATA_TRAN_QUEUE_FULL:
5735 		/*
5736 		 * Controller detected queue full condition.
5737 		 */
5738 		SATADBG1(SATA_DBG_HBA_IF, sata_hba_inst,
5739 		    "sata_hba_start: queue full\n", NULL);
5740 
5741 		spx->txlt_scsi_pkt->pkt_reason = CMD_INCOMPLETE;
5742 		*spx->txlt_scsi_pkt->pkt_scbp = STATUS_QFULL;
5743 
5744 		*rval = TRAN_BUSY;
5745 		break;
5746 
5747 	case SATA_TRAN_PORT_ERROR:
5748 		/*
5749 		 * Communication/link with device or general port error
5750 		 * detected before pkt execution begun.
5751 		 */
5752 		if (spx->txlt_sata_pkt->satapkt_device.satadev_addr.qual ==
5753 		    SATA_ADDR_CPORT ||
5754 		    spx->txlt_sata_pkt->satapkt_device.satadev_addr.qual ==
5755 		    SATA_ADDR_DCPORT)
5756 			sata_log(sata_hba_inst, CE_CONT,
5757 			    "SATA port %d error",
5758 			    sata_device->satadev_addr.cport);
5759 		else
5760 			sata_log(sata_hba_inst, CE_CONT,
5761 			    "SATA port %d pmport %d error\n",
5762 			    sata_device->satadev_addr.cport,
5763 			    sata_device->satadev_addr.pmport);
5764 
5765 		/*
5766 		 * Update the port/device structure.
5767 		 * sata_pkt should be still valid. Since port error is
5768 		 * returned, sata_device content should reflect port
5769 		 * state - it means, that sata address have been changed,
5770 		 * because original packet's sata address refered to a device
5771 		 * attached to some port.
5772 		 */
5773 		sata_update_port_info(sata_hba_inst, sata_device);
5774 		spx->txlt_scsi_pkt->pkt_reason = CMD_TRAN_ERR;
5775 		*rval = TRAN_FATAL_ERROR;
5776 		break;
5777 
5778 	case SATA_TRAN_CMD_UNSUPPORTED:
5779 		/*
5780 		 * Command rejected by HBA as unsupported. It was HBA driver
5781 		 * that rejected the command, command was not sent to
5782 		 * an attached device.
5783 		 */
5784 		if ((sdinfo != NULL) &&
5785 		    (sdinfo->satadrv_state & SATA_DSTATE_RESET))
5786 			SATADBG1(SATA_DBG_EVENTS, sata_hba_inst,
5787 			    "sat_hba_start: cmd 0x%2x rejected "
5788 			    "with SATA_TRAN_CMD_UNSUPPORTED status\n", cmd);
5789 
5790 		mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, cport)));
5791 		(void) sata_txlt_invalid_command(spx);
5792 		mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, cport)));
5793 
5794 		*rval = TRAN_ACCEPT;
5795 		break;
5796 
5797 	case SATA_TRAN_BUSY:
5798 		/*
5799 		 * Command rejected by HBA because other operation prevents
5800 		 * accepting the packet, or device is in RESET condition.
5801 		 */
5802 		if (sdinfo != NULL) {
5803 			sdinfo->satadrv_state =
5804 			    spx->txlt_sata_pkt->satapkt_device.satadev_state;
5805 
5806 			if (sdinfo->satadrv_state & SATA_DSTATE_RESET) {
5807 				SATADBG1(SATA_DBG_EVENTS, sata_hba_inst,
5808 				    "sata_hba_start: cmd 0x%2x rejected "
5809 				    "because of device reset condition\n",
5810 				    cmd);
5811 			} else {
5812 				SATADBG1(SATA_DBG_EVENTS, sata_hba_inst,
5813 				    "sata_hba_start: cmd 0x%2x rejected "
5814 				    "with SATA_TRAN_BUSY status\n",
5815 				    cmd);
5816 			}
5817 		}
5818 		spx->txlt_scsi_pkt->pkt_reason = CMD_INCOMPLETE;
5819 		*rval = TRAN_BUSY;
5820 		break;
5821 
5822 	default:
5823 		/* Unrecognized HBA response */
5824 		SATA_LOG_D((sata_hba_inst, CE_WARN,
5825 		    "sata_hba_start: unrecognized HBA response "
5826 		    "to cmd : 0x%2x resp 0x%x", cmd, rval));
5827 		spx->txlt_scsi_pkt->pkt_reason = CMD_TRAN_ERR;
5828 		*rval = TRAN_FATAL_ERROR;
5829 		break;
5830 	}
5831 
5832 	/*
5833 	 * If we got here, the packet was rejected.
5834 	 * Check if we need to remember reset state clearing request
5835 	 */
5836 	if (cmd_flags.sata_clear_dev_reset) {
5837 		/*
5838 		 * Check if device is still configured - it may have
5839 		 * disapeared from the configuration
5840 		 */
5841 		sdinfo = sata_get_device_info(sata_hba_inst, sata_device);
5842 		if (sdinfo != NULL) {
5843 			/*
5844 			 * Restore the flag that requests clearing of
5845 			 * the device reset state,
5846 			 * so the next sata packet may carry it to HBA.
5847 			 */
5848 			sdinfo->satadrv_event_flags |=
5849 			    SATA_EVNT_CLEAR_DEVICE_RESET;
5850 		}
5851 	}
5852 	return (-1);
5853 }
5854 
5855 /*
5856  * Scsi response setup for invalid LBA
5857  *
5858  * Returns TRAN_ACCEPT and appropriate values in scsi_pkt fields.
5859  */
5860 static int
5861 sata_txlt_lba_out_of_range(sata_pkt_txlate_t *spx)
5862 {
5863 	struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt;
5864 	struct scsi_extended_sense *sense;
5865 
5866 	scsipkt->pkt_reason = CMD_CMPLT;
5867 	scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET |
5868 		STATE_SENT_CMD | STATE_GOT_STATUS;
5869 	*scsipkt->pkt_scbp = STATUS_CHECK;
5870 
5871 	*scsipkt->pkt_scbp = STATUS_CHECK;
5872 	sense = sata_arq_sense(spx);
5873 	sense->es_key = KEY_ILLEGAL_REQUEST;
5874 	sense->es_add_code = SD_SCSI_LBA_OUT_OF_RANGE;
5875 
5876 	SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst,
5877 	    "Scsi_pkt completion reason %x\n", scsipkt->pkt_reason);
5878 
5879 	if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0 &&
5880 	    scsipkt->pkt_comp != NULL)
5881 		/* scsi callback required */
5882 		if (taskq_dispatch(SATA_TXLT_TASKQ(spx),
5883 		    (task_func_t *)scsipkt->pkt_comp, (void *) scsipkt,
5884 		    TQ_SLEEP) == NULL)
5885 			/* Scheduling the callback failed */
5886 			return (TRAN_BUSY);
5887 	return (TRAN_ACCEPT);
5888 }
5889 
5890 
5891 /*
5892  * Analyze device status and error registers and translate them into
5893  * appropriate scsi sense codes.
5894  * NOTE: non-packet commands only for now
5895  */
5896 static void
5897 sata_decode_device_error(sata_pkt_txlate_t *spx,
5898     struct scsi_extended_sense *sense)
5899 {
5900 	uint8_t err_reg = spx->txlt_sata_pkt->satapkt_cmd.satacmd_error_reg;
5901 
5902 	ASSERT(sense != NULL);
5903 	ASSERT(spx->txlt_sata_pkt->satapkt_cmd.satacmd_status_reg &
5904 	    SATA_STATUS_ERR);
5905 
5906 
5907 	if (err_reg & SATA_ERROR_ICRC) {
5908 		sense->es_key = KEY_ABORTED_COMMAND;
5909 		sense->es_add_code = 0x08; /* Communication failure */
5910 		return;
5911 	}
5912 
5913 	if (err_reg & SATA_ERROR_UNC) {
5914 		sense->es_key = KEY_MEDIUM_ERROR;
5915 		/* Information bytes (LBA) need to be set by a caller */
5916 		return;
5917 	}
5918 
5919 	/* ADD HERE: MC error bit handling for ATAPI CD/DVD */
5920 	if (err_reg & (SATA_ERROR_MCR | SATA_ERROR_NM)) {
5921 		sense->es_key = KEY_UNIT_ATTENTION;
5922 		sense->es_add_code = 0x3a; /* No media present */
5923 		return;
5924 	}
5925 
5926 	if (err_reg & SATA_ERROR_IDNF) {
5927 		if (err_reg & SATA_ERROR_ABORT) {
5928 			sense->es_key = KEY_ABORTED_COMMAND;
5929 		} else {
5930 			sense->es_key = KEY_ILLEGAL_REQUEST;
5931 			sense->es_add_code = 0x21; /* LBA out of range */
5932 		}
5933 		return;
5934 	}
5935 
5936 	if (err_reg & SATA_ERROR_ABORT) {
5937 		ASSERT(spx->txlt_sata_pkt != NULL);
5938 		sense->es_key = KEY_ABORTED_COMMAND;
5939 		return;
5940 	}
5941 }
5942 
5943 /*
5944  * Extract error LBA from sata_pkt.satapkt_cmd register fields
5945  */
5946 static void
5947 sata_extract_error_lba(sata_pkt_txlate_t *spx, uint64_t *lba)
5948 {
5949 	sata_cmd_t *sata_cmd = &spx->txlt_sata_pkt->satapkt_cmd;
5950 
5951 	*lba = 0;
5952 	if (sata_cmd->satacmd_addr_type == ATA_ADDR_LBA48) {
5953 		*lba = sata_cmd->satacmd_lba_high_msb;
5954 		*lba = (*lba << 8) | sata_cmd->satacmd_lba_mid_msb;
5955 		*lba = (*lba << 8) | sata_cmd->satacmd_lba_low_msb;
5956 	} else if (sata_cmd->satacmd_addr_type == ATA_ADDR_LBA28) {
5957 		*lba = sata_cmd->satacmd_device_reg & 0xf;
5958 	}
5959 	*lba = (*lba << 8) | sata_cmd->satacmd_lba_high_lsb;
5960 	*lba = (*lba << 8) | sata_cmd->satacmd_lba_mid_lsb;
5961 	*lba = (*lba << 8) | sata_cmd->satacmd_lba_low_lsb;
5962 }
5963 
5964 /*
5965  * This is fixed sense format - if LBA exceeds the info field size,
5966  * no valid info will be returned (valid bit in extended sense will
5967  * be set to 0).
5968  */
5969 static struct scsi_extended_sense *
5970 sata_arq_sense(sata_pkt_txlate_t *spx)
5971 {
5972 	struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt;
5973 	struct scsi_arq_status *arqs;
5974 	struct scsi_extended_sense *sense;
5975 
5976 	/* Fill ARQ sense data */
5977 	scsipkt->pkt_state |= STATE_ARQ_DONE;
5978 	arqs = (struct scsi_arq_status *)scsipkt->pkt_scbp;
5979 	*(uchar_t *)&arqs->sts_status = STATUS_CHECK;
5980 	*(uchar_t *)&arqs->sts_rqpkt_status = STATUS_GOOD;
5981 	arqs->sts_rqpkt_reason = CMD_CMPLT;
5982 	arqs->sts_rqpkt_state = STATE_GOT_BUS | STATE_GOT_TARGET |
5983 	    STATE_XFERRED_DATA | STATE_SENT_CMD | STATE_GOT_STATUS;
5984 	arqs->sts_rqpkt_resid = 0;
5985 	sense = &arqs->sts_sensedata;
5986 	bzero(sense, sizeof (struct scsi_extended_sense));
5987 	sense->es_valid = 1;		/* Valid sense */
5988 	sense->es_class = 7;		/* Response code 0x70 - current err */
5989 	sense->es_key = KEY_NO_SENSE;
5990 	sense->es_info_1 = 0;
5991 	sense->es_info_2 = 0;
5992 	sense->es_info_3 = 0;
5993 	sense->es_info_4 = 0;
5994 	sense->es_add_len = 6;		/* Additional length */
5995 	sense->es_cmd_info[0] = 0;
5996 	sense->es_cmd_info[1] = 0;
5997 	sense->es_cmd_info[2] = 0;
5998 	sense->es_cmd_info[3] = 0;
5999 	sense->es_add_code = 0;
6000 	sense->es_qual_code = 0;
6001 	return (sense);
6002 }
6003 
6004 
6005 /*
6006  * Emulated SATA Read/Write command completion for zero-length requests.
6007  * This request always succedes, so in synchronous mode it always returns
6008  * TRAN_ACCEPT, and in non-synchronous mode it may return TRAN_BUSY if the
6009  * callback cannot be scheduled.
6010  */
6011 static int
6012 sata_emul_rw_completion(sata_pkt_txlate_t *spx)
6013 {
6014 	struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt;
6015 
6016 	scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET |
6017 	    STATE_SENT_CMD | STATE_GOT_STATUS;
6018 	scsipkt->pkt_reason = CMD_CMPLT;
6019 	*scsipkt->pkt_scbp = STATUS_GOOD;
6020 	if (!(spx->txlt_sata_pkt->satapkt_op_mode & SATA_OPMODE_SYNCH)) {
6021 		/* scsi callback required - have to schedule it */
6022 		if (taskq_dispatch(SATA_TXLT_TASKQ(spx),
6023 		    (task_func_t *)scsipkt->pkt_comp,
6024 		    (void *)scsipkt, TQ_SLEEP) == NULL)
6025 			/* Scheduling the callback failed */
6026 			return (TRAN_BUSY);
6027 	}
6028 	return (TRAN_ACCEPT);
6029 }
6030 
6031 
6032 /*
6033  * Translate completion status of SATA read/write commands into scsi response.
6034  * pkt completion_reason is checked to determine the completion status.
6035  * Do scsi callback if necessary.
6036  *
6037  * Note: this function may be called also for synchronously executed
6038  * commands.
6039  * This function may be used only if scsi_pkt is non-NULL.
6040  */
6041 static void
6042 sata_txlt_rw_completion(sata_pkt_t *sata_pkt)
6043 {
6044 	sata_pkt_txlate_t *spx =
6045 	    (sata_pkt_txlate_t *)sata_pkt->satapkt_framework_private;
6046 	sata_cmd_t *scmd = &sata_pkt->satapkt_cmd;
6047 	struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt;
6048 	struct scsi_extended_sense *sense;
6049 	uint64_t lba;
6050 	struct buf *bp;
6051 	int rval;
6052 	if (sata_pkt->satapkt_reason == SATA_PKT_COMPLETED) {
6053 		/* Normal completion */
6054 		scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET |
6055 		    STATE_SENT_CMD | STATE_XFERRED_DATA | STATE_GOT_STATUS;
6056 		scsipkt->pkt_reason = CMD_CMPLT;
6057 		*scsipkt->pkt_scbp = STATUS_GOOD;
6058 		if (spx->txlt_tmp_buf != NULL) {
6059 			/* Temporary buffer was used */
6060 			bp = spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp;
6061 			if (bp->b_flags & B_READ) {
6062 				rval = ddi_dma_sync(
6063 				    spx->txlt_buf_dma_handle, 0, 0,
6064 				    DDI_DMA_SYNC_FORCPU);
6065 				ASSERT(rval == DDI_SUCCESS);
6066 				bcopy(spx->txlt_tmp_buf, bp->b_un.b_addr,
6067 				    bp->b_bcount);
6068 			}
6069 		}
6070 	} else {
6071 		/*
6072 		 * Something went wrong - analyze return
6073 		 */
6074 		scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET |
6075 		    STATE_SENT_CMD | STATE_GOT_STATUS;
6076 		scsipkt->pkt_reason = CMD_INCOMPLETE;
6077 		*scsipkt->pkt_scbp = STATUS_CHECK;
6078 		sense = sata_arq_sense(spx);
6079 		ASSERT(sense != NULL);
6080 
6081 		/*
6082 		 * SATA_PKT_DEV_ERROR is the only case where we may be able to
6083 		 * extract from device registers the failing LBA.
6084 		 */
6085 		if (sata_pkt->satapkt_reason == SATA_PKT_DEV_ERROR) {
6086 			if ((scmd->satacmd_addr_type == ATA_ADDR_LBA48) &&
6087 			    (scmd->satacmd_lba_mid_msb != 0 ||
6088 			    scmd->satacmd_lba_high_msb != 0)) {
6089 				/*
6090 				 * We have problem reporting this cmd LBA
6091 				 * in fixed sense data format, because of
6092 				 * the size of the scsi LBA fields.
6093 				 */
6094 				sense->es_valid = 0;
6095 			} else {
6096 				sata_extract_error_lba(spx, &lba);
6097 				sense->es_info_1 = (lba & 0xFF000000) >> 24;
6098 				sense->es_info_2 = (lba & 0xFF0000) >> 16;
6099 				sense->es_info_3 = (lba & 0xFF00) >> 8;
6100 				sense->es_info_4 = lba & 0xFF;
6101 			}
6102 		} else {
6103 			/* Invalid extended sense info */
6104 			sense->es_valid = 0;
6105 		}
6106 
6107 		switch (sata_pkt->satapkt_reason) {
6108 		case SATA_PKT_PORT_ERROR:
6109 			/* We may want to handle DEV GONE state as well */
6110 			/*
6111 			 * We have no device data. Assume no data transfered.
6112 			 */
6113 			sense->es_key = KEY_HARDWARE_ERROR;
6114 			break;
6115 
6116 		case SATA_PKT_DEV_ERROR:
6117 			if (sata_pkt->satapkt_cmd.satacmd_status_reg &
6118 			    SATA_STATUS_ERR) {
6119 				/*
6120 				 * determine dev error reason from error
6121 				 * reg content
6122 				 */
6123 				sata_decode_device_error(spx, sense);
6124 				if (sense->es_key == KEY_MEDIUM_ERROR) {
6125 					switch (scmd->satacmd_cmd_reg) {
6126 					case SATAC_READ_DMA:
6127 					case SATAC_READ_DMA_EXT:
6128 					case SATAC_READ_DMA_QUEUED:
6129 					case SATAC_READ_DMA_QUEUED_EXT:
6130 					case SATAC_READ_FPDMA_QUEUED:
6131 						/* Unrecovered read error */
6132 						sense->es_add_code =
6133 						    SD_SCSI_UNREC_READ_ERROR;
6134 						break;
6135 					case SATAC_WRITE_DMA:
6136 					case SATAC_WRITE_DMA_EXT:
6137 					case SATAC_WRITE_DMA_QUEUED:
6138 					case SATAC_WRITE_DMA_QUEUED_EXT:
6139 					case SATAC_WRITE_FPDMA_QUEUED:
6140 						/* Write error */
6141 						sense->es_add_code =
6142 						    SD_SCSI_WRITE_ERROR;
6143 						break;
6144 					default:
6145 						/* Internal error */
6146 						SATA_LOG_D((
6147 						    spx->txlt_sata_hba_inst,
6148 						    CE_WARN,
6149 						    "sata_txlt_rw_completion :"
6150 						    "internal error - invalid "
6151 						    "command 0x%2x",
6152 						    scmd->satacmd_cmd_reg));
6153 						break;
6154 					}
6155 				}
6156 				break;
6157 			}
6158 			/* No extended sense key - no info available */
6159 			scsipkt->pkt_reason = CMD_INCOMPLETE;
6160 			break;
6161 
6162 		case SATA_PKT_TIMEOUT:
6163 			/* scsipkt->pkt_reason = CMD_TIMEOUT; */
6164 			scsipkt->pkt_reason = CMD_INCOMPLETE;
6165 			/* No extended sense key ? */
6166 			break;
6167 
6168 		case SATA_PKT_ABORTED:
6169 			scsipkt->pkt_reason = CMD_ABORTED;
6170 			/* No extended sense key ? */
6171 			break;
6172 
6173 		case SATA_PKT_RESET:
6174 			scsipkt->pkt_reason = CMD_RESET;
6175 			break;
6176 
6177 		default:
6178 			SATA_LOG_D((spx->txlt_sata_hba_inst, CE_WARN,
6179 			    "sata_txlt_rw_completion: "
6180 			    "invalid packet completion reason"));
6181 			scsipkt->pkt_reason = CMD_TRAN_ERR;
6182 			break;
6183 		}
6184 	}
6185 	SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst,
6186 	    "Scsi_pkt completion reason %x\n", scsipkt->pkt_reason);
6187 
6188 	if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0 &&
6189 	    scsipkt->pkt_comp != NULL)
6190 		/* scsi callback required */
6191 		(*scsipkt->pkt_comp)(scsipkt);
6192 }
6193 
6194 /*
6195  * NON FUNCTIONAL IMPLEMENTATION. THIS IS A PLACE HOLDER.
6196  * ATAPI devices are not supported currently (are not be attached recognized
6197  * as valid devices).
6198  * Will be fixed in phase 2 of the development.
6199  */
6200 static void
6201 sata_txlt_atapi_completion(sata_pkt_t *sata_pkt)
6202 {
6203 	sata_pkt_txlate_t *spx =
6204 	    (sata_pkt_txlate_t *)sata_pkt->satapkt_framework_private;
6205 	struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt;
6206 	struct scsi_arq_status *arqs;
6207 
6208 	if (sata_pkt->satapkt_reason == SATA_PKT_COMPLETED) {
6209 		/* Normal completion */
6210 		scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET |
6211 		    STATE_SENT_CMD | STATE_XFERRED_DATA | STATE_GOT_STATUS;
6212 		scsipkt->pkt_reason = CMD_CMPLT;
6213 		*scsipkt->pkt_scbp = STATUS_GOOD;
6214 		scsipkt->pkt_resid = 0;
6215 	} else {
6216 		/*
6217 		 * Something went wrong - analyze return
6218 		 */
6219 		scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET |
6220 		    STATE_SENT_CMD | STATE_GOT_STATUS | STATE_ARQ_DONE;
6221 		scsipkt->pkt_reason = CMD_CMPLT;
6222 
6223 		arqs = (struct scsi_arq_status *)scsipkt->pkt_scbp;
6224 		*(uchar_t *)&arqs->sts_status = STATUS_CHECK;
6225 		*(uchar_t *)&arqs->sts_rqpkt_status = STATUS_GOOD;
6226 		arqs->sts_rqpkt_reason = CMD_CMPLT;
6227 		arqs->sts_rqpkt_state = STATE_GOT_BUS | STATE_GOT_TARGET |
6228 		    STATE_XFERRED_DATA | STATE_SENT_CMD | STATE_GOT_STATUS;
6229 		arqs->sts_rqpkt_resid = 0;
6230 
6231 		bcopy(sata_pkt->satapkt_cmd.satacmd_rqsense,
6232 		    &arqs->sts_sensedata, SATA_ATAPI_RQSENSE_LEN);
6233 	}
6234 	SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst,
6235 	    "Scsi_pkt completion reason %x\n", scsipkt->pkt_reason);
6236 
6237 	if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0 &&
6238 	    scsipkt->pkt_comp != NULL) {
6239 		/* scsi callback required */
6240 		(*scsipkt->pkt_comp)(scsipkt);
6241 	}
6242 }
6243 
6244 
6245 /*
6246  * Translate completion status of non-data commands (i.e. commands returning
6247  * no data).
6248  * pkt completion_reason is checked to determine the completion status.
6249  * Do scsi callback if necessary (FLAG_NOINTR == 0)
6250  *
6251  * Note: this function may be called also for synchronously executed
6252  * commands.
6253  * This function may be used only if scsi_pkt is non-NULL.
6254  */
6255 
6256 static 	void
6257 sata_txlt_nodata_cmd_completion(sata_pkt_t *sata_pkt)
6258 {
6259 	sata_pkt_txlate_t *spx =
6260 	    (sata_pkt_txlate_t *)sata_pkt->satapkt_framework_private;
6261 	struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt;
6262 	struct scsi_extended_sense *sense;
6263 
6264 	scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET |
6265 	    STATE_SENT_CMD | STATE_GOT_STATUS;
6266 	if (sata_pkt->satapkt_reason == SATA_PKT_COMPLETED) {
6267 		/* Normal completion */
6268 		scsipkt->pkt_reason = CMD_CMPLT;
6269 		*scsipkt->pkt_scbp = STATUS_GOOD;
6270 	} else {
6271 		/* Something went wrong */
6272 		scsipkt->pkt_reason = CMD_INCOMPLETE;
6273 		*scsipkt->pkt_scbp = STATUS_CHECK;
6274 		sense = sata_arq_sense(spx);
6275 		switch (sata_pkt->satapkt_reason) {
6276 		case SATA_PKT_PORT_ERROR:
6277 			/*
6278 			 * We have no device data. Assume no data transfered.
6279 			 */
6280 			sense->es_key = KEY_HARDWARE_ERROR;
6281 			break;
6282 
6283 		case SATA_PKT_DEV_ERROR:
6284 		    if (sata_pkt->satapkt_cmd.satacmd_status_reg &
6285 			SATA_STATUS_ERR) {
6286 			/*
6287 			 * determine dev error reason from error
6288 			 * reg content
6289 			 */
6290 			sata_decode_device_error(spx, sense);
6291 			break;
6292 		    }
6293 		    /* No extended sense key - no info available */
6294 		    break;
6295 
6296 		case SATA_PKT_TIMEOUT:
6297 			/* scsipkt->pkt_reason = CMD_TIMEOUT; */
6298 			scsipkt->pkt_reason = CMD_INCOMPLETE;
6299 			/* No extended sense key ? */
6300 			break;
6301 
6302 		case SATA_PKT_ABORTED:
6303 			scsipkt->pkt_reason = CMD_ABORTED;
6304 			/* No extended sense key ? */
6305 			break;
6306 
6307 		case SATA_PKT_RESET:
6308 			/* pkt aborted by an explicit reset from a host */
6309 			scsipkt->pkt_reason = CMD_RESET;
6310 			break;
6311 
6312 		default:
6313 			SATA_LOG_D((spx->txlt_sata_hba_inst, CE_WARN,
6314 			    "sata_txlt_nodata_cmd_completion: "
6315 			    "invalid packet completion reason %d",
6316 			    sata_pkt->satapkt_reason));
6317 			scsipkt->pkt_reason = CMD_TRAN_ERR;
6318 			break;
6319 		}
6320 
6321 	}
6322 	SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst,
6323 	    "Scsi_pkt completion reason %x\n", scsipkt->pkt_reason);
6324 
6325 	if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0 &&
6326 	    scsipkt->pkt_comp != NULL)
6327 		/* scsi callback required */
6328 		(*scsipkt->pkt_comp)(scsipkt);
6329 }
6330 
6331 
6332 /*
6333  * Build Mode sense R/W recovery page
6334  * NOT IMPLEMENTED
6335  */
6336 
6337 static int
6338 sata_build_msense_page_1(sata_drive_info_t *sdinfo, int pcntrl, uint8_t *buf)
6339 {
6340 #ifndef __lock_lint
6341 	_NOTE(ARGUNUSED(sdinfo))
6342 	_NOTE(ARGUNUSED(pcntrl))
6343 	_NOTE(ARGUNUSED(buf))
6344 #endif
6345 	return (0);
6346 }
6347 
6348 /*
6349  * Build Mode sense caching page  -  scsi-3 implementation.
6350  * Page length distinguishes previous format from scsi-3 format.
6351  * buf must have space for 0x12 bytes.
6352  * Only DRA (disable read ahead ) and WCE (write cache enable) are changeable.
6353  *
6354  */
6355 static int
6356 sata_build_msense_page_8(sata_drive_info_t *sdinfo, int pcntrl, uint8_t *buf)
6357 {
6358 	struct mode_cache_scsi3 *page = (struct mode_cache_scsi3 *)buf;
6359 	sata_id_t *sata_id = &sdinfo->satadrv_id;
6360 
6361 	/*
6362 	 * Most of the fields are set to 0, being not supported and/or disabled
6363 	 */
6364 	bzero(buf, PAGELENGTH_DAD_MODE_CACHE_SCSI3);
6365 
6366 	/* Saved paramters not supported */
6367 	if (pcntrl == 3)
6368 		return (0);
6369 	if (pcntrl == 0 || pcntrl == 2) {
6370 		/*
6371 		 * For now treat current and default parameters as same
6372 		 * That may have to change, if target driver will complain
6373 		 */
6374 		page->mode_page.code = MODEPAGE_CACHING;	/* PS = 0 */
6375 		page->mode_page.length = PAGELENGTH_DAD_MODE_CACHE_SCSI3;
6376 
6377 		if ((sata_id->ai_cmdset82 & SATA_LOOK_AHEAD) &&
6378 		    !(sata_id->ai_features85 & SATA_LOOK_AHEAD)) {
6379 			page->dra = 1;		/* Read Ahead disabled */
6380 			page->rcd = 1;		/* Read Cache disabled */
6381 		}
6382 		if ((sata_id->ai_cmdset82 & SATA_WRITE_CACHE) &&
6383 		    (sata_id->ai_features85 & SATA_WRITE_CACHE))
6384 			page->wce = 1;		/* Write Cache enabled */
6385 	} else {
6386 		/* Changeable parameters */
6387 		page->mode_page.code = MODEPAGE_CACHING;
6388 		page->mode_page.length = PAGELENGTH_DAD_MODE_CACHE_SCSI3;
6389 		if (sata_id->ai_cmdset82 & SATA_LOOK_AHEAD) {
6390 			page->dra = 1;
6391 			page->rcd = 1;
6392 		}
6393 		if (sata_id->ai_cmdset82 & SATA_WRITE_CACHE)
6394 			page->wce = 1;
6395 	}
6396 	return (PAGELENGTH_DAD_MODE_CACHE_SCSI3 +
6397 		sizeof (struct mode_page));
6398 }
6399 
6400 /*
6401  * Build Mode sense exception cntrl page
6402  */
6403 static int
6404 sata_build_msense_page_1c(sata_drive_info_t *sdinfo, int pcntrl, uint8_t *buf)
6405 {
6406 	struct mode_info_excpt_page *page = (struct mode_info_excpt_page *)buf;
6407 	sata_id_t *sata_id = &sdinfo->satadrv_id;
6408 
6409 	/*
6410 	 * Most of the fields are set to 0, being not supported and/or disabled
6411 	 */
6412 	bzero(buf, PAGELENGTH_INFO_EXCPT);
6413 
6414 	page->mode_page.code = MODEPAGE_INFO_EXCPT;
6415 	page->mode_page.length = PAGELENGTH_INFO_EXCPT;
6416 
6417 	/* Indicate that this is page is saveable */
6418 	page->mode_page.ps = 1;
6419 
6420 	/*
6421 	 * We will return the same data for default, current and saved page.
6422 	 * The only changeable bit is dexcpt and that bit is required
6423 	 * by the ATA specification to be preserved across power cycles.
6424 	 */
6425 	if (pcntrl != 1) {
6426 		page->dexcpt = !(sata_id->ai_features85 & SATA_SMART_SUPPORTED);
6427 		page->mrie = MRIE_ONLY_ON_REQUEST;
6428 	}
6429 	else
6430 		page->dexcpt = 1;	/* Only changeable parameter */
6431 
6432 	return (PAGELENGTH_INFO_EXCPT + sizeof (struct mode_info_excpt_page));
6433 }
6434 
6435 
6436 /*
6437  * Build Mode sense power condition page
6438  * NOT IMPLEMENTED.
6439  */
6440 static int
6441 sata_build_msense_page_1a(sata_drive_info_t *sdinfo, int pcntrl, uint8_t *buf)
6442 {
6443 #ifndef __lock_lint
6444 	_NOTE(ARGUNUSED(sdinfo))
6445 	_NOTE(ARGUNUSED(pcntrl))
6446 	_NOTE(ARGUNUSED(buf))
6447 #endif
6448 	return (0);
6449 }
6450 
6451 
6452 /*
6453  * Process mode select caching page 8 (scsi3 format only).
6454  * Read Ahead (same as read cache) and Write Cache may be turned on and off
6455  * if these features are supported by the device. If these features are not
6456  * supported, quietly ignore them.
6457  * This function fails only if the SET FEATURE command sent to
6458  * the device fails. The page format is not varified, assuming that the
6459  * target driver operates correctly - if parameters length is too short,
6460  * we just drop the page.
6461  * Two command may be sent if both Read Cache/Read Ahead and Write Cache
6462  * setting have to be changed.
6463  * SET FEATURE command is executed synchronously, i.e. we wait here until
6464  * it is completed, regardless of the scsi pkt directives.
6465  *
6466  * Note: Mode Select Caching page RCD and DRA bits are tied together, i.e.
6467  * changing DRA will change RCD.
6468  *
6469  * More than one SATA command may be executed to perform operations specified
6470  * by mode select pages. The first error terminates further execution.
6471  * Operations performed successully are not backed-up in such case.
6472  *
6473  * Return SATA_SUCCESS if operation succeeded, SATA_FAILURE otherwise.
6474  * If operation resulted in changing device setup, dmod flag should be set to
6475  * one (1). If parameters were not changed, dmod flag should be set to 0.
6476  * Upon return, if operation required sending command to the device, the rval
6477  * should be set to the value returned by sata_hba_start. If operation
6478  * did not require device access, rval should be set to TRAN_ACCEPT.
6479  * The pagelen should be set to the length of the page.
6480  *
6481  * This function has to be called with a port mutex held.
6482  *
6483  * Returns SATA_SUCCESS if operation was successful, SATA_FAILURE otherwise.
6484  */
6485 int
6486 sata_mode_select_page_8(sata_pkt_txlate_t *spx, struct mode_cache_scsi3 *page,
6487     int parmlen, int *pagelen, int *rval, int *dmod)
6488 {
6489 	struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt;
6490 	sata_drive_info_t *sdinfo;
6491 	sata_cmd_t *scmd = &spx->txlt_sata_pkt->satapkt_cmd;
6492 	sata_id_t *sata_id;
6493 	struct scsi_extended_sense *sense;
6494 	int wce, dra;	/* Current settings */
6495 
6496 	sdinfo = sata_get_device_info(spx->txlt_sata_hba_inst,
6497 	    &spx->txlt_sata_pkt->satapkt_device);
6498 	sata_id = &sdinfo->satadrv_id;
6499 	*dmod = 0;
6500 
6501 	/* Verify parameters length. If too short, drop it */
6502 	if (PAGELENGTH_DAD_MODE_CACHE_SCSI3 +
6503 	    sizeof (struct mode_page) < parmlen) {
6504 		*scsipkt->pkt_scbp = STATUS_CHECK;
6505 		sense = sata_arq_sense(spx);
6506 		sense->es_key = KEY_ILLEGAL_REQUEST;
6507 		sense->es_add_code = SD_SCSI_INVALID_FIELD_IN_PARAMETER_LIST;
6508 		*pagelen = parmlen;
6509 		*rval = TRAN_ACCEPT;
6510 		return (SATA_FAILURE);
6511 	}
6512 
6513 	*pagelen = PAGELENGTH_DAD_MODE_CACHE_SCSI3 + sizeof (struct mode_page);
6514 
6515 	/*
6516 	 * We can manipulate only write cache and read ahead
6517 	 * (read cache) setting.
6518 	 */
6519 	if (!(sata_id->ai_cmdset82 & SATA_LOOK_AHEAD) &&
6520 	    !(sata_id->ai_cmdset82 & SATA_WRITE_CACHE)) {
6521 		/*
6522 		 * None of the features is supported - ignore
6523 		 */
6524 		*rval = TRAN_ACCEPT;
6525 		return (SATA_SUCCESS);
6526 	}
6527 
6528 	/* Current setting of Read Ahead (and Read Cache) */
6529 	if (sata_id->ai_features85 & SATA_LOOK_AHEAD)
6530 		dra = 0;	/* 0 == not disabled */
6531 	else
6532 		dra = 1;
6533 	/* Current setting of Write Cache */
6534 	if (sata_id->ai_features85 & SATA_WRITE_CACHE)
6535 		wce = 1;
6536 	else
6537 		wce = 0;
6538 
6539 	if (page->dra == dra && page->wce == wce && page->rcd == dra) {
6540 		/* nothing to do */
6541 		*rval = TRAN_ACCEPT;
6542 		return (SATA_SUCCESS);
6543 	}
6544 	/*
6545 	 * Need to flip some setting
6546 	 * Set-up Internal SET FEATURES command(s)
6547 	 */
6548 	scmd->satacmd_flags.sata_data_direction = SATA_DIR_NODATA_XFER;
6549 	scmd->satacmd_addr_type = 0;
6550 	scmd->satacmd_device_reg = 0;
6551 	scmd->satacmd_status_reg = 0;
6552 	scmd->satacmd_error_reg = 0;
6553 	scmd->satacmd_cmd_reg = SATAC_SET_FEATURES;
6554 	if (page->dra != dra || page->rcd != dra) {
6555 		/* Need to flip read ahead setting */
6556 		if (dra == 0)
6557 			/* Disable read ahead / read cache */
6558 			scmd->satacmd_features_reg =
6559 			    SATAC_SF_DISABLE_READ_AHEAD;
6560 		else
6561 			/* Enable read ahead  / read cache */
6562 			scmd->satacmd_features_reg =
6563 			    SATAC_SF_ENABLE_READ_AHEAD;
6564 
6565 		/* Transfer command to HBA */
6566 		if (sata_hba_start(spx, rval) != 0)
6567 			/*
6568 			 * Pkt not accepted for execution.
6569 			 */
6570 			return (SATA_FAILURE);
6571 
6572 		*dmod = 1;
6573 
6574 		/* Now process return */
6575 		if (spx->txlt_sata_pkt->satapkt_reason !=
6576 		    SATA_PKT_COMPLETED) {
6577 			goto failure;	/* Terminate */
6578 		}
6579 	}
6580 
6581 	/* Note that the packet is not removed, so it could be re-used */
6582 	if (page->wce != wce) {
6583 		/* Need to flip Write Cache setting */
6584 		if (page->wce == 1)
6585 			/* Enable write cache */
6586 			scmd->satacmd_features_reg =
6587 			    SATAC_SF_ENABLE_WRITE_CACHE;
6588 		else
6589 			/* Disable write cache */
6590 			scmd->satacmd_features_reg =
6591 			    SATAC_SF_DISABLE_WRITE_CACHE;
6592 
6593 		/* Transfer command to HBA */
6594 		if (sata_hba_start(spx, rval) != 0)
6595 			/*
6596 			 * Pkt not accepted for execution.
6597 			 */
6598 			return (SATA_FAILURE);
6599 
6600 		*dmod = 1;
6601 
6602 		/* Now process return */
6603 		if (spx->txlt_sata_pkt->satapkt_reason !=
6604 		    SATA_PKT_COMPLETED) {
6605 			goto failure;
6606 		}
6607 	}
6608 	return (SATA_SUCCESS);
6609 
6610 failure:
6611 	sata_xlate_errors(spx);
6612 
6613 	return (SATA_FAILURE);
6614 }
6615 
6616 /*
6617  * Process mode select informational exceptions control page 0x1c
6618  *
6619  * The only changeable bit is dexcpt (disable exceptions).
6620  * MRIE (method of reporting informational exceptions) must be
6621  * "only on request".
6622  *
6623  * Return SATA_SUCCESS if operation succeeded, SATA_FAILURE otherwise.
6624  * If operation resulted in changing device setup, dmod flag should be set to
6625  * one (1). If parameters were not changed, dmod flag should be set to 0.
6626  * Upon return, if operation required sending command to the device, the rval
6627  * should be set to the value returned by sata_hba_start. If operation
6628  * did not require device access, rval should be set to TRAN_ACCEPT.
6629  * The pagelen should be set to the length of the page.
6630  *
6631  * This function has to be called with a port mutex held.
6632  *
6633  * Returns SATA_SUCCESS if operation was successful, SATA_FAILURE otherwise.
6634  */
6635 static	int
6636 sata_mode_select_page_1c(
6637 	sata_pkt_txlate_t *spx,
6638 	struct mode_info_excpt_page *page,
6639 	int parmlen,
6640 	int *pagelen,
6641 	int *rval,
6642 	int *dmod)
6643 {
6644 	struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt;
6645 	sata_cmd_t *scmd = &spx->txlt_sata_pkt->satapkt_cmd;
6646 	sata_drive_info_t *sdinfo;
6647 	sata_id_t *sata_id;
6648 	struct scsi_extended_sense *sense;
6649 
6650 	sdinfo = sata_get_device_info(spx->txlt_sata_hba_inst,
6651 	    &spx->txlt_sata_pkt->satapkt_device);
6652 	sata_id = &sdinfo->satadrv_id;
6653 
6654 	*dmod = 0;
6655 
6656 	/* Verify parameters length. If too short, drop it */
6657 	if (((PAGELENGTH_INFO_EXCPT + sizeof (struct mode_page)) < parmlen) ||
6658 	    page->perf || page->test || (page->mrie != MRIE_ONLY_ON_REQUEST)) {
6659 		*scsipkt->pkt_scbp = STATUS_CHECK;
6660 		sense = sata_arq_sense(spx);
6661 		sense->es_key = KEY_ILLEGAL_REQUEST;
6662 		sense->es_add_code = SD_SCSI_INVALID_FIELD_IN_PARAMETER_LIST;
6663 		*pagelen = parmlen;
6664 		*rval = TRAN_ACCEPT;
6665 		return (SATA_FAILURE);
6666 	}
6667 
6668 	*pagelen = PAGELENGTH_INFO_EXCPT + sizeof (struct mode_page);
6669 
6670 	if (! (sata_id->ai_cmdset82 & SATA_SMART_SUPPORTED)) {
6671 		*scsipkt->pkt_scbp = STATUS_CHECK;
6672 		sense = sata_arq_sense(spx);
6673 		sense->es_key = KEY_ILLEGAL_REQUEST;
6674 		sense->es_add_code = SD_SCSI_INVALID_FIELD_IN_CDB;
6675 		*pagelen = parmlen;
6676 		*rval = TRAN_ACCEPT;
6677 		return (SATA_FAILURE);
6678 	}
6679 
6680 	/* If already in the state requested, we are done */
6681 	if (page->dexcpt == ! (sata_id->ai_features85 & SATA_SMART_ENABLED)) {
6682 		/* nothing to do */
6683 		*rval = TRAN_ACCEPT;
6684 		return (SATA_SUCCESS);
6685 	}
6686 
6687 	scmd->satacmd_flags.sata_data_direction = SATA_DIR_NODATA_XFER;
6688 
6689 	/* Build SMART_ENABLE or SMART_DISABLE command */
6690 	scmd->satacmd_addr_type = 0;		/* N/A */
6691 	scmd->satacmd_lba_mid_lsb = SMART_MAGIC_VAL_1;
6692 	scmd->satacmd_lba_high_lsb = SMART_MAGIC_VAL_2;
6693 	scmd->satacmd_features_reg = page->dexcpt ?
6694 	    SATA_SMART_DISABLE_OPS : SATA_SMART_ENABLE_OPS;
6695 	scmd->satacmd_device_reg = 0;		/* Always device 0 */
6696 	scmd->satacmd_cmd_reg = SATAC_SMART;
6697 
6698 	/* Transfer command to HBA */
6699 	if (sata_hba_start(spx, rval) != 0)
6700 		/*
6701 		 * Pkt not accepted for execution.
6702 		 */
6703 		return (SATA_FAILURE);
6704 
6705 	*dmod = 1;	/* At least may have been modified */
6706 
6707 	/* Now process return */
6708 	if (spx->txlt_sata_pkt->satapkt_reason == SATA_PKT_COMPLETED)
6709 		return (SATA_SUCCESS);
6710 
6711 	/* Packet did not complete successfully */
6712 	sata_xlate_errors(spx);
6713 
6714 	return (SATA_FAILURE);
6715 }
6716 
6717 /*
6718  * sata_build_lsense_page0() is used to create the
6719  * SCSI LOG SENSE page 0 (supported log pages)
6720  *
6721  * Currently supported pages are 0, 0x10, 0x2f and 0x30
6722  * (supported log pages, self-test results, informational exceptions
6723  *  and Sun vendor specific ATA SMART data).
6724  *
6725  * Takes a sata_drive_info t * and the address of a buffer
6726  * in which to create the page information.
6727  *
6728  * Returns the number of bytes valid in the buffer.
6729  */
6730 static	int
6731 sata_build_lsense_page_0(sata_drive_info_t *sdinfo, uint8_t *buf)
6732 {
6733 	struct log_parameter *lpp = (struct log_parameter *)buf;
6734 	uint8_t *page_ptr = (uint8_t *)lpp->param_values;
6735 	int num_pages_supported = 1; /* Always have GET_SUPPORTED_LOG_PAGES */
6736 	sata_id_t *sata_id = &sdinfo->satadrv_id;
6737 
6738 	lpp->param_code[0] = 0;
6739 	lpp->param_code[1] = 0;
6740 	lpp->param_ctrl_flags = LOG_CTRL_LP | LOG_CTRL_LBIN;
6741 	*page_ptr++ = PAGE_CODE_GET_SUPPORTED_LOG_PAGES;
6742 
6743 	if (sata_id->ai_cmdset82 & SATA_SMART_SUPPORTED) {
6744 		if (sata_id->ai_cmdset84 & SATA_SMART_SELF_TEST_SUPPORTED) {
6745 			*page_ptr++ = PAGE_CODE_SELF_TEST_RESULTS;
6746 			++num_pages_supported;
6747 		}
6748 		*page_ptr++ = PAGE_CODE_INFORMATION_EXCEPTIONS;
6749 		++num_pages_supported;
6750 		*page_ptr++ = PAGE_CODE_SMART_READ_DATA;
6751 		++num_pages_supported;
6752 	}
6753 
6754 	lpp->param_len = num_pages_supported;
6755 
6756 	return ((&lpp->param_values[0] - (uint8_t *)lpp) +
6757 	    num_pages_supported);
6758 }
6759 
6760 /*
6761  * sata_build_lsense_page_10() is used to create the
6762  * SCSI LOG SENSE page 0x10 (self-test results)
6763  *
6764  * Takes a sata_drive_info t * and the address of a buffer
6765  * in which to create the page information as well as a sata_hba_inst_t *.
6766  *
6767  * Returns the number of bytes valid in the buffer.
6768  */
6769 static	int
6770 sata_build_lsense_page_10(
6771 	sata_drive_info_t *sdinfo,
6772 	uint8_t *buf,
6773 	sata_hba_inst_t *sata_hba_inst)
6774 {
6775 	struct log_parameter *lpp = (struct log_parameter *)buf;
6776 	int rval;
6777 
6778 	if (sdinfo->satadrv_features_support & SATA_DEV_F_LBA48) {
6779 		struct smart_ext_selftest_log *ext_selftest_log;
6780 
6781 		ext_selftest_log = kmem_zalloc(
6782 		    sizeof (struct smart_ext_selftest_log), KM_SLEEP);
6783 
6784 		rval = sata_ext_smart_selftest_read_log(sata_hba_inst, sdinfo,
6785 		    ext_selftest_log, 0);
6786 		if (rval == 0) {
6787 			int index, start_index;
6788 			struct smart_ext_selftest_log_entry *entry;
6789 			static const struct smart_ext_selftest_log_entry empty =
6790 			    {0};
6791 			uint16_t block_num;
6792 			int count;
6793 			boolean_t only_one_block = B_FALSE;
6794 
6795 			index = ext_selftest_log->
6796 			    smart_ext_selftest_log_index[0];
6797 			index |= ext_selftest_log->
6798 			    smart_ext_selftest_log_index[1] << 8;
6799 			if (index == 0)
6800 				goto out;
6801 
6802 			--index;	/* Correct for 0 origin */
6803 			start_index = index;	/* remember where we started */
6804 			block_num = index / ENTRIES_PER_EXT_SELFTEST_LOG_BLK;
6805 			if (block_num != 0) {
6806 				rval = sata_ext_smart_selftest_read_log(
6807 				    sata_hba_inst, sdinfo, ext_selftest_log,
6808 				    block_num);
6809 				if (rval != 0)
6810 					goto out;
6811 			}
6812 			index %= ENTRIES_PER_EXT_SELFTEST_LOG_BLK;
6813 			entry =
6814 			    &ext_selftest_log->
6815 			    smart_ext_selftest_log_entries[index];
6816 
6817 			for (count = 1;
6818 			    count <= SCSI_ENTRIES_IN_LOG_SENSE_SELFTEST_RESULTS;
6819 			    ++count) {
6820 				uint8_t status;
6821 				uint8_t code;
6822 				uint8_t sense_key;
6823 				uint8_t add_sense_code;
6824 				uint8_t add_sense_code_qual;
6825 
6826 				/* If this is an unused entry, we are done */
6827 				if (bcmp(entry, &empty, sizeof (empty)) == 0) {
6828 					/* Broken firmware on some disks */
6829 					if (index + 1 ==
6830 					    ENTRIES_PER_EXT_SELFTEST_LOG_BLK) {
6831 						--entry;
6832 						--index;
6833 						if (bcmp(entry, &empty,
6834 						    sizeof (empty)) == 0)
6835 							goto out;
6836 					} else
6837 						goto out;
6838 				}
6839 
6840 				if (only_one_block &&
6841 				    start_index == index)
6842 					goto out;
6843 
6844 				lpp->param_code[0] = 0;
6845 				lpp->param_code[1] = count;
6846 				lpp->param_ctrl_flags =
6847 				    LOG_CTRL_LP | LOG_CTRL_LBIN;
6848 				lpp->param_len =
6849 				    SCSI_LOG_SENSE_SELFTEST_PARAM_LEN;
6850 
6851 				status = entry->smart_ext_selftest_log_status;
6852 				status >>= 4;
6853 				switch (status) {
6854 				case 0:
6855 				default:
6856 					sense_key = KEY_NO_SENSE;
6857 					add_sense_code = SD_SCSI_NO_ADD_SENSE;
6858 					add_sense_code_qual = 0;
6859 					break;
6860 				case 1:
6861 					sense_key = KEY_ABORTED_COMMAND;
6862 					add_sense_code =
6863 					    DIAGNOSTIC_FAILURE_ON_COMPONENT;
6864 					add_sense_code_qual = SCSI_COMPONENT_81;
6865 					break;
6866 				case 2:
6867 					sense_key = KEY_ABORTED_COMMAND;
6868 					add_sense_code =
6869 					    DIAGNOSTIC_FAILURE_ON_COMPONENT;
6870 					add_sense_code_qual = SCSI_COMPONENT_82;
6871 					break;
6872 				case 3:
6873 					sense_key = KEY_ABORTED_COMMAND;
6874 					add_sense_code =
6875 					    DIAGNOSTIC_FAILURE_ON_COMPONENT;
6876 					add_sense_code_qual = SCSI_COMPONENT_83;
6877 					break;
6878 				case 4:
6879 					sense_key = KEY_HARDWARE_ERROR;
6880 					add_sense_code =
6881 					    DIAGNOSTIC_FAILURE_ON_COMPONENT;
6882 					add_sense_code_qual = SCSI_COMPONENT_84;
6883 					break;
6884 				case 5:
6885 					sense_key = KEY_HARDWARE_ERROR;
6886 					add_sense_code =
6887 					    DIAGNOSTIC_FAILURE_ON_COMPONENT;
6888 					add_sense_code_qual = SCSI_COMPONENT_85;
6889 					break;
6890 				case 6:
6891 					sense_key = KEY_HARDWARE_ERROR;
6892 					add_sense_code =
6893 					    DIAGNOSTIC_FAILURE_ON_COMPONENT;
6894 					add_sense_code_qual = SCSI_COMPONENT_86;
6895 					break;
6896 				case 7:
6897 					sense_key = KEY_MEDIUM_ERROR;
6898 					add_sense_code =
6899 					    DIAGNOSTIC_FAILURE_ON_COMPONENT;
6900 					add_sense_code_qual = SCSI_COMPONENT_87;
6901 					break;
6902 				case 8:
6903 					sense_key = KEY_HARDWARE_ERROR;
6904 					add_sense_code =
6905 					    DIAGNOSTIC_FAILURE_ON_COMPONENT;
6906 					add_sense_code_qual = SCSI_COMPONENT_88;
6907 					break;
6908 				}
6909 				code = 0;	/* unspecified */
6910 				status |= (code << 4);
6911 				lpp->param_values[0] = status;
6912 				lpp->param_values[1] = 0; /* unspecified */
6913 				lpp->param_values[2] = entry->
6914 				    smart_ext_selftest_log_timestamp[1];
6915 				lpp->param_values[3] = entry->
6916 				    smart_ext_selftest_log_timestamp[0];
6917 				if (status != 0) {
6918 					lpp->param_values[4] = 0;
6919 					lpp->param_values[5] = 0;
6920 					lpp->param_values[6] = entry->
6921 					    smart_ext_selftest_log_failing_lba
6922 					    [5];
6923 					lpp->param_values[7] = entry->
6924 					    smart_ext_selftest_log_failing_lba
6925 					    [4];
6926 					lpp->param_values[8] = entry->
6927 					    smart_ext_selftest_log_failing_lba
6928 					    [3];
6929 					lpp->param_values[9] = entry->
6930 					    smart_ext_selftest_log_failing_lba
6931 					    [2];
6932 					lpp->param_values[10] = entry->
6933 					    smart_ext_selftest_log_failing_lba
6934 					    [1];
6935 					lpp->param_values[11] = entry->
6936 					    smart_ext_selftest_log_failing_lba
6937 					    [0];
6938 				} else {	/* No bad block address */
6939 					lpp->param_values[4] = 0xff;
6940 					lpp->param_values[5] = 0xff;
6941 					lpp->param_values[6] = 0xff;
6942 					lpp->param_values[7] = 0xff;
6943 					lpp->param_values[8] = 0xff;
6944 					lpp->param_values[9] = 0xff;
6945 					lpp->param_values[10] = 0xff;
6946 					lpp->param_values[11] = 0xff;
6947 				}
6948 
6949 				lpp->param_values[12] = sense_key;
6950 				lpp->param_values[13] = add_sense_code;
6951 				lpp->param_values[14] = add_sense_code_qual;
6952 				lpp->param_values[15] = 0; /* undefined */
6953 
6954 				lpp = (struct log_parameter *)
6955 				    (((uint8_t *)lpp) +
6956 				    SCSI_LOG_PARAM_HDR_LEN +
6957 				    SCSI_LOG_SENSE_SELFTEST_PARAM_LEN);
6958 
6959 				--index;	/* Back up to previous entry */
6960 				if (index < 0) {
6961 					if (block_num > 0) {
6962 						--block_num;
6963 					} else {
6964 						struct read_log_ext_directory
6965 						    logdir;
6966 
6967 						rval =
6968 						    sata_read_log_ext_directory(
6969 						    sata_hba_inst, sdinfo,
6970 						    &logdir);
6971 						if (rval == -1)
6972 							goto out;
6973 						if ((logdir.read_log_ext_vers
6974 						    [0] == 0) &&
6975 						    (logdir.read_log_ext_vers
6976 						    [1] == 0))
6977 							goto out;
6978 						block_num =
6979 						    logdir.read_log_ext_nblks
6980 						    [EXT_SMART_SELFTEST_LOG_PAGE
6981 						    - 1][0];
6982 						block_num |= logdir.
6983 						    read_log_ext_nblks
6984 						    [EXT_SMART_SELFTEST_LOG_PAGE
6985 						    - 1][1] << 8;
6986 						--block_num;
6987 						only_one_block =
6988 						    (block_num == 0);
6989 					}
6990 					rval = sata_ext_smart_selftest_read_log(
6991 					    sata_hba_inst, sdinfo,
6992 					    ext_selftest_log, block_num);
6993 					if (rval != 0)
6994 						goto out;
6995 
6996 					index =
6997 					    ENTRIES_PER_EXT_SELFTEST_LOG_BLK -
6998 					    1;
6999 				}
7000 				index %= ENTRIES_PER_EXT_SELFTEST_LOG_BLK;
7001 				entry = &ext_selftest_log->
7002 				    smart_ext_selftest_log_entries[index];
7003 			}
7004 		}
7005 out:
7006 		kmem_free(ext_selftest_log,
7007 		    sizeof (struct smart_ext_selftest_log));
7008 	} else {
7009 		struct smart_selftest_log *selftest_log;
7010 
7011 		selftest_log = kmem_zalloc(sizeof (struct smart_selftest_log),
7012 		    KM_SLEEP);
7013 
7014 		rval = sata_smart_selftest_log(sata_hba_inst, sdinfo,
7015 		    selftest_log);
7016 
7017 		if (rval == 0) {
7018 			int index;
7019 			int count;
7020 			struct smart_selftest_log_entry *entry;
7021 			static const struct smart_selftest_log_entry empty =
7022 			    { 0 };
7023 
7024 			index = selftest_log->smart_selftest_log_index;
7025 			if (index == 0)
7026 				goto done;
7027 			--index;	/* Correct for 0 origin */
7028 			entry = &selftest_log->
7029 			    smart_selftest_log_entries[index];
7030 			for (count = 1;
7031 			    count <= SCSI_ENTRIES_IN_LOG_SENSE_SELFTEST_RESULTS;
7032 			    ++count) {
7033 				uint8_t status;
7034 				uint8_t code;
7035 				uint8_t sense_key;
7036 				uint8_t add_sense_code;
7037 				uint8_t add_sense_code_qual;
7038 
7039 				if (bcmp(entry, &empty, sizeof (empty)) == 0)
7040 					goto done;
7041 
7042 				lpp->param_code[0] = 0;
7043 				lpp->param_code[1] = count;
7044 				lpp->param_ctrl_flags =
7045 				    LOG_CTRL_LP | LOG_CTRL_LBIN;
7046 				lpp->param_len =
7047 				    SCSI_LOG_SENSE_SELFTEST_PARAM_LEN;
7048 
7049 				status = entry->smart_selftest_log_status;
7050 				status >>= 4;
7051 				switch (status) {
7052 				case 0:
7053 				default:
7054 					sense_key = KEY_NO_SENSE;
7055 					add_sense_code = SD_SCSI_NO_ADD_SENSE;
7056 					break;
7057 				case 1:
7058 					sense_key = KEY_ABORTED_COMMAND;
7059 					add_sense_code =
7060 					    DIAGNOSTIC_FAILURE_ON_COMPONENT;
7061 					add_sense_code_qual = SCSI_COMPONENT_81;
7062 					break;
7063 				case 2:
7064 					sense_key = KEY_ABORTED_COMMAND;
7065 					add_sense_code =
7066 					    DIAGNOSTIC_FAILURE_ON_COMPONENT;
7067 					add_sense_code_qual = SCSI_COMPONENT_82;
7068 					break;
7069 				case 3:
7070 					sense_key = KEY_ABORTED_COMMAND;
7071 					add_sense_code =
7072 					    DIAGNOSTIC_FAILURE_ON_COMPONENT;
7073 					add_sense_code_qual = SCSI_COMPONENT_83;
7074 					break;
7075 				case 4:
7076 					sense_key = KEY_HARDWARE_ERROR;
7077 					add_sense_code =
7078 					    DIAGNOSTIC_FAILURE_ON_COMPONENT;
7079 					add_sense_code_qual = SCSI_COMPONENT_84;
7080 					break;
7081 				case 5:
7082 					sense_key = KEY_HARDWARE_ERROR;
7083 					add_sense_code =
7084 					    DIAGNOSTIC_FAILURE_ON_COMPONENT;
7085 					add_sense_code_qual = SCSI_COMPONENT_85;
7086 					break;
7087 				case 6:
7088 					sense_key = KEY_HARDWARE_ERROR;
7089 					add_sense_code =
7090 					    DIAGNOSTIC_FAILURE_ON_COMPONENT;
7091 					add_sense_code_qual = SCSI_COMPONENT_86;
7092 					break;
7093 				case 7:
7094 					sense_key = KEY_MEDIUM_ERROR;
7095 					add_sense_code =
7096 					    DIAGNOSTIC_FAILURE_ON_COMPONENT;
7097 					add_sense_code_qual = SCSI_COMPONENT_87;
7098 					break;
7099 				case 8:
7100 					sense_key = KEY_HARDWARE_ERROR;
7101 					add_sense_code =
7102 					    DIAGNOSTIC_FAILURE_ON_COMPONENT;
7103 					add_sense_code_qual = SCSI_COMPONENT_88;
7104 					break;
7105 				}
7106 				code = 0;	/* unspecified */
7107 				status |= (code << 4);
7108 				lpp->param_values[0] = status;
7109 				lpp->param_values[1] = 0; /* unspecified */
7110 				lpp->param_values[2] = entry->
7111 				    smart_selftest_log_timestamp[1];
7112 				lpp->param_values[3] = entry->
7113 				    smart_selftest_log_timestamp[0];
7114 				if (status != 0) {
7115 					lpp->param_values[4] = 0;
7116 					lpp->param_values[5] = 0;
7117 					lpp->param_values[6] = 0;
7118 					lpp->param_values[7] = 0;
7119 					lpp->param_values[8] = entry->
7120 					    smart_selftest_log_failing_lba[3];
7121 					lpp->param_values[9] = entry->
7122 					    smart_selftest_log_failing_lba[2];
7123 					lpp->param_values[10] = entry->
7124 					    smart_selftest_log_failing_lba[1];
7125 					lpp->param_values[11] = entry->
7126 					    smart_selftest_log_failing_lba[0];
7127 				} else {	/* No block address */
7128 					lpp->param_values[4] = 0xff;
7129 					lpp->param_values[5] = 0xff;
7130 					lpp->param_values[6] = 0xff;
7131 					lpp->param_values[7] = 0xff;
7132 					lpp->param_values[8] = 0xff;
7133 					lpp->param_values[9] = 0xff;
7134 					lpp->param_values[10] = 0xff;
7135 					lpp->param_values[11] = 0xff;
7136 				}
7137 				lpp->param_values[12] = sense_key;
7138 				lpp->param_values[13] = add_sense_code;
7139 				lpp->param_values[14] = add_sense_code_qual;
7140 				lpp->param_values[15] = 0; /* undefined */
7141 
7142 				lpp = (struct log_parameter *)
7143 				    (((uint8_t *)lpp) +
7144 				    SCSI_LOG_PARAM_HDR_LEN +
7145 				    SCSI_LOG_SENSE_SELFTEST_PARAM_LEN);
7146 				--index;	/* back up to previous entry */
7147 				if (index < 0) {
7148 					index =
7149 					    NUM_SMART_SELFTEST_LOG_ENTRIES - 1;
7150 				}
7151 				entry = &selftest_log->
7152 					smart_selftest_log_entries[index];
7153 			}
7154 		}
7155 done:
7156 		kmem_free(selftest_log, sizeof (struct smart_selftest_log));
7157 	}
7158 
7159 	return ((SCSI_LOG_PARAM_HDR_LEN + SCSI_LOG_SENSE_SELFTEST_PARAM_LEN) *
7160 	    SCSI_ENTRIES_IN_LOG_SENSE_SELFTEST_RESULTS);
7161 }
7162 
7163 /*
7164  * sata_build_lsense_page_2f() is used to create the
7165  * SCSI LOG SENSE page 0x10 (informational exceptions)
7166  *
7167  * Takes a sata_drive_info t * and the address of a buffer
7168  * in which to create the page information as well as a sata_hba_inst_t *.
7169  *
7170  * Returns the number of bytes valid in the buffer.
7171  */
7172 static	int
7173 sata_build_lsense_page_2f(
7174 	sata_drive_info_t *sdinfo,
7175 	uint8_t *buf,
7176 	sata_hba_inst_t *sata_hba_inst)
7177 {
7178 	struct log_parameter *lpp = (struct log_parameter *)buf;
7179 	int rval;
7180 	uint8_t *smart_data;
7181 	uint8_t temp;
7182 	sata_id_t *sata_id;
7183 #define	SMART_NO_TEMP	0xff
7184 
7185 	lpp->param_code[0] = 0;
7186 	lpp->param_code[1] = 0;
7187 	lpp->param_ctrl_flags = LOG_CTRL_LP | LOG_CTRL_LBIN;
7188 
7189 	/* Now get the SMART status w.r.t. threshold exceeded */
7190 	rval = sata_fetch_smart_return_status(sata_hba_inst, sdinfo);
7191 	switch (rval) {
7192 	case 1:
7193 		lpp->param_values[0] = SCSI_PREDICTED_FAILURE;
7194 		lpp->param_values[1] = SCSI_GENERAL_HD_FAILURE;
7195 		break;
7196 	case 0:
7197 	case -1:	/* failed to get data */
7198 		lpp->param_values[0] = 0;	/* No failure predicted */
7199 		lpp->param_values[1] = 0;
7200 		break;
7201 #if defined(SATA_DEBUG)
7202 	default:
7203 		cmn_err(CE_PANIC, "sata_build_lsense_page_2f bad return value");
7204 		/* NOTREACHED */
7205 #endif
7206 	}
7207 
7208 	sata_id = &sdinfo->satadrv_id;
7209 	if (! (sata_id->ai_sctsupport & SATA_SCT_CMD_TRANS_SUP))
7210 		temp = SMART_NO_TEMP;
7211 	else {
7212 		/* Now get the temperature */
7213 		smart_data = kmem_zalloc(512, KM_SLEEP);
7214 		rval = sata_smart_read_log(sata_hba_inst, sdinfo, smart_data,
7215 		    SCT_STATUS_LOG_PAGE, 1);
7216 		if (rval == -1)
7217 			temp = SMART_NO_TEMP;
7218 		else {
7219 			temp = smart_data[200];
7220 			if (temp & 0x80) {
7221 				if (temp & 0x7f)
7222 					temp = 0;
7223 				else
7224 					temp = SMART_NO_TEMP;
7225 			}
7226 		}
7227 		kmem_free(smart_data, 512);
7228 	}
7229 
7230 	lpp->param_values[2] = temp;	/* most recent temperature */
7231 	lpp->param_values[3] = 0;	/* required vendor specific byte */
7232 
7233 	lpp->param_len = SCSI_INFO_EXCEPTIONS_PARAM_LEN;
7234 
7235 
7236 	return (SCSI_INFO_EXCEPTIONS_PARAM_LEN + SCSI_LOG_PARAM_HDR_LEN);
7237 }
7238 
7239 /*
7240  * sata_build_lsense_page_30() is used to create the
7241  * SCSI LOG SENSE page 0x30 (Sun's vendor specific page for ATA SMART data).
7242  *
7243  * Takes a sata_drive_info t * and the address of a buffer
7244  * in which to create the page information as well as a sata_hba_inst_t *.
7245  *
7246  * Returns the number of bytes valid in the buffer.
7247  */
7248 static int
7249 sata_build_lsense_page_30(
7250 	sata_drive_info_t *sdinfo,
7251 	uint8_t *buf,
7252 	sata_hba_inst_t *sata_hba_inst)
7253 {
7254 	struct smart_data *smart_data = (struct smart_data *)buf;
7255 	int rval;
7256 
7257 	/* Now do the SMART READ DATA */
7258 	rval = sata_fetch_smart_data(sata_hba_inst, sdinfo, smart_data);
7259 	if (rval == -1)
7260 		return (0);
7261 
7262 	return (sizeof (struct smart_data));
7263 }
7264 
7265 
7266 
7267 
7268 
7269 /* ************************** LOCAL FUNCTIONS ************************** */
7270 
7271 /*
7272  * Validate sata_tran info
7273  * SATA_FAILURE returns if structure is inconsistent or structure revision
7274  * does not match one used by the framework.
7275  *
7276  * Returns SATA_SUCCESS if sata_hba_tran has matching revision and contains
7277  * required function pointers.
7278  * Returns SATA_FAILURE otherwise.
7279  */
7280 static int
7281 sata_validate_sata_hba_tran(dev_info_t *dip, sata_hba_tran_t *sata_tran)
7282 {
7283 	if (sata_tran->sata_tran_hba_rev != SATA_TRAN_HBA_REV) {
7284 		sata_log(NULL, CE_WARN,
7285 		    "sata: invalid sata_hba_tran version %d for driver %s",
7286 		    sata_tran->sata_tran_hba_rev, ddi_driver_name(dip));
7287 		return (SATA_FAILURE);
7288 	}
7289 
7290 	if (dip != sata_tran->sata_tran_hba_dip) {
7291 		SATA_LOG_D((NULL, CE_WARN,
7292 		    "sata: inconsistent sata_tran_hba_dip "
7293 		    "%p / %p", sata_tran->sata_tran_hba_dip, dip));
7294 		return (SATA_FAILURE);
7295 	}
7296 
7297 	if (sata_tran->sata_tran_probe_port == NULL ||
7298 	    sata_tran->sata_tran_start == NULL ||
7299 	    sata_tran->sata_tran_abort == NULL ||
7300 	    sata_tran->sata_tran_reset_dport == NULL) {
7301 		SATA_LOG_D((NULL, CE_WARN, "sata: sata_hba_tran missing "
7302 		    "required functions"));
7303 	}
7304 	return (SATA_SUCCESS);
7305 }
7306 
7307 /*
7308  * Remove HBA instance from sata_hba_list.
7309  */
7310 static void
7311 sata_remove_hba_instance(dev_info_t *dip)
7312 {
7313 	sata_hba_inst_t	*sata_hba_inst;
7314 
7315 	mutex_enter(&sata_mutex);
7316 	for (sata_hba_inst = sata_hba_list;
7317 	    sata_hba_inst != (struct sata_hba_inst *)NULL;
7318 	    sata_hba_inst = sata_hba_inst->satahba_next) {
7319 		if (sata_hba_inst->satahba_dip == dip)
7320 			break;
7321 	}
7322 
7323 	if (sata_hba_inst == (struct sata_hba_inst *)NULL) {
7324 #ifdef SATA_DEBUG
7325 		cmn_err(CE_WARN, "sata_remove_hba_instance: "
7326 		    "unknown HBA instance\n");
7327 #endif
7328 		ASSERT(FALSE);
7329 	}
7330 	if (sata_hba_inst == sata_hba_list) {
7331 		sata_hba_list = sata_hba_inst->satahba_next;
7332 		if (sata_hba_list) {
7333 			sata_hba_list->satahba_prev =
7334 			    (struct sata_hba_inst *)NULL;
7335 		}
7336 		if (sata_hba_inst == sata_hba_list_tail) {
7337 			sata_hba_list_tail = NULL;
7338 		}
7339 	} else if (sata_hba_inst == sata_hba_list_tail) {
7340 		sata_hba_list_tail = sata_hba_inst->satahba_prev;
7341 		if (sata_hba_list_tail) {
7342 			sata_hba_list_tail->satahba_next =
7343 			    (struct sata_hba_inst *)NULL;
7344 		}
7345 	} else {
7346 		sata_hba_inst->satahba_prev->satahba_next =
7347 		    sata_hba_inst->satahba_next;
7348 		sata_hba_inst->satahba_next->satahba_prev =
7349 		    sata_hba_inst->satahba_prev;
7350 	}
7351 	mutex_exit(&sata_mutex);
7352 }
7353 
7354 
7355 
7356 
7357 
7358 /*
7359  * Probe all SATA ports of the specified HBA instance.
7360  * The assumption is that there are no target and attachment point minor nodes
7361  * created by the boot subsystems, so we do not need to prune device tree.
7362  *
7363  * This function is called only from sata_hba_attach(). It does not have to
7364  * be protected by controller mutex, because the hba_attached flag is not set
7365  * yet and no one would be touching this HBA instance other then this thread.
7366  * Determines if port is active and what type of the device is attached
7367  * (if any). Allocates necessary structures for each port.
7368  *
7369  * An AP (Attachement Point) node is created for each SATA device port even
7370  * when there is no device attached.
7371  */
7372 
7373 static 	void
7374 sata_probe_ports(sata_hba_inst_t *sata_hba_inst)
7375 {
7376 	dev_info_t		*dip = SATA_DIP(sata_hba_inst);
7377 	int			ncport, npmport;
7378 	sata_cport_info_t 	*cportinfo;
7379 	sata_drive_info_t	*drive;
7380 	sata_pmult_info_t	*pminfo;
7381 	sata_pmport_info_t 	*pmportinfo;
7382 	sata_device_t		sata_device;
7383 	int			rval;
7384 	dev_t			minor_number;
7385 	char			name[16];
7386 	clock_t			start_time, cur_time;
7387 
7388 	/*
7389 	 * Probe controller ports first, to find port status and
7390 	 * any port multiplier attached.
7391 	 */
7392 	for (ncport = 0; ncport < SATA_NUM_CPORTS(sata_hba_inst); ncport++) {
7393 		/* allocate cport structure */
7394 		cportinfo = kmem_zalloc(sizeof (sata_cport_info_t), KM_SLEEP);
7395 		ASSERT(cportinfo != NULL);
7396 		mutex_init(&cportinfo->cport_mutex, NULL, MUTEX_DRIVER, NULL);
7397 
7398 		mutex_enter(&cportinfo->cport_mutex);
7399 
7400 		cportinfo->cport_addr.cport = ncport;
7401 		cportinfo->cport_addr.pmport = 0;
7402 		cportinfo->cport_addr.qual = SATA_ADDR_CPORT;
7403 		cportinfo->cport_state &= ~SATA_PORT_STATE_CLEAR_MASK;
7404 		cportinfo->cport_state |= SATA_STATE_PROBING;
7405 		SATA_CPORT_INFO(sata_hba_inst, ncport) = cportinfo;
7406 
7407 		/*
7408 		 * Regardless if a port is usable or not, create
7409 		 * an attachment point
7410 		 */
7411 		mutex_exit(&cportinfo->cport_mutex);
7412 		minor_number =
7413 		    SATA_MAKE_AP_MINOR(ddi_get_instance(dip), ncport, 0, 0);
7414 		(void) sprintf(name, "%d", ncport);
7415 		if (ddi_create_minor_node(dip, name, S_IFCHR,
7416 		    minor_number, DDI_NT_SATA_ATTACHMENT_POINT, 0) !=
7417 		    DDI_SUCCESS) {
7418 			sata_log(sata_hba_inst, CE_WARN, "sata_hba_attach: "
7419 			    "cannot create SATA attachment point for port %d",
7420 			    ncport);
7421 		}
7422 
7423 		/* Probe port */
7424 		start_time = ddi_get_lbolt();
7425 	reprobe_cport:
7426 		sata_device.satadev_addr.cport = ncport;
7427 		sata_device.satadev_addr.pmport = 0;
7428 		sata_device.satadev_addr.qual = SATA_ADDR_CPORT;
7429 		sata_device.satadev_rev = SATA_DEVICE_REV;
7430 
7431 		rval = (*SATA_PROBE_PORT_FUNC(sata_hba_inst))
7432 		    (dip, &sata_device);
7433 
7434 		mutex_enter(&cportinfo->cport_mutex);
7435 		sata_update_port_scr(&cportinfo->cport_scr, &sata_device);
7436 		if (rval != SATA_SUCCESS) {
7437 			/* Something went wrong? Fail the port */
7438 			cportinfo->cport_state = SATA_PSTATE_FAILED;
7439 			mutex_exit(&cportinfo->cport_mutex);
7440 			continue;
7441 		}
7442 		cportinfo->cport_state &= ~SATA_STATE_PROBING;
7443 		cportinfo->cport_state |= SATA_STATE_PROBED;
7444 		cportinfo->cport_dev_type = sata_device.satadev_type;
7445 
7446 		cportinfo->cport_state |= SATA_STATE_READY;
7447 		if (cportinfo->cport_dev_type == SATA_DTYPE_NONE) {
7448 			mutex_exit(&cportinfo->cport_mutex);
7449 			continue;
7450 		}
7451 		if (cportinfo->cport_dev_type != SATA_DTYPE_PMULT) {
7452 			/*
7453 			 * There is some device attached.
7454 			 * Allocate device info structure
7455 			 */
7456 			if (SATA_CPORTINFO_DRV_INFO(cportinfo) == NULL) {
7457 				mutex_exit(&cportinfo->cport_mutex);
7458 				SATA_CPORTINFO_DRV_INFO(cportinfo) =
7459 				    kmem_zalloc(sizeof (sata_drive_info_t),
7460 				    KM_SLEEP);
7461 				mutex_enter(&cportinfo->cport_mutex);
7462 			}
7463 			drive = SATA_CPORTINFO_DRV_INFO(cportinfo);
7464 			drive->satadrv_addr = cportinfo->cport_addr;
7465 			drive->satadrv_addr.qual = SATA_ADDR_DCPORT;
7466 			drive->satadrv_type = cportinfo->cport_dev_type;
7467 			drive->satadrv_state = SATA_STATE_UNKNOWN;
7468 
7469 			mutex_exit(&cportinfo->cport_mutex);
7470 			if (sata_add_device(dip, sata_hba_inst, ncport, 0) !=
7471 			    SATA_SUCCESS) {
7472 				/*
7473 				 * Plugged device was not correctly identified.
7474 				 * Retry, within a SATA_DEV_IDENTIFY_TIMEOUT
7475 				 */
7476 				cur_time = ddi_get_lbolt();
7477 				if ((cur_time - start_time) <
7478 				    drv_usectohz(SATA_DEV_IDENTIFY_TIMEOUT)) {
7479 					/* sleep for a while */
7480 					delay(drv_usectohz(
7481 					    SATA_DEV_IDENTIFY_RETRY_DELAY));
7482 					goto reprobe_cport;
7483 				}
7484 			}
7485 		} else {
7486 			mutex_exit(&cportinfo->cport_mutex);
7487 			ASSERT(cportinfo->cport_dev_type == SATA_DTYPE_PMULT);
7488 			pminfo = kmem_zalloc(sizeof (sata_pmult_info_t),
7489 			    KM_SLEEP);
7490 			mutex_enter(&cportinfo->cport_mutex);
7491 			ASSERT(pminfo != NULL);
7492 			SATA_CPORTINFO_PMULT_INFO(cportinfo) = pminfo;
7493 			pminfo->pmult_addr.cport = cportinfo->cport_addr.cport;
7494 			pminfo->pmult_addr.pmport = SATA_PMULT_HOSTPORT;
7495 			pminfo->pmult_addr.qual = SATA_ADDR_PMPORT;
7496 			pminfo->pmult_num_dev_ports =
7497 			    sata_device.satadev_add_info;
7498 			mutex_init(&pminfo->pmult_mutex, NULL, MUTEX_DRIVER,
7499 			    NULL);
7500 			pminfo->pmult_state = SATA_STATE_PROBING;
7501 			mutex_exit(&cportinfo->cport_mutex);
7502 
7503 			/* Probe Port Multiplier ports */
7504 			for (npmport = 0;
7505 			    npmport < pminfo->pmult_num_dev_ports;
7506 			    npmport++) {
7507 				pmportinfo = kmem_zalloc(
7508 				    sizeof (sata_pmport_info_t), KM_SLEEP);
7509 				mutex_enter(&cportinfo->cport_mutex);
7510 				ASSERT(pmportinfo != NULL);
7511 				pmportinfo->pmport_addr.cport = ncport;
7512 				pmportinfo->pmport_addr.pmport = npmport;
7513 				pmportinfo->pmport_addr.qual =
7514 				    SATA_ADDR_PMPORT;
7515 				pminfo->pmult_dev_port[npmport] = pmportinfo;
7516 
7517 				mutex_init(&pmportinfo->pmport_mutex, NULL,
7518 				    MUTEX_DRIVER, NULL);
7519 
7520 				mutex_exit(&cportinfo->cport_mutex);
7521 
7522 				/* Create an attachment point */
7523 				minor_number = SATA_MAKE_AP_MINOR(
7524 				    ddi_get_instance(dip), ncport, npmport, 1);
7525 				(void) sprintf(name, "%d.%d", ncport, npmport);
7526 				if (ddi_create_minor_node(dip, name, S_IFCHR,
7527 				    minor_number, DDI_NT_SATA_ATTACHMENT_POINT,
7528 				    0) != DDI_SUCCESS) {
7529 					sata_log(sata_hba_inst, CE_WARN,
7530 					    "sata_hba_attach: "
7531 					    "cannot create SATA attachment "
7532 					    "point for port %d pmult port %d",
7533 					    ncport, npmport);
7534 				}
7535 
7536 				start_time = ddi_get_lbolt();
7537 			reprobe_pmport:
7538 				sata_device.satadev_addr.pmport = npmport;
7539 				sata_device.satadev_addr.qual =
7540 				    SATA_ADDR_PMPORT;
7541 
7542 				rval = (*SATA_PROBE_PORT_FUNC(sata_hba_inst))
7543 				    (dip, &sata_device);
7544 				mutex_enter(&cportinfo->cport_mutex);
7545 
7546 				/* sata_update_port_info() */
7547 				sata_update_port_scr(&pmportinfo->pmport_scr,
7548 				    &sata_device);
7549 
7550 				if (rval != SATA_SUCCESS) {
7551 					pmportinfo->pmport_state =
7552 					    SATA_PSTATE_FAILED;
7553 					mutex_exit(&cportinfo->cport_mutex);
7554 					continue;
7555 				}
7556 				pmportinfo->pmport_state &=
7557 				    ~SATA_STATE_PROBING;
7558 				pmportinfo->pmport_state |= SATA_STATE_PROBED;
7559 				pmportinfo->pmport_dev_type =
7560 				    sata_device.satadev_type;
7561 
7562 				pmportinfo->pmport_state |= SATA_STATE_READY;
7563 				if (pmportinfo->pmport_dev_type ==
7564 				    SATA_DTYPE_NONE) {
7565 					mutex_exit(&cportinfo->cport_mutex);
7566 					continue;
7567 				}
7568 				/* Port multipliers cannot be chained */
7569 				ASSERT(pmportinfo->pmport_dev_type !=
7570 				    SATA_DTYPE_PMULT);
7571 				/*
7572 				 * There is something attached to Port
7573 				 * Multiplier device port
7574 				 * Allocate device info structure
7575 				 */
7576 				if (pmportinfo->pmport_sata_drive == NULL) {
7577 					mutex_exit(&cportinfo->cport_mutex);
7578 					pmportinfo->pmport_sata_drive =
7579 					    kmem_zalloc(
7580 					    sizeof (sata_drive_info_t),
7581 					    KM_SLEEP);
7582 					mutex_enter(&cportinfo->cport_mutex);
7583 				}
7584 				drive = pmportinfo->pmport_sata_drive;
7585 				drive->satadrv_addr.cport =
7586 				    pmportinfo->pmport_addr.cport;
7587 				drive->satadrv_addr.pmport = npmport;
7588 				drive->satadrv_addr.qual = SATA_ADDR_DPMPORT;
7589 				drive->satadrv_type = pmportinfo->
7590 				    pmport_dev_type;
7591 				drive->satadrv_state = SATA_STATE_UNKNOWN;
7592 
7593 				mutex_exit(&cportinfo->cport_mutex);
7594 				if (sata_add_device(dip, sata_hba_inst, ncport,
7595 				    npmport) != SATA_SUCCESS) {
7596 					/*
7597 					 * Plugged device was not correctly
7598 					 * identified. Retry, within the
7599 					 * SATA_DEV_IDENTIFY_TIMEOUT
7600 					 */
7601 					cur_time = ddi_get_lbolt();
7602 					if ((cur_time - start_time) <
7603 					    drv_usectohz(
7604 					    SATA_DEV_IDENTIFY_TIMEOUT)) {
7605 						/* sleep for a while */
7606 						delay(drv_usectohz(
7607 						SATA_DEV_IDENTIFY_RETRY_DELAY));
7608 						goto reprobe_pmport;
7609 					}
7610 				}
7611 			}
7612 			pmportinfo->pmport_state =
7613 			    SATA_STATE_PROBED | SATA_STATE_READY;
7614 		}
7615 	}
7616 }
7617 
7618 /*
7619  * Add SATA device for specified HBA instance & port (SCSI target
7620  * device nodes).
7621  * This function is called (indirectly) only from sata_hba_attach().
7622  * A target node is created when there is a supported type device attached,
7623  * but may be removed if it cannot be put online.
7624  *
7625  * This function cannot be called from an interrupt context.
7626  *
7627  * ONLY DISK TARGET NODES ARE CREATED NOW
7628  *
7629  * Returns SATA_SUCCESS when port/device was fully processed, SATA_FAILURE when
7630  * device identification failed - adding a device could be retried.
7631  *
7632  */
7633 static 	int
7634 sata_add_device(dev_info_t *pdip, sata_hba_inst_t *sata_hba_inst, int cport,
7635     int pmport)
7636 {
7637 	sata_cport_info_t 	*cportinfo;
7638 	sata_pmult_info_t	*pminfo;
7639 	sata_pmport_info_t	*pmportinfo;
7640 	dev_info_t		*cdip;		/* child dip */
7641 	sata_device_t		sata_device;
7642 	int			rval;
7643 
7644 
7645 
7646 	cportinfo = SATA_CPORT_INFO(sata_hba_inst, cport);
7647 	ASSERT(cportinfo->cport_dev_type != SATA_DTYPE_NONE);
7648 	mutex_enter(&cportinfo->cport_mutex);
7649 	/*
7650 	 * Some device is attached to a controller port.
7651 	 * We rely on controllers distinquishing between no-device,
7652 	 * attached port multiplier and other kind of attached device.
7653 	 * We need to get Identify Device data and determine
7654 	 * positively the dev type before trying to attach
7655 	 * the target driver.
7656 	 */
7657 	sata_device.satadev_rev = SATA_DEVICE_REV;
7658 	if (cportinfo->cport_dev_type != SATA_DTYPE_PMULT) {
7659 		/*
7660 		 * Not port multiplier.
7661 		 */
7662 		sata_device.satadev_addr = cportinfo->cport_addr;
7663 		sata_device.satadev_addr.qual = SATA_ADDR_DCPORT;
7664 		mutex_exit(&cportinfo->cport_mutex);
7665 
7666 		rval = sata_probe_device(sata_hba_inst, &sata_device);
7667 		if (rval != SATA_SUCCESS ||
7668 		    sata_device.satadev_type == SATA_DTYPE_UNKNOWN)
7669 			return (SATA_FAILURE);
7670 
7671 		mutex_enter(&cportinfo->cport_mutex);
7672 		if ((sata_device.satadev_type & SATA_VALID_DEV_TYPE) == 0) {
7673 			/*
7674 			 * Could not determine device type or
7675 			 * a device is not supported.
7676 			 * Degrade this device to unknown.
7677 			 */
7678 			cportinfo->cport_dev_type = SATA_DTYPE_UNKNOWN;
7679 			mutex_exit(&cportinfo->cport_mutex);
7680 			return (SATA_SUCCESS);
7681 		}
7682 		cportinfo->cport_dev_type = sata_device.satadev_type;
7683 		mutex_exit(&cportinfo->cport_mutex);
7684 
7685 		/*
7686 		 * Initialize device to the desired state. Even if it
7687 		 * fails, the device will still attach but syslog
7688 		 * will show the warning.
7689 		 */
7690 		if (sata_initialize_device(sata_hba_inst,
7691 		    SATA_CPORTINFO_DRV_INFO(cportinfo)) != SATA_SUCCESS)
7692 			/* Retry */
7693 			(void) sata_initialize_device(sata_hba_inst,
7694 			    SATA_CPORTINFO_DRV_INFO(cportinfo));
7695 
7696 		mutex_enter(&cportinfo->cport_mutex);
7697 		sata_show_drive_info(sata_hba_inst,
7698 		    SATA_CPORTINFO_DRV_INFO(cportinfo));
7699 		cportinfo->cport_tgtnode_clean = B_TRUE;
7700 		mutex_exit(&cportinfo->cport_mutex);
7701 		cdip = sata_create_target_node(pdip, sata_hba_inst,
7702 		    &sata_device.satadev_addr);
7703 		mutex_enter(&cportinfo->cport_mutex);
7704 		if (cdip == NULL) {
7705 			/*
7706 			 * Attaching target node failed.
7707 			 * We retain sata_drive_info structure...
7708 			 */
7709 			(SATA_CPORTINFO_DRV_INFO(cportinfo))->
7710 			    satadrv_type = SATA_DTYPE_UNKNOWN;
7711 			(SATA_CPORTINFO_DRV_INFO(cportinfo))->
7712 			    satadrv_state = SATA_STATE_UNKNOWN;
7713 			cportinfo->cport_dev_type = SATA_DTYPE_UNKNOWN;
7714 			mutex_exit(&cportinfo->cport_mutex);
7715 			return (SATA_SUCCESS);
7716 		}
7717 		(SATA_CPORTINFO_DRV_INFO(cportinfo))->
7718 		    satadrv_state = SATA_STATE_READY;
7719 	} else {
7720 		/* This must be Port Multiplier type */
7721 		if (cportinfo->cport_dev_type != SATA_DTYPE_PMULT) {
7722 			SATA_LOG_D((sata_hba_inst, CE_WARN,
7723 			    "sata_add_device: "
7724 			    "unrecognized dev type %x",
7725 			    cportinfo->cport_dev_type));
7726 			mutex_exit(&cportinfo->cport_mutex);
7727 			return (SATA_SUCCESS);
7728 		}
7729 		pminfo = SATA_CPORTINFO_PMULT_INFO(cportinfo);
7730 		pmportinfo = pminfo->pmult_dev_port[pmport];
7731 		sata_device.satadev_addr = pmportinfo->pmport_addr;
7732 		sata_device.satadev_addr.qual = SATA_ADDR_DPMPORT;
7733 		mutex_exit(&cportinfo->cport_mutex);
7734 
7735 		rval = sata_probe_device(sata_hba_inst, &sata_device);
7736 		if (rval != SATA_SUCCESS ||
7737 		    sata_device.satadev_type == SATA_DTYPE_UNKNOWN) {
7738 			return (SATA_FAILURE);
7739 		}
7740 		mutex_enter(&cportinfo->cport_mutex);
7741 		if ((sata_device.satadev_type & SATA_VALID_DEV_TYPE) == 0) {
7742 			/*
7743 			 * Could not determine device type.
7744 			 * Degrade this device to unknown.
7745 			 */
7746 			pmportinfo->pmport_dev_type = SATA_DTYPE_UNKNOWN;
7747 			mutex_exit(&cportinfo->cport_mutex);
7748 			return (SATA_SUCCESS);
7749 		}
7750 		pmportinfo->pmport_dev_type = sata_device.satadev_type;
7751 		mutex_exit(&cportinfo->cport_mutex);
7752 		/*
7753 		 * Initialize device to the desired state.
7754 		 * Even if it fails, the device will still
7755 		 * attach but syslog will show the warning.
7756 		 */
7757 		if (sata_initialize_device(sata_hba_inst,
7758 		    pmportinfo->pmport_sata_drive) != SATA_SUCCESS)
7759 			/* Retry */
7760 			(void) sata_initialize_device(sata_hba_inst,
7761 			    pmportinfo->pmport_sata_drive);
7762 
7763 		mutex_enter(&cportinfo->cport_mutex);
7764 		sata_show_drive_info(sata_hba_inst,
7765 		    pmportinfo->pmport_sata_drive);
7766 		pmportinfo->pmport_tgtnode_clean = B_TRUE;
7767 		mutex_exit(&cportinfo->cport_mutex);
7768 		cdip = sata_create_target_node(pdip, sata_hba_inst,
7769 		    &sata_device.satadev_addr);
7770 		mutex_enter(&cportinfo->cport_mutex);
7771 		if (cdip == NULL) {
7772 			/*
7773 			 * Attaching target node failed.
7774 			 * We retain sata_drive_info structure...
7775 			 */
7776 			pmportinfo->pmport_sata_drive->
7777 			    satadrv_type = SATA_DTYPE_UNKNOWN;
7778 			pmportinfo->pmport_sata_drive->
7779 			    satadrv_state = SATA_STATE_UNKNOWN;
7780 			pmportinfo->pmport_dev_type =
7781 			    SATA_DTYPE_UNKNOWN;
7782 			mutex_exit(&cportinfo->cport_mutex);
7783 			return (SATA_SUCCESS);
7784 		}
7785 		pmportinfo->pmport_sata_drive->satadrv_state |=
7786 		    SATA_STATE_READY;
7787 	}
7788 	mutex_exit(&cportinfo->cport_mutex);
7789 	return (SATA_SUCCESS);
7790 }
7791 
7792 
7793 /*
7794  * Create scsi target node for attached device, create node properties and
7795  * attach the node.
7796  * The node could be removed if the device onlining fails.
7797  *
7798  * A dev_info_t pointer is returned if operation is successful, NULL is
7799  * returned otherwise.
7800  *
7801  * No port multiplier support.
7802  */
7803 
7804 static dev_info_t *
7805 sata_create_target_node(dev_info_t *dip, sata_hba_inst_t *sata_hba_inst,
7806 			sata_address_t *sata_addr)
7807 {
7808 	dev_info_t *cdip = NULL;
7809 	int rval;
7810 	char *nname = NULL;
7811 	char **compatible = NULL;
7812 	int ncompatible;
7813 	struct scsi_inquiry inq;
7814 	sata_device_t sata_device;
7815 	sata_drive_info_t *sdinfo;
7816 	int target;
7817 	int i;
7818 
7819 	sata_device.satadev_rev = SATA_DEVICE_REV;
7820 	sata_device.satadev_addr = *sata_addr;
7821 
7822 	mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, sata_addr->cport)));
7823 
7824 	sdinfo = sata_get_device_info(sata_hba_inst, &sata_device);
7825 
7826 	target = SATA_TO_SCSI_TARGET(sata_addr->cport,
7827 	    sata_addr->pmport, sata_addr->qual);
7828 
7829 	if (sdinfo == NULL) {
7830 		mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst,
7831 		    sata_addr->cport)));
7832 		SATA_LOG_D((sata_hba_inst, CE_WARN,
7833 		    "sata_create_target_node: no sdinfo for target %x",
7834 		    target));
7835 		return (NULL);
7836 	}
7837 
7838 	/*
7839 	 * create scsi inquiry data, expected by
7840 	 * scsi_hba_nodename_compatible_get()
7841 	 */
7842 	sata_identdev_to_inquiry(sata_hba_inst, sdinfo, (uint8_t *)&inq);
7843 	mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, sata_addr->cport)));
7844 
7845 	/* determine the node name and compatible */
7846 	scsi_hba_nodename_compatible_get(&inq, NULL,
7847 	    inq.inq_dtype, NULL, &nname, &compatible, &ncompatible);
7848 
7849 #ifdef SATA_DEBUG
7850 	if (sata_debug_flags & SATA_DBG_NODES) {
7851 		if (nname == NULL) {
7852 			cmn_err(CE_NOTE, "sata_create_target_node: "
7853 			    "cannot determine nodename for target %d\n",
7854 			    target);
7855 		} else {
7856 			cmn_err(CE_WARN, "sata_create_target_node: "
7857 			    "target %d nodename: %s\n", target, nname);
7858 		}
7859 		if (compatible == NULL) {
7860 			cmn_err(CE_WARN,
7861 			    "sata_create_target_node: no compatible name\n");
7862 		} else {
7863 			for (i = 0; i < ncompatible; i++) {
7864 				cmn_err(CE_WARN, "sata_create_target_node: "
7865 				    "compatible name: %s\n", compatible[i]);
7866 			}
7867 		}
7868 	}
7869 #endif
7870 
7871 	/* if nodename can't be determined, log error and exit */
7872 	if (nname == NULL) {
7873 		SATA_LOG_D((sata_hba_inst, CE_WARN,
7874 		    "sata_create_target_node: cannot determine nodename "
7875 		    "for target %d\n", target));
7876 		scsi_hba_nodename_compatible_free(nname, compatible);
7877 		return (NULL);
7878 	}
7879 	/*
7880 	 * Create scsi target node
7881 	 */
7882 	ndi_devi_alloc_sleep(dip, nname, (pnode_t)DEVI_SID_NODEID, &cdip);
7883 	rval = ndi_prop_update_string(DDI_DEV_T_NONE, cdip,
7884 	    "device-type", "scsi");
7885 
7886 	if (rval != DDI_PROP_SUCCESS) {
7887 		SATA_LOG_D((sata_hba_inst, CE_WARN, "sata_create_target_node: "
7888 		    "updating device_type prop failed %d", rval));
7889 		goto fail;
7890 	}
7891 
7892 	/*
7893 	 * Create target node properties: target & lun
7894 	 */
7895 	rval = ndi_prop_update_int(DDI_DEV_T_NONE, cdip, "target", target);
7896 	if (rval != DDI_PROP_SUCCESS) {
7897 		SATA_LOG_D((sata_hba_inst, CE_WARN, "sata_create_target_node: "
7898 		    "updating target prop failed %d", rval));
7899 		goto fail;
7900 	}
7901 	rval = ndi_prop_update_int(DDI_DEV_T_NONE, cdip, "lun", 0);
7902 	if (rval != DDI_PROP_SUCCESS) {
7903 		SATA_LOG_D((sata_hba_inst, CE_WARN, "sata_create_target_node: "
7904 		    "updating target prop failed %d", rval));
7905 		goto fail;
7906 	}
7907 
7908 	/* decorate the node with compatible */
7909 	if (ndi_prop_update_string_array(DDI_DEV_T_NONE, cdip, "compatible",
7910 	    compatible, ncompatible) != DDI_PROP_SUCCESS) {
7911 		SATA_LOG_D((sata_hba_inst, CE_WARN,
7912 		    "sata_create_target_node: FAIL compatible props cdip 0x%p",
7913 		    (void *)cdip));
7914 		goto fail;
7915 	}
7916 
7917 	/*
7918 	 * Now, try to attach the driver. If probing of the device fails,
7919 	 * the target node may be removed
7920 	 */
7921 	rval = ndi_devi_online(cdip, NDI_ONLINE_ATTACH);
7922 
7923 	scsi_hba_nodename_compatible_free(nname, compatible);
7924 
7925 	if (rval == NDI_SUCCESS)
7926 		return (cdip);
7927 
7928 	/* target node was removed - are we sure? */
7929 	return (NULL);
7930 
7931 fail:
7932 	scsi_hba_nodename_compatible_free(nname, compatible);
7933 	ddi_prop_remove_all(cdip);
7934 	rval = ndi_devi_free(cdip);
7935 	if (rval != NDI_SUCCESS) {
7936 		SATA_LOG_D((sata_hba_inst, CE_WARN, "sata_create_target_node: "
7937 		    "node removal failed %d", rval));
7938 	}
7939 	sata_log(sata_hba_inst, CE_WARN, "sata_create_target_node: "
7940 	    "cannot create target node for SATA device at port %d",
7941 	    sata_addr->cport);
7942 	return (NULL);
7943 }
7944 
7945 
7946 
7947 /*
7948  * Re-probe sata port, check for a device and attach info
7949  * structures when necessary. Identify Device data is fetched, if possible.
7950  * Assumption: sata address is already validated.
7951  * SATA_SUCCESS is returned if port is re-probed sucessfully, regardless of
7952  * the presence of a device and its type.
7953  *
7954  * flag arg specifies that the function should try multiple times to identify
7955  * device type and to initialize it, or it should return immediately on failure.
7956  * SATA_DEV_IDENTIFY_RETRY - retry
7957  * SATA_DEV_IDENTIFY_NORETRY - no retry
7958  *
7959  * SATA_FAILURE is returned if one of the operations failed.
7960  *
7961  * This function cannot be called in interrupt context - it may sleep.
7962  */
7963 static int
7964 sata_reprobe_port(sata_hba_inst_t *sata_hba_inst, sata_device_t *sata_device,
7965     int flag)
7966 {
7967 	sata_cport_info_t *cportinfo;
7968 	sata_drive_info_t *sdinfo;
7969 	boolean_t init_device = B_FALSE;
7970 	int prev_device_type = SATA_DTYPE_NONE;
7971 	int prev_device_settings = 0;
7972 	clock_t start_time;
7973 	int retry = B_FALSE;
7974 	int rval;
7975 
7976 	/* We only care about host sata cport for now */
7977 	cportinfo = SATA_CPORT_INFO(sata_hba_inst,
7978 	    sata_device->satadev_addr.cport);
7979 	sdinfo = SATA_CPORTINFO_DRV_INFO(cportinfo);
7980 	if (sdinfo != NULL) {
7981 		/*
7982 		 * We are re-probing port with a previously attached device.
7983 		 * Save previous device type and settings
7984 		 */
7985 		prev_device_type = cportinfo->cport_dev_type;
7986 		prev_device_settings = sdinfo->satadrv_settings;
7987 	}
7988 	if (flag == SATA_DEV_IDENTIFY_RETRY) {
7989 		start_time = ddi_get_lbolt();
7990 		retry = B_TRUE;
7991 	}
7992 retry_probe:
7993 
7994 	/* probe port */
7995 	mutex_enter(&cportinfo->cport_mutex);
7996 	cportinfo->cport_state &= ~SATA_PORT_STATE_CLEAR_MASK;
7997 	cportinfo->cport_state |= SATA_STATE_PROBING;
7998 	mutex_exit(&cportinfo->cport_mutex);
7999 
8000 	rval = (*SATA_PROBE_PORT_FUNC(sata_hba_inst))
8001 	    (SATA_DIP(sata_hba_inst), sata_device);
8002 
8003 	mutex_enter(&cportinfo->cport_mutex);
8004 	if (rval != SATA_SUCCESS) {
8005 		cportinfo->cport_state = SATA_PSTATE_FAILED;
8006 		mutex_exit(&cportinfo->cport_mutex);
8007 		SATA_LOG_D((sata_hba_inst, CE_WARN, "sata_reprobe_port: "
8008 		    "SATA port %d probing failed",
8009 		    cportinfo->cport_addr.cport));
8010 		return (SATA_FAILURE);
8011 	}
8012 
8013 	/*
8014 	 * update sata port state and set device type
8015 	 */
8016 	sata_update_port_info(sata_hba_inst, sata_device);
8017 	cportinfo->cport_state |= SATA_STATE_PROBED;
8018 
8019 	/*
8020 	 * Sanity check - Port is active? Is the link active?
8021 	 * Is there any device attached?
8022 	 */
8023 	if ((cportinfo->cport_state &
8024 	    (SATA_PSTATE_SHUTDOWN | SATA_PSTATE_FAILED)) ||
8025 	    (cportinfo->cport_scr.sstatus & SATA_PORT_DEVLINK_UP_MASK) !=
8026 	    SATA_PORT_DEVLINK_UP) {
8027 		/*
8028 		 * Port in non-usable state or no link active/no device.
8029 		 * Free info structure if necessary (direct attached drive
8030 		 * only, for now!
8031 		 */
8032 		sdinfo = SATA_CPORTINFO_DRV_INFO(cportinfo);
8033 		SATA_CPORTINFO_DRV_INFO(cportinfo) = NULL;
8034 		/* Add here differentiation for device attached or not */
8035 		cportinfo->cport_dev_type = SATA_DTYPE_NONE;
8036 		mutex_exit(&cportinfo->cport_mutex);
8037 		if (sdinfo != NULL)
8038 			kmem_free(sdinfo, sizeof (sata_drive_info_t));
8039 		return (SATA_SUCCESS);
8040 	}
8041 
8042 	cportinfo->cport_state |= SATA_STATE_READY;
8043 	cportinfo->cport_dev_type = sata_device->satadev_type;
8044 	sdinfo = SATA_CPORTINFO_DRV_INFO(cportinfo);
8045 
8046 	/*
8047 	 * If we are re-probing the port, there may be
8048 	 * sata_drive_info structure attached
8049 	 * (or sata_pm_info, if PMult is supported).
8050 	 */
8051 	if (sata_device->satadev_type == SATA_DTYPE_NONE) {
8052 		/*
8053 		 * There is no device, so remove device info structure,
8054 		 * if necessary. Direct attached drive only!
8055 		 */
8056 		SATA_CPORTINFO_DRV_INFO(cportinfo) = NULL;
8057 		cportinfo->cport_dev_type = SATA_DTYPE_NONE;
8058 		if (sdinfo != NULL) {
8059 			kmem_free(sdinfo, sizeof (sata_drive_info_t));
8060 			sata_log(sata_hba_inst, CE_WARN,
8061 			    "SATA device detached "
8062 			    "from port %d", cportinfo->cport_addr.cport);
8063 		}
8064 		mutex_exit(&cportinfo->cport_mutex);
8065 		return (SATA_SUCCESS);
8066 	}
8067 
8068 	if (sata_device->satadev_type != SATA_DTYPE_PMULT) {
8069 		if (sdinfo == NULL) {
8070 			/*
8071 			 * There is some device attached, but there is
8072 			 * no sata_drive_info structure - allocate one
8073 			 */
8074 			mutex_exit(&cportinfo->cport_mutex);
8075 			sdinfo = kmem_zalloc(
8076 			    sizeof (sata_drive_info_t), KM_SLEEP);
8077 			mutex_enter(&cportinfo->cport_mutex);
8078 			/*
8079 			 * Recheck, that the port state did not change when we
8080 			 * released mutex.
8081 			 */
8082 			if (cportinfo->cport_state & SATA_STATE_READY) {
8083 				SATA_CPORTINFO_DRV_INFO(cportinfo) = sdinfo;
8084 				sdinfo->satadrv_addr = cportinfo->cport_addr;
8085 				sdinfo->satadrv_addr.qual = SATA_ADDR_DCPORT;
8086 				sdinfo->satadrv_type = SATA_DTYPE_UNKNOWN;
8087 				sdinfo->satadrv_state = SATA_STATE_UNKNOWN;
8088 			} else {
8089 				/*
8090 				 * Port is not in ready state, we
8091 				 * cannot attach a device.
8092 				 */
8093 				mutex_exit(&cportinfo->cport_mutex);
8094 				kmem_free(sdinfo, sizeof (sata_drive_info_t));
8095 				return (SATA_SUCCESS);
8096 			}
8097 			/*
8098 			 * Since we are adding device, presumably new one,
8099 			 * indicate that it  should be initalized,
8100 			 * as well as some internal framework states).
8101 			 */
8102 			init_device = B_TRUE;
8103 		}
8104 		cportinfo->cport_dev_type = SATA_DTYPE_UNKNOWN;
8105 		sata_device->satadev_addr.qual = sdinfo->satadrv_addr.qual;
8106 	} else {
8107 		/*
8108 		 * The device is a port multiplier - not handled now.
8109 		 */
8110 		cportinfo->cport_dev_type = SATA_DTYPE_UNKNOWN;
8111 		mutex_exit(&cportinfo->cport_mutex);
8112 		return (SATA_SUCCESS);
8113 	}
8114 	mutex_exit(&cportinfo->cport_mutex);
8115 	/*
8116 	 * Figure out what kind of device we are really
8117 	 * dealing with.
8118 	 */
8119 	rval = sata_probe_device(sata_hba_inst, sata_device);
8120 
8121 	if (rval == SATA_SUCCESS) {
8122 		/*
8123 		 * If we are dealing with the same type of a device as before,
8124 		 * restore its settings flags.
8125 		 */
8126 		if (sata_device->satadev_type == prev_device_type)
8127 			sdinfo->satadrv_settings = prev_device_settings;
8128 
8129 		/* Set initial device features, if necessary */
8130 		if (init_device == B_TRUE) {
8131 			rval = sata_initialize_device(sata_hba_inst, sdinfo);
8132 		}
8133 		if (rval == SATA_SUCCESS)
8134 			return (rval);
8135 	}
8136 
8137 	if (retry) {
8138 		clock_t cur_time = ddi_get_lbolt();
8139 		/*
8140 		 * A device was not successfully identified or initialized.
8141 		 * Track retry time for device identification.
8142 		 */
8143 		if ((cur_time - start_time) <
8144 		    drv_usectohz(SATA_DEV_IDENTIFY_TIMEOUT)) {
8145 			/* sleep for a while */
8146 			delay(drv_usectohz(SATA_DEV_IDENTIFY_RETRY_DELAY));
8147 			goto retry_probe;
8148 		}
8149 	}
8150 	return (rval);
8151 }
8152 
8153 /*
8154  * Initialize device
8155  * Specified device is initialized to a default state.
8156  * At this point only read cache and UDMA modes are set here.
8157  * Write cache mode should be set when a disk is configured.
8158  *
8159  * Only SATA disks are initialized for now.
8160  *
8161  * Returns SATA_SUCCESS if all device features are set successfully,
8162  * SATA_FAILURE otherwise
8163  */
8164 static int
8165 sata_initialize_device(sata_hba_inst_t *sata_hba_inst,
8166     sata_drive_info_t *sdinfo)
8167 {
8168 
8169 	sata_save_drive_settings(sdinfo);
8170 
8171 	sdinfo->satadrv_settings |= SATA_DEV_READ_AHEAD;
8172 
8173 	sata_init_write_cache_mode(sdinfo);
8174 
8175 	return (sata_set_drive_features(sata_hba_inst, sdinfo, 0));
8176 }
8177 
8178 
8179 /*
8180  * Initialize write cache mode.
8181  *
8182  * The default write cache setting is provided by sata_write_cache
8183  * static variable:
8184  * 1 - enable
8185  * 0 - disable
8186  * any other value - current drive setting
8187  *
8188  * In the future, it may be overridden by the
8189  * disk-write-cache-enable property setting, if it is defined.
8190  * Returns SATA_SUCCESS if all device features are set successfully,
8191  * SATA_FAILURE otherwise.
8192  */
8193 static void
8194 sata_init_write_cache_mode(sata_drive_info_t *sdinfo)
8195 {
8196 	if (sata_write_cache == 1)
8197 		sdinfo->satadrv_settings |= SATA_DEV_WRITE_CACHE;
8198 	else if (sata_write_cache == 0)
8199 		sdinfo->satadrv_settings &= ~SATA_DEV_WRITE_CACHE;
8200 	/*
8201 	 * When sata_write_cache value is not 0 or 1,
8202 	 * a current setting of the drive's write cache is used.
8203 	 */
8204 }
8205 
8206 
8207 /*
8208  * Validate sata address.
8209  * Specified cport, pmport and qualifier has to match
8210  * passed sata_scsi configuration info.
8211  * The presence of an attached device is not verified.
8212  *
8213  * Returns 0 when address is valid, -1 otherwise.
8214  */
8215 static int
8216 sata_validate_sata_address(sata_hba_inst_t *sata_hba_inst, int cport,
8217 	int pmport, int qual)
8218 {
8219 	if (qual == SATA_ADDR_DCPORT && pmport != 0)
8220 		goto invalid_address;
8221 	if (cport >= SATA_NUM_CPORTS(sata_hba_inst))
8222 		goto invalid_address;
8223 	if ((qual == SATA_ADDR_DPMPORT || qual == SATA_ADDR_PMPORT) &&
8224 	    ((SATA_CPORT_DEV_TYPE(sata_hba_inst, cport) != SATA_DTYPE_PMULT) ||
8225 	    (SATA_PMULT_INFO(sata_hba_inst, cport) == NULL) ||
8226 	    (pmport >= SATA_NUM_PMPORTS(sata_hba_inst, cport))))
8227 		goto invalid_address;
8228 
8229 	return (0);
8230 
8231 invalid_address:
8232 	return (-1);
8233 
8234 }
8235 
8236 /*
8237  * Validate scsi address
8238  * SCSI target address is translated into SATA cport/pmport and compared
8239  * with a controller port/device configuration. LUN has to be 0.
8240  * Returns 0 if a scsi target refers to an attached device,
8241  * returns 1 if address is valid but device is not attached,
8242  * returns -1 if bad address or device is of an unsupported type.
8243  * Upon return sata_device argument is set.
8244  */
8245 static int
8246 sata_validate_scsi_address(sata_hba_inst_t *sata_hba_inst,
8247 	struct scsi_address *ap, sata_device_t *sata_device)
8248 {
8249 	int cport, pmport, qual, rval;
8250 
8251 	rval = -1;	/* Invalid address */
8252 	if (ap->a_lun != 0)
8253 		goto out;
8254 
8255 	qual = SCSI_TO_SATA_ADDR_QUAL(ap->a_target);
8256 	cport = SCSI_TO_SATA_CPORT(ap->a_target);
8257 	pmport = SCSI_TO_SATA_PMPORT(ap->a_target);
8258 
8259 	if (qual != SATA_ADDR_DCPORT && qual != SATA_ADDR_DPMPORT)
8260 		goto out;
8261 
8262 	if (sata_validate_sata_address(sata_hba_inst, cport, pmport, qual) ==
8263 	    0) {
8264 
8265 		sata_cport_info_t *cportinfo;
8266 		sata_pmult_info_t *pmultinfo;
8267 		sata_drive_info_t *sdinfo = NULL;
8268 
8269 		rval = 1;	/* Valid sata address */
8270 
8271 		cportinfo = SATA_CPORT_INFO(sata_hba_inst, cport);
8272 		if (qual == SATA_ADDR_DCPORT) {
8273 			if (cportinfo == NULL ||
8274 			    cportinfo->cport_dev_type == SATA_DTYPE_NONE)
8275 				goto out;
8276 
8277 			if (cportinfo->cport_dev_type == SATA_DTYPE_PMULT ||
8278 			    (cportinfo->cport_dev_type &
8279 			    SATA_VALID_DEV_TYPE) == 0) {
8280 				rval = -1;
8281 				goto out;
8282 			}
8283 			sdinfo = SATA_CPORTINFO_DRV_INFO(cportinfo);
8284 
8285 		} else if (qual == SATA_ADDR_DPMPORT) {
8286 			pmultinfo = SATA_CPORTINFO_PMULT_INFO(cportinfo);
8287 			if (pmultinfo == NULL) {
8288 				rval = -1;
8289 				goto out;
8290 			}
8291 			if (SATA_PMPORT_INFO(sata_hba_inst, cport, pmport) ==
8292 			    NULL ||
8293 			    SATA_PMPORT_DEV_TYPE(sata_hba_inst, cport,
8294 			    pmport) == SATA_DTYPE_NONE)
8295 				goto out;
8296 
8297 			sdinfo = SATA_PMPORT_DRV_INFO(sata_hba_inst, cport,
8298 			    pmport);
8299 		} else {
8300 			rval = -1;
8301 			goto out;
8302 		}
8303 		if ((sdinfo == NULL) ||
8304 		    (sdinfo->satadrv_type & SATA_VALID_DEV_TYPE) == 0)
8305 			goto out;
8306 
8307 		sata_device->satadev_type = sdinfo->satadrv_type;
8308 		sata_device->satadev_addr.qual = qual;
8309 		sata_device->satadev_addr.cport = cport;
8310 		sata_device->satadev_addr.pmport = pmport;
8311 		sata_device->satadev_rev = SATA_DEVICE_REV_1;
8312 		return (0);
8313 	}
8314 out:
8315 	if (rval == 1) {
8316 		SATADBG2(SATA_DBG_SCSI_IF, sata_hba_inst,
8317 		    "sata_validate_scsi_address: no valid target %x lun %x",
8318 		    ap->a_target, ap->a_lun);
8319 	}
8320 	return (rval);
8321 }
8322 
8323 /*
8324  * Find dip corresponding to passed device number
8325  *
8326  * Returns NULL if invalid device number is passed or device cannot be found,
8327  * Returns dip is device is found.
8328  */
8329 static dev_info_t *
8330 sata_devt_to_devinfo(dev_t dev)
8331 {
8332 	dev_info_t *dip;
8333 #ifndef __lock_lint
8334 	struct devnames *dnp;
8335 	major_t major = getmajor(dev);
8336 	int instance = SATA_MINOR2INSTANCE(getminor(dev));
8337 
8338 	if (major >= devcnt)
8339 		return (NULL);
8340 
8341 	dnp = &devnamesp[major];
8342 	LOCK_DEV_OPS(&(dnp->dn_lock));
8343 	dip = dnp->dn_head;
8344 	while (dip && (ddi_get_instance(dip) != instance)) {
8345 		dip = ddi_get_next(dip);
8346 	}
8347 	UNLOCK_DEV_OPS(&(dnp->dn_lock));
8348 #endif
8349 
8350 	return (dip);
8351 }
8352 
8353 
8354 /*
8355  * Probe device.
8356  * This function issues Identify Device command and initializes local
8357  * sata_drive_info structure if the device can be identified.
8358  * The device type is determined by examining Identify Device
8359  * command response.
8360  * If the sata_hba_inst has linked drive info structure for this
8361  * device address, the Identify Device data is stored into sata_drive_info
8362  * structure linked to the port info structure.
8363  *
8364  * sata_device has to refer to the valid sata port(s) for HBA described
8365  * by sata_hba_inst structure.
8366  *
8367  * Returns: SATA_SUCCESS if device type was successfully probed and port-linked
8368  *	drive info structure was updated;
8369  * 	SATA_FAILURE if there is no device, or device was not probed
8370  *	successully.
8371  * If a device cannot be identified, sata_device's dev_state and dev_type
8372  * fields are set to unknown.
8373  * There are no retries in this function. Any retries should be managed by
8374  * the caller.
8375  */
8376 
8377 
8378 static int
8379 sata_probe_device(sata_hba_inst_t *sata_hba_inst, sata_device_t *sata_device)
8380 {
8381 	sata_drive_info_t *sdinfo;
8382 	sata_drive_info_t new_sdinfo;	/* local drive info struct */
8383 	int rval;
8384 
8385 	ASSERT((SATA_CPORT_STATE(sata_hba_inst,
8386 	    sata_device->satadev_addr.cport) &
8387 	    (SATA_STATE_PROBED | SATA_STATE_READY)) != 0);
8388 
8389 	sata_device->satadev_type = SATA_DTYPE_NONE;
8390 
8391 	mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst,
8392 	    sata_device->satadev_addr.cport)));
8393 
8394 	/* Get pointer to port-linked sata device info structure */
8395 	sdinfo = sata_get_device_info(sata_hba_inst, sata_device);
8396 	if (sdinfo != NULL) {
8397 		sdinfo->satadrv_state &=
8398 		    ~(SATA_STATE_PROBED | SATA_STATE_READY);
8399 		sdinfo->satadrv_state |= SATA_STATE_PROBING;
8400 	} else {
8401 		/* No device to probe */
8402 		mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst,
8403 		    sata_device->satadev_addr.cport)));
8404 		sata_device->satadev_type = SATA_DTYPE_NONE;
8405 		sata_device->satadev_state = SATA_STATE_UNKNOWN;
8406 		return (SATA_FAILURE);
8407 	}
8408 	/*
8409 	 * Need to issue both types of identify device command and
8410 	 * determine device type by examining retreived data/status.
8411 	 * First, ATA Identify Device.
8412 	 */
8413 	bzero(&new_sdinfo, sizeof (sata_drive_info_t));
8414 	new_sdinfo.satadrv_addr = sata_device->satadev_addr;
8415 	mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst,
8416 	    sata_device->satadev_addr.cport)));
8417 	new_sdinfo.satadrv_type = SATA_DTYPE_ATADISK;
8418 	rval = sata_identify_device(sata_hba_inst, &new_sdinfo);
8419 	if (rval == 1) {
8420 		/* We may try to check for ATAPI device */
8421 		if (SATA_FEATURES(sata_hba_inst) & SATA_CTLF_ATAPI) {
8422 			/*
8423 			 * HBA supports ATAPI - try to issue Identify Packet
8424 			 * Device command.
8425 			 */
8426 			new_sdinfo.satadrv_type = SATA_DTYPE_ATAPICD;
8427 			rval = sata_identify_device(sata_hba_inst, &new_sdinfo);
8428 		}
8429 	}
8430 	if (rval == -1)
8431 		goto failure;
8432 	if (rval == 0) {
8433 		/*
8434 		 * Got something responding to ATA Identify Device or to
8435 		 * Identify Packet Device cmd.
8436 		 */
8437 		sata_device->satadev_type = new_sdinfo.satadrv_type;
8438 
8439 		/* save device info, if possible */
8440 		mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst,
8441 		    sata_device->satadev_addr.cport)));
8442 		sdinfo = sata_get_device_info(sata_hba_inst, sata_device);
8443 		if (sdinfo == NULL) {
8444 			mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst,
8445 			    sata_device->satadev_addr.cport)));
8446 			return (SATA_FAILURE);
8447 		}
8448 		/*
8449 		 * Copy drive info into the port-linked drive info structure.
8450 		 */
8451 		*sdinfo = new_sdinfo;
8452 		sdinfo->satadrv_state &= ~SATA_STATE_PROBING;
8453 		sdinfo->satadrv_state |= SATA_STATE_PROBED;
8454 		if (sata_device->satadev_addr.qual == SATA_ADDR_DCPORT)
8455 			SATA_CPORT_DEV_TYPE(sata_hba_inst,
8456 			    sata_device->satadev_addr.cport) =
8457 			    sdinfo->satadrv_type;
8458 		else /* SATA_ADDR_DPMPORT */
8459 			SATA_PMPORT_DEV_TYPE(sata_hba_inst,
8460 			    sata_device->satadev_addr.cport,
8461 			    sata_device->satadev_addr.pmport) =
8462 			    sdinfo->satadrv_type;
8463 		mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst,
8464 		    sata_device->satadev_addr.cport)));
8465 		return (SATA_SUCCESS);
8466 	}
8467 
8468 failure:
8469 	/*
8470 	 * Looks like we cannot determine the device type.
8471 	 */
8472 	mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst,
8473 	    sata_device->satadev_addr.cport)));
8474 	sdinfo = sata_get_device_info(sata_hba_inst, sata_device);
8475 	if (sdinfo != NULL) {
8476 		sata_device->satadev_type = SATA_DTYPE_UNKNOWN;
8477 		sdinfo->satadrv_type = SATA_DTYPE_UNKNOWN;
8478 		sdinfo->satadrv_state &= ~SATA_STATE_PROBING;
8479 		sdinfo->satadrv_state = SATA_STATE_PROBED;
8480 		if (sata_device->satadev_addr.qual == SATA_ADDR_DCPORT)
8481 			SATA_CPORT_DEV_TYPE(sata_hba_inst,
8482 			    sata_device->satadev_addr.cport) =
8483 			    SATA_DTYPE_UNKNOWN;
8484 		else {
8485 			/* SATA_ADDR_DPMPORT */
8486 			if ((SATA_PMULT_INFO(sata_hba_inst,
8487 			    sata_device->satadev_addr.cport) != NULL) &&
8488 			    (SATA_PMPORT_INFO(sata_hba_inst,
8489 			    sata_device->satadev_addr.cport,
8490 			    sata_device->satadev_addr.pmport) != NULL))
8491 				SATA_PMPORT_DEV_TYPE(sata_hba_inst,
8492 				    sata_device->satadev_addr.cport,
8493 				    sata_device->satadev_addr.pmport) =
8494 				    SATA_DTYPE_UNKNOWN;
8495 		}
8496 	}
8497 	mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst,
8498 	    sata_device->satadev_addr.cport)));
8499 	return (SATA_FAILURE);
8500 }
8501 
8502 
8503 /*
8504  * Get pointer to sata_drive_info structure.
8505  *
8506  * The sata_device has to contain address (cport, pmport and qualifier) for
8507  * specified sata_scsi structure.
8508  *
8509  * Returns NULL if device address is not valid for this HBA configuration.
8510  * Otherwise, returns a pointer to sata_drive_info structure.
8511  *
8512  * This function should be called with a port mutex held.
8513  */
8514 static sata_drive_info_t *
8515 sata_get_device_info(sata_hba_inst_t *sata_hba_inst,
8516     sata_device_t *sata_device)
8517 {
8518 	uint8_t cport = sata_device->satadev_addr.cport;
8519 	uint8_t pmport = sata_device->satadev_addr.pmport;
8520 	uint8_t qual = sata_device->satadev_addr.qual;
8521 
8522 	if (cport >= SATA_NUM_CPORTS(sata_hba_inst))
8523 		return (NULL);
8524 
8525 	if (!(SATA_CPORT_STATE(sata_hba_inst, cport) &
8526 	    (SATA_STATE_PROBED | SATA_STATE_READY)))
8527 		/* Port not probed yet */
8528 		return (NULL);
8529 
8530 	if (SATA_CPORT_DEV_TYPE(sata_hba_inst, cport) == SATA_DTYPE_NONE)
8531 		return (NULL);
8532 
8533 	if (qual == SATA_ADDR_DCPORT) {
8534 		/* Request for a device on a controller port */
8535 		if (SATA_CPORT_DEV_TYPE(sata_hba_inst, cport) ==
8536 		    SATA_DTYPE_PMULT)
8537 			/* Port multiplier attached */
8538 			return (NULL);
8539 		return (SATA_CPORT_DRV_INFO(sata_hba_inst, cport));
8540 	}
8541 	if (qual == SATA_ADDR_DPMPORT) {
8542 		if (SATA_CPORT_DEV_TYPE(sata_hba_inst, cport) !=
8543 		    SATA_DTYPE_PMULT)
8544 			return (NULL);
8545 
8546 		if (pmport > SATA_NUM_PMPORTS(sata_hba_inst, cport))
8547 			return (NULL);
8548 
8549 		return (SATA_PMPORT_DRV_INFO(sata_hba_inst, cport, pmport));
8550 	}
8551 
8552 	/* we should not get here */
8553 	return (NULL);
8554 }
8555 
8556 
8557 /*
8558  * sata_identify_device.
8559  * Send Identify Device command to SATA HBA driver.
8560  * If command executes successfully, update sata_drive_info structure pointed
8561  * to by sdinfo argument, including Identify Device data.
8562  * If command fails, invalidate data in sata_drive_info.
8563  *
8564  * Cannot be called from interrupt level.
8565  *
8566  * Returns:
8567  * 0 if device was identified as a supported device,
8568  * 1 if device was not idenitfied but identify attempt could be retried,
8569  * -1if device was not idenitfied and identify attempt should not be retried.
8570  */
8571 static int
8572 sata_identify_device(sata_hba_inst_t *sata_hba_inst,
8573     sata_drive_info_t *sdinfo)
8574 {
8575 	uint16_t cfg_word;
8576 	int rval;
8577 	int i;
8578 
8579 	/* fetch device identify data */
8580 	if ((rval = sata_fetch_device_identify_data(
8581 	    sata_hba_inst, sdinfo)) != 0)
8582 		goto fail_unknown;
8583 
8584 	cfg_word = sdinfo->satadrv_id.ai_config;
8585 	if (sdinfo->satadrv_type == SATA_DTYPE_ATADISK &&
8586 	    (cfg_word & SATA_ATA_TYPE_MASK) != SATA_ATA_TYPE) {
8587 		/* Change device type to reflect Identify Device data */
8588 		if (((cfg_word & SATA_ATAPI_TYPE_MASK) ==
8589 		    SATA_ATAPI_TYPE) &&
8590 		    ((cfg_word & SATA_ATAPI_ID_DEV_TYPE) ==
8591 		    SATA_ATAPI_CDROM_DEV)) {
8592 			sdinfo->satadrv_type = SATA_DTYPE_ATAPICD;
8593 		} else {
8594 			sdinfo->satadrv_type = SATA_DTYPE_UNKNOWN;
8595 		}
8596 	} else if (sdinfo->satadrv_type == SATA_DTYPE_ATAPICD &&
8597 	    (((cfg_word & SATA_ATAPI_TYPE_MASK) != SATA_ATAPI_TYPE) ||
8598 	    ((cfg_word & SATA_ATAPI_ID_DEV_TYPE) != SATA_ATAPI_CDROM_DEV))) {
8599 		/* Change device type to reflect Identify Device data ! */
8600 		if ((sdinfo->satadrv_id.ai_config & SATA_ATA_TYPE_MASK) ==
8601 		    SATA_ATA_TYPE) {
8602 			sdinfo->satadrv_type = SATA_DTYPE_ATADISK;
8603 		} else {
8604 			sdinfo->satadrv_type = SATA_DTYPE_UNKNOWN;
8605 		}
8606 	}
8607 	if (sdinfo->satadrv_type == SATA_DTYPE_ATADISK) {
8608 		if (sdinfo->satadrv_capacity == 0) {
8609 			/* Non-LBA disk. Too bad... */
8610 			sata_log(sata_hba_inst, CE_WARN,
8611 			    "SATA disk device at port %d does not support LBA",
8612 			    sdinfo->satadrv_addr.cport);
8613 			rval = -1;
8614 			goto fail_unknown;
8615 		}
8616 	}
8617 	/* Check for Ultra DMA modes 6 through 0 being supported */
8618 	for (i = 6; i >= 0; --i) {
8619 		if (sdinfo->satadrv_id.ai_ultradma & (1 << i))
8620 			break;
8621 	}
8622 	/*
8623 	 * At least UDMA 4 mode has to be supported. If mode 4 or
8624 	 * higher are not supported by the device, fail this
8625 	 * device.
8626 	 */
8627 	if (i < 4) {
8628 		/* No required Ultra DMA mode supported */
8629 		sata_log(sata_hba_inst, CE_WARN,
8630 		    "SATA disk device at port %d does not support UDMA "
8631 		    "mode 4 or higher", sdinfo->satadrv_addr.cport);
8632 		SATA_LOG_D((sata_hba_inst, CE_WARN,
8633 		    "mode 4 or higher required, %d supported", i));
8634 		rval = -1;
8635 		goto fail_unknown;
8636 	}
8637 
8638 	return (0);
8639 
8640 fail_unknown:
8641 	/* Invalidate sata_drive_info ? */
8642 	sdinfo->satadrv_type = SATA_DTYPE_UNKNOWN;
8643 	sdinfo->satadrv_state = SATA_STATE_UNKNOWN;
8644 	return (rval);
8645 }
8646 
8647 /*
8648  * Log/display device information
8649  */
8650 static void
8651 sata_show_drive_info(sata_hba_inst_t *sata_hba_inst,
8652     sata_drive_info_t *sdinfo)
8653 {
8654 	int valid_version;
8655 	char msg_buf[MAXPATHLEN];
8656 
8657 	/* Show HBA path */
8658 	(void) ddi_pathname(SATA_DIP(sata_hba_inst), msg_buf);
8659 
8660 	cmn_err(CE_CONT, "?%s :\n", msg_buf);
8661 
8662 	if (sdinfo->satadrv_type == SATA_DTYPE_UNKNOWN) {
8663 		(void) sprintf(msg_buf,
8664 		    "Unsupported SATA device type (cfg 0x%x) at ",
8665 		    sdinfo->satadrv_id.ai_config);
8666 	} else {
8667 		(void) sprintf(msg_buf, "SATA %s device at",
8668 		    sdinfo->satadrv_type == SATA_DTYPE_ATADISK ?
8669 		    "disk":"CD/DVD (ATAPI)");
8670 	}
8671 	if (sdinfo->satadrv_addr.qual == SATA_ADDR_DCPORT)
8672 		cmn_err(CE_CONT, "?\t%s port %d\n",
8673 		    msg_buf, sdinfo->satadrv_addr.cport);
8674 	else
8675 		cmn_err(CE_CONT, "?\t%s port %d pmport %d\n",
8676 		    msg_buf, sdinfo->satadrv_addr.cport,
8677 		    sdinfo->satadrv_addr.pmport);
8678 
8679 	bcopy(&sdinfo->satadrv_id.ai_model, msg_buf,
8680 	    sizeof (sdinfo->satadrv_id.ai_model));
8681 	swab(msg_buf, msg_buf, sizeof (sdinfo->satadrv_id.ai_model));
8682 	msg_buf[sizeof (sdinfo->satadrv_id.ai_model)] = '\0';
8683 	cmn_err(CE_CONT, "?\tmodel %s\n", msg_buf);
8684 
8685 	bcopy(&sdinfo->satadrv_id.ai_fw, msg_buf,
8686 	    sizeof (sdinfo->satadrv_id.ai_fw));
8687 	swab(msg_buf, msg_buf, sizeof (sdinfo->satadrv_id.ai_fw));
8688 	msg_buf[sizeof (sdinfo->satadrv_id.ai_fw)] = '\0';
8689 	cmn_err(CE_CONT, "?\tfirmware %s\n", msg_buf);
8690 
8691 	bcopy(&sdinfo->satadrv_id.ai_drvser, msg_buf,
8692 	    sizeof (sdinfo->satadrv_id.ai_drvser));
8693 	swab(msg_buf, msg_buf, sizeof (sdinfo->satadrv_id.ai_drvser));
8694 	msg_buf[sizeof (sdinfo->satadrv_id.ai_drvser)] = '\0';
8695 	cmn_err(CE_CONT, "?\tserial number %s\n", msg_buf);
8696 
8697 #ifdef SATA_DEBUG
8698 	if (sdinfo->satadrv_id.ai_majorversion != 0 &&
8699 	    sdinfo->satadrv_id.ai_majorversion != 0xffff) {
8700 		int i;
8701 		for (i = 14; i >= 2; i--) {
8702 			if (sdinfo->satadrv_id.ai_majorversion & (1 << i)) {
8703 				valid_version = i;
8704 				break;
8705 			}
8706 		}
8707 		cmn_err(CE_CONT,
8708 		    "?\tATA/ATAPI-%d supported, majver 0x%x minver 0x%x\n",
8709 		    valid_version,
8710 		    sdinfo->satadrv_id.ai_majorversion,
8711 		    sdinfo->satadrv_id.ai_minorversion);
8712 	}
8713 #endif
8714 	/* Log some info */
8715 	cmn_err(CE_CONT, "?\tsupported features:\n");
8716 	msg_buf[0] = '\0';
8717 	if (sdinfo->satadrv_features_support & SATA_DEV_F_LBA48)
8718 		(void) strlcat(msg_buf, "48-bit LBA", MAXPATHLEN);
8719 	else if (sdinfo->satadrv_features_support & SATA_DEV_F_LBA28)
8720 		(void) strlcat(msg_buf, "28-bit LBA", MAXPATHLEN);
8721 	if (sdinfo->satadrv_features_support & SATA_DEV_F_DMA)
8722 		(void) strlcat(msg_buf, ", DMA", MAXPATHLEN);
8723 	if (sdinfo->satadrv_features_support & SATA_DEV_F_NCQ)
8724 		(void) strlcat(msg_buf, ", Native Command Queueing",
8725 		    MAXPATHLEN);
8726 	if (sdinfo->satadrv_features_support & SATA_DEV_F_TCQ)
8727 		(void) strlcat(msg_buf, ", Legacy Tagged Queuing", MAXPATHLEN);
8728 	if ((sdinfo->satadrv_id.ai_cmdset82 & SATA_SMART_SUPPORTED) &&
8729 	    (sdinfo->satadrv_id.ai_features85 & SATA_SMART_ENABLED))
8730 		(void) strlcat(msg_buf, ", SMART", MAXPATHLEN);
8731 	if ((sdinfo->satadrv_id.ai_cmdset84 & SATA_SMART_SELF_TEST_SUPPORTED) &&
8732 	    (sdinfo->satadrv_id.ai_features87 & SATA_SMART_SELF_TEST_SUPPORTED))
8733 		(void) strlcat(msg_buf, ", SMART self-test", MAXPATHLEN);
8734 	cmn_err(CE_CONT, "?\t %s\n", msg_buf);
8735 	if (sdinfo->satadrv_features_support & SATA_DEV_F_SATA2)
8736 		cmn_err(CE_CONT, "?\tSATA1 & SATA2 compatible\n");
8737 	else if (sdinfo->satadrv_features_support & SATA_DEV_F_SATA1)
8738 		cmn_err(CE_CONT, "?\tSATA1 compatible\n");
8739 	if (sdinfo->satadrv_features_support & SATA_DEV_F_TCQ) {
8740 		cmn_err(CE_CONT, "?\tQueue depth %d\n",
8741 			sdinfo->satadrv_queue_depth);
8742 	}
8743 
8744 	if (sdinfo->satadrv_features_support &
8745 		(SATA_DEV_F_TCQ | SATA_DEV_F_NCQ)) {
8746 		(void) sprintf(msg_buf, "\tqueue depth %d\n",
8747 				sdinfo->satadrv_queue_depth);
8748 		cmn_err(CE_CONT, "?%s", msg_buf);
8749 	}
8750 
8751 #ifdef __i386
8752 	(void) sprintf(msg_buf, "\tcapacity = %llu sectors\n",
8753 		sdinfo->satadrv_capacity);
8754 #else
8755 	(void) sprintf(msg_buf, "\tcapacity = %lu sectors\n",
8756 		sdinfo->satadrv_capacity);
8757 #endif
8758 	cmn_err(CE_CONT, "?%s", msg_buf);
8759 }
8760 
8761 
8762 /*
8763  * sata_save_drive_settings extracts current setting of the device and stores
8764  * it for future reference, in case the device setup would need to be restored
8765  * after the device reset.
8766  *
8767  * At the moment only read ahead and write cache settings are saved, if the
8768  * device supports these features at all.
8769  */
8770 static void
8771 sata_save_drive_settings(sata_drive_info_t *sdinfo)
8772 {
8773 	if (!(sdinfo->satadrv_id.ai_cmdset82 & SATA_LOOK_AHEAD) &&
8774 	    !(sdinfo->satadrv_id.ai_cmdset82 & SATA_WRITE_CACHE)) {
8775 		/* None of the features is supported - do nothing */
8776 		return;
8777 	}
8778 
8779 	/* Current setting of Read Ahead (and Read Cache) */
8780 	if (sdinfo->satadrv_id.ai_features85 & SATA_LOOK_AHEAD)
8781 		sdinfo->satadrv_settings |= SATA_DEV_READ_AHEAD;
8782 	else
8783 		sdinfo->satadrv_settings &= ~SATA_DEV_READ_AHEAD;
8784 
8785 	/* Current setting of Write Cache */
8786 	if (sdinfo->satadrv_id.ai_features85 & SATA_WRITE_CACHE)
8787 		sdinfo->satadrv_settings |= SATA_DEV_WRITE_CACHE;
8788 	else
8789 		sdinfo->satadrv_settings &= ~SATA_DEV_WRITE_CACHE;
8790 }
8791 
8792 
8793 /*
8794  * sata_check_capacity function determines a disk capacity
8795  * and addressing mode (LBA28/LBA48) by examining a disk identify device data.
8796  *
8797  * NOTE: CHS mode is not supported! If a device does not support LBA,
8798  * this function is not called.
8799  *
8800  * Returns device capacity in number of blocks, i.e. largest addressable LBA+1
8801  */
8802 static uint64_t
8803 sata_check_capacity(sata_drive_info_t *sdinfo)
8804 {
8805 	uint64_t capacity = 0;
8806 	int i;
8807 
8808 	if (sdinfo->satadrv_type != SATA_DTYPE_ATADISK ||
8809 	    !sdinfo->satadrv_id.ai_cap & SATA_LBA_SUPPORT)
8810 		/* Capacity valid only for LBA-addressable disk devices */
8811 		return (0);
8812 
8813 	if ((sdinfo->satadrv_id.ai_validinfo & SATA_VALIDINFO_88) &&
8814 	    (sdinfo->satadrv_id.ai_cmdset83 & SATA_EXT48) &&
8815 	    (sdinfo->satadrv_id.ai_features86 & SATA_EXT48)) {
8816 		/* LBA48 mode supported and enabled */
8817 		sdinfo->satadrv_features_support |= SATA_DEV_F_LBA48 |
8818 		    SATA_DEV_F_LBA28;
8819 		for (i = 3;  i >= 0;  --i) {
8820 			capacity <<= 16;
8821 			capacity += sdinfo->satadrv_id.ai_addrsecxt[i];
8822 		}
8823 	} else {
8824 		capacity = sdinfo->satadrv_id.ai_addrsec[1];
8825 		capacity <<= 16;
8826 		capacity += sdinfo->satadrv_id.ai_addrsec[0];
8827 		if (capacity >= 0x1000000)
8828 			/* LBA28 mode */
8829 			sdinfo->satadrv_features_support |= SATA_DEV_F_LBA28;
8830 	}
8831 	return (capacity);
8832 }
8833 
8834 
8835 /*
8836  * Allocate consistent buffer for DMA transfer
8837  *
8838  * Cannot be called from interrupt level or with mutex held - it may sleep.
8839  *
8840  * Returns pointer to allocated buffer structure, or NULL if allocation failed.
8841  */
8842 static struct buf *
8843 sata_alloc_local_buffer(sata_pkt_txlate_t *spx, int len)
8844 {
8845 	struct scsi_address ap;
8846 	struct buf *bp;
8847 	ddi_dma_attr_t	cur_dma_attr;
8848 
8849 	ASSERT(spx->txlt_sata_pkt != NULL);
8850 	ap.a_hba_tran = spx->txlt_sata_hba_inst->satahba_scsi_tran;
8851 	ap.a_target = SATA_TO_SCSI_TARGET(
8852 	    spx->txlt_sata_pkt->satapkt_device.satadev_addr.cport,
8853 	    spx->txlt_sata_pkt->satapkt_device.satadev_addr.pmport,
8854 	    spx->txlt_sata_pkt->satapkt_device.satadev_addr.qual);
8855 	ap.a_lun = 0;
8856 
8857 	bp = scsi_alloc_consistent_buf(&ap, NULL, len,
8858 		B_READ, SLEEP_FUNC, NULL);
8859 
8860 	if (bp != NULL) {
8861 		/* Allocate DMA resources for this buffer */
8862 		spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp = bp;
8863 		/*
8864 		 * We use a local version of the dma_attr, to account
8865 		 * for a device addressing limitations.
8866 		 * sata_adjust_dma_attr() will handle sdinfo == NULL which
8867 		 * will cause dma attributes to be adjusted to a lowest
8868 		 * acceptable level.
8869 		 */
8870 		sata_adjust_dma_attr(NULL,
8871 		    SATA_DMA_ATTR(spx->txlt_sata_hba_inst), &cur_dma_attr);
8872 
8873 		if (sata_dma_buf_setup(spx, PKT_CONSISTENT,
8874 		    SLEEP_FUNC, NULL, &cur_dma_attr) != DDI_SUCCESS) {
8875 			scsi_free_consistent_buf(bp);
8876 			spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp = NULL;
8877 			bp = NULL;
8878 		}
8879 	}
8880 	return (bp);
8881 }
8882 
8883 /*
8884  * Release local buffer (consistent buffer for DMA transfer) allocated
8885  * via sata_alloc_local_buffer().
8886  */
8887 static void
8888 sata_free_local_buffer(sata_pkt_txlate_t *spx)
8889 {
8890 	ASSERT(spx->txlt_sata_pkt != NULL);
8891 	ASSERT(spx->txlt_dma_cookie_list != NULL);
8892 	ASSERT(spx->txlt_dma_cookie_list_len != 0);
8893 	ASSERT(spx->txlt_buf_dma_handle != NULL);
8894 	ASSERT(spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp != NULL);
8895 
8896 	spx->txlt_sata_pkt->satapkt_cmd.satacmd_num_dma_cookies = 0;
8897 	spx->txlt_sata_pkt->satapkt_cmd.satacmd_dma_cookie_list = NULL;
8898 
8899 	/* Free DMA resources */
8900 	(void) ddi_dma_unbind_handle(spx->txlt_buf_dma_handle);
8901 	ddi_dma_free_handle(&spx->txlt_buf_dma_handle);
8902 	spx->txlt_buf_dma_handle = 0;
8903 
8904 	if (spx->txlt_dma_cookie_list != &spx->txlt_dma_cookie) {
8905 		kmem_free(spx->txlt_dma_cookie_list,
8906 		    spx->txlt_dma_cookie_list_len * sizeof (ddi_dma_cookie_t));
8907 		spx->txlt_dma_cookie_list = NULL;
8908 		spx->txlt_dma_cookie_list_len = 0;
8909 	}
8910 	/* Free buffer */
8911 	scsi_free_consistent_buf(spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp);
8912 }
8913 
8914 
8915 
8916 
8917 /*
8918  * Allocate sata_pkt
8919  * Pkt structure version and embedded strcutures version are initialized.
8920  * sata_pkt and sata_pkt_txlate structures are cross-linked.
8921  *
8922  * Since this may be called in interrupt context by sata_scsi_init_pkt,
8923  * callback argument determines if it can sleep or not.
8924  * Hence, it should not be called from interrupt context.
8925  *
8926  * If successful, non-NULL pointer to a sata pkt is returned.
8927  * Upon failure, NULL pointer is returned.
8928  */
8929 static sata_pkt_t *
8930 sata_pkt_alloc(sata_pkt_txlate_t *spx, int (*callback)(caddr_t))
8931 {
8932 	sata_pkt_t *spkt;
8933 	int kmsflag;
8934 
8935 	kmsflag = (callback == SLEEP_FUNC) ? KM_SLEEP : KM_NOSLEEP;
8936 	spkt = kmem_zalloc(sizeof (sata_pkt_t), kmsflag);
8937 	if (spkt == NULL) {
8938 		SATA_LOG_D((spx->txlt_sata_hba_inst, CE_WARN,
8939 		    "sata_pkt_alloc: failed"));
8940 		return (NULL);
8941 	}
8942 	spkt->satapkt_rev = SATA_PKT_REV;
8943 	spkt->satapkt_cmd.satacmd_rev = SATA_CMD_REV;
8944 	spkt->satapkt_device.satadev_rev = SATA_DEVICE_REV;
8945 	spkt->satapkt_framework_private = spx;
8946 	spx->txlt_sata_pkt = spkt;
8947 	return (spkt);
8948 }
8949 
8950 /*
8951  * Free sata pkt allocated via sata_pkt_alloc()
8952  */
8953 static void
8954 sata_pkt_free(sata_pkt_txlate_t *spx)
8955 {
8956 	ASSERT(spx->txlt_sata_pkt != NULL);
8957 	ASSERT(spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp == NULL);
8958 	kmem_free(spx->txlt_sata_pkt, sizeof (sata_pkt_t));
8959 	spx->txlt_sata_pkt = NULL;
8960 }
8961 
8962 
8963 /*
8964  * Adjust DMA attributes.
8965  * SCSI cmds block count is up to 24 bits, SATA cmd block count vary
8966  * from 8 bits to 16 bits, depending on a command being used.
8967  * Limiting max block count arbitrarily to 256 for all read/write
8968  * commands may affects performance, so check both the device and
8969  * controller capability before adjusting dma attributes.
8970  * For ATAPI CD/DVD dma granularity has to be adjusted as well,
8971  * because these devices support block size of 2k rather
8972  * then 512 bytes.
8973  */
8974 void
8975 sata_adjust_dma_attr(sata_drive_info_t *sdinfo, ddi_dma_attr_t *dma_attr,
8976     ddi_dma_attr_t *adj_dma_attr)
8977 {
8978 	uint32_t count_max;
8979 
8980 	/* Copy original attributes */
8981 	*adj_dma_attr = *dma_attr;
8982 
8983 	/*
8984 	 * Things to consider: device addressing capability,
8985 	 * "excessive" controller DMA capabilities.
8986 	 * If a device is being probed/initialized, there are
8987 	 * no device info - use default limits then.
8988 	 */
8989 	if (sdinfo == NULL) {
8990 		count_max = dma_attr->dma_attr_granular * 0x100;
8991 		if (dma_attr->dma_attr_count_max > count_max)
8992 			adj_dma_attr->dma_attr_count_max = count_max;
8993 		if (dma_attr->dma_attr_maxxfer > count_max)
8994 			adj_dma_attr->dma_attr_maxxfer = count_max;
8995 		return;
8996 	}
8997 	if (sdinfo->satadrv_type == SATA_DTYPE_ATAPICD) {
8998 		/* arbitrarily modify controller dma granularity */
8999 		adj_dma_attr->dma_attr_granular = SATA_ATAPI_SECTOR_SIZE;
9000 	}
9001 
9002 	if (sdinfo->satadrv_features_support & (SATA_DEV_F_LBA48)) {
9003 		/*
9004 		 * 16-bit sector count may be used - we rely on
9005 		 * the assumption that only read and write cmds
9006 		 * will request more than 256 sectors worth of data
9007 		 */
9008 		count_max = adj_dma_attr->dma_attr_granular * 0x10000;
9009 	} else {
9010 		/*
9011 		 * 8-bit sector count will be used - default limits
9012 		 * for dma attributes
9013 		 */
9014 		count_max = adj_dma_attr->dma_attr_granular * 0x100;
9015 	}
9016 
9017 
9018 	/*
9019 	 * Adjust controler dma attributes, if necessary
9020 	 */
9021 	if (dma_attr->dma_attr_count_max > count_max)
9022 		adj_dma_attr->dma_attr_count_max = count_max;
9023 	if (dma_attr->dma_attr_maxxfer > count_max)
9024 		adj_dma_attr->dma_attr_maxxfer = count_max;
9025 }
9026 
9027 
9028 /*
9029  * Allocate DMA resources for the buffer
9030  * This function handles initial DMA resource allocation as well as
9031  * DMA window shift and may be called repeatedly for the same DMA window
9032  * until all DMA cookies in the DMA window are processed.
9033  * To guarantee that there is always a coherent set of cookies to process
9034  * by SATA HBA driver (observing alignment, device granularity, etc.),
9035  * the number of slots for DMA cookies is equal to lesser of  a number of
9036  * cookies in a DMA window and a max number of scatter/gather entries.
9037  *
9038  * Returns DDI_SUCCESS upon successful operation.
9039  * Return failure code of a failing command or DDI_FAILURE when
9040  * internal cleanup failed.
9041  */
9042 static int
9043 sata_dma_buf_setup(sata_pkt_txlate_t *spx, int flags,
9044     int (*callback)(caddr_t), caddr_t arg,
9045     ddi_dma_attr_t *cur_dma_attr)
9046 {
9047 	int	rval;
9048 	off_t	offset;
9049 	size_t	size;
9050 	int	max_sg_len, req_len, i;
9051 	uint_t	dma_flags;
9052 	struct buf	*bp;
9053 	uint64_t	cur_txfer_len;
9054 
9055 
9056 	ASSERT(spx->txlt_sata_pkt != NULL);
9057 	bp = spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp;
9058 	ASSERT(bp != NULL);
9059 
9060 
9061 	if (spx->txlt_buf_dma_handle == NULL) {
9062 		/*
9063 		 * No DMA resources allocated so far - this is a first call
9064 		 * for this sata pkt.
9065 		 */
9066 		rval = ddi_dma_alloc_handle(SATA_DIP(spx->txlt_sata_hba_inst),
9067 		    cur_dma_attr, callback, arg, &spx->txlt_buf_dma_handle);
9068 
9069 		if (rval != DDI_SUCCESS) {
9070 			SATA_LOG_D((spx->txlt_sata_hba_inst, CE_WARN,
9071 			    "sata_dma_buf_setup: no buf DMA resources %x",
9072 			    rval));
9073 			return (rval);
9074 		}
9075 
9076 		if (bp->b_flags & B_READ)
9077 			dma_flags = DDI_DMA_READ;
9078 		else
9079 			dma_flags = DDI_DMA_WRITE;
9080 
9081 		if (flags & PKT_CONSISTENT)
9082 			dma_flags |= DDI_DMA_CONSISTENT;
9083 
9084 		if (flags & PKT_DMA_PARTIAL)
9085 			dma_flags |= DDI_DMA_PARTIAL;
9086 
9087 		/*
9088 		 * Check buffer alignment and size against dma attributes
9089 		 * Consider dma_attr_align only. There may be requests
9090 		 * with the size lower then device granularity, but they
9091 		 * will not read/write from/to the device, so no adjustment
9092 		 * is necessary. The dma_attr_minxfer theoretically should
9093 		 * be considered, but no HBA driver is checking it.
9094 		 */
9095 		if (IS_P2ALIGNED(bp->b_un.b_addr,
9096 		    cur_dma_attr->dma_attr_align)) {
9097 			rval = ddi_dma_buf_bind_handle(
9098 					spx->txlt_buf_dma_handle,
9099 					bp, dma_flags, callback, arg,
9100 					&spx->txlt_dma_cookie,
9101 					&spx->txlt_curwin_num_dma_cookies);
9102 		} else { /* Buffer is not aligned */
9103 
9104 			int	(*ddicallback)(caddr_t);
9105 			size_t	bufsz;
9106 
9107 			/* Check id sleeping is allowed */
9108 			ddicallback = (callback == NULL_FUNC) ?
9109 			    DDI_DMA_DONTWAIT : DDI_DMA_SLEEP;
9110 
9111 			SATADBG2(SATA_DBG_DMA_SETUP, spx->txlt_sata_hba_inst,
9112 				"mis-aligned buffer: addr=0x%p, cnt=%lu",
9113 				(void *)bp->b_un.b_addr, bp->b_bcount);
9114 
9115 			if (bp->b_flags & (B_PAGEIO|B_PHYS))
9116 				/*
9117 				 * CPU will need to access data in the buffer
9118 				 * (for copying) so map it.
9119 				 */
9120 				bp_mapin(bp);
9121 
9122 			ASSERT(spx->txlt_tmp_buf == NULL);
9123 
9124 			/* Buffer may be padded by ddi_dma_mem_alloc()! */
9125 			rval = ddi_dma_mem_alloc(
9126 				spx->txlt_buf_dma_handle,
9127 				bp->b_bcount,
9128 				&sata_acc_attr,
9129 				DDI_DMA_STREAMING,
9130 				ddicallback, NULL,
9131 				&spx->txlt_tmp_buf,
9132 				&bufsz,
9133 				&spx->txlt_tmp_buf_handle);
9134 
9135 			if (rval != DDI_SUCCESS) {
9136 				/* DMA mapping failed */
9137 				(void) ddi_dma_free_handle(
9138 				    &spx->txlt_buf_dma_handle);
9139 				spx->txlt_buf_dma_handle = NULL;
9140 #ifdef SATA_DEBUG
9141 				mbuffail_count++;
9142 #endif
9143 				SATADBG1(SATA_DBG_DMA_SETUP,
9144 				    spx->txlt_sata_hba_inst,
9145 				    "sata_dma_buf_setup: "
9146 				    "buf dma mem alloc failed %x\n", rval);
9147 				return (rval);
9148 			}
9149 			ASSERT(IS_P2ALIGNED(spx->txlt_tmp_buf,
9150 			    cur_dma_attr->dma_attr_align));
9151 
9152 #ifdef SATA_DEBUG
9153 			mbuf_count++;
9154 
9155 			if (bp->b_bcount != bufsz)
9156 				/*
9157 				 * This will require special handling, because
9158 				 * DMA cookies will be based on the temporary
9159 				 * buffer size, not the original buffer
9160 				 * b_bcount, so the residue may have to
9161 				 * be counted differently.
9162 				 */
9163 				SATADBG2(SATA_DBG_DMA_SETUP,
9164 				    spx->txlt_sata_hba_inst,
9165 				    "sata_dma_buf_setup: bp size %x != "
9166 				    "bufsz %x\n", bp->b_bcount, bufsz);
9167 #endif
9168 			if (dma_flags & DDI_DMA_WRITE) {
9169 				/*
9170 				 * Write operation - copy data into
9171 				 * an aligned temporary buffer. Buffer will be
9172 				 * synced for device by ddi_dma_addr_bind_handle
9173 				 */
9174 				bcopy(bp->b_un.b_addr, spx->txlt_tmp_buf,
9175 				    bp->b_bcount);
9176 			}
9177 
9178 			rval = ddi_dma_addr_bind_handle(
9179 				spx->txlt_buf_dma_handle,
9180 				NULL,
9181 				spx->txlt_tmp_buf,
9182 				bufsz, dma_flags, ddicallback, 0,
9183 				&spx->txlt_dma_cookie,
9184 				&spx->txlt_curwin_num_dma_cookies);
9185 		}
9186 
9187 		switch (rval) {
9188 		case DDI_DMA_PARTIAL_MAP:
9189 			SATADBG1(SATA_DBG_DMA_SETUP, spx->txlt_sata_hba_inst,
9190 			    "sata_dma_buf_setup: DMA Partial Map\n", NULL);
9191 			/*
9192 			 * Partial DMA mapping.
9193 			 * Retrieve number of DMA windows for this request.
9194 			 */
9195 			if (ddi_dma_numwin(spx->txlt_buf_dma_handle,
9196 			    &spx->txlt_num_dma_win) != DDI_SUCCESS) {
9197 				if (spx->txlt_tmp_buf != NULL) {
9198 					ddi_dma_mem_free(
9199 					    &spx->txlt_tmp_buf_handle);
9200 					spx->txlt_tmp_buf = NULL;
9201 				}
9202 				(void) ddi_dma_unbind_handle(
9203 				    spx->txlt_buf_dma_handle);
9204 				(void) ddi_dma_free_handle(
9205 				    &spx->txlt_buf_dma_handle);
9206 				spx->txlt_buf_dma_handle = NULL;
9207 				SATA_LOG_D((spx->txlt_sata_hba_inst, CE_WARN,
9208 				    "sata_dma_buf_setup: numwin failed\n"));
9209 				return (DDI_FAILURE);
9210 			}
9211 			SATADBG2(SATA_DBG_DMA_SETUP,
9212 			    spx->txlt_sata_hba_inst,
9213 			    "sata_dma_buf_setup: windows: %d, cookies: %d\n",
9214 			    spx->txlt_num_dma_win,
9215 			    spx->txlt_curwin_num_dma_cookies);
9216 			spx->txlt_cur_dma_win = 0;
9217 			break;
9218 
9219 		case DDI_DMA_MAPPED:
9220 			/* DMA fully mapped */
9221 			spx->txlt_num_dma_win = 1;
9222 			spx->txlt_cur_dma_win = 0;
9223 			SATADBG1(SATA_DBG_DMA_SETUP,
9224 			    spx->txlt_sata_hba_inst,
9225 			    "sata_dma_buf_setup: windows: 1 "
9226 			    "cookies: %d\n", spx->txlt_curwin_num_dma_cookies);
9227 			break;
9228 
9229 		default:
9230 			/* DMA mapping failed */
9231 			if (spx->txlt_tmp_buf != NULL) {
9232 				ddi_dma_mem_free(
9233 				    &spx->txlt_tmp_buf_handle);
9234 				spx->txlt_tmp_buf = NULL;
9235 			}
9236 			(void) ddi_dma_free_handle(&spx->txlt_buf_dma_handle);
9237 			spx->txlt_buf_dma_handle = NULL;
9238 			SATA_LOG_D((spx->txlt_sata_hba_inst, CE_WARN,
9239 			    "sata_dma_buf_setup: buf dma handle binding "
9240 			    "failed %x\n", rval));
9241 			return (rval);
9242 		}
9243 		spx->txlt_curwin_processed_dma_cookies = 0;
9244 		spx->txlt_dma_cookie_list = NULL;
9245 	} else {
9246 		/*
9247 		 * DMA setup is reused. Check if we need to process more
9248 		 * cookies in current window, or to get next window, if any.
9249 		 */
9250 
9251 		ASSERT(spx->txlt_curwin_processed_dma_cookies <=
9252 		    spx->txlt_curwin_num_dma_cookies);
9253 
9254 		if (spx->txlt_curwin_processed_dma_cookies ==
9255 		    spx->txlt_curwin_num_dma_cookies) {
9256 			/*
9257 			 * All cookies from current DMA window were processed.
9258 			 * Get next DMA window.
9259 			 */
9260 			spx->txlt_cur_dma_win++;
9261 			if (spx->txlt_cur_dma_win < spx->txlt_num_dma_win) {
9262 				(void) ddi_dma_getwin(spx->txlt_buf_dma_handle,
9263 				    spx->txlt_cur_dma_win, &offset, &size,
9264 				    &spx->txlt_dma_cookie,
9265 				    &spx->txlt_curwin_num_dma_cookies);
9266 				spx->txlt_curwin_processed_dma_cookies = 0;
9267 			} else {
9268 				/* No more windows! End of request! */
9269 				/* What to do? - panic for now */
9270 				ASSERT(spx->txlt_cur_dma_win >=
9271 				    spx->txlt_num_dma_win);
9272 
9273 				spx->txlt_curwin_num_dma_cookies = 0;
9274 				spx->txlt_curwin_processed_dma_cookies = 0;
9275 				spx->txlt_sata_pkt->
9276 				    satapkt_cmd.satacmd_num_dma_cookies = 0;
9277 				return (DDI_SUCCESS);
9278 			}
9279 		}
9280 	}
9281 	/* There better be at least one DMA cookie outstanding */
9282 	ASSERT((spx->txlt_curwin_num_dma_cookies -
9283 	    spx->txlt_curwin_processed_dma_cookies) > 0);
9284 
9285 	if (spx->txlt_dma_cookie_list == &spx->txlt_dma_cookie) {
9286 		/* The default cookie slot was used in previous run */
9287 		ASSERT(spx->txlt_curwin_processed_dma_cookies == 0);
9288 		spx->txlt_dma_cookie_list = NULL;
9289 		spx->txlt_dma_cookie_list_len = 0;
9290 	}
9291 	if (spx->txlt_curwin_processed_dma_cookies == 0) {
9292 		/*
9293 		 * Processing a new DMA window - set-up dma cookies list.
9294 		 * We may reuse previously allocated cookie array if it is
9295 		 * possible.
9296 		 */
9297 		if (spx->txlt_dma_cookie_list != NULL &&
9298 		    spx->txlt_dma_cookie_list_len <
9299 		    spx->txlt_curwin_num_dma_cookies) {
9300 			/*
9301 			 * New DMA window contains more cookies than
9302 			 * the previous one. We need larger cookie list - free
9303 			 * the old one.
9304 			 */
9305 			(void) kmem_free(spx->txlt_dma_cookie_list,
9306 			    spx->txlt_dma_cookie_list_len *
9307 			    sizeof (ddi_dma_cookie_t));
9308 			spx->txlt_dma_cookie_list = NULL;
9309 			spx->txlt_dma_cookie_list_len = 0;
9310 		}
9311 		if (spx->txlt_dma_cookie_list == NULL) {
9312 			/*
9313 			 * Calculate lesser of number of cookies in this
9314 			 * DMA window and number of s/g entries.
9315 			 */
9316 			max_sg_len = cur_dma_attr->dma_attr_sgllen;
9317 			req_len = MIN(max_sg_len,
9318 			    spx->txlt_curwin_num_dma_cookies);
9319 
9320 			/* Allocate new dma cookie array if necessary */
9321 			if (req_len == 1) {
9322 				/* Only one cookie - no need for a list */
9323 				spx->txlt_dma_cookie_list =
9324 				    &spx->txlt_dma_cookie;
9325 				spx->txlt_dma_cookie_list_len = 1;
9326 			} else {
9327 				/*
9328 				 * More than one cookie - try to allocate space.
9329 				 */
9330 				spx->txlt_dma_cookie_list = kmem_zalloc(
9331 				    sizeof (ddi_dma_cookie_t) * req_len,
9332 				    callback == NULL_FUNC ? KM_NOSLEEP :
9333 				    KM_SLEEP);
9334 				if (spx->txlt_dma_cookie_list == NULL) {
9335 					SATADBG1(SATA_DBG_DMA_SETUP,
9336 					    spx->txlt_sata_hba_inst,
9337 					    "sata_dma_buf_setup: cookie list "
9338 					    "allocation failed\n", NULL);
9339 					/*
9340 					 * We could not allocate space for
9341 					 * neccessary number of dma cookies in
9342 					 * this window, so we fail this request.
9343 					 * Next invocation would try again to
9344 					 * allocate space for cookie list.
9345 					 * Note:Packet residue was not modified.
9346 					 */
9347 					return (DDI_DMA_NORESOURCES);
9348 				} else {
9349 					spx->txlt_dma_cookie_list_len = req_len;
9350 				}
9351 			}
9352 		}
9353 		/*
9354 		 * Fetch DMA cookies into cookie list in sata_pkt_txlate.
9355 		 * First cookie was already fetched.
9356 		 */
9357 		*(&spx->txlt_dma_cookie_list[0]) = spx->txlt_dma_cookie;
9358 		cur_txfer_len =
9359 		    (uint64_t)spx->txlt_dma_cookie_list[0].dmac_size;
9360 		spx->txlt_sata_pkt->satapkt_cmd.satacmd_num_dma_cookies = 1;
9361 		spx->txlt_curwin_processed_dma_cookies++;
9362 		for (i = 1; (i < spx->txlt_dma_cookie_list_len) &&
9363 		    (i < spx->txlt_curwin_num_dma_cookies); i++) {
9364 			ddi_dma_nextcookie(spx->txlt_buf_dma_handle,
9365 			&spx->txlt_dma_cookie_list[i]);
9366 			cur_txfer_len +=
9367 			    (uint64_t)spx->txlt_dma_cookie_list[i].dmac_size;
9368 			spx->txlt_curwin_processed_dma_cookies++;
9369 			spx->txlt_sata_pkt->
9370 			    satapkt_cmd.satacmd_num_dma_cookies += 1;
9371 		}
9372 	} else {
9373 		SATADBG2(SATA_DBG_DMA_SETUP, spx->txlt_sata_hba_inst,
9374 		    "sata_dma_buf_setup: sliding within DMA window, "
9375 		    "cur cookie %d, total cookies %d\n",
9376 		    spx->txlt_curwin_processed_dma_cookies,
9377 		    spx->txlt_curwin_num_dma_cookies);
9378 
9379 		/*
9380 		 * Not all cookies from the current dma window were used because
9381 		 * of s/g limitation.
9382 		 * There is no need to re-size the list - it was set at
9383 		 * optimal size, or only default entry is used (s/g = 1).
9384 		 */
9385 		if (spx->txlt_dma_cookie_list == NULL) {
9386 			spx->txlt_dma_cookie_list = &spx->txlt_dma_cookie;
9387 			spx->txlt_dma_cookie_list_len = 1;
9388 		}
9389 		/*
9390 		 * Since we are processing remaining cookies in a DMA window,
9391 		 * there may be less of them than the number of entries in the
9392 		 * current dma cookie list.
9393 		 */
9394 		req_len = MIN(spx->txlt_dma_cookie_list_len,
9395 		    (spx->txlt_curwin_num_dma_cookies -
9396 		    spx->txlt_curwin_processed_dma_cookies));
9397 
9398 		/* Fetch the next batch of cookies */
9399 		for (i = 0, cur_txfer_len = 0; i < req_len; i++) {
9400 			ddi_dma_nextcookie(spx->txlt_buf_dma_handle,
9401 			&spx->txlt_dma_cookie_list[i]);
9402 			cur_txfer_len +=
9403 			    (uint64_t)spx->txlt_dma_cookie_list[i].dmac_size;
9404 			spx->txlt_sata_pkt->
9405 			    satapkt_cmd.satacmd_num_dma_cookies++;
9406 			spx->txlt_curwin_processed_dma_cookies++;
9407 		}
9408 	}
9409 
9410 	ASSERT(spx->txlt_sata_pkt->satapkt_cmd.satacmd_num_dma_cookies > 0);
9411 
9412 	/* Point sata_cmd to the cookie list */
9413 	spx->txlt_sata_pkt->satapkt_cmd.satacmd_dma_cookie_list =
9414 	    &spx->txlt_dma_cookie_list[0];
9415 
9416 	/* Remember number of DMA cookies passed in sata packet */
9417 	spx->txlt_num_dma_cookies =
9418 	    spx->txlt_sata_pkt->satapkt_cmd.satacmd_num_dma_cookies;
9419 
9420 	ASSERT(cur_txfer_len != 0);
9421 	if (cur_txfer_len <= bp->b_bcount)
9422 		spx->txlt_total_residue -= cur_txfer_len;
9423 	else {
9424 		/*
9425 		 * Temporary DMA buffer has been padded by
9426 		 * ddi_dma_mem_alloc()!
9427 		 * This requires special handling, because DMA cookies are
9428 		 * based on the temporary buffer size, not the b_bcount,
9429 		 * and we have extra bytes to transfer - but the packet
9430 		 * residue has to stay correct because we will copy only
9431 		 * the requested number of bytes.
9432 		 */
9433 		spx->txlt_total_residue -= bp->b_bcount;
9434 	}
9435 
9436 	return (DDI_SUCCESS);
9437 }
9438 
9439 
9440 /*
9441  * Fetch Device Identify data.
9442  * Send DEVICE IDENTIFY command to a device and get the device identify data.
9443  * The device_info structure has to be set to device type (for selecting proper
9444  * device identify command).
9445  *
9446  * Returns:
9447  * 0 if cmd succeeded
9448  * 1 if cmd was rejected and could be retried,
9449  * -1if cmd failed and should not be retried (port error)
9450  *
9451  * Cannot be called in an interrupt context.
9452  */
9453 
9454 static int
9455 sata_fetch_device_identify_data(sata_hba_inst_t *sata_hba_inst,
9456     sata_drive_info_t *sdinfo)
9457 {
9458 	struct buf *bp;
9459 	sata_pkt_t *spkt;
9460 	sata_cmd_t *scmd;
9461 	sata_pkt_txlate_t *spx;
9462 	int rval;
9463 
9464 	spx = kmem_zalloc(sizeof (sata_pkt_txlate_t), KM_SLEEP);
9465 	spx->txlt_sata_hba_inst = sata_hba_inst;
9466 	spx->txlt_scsi_pkt = NULL;		/* No scsi pkt involved */
9467 	spkt = sata_pkt_alloc(spx, SLEEP_FUNC);
9468 	if (spkt == NULL) {
9469 		kmem_free(spx, sizeof (sata_pkt_txlate_t));
9470 		return (1); /* may retry later */
9471 	}
9472 	/* address is needed now */
9473 	spkt->satapkt_device.satadev_addr = sdinfo->satadrv_addr;
9474 
9475 	/*
9476 	 * Allocate buffer for Identify Data return data
9477 	 */
9478 	bp = sata_alloc_local_buffer(spx, sizeof (sata_id_t));
9479 	if (bp == NULL) {
9480 		sata_pkt_free(spx);
9481 		kmem_free(spx, sizeof (sata_pkt_txlate_t));
9482 		SATA_LOG_D((sata_hba_inst, CE_WARN,
9483 		    "sata_fetch_device_identify_data: "
9484 		    "cannot allocate buffer for ID"));
9485 		return (1); /* may retry later */
9486 	}
9487 
9488 	/* Fill sata_pkt */
9489 	sdinfo->satadrv_state = SATA_STATE_PROBING;
9490 	spkt->satapkt_device.satadev_addr = sdinfo->satadrv_addr;
9491 	spkt->satapkt_op_mode = SATA_OPMODE_SYNCH | SATA_OPMODE_INTERRUPTS;
9492 	/* Synchronous mode, no callback */
9493 	spkt->satapkt_comp = NULL;
9494 	/* Timeout 30s */
9495 	spkt->satapkt_time = sata_default_pkt_time;
9496 
9497 	scmd = &spkt->satapkt_cmd;
9498 	scmd->satacmd_bp = bp;
9499 	scmd->satacmd_flags.sata_data_direction = SATA_DIR_READ;
9500 	scmd->satacmd_flags.sata_ignore_dev_reset = B_TRUE;
9501 
9502 	/* Build Identify Device cmd in the sata_pkt */
9503 	scmd->satacmd_addr_type = 0;		/* N/A */
9504 	scmd->satacmd_sec_count_lsb = 0;	/* N/A */
9505 	scmd->satacmd_lba_low_lsb = 0;		/* N/A */
9506 	scmd->satacmd_lba_mid_lsb = 0;		/* N/A */
9507 	scmd->satacmd_lba_high_lsb = 0;		/* N/A */
9508 	scmd->satacmd_features_reg = 0;		/* N/A */
9509 	scmd->satacmd_device_reg = 0;		/* Always device 0 */
9510 	if (sdinfo->satadrv_type == SATA_DTYPE_ATAPICD) {
9511 		/* Identify Packet Device cmd */
9512 		scmd->satacmd_cmd_reg = SATAC_ID_PACKET_DEVICE;
9513 	} else {
9514 		/* Identify Device cmd - mandatory for all other devices */
9515 		scmd->satacmd_cmd_reg = SATAC_ID_DEVICE;
9516 	}
9517 
9518 	/* Send pkt to SATA HBA driver */
9519 	rval = (*SATA_START_FUNC(sata_hba_inst))(SATA_DIP(sata_hba_inst), spkt);
9520 	if (rval == SATA_TRAN_ACCEPTED &&
9521 	    spkt->satapkt_reason == SATA_PKT_COMPLETED) {
9522 		if ((sdinfo->satadrv_id.ai_config & SATA_INCOMPLETE_DATA) ==
9523 		    SATA_INCOMPLETE_DATA) {
9524 			SATA_LOG_D((sata_hba_inst, CE_WARN,
9525 			    "SATA disk device at port %d - "
9526 			    "partial Identify Data",
9527 			    sdinfo->satadrv_addr.cport));
9528 			rval = 1; /* may retry later */
9529 			goto fail;
9530 		}
9531 		/* Update sata_drive_info */
9532 		rval = ddi_dma_sync(spx->txlt_buf_dma_handle, 0, 0,
9533 			DDI_DMA_SYNC_FORKERNEL);
9534 		ASSERT(rval == DDI_SUCCESS);
9535 		bcopy(bp->b_un.b_addr, &sdinfo->satadrv_id,
9536 		    sizeof (sata_id_t));
9537 
9538 		sdinfo->satadrv_features_support = 0;
9539 		if (sdinfo->satadrv_type == SATA_DTYPE_ATADISK) {
9540 			/*
9541 			 * Retrieve capacity (disks only) and addressing mode
9542 			 */
9543 			sdinfo->satadrv_capacity = sata_check_capacity(sdinfo);
9544 		} else {
9545 			/*
9546 			 * For ATAPI devices one has to issue Get Capacity cmd
9547 			 * (not needed at the moment)
9548 			 */
9549 			sdinfo->satadrv_capacity = 0;
9550 		}
9551 		/* Setup supported features flags */
9552 		if (sdinfo->satadrv_id.ai_cap & SATA_DMA_SUPPORT)
9553 			sdinfo->satadrv_features_support |= SATA_DEV_F_DMA;
9554 
9555 		/* Check for NCQ support */
9556 		if (sdinfo->satadrv_id.ai_satacap != 0 &&
9557 		    sdinfo->satadrv_id.ai_satacap != 0xffff) {
9558 			/* SATA compliance */
9559 			if (sdinfo->satadrv_id.ai_satacap & SATA_NCQ)
9560 				sdinfo->satadrv_features_support |=
9561 				    SATA_DEV_F_NCQ;
9562 			if (sdinfo->satadrv_id.ai_satacap &
9563 			    (SATA_1_SPEED | SATA_2_SPEED)) {
9564 				if (sdinfo->satadrv_id.ai_satacap &
9565 				    SATA_2_SPEED)
9566 					sdinfo->satadrv_features_support |=
9567 					    SATA_DEV_F_SATA2;
9568 				if (sdinfo->satadrv_id.ai_satacap &
9569 				    SATA_1_SPEED)
9570 					sdinfo->satadrv_features_support |=
9571 					    SATA_DEV_F_SATA1;
9572 			} else {
9573 				sdinfo->satadrv_features_support |=
9574 				    SATA_DEV_F_SATA1;
9575 			}
9576 		}
9577 		if ((sdinfo->satadrv_id.ai_cmdset83 & SATA_RW_DMA_QUEUED_CMD) &&
9578 		    (sdinfo->satadrv_id.ai_features86 & SATA_RW_DMA_QUEUED_CMD))
9579 			sdinfo->satadrv_features_support |= SATA_DEV_F_TCQ;
9580 
9581 		sdinfo->satadrv_queue_depth = sdinfo->satadrv_id.ai_qdepth;
9582 		if ((sdinfo->satadrv_features_support & SATA_DEV_F_NCQ) ||
9583 			(sdinfo->satadrv_features_support & SATA_DEV_F_TCQ))
9584 			++sdinfo->satadrv_queue_depth;
9585 		rval = 0;
9586 	} else {
9587 		/*
9588 		 * Woops, no Identify Data.
9589 		 */
9590 		if (rval == SATA_TRAN_BUSY || rval == SATA_TRAN_QUEUE_FULL) {
9591 		    rval = 1; /* may retry later */
9592 		} else if (rval == SATA_TRAN_ACCEPTED) {
9593 			if (spkt->satapkt_reason == SATA_PKT_DEV_ERROR ||
9594 			    spkt->satapkt_reason == SATA_PKT_ABORTED ||
9595 			    spkt->satapkt_reason == SATA_PKT_TIMEOUT ||
9596 			    spkt->satapkt_reason == SATA_PKT_RESET)
9597 				rval = 1; /* may retry later */
9598 			else
9599 				rval = -1;
9600 		} else {
9601 			rval = -1;
9602 		}
9603 	}
9604 fail:
9605 	/* Free allocated resources */
9606 	sata_free_local_buffer(spx);
9607 	spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp = NULL;
9608 	sata_pkt_free(spx);
9609 	kmem_free(spx, sizeof (sata_pkt_txlate_t));
9610 
9611 	return (rval);
9612 }
9613 
9614 
9615 /*
9616  * SATA spec requires that the device supports at least UDMA 4 mode and
9617  * UDMA mode is selected.
9618  * Some devices (bridged devices) may not come-up with default UDMA mode
9619  * set correctly, so this function is setting it.
9620  *
9621  * Returns SATA_SUCCESS if proper UDMA mode is selected.
9622  * Returns SATA_FAILURE if proper UDMA mode could not be selected.
9623  */
9624 static int
9625 sata_set_udma_mode(sata_hba_inst_t *sata_hba_inst, sata_drive_info_t *sdinfo)
9626 {
9627 	sata_pkt_t *spkt;
9628 	sata_cmd_t *scmd;
9629 	sata_pkt_txlate_t *spx;
9630 	int result = SATA_SUCCESS;
9631 	int i, mode;
9632 
9633 	ASSERT(sdinfo != NULL);
9634 	ASSERT(sata_hba_inst != NULL);
9635 
9636 	/* Find highest Ultra DMA mode supported */
9637 	for (mode = 6; mode >= 0; --mode) {
9638 		if (sdinfo->satadrv_id.ai_ultradma & (1 << mode))
9639 			break;
9640 	}
9641 	if (mode < 4)
9642 		return (SATA_FAILURE);
9643 
9644 	/* Find UDMA mode currently selected */
9645 	for (i = 6; i >= 0; --i) {
9646 		if (sdinfo->satadrv_id.ai_ultradma & (1 << (i + 8)))
9647 			break;
9648 	}
9649 
9650 	if (i < mode) {
9651 		/* Set UDMA mode via SET FEATURES COMMAND */
9652 		/* Prepare packet for SET FEATURES COMMAND */
9653 		spx = kmem_zalloc(sizeof (sata_pkt_txlate_t), KM_SLEEP);
9654 		spx->txlt_sata_hba_inst = sata_hba_inst;
9655 		spx->txlt_scsi_pkt = NULL;	/* No scsi pkt involved */
9656 		spkt = sata_pkt_alloc(spx, SLEEP_FUNC);
9657 		if (spkt == NULL) {
9658 			result = SATA_FAILURE;
9659 			goto failure;
9660 		}
9661 		/* Fill sata_pkt */
9662 		spkt->satapkt_device.satadev_addr = sdinfo->satadrv_addr;
9663 		/* Timeout 30s */
9664 		spkt->satapkt_time = sata_default_pkt_time;
9665 		/* Synchronous mode, no callback, interrupts */
9666 		spkt->satapkt_op_mode =
9667 		    SATA_OPMODE_SYNCH | SATA_OPMODE_INTERRUPTS;
9668 		spkt->satapkt_comp = NULL;
9669 		scmd = &spkt->satapkt_cmd;
9670 		scmd->satacmd_flags.sata_data_direction = SATA_DIR_NODATA_XFER;
9671 		scmd->satacmd_flags.sata_ignore_dev_reset = B_TRUE;
9672 		scmd->satacmd_addr_type = 0;
9673 		scmd->satacmd_device_reg = 0;
9674 		scmd->satacmd_status_reg = 0;
9675 		scmd->satacmd_error_reg = 0;
9676 		scmd->satacmd_cmd_reg = SATAC_SET_FEATURES;
9677 		scmd->satacmd_features_reg = SATAC_SF_TRANSFER_MODE;
9678 		scmd->satacmd_sec_count_lsb =
9679 		    SATAC_TRANSFER_MODE_ULTRA_DMA | mode;
9680 
9681 		/* Transfer command to HBA */
9682 		if ((*SATA_START_FUNC(sata_hba_inst))(SATA_DIP(sata_hba_inst),
9683 		    spkt) != SATA_TRAN_ACCEPTED ||
9684 		    spkt->satapkt_reason != SATA_PKT_COMPLETED) {
9685 			/* Pkt execution failed */
9686 			result = SATA_FAILURE;
9687 		}
9688 failure:
9689 		if (result == SATA_FAILURE)
9690 			SATA_LOG_D((sata_hba_inst, CE_WARN,
9691 			    "sata_set_udma_mode: could not set UDMA "
9692 			    "mode %", mode));
9693 
9694 		/* Free allocated resources */
9695 		if (spkt != NULL)
9696 			sata_pkt_free(spx);
9697 		(void) kmem_free(spx, sizeof (sata_pkt_txlate_t));
9698 	}
9699 	return (result);
9700 }
9701 
9702 
9703 /*
9704  * Set device caching mode.
9705  * One of the following operations should be specified:
9706  * SATAC_SF_ENABLE_READ_AHEAD
9707  * SATAC_SF_DISABLE_READ_AHEAD
9708  * SATAC_SF_ENABLE_WRITE_CACHE
9709  * SATAC_SF_DISABLE_WRITE_CACHE
9710  *
9711  * If operation fails, system log messgage is emitted.
9712  * Returns SATA_SUCCESS when the operation succeeds, SATA_FAILURE otherwise.
9713  */
9714 
9715 static int
9716 sata_set_cache_mode(sata_hba_inst_t *sata_hba_inst, sata_drive_info_t *sdinfo,
9717     int cache_op)
9718 {
9719 	sata_pkt_t *spkt;
9720 	sata_cmd_t *scmd;
9721 	sata_pkt_txlate_t *spx;
9722 	int rval = SATA_SUCCESS;
9723 	char *infop;
9724 
9725 	ASSERT(sdinfo != NULL);
9726 	ASSERT(sata_hba_inst != NULL);
9727 	ASSERT(cache_op == SATAC_SF_ENABLE_READ_AHEAD ||
9728 	    cache_op == SATAC_SF_DISABLE_READ_AHEAD ||
9729 	    cache_op == SATAC_SF_ENABLE_WRITE_CACHE ||
9730 	    cache_op == SATAC_SF_DISABLE_WRITE_CACHE);
9731 
9732 
9733 	/* Prepare packet for SET FEATURES COMMAND */
9734 	spx = kmem_zalloc(sizeof (sata_pkt_txlate_t), KM_SLEEP);
9735 	spx->txlt_sata_hba_inst = sata_hba_inst;
9736 	spx->txlt_scsi_pkt = NULL;	/* No scsi pkt involved */
9737 	spkt = sata_pkt_alloc(spx, SLEEP_FUNC);
9738 	if (spkt == NULL) {
9739 		rval = SATA_FAILURE;
9740 		goto failure;
9741 	}
9742 	/* Fill sata_pkt */
9743 	spkt->satapkt_device.satadev_addr = sdinfo->satadrv_addr;
9744 	/* Timeout 30s */
9745 	spkt->satapkt_time = sata_default_pkt_time;
9746 	/* Synchronous mode, no callback, interrupts */
9747 	spkt->satapkt_op_mode =
9748 	    SATA_OPMODE_SYNCH | SATA_OPMODE_INTERRUPTS;
9749 	spkt->satapkt_comp = NULL;
9750 	scmd = &spkt->satapkt_cmd;
9751 	scmd->satacmd_flags.sata_data_direction = SATA_DIR_NODATA_XFER;
9752 	scmd->satacmd_flags.sata_ignore_dev_reset = B_TRUE;
9753 	scmd->satacmd_addr_type = 0;
9754 	scmd->satacmd_device_reg = 0;
9755 	scmd->satacmd_status_reg = 0;
9756 	scmd->satacmd_error_reg = 0;
9757 	scmd->satacmd_cmd_reg = SATAC_SET_FEATURES;
9758 	scmd->satacmd_features_reg = cache_op;
9759 
9760 	/* Transfer command to HBA */
9761 	if (((*SATA_START_FUNC(sata_hba_inst))(
9762 	    SATA_DIP(sata_hba_inst), spkt) != 0) ||
9763 	    (spkt->satapkt_reason != SATA_PKT_COMPLETED)) {
9764 		/* Pkt execution failed */
9765 		switch (cache_op) {
9766 		case SATAC_SF_ENABLE_READ_AHEAD:
9767 			infop = "enabling read ahead failed";
9768 			break;
9769 		case SATAC_SF_DISABLE_READ_AHEAD:
9770 			infop = "disabling read ahead failed";
9771 			break;
9772 		case SATAC_SF_ENABLE_WRITE_CACHE:
9773 			infop = "enabling write cache failed";
9774 			break;
9775 		case SATAC_SF_DISABLE_WRITE_CACHE:
9776 			infop = "disabling write cache failed";
9777 			break;
9778 		}
9779 		SATA_LOG_D((sata_hba_inst, CE_WARN, "%s", infop));
9780 		rval = SATA_FAILURE;
9781 	}
9782 failure:
9783 	/* Free allocated resources */
9784 	if (spkt != NULL)
9785 		sata_pkt_free(spx);
9786 	(void) kmem_free(spx, sizeof (sata_pkt_txlate_t));
9787 	return (rval);
9788 }
9789 
9790 
9791 
9792 /*
9793  * Update port SCR block
9794  */
9795 static void
9796 sata_update_port_scr(sata_port_scr_t *port_scr, sata_device_t *device)
9797 {
9798 	port_scr->sstatus = device->satadev_scr.sstatus;
9799 	port_scr->serror = device->satadev_scr.serror;
9800 	port_scr->scontrol = device->satadev_scr.scontrol;
9801 	port_scr->sactive = device->satadev_scr.sactive;
9802 	port_scr->snotific = device->satadev_scr.snotific;
9803 }
9804 
9805 /*
9806  * Update state and copy port ss* values from passed sata_device structure.
9807  * sata_address is validated - if not valid, nothing is changed in sata_scsi
9808  * configuration struct.
9809  *
9810  * SATA_PSTATE_SHUTDOWN in port state is not reset to 0 by this function
9811  * regardless of the state in device argument.
9812  *
9813  * Port mutex should be held while calling this function.
9814  */
9815 static void
9816 sata_update_port_info(sata_hba_inst_t *sata_hba_inst,
9817 	sata_device_t *sata_device)
9818 {
9819 	ASSERT(mutex_owned(&SATA_CPORT_MUTEX(sata_hba_inst,
9820 	    sata_device->satadev_addr.cport)));
9821 
9822 	if (sata_device->satadev_addr.qual == SATA_ADDR_CPORT ||
9823 	    sata_device->satadev_addr.qual == SATA_ADDR_DCPORT) {
9824 
9825 		sata_cport_info_t *cportinfo;
9826 
9827 		if (SATA_NUM_CPORTS(sata_hba_inst) <=
9828 		    sata_device->satadev_addr.cport)
9829 			return;
9830 
9831 		cportinfo = SATA_CPORT_INFO(sata_hba_inst,
9832 		    sata_device->satadev_addr.cport);
9833 		sata_update_port_scr(&cportinfo->cport_scr, sata_device);
9834 
9835 		/* Preserve SATA_PSTATE_SHUTDOWN flag */
9836 		cportinfo->cport_state &= ~(SATA_PSTATE_PWRON |
9837 		    SATA_PSTATE_PWROFF | SATA_PSTATE_FAILED);
9838 		cportinfo->cport_state |=
9839 		    sata_device->satadev_state & SATA_PSTATE_VALID;
9840 	} else {
9841 		sata_pmport_info_t *pmportinfo;
9842 
9843 		if ((sata_device->satadev_addr.qual != SATA_ADDR_PMPORT) ||
9844 		    (sata_device->satadev_addr.qual != SATA_ADDR_DPMPORT) ||
9845 		    SATA_NUM_PMPORTS(sata_hba_inst,
9846 		    sata_device->satadev_addr.cport) <
9847 		    sata_device->satadev_addr.pmport)
9848 			return;
9849 
9850 		pmportinfo = SATA_PMPORT_INFO(sata_hba_inst,
9851 		    sata_device->satadev_addr.cport,
9852 		    sata_device->satadev_addr.pmport);
9853 		sata_update_port_scr(&pmportinfo->pmport_scr, sata_device);
9854 
9855 		/* Preserve SATA_PSTATE_SHUTDOWN flag */
9856 		pmportinfo->pmport_state &=
9857 		    ~(SATA_PSTATE_PWRON | SATA_PSTATE_PWROFF |
9858 		    SATA_PSTATE_FAILED);
9859 		pmportinfo->pmport_state |=
9860 		    sata_device->satadev_state & SATA_PSTATE_VALID;
9861 	}
9862 }
9863 
9864 
9865 
9866 /*
9867  * Extract SATA port specification from an IOCTL argument.
9868  *
9869  * This function return the port the user land send us as is, unless it
9870  * cannot retrieve port spec, then -1 is returned.
9871  *
9872  * Note: Only cport  - no port multiplier port.
9873  */
9874 static int32_t
9875 sata_get_port_num(sata_hba_inst_t *sata_hba_inst, struct devctl_iocdata *dcp)
9876 {
9877 	int32_t port;
9878 
9879 	/* Extract port number from nvpair in dca structure  */
9880 	if (nvlist_lookup_int32(ndi_dc_get_ap_data(dcp), "port", &port) != 0) {
9881 		SATA_LOG_D((sata_hba_inst, CE_NOTE,
9882 		    "sata_get_port_num: invalid port spec 0x%x in ioctl",
9883 		    port));
9884 		port = -1;
9885 	}
9886 
9887 	return (port);
9888 }
9889 
9890 /*
9891  * Get dev_info_t pointer to the device node pointed to by port argument.
9892  * NOTE: target argument is a value used in ioctls to identify
9893  * the AP - it is not a sata_address.
9894  * It is a combination of cport, pmport and address qualifier, encodded same
9895  * way as a scsi target number.
9896  * At this moment it carries only cport number.
9897  *
9898  * No PMult hotplug support.
9899  *
9900  * Returns dev_info_t pointer if target device was found, NULL otherwise.
9901  */
9902 
9903 static dev_info_t *
9904 sata_get_target_dip(dev_info_t *dip, int32_t port)
9905 {
9906 	dev_info_t	*cdip = NULL;
9907 	int		target, tgt;
9908 	int		ncport;
9909 	int 		circ;
9910 
9911 	ncport = port & SATA_CFGA_CPORT_MASK;
9912 	target = SATA_TO_SCSI_TARGET(ncport, 0, SATA_ADDR_DCPORT);
9913 
9914 	ndi_devi_enter(dip, &circ);
9915 	for (cdip = ddi_get_child(dip); cdip != NULL; ) {
9916 		dev_info_t *next = ddi_get_next_sibling(cdip);
9917 
9918 		tgt = ddi_prop_get_int(DDI_DEV_T_ANY, cdip,
9919 		    DDI_PROP_DONTPASS, "target", -1);
9920 		if (tgt == -1) {
9921 			/*
9922 			 * This is actually an error condition, but not
9923 			 * a fatal one. Just continue the search.
9924 			 */
9925 			cdip = next;
9926 			continue;
9927 		}
9928 
9929 		if (tgt == target)
9930 			break;
9931 
9932 		cdip = next;
9933 	}
9934 	ndi_devi_exit(dip, circ);
9935 
9936 	return (cdip);
9937 }
9938 
9939 
9940 /*
9941  * sata_cfgadm_state:
9942  * Use the sata port state and state of the target node to figure out
9943  * the cfgadm_state.
9944  *
9945  * The port argument is a value with encoded cport,
9946  * pmport and address qualifier, in the same manner as a scsi target number.
9947  * SCSI_TO_SATA_CPORT macro extracts cport number,
9948  * SCSI_TO_SATA_PMPORT extracts pmport number and
9949  * SCSI_TO_SATA_ADDR_QUAL extracts port mulitplier qualifier flag.
9950  *
9951  * For now, support is for cports only - no port multiplier device ports.
9952  */
9953 
9954 static void
9955 sata_cfgadm_state(sata_hba_inst_t *sata_hba_inst, int32_t port,
9956     devctl_ap_state_t *ap_state)
9957 {
9958 	uint16_t	cport;
9959 	int		port_state;
9960 
9961 	/* Cport only */
9962 	cport = SCSI_TO_SATA_CPORT(port);
9963 
9964 	port_state = SATA_CPORT_STATE(sata_hba_inst, cport);
9965 	if (port_state & SATA_PSTATE_SHUTDOWN ||
9966 	    port_state & SATA_PSTATE_FAILED) {
9967 		ap_state->ap_rstate = AP_RSTATE_DISCONNECTED;
9968 		ap_state->ap_ostate = AP_OSTATE_UNCONFIGURED;
9969 		if (port_state & SATA_PSTATE_FAILED)
9970 			ap_state->ap_condition = AP_COND_FAILED;
9971 		else
9972 			ap_state->ap_condition = AP_COND_UNKNOWN;
9973 
9974 		return;
9975 	}
9976 
9977 	/* Need to check pmult device port here as well, when supported */
9978 
9979 	/* Port is enabled and ready */
9980 
9981 	switch (SATA_CPORT_DEV_TYPE(sata_hba_inst, cport)) {
9982 	case SATA_DTYPE_NONE:
9983 	{
9984 		ap_state->ap_ostate = AP_OSTATE_UNCONFIGURED;
9985 		ap_state->ap_condition = AP_COND_OK;
9986 		/* No device attached */
9987 		ap_state->ap_rstate = AP_RSTATE_EMPTY;
9988 		break;
9989 	}
9990 	case SATA_DTYPE_UNKNOWN:
9991 	case SATA_DTYPE_ATAPINONCD:
9992 	case SATA_DTYPE_PMULT:	/* Until PMult is supported */
9993 	case SATA_DTYPE_ATADISK:
9994 	case SATA_DTYPE_ATAPICD:
9995 	{
9996 		dev_info_t *tdip = NULL;
9997 		dev_info_t *dip = NULL;
9998 		int circ;
9999 
10000 		dip = SATA_DIP(sata_hba_inst);
10001 		tdip = sata_get_target_dip(dip, port);
10002 		ap_state->ap_rstate = AP_RSTATE_CONNECTED;
10003 		if (tdip != NULL) {
10004 			ndi_devi_enter(dip, &circ);
10005 			mutex_enter(&(DEVI(tdip)->devi_lock));
10006 			if (DEVI_IS_DEVICE_REMOVED(tdip)) {
10007 				/*
10008 				 * There could be the case where previously
10009 				 * configured and opened device was removed
10010 				 * and unknown device was plugged.
10011 				 * In such case we want to show a device, and
10012 				 * its configured or unconfigured state but
10013 				 * indicate unusable condition untill the
10014 				 * old target node is released and removed.
10015 				 */
10016 				ap_state->ap_condition = AP_COND_UNUSABLE;
10017 			} else {
10018 				ap_state->ap_condition = AP_COND_OK;
10019 			}
10020 			if ((DEVI_IS_DEVICE_OFFLINE(tdip)) ||
10021 			    (DEVI_IS_DEVICE_DOWN(tdip))) {
10022 				ap_state->ap_ostate =
10023 				    AP_OSTATE_UNCONFIGURED;
10024 			} else {
10025 				ap_state->ap_ostate =
10026 				    AP_OSTATE_CONFIGURED;
10027 			}
10028 			mutex_exit(&(DEVI(tdip)->devi_lock));
10029 			ndi_devi_exit(dip, circ);
10030 		} else {
10031 			ap_state->ap_ostate = AP_OSTATE_UNCONFIGURED;
10032 			ap_state->ap_condition = AP_COND_UNKNOWN;
10033 		}
10034 		break;
10035 	}
10036 	default:
10037 		ap_state->ap_rstate = AP_RSTATE_CONNECTED;
10038 		ap_state->ap_ostate = AP_OSTATE_UNCONFIGURED;
10039 		ap_state->ap_condition = AP_COND_UNKNOWN;
10040 		/*
10041 		 * This is actually internal error condition (non fatal),
10042 		 * because we have already checked all defined device types.
10043 		 */
10044 		SATA_LOG_D((sata_hba_inst, CE_WARN,
10045 		    "sata_cfgadm_state: Internal error: "
10046 		    "unknown device type"));
10047 		break;
10048 	}
10049 }
10050 
10051 /*
10052  * Start or terminate the thread, depending on flag arg and current state
10053  */
10054 static void
10055 sata_event_thread_control(int startstop)
10056 {
10057 	static 	int sata_event_thread_terminating = 0;
10058 	static 	int sata_event_thread_starting = 0;
10059 	int i;
10060 
10061 	mutex_enter(&sata_event_mutex);
10062 
10063 	if (startstop == 0 && (sata_event_thread_starting == 1 ||
10064 	    sata_event_thread_terminating == 1)) {
10065 		mutex_exit(&sata_event_mutex);
10066 		return;
10067 	}
10068 	if (startstop == 1 && sata_event_thread_starting == 1) {
10069 		mutex_exit(&sata_event_mutex);
10070 		return;
10071 	}
10072 	if (startstop == 1 && sata_event_thread_terminating == 1) {
10073 		sata_event_thread_starting = 1;
10074 		/* wait til terminate operation completes */
10075 		i = SATA_EVNT_DAEMON_TERM_WAIT/SATA_EVNT_DAEMON_TERM_TIMEOUT;
10076 		while (sata_event_thread_terminating == 1) {
10077 			if (i-- <= 0) {
10078 				sata_event_thread_starting = 0;
10079 				mutex_exit(&sata_event_mutex);
10080 #ifdef SATA_DEBUG
10081 				cmn_err(CE_WARN, "sata_event_thread_control: "
10082 				    "timeout waiting for thread to terminate");
10083 #endif
10084 				return;
10085 			}
10086 			mutex_exit(&sata_event_mutex);
10087 			delay(drv_usectohz(SATA_EVNT_DAEMON_TERM_TIMEOUT));
10088 			mutex_enter(&sata_event_mutex);
10089 		}
10090 	}
10091 	if (startstop == 1) {
10092 		if (sata_event_thread == NULL) {
10093 			sata_event_thread = thread_create(NULL, 0,
10094 			    (void (*)())sata_event_daemon,
10095 			    &sata_hba_list, 0, &p0, TS_RUN, minclsyspri);
10096 		}
10097 		sata_event_thread_starting = 0;
10098 		mutex_exit(&sata_event_mutex);
10099 		return;
10100 	}
10101 
10102 	/*
10103 	 * If we got here, thread may need to be terminated
10104 	 */
10105 	if (sata_event_thread != NULL) {
10106 		int i;
10107 		/* Signal event thread to go away */
10108 		sata_event_thread_terminating = 1;
10109 		sata_event_thread_terminate = 1;
10110 		cv_signal(&sata_event_cv);
10111 		/*
10112 		 * Wait til daemon terminates.
10113 		 */
10114 		i = SATA_EVNT_DAEMON_TERM_WAIT/SATA_EVNT_DAEMON_TERM_TIMEOUT;
10115 		while (sata_event_thread_terminate == 1) {
10116 			mutex_exit(&sata_event_mutex);
10117 			if (i-- <= 0) {
10118 				/* Daemon did not go away !!! */
10119 #ifdef SATA_DEBUG
10120 				cmn_err(CE_WARN, "sata_event_thread_control: "
10121 				    "cannot terminate event daemon thread");
10122 #endif
10123 				mutex_enter(&sata_event_mutex);
10124 				break;
10125 			}
10126 			delay(drv_usectohz(SATA_EVNT_DAEMON_TERM_TIMEOUT));
10127 			mutex_enter(&sata_event_mutex);
10128 		}
10129 		sata_event_thread_terminating = 0;
10130 	}
10131 	ASSERT(sata_event_thread_terminating == 0);
10132 	ASSERT(sata_event_thread_starting == 0);
10133 	mutex_exit(&sata_event_mutex);
10134 }
10135 
10136 
10137 /*
10138  * Log sata message
10139  * dev pathname msg line preceeds the logged message.
10140  */
10141 
10142 static	void
10143 sata_log(sata_hba_inst_t *sata_hba_inst, uint_t level, char *fmt, ...)
10144 {
10145 	char pathname[128];
10146 	dev_info_t *dip;
10147 	va_list ap;
10148 
10149 	mutex_enter(&sata_log_mutex);
10150 
10151 	va_start(ap, fmt);
10152 	(void) vsprintf(sata_log_buf, fmt, ap);
10153 	va_end(ap);
10154 
10155 	if (sata_hba_inst != NULL) {
10156 		dip = SATA_DIP(sata_hba_inst);
10157 		(void) ddi_pathname(dip, pathname);
10158 	} else {
10159 		pathname[0] = 0;
10160 	}
10161 	if (level == CE_CONT) {
10162 		if (sata_debug_flags == 0)
10163 			cmn_err(level, "?%s:\n %s\n", pathname, sata_log_buf);
10164 		else
10165 			cmn_err(level, "%s:\n %s\n", pathname, sata_log_buf);
10166 	} else
10167 		cmn_err(level, "%s:\n %s", pathname, sata_log_buf);
10168 
10169 	mutex_exit(&sata_log_mutex);
10170 }
10171 
10172 
10173 /* ******** Asynchronous HBA events handling & hotplugging support ******** */
10174 
10175 /*
10176  * SATA HBA event notification function.
10177  * Events reported by SATA HBA drivers per HBA instance relate to a change in
10178  * a port and/or device state or a controller itself.
10179  * Events for different addresses/addr types cannot be combined.
10180  * A warning message is generated for each event type.
10181  * Events are not processed by this function, so only the
10182  * event flag(s)is set for an affected entity and the event thread is
10183  * waken up. Event daemon thread processes all events.
10184  *
10185  * NOTE: Since more than one event may be reported at the same time, one
10186  * cannot determine a sequence of events when opposite event are reported, eg.
10187  * LINK_LOST and LINK_ESTABLISHED. Actual port status during event processing
10188  * is taking precedence over reported events, i.e. may cause ignoring some
10189  * events.
10190  */
10191 #define	SATA_EVENT_MAX_MSG_LENGTH	79
10192 
10193 void
10194 sata_hba_event_notify(dev_info_t *dip, sata_device_t *sata_device, int event)
10195 {
10196 	sata_hba_inst_t *sata_hba_inst = NULL;
10197 	sata_address_t *saddr;
10198 	sata_drive_info_t *sdinfo;
10199 	sata_port_stats_t *pstats;
10200 	int cport, pmport;
10201 	char buf1[SATA_EVENT_MAX_MSG_LENGTH + 1];
10202 	char buf2[SATA_EVENT_MAX_MSG_LENGTH + 1];
10203 	char *lcp;
10204 	static char *err_msg_evnt_1 =
10205 	    "sata_hba_event_notify: invalid port event 0x%x ";
10206 	static char *err_msg_evnt_2 =
10207 	    "sata_hba_event_notify: invalid device event 0x%x ";
10208 	int linkevent;
10209 
10210 	/*
10211 	 * There is a possibility that an event will be generated on HBA
10212 	 * that has not completed attachment or is detaching.
10213 	 * HBA driver should prevent this, but just in case it does not,
10214 	 * we need to ignore events for such HBA.
10215 	 */
10216 	mutex_enter(&sata_mutex);
10217 	for (sata_hba_inst = sata_hba_list; sata_hba_inst != NULL;
10218 	    sata_hba_inst = sata_hba_inst->satahba_next) {
10219 		if (SATA_DIP(sata_hba_inst) == dip)
10220 			if (sata_hba_inst->satahba_attached == 1)
10221 				break;
10222 	}
10223 	mutex_exit(&sata_mutex);
10224 	if (sata_hba_inst == NULL)
10225 		/* HBA not attached */
10226 		return;
10227 
10228 	ASSERT(sata_device != NULL);
10229 
10230 	/*
10231 	 * Validate address before - do not proceed with invalid address.
10232 	 */
10233 	saddr = &sata_device->satadev_addr;
10234 	if (saddr->cport >= SATA_NUM_CPORTS(sata_hba_inst))
10235 		return;
10236 	if (saddr->qual == SATA_ADDR_PMPORT ||
10237 	    saddr->qual == SATA_ADDR_DPMPORT)
10238 		/* Port Multiplier not supported yet */
10239 		return;
10240 
10241 	cport = saddr->cport;
10242 	pmport = saddr->pmport;
10243 
10244 	buf1[0] = buf2[0] = '\0';
10245 
10246 	/*
10247 	 * Events refer to devices, ports and controllers - each has
10248 	 * unique address. Events for different addresses cannot be combined.
10249 	 */
10250 	if (saddr->qual & (SATA_ADDR_CPORT | SATA_ADDR_PMPORT)) {
10251 
10252 		mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, cport)));
10253 
10254 		/* qualify this event(s) */
10255 		if ((event & SATA_EVNT_PORT_EVENTS) == 0) {
10256 			/* Invalid event for the device port */
10257 			(void) sprintf(buf2, err_msg_evnt_1,
10258 			    event & SATA_EVNT_PORT_EVENTS);
10259 			mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, cport)));
10260 			goto event_info;
10261 		}
10262 		if (saddr->qual == SATA_ADDR_CPORT) {
10263 			/* Controller's device port event */
10264 
10265 			(SATA_CPORT_INFO(sata_hba_inst, cport))->
10266 			    cport_event_flags |=
10267 			    event & SATA_EVNT_PORT_EVENTS;
10268 			pstats =
10269 			    &(SATA_CPORT_INFO(sata_hba_inst, cport))->
10270 			    cport_stats;
10271 		} else {
10272 			/* Port multiplier's device port event */
10273 			(SATA_PMPORT_INFO(sata_hba_inst, cport, pmport))->
10274 			    pmport_event_flags |=
10275 			    event & SATA_EVNT_PORT_EVENTS;
10276 			pstats =
10277 			    &(SATA_PMPORT_INFO(sata_hba_inst, cport, pmport))->
10278 			    pmport_stats;
10279 		}
10280 
10281 		/*
10282 		 * Add to statistics and log the message. We have to do it
10283 		 * here rather than in the event daemon, because there may be
10284 		 * multiple events occuring before they are processed.
10285 		 */
10286 		linkevent = event &
10287 			(SATA_EVNT_LINK_LOST | SATA_EVNT_LINK_ESTABLISHED);
10288 		if (linkevent) {
10289 			if (linkevent == (SATA_EVNT_LINK_LOST |
10290 			    SATA_EVNT_LINK_ESTABLISHED)) {
10291 				/* This is likely event combination */
10292 				(void) strlcat(buf1, "link lost/established, ",
10293 				    SATA_EVENT_MAX_MSG_LENGTH);
10294 
10295 				if (pstats->link_lost < 0xffffffffffffffffULL)
10296 					pstats->link_lost++;
10297 				if (pstats->link_established <
10298 				    0xffffffffffffffffULL)
10299 					pstats->link_established++;
10300 				linkevent = 0;
10301 			} else if (linkevent & SATA_EVNT_LINK_LOST) {
10302 				(void) strlcat(buf1, "link lost, ",
10303 				    SATA_EVENT_MAX_MSG_LENGTH);
10304 
10305 				if (pstats->link_lost < 0xffffffffffffffffULL)
10306 					pstats->link_lost++;
10307 			} else {
10308 				(void) strlcat(buf1, "link established, ",
10309 				    SATA_EVENT_MAX_MSG_LENGTH);
10310 				if (pstats->link_established <
10311 				    0xffffffffffffffffULL)
10312 					pstats->link_established++;
10313 			}
10314 		}
10315 		if (event & SATA_EVNT_DEVICE_ATTACHED) {
10316 			(void) strlcat(buf1, "device attached, ",
10317 			    SATA_EVENT_MAX_MSG_LENGTH);
10318 			if (pstats->device_attached < 0xffffffffffffffffULL)
10319 				pstats->device_attached++;
10320 		}
10321 		if (event & SATA_EVNT_DEVICE_DETACHED) {
10322 			(void) strlcat(buf1, "device detached, ",
10323 			    SATA_EVENT_MAX_MSG_LENGTH);
10324 			if (pstats->device_detached < 0xffffffffffffffffULL)
10325 				pstats->device_detached++;
10326 		}
10327 		if (event & SATA_EVNT_PWR_LEVEL_CHANGED) {
10328 			SATADBG1(SATA_DBG_EVENTS, sata_hba_inst,
10329 			    "port %d power level changed", cport);
10330 			if (pstats->port_pwr_changed < 0xffffffffffffffffULL)
10331 				pstats->port_pwr_changed++;
10332 		}
10333 
10334 		if ((event & ~SATA_EVNT_PORT_EVENTS) != 0) {
10335 			/* There should be no other events for this address */
10336 			(void) sprintf(buf2, err_msg_evnt_1,
10337 			    event & ~SATA_EVNT_PORT_EVENTS);
10338 		}
10339 		mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, cport)));
10340 
10341 	} else if (saddr->qual & (SATA_ADDR_DCPORT | SATA_ADDR_DPMPORT)) {
10342 		mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, cport)));
10343 
10344 		/* qualify this event */
10345 		if ((event & SATA_EVNT_DEVICE_RESET) == 0) {
10346 			/* Invalid event for a device */
10347 			(void) sprintf(buf2, err_msg_evnt_2,
10348 			    event & SATA_EVNT_DEVICE_RESET);
10349 			mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, cport)));
10350 			goto event_info;
10351 		}
10352 		/* drive event */
10353 		sdinfo = sata_get_device_info(sata_hba_inst, sata_device);
10354 		if (sdinfo != NULL) {
10355 			if (event & SATA_EVNT_DEVICE_RESET) {
10356 				(void) strlcat(buf1, "device reset, ",
10357 				    SATA_EVENT_MAX_MSG_LENGTH);
10358 				if (sdinfo->satadrv_stats.drive_reset <
10359 				    0xffffffffffffffffULL)
10360 					sdinfo->satadrv_stats.drive_reset++;
10361 				sdinfo->satadrv_event_flags |=
10362 				    SATA_EVNT_DEVICE_RESET;
10363 			}
10364 		}
10365 		if ((event & ~SATA_EVNT_DEVICE_RESET) != 0) {
10366 			/* Invalid event for a device */
10367 			(void) sprintf(buf2, err_msg_evnt_2,
10368 			    event & ~SATA_EVNT_DRIVE_EVENTS);
10369 		}
10370 		mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, cport)));
10371 	} else {
10372 		if (saddr->qual != SATA_ADDR_NULL) {
10373 			/* Wrong address qualifier */
10374 			SATA_LOG_D((sata_hba_inst, CE_WARN,
10375 			    "sata_hba_event_notify: invalid address 0x%x",
10376 			    *(uint32_t *)saddr));
10377 			return;
10378 		}
10379 		if ((event & SATA_EVNT_CONTROLLER_EVENTS) == 0 ||
10380 		    (event & ~SATA_EVNT_CONTROLLER_EVENTS) != 0) {
10381 			/* Invalid event for the controller */
10382 			SATA_LOG_D((sata_hba_inst, CE_WARN,
10383 			    "sata_hba_event_notify: invalid event 0x%x for "
10384 			    "controller",
10385 			    event & SATA_EVNT_CONTROLLER_EVENTS));
10386 			return;
10387 		}
10388 		buf1[0] = '\0';
10389 		/* This may be a frequent and not interesting event */
10390 		SATADBG1(SATA_DBG_EVENTS, sata_hba_inst,
10391 		    "controller power level changed\n", NULL);
10392 
10393 		mutex_enter(&sata_hba_inst->satahba_mutex);
10394 		if (sata_hba_inst->satahba_stats.ctrl_pwr_change <
10395 		    0xffffffffffffffffULL)
10396 			sata_hba_inst->satahba_stats.ctrl_pwr_change++;
10397 
10398 		sata_hba_inst->satahba_event_flags |=
10399 		    SATA_EVNT_PWR_LEVEL_CHANGED;
10400 		mutex_exit(&sata_hba_inst->satahba_mutex);
10401 	}
10402 	/*
10403 	 * If we got here, there is something to do with this HBA
10404 	 * instance.
10405 	 */
10406 	mutex_enter(&sata_hba_inst->satahba_mutex);
10407 	sata_hba_inst->satahba_event_flags |= SATA_EVNT_MAIN;
10408 	mutex_exit(&sata_hba_inst->satahba_mutex);
10409 	mutex_enter(&sata_mutex);
10410 	sata_event_pending |= SATA_EVNT_MAIN;	/* global event indicator */
10411 	mutex_exit(&sata_mutex);
10412 
10413 	/* Tickle event thread */
10414 	mutex_enter(&sata_event_mutex);
10415 	if (sata_event_thread_active == 0)
10416 		cv_signal(&sata_event_cv);
10417 	mutex_exit(&sata_event_mutex);
10418 
10419 event_info:
10420 	if (buf1[0] != '\0') {
10421 		lcp = strrchr(buf1, ',');
10422 		if (lcp != NULL)
10423 			*lcp = '\0';
10424 	}
10425 	if (saddr->qual == SATA_ADDR_CPORT ||
10426 	    saddr->qual == SATA_ADDR_DCPORT) {
10427 		if (buf1[0] != '\0') {
10428 			sata_log(sata_hba_inst, CE_NOTE, "port %d: %s\n",
10429 			    cport, buf1);
10430 		}
10431 		if (buf2[0] != '\0') {
10432 			sata_log(sata_hba_inst, CE_NOTE, "port %d: %s\n",
10433 			    cport, buf2);
10434 		}
10435 	} else if (saddr->qual == SATA_ADDR_PMPORT ||
10436 	    saddr->qual == SATA_ADDR_DPMPORT) {
10437 		if (buf1[0] != '\0') {
10438 			sata_log(sata_hba_inst, CE_NOTE,
10439 			    "port %d pmport %d: %s\n", cport, pmport, buf1);
10440 		}
10441 		if (buf2[0] != '\0') {
10442 			sata_log(sata_hba_inst, CE_NOTE,
10443 			    "port %d pmport %d: %s\n", cport, pmport, buf2);
10444 		}
10445 	}
10446 }
10447 
10448 
10449 /*
10450  * Event processing thread.
10451  * Arg is a pointer to the sata_hba_list pointer.
10452  * It is not really needed, because sata_hba_list is global and static
10453  */
10454 static void
10455 sata_event_daemon(void *arg)
10456 {
10457 #ifndef __lock_lint
10458 	_NOTE(ARGUNUSED(arg))
10459 #endif
10460 	sata_hba_inst_t *sata_hba_inst;
10461 	clock_t lbolt;
10462 
10463 	SATADBG1(SATA_DBG_EVENTS_DAEMON, NULL,
10464 	    "SATA event daemon started\n", NULL);
10465 loop:
10466 	/*
10467 	 * Process events here. Walk through all registered HBAs
10468 	 */
10469 	mutex_enter(&sata_mutex);
10470 	for (sata_hba_inst = sata_hba_list; sata_hba_inst != NULL;
10471 	    sata_hba_inst = sata_hba_inst->satahba_next) {
10472 		ASSERT(sata_hba_inst != NULL);
10473 		mutex_enter(&sata_hba_inst->satahba_mutex);
10474 		if (sata_hba_inst->satahba_attached != 1 ||
10475 		    (sata_hba_inst->satahba_event_flags &
10476 		    SATA_EVNT_SKIP) != 0) {
10477 			mutex_exit(&sata_hba_inst->satahba_mutex);
10478 			continue;
10479 		}
10480 		if (sata_hba_inst->satahba_event_flags & SATA_EVNT_MAIN) {
10481 			sata_hba_inst->satahba_event_flags |= SATA_EVNT_SKIP;
10482 			mutex_exit(&sata_hba_inst->satahba_mutex);
10483 			mutex_exit(&sata_mutex);
10484 			/* Got the controller with pending event */
10485 			sata_process_controller_events(sata_hba_inst);
10486 			/*
10487 			 * Since global mutex was released, there is a
10488 			 * possibility that HBA list has changed, so start
10489 			 * over from the top. Just processed controller
10490 			 * will be passed-over because of the SKIP flag.
10491 			 */
10492 			goto loop;
10493 		}
10494 		mutex_exit(&sata_hba_inst->satahba_mutex);
10495 	}
10496 	/* Clear SKIP flag in all controllers */
10497 	for (sata_hba_inst = sata_hba_list; sata_hba_inst != NULL;
10498 	    sata_hba_inst = sata_hba_inst->satahba_next) {
10499 		mutex_enter(&sata_hba_inst->satahba_mutex);
10500 		sata_hba_inst->satahba_event_flags &= ~SATA_EVNT_SKIP;
10501 		mutex_exit(&sata_hba_inst->satahba_mutex);
10502 	}
10503 	mutex_exit(&sata_mutex);
10504 
10505 	SATADBG1(SATA_DBG_EVENTS_DAEMON, NULL,
10506 	    "SATA EVENT DAEMON suspending itself", NULL);
10507 
10508 #ifdef SATA_DEBUG
10509 	if ((sata_func_enable & SATA_ENABLE_PROCESS_EVENTS) == 0) {
10510 		sata_log(sata_hba_inst, CE_WARN,
10511 		    "SATA EVENTS PROCESSING DISABLED\n");
10512 		thread_exit(); /* Daemon will not run again */
10513 	}
10514 #endif
10515 	mutex_enter(&sata_event_mutex);
10516 	sata_event_thread_active = 0;
10517 	mutex_exit(&sata_event_mutex);
10518 	/*
10519 	 * Go to sleep/suspend itself and wake up either because new event or
10520 	 * wait timeout. Exit if there is a termination request (driver
10521 	 * unload).
10522 	 */
10523 	do {
10524 		lbolt = ddi_get_lbolt();
10525 		lbolt += drv_usectohz(SATA_EVNT_DAEMON_SLEEP_TIME);
10526 		mutex_enter(&sata_event_mutex);
10527 		(void) cv_timedwait(&sata_event_cv, &sata_event_mutex, lbolt);
10528 
10529 		if (sata_event_thread_active != 0) {
10530 			mutex_exit(&sata_event_mutex);
10531 			continue;
10532 		}
10533 
10534 		/* Check if it is time to go away */
10535 		if (sata_event_thread_terminate == 1) {
10536 			/*
10537 			 * It is up to the thread setting above flag to make
10538 			 * sure that this thread is not killed prematurely.
10539 			 */
10540 			sata_event_thread_terminate = 0;
10541 			sata_event_thread = NULL;
10542 			mutex_exit(&sata_event_mutex);
10543 			SATADBG1(SATA_DBG_EVENTS_DAEMON, NULL,
10544 			    "SATA_EVENT_DAEMON_TERMINATING", NULL);
10545 			thread_exit();  { _NOTE(NOT_REACHED) }
10546 		}
10547 		mutex_exit(&sata_event_mutex);
10548 	} while (!(sata_event_pending & SATA_EVNT_MAIN));
10549 
10550 	mutex_enter(&sata_event_mutex);
10551 	sata_event_thread_active = 1;
10552 	mutex_exit(&sata_event_mutex);
10553 
10554 	mutex_enter(&sata_mutex);
10555 	sata_event_pending &= ~SATA_EVNT_MAIN;
10556 	mutex_exit(&sata_mutex);
10557 
10558 	SATADBG1(SATA_DBG_EVENTS_DAEMON, NULL,
10559 	    "SATA EVENT DAEMON READY TO PROCESS EVENT", NULL);
10560 
10561 	goto loop;
10562 }
10563 
10564 /*
10565  * Specific HBA instance event processing.
10566  *
10567  * NOTE: At the moment, device event processing is limited to hard disks
10568  * only.
10569  * cports only are supported - no pmports.
10570  */
10571 static void
10572 sata_process_controller_events(sata_hba_inst_t *sata_hba_inst)
10573 {
10574 	int ncport;
10575 	uint32_t event_flags;
10576 	sata_address_t *saddr;
10577 
10578 	SATADBG1(SATA_DBG_EVENTS_CNTRL, sata_hba_inst,
10579 	    "Processing controller %d event(s)",
10580 	    ddi_get_instance(SATA_DIP(sata_hba_inst)));
10581 
10582 	mutex_enter(&sata_hba_inst->satahba_mutex);
10583 	sata_hba_inst->satahba_event_flags &= ~SATA_EVNT_MAIN;
10584 	event_flags = sata_hba_inst->satahba_event_flags;
10585 	mutex_exit(&sata_hba_inst->satahba_mutex);
10586 	/*
10587 	 * Process controller power change first
10588 	 * HERE
10589 	 */
10590 	if (event_flags & SATA_EVNT_PWR_LEVEL_CHANGED)
10591 		sata_process_cntrl_pwr_level_change(sata_hba_inst);
10592 
10593 	/*
10594 	 * Search through ports/devices to identify affected port/device.
10595 	 * We may have to process events for more than one port/device.
10596 	 */
10597 	for (ncport = 0; ncport < SATA_NUM_CPORTS(sata_hba_inst); ncport++) {
10598 		mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, ncport)));
10599 		event_flags = (SATA_CPORT_INFO(sata_hba_inst, ncport))->
10600 		    cport_event_flags;
10601 		/* Check if port was locked by IOCTL processing */
10602 		if (event_flags & SATA_APCTL_LOCK_PORT_BUSY) {
10603 			/*
10604 			 * We ignore port events because port is busy
10605 			 * with AP control processing. Set again
10606 			 * controller and main event flag, so that
10607 			 * events may be processed by the next daemon
10608 			 * run.
10609 			 */
10610 			mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, ncport)));
10611 			mutex_enter(&sata_hba_inst->satahba_mutex);
10612 			sata_hba_inst->satahba_event_flags |= SATA_EVNT_MAIN;
10613 			mutex_exit(&sata_hba_inst->satahba_mutex);
10614 			mutex_enter(&sata_mutex);
10615 			sata_event_pending |= SATA_EVNT_MAIN;
10616 			mutex_exit(&sata_mutex);
10617 			SATADBG1(SATA_DBG_EVENTS_PROCPST, sata_hba_inst,
10618 			    "Event processing postponed until "
10619 			    "AP control processing completes",
10620 			    NULL);
10621 			/* Check other ports */
10622 			continue;
10623 		} else {
10624 			/*
10625 			 * Set BSY flag so that AP control would not
10626 			 * interfere with events processing for
10627 			 * this port.
10628 			 */
10629 			(SATA_CPORT_INFO(sata_hba_inst, ncport))->
10630 			    cport_event_flags |= SATA_EVNT_LOCK_PORT_BUSY;
10631 		}
10632 		mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, ncport)));
10633 
10634 		saddr = &(SATA_CPORT_INFO(sata_hba_inst, ncport))->cport_addr;
10635 
10636 		if ((event_flags &
10637 		    (SATA_EVNT_PORT_EVENTS | SATA_EVNT_DRIVE_EVENTS)) != 0) {
10638 			/*
10639 			 * Got port event.
10640 			 * We need some hierarchy of event processing as they
10641 			 * are affecting each other:
10642 			 * 1. port failed
10643 			 * 2. device detached/attached
10644 			 * 3. link events - link events may trigger device
10645 			 *    detached or device attached events in some
10646 			 *    circumstances.
10647 			 * 4. port power level changed
10648 			 */
10649 			if (event_flags & SATA_EVNT_PORT_FAILED) {
10650 				sata_process_port_failed_event(sata_hba_inst,
10651 				    saddr);
10652 			}
10653 			if (event_flags & SATA_EVNT_DEVICE_DETACHED) {
10654 				sata_process_device_detached(sata_hba_inst,
10655 				    saddr);
10656 			}
10657 			if (event_flags & SATA_EVNT_DEVICE_ATTACHED) {
10658 				sata_process_device_attached(sata_hba_inst,
10659 				    saddr);
10660 			}
10661 			if (event_flags &
10662 			    (SATA_EVNT_LINK_ESTABLISHED |
10663 			    SATA_EVNT_LINK_LOST)) {
10664 				sata_process_port_link_events(sata_hba_inst,
10665 				    saddr);
10666 			}
10667 			if (event_flags & SATA_EVNT_PWR_LEVEL_CHANGED) {
10668 				sata_process_port_pwr_change(sata_hba_inst,
10669 				    saddr);
10670 			}
10671 			if (event_flags & SATA_EVNT_TARGET_NODE_CLEANUP) {
10672 				sata_process_target_node_cleanup(
10673 				    sata_hba_inst, saddr);
10674 			}
10675 		}
10676 		if (SATA_CPORT_DEV_TYPE(sata_hba_inst, ncport) !=
10677 		    SATA_DTYPE_NONE) {
10678 			/* May have device event */
10679 			sata_process_device_reset(sata_hba_inst, saddr);
10680 		}
10681 		mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, ncport)));
10682 		/* Release PORT_BUSY flag */
10683 		(SATA_CPORT_INFO(sata_hba_inst, ncport))->
10684 		    cport_event_flags &= ~SATA_EVNT_LOCK_PORT_BUSY;
10685 		mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, ncport)));
10686 
10687 	} /* End of loop through the controller SATA ports */
10688 }
10689 
10690 /*
10691  * Process HBA power level change reported by HBA driver.
10692  * Not implemented at this time - event is ignored.
10693  */
10694 static void
10695 sata_process_cntrl_pwr_level_change(sata_hba_inst_t *sata_hba_inst)
10696 {
10697 	SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst,
10698 	    "Processing controller power level change", NULL);
10699 
10700 	/* Ignoring it for now */
10701 	mutex_enter(&sata_hba_inst->satahba_mutex);
10702 	sata_hba_inst->satahba_event_flags &= ~SATA_EVNT_PWR_LEVEL_CHANGED;
10703 	mutex_exit(&sata_hba_inst->satahba_mutex);
10704 }
10705 
10706 /*
10707  * Process port power level change reported by HBA driver.
10708  * Not implemented at this time - event is ignored.
10709  */
10710 static void
10711 sata_process_port_pwr_change(sata_hba_inst_t *sata_hba_inst,
10712     sata_address_t *saddr)
10713 {
10714 	sata_cport_info_t *cportinfo;
10715 
10716 	SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst,
10717 	    "Processing port power level change", NULL);
10718 
10719 	cportinfo = SATA_CPORT_INFO(sata_hba_inst, saddr->cport);
10720 	mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex);
10721 	/* Reset event flag */
10722 	cportinfo->cport_event_flags &= ~SATA_EVNT_PWR_LEVEL_CHANGED;
10723 	mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex);
10724 }
10725 
10726 /*
10727  * Process port failure reported by HBA driver.
10728  * cports support only - no pmports.
10729  */
10730 static void
10731 sata_process_port_failed_event(sata_hba_inst_t *sata_hba_inst,
10732     sata_address_t *saddr)
10733 {
10734 	sata_cport_info_t *cportinfo;
10735 
10736 	cportinfo = SATA_CPORT_INFO(sata_hba_inst, saddr->cport);
10737 	mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex);
10738 	/* Reset event flag first */
10739 	cportinfo->cport_event_flags &= ~SATA_EVNT_PORT_FAILED;
10740 	/* If the port is in SHUTDOWN or FAILED state, ignore this event. */
10741 	if ((cportinfo->cport_state &
10742 	    (SATA_PSTATE_SHUTDOWN | SATA_PSTATE_FAILED)) == 0) {
10743 		mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->
10744 		    cport_mutex);
10745 		return;
10746 	}
10747 	/* Fail the port */
10748 	cportinfo->cport_state = SATA_PSTATE_FAILED;
10749 	mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex);
10750 	sata_log(sata_hba_inst, CE_WARN, "SATA port %d failed", saddr->cport);
10751 }
10752 
10753 /*
10754  * Device Reset Event processing.
10755  * The seqeunce is managed by 3 stage flags:
10756  * - reset event reported,
10757  * - reset event being processed,
10758  * - request to clear device reset state.
10759  */
10760 static void
10761 sata_process_device_reset(sata_hba_inst_t *sata_hba_inst,
10762     sata_address_t *saddr)
10763 {
10764 	sata_drive_info_t old_sdinfo; /* local copy of the drive info */
10765 	sata_drive_info_t *sdinfo;
10766 	sata_cport_info_t *cportinfo;
10767 	sata_device_t sata_device;
10768 	int rval;
10769 
10770 	/* We only care about host sata cport for now */
10771 	cportinfo = SATA_CPORT_INFO(sata_hba_inst, saddr->cport);
10772 
10773 	mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex);
10774 
10775 	/* If the port is in SHUTDOWN or FAILED state, ignore reset event. */
10776 	if ((cportinfo->cport_state &
10777 	    (SATA_PSTATE_SHUTDOWN | SATA_PSTATE_FAILED)) != 0) {
10778 		mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->
10779 		    cport_mutex);
10780 		return;
10781 	}
10782 
10783 	if ((SATA_CPORT_DEV_TYPE(sata_hba_inst, saddr->cport) &
10784 	    SATA_VALID_DEV_TYPE) == 0) {
10785 		mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->
10786 		    cport_mutex);
10787 		return;
10788 	}
10789 	sdinfo = SATA_CPORT_DRV_INFO(sata_hba_inst, saddr->cport);
10790 	if (sdinfo == NULL) {
10791 		mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->
10792 		    cport_mutex);
10793 		return;
10794 	}
10795 
10796 	if ((sdinfo->satadrv_event_flags &
10797 	    (SATA_EVNT_DEVICE_RESET | SATA_EVNT_INPROC_DEVICE_RESET)) == 0) {
10798 		/* Nothing to do */
10799 		mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->
10800 		    cport_mutex);
10801 		return;
10802 	}
10803 #ifdef SATA_DEBUG
10804 	if ((sdinfo->satadrv_event_flags &
10805 	    (SATA_EVNT_DEVICE_RESET | SATA_EVNT_INPROC_DEVICE_RESET)) ==
10806 	    (SATA_EVNT_DEVICE_RESET | SATA_EVNT_INPROC_DEVICE_RESET)) {
10807 		/* Something is weird - new device reset event */
10808 		SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst,
10809 		    "Overlapping device reset events!", NULL);
10810 	}
10811 #endif
10812 	SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst,
10813 	    "Processing port %d device reset", saddr->cport);
10814 
10815 	/* Clear event flag */
10816 	sdinfo->satadrv_event_flags &= ~SATA_EVNT_DEVICE_RESET;
10817 
10818 	/* It seems that we always need to check the port state first */
10819 	sata_device.satadev_rev = SATA_DEVICE_REV;
10820 	sata_device.satadev_addr = *saddr;
10821 	/*
10822 	 * We have to exit mutex, because the HBA probe port function may
10823 	 * block on its own mutex.
10824 	 */
10825 	mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex);
10826 	rval = (*SATA_PROBE_PORT_FUNC(sata_hba_inst))
10827 	    (SATA_DIP(sata_hba_inst), &sata_device);
10828 	mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex);
10829 	sata_update_port_info(sata_hba_inst, &sata_device);
10830 	if (rval != SATA_SUCCESS) {
10831 		/* Something went wrong? Fail the port */
10832 		cportinfo->cport_state = SATA_PSTATE_FAILED;
10833 		mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->
10834 		    cport_mutex);
10835 		SATA_LOG_D((sata_hba_inst, CE_WARN,
10836 		    "SATA port %d probing failed",
10837 		    saddr->cport));
10838 		return;
10839 	}
10840 	if ((sata_device.satadev_scr.sstatus  &
10841 	    SATA_PORT_DEVLINK_UP_MASK) !=
10842 	    SATA_PORT_DEVLINK_UP ||
10843 	    sata_device.satadev_type == SATA_DTYPE_NONE) {
10844 		/*
10845 		 * No device to process, anymore. Some other event processing
10846 		 * would or have already performed port info cleanup.
10847 		 * To be safe (HBA may need it), request clearing device
10848 		 * reset condition.
10849 		 */
10850 		sdinfo->satadrv_event_flags = 0;
10851 		sdinfo->satadrv_event_flags |= SATA_EVNT_CLEAR_DEVICE_RESET;
10852 		mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->
10853 		    cport_mutex);
10854 		return;
10855 	}
10856 
10857 	/* Mark device reset processing as active */
10858 	sdinfo->satadrv_event_flags |= SATA_EVNT_INPROC_DEVICE_RESET;
10859 
10860 	old_sdinfo = *sdinfo;	/* local copy of the drive info */
10861 	mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex);
10862 
10863 	if (sata_set_drive_features(sata_hba_inst, &old_sdinfo, 1) ==
10864 	    SATA_FAILURE) {
10865 		/*
10866 		 * Restoring drive setting failed.
10867 		 * Probe the port first, to check if the port state has changed
10868 		 */
10869 		sata_device.satadev_rev = SATA_DEVICE_REV;
10870 		sata_device.satadev_addr = *saddr;
10871 		sata_device.satadev_addr.qual = SATA_ADDR_CPORT;
10872 		/* probe port */
10873 		rval = (*SATA_PROBE_PORT_FUNC(sata_hba_inst))
10874 		    (SATA_DIP(sata_hba_inst), &sata_device);
10875 		mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->
10876 		    cport_mutex);
10877 		if (rval == SATA_SUCCESS &&
10878 		    (sata_device.satadev_state &
10879 		    (SATA_PSTATE_SHUTDOWN | SATA_PSTATE_FAILED)) == 0 &&
10880 		    (sata_device.satadev_scr.sstatus  &
10881 		    SATA_PORT_DEVLINK_UP_MASK) == SATA_PORT_DEVLINK_UP &&
10882 		    (sata_device.satadev_type & SATA_DTYPE_ATADISK) != 0) {
10883 			/*
10884 			 * We may retry this a bit later - in-process reset
10885 			 * condition is already set.
10886 			 */
10887 			if ((cportinfo->cport_dev_type &
10888 			    SATA_VALID_DEV_TYPE) != 0 &&
10889 			    SATA_CPORTINFO_DRV_INFO(cportinfo) != NULL) {
10890 				sdinfo = SATA_CPORTINFO_DRV_INFO(cportinfo);
10891 				mutex_exit(&SATA_CPORT_INFO(sata_hba_inst,
10892 				    saddr->cport)->cport_mutex);
10893 				mutex_enter(&sata_hba_inst->satahba_mutex);
10894 				sata_hba_inst->satahba_event_flags |=
10895 				    SATA_EVNT_MAIN;
10896 				mutex_exit(&sata_hba_inst->satahba_mutex);
10897 				mutex_enter(&sata_mutex);
10898 				sata_event_pending |= SATA_EVNT_MAIN;
10899 				mutex_exit(&sata_mutex);
10900 				return;
10901 			}
10902 		} else {
10903 			/*
10904 			 * No point of retrying - some other event processing
10905 			 * would or already did port info cleanup.
10906 			 * To be safe (HBA may need it),
10907 			 * request clearing device reset condition.
10908 			 */
10909 			sdinfo->satadrv_event_flags = 0;
10910 			sdinfo->satadrv_event_flags |=
10911 			    SATA_EVNT_CLEAR_DEVICE_RESET;
10912 		}
10913 		mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->
10914 		    cport_mutex);
10915 		return;
10916 	}
10917 
10918 	/*
10919 	 * Raise the flag indicating that the next sata command could
10920 	 * be sent with SATA_CLEAR_DEV_RESET_STATE flag, if no new device
10921 	 * reset is reported.
10922 	 */
10923 	mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex);
10924 	if ((cportinfo->cport_dev_type & SATA_VALID_DEV_TYPE) != 0 &&
10925 	    SATA_CPORTINFO_DRV_INFO(cportinfo) != NULL) {
10926 		sdinfo = SATA_CPORTINFO_DRV_INFO(cportinfo);
10927 		sdinfo->satadrv_event_flags &= ~SATA_EVNT_INPROC_DEVICE_RESET;
10928 		sdinfo->satadrv_event_flags |= SATA_EVNT_CLEAR_DEVICE_RESET;
10929 	}
10930 	mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex);
10931 }
10932 
10933 
10934 /*
10935  * Port Link Events processing.
10936  * Every link established event may involve device reset (due to
10937  * COMRESET signal, equivalent of the hard reset) so arbitrarily
10938  * set device reset event for an attached device (if any).
10939  * If the port is in SHUTDOWN or FAILED state, ignore link events.
10940  *
10941  * The link established event processing varies, depending on the state
10942  * of the target node, HBA hotplugging capabilities, state of the port.
10943  * If the link is not active, the link established event is ignored.
10944  * If HBA cannot detect device attachment and there is no target node,
10945  * the link established event triggers device attach event processing.
10946  * Else, link established event triggers device reset event processing.
10947  *
10948  * The link lost event processing varies, depending on a HBA hotplugging
10949  * capability and the state of the port (link active or not active).
10950  * If the link is active, the lost link event is ignored.
10951  * If HBA cannot detect device removal, the lost link event triggers
10952  * device detached event processing after link lost timeout.
10953  * Else, the event is ignored.
10954  *
10955  * NOTE: Only cports are processed for now, i.e. no port multiplier ports
10956  */
10957 static void
10958 sata_process_port_link_events(sata_hba_inst_t *sata_hba_inst,
10959     sata_address_t *saddr)
10960 {
10961 	sata_device_t sata_device;
10962 	sata_cport_info_t *cportinfo;
10963 	sata_drive_info_t *sdinfo;
10964 	uint32_t event_flags;
10965 	int rval;
10966 
10967 	SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst,
10968 	    "Processing port %d link event(s)", saddr->cport);
10969 
10970 	cportinfo = SATA_CPORT_INFO(sata_hba_inst, saddr->cport);
10971 	mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex);
10972 	event_flags = cportinfo->cport_event_flags;
10973 
10974 	/* Reset event flags first */
10975 	cportinfo->cport_event_flags &=
10976 	    ~(SATA_EVNT_LINK_ESTABLISHED | SATA_EVNT_LINK_LOST);
10977 
10978 	/* If the port is in SHUTDOWN or FAILED state, ignore link events. */
10979 	if ((cportinfo->cport_state &
10980 	    (SATA_PSTATE_SHUTDOWN | SATA_PSTATE_FAILED)) != 0) {
10981 		mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->
10982 		    cport_mutex);
10983 		return;
10984 	}
10985 
10986 	/*
10987 	 * For the sanity sake get current port state.
10988 	 * Set device address only. Other sata_device fields should be
10989 	 * set by HBA driver.
10990 	 */
10991 	sata_device.satadev_rev = SATA_DEVICE_REV;
10992 	sata_device.satadev_addr = *saddr;
10993 	/*
10994 	 * We have to exit mutex, because the HBA probe port function may
10995 	 * block on its own mutex.
10996 	 */
10997 	mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex);
10998 	rval = (*SATA_PROBE_PORT_FUNC(sata_hba_inst))
10999 	    (SATA_DIP(sata_hba_inst), &sata_device);
11000 	mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex);
11001 	sata_update_port_info(sata_hba_inst, &sata_device);
11002 	if (rval != SATA_SUCCESS) {
11003 		/* Something went wrong? Fail the port */
11004 		cportinfo->cport_state = SATA_PSTATE_FAILED;
11005 		mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->
11006 		    cport_mutex);
11007 		SATA_LOG_D((sata_hba_inst, CE_WARN,
11008 		    "SATA port %d probing failed",
11009 		    saddr->cport));
11010 		/*
11011 		 * We may want to release device info structure, but
11012 		 * it is not necessary.
11013 		 */
11014 		return;
11015 	} else {
11016 		/* port probed successfully */
11017 		cportinfo->cport_state |= SATA_STATE_PROBED | SATA_STATE_READY;
11018 	}
11019 	if (event_flags & SATA_EVNT_LINK_ESTABLISHED) {
11020 
11021 		if ((sata_device.satadev_scr.sstatus &
11022 		    SATA_PORT_DEVLINK_UP_MASK) != SATA_PORT_DEVLINK_UP) {
11023 			/* Ignore event */
11024 			SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst,
11025 			    "Ignoring port %d link established event - "
11026 			    "link down",
11027 			    saddr->cport);
11028 			goto linklost;
11029 		}
11030 
11031 		SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst,
11032 		    "Processing port %d link established event",
11033 		    saddr->cport);
11034 
11035 		/*
11036 		 * For the sanity sake check if a device is attached - check
11037 		 * return state of a port probing.
11038 		 */
11039 		if (sata_device.satadev_type != SATA_DTYPE_NONE &&
11040 		    sata_device.satadev_type != SATA_DTYPE_PMULT) {
11041 			/*
11042 			 * HBA port probe indicated that there is a device
11043 			 * attached. Check if the framework had device info
11044 			 * structure attached for this device.
11045 			 */
11046 			if (cportinfo->cport_dev_type != SATA_DTYPE_NONE) {
11047 				ASSERT(SATA_CPORTINFO_DRV_INFO(cportinfo) !=
11048 				    NULL);
11049 
11050 				sdinfo = SATA_CPORTINFO_DRV_INFO(cportinfo);
11051 				if ((sdinfo->satadrv_type &
11052 				    SATA_VALID_DEV_TYPE) != 0) {
11053 					/*
11054 					 * Dev info structure is present.
11055 					 * If dev_type is set to known type in
11056 					 * the framework's drive info struct
11057 					 * then the device existed before and
11058 					 * the link was probably lost
11059 					 * momentarily - in such case
11060 					 * we may want to check device
11061 					 * identity.
11062 					 * Identity check is not supported now.
11063 					 *
11064 					 * Link established event
11065 					 * triggers device reset event.
11066 					 */
11067 					(SATA_CPORTINFO_DRV_INFO(cportinfo))->
11068 					    satadrv_event_flags |=
11069 					    SATA_EVNT_DEVICE_RESET;
11070 				}
11071 			} else if (cportinfo->cport_dev_type ==
11072 			    SATA_DTYPE_NONE) {
11073 				/*
11074 				 * We got new device attached! If HBA does not
11075 				 * generate device attached events, trigger it
11076 				 * here.
11077 				 */
11078 				if (!(SATA_FEATURES(sata_hba_inst) &
11079 				    SATA_CTLF_HOTPLUG)) {
11080 					cportinfo->cport_event_flags |=
11081 					    SATA_EVNT_DEVICE_ATTACHED;
11082 				}
11083 			}
11084 			/* Reset link lost timeout */
11085 			cportinfo->cport_link_lost_time = 0;
11086 		}
11087 	}
11088 linklost:
11089 	if (event_flags & SATA_EVNT_LINK_LOST) {
11090 		if ((sata_device.satadev_scr.sstatus &
11091 		    SATA_PORT_DEVLINK_UP_MASK) == SATA_PORT_DEVLINK_UP) {
11092 			/* Ignore event */
11093 			SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst,
11094 			    "Ignoring port %d link lost event - link is up",
11095 			    saddr->cport);
11096 			goto done;
11097 		}
11098 #ifdef SATA_DEBUG
11099 		if (cportinfo->cport_link_lost_time == 0) {
11100 			SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst,
11101 			    "Processing port %d link lost event",
11102 			    saddr->cport);
11103 		}
11104 #endif
11105 		/*
11106 		 * When HBA cannot generate device attached/detached events,
11107 		 * we need to track link lost time and eventually generate
11108 		 * device detach event.
11109 		 */
11110 		if (!(SATA_FEATURES(sata_hba_inst) & SATA_CTLF_HOTPLUG)) {
11111 			/* We are tracking link lost time */
11112 			if (cportinfo->cport_link_lost_time == 0) {
11113 				/* save current time (lbolt value) */
11114 				cportinfo->cport_link_lost_time =
11115 				    ddi_get_lbolt();
11116 				/* just keep link lost event */
11117 				cportinfo->cport_event_flags |=
11118 				    SATA_EVNT_LINK_LOST;
11119 			} else {
11120 				clock_t cur_time = ddi_get_lbolt();
11121 				if ((cur_time -
11122 				    cportinfo->cport_link_lost_time) >=
11123 				    drv_usectohz(
11124 				    SATA_EVNT_LINK_LOST_TIMEOUT)) {
11125 					/* trigger device detach event */
11126 					cportinfo->cport_event_flags |=
11127 					    SATA_EVNT_DEVICE_DETACHED;
11128 					cportinfo->cport_link_lost_time = 0;
11129 					SATADBG1(SATA_DBG_EVENTS,
11130 					    sata_hba_inst,
11131 					    "Triggering port %d "
11132 					    "device detached event",
11133 					    saddr->cport);
11134 				} else {
11135 					/* keep link lost event */
11136 					cportinfo->cport_event_flags |=
11137 					    SATA_EVNT_LINK_LOST;
11138 				}
11139 			}
11140 		}
11141 		/*
11142 		 * We could change port state to disable/delay access to
11143 		 * the attached device until the link is recovered.
11144 		 */
11145 	}
11146 done:
11147 	event_flags = cportinfo->cport_event_flags;
11148 	mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex);
11149 	if (event_flags != 0) {
11150 		mutex_enter(&sata_hba_inst->satahba_mutex);
11151 		sata_hba_inst->satahba_event_flags |= SATA_EVNT_MAIN;
11152 		mutex_exit(&sata_hba_inst->satahba_mutex);
11153 		mutex_enter(&sata_mutex);
11154 		sata_event_pending |= SATA_EVNT_MAIN;
11155 		mutex_exit(&sata_mutex);
11156 	}
11157 }
11158 
11159 /*
11160  * Device Detached Event processing.
11161  * Port is probed to find if a device is really gone. If so,
11162  * the device info structure is detached from the SATA port info structure
11163  * and released.
11164  * Port status is updated.
11165  *
11166  * NOTE: Process cports event only, no port multiplier ports.
11167  */
11168 static void
11169 sata_process_device_detached(sata_hba_inst_t *sata_hba_inst,
11170     sata_address_t *saddr)
11171 {
11172 	sata_cport_info_t *cportinfo;
11173 	sata_drive_info_t *sdevinfo;
11174 	sata_device_t sata_device;
11175 	dev_info_t *tdip;
11176 	int rval;
11177 
11178 	SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst,
11179 	    "Processing port %d device detached", saddr->cport);
11180 
11181 	cportinfo = SATA_CPORT_INFO(sata_hba_inst, saddr->cport);
11182 	mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex);
11183 	/* Clear event flag */
11184 	cportinfo->cport_event_flags &= ~SATA_EVNT_DEVICE_DETACHED;
11185 
11186 	/* If the port is in SHUTDOWN or FAILED state, ignore detach event. */
11187 	if ((cportinfo->cport_state &
11188 	    (SATA_PSTATE_SHUTDOWN | SATA_PSTATE_FAILED)) != 0) {
11189 		mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->
11190 		    cport_mutex);
11191 		return;
11192 	}
11193 	/* For sanity, re-probe the port */
11194 	sata_device.satadev_rev = SATA_DEVICE_REV;
11195 	sata_device.satadev_addr = *saddr;
11196 
11197 	/*
11198 	 * We have to exit mutex, because the HBA probe port function may
11199 	 * block on its own mutex.
11200 	 */
11201 	mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex);
11202 	rval = (*SATA_PROBE_PORT_FUNC(sata_hba_inst))
11203 	    (SATA_DIP(sata_hba_inst), &sata_device);
11204 	mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex);
11205 	sata_update_port_info(sata_hba_inst, &sata_device);
11206 	if (rval != SATA_SUCCESS) {
11207 		/* Something went wrong? Fail the port */
11208 		cportinfo->cport_state = SATA_PSTATE_FAILED;
11209 		mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->
11210 		    cport_mutex);
11211 		SATA_LOG_D((sata_hba_inst, CE_WARN,
11212 		    "SATA port %d probing failed",
11213 		    saddr->cport));
11214 		/*
11215 		 * We may want to release device info structure, but
11216 		 * it is not necessary.
11217 		 */
11218 		return;
11219 	} else {
11220 		/* port probed successfully */
11221 		cportinfo->cport_state |= SATA_STATE_PROBED | SATA_STATE_READY;
11222 	}
11223 	/*
11224 	 * Check if a device is still attached. For sanity, check also
11225 	 * link status - if no link, there is no device.
11226 	 */
11227 	if ((sata_device.satadev_scr.sstatus & SATA_PORT_DEVLINK_UP_MASK) ==
11228 	    SATA_PORT_DEVLINK_UP && sata_device.satadev_type !=
11229 	    SATA_DTYPE_NONE) {
11230 		/*
11231 		 * Device is still attached - ignore detach event.
11232 		 */
11233 		mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->
11234 		    cport_mutex);
11235 		SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst,
11236 		    "Ignoring detach - device still attached to port %d",
11237 		    sata_device.satadev_addr.cport);
11238 		return;
11239 	}
11240 	/*
11241 	 * We need to detach and release device info structure here
11242 	 */
11243 	if (SATA_CPORTINFO_DRV_INFO(cportinfo) != NULL) {
11244 		sdevinfo = SATA_CPORTINFO_DRV_INFO(cportinfo);
11245 		SATA_CPORTINFO_DRV_INFO(cportinfo) = NULL;
11246 		(void) kmem_free((void *)sdevinfo,
11247 		    sizeof (sata_drive_info_t));
11248 	}
11249 	cportinfo->cport_dev_type = SATA_DTYPE_NONE;
11250 	/*
11251 	 * Device cannot be reached anymore, even if the target node may be
11252 	 * still present.
11253 	 */
11254 
11255 	mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex);
11256 	sata_log(sata_hba_inst, CE_WARN, "SATA device detached at port %d",
11257 	    sata_device.satadev_addr.cport);
11258 
11259 	/*
11260 	 * Try to offline a device and remove target node if it still exists
11261 	 */
11262 	tdip = sata_get_target_dip(SATA_DIP(sata_hba_inst), saddr->cport);
11263 	if (tdip != NULL) {
11264 		/*
11265 		 * Target node exists.  Unconfigure device then remove
11266 		 * the target node (one ndi operation).
11267 		 */
11268 		if (ndi_devi_offline(tdip, NDI_DEVI_REMOVE) != NDI_SUCCESS) {
11269 			/*
11270 			 * PROBLEM - no device, but target node remained
11271 			 * This happens when the file was open or node was
11272 			 * waiting for resources.
11273 			 */
11274 			SATA_LOG_D((sata_hba_inst, CE_WARN,
11275 			    "sata_process_device_detached: "
11276 			    "Failed to remove target node for "
11277 			    "detached SATA device."));
11278 			/*
11279 			 * Set target node state to DEVI_DEVICE_REMOVED.
11280 			 * But re-check first that the node still exists.
11281 			 */
11282 			tdip = sata_get_target_dip(SATA_DIP(sata_hba_inst),
11283 			    saddr->cport);
11284 			if (tdip != NULL) {
11285 				sata_set_device_removed(tdip);
11286 				/*
11287 				 * Instruct event daemon to retry the
11288 				 * cleanup later.
11289 				 */
11290 				sata_set_target_node_cleanup(sata_hba_inst,
11291 				    saddr->cport);
11292 			}
11293 		}
11294 	}
11295 	/*
11296 	 * Generate sysevent - EC_DR / ESC_DR_AP_STATE_CHANGE
11297 	 * with the hint: SE_HINT_REMOVE
11298 	 */
11299 	sata_gen_sysevent(sata_hba_inst, saddr, SE_HINT_REMOVE);
11300 }
11301 
11302 
11303 /*
11304  * Device Attached Event processing.
11305  * Port state is checked to verify that a device is really attached. If so,
11306  * the device info structure is created and attached to the SATA port info
11307  * structure.
11308  *
11309  * If attached device cannot be identified or set-up, the retry for the
11310  * attach processing is set-up. Subsequent daemon run would try again to
11311  * identify the device, until the time limit is reached
11312  * (SATA_DEV_IDENTIFY_TIMEOUT).
11313  *
11314  * This function cannot be called in interrupt context (it may sleep).
11315  *
11316  * NOTE: Process cports event only, no port multiplier ports.
11317  */
11318 static void
11319 sata_process_device_attached(sata_hba_inst_t *sata_hba_inst,
11320     sata_address_t *saddr)
11321 {
11322 	sata_cport_info_t *cportinfo;
11323 	sata_drive_info_t *sdevinfo;
11324 	sata_device_t sata_device;
11325 	dev_info_t *tdip;
11326 	uint32_t event_flags;
11327 	int rval;
11328 
11329 	SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst,
11330 	    "Processing port %d device attached", saddr->cport);
11331 
11332 	cportinfo = SATA_CPORT_INFO(sata_hba_inst, saddr->cport);
11333 	mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex);
11334 
11335 	/* Clear attach event flag first */
11336 	cportinfo->cport_event_flags &= ~SATA_EVNT_DEVICE_ATTACHED;
11337 
11338 	/* If the port is in SHUTDOWN or FAILED state, ignore event. */
11339 	if ((cportinfo->cport_state &
11340 	    (SATA_PSTATE_SHUTDOWN | SATA_PSTATE_FAILED)) != 0) {
11341 		cportinfo->cport_dev_attach_time = 0;
11342 		mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->
11343 		    cport_mutex);
11344 		return;
11345 	}
11346 
11347 	/*
11348 	 * If the sata_drive_info structure is found attached to the port info,
11349 	 * despite the fact the device was removed and now it is re-attached,
11350 	 * the old drive info structure was not removed.
11351 	 * Arbitrarily release device info structure.
11352 	 */
11353 	if (SATA_CPORTINFO_DRV_INFO(cportinfo) != NULL) {
11354 		sdevinfo = SATA_CPORTINFO_DRV_INFO(cportinfo);
11355 		SATA_CPORTINFO_DRV_INFO(cportinfo) = NULL;
11356 		(void) kmem_free((void *)sdevinfo,
11357 		    sizeof (sata_drive_info_t));
11358 		SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst,
11359 		    "Arbitrarily detaching old device info.", NULL);
11360 	}
11361 	cportinfo->cport_dev_type = SATA_DTYPE_NONE;
11362 
11363 	/* For sanity, re-probe the port */
11364 	sata_device.satadev_rev = SATA_DEVICE_REV;
11365 	sata_device.satadev_addr = *saddr;
11366 
11367 	/*
11368 	 * We have to exit mutex, because the HBA probe port function may
11369 	 * block on its own mutex.
11370 	 */
11371 	mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex);
11372 	rval = (*SATA_PROBE_PORT_FUNC(sata_hba_inst))
11373 	    (SATA_DIP(sata_hba_inst), &sata_device);
11374 	mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex);
11375 	sata_update_port_info(sata_hba_inst, &sata_device);
11376 	if (rval != SATA_SUCCESS) {
11377 		/* Something went wrong? Fail the port */
11378 		cportinfo->cport_state = SATA_PSTATE_FAILED;
11379 		cportinfo->cport_dev_attach_time = 0;
11380 		mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->
11381 		    cport_mutex);
11382 		SATA_LOG_D((sata_hba_inst, CE_WARN,
11383 		    "SATA port %d probing failed",
11384 		    saddr->cport));
11385 		return;
11386 	} else {
11387 		/* port probed successfully */
11388 		cportinfo->cport_state |= SATA_STATE_PROBED | SATA_STATE_READY;
11389 	}
11390 	/*
11391 	 * Check if a device is still attached. For sanity, check also
11392 	 * link status - if no link, there is no device.
11393 	 */
11394 	if ((sata_device.satadev_scr.sstatus & SATA_PORT_DEVLINK_UP_MASK) !=
11395 	    SATA_PORT_DEVLINK_UP || sata_device.satadev_type ==
11396 	    SATA_DTYPE_NONE) {
11397 		/*
11398 		 * No device - ignore attach event.
11399 		 */
11400 		cportinfo->cport_dev_attach_time = 0;
11401 		mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->
11402 		    cport_mutex);
11403 		SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst,
11404 		    "Ignoring attach - no device connected to port %d",
11405 		    sata_device.satadev_addr.cport);
11406 		return;
11407 	}
11408 
11409 	mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex);
11410 	/*
11411 	 * Generate sysevent - EC_DR / ESC_DR_AP_STATE_CHANGE
11412 	 * with the hint: SE_HINT_INSERT
11413 	 */
11414 	sata_gen_sysevent(sata_hba_inst, saddr, SE_HINT_INSERT);
11415 
11416 	/*
11417 	 * Port reprobing will take care of the creation of the device
11418 	 * info structure and determination of the device type.
11419 	 */
11420 	sata_device.satadev_addr = *saddr;
11421 	(void) sata_reprobe_port(sata_hba_inst, &sata_device,
11422 	    SATA_DEV_IDENTIFY_NORETRY);
11423 
11424 	mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->
11425 	    cport_mutex);
11426 	if ((cportinfo->cport_state & SATA_STATE_READY) &&
11427 	    (cportinfo->cport_dev_type != SATA_DTYPE_NONE)) {
11428 		/* Some device is attached to the port */
11429 		if (cportinfo->cport_dev_type == SATA_DTYPE_UNKNOWN) {
11430 			/*
11431 			 * A device was not successfully attached.
11432 			 * Track retry time for device identification.
11433 			 */
11434 			if (cportinfo->cport_dev_attach_time != 0) {
11435 				clock_t cur_time = ddi_get_lbolt();
11436 				/*
11437 				 * If the retry time limit was not exceeded,
11438 				 * reinstate attach event.
11439 				 */
11440 				if ((cur_time -
11441 				    cportinfo->cport_dev_attach_time) <
11442 				    drv_usectohz(
11443 				    SATA_DEV_IDENTIFY_TIMEOUT)) {
11444 					/* OK, restore attach event */
11445 					cportinfo->cport_event_flags |=
11446 					    SATA_EVNT_DEVICE_ATTACHED;
11447 				} else {
11448 					/* Timeout - cannot identify device */
11449 					cportinfo->cport_dev_attach_time = 0;
11450 					sata_log(sata_hba_inst,
11451 					    CE_WARN,
11452 					    "Cannot identify SATA device "
11453 					    "at port %d - device will not be "
11454 					    "attached.",
11455 					    saddr->cport);
11456 				}
11457 			} else {
11458 				/*
11459 				 * Start tracking time for device
11460 				 * identification.
11461 				 * Save current time (lbolt value).
11462 				 */
11463 				cportinfo->cport_dev_attach_time =
11464 				    ddi_get_lbolt();
11465 				/* Restore attach event */
11466 				cportinfo->cport_event_flags |=
11467 				    SATA_EVNT_DEVICE_ATTACHED;
11468 			}
11469 		} else {
11470 			/*
11471 			 * If device was successfully attached, an explicit
11472 			 * 'configure' command will be needed to configure it.
11473 			 * Log the message indicating that a device
11474 			 * was attached.
11475 			 */
11476 			cportinfo->cport_dev_attach_time = 0;
11477 			sata_log(sata_hba_inst, CE_WARN,
11478 			    "SATA device detected at port %d", saddr->cport);
11479 
11480 			if (SATA_CPORTINFO_DRV_INFO(cportinfo) != NULL) {
11481 				sata_drive_info_t new_sdinfo;
11482 
11483 				/* Log device info data */
11484 				new_sdinfo = *(SATA_CPORTINFO_DRV_INFO(
11485 				    cportinfo));
11486 				sata_show_drive_info(sata_hba_inst,
11487 				    &new_sdinfo);
11488 			}
11489 
11490 			mutex_exit(&SATA_CPORT_INFO(sata_hba_inst,
11491 			    saddr->cport)->cport_mutex);
11492 
11493 			/*
11494 			 * Make sure that there is no target node for that
11495 			 * device. If so, release it. It should not happen,
11496 			 * unless we had problem removing the node when
11497 			 * device was detached.
11498 			 */
11499 			tdip = sata_get_target_dip(SATA_DIP(sata_hba_inst),
11500 			    saddr->cport);
11501 			mutex_enter(&SATA_CPORT_INFO(sata_hba_inst,
11502 			    saddr->cport)->cport_mutex);
11503 			if (tdip != NULL) {
11504 
11505 #ifdef SATA_DEBUG
11506 				if ((cportinfo->cport_event_flags &
11507 				    SATA_EVNT_TARGET_NODE_CLEANUP) == 0)
11508 					sata_log(sata_hba_inst, CE_WARN,
11509 					    "sata_process_device_attached: "
11510 					    "old device target node exists!");
11511 #endif
11512 				/*
11513 				 * target node exists - try to unconfigure
11514 				 * device and remove the node.
11515 				 */
11516 				mutex_exit(&SATA_CPORT_INFO(sata_hba_inst,
11517 				    saddr->cport)->cport_mutex);
11518 				rval = ndi_devi_offline(tdip,
11519 				    NDI_DEVI_REMOVE);
11520 				mutex_enter(&SATA_CPORT_INFO(sata_hba_inst,
11521 				    saddr->cport)->cport_mutex);
11522 
11523 				if (rval == NDI_SUCCESS) {
11524 					cportinfo->cport_event_flags &=
11525 					    ~SATA_EVNT_TARGET_NODE_CLEANUP;
11526 					cportinfo->cport_tgtnode_clean = B_TRUE;
11527 				} else {
11528 					/*
11529 					 * PROBLEM - the target node remained
11530 					 * and it belongs to a previously
11531 					 * attached device.
11532 					 * This happens when the file was open
11533 					 * or the node was waiting for
11534 					 * resources at the time the
11535 					 * associated device was removed.
11536 					 * Instruct event daemon to retry the
11537 					 * cleanup later.
11538 					 */
11539 					sata_log(sata_hba_inst,
11540 					    CE_WARN,
11541 					    "Application(s) accessing "
11542 					    "previously attached SATA "
11543 					    "device have to release "
11544 					    "it before newly inserted "
11545 					    "device can be made accessible.",
11546 					    saddr->cport);
11547 					cportinfo->cport_event_flags |=
11548 					    SATA_EVNT_TARGET_NODE_CLEANUP;
11549 					cportinfo->cport_tgtnode_clean =
11550 					    B_FALSE;
11551 				}
11552 			}
11553 
11554 		}
11555 	} else {
11556 		cportinfo->cport_dev_attach_time = 0;
11557 	}
11558 
11559 	event_flags = cportinfo->cport_event_flags;
11560 	mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex);
11561 	if (event_flags != 0) {
11562 		mutex_enter(&sata_hba_inst->satahba_mutex);
11563 		sata_hba_inst->satahba_event_flags |= SATA_EVNT_MAIN;
11564 		mutex_exit(&sata_hba_inst->satahba_mutex);
11565 		mutex_enter(&sata_mutex);
11566 		sata_event_pending |= SATA_EVNT_MAIN;
11567 		mutex_exit(&sata_mutex);
11568 	}
11569 }
11570 
11571 
11572 /*
11573  * Device Target Node Cleanup Event processing.
11574  * If the target node associated with a sata port device is in
11575  * DEVI_DEVICE_REMOVED state, an attempt is made to remove it.
11576  * If the target node cannot be removed, the event flag is left intact,
11577  * so that event daemon may re-run this function later.
11578  *
11579  * This function cannot be called in interrupt context (it may sleep).
11580  *
11581  * NOTE: Processes cport events only, not port multiplier ports.
11582  */
11583 static void
11584 sata_process_target_node_cleanup(sata_hba_inst_t *sata_hba_inst,
11585     sata_address_t *saddr)
11586 {
11587 	sata_cport_info_t *cportinfo;
11588 	dev_info_t *tdip;
11589 
11590 	SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst,
11591 	    "Processing port %d device target node cleanup", saddr->cport);
11592 
11593 	cportinfo = SATA_CPORT_INFO(sata_hba_inst, saddr->cport);
11594 
11595 	/*
11596 	 * Check if there is target node for that device and it is in the
11597 	 * DEVI_DEVICE_REMOVED state. If so, release it.
11598 	 */
11599 	tdip = sata_get_target_dip(SATA_DIP(sata_hba_inst), saddr->cport);
11600 	if (tdip != NULL) {
11601 		/*
11602 		 * target node exists - check if it is target node of
11603 		 * a removed device.
11604 		 */
11605 		if (sata_check_device_removed(tdip) == B_TRUE) {
11606 			SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst,
11607 			    "sata_process_target_node_cleanup: "
11608 			    "old device target node exists!", NULL);
11609 			/*
11610 			 * Unconfigure and remove the target node
11611 			 */
11612 			if (ndi_devi_offline(tdip, NDI_DEVI_REMOVE) ==
11613 			    NDI_SUCCESS) {
11614 				mutex_enter(&SATA_CPORT_INFO(sata_hba_inst,
11615 				    saddr->cport)->cport_mutex);
11616 				cportinfo->cport_event_flags &=
11617 				    ~SATA_EVNT_TARGET_NODE_CLEANUP;
11618 				mutex_exit(&SATA_CPORT_INFO(sata_hba_inst,
11619 				    saddr->cport)->cport_mutex);
11620 				return;
11621 			}
11622 			/*
11623 			 * Event daemon will retry the cleanup later.
11624 			 */
11625 			mutex_enter(&sata_hba_inst->satahba_mutex);
11626 			sata_hba_inst->satahba_event_flags |= SATA_EVNT_MAIN;
11627 			mutex_exit(&sata_hba_inst->satahba_mutex);
11628 			mutex_enter(&sata_mutex);
11629 			sata_event_pending |= SATA_EVNT_MAIN;
11630 			mutex_exit(&sata_mutex);
11631 		}
11632 	} else {
11633 		mutex_enter(&SATA_CPORT_INFO(sata_hba_inst,
11634 		    saddr->cport)->cport_mutex);
11635 		cportinfo->cport_event_flags &=
11636 		    ~SATA_EVNT_TARGET_NODE_CLEANUP;
11637 		mutex_exit(&SATA_CPORT_INFO(sata_hba_inst,
11638 		    saddr->cport)->cport_mutex);
11639 	}
11640 }
11641 
11642 
11643 
11644 /*
11645  * sata_set_drive_features function compares current device features setting
11646  * with the saved device features settings and, if there is a difference,
11647  * it restores device features setting to the previously saved state.
11648  * Device Identify data has to be current.
11649  * At the moment only read ahead and write cache settings are considered.
11650  *
11651  * This function cannot be called in the interrupt context (it may sleep).
11652  *
11653  * The input argument sdinfo should point to the drive info structure
11654  * to be updated after features are set.
11655  *
11656  * Returns TRUE if successful or there was nothing to do.
11657  * Returns FALSE if device features could not be set .
11658  *
11659  * Note: This function may fail the port, making it inaccessible.
11660  * Explicit port disconnect/connect or physical device
11661  * detach/attach is required to re-evaluate it's state afterwards
11662  */
11663 
11664 static int
11665 sata_set_drive_features(sata_hba_inst_t *sata_hba_inst,
11666     sata_drive_info_t *sdinfo, int restore)
11667 {
11668 	int rval = SATA_SUCCESS;
11669 	sata_drive_info_t new_sdinfo;
11670 	char *finfo = "sata_set_drive_features: cannot";
11671 	char *finfox;
11672 	int cache_op;
11673 
11674 	bzero(&new_sdinfo, sizeof (sata_drive_info_t));
11675 	new_sdinfo.satadrv_addr = sdinfo->satadrv_addr;
11676 	new_sdinfo.satadrv_type = sdinfo->satadrv_type;
11677 	if (sata_fetch_device_identify_data(sata_hba_inst, &new_sdinfo) != 0) {
11678 		/*
11679 		 * Cannot get device identification - retry later
11680 		 */
11681 		SATA_LOG_D((sata_hba_inst, CE_WARN,
11682 		    "%s fetch device identify data\n", finfo));
11683 		return (SATA_FAILURE);
11684 	}
11685 	/* Arbitrarily set UDMA mode */
11686 	if (sata_set_udma_mode(sata_hba_inst, &new_sdinfo) != SATA_SUCCESS) {
11687 		SATA_LOG_D((sata_hba_inst, CE_WARN,
11688 		    "%s set UDMA mode\n", finfo));
11689 		return (SATA_FAILURE);
11690 	}
11691 
11692 	if (!(new_sdinfo.satadrv_id.ai_cmdset82 & SATA_LOOK_AHEAD) &&
11693 	    !(new_sdinfo.satadrv_id.ai_cmdset82 & SATA_WRITE_CACHE)) {
11694 		/* None of the features is supported - do nothing */
11695 		SATADBG1(SATA_DBG_DEV_SETTINGS, sata_hba_inst,
11696 		    "settable features not supported\n", NULL);
11697 		return (SATA_SUCCESS);
11698 	}
11699 
11700 	if (((new_sdinfo.satadrv_id.ai_features85 & SATA_LOOK_AHEAD) &&
11701 	    (sdinfo->satadrv_settings & SATA_DEV_READ_AHEAD)) &&
11702 	    ((new_sdinfo.satadrv_id.ai_features85 & SATA_WRITE_CACHE) &&
11703 	    (sdinfo->satadrv_settings & SATA_DEV_WRITE_CACHE))) {
11704 		/* Nothing to do */
11705 		SATADBG1(SATA_DBG_DEV_SETTINGS, sata_hba_inst,
11706 		    "no device features to set\n", NULL);
11707 		return (SATA_SUCCESS);
11708 	}
11709 
11710 	finfox = (restore != 0) ? " restore device features" :
11711 	    " initialize device features\n";
11712 
11713 	if (!((new_sdinfo.satadrv_id.ai_features85 & SATA_LOOK_AHEAD) &&
11714 	    (sdinfo->satadrv_settings & SATA_DEV_READ_AHEAD))) {
11715 		if (sdinfo->satadrv_settings & SATA_DEV_READ_AHEAD) {
11716 			/* Enable read ahead / read cache */
11717 			cache_op = SATAC_SF_ENABLE_READ_AHEAD;
11718 			SATADBG1(SATA_DBG_DEV_SETTINGS, sata_hba_inst,
11719 			    "enabling read cache\n", NULL);
11720 		} else {
11721 			/* Disable read ahead  / read cache */
11722 			cache_op = SATAC_SF_DISABLE_READ_AHEAD;
11723 			SATADBG1(SATA_DBG_DEV_SETTINGS, sata_hba_inst,
11724 			    "disabling read cache\n", NULL);
11725 		}
11726 
11727 		/* Try to set read cache mode */
11728 		if (sata_set_cache_mode(sata_hba_inst, &new_sdinfo,
11729 		    cache_op) != SATA_SUCCESS) {
11730 			/* Pkt execution failed */
11731 			rval = SATA_FAILURE;
11732 		}
11733 	}
11734 
11735 	if (!((new_sdinfo.satadrv_id.ai_features85 & SATA_WRITE_CACHE) &&
11736 	    (sdinfo->satadrv_settings & SATA_DEV_WRITE_CACHE))) {
11737 		if (sdinfo->satadrv_settings & SATA_DEV_WRITE_CACHE) {
11738 			/* Enable write cache */
11739 			cache_op = SATAC_SF_ENABLE_WRITE_CACHE;
11740 			SATADBG1(SATA_DBG_DEV_SETTINGS, sata_hba_inst,
11741 			    "enabling write cache\n", NULL);
11742 		} else {
11743 			/* Disable write cache */
11744 			cache_op = SATAC_SF_DISABLE_WRITE_CACHE;
11745 			SATADBG1(SATA_DBG_DEV_SETTINGS, sata_hba_inst,
11746 			    "disabling write cache\n", NULL);
11747 		}
11748 		/* Try to set write cache mode */
11749 		if (sata_set_cache_mode(sata_hba_inst, &new_sdinfo,
11750 		    cache_op) != SATA_SUCCESS) {
11751 			/* Pkt execution failed */
11752 			rval = SATA_FAILURE;
11753 		}
11754 	}
11755 
11756 	if (rval == SATA_FAILURE)
11757 		SATA_LOG_D((sata_hba_inst, CE_WARN,
11758 		    "%s %s", finfo, finfox));
11759 
11760 	/*
11761 	 * We need to fetch Device Identify data again
11762 	 */
11763 	if (sata_fetch_device_identify_data(sata_hba_inst, &new_sdinfo) != 0) {
11764 		/*
11765 		 * Cannot get device identification - retry later
11766 		 */
11767 		SATA_LOG_D((sata_hba_inst, CE_WARN,
11768 		    "%s cannot re-fetch device identify data\n"));
11769 		rval = SATA_FAILURE;
11770 	}
11771 	/* Copy device sata info. */
11772 	sdinfo->satadrv_id = new_sdinfo.satadrv_id;
11773 
11774 	return (rval);
11775 }
11776 
11777 
11778 /*
11779  *
11780  * Returns 1 if threshold exceeded, 0 if threshold not exceeded, -1 if
11781  * unable to determine.
11782  *
11783  * Cannot be called in an interrupt context.
11784  *
11785  * Called by sata_build_lsense_page_2f()
11786  */
11787 
11788 static int
11789 sata_fetch_smart_return_status(sata_hba_inst_t *sata_hba_inst,
11790     sata_drive_info_t *sdinfo)
11791 {
11792 	sata_pkt_t *spkt;
11793 	sata_cmd_t *scmd;
11794 	sata_pkt_txlate_t *spx;
11795 	int rval;
11796 
11797 	spx = kmem_zalloc(sizeof (sata_pkt_txlate_t), KM_SLEEP);
11798 	spx->txlt_sata_hba_inst = sata_hba_inst;
11799 	spx->txlt_scsi_pkt = NULL;		/* No scsi pkt involved */
11800 	spkt = sata_pkt_alloc(spx, SLEEP_FUNC);
11801 	if (spkt == NULL) {
11802 		kmem_free(spx, sizeof (sata_pkt_txlate_t));
11803 		return (-1);
11804 	}
11805 	/* address is needed now */
11806 	spkt->satapkt_device.satadev_addr = sdinfo->satadrv_addr;
11807 
11808 
11809 	/* Fill sata_pkt */
11810 	spkt->satapkt_device.satadev_addr = sdinfo->satadrv_addr;
11811 	spkt->satapkt_op_mode = SATA_OPMODE_SYNCH | SATA_OPMODE_INTERRUPTS;
11812 	/* Synchronous mode, no callback */
11813 	spkt->satapkt_comp = NULL;
11814 	/* Timeout 30s */
11815 	spkt->satapkt_time = sata_default_pkt_time;
11816 
11817 	scmd = &spkt->satapkt_cmd;
11818 	scmd->satacmd_flags.sata_special_regs = B_TRUE;
11819 	scmd->satacmd_flags.sata_data_direction = SATA_DIR_NODATA_XFER;
11820 
11821 	/* Set up which registers need to be returned */
11822 	scmd->satacmd_flags.sata_copy_out_lba_mid_lsb = B_TRUE;
11823 	scmd->satacmd_flags.sata_copy_out_lba_high_lsb = B_TRUE;
11824 
11825 	/* Build SMART_RETURN_STATUS cmd in the sata_pkt */
11826 	scmd->satacmd_addr_type = 0;		/* N/A */
11827 	scmd->satacmd_sec_count_lsb = 0;	/* N/A */
11828 	scmd->satacmd_lba_low_lsb = 0;		/* N/A */
11829 	scmd->satacmd_lba_mid_lsb = SMART_MAGIC_VAL_1;
11830 	scmd->satacmd_lba_high_lsb = SMART_MAGIC_VAL_2;
11831 	scmd->satacmd_features_reg = SATA_SMART_RETURN_STATUS;
11832 	scmd->satacmd_device_reg = 0;		/* Always device 0 */
11833 	scmd->satacmd_cmd_reg = SATAC_SMART;
11834 	mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst,
11835 	    sdinfo->satadrv_addr.cport)));
11836 
11837 
11838 	/* Send pkt to SATA HBA driver */
11839 	if ((*SATA_START_FUNC(sata_hba_inst))(SATA_DIP(sata_hba_inst), spkt) !=
11840 	    SATA_TRAN_ACCEPTED ||
11841 	    spkt->satapkt_reason != SATA_PKT_COMPLETED) {
11842 		mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst,
11843 		    sdinfo->satadrv_addr.cport)));
11844 		/*
11845 		 * Whoops, no SMART RETURN STATUS
11846 		 */
11847 		rval = -1;
11848 	} else {
11849 		mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst,
11850 		    sdinfo->satadrv_addr.cport)));
11851 		if (scmd->satacmd_error_reg & SATA_ERROR_ABORT) {
11852 			rval = -1;
11853 			goto fail;
11854 		}
11855 		if (scmd->satacmd_status_reg & SATA_STATUS_ERR) {
11856 			rval = -1;
11857 			goto fail;
11858 		}
11859 		if ((scmd->satacmd_lba_mid_lsb == SMART_MAGIC_VAL_1) &&
11860 		    (scmd->satacmd_lba_high_lsb == SMART_MAGIC_VAL_2))
11861 			rval = 0;
11862 		else if ((scmd->satacmd_lba_mid_lsb == SMART_MAGIC_VAL_3) &&
11863 		    (scmd->satacmd_lba_high_lsb == SMART_MAGIC_VAL_4))
11864 			rval = 1;
11865 		else {
11866 			rval = -1;
11867 			goto fail;
11868 		}
11869 	}
11870 fail:
11871 	/* Free allocated resources */
11872 	sata_pkt_free(spx);
11873 	kmem_free(spx, sizeof (sata_pkt_txlate_t));
11874 
11875 	return (rval);
11876 }
11877 
11878 /*
11879  *
11880  * Returns 0 if succeeded, -1 otherwise
11881  *
11882  * Cannot be called in an interrupt context.
11883  *
11884  */
11885 static int
11886 sata_fetch_smart_data(
11887 	sata_hba_inst_t *sata_hba_inst,
11888 	sata_drive_info_t *sdinfo,
11889 	struct smart_data *smart_data)
11890 {
11891 	sata_pkt_t *spkt;
11892 	sata_cmd_t *scmd;
11893 	sata_pkt_txlate_t *spx;
11894 	int rval;
11895 
11896 #if ! defined(lint)
11897 	ASSERT(sizeof (struct smart_data) == 512);
11898 #endif
11899 
11900 	spx = kmem_zalloc(sizeof (sata_pkt_txlate_t), KM_SLEEP);
11901 	spx->txlt_sata_hba_inst = sata_hba_inst;
11902 	spx->txlt_scsi_pkt = NULL;		/* No scsi pkt involved */
11903 	spkt = sata_pkt_alloc(spx, SLEEP_FUNC);
11904 	if (spkt == NULL) {
11905 		kmem_free(spx, sizeof (sata_pkt_txlate_t));
11906 		return (-1);
11907 	}
11908 	/* address is needed now */
11909 	spkt->satapkt_device.satadev_addr = sdinfo->satadrv_addr;
11910 
11911 
11912 	/* Fill sata_pkt */
11913 	spkt->satapkt_device.satadev_addr = sdinfo->satadrv_addr;
11914 	spkt->satapkt_op_mode = SATA_OPMODE_SYNCH | SATA_OPMODE_INTERRUPTS;
11915 	/* Synchronous mode, no callback */
11916 	spkt->satapkt_comp = NULL;
11917 	/* Timeout 30s */
11918 	spkt->satapkt_time = sata_default_pkt_time;
11919 
11920 	scmd = &spkt->satapkt_cmd;
11921 	scmd->satacmd_flags.sata_data_direction = SATA_DIR_READ;
11922 
11923 	/*
11924 	 * Allocate buffer for SMART data
11925 	 */
11926 	scmd->satacmd_bp = sata_alloc_local_buffer(spx,
11927 	    sizeof (struct smart_data));
11928 	if (scmd->satacmd_bp == NULL) {
11929 		sata_pkt_free(spx);
11930 		kmem_free(spx, sizeof (sata_pkt_txlate_t));
11931 		SATA_LOG_D((sata_hba_inst, CE_WARN,
11932 		    "sata_fetch_smart_data: "
11933 		    "cannot allocate buffer"));
11934 		return (-1);
11935 	}
11936 
11937 
11938 	/* Build SMART_READ_DATA cmd in the sata_pkt */
11939 	scmd->satacmd_addr_type = 0;		/* N/A */
11940 	scmd->satacmd_sec_count_lsb = 0;	/* N/A */
11941 	scmd->satacmd_lba_low_lsb = 0;		/* N/A */
11942 	scmd->satacmd_lba_mid_lsb = SMART_MAGIC_VAL_1;
11943 	scmd->satacmd_lba_high_lsb = SMART_MAGIC_VAL_2;
11944 	scmd->satacmd_features_reg = SATA_SMART_READ_DATA;
11945 	scmd->satacmd_device_reg = 0;		/* Always device 0 */
11946 	scmd->satacmd_cmd_reg = SATAC_SMART;
11947 	mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst,
11948 	    sdinfo->satadrv_addr.cport)));
11949 
11950 	/* Send pkt to SATA HBA driver */
11951 	if ((*SATA_START_FUNC(sata_hba_inst))(SATA_DIP(sata_hba_inst), spkt) !=
11952 	    SATA_TRAN_ACCEPTED ||
11953 	    spkt->satapkt_reason != SATA_PKT_COMPLETED) {
11954 		mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst,
11955 		    sdinfo->satadrv_addr.cport)));
11956 		/*
11957 		 * Whoops, no SMART DATA available
11958 		 */
11959 		rval = -1;
11960 		goto fail;
11961 	} else {
11962 		mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst,
11963 		    sdinfo->satadrv_addr.cport)));
11964 		rval = ddi_dma_sync(spx->txlt_buf_dma_handle, 0, 0,
11965 			DDI_DMA_SYNC_FORKERNEL);
11966 		ASSERT(rval == DDI_SUCCESS);
11967 		bcopy(scmd->satacmd_bp->b_un.b_addr, (uint8_t *)smart_data,
11968 		    sizeof (struct smart_data));
11969 	}
11970 
11971 fail:
11972 	/* Free allocated resources */
11973 	sata_free_local_buffer(spx);
11974 	spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp = NULL;
11975 	sata_pkt_free(spx);
11976 	kmem_free(spx, sizeof (sata_pkt_txlate_t));
11977 
11978 	return (rval);
11979 }
11980 
11981 /*
11982  * Used by LOG SENSE page 0x10
11983  *
11984  * return 0 for success, -1 otherwise
11985  *
11986  */
11987 static int
11988 sata_ext_smart_selftest_read_log(
11989 	sata_hba_inst_t *sata_hba_inst,
11990 	sata_drive_info_t *sdinfo,
11991 	struct smart_ext_selftest_log *ext_selftest_log,
11992 	uint16_t block_num)
11993 {
11994 	sata_pkt_txlate_t *spx;
11995 	sata_pkt_t *spkt;
11996 	sata_cmd_t *scmd;
11997 	int rval;
11998 
11999 #if ! defined(lint)
12000 	ASSERT(sizeof (struct smart_ext_selftest_log) == 512);
12001 #endif
12002 
12003 	spx = kmem_zalloc(sizeof (sata_pkt_txlate_t), KM_SLEEP);
12004 	spx->txlt_sata_hba_inst = sata_hba_inst;
12005 	spx->txlt_scsi_pkt = NULL;		/* No scsi pkt involved */
12006 	spkt = sata_pkt_alloc(spx, SLEEP_FUNC);
12007 	if (spkt == NULL) {
12008 		kmem_free(spx, sizeof (sata_pkt_txlate_t));
12009 		return (-1);
12010 	}
12011 	/* address is needed now */
12012 	spkt->satapkt_device.satadev_addr = sdinfo->satadrv_addr;
12013 
12014 
12015 	/* Fill sata_pkt */
12016 	spkt->satapkt_device.satadev_addr = sdinfo->satadrv_addr;
12017 	spkt->satapkt_op_mode = SATA_OPMODE_SYNCH | SATA_OPMODE_INTERRUPTS;
12018 	/* Synchronous mode, no callback */
12019 	spkt->satapkt_comp = NULL;
12020 	/* Timeout 30s */
12021 	spkt->satapkt_time = sata_default_pkt_time;
12022 
12023 	scmd = &spkt->satapkt_cmd;
12024 	scmd->satacmd_flags.sata_data_direction = SATA_DIR_READ;
12025 
12026 	/*
12027 	 * Allocate buffer for SMART extended self-test log
12028 	 */
12029 	scmd->satacmd_bp = sata_alloc_local_buffer(spx,
12030 	    sizeof (struct smart_ext_selftest_log));
12031 	if (scmd->satacmd_bp == NULL) {
12032 		sata_pkt_free(spx);
12033 		kmem_free(spx, sizeof (sata_pkt_txlate_t));
12034 		SATA_LOG_D((sata_hba_inst, CE_WARN,
12035 		    "sata_ext_smart_selftest_log: "
12036 		    "cannot allocate buffer"));
12037 		return (-1);
12038 	}
12039 
12040 	/* Build READ LOG EXT w/ extended self-test log cmd in the sata_pkt */
12041 	scmd->satacmd_addr_type = ATA_ADDR_LBA48;
12042 	scmd->satacmd_sec_count_lsb = 1;	/* One sector of selftest log */
12043 	scmd->satacmd_sec_count_msb = 0;	/* One sector of selftest log */
12044 	scmd->satacmd_lba_low_lsb = EXT_SMART_SELFTEST_LOG_PAGE;
12045 	scmd->satacmd_lba_low_msb = 0;
12046 	scmd->satacmd_lba_mid_lsb = block_num & 0xff;
12047 	scmd->satacmd_lba_mid_msb = block_num >> 8;
12048 	scmd->satacmd_device_reg = 0;		/* Always device 0 */
12049 	scmd->satacmd_cmd_reg = SATAC_READ_LOG_EXT;
12050 
12051 	mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst,
12052 	    sdinfo->satadrv_addr.cport)));
12053 
12054 	/* Send pkt to SATA HBA driver */
12055 	if ((*SATA_START_FUNC(sata_hba_inst))(SATA_DIP(sata_hba_inst), spkt) !=
12056 	    SATA_TRAN_ACCEPTED ||
12057 	    spkt->satapkt_reason != SATA_PKT_COMPLETED) {
12058 		mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst,
12059 		    sdinfo->satadrv_addr.cport)));
12060 
12061 		/*
12062 		 * Whoops, no SMART selftest log info available
12063 		 */
12064 		rval = -1;
12065 		goto fail;
12066 	} else {
12067 		mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst,
12068 		    sdinfo->satadrv_addr.cport)));
12069 
12070 		rval = ddi_dma_sync(spx->txlt_buf_dma_handle, 0, 0,
12071 			DDI_DMA_SYNC_FORKERNEL);
12072 		ASSERT(rval == DDI_SUCCESS);
12073 		bcopy(scmd->satacmd_bp->b_un.b_addr,
12074 		    (uint8_t *)ext_selftest_log,
12075 		    sizeof (struct smart_ext_selftest_log));
12076 		rval = 0;
12077 	}
12078 
12079 fail:
12080 	/* Free allocated resources */
12081 	sata_free_local_buffer(spx);
12082 	spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp = NULL;
12083 	sata_pkt_free(spx);
12084 	kmem_free(spx, sizeof (sata_pkt_txlate_t));
12085 
12086 	return (rval);
12087 }
12088 
12089 /*
12090  * Returns 0 for success, -1 otherwise
12091  *
12092  * SMART self-test log data is returned in buffer pointed to by selftest_log
12093  */
12094 static int
12095 sata_smart_selftest_log(
12096 	sata_hba_inst_t *sata_hba_inst,
12097 	sata_drive_info_t *sdinfo,
12098 	struct smart_selftest_log *selftest_log)
12099 {
12100 	sata_pkt_t *spkt;
12101 	sata_cmd_t *scmd;
12102 	sata_pkt_txlate_t *spx;
12103 	int rval;
12104 
12105 #if ! defined(lint)
12106 	ASSERT(sizeof (struct smart_selftest_log) == 512);
12107 #endif
12108 
12109 	spx = kmem_zalloc(sizeof (sata_pkt_txlate_t), KM_SLEEP);
12110 	spx->txlt_sata_hba_inst = sata_hba_inst;
12111 	spx->txlt_scsi_pkt = NULL;		/* No scsi pkt involved */
12112 	spkt = sata_pkt_alloc(spx, SLEEP_FUNC);
12113 	if (spkt == NULL) {
12114 		kmem_free(spx, sizeof (sata_pkt_txlate_t));
12115 		return (-1);
12116 	}
12117 	/* address is needed now */
12118 	spkt->satapkt_device.satadev_addr = sdinfo->satadrv_addr;
12119 
12120 
12121 	/* Fill sata_pkt */
12122 	spkt->satapkt_device.satadev_addr = sdinfo->satadrv_addr;
12123 	spkt->satapkt_op_mode = SATA_OPMODE_SYNCH | SATA_OPMODE_INTERRUPTS;
12124 	/* Synchronous mode, no callback */
12125 	spkt->satapkt_comp = NULL;
12126 	/* Timeout 30s */
12127 	spkt->satapkt_time = sata_default_pkt_time;
12128 
12129 	scmd = &spkt->satapkt_cmd;
12130 	scmd->satacmd_flags.sata_data_direction = SATA_DIR_READ;
12131 
12132 	/*
12133 	 * Allocate buffer for SMART SELFTEST LOG
12134 	 */
12135 	scmd->satacmd_bp = sata_alloc_local_buffer(spx,
12136 	    sizeof (struct smart_selftest_log));
12137 	if (scmd->satacmd_bp == NULL) {
12138 		sata_pkt_free(spx);
12139 		kmem_free(spx, sizeof (sata_pkt_txlate_t));
12140 		SATA_LOG_D((sata_hba_inst, CE_WARN,
12141 		    "sata_smart_selftest_log: "
12142 		    "cannot allocate buffer"));
12143 		return (-1);
12144 	}
12145 
12146 	/* Build SMART_READ_LOG cmd in the sata_pkt */
12147 	scmd->satacmd_addr_type = 0;		/* N/A */
12148 	scmd->satacmd_sec_count_lsb = 1;	/* One sector of SMART log */
12149 	scmd->satacmd_lba_low_lsb = SMART_SELFTEST_LOG_PAGE;
12150 	scmd->satacmd_lba_mid_lsb = SMART_MAGIC_VAL_1;
12151 	scmd->satacmd_lba_high_lsb = SMART_MAGIC_VAL_2;
12152 	scmd->satacmd_features_reg = SATA_SMART_READ_LOG;
12153 	scmd->satacmd_device_reg = 0;		/* Always device 0 */
12154 	scmd->satacmd_cmd_reg = SATAC_SMART;
12155 	mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst,
12156 	    sdinfo->satadrv_addr.cport)));
12157 
12158 	/* Send pkt to SATA HBA driver */
12159 	if ((*SATA_START_FUNC(sata_hba_inst))(SATA_DIP(sata_hba_inst), spkt) !=
12160 	    SATA_TRAN_ACCEPTED ||
12161 	    spkt->satapkt_reason != SATA_PKT_COMPLETED) {
12162 		mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst,
12163 		    sdinfo->satadrv_addr.cport)));
12164 		/*
12165 		 * Whoops, no SMART DATA available
12166 		 */
12167 		rval = -1;
12168 		goto fail;
12169 	} else {
12170 		mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst,
12171 		    sdinfo->satadrv_addr.cport)));
12172 		rval = ddi_dma_sync(spx->txlt_buf_dma_handle, 0, 0,
12173 			DDI_DMA_SYNC_FORKERNEL);
12174 		ASSERT(rval == DDI_SUCCESS);
12175 		bcopy(scmd->satacmd_bp->b_un.b_addr, (uint8_t *)selftest_log,
12176 		    sizeof (struct smart_selftest_log));
12177 		rval = 0;
12178 	}
12179 
12180 fail:
12181 	/* Free allocated resources */
12182 	sata_free_local_buffer(spx);
12183 	spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp = NULL;
12184 	sata_pkt_free(spx);
12185 	kmem_free(spx, sizeof (sata_pkt_txlate_t));
12186 
12187 	return (rval);
12188 }
12189 
12190 
12191 /*
12192  * Returns 0 for success, -1 otherwise
12193  *
12194  * SMART READ LOG data is returned in buffer pointed to by smart_log
12195  */
12196 static int
12197 sata_smart_read_log(
12198 	sata_hba_inst_t *sata_hba_inst,
12199 	sata_drive_info_t *sdinfo,
12200 	uint8_t *smart_log,		/* where the data should be returned */
12201 	uint8_t which_log,		/* which log should be returned */
12202 	uint8_t log_size)		/* # of 512 bytes in log */
12203 {
12204 	sata_pkt_t *spkt;
12205 	sata_cmd_t *scmd;
12206 	sata_pkt_txlate_t *spx;
12207 	int rval;
12208 
12209 	spx = kmem_zalloc(sizeof (sata_pkt_txlate_t), KM_SLEEP);
12210 	spx->txlt_sata_hba_inst = sata_hba_inst;
12211 	spx->txlt_scsi_pkt = NULL;		/* No scsi pkt involved */
12212 	spkt = sata_pkt_alloc(spx, SLEEP_FUNC);
12213 	if (spkt == NULL) {
12214 		kmem_free(spx, sizeof (sata_pkt_txlate_t));
12215 		return (-1);
12216 	}
12217 	/* address is needed now */
12218 	spkt->satapkt_device.satadev_addr = sdinfo->satadrv_addr;
12219 
12220 
12221 	/* Fill sata_pkt */
12222 	spkt->satapkt_device.satadev_addr = sdinfo->satadrv_addr;
12223 	spkt->satapkt_op_mode = SATA_OPMODE_SYNCH | SATA_OPMODE_INTERRUPTS;
12224 	/* Synchronous mode, no callback */
12225 	spkt->satapkt_comp = NULL;
12226 	/* Timeout 30s */
12227 	spkt->satapkt_time = sata_default_pkt_time;
12228 
12229 	scmd = &spkt->satapkt_cmd;
12230 	scmd->satacmd_flags.sata_data_direction = SATA_DIR_READ;
12231 
12232 	/*
12233 	 * Allocate buffer for SMART READ LOG
12234 	 */
12235 	scmd->satacmd_bp = sata_alloc_local_buffer(spx, log_size * 512);
12236 	if (scmd->satacmd_bp == NULL) {
12237 		sata_pkt_free(spx);
12238 		kmem_free(spx, sizeof (sata_pkt_txlate_t));
12239 		SATA_LOG_D((sata_hba_inst, CE_WARN,
12240 		    "sata_smart_read_log: " "cannot allocate buffer"));
12241 		return (-1);
12242 	}
12243 
12244 	/* Build SMART_READ_LOG cmd in the sata_pkt */
12245 	scmd->satacmd_addr_type = 0;		/* N/A */
12246 	scmd->satacmd_sec_count_lsb = log_size;	/* what the caller asked for */
12247 	scmd->satacmd_lba_low_lsb = which_log;	/* which log page */
12248 	scmd->satacmd_lba_mid_lsb = SMART_MAGIC_VAL_1;
12249 	scmd->satacmd_lba_high_lsb = SMART_MAGIC_VAL_2;
12250 	scmd->satacmd_features_reg = SATA_SMART_READ_LOG;
12251 	scmd->satacmd_device_reg = 0;		/* Always device 0 */
12252 	scmd->satacmd_cmd_reg = SATAC_SMART;
12253 
12254 	mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst,
12255 	    sdinfo->satadrv_addr.cport)));
12256 
12257 	/* Send pkt to SATA HBA driver */
12258 	if ((*SATA_START_FUNC(sata_hba_inst))(SATA_DIP(sata_hba_inst), spkt) !=
12259 	    SATA_TRAN_ACCEPTED ||
12260 	    spkt->satapkt_reason != SATA_PKT_COMPLETED) {
12261 		mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst,
12262 		    sdinfo->satadrv_addr.cport)));
12263 
12264 		/*
12265 		 * Whoops, no SMART DATA available
12266 		 */
12267 		rval = -1;
12268 		goto fail;
12269 	} else {
12270 		mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst,
12271 		    sdinfo->satadrv_addr.cport)));
12272 
12273 		rval = ddi_dma_sync(spx->txlt_buf_dma_handle, 0, 0,
12274 			DDI_DMA_SYNC_FORKERNEL);
12275 		ASSERT(rval == DDI_SUCCESS);
12276 		bcopy(scmd->satacmd_bp->b_un.b_addr, smart_log, log_size * 512);
12277 		rval = 0;
12278 	}
12279 
12280 fail:
12281 	/* Free allocated resources */
12282 	sata_free_local_buffer(spx);
12283 	spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp = NULL;
12284 	sata_pkt_free(spx);
12285 	kmem_free(spx, sizeof (sata_pkt_txlate_t));
12286 
12287 	return (rval);
12288 }
12289 
12290 /*
12291  * Used by LOG SENSE page 0x10
12292  *
12293  * return 0 for success, -1 otherwise
12294  *
12295  */
12296 static int
12297 sata_read_log_ext_directory(
12298 	sata_hba_inst_t *sata_hba_inst,
12299 	sata_drive_info_t *sdinfo,
12300 	struct read_log_ext_directory *logdir)
12301 {
12302 	sata_pkt_txlate_t *spx;
12303 	sata_pkt_t *spkt;
12304 	sata_cmd_t *scmd;
12305 	int rval;
12306 
12307 #if ! defined(lint)
12308 	ASSERT(sizeof (struct read_log_ext_directory) == 512);
12309 #endif
12310 
12311 	spx = kmem_zalloc(sizeof (sata_pkt_txlate_t), KM_SLEEP);
12312 	spx->txlt_sata_hba_inst = sata_hba_inst;
12313 	spx->txlt_scsi_pkt = NULL;		/* No scsi pkt involved */
12314 	spkt = sata_pkt_alloc(spx, SLEEP_FUNC);
12315 	if (spkt == NULL) {
12316 		kmem_free(spx, sizeof (sata_pkt_txlate_t));
12317 		return (-1);
12318 	}
12319 
12320 	/* Fill sata_pkt */
12321 	spkt->satapkt_device.satadev_addr = sdinfo->satadrv_addr;
12322 	spkt->satapkt_op_mode = SATA_OPMODE_SYNCH | SATA_OPMODE_INTERRUPTS;
12323 	/* Synchronous mode, no callback */
12324 	spkt->satapkt_comp = NULL;
12325 	/* Timeout 30s */
12326 	spkt->satapkt_time = sata_default_pkt_time;
12327 
12328 	scmd = &spkt->satapkt_cmd;
12329 	scmd->satacmd_flags.sata_data_direction = SATA_DIR_READ;
12330 
12331 	/*
12332 	 * Allocate buffer for SMART READ LOG EXTENDED command
12333 	 */
12334 	scmd->satacmd_bp = sata_alloc_local_buffer(spx,
12335 	    sizeof (struct read_log_ext_directory));
12336 	if (scmd->satacmd_bp == NULL) {
12337 		sata_pkt_free(spx);
12338 		kmem_free(spx, sizeof (sata_pkt_txlate_t));
12339 		SATA_LOG_D((sata_hba_inst, CE_WARN,
12340 		    "sata_read_log_ext_directory: "
12341 		    "cannot allocate buffer"));
12342 		return (-1);
12343 	}
12344 
12345 	/* Build READ LOG EXT w/ log directory cmd in the  sata_pkt */
12346 	scmd->satacmd_addr_type = ATA_ADDR_LBA48;
12347 	scmd->satacmd_sec_count_lsb = 1;	/* One sector of directory */
12348 	scmd->satacmd_sec_count_msb = 0;	/* One sector of directory */
12349 	scmd->satacmd_lba_low_lsb = READ_LOG_EXT_LOG_DIRECTORY;
12350 	scmd->satacmd_lba_low_msb = 0;
12351 	scmd->satacmd_lba_mid_lsb = 0;
12352 	scmd->satacmd_lba_mid_msb = 0;
12353 	scmd->satacmd_device_reg = 0;		/* Always device 0 */
12354 	scmd->satacmd_cmd_reg = SATAC_READ_LOG_EXT;
12355 
12356 	mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst,
12357 	    sdinfo->satadrv_addr.cport)));
12358 
12359 	/* Send pkt to SATA HBA driver */
12360 	if ((*SATA_START_FUNC(sata_hba_inst))(SATA_DIP(sata_hba_inst), spkt) !=
12361 	    SATA_TRAN_ACCEPTED ||
12362 	    spkt->satapkt_reason != SATA_PKT_COMPLETED) {
12363 		mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst,
12364 		    sdinfo->satadrv_addr.cport)));
12365 		/*
12366 		 * Whoops, no SMART selftest log info available
12367 		 */
12368 		rval = -1;
12369 		goto fail;
12370 	} else {
12371 		mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst,
12372 		    sdinfo->satadrv_addr.cport)));
12373 		rval = ddi_dma_sync(spx->txlt_buf_dma_handle, 0, 0,
12374 			DDI_DMA_SYNC_FORKERNEL);
12375 		ASSERT(rval == DDI_SUCCESS);
12376 		bcopy(scmd->satacmd_bp->b_un.b_addr, (uint8_t *)logdir,
12377 		    sizeof (struct read_log_ext_directory));
12378 		rval = 0;
12379 	}
12380 
12381 fail:
12382 	/* Free allocated resources */
12383 	sata_free_local_buffer(spx);
12384 	spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp = NULL;
12385 	sata_pkt_free(spx);
12386 	kmem_free(spx, sizeof (sata_pkt_txlate_t));
12387 
12388 	return (rval);
12389 }
12390 
12391 static void
12392 sata_gen_sysevent(sata_hba_inst_t *sata_hba_inst, sata_address_t *saddr,
12393     int hint)
12394 {
12395 	char ap[MAXPATHLEN];
12396 	nvlist_t *ev_attr_list = NULL;
12397 	int err;
12398 
12399 	/* Allocate and build sysevent attribute list */
12400 	err = nvlist_alloc(&ev_attr_list, NV_UNIQUE_NAME_TYPE, DDI_NOSLEEP);
12401 	if (err != 0) {
12402 		SATA_LOG_D((sata_hba_inst, CE_WARN,
12403 		    "sata_gen_sysevent: "
12404 		    "cannot allocate memory for sysevent attributes\n"));
12405 		return;
12406 	}
12407 	/* Add hint attribute */
12408 	err = nvlist_add_string(ev_attr_list, DR_HINT, SE_HINT2STR(hint));
12409 	if (err != 0) {
12410 		SATA_LOG_D((sata_hba_inst, CE_WARN,
12411 		    "sata_gen_sysevent: "
12412 		    "failed to add DR_HINT attr for sysevent"));
12413 		nvlist_free(ev_attr_list);
12414 		return;
12415 	}
12416 	/*
12417 	 * Add AP attribute.
12418 	 * Get controller pathname and convert it into AP pathname by adding
12419 	 * a target number.
12420 	 */
12421 	(void) snprintf(ap, MAXPATHLEN, "/devices");
12422 	(void) ddi_pathname(SATA_DIP(sata_hba_inst), ap + strlen(ap));
12423 	(void) snprintf(ap + strlen(ap), MAXPATHLEN - strlen(ap), ":%d",
12424 	    SATA_MAKE_AP_NUMBER(saddr->cport, saddr->pmport, saddr->qual));
12425 
12426 	err = nvlist_add_string(ev_attr_list, DR_AP_ID, ap);
12427 	if (err != 0) {
12428 		SATA_LOG_D((sata_hba_inst, CE_WARN,
12429 		    "sata_gen_sysevent: "
12430 		    "failed to add DR_AP_ID attr for sysevent"));
12431 		nvlist_free(ev_attr_list);
12432 		return;
12433 	}
12434 
12435 	/* Generate/log sysevent */
12436 	err = ddi_log_sysevent(SATA_DIP(sata_hba_inst), DDI_VENDOR_SUNW, EC_DR,
12437 	    ESC_DR_AP_STATE_CHANGE, ev_attr_list, NULL, DDI_NOSLEEP);
12438 	if (err != DDI_SUCCESS) {
12439 		SATA_LOG_D((sata_hba_inst, CE_WARN,
12440 		    "sata_gen_sysevent: "
12441 		    "cannot log sysevent, err code %x\n", err));
12442 	}
12443 
12444 	nvlist_free(ev_attr_list);
12445 }
12446 
12447 /*
12448  * sata_xlate_errors() is used to translate (S)ATA error
12449  * information to SCSI information returned in the SCSI
12450  * packet.
12451  */
12452 static void
12453 sata_xlate_errors(sata_pkt_txlate_t *spx)
12454 {
12455 	struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt;
12456 	struct scsi_extended_sense *sense;
12457 
12458 	scsipkt->pkt_reason = CMD_INCOMPLETE;
12459 	*scsipkt->pkt_scbp = STATUS_CHECK;
12460 	sense = sata_arq_sense(spx);
12461 
12462 	switch (spx->txlt_sata_pkt->satapkt_reason) {
12463 	case SATA_PKT_PORT_ERROR:
12464 		/*
12465 		 * We have no device data. Assume no data transfered.
12466 		 */
12467 		sense->es_key = KEY_HARDWARE_ERROR;
12468 		break;
12469 
12470 	case SATA_PKT_DEV_ERROR:
12471 		if (spx->txlt_sata_pkt->satapkt_cmd.satacmd_status_reg &
12472 		    SATA_STATUS_ERR) {
12473 			/*
12474 			 * determine dev error reason from error
12475 			 * reg content
12476 			 */
12477 			sata_decode_device_error(spx, sense);
12478 			break;
12479 		}
12480 		/* No extended sense key - no info available */
12481 		break;
12482 
12483 	case SATA_PKT_TIMEOUT:
12484 		/*
12485 		 * scsipkt->pkt_reason = CMD_TIMEOUT; This causes problems.
12486 		 */
12487 		scsipkt->pkt_reason = CMD_INCOMPLETE;
12488 		/* No extended sense key */
12489 		break;
12490 
12491 	case SATA_PKT_ABORTED:
12492 		scsipkt->pkt_reason = CMD_ABORTED;
12493 		/* No extended sense key */
12494 		break;
12495 
12496 	case SATA_PKT_RESET:
12497 		/*
12498 		 * pkt aborted either by an explicit reset request from
12499 		 * a host, or due to error recovery
12500 		 */
12501 		scsipkt->pkt_reason = CMD_RESET;
12502 		break;
12503 
12504 	default:
12505 		scsipkt->pkt_reason = CMD_TRAN_ERR;
12506 		break;
12507 	}
12508 }
12509 
12510 
12511 
12512 /*
12513  * Set DEVI_DEVICE_REMOVED state in the SATA device target node.
12514  */
12515 static void
12516 sata_set_device_removed(dev_info_t *tdip)
12517 {
12518 	int circ;
12519 
12520 	ASSERT(tdip != NULL);
12521 
12522 	ndi_devi_enter(tdip, &circ);
12523 	mutex_enter(&DEVI(tdip)->devi_lock);
12524 	DEVI_SET_DEVICE_REMOVED(tdip);
12525 	mutex_exit(&DEVI(tdip)->devi_lock);
12526 	ndi_devi_exit(tdip, circ);
12527 }
12528 
12529 
12530 /*
12531  * Set internal event instructing event daemon to try
12532  * to perform the target node cleanup.
12533  */
12534 static void
12535 sata_set_target_node_cleanup(sata_hba_inst_t *sata_hba_inst, int cport)
12536 {
12537 	mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex);
12538 	SATA_CPORT_EVENT_FLAGS(sata_hba_inst, cport) |=
12539 	    SATA_EVNT_TARGET_NODE_CLEANUP;
12540 	SATA_CPORT_INFO(sata_hba_inst, cport)->cport_tgtnode_clean = B_FALSE;
12541 	mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex);
12542 	mutex_enter(&sata_hba_inst->satahba_mutex);
12543 	sata_hba_inst->satahba_event_flags |= SATA_EVNT_MAIN;
12544 	mutex_exit(&sata_hba_inst->satahba_mutex);
12545 	mutex_enter(&sata_mutex);
12546 	sata_event_pending |= SATA_EVNT_MAIN;
12547 	mutex_exit(&sata_mutex);
12548 }
12549 
12550 
12551 /*
12552  * Check if the SATA device target node is in DEVI_DEVICE_REMOVED state,
12553  * i.e. check if the target node state indicates that it belongs to a removed
12554  * device.
12555  *
12556  * Returns B_TRUE if the target node is in DEVI_DEVICE_REMOVED state,
12557  * B_FALSE otherwise.
12558  *
12559  * NOTE: No port multiplier support.
12560  */
12561 static boolean_t
12562 sata_check_device_removed(dev_info_t *tdip)
12563 {
12564 	ASSERT(tdip != NULL);
12565 
12566 	if (DEVI_IS_DEVICE_REMOVED(tdip))
12567 		return (B_TRUE);
12568 	else
12569 		return (B_FALSE);
12570 }
12571