1 /*
2 * CDDL HEADER START
3 *
4 * The contents of this file are subject to the terms of the
5 * Common Development and Distribution License (the "License").
6 * You may not use this file except in compliance with the License.
7 *
8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9 * or http://www.opensolaris.org/os/licensing.
10 * See the License for the specific language governing permissions
11 * and limitations under the License.
12 *
13 * When distributing Covered Code, include this CDDL HEADER in each
14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15 * If applicable, add the following below this CDDL HEADER, with the
16 * fields enclosed by brackets "[]" replaced with your own identifying
17 * information: Portions Copyright [yyyy] [name of copyright owner]
18 *
19 * CDDL HEADER END
20 */
21
22 /*
23 * Copyright (c) 2006, 2010, Oracle and/or its affiliates. All rights reserved.
24 * Copyright 2016 Nexenta Systems, Inc.
25 * Copyright 2016 Argo Technologies SA
26 * Copyright (c) 2018, Joyent, Inc.
27 */
28
29 /*
30 * SATA Framework
31 * Generic SATA Host Adapter Implementation
32 */
33
34 #include <sys/conf.h>
35 #include <sys/file.h>
36 #include <sys/ddi.h>
37 #include <sys/sunddi.h>
38 #include <sys/modctl.h>
39 #include <sys/cmn_err.h>
40 #include <sys/errno.h>
41 #include <sys/thread.h>
42 #include <sys/kstat.h>
43 #include <sys/note.h>
44 #include <sys/sysevent.h>
45 #include <sys/sysevent/eventdefs.h>
46 #include <sys/sysevent/dr.h>
47 #include <sys/taskq.h>
48 #include <sys/disp.h>
49 #include <sys/sdt.h>
50
51 #include <sys/sata/impl/sata.h>
52 #include <sys/sata/sata_hba.h>
53 #include <sys/sata/sata_defs.h>
54 #include <sys/sata/sata_cfgadm.h>
55 #include <sys/sata/sata_blacklist.h>
56 #include <sys/sata/sata_satl.h>
57
58 #include <sys/scsi/impl/spc3_types.h>
59
60 /*
61 * FMA header files
62 */
63 #include <sys/ddifm.h>
64 #include <sys/fm/protocol.h>
65 #include <sys/fm/util.h>
66 #include <sys/fm/io/ddi.h>
67
68 /* Debug flags - defined in sata.h */
69 int sata_debug_flags = 0;
70 int sata_msg = 0;
71
72 /*
73 * Flags enabling selected SATA HBA framework functionality
74 */
75 #define SATA_ENABLE_QUEUING 1
76 #define SATA_ENABLE_NCQ 2
77 #define SATA_ENABLE_PROCESS_EVENTS 4
78 #define SATA_ENABLE_PMULT_FBS 8 /* FIS-Based Switching */
79 int sata_func_enable =
80 SATA_ENABLE_PROCESS_EVENTS | SATA_ENABLE_QUEUING | SATA_ENABLE_NCQ;
81
82 /*
83 * Global variable setting default maximum queue depth (NCQ or TCQ)
84 * Note:minimum queue depth is 1
85 */
86 int sata_max_queue_depth = SATA_MAX_QUEUE_DEPTH; /* max NCQ/TCQ queue depth */
87
88 /*
89 * Currently used default NCQ/TCQ queue depth. It is set-up during the driver
90 * initialization, using value from sata_max_queue_depth
91 * It is adjusted to minimum supported by the controller and by the device,
92 * if queueing is enabled.
93 */
94 static int sata_current_max_qdepth;
95
96 /*
97 * Global variable determining the default behavior after device hotpluggin.
98 * If non-zero, the hotplugged device is onlined (if possible) without explicit
99 * IOCTL request (AP_CONFIGURE).
100 * If zero, hotplugged device is identified, but not onlined.
101 * Enabling (AP_CONNECT) device port with an attached device does not result
102 * in device onlining regardless of the flag setting
103 */
104 int sata_auto_online = 0;
105
106 #ifdef SATA_DEBUG
107
108 #define SATA_LOG_D(args) sata_log args
109 uint64_t mbuf_count = 0;
110 uint64_t mbuffail_count = 0;
111
112 sata_atapi_cmd_t sata_atapi_trace[64];
113 uint32_t sata_atapi_trace_index = 0;
114 int sata_atapi_trace_save = 1;
115 static void sata_save_atapi_trace(sata_pkt_txlate_t *, int);
116 #define SATAATAPITRACE(spx, count) if (sata_atapi_trace_save) \
117 sata_save_atapi_trace(spx, count);
118
119 #else
120 #define SATA_LOG_D(args) sata_trace_log args
121 #define SATAATAPITRACE(spx, count)
122 #endif
123
124 #if 0
125 static void
126 sata_test_atapi_packet_command(sata_hba_inst_t *, int);
127 #endif
128
129 #ifdef SATA_INJECT_FAULTS
130
131 #define SATA_INJECT_PKT_FAULT 1
132 uint32_t sata_inject_fault = 0;
133
134 uint32_t sata_inject_fault_count = 0;
135 uint32_t sata_inject_fault_pause_count = 0;
136 uint32_t sata_fault_type = 0;
137 uint32_t sata_fault_cmd = 0;
138 dev_info_t *sata_fault_ctrl = NULL;
139 sata_device_t sata_fault_device;
140
141 static void sata_inject_pkt_fault(sata_pkt_t *, int *, int);
142
143 #endif
144
145 #define LEGACY_HWID_LEN 64 /* Model (40) + Serial (20) + pad */
146
147 static char sata_rev_tag[] = {"1.46"};
148
149 /*
150 * SATA cb_ops functions
151 */
152 static int sata_hba_open(dev_t *, int, int, cred_t *);
153 static int sata_hba_close(dev_t, int, int, cred_t *);
154 static int sata_hba_ioctl(dev_t, int, intptr_t, int, cred_t *, int *);
155
156 /*
157 * SCSA required entry points
158 */
159 static int sata_scsi_tgt_init(dev_info_t *, dev_info_t *,
160 scsi_hba_tran_t *, struct scsi_device *);
161 static int sata_scsi_tgt_probe(struct scsi_device *,
162 int (*callback)(void));
163 static void sata_scsi_tgt_free(dev_info_t *, dev_info_t *,
164 scsi_hba_tran_t *, struct scsi_device *);
165 static int sata_scsi_start(struct scsi_address *, struct scsi_pkt *);
166 static int sata_scsi_abort(struct scsi_address *, struct scsi_pkt *);
167 static int sata_scsi_reset(struct scsi_address *, int);
168 static int sata_scsi_getcap(struct scsi_address *, char *, int);
169 static int sata_scsi_setcap(struct scsi_address *, char *, int, int);
170 static struct scsi_pkt *sata_scsi_init_pkt(struct scsi_address *,
171 struct scsi_pkt *, struct buf *, int, int, int, int, int (*)(caddr_t),
172 caddr_t);
173 static void sata_scsi_destroy_pkt(struct scsi_address *, struct scsi_pkt *);
174 static void sata_scsi_dmafree(struct scsi_address *, struct scsi_pkt *);
175 static void sata_scsi_sync_pkt(struct scsi_address *, struct scsi_pkt *);
176
177 /*
178 * SATA HBA interface functions are defined in sata_hba.h header file
179 */
180
181 /* Event processing functions */
182 static void sata_event_daemon(void *);
183 static void sata_event_thread_control(int);
184 static void sata_process_controller_events(sata_hba_inst_t *sata_hba_inst);
185 static void sata_process_pmult_events(sata_hba_inst_t *, uint8_t);
186 static void sata_process_device_reset(sata_hba_inst_t *, sata_address_t *);
187 static void sata_process_pmdevice_reset(sata_hba_inst_t *, sata_address_t *);
188 static void sata_process_port_failed_event(sata_hba_inst_t *,
189 sata_address_t *);
190 static void sata_process_port_link_events(sata_hba_inst_t *,
191 sata_address_t *);
192 static void sata_process_pmport_link_events(sata_hba_inst_t *,
193 sata_address_t *);
194 static void sata_process_device_detached(sata_hba_inst_t *, sata_address_t *);
195 static void sata_process_pmdevice_detached(sata_hba_inst_t *,
196 sata_address_t *);
197 static void sata_process_device_attached(sata_hba_inst_t *, sata_address_t *);
198 static void sata_process_pmdevice_attached(sata_hba_inst_t *,
199 sata_address_t *);
200 static void sata_process_port_pwr_change(sata_hba_inst_t *, sata_address_t *);
201 static void sata_process_cntrl_pwr_level_change(sata_hba_inst_t *);
202 static void sata_process_target_node_cleanup(sata_hba_inst_t *,
203 sata_address_t *);
204 static void sata_process_device_autoonline(sata_hba_inst_t *,
205 sata_address_t *saddr);
206
207 /*
208 * Local translation functions
209 */
210 static int sata_txlt_inquiry(sata_pkt_txlate_t *);
211 static int sata_txlt_test_unit_ready(sata_pkt_txlate_t *);
212 static int sata_txlt_start_stop_unit(sata_pkt_txlate_t *);
213 static int sata_txlt_read_capacity(sata_pkt_txlate_t *);
214 static int sata_txlt_read_capacity16(sata_pkt_txlate_t *);
215 static int sata_txlt_unmap(sata_pkt_txlate_t *);
216 static int sata_txlt_request_sense(sata_pkt_txlate_t *);
217 static int sata_txlt_read(sata_pkt_txlate_t *);
218 static int sata_txlt_write(sata_pkt_txlate_t *);
219 static int sata_txlt_log_sense(sata_pkt_txlate_t *);
220 static int sata_txlt_log_select(sata_pkt_txlate_t *);
221 static int sata_txlt_mode_sense(sata_pkt_txlate_t *);
222 static int sata_txlt_mode_select(sata_pkt_txlate_t *);
223 static int sata_txlt_ata_pass_thru(sata_pkt_txlate_t *);
224 static int sata_txlt_synchronize_cache(sata_pkt_txlate_t *);
225 static int sata_txlt_write_buffer(sata_pkt_txlate_t *);
226 static int sata_txlt_nodata_cmd_immediate(sata_pkt_txlate_t *);
227
228 static int sata_hba_start(sata_pkt_txlate_t *, int *);
229 static int sata_txlt_invalid_command(sata_pkt_txlate_t *);
230 static int sata_txlt_check_condition(sata_pkt_txlate_t *, uchar_t, uchar_t);
231 static int sata_txlt_lba_out_of_range(sata_pkt_txlate_t *);
232 static int sata_txlt_ata_pass_thru_illegal_cmd(sata_pkt_txlate_t *);
233 static int sata_txlt_unmap_nodata_cmd(sata_pkt_txlate_t *);
234 static void sata_txlt_rw_completion(sata_pkt_t *);
235 static void sata_txlt_nodata_cmd_completion(sata_pkt_t *);
236 static void sata_txlt_apt_completion(sata_pkt_t *sata_pkt);
237 static void sata_txlt_unmap_completion(sata_pkt_t *sata_pkt);
238 static void sata_txlt_download_mcode_cmd_completion(sata_pkt_t *);
239 static int sata_emul_rw_completion(sata_pkt_txlate_t *);
240 static void sata_fill_ata_return_desc(sata_pkt_t *, uint8_t, uint8_t,
241 uint8_t);
242 static struct scsi_extended_sense *sata_immediate_error_response(
243 sata_pkt_txlate_t *, int);
244 static struct scsi_extended_sense *sata_arq_sense(sata_pkt_txlate_t *);
245
246 static int sata_txlt_atapi(sata_pkt_txlate_t *);
247 static void sata_txlt_atapi_completion(sata_pkt_t *);
248
249 /*
250 * Local functions for ioctl
251 */
252 static int32_t sata_get_port_num(sata_hba_inst_t *, struct devctl_iocdata *);
253 static void sata_cfgadm_state(sata_hba_inst_t *, int32_t,
254 devctl_ap_state_t *);
255 static dev_info_t *sata_get_target_dip(dev_info_t *, uint8_t, uint8_t);
256 static dev_info_t *sata_get_scsi_target_dip(dev_info_t *, sata_address_t *);
257 static dev_info_t *sata_devt_to_devinfo(dev_t);
258 static int sata_ioctl_connect(sata_hba_inst_t *, sata_device_t *);
259 static int sata_ioctl_disconnect(sata_hba_inst_t *, sata_device_t *);
260 static int sata_ioctl_configure(sata_hba_inst_t *, sata_device_t *);
261 static int sata_ioctl_unconfigure(sata_hba_inst_t *, sata_device_t *);
262 static int sata_ioctl_activate(sata_hba_inst_t *, sata_device_t *);
263 static int sata_ioctl_deactivate(sata_hba_inst_t *, sata_device_t *);
264 static int sata_ioctl_reset_port(sata_hba_inst_t *, sata_device_t *);
265 static int sata_ioctl_reset_device(sata_hba_inst_t *, sata_device_t *);
266 static int sata_ioctl_reset_all(sata_hba_inst_t *);
267 static int sata_ioctl_port_self_test(sata_hba_inst_t *, sata_device_t *);
268 static int sata_ioctl_get_device_path(sata_hba_inst_t *, sata_device_t *,
269 sata_ioctl_data_t *, int mode);
270 static int sata_ioctl_get_ap_type(sata_hba_inst_t *, sata_device_t *,
271 sata_ioctl_data_t *, int mode);
272 static int sata_ioctl_get_model_info(sata_hba_inst_t *, sata_device_t *,
273 sata_ioctl_data_t *, int mode);
274 static int sata_ioctl_get_revfirmware_info(sata_hba_inst_t *, sata_device_t *,
275 sata_ioctl_data_t *, int mode);
276 static int sata_ioctl_get_serialnumber_info(sata_hba_inst_t *,
277 sata_device_t *, sata_ioctl_data_t *, int mode);
278
279 /*
280 * Local functions
281 */
282 static void sata_remove_hba_instance(dev_info_t *);
283 static int sata_validate_sata_hba_tran(dev_info_t *, sata_hba_tran_t *);
284 static void sata_probe_ports(sata_hba_inst_t *);
285 static void sata_probe_pmports(sata_hba_inst_t *, uint8_t);
286 static int sata_reprobe_port(sata_hba_inst_t *, sata_device_t *, int);
287 static int sata_reprobe_pmult(sata_hba_inst_t *, sata_device_t *, int);
288 static int sata_reprobe_pmport(sata_hba_inst_t *, sata_device_t *, int);
289 static int sata_alloc_pmult(sata_hba_inst_t *, sata_device_t *);
290 static void sata_free_pmult(sata_hba_inst_t *, sata_device_t *);
291 static int sata_add_device(dev_info_t *, sata_hba_inst_t *, sata_device_t *);
292 static int sata_offline_device(sata_hba_inst_t *, sata_device_t *,
293 sata_drive_info_t *);
294 static dev_info_t *sata_create_target_node(dev_info_t *, sata_hba_inst_t *,
295 sata_address_t *);
296 static void sata_remove_target_node(sata_hba_inst_t *,
297 sata_address_t *);
298 static int sata_validate_scsi_address(sata_hba_inst_t *,
299 struct scsi_address *, sata_device_t *);
300 static int sata_validate_sata_address(sata_hba_inst_t *, int, int, int);
301 static sata_pkt_t *sata_pkt_alloc(sata_pkt_txlate_t *, int (*)(caddr_t));
302 static void sata_pkt_free(sata_pkt_txlate_t *);
303 static int sata_dma_buf_setup(sata_pkt_txlate_t *, int, int (*)(caddr_t),
304 caddr_t, ddi_dma_attr_t *);
305 static void sata_common_free_dma_rsrcs(sata_pkt_txlate_t *);
306 static int sata_probe_device(sata_hba_inst_t *, sata_device_t *);
307 static sata_drive_info_t *sata_get_device_info(sata_hba_inst_t *,
308 sata_device_t *);
309 static int sata_identify_device(sata_hba_inst_t *, sata_drive_info_t *);
310 static void sata_reidentify_device(sata_pkt_txlate_t *);
311 static struct buf *sata_alloc_local_buffer(sata_pkt_txlate_t *, int);
312 static void sata_free_local_buffer(sata_pkt_txlate_t *);
313 static uint64_t sata_check_capacity(sata_drive_info_t *);
314 void sata_adjust_dma_attr(sata_drive_info_t *, ddi_dma_attr_t *,
315 ddi_dma_attr_t *);
316 static int sata_fetch_device_identify_data(sata_hba_inst_t *,
317 sata_drive_info_t *);
318 static void sata_update_port_info(sata_hba_inst_t *, sata_device_t *);
319 static void sata_update_pmport_info(sata_hba_inst_t *, sata_device_t *);
320 static void sata_update_port_scr(sata_port_scr_t *, sata_device_t *);
321 static int sata_set_dma_mode(sata_hba_inst_t *, sata_drive_info_t *);
322 static int sata_set_cache_mode(sata_hba_inst_t *, sata_drive_info_t *, int);
323 static int sata_set_rmsn(sata_hba_inst_t *, sata_drive_info_t *, int);
324 static int sata_set_drive_features(sata_hba_inst_t *,
325 sata_drive_info_t *, int flag);
326 static void sata_init_write_cache_mode(sata_drive_info_t *sdinfo);
327 static int sata_initialize_device(sata_hba_inst_t *, sata_drive_info_t *);
328 static void sata_identdev_to_inquiry(sata_hba_inst_t *, sata_drive_info_t *,
329 uint8_t *);
330 static int sata_get_atapi_inquiry_data(sata_hba_inst_t *, sata_address_t *,
331 struct scsi_inquiry *);
332 static int sata_build_msense_page_1(sata_drive_info_t *, int, uint8_t *);
333 static int sata_build_msense_page_8(sata_drive_info_t *, int, uint8_t *);
334 static int sata_build_msense_page_1a(sata_drive_info_t *, int, uint8_t *);
335 static int sata_build_msense_page_1c(sata_drive_info_t *, int, uint8_t *);
336 static int sata_build_msense_page_30(sata_drive_info_t *, int, uint8_t *);
337 static int sata_mode_select_page_8(sata_pkt_txlate_t *,
338 struct mode_cache_scsi3 *, int, int *, int *, int *);
339 static int sata_mode_select_page_1a(sata_pkt_txlate_t *,
340 struct mode_info_power_cond *, int, int *, int *, int *);
341 static int sata_mode_select_page_1c(sata_pkt_txlate_t *,
342 struct mode_info_excpt_page *, int, int *, int *, int *);
343 static int sata_mode_select_page_30(sata_pkt_txlate_t *,
344 struct mode_acoustic_management *, int, int *, int *, int *);
345
346 static int sata_build_lsense_page_0(sata_drive_info_t *, uint8_t *);
347 static int sata_build_lsense_page_10(sata_drive_info_t *, uint8_t *,
348 sata_hba_inst_t *);
349 static int sata_build_lsense_page_2f(sata_drive_info_t *, uint8_t *,
350 sata_hba_inst_t *);
351 static int sata_build_lsense_page_30(sata_drive_info_t *, uint8_t *,
352 sata_hba_inst_t *);
353 static int sata_build_lsense_page_0e(sata_drive_info_t *, uint8_t *,
354 sata_pkt_txlate_t *);
355
356 static void sata_set_arq_data(sata_pkt_t *);
357 static void sata_build_read_verify_cmd(sata_cmd_t *, uint16_t, uint64_t);
358 static void sata_build_generic_cmd(sata_cmd_t *, uint8_t);
359 static uint8_t sata_get_standby_timer(uint8_t *timer);
360
361 static void sata_save_drive_settings(sata_drive_info_t *);
362 static void sata_show_drive_info(sata_hba_inst_t *, sata_drive_info_t *);
363 static void sata_show_pmult_info(sata_hba_inst_t *, sata_device_t *);
364 static void sata_log(sata_hba_inst_t *, uint_t, char *fmt, ...);
365 static void sata_trace_log(sata_hba_inst_t *, uint_t, const char *fmt, ...);
366 static int sata_fetch_smart_return_status(sata_hba_inst_t *,
367 sata_drive_info_t *);
368 static int sata_fetch_smart_data(sata_hba_inst_t *, sata_drive_info_t *,
369 struct smart_data *);
370 static int sata_smart_selftest_log(sata_hba_inst_t *,
371 sata_drive_info_t *,
372 struct smart_selftest_log *);
373 static int sata_ext_smart_selftest_read_log(sata_hba_inst_t *,
374 sata_drive_info_t *, struct smart_ext_selftest_log *, uint16_t);
375 static int sata_smart_read_log(sata_hba_inst_t *, sata_drive_info_t *,
376 uint8_t *, uint8_t, uint8_t);
377 static int sata_read_log_ext_directory(sata_hba_inst_t *, sata_drive_info_t *,
378 struct read_log_ext_directory *);
379 static void sata_gen_sysevent(sata_hba_inst_t *, sata_address_t *, int);
380 static void sata_xlate_errors(sata_pkt_txlate_t *);
381 static void sata_decode_device_error(sata_pkt_txlate_t *,
382 struct scsi_extended_sense *);
383 static void sata_set_device_removed(dev_info_t *);
384 static boolean_t sata_check_device_removed(dev_info_t *);
385 static void sata_set_target_node_cleanup(sata_hba_inst_t *, sata_address_t *);
386 static int sata_ncq_err_ret_cmd_setup(sata_pkt_txlate_t *,
387 sata_drive_info_t *);
388 static int sata_atapi_err_ret_cmd_setup(sata_pkt_txlate_t *,
389 sata_drive_info_t *);
390 static void sata_atapi_packet_cmd_setup(sata_cmd_t *, sata_drive_info_t *);
391 static void sata_fixed_sense_data_preset(struct scsi_extended_sense *);
392 static void sata_target_devid_register(dev_info_t *, sata_drive_info_t *);
393 static int sata_check_modser(char *, int);
394
395 /*
396 * FMA
397 */
398 static boolean_t sata_check_for_dma_error(dev_info_t *, sata_pkt_txlate_t *);
399
400
401 /*
402 * SATA Framework will ignore SATA HBA driver cb_ops structure and
403 * register following one with SCSA framework.
404 * Open & close are provided, so scsi framework will not use its own
405 */
406 static struct cb_ops sata_cb_ops = {
407 sata_hba_open, /* open */
408 sata_hba_close, /* close */
409 nodev, /* strategy */
410 nodev, /* print */
411 nodev, /* dump */
412 nodev, /* read */
413 nodev, /* write */
414 sata_hba_ioctl, /* ioctl */
415 nodev, /* devmap */
416 nodev, /* mmap */
417 nodev, /* segmap */
418 nochpoll, /* chpoll */
419 ddi_prop_op, /* cb_prop_op */
420 0, /* streamtab */
421 D_NEW | D_MP, /* cb_flag */
422 CB_REV, /* rev */
423 nodev, /* aread */
424 nodev /* awrite */
425 };
426
427
428 extern struct mod_ops mod_miscops;
429 extern uchar_t scsi_cdb_size[];
430
431 static struct modlmisc modlmisc = {
432 &mod_miscops, /* Type of module */
433 "SATA Module" /* module name */
434 };
435
436
437 static struct modlinkage modlinkage = {
438 MODREV_1,
439 (void *)&modlmisc,
440 NULL
441 };
442
443 /*
444 * Default sata pkt timeout. Used when a target driver scsi_pkt time is zero,
445 * i.e. when scsi_pkt has not timeout specified.
446 */
447 static int sata_default_pkt_time = 60; /* 60 seconds */
448
449 /*
450 * Intermediate buffer device access attributes - they are required,
451 * but not necessarily used.
452 */
453 static ddi_device_acc_attr_t sata_acc_attr = {
454 DDI_DEVICE_ATTR_V0,
455 DDI_STRUCTURE_LE_ACC,
456 DDI_STRICTORDER_ACC
457 };
458
459
460 /*
461 * Mutexes protecting structures in multithreaded operations.
462 * Because events are relatively rare, a single global mutex protecting
463 * data structures should be sufficient. To increase performance, add
464 * separate mutex per each sata port and use global mutex only to protect
465 * common data structures.
466 */
467 static kmutex_t sata_mutex; /* protects sata_hba_list */
468 static kmutex_t sata_log_mutex; /* protects log */
469
470 static char sata_log_buf[256];
471
472 /*
473 * sata trace debug
474 */
475 static sata_trace_rbuf_t *sata_debug_rbuf;
476 static sata_trace_dmsg_t *sata_trace_dmsg_alloc(void);
477 static void sata_trace_dmsg_free(void);
478 static void sata_trace_rbuf_alloc(void);
479 static void sata_trace_rbuf_free(void);
480
481 int dmsg_ring_size = DMSG_RING_SIZE;
482
483 /* Default write cache setting for SATA hard disks */
484 int sata_write_cache = 1; /* enabled */
485
486 /* Default write cache setting for SATA ATAPI CD/DVD */
487 int sata_atapicdvd_write_cache = 1; /* enabled */
488
489 /* Default write cache setting for SATA ATAPI tape */
490 int sata_atapitape_write_cache = 1; /* enabled */
491
492 /* Default write cache setting for SATA ATAPI disk */
493 int sata_atapidisk_write_cache = 1; /* enabled */
494
495 /*
496 * Linked list of HBA instances
497 */
498 static sata_hba_inst_t *sata_hba_list = NULL;
499 static sata_hba_inst_t *sata_hba_list_tail = NULL;
500 /*
501 * Pointer to per-instance SATA HBA soft structure is stored in sata_hba_tran
502 * structure and in sata soft state.
503 */
504
505 /*
506 * Event daemon related variables
507 */
508 static kmutex_t sata_event_mutex;
509 static kcondvar_t sata_event_cv;
510 static kthread_t *sata_event_thread = NULL;
511 static int sata_event_thread_terminate = 0;
512 static int sata_event_pending = 0;
513 static int sata_event_thread_active = 0;
514 extern pri_t minclsyspri;
515
516 /*
517 * NCQ error recovery command
518 */
519 static const sata_cmd_t sata_rle_cmd = {
520 SATA_CMD_REV,
521 NULL,
522 {
523 SATA_DIR_READ
524 },
525 ATA_ADDR_LBA48,
526 0,
527 0,
528 0,
529 0,
530 0,
531 1,
532 READ_LOG_EXT_NCQ_ERROR_RECOVERY,
533 0,
534 0,
535 0,
536 SATAC_READ_LOG_EXT,
537 0,
538 0,
539 0,
540 };
541
542 /*
543 * ATAPI error recovery CDB
544 */
545 static const uint8_t sata_rqsense_cdb[SATA_ATAPI_RQSENSE_CDB_LEN] = {
546 SCMD_REQUEST_SENSE,
547 0, /* Only fixed RQ format is supported */
548 0,
549 0,
550 SATA_ATAPI_MIN_RQSENSE_LEN, /* Less data may be returned */
551 0
552 };
553
554
555 /* Warlock directives */
556
557 _NOTE(SCHEME_PROTECTS_DATA("No Mutex Needed", scsi_hba_tran))
558 _NOTE(SCHEME_PROTECTS_DATA("No Mutex Needed", scsi_device))
559 _NOTE(SCHEME_PROTECTS_DATA("No Mutex Needed", dev_ops))
560 _NOTE(SCHEME_PROTECTS_DATA("No Mutex Needed", scsi_extended_sense))
561 _NOTE(SCHEME_PROTECTS_DATA("No Mutex Needed", scsi_arq_status))
562 _NOTE(SCHEME_PROTECTS_DATA("No Mutex Needed", ddi_dma_attr))
563 _NOTE(SCHEME_PROTECTS_DATA("No Mutex Needed", ddi_dma_cookie_t))
564 _NOTE(SCHEME_PROTECTS_DATA("No Mutex Needed", devctl_ap_state))
565 _NOTE(SCHEME_PROTECTS_DATA("No Mutex Needed", dev_info::devi_state))
566 _NOTE(MUTEX_PROTECTS_DATA(sata_mutex, sata_hba_list))
567 _NOTE(DATA_READABLE_WITHOUT_LOCK(sata_hba_list))
568 _NOTE(MUTEX_PROTECTS_DATA(sata_mutex, sata_hba_inst::satahba_next))
569 _NOTE(MUTEX_PROTECTS_DATA(sata_mutex, sata_hba_inst::satahba_prev))
570 _NOTE(SCHEME_PROTECTS_DATA("No Mutex Needed", \
571 sata_hba_inst::satahba_scsi_tran))
572 _NOTE(SCHEME_PROTECTS_DATA("No Mutex Needed", sata_hba_inst::satahba_tran))
573 _NOTE(SCHEME_PROTECTS_DATA("No Mutex Needed", sata_hba_inst::satahba_dip))
574 _NOTE(SCHEME_PROTECTS_DATA("Scheme", sata_hba_inst::satahba_attached))
575 _NOTE(DATA_READABLE_WITHOUT_LOCK(sata_hba_inst::satahba_dev_port))
576 _NOTE(MUTEX_PROTECTS_DATA(sata_hba_inst::satahba_mutex,
577 sata_hba_inst::satahba_event_flags))
578 _NOTE(MUTEX_PROTECTS_DATA(sata_cport_info::cport_mutex, \
579 sata_cport_info::cport_devp))
580 _NOTE(DATA_READABLE_WITHOUT_LOCK(sata_cport_info::cport_devp))
581 _NOTE(SCHEME_PROTECTS_DATA("Scheme", sata_cport_info::cport_addr))
582 _NOTE(MUTEX_PROTECTS_DATA(sata_cport_info::cport_mutex, \
583 sata_cport_info::cport_dev_type))
584 _NOTE(DATA_READABLE_WITHOUT_LOCK(sata_cport_info::cport_dev_type))
585 _NOTE(MUTEX_PROTECTS_DATA(sata_cport_info::cport_mutex, \
586 sata_cport_info::cport_state))
587 _NOTE(DATA_READABLE_WITHOUT_LOCK(sata_cport_info::cport_state))
588 _NOTE(MUTEX_PROTECTS_DATA(sata_pmport_info::pmport_mutex, \
589 sata_pmport_info::pmport_state))
590 _NOTE(DATA_READABLE_WITHOUT_LOCK(sata_pmport_info::pmport_state))
591 _NOTE(MUTEX_PROTECTS_DATA(sata_pmport_info::pmport_mutex, \
592 sata_pmport_info::pmport_dev_type))
593 _NOTE(DATA_READABLE_WITHOUT_LOCK(sata_pmport_info::pmport_dev_type))
594 _NOTE(MUTEX_PROTECTS_DATA(sata_pmport_info::pmport_mutex, \
595 sata_pmport_info::pmport_sata_drive))
596 _NOTE(MUTEX_PROTECTS_DATA(sata_pmport_info::pmport_mutex, \
597 sata_pmport_info::pmport_tgtnode_clean))
598 _NOTE(MUTEX_PROTECTS_DATA(sata_pmport_info::pmport_mutex, \
599 sata_pmport_info::pmport_event_flags))
600 _NOTE(DATA_READABLE_WITHOUT_LOCK(sata_pmport_info::pmport_sata_drive))
601 _NOTE(DATA_READABLE_WITHOUT_LOCK(sata_pmult_info::pmult_dev_port))
602 _NOTE(DATA_READABLE_WITHOUT_LOCK(sata_pmult_info::pmult_num_dev_ports))
603 #ifdef SATA_DEBUG
604 _NOTE(SCHEME_PROTECTS_DATA("No Mutex Needed", mbuf_count))
605 _NOTE(SCHEME_PROTECTS_DATA("No Mutex Needed", mbuffail_count))
606 _NOTE(SCHEME_PROTECTS_DATA("No Mutex Needed", sata_atapi_trace))
607 _NOTE(SCHEME_PROTECTS_DATA("No Mutex Needed", sata_atapi_trace_index))
608 #endif
609
610 /* End of warlock directives */
611
612 /* ************** loadable module configuration functions ************** */
613
614 int
615 _init()
616 {
617 int rval;
618
619 mutex_init(&sata_mutex, NULL, MUTEX_DRIVER, NULL);
620 mutex_init(&sata_event_mutex, NULL, MUTEX_DRIVER, NULL);
621 mutex_init(&sata_log_mutex, NULL, MUTEX_DRIVER, NULL);
622 cv_init(&sata_event_cv, NULL, CV_DRIVER, NULL);
623 sata_trace_rbuf_alloc();
624 if ((rval = mod_install(&modlinkage)) != 0) {
625 #ifdef SATA_DEBUG
626 cmn_err(CE_WARN, "sata: _init: mod_install failed\n");
627 #endif
628 sata_trace_rbuf_free();
629 mutex_destroy(&sata_log_mutex);
630 cv_destroy(&sata_event_cv);
631 mutex_destroy(&sata_event_mutex);
632 mutex_destroy(&sata_mutex);
633 }
634 return (rval);
635 }
636
637 int
638 _fini()
639 {
640 int rval;
641
642 if ((rval = mod_remove(&modlinkage)) != 0)
643 return (rval);
644
645 sata_trace_rbuf_free();
646 mutex_destroy(&sata_log_mutex);
647 cv_destroy(&sata_event_cv);
648 mutex_destroy(&sata_event_mutex);
649 mutex_destroy(&sata_mutex);
650 return (rval);
651 }
652
653 int
654 _info(struct modinfo *modinfop)
655 {
656 return (mod_info(&modlinkage, modinfop));
657 }
658
659
660
661 /* ********************* SATA HBA entry points ********************* */
662
663
664 /*
665 * Called by SATA HBA from _init().
666 * Registers HBA driver instance/sata framework pair with scsi framework, by
667 * calling scsi_hba_init().
668 *
669 * SATA HBA driver cb_ops are ignored - SATA HBA framework cb_ops are used
670 * instead. SATA HBA framework cb_ops pointer overwrites SATA HBA driver
671 * cb_ops pointer in SATA HBA driver dev_ops structure.
672 * SATA HBA framework cb_ops supplies cb_open cb_close and cb_ioctl vectors.
673 *
674 * Return status of the scsi_hba_init() is returned to a calling SATA HBA
675 * driver.
676 */
677 int
678 sata_hba_init(struct modlinkage *modlp)
679 {
680 int rval;
681 struct dev_ops *hba_ops;
682
683 SATADBG1(SATA_DBG_HBA_IF, NULL,
684 "sata_hba_init: name %s \n",
685 ((struct modldrv *)(modlp->ml_linkage[0]))->drv_linkinfo);
686 /*
687 * Fill-up cb_ops and dev_ops when necessary
688 */
689 hba_ops = ((struct modldrv *)(modlp->ml_linkage[0]))->drv_dev_ops;
690 /*
691 * Provide pointer to SATA dev_ops
692 */
693 hba_ops->devo_cb_ops = &sata_cb_ops;
694
695 /*
696 * Register SATA HBA with SCSI framework
697 */
698 if ((rval = scsi_hba_init(modlp)) != 0) {
699 SATADBG1(SATA_DBG_HBA_IF, NULL,
700 "sata_hba_init: scsi hba init failed\n", NULL);
701 return (rval);
702 }
703
704 return (0);
705 }
706
707
708 /* HBA attach stages */
709 #define HBA_ATTACH_STAGE_SATA_HBA_INST 1
710 #define HBA_ATTACH_STAGE_SCSI_ATTACHED 2
711 #define HBA_ATTACH_STAGE_SETUP 4
712 #define HBA_ATTACH_STAGE_LINKED 8
713
714
715 /*
716 *
717 * Called from SATA HBA driver's attach routine to attach an instance of
718 * the HBA.
719 *
720 * For DDI_ATTACH command:
721 * sata_hba_inst structure is allocated here and initialized with pointers to
722 * SATA framework implementation of required scsi tran functions.
723 * The scsi_tran's tran_hba_private field is used by SATA Framework to point
724 * to the soft structure (sata_hba_inst) allocated by SATA framework for
725 * SATA HBA instance related data.
726 * The scsi_tran's tran_hba_private field is used by SATA framework to
727 * store a pointer to per-HBA-instance of sata_hba_inst structure.
728 * The sata_hba_inst structure is cross-linked to scsi tran structure.
729 * Among other info, a pointer to sata_hba_tran structure is stored in
730 * sata_hba_inst. The sata_hba_inst structures for different HBA instances are
731 * linked together into the list, pointed to by sata_hba_list.
732 * On the first HBA instance attach the sata event thread is initialized.
733 * Attachment points are created for all SATA ports of the HBA being attached.
734 * All HBA instance's SATA ports are probed and type of plugged devices is
735 * determined. For each device of a supported type, a target node is created.
736 *
737 * DDI_SUCCESS is returned when attachment process is successful,
738 * DDI_FAILURE is returned otherwise.
739 *
740 * For DDI_RESUME command:
741 * Not implemented at this time (postponed until phase 2 of the development).
742 */
743 int
744 sata_hba_attach(dev_info_t *dip, sata_hba_tran_t *sata_tran,
745 ddi_attach_cmd_t cmd)
746 {
747 sata_hba_inst_t *sata_hba_inst;
748 scsi_hba_tran_t *scsi_tran = NULL;
749 int hba_attach_state = 0;
750 char taskq_name[MAXPATHLEN];
751
752 SATADBG3(SATA_DBG_HBA_IF, NULL,
753 "sata_hba_attach: node %s (%s%d)\n",
754 ddi_node_name(dip), ddi_driver_name(dip),
755 ddi_get_instance(dip));
756
757 if (cmd == DDI_RESUME) {
758 /*
759 * Postponed until phase 2 of the development
760 */
761 return (DDI_FAILURE);
762 }
763
764 if (cmd != DDI_ATTACH) {
765 return (DDI_FAILURE);
766 }
767
768 /* cmd == DDI_ATTACH */
769
770 if (sata_validate_sata_hba_tran(dip, sata_tran) != SATA_SUCCESS) {
771 SATA_LOG_D((NULL, CE_WARN,
772 "sata_hba_attach: invalid sata_hba_tran"));
773 return (DDI_FAILURE);
774 }
775 /*
776 * Allocate and initialize SCSI tran structure.
777 * SATA copy of tran_bus_config is provided to create port nodes.
778 */
779 scsi_tran = scsi_hba_tran_alloc(dip, SCSI_HBA_CANSLEEP);
780 if (scsi_tran == NULL)
781 return (DDI_FAILURE);
782 /*
783 * Allocate soft structure for SATA HBA instance.
784 * There is a separate softstate for each HBA instance.
785 */
786 sata_hba_inst = kmem_zalloc(sizeof (struct sata_hba_inst), KM_SLEEP);
787 ASSERT(sata_hba_inst != NULL); /* this should not fail */
788 mutex_init(&sata_hba_inst->satahba_mutex, NULL, MUTEX_DRIVER, NULL);
789 hba_attach_state |= HBA_ATTACH_STAGE_SATA_HBA_INST;
790
791 /*
792 * scsi_trans's tran_hba_private is used by SATA Framework to point to
793 * soft structure allocated by SATA framework for
794 * SATA HBA instance related data.
795 */
796 scsi_tran->tran_hba_private = sata_hba_inst;
797 scsi_tran->tran_tgt_private = NULL;
798
799 scsi_tran->tran_tgt_init = sata_scsi_tgt_init;
800 scsi_tran->tran_tgt_probe = sata_scsi_tgt_probe;
801 scsi_tran->tran_tgt_free = sata_scsi_tgt_free;
802
803 scsi_tran->tran_start = sata_scsi_start;
804 scsi_tran->tran_reset = sata_scsi_reset;
805 scsi_tran->tran_abort = sata_scsi_abort;
806 scsi_tran->tran_getcap = sata_scsi_getcap;
807 scsi_tran->tran_setcap = sata_scsi_setcap;
808 scsi_tran->tran_init_pkt = sata_scsi_init_pkt;
809 scsi_tran->tran_destroy_pkt = sata_scsi_destroy_pkt;
810
811 scsi_tran->tran_dmafree = sata_scsi_dmafree;
812 scsi_tran->tran_sync_pkt = sata_scsi_sync_pkt;
813
814 scsi_tran->tran_reset_notify = NULL;
815 scsi_tran->tran_get_bus_addr = NULL;
816 scsi_tran->tran_quiesce = NULL;
817 scsi_tran->tran_unquiesce = NULL;
818 scsi_tran->tran_bus_reset = NULL;
819
820 if (scsi_hba_attach_setup(dip, sata_tran->sata_tran_hba_dma_attr,
821 scsi_tran, 0) != DDI_SUCCESS) {
822 #ifdef SATA_DEBUG
823 cmn_err(CE_WARN, "?SATA: %s%d hba scsi attach failed",
824 ddi_driver_name(dip), ddi_get_instance(dip));
825 #endif
826 goto fail;
827 }
828 hba_attach_state |= HBA_ATTACH_STAGE_SCSI_ATTACHED;
829
830 if (!ddi_prop_exists(DDI_DEV_T_ANY, dip, DDI_PROP_DONTPASS, "sata")) {
831 if (ddi_prop_update_int(DDI_DEV_T_NONE, dip,
832 "sata", 1) != DDI_PROP_SUCCESS) {
833 SATA_LOG_D((NULL, CE_WARN, "sata_hba_attach: "
834 "failed to create hba sata prop"));
835 goto fail;
836 }
837 }
838
839 /*
840 * Save pointers in hba instance soft state.
841 */
842 sata_hba_inst->satahba_scsi_tran = scsi_tran;
843 sata_hba_inst->satahba_tran = sata_tran;
844 sata_hba_inst->satahba_dip = dip;
845
846 /*
847 * Create a task queue to handle emulated commands completion
848 * Use node name, dash, instance number as the queue name.
849 */
850 taskq_name[0] = '\0';
851 (void) strlcat(taskq_name, DEVI(dip)->devi_node_name,
852 sizeof (taskq_name));
853 (void) snprintf(taskq_name + strlen(taskq_name),
854 sizeof (taskq_name) - strlen(taskq_name),
855 "-%d", DEVI(dip)->devi_instance);
856 sata_hba_inst->satahba_taskq = taskq_create(taskq_name, 1,
857 minclsyspri, 1, sata_tran->sata_tran_hba_num_cports * 4,
858 TASKQ_DYNAMIC);
859
860 hba_attach_state |= HBA_ATTACH_STAGE_SETUP;
861
862 /*
863 * Create events thread if not created yet.
864 */
865 sata_event_thread_control(1);
866
867 /*
868 * Link this hba instance into the list.
869 */
870 mutex_enter(&sata_mutex);
871
872 if (sata_hba_list == NULL) {
873 /*
874 * The first instance of HBA is attached.
875 * Set current/active default maximum NCQ/TCQ queue depth for
876 * all SATA devices. It is done here and now, to eliminate the
877 * possibility of the dynamic, programatic modification of the
878 * queue depth via global (and public) sata_max_queue_depth
879 * variable (this would require special handling in HBA drivers)
880 */
881 sata_current_max_qdepth = sata_max_queue_depth;
882 if (sata_current_max_qdepth > 32)
883 sata_current_max_qdepth = 32;
884 else if (sata_current_max_qdepth < 1)
885 sata_current_max_qdepth = 1;
886 }
887
888 sata_hba_inst->satahba_next = NULL;
889 sata_hba_inst->satahba_prev = sata_hba_list_tail;
890 if (sata_hba_list == NULL) {
891 sata_hba_list = sata_hba_inst;
892 }
893 if (sata_hba_list_tail != NULL) {
894 sata_hba_list_tail->satahba_next = sata_hba_inst;
895 }
896 sata_hba_list_tail = sata_hba_inst;
897 mutex_exit(&sata_mutex);
898 hba_attach_state |= HBA_ATTACH_STAGE_LINKED;
899
900 /*
901 * Create SATA HBA devctl minor node for sata_hba_open, close, ioctl
902 * SATA HBA driver should not use its own open/close entry points.
903 *
904 * Make sure that instance number doesn't overflow
905 * when forming minor numbers.
906 */
907 ASSERT(ddi_get_instance(dip) <= (L_MAXMIN >> INST_MINOR_SHIFT));
908 if (ddi_create_minor_node(dip, "devctl", S_IFCHR,
909 INST2DEVCTL(ddi_get_instance(dip)),
910 DDI_NT_SATA_NEXUS, 0) != DDI_SUCCESS) {
911 #ifdef SATA_DEBUG
912 cmn_err(CE_WARN, "sata_hba_attach: "
913 "cannot create devctl minor node");
914 #endif
915 goto fail;
916 }
917
918
919 /*
920 * Set-up kstats here, if necessary.
921 * (postponed until future phase of the development).
922 */
923
924 /*
925 * Indicate that HBA is attached. This will enable events processing
926 * for this HBA.
927 */
928 sata_hba_inst->satahba_attached = 1;
929 /*
930 * Probe controller ports. This operation will describe a current
931 * controller/port/multipliers/device configuration and will create
932 * attachment points.
933 * We may end-up with just a controller with no devices attached.
934 * For the ports with a supported device attached, device target nodes
935 * are created and devices are initialized.
936 */
937 sata_probe_ports(sata_hba_inst);
938
939 return (DDI_SUCCESS);
940
941 fail:
942 if (hba_attach_state & HBA_ATTACH_STAGE_LINKED) {
943 (void) sata_remove_hba_instance(dip);
944 if (sata_hba_list == NULL)
945 sata_event_thread_control(0);
946 }
947
948 if (hba_attach_state & HBA_ATTACH_STAGE_SETUP) {
949 (void) ddi_prop_remove(DDI_DEV_T_ANY, dip, "sata");
950 taskq_destroy(sata_hba_inst->satahba_taskq);
951 }
952
953 if (hba_attach_state & HBA_ATTACH_STAGE_SCSI_ATTACHED)
954 (void) scsi_hba_detach(dip);
955
956 if (hba_attach_state & HBA_ATTACH_STAGE_SATA_HBA_INST) {
957 mutex_destroy(&sata_hba_inst->satahba_mutex);
958 kmem_free((void *)sata_hba_inst,
959 sizeof (struct sata_hba_inst));
960 scsi_hba_tran_free(scsi_tran);
961 }
962
963 sata_log(NULL, CE_WARN, "?SATA: %s%d hba attach failed",
964 ddi_driver_name(dip), ddi_get_instance(dip));
965
966 return (DDI_FAILURE);
967 }
968
969
970 /*
971 * Called by SATA HBA from to detach an instance of the driver.
972 *
973 * For DDI_DETACH command:
974 * Free local structures allocated for SATA HBA instance during
975 * sata_hba_attach processing.
976 *
977 * Returns DDI_SUCCESS when HBA was detached, DDI_FAILURE otherwise.
978 *
979 * For DDI_SUSPEND command:
980 * Not implemented at this time (postponed until phase 2 of the development)
981 * Returnd DDI_SUCCESS.
982 *
983 * When the last HBA instance is detached, the event daemon is terminated.
984 *
985 * NOTE: Port multiplier is supported.
986 */
987 int
988 sata_hba_detach(dev_info_t *dip, ddi_detach_cmd_t cmd)
989 {
990 dev_info_t *tdip;
991 sata_hba_inst_t *sata_hba_inst;
992 scsi_hba_tran_t *scsi_hba_tran;
993 sata_cport_info_t *cportinfo;
994 sata_pmult_info_t *pminfo;
995 sata_drive_info_t *sdinfo;
996 sata_device_t sdevice;
997 int ncport, npmport;
998
999 SATADBG3(SATA_DBG_HBA_IF, NULL, "sata_hba_detach: node %s (%s%d)\n",
1000 ddi_node_name(dip), ddi_driver_name(dip), ddi_get_instance(dip));
1001
1002 switch (cmd) {
1003 case DDI_DETACH:
1004
1005 if ((scsi_hba_tran = ddi_get_driver_private(dip)) == NULL)
1006 return (DDI_FAILURE);
1007
1008 sata_hba_inst = scsi_hba_tran->tran_hba_private;
1009 if (sata_hba_inst == NULL)
1010 return (DDI_FAILURE);
1011
1012 if (scsi_hba_detach(dip) == DDI_FAILURE) {
1013 sata_hba_inst->satahba_attached = 1;
1014 return (DDI_FAILURE);
1015 }
1016
1017 /*
1018 * Free all target nodes - at this point
1019 * devices should be at least offlined
1020 * otherwise scsi_hba_detach() should not be called.
1021 */
1022 for (ncport = 0; ncport < SATA_NUM_CPORTS(sata_hba_inst);
1023 ncport++) {
1024 cportinfo = SATA_CPORT_INFO(sata_hba_inst, ncport);
1025 if (cportinfo->cport_dev_type != SATA_DTYPE_PMULT) {
1026 sdinfo = SATA_CPORTINFO_DRV_INFO(cportinfo);
1027 if (sdinfo != NULL) {
1028 tdip = sata_get_target_dip(dip,
1029 ncport, 0);
1030 if (tdip != NULL) {
1031 if (ndi_devi_offline(tdip,
1032 NDI_DEVI_REMOVE) !=
1033 NDI_SUCCESS) {
1034 SATA_LOG_D((
1035 sata_hba_inst,
1036 CE_WARN,
1037 "sata_hba_detach: "
1038 "Target node not "
1039 "removed !"));
1040 return (DDI_FAILURE);
1041 }
1042 }
1043 }
1044 } else { /* SATA_DTYPE_PMULT */
1045 mutex_enter(&cportinfo->cport_mutex);
1046 pminfo = SATA_CPORTINFO_PMULT_INFO(cportinfo);
1047
1048 if (pminfo == NULL) {
1049 SATA_LOG_D((sata_hba_inst, CE_WARN,
1050 "sata_hba_detach: Port multiplier "
1051 "not ready yet!"));
1052 mutex_exit(&cportinfo->cport_mutex);
1053 return (DDI_FAILURE);
1054 }
1055
1056 /*
1057 * Detach would fail if removal of any of the
1058 * target nodes is failed - albeit in that
1059 * case some of them may have been removed.
1060 */
1061 for (npmport = 0; npmport < SATA_NUM_PMPORTS(
1062 sata_hba_inst, ncport); npmport++) {
1063 tdip = sata_get_target_dip(dip, ncport,
1064 npmport);
1065 if (tdip != NULL) {
1066 if (ndi_devi_offline(tdip,
1067 NDI_DEVI_REMOVE) !=
1068 NDI_SUCCESS) {
1069 SATA_LOG_D((
1070 sata_hba_inst,
1071 CE_WARN,
1072 "sata_hba_detach: "
1073 "Target node not "
1074 "removed !"));
1075 mutex_exit(&cportinfo->
1076 cport_mutex);
1077 return (DDI_FAILURE);
1078 }
1079 }
1080 }
1081 mutex_exit(&cportinfo->cport_mutex);
1082 }
1083 }
1084 /*
1085 * Disable sata event daemon processing for this HBA
1086 */
1087 sata_hba_inst->satahba_attached = 0;
1088
1089 /*
1090 * Remove event daemon thread, if it is last HBA instance.
1091 */
1092
1093 mutex_enter(&sata_mutex);
1094 if (sata_hba_list->satahba_next == NULL) {
1095 mutex_exit(&sata_mutex);
1096 sata_event_thread_control(0);
1097 mutex_enter(&sata_mutex);
1098 }
1099 mutex_exit(&sata_mutex);
1100
1101 /* Remove this HBA instance from the HBA list */
1102 sata_remove_hba_instance(dip);
1103
1104 /*
1105 * At this point there should be no target nodes attached.
1106 * Detach and destroy device and port info structures.
1107 */
1108 for (ncport = 0; ncport < SATA_NUM_CPORTS(sata_hba_inst);
1109 ncport++) {
1110 cportinfo = SATA_CPORT_INFO(sata_hba_inst, ncport);
1111 if (cportinfo->cport_dev_type != SATA_DTYPE_PMULT) {
1112 sdinfo =
1113 cportinfo->cport_devp.cport_sata_drive;
1114 if (sdinfo != NULL) {
1115 /* Release device structure */
1116 kmem_free(sdinfo,
1117 sizeof (sata_drive_info_t));
1118 }
1119 /* Release cport info */
1120 mutex_destroy(&cportinfo->cport_mutex);
1121 kmem_free(cportinfo,
1122 sizeof (sata_cport_info_t));
1123 } else { /* SATA_DTYPE_PMULT */
1124 sdevice.satadev_addr.cport = (uint8_t)ncport;
1125 sdevice.satadev_addr.qual = SATA_ADDR_PMULT;
1126 sata_free_pmult(sata_hba_inst, &sdevice);
1127 }
1128 }
1129
1130 scsi_hba_tran_free(sata_hba_inst->satahba_scsi_tran);
1131
1132 (void) ddi_prop_remove(DDI_DEV_T_ANY, dip, "sata");
1133
1134 taskq_destroy(sata_hba_inst->satahba_taskq);
1135
1136 mutex_destroy(&sata_hba_inst->satahba_mutex);
1137 kmem_free((void *)sata_hba_inst,
1138 sizeof (struct sata_hba_inst));
1139
1140 return (DDI_SUCCESS);
1141
1142 case DDI_SUSPEND:
1143 /*
1144 * Postponed until phase 2
1145 */
1146 return (DDI_FAILURE);
1147
1148 default:
1149 return (DDI_FAILURE);
1150 }
1151 }
1152
1153
1154 /*
1155 * Called by an HBA drive from _fini() routine.
1156 * Unregisters SATA HBA instance/SATA framework pair from the scsi framework.
1157 */
1158 void
1159 sata_hba_fini(struct modlinkage *modlp)
1160 {
1161 SATADBG1(SATA_DBG_HBA_IF, NULL,
1162 "sata_hba_fini: name %s\n",
1163 ((struct modldrv *)(modlp->ml_linkage[0]))->drv_linkinfo);
1164
1165 scsi_hba_fini(modlp);
1166 }
1167
1168
1169 /*
1170 * Default open and close routine for sata_hba framework.
1171 *
1172 */
1173 /*
1174 * Open devctl node.
1175 *
1176 * Returns:
1177 * 0 if node was open successfully, error code otherwise.
1178 *
1179 *
1180 */
1181
1182 static int
1183 sata_hba_open(dev_t *devp, int flags, int otyp, cred_t *credp)
1184 {
1185 #ifndef __lock_lint
1186 _NOTE(ARGUNUSED(credp))
1187 #endif
1188 int rv = 0;
1189 dev_info_t *dip;
1190 scsi_hba_tran_t *scsi_hba_tran;
1191 sata_hba_inst_t *sata_hba_inst;
1192
1193 SATADBG1(SATA_DBG_IOCTL_IF, NULL, "sata_hba_open: entered", NULL);
1194
1195 if (otyp != OTYP_CHR)
1196 return (EINVAL);
1197
1198 dip = sata_devt_to_devinfo(*devp);
1199 if (dip == NULL)
1200 return (ENXIO);
1201
1202 if ((scsi_hba_tran = ddi_get_driver_private(dip)) == NULL)
1203 return (ENXIO);
1204
1205 sata_hba_inst = scsi_hba_tran->tran_hba_private;
1206 if (sata_hba_inst == NULL || sata_hba_inst->satahba_attached == 0)
1207 return (ENXIO);
1208
1209 mutex_enter(&sata_mutex);
1210 if (flags & FEXCL) {
1211 if (sata_hba_inst->satahba_open_flag != 0) {
1212 rv = EBUSY;
1213 } else {
1214 sata_hba_inst->satahba_open_flag =
1215 SATA_DEVCTL_EXOPENED;
1216 }
1217 } else {
1218 if (sata_hba_inst->satahba_open_flag == SATA_DEVCTL_EXOPENED) {
1219 rv = EBUSY;
1220 } else {
1221 sata_hba_inst->satahba_open_flag =
1222 SATA_DEVCTL_SOPENED;
1223 }
1224 }
1225 mutex_exit(&sata_mutex);
1226
1227 return (rv);
1228 }
1229
1230
1231 /*
1232 * Close devctl node.
1233 * Returns:
1234 * 0 if node was closed successfully, error code otherwise.
1235 *
1236 */
1237
1238 static int
1239 sata_hba_close(dev_t dev, int flag, int otyp, cred_t *credp)
1240 {
1241 #ifndef __lock_lint
1242 _NOTE(ARGUNUSED(credp))
1243 _NOTE(ARGUNUSED(flag))
1244 #endif
1245 dev_info_t *dip;
1246 scsi_hba_tran_t *scsi_hba_tran;
1247 sata_hba_inst_t *sata_hba_inst;
1248
1249 SATADBG1(SATA_DBG_IOCTL_IF, NULL, "sata_hba_close: entered", NULL);
1250
1251 if (otyp != OTYP_CHR)
1252 return (EINVAL);
1253
1254 dip = sata_devt_to_devinfo(dev);
1255 if (dip == NULL)
1256 return (ENXIO);
1257
1258 if ((scsi_hba_tran = ddi_get_driver_private(dip)) == NULL)
1259 return (ENXIO);
1260
1261 sata_hba_inst = scsi_hba_tran->tran_hba_private;
1262 if (sata_hba_inst == NULL || sata_hba_inst->satahba_attached == 0)
1263 return (ENXIO);
1264
1265 mutex_enter(&sata_mutex);
1266 sata_hba_inst->satahba_open_flag = 0;
1267 mutex_exit(&sata_mutex);
1268 return (0);
1269 }
1270
1271
1272
1273 /*
1274 * Standard IOCTL commands for SATA hotplugging.
1275 * Implemented DEVCTL_AP commands:
1276 * DEVCTL_AP_CONNECT
1277 * DEVCTL_AP_DISCONNECT
1278 * DEVCTL_AP_CONFIGURE
1279 * DEVCTL_UNCONFIGURE
1280 * DEVCTL_AP_CONTROL
1281 *
1282 * Commands passed to default ndi ioctl handler:
1283 * DEVCTL_DEVICE_GETSTATE
1284 * DEVCTL_DEVICE_ONLINE
1285 * DEVCTL_DEVICE_OFFLINE
1286 * DEVCTL_DEVICE_REMOVE
1287 * DEVCTL_DEVICE_INSERT
1288 * DEVCTL_BUS_GETSTATE
1289 *
1290 * All other cmds are passed to HBA if it provide ioctl handler, or failed
1291 * if not.
1292 *
1293 * Returns:
1294 * 0 if successful,
1295 * error code if operation failed.
1296 *
1297 * Port Multiplier support is supported now.
1298 *
1299 * NOTE: qual should be SATA_ADDR_DCPORT or SATA_ADDR_DPMPORT
1300 */
1301
1302 static int
1303 sata_hba_ioctl(dev_t dev, int cmd, intptr_t arg, int mode, cred_t *credp,
1304 int *rvalp)
1305 {
1306 #ifndef __lock_lint
1307 _NOTE(ARGUNUSED(credp))
1308 _NOTE(ARGUNUSED(rvalp))
1309 #endif
1310 int rv = 0;
1311 int32_t comp_port = -1;
1312 dev_info_t *dip;
1313 devctl_ap_state_t ap_state;
1314 struct devctl_iocdata *dcp = NULL;
1315 scsi_hba_tran_t *scsi_hba_tran;
1316 sata_hba_inst_t *sata_hba_inst;
1317 sata_device_t sata_device;
1318 sata_cport_info_t *cportinfo;
1319 int cport, pmport, qual;
1320 int rval = SATA_SUCCESS;
1321
1322 dip = sata_devt_to_devinfo(dev);
1323 if (dip == NULL)
1324 return (ENXIO);
1325
1326 if ((scsi_hba_tran = ddi_get_driver_private(dip)) == NULL)
1327 return (ENXIO);
1328
1329 sata_hba_inst = scsi_hba_tran->tran_hba_private;
1330 if (sata_hba_inst == NULL)
1331 return (ENXIO);
1332
1333 if (sata_hba_inst->satahba_tran == NULL)
1334 return (ENXIO);
1335
1336 switch (cmd) {
1337
1338 case DEVCTL_DEVICE_GETSTATE:
1339 case DEVCTL_DEVICE_ONLINE:
1340 case DEVCTL_DEVICE_OFFLINE:
1341 case DEVCTL_DEVICE_REMOVE:
1342 case DEVCTL_BUS_GETSTATE:
1343 /*
1344 * There may be more cases that we want to pass to default
1345 * handler rather than fail them.
1346 */
1347 return (ndi_devctl_ioctl(dip, cmd, arg, mode, 0));
1348 }
1349
1350 /* read devctl ioctl data */
1351 if (cmd != DEVCTL_AP_CONTROL && cmd >= DEVCTL_IOC &&
1352 cmd <= DEVCTL_IOC_MAX) {
1353 if (ndi_dc_allochdl((void *)arg, &dcp) != NDI_SUCCESS)
1354 return (EFAULT);
1355
1356 if ((comp_port = sata_get_port_num(sata_hba_inst, dcp)) ==
1357 -1) {
1358 if (dcp)
1359 ndi_dc_freehdl(dcp);
1360 return (EINVAL);
1361 }
1362
1363 /*
1364 * According to SCSI_TO_SATA_ADDR_QUAL, qual should be either
1365 * SATA_ADDR_DCPORT or SATA_ADDR_DPMPORT.
1366 */
1367 cport = SCSI_TO_SATA_CPORT(comp_port);
1368 pmport = SCSI_TO_SATA_PMPORT(comp_port);
1369 qual = SCSI_TO_SATA_ADDR_QUAL(comp_port);
1370
1371 if (sata_validate_sata_address(sata_hba_inst, cport, pmport,
1372 qual) != 0) {
1373 ndi_dc_freehdl(dcp);
1374 return (EINVAL);
1375 }
1376
1377 cportinfo = SATA_CPORT_INFO(sata_hba_inst, cport);
1378 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, cport)->
1379 cport_mutex);
1380 if (cportinfo->cport_event_flags & SATA_EVNT_LOCK_PORT_BUSY) {
1381 /*
1382 * Cannot process ioctl request now. Come back later.
1383 */
1384 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)->
1385 cport_mutex);
1386 ndi_dc_freehdl(dcp);
1387 return (EBUSY);
1388 }
1389 /* Block event processing for this port */
1390 cportinfo->cport_event_flags |= SATA_APCTL_LOCK_PORT_BUSY;
1391 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex);
1392
1393 sata_device.satadev_addr.cport = cport;
1394 sata_device.satadev_addr.pmport = pmport;
1395 sata_device.satadev_addr.qual = qual;
1396 sata_device.satadev_rev = SATA_DEVICE_REV;
1397 }
1398
1399 switch (cmd) {
1400
1401 case DEVCTL_AP_DISCONNECT:
1402
1403 /*
1404 * Normally, cfgadm sata plugin will try to offline
1405 * (unconfigure) device before this request. Nevertheless,
1406 * if a device is still configured, we need to
1407 * attempt to offline and unconfigure device first, and we will
1408 * deactivate the port regardless of the unconfigure
1409 * operation results.
1410 *
1411 */
1412 rv = sata_ioctl_disconnect(sata_hba_inst, &sata_device);
1413
1414 break;
1415
1416 case DEVCTL_AP_UNCONFIGURE:
1417
1418 /*
1419 * The unconfigure operation uses generic nexus operation to
1420 * offline a device. It leaves a target device node attached.
1421 * and obviously sata_drive_info attached as well, because
1422 * from the hardware point of view nothing has changed.
1423 */
1424 rv = sata_ioctl_unconfigure(sata_hba_inst, &sata_device);
1425 break;
1426
1427 case DEVCTL_AP_CONNECT:
1428 {
1429 /*
1430 * The sata cfgadm pluging will invoke this operation only if
1431 * port was found in the disconnect state (failed state
1432 * is also treated as the disconnected state).
1433 * If port activation is successful and a device is found
1434 * attached to the port, the initialization sequence is
1435 * executed to probe the port and attach
1436 * a device structure to a port structure. The device is not
1437 * set in configured state (system-wise) by this operation.
1438 */
1439
1440 rv = sata_ioctl_connect(sata_hba_inst, &sata_device);
1441
1442 break;
1443 }
1444
1445 case DEVCTL_AP_CONFIGURE:
1446 {
1447 /*
1448 * A port may be in an active or shutdown state.
1449 * If port is in a failed state, operation is aborted.
1450 * If a port is in a shutdown state, sata_tran_port_activate()
1451 * is invoked prior to any other operation.
1452 *
1453 * Onlining the device involves creating a new target node.
1454 * If there is an old target node present (belonging to
1455 * previously removed device), the operation is aborted - the
1456 * old node has to be released and removed before configure
1457 * operation is attempted.
1458 */
1459
1460 rv = sata_ioctl_configure(sata_hba_inst, &sata_device);
1461
1462 break;
1463 }
1464
1465 case DEVCTL_AP_GETSTATE:
1466
1467 sata_cfgadm_state(sata_hba_inst, comp_port, &ap_state);
1468
1469 ap_state.ap_last_change = (time_t)-1;
1470 ap_state.ap_error_code = 0;
1471 ap_state.ap_in_transition = 0;
1472
1473 /* Copy the return AP-state information to the user space */
1474 if (ndi_dc_return_ap_state(&ap_state, dcp) != NDI_SUCCESS) {
1475 rv = EFAULT;
1476 }
1477 break;
1478
1479 case DEVCTL_AP_CONTROL:
1480 {
1481 /*
1482 * Generic devctl for hardware specific functionality
1483 */
1484 sata_ioctl_data_t ioc;
1485
1486 ASSERT(dcp == NULL);
1487
1488 /* Copy in user ioctl data first */
1489 #ifdef _MULTI_DATAMODEL
1490 if (ddi_model_convert_from(mode & FMODELS) ==
1491 DDI_MODEL_ILP32) {
1492
1493 sata_ioctl_data_32_t ioc32;
1494
1495 if (ddi_copyin((void *)arg, (void *)&ioc32,
1496 sizeof (ioc32), mode) != 0) {
1497 rv = EFAULT;
1498 break;
1499 }
1500 ioc.cmd = (uint_t)ioc32.cmd;
1501 ioc.port = (uint_t)ioc32.port;
1502 ioc.get_size = (uint_t)ioc32.get_size;
1503 ioc.buf = (caddr_t)(uintptr_t)ioc32.buf;
1504 ioc.bufsiz = (uint_t)ioc32.bufsiz;
1505 ioc.misc_arg = (uint_t)ioc32.misc_arg;
1506 } else
1507 #endif /* _MULTI_DATAMODEL */
1508 if (ddi_copyin((void *)arg, (void *)&ioc, sizeof (ioc),
1509 mode) != 0) {
1510 return (EFAULT);
1511 }
1512
1513 SATADBG2(SATA_DBG_IOCTL_IF, sata_hba_inst,
1514 "sata_hba_ioctl: DEVCTL_AP_CONTROL "
1515 "cmd 0x%x, port 0x%x", ioc.cmd, ioc.port);
1516
1517 /*
1518 * To avoid BE/LE and 32/64 issues, a get_size always returns
1519 * a 32-bit number.
1520 */
1521 if (ioc.get_size != 0 && ioc.bufsiz != (sizeof (uint32_t))) {
1522 return (EINVAL);
1523 }
1524 /* validate address */
1525 cport = SCSI_TO_SATA_CPORT(ioc.port);
1526 pmport = SCSI_TO_SATA_PMPORT(ioc.port);
1527 qual = SCSI_TO_SATA_ADDR_QUAL(ioc.port);
1528
1529 SATADBG3(SATA_DBG_IOCTL_IF, sata_hba_inst,
1530 "sata_hba_ioctl: target port is %d:%d (%d)",
1531 cport, pmport, qual);
1532
1533 if (sata_validate_sata_address(sata_hba_inst, cport,
1534 pmport, qual) != 0)
1535 return (EINVAL);
1536
1537 cportinfo = SATA_CPORT_INFO(sata_hba_inst, cport);
1538 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, cport)->
1539 cport_mutex);
1540 /* Is the port locked by event processing daemon ? */
1541 if (cportinfo->cport_event_flags & SATA_EVNT_LOCK_PORT_BUSY) {
1542 /*
1543 * Cannot process ioctl request now. Come back later
1544 */
1545 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)->
1546 cport_mutex);
1547 return (EBUSY);
1548 }
1549 /* Block event processing for this port */
1550 cportinfo->cport_event_flags |= SATA_APCTL_LOCK_PORT_BUSY;
1551 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex);
1552
1553
1554 sata_device.satadev_addr.cport = cport;
1555 sata_device.satadev_addr.pmport = pmport;
1556 sata_device.satadev_addr.qual = qual;
1557 sata_device.satadev_rev = SATA_DEVICE_REV;
1558
1559 switch (ioc.cmd) {
1560
1561 case SATA_CFGA_RESET_PORT:
1562 /*
1563 * There is no protection for configured device.
1564 */
1565 rv = sata_ioctl_reset_port(sata_hba_inst, &sata_device);
1566 break;
1567
1568 case SATA_CFGA_RESET_DEVICE:
1569 /*
1570 * There is no protection for configured device.
1571 */
1572 rv = sata_ioctl_reset_device(sata_hba_inst,
1573 &sata_device);
1574 break;
1575
1576 case SATA_CFGA_RESET_ALL:
1577 /*
1578 * There is no protection for configured devices.
1579 */
1580 rv = sata_ioctl_reset_all(sata_hba_inst);
1581 /*
1582 * We return here, because common return is for
1583 * a single port operation - we have already unlocked
1584 * all ports and no dc handle was allocated.
1585 */
1586 return (rv);
1587
1588 case SATA_CFGA_PORT_DEACTIVATE:
1589 /*
1590 * Arbitrarily unconfigure attached device, if any.
1591 * Even if the unconfigure fails, proceed with the
1592 * port deactivation.
1593 */
1594 rv = sata_ioctl_deactivate(sata_hba_inst, &sata_device);
1595
1596 break;
1597
1598 case SATA_CFGA_PORT_ACTIVATE:
1599
1600 rv = sata_ioctl_activate(sata_hba_inst, &sata_device);
1601 break;
1602
1603 case SATA_CFGA_PORT_SELF_TEST:
1604
1605 rv = sata_ioctl_port_self_test(sata_hba_inst,
1606 &sata_device);
1607 break;
1608
1609 case SATA_CFGA_GET_DEVICE_PATH:
1610
1611 rv = sata_ioctl_get_device_path(sata_hba_inst,
1612 &sata_device, &ioc, mode);
1613 break;
1614
1615 case SATA_CFGA_GET_AP_TYPE:
1616
1617 rv = sata_ioctl_get_ap_type(sata_hba_inst,
1618 &sata_device, &ioc, mode);
1619 break;
1620
1621 case SATA_CFGA_GET_MODEL_INFO:
1622
1623 rv = sata_ioctl_get_model_info(sata_hba_inst,
1624 &sata_device, &ioc, mode);
1625 break;
1626
1627 case SATA_CFGA_GET_REVFIRMWARE_INFO:
1628
1629 rv = sata_ioctl_get_revfirmware_info(sata_hba_inst,
1630 &sata_device, &ioc, mode);
1631 break;
1632
1633 case SATA_CFGA_GET_SERIALNUMBER_INFO:
1634
1635 rv = sata_ioctl_get_serialnumber_info(sata_hba_inst,
1636 &sata_device, &ioc, mode);
1637 break;
1638
1639 default:
1640 rv = EINVAL;
1641 break;
1642
1643 } /* End of DEVCTL_AP_CONTROL cmd switch */
1644
1645 break;
1646 }
1647
1648 default:
1649 {
1650 /*
1651 * If we got here, we got an IOCTL that SATA HBA Framework
1652 * does not recognize. Pass ioctl to HBA driver, in case
1653 * it could process it.
1654 */
1655 sata_hba_tran_t *sata_tran = sata_hba_inst->satahba_tran;
1656 dev_info_t *mydip = SATA_DIP(sata_hba_inst);
1657
1658 SATADBG1(SATA_DBG_IOCTL_IF, sata_hba_inst,
1659 "IOCTL 0x%2x not supported in SATA framework, "
1660 "passthrough to HBA", cmd);
1661
1662 if (sata_tran->sata_tran_ioctl == NULL) {
1663 rv = EINVAL;
1664 break;
1665 }
1666 rval = (*sata_tran->sata_tran_ioctl)(mydip, cmd, arg);
1667 if (rval != 0) {
1668 SATADBG1(SATA_DBG_IOCTL_IF, sata_hba_inst,
1669 "IOCTL 0x%2x failed in HBA", cmd);
1670 rv = rval;
1671 }
1672 break;
1673 }
1674
1675 } /* End of main IOCTL switch */
1676
1677 if (dcp) {
1678 ndi_dc_freehdl(dcp);
1679 }
1680
1681 if (cmd >= DEVCTL_IOC && cmd <= DEVCTL_IOC_MAX) {
1682 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst,
1683 cport)->cport_mutex);
1684 cportinfo->cport_event_flags &= ~SATA_APCTL_LOCK_PORT_BUSY;
1685 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex);
1686 }
1687
1688 return (rv);
1689 }
1690
1691
1692 /*
1693 * Create error retrieval sata packet
1694 *
1695 * A sata packet is allocated and set-up to contain specified error retrieval
1696 * command and appropriate dma-able data buffer.
1697 * No association with any scsi packet is made and no callback routine is
1698 * specified.
1699 *
1700 * Returns a pointer to sata packet upon successful packet creation.
1701 * Returns NULL, if packet cannot be created.
1702 */
1703 sata_pkt_t *
1704 sata_get_error_retrieval_pkt(dev_info_t *dip, sata_device_t *sata_device,
1705 int pkt_type)
1706 {
1707 sata_hba_inst_t *sata_hba_inst;
1708 sata_pkt_txlate_t *spx;
1709 sata_pkt_t *spkt;
1710 sata_drive_info_t *sdinfo;
1711
1712 mutex_enter(&sata_mutex);
1713 for (sata_hba_inst = sata_hba_list; sata_hba_inst != NULL;
1714 sata_hba_inst = sata_hba_inst->satahba_next) {
1715 if (SATA_DIP(sata_hba_inst) == dip)
1716 break;
1717 }
1718 mutex_exit(&sata_mutex);
1719 ASSERT(sata_hba_inst != NULL);
1720
1721 sdinfo = sata_get_device_info(sata_hba_inst, sata_device);
1722 if (sdinfo == NULL) {
1723 sata_log(sata_hba_inst, CE_WARN,
1724 "sata: error recovery request for non-attached device at "
1725 "cport %d", sata_device->satadev_addr.cport);
1726 return (NULL);
1727 }
1728
1729 spx = kmem_zalloc(sizeof (sata_pkt_txlate_t), KM_SLEEP);
1730 spx->txlt_sata_hba_inst = sata_hba_inst;
1731 spx->txlt_scsi_pkt = NULL; /* No scsi pkt involved */
1732 spkt = sata_pkt_alloc(spx, NULL);
1733 if (spkt == NULL) {
1734 kmem_free(spx, sizeof (sata_pkt_txlate_t));
1735 return (NULL);
1736 }
1737 /* address is needed now */
1738 spkt->satapkt_device.satadev_addr = sata_device->satadev_addr;
1739
1740 switch (pkt_type) {
1741 case SATA_ERR_RETR_PKT_TYPE_NCQ:
1742 if (sata_ncq_err_ret_cmd_setup(spx, sdinfo) == SATA_SUCCESS) {
1743 if (sata_check_for_dma_error(dip, spx)) {
1744 ddi_fm_service_impact(dip,
1745 DDI_SERVICE_UNAFFECTED);
1746 break;
1747 }
1748 return (spkt);
1749 }
1750 break;
1751
1752 case SATA_ERR_RETR_PKT_TYPE_ATAPI:
1753 if (sata_atapi_err_ret_cmd_setup(spx, sdinfo) == SATA_SUCCESS) {
1754 if (sata_check_for_dma_error(dip, spx)) {
1755 ddi_fm_service_impact(dip,
1756 DDI_SERVICE_UNAFFECTED);
1757 break;
1758 }
1759 return (spkt);
1760 }
1761 break;
1762
1763 default:
1764 break;
1765 }
1766
1767 sata_pkt_free(spx);
1768 kmem_free(spx, sizeof (sata_pkt_txlate_t));
1769 return (NULL);
1770
1771 }
1772
1773
1774 /*
1775 * Free error retrieval sata packet
1776 *
1777 * Free sata packet and any associated resources allocated previously by
1778 * sata_get_error_retrieval_pkt().
1779 *
1780 * Void return.
1781 */
1782 void
1783 sata_free_error_retrieval_pkt(sata_pkt_t *sata_pkt)
1784 {
1785 sata_pkt_txlate_t *spx =
1786 (sata_pkt_txlate_t *)sata_pkt->satapkt_framework_private;
1787
1788 ASSERT(sata_pkt != NULL);
1789
1790 sata_free_local_buffer(spx);
1791 sata_pkt_free(spx);
1792 kmem_free(spx, sizeof (sata_pkt_txlate_t));
1793
1794 }
1795
1796 /*
1797 * Create READ PORT MULTIPLIER and WRITE PORT MULTIPLIER sata packet
1798 *
1799 * No association with any scsi packet is made and no callback routine is
1800 * specified.
1801 *
1802 * Returns a pointer to sata packet upon successful packet creation.
1803 * Returns NULL, if packet cannot be created.
1804 *
1805 * NOTE: Input/Output value includes 64 bits accoring to SATA Spec 2.6,
1806 * only lower 32 bits are available currently.
1807 */
1808 sata_pkt_t *
1809 sata_get_rdwr_pmult_pkt(dev_info_t *dip, sata_device_t *sd,
1810 uint8_t regn, uint32_t regv, uint32_t type)
1811 {
1812 sata_hba_inst_t *sata_hba_inst;
1813 sata_pkt_txlate_t *spx;
1814 sata_pkt_t *spkt;
1815 sata_cmd_t *scmd;
1816
1817 /* Only READ/WRITE commands are accepted. */
1818 ASSERT(type == SATA_RDWR_PMULT_PKT_TYPE_READ ||
1819 type == SATA_RDWR_PMULT_PKT_TYPE_WRITE);
1820
1821 mutex_enter(&sata_mutex);
1822 for (sata_hba_inst = sata_hba_list; sata_hba_inst != NULL;
1823 sata_hba_inst = sata_hba_inst->satahba_next) {
1824 if (SATA_DIP(sata_hba_inst) == dip)
1825 break;
1826 }
1827 mutex_exit(&sata_mutex);
1828 ASSERT(sata_hba_inst != NULL);
1829
1830 spx = kmem_zalloc(sizeof (sata_pkt_txlate_t), KM_SLEEP);
1831 spx->txlt_sata_hba_inst = sata_hba_inst;
1832 spx->txlt_scsi_pkt = NULL; /* No scsi pkt involved */
1833 spkt = sata_pkt_alloc(spx, SLEEP_FUNC);
1834 if (spkt == NULL) {
1835 kmem_free(spx, sizeof (sata_pkt_txlate_t));
1836 return (NULL);
1837 }
1838
1839 /*
1840 * NOTE: We need to send this command to the port multiplier,
1841 * that means send to SATA_PMULT_HOSTPORT(0xf) pmport
1842 *
1843 * sata_device contains the address of actual target device, and the
1844 * pmport number in the command comes from the sata_device structure.
1845 */
1846 spkt->satapkt_device.satadev_addr = sd->satadev_addr;
1847 spkt->satapkt_device.satadev_addr.pmport = SATA_PMULT_HOSTPORT;
1848 spkt->satapkt_device.satadev_addr.qual = SATA_ADDR_PMULT;
1849
1850 /* Fill sata_pkt */
1851 spkt->satapkt_op_mode = SATA_OPMODE_SYNCH | SATA_OPMODE_POLLING;
1852 spkt->satapkt_comp = NULL; /* Synchronous mode, no callback */
1853 spkt->satapkt_time = 10; /* Timeout 10s */
1854
1855 /* Build READ PORT MULTIPLIER cmd in the sata_pkt */
1856 scmd = &spkt->satapkt_cmd;
1857 scmd->satacmd_features_reg = regn & 0xff;
1858 scmd->satacmd_features_reg_ext = (regn >> 8) & 0xff;
1859 scmd->satacmd_device_reg = sd->satadev_addr.pmport;
1860 scmd->satacmd_addr_type = 0; /* N/A */
1861
1862 scmd->satacmd_flags.sata_ignore_dev_reset = B_TRUE;
1863
1864 if (type == SATA_RDWR_PMULT_PKT_TYPE_READ) {
1865 scmd->satacmd_cmd_reg = SATAC_READ_PORTMULT;
1866 scmd->satacmd_flags.sata_data_direction = SATA_DIR_READ;
1867 scmd->satacmd_flags.sata_special_regs = 1;
1868 scmd->satacmd_flags.sata_copy_out_lba_high_lsb = 1;
1869 scmd->satacmd_flags.sata_copy_out_lba_mid_lsb = 1;
1870 scmd->satacmd_flags.sata_copy_out_lba_low_lsb = 1;
1871 scmd->satacmd_flags.sata_copy_out_sec_count_lsb = 1;
1872 } else if (type == SATA_RDWR_PMULT_PKT_TYPE_WRITE) {
1873 scmd->satacmd_cmd_reg = SATAC_WRITE_PORTMULT;
1874 scmd->satacmd_flags.sata_data_direction = SATA_DIR_WRITE;
1875 scmd->satacmd_sec_count_lsb = regv & 0xff;
1876 scmd->satacmd_lba_low_lsb = regv >> 8 & 0xff;
1877 scmd->satacmd_lba_mid_lsb = regv >> 16 & 0xff;
1878 scmd->satacmd_lba_high_lsb = regv >> 24 & 0xff;
1879 }
1880
1881 return (spkt);
1882 }
1883
1884 /*
1885 * Free sata packet and any associated resources allocated previously by
1886 * sata_get_rdwr_pmult_pkt().
1887 *
1888 * Void return.
1889 */
1890 void
1891 sata_free_rdwr_pmult_pkt(sata_pkt_t *sata_pkt)
1892 {
1893 sata_pkt_txlate_t *spx =
1894 (sata_pkt_txlate_t *)sata_pkt->satapkt_framework_private;
1895
1896 /* Free allocated resources */
1897 sata_pkt_free(spx);
1898 kmem_free(spx, sizeof (sata_pkt_txlate_t));
1899 }
1900
1901 /*
1902 * Register a port multiplier to framework.
1903 * 1) Store the GSCR values in the previous allocated pmult_info strctures.
1904 * 2) Search in the blacklist and update the number of the device ports of the
1905 * port multiplier.
1906 *
1907 * Void return.
1908 */
1909 void
1910 sata_register_pmult(dev_info_t *dip, sata_device_t *sd, sata_pmult_gscr_t *sg)
1911 {
1912 sata_hba_inst_t *sata_hba_inst = NULL;
1913 sata_pmult_info_t *pmultinfo;
1914 sata_pmult_bl_t *blp;
1915 int cport = sd->satadev_addr.cport;
1916
1917 mutex_enter(&sata_mutex);
1918 for (sata_hba_inst = sata_hba_list; sata_hba_inst != NULL;
1919 sata_hba_inst = sata_hba_inst->satahba_next) {
1920 if (SATA_DIP(sata_hba_inst) == dip)
1921 if (sata_hba_inst->satahba_attached == 1)
1922 break;
1923 }
1924 mutex_exit(&sata_mutex);
1925 /* HBA not attached? */
1926 if (sata_hba_inst == NULL)
1927 return;
1928
1929 /* Number of pmports */
1930 sd->satadev_add_info = sg->gscr2 & SATA_PMULT_PORTNUM_MASK;
1931
1932 /* Check the blacklist */
1933 for (blp = sata_pmult_blacklist; blp->bl_gscr0; blp++) {
1934 if (sg->gscr0 != blp->bl_gscr0 && blp->bl_gscr0)
1935 continue;
1936 if (sg->gscr1 != blp->bl_gscr1 && blp->bl_gscr1)
1937 continue;
1938 if (sg->gscr2 != blp->bl_gscr2 && blp->bl_gscr2)
1939 continue;
1940
1941 cmn_err(CE_WARN, "!Port multiplier is on the blacklist.");
1942 sd->satadev_add_info = blp->bl_flags;
1943 break;
1944 }
1945
1946 /* Register the port multiplier GSCR */
1947 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, cport)));
1948 pmultinfo = SATA_PMULT_INFO(sata_hba_inst, cport);
1949 if (pmultinfo != NULL) {
1950 pmultinfo->pmult_gscr = *sg;
1951 pmultinfo->pmult_num_dev_ports =
1952 sd->satadev_add_info & SATA_PMULT_PORTNUM_MASK;
1953 SATADBG1(SATA_DBG_PMULT, sata_hba_inst,
1954 "Port multiplier registered at port %d", cport);
1955 }
1956 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, cport)));
1957 }
1958
1959 /*
1960 * sata_split_model splits the model ID into vendor and product IDs.
1961 * It assumes that a vendor ID cannot be longer than 8 characters, and
1962 * that vendor and product ID are separated by a whitespace.
1963 */
1964 void
1965 sata_split_model(char *model, char **vendor, char **product)
1966 {
1967 int i, modlen;
1968 char *vid, *pid;
1969
1970 /*
1971 * remove whitespace at the end of model
1972 */
1973 for (i = SATA_ID_MODEL_LEN; i > 0; i--)
1974 if (model[i] == ' ' || model[i] == '\t' || model[i] == '\0')
1975 model[i] = '\0';
1976 else
1977 break;
1978
1979 /*
1980 * try to split model into into vid/pid
1981 */
1982 modlen = strlen(model);
1983 for (i = 0, pid = model; i < modlen; i++, pid++)
1984 if ((*pid == ' ') || (*pid == '\t'))
1985 break;
1986
1987 /*
1988 * only use vid if it is less than 8 chars (as in SCSI)
1989 */
1990 if (i < modlen && i <= 8) {
1991 vid = model;
1992 /*
1993 * terminate vid, establish pid
1994 */
1995 *pid++ = '\0';
1996 } else {
1997 /*
1998 * vid will stay "ATA "
1999 */
2000 vid = NULL;
2001 /*
2002 * model is all pid
2003 */
2004 pid = model;
2005 }
2006
2007 *vendor = vid;
2008 *product = pid;
2009 }
2010
2011 /*
2012 * sata_name_child is for composing the name of the node
2013 * the format of the name is "target,0".
2014 */
2015 static int
2016 sata_name_child(dev_info_t *dip, char *name, int namelen)
2017 {
2018 int target;
2019
2020 target = ddi_prop_get_int(DDI_DEV_T_ANY, dip,
2021 DDI_PROP_DONTPASS, "target", -1);
2022 if (target == -1)
2023 return (DDI_FAILURE);
2024 (void) snprintf(name, namelen, "%x,0", target);
2025 return (DDI_SUCCESS);
2026 }
2027
2028
2029
2030 /* ****************** SCSA required entry points *********************** */
2031
2032 /*
2033 * Implementation of scsi tran_tgt_init.
2034 * sata_scsi_tgt_init() initializes scsi_device structure
2035 *
2036 * If successful, DDI_SUCCESS is returned.
2037 * DDI_FAILURE is returned if addressed device does not exist
2038 */
2039
2040 static int
2041 sata_scsi_tgt_init(dev_info_t *hba_dip, dev_info_t *tgt_dip,
2042 scsi_hba_tran_t *hba_tran, struct scsi_device *sd)
2043 {
2044 #ifndef __lock_lint
2045 _NOTE(ARGUNUSED(hba_dip))
2046 _NOTE(ARGUNUSED(tgt_dip))
2047 #endif
2048 sata_device_t sata_device;
2049 sata_drive_info_t *sdinfo;
2050 struct sata_id *sid;
2051 sata_hba_inst_t *sata_hba_inst;
2052 char model[SATA_ID_MODEL_LEN + 1];
2053 char fw[SATA_ID_FW_LEN + 1];
2054 char *vid, *pid;
2055
2056 /*
2057 * Fail tran_tgt_init for .conf stub node
2058 */
2059 if (ndi_dev_is_persistent_node(tgt_dip) == 0) {
2060 (void) ndi_merge_node(tgt_dip, sata_name_child);
2061 ddi_set_name_addr(tgt_dip, NULL);
2062 return (DDI_FAILURE);
2063 }
2064
2065 sata_hba_inst = (sata_hba_inst_t *)(hba_tran->tran_hba_private);
2066
2067 /* Validate scsi device address */
2068 if (sata_validate_scsi_address(sata_hba_inst, &sd->sd_address,
2069 &sata_device) != 0)
2070 return (DDI_FAILURE);
2071
2072 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst,
2073 sata_device.satadev_addr.cport)));
2074
2075 /* sata_device now contains a valid sata address */
2076 sdinfo = sata_get_device_info(sata_hba_inst, &sata_device);
2077 if (sdinfo == NULL) {
2078 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst,
2079 sata_device.satadev_addr.cport)));
2080 return (DDI_FAILURE);
2081 }
2082 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst,
2083 sata_device.satadev_addr.cport)));
2084
2085 /*
2086 * Check if we need to create a legacy devid (i.e cmdk style) for
2087 * the target disks.
2088 *
2089 * HBA devinfo node will have the property "use-cmdk-devid-format"
2090 * if we need to create cmdk-style devid for all the disk devices
2091 * attached to this controller. This property may have been set
2092 * from HBA driver's .conf file or by the HBA driver in its
2093 * attach(9F) function.
2094 */
2095 if ((sdinfo->satadrv_type == SATA_DTYPE_ATADISK) &&
2096 (ddi_getprop(DDI_DEV_T_ANY, hba_dip, DDI_PROP_DONTPASS,
2097 "use-cmdk-devid-format", 0) == 1)) {
2098 /* register a legacy devid for this target node */
2099 sata_target_devid_register(tgt_dip, sdinfo);
2100 }
2101
2102
2103 /*
2104 * 'Identify Device Data' does not always fit in standard SCSI
2105 * INQUIRY data, so establish INQUIRY_* properties with full-form
2106 * of information.
2107 */
2108 sid = &sdinfo->satadrv_id;
2109 #ifdef _LITTLE_ENDIAN
2110 swab(sid->ai_model, model, SATA_ID_MODEL_LEN);
2111 swab(sid->ai_fw, fw, SATA_ID_FW_LEN);
2112 #else /* _LITTLE_ENDIAN */
2113 bcopy(sid->ai_model, model, SATA_ID_MODEL_LEN);
2114 bcopy(sid->ai_fw, fw, SATA_ID_FW_LEN);
2115 #endif /* _LITTLE_ENDIAN */
2116 model[SATA_ID_MODEL_LEN] = 0;
2117 fw[SATA_ID_FW_LEN] = 0;
2118
2119 sata_split_model(model, &vid, &pid);
2120
2121 if (vid)
2122 (void) scsi_device_prop_update_inqstring(sd, INQUIRY_VENDOR_ID,
2123 vid, strlen(vid));
2124 if (pid)
2125 (void) scsi_device_prop_update_inqstring(sd, INQUIRY_PRODUCT_ID,
2126 pid, strlen(pid));
2127 (void) scsi_device_prop_update_inqstring(sd, INQUIRY_REVISION_ID,
2128 fw, strlen(fw));
2129
2130 return (DDI_SUCCESS);
2131 }
2132
2133 /*
2134 * Implementation of scsi tran_tgt_probe.
2135 * Probe target, by calling default scsi routine scsi_hba_probe()
2136 */
2137 static int
2138 sata_scsi_tgt_probe(struct scsi_device *sd, int (*callback)(void))
2139 {
2140 sata_hba_inst_t *sata_hba_inst =
2141 (sata_hba_inst_t *)(sd->sd_address.a_hba_tran->tran_hba_private);
2142 int rval;
2143 uint32_t pm_cap;
2144
2145 rval = scsi_hba_probe(sd, callback);
2146 pm_cap = SATA_CAP_POWER_CONDITON | SATA_CAP_SMART_PAGE |
2147 SATA_CAP_LOG_SENSE;
2148
2149 if (rval == SCSIPROBE_EXISTS) {
2150 /*
2151 * Set property "pm-capable" on the target device node, so that
2152 * the target driver will not try to fetch scsi cycle counters
2153 * before enabling device power-management.
2154 */
2155 if ((ddi_prop_update_int(DDI_DEV_T_NONE, sd->sd_dev,
2156 "pm-capable", pm_cap)) != DDI_PROP_SUCCESS) {
2157 sata_log(sata_hba_inst, CE_WARN,
2158 "SATA device at port %d: "
2159 "will not be power-managed ",
2160 SCSI_TO_SATA_CPORT(sd->sd_address.a_target));
2161 SATA_LOG_D((sata_hba_inst, CE_WARN,
2162 "failure updating pm-capable property"));
2163 }
2164 }
2165 return (rval);
2166 }
2167
2168 /*
2169 * Implementation of scsi tran_tgt_free.
2170 * Release all resources allocated for scsi_device
2171 */
2172 static void
2173 sata_scsi_tgt_free(dev_info_t *hba_dip, dev_info_t *tgt_dip,
2174 scsi_hba_tran_t *hba_tran, struct scsi_device *sd)
2175 {
2176 #ifndef __lock_lint
2177 _NOTE(ARGUNUSED(hba_dip))
2178 #endif
2179 sata_device_t sata_device;
2180 sata_drive_info_t *sdinfo;
2181 sata_hba_inst_t *sata_hba_inst;
2182 ddi_devid_t devid;
2183
2184 sata_hba_inst = (sata_hba_inst_t *)(hba_tran->tran_hba_private);
2185
2186 /* Validate scsi device address */
2187 /*
2188 * Note: tgt_free relates to the SCSA view of a device. If called, there
2189 * was a device at this address, so even if the sata framework internal
2190 * resources were alredy released because a device was detached,
2191 * this function should be executed as long as its actions do
2192 * not require the internal sata view of a device and the address
2193 * refers to a valid sata address.
2194 * Validating the address here means that we do not trust SCSA...
2195 */
2196 if (sata_validate_scsi_address(sata_hba_inst, &sd->sd_address,
2197 &sata_device) == -1)
2198 return;
2199
2200 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst,
2201 sata_device.satadev_addr.cport)));
2202
2203 /* sata_device now should contain a valid sata address */
2204 sdinfo = sata_get_device_info(sata_hba_inst, &sata_device);
2205 if (sdinfo == NULL) {
2206 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst,
2207 sata_device.satadev_addr.cport)));
2208 return;
2209 }
2210 /*
2211 * We did not allocate any resources in sata_scsi_tgt_init()
2212 * other than few properties.
2213 * Free them.
2214 */
2215 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst,
2216 sata_device.satadev_addr.cport)));
2217 (void) ndi_prop_remove(DDI_DEV_T_NONE, tgt_dip, "pm-capable");
2218
2219 /*
2220 * If devid was previously created but not freed up from
2221 * sd(7D) driver (i.e during detach(9F)) then do it here.
2222 */
2223 if ((sdinfo->satadrv_type == SATA_DTYPE_ATADISK) &&
2224 (ddi_getprop(DDI_DEV_T_ANY, hba_dip, DDI_PROP_DONTPASS,
2225 "use-cmdk-devid-format", 0) == 1) &&
2226 (ddi_devid_get(tgt_dip, &devid) == DDI_SUCCESS)) {
2227 ddi_devid_unregister(tgt_dip);
2228 ddi_devid_free(devid);
2229 }
2230 }
2231
2232 /*
2233 * Implementation of scsi tran_init_pkt
2234 * Upon successful return, scsi pkt buffer has DMA resources allocated.
2235 *
2236 * It seems that we should always allocate pkt, even if the address is
2237 * for non-existing device - just use some default for dma_attr.
2238 * The reason is that there is no way to communicate this to a caller here.
2239 * Subsequent call to sata_scsi_start may fail appropriately.
2240 * Simply returning NULL does not seem to discourage a target driver...
2241 *
2242 * Returns a pointer to initialized scsi_pkt, or NULL otherwise.
2243 */
2244 static struct scsi_pkt *
2245 sata_scsi_init_pkt(struct scsi_address *ap, struct scsi_pkt *pkt,
2246 struct buf *bp, int cmdlen, int statuslen, int tgtlen, int flags,
2247 int (*callback)(caddr_t), caddr_t arg)
2248 {
2249 sata_hba_inst_t *sata_hba_inst =
2250 (sata_hba_inst_t *)(ap->a_hba_tran->tran_hba_private);
2251 dev_info_t *dip = SATA_DIP(sata_hba_inst);
2252 sata_device_t sata_device;
2253 sata_drive_info_t *sdinfo;
2254 sata_pkt_txlate_t *spx;
2255 ddi_dma_attr_t cur_dma_attr;
2256 int rval;
2257 boolean_t new_pkt = B_TRUE;
2258
2259 ASSERT(ap->a_hba_tran->tran_hba_dip == dip);
2260
2261 /*
2262 * We need to translate the address, even if it could be
2263 * a bogus one, for a non-existing device
2264 */
2265 sata_device.satadev_addr.qual = SCSI_TO_SATA_ADDR_QUAL(ap->a_target);
2266 sata_device.satadev_addr.cport = SCSI_TO_SATA_CPORT(ap->a_target);
2267 sata_device.satadev_addr.pmport = SCSI_TO_SATA_PMPORT(ap->a_target);
2268 sata_device.satadev_rev = SATA_DEVICE_REV;
2269
2270 if (pkt == NULL) {
2271 /*
2272 * Have to allocate a brand new scsi packet.
2273 * We need to operate with auto request sense enabled.
2274 */
2275 pkt = scsi_hba_pkt_alloc(dip, ap, cmdlen,
2276 MAX(statuslen, SATA_MAX_SENSE_LEN),
2277 tgtlen, sizeof (sata_pkt_txlate_t), callback, arg);
2278
2279 if (pkt == NULL)
2280 return (NULL);
2281
2282 /* Fill scsi packet structure */
2283 pkt->pkt_comp = (void (*)())NULL;
2284 pkt->pkt_time = 0;
2285 pkt->pkt_resid = 0;
2286 pkt->pkt_statistics = 0;
2287 pkt->pkt_reason = 0;
2288
2289 /*
2290 * pkt_hba_private will point to sata pkt txlate structure
2291 */
2292 spx = (sata_pkt_txlate_t *)pkt->pkt_ha_private;
2293 bzero(spx, sizeof (sata_pkt_txlate_t));
2294
2295 spx->txlt_scsi_pkt = pkt;
2296 spx->txlt_sata_hba_inst = sata_hba_inst;
2297
2298 /* Allocate sata_pkt */
2299 spx->txlt_sata_pkt = sata_pkt_alloc(spx, callback);
2300 if (spx->txlt_sata_pkt == NULL) {
2301 /* Could not allocate sata pkt */
2302 scsi_hba_pkt_free(ap, pkt);
2303 return (NULL);
2304 }
2305 /* Set sata address */
2306 spx->txlt_sata_pkt->satapkt_device.satadev_addr =
2307 sata_device.satadev_addr;
2308 spx->txlt_sata_pkt->satapkt_device.satadev_rev =
2309 sata_device.satadev_rev;
2310
2311 if ((bp == NULL) || (bp->b_bcount == 0))
2312 return (pkt);
2313
2314 spx->txlt_total_residue = bp->b_bcount;
2315 } else {
2316 new_pkt = B_FALSE;
2317 /*
2318 * Packet was preallocated/initialized by previous call
2319 */
2320 spx = (sata_pkt_txlate_t *)pkt->pkt_ha_private;
2321
2322 if ((bp == NULL) || (bp->b_bcount == 0)) {
2323 return (pkt);
2324 }
2325
2326 /* Pkt is available already: spx->txlt_scsi_pkt == pkt; */
2327 }
2328
2329 spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp = bp;
2330
2331 /*
2332 * We use an adjusted version of the dma_attr, to account
2333 * for device addressing limitations.
2334 * sata_adjust_dma_attr() will handle sdinfo == NULL which may
2335 * happen when a device is not yet configured.
2336 */
2337 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst,
2338 sata_device.satadev_addr.cport)));
2339 sdinfo = sata_get_device_info(spx->txlt_sata_hba_inst,
2340 &spx->txlt_sata_pkt->satapkt_device);
2341 /* NULL sdinfo may be passsed to sata_adjust_dma_attr() */
2342 sata_adjust_dma_attr(sdinfo,
2343 SATA_DMA_ATTR(spx->txlt_sata_hba_inst), &cur_dma_attr);
2344 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst,
2345 sata_device.satadev_addr.cport)));
2346 /*
2347 * Allocate necessary DMA resources for the packet's data buffer
2348 * NOTE:
2349 * In case of read/write commands, DMA resource allocation here is
2350 * based on the premise that the transfer length specified in
2351 * the read/write scsi cdb will match exactly DMA resources -
2352 * returning correct packet residue is crucial.
2353 */
2354 if ((rval = sata_dma_buf_setup(spx, flags, callback, arg,
2355 &cur_dma_attr)) != DDI_SUCCESS) {
2356 /*
2357 * If a DMA allocation request fails with
2358 * DDI_DMA_NOMAPPING, indicate the error by calling
2359 * bioerror(9F) with bp and an error code of EFAULT.
2360 * If a DMA allocation request fails with
2361 * DDI_DMA_TOOBIG, indicate the error by calling
2362 * bioerror(9F) with bp and an error code of EINVAL.
2363 * For DDI_DMA_NORESOURCES, we may have some of them allocated.
2364 * Request may be repeated later - there is no real error.
2365 */
2366 switch (rval) {
2367 case DDI_DMA_NORESOURCES:
2368 bioerror(bp, 0);
2369 break;
2370 case DDI_DMA_NOMAPPING:
2371 case DDI_DMA_BADATTR:
2372 bioerror(bp, EFAULT);
2373 break;
2374 case DDI_DMA_TOOBIG:
2375 default:
2376 bioerror(bp, EINVAL);
2377 break;
2378 }
2379 goto fail;
2380 }
2381
2382 if (sata_check_for_dma_error(dip, spx)) {
2383 ddi_fm_service_impact(dip, DDI_SERVICE_UNAFFECTED);
2384 bioerror(bp, EFAULT);
2385 goto fail;
2386 }
2387
2388 success:
2389 /* Set number of bytes that are not yet accounted for */
2390 pkt->pkt_resid = spx->txlt_total_residue;
2391 ASSERT(pkt->pkt_resid >= 0);
2392
2393 return (pkt);
2394
2395 fail:
2396 if (new_pkt == B_TRUE) {
2397 /*
2398 * Since this is a new packet, we can clean-up
2399 * everything
2400 */
2401 sata_scsi_destroy_pkt(ap, pkt);
2402 } else {
2403 /*
2404 * This is a re-used packet. It will be target driver's
2405 * responsibility to eventually destroy it (which
2406 * will free allocated resources).
2407 * Here, we just "complete" the request, leaving
2408 * allocated resources intact, so the request may
2409 * be retried.
2410 */
2411 spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp = NULL;
2412 sata_pkt_free(spx);
2413 }
2414 return (NULL);
2415 }
2416
2417 /*
2418 * Implementation of scsi tran_start.
2419 * Translate scsi cmd into sata operation and return status.
2420 * ATAPI CDBs are passed to ATAPI devices - the device determines what commands
2421 * are supported.
2422 * For SATA hard disks, supported scsi commands:
2423 * SCMD_INQUIRY
2424 * SCMD_TEST_UNIT_READY
2425 * SCMD_START_STOP
2426 * SCMD_READ_CAPACITY
2427 * SCMD_SVC_ACTION_IN_G4 (READ CAPACITY (16))
2428 * SCMD_REQUEST_SENSE
2429 * SCMD_LOG_SENSE_G1
2430 * SCMD_LOG_SELECT_G1
2431 * SCMD_MODE_SENSE (specific pages)
2432 * SCMD_MODE_SENSE_G1 (specific pages)
2433 * SCMD_MODE_SELECT (specific pages)
2434 * SCMD_MODE_SELECT_G1 (specific pages)
2435 * SCMD_SYNCHRONIZE_CACHE
2436 * SCMD_SYNCHRONIZE_CACHE_G1
2437 * SCMD_READ
2438 * SCMD_READ_G1
2439 * SCMD_READ_G4
2440 * SCMD_READ_G5
2441 * SCMD_WRITE
2442 * SCMD_WRITE_BUFFER
2443 * SCMD_WRITE_G1
2444 * SCMD_WRITE_G4
2445 * SCMD_WRITE_G5
2446 * SCMD_SEEK (noop)
2447 * SCMD_SDIAG
2448 *
2449 * All other commands are rejected as unsupported.
2450 *
2451 * Returns:
2452 * TRAN_ACCEPT if command was executed successfully or accepted by HBA driver
2453 * for execution. TRAN_ACCEPT may be returned also if device was removed but
2454 * a callback could be scheduled.
2455 * TRAN_BADPKT if cmd was directed to invalid address.
2456 * TRAN_FATAL_ERROR is command was rejected due to hardware error, including
2457 * some unspecified error. TRAN_FATAL_ERROR may be also returned if a device
2458 * was removed and there was no callback specified in scsi pkt.
2459 * TRAN_BUSY if command could not be executed becasue HBA driver or SATA
2460 * framework was busy performing some other operation(s).
2461 *
2462 */
2463 static int
2464 sata_scsi_start(struct scsi_address *ap, struct scsi_pkt *pkt)
2465 {
2466 sata_hba_inst_t *sata_hba_inst =
2467 (sata_hba_inst_t *)(ap->a_hba_tran->tran_hba_private);
2468 sata_pkt_txlate_t *spx = (sata_pkt_txlate_t *)pkt->pkt_ha_private;
2469 sata_device_t *sdevice = &spx->txlt_sata_pkt->satapkt_device;
2470 sata_drive_info_t *sdinfo;
2471 struct buf *bp;
2472 uint8_t cport, pmport;
2473 boolean_t dev_gone = B_FALSE;
2474 int rval;
2475
2476 SATADBG1(SATA_DBG_SCSI_IF, sata_hba_inst,
2477 "sata_scsi_start: cmd 0x%02x\n", pkt->pkt_cdbp[0]);
2478
2479 ASSERT(spx != NULL &&
2480 spx->txlt_scsi_pkt == pkt && spx->txlt_sata_pkt != NULL);
2481
2482 cport = SCSI_TO_SATA_CPORT(ap->a_target);
2483 pmport = SCSI_TO_SATA_PMPORT(ap->a_target);
2484
2485 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, cport)));
2486
2487 if (sdevice->satadev_addr.qual == SATA_ADDR_DCPORT) {
2488 sdinfo = sata_get_device_info(sata_hba_inst, sdevice);
2489 if (sdinfo == NULL ||
2490 SATA_CPORT_INFO(sata_hba_inst, cport)->
2491 cport_tgtnode_clean == B_FALSE ||
2492 (sdinfo->satadrv_state & SATA_DSTATE_FAILED) != 0) {
2493 dev_gone = B_TRUE;
2494 }
2495 } else if (sdevice->satadev_addr.qual == SATA_ADDR_DPMPORT) {
2496 if (SATA_CPORT_DEV_TYPE(sata_hba_inst, cport) !=
2497 SATA_DTYPE_PMULT || SATA_PMULT_INFO(sata_hba_inst,
2498 cport) == NULL) {
2499 dev_gone = B_TRUE;
2500 } else if (SATA_PMPORT_INFO(sata_hba_inst, cport,
2501 pmport) == NULL) {
2502 dev_gone = B_TRUE;
2503 } else {
2504 mutex_enter(&(SATA_PMPORT_MUTEX(sata_hba_inst,
2505 cport, pmport)));
2506 sdinfo = sata_get_device_info(sata_hba_inst, sdevice);
2507 if (sdinfo == NULL ||
2508 SATA_PMPORT_INFO(sata_hba_inst, cport, pmport)->
2509 pmport_tgtnode_clean == B_FALSE ||
2510 (sdinfo->satadrv_state & SATA_DSTATE_FAILED) != 0) {
2511 dev_gone = B_TRUE;
2512 }
2513 mutex_exit(&(SATA_PMPORT_MUTEX(sata_hba_inst,
2514 cport, pmport)));
2515 }
2516 }
2517
2518 if (dev_gone == B_TRUE) {
2519 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, cport)));
2520 pkt->pkt_reason = CMD_DEV_GONE;
2521 /*
2522 * The sd target driver is checking CMD_DEV_GONE pkt_reason
2523 * only in callback function (for normal requests) and
2524 * in the dump code path.
2525 * So, if the callback is available, we need to do
2526 * the callback rather than returning TRAN_FATAL_ERROR here.
2527 */
2528 if (pkt->pkt_comp != NULL) {
2529 /* scsi callback required */
2530 if (servicing_interrupt()) {
2531 if (taskq_dispatch(SATA_TXLT_TASKQ(spx),
2532 (task_func_t *)spx->txlt_scsi_pkt->pkt_comp,
2533 (void *)spx->txlt_scsi_pkt, TQ_NOSLEEP) ==
2534 NULL) {
2535 return (TRAN_BUSY);
2536 }
2537 } else if (taskq_dispatch(SATA_TXLT_TASKQ(spx),
2538 (task_func_t *)spx->txlt_scsi_pkt->pkt_comp,
2539 (void *)spx->txlt_scsi_pkt, TQ_SLEEP) == NULL) {
2540 /* Scheduling the callback failed */
2541 return (TRAN_BUSY);
2542 }
2543 return (TRAN_ACCEPT);
2544 }
2545 /* No callback available */
2546 return (TRAN_FATAL_ERROR);
2547 }
2548
2549 if (sdinfo->satadrv_type & SATA_DTYPE_ATAPI) {
2550 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, cport)));
2551 rval = sata_txlt_atapi(spx);
2552 SATADBG1(SATA_DBG_SCSI_IF, sata_hba_inst,
2553 "sata_scsi_start atapi: rval %d\n", rval);
2554 return (rval);
2555 }
2556 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, cport)));
2557
2558 /*
2559 * Checking for power state, if it was on
2560 * STOPPED state, then the drive is not capable
2561 * of processing media access command. And
2562 * TEST_UNIT_READY, REQUEST_SENSE has special handling
2563 * in the function for different power state.
2564 */
2565 if (((sdinfo->satadrv_power_level == SATA_POWER_STANDBY) ||
2566 (sdinfo->satadrv_power_level == SATA_POWER_STOPPED)) &&
2567 (SATA_IS_MEDIUM_ACCESS_CMD(pkt->pkt_cdbp[0]))) {
2568 return (sata_txlt_check_condition(spx, KEY_NOT_READY,
2569 SD_SCSI_ASC_LU_NOT_READY));
2570 }
2571
2572 /* ATA Disk commands processing starts here */
2573
2574 bp = spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp;
2575
2576 switch (pkt->pkt_cdbp[0]) {
2577
2578 case SCMD_INQUIRY:
2579 /* Mapped to identify device */
2580 if (bp != NULL && (bp->b_flags & (B_PHYS | B_PAGEIO)))
2581 bp_mapin(bp);
2582 rval = sata_txlt_inquiry(spx);
2583 break;
2584
2585 case SCMD_TEST_UNIT_READY:
2586 /*
2587 * SAT "SATA to ATA Translation" doc specifies translation
2588 * to ATA CHECK POWER MODE.
2589 */
2590 rval = sata_txlt_test_unit_ready(spx);
2591 break;
2592
2593 case SCMD_START_STOP:
2594 /* Mapping depends on the command */
2595 rval = sata_txlt_start_stop_unit(spx);
2596 break;
2597
2598 case SCMD_READ_CAPACITY:
2599 if (bp != NULL && (bp->b_flags & (B_PHYS | B_PAGEIO)))
2600 bp_mapin(bp);
2601 rval = sata_txlt_read_capacity(spx);
2602 break;
2603
2604 case SCMD_SVC_ACTION_IN_G4: /* READ CAPACITY (16) */
2605 if (bp != NULL && (bp->b_flags & (B_PHYS | B_PAGEIO)))
2606 bp_mapin(bp);
2607 rval = sata_txlt_read_capacity16(spx);
2608 break;
2609
2610 case SCMD_REQUEST_SENSE:
2611 /*
2612 * Always No Sense, since we force ARQ
2613 */
2614 if (bp != NULL && (bp->b_flags & (B_PHYS | B_PAGEIO)))
2615 bp_mapin(bp);
2616 rval = sata_txlt_request_sense(spx);
2617 break;
2618
2619 case SCMD_LOG_SENSE_G1:
2620 if (bp != NULL && (bp->b_flags & (B_PHYS | B_PAGEIO)))
2621 bp_mapin(bp);
2622 rval = sata_txlt_log_sense(spx);
2623 break;
2624
2625 case SCMD_LOG_SELECT_G1:
2626 if (bp != NULL && (bp->b_flags & (B_PHYS | B_PAGEIO)))
2627 bp_mapin(bp);
2628 rval = sata_txlt_log_select(spx);
2629 break;
2630
2631 case SCMD_MODE_SENSE:
2632 case SCMD_MODE_SENSE_G1:
2633 if (bp != NULL && (bp->b_flags & (B_PHYS | B_PAGEIO)))
2634 bp_mapin(bp);
2635 rval = sata_txlt_mode_sense(spx);
2636 break;
2637
2638
2639 case SCMD_MODE_SELECT:
2640 case SCMD_MODE_SELECT_G1:
2641 if (bp != NULL && (bp->b_flags & (B_PHYS | B_PAGEIO)))
2642 bp_mapin(bp);
2643 rval = sata_txlt_mode_select(spx);
2644 break;
2645
2646 case SCMD_SYNCHRONIZE_CACHE:
2647 case SCMD_SYNCHRONIZE_CACHE_G1:
2648 rval = sata_txlt_synchronize_cache(spx);
2649 break;
2650
2651 case SCMD_READ:
2652 case SCMD_READ_G1:
2653 case SCMD_READ_G4:
2654 case SCMD_READ_G5:
2655 rval = sata_txlt_read(spx);
2656 break;
2657 case SCMD_WRITE_BUFFER:
2658 if (bp != NULL && (bp->b_flags & (B_PHYS | B_PAGEIO)))
2659 bp_mapin(bp);
2660 rval = sata_txlt_write_buffer(spx);
2661 break;
2662
2663 case SCMD_WRITE:
2664 case SCMD_WRITE_G1:
2665 case SCMD_WRITE_G4:
2666 case SCMD_WRITE_G5:
2667 rval = sata_txlt_write(spx);
2668 break;
2669
2670 case SCMD_SEEK:
2671 rval = sata_txlt_nodata_cmd_immediate(spx);
2672 break;
2673
2674 case SPC3_CMD_ATA_COMMAND_PASS_THROUGH12:
2675 case SPC3_CMD_ATA_COMMAND_PASS_THROUGH16:
2676 if (bp != NULL && (bp->b_flags & (B_PHYS | B_PAGEIO)))
2677 bp_mapin(bp);
2678 rval = sata_txlt_ata_pass_thru(spx);
2679 break;
2680
2681 /* Other cases will be filed later */
2682 /* postponed until phase 2 of the development */
2683 case SPC3_CMD_UNMAP:
2684 if (bp != NULL && (bp->b_flags & (B_PHYS | B_PAGEIO)))
2685 bp_mapin(bp);
2686 rval = sata_txlt_unmap(spx);
2687 break;
2688 default:
2689 rval = sata_txlt_invalid_command(spx);
2690 break;
2691 }
2692
2693 SATADBG1(SATA_DBG_SCSI_IF, sata_hba_inst,
2694 "sata_scsi_start: rval %d\n", rval);
2695
2696 return (rval);
2697 }
2698
2699 /*
2700 * Implementation of scsi tran_abort.
2701 * Abort specific pkt or all packets.
2702 *
2703 * Returns 1 if one or more packets were aborted, returns 0 otherwise
2704 *
2705 * May be called from an interrupt level.
2706 */
2707 static int
2708 sata_scsi_abort(struct scsi_address *ap, struct scsi_pkt *scsi_pkt)
2709 {
2710 sata_hba_inst_t *sata_hba_inst =
2711 (sata_hba_inst_t *)(ap->a_hba_tran->tran_hba_private);
2712 sata_device_t sata_device;
2713 sata_pkt_t *sata_pkt;
2714
2715 SATADBG2(SATA_DBG_SCSI_IF, sata_hba_inst,
2716 "sata_scsi_abort: %s at target: 0x%x\n",
2717 scsi_pkt == NULL ? "all packets" : "one pkt", ap->a_target);
2718
2719 /* Validate address */
2720 if (sata_validate_scsi_address(sata_hba_inst, ap, &sata_device) != 0)
2721 /* Invalid address */
2722 return (0);
2723
2724 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst,
2725 sata_device.satadev_addr.cport)));
2726 if (sata_get_device_info(sata_hba_inst, &sata_device) == NULL) {
2727 /* invalid address */
2728 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst,
2729 sata_device.satadev_addr.cport)));
2730 return (0);
2731 }
2732 if (scsi_pkt == NULL) {
2733 /*
2734 * Abort all packets.
2735 * Although we do not have specific packet, we still need
2736 * dummy packet structure to pass device address to HBA.
2737 * Allocate one, without sleeping. Fail if pkt cannot be
2738 * allocated.
2739 */
2740 sata_pkt = kmem_zalloc(sizeof (sata_pkt_t), KM_NOSLEEP);
2741 if (sata_pkt == NULL) {
2742 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst,
2743 sata_device.satadev_addr.cport)));
2744 SATA_LOG_D((sata_hba_inst, CE_WARN, "sata_pkt_abort: "
2745 "could not allocate sata_pkt"));
2746 return (0);
2747 }
2748 sata_pkt->satapkt_rev = SATA_PKT_REV;
2749 sata_pkt->satapkt_device = sata_device;
2750 sata_pkt->satapkt_device.satadev_rev = SATA_DEVICE_REV;
2751 } else {
2752 if (scsi_pkt->pkt_ha_private == NULL) {
2753 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst,
2754 sata_device.satadev_addr.cport)));
2755 return (0); /* Bad scsi pkt */
2756 }
2757 /* extract pointer to sata pkt */
2758 sata_pkt = ((sata_pkt_txlate_t *)scsi_pkt->pkt_ha_private)->
2759 txlt_sata_pkt;
2760 }
2761
2762 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst,
2763 sata_device.satadev_addr.cport)));
2764 /* Send abort request to HBA */
2765 if ((*SATA_ABORT_FUNC(sata_hba_inst))
2766 (SATA_DIP(sata_hba_inst), sata_pkt,
2767 scsi_pkt == NULL ? SATA_ABORT_ALL_PACKETS : SATA_ABORT_PACKET) ==
2768 SATA_SUCCESS) {
2769 if (scsi_pkt == NULL)
2770 kmem_free(sata_pkt, sizeof (sata_pkt_t));
2771 /* Success */
2772 return (1);
2773 }
2774 /* Else, something did not go right */
2775 if (scsi_pkt == NULL)
2776 kmem_free(sata_pkt, sizeof (sata_pkt_t));
2777 /* Failure */
2778 return (0);
2779 }
2780
2781
2782 /*
2783 * Implementation of scsi tran_reset.
2784 * RESET_ALL request is translated into port reset.
2785 * RESET_TARGET requests is translated into a device reset,
2786 * RESET_LUN request is accepted only for LUN 0 and translated into
2787 * device reset.
2788 * The target reset should cause all HBA active and queued packets to
2789 * be terminated and returned with pkt reason SATA_PKT_RESET prior to
2790 * the return. HBA should report reset event for the device.
2791 *
2792 * Returns 1 upon success, 0 upon failure.
2793 */
2794 static int
2795 sata_scsi_reset(struct scsi_address *ap, int level)
2796 {
2797 sata_hba_inst_t *sata_hba_inst =
2798 (sata_hba_inst_t *)(ap->a_hba_tran->tran_hba_private);
2799 sata_device_t sata_device;
2800 int val;
2801
2802 SATADBG2(SATA_DBG_SCSI_IF, sata_hba_inst,
2803 "sata_scsi_reset: level %d target: 0x%x\n",
2804 level, ap->a_target);
2805
2806 /* Validate address */
2807 val = sata_validate_scsi_address(sata_hba_inst, ap, &sata_device);
2808 if (val == -1)
2809 /* Invalid address */
2810 return (0);
2811
2812 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst,
2813 sata_device.satadev_addr.cport)));
2814 if (sata_get_device_info(sata_hba_inst, &sata_device) == NULL) {
2815 /* invalid address */
2816 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst,
2817 sata_device.satadev_addr.cport)));
2818 return (0);
2819 }
2820 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst,
2821 sata_device.satadev_addr.cport)));
2822 if (level == RESET_ALL) {
2823 /* port reset */
2824 if (sata_device.satadev_addr.qual == SATA_ADDR_DCPORT)
2825 sata_device.satadev_addr.qual = SATA_ADDR_CPORT;
2826 else
2827 sata_device.satadev_addr.qual = SATA_ADDR_PMPORT;
2828
2829 if ((*SATA_RESET_DPORT_FUNC(sata_hba_inst))
2830 (SATA_DIP(sata_hba_inst), &sata_device) == SATA_SUCCESS)
2831 return (1);
2832 else
2833 return (0);
2834
2835 } else if (val == 0 &&
2836 (level == RESET_TARGET || level == RESET_LUN)) {
2837 /* reset device (device attached) */
2838 if ((*SATA_RESET_DPORT_FUNC(sata_hba_inst))
2839 (SATA_DIP(sata_hba_inst), &sata_device) == SATA_SUCCESS)
2840 return (1);
2841 else
2842 return (0);
2843 }
2844 return (0);
2845 }
2846
2847
2848 /*
2849 * Implementation of scsi tran_getcap (get transport/device capabilities).
2850 * Supported capabilities for SATA hard disks:
2851 * auto-rqsense (always supported)
2852 * tagged-qing (supported if HBA supports it)
2853 * untagged-qing (could be supported if disk supports it, but because
2854 * caching behavior allowing untagged queuing actually
2855 * results in reduced performance. sd tries to throttle
2856 * back to only 3 outstanding commands, which may
2857 * work for real SCSI disks, but with read ahead
2858 * caching, having more than 1 outstanding command
2859 * results in cache thrashing.)
2860 * sector_size
2861 * dma_max
2862 * interconnect-type (INTERCONNECT_SATA)
2863 *
2864 * Supported capabilities for ATAPI CD/DVD devices:
2865 * auto-rqsense (always supported)
2866 * sector_size
2867 * dma_max
2868 * max-cdb-length
2869 * interconnect-type (INTERCONNECT_SATA)
2870 *
2871 * Supported capabilities for ATAPI TAPE devices:
2872 * auto-rqsense (always supported)
2873 * dma_max
2874 * max-cdb-length
2875 *
2876 * Supported capabilities for SATA ATAPI hard disks:
2877 * auto-rqsense (always supported)
2878 * interconnect-type (INTERCONNECT_SATA)
2879 * max-cdb-length
2880 *
2881 * Request for other capabilities is rejected as unsupported.
2882 *
2883 * Returns supported capability value, or -1 if capability is unsuppported or
2884 * the address is invalid - no device.
2885 */
2886
2887 static int
2888 sata_scsi_getcap(struct scsi_address *ap, char *cap, int whom)
2889 {
2890
2891 sata_hba_inst_t *sata_hba_inst =
2892 (sata_hba_inst_t *)(ap->a_hba_tran->tran_hba_private);
2893 sata_device_t sata_device;
2894 sata_drive_info_t *sdinfo;
2895 ddi_dma_attr_t adj_dma_attr;
2896 int rval;
2897
2898 SATADBG2(SATA_DBG_SCSI_IF, sata_hba_inst,
2899 "sata_scsi_getcap: target: 0x%x, cap: %s\n",
2900 ap->a_target, cap);
2901
2902 /*
2903 * We want to process the capabilities on per port granularity.
2904 * So, we are specifically restricting ourselves to whom != 0
2905 * to exclude the controller wide handling.
2906 */
2907 if (cap == NULL || whom == 0)
2908 return (-1);
2909
2910 if (sata_validate_scsi_address(sata_hba_inst, ap, &sata_device) != 0) {
2911 /* Invalid address */
2912 return (-1);
2913 }
2914 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst,
2915 sata_device.satadev_addr.cport)));
2916 if ((sdinfo = sata_get_device_info(sata_hba_inst, &sata_device)) ==
2917 NULL) {
2918 /* invalid address */
2919 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst,
2920 sata_device.satadev_addr.cport)));
2921 return (-1);
2922 }
2923
2924 switch (scsi_hba_lookup_capstr(cap)) {
2925 case SCSI_CAP_ARQ:
2926 rval = 1; /* ARQ supported, turned on */
2927 break;
2928
2929 case SCSI_CAP_SECTOR_SIZE:
2930 if (sdinfo->satadrv_type == SATA_DTYPE_ATADISK)
2931 rval = SATA_DISK_SECTOR_SIZE; /* fixed size */
2932 else if (sdinfo->satadrv_type == SATA_DTYPE_ATAPICD)
2933 rval = SATA_ATAPI_SECTOR_SIZE;
2934 else rval = -1;
2935 break;
2936
2937 /*
2938 * untagged queuing cause a performance inversion because of
2939 * the way sd operates. Because of this reason we do not
2940 * use it when available.
2941 */
2942 case SCSI_CAP_UNTAGGED_QING:
2943 if (sdinfo->satadrv_features_enabled &
2944 SATA_DEV_F_E_UNTAGGED_QING)
2945 rval = 1; /* Untagged queuing available */
2946 else
2947 rval = -1; /* Untagged queuing not available */
2948 break;
2949
2950 case SCSI_CAP_TAGGED_QING:
2951 if ((sdinfo->satadrv_features_enabled &
2952 SATA_DEV_F_E_TAGGED_QING) &&
2953 (sdinfo->satadrv_max_queue_depth > 1))
2954 rval = 1; /* Tagged queuing available */
2955 else
2956 rval = -1; /* Tagged queuing not available */
2957 break;
2958
2959 case SCSI_CAP_DMA_MAX:
2960 sata_adjust_dma_attr(sdinfo, SATA_DMA_ATTR(sata_hba_inst),
2961 &adj_dma_attr);
2962 rval = (int)adj_dma_attr.dma_attr_maxxfer;
2963 /* We rely on the fact that dma_attr_maxxfer < 0x80000000 */
2964 break;
2965
2966 case SCSI_CAP_INTERCONNECT_TYPE:
2967 rval = INTERCONNECT_SATA; /* SATA interconnect type */
2968 break;
2969
2970 case SCSI_CAP_CDB_LEN:
2971 if (sdinfo->satadrv_type & SATA_DTYPE_ATAPI)
2972 rval = sdinfo->satadrv_atapi_cdb_len;
2973 else
2974 rval = -1;
2975 break;
2976
2977 default:
2978 rval = -1;
2979 break;
2980 }
2981 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst,
2982 sata_device.satadev_addr.cport)));
2983 return (rval);
2984 }
2985
2986 /*
2987 * Implementation of scsi tran_setcap
2988 *
2989 * Only SCSI_CAP_UNTAGGED_QING and SCSI_CAP_TAGGED_QING are changeable.
2990 *
2991 */
2992 static int
2993 sata_scsi_setcap(struct scsi_address *ap, char *cap, int value, int whom)
2994 {
2995 sata_hba_inst_t *sata_hba_inst =
2996 (sata_hba_inst_t *)(ap->a_hba_tran->tran_hba_private);
2997 sata_device_t sata_device;
2998 sata_drive_info_t *sdinfo;
2999 int rval;
3000
3001 SATADBG2(SATA_DBG_SCSI_IF, sata_hba_inst,
3002 "sata_scsi_setcap: target: 0x%x, cap: %s\n", ap->a_target, cap);
3003
3004 /*
3005 * We want to process the capabilities on per port granularity.
3006 * So, we are specifically restricting ourselves to whom != 0
3007 * to exclude the controller wide handling.
3008 */
3009 if (cap == NULL || whom == 0) {
3010 return (-1);
3011 }
3012
3013 if (sata_validate_scsi_address(sata_hba_inst, ap, &sata_device) != 0) {
3014 /* Invalid address */
3015 return (-1);
3016 }
3017 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst,
3018 sata_device.satadev_addr.cport)));
3019 if ((sdinfo = sata_get_device_info(sata_hba_inst,
3020 &sata_device)) == NULL) {
3021 /* invalid address */
3022 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst,
3023 sata_device.satadev_addr.cport)));
3024 return (-1);
3025 }
3026 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst,
3027 sata_device.satadev_addr.cport)));
3028
3029 switch (scsi_hba_lookup_capstr(cap)) {
3030 case SCSI_CAP_ARQ:
3031 case SCSI_CAP_SECTOR_SIZE:
3032 case SCSI_CAP_DMA_MAX:
3033 case SCSI_CAP_INTERCONNECT_TYPE:
3034 rval = 0;
3035 break;
3036 case SCSI_CAP_UNTAGGED_QING:
3037 if (SATA_QDEPTH(sata_hba_inst) > 1) {
3038 rval = 1;
3039 if (value == 1) {
3040 sdinfo->satadrv_features_enabled |=
3041 SATA_DEV_F_E_UNTAGGED_QING;
3042 } else if (value == 0) {
3043 sdinfo->satadrv_features_enabled &=
3044 ~SATA_DEV_F_E_UNTAGGED_QING;
3045 } else {
3046 rval = -1;
3047 }
3048 } else {
3049 rval = 0;
3050 }
3051 break;
3052 case SCSI_CAP_TAGGED_QING:
3053 /* This can TCQ or NCQ */
3054 if (sata_func_enable & SATA_ENABLE_QUEUING &&
3055 ((sdinfo->satadrv_features_support & SATA_DEV_F_TCQ &&
3056 SATA_FEATURES(sata_hba_inst) & SATA_CTLF_QCMD) ||
3057 (sata_func_enable & SATA_ENABLE_NCQ &&
3058 sdinfo->satadrv_features_support & SATA_DEV_F_NCQ &&
3059 SATA_FEATURES(sata_hba_inst) & SATA_CTLF_NCQ)) &&
3060 (sdinfo->satadrv_max_queue_depth > 1)) {
3061 rval = 1;
3062 if (value == 1) {
3063 sdinfo->satadrv_features_enabled |=
3064 SATA_DEV_F_E_TAGGED_QING;
3065 } else if (value == 0) {
3066 sdinfo->satadrv_features_enabled &=
3067 ~SATA_DEV_F_E_TAGGED_QING;
3068 } else {
3069 rval = -1;
3070 }
3071 } else {
3072 rval = 0;
3073 }
3074 break;
3075 default:
3076 rval = -1;
3077 break;
3078 }
3079 return (rval);
3080 }
3081
3082 /*
3083 * Implementations of scsi tran_destroy_pkt.
3084 * Free resources allocated by sata_scsi_init_pkt()
3085 */
3086 static void
3087 sata_scsi_destroy_pkt(struct scsi_address *ap, struct scsi_pkt *pkt)
3088 {
3089 sata_pkt_txlate_t *spx;
3090
3091 spx = (sata_pkt_txlate_t *)pkt->pkt_ha_private;
3092
3093 sata_common_free_dma_rsrcs(spx);
3094
3095 spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp = NULL;
3096 sata_pkt_free(spx);
3097
3098 scsi_hba_pkt_free(ap, pkt);
3099 }
3100
3101 /*
3102 * Implementation of scsi tran_dmafree.
3103 * Free DMA resources allocated by sata_scsi_init_pkt()
3104 */
3105
3106 static void
3107 sata_scsi_dmafree(struct scsi_address *ap, struct scsi_pkt *pkt)
3108 {
3109 #ifndef __lock_lint
3110 _NOTE(ARGUNUSED(ap))
3111 #endif
3112 sata_pkt_txlate_t *spx;
3113
3114 ASSERT(pkt != NULL);
3115 spx = (sata_pkt_txlate_t *)pkt->pkt_ha_private;
3116
3117 sata_common_free_dma_rsrcs(spx);
3118 }
3119
3120 /*
3121 * Implementation of scsi tran_sync_pkt.
3122 *
3123 * The assumption below is that pkt is unique - there is no need to check ap
3124 *
3125 * Synchronize DMA buffer and, if the intermediate buffer is used, copy data
3126 * into/from the real buffer.
3127 */
3128 static void
3129 sata_scsi_sync_pkt(struct scsi_address *ap, struct scsi_pkt *pkt)
3130 {
3131 #ifndef __lock_lint
3132 _NOTE(ARGUNUSED(ap))
3133 #endif
3134 int rval;
3135 sata_pkt_txlate_t *spx = (sata_pkt_txlate_t *)pkt->pkt_ha_private;
3136 struct buf *bp;
3137 int direction;
3138
3139 ASSERT(spx != NULL);
3140 if (spx->txlt_buf_dma_handle != NULL) {
3141 direction = spx->txlt_sata_pkt->
3142 satapkt_cmd.satacmd_flags.sata_data_direction;
3143 if (spx->txlt_sata_pkt != NULL &&
3144 direction != SATA_DIR_NODATA_XFER) {
3145 if (spx->txlt_tmp_buf != NULL) {
3146 /* Intermediate DMA buffer used */
3147 bp = spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp;
3148
3149 if (direction & SATA_DIR_WRITE) {
3150 bcopy(bp->b_un.b_addr,
3151 spx->txlt_tmp_buf, bp->b_bcount);
3152 }
3153 }
3154 /* Sync the buffer for device or for CPU */
3155 rval = ddi_dma_sync(spx->txlt_buf_dma_handle, 0, 0,
3156 (direction & SATA_DIR_WRITE) ?
3157 DDI_DMA_SYNC_FORDEV : DDI_DMA_SYNC_FORCPU);
3158 ASSERT(rval == DDI_SUCCESS);
3159 if (spx->txlt_tmp_buf != NULL &&
3160 !(direction & SATA_DIR_WRITE)) {
3161 /* Intermediate DMA buffer used for read */
3162 bcopy(spx->txlt_tmp_buf,
3163 bp->b_un.b_addr, bp->b_bcount);
3164 }
3165
3166 }
3167 }
3168 }
3169
3170
3171
3172 /* ******************* SATA - SCSI Translation functions **************** */
3173 /*
3174 * SCSI to SATA pkt and command translation and SATA to SCSI status/error
3175 * translation.
3176 */
3177
3178 /*
3179 * Checks if a device exists and can be access and translates common
3180 * scsi_pkt data to sata_pkt data.
3181 *
3182 * Flag argument indicates that a non-read/write ATA command may be sent
3183 * to HBA in arbitrary SYNC mode to execute this packet.
3184 *
3185 * Returns TRAN_ACCEPT and scsi pkt_reason CMD_CMPLT if device exists and
3186 * sata_pkt was set-up.
3187 * Returns TRAN_ACCEPT and scsi pkt_reason CMD_DEV_GONE if device does not
3188 * exist and pkt_comp callback was scheduled.
3189 * Returns other TRAN_XXXXX values when error occured and command should be
3190 * rejected with the returned TRAN_XXXXX value.
3191 *
3192 * This function should be called with port mutex held.
3193 */
3194 static int
3195 sata_txlt_generic_pkt_info(sata_pkt_txlate_t *spx, int *reason, int flag)
3196 {
3197 sata_drive_info_t *sdinfo;
3198 sata_device_t sata_device;
3199 const struct sata_cmd_flags sata_initial_cmd_flags = {
3200 SATA_DIR_NODATA_XFER,
3201 /* all other values to 0/FALSE */
3202 };
3203 /*
3204 * Pkt_reason has to be set if the pkt_comp callback is invoked,
3205 * and that implies TRAN_ACCEPT return value. Any other returned value
3206 * indicates that the scsi packet was not accepted (the reason will not
3207 * be checked by the scsi target driver).
3208 * To make debugging easier, we set pkt_reason to know value here.
3209 * It may be changed later when different completion reason is
3210 * determined.
3211 */
3212 spx->txlt_scsi_pkt->pkt_reason = CMD_TRAN_ERR;
3213 *reason = CMD_TRAN_ERR;
3214
3215 /* Validate address */
3216 switch (sata_validate_scsi_address(spx->txlt_sata_hba_inst,
3217 &spx->txlt_scsi_pkt->pkt_address, &sata_device)) {
3218
3219 case -1:
3220 /* Invalid address or invalid device type */
3221 return (TRAN_BADPKT);
3222 case 2:
3223 /*
3224 * Valid address but device type is unknown - Chack if it is
3225 * in the reset state and therefore in an indeterminate state.
3226 */
3227 sdinfo = sata_get_device_info(spx->txlt_sata_hba_inst,
3228 &spx->txlt_sata_pkt->satapkt_device);
3229 if (sdinfo != NULL && (sdinfo->satadrv_event_flags &
3230 (SATA_EVNT_DEVICE_RESET |
3231 SATA_EVNT_INPROC_DEVICE_RESET)) != 0) {
3232 if (!ddi_in_panic()) {
3233 spx->txlt_scsi_pkt->pkt_reason = CMD_INCOMPLETE;
3234 *reason = CMD_INCOMPLETE;
3235 SATADBG1(SATA_DBG_SCSI_IF,
3236 spx->txlt_sata_hba_inst,
3237 "sata_scsi_start: rejecting command "
3238 "because of device reset state\n", NULL);
3239 return (TRAN_BUSY);
3240 }
3241 }
3242 /* FALLTHROUGH */
3243 case 1:
3244 /* valid address but no valid device - it has disappeared */
3245 spx->txlt_scsi_pkt->pkt_reason = CMD_DEV_GONE;
3246 *reason = CMD_DEV_GONE;
3247 /*
3248 * The sd target driver is checking CMD_DEV_GONE pkt_reason
3249 * only in callback function (for normal requests) and
3250 * in the dump code path.
3251 * So, if the callback is available, we need to do
3252 * the callback rather than returning TRAN_FATAL_ERROR here.
3253 */
3254 if (spx->txlt_scsi_pkt->pkt_comp != NULL) {
3255 /* scsi callback required */
3256 if (servicing_interrupt()) {
3257 if (taskq_dispatch(SATA_TXLT_TASKQ(spx),
3258 (task_func_t *)spx->txlt_scsi_pkt->pkt_comp,
3259 (void *)spx->txlt_scsi_pkt, TQ_NOSLEEP) ==
3260 NULL) {
3261 return (TRAN_BUSY);
3262 }
3263 } else if (taskq_dispatch(SATA_TXLT_TASKQ(spx),
3264 (task_func_t *)spx->txlt_scsi_pkt->pkt_comp,
3265 (void *)spx->txlt_scsi_pkt, TQ_SLEEP) == NULL) {
3266 /* Scheduling the callback failed */
3267 return (TRAN_BUSY);
3268 }
3269
3270 return (TRAN_ACCEPT);
3271 }
3272 return (TRAN_FATAL_ERROR);
3273 default:
3274 /* all OK; pkt reason will be overwritten later */
3275 break;
3276 }
3277 /*
3278 * If pkt is to be executed in polling mode and a command will not be
3279 * emulated in SATA module (requires sending a non-read/write ATA
3280 * command to HBA driver in arbitrary SYNC mode) and we are in the
3281 * interrupt context and not in the panic dump, then reject the packet
3282 * to avoid a possible interrupt stack overrun or hang caused by
3283 * a potentially blocked interrupt.
3284 */
3285 if (((spx->txlt_scsi_pkt->pkt_flags & FLAG_NOINTR) != 0 || flag != 0) &&
3286 servicing_interrupt() && !ddi_in_panic()) {
3287 SATADBG1(SATA_DBG_INTR_CTX, spx->txlt_sata_hba_inst,
3288 "sata_scsi_start: rejecting synchronous command because "
3289 "of interrupt context\n", NULL);
3290 return (TRAN_BUSY);
3291 }
3292
3293 sdinfo = sata_get_device_info(spx->txlt_sata_hba_inst,
3294 &spx->txlt_sata_pkt->satapkt_device);
3295
3296 /*
3297 * If device is in reset condition, reject the packet with
3298 * TRAN_BUSY, unless:
3299 * 1. system is panicking (dumping)
3300 * In such case only one thread is running and there is no way to
3301 * process reset.
3302 * 2. cfgadm operation is is progress (internal APCTL lock is set)
3303 * Some cfgadm operations involve drive commands, so reset condition
3304 * needs to be ignored for IOCTL operations.
3305 */
3306 if ((sdinfo->satadrv_event_flags &
3307 (SATA_EVNT_DEVICE_RESET | SATA_EVNT_INPROC_DEVICE_RESET)) != 0) {
3308
3309 if (!ddi_in_panic() &&
3310 ((SATA_CPORT_EVENT_FLAGS(spx->txlt_sata_hba_inst,
3311 sata_device.satadev_addr.cport) &
3312 SATA_APCTL_LOCK_PORT_BUSY) == 0)) {
3313 spx->txlt_scsi_pkt->pkt_reason = CMD_INCOMPLETE;
3314 *reason = CMD_INCOMPLETE;
3315 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst,
3316 "sata_scsi_start: rejecting command because "
3317 "of device reset state\n", NULL);
3318 return (TRAN_BUSY);
3319 }
3320 }
3321
3322 /*
3323 * Fix the dev_type in the sata_pkt->satapkt_device. It was not set by
3324 * sata_scsi_pkt_init() because pkt init had to work also with
3325 * non-existing devices.
3326 * Now we know that the packet was set-up for a real device, so its
3327 * type is known.
3328 */
3329 spx->txlt_sata_pkt->satapkt_device.satadev_type = sdinfo->satadrv_type;
3330
3331 spx->txlt_sata_pkt->satapkt_cmd.satacmd_flags = sata_initial_cmd_flags;
3332 if ((SATA_CPORT_INFO(spx->txlt_sata_hba_inst,
3333 sata_device.satadev_addr.cport)->cport_event_flags &
3334 SATA_APCTL_LOCK_PORT_BUSY) != 0) {
3335 spx->txlt_sata_pkt->satapkt_cmd.satacmd_flags.
3336 sata_ignore_dev_reset = B_TRUE;
3337 }
3338 /*
3339 * At this point the generic translation routine determined that the
3340 * scsi packet should be accepted. Packet completion reason may be
3341 * changed later when a different completion reason is determined.
3342 */
3343 spx->txlt_scsi_pkt->pkt_reason = CMD_CMPLT;
3344 *reason = CMD_CMPLT;
3345
3346 if ((spx->txlt_scsi_pkt->pkt_flags & FLAG_NOINTR) != 0) {
3347 /* Synchronous execution */
3348 spx->txlt_sata_pkt->satapkt_op_mode = SATA_OPMODE_SYNCH |
3349 SATA_OPMODE_POLLING;
3350 spx->txlt_sata_pkt->satapkt_cmd.satacmd_flags.
3351 sata_ignore_dev_reset = ddi_in_panic();
3352 } else {
3353 /* Asynchronous execution */
3354 spx->txlt_sata_pkt->satapkt_op_mode = SATA_OPMODE_ASYNCH |
3355 SATA_OPMODE_INTERRUPTS;
3356 }
3357 /* Convert queuing information */
3358 if (spx->txlt_scsi_pkt->pkt_flags & FLAG_STAG)
3359 spx->txlt_sata_pkt->satapkt_cmd.satacmd_flags.sata_queue_stag =
3360 B_TRUE;
3361 else if (spx->txlt_scsi_pkt->pkt_flags &
3362 (FLAG_OTAG | FLAG_HTAG | FLAG_HEAD))
3363 spx->txlt_sata_pkt->satapkt_cmd.satacmd_flags.sata_queue_otag =
3364 B_TRUE;
3365
3366 /* Always limit pkt time */
3367 if (spx->txlt_scsi_pkt->pkt_time == 0)
3368 spx->txlt_sata_pkt->satapkt_time = sata_default_pkt_time;
3369 else
3370 /* Pass on scsi_pkt time */
3371 spx->txlt_sata_pkt->satapkt_time =
3372 spx->txlt_scsi_pkt->pkt_time;
3373
3374 return (TRAN_ACCEPT);
3375 }
3376
3377
3378 /*
3379 * Translate ATA Identify Device data to SCSI Inquiry data.
3380 * This function may be called only for ATA devices.
3381 * This function should not be called for ATAPI devices - they
3382 * respond directly to SCSI Inquiry command.
3383 *
3384 * SATA Identify Device data has to be valid in sata_drive_info.
3385 * Buffer has to accomodate the inquiry length (36 bytes).
3386 *
3387 * This function should be called with a port mutex held.
3388 */
3389 static void
3390 sata_identdev_to_inquiry(sata_hba_inst_t *sata_hba_inst,
3391 sata_drive_info_t *sdinfo, uint8_t *buf)
3392 {
3393
3394 struct scsi_inquiry *inq = (struct scsi_inquiry *)buf;
3395 struct sata_id *sid = &sdinfo->satadrv_id;
3396
3397 /* Start with a nice clean slate */
3398 bzero((void *)inq, sizeof (struct scsi_inquiry));
3399
3400 /*
3401 * Rely on the dev_type for setting paripheral qualifier.
3402 * Assume that DTYPE_RODIRECT applies to CD/DVD R/W devices.
3403 * It could be that DTYPE_OPTICAL could also qualify in the future.
3404 * ATAPI Inquiry may provide more data to the target driver.
3405 */
3406 inq->inq_dtype = sdinfo->satadrv_type == SATA_DTYPE_ATADISK ?
3407 DTYPE_DIRECT : DTYPE_RODIRECT; /* DTYPE_UNKNOWN; */
3408
3409 /* CFA type device is not a removable media device */
3410 inq->inq_rmb = ((sid->ai_config != SATA_CFA_TYPE) &&
3411 (sid->ai_config & SATA_REM_MEDIA)) ? 1 : 0;
3412 inq->inq_qual = 0; /* Device type qualifier (obsolete in SCSI3? */
3413 inq->inq_iso = 0; /* ISO version */
3414 inq->inq_ecma = 0; /* ECMA version */
3415 inq->inq_ansi = 3; /* ANSI version - SCSI 3 */
3416 inq->inq_aenc = 0; /* Async event notification cap. */
3417 inq->inq_trmiop = 0; /* Supports TERMINATE I/O PROC msg - NO */
3418 inq->inq_normaca = 0; /* setting NACA bit supported - NO */
3419 inq->inq_rdf = RDF_SCSI2; /* Response data format- SPC-3 */
3420 inq->inq_len = 31; /* Additional length */
3421 inq->inq_dualp = 0; /* dual port device - NO */
3422 inq->inq_reladdr = 0; /* Supports relative addressing - NO */
3423 inq->inq_sync = 0; /* Supports synchronous data xfers - NO */
3424 inq->inq_linked = 0; /* Supports linked commands - NO */
3425 /*
3426 * Queuing support - controller has to
3427 * support some sort of command queuing.
3428 */
3429 if (SATA_QDEPTH(sata_hba_inst) > 1)
3430 inq->inq_cmdque = 1; /* Supports command queueing - YES */
3431 else
3432 inq->inq_cmdque = 0; /* Supports command queueing - NO */
3433 inq->inq_sftre = 0; /* Supports Soft Reset option - NO ??? */
3434 inq->inq_wbus32 = 0; /* Supports 32 bit wide data xfers - NO */
3435 inq->inq_wbus16 = 0; /* Supports 16 bit wide data xfers - NO */
3436
3437 #ifdef _LITTLE_ENDIAN
3438 /* Swap text fields to match SCSI format */
3439 bcopy("ATA ", inq->inq_vid, 8); /* Vendor ID */
3440 swab(sid->ai_model, inq->inq_pid, 16); /* Product ID */
3441 if (strncmp(&sid->ai_fw[4], " ", 4) == 0)
3442 swab(sid->ai_fw, inq->inq_revision, 4); /* Revision level */
3443 else
3444 swab(&sid->ai_fw[4], inq->inq_revision, 4); /* Rev. level */
3445 #else /* _LITTLE_ENDIAN */
3446 bcopy("ATA ", inq->inq_vid, 8); /* Vendor ID */
3447 bcopy(sid->ai_model, inq->inq_pid, 16); /* Product ID */
3448 if (strncmp(&sid->ai_fw[4], " ", 4) == 0)
3449 bcopy(sid->ai_fw, inq->inq_revision, 4); /* Revision level */
3450 else
3451 bcopy(&sid->ai_fw[4], inq->inq_revision, 4); /* Rev. level */
3452 #endif /* _LITTLE_ENDIAN */
3453 }
3454
3455
3456 /*
3457 * Scsi response set up for invalid command (command not supported)
3458 *
3459 * Returns TRAN_ACCEPT and appropriate values in scsi_pkt fields.
3460 */
3461 static int
3462 sata_txlt_invalid_command(sata_pkt_txlate_t *spx)
3463 {
3464 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt;
3465 struct scsi_extended_sense *sense;
3466
3467 scsipkt->pkt_reason = CMD_CMPLT;
3468 scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET |
3469 STATE_SENT_CMD | STATE_GOT_STATUS;
3470
3471 *scsipkt->pkt_scbp = STATUS_CHECK;
3472
3473 sense = sata_arq_sense(spx);
3474 sense->es_key = KEY_ILLEGAL_REQUEST;
3475 sense->es_add_code = SD_SCSI_ASC_INVALID_COMMAND_CODE;
3476
3477 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst,
3478 "Scsi_pkt completion reason %x\n", scsipkt->pkt_reason);
3479
3480 if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0 &&
3481 scsipkt->pkt_comp != NULL) {
3482 /* scsi callback required */
3483 if (servicing_interrupt()) {
3484 if (taskq_dispatch(SATA_TXLT_TASKQ(spx),
3485 (task_func_t *)spx->txlt_scsi_pkt->pkt_comp,
3486 (void *)spx->txlt_scsi_pkt, TQ_NOSLEEP) == NULL) {
3487 return (TRAN_BUSY);
3488 }
3489 } else if (taskq_dispatch(SATA_TXLT_TASKQ(spx),
3490 (task_func_t *)spx->txlt_scsi_pkt->pkt_comp,
3491 (void *)spx->txlt_scsi_pkt, TQ_SLEEP) == NULL) {
3492 /* Scheduling the callback failed */
3493 return (TRAN_BUSY);
3494 }
3495 }
3496 return (TRAN_ACCEPT);
3497 }
3498
3499 /*
3500 * Scsi response set up for check condition with special sense key
3501 * and additional sense code.
3502 *
3503 * Returns TRAN_ACCEPT and appropriate values in scsi_pkt fields.
3504 */
3505 static int
3506 sata_txlt_check_condition(sata_pkt_txlate_t *spx, uchar_t key, uchar_t code)
3507 {
3508 sata_hba_inst_t *shi = SATA_TXLT_HBA_INST(spx);
3509 int cport = SATA_TXLT_CPORT(spx);
3510 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt;
3511 struct scsi_extended_sense *sense;
3512
3513 mutex_enter(&SATA_CPORT_MUTEX(shi, cport));
3514 scsipkt->pkt_reason = CMD_CMPLT;
3515 scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET |
3516 STATE_SENT_CMD | STATE_GOT_STATUS;
3517
3518 *scsipkt->pkt_scbp = STATUS_CHECK;
3519
3520 sense = sata_arq_sense(spx);
3521 sense->es_key = key;
3522 sense->es_add_code = code;
3523
3524 mutex_exit(&SATA_CPORT_MUTEX(shi, cport));
3525
3526 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst,
3527 "Scsi_pkt completion reason %x\n", scsipkt->pkt_reason);
3528
3529 if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0 &&
3530 scsipkt->pkt_comp != NULL) {
3531 /* scsi callback required */
3532 if (servicing_interrupt()) {
3533 if (taskq_dispatch(SATA_TXLT_TASKQ(spx),
3534 (task_func_t *)spx->txlt_scsi_pkt->pkt_comp,
3535 (void *)spx->txlt_scsi_pkt, TQ_NOSLEEP) == NULL) {
3536 return (TRAN_BUSY);
3537 }
3538 } else if (taskq_dispatch(SATA_TXLT_TASKQ(spx),
3539 (task_func_t *)spx->txlt_scsi_pkt->pkt_comp,
3540 (void *)spx->txlt_scsi_pkt, TQ_SLEEP) == NULL) {
3541 /* Scheduling the callback failed */
3542 return (TRAN_BUSY);
3543 }
3544 }
3545 return (TRAN_ACCEPT);
3546 }
3547
3548 /*
3549 * Scsi response setup for
3550 * emulated non-data command that requires no action/return data
3551 *
3552 * Returns TRAN_ACCEPT and appropriate values in scsi_pkt fields.
3553 */
3554 static int
3555 sata_txlt_nodata_cmd_immediate(sata_pkt_txlate_t *spx)
3556 {
3557 int rval;
3558 int reason;
3559 kmutex_t *cport_mutex = &(SATA_TXLT_CPORT_MUTEX(spx));
3560
3561 mutex_enter(cport_mutex);
3562
3563 if (((rval = sata_txlt_generic_pkt_info(spx, &reason, 0)) !=
3564 TRAN_ACCEPT) || (reason == CMD_DEV_GONE)) {
3565 mutex_exit(cport_mutex);
3566 return (rval);
3567 }
3568 mutex_exit(cport_mutex);
3569
3570 spx->txlt_scsi_pkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET |
3571 STATE_SENT_CMD | STATE_GOT_STATUS;
3572 spx->txlt_scsi_pkt->pkt_reason = CMD_CMPLT;
3573 *(spx->txlt_scsi_pkt->pkt_scbp) = STATUS_GOOD;
3574
3575 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst,
3576 "Scsi_pkt completion reason %x\n",
3577 spx->txlt_scsi_pkt->pkt_reason);
3578
3579 if ((spx->txlt_scsi_pkt->pkt_flags & FLAG_NOINTR) == 0 &&
3580 spx->txlt_scsi_pkt->pkt_comp != NULL) {
3581 /* scsi callback required */
3582 if (servicing_interrupt()) {
3583 if (taskq_dispatch(SATA_TXLT_TASKQ(spx),
3584 (task_func_t *)spx->txlt_scsi_pkt->pkt_comp,
3585 (void *)spx->txlt_scsi_pkt, TQ_NOSLEEP) == NULL) {
3586 return (TRAN_BUSY);
3587 }
3588 } else if (taskq_dispatch(SATA_TXLT_TASKQ(spx),
3589 (task_func_t *)spx->txlt_scsi_pkt->pkt_comp,
3590 (void *)spx->txlt_scsi_pkt, TQ_SLEEP) == NULL) {
3591 /* Scheduling the callback failed */
3592 return (TRAN_BUSY);
3593 }
3594 }
3595 return (TRAN_ACCEPT);
3596 }
3597
3598
3599 /*
3600 * SATA translate command: Inquiry / Identify Device
3601 * Use cached Identify Device data for now, rather than issuing actual
3602 * Device Identify cmd request. If device is detached and re-attached,
3603 * asynchronous event processing should fetch and refresh Identify Device
3604 * data.
3605 * VPD pages supported now:
3606 * Vital Product Data page
3607 * Unit Serial Number page
3608 * Block Device Characteristics Page
3609 * ATA Information Page
3610 *
3611 * Returns TRAN_ACCEPT and appropriate values in scsi_pkt fields.
3612 */
3613
3614 #define EVPD 1 /* Extended Vital Product Data flag */
3615 #define CMDDT 2 /* Command Support Data - Obsolete */
3616 #define INQUIRY_SUP_VPD_PAGE 0 /* Supported VPD Pages Page Code */
3617 #define INQUIRY_USN_PAGE 0x80 /* Unit Serial Number Page Code */
3618 #define INQUIRY_BDC_PAGE 0xB1 /* Block Device Characteristics Page */
3619 /* Code */
3620 #define INQUIRY_ATA_INFO_PAGE 0x89 /* ATA Information Page Code */
3621 #define INQUIRY_DEV_IDENTIFICATION_PAGE 0x83 /* Not needed yet */
3622
3623 static int
3624 sata_txlt_inquiry(sata_pkt_txlate_t *spx)
3625 {
3626 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt;
3627 struct buf *bp = spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp;
3628 sata_drive_info_t *sdinfo;
3629 struct scsi_extended_sense *sense;
3630 int count;
3631 uint8_t *p;
3632 int i, j;
3633 uint8_t page_buf[1024]; /* Max length */
3634 int rval, reason;
3635 ushort_t rate;
3636 kmutex_t *cport_mutex = &(SATA_TXLT_CPORT_MUTEX(spx));
3637
3638 mutex_enter(cport_mutex);
3639
3640 if (((rval = sata_txlt_generic_pkt_info(spx, &reason, 0)) !=
3641 TRAN_ACCEPT) || (reason == CMD_DEV_GONE)) {
3642 mutex_exit(cport_mutex);
3643 return (rval);
3644 }
3645
3646 sdinfo = sata_get_device_info(spx->txlt_sata_hba_inst,
3647 &spx->txlt_sata_pkt->satapkt_device);
3648
3649 ASSERT(sdinfo != NULL);
3650
3651 scsipkt->pkt_reason = CMD_CMPLT;
3652 scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET |
3653 STATE_SENT_CMD | STATE_GOT_STATUS;
3654
3655 /* Reject not supported request */
3656 if (scsipkt->pkt_cdbp[1] & CMDDT) { /* No support for this bit */
3657 *scsipkt->pkt_scbp = STATUS_CHECK;
3658 sense = sata_arq_sense(spx);
3659 sense->es_key = KEY_ILLEGAL_REQUEST;
3660 sense->es_add_code = SD_SCSI_ASC_INVALID_FIELD_IN_CDB;
3661 goto done;
3662 }
3663
3664 /* Valid Inquiry request */
3665 *scsipkt->pkt_scbp = STATUS_GOOD;
3666
3667 if (bp != NULL && bp->b_un.b_addr && bp->b_bcount) {
3668
3669 /*
3670 * Because it is fully emulated command storing data
3671 * programatically in the specified buffer, release
3672 * preallocated DMA resources before storing data in the buffer,
3673 * so no unwanted DMA sync would take place.
3674 */
3675 sata_scsi_dmafree(NULL, scsipkt);
3676
3677 if (!(scsipkt->pkt_cdbp[1] & EVPD)) {
3678 /* Standard Inquiry Data request */
3679 struct scsi_inquiry inq;
3680 unsigned int bufsize;
3681
3682 sata_identdev_to_inquiry(spx->txlt_sata_hba_inst,
3683 sdinfo, (uint8_t *)&inq);
3684 /* Copy no more than requested */
3685 count = MIN(bp->b_bcount,
3686 sizeof (struct scsi_inquiry));
3687 bufsize = scsipkt->pkt_cdbp[4];
3688 bufsize |= scsipkt->pkt_cdbp[3] << 8;
3689 count = MIN(count, bufsize);
3690 bcopy(&inq, bp->b_un.b_addr, count);
3691
3692 scsipkt->pkt_state |= STATE_XFERRED_DATA;
3693 scsipkt->pkt_resid = scsipkt->pkt_cdbp[4] > count ?
3694 bufsize - count : 0;
3695 } else {
3696 /*
3697 * peripheral_qualifier = 0;
3698 *
3699 * We are dealing only with HD and will be
3700 * dealing with CD/DVD devices soon
3701 */
3702 uint8_t peripheral_device_type =
3703 sdinfo->satadrv_type == SATA_DTYPE_ATADISK ?
3704 DTYPE_DIRECT : DTYPE_RODIRECT;
3705
3706 bzero(page_buf, sizeof (page_buf));
3707
3708 switch ((uint_t)scsipkt->pkt_cdbp[2]) {
3709 case INQUIRY_SUP_VPD_PAGE:
3710 /*
3711 * Request for supported Vital Product Data
3712 * pages.
3713 */
3714 page_buf[0] = peripheral_device_type;
3715 page_buf[1] = INQUIRY_SUP_VPD_PAGE;
3716 page_buf[2] = 0;
3717 page_buf[3] = 4; /* page length */
3718 page_buf[4] = INQUIRY_SUP_VPD_PAGE;
3719 page_buf[5] = INQUIRY_USN_PAGE;
3720 page_buf[6] = INQUIRY_BDC_PAGE;
3721 page_buf[7] = INQUIRY_ATA_INFO_PAGE;
3722 /* Copy no more than requested */
3723 count = MIN(bp->b_bcount, 8);
3724 bcopy(page_buf, bp->b_un.b_addr, count);
3725 break;
3726
3727 case INQUIRY_USN_PAGE:
3728 /*
3729 * Request for Unit Serial Number page.
3730 * Set-up the page.
3731 */
3732 page_buf[0] = peripheral_device_type;
3733 page_buf[1] = INQUIRY_USN_PAGE;
3734 page_buf[2] = 0;
3735 /* remaining page length */
3736 page_buf[3] = SATA_ID_SERIAL_LEN;
3737
3738 /*
3739 * Copy serial number from Identify Device data
3740 * words into the inquiry page and swap bytes
3741 * when necessary.
3742 */
3743 p = (uint8_t *)(sdinfo->satadrv_id.ai_drvser);
3744 #ifdef _LITTLE_ENDIAN
3745 swab(p, &page_buf[4], SATA_ID_SERIAL_LEN);
3746 #else
3747 bcopy(p, &page_buf[4], SATA_ID_SERIAL_LEN);
3748 #endif
3749 /*
3750 * Least significant character of the serial
3751 * number shall appear as the last byte,
3752 * according to SBC-3 spec.
3753 * Count trailing spaces to determine the
3754 * necessary shift length.
3755 */
3756 p = &page_buf[SATA_ID_SERIAL_LEN + 4 - 1];
3757 for (j = 0; j < SATA_ID_SERIAL_LEN; j++) {
3758 if (*(p - j) != '\0' &&
3759 *(p - j) != '\040')
3760 break;
3761 }
3762
3763 /*
3764 * Shift SN string right, so that the last
3765 * non-blank character would appear in last
3766 * byte of SN field in the page.
3767 * 'j' is the shift length.
3768 */
3769 for (i = 0;
3770 i < (SATA_ID_SERIAL_LEN - j) && j != 0;
3771 i++, p--)
3772 *p = *(p - j);
3773
3774 /*
3775 * Add leading spaces - same number as the
3776 * shift size
3777 */
3778 for (; j > 0; j--)
3779 page_buf[4 + j - 1] = '\040';
3780
3781 count = MIN(bp->b_bcount,
3782 SATA_ID_SERIAL_LEN + 4);
3783 bcopy(page_buf, bp->b_un.b_addr, count);
3784 break;
3785
3786 case INQUIRY_BDC_PAGE:
3787 /*
3788 * Request for Block Device Characteristics
3789 * page. Set-up the page.
3790 */
3791 page_buf[0] = peripheral_device_type;
3792 page_buf[1] = INQUIRY_BDC_PAGE;
3793 page_buf[2] = 0;
3794 /* remaining page length */
3795 page_buf[3] = SATA_ID_BDC_LEN;
3796
3797 rate = sdinfo->satadrv_id.ai_medrotrate;
3798 page_buf[4] = (rate >> 8) & 0xff;
3799 page_buf[5] = rate & 0xff;
3800 page_buf[6] = 0;
3801 page_buf[7] = sdinfo->satadrv_id.
3802 ai_nomformfactor & 0xf;
3803
3804 count = MIN(bp->b_bcount,
3805 SATA_ID_BDC_LEN + 4);
3806 bcopy(page_buf, bp->b_un.b_addr, count);
3807 break;
3808
3809 case INQUIRY_ATA_INFO_PAGE:
3810 /*
3811 * Request for ATA Information page.
3812 */
3813 page_buf[0] = peripheral_device_type;
3814 page_buf[1] = INQUIRY_ATA_INFO_PAGE;
3815 page_buf[2] = (SATA_ID_ATA_INFO_LEN >> 8) &
3816 0xff;
3817 page_buf[3] = SATA_ID_ATA_INFO_LEN & 0xff;
3818 /* page_buf[4-7] reserved */
3819 #ifdef _LITTLE_ENDIAN
3820 bcopy("ATA ", &page_buf[8], 8);
3821 swab(sdinfo->satadrv_id.ai_model,
3822 &page_buf[16], 16);
3823 if (strncmp(&sdinfo->satadrv_id.ai_fw[4],
3824 " ", 4) == 0) {
3825 swab(sdinfo->satadrv_id.ai_fw,
3826 &page_buf[32], 4);
3827 } else {
3828 swab(&sdinfo->satadrv_id.ai_fw[4],
3829 &page_buf[32], 4);
3830 }
3831 #else /* _LITTLE_ENDIAN */
3832 bcopy("ATA ", &page_buf[8], 8);
3833 bcopy(sdinfo->satadrv_id.ai_model,
3834 &page_buf[16], 16);
3835 if (strncmp(&sdinfo->satadrv_id.ai_fw[4],
3836 " ", 4) == 0) {
3837 bcopy(sdinfo->satadrv_id.ai_fw,
3838 &page_buf[32], 4);
3839 } else {
3840 bcopy(&sdinfo->satadrv_id.ai_fw[4],
3841 &page_buf[32], 4);
3842 }
3843 #endif /* _LITTLE_ENDIAN */
3844 /*
3845 * page_buf[36-55] which defines the device
3846 * signature is not defined at this
3847 * time.
3848 */
3849
3850 /* Set the command code */
3851 if (sdinfo->satadrv_type ==
3852 SATA_DTYPE_ATADISK) {
3853 page_buf[56] = SATAC_ID_DEVICE;
3854 } else if (sdinfo->satadrv_type ==
3855 SATA_DTYPE_ATAPI) {
3856 page_buf[56] = SATAC_ID_PACKET_DEVICE;
3857 }
3858 /*
3859 * If the command code, page_buf[56], is not
3860 * zero and if one of the identify commands
3861 * succeeds, return the identify data.
3862 */
3863 if ((page_buf[56] != 0) &&
3864 (sata_fetch_device_identify_data(
3865 spx->txlt_sata_hba_inst, sdinfo) ==
3866 SATA_SUCCESS)) {
3867 bcopy(&sdinfo->satadrv_id,
3868 &page_buf[60], sizeof (sata_id_t));
3869 }
3870
3871 /* Need to copy out the page_buf to bp */
3872 count = MIN(bp->b_bcount,
3873 SATA_ID_ATA_INFO_LEN + 4);
3874 bcopy(page_buf, bp->b_un.b_addr, count);
3875 break;
3876
3877 case INQUIRY_DEV_IDENTIFICATION_PAGE:
3878 /*
3879 * We may want to implement this page, when
3880 * identifiers are common for SATA devices
3881 * But not now.
3882 */
3883 /*FALLTHROUGH*/
3884
3885 default:
3886 /* Request for unsupported VPD page */
3887 *scsipkt->pkt_scbp = STATUS_CHECK;
3888 sense = sata_arq_sense(spx);
3889 sense->es_key = KEY_ILLEGAL_REQUEST;
3890 sense->es_add_code =
3891 SD_SCSI_ASC_INVALID_FIELD_IN_CDB;
3892 goto done;
3893 }
3894 }
3895 scsipkt->pkt_state |= STATE_XFERRED_DATA;
3896 scsipkt->pkt_resid = scsipkt->pkt_cdbp[4] > count ?
3897 scsipkt->pkt_cdbp[4] - count : 0;
3898 }
3899 done:
3900 mutex_exit(cport_mutex);
3901
3902 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst,
3903 "Scsi_pkt completion reason %x\n",
3904 scsipkt->pkt_reason);
3905
3906 if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0 &&
3907 scsipkt->pkt_comp != NULL) {
3908 /* scsi callback required */
3909 if (servicing_interrupt()) {
3910 if (taskq_dispatch(SATA_TXLT_TASKQ(spx),
3911 (task_func_t *)spx->txlt_scsi_pkt->pkt_comp,
3912 (void *)spx->txlt_scsi_pkt, TQ_NOSLEEP) == NULL) {
3913 return (TRAN_BUSY);
3914 }
3915 } else if (taskq_dispatch(SATA_TXLT_TASKQ(spx),
3916 (task_func_t *)spx->txlt_scsi_pkt->pkt_comp,
3917 (void *)spx->txlt_scsi_pkt, TQ_SLEEP) == NULL) {
3918 /* Scheduling the callback failed */
3919 return (TRAN_BUSY);
3920 }
3921 }
3922 return (TRAN_ACCEPT);
3923 }
3924
3925 /*
3926 * SATA translate command: Request Sense.
3927 *
3928 * Returns TRAN_ACCEPT and appropriate values in scsi_pkt fields.
3929 * At the moment this is an emulated command (ATA version for SATA hard disks).
3930 * May be translated into Check Power Mode command in the future.
3931 *
3932 * Note: There is a mismatch between already implemented Informational
3933 * Exception Mode Select page 0x1C and this function.
3934 * When MRIE bit is set in page 0x1C, Request Sense is supposed to return
3935 * NO SENSE and set additional sense code to the exception code - this is not
3936 * implemented here.
3937 */
3938 static int
3939 sata_txlt_request_sense(sata_pkt_txlate_t *spx)
3940 {
3941 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt;
3942 struct scsi_extended_sense sense;
3943 struct buf *bp = spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp;
3944 sata_drive_info_t *sdinfo;
3945 sata_cmd_t *scmd = &spx->txlt_sata_pkt->satapkt_cmd;
3946 int rval, reason, power_state = 0;
3947 kmutex_t *cport_mutex;
3948
3949 cport_mutex = &(SATA_TXLT_CPORT_MUTEX(spx));
3950 mutex_enter(cport_mutex);
3951
3952 if (((rval = sata_txlt_generic_pkt_info(spx, &reason, 1)) !=
3953 TRAN_ACCEPT) || (reason == CMD_DEV_GONE)) {
3954 mutex_exit(cport_mutex);
3955 return (rval);
3956 }
3957
3958 scsipkt->pkt_reason = CMD_CMPLT;
3959 scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET |
3960 STATE_SENT_CMD | STATE_GOT_STATUS;
3961 *scsipkt->pkt_scbp = STATUS_GOOD;
3962
3963 /*
3964 * when CONTROL field's NACA bit == 1
3965 * return ILLEGAL_REQUEST
3966 */
3967 if (scsipkt->pkt_cdbp[5] & CTL_BYTE_NACA_MASK) {
3968 mutex_exit(cport_mutex);
3969 return (sata_txlt_check_condition(spx, KEY_ILLEGAL_REQUEST,
3970 SD_SCSI_ASC_CMD_SEQUENCE_ERR));
3971 }
3972
3973 sdinfo = sata_get_device_info(spx->txlt_sata_hba_inst,
3974 &spx->txlt_sata_pkt->satapkt_device);
3975 ASSERT(sdinfo != NULL);
3976
3977 spx->txlt_sata_pkt->satapkt_op_mode |= SATA_OPMODE_SYNCH;
3978
3979 sata_build_generic_cmd(scmd, SATAC_CHECK_POWER_MODE);
3980 scmd->satacmd_flags.sata_copy_out_sec_count_lsb = B_TRUE;
3981 scmd->satacmd_flags.sata_copy_out_error_reg = B_TRUE;
3982 if (sata_hba_start(spx, &rval) != 0) {
3983 mutex_exit(cport_mutex);
3984 return (rval);
3985 }
3986 if (scmd->satacmd_error_reg != 0) {
3987 mutex_exit(cport_mutex);
3988 return (sata_txlt_check_condition(spx, KEY_NO_SENSE,
3989 SD_SCSI_ASC_NO_ADD_SENSE));
3990 }
3991
3992 switch (scmd->satacmd_sec_count_lsb) {
3993 case SATA_PWRMODE_STANDBY: /* device in standby mode */
3994 if (sdinfo->satadrv_power_level == SATA_POWER_STOPPED)
3995 power_state = SATA_POWER_STOPPED;
3996 else {
3997 power_state = SATA_POWER_STANDBY;
3998 sdinfo->satadrv_power_level = SATA_POWER_STANDBY;
3999 }
4000 break;
4001 case SATA_PWRMODE_IDLE: /* device in idle mode */
4002 power_state = SATA_POWER_IDLE;
4003 sdinfo->satadrv_power_level = SATA_POWER_IDLE;
4004 break;
4005 case SATA_PWRMODE_ACTIVE: /* device in active or idle mode */
4006 default: /* 0x40, 0x41 active mode */
4007 if (sdinfo->satadrv_power_level == SATA_POWER_IDLE)
4008 power_state = SATA_POWER_IDLE;
4009 else {
4010 power_state = SATA_POWER_ACTIVE;
4011 sdinfo->satadrv_power_level = SATA_POWER_ACTIVE;
4012 }
4013 break;
4014 }
4015
4016 mutex_exit(cport_mutex);
4017
4018 if (bp != NULL && bp->b_un.b_addr && bp->b_bcount) {
4019 /*
4020 * Because it is fully emulated command storing data
4021 * programatically in the specified buffer, release
4022 * preallocated DMA resources before storing data in the buffer,
4023 * so no unwanted DMA sync would take place.
4024 */
4025 int count = MIN(bp->b_bcount,
4026 sizeof (struct scsi_extended_sense));
4027 sata_scsi_dmafree(NULL, scsipkt);
4028 bzero(&sense, sizeof (struct scsi_extended_sense));
4029 sense.es_valid = 0; /* Valid LBA */
4030 sense.es_class = 7; /* Response code 0x70 - current err */
4031 sense.es_key = KEY_NO_SENSE;
4032 sense.es_add_len = 6; /* Additional length */
4033 /* Copy no more than requested */
4034 bcopy(&sense, bp->b_un.b_addr, count);
4035 scsipkt->pkt_state |= STATE_XFERRED_DATA;
4036 scsipkt->pkt_resid = 0;
4037 switch (power_state) {
4038 case SATA_POWER_IDLE:
4039 case SATA_POWER_STANDBY:
4040 sense.es_add_code =
4041 SD_SCSI_ASC_LOW_POWER_CONDITION_ON;
4042 break;
4043 case SATA_POWER_STOPPED:
4044 sense.es_add_code = SD_SCSI_ASC_NO_ADD_SENSE;
4045 break;
4046 case SATA_POWER_ACTIVE:
4047 default:
4048 break;
4049 }
4050 }
4051
4052 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst,
4053 "Scsi_pkt completion reason %x\n",
4054 scsipkt->pkt_reason);
4055
4056 if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0 &&
4057 scsipkt->pkt_comp != NULL) {
4058 /* scsi callback required */
4059 if (servicing_interrupt()) {
4060 if (taskq_dispatch(SATA_TXLT_TASKQ(spx),
4061 (task_func_t *)spx->txlt_scsi_pkt->pkt_comp,
4062 (void *)spx->txlt_scsi_pkt, TQ_NOSLEEP) == NULL) {
4063 return (TRAN_BUSY);
4064 }
4065 } else if (taskq_dispatch(SATA_TXLT_TASKQ(spx),
4066 (task_func_t *)spx->txlt_scsi_pkt->pkt_comp,
4067 (void *)spx->txlt_scsi_pkt, TQ_SLEEP) == NULL) {
4068 /* Scheduling the callback failed */
4069 return (TRAN_BUSY);
4070 }
4071 }
4072 return (TRAN_ACCEPT);
4073 }
4074
4075 /*
4076 * SATA translate command: Test Unit Ready
4077 * (ATA version for SATA hard disks).
4078 * It is translated into the Check Power Mode command.
4079 *
4080 * Returns TRAN_ACCEPT and appropriate values in scsi_pkt fields.
4081 */
4082 static int
4083 sata_txlt_test_unit_ready(sata_pkt_txlate_t *spx)
4084 {
4085 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt;
4086 struct scsi_extended_sense *sense;
4087 sata_cmd_t *scmd = &spx->txlt_sata_pkt->satapkt_cmd;
4088 sata_drive_info_t *sdinfo;
4089 int power_state;
4090 int rval, reason;
4091 kmutex_t *cport_mutex = &(SATA_TXLT_CPORT_MUTEX(spx));
4092
4093 mutex_enter(cport_mutex);
4094
4095 if (((rval = sata_txlt_generic_pkt_info(spx, &reason, 1)) !=
4096 TRAN_ACCEPT) || (reason == CMD_DEV_GONE)) {
4097 mutex_exit(cport_mutex);
4098 return (rval);
4099 }
4100
4101 sdinfo = sata_get_device_info(spx->txlt_sata_hba_inst,
4102 &spx->txlt_sata_pkt->satapkt_device);
4103 ASSERT(sdinfo != NULL);
4104
4105 spx->txlt_sata_pkt->satapkt_op_mode |= SATA_OPMODE_SYNCH;
4106
4107 /* send CHECK POWER MODE command */
4108 sata_build_generic_cmd(scmd, SATAC_CHECK_POWER_MODE);
4109 scmd->satacmd_flags.sata_copy_out_sec_count_lsb = B_TRUE;
4110 scmd->satacmd_flags.sata_copy_out_error_reg = B_TRUE;
4111 if (sata_hba_start(spx, &rval) != 0) {
4112 mutex_exit(cport_mutex);
4113 return (rval);
4114 }
4115
4116 if (scmd->satacmd_error_reg != 0) {
4117 mutex_exit(cport_mutex);
4118 return (sata_txlt_check_condition(spx, KEY_NOT_READY,
4119 SD_SCSI_ASC_LU_NOT_RESPONSE));
4120 }
4121
4122 power_state = scmd->satacmd_sec_count_lsb;
4123
4124 /*
4125 * return NOT READY when device in STOPPED mode
4126 */
4127 if (power_state == SATA_PWRMODE_STANDBY &&
4128 sdinfo->satadrv_power_level == SATA_POWER_STOPPED) {
4129 *scsipkt->pkt_scbp = STATUS_CHECK;
4130 sense = sata_arq_sense(spx);
4131 sense->es_key = KEY_NOT_READY;
4132 sense->es_add_code = SD_SCSI_ASC_LU_NOT_READY;
4133 } else {
4134 /*
4135 * For other power mode, return GOOD status
4136 */
4137 *scsipkt->pkt_scbp = STATUS_GOOD;
4138 }
4139
4140 scsipkt->pkt_reason = CMD_CMPLT;
4141 scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET |
4142 STATE_SENT_CMD | STATE_GOT_STATUS;
4143
4144 mutex_exit(cport_mutex);
4145
4146 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst,
4147 "Scsi_pkt completion reason %x\n", scsipkt->pkt_reason);
4148
4149 if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0 &&
4150 scsipkt->pkt_comp != NULL) {
4151 /* scsi callback required */
4152 if (servicing_interrupt()) {
4153 if (taskq_dispatch(SATA_TXLT_TASKQ(spx),
4154 (task_func_t *)spx->txlt_scsi_pkt->pkt_comp,
4155 (void *)spx->txlt_scsi_pkt, TQ_NOSLEEP) == NULL) {
4156 return (TRAN_BUSY);
4157 }
4158 } else if (taskq_dispatch(SATA_TXLT_TASKQ(spx),
4159 (task_func_t *)spx->txlt_scsi_pkt->pkt_comp,
4160 (void *)spx->txlt_scsi_pkt, TQ_SLEEP) == NULL) {
4161 /* Scheduling the callback failed */
4162 return (TRAN_BUSY);
4163 }
4164 }
4165
4166 return (TRAN_ACCEPT);
4167 }
4168
4169 /*
4170 * SATA translate command: Start Stop Unit
4171 * Translation depends on a command:
4172 *
4173 * Power condition bits will be supported
4174 * and the power level should be maintained by SATL,
4175 * When SATL received a command, it will check the
4176 * power level firstly, and return the status according
4177 * to SAT2 v2.6 and SAT-2 Standby Modifications
4178 *
4179 * SPC-4/SBC-3 SATL ATA power condition SATL SPC/SBC
4180 * -----------------------------------------------------------------------
4181 * SSU_PC1 Active <==> ATA Active <==> SSU:start_bit =1
4182 * SSU_PC2 Idle <==> ATA Idle <==> N/A
4183 * SSU_PC3 Standby <==> ATA Standby <==> N/A
4184 * SSU_PC4 Stopped <==> ATA Standby <==> SSU:start_bit = 0
4185 *
4186 * Unload Media / NOT SUPPORTED YET
4187 * Load Media / NOT SUPPROTED YET
4188 * Immediate bit / NOT SUPPORTED YET (deferred error)
4189 *
4190 * Returns TRAN_ACCEPT or code returned by sata_hba_start() and
4191 * appropriate values in scsi_pkt fields.
4192 */
4193 static int
4194 sata_txlt_start_stop_unit(sata_pkt_txlate_t *spx)
4195 {
4196 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt;
4197 sata_cmd_t *scmd = &spx->txlt_sata_pkt->satapkt_cmd;
4198 int rval, reason;
4199 sata_drive_info_t *sdinfo;
4200 sata_id_t *sata_id;
4201 kmutex_t *cport_mutex = &(SATA_TXLT_CPORT_MUTEX(spx));
4202
4203 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst,
4204 "sata_txlt_start_stop_unit: %d\n", scsipkt->pkt_scbp[4] & 1);
4205
4206 mutex_enter(cport_mutex);
4207
4208 if (((rval = sata_txlt_generic_pkt_info(spx, &reason, 1)) !=
4209 TRAN_ACCEPT) || (reason == CMD_DEV_GONE)) {
4210 mutex_exit(cport_mutex);
4211 return (rval);
4212 }
4213
4214 if (scsipkt->pkt_cdbp[1] & START_STOP_IMMED_MASK) {
4215 /* IMMED bit - not supported */
4216 mutex_exit(cport_mutex);
4217 return (sata_txlt_check_condition(spx, KEY_ILLEGAL_REQUEST,
4218 SD_SCSI_ASC_INVALID_FIELD_IN_CDB));
4219 }
4220
4221 spx->txlt_sata_pkt->satapkt_op_mode |= SATA_OPMODE_SYNCH;
4222 spx->txlt_sata_pkt->satapkt_comp = NULL;
4223
4224 sdinfo = sata_get_device_info(spx->txlt_sata_hba_inst,
4225 &spx->txlt_sata_pkt->satapkt_device);
4226 ASSERT(sdinfo != NULL);
4227 sata_id = &sdinfo->satadrv_id;
4228
4229 switch ((scsipkt->pkt_cdbp[4] & START_STOP_POWER_COND_MASK) >> 4) {
4230 case 0:
4231 if (scsipkt->pkt_cdbp[4] & START_STOP_LOEJ_MASK) {
4232 /* Load/Unload Media - invalid request */
4233 goto err_out;
4234 }
4235 if (scsipkt->pkt_cdbp[4] & START_STOP_START_MASK) {
4236 /* Start Unit */
4237 sata_build_read_verify_cmd(scmd, 1, 5);
4238 scmd->satacmd_flags.sata_copy_out_error_reg = B_TRUE;
4239 /* Transfer command to HBA */
4240 if (sata_hba_start(spx, &rval) != 0) {
4241 /* Pkt not accepted for execution */
4242 mutex_exit(cport_mutex);
4243 return (rval);
4244 }
4245 if (scmd->satacmd_error_reg != 0) {
4246 goto err_out;
4247 }
4248 sdinfo->satadrv_power_level = SATA_POWER_ACTIVE;
4249 } else {
4250 /* Stop Unit */
4251 sata_build_generic_cmd(scmd, SATAC_FLUSH_CACHE);
4252 scmd->satacmd_flags.sata_copy_out_error_reg = B_TRUE;
4253 if (sata_hba_start(spx, &rval) != 0) {
4254 mutex_exit(cport_mutex);
4255 return (rval);
4256 } else {
4257 if (scmd->satacmd_error_reg != 0) {
4258 goto err_out;
4259 }
4260 }
4261 /* ata standby immediate command */
4262 sata_build_generic_cmd(scmd, SATAC_STANDBY_IM);
4263 scmd->satacmd_flags.sata_copy_out_error_reg = B_TRUE;
4264 if (sata_hba_start(spx, &rval) != 0) {
4265 mutex_exit(cport_mutex);
4266 return (rval);
4267 }
4268 if (scmd->satacmd_error_reg != 0) {
4269 goto err_out;
4270 }
4271 sdinfo->satadrv_power_level = SATA_POWER_STOPPED;
4272 }
4273 break;
4274 case 0x1:
4275 sata_build_generic_cmd(scmd, SATAC_IDLE);
4276 scmd->satacmd_flags.sata_copy_out_error_reg = B_TRUE;
4277 if (sata_hba_start(spx, &rval) != 0) {
4278 mutex_exit(cport_mutex);
4279 return (rval);
4280 }
4281 if (scmd->satacmd_error_reg != 0) {
4282 goto err_out;
4283 }
4284 sata_build_read_verify_cmd(scmd, 1, 5);
4285 scmd->satacmd_flags.sata_copy_out_error_reg = B_TRUE;
4286 /* Transfer command to HBA */
4287 if (sata_hba_start(spx, &rval) != 0) {
4288 /* Pkt not accepted for execution */
4289 mutex_exit(cport_mutex);
4290 return (rval);
4291 } else {
4292 if (scmd->satacmd_error_reg != 0) {
4293 goto err_out;
4294 }
4295 }
4296 sdinfo->satadrv_power_level = SATA_POWER_ACTIVE;
4297 break;
4298 case 0x2:
4299 sata_build_generic_cmd(scmd, SATAC_FLUSH_CACHE);
4300 scmd->satacmd_flags.sata_copy_out_error_reg = B_TRUE;
4301 if (!(scsipkt->pkt_cdbp[4] & START_STOP_NOFLUSH_MASK)) {
4302 if (sata_hba_start(spx, &rval) != 0) {
4303 mutex_exit(cport_mutex);
4304 return (rval);
4305 }
4306 if (scmd->satacmd_error_reg != 0) {
4307 goto err_out;
4308 }
4309 }
4310 sata_build_generic_cmd(scmd, SATAC_IDLE);
4311 scmd->satacmd_flags.sata_copy_out_error_reg = B_TRUE;
4312 if (sata_hba_start(spx, &rval) != 0) {
4313 mutex_exit(cport_mutex);
4314 return (rval);
4315 }
4316 if (scmd->satacmd_error_reg != 0) {
4317 goto err_out;
4318 }
4319 if ((scsipkt->pkt_cdbp[3] & START_STOP_MODIFIER_MASK)) {
4320 /*
4321 * POWER CONDITION MODIFIER bit set
4322 * to 0x1 or larger it will be handled
4323 * on the same way as bit = 0x1
4324 */
4325 if (!(sata_id->ai_cmdset84 &
4326 SATA_IDLE_UNLOAD_SUPPORTED)) {
4327 sdinfo->satadrv_power_level = SATA_POWER_IDLE;
4328 break;
4329 }
4330 sata_build_generic_cmd(scmd, SATAC_IDLE_IM);
4331 scmd->satacmd_features_reg = 0x44;
4332 scmd->satacmd_lba_low_lsb = 0x4c;
4333 scmd->satacmd_lba_mid_lsb = 0x4e;
4334 scmd->satacmd_lba_high_lsb = 0x55;
4335 scmd->satacmd_flags.sata_copy_out_error_reg = B_TRUE;
4336 if (sata_hba_start(spx, &rval) != 0) {
4337 mutex_exit(cport_mutex);
4338 return (rval);
4339 }
4340 if (scmd->satacmd_error_reg != 0) {
4341 goto err_out;
4342 }
4343 }
4344 sdinfo->satadrv_power_level = SATA_POWER_IDLE;
4345 break;
4346 case 0x3:
4347 sata_build_generic_cmd(scmd, SATAC_FLUSH_CACHE);
4348 scmd->satacmd_flags.sata_copy_out_error_reg = B_TRUE;
4349 if (!(scsipkt->pkt_cdbp[4] & START_STOP_NOFLUSH_MASK)) {
4350 if (sata_hba_start(spx, &rval) != 0) {
4351 mutex_exit(cport_mutex);
4352 return (rval);
4353 }
4354 if (scmd->satacmd_error_reg != 0) {
4355 goto err_out;
4356 }
4357 }
4358 sata_build_generic_cmd(scmd, SATAC_STANDBY);
4359 scmd->satacmd_flags.sata_copy_out_error_reg = B_TRUE;
4360 if (sata_hba_start(spx, &rval) != 0) {
4361 mutex_exit(cport_mutex);
4362 return (rval);
4363 }
4364 if (scmd->satacmd_error_reg != 0) {
4365 goto err_out;
4366 }
4367 sdinfo->satadrv_power_level = SATA_POWER_STANDBY;
4368 break;
4369 case 0x7:
4370 sata_build_generic_cmd(scmd, SATAC_CHECK_POWER_MODE);
4371 scmd->satacmd_flags.sata_copy_out_sec_count_lsb = B_TRUE;
4372 scmd->satacmd_flags.sata_copy_out_error_reg = B_TRUE;
4373 if (sata_hba_start(spx, &rval) != 0) {
4374 mutex_exit(cport_mutex);
4375 return (rval);
4376 }
4377 if (scmd->satacmd_error_reg != 0) {
4378 goto err_out;
4379 }
4380 switch (scmd->satacmd_sec_count_lsb) {
4381 case SATA_PWRMODE_STANDBY:
4382 sata_build_generic_cmd(scmd, SATAC_STANDBY);
4383 scmd->satacmd_sec_count_msb = sata_get_standby_timer(
4384 sdinfo->satadrv_standby_timer);
4385 scmd->satacmd_flags.sata_copy_out_error_reg = B_TRUE;
4386 if (sata_hba_start(spx, &rval) != 0) {
4387 mutex_exit(cport_mutex);
4388 return (rval);
4389 } else {
4390 if (scmd->satacmd_error_reg != 0) {
4391 goto err_out;
4392 }
4393 }
4394 break;
4395 case SATA_PWRMODE_IDLE:
4396 sata_build_generic_cmd(scmd, SATAC_IDLE);
4397 scmd->satacmd_sec_count_msb = sata_get_standby_timer(
4398 sdinfo->satadrv_standby_timer);
4399 scmd->satacmd_flags.sata_copy_out_error_reg = B_TRUE;
4400 if (sata_hba_start(spx, &rval) != 0) {
4401 mutex_exit(cport_mutex);
4402 return (rval);
4403 } else {
4404 if (scmd->satacmd_error_reg != 0) {
4405 goto err_out;
4406 }
4407 }
4408 break;
4409 case SATA_PWRMODE_ACTIVE_SPINDOWN:
4410 case SATA_PWRMODE_ACTIVE_SPINUP:
4411 case SATA_PWRMODE_ACTIVE:
4412 sata_build_generic_cmd(scmd, SATAC_IDLE);
4413 scmd->satacmd_sec_count_msb = sata_get_standby_timer(
4414 sdinfo->satadrv_standby_timer);
4415 scmd->satacmd_flags.sata_copy_out_error_reg = B_TRUE;
4416 if (sata_hba_start(spx, &rval) != 0) {
4417 mutex_exit(cport_mutex);
4418 return (rval);
4419 }
4420 if (scmd->satacmd_error_reg != 0) {
4421 goto err_out;
4422 }
4423 sata_build_read_verify_cmd(scmd, 1, 5);
4424 scmd->satacmd_flags.sata_copy_out_error_reg = B_TRUE;
4425 if (sata_hba_start(spx, &rval) != 0) {
4426 mutex_exit(cport_mutex);
4427 return (rval);
4428 }
4429 if (scmd->satacmd_error_reg != 0) {
4430 goto err_out;
4431 }
4432 break;
4433 default:
4434 goto err_out;
4435 }
4436 break;
4437 case 0xb:
4438 if ((sata_get_standby_timer(sdinfo->satadrv_standby_timer) ==
4439 0) || (!(sata_id->ai_cap & SATA_STANDBYTIMER))) {
4440 mutex_exit(cport_mutex);
4441 return (sata_txlt_check_condition(spx,
4442 KEY_ILLEGAL_REQUEST,
4443 SD_SCSI_ASC_INVALID_FIELD_IN_CDB));
4444 }
4445 sata_build_generic_cmd(scmd, SATAC_FLUSH_CACHE);
4446 scmd->satacmd_flags.sata_copy_out_error_reg = B_TRUE;
4447 if (!(scsipkt->pkt_cdbp[4] & START_STOP_NOFLUSH_MASK)) {
4448 if (sata_hba_start(spx, &rval) != 0) {
4449 mutex_exit(cport_mutex);
4450 return (rval);
4451 }
4452 if (scmd->satacmd_error_reg != 0) {
4453 goto err_out;
4454 }
4455 sata_build_generic_cmd(scmd, SATAC_STANDBY_IM);
4456 scmd->satacmd_flags.sata_copy_out_error_reg = B_TRUE;
4457 if (sata_hba_start(spx, &rval) != 0) {
4458 mutex_exit(cport_mutex);
4459 return (rval);
4460 }
4461 if (scmd->satacmd_error_reg != 0) {
4462 goto err_out;
4463 }
4464 }
4465 bzero(sdinfo->satadrv_standby_timer, sizeof (uchar_t) * 4);
4466 break;
4467 default:
4468 err_out:
4469 mutex_exit(cport_mutex);
4470 return (sata_txlt_check_condition(spx, KEY_ILLEGAL_REQUEST,
4471 SD_SCSI_ASC_INVALID_FIELD_IN_CDB));
4472 }
4473
4474 /*
4475 * Since it was a synchronous command,
4476 * a callback function will be called directly.
4477 */
4478 mutex_exit(cport_mutex);
4479 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst,
4480 "synchronous execution status %x\n",
4481 spx->txlt_sata_pkt->satapkt_reason);
4482
4483 if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0 &&
4484 scsipkt->pkt_comp != NULL) {
4485 sata_set_arq_data(spx->txlt_sata_pkt);
4486 if (servicing_interrupt()) {
4487 if (taskq_dispatch(SATA_TXLT_TASKQ(spx),
4488 (task_func_t *)spx->txlt_scsi_pkt->pkt_comp,
4489 (void *)spx->txlt_scsi_pkt, TQ_NOSLEEP) == NULL) {
4490 return (TRAN_BUSY);
4491 }
4492 } else if (taskq_dispatch(SATA_TXLT_TASKQ(spx),
4493 (task_func_t *)spx->txlt_scsi_pkt->pkt_comp,
4494 (void *)spx->txlt_scsi_pkt, TQ_SLEEP) == NULL) {
4495 /* Scheduling the callback failed */
4496 return (TRAN_BUSY);
4497 }
4498 }
4499 else
4500
4501 sata_txlt_nodata_cmd_completion(spx->txlt_sata_pkt);
4502
4503 return (TRAN_ACCEPT);
4504
4505 }
4506
4507 /*
4508 * SATA translate command: Read Capacity.
4509 * Emulated command for SATA disks.
4510 * Capacity is retrieved from cached Idenifty Device data.
4511 * Identify Device data shows effective disk capacity, not the native
4512 * capacity, which may be limitted by Set Max Address command.
4513 * This is ATA version for SATA hard disks.
4514 *
4515 * Returns TRAN_ACCEPT and appropriate values in scsi_pkt fields.
4516 */
4517 static int
4518 sata_txlt_read_capacity(sata_pkt_txlate_t *spx)
4519 {
4520 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt;
4521 struct buf *bp = spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp;
4522 sata_drive_info_t *sdinfo;
4523 uint64_t val;
4524 uint32_t lbsize = DEV_BSIZE;
4525 uchar_t *rbuf;
4526 int rval, reason;
4527 kmutex_t *cport_mutex = &(SATA_TXLT_CPORT_MUTEX(spx));
4528
4529 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst,
4530 "sata_txlt_read_capacity: ", NULL);
4531
4532 mutex_enter(cport_mutex);
4533
4534 if (((rval = sata_txlt_generic_pkt_info(spx, &reason, 0)) !=
4535 TRAN_ACCEPT) || (reason == CMD_DEV_GONE)) {
4536 mutex_exit(cport_mutex);
4537 return (rval);
4538 }
4539
4540 scsipkt->pkt_reason = CMD_CMPLT;
4541 scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET |
4542 STATE_SENT_CMD | STATE_GOT_STATUS;
4543 *scsipkt->pkt_scbp = STATUS_GOOD;
4544 if (bp != NULL && bp->b_un.b_addr && bp->b_bcount) {
4545 /*
4546 * Because it is fully emulated command storing data
4547 * programatically in the specified buffer, release
4548 * preallocated DMA resources before storing data in the buffer,
4549 * so no unwanted DMA sync would take place.
4550 */
4551 sata_scsi_dmafree(NULL, scsipkt);
4552
4553 sdinfo = sata_get_device_info(
4554 spx->txlt_sata_hba_inst,
4555 &spx->txlt_sata_pkt->satapkt_device);
4556
4557 /*
4558 * As per SBC-3, the "returned LBA" is either the highest
4559 * addressable LBA or 0xffffffff, whichever is smaller.
4560 */
4561 val = MIN(sdinfo->satadrv_capacity - 1, UINT32_MAX);
4562
4563 if (sdinfo->satadrv_id.ai_phys_sect_sz & SATA_L2PS_CHECK_BIT) {
4564 /* physical/logical sector size word is valid */
4565
4566 if (sdinfo->satadrv_id.ai_phys_sect_sz &
4567 SATA_L2PS_BIG_SECTORS) {
4568 /* if this set 117-118 words are valid */
4569 lbsize = sdinfo->satadrv_id.ai_words_lsec[0] |
4570 (sdinfo->satadrv_id.ai_words_lsec[1] << 16);
4571 lbsize <<= 1; /* convert from words to bytes */
4572 }
4573 }
4574 rbuf = (uchar_t *)bp->b_un.b_addr;
4575 /* Need to swap endians to match scsi format */
4576 rbuf[0] = (val >> 24) & 0xff;
4577 rbuf[1] = (val >> 16) & 0xff;
4578 rbuf[2] = (val >> 8) & 0xff;
4579 rbuf[3] = val & 0xff;
4580 rbuf[4] = (lbsize >> 24) & 0xff;
4581 rbuf[5] = (lbsize >> 16) & 0xff;
4582 rbuf[6] = (lbsize >> 8) & 0xff;
4583 rbuf[7] = lbsize & 0xff;
4584
4585 scsipkt->pkt_state |= STATE_XFERRED_DATA;
4586 scsipkt->pkt_resid = 0;
4587
4588 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst, "%d\n",
4589 sdinfo->satadrv_capacity -1);
4590 }
4591 mutex_exit(cport_mutex);
4592 /*
4593 * If a callback was requested, do it now.
4594 */
4595 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst,
4596 "Scsi_pkt completion reason %x\n", scsipkt->pkt_reason);
4597
4598 if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0 &&
4599 scsipkt->pkt_comp != NULL) {
4600 /* scsi callback required */
4601 if (servicing_interrupt()) {
4602 if (taskq_dispatch(SATA_TXLT_TASKQ(spx),
4603 (task_func_t *)spx->txlt_scsi_pkt->pkt_comp,
4604 (void *)spx->txlt_scsi_pkt, TQ_NOSLEEP) == NULL) {
4605 return (TRAN_BUSY);
4606 }
4607 } else if (taskq_dispatch(SATA_TXLT_TASKQ(spx),
4608 (task_func_t *)spx->txlt_scsi_pkt->pkt_comp,
4609 (void *)spx->txlt_scsi_pkt, TQ_SLEEP) == NULL) {
4610 /* Scheduling the callback failed */
4611 return (TRAN_BUSY);
4612 }
4613 }
4614
4615 return (TRAN_ACCEPT);
4616 }
4617
4618 /*
4619 * SATA translate command: Read Capacity (16).
4620 * Emulated command for SATA disks.
4621 * Info is retrieved from cached Identify Device data.
4622 * Implemented to SBC-3 (draft 21) and SAT-2 (final) specifications.
4623 *
4624 * Returns TRAN_ACCEPT and appropriate values in scsi_pkt fields.
4625 */
4626 static int
4627 sata_txlt_read_capacity16(sata_pkt_txlate_t *spx)
4628 {
4629 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt;
4630 struct buf *bp = spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp;
4631 sata_drive_info_t *sdinfo;
4632 uint64_t val;
4633 uint16_t l2p_exp;
4634 uint32_t lbsize = DEV_BSIZE;
4635 uchar_t *rbuf;
4636 int rval, reason;
4637 #define TPE 0x80
4638 #define TPRZ 0x40
4639 kmutex_t *cport_mutex = &(SATA_TXLT_CPORT_MUTEX(spx));
4640
4641 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst,
4642 "sata_txlt_read_capacity: ", NULL);
4643
4644 mutex_enter(cport_mutex);
4645
4646 if (((rval = sata_txlt_generic_pkt_info(spx, &reason, 0)) !=
4647 TRAN_ACCEPT) || (reason == CMD_DEV_GONE)) {
4648 mutex_exit(cport_mutex);
4649 return (rval);
4650 }
4651
4652 scsipkt->pkt_reason = CMD_CMPLT;
4653 scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET |
4654 STATE_SENT_CMD | STATE_GOT_STATUS;
4655 if (bp != NULL && bp->b_un.b_addr && bp->b_bcount) {
4656 /*
4657 * Because it is fully emulated command storing data
4658 * programatically in the specified buffer, release
4659 * preallocated DMA resources before storing data in the buffer,
4660 * so no unwanted DMA sync would take place.
4661 */
4662 sata_scsi_dmafree(NULL, scsipkt);
4663
4664 /* Check SERVICE ACTION field */
4665 if ((scsipkt->pkt_cdbp[1] & 0x1f) !=
4666 SSVC_ACTION_READ_CAPACITY_G4) {
4667 mutex_exit(cport_mutex);
4668 return (sata_txlt_check_condition(spx,
4669 KEY_ILLEGAL_REQUEST,
4670 SD_SCSI_ASC_INVALID_FIELD_IN_CDB));
4671 }
4672
4673 /* Check LBA field */
4674 if ((scsipkt->pkt_cdbp[2] != 0) ||
4675 (scsipkt->pkt_cdbp[3] != 0) ||
4676 (scsipkt->pkt_cdbp[4] != 0) ||
4677 (scsipkt->pkt_cdbp[5] != 0) ||
4678 (scsipkt->pkt_cdbp[6] != 0) ||
4679 (scsipkt->pkt_cdbp[7] != 0) ||
4680 (scsipkt->pkt_cdbp[8] != 0) ||
4681 (scsipkt->pkt_cdbp[9] != 0)) {
4682 mutex_exit(cport_mutex);
4683 return (sata_txlt_check_condition(spx,
4684 KEY_ILLEGAL_REQUEST,
4685 SD_SCSI_ASC_INVALID_FIELD_IN_CDB));
4686 }
4687
4688 /* Check PMI bit */
4689 if (scsipkt->pkt_cdbp[14] & 0x1) {
4690 mutex_exit(cport_mutex);
4691 return (sata_txlt_check_condition(spx,
4692 KEY_ILLEGAL_REQUEST,
4693 SD_SCSI_ASC_INVALID_FIELD_IN_CDB));
4694 }
4695
4696 *scsipkt->pkt_scbp = STATUS_GOOD;
4697
4698 sdinfo = sata_get_device_info(
4699 spx->txlt_sata_hba_inst,
4700 &spx->txlt_sata_pkt->satapkt_device);
4701
4702 /* last logical block address */
4703 val = MIN(sdinfo->satadrv_capacity - 1,
4704 SCSI_READ_CAPACITY16_MAX_LBA);
4705
4706 /* logical to physical block size exponent */
4707 l2p_exp = 0;
4708 if (sdinfo->satadrv_id.ai_phys_sect_sz & SATA_L2PS_CHECK_BIT) {
4709 /* physical/logical sector size word is valid */
4710
4711 if (sdinfo->satadrv_id.ai_phys_sect_sz &
4712 SATA_L2PS_HAS_MULT) {
4713 /* multiple logical sectors per phys sectors */
4714 l2p_exp =
4715 sdinfo->satadrv_id.ai_phys_sect_sz &
4716 SATA_L2PS_EXP_MASK;
4717 }
4718
4719 if (sdinfo->satadrv_id.ai_phys_sect_sz &
4720 SATA_L2PS_BIG_SECTORS) {
4721 /* if this set 117-118 words are valid */
4722 lbsize = sdinfo->satadrv_id.ai_words_lsec[0] |
4723 (sdinfo->satadrv_id.ai_words_lsec[1] << 16);
4724 lbsize <<= 1; /* convert from words to bytes */
4725 }
4726 }
4727
4728 rbuf = (uchar_t *)bp->b_un.b_addr;
4729 bzero(rbuf, bp->b_bcount);
4730
4731 /* returned logical block address */
4732 rbuf[0] = (val >> 56) & 0xff;
4733 rbuf[1] = (val >> 48) & 0xff;
4734 rbuf[2] = (val >> 40) & 0xff;
4735 rbuf[3] = (val >> 32) & 0xff;
4736 rbuf[4] = (val >> 24) & 0xff;
4737 rbuf[5] = (val >> 16) & 0xff;
4738 rbuf[6] = (val >> 8) & 0xff;
4739 rbuf[7] = val & 0xff;
4740 rbuf[8] = (lbsize >> 24) & 0xff;
4741 rbuf[9] = (lbsize >> 16) & 0xff;
4742 rbuf[10] = (lbsize >> 8) & 0xff;
4743 rbuf[11] = lbsize & 0xff;
4744
4745 /* p_type, prot_en, unspecified by SAT-2 */
4746 /* rbuf[12] = 0; */
4747
4748 /* p_i_exponent, undefined by SAT-2 */
4749 /* logical blocks per physical block exponent */
4750 rbuf[13] = l2p_exp;
4751
4752 /* lowest aligned logical block address = 0 (for now) */
4753 /* tpe and tprz as defined in T10/10-079 r0 */
4754 if (sdinfo->satadrv_id.ai_addsupported &
4755 SATA_DETERMINISTIC_READ) {
4756 if (sdinfo->satadrv_id.ai_addsupported &
4757 SATA_READ_ZERO) {
4758 rbuf[14] |= TPRZ;
4759 } else {
4760 rbuf[14] |= TPE;
4761 }
4762 }
4763 /* rbuf[15] = 0; */
4764
4765 scsipkt->pkt_state |= STATE_XFERRED_DATA;
4766 scsipkt->pkt_resid = 0;
4767
4768 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst, "%llu\n",
4769 sdinfo->satadrv_capacity -1);
4770 }
4771
4772 mutex_exit(cport_mutex);
4773
4774 /*
4775 * If a callback was requested, do it now.
4776 */
4777 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst,
4778 "Scsi_pkt completion reason %x\n", scsipkt->pkt_reason);
4779
4780 if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0 &&
4781 scsipkt->pkt_comp != NULL) {
4782 /* scsi callback required */
4783 if (servicing_interrupt()) {
4784 if (taskq_dispatch(SATA_TXLT_TASKQ(spx),
4785 (task_func_t *)spx->txlt_scsi_pkt->pkt_comp,
4786 (void *)spx->txlt_scsi_pkt, TQ_NOSLEEP) == NULL) {
4787 return (TRAN_BUSY);
4788 }
4789 } else if (taskq_dispatch(SATA_TXLT_TASKQ(spx),
4790 (task_func_t *)spx->txlt_scsi_pkt->pkt_comp,
4791 (void *)spx->txlt_scsi_pkt, TQ_SLEEP) == NULL) {
4792 /* Scheduling the callback failed */
4793 return (TRAN_BUSY);
4794 }
4795 }
4796
4797 return (TRAN_ACCEPT);
4798 }
4799
4800 /*
4801 * Translate command: UNMAP
4802 *
4803 * The function cannot be called in interrupt context since it may sleep.
4804 */
4805 static int
4806 sata_txlt_unmap(sata_pkt_txlate_t *spx)
4807 {
4808 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt;
4809 sata_cmd_t *scmd = &spx->txlt_sata_pkt->satapkt_cmd;
4810 struct buf *bp = spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp;
4811 uint16_t count = 0;
4812 int synch;
4813 int rval, reason;
4814 int i, x;
4815 int bdlen = 0;
4816 int ranges = 0;
4817 int paramlen = 8;
4818 uint8_t *data, *tmpbd;
4819 sata_drive_info_t *sdinfo;
4820 kmutex_t *cport_mutex = &(SATA_TXLT_CPORT_MUTEX(spx));
4821 #define TRIM 0x1
4822
4823 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst,
4824 "sata_txlt_unmap: ", NULL);
4825
4826 mutex_enter(cport_mutex);
4827
4828 sdinfo = sata_get_device_info(spx->txlt_sata_hba_inst,
4829 &spx->txlt_sata_pkt->satapkt_device);
4830 if (sdinfo != NULL) {
4831 SATADBG2(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst,
4832 "DSM support 0x%x, max number of 512 byte blocks of LBA "
4833 "range entries 0x%x\n", sdinfo->satadrv_id.ai_dsm,
4834 sdinfo->satadrv_id.ai_maxcount);
4835 }
4836
4837 rval = sata_txlt_generic_pkt_info(spx, &reason, 1);
4838 if ((rval != TRAN_ACCEPT) || (reason == CMD_DEV_GONE)) {
4839 mutex_exit(cport_mutex);
4840 return (rval);
4841 }
4842
4843 /*
4844 * Need to modify bp to have TRIM data instead of UNMAP data.
4845 * Start by getting the block descriptor data length by subtracting
4846 * the 8 byte parameter list header from the parameter list length.
4847 * The block descriptor size has to be a multiple of 16 bytes.
4848 */
4849 bdlen = scsipkt->pkt_cdbp[7];
4850 bdlen = (bdlen << 8) + scsipkt->pkt_cdbp[8] - paramlen;
4851 if ((bdlen < 0) || ((bdlen % 16) != 0) ||
4852 ((bp != NULL) && (bdlen > (bp->b_bcount - paramlen)))) {
4853 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst,
4854 "sata_txlt_unmap: invalid block descriptor length", NULL);
4855 mutex_exit(cport_mutex);
4856 return ((sata_txlt_check_condition(spx, KEY_ILLEGAL_REQUEST,
4857 SD_SCSI_ASC_INVALID_FIELD_IN_CDB)));
4858 }
4859 /*
4860 * If there are no parameter data or block descriptors, it is not
4861 * considered an error so just complete the command without sending
4862 * TRIM.
4863 */
4864 if ((bdlen == 0) || (bp == NULL) || (bp->b_un.b_addr == NULL) ||
4865 (bp->b_bcount == 0)) {
4866 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst,
4867 "sata_txlt_unmap: no parameter data or block descriptors",
4868 NULL);
4869 mutex_exit(cport_mutex);
4870 return (sata_txlt_unmap_nodata_cmd(spx));
4871 }
4872 tmpbd = (uint8_t *)bp->b_un.b_addr + paramlen;
4873 data = kmem_zalloc(bdlen, KM_SLEEP);
4874
4875 /*
4876 * Loop through all the UNMAP block descriptors and convert the data
4877 * into TRIM format.
4878 */
4879 for (i = 0, x = 0; i < bdlen; i += 16, x += 8) {
4880 /* get range length */
4881 data[x] = tmpbd[i+7];
4882 data[x+1] = tmpbd[i+6];
4883 /* get LBA */
4884 data[x+2] = tmpbd[i+5];
4885 data[x+3] = tmpbd[i+4];
4886 data[x+4] = tmpbd[i+3];
4887 data[x+5] = tmpbd[i+2];
4888 data[x+6] = tmpbd[i+11];
4889 data[x+7] = tmpbd[i+10];
4890
4891 ranges++;
4892 }
4893
4894 /*
4895 * The TRIM command expects the data buffer to be a multiple of
4896 * 512-byte blocks of range entries. This means that the UNMAP buffer
4897 * may be too small. Free the original DMA resources and create a
4898 * local buffer.
4899 */
4900 sata_common_free_dma_rsrcs(spx);
4901
4902 /*
4903 * Get count of 512-byte blocks of range entries. The length
4904 * of a range entry is 8 bytes which means one count has 64 range
4905 * entries.
4906 */
4907 count = (ranges + 63)/64;
4908
4909 /* Allocate a buffer that is a multiple of 512 bytes. */
4910 mutex_exit(cport_mutex);
4911 bp = sata_alloc_local_buffer(spx, count * 512);
4912 if (bp == NULL) {
4913 SATADBG1(SATA_DBG_ATAPI, spx->txlt_sata_hba_inst,
4914 "sata_txlt_unmap: "
4915 "cannot allocate buffer for TRIM command", NULL);
4916 kmem_free(data, bdlen);
4917 return (TRAN_BUSY);
4918 }
4919 bp_mapin(bp); /* make data buffer accessible */
4920 mutex_enter(cport_mutex);
4921
4922 bzero(bp->b_un.b_addr, bp->b_bcount);
4923 bcopy(data, bp->b_un.b_addr, x);
4924 kmem_free(data, bdlen);
4925 rval = ddi_dma_sync(spx->txlt_buf_dma_handle, 0, 0,
4926 DDI_DMA_SYNC_FORDEV);
4927 ASSERT(rval == DDI_SUCCESS);
4928
4929 scmd->satacmd_flags.sata_data_direction = SATA_DIR_WRITE;
4930 scmd->satacmd_addr_type = ATA_ADDR_LBA48;
4931 scmd->satacmd_cmd_reg = SATAC_DSM;
4932 scmd->satacmd_sec_count_msb = (count >> 8) & 0xff;
4933 scmd->satacmd_sec_count_lsb = count & 0xff;
4934 scmd->satacmd_features_reg = TRIM;
4935 scmd->satacmd_device_reg = SATA_ADH_LBA;
4936 scmd->satacmd_status_reg = 0;
4937 scmd->satacmd_error_reg = 0;
4938
4939 /* Start processing command */
4940 if (!(spx->txlt_sata_pkt->satapkt_op_mode & SATA_OPMODE_SYNCH)) {
4941 spx->txlt_sata_pkt->satapkt_comp =
4942 sata_txlt_unmap_completion;
4943 synch = FALSE;
4944 } else {
4945 synch = TRUE;
4946 }
4947
4948 if (sata_hba_start(spx, &rval) != 0) {
4949 mutex_exit(cport_mutex);
4950 return (rval);
4951 }
4952
4953 mutex_exit(cport_mutex);
4954
4955 if (synch) {
4956 sata_txlt_unmap_completion(spx->txlt_sata_pkt);
4957 }
4958
4959 return (TRAN_ACCEPT);
4960 }
4961
4962 /*
4963 * SATA translate command: Mode Sense.
4964 * Translated into appropriate SATA command or emulated.
4965 * Saved Values Page Control (03) are not supported.
4966 *
4967 * NOTE: only caching mode sense page is currently implemented.
4968 *
4969 * Returns TRAN_ACCEPT and appropriate values in scsi_pkt fields.
4970 */
4971
4972 #define LLBAA 0x10 /* Long LBA Accepted */
4973
4974 static int
4975 sata_txlt_mode_sense(sata_pkt_txlate_t *spx)
4976 {
4977 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt;
4978 struct buf *bp = spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp;
4979 sata_drive_info_t *sdinfo;
4980 sata_id_t *sata_id;
4981 struct scsi_extended_sense *sense;
4982 int len, bdlen, count, alc_len;
4983 int pc; /* Page Control code */
4984 uint8_t *buf; /* mode sense buffer */
4985 int rval, reason;
4986 kmutex_t *cport_mutex = &(SATA_TXLT_CPORT_MUTEX(spx));
4987
4988 SATADBG2(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst,
4989 "sata_txlt_mode_sense, pc %x page code 0x%02x\n",
4990 spx->txlt_scsi_pkt->pkt_cdbp[2] >> 6,
4991 spx->txlt_scsi_pkt->pkt_cdbp[2] & 0x3f);
4992
4993 if (servicing_interrupt()) {
4994 buf = kmem_zalloc(1024, KM_NOSLEEP);
4995 if (buf == NULL) {
4996 return (TRAN_BUSY);
4997 }
4998 } else {
4999 buf = kmem_zalloc(1024, KM_SLEEP);
5000 }
5001
5002 mutex_enter(cport_mutex);
5003
5004 if (((rval = sata_txlt_generic_pkt_info(spx, &reason, 0)) !=
5005 TRAN_ACCEPT) || (reason == CMD_DEV_GONE)) {
5006 mutex_exit(cport_mutex);
5007 kmem_free(buf, 1024);
5008 return (rval);
5009 }
5010
5011 scsipkt->pkt_reason = CMD_CMPLT;
5012 scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET |
5013 STATE_SENT_CMD | STATE_GOT_STATUS;
5014
5015 pc = scsipkt->pkt_cdbp[2] >> 6;
5016
5017 if (bp != NULL && bp->b_un.b_addr && bp->b_bcount) {
5018 /*
5019 * Because it is fully emulated command storing data
5020 * programatically in the specified buffer, release
5021 * preallocated DMA resources before storing data in the buffer,
5022 * so no unwanted DMA sync would take place.
5023 */
5024 sata_scsi_dmafree(NULL, scsipkt);
5025
5026 len = 0;
5027 bdlen = 0;
5028 if (!(scsipkt->pkt_cdbp[1] & 8)) {
5029 if (scsipkt->pkt_cdbp[0] == SCMD_MODE_SENSE_G1 &&
5030 (scsipkt->pkt_cdbp[1] & LLBAA))
5031 bdlen = 16;
5032 else
5033 bdlen = 8;
5034 }
5035 /* Build mode parameter header */
5036 if (spx->txlt_scsi_pkt->pkt_cdbp[0] == SCMD_MODE_SENSE) {
5037 /* 4-byte mode parameter header */
5038 buf[len++] = 0; /* mode data length */
5039 buf[len++] = 0; /* medium type */
5040 buf[len++] = 0; /* dev-specific param */
5041 buf[len++] = bdlen; /* Block Descriptor length */
5042 } else {
5043 /* 8-byte mode parameter header */
5044 buf[len++] = 0; /* mode data length */
5045 buf[len++] = 0;
5046 buf[len++] = 0; /* medium type */
5047 buf[len++] = 0; /* dev-specific param */
5048 if (bdlen == 16)
5049 buf[len++] = 1; /* long lba descriptor */
5050 else
5051 buf[len++] = 0;
5052 buf[len++] = 0;
5053 buf[len++] = 0; /* Block Descriptor length */
5054 buf[len++] = bdlen;
5055 }
5056
5057 sdinfo = sata_get_device_info(
5058 spx->txlt_sata_hba_inst,
5059 &spx->txlt_sata_pkt->satapkt_device);
5060
5061 /* Build block descriptor only if not disabled (DBD) */
5062 if ((scsipkt->pkt_cdbp[1] & 0x08) == 0) {
5063 /* Block descriptor - direct-access device format */
5064 if (bdlen == 8) {
5065 /* build regular block descriptor */
5066 buf[len++] =
5067 (sdinfo->satadrv_capacity >> 24) & 0xff;
5068 buf[len++] =
5069 (sdinfo->satadrv_capacity >> 16) & 0xff;
5070 buf[len++] =
5071 (sdinfo->satadrv_capacity >> 8) & 0xff;
5072 buf[len++] = sdinfo->satadrv_capacity & 0xff;
5073 buf[len++] = 0; /* density code */
5074 buf[len++] = 0;
5075 if (sdinfo->satadrv_type ==
5076 SATA_DTYPE_ATADISK)
5077 buf[len++] = 2;
5078 else
5079 /* ATAPI */
5080 buf[len++] = 8;
5081 buf[len++] = 0;
5082 } else if (bdlen == 16) {
5083 /* Long LBA Accepted */
5084 /* build long lba block descriptor */
5085 #ifndef __lock_lint
5086 buf[len++] =
5087 (sdinfo->satadrv_capacity >> 56) & 0xff;
5088 buf[len++] =
5089 (sdinfo->satadrv_capacity >> 48) & 0xff;
5090 buf[len++] =
5091 (sdinfo->satadrv_capacity >> 40) & 0xff;
5092 buf[len++] =
5093 (sdinfo->satadrv_capacity >> 32) & 0xff;
5094 #endif
5095 buf[len++] =
5096 (sdinfo->satadrv_capacity >> 24) & 0xff;
5097 buf[len++] =
5098 (sdinfo->satadrv_capacity >> 16) & 0xff;
5099 buf[len++] =
5100 (sdinfo->satadrv_capacity >> 8) & 0xff;
5101 buf[len++] = sdinfo->satadrv_capacity & 0xff;
5102 buf[len++] = 0;
5103 buf[len++] = 0; /* density code */
5104 buf[len++] = 0;
5105 buf[len++] = 0;
5106 if (sdinfo->satadrv_type ==
5107 SATA_DTYPE_ATADISK)
5108 buf[len++] = 2;
5109 else
5110 /* ATAPI */
5111 buf[len++] = 8;
5112 buf[len++] = 0;
5113 }
5114 }
5115
5116 sata_id = &sdinfo->satadrv_id;
5117
5118 /*
5119 * Add requested pages.
5120 * Page 3 and 4 are obsolete and we are not supporting them.
5121 * We deal now with:
5122 * caching (read/write cache control).
5123 * We should eventually deal with following mode pages:
5124 * error recovery (0x01),
5125 * power condition (0x1a),
5126 * exception control page (enables SMART) (0x1c),
5127 * enclosure management (ses),
5128 * protocol-specific port mode (port control).
5129 */
5130 switch (scsipkt->pkt_cdbp[2] & 0x3f) {
5131 case MODEPAGE_RW_ERRRECOV:
5132 /* DAD_MODE_ERR_RECOV */
5133 /* R/W recovery */
5134 len += sata_build_msense_page_1(sdinfo, pc, buf+len);
5135 break;
5136 case MODEPAGE_CACHING:
5137 /* DAD_MODE_CACHE */
5138 /* Reject not supported request for saved parameters */
5139 if (pc == 3) {
5140 *scsipkt->pkt_scbp = STATUS_CHECK;
5141 sense = sata_arq_sense(spx);
5142 sense->es_key = KEY_ILLEGAL_REQUEST;
5143 sense->es_add_code =
5144 SD_SCSI_ASC_SAVING_PARAMS_NOT_SUPPORTED;
5145 goto done;
5146 }
5147
5148 /* caching */
5149 len += sata_build_msense_page_8(sdinfo, pc, buf+len);
5150 break;
5151 case MODEPAGE_INFO_EXCPT:
5152 /* exception cntrl */
5153 if (sata_id->ai_cmdset82 & SATA_SMART_SUPPORTED) {
5154 len += sata_build_msense_page_1c(sdinfo, pc,
5155 buf+len);
5156 }
5157 else
5158 goto err;
5159 break;
5160 case MODEPAGE_POWER_COND:
5161 /* DAD_MODE_POWER_COND */
5162 /* power condition */
5163 len += sata_build_msense_page_1a(sdinfo, pc, buf+len);
5164 break;
5165
5166 case MODEPAGE_ACOUSTIC_MANAG:
5167 /* acoustic management */
5168 len += sata_build_msense_page_30(sdinfo, pc, buf+len);
5169 break;
5170 case MODEPAGE_ALLPAGES:
5171 /* all pages */
5172 len += sata_build_msense_page_1(sdinfo, pc, buf+len);
5173 len += sata_build_msense_page_8(sdinfo, pc, buf+len);
5174 len += sata_build_msense_page_1a(sdinfo, pc, buf+len);
5175 if (sata_id->ai_cmdset82 & SATA_SMART_SUPPORTED) {
5176 len += sata_build_msense_page_1c(sdinfo, pc,
5177 buf+len);
5178 }
5179 len += sata_build_msense_page_30(sdinfo, pc, buf+len);
5180 break;
5181 default:
5182 err:
5183 /* Invalid request */
5184 *scsipkt->pkt_scbp = STATUS_CHECK;
5185 sense = sata_arq_sense(spx);
5186 sense->es_key = KEY_ILLEGAL_REQUEST;
5187 sense->es_add_code = SD_SCSI_ASC_INVALID_FIELD_IN_CDB;
5188 goto done;
5189 }
5190
5191 /* fix total mode data length */
5192 if (spx->txlt_scsi_pkt->pkt_cdbp[0] == SCMD_MODE_SENSE) {
5193 /* 4-byte mode parameter header */
5194 buf[0] = len - 1; /* mode data length */
5195 } else {
5196 buf[0] = (len -2) >> 8;
5197 buf[1] = (len -2) & 0xff;
5198 }
5199
5200
5201 /* Check allocation length */
5202 if (scsipkt->pkt_cdbp[0] == SCMD_MODE_SENSE) {
5203 alc_len = scsipkt->pkt_cdbp[4];
5204 } else {
5205 alc_len = scsipkt->pkt_cdbp[7];
5206 alc_len = (len << 8) | scsipkt->pkt_cdbp[8];
5207 }
5208 /*
5209 * We do not check for possible parameters truncation
5210 * (alc_len < len) assuming that the target driver works
5211 * correctly. Just avoiding overrun.
5212 * Copy no more than requested and possible, buffer-wise.
5213 */
5214 count = MIN(alc_len, len);
5215 count = MIN(bp->b_bcount, count);
5216 bcopy(buf, bp->b_un.b_addr, count);
5217
5218 scsipkt->pkt_state |= STATE_XFERRED_DATA;
5219 scsipkt->pkt_resid = alc_len > count ? alc_len - count : 0;
5220 }
5221 *scsipkt->pkt_scbp = STATUS_GOOD;
5222 done:
5223 mutex_exit(cport_mutex);
5224 (void) kmem_free(buf, 1024);
5225
5226 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst,
5227 "Scsi_pkt completion reason %x\n", scsipkt->pkt_reason);
5228
5229 if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0 &&
5230 scsipkt->pkt_comp != NULL) {
5231 /* scsi callback required */
5232 if (servicing_interrupt()) {
5233 if (taskq_dispatch(SATA_TXLT_TASKQ(spx),
5234 (task_func_t *)spx->txlt_scsi_pkt->pkt_comp,
5235 (void *)spx->txlt_scsi_pkt, TQ_NOSLEEP) == NULL) {
5236 return (TRAN_BUSY);
5237 }
5238 } else if (taskq_dispatch(SATA_TXLT_TASKQ(spx),
5239 (task_func_t *)spx->txlt_scsi_pkt->pkt_comp,
5240 (void *)spx->txlt_scsi_pkt, TQ_SLEEP) == NULL) {
5241 /* Scheduling the callback failed */
5242 return (TRAN_BUSY);
5243 }
5244 }
5245
5246 return (TRAN_ACCEPT);
5247 }
5248
5249
5250 /*
5251 * SATA translate command: Mode Select.
5252 * Translated into appropriate SATA command or emulated.
5253 * Saving parameters is not supported.
5254 * Changing device capacity is not supported (although theoretically
5255 * possible by executing SET FEATURES/SET MAX ADDRESS)
5256 *
5257 * Assumption is that the target driver is working correctly.
5258 *
5259 * More than one SATA command may be executed to perform operations specified
5260 * by mode select pages. The first error terminates further execution.
5261 * Operations performed successully are not backed-up in such case.
5262 *
5263 * NOTE: Implemented pages:
5264 * - caching page
5265 * - informational exception page
5266 * - acoustic management page
5267 * - power condition page
5268 * Caching setup is remembered so it could be re-stored in case of
5269 * an unexpected device reset.
5270 *
5271 * Returns TRAN_XXXX.
5272 * If TRAN_ACCEPT is returned, appropriate values are set in scsi_pkt fields.
5273 */
5274
5275 static int
5276 sata_txlt_mode_select(sata_pkt_txlate_t *spx)
5277 {
5278 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt;
5279 struct buf *bp = spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp;
5280 struct scsi_extended_sense *sense;
5281 int len, pagelen, count, pllen;
5282 uint8_t *buf; /* mode select buffer */
5283 int rval, stat, reason;
5284 uint_t nointr_flag;
5285 int dmod = 0;
5286 kmutex_t *cport_mutex = &(SATA_TXLT_CPORT_MUTEX(spx));
5287
5288 SATADBG2(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst,
5289 "sata_txlt_mode_select, pc %x page code 0x%02x\n",
5290 spx->txlt_scsi_pkt->pkt_cdbp[2] >> 6,
5291 spx->txlt_scsi_pkt->pkt_cdbp[2] & 0x3f);
5292
5293 mutex_enter(cport_mutex);
5294
5295 if (((rval = sata_txlt_generic_pkt_info(spx, &reason, 1)) !=
5296 TRAN_ACCEPT) || (reason == CMD_DEV_GONE)) {
5297 mutex_exit(cport_mutex);
5298 return (rval);
5299 }
5300
5301 rval = TRAN_ACCEPT;
5302
5303 scsipkt->pkt_reason = CMD_CMPLT;
5304 scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET |
5305 STATE_SENT_CMD | STATE_GOT_STATUS;
5306 nointr_flag = scsipkt->pkt_flags & FLAG_NOINTR;
5307
5308 /* Reject not supported request */
5309 if (! (scsipkt->pkt_cdbp[1] & 0x10)) { /* No support for PF bit = 0 */
5310 *scsipkt->pkt_scbp = STATUS_CHECK;
5311 sense = sata_arq_sense(spx);
5312 sense->es_key = KEY_ILLEGAL_REQUEST;
5313 sense->es_add_code = SD_SCSI_ASC_INVALID_FIELD_IN_CDB;
5314 goto done;
5315 }
5316
5317 if (scsipkt->pkt_cdbp[0] == SCMD_MODE_SELECT) {
5318 pllen = scsipkt->pkt_cdbp[4];
5319 } else {
5320 pllen = scsipkt->pkt_cdbp[7];
5321 pllen = (pllen << 8) | scsipkt->pkt_cdbp[7];
5322 }
5323
5324 *scsipkt->pkt_scbp = STATUS_GOOD; /* Presumed outcome */
5325
5326 if (bp != NULL && bp->b_un.b_addr && bp->b_bcount && pllen != 0) {
5327 buf = (uint8_t *)bp->b_un.b_addr;
5328 count = MIN(bp->b_bcount, pllen);
5329 scsipkt->pkt_state |= STATE_XFERRED_DATA;
5330 scsipkt->pkt_resid = 0;
5331 pllen = count;
5332
5333 /*
5334 * Check the header to skip the block descriptor(s) - we
5335 * do not support setting device capacity.
5336 * Existing macros do not recognize long LBA dscriptor,
5337 * hence manual calculation.
5338 */
5339 if (scsipkt->pkt_cdbp[0] == SCMD_MODE_SELECT) {
5340 /* 6-bytes CMD, 4 bytes header */
5341 if (count <= 4)
5342 goto done; /* header only */
5343 len = buf[3] + 4;
5344 } else {
5345 /* 10-bytes CMD, 8 bytes header */
5346 if (count <= 8)
5347 goto done; /* header only */
5348 len = buf[6];
5349 len = (len << 8) + buf[7] + 8;
5350 }
5351 if (len >= count)
5352 goto done; /* header + descriptor(s) only */
5353
5354 pllen -= len; /* remaining data length */
5355
5356 /*
5357 * We may be executing SATA command and want to execute it
5358 * in SYNCH mode, regardless of scsi_pkt setting.
5359 * Save scsi_pkt setting and indicate SYNCH mode
5360 */
5361 if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0 &&
5362 scsipkt->pkt_comp != NULL) {
5363 scsipkt->pkt_flags |= FLAG_NOINTR;
5364 }
5365 spx->txlt_sata_pkt->satapkt_op_mode = SATA_OPMODE_SYNCH;
5366
5367 /*
5368 * len is now the offset to a first mode select page
5369 * Process all pages
5370 */
5371 while (pllen > 0) {
5372 switch ((int)buf[len]) {
5373 case MODEPAGE_CACHING:
5374 /* No support for SP (saving) */
5375 if (scsipkt->pkt_cdbp[1] & 0x01) {
5376 *scsipkt->pkt_scbp = STATUS_CHECK;
5377 sense = sata_arq_sense(spx);
5378 sense->es_key = KEY_ILLEGAL_REQUEST;
5379 sense->es_add_code =
5380 SD_SCSI_ASC_INVALID_FIELD_IN_CDB;
5381 goto done;
5382 }
5383 stat = sata_mode_select_page_8(spx,
5384 (struct mode_cache_scsi3 *)&buf[len],
5385 pllen, &pagelen, &rval, &dmod);
5386 /*
5387 * The pagelen value indicates the number of
5388 * parameter bytes already processed.
5389 * The rval is the return value from
5390 * sata_tran_start().
5391 * The stat indicates the overall status of
5392 * the operation(s).
5393 */
5394 if (stat != SATA_SUCCESS)
5395 /*
5396 * Page processing did not succeed -
5397 * all error info is already set-up,
5398 * just return
5399 */
5400 pllen = 0; /* this breaks the loop */
5401 else {
5402 len += pagelen;
5403 pllen -= pagelen;
5404 }
5405 break;
5406
5407 case MODEPAGE_INFO_EXCPT:
5408 stat = sata_mode_select_page_1c(spx,
5409 (struct mode_info_excpt_page *)&buf[len],
5410 pllen, &pagelen, &rval, &dmod);
5411 /*
5412 * The pagelen value indicates the number of
5413 * parameter bytes already processed.
5414 * The rval is the return value from
5415 * sata_tran_start().
5416 * The stat indicates the overall status of
5417 * the operation(s).
5418 */
5419 if (stat != SATA_SUCCESS)
5420 /*
5421 * Page processing did not succeed -
5422 * all error info is already set-up,
5423 * just return
5424 */
5425 pllen = 0; /* this breaks the loop */
5426 else {
5427 len += pagelen;
5428 pllen -= pagelen;
5429 }
5430 break;
5431
5432 case MODEPAGE_ACOUSTIC_MANAG:
5433 stat = sata_mode_select_page_30(spx,
5434 (struct mode_acoustic_management *)
5435 &buf[len], pllen, &pagelen, &rval, &dmod);
5436 /*
5437 * The pagelen value indicates the number of
5438 * parameter bytes already processed.
5439 * The rval is the return value from
5440 * sata_tran_start().
5441 * The stat indicates the overall status of
5442 * the operation(s).
5443 */
5444 if (stat != SATA_SUCCESS)
5445 /*
5446 * Page processing did not succeed -
5447 * all error info is already set-up,
5448 * just return
5449 */
5450 pllen = 0; /* this breaks the loop */
5451 else {
5452 len += pagelen;
5453 pllen -= pagelen;
5454 }
5455
5456 break;
5457 case MODEPAGE_POWER_COND:
5458 stat = sata_mode_select_page_1a(spx,
5459 (struct mode_info_power_cond *)&buf[len],
5460 pllen, &pagelen, &rval, &dmod);
5461 /*
5462 * The pagelen value indicates the number of
5463 * parameter bytes already processed.
5464 * The rval is the return value from
5465 * sata_tran_start().
5466 * The stat indicates the overall status of
5467 * the operation(s).
5468 */
5469 if (stat != SATA_SUCCESS)
5470 /*
5471 * Page processing did not succeed -
5472 * all error info is already set-up,
5473 * just return
5474 */
5475 pllen = 0; /* this breaks the loop */
5476 else {
5477 len += pagelen;
5478 pllen -= pagelen;
5479 }
5480 break;
5481 default:
5482 *scsipkt->pkt_scbp = STATUS_CHECK;
5483 sense = sata_arq_sense(spx);
5484 sense->es_key = KEY_ILLEGAL_REQUEST;
5485 sense->es_add_code =
5486 SD_SCSI_ASC_INVALID_FIELD_IN_PARAMS_LIST;
5487 goto done;
5488 }
5489 }
5490 }
5491 done:
5492 mutex_exit(cport_mutex);
5493 /*
5494 * If device parameters were modified, fetch and store the new
5495 * Identify Device data. Since port mutex could have been released
5496 * for accessing HBA driver, we need to re-check device existence.
5497 */
5498 if (dmod != 0) {
5499 sata_drive_info_t new_sdinfo, *sdinfo;
5500 int rv = 0;
5501
5502 /*
5503 * Following statement has to be changed if this function is
5504 * used for devices other than SATA hard disks.
5505 */
5506 new_sdinfo.satadrv_type = SATA_DTYPE_ATADISK;
5507
5508 new_sdinfo.satadrv_addr =
5509 spx->txlt_sata_pkt->satapkt_device.satadev_addr;
5510 rv = sata_fetch_device_identify_data(spx->txlt_sata_hba_inst,
5511 &new_sdinfo);
5512
5513 mutex_enter(cport_mutex);
5514 /*
5515 * Since port mutex could have been released when
5516 * accessing HBA driver, we need to re-check that the
5517 * framework still holds the device info structure.
5518 */
5519 sdinfo = sata_get_device_info(spx->txlt_sata_hba_inst,
5520 &spx->txlt_sata_pkt->satapkt_device);
5521 if (sdinfo != NULL) {
5522 /*
5523 * Device still has info structure in the
5524 * sata framework. Copy newly fetched info
5525 */
5526 if (rv == 0) {
5527 sdinfo->satadrv_id = new_sdinfo.satadrv_id;
5528 sata_save_drive_settings(sdinfo);
5529 } else {
5530 /*
5531 * Could not fetch new data - invalidate
5532 * sata_drive_info. That makes device
5533 * unusable.
5534 */
5535 sdinfo->satadrv_type = SATA_DTYPE_UNKNOWN;
5536 sdinfo->satadrv_state = SATA_STATE_UNKNOWN;
5537 }
5538 }
5539 if (rv != 0 || sdinfo == NULL) {
5540 /*
5541 * This changes the overall mode select completion
5542 * reason to a failed one !!!!!
5543 */
5544 *scsipkt->pkt_scbp = STATUS_CHECK;
5545 sense = sata_arq_sense(spx);
5546 scsipkt->pkt_reason = CMD_INCOMPLETE;
5547 rval = TRAN_ACCEPT;
5548 }
5549 mutex_exit(cport_mutex);
5550 }
5551 /* Restore the scsi pkt flags */
5552 scsipkt->pkt_flags &= ~FLAG_NOINTR;
5553 scsipkt->pkt_flags |= nointr_flag;
5554
5555 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst,
5556 "Scsi_pkt completion reason %x\n", scsipkt->pkt_reason);
5557
5558 if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0 &&
5559 scsipkt->pkt_comp != NULL) {
5560 /* scsi callback required */
5561 if (servicing_interrupt()) {
5562 if (taskq_dispatch(SATA_TXLT_TASKQ(spx),
5563 (task_func_t *)spx->txlt_scsi_pkt->pkt_comp,
5564 (void *)spx->txlt_scsi_pkt, TQ_NOSLEEP) == NULL) {
5565 return (TRAN_BUSY);
5566 }
5567 } else if (taskq_dispatch(SATA_TXLT_TASKQ(spx),
5568 (task_func_t *)spx->txlt_scsi_pkt->pkt_comp,
5569 (void *)spx->txlt_scsi_pkt, TQ_SLEEP) == NULL) {
5570 /* Scheduling the callback failed */
5571 return (TRAN_BUSY);
5572 }
5573 }
5574
5575 return (rval);
5576 }
5577
5578 /*
5579 * Translate command: ATA Pass Through
5580 * Incomplete implementation. Only supports No-Data, PIO Data-In, and
5581 * PIO Data-Out protocols. Also supports CK_COND bit.
5582 *
5583 * Mapping of the incoming CDB bytes to the outgoing satacmd bytes is
5584 * described in Table 111 of SAT-2 (Draft 9).
5585 */
5586 static int
5587 sata_txlt_ata_pass_thru(sata_pkt_txlate_t *spx)
5588 {
5589 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt;
5590 sata_cmd_t *scmd = &spx->txlt_sata_pkt->satapkt_cmd;
5591 struct buf *bp = spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp;
5592 int extend;
5593 uint64_t lba;
5594 uint16_t feature, sec_count;
5595 int t_len, synch;
5596 int rval, reason;
5597 kmutex_t *cport_mutex = &(SATA_TXLT_CPORT_MUTEX(spx));
5598
5599 mutex_enter(cport_mutex);
5600
5601 rval = sata_txlt_generic_pkt_info(spx, &reason, 1);
5602 if ((rval != TRAN_ACCEPT) || (reason == CMD_DEV_GONE)) {
5603 mutex_exit(cport_mutex);
5604 return (rval);
5605 }
5606
5607 /* T_DIR bit */
5608 if (scsipkt->pkt_cdbp[2] & SATL_APT_BM_T_DIR)
5609 scmd->satacmd_flags.sata_data_direction = SATA_DIR_READ;
5610 else
5611 scmd->satacmd_flags.sata_data_direction = SATA_DIR_WRITE;
5612
5613 /* MULTIPLE_COUNT field. If non-zero, invalid command (for now). */
5614 if (((scsipkt->pkt_cdbp[1] >> 5) & 0x7) != 0) {
5615 mutex_exit(cport_mutex);
5616 return (sata_txlt_ata_pass_thru_illegal_cmd(spx));
5617 }
5618
5619 /* OFFLINE field. If non-zero, invalid command (for now). */
5620 if (((scsipkt->pkt_cdbp[2] >> 6) & 0x3) != 0) {
5621 mutex_exit(cport_mutex);
5622 return (sata_txlt_ata_pass_thru_illegal_cmd(spx));
5623 }
5624
5625 /* PROTOCOL field */
5626 switch ((scsipkt->pkt_cdbp[1] >> 1) & 0xf) {
5627 case SATL_APT_P_HW_RESET:
5628 case SATL_APT_P_SRST:
5629 case SATL_APT_P_DMA:
5630 case SATL_APT_P_DMA_QUEUED:
5631 case SATL_APT_P_DEV_DIAG:
5632 case SATL_APT_P_DEV_RESET:
5633 case SATL_APT_P_UDMA_IN:
5634 case SATL_APT_P_UDMA_OUT:
5635 case SATL_APT_P_FPDMA:
5636 case SATL_APT_P_RET_RESP:
5637 /* Not yet implemented */
5638 default:
5639 mutex_exit(cport_mutex);
5640 return (sata_txlt_ata_pass_thru_illegal_cmd(spx));
5641
5642 case SATL_APT_P_NON_DATA:
5643 scmd->satacmd_flags.sata_data_direction = SATA_DIR_NODATA_XFER;
5644 break;
5645
5646 case SATL_APT_P_PIO_DATA_IN:
5647 /* If PROTOCOL disagrees with T_DIR, invalid command */
5648 if (scmd->satacmd_flags.sata_data_direction == SATA_DIR_WRITE) {
5649 mutex_exit(cport_mutex);
5650 return (sata_txlt_ata_pass_thru_illegal_cmd(spx));
5651 }
5652
5653 /* if there is a buffer, release its DMA resources */
5654 if ((bp != NULL) && bp->b_un.b_addr && bp->b_bcount) {
5655 sata_scsi_dmafree(NULL, scsipkt);
5656 } else {
5657 /* if there is no buffer, how do you PIO in? */
5658 mutex_exit(cport_mutex);
5659 return (sata_txlt_ata_pass_thru_illegal_cmd(spx));
5660 }
5661
5662 break;
5663
5664 case SATL_APT_P_PIO_DATA_OUT:
5665 /* If PROTOCOL disagrees with T_DIR, invalid command */
5666 if (scmd->satacmd_flags.sata_data_direction == SATA_DIR_READ) {
5667 mutex_exit(cport_mutex);
5668 return (sata_txlt_ata_pass_thru_illegal_cmd(spx));
5669 }
5670
5671 /* if there is a buffer, release its DMA resources */
5672 if ((bp != NULL) && bp->b_un.b_addr && bp->b_bcount) {
5673 sata_scsi_dmafree(NULL, scsipkt);
5674 } else {
5675 /* if there is no buffer, how do you PIO out? */
5676 mutex_exit(cport_mutex);
5677 return (sata_txlt_ata_pass_thru_illegal_cmd(spx));
5678 }
5679
5680 break;
5681 }
5682
5683 /* Parse the ATA cmd fields, transfer some straight to the satacmd */
5684 switch ((uint_t)scsipkt->pkt_cdbp[0]) {
5685 case SPC3_CMD_ATA_COMMAND_PASS_THROUGH12:
5686 feature = scsipkt->pkt_cdbp[3];
5687
5688 sec_count = scsipkt->pkt_cdbp[4];
5689
5690 lba = scsipkt->pkt_cdbp[8] & 0xf;
5691 lba = (lba << 8) | scsipkt->pkt_cdbp[7];
5692 lba = (lba << 8) | scsipkt->pkt_cdbp[6];
5693 lba = (lba << 8) | scsipkt->pkt_cdbp[5];
5694
5695 scmd->satacmd_device_reg = scsipkt->pkt_cdbp[13] & 0xf0;
5696 scmd->satacmd_cmd_reg = scsipkt->pkt_cdbp[9];
5697
5698 break;
5699
5700 case SPC3_CMD_ATA_COMMAND_PASS_THROUGH16:
5701 if (scsipkt->pkt_cdbp[1] & SATL_APT_BM_EXTEND) {
5702 extend = 1;
5703
5704 feature = scsipkt->pkt_cdbp[3];
5705 feature = (feature << 8) | scsipkt->pkt_cdbp[4];
5706
5707 sec_count = scsipkt->pkt_cdbp[5];
5708 sec_count = (sec_count << 8) | scsipkt->pkt_cdbp[6];
5709
5710 lba = scsipkt->pkt_cdbp[11];
5711 lba = (lba << 8) | scsipkt->pkt_cdbp[12];
5712 lba = (lba << 8) | scsipkt->pkt_cdbp[9];
5713 lba = (lba << 8) | scsipkt->pkt_cdbp[10];
5714 lba = (lba << 8) | scsipkt->pkt_cdbp[7];
5715 lba = (lba << 8) | scsipkt->pkt_cdbp[8];
5716
5717 scmd->satacmd_device_reg = scsipkt->pkt_cdbp[13];
5718 scmd->satacmd_cmd_reg = scsipkt->pkt_cdbp[14];
5719 } else {
5720 feature = scsipkt->pkt_cdbp[3];
5721
5722 sec_count = scsipkt->pkt_cdbp[5];
5723
5724 lba = scsipkt->pkt_cdbp[13] & 0xf;
5725 lba = (lba << 8) | scsipkt->pkt_cdbp[12];
5726 lba = (lba << 8) | scsipkt->pkt_cdbp[10];
5727 lba = (lba << 8) | scsipkt->pkt_cdbp[8];
5728
5729 scmd->satacmd_device_reg = scsipkt->pkt_cdbp[13] &
5730 0xf0;
5731 scmd->satacmd_cmd_reg = scsipkt->pkt_cdbp[14];
5732 }
5733
5734 break;
5735 }
5736
5737 /* CK_COND bit */
5738 if (scsipkt->pkt_cdbp[2] & SATL_APT_BM_CK_COND) {
5739 if (extend) {
5740 scmd->satacmd_flags.sata_copy_out_sec_count_msb = 1;
5741 scmd->satacmd_flags.sata_copy_out_lba_low_msb = 1;
5742 scmd->satacmd_flags.sata_copy_out_lba_mid_msb = 1;
5743 scmd->satacmd_flags.sata_copy_out_lba_high_msb = 1;
5744 }
5745
5746 scmd->satacmd_flags.sata_copy_out_sec_count_lsb = 1;
5747 scmd->satacmd_flags.sata_copy_out_lba_low_lsb = 1;
5748 scmd->satacmd_flags.sata_copy_out_lba_mid_lsb = 1;
5749 scmd->satacmd_flags.sata_copy_out_lba_high_lsb = 1;
5750 scmd->satacmd_flags.sata_copy_out_device_reg = 1;
5751 scmd->satacmd_flags.sata_copy_out_error_reg = 1;
5752 }
5753
5754 /* Transfer remaining parsed ATA cmd values to the satacmd */
5755 if (extend) {
5756 scmd->satacmd_addr_type = ATA_ADDR_LBA48;
5757
5758 scmd->satacmd_features_reg_ext = (feature >> 8) & 0xff;
5759 scmd->satacmd_sec_count_msb = (sec_count >> 8) & 0xff;
5760 scmd->satacmd_lba_low_msb = (lba >> 8) & 0xff;
5761 scmd->satacmd_lba_mid_msb = (lba >> 8) & 0xff;
5762 scmd->satacmd_lba_high_msb = lba >> 40;
5763 } else {
5764 scmd->satacmd_addr_type = ATA_ADDR_LBA28;
5765
5766 scmd->satacmd_features_reg_ext = 0;
5767 scmd->satacmd_sec_count_msb = 0;
5768 scmd->satacmd_lba_low_msb = 0;
5769 scmd->satacmd_lba_mid_msb = 0;
5770 scmd->satacmd_lba_high_msb = 0;
5771 }
5772
5773 scmd->satacmd_features_reg = feature & 0xff;
5774 scmd->satacmd_sec_count_lsb = sec_count & 0xff;
5775 scmd->satacmd_lba_low_lsb = lba & 0xff;
5776 scmd->satacmd_lba_mid_lsb = (lba >> 8) & 0xff;
5777 scmd->satacmd_lba_high_lsb = (lba >> 16) & 0xff;
5778
5779 /* Determine transfer length */
5780 switch (scsipkt->pkt_cdbp[2] & 0x3) { /* T_LENGTH field */
5781 case 1:
5782 t_len = feature;
5783 break;
5784 case 2:
5785 t_len = sec_count;
5786 break;
5787 default:
5788 t_len = 0;
5789 break;
5790 }
5791
5792 /* Adjust transfer length for the Byte Block bit */
5793 if ((scsipkt->pkt_cdbp[2] >> 2) & 1)
5794 t_len *= SATA_DISK_SECTOR_SIZE;
5795
5796 /* Start processing command */
5797 if (!(spx->txlt_sata_pkt->satapkt_op_mode & SATA_OPMODE_SYNCH)) {
5798 spx->txlt_sata_pkt->satapkt_comp = sata_txlt_apt_completion;
5799 synch = FALSE;
5800 } else {
5801 synch = TRUE;
5802 }
5803
5804 if (sata_hba_start(spx, &rval) != 0) {
5805 mutex_exit(cport_mutex);
5806 return (rval);
5807 }
5808
5809 mutex_exit(cport_mutex);
5810
5811 if (synch) {
5812 sata_txlt_apt_completion(spx->txlt_sata_pkt);
5813 }
5814
5815 return (TRAN_ACCEPT);
5816 }
5817
5818 /*
5819 * Translate command: Log Sense
5820 */
5821 static int
5822 sata_txlt_log_sense(sata_pkt_txlate_t *spx)
5823 {
5824 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt;
5825 struct buf *bp = spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp;
5826 sata_drive_info_t *sdinfo;
5827 struct scsi_extended_sense *sense;
5828 int len, count, alc_len;
5829 int pc; /* Page Control code */
5830 int page_code; /* Page code */
5831 uint8_t *buf; /* log sense buffer */
5832 int rval, reason;
5833 #define MAX_LOG_SENSE_PAGE_SIZE 512
5834 kmutex_t *cport_mutex = &(SATA_TXLT_CPORT_MUTEX(spx));
5835
5836 SATADBG2(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst,
5837 "sata_txlt_log_sense, pc 0x%x, page code 0x%x\n",
5838 spx->txlt_scsi_pkt->pkt_cdbp[2] >> 6,
5839 spx->txlt_scsi_pkt->pkt_cdbp[2] & 0x3f);
5840
5841 if (servicing_interrupt()) {
5842 buf = kmem_zalloc(MAX_LOG_SENSE_PAGE_SIZE, KM_NOSLEEP);
5843 if (buf == NULL) {
5844 return (TRAN_BUSY);
5845 }
5846 } else {
5847 buf = kmem_zalloc(MAX_LOG_SENSE_PAGE_SIZE, KM_SLEEP);
5848 }
5849
5850 mutex_enter(cport_mutex);
5851
5852 if (((rval = sata_txlt_generic_pkt_info(spx, &reason, 1)) !=
5853 TRAN_ACCEPT) || (reason == CMD_DEV_GONE)) {
5854 mutex_exit(cport_mutex);
5855 kmem_free(buf, MAX_LOG_SENSE_PAGE_SIZE);
5856 return (rval);
5857 }
5858
5859 scsipkt->pkt_reason = CMD_CMPLT;
5860 scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET |
5861 STATE_SENT_CMD | STATE_GOT_STATUS;
5862
5863 pc = scsipkt->pkt_cdbp[2] >> 6;
5864 page_code = scsipkt->pkt_cdbp[2] & 0x3f;
5865
5866 /* Reject not supported request for all but cumulative values */
5867 switch (pc) {
5868 case PC_CUMULATIVE_VALUES:
5869 break;
5870 default:
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_ASC_INVALID_FIELD_IN_CDB;
5875 goto done;
5876 }
5877
5878 switch (page_code) {
5879 case PAGE_CODE_GET_SUPPORTED_LOG_PAGES:
5880 case PAGE_CODE_SELF_TEST_RESULTS:
5881 case PAGE_CODE_INFORMATION_EXCEPTIONS:
5882 case PAGE_CODE_SMART_READ_DATA:
5883 case PAGE_CODE_START_STOP_CYCLE_COUNTER:
5884 break;
5885 default:
5886 *scsipkt->pkt_scbp = STATUS_CHECK;
5887 sense = sata_arq_sense(spx);
5888 sense->es_key = KEY_ILLEGAL_REQUEST;
5889 sense->es_add_code = SD_SCSI_ASC_INVALID_FIELD_IN_CDB;
5890 goto done;
5891 }
5892
5893 if (bp != NULL && bp->b_un.b_addr && bp->b_bcount) {
5894 /*
5895 * Because log sense uses local buffers for data retrieval from
5896 * the devices and sets the data programatically in the
5897 * original specified buffer, release preallocated DMA
5898 * resources before storing data in the original buffer,
5899 * so no unwanted DMA sync would take place.
5900 */
5901 sata_id_t *sata_id;
5902
5903 sata_scsi_dmafree(NULL, scsipkt);
5904
5905 len = 0;
5906
5907 /* Build log parameter header */
5908 buf[len++] = page_code; /* page code as in the CDB */
5909 buf[len++] = 0; /* reserved */
5910 buf[len++] = 0; /* Zero out page length for now (MSB) */
5911 buf[len++] = 0; /* (LSB) */
5912
5913 sdinfo = sata_get_device_info(
5914 spx->txlt_sata_hba_inst,
5915 &spx->txlt_sata_pkt->satapkt_device);
5916
5917 /*
5918 * Add requested pages.
5919 */
5920 switch (page_code) {
5921 case PAGE_CODE_GET_SUPPORTED_LOG_PAGES:
5922 len = sata_build_lsense_page_0(sdinfo, buf + len);
5923 break;
5924 case PAGE_CODE_SELF_TEST_RESULTS:
5925 sata_id = &sdinfo->satadrv_id;
5926 if ((! (sata_id->ai_cmdset84 &
5927 SATA_SMART_SELF_TEST_SUPPORTED)) ||
5928 (! (sata_id->ai_features87 &
5929 SATA_SMART_SELF_TEST_SUPPORTED))) {
5930 *scsipkt->pkt_scbp = STATUS_CHECK;
5931 sense = sata_arq_sense(spx);
5932 sense->es_key = KEY_ILLEGAL_REQUEST;
5933 sense->es_add_code =
5934 SD_SCSI_ASC_INVALID_FIELD_IN_CDB;
5935
5936 goto done;
5937 }
5938 len = sata_build_lsense_page_10(sdinfo, buf + len,
5939 spx->txlt_sata_hba_inst);
5940 break;
5941 case PAGE_CODE_INFORMATION_EXCEPTIONS:
5942 sata_id = &sdinfo->satadrv_id;
5943 if (! (sata_id->ai_cmdset82 & SATA_SMART_SUPPORTED)) {
5944 *scsipkt->pkt_scbp = STATUS_CHECK;
5945 sense = sata_arq_sense(spx);
5946 sense->es_key = KEY_ILLEGAL_REQUEST;
5947 sense->es_add_code =
5948 SD_SCSI_ASC_INVALID_FIELD_IN_CDB;
5949
5950 goto done;
5951 }
5952 if (! (sata_id->ai_features85 & SATA_SMART_ENABLED)) {
5953 *scsipkt->pkt_scbp = STATUS_CHECK;
5954 sense = sata_arq_sense(spx);
5955 sense->es_key = KEY_ABORTED_COMMAND;
5956 sense->es_add_code =
5957 SCSI_ASC_ATA_DEV_FEAT_NOT_ENABLED;
5958 sense->es_qual_code =
5959 SCSI_ASCQ_ATA_DEV_FEAT_NOT_ENABLED;
5960
5961 goto done;
5962 }
5963
5964 len = sata_build_lsense_page_2f(sdinfo, buf + len,
5965 spx->txlt_sata_hba_inst);
5966 break;
5967 case PAGE_CODE_SMART_READ_DATA:
5968 sata_id = &sdinfo->satadrv_id;
5969 if (! (sata_id->ai_cmdset82 & SATA_SMART_SUPPORTED)) {
5970 *scsipkt->pkt_scbp = STATUS_CHECK;
5971 sense = sata_arq_sense(spx);
5972 sense->es_key = KEY_ILLEGAL_REQUEST;
5973 sense->es_add_code =
5974 SD_SCSI_ASC_INVALID_FIELD_IN_CDB;
5975
5976 goto done;
5977 }
5978 if (! (sata_id->ai_features85 & SATA_SMART_ENABLED)) {
5979 *scsipkt->pkt_scbp = STATUS_CHECK;
5980 sense = sata_arq_sense(spx);
5981 sense->es_key = KEY_ABORTED_COMMAND;
5982 sense->es_add_code =
5983 SCSI_ASC_ATA_DEV_FEAT_NOT_ENABLED;
5984 sense->es_qual_code =
5985 SCSI_ASCQ_ATA_DEV_FEAT_NOT_ENABLED;
5986
5987 goto done;
5988 }
5989
5990 /* This page doesn't include a page header */
5991 len = sata_build_lsense_page_30(sdinfo, buf,
5992 spx->txlt_sata_hba_inst);
5993 goto no_header;
5994 case PAGE_CODE_START_STOP_CYCLE_COUNTER:
5995 sata_id = &sdinfo->satadrv_id;
5996 if (! (sata_id->ai_cmdset82 & SATA_SMART_SUPPORTED)) {
5997 *scsipkt->pkt_scbp = STATUS_CHECK;
5998 sense = sata_arq_sense(spx);
5999 sense->es_key = KEY_ILLEGAL_REQUEST;
6000 sense->es_add_code =
6001 SD_SCSI_ASC_INVALID_FIELD_IN_CDB;
6002
6003 goto done;
6004 }
6005 if (! (sata_id->ai_features85 & SATA_SMART_ENABLED)) {
6006 *scsipkt->pkt_scbp = STATUS_CHECK;
6007 sense = sata_arq_sense(spx);
6008 sense->es_key = KEY_ABORTED_COMMAND;
6009 sense->es_add_code =
6010 SCSI_ASC_ATA_DEV_FEAT_NOT_ENABLED;
6011 sense->es_qual_code =
6012 SCSI_ASCQ_ATA_DEV_FEAT_NOT_ENABLED;
6013
6014 goto done;
6015 }
6016 len = sata_build_lsense_page_0e(sdinfo, buf, spx);
6017 goto no_header;
6018 default:
6019 /* Invalid request */
6020 *scsipkt->pkt_scbp = STATUS_CHECK;
6021 sense = sata_arq_sense(spx);
6022 sense->es_key = KEY_ILLEGAL_REQUEST;
6023 sense->es_add_code = SD_SCSI_ASC_INVALID_FIELD_IN_CDB;
6024 goto done;
6025 }
6026
6027 /* set parameter log sense data length */
6028 buf[2] = len >> 8; /* log sense length (MSB) */
6029 buf[3] = len & 0xff; /* log sense length (LSB) */
6030
6031 len += SCSI_LOG_PAGE_HDR_LEN;
6032 ASSERT(len <= MAX_LOG_SENSE_PAGE_SIZE);
6033
6034 no_header:
6035 /* Check allocation length */
6036 alc_len = scsipkt->pkt_cdbp[7];
6037 alc_len = (len << 8) | scsipkt->pkt_cdbp[8];
6038
6039 /*
6040 * We do not check for possible parameters truncation
6041 * (alc_len < len) assuming that the target driver works
6042 * correctly. Just avoiding overrun.
6043 * Copy no more than requested and possible, buffer-wise.
6044 */
6045 count = MIN(alc_len, len);
6046 count = MIN(bp->b_bcount, count);
6047 bcopy(buf, bp->b_un.b_addr, count);
6048
6049 scsipkt->pkt_state |= STATE_XFERRED_DATA;
6050 scsipkt->pkt_resid = alc_len > count ? alc_len - count : 0;
6051 }
6052 *scsipkt->pkt_scbp = STATUS_GOOD;
6053 done:
6054 mutex_exit(cport_mutex);
6055 (void) kmem_free(buf, MAX_LOG_SENSE_PAGE_SIZE);
6056
6057 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst,
6058 "Scsi_pkt completion reason %x\n", scsipkt->pkt_reason);
6059
6060 if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0 &&
6061 scsipkt->pkt_comp != NULL) {
6062 /* scsi callback required */
6063 if (servicing_interrupt()) {
6064 if (taskq_dispatch(SATA_TXLT_TASKQ(spx),
6065 (task_func_t *)spx->txlt_scsi_pkt->pkt_comp,
6066 (void *)spx->txlt_scsi_pkt, TQ_NOSLEEP) == NULL) {
6067 return (TRAN_BUSY);
6068 }
6069 } else if (taskq_dispatch(SATA_TXLT_TASKQ(spx),
6070 (task_func_t *)spx->txlt_scsi_pkt->pkt_comp,
6071 (void *)spx->txlt_scsi_pkt, TQ_SLEEP) == NULL) {
6072 /* Scheduling the callback failed */
6073 return (TRAN_BUSY);
6074 }
6075 }
6076
6077 return (TRAN_ACCEPT);
6078 }
6079
6080 /*
6081 * Translate command: Log Select
6082 * Not implemented at this time - returns invalid command response.
6083 */
6084 static int
6085 sata_txlt_log_select(sata_pkt_txlate_t *spx)
6086 {
6087 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst,
6088 "sata_txlt_log_select\n", NULL);
6089
6090 return (sata_txlt_invalid_command(spx));
6091 }
6092
6093
6094 /*
6095 * Translate command: Read (various types).
6096 * Translated into appropriate type of ATA READ command
6097 * for SATA hard disks.
6098 * Both the device capabilities and requested operation mode are
6099 * considered.
6100 *
6101 * Following scsi cdb fields are ignored:
6102 * rdprotect, dpo, fua, fua_nv, group_number.
6103 *
6104 * If SATA_ENABLE_QUEUING flag is set (in the global SATA HBA framework
6105 * enable variable sata_func_enable), the capability of the controller and
6106 * capability of a device are checked and if both support queueing, read
6107 * request will be translated to READ_DMA_QUEUEING or READ_DMA_QUEUEING_EXT
6108 * command rather than plain READ_XXX command.
6109 * If SATA_ENABLE_NCQ flag is set in addition to SATA_ENABLE_QUEUING flag and
6110 * both the controller and device suport such functionality, the read
6111 * request will be translated to READ_FPDMA_QUEUED command.
6112 * In both cases the maximum queue depth is derived as minimum of:
6113 * HBA capability,device capability and sata_max_queue_depth variable setting.
6114 * The value passed to HBA driver is decremented by 1, because only 5 bits are
6115 * used to pass max queue depth value, and the maximum possible queue depth
6116 * is 32.
6117 *
6118 * Returns TRAN_ACCEPT or code returned by sata_hba_start() and
6119 * appropriate values in scsi_pkt fields.
6120 */
6121 static int
6122 sata_txlt_read(sata_pkt_txlate_t *spx)
6123 {
6124 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt;
6125 sata_cmd_t *scmd = &spx->txlt_sata_pkt->satapkt_cmd;
6126 sata_drive_info_t *sdinfo;
6127 sata_hba_inst_t *shi = SATA_TXLT_HBA_INST(spx);
6128 kmutex_t *cport_mutex = &(SATA_TXLT_CPORT_MUTEX(spx));
6129 uint16_t sec_count;
6130 uint64_t lba;
6131 int rval, reason;
6132 int synch;
6133
6134 mutex_enter(cport_mutex);
6135
6136 if (((rval = sata_txlt_generic_pkt_info(spx, &reason, 0)) !=
6137 TRAN_ACCEPT) || (reason == CMD_DEV_GONE)) {
6138 mutex_exit(cport_mutex);
6139 return (rval);
6140 }
6141
6142 sdinfo = sata_get_device_info(spx->txlt_sata_hba_inst,
6143 &spx->txlt_sata_pkt->satapkt_device);
6144
6145 scmd->satacmd_flags.sata_data_direction = SATA_DIR_READ;
6146 /*
6147 * Extract LBA and sector count from scsi CDB.
6148 */
6149 switch ((uint_t)scsipkt->pkt_cdbp[0]) {
6150 case SCMD_READ:
6151 /* 6-byte scsi read cmd : 0x08 */
6152 lba = (scsipkt->pkt_cdbp[1] & 0x1f);
6153 lba = (lba << 8) | scsipkt->pkt_cdbp[2];
6154 lba = (lba << 8) | scsipkt->pkt_cdbp[3];
6155 sec_count = scsipkt->pkt_cdbp[4];
6156 /* sec_count 0 will be interpreted as 256 by a device */
6157 break;
6158 case SCMD_READ_G1:
6159 /* 10-bytes scsi read command : 0x28 */
6160 lba = scsipkt->pkt_cdbp[2];
6161 lba = (lba << 8) | scsipkt->pkt_cdbp[3];
6162 lba = (lba << 8) | scsipkt->pkt_cdbp[4];
6163 lba = (lba << 8) | scsipkt->pkt_cdbp[5];
6164 sec_count = scsipkt->pkt_cdbp[7];
6165 sec_count = (sec_count << 8) | scsipkt->pkt_cdbp[8];
6166 break;
6167 case SCMD_READ_G5:
6168 /* 12-bytes scsi read command : 0xA8 */
6169 lba = scsipkt->pkt_cdbp[2];
6170 lba = (lba << 8) | scsipkt->pkt_cdbp[3];
6171 lba = (lba << 8) | scsipkt->pkt_cdbp[4];
6172 lba = (lba << 8) | scsipkt->pkt_cdbp[5];
6173 sec_count = scsipkt->pkt_cdbp[6];
6174 sec_count = (sec_count << 8) | scsipkt->pkt_cdbp[7];
6175 sec_count = (sec_count << 8) | scsipkt->pkt_cdbp[8];
6176 sec_count = (sec_count << 8) | scsipkt->pkt_cdbp[9];
6177 break;
6178 case SCMD_READ_G4:
6179 /* 16-bytes scsi read command : 0x88 */
6180 lba = scsipkt->pkt_cdbp[2];
6181 lba = (lba << 8) | scsipkt->pkt_cdbp[3];
6182 lba = (lba << 8) | scsipkt->pkt_cdbp[4];
6183 lba = (lba << 8) | scsipkt->pkt_cdbp[5];
6184 lba = (lba << 8) | scsipkt->pkt_cdbp[6];
6185 lba = (lba << 8) | scsipkt->pkt_cdbp[7];
6186 lba = (lba << 8) | scsipkt->pkt_cdbp[8];
6187 lba = (lba << 8) | scsipkt->pkt_cdbp[9];
6188 sec_count = scsipkt->pkt_cdbp[10];
6189 sec_count = (sec_count << 8) | scsipkt->pkt_cdbp[11];
6190 sec_count = (sec_count << 8) | scsipkt->pkt_cdbp[12];
6191 sec_count = (sec_count << 8) | scsipkt->pkt_cdbp[13];
6192 break;
6193 default:
6194 /* Unsupported command */
6195 mutex_exit(cport_mutex);
6196 return (sata_txlt_invalid_command(spx));
6197 }
6198
6199 /*
6200 * Check if specified address exceeds device capacity
6201 */
6202 if ((lba >= sdinfo->satadrv_capacity) ||
6203 ((lba + sec_count) > sdinfo->satadrv_capacity)) {
6204 /* LBA out of range */
6205 mutex_exit(cport_mutex);
6206 return (sata_txlt_lba_out_of_range(spx));
6207 }
6208
6209 /*
6210 * For zero-length transfer, emulate good completion of the command
6211 * (reasons for rejecting the command were already checked).
6212 * No DMA resources were allocated.
6213 */
6214 if (spx->txlt_dma_cookie_list == NULL) {
6215 mutex_exit(cport_mutex);
6216 return (sata_emul_rw_completion(spx));
6217 }
6218
6219 /*
6220 * Build cmd block depending on the device capability and
6221 * requested operation mode.
6222 * Do not bother with non-dma mode - we are working only with
6223 * devices supporting DMA.
6224 */
6225 scmd->satacmd_addr_type = ATA_ADDR_LBA;
6226 scmd->satacmd_device_reg = SATA_ADH_LBA;
6227 scmd->satacmd_cmd_reg = SATAC_READ_DMA;
6228 if (sdinfo->satadrv_features_support & SATA_DEV_F_LBA48) {
6229 scmd->satacmd_addr_type = ATA_ADDR_LBA48;
6230 scmd->satacmd_cmd_reg = SATAC_READ_DMA_EXT;
6231 scmd->satacmd_sec_count_msb = sec_count >> 8;
6232 #ifndef __lock_lint
6233 scmd->satacmd_lba_low_msb = (lba >> 24) & 0xff;
6234 scmd->satacmd_lba_mid_msb = (lba >> 32) & 0xff;
6235 scmd->satacmd_lba_high_msb = lba >> 40;
6236 #endif
6237 } else if (sdinfo->satadrv_features_support & SATA_DEV_F_LBA28) {
6238 scmd->satacmd_addr_type = ATA_ADDR_LBA28;
6239 scmd->satacmd_device_reg = SATA_ADH_LBA | ((lba >> 24) & 0xf);
6240 }
6241 scmd->satacmd_sec_count_lsb = sec_count & 0xff;
6242 scmd->satacmd_lba_low_lsb = lba & 0xff;
6243 scmd->satacmd_lba_mid_lsb = (lba >> 8) & 0xff;
6244 scmd->satacmd_lba_high_lsb = (lba >> 16) & 0xff;
6245 scmd->satacmd_features_reg = 0;
6246 scmd->satacmd_status_reg = 0;
6247 scmd->satacmd_error_reg = 0;
6248
6249 /*
6250 * Check if queueing commands should be used and switch
6251 * to appropriate command if possible
6252 */
6253 if (sata_func_enable & SATA_ENABLE_QUEUING) {
6254 boolean_t using_queuing;
6255
6256 /* Queuing supported by controller and device? */
6257 if ((sata_func_enable & SATA_ENABLE_NCQ) &&
6258 (sdinfo->satadrv_features_support &
6259 SATA_DEV_F_NCQ) &&
6260 (SATA_FEATURES(spx->txlt_sata_hba_inst) &
6261 SATA_CTLF_NCQ)) {
6262 using_queuing = B_TRUE;
6263
6264 /* NCQ supported - use FPDMA READ */
6265 scmd->satacmd_cmd_reg =
6266 SATAC_READ_FPDMA_QUEUED;
6267 scmd->satacmd_features_reg_ext =
6268 scmd->satacmd_sec_count_msb;
6269 scmd->satacmd_sec_count_msb = 0;
6270 } else if ((sdinfo->satadrv_features_support &
6271 SATA_DEV_F_TCQ) &&
6272 (SATA_FEATURES(spx->txlt_sata_hba_inst) &
6273 SATA_CTLF_QCMD)) {
6274 using_queuing = B_TRUE;
6275
6276 /* Legacy queueing */
6277 if (sdinfo->satadrv_features_support &
6278 SATA_DEV_F_LBA48) {
6279 scmd->satacmd_cmd_reg =
6280 SATAC_READ_DMA_QUEUED_EXT;
6281 scmd->satacmd_features_reg_ext =
6282 scmd->satacmd_sec_count_msb;
6283 scmd->satacmd_sec_count_msb = 0;
6284 } else {
6285 scmd->satacmd_cmd_reg =
6286 SATAC_READ_DMA_QUEUED;
6287 }
6288 } else /* NCQ nor legacy queuing not supported */
6289 using_queuing = B_FALSE;
6290
6291 /*
6292 * If queuing, the sector count goes in the features register
6293 * and the secount count will contain the tag.
6294 */
6295 if (using_queuing) {
6296 scmd->satacmd_features_reg =
6297 scmd->satacmd_sec_count_lsb;
6298 scmd->satacmd_sec_count_lsb = 0;
6299 scmd->satacmd_flags.sata_queued = B_TRUE;
6300
6301 /* Set-up maximum queue depth */
6302 scmd->satacmd_flags.sata_max_queue_depth =
6303 sdinfo->satadrv_max_queue_depth - 1;
6304 } else if (sdinfo->satadrv_features_enabled &
6305 SATA_DEV_F_E_UNTAGGED_QING) {
6306 /*
6307 * Although NCQ/TCQ is not enabled, untagged queuing
6308 * may be still used.
6309 * Set-up the maximum untagged queue depth.
6310 * Use controller's queue depth from sata_hba_tran.
6311 * SATA HBA drivers may ignore this value and rely on
6312 * the internal limits.For drivers that do not
6313 * ignore untaged queue depth, limit the value to
6314 * SATA_MAX_QUEUE_DEPTH (32), as this is the
6315 * largest value that can be passed via
6316 * satacmd_flags.sata_max_queue_depth.
6317 */
6318 scmd->satacmd_flags.sata_max_queue_depth =
6319 SATA_QDEPTH(shi) <= SATA_MAX_QUEUE_DEPTH ?
6320 SATA_QDEPTH(shi) - 1: SATA_MAX_QUEUE_DEPTH - 1;
6321
6322 } else {
6323 scmd->satacmd_flags.sata_max_queue_depth = 0;
6324 }
6325 } else
6326 scmd->satacmd_flags.sata_max_queue_depth = 0;
6327
6328 SATADBG3(SATA_DBG_HBA_IF, spx->txlt_sata_hba_inst,
6329 "sata_txlt_read cmd 0x%2x, lba %llx, sec count %x\n",
6330 scmd->satacmd_cmd_reg, lba, sec_count);
6331
6332 if (!(spx->txlt_sata_pkt->satapkt_op_mode & SATA_OPMODE_SYNCH)) {
6333 /* Need callback function */
6334 spx->txlt_sata_pkt->satapkt_comp = sata_txlt_rw_completion;
6335 synch = FALSE;
6336 } else
6337 synch = TRUE;
6338
6339 /* Transfer command to HBA */
6340 if (sata_hba_start(spx, &rval) != 0) {
6341 /* Pkt not accepted for execution */
6342 mutex_exit(cport_mutex);
6343 return (rval);
6344 }
6345 mutex_exit(cport_mutex);
6346 /*
6347 * If execution is non-synchronous,
6348 * a callback function will handle potential errors, translate
6349 * the response and will do a callback to a target driver.
6350 * If it was synchronous, check execution status using the same
6351 * framework callback.
6352 */
6353 if (synch) {
6354 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst,
6355 "synchronous execution status %x\n",
6356 spx->txlt_sata_pkt->satapkt_reason);
6357 sata_txlt_rw_completion(spx->txlt_sata_pkt);
6358 }
6359 return (TRAN_ACCEPT);
6360 }
6361
6362
6363 /*
6364 * SATA translate command: Write (various types)
6365 * Translated into appropriate type of ATA WRITE command
6366 * for SATA hard disks.
6367 * Both the device capabilities and requested operation mode are
6368 * considered.
6369 *
6370 * Following scsi cdb fields are ignored:
6371 * rwprotect, dpo, fua, fua_nv, group_number.
6372 *
6373 * If SATA_ENABLE_QUEUING flag is set (in the global SATA HBA framework
6374 * enable variable sata_func_enable), the capability of the controller and
6375 * capability of a device are checked and if both support queueing, write
6376 * request will be translated to WRITE_DMA_QUEUEING or WRITE_DMA_QUEUEING_EXT
6377 * command rather than plain WRITE_XXX command.
6378 * If SATA_ENABLE_NCQ flag is set in addition to SATA_ENABLE_QUEUING flag and
6379 * both the controller and device suport such functionality, the write
6380 * request will be translated to WRITE_FPDMA_QUEUED command.
6381 * In both cases the maximum queue depth is derived as minimum of:
6382 * HBA capability,device capability and sata_max_queue_depth variable setting.
6383 * The value passed to HBA driver is decremented by 1, because only 5 bits are
6384 * used to pass max queue depth value, and the maximum possible queue depth
6385 * is 32.
6386 *
6387 * Returns TRAN_ACCEPT or code returned by sata_hba_start() and
6388 * appropriate values in scsi_pkt fields.
6389 */
6390 static int
6391 sata_txlt_write(sata_pkt_txlate_t *spx)
6392 {
6393 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt;
6394 sata_cmd_t *scmd = &spx->txlt_sata_pkt->satapkt_cmd;
6395 sata_drive_info_t *sdinfo;
6396 sata_hba_inst_t *shi = SATA_TXLT_HBA_INST(spx);
6397 uint16_t sec_count;
6398 uint64_t lba;
6399 int rval, reason;
6400 int synch;
6401 kmutex_t *cport_mutex = &(SATA_TXLT_CPORT_MUTEX(spx));
6402
6403 mutex_enter(cport_mutex);
6404
6405 if (((rval = sata_txlt_generic_pkt_info(spx, &reason, 0)) !=
6406 TRAN_ACCEPT) || (reason == CMD_DEV_GONE)) {
6407 mutex_exit(cport_mutex);
6408 return (rval);
6409 }
6410
6411 sdinfo = sata_get_device_info(spx->txlt_sata_hba_inst,
6412 &spx->txlt_sata_pkt->satapkt_device);
6413
6414 scmd->satacmd_flags.sata_data_direction = SATA_DIR_WRITE;
6415 /*
6416 * Extract LBA and sector count from scsi CDB
6417 */
6418 switch ((uint_t)scsipkt->pkt_cdbp[0]) {
6419 case SCMD_WRITE:
6420 /* 6-byte scsi read cmd : 0x0A */
6421 lba = (scsipkt->pkt_cdbp[1] & 0x1f);
6422 lba = (lba << 8) | scsipkt->pkt_cdbp[2];
6423 lba = (lba << 8) | scsipkt->pkt_cdbp[3];
6424 sec_count = scsipkt->pkt_cdbp[4];
6425 /* sec_count 0 will be interpreted as 256 by a device */
6426 break;
6427 case SCMD_WRITE_G1:
6428 /* 10-bytes scsi write command : 0x2A */
6429 lba = scsipkt->pkt_cdbp[2];
6430 lba = (lba << 8) | scsipkt->pkt_cdbp[3];
6431 lba = (lba << 8) | scsipkt->pkt_cdbp[4];
6432 lba = (lba << 8) | scsipkt->pkt_cdbp[5];
6433 sec_count = scsipkt->pkt_cdbp[7];
6434 sec_count = (sec_count << 8) | scsipkt->pkt_cdbp[8];
6435 break;
6436 case SCMD_WRITE_G5:
6437 /* 12-bytes scsi read command : 0xAA */
6438 lba = scsipkt->pkt_cdbp[2];
6439 lba = (lba << 8) | scsipkt->pkt_cdbp[3];
6440 lba = (lba << 8) | scsipkt->pkt_cdbp[4];
6441 lba = (lba << 8) | scsipkt->pkt_cdbp[5];
6442 sec_count = scsipkt->pkt_cdbp[6];
6443 sec_count = (sec_count << 8) | scsipkt->pkt_cdbp[7];
6444 sec_count = (sec_count << 8) | scsipkt->pkt_cdbp[8];
6445 sec_count = (sec_count << 8) | scsipkt->pkt_cdbp[9];
6446 break;
6447 case SCMD_WRITE_G4:
6448 /* 16-bytes scsi write command : 0x8A */
6449 lba = scsipkt->pkt_cdbp[2];
6450 lba = (lba << 8) | scsipkt->pkt_cdbp[3];
6451 lba = (lba << 8) | scsipkt->pkt_cdbp[4];
6452 lba = (lba << 8) | scsipkt->pkt_cdbp[5];
6453 lba = (lba << 8) | scsipkt->pkt_cdbp[6];
6454 lba = (lba << 8) | scsipkt->pkt_cdbp[7];
6455 lba = (lba << 8) | scsipkt->pkt_cdbp[8];
6456 lba = (lba << 8) | scsipkt->pkt_cdbp[9];
6457 sec_count = scsipkt->pkt_cdbp[10];
6458 sec_count = (sec_count << 8) | scsipkt->pkt_cdbp[11];
6459 sec_count = (sec_count << 8) | scsipkt->pkt_cdbp[12];
6460 sec_count = (sec_count << 8) | scsipkt->pkt_cdbp[13];
6461 break;
6462 default:
6463 /* Unsupported command */
6464 mutex_exit(cport_mutex);
6465 return (sata_txlt_invalid_command(spx));
6466 }
6467
6468 /*
6469 * Check if specified address and length exceeds device capacity
6470 */
6471 if ((lba >= sdinfo->satadrv_capacity) ||
6472 ((lba + sec_count) > sdinfo->satadrv_capacity)) {
6473 /* LBA out of range */
6474 mutex_exit(cport_mutex);
6475 return (sata_txlt_lba_out_of_range(spx));
6476 }
6477
6478 /*
6479 * For zero-length transfer, emulate good completion of the command
6480 * (reasons for rejecting the command were already checked).
6481 * No DMA resources were allocated.
6482 */
6483 if (spx->txlt_dma_cookie_list == NULL) {
6484 mutex_exit(cport_mutex);
6485 return (sata_emul_rw_completion(spx));
6486 }
6487
6488 /*
6489 * Build cmd block depending on the device capability and
6490 * requested operation mode.
6491 * Do not bother with non-dma mode- we are working only with
6492 * devices supporting DMA.
6493 */
6494 scmd->satacmd_addr_type = ATA_ADDR_LBA;
6495 scmd->satacmd_device_reg = SATA_ADH_LBA;
6496 scmd->satacmd_cmd_reg = SATAC_WRITE_DMA;
6497 if (sdinfo->satadrv_features_support & SATA_DEV_F_LBA48) {
6498 scmd->satacmd_addr_type = ATA_ADDR_LBA48;
6499 scmd->satacmd_cmd_reg = SATAC_WRITE_DMA_EXT;
6500 scmd->satacmd_sec_count_msb = sec_count >> 8;
6501 scmd->satacmd_lba_low_msb = (lba >> 24) & 0xff;
6502 #ifndef __lock_lint
6503 scmd->satacmd_lba_mid_msb = (lba >> 32) & 0xff;
6504 scmd->satacmd_lba_high_msb = lba >> 40;
6505 #endif
6506 } else if (sdinfo->satadrv_features_support & SATA_DEV_F_LBA28) {
6507 scmd->satacmd_addr_type = ATA_ADDR_LBA28;
6508 scmd->satacmd_device_reg = SATA_ADH_LBA | ((lba >> 24) & 0xf);
6509 }
6510 scmd->satacmd_sec_count_lsb = sec_count & 0xff;
6511 scmd->satacmd_lba_low_lsb = lba & 0xff;
6512 scmd->satacmd_lba_mid_lsb = (lba >> 8) & 0xff;
6513 scmd->satacmd_lba_high_lsb = (lba >> 16) & 0xff;
6514 scmd->satacmd_features_reg = 0;
6515 scmd->satacmd_status_reg = 0;
6516 scmd->satacmd_error_reg = 0;
6517
6518 /*
6519 * Check if queueing commands should be used and switch
6520 * to appropriate command if possible
6521 */
6522 if (sata_func_enable & SATA_ENABLE_QUEUING) {
6523 boolean_t using_queuing;
6524
6525 /* Queuing supported by controller and device? */
6526 if ((sata_func_enable & SATA_ENABLE_NCQ) &&
6527 (sdinfo->satadrv_features_support &
6528 SATA_DEV_F_NCQ) &&
6529 (SATA_FEATURES(spx->txlt_sata_hba_inst) &
6530 SATA_CTLF_NCQ)) {
6531 using_queuing = B_TRUE;
6532
6533 /* NCQ supported - use FPDMA WRITE */
6534 scmd->satacmd_cmd_reg =
6535 SATAC_WRITE_FPDMA_QUEUED;
6536 scmd->satacmd_features_reg_ext =
6537 scmd->satacmd_sec_count_msb;
6538 scmd->satacmd_sec_count_msb = 0;
6539 } else if ((sdinfo->satadrv_features_support &
6540 SATA_DEV_F_TCQ) &&
6541 (SATA_FEATURES(spx->txlt_sata_hba_inst) &
6542 SATA_CTLF_QCMD)) {
6543 using_queuing = B_TRUE;
6544
6545 /* Legacy queueing */
6546 if (sdinfo->satadrv_features_support &
6547 SATA_DEV_F_LBA48) {
6548 scmd->satacmd_cmd_reg =
6549 SATAC_WRITE_DMA_QUEUED_EXT;
6550 scmd->satacmd_features_reg_ext =
6551 scmd->satacmd_sec_count_msb;
6552 scmd->satacmd_sec_count_msb = 0;
6553 } else {
6554 scmd->satacmd_cmd_reg =
6555 SATAC_WRITE_DMA_QUEUED;
6556 }
6557 } else /* NCQ nor legacy queuing not supported */
6558 using_queuing = B_FALSE;
6559
6560 if (using_queuing) {
6561 scmd->satacmd_features_reg =
6562 scmd->satacmd_sec_count_lsb;
6563 scmd->satacmd_sec_count_lsb = 0;
6564 scmd->satacmd_flags.sata_queued = B_TRUE;
6565 /* Set-up maximum queue depth */
6566 scmd->satacmd_flags.sata_max_queue_depth =
6567 sdinfo->satadrv_max_queue_depth - 1;
6568 } else if (sdinfo->satadrv_features_enabled &
6569 SATA_DEV_F_E_UNTAGGED_QING) {
6570 /*
6571 * Although NCQ/TCQ is not enabled, untagged queuing
6572 * may be still used.
6573 * Set-up the maximum untagged queue depth.
6574 * Use controller's queue depth from sata_hba_tran.
6575 * SATA HBA drivers may ignore this value and rely on
6576 * the internal limits. For drivera that do not
6577 * ignore untaged queue depth, limit the value to
6578 * SATA_MAX_QUEUE_DEPTH (32), as this is the
6579 * largest value that can be passed via
6580 * satacmd_flags.sata_max_queue_depth.
6581 */
6582 scmd->satacmd_flags.sata_max_queue_depth =
6583 SATA_QDEPTH(shi) <= SATA_MAX_QUEUE_DEPTH ?
6584 SATA_QDEPTH(shi) - 1: SATA_MAX_QUEUE_DEPTH - 1;
6585
6586 } else {
6587 scmd->satacmd_flags.sata_max_queue_depth = 0;
6588 }
6589 } else
6590 scmd->satacmd_flags.sata_max_queue_depth = 0;
6591
6592 SATADBG3(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst,
6593 "sata_txlt_write cmd 0x%2x, lba %llx, sec count %x\n",
6594 scmd->satacmd_cmd_reg, lba, sec_count);
6595
6596 if (!(spx->txlt_sata_pkt->satapkt_op_mode & SATA_OPMODE_SYNCH)) {
6597 /* Need callback function */
6598 spx->txlt_sata_pkt->satapkt_comp = sata_txlt_rw_completion;
6599 synch = FALSE;
6600 } else
6601 synch = TRUE;
6602
6603 /* Transfer command to HBA */
6604 if (sata_hba_start(spx, &rval) != 0) {
6605 /* Pkt not accepted for execution */
6606 mutex_exit(cport_mutex);
6607 return (rval);
6608 }
6609 mutex_exit(cport_mutex);
6610
6611 /*
6612 * If execution is non-synchronous,
6613 * a callback function will handle potential errors, translate
6614 * the response and will do a callback to a target driver.
6615 * If it was synchronous, check execution status using the same
6616 * framework callback.
6617 */
6618 if (synch) {
6619 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst,
6620 "synchronous execution status %x\n",
6621 spx->txlt_sata_pkt->satapkt_reason);
6622 sata_txlt_rw_completion(spx->txlt_sata_pkt);
6623 }
6624 return (TRAN_ACCEPT);
6625 }
6626
6627
6628 /*
6629 * Implements SCSI SBC WRITE BUFFER command download microcode option
6630 */
6631 static int
6632 sata_txlt_write_buffer(sata_pkt_txlate_t *spx)
6633 {
6634 #define WB_DOWNLOAD_MICROCODE_AND_REVERT_MODE 4
6635 #define WB_DOWNLOAD_MICROCODE_AND_SAVE_MODE 5
6636
6637 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt;
6638 struct sata_pkt *sata_pkt = spx->txlt_sata_pkt;
6639 sata_cmd_t *scmd = &spx->txlt_sata_pkt->satapkt_cmd;
6640
6641 struct buf *bp = spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp;
6642 struct scsi_extended_sense *sense;
6643 int rval, mode, sector_count, reason;
6644 kmutex_t *cport_mutex = &(SATA_TXLT_CPORT_MUTEX(spx));
6645
6646 mode = scsipkt->pkt_cdbp[1] & 0x1f;
6647
6648 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst,
6649 "sata_txlt_write_buffer, mode 0x%x\n", mode);
6650
6651 mutex_enter(cport_mutex);
6652
6653 if ((rval = sata_txlt_generic_pkt_info(spx, &reason, 1)) !=
6654 TRAN_ACCEPT) {
6655 mutex_exit(cport_mutex);
6656 return (rval);
6657 }
6658
6659 /* Use synchronous mode */
6660 spx->txlt_sata_pkt->satapkt_op_mode
6661 |= SATA_OPMODE_SYNCH | SATA_OPMODE_INTERRUPTS;
6662
6663 scmd->satacmd_flags.sata_data_direction = SATA_DIR_WRITE;
6664
6665 scsipkt->pkt_reason = CMD_CMPLT;
6666 scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET |
6667 STATE_SENT_CMD | STATE_GOT_STATUS;
6668
6669 /*
6670 * The SCSI to ATA translation specification only calls
6671 * for WB_DOWNLOAD_MICROCODE_AND_SAVE_MODE.
6672 * WB_DOWNLOAD_MICROC_AND_REVERT_MODE is implemented, but
6673 * ATA 8 (draft) got rid of download microcode for temp
6674 * and it is even optional for ATA 7, so it may be aborted.
6675 * WB_DOWNLOAD_MICROCODE_WITH_OFFSET is not implemented as
6676 * it is not specified and the buffer offset for SCSI is a 16-bit
6677 * value in bytes, but for ATA it is a 16-bit offset in 512 byte
6678 * sectors. Thus the offset really doesn't buy us anything.
6679 * If and when ATA 8 is stabilized and the SCSI to ATA specification
6680 * is revised, this can be revisisted.
6681 */
6682 /* Reject not supported request */
6683 switch (mode) {
6684 case WB_DOWNLOAD_MICROCODE_AND_REVERT_MODE:
6685 scmd->satacmd_features_reg = SATA_DOWNLOAD_MCODE_TEMP;
6686 break;
6687 case WB_DOWNLOAD_MICROCODE_AND_SAVE_MODE:
6688 scmd->satacmd_features_reg = SATA_DOWNLOAD_MCODE_SAVE;
6689 break;
6690 default:
6691 goto bad_param;
6692 }
6693
6694 *scsipkt->pkt_scbp = STATUS_GOOD; /* Presumed outcome */
6695
6696 scmd->satacmd_cmd_reg = SATAC_DOWNLOAD_MICROCODE;
6697 if ((bp->b_bcount % SATA_DISK_SECTOR_SIZE) != 0)
6698 goto bad_param;
6699 sector_count = bp->b_bcount / SATA_DISK_SECTOR_SIZE;
6700 scmd->satacmd_sec_count_lsb = (uint8_t)sector_count;
6701 scmd->satacmd_lba_low_lsb = ((uint16_t)sector_count) >> 8;
6702 scmd->satacmd_lba_mid_lsb = 0;
6703 scmd->satacmd_lba_high_lsb = 0;
6704 scmd->satacmd_device_reg = 0;
6705 spx->txlt_sata_pkt->satapkt_comp = NULL;
6706 scmd->satacmd_addr_type = 0;
6707
6708 /* Transfer command to HBA */
6709 if (sata_hba_start(spx, &rval) != 0) {
6710 /* Pkt not accepted for execution */
6711 mutex_exit(cport_mutex);
6712 return (rval);
6713 }
6714
6715 mutex_exit(cport_mutex);
6716
6717 /* Then we need synchronous check the status of the disk */
6718 scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET |
6719 STATE_SENT_CMD | STATE_XFERRED_DATA | STATE_GOT_STATUS;
6720 if (sata_pkt->satapkt_reason == SATA_PKT_COMPLETED) {
6721 scsipkt->pkt_reason = CMD_CMPLT;
6722
6723 /* Download commmand succeed, so probe and identify device */
6724 sata_reidentify_device(spx);
6725 } else {
6726 /* Something went wrong, microcode download command failed */
6727 scsipkt->pkt_reason = CMD_INCOMPLETE;
6728 *scsipkt->pkt_scbp = STATUS_CHECK;
6729 sense = sata_arq_sense(spx);
6730 switch (sata_pkt->satapkt_reason) {
6731 case SATA_PKT_PORT_ERROR:
6732 /*
6733 * We have no device data. Assume no data transfered.
6734 */
6735 sense->es_key = KEY_HARDWARE_ERROR;
6736 break;
6737
6738 case SATA_PKT_DEV_ERROR:
6739 if (sata_pkt->satapkt_cmd.satacmd_status_reg &
6740 SATA_STATUS_ERR) {
6741 /*
6742 * determine dev error reason from error
6743 * reg content
6744 */
6745 sata_decode_device_error(spx, sense);
6746 break;
6747 }
6748 /* No extended sense key - no info available */
6749 break;
6750
6751 case SATA_PKT_TIMEOUT:
6752 scsipkt->pkt_reason = CMD_TIMEOUT;
6753 scsipkt->pkt_statistics |=
6754 STAT_TIMEOUT | STAT_DEV_RESET;
6755 /* No extended sense key ? */
6756 break;
6757
6758 case SATA_PKT_ABORTED:
6759 scsipkt->pkt_reason = CMD_ABORTED;
6760 scsipkt->pkt_statistics |= STAT_ABORTED;
6761 /* No extended sense key ? */
6762 break;
6763
6764 case SATA_PKT_RESET:
6765 /* pkt aborted by an explicit reset from a host */
6766 scsipkt->pkt_reason = CMD_RESET;
6767 scsipkt->pkt_statistics |= STAT_DEV_RESET;
6768 break;
6769
6770 default:
6771 SATA_LOG_D((spx->txlt_sata_hba_inst, CE_WARN,
6772 "sata_txlt_nodata_cmd_completion: "
6773 "invalid packet completion reason %d",
6774 sata_pkt->satapkt_reason));
6775 scsipkt->pkt_reason = CMD_TRAN_ERR;
6776 break;
6777 }
6778
6779 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst,
6780 "scsi_pkt completion reason %x\n", scsipkt->pkt_reason);
6781
6782 if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0)
6783 /* scsi callback required */
6784 scsi_hba_pkt_comp(scsipkt);
6785 }
6786 return (TRAN_ACCEPT);
6787
6788 bad_param:
6789 mutex_exit(cport_mutex);
6790 *scsipkt->pkt_scbp = STATUS_CHECK;
6791 sense = sata_arq_sense(spx);
6792 sense->es_key = KEY_ILLEGAL_REQUEST;
6793 sense->es_add_code = SD_SCSI_ASC_INVALID_FIELD_IN_CDB;
6794 if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0 &&
6795 scsipkt->pkt_comp != NULL) {
6796 /* scsi callback required */
6797 if (servicing_interrupt()) {
6798 if (taskq_dispatch(SATA_TXLT_TASKQ(spx),
6799 (task_func_t *)spx->txlt_scsi_pkt->pkt_comp,
6800 (void *)spx->txlt_scsi_pkt, TQ_NOSLEEP) == NULL) {
6801 return (TRAN_BUSY);
6802 }
6803 } else if (taskq_dispatch(SATA_TXLT_TASKQ(spx),
6804 (task_func_t *)spx->txlt_scsi_pkt->pkt_comp,
6805 (void *)spx->txlt_scsi_pkt, TQ_SLEEP) == NULL) {
6806 /* Scheduling the callback failed */
6807 return (TRAN_BUSY);
6808 }
6809 }
6810 return (rval);
6811 }
6812
6813 /*
6814 * Re-identify device after doing a firmware download.
6815 */
6816 static void
6817 sata_reidentify_device(sata_pkt_txlate_t *spx)
6818 {
6819 #define DOWNLOAD_WAIT_TIME_SECS 60
6820 #define DOWNLOAD_WAIT_INTERVAL_SECS 1
6821 int rval;
6822 int retry_cnt;
6823 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt;
6824 sata_hba_inst_t *sata_hba_inst = spx->txlt_sata_hba_inst;
6825 sata_device_t sata_device = spx->txlt_sata_pkt->satapkt_device;
6826 sata_drive_info_t *sdinfo;
6827
6828 /*
6829 * Before returning good status, probe device.
6830 * Device probing will get IDENTIFY DEVICE data, if possible.
6831 * The assumption is that the new microcode is applied by the
6832 * device. It is a caller responsibility to verify this.
6833 */
6834 for (retry_cnt = 0;
6835 retry_cnt < DOWNLOAD_WAIT_TIME_SECS / DOWNLOAD_WAIT_INTERVAL_SECS;
6836 retry_cnt++) {
6837 rval = sata_probe_device(sata_hba_inst, &sata_device);
6838
6839 if (rval == SATA_SUCCESS) { /* Set default features */
6840 sdinfo = sata_get_device_info(sata_hba_inst,
6841 &sata_device);
6842 if (sata_initialize_device(sata_hba_inst, sdinfo) !=
6843 SATA_SUCCESS) {
6844 /* retry */
6845 rval = sata_initialize_device(sata_hba_inst,
6846 sdinfo);
6847 if (rval == SATA_RETRY)
6848 sata_log(sata_hba_inst, CE_WARN,
6849 "SATA device at port %d pmport %d -"
6850 " default device features could not"
6851 " be set. Device may not operate "
6852 "as expected.",
6853 sata_device.satadev_addr.cport,
6854 sata_device.satadev_addr.pmport);
6855 }
6856 if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0)
6857 scsi_hba_pkt_comp(scsipkt);
6858 return;
6859 } else if (rval == SATA_RETRY) {
6860 delay(drv_usectohz(1000000 *
6861 DOWNLOAD_WAIT_INTERVAL_SECS));
6862 continue;
6863 } else /* failed - no reason to retry */
6864 break;
6865 }
6866
6867 /*
6868 * Something went wrong, device probing failed.
6869 */
6870 SATA_LOG_D((sata_hba_inst, CE_WARN,
6871 "Cannot probe device after downloading microcode\n"));
6872
6873 /* Reset device to force retrying the probe. */
6874 (void) (*SATA_RESET_DPORT_FUNC(sata_hba_inst))
6875 (SATA_DIP(sata_hba_inst), &sata_device);
6876
6877 if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0)
6878 scsi_hba_pkt_comp(scsipkt);
6879 }
6880
6881
6882 /*
6883 * Translate command: Synchronize Cache.
6884 * Translates into Flush Cache command for SATA hard disks.
6885 *
6886 * Returns TRAN_ACCEPT or code returned by sata_hba_start() and
6887 * appropriate values in scsi_pkt fields.
6888 */
6889 static int
6890 sata_txlt_synchronize_cache(sata_pkt_txlate_t *spx)
6891 {
6892 sata_cmd_t *scmd = &spx->txlt_sata_pkt->satapkt_cmd;
6893 kmutex_t *cport_mutex = &(SATA_TXLT_CPORT_MUTEX(spx));
6894 int rval, reason;
6895 int synch;
6896
6897 mutex_enter(cport_mutex);
6898
6899 if (((rval = sata_txlt_generic_pkt_info(spx, &reason, 1)) !=
6900 TRAN_ACCEPT) || (reason == CMD_DEV_GONE)) {
6901 mutex_exit(cport_mutex);
6902 return (rval);
6903 }
6904
6905 scmd->satacmd_addr_type = 0;
6906 scmd->satacmd_cmd_reg = SATAC_FLUSH_CACHE;
6907 scmd->satacmd_device_reg = 0;
6908 scmd->satacmd_sec_count_lsb = 0;
6909 scmd->satacmd_lba_low_lsb = 0;
6910 scmd->satacmd_lba_mid_lsb = 0;
6911 scmd->satacmd_lba_high_lsb = 0;
6912 scmd->satacmd_features_reg = 0;
6913 scmd->satacmd_status_reg = 0;
6914 scmd->satacmd_error_reg = 0;
6915
6916 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst,
6917 "sata_txlt_synchronize_cache\n", NULL);
6918
6919 if (!(spx->txlt_sata_pkt->satapkt_op_mode & SATA_OPMODE_SYNCH)) {
6920 /* Need to set-up a callback function */
6921 spx->txlt_sata_pkt->satapkt_comp =
6922 sata_txlt_nodata_cmd_completion;
6923 synch = FALSE;
6924 } else
6925 synch = TRUE;
6926
6927 /* Transfer command to HBA */
6928 if (sata_hba_start(spx, &rval) != 0) {
6929 /* Pkt not accepted for execution */
6930 mutex_exit(cport_mutex);
6931 return (rval);
6932 }
6933 mutex_exit(cport_mutex);
6934
6935 /*
6936 * If execution non-synchronous, it had to be completed
6937 * a callback function will handle potential errors, translate
6938 * the response and will do a callback to a target driver.
6939 * If it was synchronous, check status, using the same
6940 * framework callback.
6941 */
6942 if (synch) {
6943 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst,
6944 "synchronous execution status %x\n",
6945 spx->txlt_sata_pkt->satapkt_reason);
6946 sata_txlt_nodata_cmd_completion(spx->txlt_sata_pkt);
6947 }
6948 return (TRAN_ACCEPT);
6949 }
6950
6951
6952 /*
6953 * Send pkt to SATA HBA driver
6954 *
6955 * This function may be called only if the operation is requested by scsi_pkt,
6956 * i.e. scsi_pkt is not NULL.
6957 *
6958 * This function has to be called with cport mutex held. It does release
6959 * the mutex when it calls HBA driver sata_tran_start function and
6960 * re-acquires it afterwards.
6961 *
6962 * If return value is 0, pkt was accepted, -1 otherwise
6963 * rval is set to appropriate sata_scsi_start return value.
6964 *
6965 * Note 1:If HBA driver returns value other than TRAN_ACCEPT, it should not
6966 * have called the sata_pkt callback function for this packet.
6967 *
6968 * The scsi callback has to be performed by the caller of this routine.
6969 */
6970 static int
6971 sata_hba_start(sata_pkt_txlate_t *spx, int *rval)
6972 {
6973 int stat;
6974 uint8_t cport = SATA_TXLT_CPORT(spx);
6975 uint8_t pmport = SATA_TXLT_PMPORT(spx);
6976 sata_hba_inst_t *sata_hba_inst = spx->txlt_sata_hba_inst;
6977 sata_drive_info_t *sdinfo;
6978 sata_pmult_info_t *pminfo;
6979 sata_pmport_info_t *pmportinfo = NULL;
6980 sata_device_t *sata_device = NULL;
6981 uint8_t cmd;
6982 struct sata_cmd_flags cmd_flags;
6983
6984 ASSERT(spx->txlt_sata_pkt != NULL);
6985
6986 ASSERT(mutex_owned(&SATA_CPORT_MUTEX(sata_hba_inst, cport)));
6987
6988 sdinfo = sata_get_device_info(sata_hba_inst,
6989 &spx->txlt_sata_pkt->satapkt_device);
6990 ASSERT(sdinfo != NULL);
6991
6992 /* Clear device reset state? */
6993 /* qual should be XXX_DPMPORT, but add XXX_PMPORT in case */
6994 if (sdinfo->satadrv_addr.qual == SATA_ADDR_DPMPORT ||
6995 sdinfo->satadrv_addr.qual == SATA_ADDR_PMPORT) {
6996
6997 /*
6998 * Get the pmult_info of the its parent port multiplier, all
6999 * sub-devices share a common device reset flags on in
7000 * pmult_info.
7001 */
7002 pminfo = SATA_PMULT_INFO(sata_hba_inst, cport);
7003 pmportinfo = pminfo->pmult_dev_port[pmport];
7004 ASSERT(pminfo != NULL);
7005 if (pminfo->pmult_event_flags & SATA_EVNT_CLEAR_DEVICE_RESET) {
7006 spx->txlt_sata_pkt->satapkt_cmd.satacmd_flags.
7007 sata_clear_dev_reset = B_TRUE;
7008 pminfo->pmult_event_flags &=
7009 ~SATA_EVNT_CLEAR_DEVICE_RESET;
7010 SATADBG1(SATA_DBG_EVENTS, sata_hba_inst,
7011 "sata_hba_start: clearing device reset state"
7012 "on pmult.\n", NULL);
7013 }
7014 } else {
7015 if (sdinfo->satadrv_event_flags &
7016 SATA_EVNT_CLEAR_DEVICE_RESET) {
7017 spx->txlt_sata_pkt->satapkt_cmd.satacmd_flags.
7018 sata_clear_dev_reset = B_TRUE;
7019 sdinfo->satadrv_event_flags &=
7020 ~SATA_EVNT_CLEAR_DEVICE_RESET;
7021 SATADBG1(SATA_DBG_EVENTS, sata_hba_inst,
7022 "sata_hba_start: clearing device reset state\n",
7023 NULL);
7024 }
7025 }
7026
7027 cmd = spx->txlt_sata_pkt->satapkt_cmd.satacmd_cmd_reg;
7028 cmd_flags = spx->txlt_sata_pkt->satapkt_cmd.satacmd_flags;
7029 sata_device = &spx->txlt_sata_pkt->satapkt_device;
7030
7031 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, cport)));
7032
7033 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst,
7034 "Sata cmd 0x%2x\n", cmd);
7035
7036 stat = (*SATA_START_FUNC(sata_hba_inst))(SATA_DIP(sata_hba_inst),
7037 spx->txlt_sata_pkt);
7038 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, cport)));
7039 /*
7040 * If sata pkt was accepted and executed in asynchronous mode, i.e.
7041 * with the sata callback, the sata_pkt could be already destroyed
7042 * by the time we check ther return status from the hba_start()
7043 * function, because sata_scsi_destroy_pkt() could have been already
7044 * called (perhaps in the interrupt context). So, in such case, there
7045 * should be no references to it. In other cases, sata_pkt still
7046 * exists.
7047 */
7048 if (stat == SATA_TRAN_ACCEPTED) {
7049 /*
7050 * pkt accepted for execution.
7051 * If it was executed synchronously, it is already completed
7052 * and pkt completion_reason indicates completion status.
7053 */
7054 *rval = TRAN_ACCEPT;
7055 return (0);
7056 }
7057
7058 sdinfo = sata_get_device_info(sata_hba_inst, sata_device);
7059 switch (stat) {
7060 case SATA_TRAN_QUEUE_FULL:
7061 /*
7062 * Controller detected queue full condition.
7063 */
7064 SATADBG1(SATA_DBG_HBA_IF, sata_hba_inst,
7065 "sata_hba_start: queue full\n", NULL);
7066
7067 spx->txlt_scsi_pkt->pkt_reason = CMD_INCOMPLETE;
7068 *spx->txlt_scsi_pkt->pkt_scbp = STATUS_QFULL;
7069
7070 *rval = TRAN_BUSY;
7071 break;
7072
7073 case SATA_TRAN_PORT_ERROR:
7074 /*
7075 * Communication/link with device or general port error
7076 * detected before pkt execution begun.
7077 */
7078 if (spx->txlt_sata_pkt->satapkt_device.satadev_addr.qual ==
7079 SATA_ADDR_CPORT ||
7080 spx->txlt_sata_pkt->satapkt_device.satadev_addr.qual ==
7081 SATA_ADDR_DCPORT)
7082 sata_log(sata_hba_inst, CE_CONT,
7083 "SATA port %d error",
7084 sata_device->satadev_addr.cport);
7085 else
7086 sata_log(sata_hba_inst, CE_CONT,
7087 "SATA port %d:%d error\n",
7088 sata_device->satadev_addr.cport,
7089 sata_device->satadev_addr.pmport);
7090
7091 /*
7092 * Update the port/device structure.
7093 * sata_pkt should be still valid. Since port error is
7094 * returned, sata_device content should reflect port
7095 * state - it means, that sata address have been changed,
7096 * because original packet's sata address refered to a device
7097 * attached to some port.
7098 */
7099 if (sata_device->satadev_addr.qual == SATA_ADDR_DPMPORT ||
7100 sata_device->satadev_addr.qual == SATA_ADDR_PMPORT) {
7101 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, cport)));
7102 mutex_enter(&pmportinfo->pmport_mutex);
7103 sata_update_pmport_info(sata_hba_inst, sata_device);
7104 mutex_exit(&pmportinfo->pmport_mutex);
7105 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, cport)));
7106 } else {
7107 sata_update_port_info(sata_hba_inst, sata_device);
7108 }
7109
7110 spx->txlt_scsi_pkt->pkt_reason = CMD_TRAN_ERR;
7111 *rval = TRAN_FATAL_ERROR;
7112 break;
7113
7114 case SATA_TRAN_CMD_UNSUPPORTED:
7115 /*
7116 * Command rejected by HBA as unsupported. It was HBA driver
7117 * that rejected the command, command was not sent to
7118 * an attached device.
7119 */
7120 if ((sdinfo != NULL) &&
7121 (sdinfo->satadrv_state & SATA_DSTATE_RESET))
7122 SATADBG1(SATA_DBG_EVENTS, sata_hba_inst,
7123 "sat_hba_start: cmd 0x%2x rejected "
7124 "with SATA_TRAN_CMD_UNSUPPORTED status\n", cmd);
7125
7126 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, cport)));
7127 (void) sata_txlt_invalid_command(spx);
7128 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, cport)));
7129
7130 *rval = TRAN_ACCEPT;
7131 break;
7132
7133 case SATA_TRAN_BUSY:
7134 /*
7135 * Command rejected by HBA because other operation prevents
7136 * accepting the packet, or device is in RESET condition.
7137 */
7138 if (sdinfo != NULL) {
7139 sdinfo->satadrv_state =
7140 spx->txlt_sata_pkt->satapkt_device.satadev_state;
7141
7142 if (sdinfo->satadrv_state & SATA_DSTATE_RESET) {
7143 SATADBG1(SATA_DBG_EVENTS, sata_hba_inst,
7144 "sata_hba_start: cmd 0x%2x rejected "
7145 "because of device reset condition\n",
7146 cmd);
7147 } else {
7148 SATADBG1(SATA_DBG_EVENTS, sata_hba_inst,
7149 "sata_hba_start: cmd 0x%2x rejected "
7150 "with SATA_TRAN_BUSY status\n",
7151 cmd);
7152 }
7153 }
7154 spx->txlt_scsi_pkt->pkt_reason = CMD_INCOMPLETE;
7155 *rval = TRAN_BUSY;
7156 break;
7157
7158 default:
7159 /* Unrecognized HBA response */
7160 SATA_LOG_D((sata_hba_inst, CE_WARN,
7161 "sata_hba_start: unrecognized HBA response "
7162 "to cmd : 0x%2x resp 0x%x", cmd, rval));
7163 spx->txlt_scsi_pkt->pkt_reason = CMD_TRAN_ERR;
7164 *rval = TRAN_FATAL_ERROR;
7165 break;
7166 }
7167
7168 /*
7169 * If we got here, the packet was rejected.
7170 * Check if we need to remember reset state clearing request
7171 */
7172 if (cmd_flags.sata_clear_dev_reset) {
7173 /*
7174 * Check if device is still configured - it may have
7175 * disapeared from the configuration
7176 */
7177 sdinfo = sata_get_device_info(sata_hba_inst, sata_device);
7178 if (sdinfo != NULL) {
7179 /*
7180 * Restore the flag that requests clearing of
7181 * the device reset state,
7182 * so the next sata packet may carry it to HBA.
7183 */
7184 if (sdinfo->satadrv_addr.qual == SATA_ADDR_PMPORT ||
7185 sdinfo->satadrv_addr.qual == SATA_ADDR_DPMPORT) {
7186 pminfo->pmult_event_flags |=
7187 SATA_EVNT_CLEAR_DEVICE_RESET;
7188 } else {
7189 sdinfo->satadrv_event_flags |=
7190 SATA_EVNT_CLEAR_DEVICE_RESET;
7191 }
7192 }
7193 }
7194 return (-1);
7195 }
7196
7197 /*
7198 * Scsi response setup for invalid LBA
7199 *
7200 * Returns TRAN_ACCEPT and appropriate values in scsi_pkt fields.
7201 */
7202 static int
7203 sata_txlt_lba_out_of_range(sata_pkt_txlate_t *spx)
7204 {
7205 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt;
7206 struct scsi_extended_sense *sense;
7207
7208 scsipkt->pkt_reason = CMD_CMPLT;
7209 scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET |
7210 STATE_SENT_CMD | STATE_GOT_STATUS;
7211 *scsipkt->pkt_scbp = STATUS_CHECK;
7212
7213 *scsipkt->pkt_scbp = STATUS_CHECK;
7214 sense = sata_arq_sense(spx);
7215 sense->es_key = KEY_ILLEGAL_REQUEST;
7216 sense->es_add_code = SD_SCSI_ASC_LBA_OUT_OF_RANGE;
7217
7218 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst,
7219 "Scsi_pkt completion reason %x\n", scsipkt->pkt_reason);
7220
7221 if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0 &&
7222 scsipkt->pkt_comp != NULL) {
7223 /* scsi callback required */
7224 if (servicing_interrupt()) {
7225 if (taskq_dispatch(SATA_TXLT_TASKQ(spx),
7226 (task_func_t *)spx->txlt_scsi_pkt->pkt_comp,
7227 (void *)spx->txlt_scsi_pkt, TQ_NOSLEEP) == NULL) {
7228 return (TRAN_BUSY);
7229 }
7230 } else if (taskq_dispatch(SATA_TXLT_TASKQ(spx),
7231 (task_func_t *)spx->txlt_scsi_pkt->pkt_comp,
7232 (void *)spx->txlt_scsi_pkt, TQ_SLEEP) == NULL) {
7233 /* Scheduling the callback failed */
7234 return (TRAN_BUSY);
7235 }
7236 }
7237 return (TRAN_ACCEPT);
7238 }
7239
7240
7241 /*
7242 * Analyze device status and error registers and translate them into
7243 * appropriate scsi sense codes.
7244 * NOTE: non-packet commands only for now
7245 */
7246 static void
7247 sata_decode_device_error(sata_pkt_txlate_t *spx,
7248 struct scsi_extended_sense *sense)
7249 {
7250 uint8_t err_reg = spx->txlt_sata_pkt->satapkt_cmd.satacmd_error_reg;
7251
7252 ASSERT(sense != NULL);
7253 ASSERT(spx->txlt_sata_pkt->satapkt_cmd.satacmd_status_reg &
7254 SATA_STATUS_ERR);
7255
7256
7257 if (err_reg & SATA_ERROR_ICRC) {
7258 sense->es_key = KEY_ABORTED_COMMAND;
7259 sense->es_add_code = 0x08; /* Communication failure */
7260 return;
7261 }
7262
7263 if (err_reg & SATA_ERROR_UNC) {
7264 sense->es_key = KEY_MEDIUM_ERROR;
7265 /* Information bytes (LBA) need to be set by a caller */
7266 return;
7267 }
7268
7269 /* ADD HERE: MC error bit handling for ATAPI CD/DVD */
7270 if (err_reg & (SATA_ERROR_MCR | SATA_ERROR_NM)) {
7271 sense->es_key = KEY_UNIT_ATTENTION;
7272 sense->es_add_code = 0x3a; /* No media present */
7273 return;
7274 }
7275
7276 if (err_reg & SATA_ERROR_IDNF) {
7277 if (err_reg & SATA_ERROR_ABORT) {
7278 sense->es_key = KEY_ABORTED_COMMAND;
7279 } else {
7280 sense->es_key = KEY_ILLEGAL_REQUEST;
7281 sense->es_add_code = 0x21; /* LBA out of range */
7282 }
7283 return;
7284 }
7285
7286 if (err_reg & SATA_ERROR_ABORT) {
7287 ASSERT(spx->txlt_sata_pkt != NULL);
7288 sense->es_key = KEY_ABORTED_COMMAND;
7289 return;
7290 }
7291 }
7292
7293 /*
7294 * Extract error LBA from sata_pkt.satapkt_cmd register fields
7295 */
7296 static void
7297 sata_extract_error_lba(sata_pkt_txlate_t *spx, uint64_t *lba)
7298 {
7299 sata_cmd_t *sata_cmd = &spx->txlt_sata_pkt->satapkt_cmd;
7300
7301 *lba = 0;
7302 if (sata_cmd->satacmd_addr_type == ATA_ADDR_LBA48) {
7303 *lba = sata_cmd->satacmd_lba_high_msb;
7304 *lba = (*lba << 8) | sata_cmd->satacmd_lba_mid_msb;
7305 *lba = (*lba << 8) | sata_cmd->satacmd_lba_low_msb;
7306 } else if (sata_cmd->satacmd_addr_type == ATA_ADDR_LBA28) {
7307 *lba = sata_cmd->satacmd_device_reg & 0xf;
7308 }
7309 *lba = (*lba << 8) | sata_cmd->satacmd_lba_high_lsb;
7310 *lba = (*lba << 8) | sata_cmd->satacmd_lba_mid_lsb;
7311 *lba = (*lba << 8) | sata_cmd->satacmd_lba_low_lsb;
7312 }
7313
7314 /*
7315 * This is fixed sense format - if LBA exceeds the info field size,
7316 * no valid info will be returned (valid bit in extended sense will
7317 * be set to 0).
7318 */
7319 static struct scsi_extended_sense *
7320 sata_arq_sense(sata_pkt_txlate_t *spx)
7321 {
7322 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt;
7323 struct scsi_arq_status *arqs;
7324 struct scsi_extended_sense *sense;
7325
7326 /* Fill ARQ sense data */
7327 scsipkt->pkt_state |= STATE_ARQ_DONE;
7328 arqs = (struct scsi_arq_status *)scsipkt->pkt_scbp;
7329 *(uchar_t *)&arqs->sts_status = STATUS_CHECK;
7330 *(uchar_t *)&arqs->sts_rqpkt_status = STATUS_GOOD;
7331 arqs->sts_rqpkt_reason = CMD_CMPLT;
7332 arqs->sts_rqpkt_state = STATE_GOT_BUS | STATE_GOT_TARGET |
7333 STATE_XFERRED_DATA | STATE_SENT_CMD | STATE_GOT_STATUS;
7334 arqs->sts_rqpkt_resid = 0;
7335 sense = &arqs->sts_sensedata;
7336 bzero(sense, sizeof (struct scsi_extended_sense));
7337 sata_fixed_sense_data_preset(sense);
7338 return (sense);
7339 }
7340
7341 /*
7342 * ATA Pass Through support
7343 * Sets flags indicating that an invalid value was found in some
7344 * field in the command. It could be something illegal according to
7345 * the SAT-2 spec or it could be a feature that is not (yet?)
7346 * supported.
7347 */
7348 static int
7349 sata_txlt_ata_pass_thru_illegal_cmd(sata_pkt_txlate_t *spx)
7350 {
7351 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt;
7352 struct scsi_extended_sense *sense = sata_arq_sense(spx);
7353
7354 scsipkt->pkt_reason = CMD_CMPLT;
7355 *scsipkt->pkt_scbp = STATUS_CHECK;
7356 scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET |
7357 STATE_SENT_CMD | STATE_GOT_STATUS;
7358
7359 sense = sata_arq_sense(spx);
7360 sense->es_key = KEY_ILLEGAL_REQUEST;
7361 sense->es_add_code = SD_SCSI_ASC_INVALID_FIELD_IN_CDB;
7362
7363 if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0 &&
7364 scsipkt->pkt_comp != NULL) {
7365 /* scsi callback required */
7366 if (servicing_interrupt()) {
7367 if (taskq_dispatch(SATA_TXLT_TASKQ(spx),
7368 (task_func_t *)spx->txlt_scsi_pkt->pkt_comp,
7369 (void *)spx->txlt_scsi_pkt, TQ_NOSLEEP) == NULL) {
7370 return (TRAN_BUSY);
7371 }
7372 } else if (taskq_dispatch(SATA_TXLT_TASKQ(spx),
7373 (task_func_t *)spx->txlt_scsi_pkt->pkt_comp,
7374 (void *)spx->txlt_scsi_pkt, TQ_SLEEP) == NULL) {
7375 /* Scheduling the callback failed */
7376 return (TRAN_BUSY);
7377 }
7378 }
7379
7380 return (TRAN_ACCEPT);
7381 }
7382
7383 /*
7384 * The UNMAP command considers it not to be an error if the parameter length
7385 * or block descriptor length is 0. For this case, there is nothing for TRIM
7386 * to do so just complete the command.
7387 */
7388 static int
7389 sata_txlt_unmap_nodata_cmd(sata_pkt_txlate_t *spx)
7390 {
7391 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt;
7392
7393 scsipkt->pkt_reason = CMD_CMPLT;
7394 *scsipkt->pkt_scbp = STATUS_GOOD;
7395 scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET |
7396 STATE_SENT_CMD | STATE_GOT_STATUS;
7397
7398 if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0 &&
7399 scsipkt->pkt_comp != NULL) {
7400 /* scsi callback required */
7401 if (taskq_dispatch(SATA_TXLT_TASKQ(spx),
7402 (task_func_t *)spx->txlt_scsi_pkt->pkt_comp,
7403 (void *)spx->txlt_scsi_pkt, TQ_SLEEP) == NULL) {
7404 /* Scheduling the callback failed */
7405 return (TRAN_BUSY);
7406 }
7407 }
7408
7409 return (TRAN_ACCEPT);
7410 }
7411
7412 /*
7413 * Emulated SATA Read/Write command completion for zero-length requests.
7414 * This request always succedes, so in synchronous mode it always returns
7415 * TRAN_ACCEPT, and in non-synchronous mode it may return TRAN_BUSY if the
7416 * callback cannot be scheduled.
7417 */
7418 static int
7419 sata_emul_rw_completion(sata_pkt_txlate_t *spx)
7420 {
7421 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt;
7422
7423 scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET |
7424 STATE_SENT_CMD | STATE_GOT_STATUS;
7425 scsipkt->pkt_reason = CMD_CMPLT;
7426 *scsipkt->pkt_scbp = STATUS_GOOD;
7427 if (!(spx->txlt_sata_pkt->satapkt_op_mode & SATA_OPMODE_SYNCH)) {
7428 /* scsi callback required - have to schedule it */
7429 if (servicing_interrupt()) {
7430 if (taskq_dispatch(SATA_TXLT_TASKQ(spx),
7431 (task_func_t *)spx->txlt_scsi_pkt->pkt_comp,
7432 (void *)spx->txlt_scsi_pkt, TQ_NOSLEEP) == NULL) {
7433 return (TRAN_BUSY);
7434 }
7435 } else if (taskq_dispatch(SATA_TXLT_TASKQ(spx),
7436 (task_func_t *)spx->txlt_scsi_pkt->pkt_comp,
7437 (void *)spx->txlt_scsi_pkt, TQ_SLEEP) == NULL) {
7438 /* Scheduling the callback failed */
7439 return (TRAN_BUSY);
7440 }
7441 }
7442 return (TRAN_ACCEPT);
7443 }
7444
7445
7446 /*
7447 * Translate completion status of SATA read/write commands into scsi response.
7448 * pkt completion_reason is checked to determine the completion status.
7449 * Do scsi callback if necessary.
7450 *
7451 * Note: this function may be called also for synchronously executed
7452 * commands.
7453 * This function may be used only if scsi_pkt is non-NULL.
7454 */
7455 static void
7456 sata_txlt_rw_completion(sata_pkt_t *sata_pkt)
7457 {
7458 sata_pkt_txlate_t *spx =
7459 (sata_pkt_txlate_t *)sata_pkt->satapkt_framework_private;
7460 sata_cmd_t *scmd = &sata_pkt->satapkt_cmd;
7461 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt;
7462 struct scsi_extended_sense *sense;
7463 uint64_t lba;
7464 struct buf *bp;
7465 int rval;
7466 if (sata_pkt->satapkt_reason == SATA_PKT_COMPLETED) {
7467 /* Normal completion */
7468 scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET |
7469 STATE_SENT_CMD | STATE_XFERRED_DATA | STATE_GOT_STATUS;
7470 scsipkt->pkt_reason = CMD_CMPLT;
7471 *scsipkt->pkt_scbp = STATUS_GOOD;
7472 if (spx->txlt_tmp_buf != NULL) {
7473 /* Temporary buffer was used */
7474 bp = spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp;
7475 if (bp->b_flags & B_READ) {
7476 rval = ddi_dma_sync(
7477 spx->txlt_buf_dma_handle, 0, 0,
7478 DDI_DMA_SYNC_FORCPU);
7479 ASSERT(rval == DDI_SUCCESS);
7480 bcopy(spx->txlt_tmp_buf, bp->b_un.b_addr,
7481 bp->b_bcount);
7482 }
7483 }
7484 } else {
7485 /*
7486 * Something went wrong - analyze return
7487 */
7488 scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET |
7489 STATE_SENT_CMD | STATE_GOT_STATUS;
7490 scsipkt->pkt_reason = CMD_INCOMPLETE;
7491 *scsipkt->pkt_scbp = STATUS_CHECK;
7492 sense = sata_arq_sense(spx);
7493 ASSERT(sense != NULL);
7494
7495 /*
7496 * SATA_PKT_DEV_ERROR is the only case where we may be able to
7497 * extract from device registers the failing LBA.
7498 */
7499 if (sata_pkt->satapkt_reason == SATA_PKT_DEV_ERROR) {
7500 if ((scmd->satacmd_addr_type == ATA_ADDR_LBA48) &&
7501 (scmd->satacmd_lba_mid_msb != 0 ||
7502 scmd->satacmd_lba_high_msb != 0)) {
7503 /*
7504 * We have problem reporting this cmd LBA
7505 * in fixed sense data format, because of
7506 * the size of the scsi LBA fields.
7507 */
7508 sense->es_valid = 0;
7509 } else {
7510 sata_extract_error_lba(spx, &lba);
7511 sense->es_info_1 = (lba & 0xFF000000) >> 24;
7512 sense->es_info_2 = (lba & 0xFF0000) >> 16;
7513 sense->es_info_3 = (lba & 0xFF00) >> 8;
7514 sense->es_info_4 = lba & 0xFF;
7515 }
7516 } else {
7517 /* Invalid extended sense info */
7518 sense->es_valid = 0;
7519 }
7520
7521 switch (sata_pkt->satapkt_reason) {
7522 case SATA_PKT_PORT_ERROR:
7523 /* We may want to handle DEV GONE state as well */
7524 /*
7525 * We have no device data. Assume no data transfered.
7526 */
7527 sense->es_key = KEY_HARDWARE_ERROR;
7528 break;
7529
7530 case SATA_PKT_DEV_ERROR:
7531 if (sata_pkt->satapkt_cmd.satacmd_status_reg &
7532 SATA_STATUS_ERR) {
7533 /*
7534 * determine dev error reason from error
7535 * reg content
7536 */
7537 sata_decode_device_error(spx, sense);
7538 if (sense->es_key == KEY_MEDIUM_ERROR) {
7539 switch (scmd->satacmd_cmd_reg) {
7540 case SATAC_READ_DMA:
7541 case SATAC_READ_DMA_EXT:
7542 case SATAC_READ_DMA_QUEUED:
7543 case SATAC_READ_DMA_QUEUED_EXT:
7544 case SATAC_READ_FPDMA_QUEUED:
7545 /* Unrecovered read error */
7546 sense->es_add_code =
7547 SD_SCSI_ASC_UNREC_READ_ERR;
7548 break;
7549 case SATAC_WRITE_DMA:
7550 case SATAC_WRITE_DMA_EXT:
7551 case SATAC_WRITE_DMA_QUEUED:
7552 case SATAC_WRITE_DMA_QUEUED_EXT:
7553 case SATAC_WRITE_FPDMA_QUEUED:
7554 /* Write error */
7555 sense->es_add_code =
7556 SD_SCSI_ASC_WRITE_ERR;
7557 break;
7558 default:
7559 /* Internal error */
7560 SATA_LOG_D((
7561 spx->txlt_sata_hba_inst,
7562 CE_WARN,
7563 "sata_txlt_rw_completion :"
7564 "internal error - invalid "
7565 "command 0x%2x",
7566 scmd->satacmd_cmd_reg));
7567 break;
7568 }
7569 }
7570 break;
7571 }
7572 /* No extended sense key - no info available */
7573 scsipkt->pkt_reason = CMD_INCOMPLETE;
7574 break;
7575
7576 case SATA_PKT_TIMEOUT:
7577 scsipkt->pkt_reason = CMD_TIMEOUT;
7578 scsipkt->pkt_statistics |=
7579 STAT_TIMEOUT | STAT_DEV_RESET;
7580 sense->es_key = KEY_ABORTED_COMMAND;
7581 break;
7582
7583 case SATA_PKT_ABORTED:
7584 scsipkt->pkt_reason = CMD_ABORTED;
7585 scsipkt->pkt_statistics |= STAT_ABORTED;
7586 sense->es_key = KEY_ABORTED_COMMAND;
7587 break;
7588
7589 case SATA_PKT_RESET:
7590 scsipkt->pkt_reason = CMD_RESET;
7591 scsipkt->pkt_statistics |= STAT_DEV_RESET;
7592 sense->es_key = KEY_ABORTED_COMMAND;
7593 break;
7594
7595 default:
7596 SATA_LOG_D((spx->txlt_sata_hba_inst, CE_WARN,
7597 "sata_txlt_rw_completion: "
7598 "invalid packet completion reason"));
7599 scsipkt->pkt_reason = CMD_TRAN_ERR;
7600 break;
7601 }
7602 }
7603 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst,
7604 "Scsi_pkt completion reason %x\n", scsipkt->pkt_reason);
7605
7606 if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0)
7607 /* scsi callback required */
7608 scsi_hba_pkt_comp(scsipkt);
7609 }
7610
7611
7612 /*
7613 * Translate completion status of non-data commands (i.e. commands returning
7614 * no data).
7615 * pkt completion_reason is checked to determine the completion status.
7616 * Do scsi callback if necessary (FLAG_NOINTR == 0)
7617 *
7618 * Note: this function may be called also for synchronously executed
7619 * commands.
7620 * This function may be used only if scsi_pkt is non-NULL.
7621 */
7622
7623 static void
7624 sata_txlt_nodata_cmd_completion(sata_pkt_t *sata_pkt)
7625 {
7626 sata_pkt_txlate_t *spx =
7627 (sata_pkt_txlate_t *)sata_pkt->satapkt_framework_private;
7628 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt;
7629
7630 sata_set_arq_data(sata_pkt);
7631
7632 if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0)
7633 /* scsi callback required */
7634 scsi_hba_pkt_comp(scsipkt);
7635 }
7636
7637 /*
7638 * Completion handler for ATA Pass Through command
7639 */
7640 static void
7641 sata_txlt_apt_completion(sata_pkt_t *sata_pkt)
7642 {
7643 sata_pkt_txlate_t *spx =
7644 (sata_pkt_txlate_t *)sata_pkt->satapkt_framework_private;
7645 sata_cmd_t *scmd = &sata_pkt->satapkt_cmd;
7646 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt;
7647 struct buf *bp;
7648 uint8_t sense_key = 0, addl_sense_code = 0, addl_sense_qual = 0;
7649
7650 if (sata_pkt->satapkt_reason == SATA_PKT_COMPLETED) {
7651 /* Normal completion */
7652 scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET |
7653 STATE_SENT_CMD | STATE_XFERRED_DATA | STATE_GOT_STATUS;
7654 scsipkt->pkt_reason = CMD_CMPLT;
7655 *scsipkt->pkt_scbp = STATUS_GOOD;
7656
7657 /*
7658 * If the command has CK_COND set
7659 */
7660 if (scsipkt->pkt_cdbp[2] & SATL_APT_BM_CK_COND) {
7661 *scsipkt->pkt_scbp = STATUS_CHECK;
7662 sata_fill_ata_return_desc(sata_pkt,
7663 KEY_RECOVERABLE_ERROR,
7664 SD_SCSI_ASC_APT_INFO_AVAIL, 0x1d);
7665 }
7666
7667 if (spx->txlt_tmp_buf != NULL) {
7668 /* Temporary buffer was used */
7669 bp = spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp;
7670 if (bp->b_flags & B_READ) {
7671 bcopy(spx->txlt_tmp_buf, bp->b_un.b_addr,
7672 bp->b_bcount);
7673 }
7674 }
7675 } else {
7676 scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET |
7677 STATE_SENT_CMD | STATE_GOT_STATUS;
7678 scsipkt->pkt_reason = CMD_INCOMPLETE;
7679 *scsipkt->pkt_scbp = STATUS_CHECK;
7680
7681 /*
7682 * If DF or ERR was set, the HBA should have copied out the
7683 * status and error registers to the satacmd structure.
7684 */
7685 if (scmd->satacmd_status_reg & SATA_STATUS_DF) {
7686 sense_key = KEY_HARDWARE_ERROR;
7687 addl_sense_code = SD_SCSI_ASC_INTERNAL_TARGET_FAILURE;
7688 addl_sense_qual = 0;
7689 } else if (scmd->satacmd_status_reg & SATA_STATUS_ERR) {
7690 if (scmd->satacmd_error_reg & SATA_ERROR_NM) {
7691 sense_key = KEY_NOT_READY;
7692 addl_sense_code =
7693 SD_SCSI_ASC_MEDIUM_NOT_PRESENT;
7694 addl_sense_qual = 0;
7695 } else if (scmd->satacmd_error_reg & SATA_ERROR_UNC) {
7696 sense_key = KEY_MEDIUM_ERROR;
7697 addl_sense_code = SD_SCSI_ASC_UNREC_READ_ERR;
7698 addl_sense_qual = 0;
7699 } else if (scmd->satacmd_error_reg & SATA_ERROR_ILI) {
7700 sense_key = KEY_DATA_PROTECT;
7701 addl_sense_code = SD_SCSI_ASC_WRITE_PROTECTED;
7702 addl_sense_qual = 0;
7703 } else if (scmd->satacmd_error_reg & SATA_ERROR_IDNF) {
7704 sense_key = KEY_ILLEGAL_REQUEST;
7705 addl_sense_code = SD_SCSI_ASC_LBA_OUT_OF_RANGE;
7706 addl_sense_qual = 0;
7707 } else if (scmd->satacmd_error_reg & SATA_ERROR_ABORT) {
7708 sense_key = KEY_ABORTED_COMMAND;
7709 addl_sense_code = SD_SCSI_ASC_NO_ADD_SENSE;
7710 addl_sense_qual = 0;
7711 } else if (scmd->satacmd_error_reg & SATA_ERROR_MC) {
7712 sense_key = KEY_UNIT_ATTENTION;
7713 addl_sense_code =
7714 SD_SCSI_ASC_MEDIUM_MAY_HAVE_CHANGED;
7715 addl_sense_qual = 0;
7716 } else if (scmd->satacmd_error_reg & SATA_ERROR_MCR) {
7717 sense_key = KEY_UNIT_ATTENTION;
7718 addl_sense_code = SD_SCSI_ASC_OP_MEDIUM_REM_REQ;
7719 addl_sense_qual = 0;
7720 } else if (scmd->satacmd_error_reg & SATA_ERROR_ICRC) {
7721 sense_key = KEY_ABORTED_COMMAND;
7722 addl_sense_code =
7723 SD_SCSI_ASC_INFO_UNIT_IUCRC_ERR;
7724 addl_sense_qual = 0;
7725 }
7726 }
7727
7728 sata_fill_ata_return_desc(sata_pkt, sense_key, addl_sense_code,
7729 addl_sense_qual);
7730 }
7731
7732 if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0)
7733 /* scsi callback required */
7734 scsi_hba_pkt_comp(scsipkt);
7735 }
7736
7737 /*
7738 * Completion handler for unmap translation command
7739 */
7740 static void
7741 sata_txlt_unmap_completion(sata_pkt_t *sata_pkt)
7742 {
7743 sata_pkt_txlate_t *spx =
7744 (sata_pkt_txlate_t *)sata_pkt->satapkt_framework_private;
7745 sata_cmd_t *scmd = &sata_pkt->satapkt_cmd;
7746 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt;
7747 struct buf *bp;
7748 uint8_t sense_key = 0, addl_sense_code = 0, addl_sense_qual = 0;
7749
7750 if (sata_pkt->satapkt_reason == SATA_PKT_COMPLETED) {
7751 /* Normal completion */
7752 scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET |
7753 STATE_SENT_CMD | STATE_XFERRED_DATA | STATE_GOT_STATUS;
7754 scsipkt->pkt_reason = CMD_CMPLT;
7755 *scsipkt->pkt_scbp = STATUS_GOOD;
7756
7757 if (spx->txlt_tmp_buf != NULL) {
7758 /* Temporary buffer was used */
7759 bp = spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp;
7760 if (bp->b_flags & B_READ) {
7761 bcopy(spx->txlt_tmp_buf, bp->b_un.b_addr,
7762 bp->b_bcount);
7763 }
7764 }
7765 } else {
7766 scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET |
7767 STATE_SENT_CMD | STATE_GOT_STATUS;
7768 scsipkt->pkt_reason = CMD_INCOMPLETE;
7769 *scsipkt->pkt_scbp = STATUS_CHECK;
7770
7771 /*
7772 * If DF or ERR was set, the HBA should have copied out the
7773 * status and error registers to the satacmd structure.
7774 */
7775 if (scmd->satacmd_status_reg & SATA_STATUS_DF) {
7776 sense_key = KEY_HARDWARE_ERROR;
7777 addl_sense_code = SD_SCSI_ASC_INTERNAL_TARGET_FAILURE;
7778 addl_sense_qual = 0;
7779 } else if (scmd->satacmd_status_reg & SATA_STATUS_ERR) {
7780 if (scmd->satacmd_error_reg & SATA_ERROR_NM) {
7781 sense_key = KEY_NOT_READY;
7782 addl_sense_code =
7783 SD_SCSI_ASC_MEDIUM_NOT_PRESENT;
7784 addl_sense_qual = 0;
7785 } else if (scmd->satacmd_error_reg & SATA_ERROR_UNC) {
7786 sense_key = KEY_MEDIUM_ERROR;
7787 addl_sense_code = SD_SCSI_ASC_WRITE_ERR;
7788 addl_sense_qual = 0;
7789 } else if (scmd->satacmd_error_reg & SATA_ERROR_ILI) {
7790 sense_key = KEY_DATA_PROTECT;
7791 addl_sense_code = SD_SCSI_ASC_WRITE_PROTECTED;
7792 addl_sense_qual = 0;
7793 } else if (scmd->satacmd_error_reg & SATA_ERROR_IDNF) {
7794 sense_key = KEY_ILLEGAL_REQUEST;
7795 addl_sense_code = SD_SCSI_ASC_LBA_OUT_OF_RANGE;
7796 addl_sense_qual = 0;
7797 } else if (scmd->satacmd_error_reg & SATA_ERROR_ABORT) {
7798 sense_key = KEY_ABORTED_COMMAND;
7799 addl_sense_code = SD_SCSI_ASC_NO_ADD_SENSE;
7800 addl_sense_qual = 0;
7801 } else if (scmd->satacmd_error_reg & SATA_ERROR_MC) {
7802 sense_key = KEY_UNIT_ATTENTION;
7803 addl_sense_code =
7804 SD_SCSI_ASC_MEDIUM_MAY_HAVE_CHANGED;
7805 addl_sense_qual = 0;
7806 } else if (scmd->satacmd_error_reg & SATA_ERROR_MCR) {
7807 sense_key = KEY_UNIT_ATTENTION;
7808 addl_sense_code = SD_SCSI_ASC_OP_MEDIUM_REM_REQ;
7809 addl_sense_qual = 0;
7810 } else if (scmd->satacmd_error_reg & SATA_ERROR_ICRC) {
7811 sense_key = KEY_ABORTED_COMMAND;
7812 addl_sense_code =
7813 SD_SCSI_ASC_INFO_UNIT_IUCRC_ERR;
7814 addl_sense_qual = 0;
7815 }
7816 }
7817
7818 sata_fill_ata_return_desc(sata_pkt, sense_key, addl_sense_code,
7819 addl_sense_qual);
7820 }
7821
7822 sata_free_local_buffer(spx);
7823
7824 if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0)
7825 /* scsi callback required */
7826 scsi_hba_pkt_comp(scsipkt);
7827 }
7828
7829 /*
7830 *
7831 */
7832 static void
7833 sata_fill_ata_return_desc(sata_pkt_t *sata_pkt, uint8_t sense_key,
7834 uint8_t addl_sense_code, uint8_t addl_sense_qual)
7835 {
7836 sata_pkt_txlate_t *spx =
7837 (sata_pkt_txlate_t *)sata_pkt->satapkt_framework_private;
7838 sata_cmd_t *scmd = &sata_pkt->satapkt_cmd;
7839 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt;
7840 struct sata_apt_sense_data *apt_sd =
7841 (struct sata_apt_sense_data *)scsipkt->pkt_scbp;
7842 struct scsi_descr_sense_hdr *sds = &(apt_sd->apt_sd_hdr);
7843 struct scsi_ata_status_ret_sense_descr *ata_ret_desc =
7844 &(apt_sd->apt_sd_sense);
7845 int extend = 0;
7846
7847 if ((scsipkt->pkt_cdbp[0] == SPC3_CMD_ATA_COMMAND_PASS_THROUGH16) &&
7848 (scsipkt->pkt_cdbp[2] & SATL_APT_BM_EXTEND))
7849 extend = 1;
7850
7851 scsipkt->pkt_state |= STATE_ARQ_DONE;
7852
7853 /* update the residual count */
7854 *(uchar_t *)&apt_sd->apt_status = STATUS_CHECK;
7855 *(uchar_t *)&apt_sd->apt_rqpkt_status = STATUS_GOOD;
7856 apt_sd->apt_rqpkt_reason = CMD_CMPLT;
7857 apt_sd->apt_rqpkt_state = STATE_GOT_BUS | STATE_GOT_TARGET |
7858 STATE_XFERRED_DATA | STATE_SENT_CMD | STATE_GOT_STATUS;
7859 apt_sd->apt_rqpkt_resid = scsipkt->pkt_scblen -
7860 sizeof (struct sata_apt_sense_data);
7861
7862 /*
7863 * Fill in the Descriptor sense header
7864 */
7865 bzero(sds, sizeof (struct scsi_descr_sense_hdr));
7866 sds->ds_code = CODE_FMT_DESCR_CURRENT;
7867 sds->ds_class = CLASS_EXTENDED_SENSE;
7868 sds->ds_key = sense_key & 0xf;
7869 sds->ds_add_code = addl_sense_code;
7870 sds->ds_qual_code = addl_sense_qual;
7871 sds->ds_addl_sense_length =
7872 sizeof (struct scsi_ata_status_ret_sense_descr);
7873
7874 /*
7875 * Fill in the ATA Return descriptor sense data
7876 */
7877 bzero(ata_ret_desc, sizeof (struct scsi_ata_status_ret_sense_descr));
7878 ata_ret_desc->ars_descr_type = DESCR_ATA_STATUS_RETURN;
7879 ata_ret_desc->ars_addl_length = 0xc;
7880 ata_ret_desc->ars_error = scmd->satacmd_error_reg;
7881 ata_ret_desc->ars_sec_count_lsb = scmd->satacmd_sec_count_lsb;
7882 ata_ret_desc->ars_lba_low_lsb = scmd->satacmd_lba_low_lsb;
7883 ata_ret_desc->ars_lba_mid_lsb = scmd->satacmd_lba_mid_lsb;
7884 ata_ret_desc->ars_lba_high_lsb = scmd->satacmd_lba_high_lsb;
7885 ata_ret_desc->ars_device = scmd->satacmd_device_reg;
7886 ata_ret_desc->ars_status = scmd->satacmd_status_reg;
7887
7888 if (extend == 1) {
7889 ata_ret_desc->ars_extend = 1;
7890 ata_ret_desc->ars_sec_count_msb = scmd->satacmd_sec_count_msb;
7891 ata_ret_desc->ars_lba_low_msb = scmd->satacmd_lba_low_msb;
7892 ata_ret_desc->ars_lba_mid_msb = scmd->satacmd_lba_mid_msb;
7893 ata_ret_desc->ars_lba_high_msb = scmd->satacmd_lba_high_msb;
7894 } else {
7895 ata_ret_desc->ars_extend = 0;
7896 ata_ret_desc->ars_sec_count_msb = 0;
7897 ata_ret_desc->ars_lba_low_msb = 0;
7898 ata_ret_desc->ars_lba_mid_msb = 0;
7899 ata_ret_desc->ars_lba_high_msb = 0;
7900 }
7901 }
7902
7903 static void
7904 sata_set_arq_data(sata_pkt_t *sata_pkt)
7905 {
7906 sata_pkt_txlate_t *spx =
7907 (sata_pkt_txlate_t *)sata_pkt->satapkt_framework_private;
7908 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt;
7909 struct scsi_extended_sense *sense;
7910
7911 scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET |
7912 STATE_SENT_CMD | STATE_GOT_STATUS;
7913 if (sata_pkt->satapkt_reason == SATA_PKT_COMPLETED) {
7914 /* Normal completion */
7915 scsipkt->pkt_reason = CMD_CMPLT;
7916 *scsipkt->pkt_scbp = STATUS_GOOD;
7917 } else {
7918 /* Something went wrong */
7919 scsipkt->pkt_reason = CMD_INCOMPLETE;
7920 *scsipkt->pkt_scbp = STATUS_CHECK;
7921 sense = sata_arq_sense(spx);
7922 switch (sata_pkt->satapkt_reason) {
7923 case SATA_PKT_PORT_ERROR:
7924 /*
7925 * We have no device data. Assume no data transfered.
7926 */
7927 sense->es_key = KEY_HARDWARE_ERROR;
7928 break;
7929
7930 case SATA_PKT_DEV_ERROR:
7931 if (sata_pkt->satapkt_cmd.satacmd_status_reg &
7932 SATA_STATUS_ERR) {
7933 /*
7934 * determine dev error reason from error
7935 * reg content
7936 */
7937 sata_decode_device_error(spx, sense);
7938 break;
7939 }
7940 /* No extended sense key - no info available */
7941 break;
7942
7943 case SATA_PKT_TIMEOUT:
7944 scsipkt->pkt_reason = CMD_TIMEOUT;
7945 scsipkt->pkt_statistics |=
7946 STAT_TIMEOUT | STAT_DEV_RESET;
7947 /* No extended sense key ? */
7948 break;
7949
7950 case SATA_PKT_ABORTED:
7951 scsipkt->pkt_reason = CMD_ABORTED;
7952 scsipkt->pkt_statistics |= STAT_ABORTED;
7953 /* No extended sense key ? */
7954 break;
7955
7956 case SATA_PKT_RESET:
7957 /* pkt aborted by an explicit reset from a host */
7958 scsipkt->pkt_reason = CMD_RESET;
7959 scsipkt->pkt_statistics |= STAT_DEV_RESET;
7960 break;
7961
7962 default:
7963 SATA_LOG_D((spx->txlt_sata_hba_inst, CE_WARN,
7964 "sata_txlt_nodata_cmd_completion: "
7965 "invalid packet completion reason %d",
7966 sata_pkt->satapkt_reason));
7967 scsipkt->pkt_reason = CMD_TRAN_ERR;
7968 break;
7969 }
7970
7971 }
7972 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst,
7973 "Scsi_pkt completion reason %x\n", scsipkt->pkt_reason);
7974 }
7975
7976
7977 /*
7978 * Build Mode sense R/W recovery page
7979 * NOT IMPLEMENTED
7980 */
7981
7982 static int
7983 sata_build_msense_page_1(sata_drive_info_t *sdinfo, int pcntrl, uint8_t *buf)
7984 {
7985 #ifndef __lock_lint
7986 _NOTE(ARGUNUSED(sdinfo))
7987 _NOTE(ARGUNUSED(pcntrl))
7988 _NOTE(ARGUNUSED(buf))
7989 #endif
7990 return (0);
7991 }
7992
7993 /*
7994 * Build Mode sense caching page - scsi-3 implementation.
7995 * Page length distinguishes previous format from scsi-3 format.
7996 * buf must have space for 0x12 bytes.
7997 * Only DRA (disable read ahead ) and WCE (write cache enable) are changeable.
7998 *
7999 */
8000 static int
8001 sata_build_msense_page_8(sata_drive_info_t *sdinfo, int pcntrl, uint8_t *buf)
8002 {
8003 struct mode_cache_scsi3 *page = (struct mode_cache_scsi3 *)buf;
8004 sata_id_t *sata_id = &sdinfo->satadrv_id;
8005
8006 /*
8007 * Most of the fields are set to 0, being not supported and/or disabled
8008 */
8009 bzero(buf, PAGELENGTH_DAD_MODE_CACHE_SCSI3);
8010
8011 /* Saved paramters not supported */
8012 if (pcntrl == 3)
8013 return (0);
8014 if (pcntrl == 0 || pcntrl == 2) {
8015 /*
8016 * For now treat current and default parameters as same
8017 * That may have to change, if target driver will complain
8018 */
8019 page->mode_page.code = MODEPAGE_CACHING; /* PS = 0 */
8020 page->mode_page.length = PAGELENGTH_DAD_MODE_CACHE_SCSI3;
8021
8022 if (SATA_READ_AHEAD_SUPPORTED(*sata_id) &&
8023 !SATA_READ_AHEAD_ENABLED(*sata_id)) {
8024 page->dra = 1; /* Read Ahead disabled */
8025 page->rcd = 1; /* Read Cache disabled */
8026 }
8027 if (SATA_WRITE_CACHE_SUPPORTED(*sata_id) &&
8028 SATA_WRITE_CACHE_ENABLED(*sata_id))
8029 page->wce = 1; /* Write Cache enabled */
8030 } else {
8031 /* Changeable parameters */
8032 page->mode_page.code = MODEPAGE_CACHING;
8033 page->mode_page.length = PAGELENGTH_DAD_MODE_CACHE_SCSI3;
8034 if (SATA_READ_AHEAD_SUPPORTED(*sata_id)) {
8035 page->dra = 1;
8036 page->rcd = 1;
8037 }
8038 if (SATA_WRITE_CACHE_SUPPORTED(*sata_id))
8039 page->wce = 1;
8040 }
8041 return (PAGELENGTH_DAD_MODE_CACHE_SCSI3 +
8042 sizeof (struct mode_page));
8043 }
8044
8045 /*
8046 * Build Mode sense exception cntrl page
8047 */
8048 static int
8049 sata_build_msense_page_1c(sata_drive_info_t *sdinfo, int pcntrl, uint8_t *buf)
8050 {
8051 struct mode_info_excpt_page *page = (struct mode_info_excpt_page *)buf;
8052 sata_id_t *sata_id = &sdinfo->satadrv_id;
8053
8054 /*
8055 * Most of the fields are set to 0, being not supported and/or disabled
8056 */
8057 bzero(buf, PAGELENGTH_INFO_EXCPT);
8058
8059 page->mode_page.code = MODEPAGE_INFO_EXCPT;
8060 page->mode_page.length = PAGELENGTH_INFO_EXCPT;
8061
8062 /* Indicate that this is page is saveable */
8063 page->mode_page.ps = 1;
8064
8065 /*
8066 * We will return the same data for default, current and saved page.
8067 * The only changeable bit is dexcpt and that bit is required
8068 * by the ATA specification to be preserved across power cycles.
8069 */
8070 if (pcntrl != 1) {
8071 page->dexcpt = !(sata_id->ai_features85 & SATA_SMART_SUPPORTED);
8072 page->mrie = MRIE_ONLY_ON_REQUEST;
8073 }
8074 else
8075 page->dexcpt = 1; /* Only changeable parameter */
8076
8077 return (PAGELENGTH_INFO_EXCPT + sizeof (struct mode_page));
8078 }
8079
8080
8081 static int
8082 sata_build_msense_page_30(sata_drive_info_t *sdinfo, int pcntrl, uint8_t *buf)
8083 {
8084 struct mode_acoustic_management *page =
8085 (struct mode_acoustic_management *)buf;
8086 sata_id_t *sata_id = &sdinfo->satadrv_id;
8087
8088 /*
8089 * Most of the fields are set to 0, being not supported and/or disabled
8090 */
8091 bzero(buf, PAGELENGTH_DAD_MODE_ACOUSTIC_MANAGEMENT);
8092
8093 switch (pcntrl) {
8094 case P_CNTRL_DEFAULT:
8095 /* default paramters not supported */
8096 return (0);
8097
8098 case P_CNTRL_CURRENT:
8099 case P_CNTRL_SAVED:
8100 /* Saved and current are supported and are identical */
8101 page->mode_page.code = MODEPAGE_ACOUSTIC_MANAG;
8102 page->mode_page.length =
8103 PAGELENGTH_DAD_MODE_ACOUSTIC_MANAGEMENT;
8104 page->mode_page.ps = 1;
8105
8106 /* Word 83 indicates if feature is supported */
8107 /* If feature is not supported */
8108 if (!(sata_id->ai_cmdset83 & SATA_ACOUSTIC_MGMT)) {
8109 page->acoustic_manag_enable =
8110 ACOUSTIC_DISABLED;
8111 } else {
8112 page->acoustic_manag_enable =
8113 ((sata_id->ai_features86 & SATA_ACOUSTIC_MGMT)
8114 != 0);
8115 /* Word 94 inidicates the value */
8116 #ifdef _LITTLE_ENDIAN
8117 page->acoustic_manag_level =
8118 (uchar_t)sata_id->ai_acoustic;
8119 page->vendor_recommended_value =
8120 sata_id->ai_acoustic >> 8;
8121 #else
8122 page->acoustic_manag_level =
8123 sata_id->ai_acoustic >> 8;
8124 page->vendor_recommended_value =
8125 (uchar_t)sata_id->ai_acoustic;
8126 #endif
8127 }
8128 break;
8129
8130 case P_CNTRL_CHANGEABLE:
8131 page->mode_page.code = MODEPAGE_ACOUSTIC_MANAG;
8132 page->mode_page.length =
8133 PAGELENGTH_DAD_MODE_ACOUSTIC_MANAGEMENT;
8134 page->mode_page.ps = 1;
8135
8136 /* Word 83 indicates if the feature is supported */
8137 if (sata_id->ai_cmdset83 & SATA_ACOUSTIC_MGMT) {
8138 page->acoustic_manag_enable =
8139 ACOUSTIC_ENABLED;
8140 page->acoustic_manag_level = 0xff;
8141 }
8142 break;
8143 }
8144 return (PAGELENGTH_DAD_MODE_ACOUSTIC_MANAGEMENT +
8145 sizeof (struct mode_page));
8146 }
8147
8148
8149 /*
8150 * Build Mode sense power condition page.
8151 */
8152 static int
8153 sata_build_msense_page_1a(sata_drive_info_t *sdinfo, int pcntrl, uint8_t *buf)
8154 {
8155 struct mode_info_power_cond *page = (struct mode_info_power_cond *)buf;
8156 sata_id_t *sata_id = &sdinfo->satadrv_id;
8157
8158 /*
8159 * Most of the fields are set to 0, being not supported and/or disabled
8160 * power condition page length was 0x0a
8161 */
8162 bzero(buf, sizeof (struct mode_info_power_cond));
8163
8164 if (pcntrl == P_CNTRL_DEFAULT) {
8165 /* default paramters not supported */
8166 return (0);
8167 }
8168
8169 page->mode_page.code = MODEPAGE_POWER_COND;
8170 page->mode_page.length = sizeof (struct mode_info_power_cond);
8171
8172 if (sata_id->ai_cap & SATA_STANDBYTIMER) {
8173 page->standby = 1;
8174 bcopy(sdinfo->satadrv_standby_timer, page->standby_cond_timer,
8175 sizeof (uchar_t) * 4);
8176 }
8177
8178 return (sizeof (struct mode_info_power_cond));
8179 }
8180
8181 /*
8182 * Process mode select caching page 8 (scsi3 format only).
8183 * Read Ahead (same as read cache) and Write Cache may be turned on and off
8184 * if these features are supported by the device. If these features are not
8185 * supported, the command will be terminated with STATUS_CHECK.
8186 * This function fails only if the SET FEATURE command sent to
8187 * the device fails. The page format is not verified, assuming that the
8188 * target driver operates correctly - if parameters length is too short,
8189 * we just drop the page.
8190 * Two command may be sent if both Read Cache/Read Ahead and Write Cache
8191 * setting have to be changed.
8192 * SET FEATURE command is executed synchronously, i.e. we wait here until
8193 * it is completed, regardless of the scsi pkt directives.
8194 *
8195 * Note: Mode Select Caching page RCD and DRA bits are tied together, i.e.
8196 * changing DRA will change RCD.
8197 *
8198 * More than one SATA command may be executed to perform operations specified
8199 * by mode select pages. The first error terminates further execution.
8200 * Operations performed successully are not backed-up in such case.
8201 *
8202 * Return SATA_SUCCESS if operation succeeded, SATA_FAILURE otherwise.
8203 * If operation resulted in changing device setup, dmod flag should be set to
8204 * one (1). If parameters were not changed, dmod flag should be set to 0.
8205 * Upon return, if operation required sending command to the device, the rval
8206 * should be set to the value returned by sata_hba_start. If operation
8207 * did not require device access, rval should be set to TRAN_ACCEPT.
8208 * The pagelen should be set to the length of the page.
8209 *
8210 * This function has to be called with a port mutex held.
8211 *
8212 * Returns SATA_SUCCESS if operation was successful, SATA_FAILURE otherwise.
8213 */
8214 int
8215 sata_mode_select_page_8(sata_pkt_txlate_t *spx, struct mode_cache_scsi3 *page,
8216 int parmlen, int *pagelen, int *rval, int *dmod)
8217 {
8218 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt;
8219 sata_drive_info_t *sdinfo;
8220 sata_cmd_t *scmd = &spx->txlt_sata_pkt->satapkt_cmd;
8221 sata_id_t *sata_id;
8222 struct scsi_extended_sense *sense;
8223 int wce, dra; /* Current settings */
8224
8225 sdinfo = sata_get_device_info(spx->txlt_sata_hba_inst,
8226 &spx->txlt_sata_pkt->satapkt_device);
8227 sata_id = &sdinfo->satadrv_id;
8228 *dmod = 0;
8229
8230 /* Verify parameters length. If too short, drop it */
8231 if ((PAGELENGTH_DAD_MODE_CACHE_SCSI3 +
8232 sizeof (struct mode_page)) > parmlen) {
8233 *scsipkt->pkt_scbp = STATUS_CHECK;
8234 sense = sata_arq_sense(spx);
8235 sense->es_key = KEY_ILLEGAL_REQUEST;
8236 sense->es_add_code = SD_SCSI_ASC_INVALID_FIELD_IN_PARAMS_LIST;
8237 *pagelen = parmlen;
8238 *rval = TRAN_ACCEPT;
8239 return (SATA_FAILURE);
8240 }
8241
8242 *pagelen = PAGELENGTH_DAD_MODE_CACHE_SCSI3 + sizeof (struct mode_page);
8243
8244 /* Current setting of Read Ahead (and Read Cache) */
8245 if (SATA_READ_AHEAD_ENABLED(*sata_id))
8246 dra = 0; /* 0 == not disabled */
8247 else
8248 dra = 1;
8249 /* Current setting of Write Cache */
8250 if (SATA_WRITE_CACHE_ENABLED(*sata_id))
8251 wce = 1;
8252 else
8253 wce = 0;
8254
8255 if (page->dra == dra && page->wce == wce && page->rcd == dra) {
8256 /* nothing to do */
8257 *rval = TRAN_ACCEPT;
8258 return (SATA_SUCCESS);
8259 }
8260
8261 /*
8262 * Need to flip some setting
8263 * Set-up Internal SET FEATURES command(s)
8264 */
8265 scmd->satacmd_flags.sata_data_direction = SATA_DIR_NODATA_XFER;
8266 scmd->satacmd_addr_type = 0;
8267 scmd->satacmd_device_reg = 0;
8268 scmd->satacmd_status_reg = 0;
8269 scmd->satacmd_error_reg = 0;
8270 scmd->satacmd_cmd_reg = SATAC_SET_FEATURES;
8271 if (page->dra != dra || page->rcd != dra) {
8272 if (SATA_READ_AHEAD_SUPPORTED(*sata_id)) {
8273 /* Need to flip read ahead setting */
8274 if (dra == 0)
8275 /* Disable read ahead / read cache */
8276 scmd->satacmd_features_reg =
8277 SATAC_SF_DISABLE_READ_AHEAD;
8278 else
8279 /* Enable read ahead / read cache */
8280 scmd->satacmd_features_reg =
8281 SATAC_SF_ENABLE_READ_AHEAD;
8282
8283 /* Transfer command to HBA */
8284 if (sata_hba_start(spx, rval) != 0)
8285 /*
8286 * Pkt not accepted for execution.
8287 */
8288 return (SATA_FAILURE);
8289
8290 *dmod = 1;
8291
8292 /* Now process return */
8293 if (spx->txlt_sata_pkt->satapkt_reason !=
8294 SATA_PKT_COMPLETED) {
8295 goto failure; /* Terminate */
8296 }
8297 } else {
8298 *scsipkt->pkt_scbp = STATUS_CHECK;
8299 sense = sata_arq_sense(spx);
8300 sense->es_key = KEY_ILLEGAL_REQUEST;
8301 sense->es_add_code =
8302 SD_SCSI_ASC_INVALID_FIELD_IN_PARAMS_LIST;
8303 *pagelen = parmlen;
8304 *rval = TRAN_ACCEPT;
8305 return (SATA_FAILURE);
8306 }
8307 }
8308
8309 /* Note that the packet is not removed, so it could be re-used */
8310 if (page->wce != wce) {
8311 if (SATA_WRITE_CACHE_SUPPORTED(*sata_id)) {
8312 /* Need to flip Write Cache setting */
8313 if (page->wce == 1)
8314 /* Enable write cache */
8315 scmd->satacmd_features_reg =
8316 SATAC_SF_ENABLE_WRITE_CACHE;
8317 else
8318 /* Disable write cache */
8319 scmd->satacmd_features_reg =
8320 SATAC_SF_DISABLE_WRITE_CACHE;
8321
8322 /* Transfer command to HBA */
8323 if (sata_hba_start(spx, rval) != 0)
8324 /*
8325 * Pkt not accepted for execution.
8326 */
8327 return (SATA_FAILURE);
8328
8329 *dmod = 1;
8330
8331 /* Now process return */
8332 if (spx->txlt_sata_pkt->satapkt_reason !=
8333 SATA_PKT_COMPLETED) {
8334 goto failure;
8335 }
8336 } else {
8337 *scsipkt->pkt_scbp = STATUS_CHECK;
8338 sense = sata_arq_sense(spx);
8339 sense->es_key = KEY_ILLEGAL_REQUEST;
8340 sense->es_add_code =
8341 SD_SCSI_ASC_INVALID_FIELD_IN_PARAMS_LIST;
8342 *pagelen = parmlen;
8343 *rval = TRAN_ACCEPT;
8344 return (SATA_FAILURE);
8345 }
8346 }
8347 return (SATA_SUCCESS);
8348
8349 failure:
8350 sata_xlate_errors(spx);
8351
8352 return (SATA_FAILURE);
8353 }
8354
8355 /*
8356 * Process mode select informational exceptions control page 0x1c
8357 *
8358 * The only changeable bit is dexcpt (disable exceptions).
8359 * MRIE (method of reporting informational exceptions) must be
8360 * "only on request".
8361 * This page applies to informational exceptions that report
8362 * additional sense codes with the ADDITIONAL SENSE CODE field set to 5Dh
8363 * (e.g.,FAILURE PREDICTION THRESHOLD EXCEEDED) or 0Bh (e.g., WARNING_).
8364 * Informational exception conditions occur as the result of background scan
8365 * errors, background self-test errors, or vendor specific events within a
8366 * logical unit. An informational exception condition may occur asynchronous
8367 * to any commands.
8368 *
8369 * Returns: SATA_SUCCESS if operation succeeded, SATA_FAILURE otherwise.
8370 * If operation resulted in changing device setup, dmod flag should be set to
8371 * one (1). If parameters were not changed, dmod flag should be set to 0.
8372 * Upon return, if operation required sending command to the device, the rval
8373 * should be set to the value returned by sata_hba_start. If operation
8374 * did not require device access, rval should be set to TRAN_ACCEPT.
8375 * The pagelen should be set to the length of the page.
8376 *
8377 * This function has to be called with a port mutex held.
8378 *
8379 * Returns SATA_SUCCESS if operation was successful, SATA_FAILURE otherwise.
8380 *
8381 * Cannot be called in the interrupt context.
8382 */
8383 static int
8384 sata_mode_select_page_1c(
8385 sata_pkt_txlate_t *spx,
8386 struct mode_info_excpt_page *page,
8387 int parmlen,
8388 int *pagelen,
8389 int *rval,
8390 int *dmod)
8391 {
8392 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt;
8393 sata_cmd_t *scmd = &spx->txlt_sata_pkt->satapkt_cmd;
8394 sata_drive_info_t *sdinfo;
8395 sata_id_t *sata_id;
8396 struct scsi_extended_sense *sense;
8397
8398 sdinfo = sata_get_device_info(spx->txlt_sata_hba_inst,
8399 &spx->txlt_sata_pkt->satapkt_device);
8400 sata_id = &sdinfo->satadrv_id;
8401
8402 *dmod = 0;
8403
8404 /* Verify parameters length. If too short, drop it */
8405 if (((PAGELENGTH_INFO_EXCPT + sizeof (struct mode_page)) > parmlen) ||
8406 page->perf || page->test || (page->mrie != MRIE_ONLY_ON_REQUEST)) {
8407 *scsipkt->pkt_scbp = STATUS_CHECK;
8408 sense = sata_arq_sense(spx);
8409 sense->es_key = KEY_ILLEGAL_REQUEST;
8410 sense->es_add_code = SD_SCSI_ASC_INVALID_FIELD_IN_PARAMS_LIST;
8411 *pagelen = parmlen;
8412 *rval = TRAN_ACCEPT;
8413 return (SATA_FAILURE);
8414 }
8415
8416 *pagelen = PAGELENGTH_INFO_EXCPT + sizeof (struct mode_page);
8417
8418 if (! (sata_id->ai_cmdset82 & SATA_SMART_SUPPORTED)) {
8419 *scsipkt->pkt_scbp = STATUS_CHECK;
8420 sense = sata_arq_sense(spx);
8421 sense->es_key = KEY_ILLEGAL_REQUEST;
8422 sense->es_add_code = SD_SCSI_ASC_INVALID_FIELD_IN_CDB;
8423 *pagelen = parmlen;
8424 *rval = TRAN_ACCEPT;
8425 return (SATA_FAILURE);
8426 }
8427
8428 /* If already in the state requested, we are done */
8429 if (page->dexcpt == ! (sata_id->ai_features85 & SATA_SMART_ENABLED)) {
8430 /* nothing to do */
8431 *rval = TRAN_ACCEPT;
8432 return (SATA_SUCCESS);
8433 }
8434
8435 scmd->satacmd_flags.sata_data_direction = SATA_DIR_NODATA_XFER;
8436
8437 /* Build SMART_ENABLE or SMART_DISABLE command */
8438 scmd->satacmd_addr_type = 0; /* N/A */
8439 scmd->satacmd_lba_mid_lsb = SMART_MAGIC_VAL_1;
8440 scmd->satacmd_lba_high_lsb = SMART_MAGIC_VAL_2;
8441 scmd->satacmd_features_reg = page->dexcpt ?
8442 SATA_SMART_DISABLE_OPS : SATA_SMART_ENABLE_OPS;
8443 scmd->satacmd_device_reg = 0; /* Always device 0 */
8444 scmd->satacmd_cmd_reg = SATAC_SMART;
8445
8446 /* Transfer command to HBA */
8447 if (sata_hba_start(spx, rval) != 0)
8448 /*
8449 * Pkt not accepted for execution.
8450 */
8451 return (SATA_FAILURE);
8452
8453 *dmod = 1; /* At least may have been modified */
8454
8455 /* Now process return */
8456 if (spx->txlt_sata_pkt->satapkt_reason == SATA_PKT_COMPLETED)
8457 return (SATA_SUCCESS);
8458
8459 /* Packet did not complete successfully */
8460 sata_xlate_errors(spx);
8461
8462 return (SATA_FAILURE);
8463 }
8464
8465 /*
8466 * Process mode select acoustic management control page 0x30
8467 *
8468 *
8469 * This function has to be called with a port mutex held.
8470 *
8471 * Returns SATA_SUCCESS if operation was successful, SATA_FAILURE otherwise.
8472 *
8473 * Cannot be called in the interrupt context.
8474 */
8475 int
8476 sata_mode_select_page_30(sata_pkt_txlate_t *spx, struct
8477 mode_acoustic_management *page, int parmlen, int *pagelen,
8478 int *rval, int *dmod)
8479 {
8480 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt;
8481 sata_drive_info_t *sdinfo;
8482 sata_cmd_t *scmd = &spx->txlt_sata_pkt->satapkt_cmd;
8483 sata_id_t *sata_id;
8484 struct scsi_extended_sense *sense;
8485
8486 sdinfo = sata_get_device_info(spx->txlt_sata_hba_inst,
8487 &spx->txlt_sata_pkt->satapkt_device);
8488 sata_id = &sdinfo->satadrv_id;
8489 *dmod = 0;
8490
8491 /* If parmlen is too short or the feature is not supported, drop it */
8492 if (((PAGELENGTH_DAD_MODE_ACOUSTIC_MANAGEMENT +
8493 sizeof (struct mode_page)) > parmlen) ||
8494 (! (sata_id->ai_cmdset83 & SATA_ACOUSTIC_MGMT))) {
8495 *scsipkt->pkt_scbp = STATUS_CHECK;
8496 sense = sata_arq_sense(spx);
8497 sense->es_key = KEY_ILLEGAL_REQUEST;
8498 sense->es_add_code = SD_SCSI_ASC_INVALID_FIELD_IN_PARAMS_LIST;
8499 *pagelen = parmlen;
8500 *rval = TRAN_ACCEPT;
8501 return (SATA_FAILURE);
8502 }
8503
8504 *pagelen = PAGELENGTH_DAD_MODE_ACOUSTIC_MANAGEMENT +
8505 sizeof (struct mode_page);
8506
8507 /*
8508 * We can enable and disable acoustice management and
8509 * set the acoustic management level.
8510 */
8511
8512 /*
8513 * Set-up Internal SET FEATURES command(s)
8514 */
8515 scmd->satacmd_flags.sata_data_direction = SATA_DIR_NODATA_XFER;
8516 scmd->satacmd_addr_type = 0;
8517 scmd->satacmd_device_reg = 0;
8518 scmd->satacmd_status_reg = 0;
8519 scmd->satacmd_error_reg = 0;
8520 scmd->satacmd_cmd_reg = SATAC_SET_FEATURES;
8521 if (page->acoustic_manag_enable) {
8522 scmd->satacmd_features_reg = SATAC_SF_ENABLE_ACOUSTIC;
8523 scmd->satacmd_sec_count_lsb = page->acoustic_manag_level;
8524 } else { /* disabling acoustic management */
8525 scmd->satacmd_features_reg = SATAC_SF_DISABLE_ACOUSTIC;
8526 }
8527
8528 /* Transfer command to HBA */
8529 if (sata_hba_start(spx, rval) != 0)
8530 /*
8531 * Pkt not accepted for execution.
8532 */
8533 return (SATA_FAILURE);
8534
8535 /* Now process return */
8536 if (spx->txlt_sata_pkt->satapkt_reason != SATA_PKT_COMPLETED) {
8537 sata_xlate_errors(spx);
8538 return (SATA_FAILURE);
8539 }
8540
8541 *dmod = 1;
8542
8543 return (SATA_SUCCESS);
8544 }
8545
8546 /*
8547 * Process mode select power condition page 0x1a
8548 *
8549 * This function has to be called with a port mutex held.
8550 *
8551 * Returns SATA_SUCCESS if operation was successful, SATA_FAILURE otherwise.
8552 *
8553 * Cannot be called in the interrupt context.
8554 */
8555 int
8556 sata_mode_select_page_1a(sata_pkt_txlate_t *spx, struct
8557 mode_info_power_cond *page, int parmlen, int *pagelen,
8558 int *rval, int *dmod)
8559 {
8560 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt;
8561 sata_drive_info_t *sdinfo;
8562 sata_cmd_t *scmd = &spx->txlt_sata_pkt->satapkt_cmd;
8563 sata_id_t *sata_id;
8564 struct scsi_extended_sense *sense;
8565 uint8_t ata_count;
8566 int i, len;
8567
8568 sdinfo = sata_get_device_info(spx->txlt_sata_hba_inst,
8569 &spx->txlt_sata_pkt->satapkt_device);
8570 sata_id = &sdinfo->satadrv_id;
8571 *dmod = 0;
8572
8573 len = sizeof (struct mode_info_power_cond);
8574 len += sizeof (struct mode_page);
8575
8576 /* If parmlen is too short or the feature is not supported, drop it */
8577 if ((len < parmlen) || (page->idle == 1) ||
8578 (!(sata_id->ai_cap & SATA_STANDBYTIMER) && page->standby == 1)) {
8579 *scsipkt->pkt_scbp = STATUS_CHECK;
8580 sense = sata_arq_sense(spx);
8581 sense->es_key = KEY_ILLEGAL_REQUEST;
8582 sense->es_add_code = SD_SCSI_ASC_INVALID_FIELD_IN_PARAMS_LIST;
8583 *pagelen = parmlen;
8584 *rval = TRAN_ACCEPT;
8585 return (SATA_FAILURE);
8586 }
8587
8588 *pagelen = len;
8589
8590 /*
8591 * Set-up Internal STANDBY command(s)
8592 */
8593 if (page->standby == 0)
8594 goto out;
8595
8596 ata_count = sata_get_standby_timer(page->standby_cond_timer);
8597
8598 scmd->satacmd_addr_type = 0;
8599 scmd->satacmd_sec_count_lsb = ata_count;
8600 scmd->satacmd_lba_low_lsb = 0;
8601 scmd->satacmd_lba_mid_lsb = 0;
8602 scmd->satacmd_lba_high_lsb = 0;
8603 scmd->satacmd_features_reg = 0;
8604 scmd->satacmd_device_reg = 0;
8605 scmd->satacmd_status_reg = 0;
8606 scmd->satacmd_cmd_reg = SATAC_STANDBY;
8607 scmd->satacmd_flags.sata_special_regs = B_TRUE;
8608 scmd->satacmd_flags.sata_copy_out_error_reg = B_TRUE;
8609
8610 /* Transfer command to HBA */
8611 if (sata_hba_start(spx, rval) != 0) {
8612 return (SATA_FAILURE);
8613 } else {
8614 if ((scmd->satacmd_error_reg != 0) ||
8615 (spx->txlt_sata_pkt->satapkt_reason !=
8616 SATA_PKT_COMPLETED)) {
8617 sata_xlate_errors(spx);
8618 return (SATA_FAILURE);
8619 }
8620 }
8621
8622 for (i = 0; i < 4; i++) {
8623 sdinfo->satadrv_standby_timer[i] = page->standby_cond_timer[i];
8624 }
8625 out:
8626 *dmod = 1;
8627 return (SATA_SUCCESS);
8628 }
8629
8630 /*
8631 * sata_build_lsense_page0() is used to create the
8632 * SCSI LOG SENSE page 0 (supported log pages)
8633 *
8634 * Currently supported pages are 0, 0x10, 0x2f, 0x30 and 0x0e
8635 * (supported log pages, self-test results, informational exceptions
8636 * Sun vendor specific ATA SMART data, and start stop cycle counter).
8637 *
8638 * Takes a sata_drive_info t * and the address of a buffer
8639 * in which to create the page information.
8640 *
8641 * Returns the number of bytes valid in the buffer.
8642 */
8643 static int
8644 sata_build_lsense_page_0(sata_drive_info_t *sdinfo, uint8_t *buf)
8645 {
8646 struct log_parameter *lpp = (struct log_parameter *)buf;
8647 uint8_t *page_ptr = (uint8_t *)lpp->param_values;
8648 int num_pages_supported = 1; /* Always have GET_SUPPORTED_LOG_PAGES */
8649 sata_id_t *sata_id = &sdinfo->satadrv_id;
8650
8651 lpp->param_code[0] = 0;
8652 lpp->param_code[1] = 0;
8653 lpp->param_ctrl_flags = LOG_CTRL_LP | LOG_CTRL_LBIN;
8654 *page_ptr++ = PAGE_CODE_GET_SUPPORTED_LOG_PAGES;
8655
8656 if (sata_id->ai_cmdset82 & SATA_SMART_SUPPORTED) {
8657 if (sata_id->ai_cmdset84 & SATA_SMART_SELF_TEST_SUPPORTED) {
8658 *page_ptr++ = PAGE_CODE_SELF_TEST_RESULTS;
8659 ++num_pages_supported;
8660 }
8661 *page_ptr++ = PAGE_CODE_INFORMATION_EXCEPTIONS;
8662 ++num_pages_supported;
8663 *page_ptr++ = PAGE_CODE_SMART_READ_DATA;
8664 ++num_pages_supported;
8665 *page_ptr++ = PAGE_CODE_START_STOP_CYCLE_COUNTER;
8666 ++num_pages_supported;
8667 }
8668
8669 lpp->param_len = num_pages_supported;
8670
8671 return ((&lpp->param_values[0] - (uint8_t *)lpp) +
8672 num_pages_supported);
8673 }
8674
8675 /*
8676 * sata_build_lsense_page_10() is used to create the
8677 * SCSI LOG SENSE page 0x10 (self-test results)
8678 *
8679 * Takes a sata_drive_info t * and the address of a buffer
8680 * in which to create the page information as well as a sata_hba_inst_t *.
8681 *
8682 * Returns the number of bytes valid in the buffer.
8683 *
8684 * Note: Self test and SMART data is accessible in device log pages.
8685 * The log pages can be accessed by SMART READ/WRITE LOG (up to 255 sectors
8686 * of data can be transferred by a single command), or by the General Purpose
8687 * Logging commands (GPL) READ LOG EXT and WRITE LOG EXT (up to 65,535 sectors
8688 * - approximately 33MB - can be transferred by a single command.
8689 * The SCT Command response (either error or command) is the same for both
8690 * the SMART and GPL methods of issuing commands.
8691 * This function uses READ LOG EXT command when drive supports LBA48, and
8692 * SMART READ command otherwise.
8693 *
8694 * Since above commands are executed in a synchronous mode, this function
8695 * should not be called in an interrupt context.
8696 */
8697 static int
8698 sata_build_lsense_page_10(
8699 sata_drive_info_t *sdinfo,
8700 uint8_t *buf,
8701 sata_hba_inst_t *sata_hba_inst)
8702 {
8703 struct log_parameter *lpp = (struct log_parameter *)buf;
8704 int rval;
8705
8706 if (sdinfo->satadrv_features_support & SATA_DEV_F_LBA48) {
8707 struct smart_ext_selftest_log *ext_selftest_log;
8708
8709 ext_selftest_log = kmem_zalloc(
8710 sizeof (struct smart_ext_selftest_log), KM_SLEEP);
8711
8712 rval = sata_ext_smart_selftest_read_log(sata_hba_inst, sdinfo,
8713 ext_selftest_log, 0);
8714 if (rval == 0) {
8715 int index, start_index;
8716 struct smart_ext_selftest_log_entry *entry;
8717 static const struct smart_ext_selftest_log_entry empty =
8718 {0};
8719 uint16_t block_num;
8720 int count;
8721 boolean_t only_one_block = B_FALSE;
8722
8723 index = ext_selftest_log->
8724 smart_ext_selftest_log_index[0];
8725 index |= ext_selftest_log->
8726 smart_ext_selftest_log_index[1] << 8;
8727 if (index == 0)
8728 goto out;
8729
8730 --index; /* Correct for 0 origin */
8731 start_index = index; /* remember where we started */
8732 block_num = index / ENTRIES_PER_EXT_SELFTEST_LOG_BLK;
8733 if (block_num != 0) {
8734 rval = sata_ext_smart_selftest_read_log(
8735 sata_hba_inst, sdinfo, ext_selftest_log,
8736 block_num);
8737 if (rval != 0)
8738 goto out;
8739 }
8740 index %= ENTRIES_PER_EXT_SELFTEST_LOG_BLK;
8741 entry =
8742 &ext_selftest_log->
8743 smart_ext_selftest_log_entries[index];
8744
8745 for (count = 1;
8746 count <= SCSI_ENTRIES_IN_LOG_SENSE_SELFTEST_RESULTS;
8747 ++count) {
8748 uint8_t status;
8749 uint8_t code;
8750 uint8_t sense_key;
8751 uint8_t add_sense_code;
8752 uint8_t add_sense_code_qual;
8753
8754 /* If this is an unused entry, we are done */
8755 if (bcmp(entry, &empty, sizeof (empty)) == 0) {
8756 /* Broken firmware on some disks */
8757 if (index + 1 ==
8758 ENTRIES_PER_EXT_SELFTEST_LOG_BLK) {
8759 --entry;
8760 --index;
8761 if (bcmp(entry, &empty,
8762 sizeof (empty)) == 0)
8763 goto out;
8764 } else
8765 goto out;
8766 }
8767
8768 if (only_one_block &&
8769 start_index == index)
8770 goto out;
8771
8772 lpp->param_code[0] = 0;
8773 lpp->param_code[1] = count;
8774 lpp->param_ctrl_flags =
8775 LOG_CTRL_LP | LOG_CTRL_LBIN;
8776 lpp->param_len =
8777 SCSI_LOG_SENSE_SELFTEST_PARAM_LEN;
8778
8779 status = entry->smart_ext_selftest_log_status;
8780 status >>= 4;
8781 switch (status) {
8782 case 0:
8783 default:
8784 sense_key = KEY_NO_SENSE;
8785 add_sense_code =
8786 SD_SCSI_ASC_NO_ADD_SENSE;
8787 add_sense_code_qual = 0;
8788 break;
8789 case 1:
8790 sense_key = KEY_ABORTED_COMMAND;
8791 add_sense_code =
8792 DIAGNOSTIC_FAILURE_ON_COMPONENT;
8793 add_sense_code_qual = SCSI_COMPONENT_81;
8794 break;
8795 case 2:
8796 sense_key = KEY_ABORTED_COMMAND;
8797 add_sense_code =
8798 DIAGNOSTIC_FAILURE_ON_COMPONENT;
8799 add_sense_code_qual = SCSI_COMPONENT_82;
8800 break;
8801 case 3:
8802 sense_key = KEY_ABORTED_COMMAND;
8803 add_sense_code =
8804 DIAGNOSTIC_FAILURE_ON_COMPONENT;
8805 add_sense_code_qual = SCSI_COMPONENT_83;
8806 break;
8807 case 4:
8808 sense_key = KEY_HARDWARE_ERROR;
8809 add_sense_code =
8810 DIAGNOSTIC_FAILURE_ON_COMPONENT;
8811 add_sense_code_qual = SCSI_COMPONENT_84;
8812 break;
8813 case 5:
8814 sense_key = KEY_HARDWARE_ERROR;
8815 add_sense_code =
8816 DIAGNOSTIC_FAILURE_ON_COMPONENT;
8817 add_sense_code_qual = SCSI_COMPONENT_85;
8818 break;
8819 case 6:
8820 sense_key = KEY_HARDWARE_ERROR;
8821 add_sense_code =
8822 DIAGNOSTIC_FAILURE_ON_COMPONENT;
8823 add_sense_code_qual = SCSI_COMPONENT_86;
8824 break;
8825 case 7:
8826 sense_key = KEY_MEDIUM_ERROR;
8827 add_sense_code =
8828 DIAGNOSTIC_FAILURE_ON_COMPONENT;
8829 add_sense_code_qual = SCSI_COMPONENT_87;
8830 break;
8831 case 8:
8832 sense_key = KEY_HARDWARE_ERROR;
8833 add_sense_code =
8834 DIAGNOSTIC_FAILURE_ON_COMPONENT;
8835 add_sense_code_qual = SCSI_COMPONENT_88;
8836 break;
8837 }
8838 code = 0; /* unspecified */
8839 status |= (code << 4);
8840 lpp->param_values[0] = status;
8841 lpp->param_values[1] = 0; /* unspecified */
8842 lpp->param_values[2] = entry->
8843 smart_ext_selftest_log_timestamp[1];
8844 lpp->param_values[3] = entry->
8845 smart_ext_selftest_log_timestamp[0];
8846 if (status != 0) {
8847 lpp->param_values[4] = 0;
8848 lpp->param_values[5] = 0;
8849 lpp->param_values[6] = entry->
8850 smart_ext_selftest_log_failing_lba
8851 [5];
8852 lpp->param_values[7] = entry->
8853 smart_ext_selftest_log_failing_lba
8854 [4];
8855 lpp->param_values[8] = entry->
8856 smart_ext_selftest_log_failing_lba
8857 [3];
8858 lpp->param_values[9] = entry->
8859 smart_ext_selftest_log_failing_lba
8860 [2];
8861 lpp->param_values[10] = entry->
8862 smart_ext_selftest_log_failing_lba
8863 [1];
8864 lpp->param_values[11] = entry->
8865 smart_ext_selftest_log_failing_lba
8866 [0];
8867 } else { /* No bad block address */
8868 lpp->param_values[4] = 0xff;
8869 lpp->param_values[5] = 0xff;
8870 lpp->param_values[6] = 0xff;
8871 lpp->param_values[7] = 0xff;
8872 lpp->param_values[8] = 0xff;
8873 lpp->param_values[9] = 0xff;
8874 lpp->param_values[10] = 0xff;
8875 lpp->param_values[11] = 0xff;
8876 }
8877
8878 lpp->param_values[12] = sense_key;
8879 lpp->param_values[13] = add_sense_code;
8880 lpp->param_values[14] = add_sense_code_qual;
8881 lpp->param_values[15] = 0; /* undefined */
8882
8883 lpp = (struct log_parameter *)
8884 (((uint8_t *)lpp) +
8885 SCSI_LOG_PARAM_HDR_LEN +
8886 SCSI_LOG_SENSE_SELFTEST_PARAM_LEN);
8887
8888 --index; /* Back up to previous entry */
8889 if (index < 0) {
8890 if (block_num > 0) {
8891 --block_num;
8892 } else {
8893 struct read_log_ext_directory
8894 logdir;
8895
8896 rval =
8897 sata_read_log_ext_directory(
8898 sata_hba_inst, sdinfo,
8899 &logdir);
8900 if (rval == -1)
8901 goto out;
8902 if ((logdir.read_log_ext_vers
8903 [0] == 0) &&
8904 (logdir.read_log_ext_vers
8905 [1] == 0))
8906 goto out;
8907 block_num =
8908 logdir.read_log_ext_nblks
8909 [EXT_SMART_SELFTEST_LOG_PAGE
8910 - 1][0];
8911 block_num |= logdir.
8912 read_log_ext_nblks
8913 [EXT_SMART_SELFTEST_LOG_PAGE
8914 - 1][1] << 8;
8915 --block_num;
8916 only_one_block =
8917 (block_num == 0);
8918 }
8919 rval = sata_ext_smart_selftest_read_log(
8920 sata_hba_inst, sdinfo,
8921 ext_selftest_log, block_num);
8922 if (rval != 0)
8923 goto out;
8924
8925 index =
8926 ENTRIES_PER_EXT_SELFTEST_LOG_BLK -
8927 1;
8928 }
8929 index %= ENTRIES_PER_EXT_SELFTEST_LOG_BLK;
8930 entry = &ext_selftest_log->
8931 smart_ext_selftest_log_entries[index];
8932 }
8933 }
8934 out:
8935 kmem_free(ext_selftest_log,
8936 sizeof (struct smart_ext_selftest_log));
8937 } else {
8938 struct smart_selftest_log *selftest_log;
8939
8940 selftest_log = kmem_zalloc(sizeof (struct smart_selftest_log),
8941 KM_SLEEP);
8942
8943 rval = sata_smart_selftest_log(sata_hba_inst, sdinfo,
8944 selftest_log);
8945
8946 if (rval == 0) {
8947 int index;
8948 int count;
8949 struct smart_selftest_log_entry *entry;
8950 static const struct smart_selftest_log_entry empty =
8951 { 0 };
8952
8953 index = selftest_log->smart_selftest_log_index;
8954 if (index == 0)
8955 goto done;
8956 --index; /* Correct for 0 origin */
8957 entry = &selftest_log->
8958 smart_selftest_log_entries[index];
8959 for (count = 1;
8960 count <= SCSI_ENTRIES_IN_LOG_SENSE_SELFTEST_RESULTS;
8961 ++count) {
8962 uint8_t status;
8963 uint8_t code;
8964 uint8_t sense_key;
8965 uint8_t add_sense_code;
8966 uint8_t add_sense_code_qual;
8967
8968 if (bcmp(entry, &empty, sizeof (empty)) == 0)
8969 goto done;
8970
8971 lpp->param_code[0] = 0;
8972 lpp->param_code[1] = count;
8973 lpp->param_ctrl_flags =
8974 LOG_CTRL_LP | LOG_CTRL_LBIN;
8975 lpp->param_len =
8976 SCSI_LOG_SENSE_SELFTEST_PARAM_LEN;
8977
8978 status = entry->smart_selftest_log_status;
8979 status >>= 4;
8980 switch (status) {
8981 case 0:
8982 default:
8983 sense_key = KEY_NO_SENSE;
8984 add_sense_code =
8985 SD_SCSI_ASC_NO_ADD_SENSE;
8986 break;
8987 case 1:
8988 sense_key = KEY_ABORTED_COMMAND;
8989 add_sense_code =
8990 DIAGNOSTIC_FAILURE_ON_COMPONENT;
8991 add_sense_code_qual = SCSI_COMPONENT_81;
8992 break;
8993 case 2:
8994 sense_key = KEY_ABORTED_COMMAND;
8995 add_sense_code =
8996 DIAGNOSTIC_FAILURE_ON_COMPONENT;
8997 add_sense_code_qual = SCSI_COMPONENT_82;
8998 break;
8999 case 3:
9000 sense_key = KEY_ABORTED_COMMAND;
9001 add_sense_code =
9002 DIAGNOSTIC_FAILURE_ON_COMPONENT;
9003 add_sense_code_qual = SCSI_COMPONENT_83;
9004 break;
9005 case 4:
9006 sense_key = KEY_HARDWARE_ERROR;
9007 add_sense_code =
9008 DIAGNOSTIC_FAILURE_ON_COMPONENT;
9009 add_sense_code_qual = SCSI_COMPONENT_84;
9010 break;
9011 case 5:
9012 sense_key = KEY_HARDWARE_ERROR;
9013 add_sense_code =
9014 DIAGNOSTIC_FAILURE_ON_COMPONENT;
9015 add_sense_code_qual = SCSI_COMPONENT_85;
9016 break;
9017 case 6:
9018 sense_key = KEY_HARDWARE_ERROR;
9019 add_sense_code =
9020 DIAGNOSTIC_FAILURE_ON_COMPONENT;
9021 add_sense_code_qual = SCSI_COMPONENT_86;
9022 break;
9023 case 7:
9024 sense_key = KEY_MEDIUM_ERROR;
9025 add_sense_code =
9026 DIAGNOSTIC_FAILURE_ON_COMPONENT;
9027 add_sense_code_qual = SCSI_COMPONENT_87;
9028 break;
9029 case 8:
9030 sense_key = KEY_HARDWARE_ERROR;
9031 add_sense_code =
9032 DIAGNOSTIC_FAILURE_ON_COMPONENT;
9033 add_sense_code_qual = SCSI_COMPONENT_88;
9034 break;
9035 }
9036 code = 0; /* unspecified */
9037 status |= (code << 4);
9038 lpp->param_values[0] = status;
9039 lpp->param_values[1] = 0; /* unspecified */
9040 lpp->param_values[2] = entry->
9041 smart_selftest_log_timestamp[1];
9042 lpp->param_values[3] = entry->
9043 smart_selftest_log_timestamp[0];
9044 if (status != 0) {
9045 lpp->param_values[4] = 0;
9046 lpp->param_values[5] = 0;
9047 lpp->param_values[6] = 0;
9048 lpp->param_values[7] = 0;
9049 lpp->param_values[8] = entry->
9050 smart_selftest_log_failing_lba[3];
9051 lpp->param_values[9] = entry->
9052 smart_selftest_log_failing_lba[2];
9053 lpp->param_values[10] = entry->
9054 smart_selftest_log_failing_lba[1];
9055 lpp->param_values[11] = entry->
9056 smart_selftest_log_failing_lba[0];
9057 } else { /* No block address */
9058 lpp->param_values[4] = 0xff;
9059 lpp->param_values[5] = 0xff;
9060 lpp->param_values[6] = 0xff;
9061 lpp->param_values[7] = 0xff;
9062 lpp->param_values[8] = 0xff;
9063 lpp->param_values[9] = 0xff;
9064 lpp->param_values[10] = 0xff;
9065 lpp->param_values[11] = 0xff;
9066 }
9067 lpp->param_values[12] = sense_key;
9068 lpp->param_values[13] = add_sense_code;
9069 lpp->param_values[14] = add_sense_code_qual;
9070 lpp->param_values[15] = 0; /* undefined */
9071
9072 lpp = (struct log_parameter *)
9073 (((uint8_t *)lpp) +
9074 SCSI_LOG_PARAM_HDR_LEN +
9075 SCSI_LOG_SENSE_SELFTEST_PARAM_LEN);
9076 --index; /* back up to previous entry */
9077 if (index < 0) {
9078 index =
9079 NUM_SMART_SELFTEST_LOG_ENTRIES - 1;
9080 }
9081 entry = &selftest_log->
9082 smart_selftest_log_entries[index];
9083 }
9084 }
9085 done:
9086 kmem_free(selftest_log, sizeof (struct smart_selftest_log));
9087 }
9088
9089 return ((SCSI_LOG_PARAM_HDR_LEN + SCSI_LOG_SENSE_SELFTEST_PARAM_LEN) *
9090 SCSI_ENTRIES_IN_LOG_SENSE_SELFTEST_RESULTS);
9091 }
9092
9093 /*
9094 * sata_build_lsense_page_2f() is used to create the
9095 * SCSI LOG SENSE page 0x2f (informational exceptions)
9096 *
9097 * Takes a sata_drive_info t * and the address of a buffer
9098 * in which to create the page information as well as a sata_hba_inst_t *.
9099 *
9100 * Returns the number of bytes valid in the buffer.
9101 *
9102 * Because it invokes function(s) that send synchronously executed command
9103 * to the HBA, it cannot be called in the interrupt context.
9104 */
9105 static int
9106 sata_build_lsense_page_2f(
9107 sata_drive_info_t *sdinfo,
9108 uint8_t *buf,
9109 sata_hba_inst_t *sata_hba_inst)
9110 {
9111 struct log_parameter *lpp = (struct log_parameter *)buf;
9112 int rval;
9113 uint8_t *smart_data;
9114 uint8_t temp;
9115 sata_id_t *sata_id;
9116 #define SMART_NO_TEMP 0xff
9117
9118 lpp->param_code[0] = 0;
9119 lpp->param_code[1] = 0;
9120 lpp->param_ctrl_flags = LOG_CTRL_LP | LOG_CTRL_LBIN;
9121
9122 /* Now get the SMART status w.r.t. threshold exceeded */
9123 rval = sata_fetch_smart_return_status(sata_hba_inst, sdinfo);
9124 switch (rval) {
9125 case 1:
9126 lpp->param_values[0] = SCSI_PREDICTED_FAILURE;
9127 lpp->param_values[1] = SCSI_GENERAL_HD_FAILURE;
9128 break;
9129 case 0:
9130 case -1: /* failed to get data */
9131 lpp->param_values[0] = 0; /* No failure predicted */
9132 lpp->param_values[1] = 0;
9133 break;
9134 #if defined(SATA_DEBUG)
9135 default:
9136 cmn_err(CE_PANIC, "sata_build_lsense_page_2f bad return value");
9137 /* NOTREACHED */
9138 #endif
9139 }
9140
9141 sata_id = &sdinfo->satadrv_id;
9142 if (! (sata_id->ai_sctsupport & SATA_SCT_CMD_TRANS_SUP))
9143 temp = SMART_NO_TEMP;
9144 else {
9145 /* Now get the temperature */
9146 smart_data = kmem_zalloc(512, KM_SLEEP);
9147 rval = sata_smart_read_log(sata_hba_inst, sdinfo, smart_data,
9148 SCT_STATUS_LOG_PAGE, 1);
9149 if (rval == -1)
9150 temp = SMART_NO_TEMP;
9151 else {
9152 temp = smart_data[200];
9153 if (temp & 0x80) {
9154 if (temp & 0x7f)
9155 temp = 0;
9156 else
9157 temp = SMART_NO_TEMP;
9158 }
9159 }
9160 kmem_free(smart_data, 512);
9161 }
9162
9163 lpp->param_values[2] = temp; /* most recent temperature */
9164 lpp->param_values[3] = 0; /* required vendor specific byte */
9165
9166 lpp->param_len = SCSI_INFO_EXCEPTIONS_PARAM_LEN;
9167
9168
9169 return (SCSI_INFO_EXCEPTIONS_PARAM_LEN + SCSI_LOG_PARAM_HDR_LEN);
9170 }
9171
9172 /*
9173 * sata_build_lsense_page_30() is used to create the
9174 * SCSI LOG SENSE page 0x30 (Sun's vendor specific page for ATA SMART data).
9175 *
9176 * Takes a sata_drive_info t * and the address of a buffer
9177 * in which to create the page information as well as a sata_hba_inst_t *.
9178 *
9179 * Returns the number of bytes valid in the buffer.
9180 */
9181 static int
9182 sata_build_lsense_page_30(
9183 sata_drive_info_t *sdinfo,
9184 uint8_t *buf,
9185 sata_hba_inst_t *sata_hba_inst)
9186 {
9187 struct smart_data *smart_data = (struct smart_data *)buf;
9188 int rval;
9189
9190 /* Now do the SMART READ DATA */
9191 rval = sata_fetch_smart_data(sata_hba_inst, sdinfo, smart_data);
9192 if (rval == -1)
9193 return (0);
9194
9195 return (sizeof (struct smart_data));
9196 }
9197
9198 /*
9199 * sata_build_lsense_page_0e() is used to create the
9200 * SCSI LOG SENSE page 0e (start-stop cycle counter page)
9201 *
9202 * Date of Manufacture (0x0001)
9203 * YEAR = "0000"
9204 * WEEK = "00"
9205 * Accounting Date (0x0002)
9206 * 6 ASCII space character(20h)
9207 * Specified cycle count over device lifetime
9208 * VALUE - THRESH - the delta between max and min;
9209 * Accumulated start-stop cycles
9210 * VALUE - WORST - the accumulated cycles;
9211 *
9212 * ID FLAG THRESH VALUE WORST RAW on start/stop counter attribute
9213 *
9214 * Takes a sata_drive_info t * and the address of a buffer
9215 * in which to create the page information as well as a sata_hba_inst_t *.
9216 *
9217 * Returns the number of bytes valid in the buffer.
9218 */
9219 static int
9220 sata_build_lsense_page_0e(sata_drive_info_t *sdinfo, uint8_t *buf,
9221 sata_pkt_txlate_t *spx)
9222 {
9223 struct start_stop_cycle_counter_log *log_page;
9224 int i, rval, index;
9225 uint8_t smart_data[512], id, value, worst, thresh;
9226 uint32_t max_count, cycles;
9227
9228 /* Now do the SMART READ DATA */
9229 rval = sata_fetch_smart_data(spx->txlt_sata_hba_inst, sdinfo,
9230 (struct smart_data *)smart_data);
9231 if (rval == -1)
9232 return (0);
9233 for (i = 0, id = 0; i < SMART_START_STOP_COUNT_ID * 2; i++) {
9234 index = (i * 12) + 2;
9235 id = smart_data[index];
9236 if (id != SMART_START_STOP_COUNT_ID)
9237 continue;
9238 else {
9239 thresh = smart_data[index + 2];
9240 value = smart_data[index + 3];
9241 worst = smart_data[index + 4];
9242 break;
9243 }
9244 }
9245 if (id != SMART_START_STOP_COUNT_ID)
9246 return (0);
9247 max_count = value - thresh;
9248 cycles = value - worst;
9249
9250 log_page = (struct start_stop_cycle_counter_log *)buf;
9251 bzero(log_page, sizeof (struct start_stop_cycle_counter_log));
9252 log_page->code = 0x0e;
9253 log_page->page_len_low = 0x24;
9254
9255 log_page->manufactor_date_low = 0x1;
9256 log_page->param_1.fmt_link = 0x1; /* 01b */
9257 log_page->param_len_1 = 0x06;
9258 for (i = 0; i < 4; i++) {
9259 log_page->year_manu[i] = 0x30;
9260 if (i < 2)
9261 log_page->week_manu[i] = 0x30;
9262 }
9263
9264 log_page->account_date_low = 0x02;
9265 log_page->param_2.fmt_link = 0x01; /* 01b */
9266 log_page->param_len_2 = 0x06;
9267 for (i = 0; i < 4; i++) {
9268 log_page->year_account[i] = 0x20;
9269 if (i < 2)
9270 log_page->week_account[i] = 0x20;
9271 }
9272
9273 log_page->lifetime_code_low = 0x03;
9274 log_page->param_3.fmt_link = 0x03; /* 11b */
9275 log_page->param_len_3 = 0x04;
9276 /* VALUE - THRESH - the delta between max and min */
9277 log_page->cycle_code_low = 0x04;
9278 log_page->param_4.fmt_link = 0x03; /* 11b */
9279 log_page->param_len_4 = 0x04;
9280 /* WORST - THRESH - the distance from 'now' to min */
9281
9282 for (i = 0; i < 4; i++) {
9283 log_page->cycle_lifetime[i] =
9284 (max_count >> (8 * (3 - i))) & 0xff;
9285 log_page->cycle_accumulated[i] =
9286 (cycles >> (8 * (3 - i))) & 0xff;
9287 }
9288
9289 return (sizeof (struct start_stop_cycle_counter_log));
9290 }
9291
9292 /*
9293 * This function was used for build a ATA read verify sector command
9294 */
9295 static void
9296 sata_build_read_verify_cmd(sata_cmd_t *scmd, uint16_t sec, uint64_t lba)
9297 {
9298 scmd->satacmd_cmd_reg = SATAC_RDVER;
9299 scmd->satacmd_addr_type = ATA_ADDR_LBA28;
9300 scmd->satacmd_flags.sata_special_regs = B_TRUE;
9301
9302 scmd->satacmd_sec_count_lsb = sec & 0xff;
9303 scmd->satacmd_lba_low_lsb = lba & 0xff;
9304 scmd->satacmd_lba_mid_lsb = (lba >> 8) & 0xff;
9305 scmd->satacmd_lba_high_lsb = (lba >> 16) & 0xff;
9306 scmd->satacmd_device_reg = (SATA_ADH_LBA | (lba >> 24) & 0xf);
9307 scmd->satacmd_features_reg = 0;
9308 scmd->satacmd_status_reg = 0;
9309 scmd->satacmd_error_reg = 0;
9310 }
9311
9312 /*
9313 * This function was used for building an ATA
9314 * command, and only command register need to
9315 * be defined, other register will be zero or na.
9316 */
9317 static void
9318 sata_build_generic_cmd(sata_cmd_t *scmd, uint8_t cmd)
9319 {
9320 scmd->satacmd_addr_type = 0;
9321 scmd->satacmd_cmd_reg = cmd;
9322 scmd->satacmd_device_reg = 0;
9323 scmd->satacmd_sec_count_lsb = 0;
9324 scmd->satacmd_lba_low_lsb = 0;
9325 scmd->satacmd_lba_mid_lsb = 0;
9326 scmd->satacmd_lba_high_lsb = 0;
9327 scmd->satacmd_features_reg = 0;
9328 scmd->satacmd_status_reg = 0;
9329 scmd->satacmd_error_reg = 0;
9330 scmd->satacmd_flags.sata_special_regs = B_TRUE;
9331 }
9332
9333 /*
9334 * This function was used for changing the standby
9335 * timer format from SCSI to ATA.
9336 */
9337 static uint8_t
9338 sata_get_standby_timer(uint8_t *timer)
9339 {
9340 uint32_t i = 0, count = 0;
9341 uint8_t ata_count;
9342
9343 for (i = 0; i < 4; i++) {
9344 count = count << 8 | timer[i];
9345 }
9346
9347 if (count == 0)
9348 return (0);
9349
9350 if (count >= 1 && count <= 12000)
9351 ata_count = (count -1) / 50 + 1;
9352 else if (count > 12000 && count <= 12600)
9353 ata_count = 0xfc;
9354 else if (count > 12601 && count <= 12750)
9355 ata_count = 0xff;
9356 else if (count > 12750 && count <= 17999)
9357 ata_count = 0xf1;
9358 else if (count > 18000 && count <= 198000)
9359 ata_count = count / 18000 + 240;
9360 else
9361 ata_count = 0xfd;
9362 return (ata_count);
9363 }
9364
9365 /* ************************** ATAPI-SPECIFIC FUNCTIONS ********************** */
9366
9367 /*
9368 * Start command for ATAPI device.
9369 * This function processes scsi_pkt requests.
9370 * Now CD/DVD, tape and ATAPI disk devices are supported.
9371 * Most commands are packet without any translation into Packet Command.
9372 * Some may be trapped and executed as SATA commands (not clear which one).
9373 *
9374 * Returns TRAN_ACCEPT if command is accepted for execution (or completed
9375 * execution).
9376 * Returns other TRAN_XXXX codes if command is not accepted or completed
9377 * (see return values for sata_hba_start()).
9378 *
9379 * Note:
9380 * Inquiry cdb format differs between transport version 2 and 3.
9381 * However, the transport version 3 devices that were checked did not adhere
9382 * to the specification (ignored MSB of the allocation length). Therefore,
9383 * the transport version is not checked, but Inquiry allocation length is
9384 * truncated to 255 bytes if the original allocation length set-up by the
9385 * target driver is greater than 255 bytes.
9386 */
9387 static int
9388 sata_txlt_atapi(sata_pkt_txlate_t *spx)
9389 {
9390 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt;
9391 sata_cmd_t *scmd = &spx->txlt_sata_pkt->satapkt_cmd;
9392 struct buf *bp = spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp;
9393 sata_hba_inst_t *sata_hba = SATA_TXLT_HBA_INST(spx);
9394 sata_drive_info_t *sdinfo = sata_get_device_info(sata_hba,
9395 &spx->txlt_sata_pkt->satapkt_device);
9396 kmutex_t *cport_mutex = &(SATA_TXLT_CPORT_MUTEX(spx));
9397 int cdblen;
9398 int rval, reason;
9399 int synch;
9400 union scsi_cdb *cdbp = (union scsi_cdb *)scsipkt->pkt_cdbp;
9401
9402 mutex_enter(cport_mutex);
9403
9404 if (((rval = sata_txlt_generic_pkt_info(spx, &reason, 0)) !=
9405 TRAN_ACCEPT) || (reason == CMD_DEV_GONE)) {
9406 mutex_exit(cport_mutex);
9407 return (rval);
9408 }
9409
9410 /*
9411 * ATAPI device executes some ATA commands in addition to those
9412 * commands sent via PACKET command. These ATA commands may be
9413 * executed by the regular SATA translation functions. None needs
9414 * to be captured now.
9415 *
9416 * Commands sent via PACKET command include:
9417 * MMC command set for ATAPI CD/DVD device
9418 * SSC command set for ATAPI TAPE device
9419 * SBC command set for ATAPI disk device
9420 *
9421 */
9422
9423 /* Check the size of cdb */
9424
9425 switch (GETGROUP(cdbp)) {
9426 case CDB_GROUPID_3: /* Reserved, per SPC-4 */
9427 /*
9428 * opcodes 0x7e and 0x7f identify variable-length CDBs and
9429 * therefore require special handling. Return failure, for now.
9430 */
9431 mutex_exit(cport_mutex);
9432 return (TRAN_BADPKT);
9433
9434 case CDB_GROUPID_6: /* Vendor-specific, per SPC-4 */
9435 case CDB_GROUPID_7: /* Vendor-specific, per SPC-4 */
9436 /* obtain length from the scsi_pkt */
9437 cdblen = scsipkt->pkt_cdblen;
9438 break;
9439
9440 default:
9441 /* CDB's length is statically known, per SPC-4 */
9442 cdblen = scsi_cdb_size[GETGROUP(cdbp)];
9443 break;
9444 }
9445
9446 if (cdblen <= 0 || cdblen > sdinfo->satadrv_atapi_cdb_len) {
9447 sata_log(NULL, CE_WARN,
9448 "sata: invalid ATAPI cdb length %d",
9449 cdblen);
9450 mutex_exit(cport_mutex);
9451 return (TRAN_BADPKT);
9452 }
9453
9454 SATAATAPITRACE(spx, cdblen);
9455
9456 /*
9457 * For non-read/write commands we need to
9458 * map buffer
9459 */
9460 switch ((uint_t)scsipkt->pkt_cdbp[0]) {
9461 case SCMD_READ:
9462 case SCMD_READ_G1:
9463 case SCMD_READ_G5:
9464 case SCMD_READ_G4:
9465 case SCMD_WRITE:
9466 case SCMD_WRITE_G1:
9467 case SCMD_WRITE_G5:
9468 case SCMD_WRITE_G4:
9469 break;
9470 default:
9471 if (bp != NULL) {
9472 if (bp->b_flags & (B_PHYS | B_PAGEIO))
9473 bp_mapin(bp);
9474 }
9475 break;
9476 }
9477 /*
9478 * scmd->satacmd_flags.sata_data_direction default -
9479 * SATA_DIR_NODATA_XFER - is set by
9480 * sata_txlt_generic_pkt_info().
9481 */
9482 if (scmd->satacmd_bp) {
9483 if (scmd->satacmd_bp->b_flags & B_READ) {
9484 scmd->satacmd_flags.sata_data_direction = SATA_DIR_READ;
9485 } else {
9486 scmd->satacmd_flags.sata_data_direction =
9487 SATA_DIR_WRITE;
9488 }
9489 }
9490
9491 /*
9492 * Set up ATAPI packet command.
9493 */
9494
9495 sata_atapi_packet_cmd_setup(scmd, sdinfo);
9496
9497 /* Copy cdb into sata_cmd */
9498 scmd->satacmd_acdb_len = sdinfo->satadrv_atapi_cdb_len;
9499 bzero(scmd->satacmd_acdb, SATA_ATAPI_MAX_CDB_LEN);
9500 bcopy(cdbp, scmd->satacmd_acdb, cdblen);
9501
9502 /* See note in the command header */
9503 if (scmd->satacmd_acdb[0] == SCMD_INQUIRY) {
9504 if (scmd->satacmd_acdb[3] != 0)
9505 scmd->satacmd_acdb[4] = 255;
9506 }
9507
9508 #ifdef SATA_DEBUG
9509 if (sata_debug_flags & SATA_DBG_ATAPI) {
9510 uint8_t *p = scmd->satacmd_acdb;
9511 char buf[3 * SATA_ATAPI_MAX_CDB_LEN];
9512
9513 (void) snprintf(buf, SATA_ATAPI_MAX_CDB_LEN,
9514 "%02x %02x %02x %02x %02x %02x %02x %02x "
9515 "%2x %02x %02x %02x %02x %02x %02x %02x",
9516 p[0], p[1], p[2], p[3], p[4], p[5], p[6], p[7],
9517 p[8], p[9], p[10], p[11], p[12], p[13], p[14], p[15]);
9518 buf[(3 * SATA_ATAPI_MAX_CDB_LEN) - 1] = '\0';
9519 cmn_err(CE_NOTE, "ATAPI cdb: %s\n", buf);
9520 }
9521 #endif
9522
9523 /*
9524 * Preset request sense data to NO SENSE.
9525 * If there is no way to get error information via Request Sense,
9526 * the packet request sense data would not have to be modified by HBA,
9527 * but it could be returned as is.
9528 */
9529 bzero(scmd->satacmd_rqsense, SATA_ATAPI_RQSENSE_LEN);
9530 sata_fixed_sense_data_preset(
9531 (struct scsi_extended_sense *)scmd->satacmd_rqsense);
9532
9533 if (!(spx->txlt_sata_pkt->satapkt_op_mode & SATA_OPMODE_SYNCH)) {
9534 /* Need callback function */
9535 spx->txlt_sata_pkt->satapkt_comp = sata_txlt_atapi_completion;
9536 synch = FALSE;
9537 } else
9538 synch = TRUE;
9539
9540 /* Transfer command to HBA */
9541 if (sata_hba_start(spx, &rval) != 0) {
9542 /* Pkt not accepted for execution */
9543 mutex_exit(cport_mutex);
9544 return (rval);
9545 }
9546 mutex_exit(cport_mutex);
9547 /*
9548 * If execution is non-synchronous,
9549 * a callback function will handle potential errors, translate
9550 * the response and will do a callback to a target driver.
9551 * If it was synchronous, use the same framework callback to check
9552 * an execution status.
9553 */
9554 if (synch) {
9555 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst,
9556 "synchronous execution status %x\n",
9557 spx->txlt_sata_pkt->satapkt_reason);
9558 sata_txlt_atapi_completion(spx->txlt_sata_pkt);
9559 }
9560 return (TRAN_ACCEPT);
9561 }
9562
9563
9564 /*
9565 * ATAPI Packet command completion.
9566 *
9567 * Failure of the command passed via Packet command are considered device
9568 * error. SATA HBA driver would have to retrieve error data (via Request
9569 * Sense command delivered via error retrieval sata packet) and copy it
9570 * to satacmd_rqsense array. From there, it is moved into scsi pkt sense data.
9571 */
9572 static void
9573 sata_txlt_atapi_completion(sata_pkt_t *sata_pkt)
9574 {
9575 sata_pkt_txlate_t *spx =
9576 (sata_pkt_txlate_t *)sata_pkt->satapkt_framework_private;
9577 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt;
9578 struct scsi_extended_sense *sense;
9579 struct buf *bp;
9580 int rval;
9581
9582 #ifdef SATA_DEBUG
9583 uint8_t *rqsp = sata_pkt->satapkt_cmd.satacmd_rqsense;
9584 #endif
9585
9586 scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET |
9587 STATE_SENT_CMD | STATE_GOT_STATUS;
9588
9589 if (sata_pkt->satapkt_reason == SATA_PKT_COMPLETED) {
9590 /* Normal completion */
9591 if (sata_pkt->satapkt_cmd.satacmd_bp != NULL)
9592 scsipkt->pkt_state |= STATE_XFERRED_DATA;
9593 scsipkt->pkt_reason = CMD_CMPLT;
9594 *scsipkt->pkt_scbp = STATUS_GOOD;
9595 if (spx->txlt_tmp_buf != NULL) {
9596 /* Temporary buffer was used */
9597 bp = spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp;
9598 if (bp->b_flags & B_READ) {
9599 rval = ddi_dma_sync(
9600 spx->txlt_buf_dma_handle, 0, 0,
9601 DDI_DMA_SYNC_FORCPU);
9602 ASSERT(rval == DDI_SUCCESS);
9603 bcopy(spx->txlt_tmp_buf, bp->b_un.b_addr,
9604 bp->b_bcount);
9605 }
9606 }
9607 } else {
9608 /*
9609 * Something went wrong - analyze return
9610 */
9611 *scsipkt->pkt_scbp = STATUS_CHECK;
9612 sense = sata_arq_sense(spx);
9613
9614 if (sata_pkt->satapkt_reason == SATA_PKT_DEV_ERROR) {
9615 /*
9616 * pkt_reason should be CMD_CMPLT for DEVICE ERROR.
9617 * Under this condition ERR bit is set for ATA command,
9618 * and CHK bit set for ATAPI command.
9619 *
9620 * Please check st_intr & sdintr about how pkt_reason
9621 * is used.
9622 */
9623 scsipkt->pkt_reason = CMD_CMPLT;
9624
9625 /*
9626 * We may not have ARQ data if there was a double
9627 * error. But sense data in sata packet was pre-set
9628 * with NO SENSE so it is valid even if HBA could
9629 * not retrieve a real sense data.
9630 * Just copy this sense data into scsi pkt sense area.
9631 */
9632 bcopy(sata_pkt->satapkt_cmd.satacmd_rqsense, sense,
9633 SATA_ATAPI_MIN_RQSENSE_LEN);
9634 #ifdef SATA_DEBUG
9635 if (sata_debug_flags & SATA_DBG_SCSI_IF) {
9636 sata_log(spx->txlt_sata_hba_inst, CE_WARN,
9637 "sata_txlt_atapi_completion: %02x\n"
9638 "RQSENSE: %02x %02x %02x %02x %02x %02x "
9639 " %02x %02x %02x %02x %02x %02x "
9640 " %02x %02x %02x %02x %02x %02x\n",
9641 scsipkt->pkt_reason,
9642 rqsp[0], rqsp[1], rqsp[2], rqsp[3],
9643 rqsp[4], rqsp[5], rqsp[6], rqsp[7],
9644 rqsp[8], rqsp[9], rqsp[10], rqsp[11],
9645 rqsp[12], rqsp[13], rqsp[14], rqsp[15],
9646 rqsp[16], rqsp[17]);
9647 }
9648 #endif
9649 } else {
9650 switch (sata_pkt->satapkt_reason) {
9651 case SATA_PKT_PORT_ERROR:
9652 /*
9653 * We have no device data.
9654 */
9655 scsipkt->pkt_reason = CMD_INCOMPLETE;
9656 scsipkt->pkt_state &= ~(STATE_GOT_BUS |
9657 STATE_GOT_TARGET | STATE_SENT_CMD |
9658 STATE_GOT_STATUS);
9659 sense->es_key = KEY_HARDWARE_ERROR;
9660 break;
9661
9662 case SATA_PKT_TIMEOUT:
9663 scsipkt->pkt_reason = CMD_TIMEOUT;
9664 scsipkt->pkt_statistics |=
9665 STAT_TIMEOUT | STAT_DEV_RESET;
9666 /*
9667 * Need to check if HARDWARE_ERROR/
9668 * TIMEOUT_ON_LOGICAL_UNIT 4/3E/2 would be more
9669 * appropriate.
9670 */
9671 break;
9672
9673 case SATA_PKT_ABORTED:
9674 scsipkt->pkt_reason = CMD_ABORTED;
9675 scsipkt->pkt_statistics |= STAT_ABORTED;
9676 /* Should we set key COMMAND_ABPRTED? */
9677 break;
9678
9679 case SATA_PKT_RESET:
9680 scsipkt->pkt_reason = CMD_RESET;
9681 scsipkt->pkt_statistics |= STAT_DEV_RESET;
9682 /*
9683 * May be we should set Unit Attention /
9684 * Reset. Perhaps the same should be
9685 * returned for disks....
9686 */
9687 sense->es_key = KEY_UNIT_ATTENTION;
9688 sense->es_add_code = SD_SCSI_ASC_RESET;
9689 break;
9690
9691 default:
9692 SATA_LOG_D((spx->txlt_sata_hba_inst, CE_WARN,
9693 "sata_txlt_atapi_completion: "
9694 "invalid packet completion reason"));
9695 scsipkt->pkt_reason = CMD_TRAN_ERR;
9696 scsipkt->pkt_state &= ~(STATE_GOT_BUS |
9697 STATE_GOT_TARGET | STATE_SENT_CMD |
9698 STATE_GOT_STATUS);
9699 break;
9700 }
9701 }
9702 }
9703
9704 SATAATAPITRACE(spx, 0);
9705
9706 if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0 &&
9707 scsipkt->pkt_comp != NULL) {
9708 /* scsi callback required */
9709 (*scsipkt->pkt_comp)(scsipkt);
9710 }
9711 }
9712
9713 /*
9714 * Set up error retrieval sata command for ATAPI Packet Command error data
9715 * recovery.
9716 *
9717 * Returns SATA_SUCCESS when data buffer is allocated and packet set-up,
9718 * returns SATA_FAILURE otherwise.
9719 */
9720
9721 static int
9722 sata_atapi_err_ret_cmd_setup(sata_pkt_txlate_t *spx, sata_drive_info_t *sdinfo)
9723 {
9724 sata_pkt_t *spkt = spx->txlt_sata_pkt;
9725 sata_cmd_t *scmd;
9726 struct buf *bp;
9727
9728 /*
9729 * Allocate dma-able buffer error data.
9730 * Buffer allocation will take care of buffer alignment and other DMA
9731 * attributes.
9732 */
9733 bp = sata_alloc_local_buffer(spx, SATA_ATAPI_MIN_RQSENSE_LEN);
9734 if (bp == NULL) {
9735 SATADBG1(SATA_DBG_ATAPI, spx->txlt_sata_hba_inst,
9736 "sata_get_err_retrieval_pkt: "
9737 "cannot allocate buffer for error data", NULL);
9738 return (SATA_FAILURE);
9739 }
9740 bp_mapin(bp); /* make data buffer accessible */
9741
9742 /* Operation modes are up to the caller */
9743 spkt->satapkt_op_mode = SATA_OPMODE_SYNCH | SATA_OPMODE_INTERRUPTS;
9744
9745 /* Synchronous mode, no callback - may be changed by the caller */
9746 spkt->satapkt_comp = NULL;
9747 spkt->satapkt_time = sata_default_pkt_time;
9748
9749 scmd = &spkt->satapkt_cmd;
9750 scmd->satacmd_flags.sata_data_direction = SATA_DIR_READ;
9751 scmd->satacmd_flags.sata_ignore_dev_reset = B_TRUE;
9752
9753 sata_atapi_packet_cmd_setup(scmd, sdinfo);
9754
9755 /*
9756 * Set-up acdb. Request Sense CDB (packet command content) is
9757 * not in DMA-able buffer. Its handling is HBA-specific (how
9758 * it is transfered into packet FIS).
9759 */
9760 scmd->satacmd_acdb_len = sdinfo->satadrv_atapi_cdb_len;
9761 bcopy(sata_rqsense_cdb, scmd->satacmd_acdb, SATA_ATAPI_RQSENSE_CDB_LEN);
9762 /* Following zeroing of pad bytes may not be necessary */
9763 bzero(&scmd->satacmd_acdb[SATA_ATAPI_RQSENSE_CDB_LEN],
9764 sdinfo->satadrv_atapi_cdb_len - SATA_ATAPI_RQSENSE_CDB_LEN);
9765
9766 /*
9767 * Set-up pointer to the buffer handle, so HBA can sync buffer
9768 * before accessing it. Handle is in usual place in translate struct.
9769 */
9770 scmd->satacmd_err_ret_buf_handle = &spx->txlt_buf_dma_handle;
9771
9772 /*
9773 * Preset request sense data to NO SENSE.
9774 * Here it is redundant, only for a symetry with scsi-originated
9775 * packets. It should not be used for anything but debugging.
9776 */
9777 bzero(scmd->satacmd_rqsense, SATA_ATAPI_RQSENSE_LEN);
9778 sata_fixed_sense_data_preset(
9779 (struct scsi_extended_sense *)scmd->satacmd_rqsense);
9780
9781 ASSERT(scmd->satacmd_num_dma_cookies != 0);
9782 ASSERT(scmd->satacmd_dma_cookie_list != NULL);
9783
9784 return (SATA_SUCCESS);
9785 }
9786
9787 /*
9788 * Set-up ATAPI packet command.
9789 * Data transfer direction has to be set-up in sata_cmd structure prior to
9790 * calling this function.
9791 *
9792 * Returns void
9793 */
9794
9795 static void
9796 sata_atapi_packet_cmd_setup(sata_cmd_t *scmd, sata_drive_info_t *sdinfo)
9797 {
9798 scmd->satacmd_addr_type = 0; /* N/A */
9799 scmd->satacmd_sec_count_lsb = 0; /* no tag */
9800 scmd->satacmd_lba_low_lsb = 0; /* N/A */
9801 scmd->satacmd_lba_mid_lsb = (uint8_t)SATA_ATAPI_MAX_BYTES_PER_DRQ;
9802 scmd->satacmd_lba_high_lsb =
9803 (uint8_t)(SATA_ATAPI_MAX_BYTES_PER_DRQ >> 8);
9804 scmd->satacmd_cmd_reg = SATAC_PACKET; /* Command */
9805
9806 /*
9807 * We want all data to be transfered via DMA.
9808 * But specify it only if drive supports DMA and DMA mode is
9809 * selected - some drives are sensitive about it.
9810 * Hopefully it wil work for all drives....
9811 */
9812 if (sdinfo->satadrv_settings & SATA_DEV_DMA)
9813 scmd->satacmd_features_reg = SATA_ATAPI_F_DMA;
9814
9815 /*
9816 * Features register requires special care for devices that use
9817 * Serial ATA bridge - they need an explicit specification of
9818 * the data transfer direction for Packet DMA commands.
9819 * Setting this bit is harmless if DMA is not used.
9820 *
9821 * Many drives do not implement word 80, specifying what ATA/ATAPI
9822 * spec they follow.
9823 * We are arbitrarily following the latest SerialATA 2.6 spec,
9824 * which uses ATA/ATAPI 6 specification for Identify Data, unless
9825 * ATA/ATAPI-7 support is explicitly indicated.
9826 */
9827 if (sdinfo->satadrv_id.ai_majorversion != 0 &&
9828 sdinfo->satadrv_id.ai_majorversion != 0xffff &&
9829 (sdinfo->satadrv_id.ai_majorversion & SATA_MAJVER_7) != 0) {
9830 /*
9831 * Specification of major version is valid and version 7
9832 * is supported. It does automatically imply that all
9833 * spec features are supported. For now, we assume that
9834 * DMADIR setting is valid. ATA/ATAPI7 spec is incomplete.
9835 */
9836 if ((sdinfo->satadrv_id.ai_dirdma &
9837 SATA_ATAPI_ID_DMADIR_REQ) != 0) {
9838 if (scmd->satacmd_flags.sata_data_direction ==
9839 SATA_DIR_READ)
9840 scmd->satacmd_features_reg |=
9841 SATA_ATAPI_F_DATA_DIR_READ;
9842 }
9843 }
9844 }
9845
9846
9847 #ifdef SATA_DEBUG
9848
9849 /* Display 18 bytes of Inquiry data */
9850 static void
9851 sata_show_inqry_data(uint8_t *buf)
9852 {
9853 struct scsi_inquiry *inq = (struct scsi_inquiry *)buf;
9854 uint8_t *p;
9855
9856 cmn_err(CE_NOTE, "Inquiry data:");
9857 cmn_err(CE_NOTE, "device type %x", inq->inq_dtype);
9858 cmn_err(CE_NOTE, "removable media %x", inq->inq_rmb);
9859 cmn_err(CE_NOTE, "version %x", inq->inq_ansi);
9860 cmn_err(CE_NOTE, "ATAPI transport version %d",
9861 SATA_ATAPI_TRANS_VERSION(inq));
9862 cmn_err(CE_NOTE, "response data format %d, aenc %d",
9863 inq->inq_rdf, inq->inq_aenc);
9864 cmn_err(CE_NOTE, " additional length %d", inq->inq_len);
9865 cmn_err(CE_NOTE, "tpgs %d", inq->inq_tpgs);
9866 p = (uint8_t *)inq->inq_vid;
9867 cmn_err(CE_NOTE, "vendor id (binary): %02x %02x %02x %02x "
9868 "%02x %02x %02x %02x",
9869 p[0], p[1], p[2], p[3], p[4], p[5], p[6], p[7]);
9870 p = (uint8_t *)inq->inq_vid;
9871 cmn_err(CE_NOTE, "vendor id: %c %c %c %c %c %c %c %c",
9872 p[0], p[1], p[2], p[3], p[4], p[5], p[6], p[7]);
9873
9874 p = (uint8_t *)inq->inq_pid;
9875 cmn_err(CE_NOTE, "product id (binary): %02x %02x %02x %02x "
9876 "%02x %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x",
9877 p[0], p[1], p[2], p[3], p[4], p[5], p[6], p[7],
9878 p[8], p[9], p[10], p[11], p[12], p[13], p[14], p[15]);
9879 p = (uint8_t *)inq->inq_pid;
9880 cmn_err(CE_NOTE, "product id: %c %c %c %c %c %c %c %c "
9881 "%c %c %c %c %c %c %c %c",
9882 p[0], p[1], p[2], p[3], p[4], p[5], p[6], p[7],
9883 p[8], p[9], p[10], p[11], p[12], p[13], p[14], p[15]);
9884
9885 p = (uint8_t *)inq->inq_revision;
9886 cmn_err(CE_NOTE, "revision (binary): %02x %02x %02x %02x",
9887 p[0], p[1], p[2], p[3]);
9888 p = (uint8_t *)inq->inq_revision;
9889 cmn_err(CE_NOTE, "revision: %c %c %c %c",
9890 p[0], p[1], p[2], p[3]);
9891
9892 }
9893
9894
9895 static void
9896 sata_save_atapi_trace(sata_pkt_txlate_t *spx, int count)
9897 {
9898 struct scsi_pkt *scsi_pkt = spx->txlt_scsi_pkt;
9899
9900 if (scsi_pkt == NULL)
9901 return;
9902 if (count != 0) {
9903 /* saving cdb */
9904 bzero(sata_atapi_trace[sata_atapi_trace_index].acdb,
9905 SATA_ATAPI_MAX_CDB_LEN);
9906 bcopy(scsi_pkt->pkt_cdbp,
9907 sata_atapi_trace[sata_atapi_trace_index].acdb, count);
9908 } else {
9909 bcopy(&((struct scsi_arq_status *)scsi_pkt->pkt_scbp)->
9910 sts_sensedata,
9911 sata_atapi_trace[sata_atapi_trace_index].arqs,
9912 SATA_ATAPI_MIN_RQSENSE_LEN);
9913 sata_atapi_trace[sata_atapi_trace_index].scsi_pkt_reason =
9914 scsi_pkt->pkt_reason;
9915 sata_atapi_trace[sata_atapi_trace_index].sata_pkt_reason =
9916 spx->txlt_sata_pkt->satapkt_reason;
9917
9918 if (++sata_atapi_trace_index >= 64)
9919 sata_atapi_trace_index = 0;
9920 }
9921 }
9922
9923 #endif
9924
9925 /*
9926 * Fetch inquiry data from ATAPI device
9927 * Returns SATA_SUCCESS if operation was successful, SATA_FAILURE otherwise.
9928 *
9929 * Note:
9930 * inqb pointer does not point to a DMA-able buffer. It is a local buffer
9931 * where the caller expects to see the inquiry data.
9932 *
9933 */
9934
9935 static int
9936 sata_get_atapi_inquiry_data(sata_hba_inst_t *sata_hba,
9937 sata_address_t *saddr, struct scsi_inquiry *inq)
9938 {
9939 sata_pkt_txlate_t *spx;
9940 sata_pkt_t *spkt;
9941 struct buf *bp;
9942 sata_drive_info_t *sdinfo;
9943 sata_cmd_t *scmd;
9944 int rval;
9945 uint8_t *rqsp;
9946 dev_info_t *dip = SATA_DIP(sata_hba);
9947 #ifdef SATA_DEBUG
9948 char msg_buf[MAXPATHLEN];
9949 #endif
9950 kmutex_t *cport_mutex;
9951
9952 ASSERT(sata_hba != NULL);
9953
9954 spx = kmem_zalloc(sizeof (sata_pkt_txlate_t), KM_SLEEP);
9955 spx->txlt_sata_hba_inst = sata_hba;
9956 spx->txlt_scsi_pkt = NULL; /* No scsi pkt involved */
9957 spkt = sata_pkt_alloc(spx, NULL);
9958 if (spkt == NULL) {
9959 kmem_free(spx, sizeof (sata_pkt_txlate_t));
9960 return (SATA_FAILURE);
9961 }
9962 /* address is needed now */
9963 spkt->satapkt_device.satadev_addr = *saddr;
9964
9965 /* scsi_inquiry size buffer */
9966 bp = sata_alloc_local_buffer(spx, sizeof (struct scsi_inquiry));
9967 if (bp == NULL) {
9968 sata_pkt_free(spx);
9969 kmem_free(spx, sizeof (sata_pkt_txlate_t));
9970 SATA_LOG_D((sata_hba, CE_WARN,
9971 "sata_get_atapi_inquiry_data: "
9972 "cannot allocate data buffer"));
9973 return (SATA_FAILURE);
9974 }
9975 bp_mapin(bp); /* make data buffer accessible */
9976
9977 scmd = &spkt->satapkt_cmd;
9978 ASSERT(scmd->satacmd_num_dma_cookies != 0);
9979 ASSERT(scmd->satacmd_dma_cookie_list != NULL);
9980
9981 /* Use synchronous mode */
9982 spkt->satapkt_op_mode = SATA_OPMODE_SYNCH | SATA_OPMODE_INTERRUPTS;
9983 spkt->satapkt_comp = NULL;
9984 spkt->satapkt_time = sata_default_pkt_time;
9985
9986 /* Issue inquiry command - 6 bytes cdb, data transfer, read */
9987
9988 scmd->satacmd_flags.sata_data_direction = SATA_DIR_READ;
9989 scmd->satacmd_flags.sata_ignore_dev_reset = B_TRUE;
9990
9991 cport_mutex = &(SATA_CPORT_MUTEX(sata_hba, saddr->cport));
9992 mutex_enter(cport_mutex);
9993 sdinfo = sata_get_device_info(sata_hba,
9994 &spx->txlt_sata_pkt->satapkt_device);
9995 if (sdinfo == NULL) {
9996 /* we have to be carefull about the disapearing device */
9997 mutex_exit(cport_mutex);
9998 rval = SATA_FAILURE;
9999 goto cleanup;
10000 }
10001 sata_atapi_packet_cmd_setup(scmd, sdinfo);
10002
10003 /*
10004 * Set-up acdb. This works for atapi transport version 2 and later.
10005 */
10006 scmd->satacmd_acdb_len = sdinfo->satadrv_atapi_cdb_len;
10007 bzero(scmd->satacmd_acdb, SATA_ATAPI_MAX_CDB_LEN);
10008 scmd->satacmd_acdb[0] = 0x12; /* Inquiry */
10009 scmd->satacmd_acdb[1] = 0x00;
10010 scmd->satacmd_acdb[2] = 0x00;
10011 scmd->satacmd_acdb[3] = 0x00;
10012 scmd->satacmd_acdb[4] = sizeof (struct scsi_inquiry);
10013 scmd->satacmd_acdb[5] = 0x00;
10014
10015 sata_fixed_sense_data_preset(
10016 (struct scsi_extended_sense *)scmd->satacmd_rqsense);
10017
10018 /* Transfer command to HBA */
10019 if (sata_hba_start(spx, &rval) != 0) {
10020 /* Pkt not accepted for execution */
10021 SATADBG1(SATA_DBG_ATAPI, sata_hba,
10022 "sata_get_atapi_inquiry_data: "
10023 "Packet not accepted for execution - ret: %02x", rval);
10024 mutex_exit(cport_mutex);
10025 rval = SATA_FAILURE;
10026 goto cleanup;
10027 }
10028 mutex_exit(cport_mutex);
10029
10030 if (spkt->satapkt_reason == SATA_PKT_COMPLETED) {
10031 SATADBG1(SATA_DBG_ATAPI, sata_hba,
10032 "sata_get_atapi_inquiry_data: "
10033 "Packet completed successfully - ret: %02x", rval);
10034 if (spx->txlt_buf_dma_handle != NULL) {
10035 /*
10036 * Sync buffer. Handle is in usual place in translate
10037 * struct.
10038 */
10039 rval = ddi_dma_sync(spx->txlt_buf_dma_handle, 0, 0,
10040 DDI_DMA_SYNC_FORCPU);
10041 ASSERT(rval == DDI_SUCCESS);
10042 }
10043
10044 if (sata_check_for_dma_error(dip, spx)) {
10045 ddi_fm_service_impact(dip, DDI_SERVICE_UNAFFECTED);
10046 rval = SATA_FAILURE;
10047 } else {
10048 /*
10049 * Normal completion - copy data into caller's buffer
10050 */
10051 bcopy(bp->b_un.b_addr, (uint8_t *)inq,
10052 sizeof (struct scsi_inquiry));
10053 #ifdef SATA_DEBUG
10054 if (sata_debug_flags & SATA_DBG_ATAPI) {
10055 sata_show_inqry_data((uint8_t *)inq);
10056 }
10057 #endif
10058 rval = SATA_SUCCESS;
10059 }
10060 } else {
10061 /*
10062 * Something went wrong - analyze return - check rqsense data
10063 */
10064 rval = SATA_FAILURE;
10065 if (spkt->satapkt_reason == SATA_PKT_DEV_ERROR) {
10066 /*
10067 * ARQ data hopefull show something other than NO SENSE
10068 */
10069 rqsp = scmd->satacmd_rqsense;
10070 #ifdef SATA_DEBUG
10071 if (sata_debug_flags & SATA_DBG_ATAPI) {
10072 msg_buf[0] = '\0';
10073 (void) snprintf(msg_buf, MAXPATHLEN,
10074 "ATAPI packet completion reason: %02x\n"
10075 "RQSENSE: %02x %02x %02x %02x %02x %02x\n"
10076 " %02x %02x %02x %02x %02x %02x\n"
10077 " %02x %02x %02x %02x %02x %02x",
10078 spkt->satapkt_reason,
10079 rqsp[0], rqsp[1], rqsp[2], rqsp[3],
10080 rqsp[4], rqsp[5], rqsp[6], rqsp[7],
10081 rqsp[8], rqsp[9], rqsp[10], rqsp[11],
10082 rqsp[12], rqsp[13], rqsp[14], rqsp[15],
10083 rqsp[16], rqsp[17]);
10084 sata_log(spx->txlt_sata_hba_inst, CE_WARN,
10085 "%s", msg_buf);
10086 }
10087 #endif
10088 } else {
10089 switch (spkt->satapkt_reason) {
10090 case SATA_PKT_PORT_ERROR:
10091 SATADBG1(SATA_DBG_ATAPI, sata_hba,
10092 "sata_get_atapi_inquiry_data: "
10093 "packet reason: port error", NULL);
10094 break;
10095
10096 case SATA_PKT_TIMEOUT:
10097 SATADBG1(SATA_DBG_ATAPI, sata_hba,
10098 "sata_get_atapi_inquiry_data: "
10099 "packet reason: timeout", NULL);
10100 break;
10101
10102 case SATA_PKT_ABORTED:
10103 SATADBG1(SATA_DBG_ATAPI, sata_hba,
10104 "sata_get_atapi_inquiry_data: "
10105 "packet reason: aborted", NULL);
10106 break;
10107
10108 case SATA_PKT_RESET:
10109 SATADBG1(SATA_DBG_ATAPI, sata_hba,
10110 "sata_get_atapi_inquiry_data: "
10111 "packet reason: reset\n", NULL);
10112 break;
10113 default:
10114 SATADBG1(SATA_DBG_ATAPI, sata_hba,
10115 "sata_get_atapi_inquiry_data: "
10116 "invalid packet reason: %02x\n",
10117 spkt->satapkt_reason);
10118 break;
10119 }
10120 }
10121 }
10122 cleanup:
10123 sata_free_local_buffer(spx);
10124 sata_pkt_free(spx);
10125 kmem_free(spx, sizeof (sata_pkt_txlate_t));
10126 return (rval);
10127 }
10128
10129
10130
10131
10132
10133 #if 0
10134 #ifdef SATA_DEBUG
10135
10136 /*
10137 * Test ATAPI packet command.
10138 * Single threaded test: send packet command in synch mode, process completion
10139 *
10140 */
10141 static void
10142 sata_test_atapi_packet_command(sata_hba_inst_t *sata_hba_inst, int cport)
10143 {
10144 sata_pkt_txlate_t *spx;
10145 sata_pkt_t *spkt;
10146 struct buf *bp;
10147 sata_device_t sata_device;
10148 sata_drive_info_t *sdinfo;
10149 sata_cmd_t *scmd;
10150 int rval;
10151 uint8_t *rqsp;
10152
10153 ASSERT(sata_hba_inst != NULL);
10154 sata_device.satadev_addr.cport = cport;
10155 sata_device.satadev_addr.pmport = 0;
10156 sata_device.satadev_addr.qual = SATA_ADDR_DCPORT;
10157 sata_device.satadev_rev = SATA_DEVICE_REV;
10158 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex);
10159 sdinfo = sata_get_device_info(sata_hba_inst, &sata_device);
10160 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex);
10161 if (sdinfo == NULL) {
10162 sata_log(sata_hba_inst, CE_WARN,
10163 "sata_test_atapi_packet_command: "
10164 "no device info for cport %d",
10165 sata_device.satadev_addr.cport);
10166 return;
10167 }
10168
10169 spx = kmem_zalloc(sizeof (sata_pkt_txlate_t), KM_SLEEP);
10170 spx->txlt_sata_hba_inst = sata_hba_inst;
10171 spx->txlt_scsi_pkt = NULL; /* No scsi pkt involved */
10172 spkt = sata_pkt_alloc(spx, NULL);
10173 if (spkt == NULL) {
10174 kmem_free(spx, sizeof (sata_pkt_txlate_t));
10175 return;
10176 }
10177 /* address is needed now */
10178 spkt->satapkt_device.satadev_addr = sata_device.satadev_addr;
10179
10180 /* 1024k buffer */
10181 bp = sata_alloc_local_buffer(spx, 1024);
10182 if (bp == NULL) {
10183 sata_pkt_free(spx);
10184 kmem_free(spx, sizeof (sata_pkt_txlate_t));
10185 sata_log(sata_hba_inst, CE_WARN,
10186 "sata_test_atapi_packet_command: "
10187 "cannot allocate data buffer");
10188 return;
10189 }
10190 bp_mapin(bp); /* make data buffer accessible */
10191
10192 scmd = &spkt->satapkt_cmd;
10193 ASSERT(scmd->satacmd_num_dma_cookies != 0);
10194 ASSERT(scmd->satacmd_dma_cookie_list != NULL);
10195
10196 /* Use synchronous mode */
10197 spkt->satapkt_op_mode = SATA_OPMODE_SYNCH | SATA_OPMODE_INTERRUPTS;
10198
10199 /* Synchronous mode, no callback - may be changed by the caller */
10200 spkt->satapkt_comp = NULL;
10201 spkt->satapkt_time = sata_default_pkt_time;
10202
10203 /* Issue inquiry command - 6 bytes cdb, data transfer, read */
10204
10205 scmd->satacmd_flags.sata_data_direction = SATA_DIR_READ;
10206 scmd->satacmd_flags.sata_ignore_dev_reset = B_TRUE;
10207
10208 sata_atapi_packet_cmd_setup(scmd, sdinfo);
10209
10210 /* Set-up acdb. */
10211 scmd->satacmd_acdb_len = sdinfo->satadrv_atapi_cdb_len;
10212 bzero(scmd->satacmd_acdb, SATA_ATAPI_MAX_CDB_LEN);
10213 scmd->satacmd_acdb[0] = 0x12; /* Inquiry */
10214 scmd->satacmd_acdb[1] = 0x00;
10215 scmd->satacmd_acdb[2] = 0x00;
10216 scmd->satacmd_acdb[3] = 0x00;
10217 scmd->satacmd_acdb[4] = sizeof (struct scsi_inquiry);
10218 scmd->satacmd_acdb[5] = 0x00;
10219
10220 sata_fixed_sense_data_preset(
10221 (struct scsi_extended_sense *)scmd->satacmd_rqsense);
10222
10223 /* Transfer command to HBA */
10224 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex);
10225 if (sata_hba_start(spx, &rval) != 0) {
10226 /* Pkt not accepted for execution */
10227 sata_log(sata_hba_inst, CE_WARN,
10228 "sata_test_atapi_packet_command: "
10229 "Packet not accepted for execution - ret: %02x", rval);
10230 mutex_exit(
10231 &SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex);
10232 goto cleanup;
10233 }
10234 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex);
10235
10236 if (spx->txlt_buf_dma_handle != NULL) {
10237 /*
10238 * Sync buffer. Handle is in usual place in translate struct.
10239 */
10240 rval = ddi_dma_sync(spx->txlt_buf_dma_handle, 0, 0,
10241 DDI_DMA_SYNC_FORCPU);
10242 ASSERT(rval == DDI_SUCCESS);
10243 }
10244 if (spkt->satapkt_reason == SATA_PKT_COMPLETED) {
10245 sata_log(sata_hba_inst, CE_WARN,
10246 "sata_test_atapi_packet_command: "
10247 "Packet completed successfully");
10248 /*
10249 * Normal completion - show inquiry data
10250 */
10251 sata_show_inqry_data((uint8_t *)bp->b_un.b_addr);
10252 } else {
10253 /*
10254 * Something went wrong - analyze return - check rqsense data
10255 */
10256 if (spkt->satapkt_reason == SATA_PKT_DEV_ERROR) {
10257 /*
10258 * ARQ data hopefull show something other than NO SENSE
10259 */
10260 rqsp = scmd->satacmd_rqsense;
10261 sata_log(spx->txlt_sata_hba_inst, CE_WARN,
10262 "ATAPI packet completion reason: %02x\n"
10263 "RQSENSE: %02x %02x %02x %02x %02x %02x "
10264 " %02x %02x %02x %02x %02x %02x "
10265 " %02x %02x %02x %02x %02x %02x\n",
10266 spkt->satapkt_reason,
10267 rqsp[0], rqsp[1], rqsp[2], rqsp[3],
10268 rqsp[4], rqsp[5], rqsp[6], rqsp[7],
10269 rqsp[8], rqsp[9], rqsp[10], rqsp[11],
10270 rqsp[12], rqsp[13], rqsp[14], rqsp[15],
10271 rqsp[16], rqsp[17]);
10272 } else {
10273 switch (spkt->satapkt_reason) {
10274 case SATA_PKT_PORT_ERROR:
10275 sata_log(sata_hba_inst, CE_WARN,
10276 "sata_test_atapi_packet_command: "
10277 "packet reason: port error\n");
10278 break;
10279
10280 case SATA_PKT_TIMEOUT:
10281 sata_log(sata_hba_inst, CE_WARN,
10282 "sata_test_atapi_packet_command: "
10283 "packet reason: timeout\n");
10284 break;
10285
10286 case SATA_PKT_ABORTED:
10287 sata_log(sata_hba_inst, CE_WARN,
10288 "sata_test_atapi_packet_command: "
10289 "packet reason: aborted\n");
10290 break;
10291
10292 case SATA_PKT_RESET:
10293 sata_log(sata_hba_inst, CE_WARN,
10294 "sata_test_atapi_packet_command: "
10295 "packet reason: reset\n");
10296 break;
10297 default:
10298 sata_log(sata_hba_inst, CE_WARN,
10299 "sata_test_atapi_packet_command: "
10300 "invalid packet reason: %02x\n",
10301 spkt->satapkt_reason);
10302 break;
10303 }
10304 }
10305 }
10306 cleanup:
10307 sata_free_local_buffer(spx);
10308 sata_pkt_free(spx);
10309 kmem_free(spx, sizeof (sata_pkt_txlate_t));
10310 }
10311
10312 #endif /* SATA_DEBUG */
10313 #endif /* 1 */
10314
10315
10316 /* ************************** LOCAL HELPER FUNCTIONS *********************** */
10317
10318 /*
10319 * Validate sata_tran info
10320 * SATA_FAILURE returns if structure is inconsistent or structure revision
10321 * does not match one used by the framework.
10322 *
10323 * Returns SATA_SUCCESS if sata_hba_tran has matching revision and contains
10324 * required function pointers.
10325 * Returns SATA_FAILURE otherwise.
10326 */
10327 static int
10328 sata_validate_sata_hba_tran(dev_info_t *dip, sata_hba_tran_t *sata_tran)
10329 {
10330 /*
10331 * SATA_TRAN_HBA_REV is the current (highest) revision number
10332 * of the SATA interface.
10333 */
10334 if (sata_tran->sata_tran_hba_rev > SATA_TRAN_HBA_REV) {
10335 sata_log(NULL, CE_WARN,
10336 "sata: invalid sata_hba_tran version %d for driver %s",
10337 sata_tran->sata_tran_hba_rev, ddi_driver_name(dip));
10338 return (SATA_FAILURE);
10339 }
10340
10341 if (dip != sata_tran->sata_tran_hba_dip) {
10342 SATA_LOG_D((NULL, CE_WARN,
10343 "sata: inconsistent sata_tran_hba_dip "
10344 "%p / %p", sata_tran->sata_tran_hba_dip, dip));
10345 return (SATA_FAILURE);
10346 }
10347
10348 if (sata_tran->sata_tran_probe_port == NULL ||
10349 sata_tran->sata_tran_start == NULL ||
10350 sata_tran->sata_tran_abort == NULL ||
10351 sata_tran->sata_tran_reset_dport == NULL ||
10352 sata_tran->sata_tran_hotplug_ops == NULL ||
10353 sata_tran->sata_tran_hotplug_ops->sata_tran_port_activate == NULL ||
10354 sata_tran->sata_tran_hotplug_ops->sata_tran_port_deactivate ==
10355 NULL) {
10356 SATA_LOG_D((NULL, CE_WARN, "sata: sata_hba_tran missing "
10357 "required functions"));
10358 }
10359 return (SATA_SUCCESS);
10360 }
10361
10362 /*
10363 * Remove HBA instance from sata_hba_list.
10364 */
10365 static void
10366 sata_remove_hba_instance(dev_info_t *dip)
10367 {
10368 sata_hba_inst_t *sata_hba_inst;
10369
10370 mutex_enter(&sata_mutex);
10371 for (sata_hba_inst = sata_hba_list;
10372 sata_hba_inst != (struct sata_hba_inst *)NULL;
10373 sata_hba_inst = sata_hba_inst->satahba_next) {
10374 if (sata_hba_inst->satahba_dip == dip)
10375 break;
10376 }
10377
10378 if (sata_hba_inst == (struct sata_hba_inst *)NULL) {
10379 #ifdef SATA_DEBUG
10380 cmn_err(CE_WARN, "sata_remove_hba_instance: "
10381 "unknown HBA instance\n");
10382 #endif
10383 ASSERT(FALSE);
10384 }
10385 if (sata_hba_inst == sata_hba_list) {
10386 sata_hba_list = sata_hba_inst->satahba_next;
10387 if (sata_hba_list) {
10388 sata_hba_list->satahba_prev =
10389 (struct sata_hba_inst *)NULL;
10390 }
10391 if (sata_hba_inst == sata_hba_list_tail) {
10392 sata_hba_list_tail = NULL;
10393 }
10394 } else if (sata_hba_inst == sata_hba_list_tail) {
10395 sata_hba_list_tail = sata_hba_inst->satahba_prev;
10396 if (sata_hba_list_tail) {
10397 sata_hba_list_tail->satahba_next =
10398 (struct sata_hba_inst *)NULL;
10399 }
10400 } else {
10401 sata_hba_inst->satahba_prev->satahba_next =
10402 sata_hba_inst->satahba_next;
10403 sata_hba_inst->satahba_next->satahba_prev =
10404 sata_hba_inst->satahba_prev;
10405 }
10406 mutex_exit(&sata_mutex);
10407 }
10408
10409 /*
10410 * Probe all SATA ports of the specified HBA instance.
10411 * The assumption is that there are no target and attachment point minor nodes
10412 * created by the boot subsystems, so we do not need to prune device tree.
10413 *
10414 * This function is called only from sata_hba_attach(). It does not have to
10415 * be protected by controller mutex, because the hba_attached flag is not set
10416 * yet and no one would be touching this HBA instance other than this thread.
10417 * Determines if port is active and what type of the device is attached
10418 * (if any). Allocates necessary structures for each port.
10419 *
10420 * An AP (Attachement Point) node is created for each SATA device port even
10421 * when there is no device attached.
10422 */
10423
10424 static void
10425 sata_probe_ports(sata_hba_inst_t *sata_hba_inst)
10426 {
10427 dev_info_t *dip = SATA_DIP(sata_hba_inst);
10428 int ncport;
10429 sata_cport_info_t *cportinfo;
10430 sata_drive_info_t *drive;
10431 sata_device_t sata_device;
10432 int rval;
10433 dev_t minor_number;
10434 char name[16];
10435 clock_t start_time, cur_time;
10436
10437 /*
10438 * Probe controller ports first, to find port status and
10439 * any port multiplier attached.
10440 */
10441 for (ncport = 0; ncport < SATA_NUM_CPORTS(sata_hba_inst); ncport++) {
10442 /* allocate cport structure */
10443 cportinfo = kmem_zalloc(sizeof (sata_cport_info_t), KM_SLEEP);
10444 ASSERT(cportinfo != NULL);
10445 mutex_init(&cportinfo->cport_mutex, NULL, MUTEX_DRIVER, NULL);
10446
10447 mutex_enter(&cportinfo->cport_mutex);
10448
10449 cportinfo->cport_addr.cport = ncport;
10450 cportinfo->cport_addr.pmport = 0;
10451 cportinfo->cport_addr.qual = SATA_ADDR_CPORT;
10452 cportinfo->cport_state &= ~SATA_PORT_STATE_CLEAR_MASK;
10453 cportinfo->cport_state |= SATA_STATE_PROBING;
10454 SATA_CPORT_INFO(sata_hba_inst, ncport) = cportinfo;
10455
10456 /*
10457 * Regardless if a port is usable or not, create
10458 * an attachment point
10459 */
10460 mutex_exit(&cportinfo->cport_mutex);
10461 minor_number = SATA_MAKE_AP_MINOR(ddi_get_instance(dip),
10462 ncport, 0, SATA_ADDR_CPORT);
10463 (void) sprintf(name, "%d", ncport);
10464 if (ddi_create_minor_node(dip, name, S_IFCHR,
10465 minor_number, DDI_NT_SATA_ATTACHMENT_POINT, 0) !=
10466 DDI_SUCCESS) {
10467 sata_log(sata_hba_inst, CE_WARN, "sata_hba_attach: "
10468 "cannot create SATA attachment point for port %d",
10469 ncport);
10470 }
10471
10472 /* Probe port */
10473 start_time = ddi_get_lbolt();
10474 reprobe_cport:
10475 sata_device.satadev_addr.cport = ncport;
10476 sata_device.satadev_addr.pmport = 0;
10477 sata_device.satadev_addr.qual = SATA_ADDR_CPORT;
10478 sata_device.satadev_rev = SATA_DEVICE_REV;
10479
10480 rval = (*SATA_PROBE_PORT_FUNC(sata_hba_inst))
10481 (dip, &sata_device);
10482
10483 mutex_enter(&cportinfo->cport_mutex);
10484 cportinfo->cport_scr = sata_device.satadev_scr;
10485 if (rval != SATA_SUCCESS) {
10486 /* Something went wrong? Fail the port */
10487 cportinfo->cport_state = SATA_PSTATE_FAILED;
10488 mutex_exit(&cportinfo->cport_mutex);
10489 continue;
10490 }
10491 cportinfo->cport_state &= ~SATA_STATE_PROBING;
10492 cportinfo->cport_state |= SATA_STATE_PROBED;
10493 cportinfo->cport_dev_type = sata_device.satadev_type;
10494
10495 cportinfo->cport_state |= SATA_STATE_READY;
10496 if (cportinfo->cport_dev_type == SATA_DTYPE_NONE) {
10497 mutex_exit(&cportinfo->cport_mutex);
10498 continue;
10499 }
10500 if (cportinfo->cport_dev_type != SATA_DTYPE_PMULT) {
10501 /*
10502 * There is some device attached.
10503 * Allocate device info structure
10504 */
10505 if (SATA_CPORTINFO_DRV_INFO(cportinfo) == NULL) {
10506 mutex_exit(&cportinfo->cport_mutex);
10507 SATA_CPORTINFO_DRV_INFO(cportinfo) =
10508 kmem_zalloc(sizeof (sata_drive_info_t),
10509 KM_SLEEP);
10510 mutex_enter(&cportinfo->cport_mutex);
10511 }
10512 drive = SATA_CPORTINFO_DRV_INFO(cportinfo);
10513 drive->satadrv_addr = cportinfo->cport_addr;
10514 drive->satadrv_addr.qual = SATA_ADDR_DCPORT;
10515 drive->satadrv_type = cportinfo->cport_dev_type;
10516 drive->satadrv_state = SATA_STATE_UNKNOWN;
10517
10518 mutex_exit(&cportinfo->cport_mutex);
10519 if (sata_add_device(dip, sata_hba_inst, &sata_device) !=
10520 SATA_SUCCESS) {
10521 /*
10522 * Plugged device was not correctly identified.
10523 * Retry, within a SATA_DEV_IDENTIFY_TIMEOUT
10524 */
10525 cur_time = ddi_get_lbolt();
10526 if ((cur_time - start_time) <
10527 drv_usectohz(SATA_DEV_IDENTIFY_TIMEOUT)) {
10528 /* sleep for a while */
10529 delay(drv_usectohz(
10530 SATA_DEV_RETRY_DLY));
10531 goto reprobe_cport;
10532 }
10533 }
10534 } else { /* SATA_DTYPE_PMULT */
10535 mutex_exit(&cportinfo->cport_mutex);
10536
10537 /* Allocate sata_pmult_info and sata_pmport_info */
10538 if (sata_alloc_pmult(sata_hba_inst, &sata_device) !=
10539 SATA_SUCCESS)
10540 continue;
10541
10542 /* Log the information of the port multiplier */
10543 sata_show_pmult_info(sata_hba_inst, &sata_device);
10544
10545 /* Probe its pmports */
10546 sata_probe_pmports(sata_hba_inst, ncport);
10547 }
10548 }
10549 }
10550
10551 /*
10552 * Probe all device ports behind a port multiplier.
10553 *
10554 * PMult-related structure should be allocated before by sata_alloc_pmult().
10555 *
10556 * NOTE1: Only called from sata_probe_ports()
10557 * NOTE2: No mutex should be hold.
10558 */
10559 static void
10560 sata_probe_pmports(sata_hba_inst_t *sata_hba_inst, uint8_t ncport)
10561 {
10562 dev_info_t *dip = SATA_DIP(sata_hba_inst);
10563 sata_pmult_info_t *pmultinfo = NULL;
10564 sata_pmport_info_t *pmportinfo = NULL;
10565 sata_drive_info_t *drive = NULL;
10566 sata_device_t sata_device;
10567
10568 clock_t start_time, cur_time;
10569 int npmport;
10570 int rval;
10571
10572 pmultinfo = SATA_PMULT_INFO(sata_hba_inst, ncport);
10573
10574 /* Probe Port Multiplier ports */
10575 for (npmport = 0; npmport < pmultinfo->pmult_num_dev_ports; npmport++) {
10576 pmportinfo = pmultinfo->pmult_dev_port[npmport];
10577 start_time = ddi_get_lbolt();
10578 reprobe_pmport:
10579 sata_device.satadev_addr.cport = ncport;
10580 sata_device.satadev_addr.pmport = npmport;
10581 sata_device.satadev_addr.qual = SATA_ADDR_PMPORT;
10582 sata_device.satadev_rev = SATA_DEVICE_REV;
10583
10584 /* Let HBA driver probe it. */
10585 rval = (*SATA_PROBE_PORT_FUNC(sata_hba_inst))
10586 (dip, &sata_device);
10587 mutex_enter(&pmportinfo->pmport_mutex);
10588
10589 pmportinfo->pmport_scr = sata_device.satadev_scr;
10590
10591 if (rval != SATA_SUCCESS) {
10592 pmportinfo->pmport_state =
10593 SATA_PSTATE_FAILED;
10594 mutex_exit(&pmportinfo->pmport_mutex);
10595 continue;
10596 }
10597 pmportinfo->pmport_state &= ~SATA_STATE_PROBING;
10598 pmportinfo->pmport_state |= SATA_STATE_PROBED;
10599 pmportinfo->pmport_dev_type = sata_device.satadev_type;
10600
10601 pmportinfo->pmport_state |= SATA_STATE_READY;
10602 if (pmportinfo->pmport_dev_type ==
10603 SATA_DTYPE_NONE) {
10604 SATADBG2(SATA_DBG_PMULT, sata_hba_inst,
10605 "no device found at port %d:%d", ncport, npmport);
10606 mutex_exit(&pmportinfo->pmport_mutex);
10607 continue;
10608 }
10609 /* Port multipliers cannot be chained */
10610 ASSERT(pmportinfo->pmport_dev_type != SATA_DTYPE_PMULT);
10611 /*
10612 * There is something attached to Port
10613 * Multiplier device port
10614 * Allocate device info structure
10615 */
10616 if (pmportinfo->pmport_sata_drive == NULL) {
10617 mutex_exit(&pmportinfo->pmport_mutex);
10618 pmportinfo->pmport_sata_drive =
10619 kmem_zalloc(sizeof (sata_drive_info_t), KM_SLEEP);
10620 mutex_enter(&pmportinfo->pmport_mutex);
10621 }
10622 drive = pmportinfo->pmport_sata_drive;
10623 drive->satadrv_addr.cport = pmportinfo->pmport_addr.cport;
10624 drive->satadrv_addr.pmport = npmport;
10625 drive->satadrv_addr.qual = SATA_ADDR_DPMPORT;
10626 drive->satadrv_type = pmportinfo-> pmport_dev_type;
10627 drive->satadrv_state = SATA_STATE_UNKNOWN;
10628
10629 mutex_exit(&pmportinfo->pmport_mutex);
10630 rval = sata_add_device(dip, sata_hba_inst, &sata_device);
10631
10632 if (rval != SATA_SUCCESS) {
10633 /*
10634 * Plugged device was not correctly identified.
10635 * Retry, within the SATA_DEV_IDENTIFY_TIMEOUT
10636 */
10637 cur_time = ddi_get_lbolt();
10638 if ((cur_time - start_time) < drv_usectohz(
10639 SATA_DEV_IDENTIFY_TIMEOUT)) {
10640 /* sleep for a while */
10641 delay(drv_usectohz(SATA_DEV_RETRY_DLY));
10642 goto reprobe_pmport;
10643 }
10644 }
10645 }
10646 }
10647
10648 /*
10649 * Add SATA device for specified HBA instance & port (SCSI target
10650 * device nodes).
10651 * This function is called (indirectly) only from sata_hba_attach().
10652 * A target node is created when there is a supported type device attached,
10653 * but may be removed if it cannot be put online.
10654 *
10655 * This function cannot be called from an interrupt context.
10656 *
10657 * Create target nodes for disk, CD/DVD, Tape and ATAPI disk devices
10658 *
10659 * Returns SATA_SUCCESS when port/device was fully processed, SATA_FAILURE when
10660 * device identification failed - adding a device could be retried.
10661 *
10662 */
10663 static int
10664 sata_add_device(dev_info_t *pdip, sata_hba_inst_t *sata_hba_inst,
10665 sata_device_t *sata_device)
10666 {
10667 sata_cport_info_t *cportinfo;
10668 sata_pmult_info_t *pminfo;
10669 sata_pmport_info_t *pmportinfo;
10670 dev_info_t *cdip; /* child dip */
10671 sata_address_t *saddr = &sata_device->satadev_addr;
10672 uint8_t cport, pmport;
10673 int rval;
10674
10675 cport = saddr->cport;
10676 pmport = saddr->pmport;
10677 cportinfo = SATA_CPORT_INFO(sata_hba_inst, cport);
10678 ASSERT(cportinfo->cport_dev_type != SATA_DTYPE_NONE);
10679
10680 /*
10681 * Some device is attached to a controller port.
10682 * We rely on controllers distinquishing between no-device,
10683 * attached port multiplier and other kind of attached device.
10684 * We need to get Identify Device data and determine
10685 * positively the dev type before trying to attach
10686 * the target driver.
10687 */
10688 sata_device->satadev_rev = SATA_DEVICE_REV;
10689 switch (saddr->qual) {
10690 case SATA_ADDR_CPORT:
10691 /*
10692 * Add a non-port-multiplier device at controller port.
10693 */
10694 saddr->qual = SATA_ADDR_DCPORT;
10695
10696 rval = sata_probe_device(sata_hba_inst, sata_device);
10697 if (rval != SATA_SUCCESS ||
10698 sata_device->satadev_type == SATA_DTYPE_UNKNOWN)
10699 return (SATA_FAILURE);
10700
10701 mutex_enter(&cportinfo->cport_mutex);
10702 sata_show_drive_info(sata_hba_inst,
10703 SATA_CPORTINFO_DRV_INFO(cportinfo));
10704
10705 if ((sata_device->satadev_type & SATA_VALID_DEV_TYPE) == 0) {
10706 /*
10707 * Could not determine device type or
10708 * a device is not supported.
10709 * Degrade this device to unknown.
10710 */
10711 cportinfo->cport_dev_type = SATA_DTYPE_UNKNOWN;
10712 mutex_exit(&cportinfo->cport_mutex);
10713 return (SATA_SUCCESS);
10714 }
10715 cportinfo->cport_dev_type = sata_device->satadev_type;
10716 cportinfo->cport_tgtnode_clean = B_TRUE;
10717 mutex_exit(&cportinfo->cport_mutex);
10718
10719 /*
10720 * Initialize device to the desired state. Even if it
10721 * fails, the device will still attach but syslog
10722 * will show the warning.
10723 */
10724 if (sata_initialize_device(sata_hba_inst,
10725 SATA_CPORTINFO_DRV_INFO(cportinfo)) != SATA_SUCCESS) {
10726 /* Retry */
10727 rval = sata_initialize_device(sata_hba_inst,
10728 SATA_CPORTINFO_DRV_INFO(cportinfo));
10729
10730 if (rval == SATA_RETRY)
10731 sata_log(sata_hba_inst, CE_WARN,
10732 "SATA device at port %d - "
10733 "default device features could not be set."
10734 " Device may not operate as expected.",
10735 cport);
10736 }
10737
10738 cdip = sata_create_target_node(pdip, sata_hba_inst, saddr);
10739 if (cdip == NULL) {
10740 /*
10741 * Attaching target node failed.
10742 * We retain sata_drive_info structure...
10743 */
10744 return (SATA_SUCCESS);
10745 }
10746
10747 mutex_enter(&cportinfo->cport_mutex);
10748 (SATA_CPORTINFO_DRV_INFO(cportinfo))->
10749 satadrv_state = SATA_STATE_READY;
10750 mutex_exit(&cportinfo->cport_mutex);
10751
10752 break;
10753
10754 case SATA_ADDR_PMPORT:
10755 saddr->qual = SATA_ADDR_DPMPORT;
10756
10757 mutex_enter(&cportinfo->cport_mutex);
10758 /* It must be a Port Multiplier at the controller port */
10759 ASSERT(cportinfo->cport_dev_type == SATA_DTYPE_PMULT);
10760
10761 pminfo = SATA_CPORTINFO_PMULT_INFO(cportinfo);
10762 pmportinfo = pminfo->pmult_dev_port[saddr->pmport];
10763 mutex_exit(&cportinfo->cport_mutex);
10764
10765 rval = sata_probe_device(sata_hba_inst, sata_device);
10766 if (rval != SATA_SUCCESS ||
10767 sata_device->satadev_type == SATA_DTYPE_UNKNOWN) {
10768 return (SATA_FAILURE);
10769 }
10770
10771 mutex_enter(&pmportinfo->pmport_mutex);
10772 sata_show_drive_info(sata_hba_inst,
10773 SATA_PMPORTINFO_DRV_INFO(pmportinfo));
10774
10775 if ((sata_device->satadev_type & SATA_VALID_DEV_TYPE) == 0) {
10776 /*
10777 * Could not determine device type.
10778 * Degrade this device to unknown.
10779 */
10780 pmportinfo->pmport_dev_type = SATA_DTYPE_UNKNOWN;
10781 mutex_exit(&pmportinfo->pmport_mutex);
10782 return (SATA_SUCCESS);
10783 }
10784 pmportinfo->pmport_dev_type = sata_device->satadev_type;
10785 pmportinfo->pmport_tgtnode_clean = B_TRUE;
10786 mutex_exit(&pmportinfo->pmport_mutex);
10787
10788 /*
10789 * Initialize device to the desired state.
10790 * Even if it fails, the device will still
10791 * attach but syslog will show the warning.
10792 */
10793 if (sata_initialize_device(sata_hba_inst,
10794 pmportinfo->pmport_sata_drive) != SATA_SUCCESS) {
10795 /* Retry */
10796 rval = sata_initialize_device(sata_hba_inst,
10797 pmportinfo->pmport_sata_drive);
10798
10799 if (rval == SATA_RETRY)
10800 sata_log(sata_hba_inst, CE_WARN,
10801 "SATA device at port %d:%d - "
10802 "default device features could not be set."
10803 " Device may not operate as expected.",
10804 cport, pmport);
10805 }
10806
10807 cdip = sata_create_target_node(pdip, sata_hba_inst, saddr);
10808 if (cdip == NULL) {
10809 /*
10810 * Attaching target node failed.
10811 * We retain sata_drive_info structure...
10812 */
10813 return (SATA_SUCCESS);
10814 }
10815 mutex_enter(&pmportinfo->pmport_mutex);
10816 pmportinfo->pmport_sata_drive->satadrv_state |=
10817 SATA_STATE_READY;
10818 mutex_exit(&pmportinfo->pmport_mutex);
10819
10820 break;
10821
10822 default:
10823 return (SATA_FAILURE);
10824 }
10825
10826 return (SATA_SUCCESS);
10827 }
10828
10829 /*
10830 * Clean up target node at specific address.
10831 *
10832 * NOTE: No Mutex should be hold.
10833 */
10834 static int
10835 sata_offline_device(sata_hba_inst_t *sata_hba_inst,
10836 sata_device_t *sata_device, sata_drive_info_t *sdinfo)
10837 {
10838 uint8_t cport, pmport, qual;
10839 dev_info_t *tdip;
10840
10841 cport = sata_device->satadev_addr.cport;
10842 pmport = sata_device->satadev_addr.pmport;
10843 qual = sata_device->satadev_addr.qual;
10844
10845 if (qual == SATA_ADDR_DCPORT) {
10846 SATA_LOG_D((sata_hba_inst, CE_WARN,
10847 "sata_hba_ioctl: disconnect device at port %d", cport));
10848 } else {
10849 SATA_LOG_D((sata_hba_inst, CE_WARN,
10850 "sata_hba_ioctl: disconnect device at port %d:%d",
10851 cport, pmport));
10852 }
10853
10854 /* We are addressing attached device, not a port */
10855 sata_device->satadev_addr.qual =
10856 sdinfo->satadrv_addr.qual;
10857 tdip = sata_get_scsi_target_dip(SATA_DIP(sata_hba_inst),
10858 &sata_device->satadev_addr);
10859 if (tdip != NULL && ndi_devi_offline(tdip,
10860 NDI_DEVI_REMOVE) != NDI_SUCCESS) {
10861 /*
10862 * Problem :
10863 * The target node remained attached.
10864 * This happens when the device file was open
10865 * or a node was waiting for resources.
10866 * Cannot do anything about it.
10867 */
10868 if (qual == SATA_ADDR_DCPORT) {
10869 SATA_LOG_D((sata_hba_inst, CE_WARN,
10870 "sata_hba_ioctl: disconnect: could "
10871 "not unconfigure device before "
10872 "disconnecting the SATA port %d",
10873 cport));
10874 } else {
10875 SATA_LOG_D((sata_hba_inst, CE_WARN,
10876 "sata_hba_ioctl: disconnect: could "
10877 "not unconfigure device before "
10878 "disconnecting the SATA port %d:%d",
10879 cport, pmport));
10880 }
10881 /*
10882 * Set DEVICE REMOVED state in the target
10883 * node. It will prevent access to the device
10884 * even when a new device is attached, until
10885 * the old target node is released, removed and
10886 * recreated for a new device.
10887 */
10888 sata_set_device_removed(tdip);
10889
10890 /*
10891 * Instruct event daemon to try the target
10892 * node cleanup later.
10893 */
10894 sata_set_target_node_cleanup(
10895 sata_hba_inst, &sata_device->satadev_addr);
10896 }
10897
10898
10899 return (SATA_SUCCESS);
10900 }
10901
10902
10903 /*
10904 * Create scsi target node for attached device, create node properties and
10905 * attach the node.
10906 * The node could be removed if the device onlining fails.
10907 *
10908 * A dev_info_t pointer is returned if operation is successful, NULL is
10909 * returned otherwise.
10910 */
10911
10912 static dev_info_t *
10913 sata_create_target_node(dev_info_t *dip, sata_hba_inst_t *sata_hba_inst,
10914 sata_address_t *sata_addr)
10915 {
10916 dev_info_t *cdip = NULL;
10917 int rval;
10918 char *nname = NULL;
10919 char **compatible = NULL;
10920 int ncompatible;
10921 struct scsi_inquiry inq;
10922 sata_device_t sata_device;
10923 sata_drive_info_t *sdinfo;
10924 int target;
10925 int i;
10926
10927 sata_device.satadev_rev = SATA_DEVICE_REV;
10928 sata_device.satadev_addr = *sata_addr;
10929
10930 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, sata_addr->cport)));
10931
10932 sdinfo = sata_get_device_info(sata_hba_inst, &sata_device);
10933
10934 target = SATA_TO_SCSI_TARGET(sata_addr->cport,
10935 sata_addr->pmport, sata_addr->qual);
10936
10937 if (sdinfo == NULL) {
10938 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst,
10939 sata_addr->cport)));
10940 SATA_LOG_D((sata_hba_inst, CE_WARN,
10941 "sata_create_target_node: no sdinfo for target %x",
10942 target));
10943 return (NULL);
10944 }
10945
10946 /*
10947 * create or get scsi inquiry data, expected by
10948 * scsi_hba_nodename_compatible_get()
10949 * SATA hard disks get Identify Data translated into Inguiry Data.
10950 * ATAPI devices respond directly to Inquiry request.
10951 */
10952 if (sdinfo->satadrv_type == SATA_DTYPE_ATADISK) {
10953 sata_identdev_to_inquiry(sata_hba_inst, sdinfo,
10954 (uint8_t *)&inq);
10955 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst,
10956 sata_addr->cport)));
10957 } else { /* Assume supported ATAPI device */
10958 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst,
10959 sata_addr->cport)));
10960 if (sata_get_atapi_inquiry_data(sata_hba_inst, sata_addr,
10961 &inq) == SATA_FAILURE)
10962 return (NULL);
10963 /*
10964 * Save supported ATAPI transport version
10965 */
10966 sdinfo->satadrv_atapi_trans_ver =
10967 SATA_ATAPI_TRANS_VERSION(&inq);
10968 }
10969
10970 /* determine the node name and compatible */
10971 scsi_hba_nodename_compatible_get(&inq, NULL,
10972 inq.inq_dtype, NULL, &nname, &compatible, &ncompatible);
10973
10974 #ifdef SATA_DEBUG
10975 if (sata_debug_flags & SATA_DBG_NODES) {
10976 if (nname == NULL) {
10977 cmn_err(CE_NOTE, "sata_create_target_node: "
10978 "cannot determine nodename for target %d\n",
10979 target);
10980 } else {
10981 cmn_err(CE_WARN, "sata_create_target_node: "
10982 "target %d nodename: %s\n", target, nname);
10983 }
10984 if (compatible == NULL) {
10985 cmn_err(CE_WARN,
10986 "sata_create_target_node: no compatible name\n");
10987 } else {
10988 for (i = 0; i < ncompatible; i++) {
10989 cmn_err(CE_WARN, "sata_create_target_node: "
10990 "compatible name: %s\n", compatible[i]);
10991 }
10992 }
10993 }
10994 #endif
10995
10996 /* if nodename can't be determined, log error and exit */
10997 if (nname == NULL) {
10998 SATA_LOG_D((sata_hba_inst, CE_WARN,
10999 "sata_create_target_node: cannot determine nodename "
11000 "for target %d\n", target));
11001 scsi_hba_nodename_compatible_free(nname, compatible);
11002 return (NULL);
11003 }
11004 /*
11005 * Create scsi target node
11006 */
11007 ndi_devi_alloc_sleep(dip, nname, (pnode_t)DEVI_SID_NODEID, &cdip);
11008 rval = ndi_prop_update_string(DDI_DEV_T_NONE, cdip,
11009 "device-type", "scsi");
11010
11011 if (rval != DDI_PROP_SUCCESS) {
11012 SATA_LOG_D((sata_hba_inst, CE_WARN, "sata_create_target_node: "
11013 "updating device_type prop failed %d", rval));
11014 goto fail;
11015 }
11016
11017 /*
11018 * Create target node properties: target & lun
11019 */
11020 rval = ndi_prop_update_int(DDI_DEV_T_NONE, cdip, "target", target);
11021 if (rval != DDI_PROP_SUCCESS) {
11022 SATA_LOG_D((sata_hba_inst, CE_WARN, "sata_create_target_node: "
11023 "updating target prop failed %d", rval));
11024 goto fail;
11025 }
11026 rval = ndi_prop_update_int(DDI_DEV_T_NONE, cdip, "lun", 0);
11027 if (rval != DDI_PROP_SUCCESS) {
11028 SATA_LOG_D((sata_hba_inst, CE_WARN, "sata_create_target_node: "
11029 "updating target prop failed %d", rval));
11030 goto fail;
11031 }
11032
11033 if (sdinfo->satadrv_type & SATA_DTYPE_ATAPI) {
11034 /*
11035 * Add "variant" property
11036 */
11037 rval = ndi_prop_update_string(DDI_DEV_T_NONE, cdip,
11038 "variant", "atapi");
11039 if (rval != DDI_PROP_SUCCESS) {
11040 SATA_LOG_D((sata_hba_inst, CE_WARN,
11041 "sata_create_target_node: variant atapi "
11042 "property could not be created: %d", rval));
11043 goto fail;
11044 }
11045 }
11046 /* decorate the node with compatible */
11047 if (ndi_prop_update_string_array(DDI_DEV_T_NONE, cdip, "compatible",
11048 compatible, ncompatible) != DDI_PROP_SUCCESS) {
11049 SATA_LOG_D((sata_hba_inst, CE_WARN,
11050 "sata_create_target_node: FAIL compatible props cdip 0x%p",
11051 (void *)cdip));
11052 goto fail;
11053 }
11054
11055 if (sdinfo->satadrv_type == SATA_DTYPE_ATADISK) {
11056 /*
11057 * Add "sata-phy" property
11058 */
11059 if (ndi_prop_update_int(DDI_DEV_T_NONE, cdip, "sata-phy",
11060 (int)sata_addr->cport) != DDI_PROP_SUCCESS) {
11061 SATA_LOG_D((sata_hba_inst, CE_WARN,
11062 "sata_create_target_node: failed to create "
11063 "\"sata-phy\" property: port %d",
11064 sata_addr->cport));
11065 }
11066 }
11067
11068
11069 /*
11070 * Now, try to attach the driver. If probing of the device fails,
11071 * the target node may be removed
11072 */
11073 rval = ndi_devi_online(cdip, NDI_ONLINE_ATTACH);
11074
11075 scsi_hba_nodename_compatible_free(nname, compatible);
11076
11077 if (rval == NDI_SUCCESS)
11078 return (cdip);
11079
11080 /* target node was removed - are we sure? */
11081 return (NULL);
11082
11083 fail:
11084 scsi_hba_nodename_compatible_free(nname, compatible);
11085 ddi_prop_remove_all(cdip);
11086 rval = ndi_devi_free(cdip);
11087 if (rval != NDI_SUCCESS) {
11088 SATA_LOG_D((sata_hba_inst, CE_WARN, "sata_create_target_node: "
11089 "node removal failed %d", rval));
11090 }
11091 sata_log(sata_hba_inst, CE_WARN, "sata_create_target_node: "
11092 "cannot create target node for SATA device at port %d",
11093 sata_addr->cport);
11094 return (NULL);
11095 }
11096
11097 /*
11098 * Remove a target node.
11099 */
11100 static void
11101 sata_remove_target_node(sata_hba_inst_t *sata_hba_inst,
11102 sata_address_t *sata_addr)
11103 {
11104 dev_info_t *tdip;
11105 uint8_t cport = sata_addr->cport;
11106 uint8_t pmport = sata_addr->pmport;
11107 uint8_t qual = sata_addr->qual;
11108
11109 /* Note the sata daemon uses the address of the port/pmport */
11110 ASSERT(qual == SATA_ADDR_CPORT || qual == SATA_ADDR_PMPORT);
11111
11112 /* Remove target node */
11113 tdip = sata_get_target_dip(SATA_DIP(sata_hba_inst), cport, pmport);
11114 if (tdip != NULL) {
11115 /*
11116 * Target node exists. Unconfigure device
11117 * then remove the target node (one ndi
11118 * operation).
11119 */
11120 if (ndi_devi_offline(tdip, NDI_DEVI_REMOVE) != NDI_SUCCESS) {
11121 /*
11122 * PROBLEM - no device, but target node remained. This
11123 * happens when the file was open or node was waiting
11124 * for resources.
11125 */
11126 SATA_LOG_D((sata_hba_inst, CE_WARN,
11127 "sata_remove_target_node: "
11128 "Failed to remove target node for "
11129 "detached SATA device."));
11130 /*
11131 * Set target node state to DEVI_DEVICE_REMOVED. But
11132 * re-check first that the node still exists.
11133 */
11134 tdip = sata_get_target_dip(SATA_DIP(sata_hba_inst),
11135 cport, pmport);
11136 if (tdip != NULL) {
11137 sata_set_device_removed(tdip);
11138 /*
11139 * Instruct event daemon to retry the cleanup
11140 * later.
11141 */
11142 sata_set_target_node_cleanup(sata_hba_inst,
11143 sata_addr);
11144 }
11145 }
11146
11147 if (qual == SATA_ADDR_CPORT)
11148 sata_log(sata_hba_inst, CE_WARN,
11149 "SATA device detached at port %d", cport);
11150 else
11151 sata_log(sata_hba_inst, CE_WARN,
11152 "SATA device detached at port %d:%d",
11153 cport, pmport);
11154 }
11155 #ifdef SATA_DEBUG
11156 else {
11157 if (qual == SATA_ADDR_CPORT)
11158 sata_log(sata_hba_inst, CE_WARN,
11159 "target node not found at port %d", cport);
11160 else
11161 sata_log(sata_hba_inst, CE_WARN,
11162 "target node not found at port %d:%d",
11163 cport, pmport);
11164 }
11165 #endif
11166 }
11167
11168
11169 /*
11170 * Re-probe sata port, check for a device and attach info
11171 * structures when necessary. Identify Device data is fetched, if possible.
11172 * Assumption: sata address is already validated.
11173 * SATA_SUCCESS is returned if port is re-probed sucessfully, regardless of
11174 * the presence of a device and its type.
11175 *
11176 * flag arg specifies that the function should try multiple times to identify
11177 * device type and to initialize it, or it should return immediately on failure.
11178 * SATA_DEV_IDENTIFY_RETRY - retry
11179 * SATA_DEV_IDENTIFY_NORETRY - no retry
11180 *
11181 * SATA_FAILURE is returned if one of the operations failed.
11182 *
11183 * This function cannot be called in interrupt context - it may sleep.
11184 *
11185 * Note: Port multiplier is supported.
11186 */
11187 static int
11188 sata_reprobe_port(sata_hba_inst_t *sata_hba_inst, sata_device_t *sata_device,
11189 int flag)
11190 {
11191 sata_cport_info_t *cportinfo;
11192 sata_pmult_info_t *pmultinfo;
11193 sata_drive_info_t *sdinfo, *osdinfo;
11194 boolean_t init_device = B_FALSE;
11195 int prev_device_type = SATA_DTYPE_NONE;
11196 int prev_device_settings = 0;
11197 int prev_device_state = 0;
11198 clock_t start_time;
11199 int retry = B_FALSE;
11200 uint8_t cport = sata_device->satadev_addr.cport;
11201 int rval_probe, rval_init;
11202
11203 /*
11204 * If target is pmport, sata_reprobe_pmport() will handle it.
11205 */
11206 if (sata_device->satadev_addr.qual == SATA_ADDR_PMPORT ||
11207 sata_device->satadev_addr.qual == SATA_ADDR_DPMPORT)
11208 return (sata_reprobe_pmport(sata_hba_inst, sata_device, flag));
11209
11210 /* We only care about host sata cport for now */
11211 cportinfo = SATA_CPORT_INFO(sata_hba_inst,
11212 sata_device->satadev_addr.cport);
11213
11214 /*
11215 * If a port multiplier was previously attached (we have no idea it
11216 * still there or not), sata_reprobe_pmult() will handle it.
11217 */
11218 if (cportinfo->cport_dev_type == SATA_DTYPE_PMULT)
11219 return (sata_reprobe_pmult(sata_hba_inst, sata_device, flag));
11220
11221 /* Store sata_drive_info when a non-pmult device was attached. */
11222 osdinfo = SATA_CPORTINFO_DRV_INFO(cportinfo);
11223 if (osdinfo != NULL) {
11224 /*
11225 * We are re-probing port with a previously attached device.
11226 * Save previous device type and settings.
11227 */
11228 prev_device_type = cportinfo->cport_dev_type;
11229 prev_device_settings = osdinfo->satadrv_settings;
11230 prev_device_state = osdinfo->satadrv_state;
11231 }
11232 if (flag == SATA_DEV_IDENTIFY_RETRY) {
11233 start_time = ddi_get_lbolt();
11234 retry = B_TRUE;
11235 }
11236 retry_probe:
11237
11238 /* probe port */
11239 mutex_enter(&cportinfo->cport_mutex);
11240 cportinfo->cport_state &= ~SATA_PORT_STATE_CLEAR_MASK;
11241 cportinfo->cport_state |= SATA_STATE_PROBING;
11242 mutex_exit(&cportinfo->cport_mutex);
11243
11244 rval_probe = (*SATA_PROBE_PORT_FUNC(sata_hba_inst))
11245 (SATA_DIP(sata_hba_inst), sata_device);
11246
11247 mutex_enter(&cportinfo->cport_mutex);
11248 if (rval_probe != SATA_SUCCESS) {
11249 cportinfo->cport_state = SATA_PSTATE_FAILED;
11250 mutex_exit(&cportinfo->cport_mutex);
11251 SATA_LOG_D((sata_hba_inst, CE_WARN, "sata_reprobe_port: "
11252 "SATA port %d probing failed",
11253 cportinfo->cport_addr.cport));
11254 return (SATA_FAILURE);
11255 }
11256
11257 /*
11258 * update sata port state and set device type
11259 */
11260 sata_update_port_info(sata_hba_inst, sata_device);
11261 cportinfo->cport_state &= ~SATA_STATE_PROBING;
11262
11263 /*
11264 * Sanity check - Port is active? Is the link active?
11265 * Is there any device attached?
11266 */
11267 if ((cportinfo->cport_state &
11268 (SATA_PSTATE_SHUTDOWN | SATA_PSTATE_FAILED)) ||
11269 (cportinfo->cport_scr.sstatus & SATA_PORT_DEVLINK_UP_MASK) !=
11270 SATA_PORT_DEVLINK_UP) {
11271 /*
11272 * Port in non-usable state or no link active/no device.
11273 * Free info structure if necessary (direct attached drive
11274 * only, for now!
11275 */
11276 sdinfo = SATA_CPORTINFO_DRV_INFO(cportinfo);
11277 SATA_CPORTINFO_DRV_INFO(cportinfo) = NULL;
11278 /* Add here differentiation for device attached or not */
11279 cportinfo->cport_dev_type = SATA_DTYPE_NONE;
11280 mutex_exit(&cportinfo->cport_mutex);
11281 if (sdinfo != NULL)
11282 kmem_free(sdinfo, sizeof (sata_drive_info_t));
11283 return (SATA_SUCCESS);
11284 }
11285
11286 cportinfo->cport_state |= SATA_STATE_READY;
11287 cportinfo->cport_state |= SATA_STATE_PROBED;
11288
11289 cportinfo->cport_dev_type = sata_device->satadev_type;
11290 sdinfo = SATA_CPORTINFO_DRV_INFO(cportinfo);
11291
11292 /*
11293 * If we are re-probing the port, there may be
11294 * sata_drive_info structure attached
11295 */
11296 if (sata_device->satadev_type == SATA_DTYPE_NONE) {
11297
11298 /*
11299 * There is no device, so remove device info structure,
11300 * if necessary.
11301 */
11302 /* Device change: Drive -> None */
11303 SATA_CPORTINFO_DRV_INFO(cportinfo) = NULL;
11304 cportinfo->cport_dev_type = SATA_DTYPE_NONE;
11305 if (sdinfo != NULL) {
11306 kmem_free(sdinfo, sizeof (sata_drive_info_t));
11307 sata_log(sata_hba_inst, CE_WARN,
11308 "SATA device detached "
11309 "from port %d", cportinfo->cport_addr.cport);
11310 }
11311 mutex_exit(&cportinfo->cport_mutex);
11312 return (SATA_SUCCESS);
11313
11314 }
11315
11316 if (sata_device->satadev_type != SATA_DTYPE_PMULT) {
11317
11318 /* Device (may) change: Drive -> Drive */
11319 if (sdinfo == NULL) {
11320 /*
11321 * There is some device attached, but there is
11322 * no sata_drive_info structure - allocate one
11323 */
11324 mutex_exit(&cportinfo->cport_mutex);
11325 sdinfo = kmem_zalloc(
11326 sizeof (sata_drive_info_t), KM_SLEEP);
11327 mutex_enter(&cportinfo->cport_mutex);
11328 /*
11329 * Recheck, that the port state did not change when we
11330 * released mutex.
11331 */
11332 if (cportinfo->cport_state & SATA_STATE_READY) {
11333 SATA_CPORTINFO_DRV_INFO(cportinfo) = sdinfo;
11334 sdinfo->satadrv_addr = cportinfo->cport_addr;
11335 sdinfo->satadrv_addr.qual = SATA_ADDR_DCPORT;
11336 sdinfo->satadrv_type = SATA_DTYPE_UNKNOWN;
11337 sdinfo->satadrv_state = SATA_STATE_UNKNOWN;
11338 } else {
11339 /*
11340 * Port is not in ready state, we
11341 * cannot attach a device.
11342 */
11343 mutex_exit(&cportinfo->cport_mutex);
11344 kmem_free(sdinfo, sizeof (sata_drive_info_t));
11345 return (SATA_SUCCESS);
11346 }
11347 /*
11348 * Since we are adding device, presumably new one,
11349 * indicate that it should be initalized,
11350 * as well as some internal framework states).
11351 */
11352 init_device = B_TRUE;
11353 }
11354 cportinfo->cport_dev_type = SATA_DTYPE_UNKNOWN;
11355 sata_device->satadev_addr.qual = sdinfo->satadrv_addr.qual;
11356 } else {
11357 /* Device change: Drive -> PMult */
11358 SATA_CPORTINFO_DRV_INFO(cportinfo) = NULL;
11359 if (sdinfo != NULL) {
11360 kmem_free(sdinfo, sizeof (sata_drive_info_t));
11361 sata_log(sata_hba_inst, CE_WARN,
11362 "SATA device detached "
11363 "from port %d", cportinfo->cport_addr.cport);
11364 }
11365
11366 sata_log(sata_hba_inst, CE_WARN,
11367 "SATA port multiplier detected at port %d",
11368 cportinfo->cport_addr.cport);
11369
11370 mutex_exit(&cportinfo->cport_mutex);
11371 if (sata_alloc_pmult(sata_hba_inst, sata_device) !=
11372 SATA_SUCCESS)
11373 return (SATA_FAILURE);
11374 sata_show_pmult_info(sata_hba_inst, sata_device);
11375 mutex_enter(&cportinfo->cport_mutex);
11376
11377 /*
11378 * Mark all the port multiplier port behind the port
11379 * multiplier behind with link events, so that the sata daemon
11380 * will update their status.
11381 */
11382 pmultinfo = SATA_PMULT_INFO(sata_hba_inst, cport);
11383 pmultinfo->pmult_event_flags |= SATA_EVNT_DEVICE_RESET;
11384 mutex_exit(&cportinfo->cport_mutex);
11385 return (SATA_SUCCESS);
11386 }
11387 mutex_exit(&cportinfo->cport_mutex);
11388
11389 /*
11390 * Figure out what kind of device we are really
11391 * dealing with. Failure of identifying device does not fail this
11392 * function.
11393 */
11394 rval_probe = sata_probe_device(sata_hba_inst, sata_device);
11395 rval_init = SATA_FAILURE;
11396 mutex_enter(&cportinfo->cport_mutex);
11397 if (rval_probe == SATA_SUCCESS) {
11398 /*
11399 * If we are dealing with the same type of a device as before,
11400 * restore its settings flags.
11401 */
11402 if (osdinfo != NULL &&
11403 sata_device->satadev_type == prev_device_type)
11404 sdinfo->satadrv_settings = prev_device_settings;
11405
11406 mutex_exit(&cportinfo->cport_mutex);
11407 rval_init = SATA_SUCCESS;
11408 /* Set initial device features, if necessary */
11409 if (init_device == B_TRUE) {
11410 rval_init = sata_initialize_device(sata_hba_inst,
11411 sdinfo);
11412 }
11413 if (rval_init == SATA_SUCCESS)
11414 return (rval_init);
11415 /* else we will retry if retry was asked for */
11416
11417 } else {
11418 /*
11419 * If there was some device info before we probe the device,
11420 * restore previous device setting, so we can retry from scratch
11421 * later. Providing, of course, that device has not disapear
11422 * during probing process.
11423 */
11424 if (sata_device->satadev_type != SATA_DTYPE_NONE) {
11425 if (osdinfo != NULL) {
11426 cportinfo->cport_dev_type = prev_device_type;
11427 sdinfo->satadrv_type = prev_device_type;
11428 sdinfo->satadrv_state = prev_device_state;
11429 }
11430 } else {
11431 /* device is gone */
11432 kmem_free(sdinfo, sizeof (sata_drive_info_t));
11433 cportinfo->cport_dev_type = SATA_DTYPE_NONE;
11434 SATA_CPORTINFO_DRV_INFO(cportinfo) = NULL;
11435 mutex_exit(&cportinfo->cport_mutex);
11436 return (SATA_SUCCESS);
11437 }
11438 mutex_exit(&cportinfo->cport_mutex);
11439 }
11440
11441 if (retry) {
11442 clock_t cur_time = ddi_get_lbolt();
11443 /*
11444 * A device was not successfully identified or initialized.
11445 * Track retry time for device identification.
11446 */
11447 if ((cur_time - start_time) <
11448 drv_usectohz(SATA_DEV_REPROBE_TIMEOUT)) {
11449 /* sleep for a while */
11450 delay(drv_usectohz(SATA_DEV_RETRY_DLY));
11451 goto retry_probe;
11452 }
11453 /* else no more retries */
11454 mutex_enter(&cportinfo->cport_mutex);
11455 if (SATA_CPORTINFO_DRV_INFO(cportinfo) != NULL) {
11456 if (rval_init == SATA_RETRY) {
11457 /*
11458 * Setting drive features have failed, but
11459 * because the drive is still accessible,
11460 * keep it and emit a warning message.
11461 */
11462 sata_log(sata_hba_inst, CE_WARN,
11463 "SATA device at port %d - desired "
11464 "drive features could not be set. "
11465 "Device may not operate as expected.",
11466 cportinfo->cport_addr.cport);
11467 } else {
11468 SATA_CPORTINFO_DRV_INFO(cportinfo)->
11469 satadrv_state = SATA_DSTATE_FAILED;
11470 }
11471 }
11472 mutex_exit(&cportinfo->cport_mutex);
11473 }
11474 return (SATA_SUCCESS);
11475 }
11476
11477 /*
11478 * Reprobe a controller port that connected to a port multiplier.
11479 *
11480 * NOTE: No Mutex should be hold.
11481 */
11482 static int
11483 sata_reprobe_pmult(sata_hba_inst_t *sata_hba_inst, sata_device_t *sata_device,
11484 int flag)
11485 {
11486 _NOTE(ARGUNUSED(flag))
11487 sata_cport_info_t *cportinfo;
11488 sata_pmult_info_t *pmultinfo;
11489 uint8_t cport = sata_device->satadev_addr.cport;
11490 int rval_probe;
11491
11492 cportinfo = SATA_CPORT_INFO(sata_hba_inst, cport);
11493 pmultinfo = SATA_PMULT_INFO(sata_hba_inst, cport);
11494
11495 /* probe port */
11496 mutex_enter(&cportinfo->cport_mutex);
11497 cportinfo->cport_state &= ~SATA_PORT_STATE_CLEAR_MASK;
11498 cportinfo->cport_state |= SATA_STATE_PROBING;
11499 mutex_exit(&cportinfo->cport_mutex);
11500
11501 rval_probe = (*SATA_PROBE_PORT_FUNC(sata_hba_inst))
11502 (SATA_DIP(sata_hba_inst), sata_device);
11503
11504 mutex_enter(&cportinfo->cport_mutex);
11505 if (rval_probe != SATA_SUCCESS) {
11506 cportinfo->cport_state = SATA_PSTATE_FAILED;
11507 SATA_LOG_D((sata_hba_inst, CE_WARN, "sata_reprobe_pmult: "
11508 "SATA port %d probing failed", cport));
11509 sata_log(sata_hba_inst, CE_WARN,
11510 "SATA port multiplier detached at port %d", cport);
11511 mutex_exit(&cportinfo->cport_mutex);
11512 sata_free_pmult(sata_hba_inst, sata_device);
11513 return (SATA_FAILURE);
11514 }
11515
11516 /*
11517 * update sata port state and set device type
11518 */
11519 sata_update_port_info(sata_hba_inst, sata_device);
11520 cportinfo->cport_state &= ~SATA_STATE_PROBING;
11521 cportinfo->cport_state |= SATA_STATE_PROBED;
11522
11523 /*
11524 * Sanity check - Port is active? Is the link active?
11525 * Is there any device attached?
11526 */
11527 if ((cportinfo->cport_state &
11528 (SATA_PSTATE_SHUTDOWN | SATA_PSTATE_FAILED)) ||
11529 (cportinfo->cport_scr.sstatus & SATA_PORT_DEVLINK_UP_MASK) !=
11530 SATA_PORT_DEVLINK_UP ||
11531 (sata_device->satadev_type == SATA_DTYPE_NONE)) {
11532 cportinfo->cport_dev_type = SATA_DTYPE_NONE;
11533 mutex_exit(&cportinfo->cport_mutex);
11534 sata_free_pmult(sata_hba_inst, sata_device);
11535 sata_log(sata_hba_inst, CE_WARN,
11536 "SATA port multiplier detached at port %d", cport);
11537 return (SATA_SUCCESS);
11538 }
11539
11540 /*
11541 * Device changed: PMult -> Non-PMult
11542 *
11543 * This situation is uncommon, most possibly being caused by errors
11544 * after which the port multiplier is not correct initialized and
11545 * recognized. In that case the new device will be marked as unknown
11546 * and will not be automatically probed in this routine. Instead
11547 * system administrator could manually restart it via cfgadm(1M).
11548 */
11549 if (sata_device->satadev_type != SATA_DTYPE_PMULT) {
11550 cportinfo->cport_dev_type = SATA_DTYPE_UNKNOWN;
11551 mutex_exit(&cportinfo->cport_mutex);
11552 sata_free_pmult(sata_hba_inst, sata_device);
11553 sata_log(sata_hba_inst, CE_WARN,
11554 "SATA port multiplier detached at port %d", cport);
11555 return (SATA_FAILURE);
11556 }
11557
11558 /*
11559 * Now we know it is a port multiplier. However, if this is not the
11560 * previously attached port multiplier - they may have different
11561 * pmport numbers - we need to re-allocate data structures for every
11562 * pmport and drive.
11563 *
11564 * Port multipliers of the same model have identical values in these
11565 * registers, so it is still necessary to update the information of
11566 * all drives attached to the previous port multiplier afterwards.
11567 */
11568 /* Device changed: PMult -> another PMult */
11569 mutex_exit(&cportinfo->cport_mutex);
11570 sata_free_pmult(sata_hba_inst, sata_device);
11571 if (sata_alloc_pmult(sata_hba_inst, sata_device) != SATA_SUCCESS)
11572 return (SATA_FAILURE);
11573 mutex_enter(&cportinfo->cport_mutex);
11574
11575 SATADBG1(SATA_DBG_PMULT, sata_hba_inst,
11576 "SATA port multiplier [changed] at port %d", cport);
11577 sata_log(sata_hba_inst, CE_WARN,
11578 "SATA port multiplier detected at port %d", cport);
11579
11580 /*
11581 * Mark all the port multiplier port behind the port
11582 * multiplier behind with link events, so that the sata daemon
11583 * will update their status.
11584 */
11585 pmultinfo->pmult_event_flags |= SATA_EVNT_DEVICE_RESET;
11586 mutex_exit(&cportinfo->cport_mutex);
11587
11588 return (SATA_SUCCESS);
11589 }
11590
11591 /*
11592 * Re-probe a port multiplier port, check for a device and attach info
11593 * structures when necessary. Identify Device data is fetched, if possible.
11594 * Assumption: sata address is already validated as port multiplier port.
11595 * SATA_SUCCESS is returned if port is re-probed sucessfully, regardless of
11596 * the presence of a device and its type.
11597 *
11598 * flag arg specifies that the function should try multiple times to identify
11599 * device type and to initialize it, or it should return immediately on failure.
11600 * SATA_DEV_IDENTIFY_RETRY - retry
11601 * SATA_DEV_IDENTIFY_NORETRY - no retry
11602 *
11603 * SATA_FAILURE is returned if one of the operations failed.
11604 *
11605 * This function cannot be called in interrupt context - it may sleep.
11606 *
11607 * NOTE: Should be only called by sata_probe_port() in case target port is a
11608 * port multiplier port.
11609 * NOTE: No Mutex should be hold.
11610 */
11611 static int
11612 sata_reprobe_pmport(sata_hba_inst_t *sata_hba_inst, sata_device_t *sata_device,
11613 int flag)
11614 {
11615 sata_cport_info_t *cportinfo = NULL;
11616 sata_pmport_info_t *pmportinfo = NULL;
11617 sata_drive_info_t *sdinfo, *osdinfo;
11618 sata_device_t sdevice;
11619 boolean_t init_device = B_FALSE;
11620 int prev_device_type = SATA_DTYPE_NONE;
11621 int prev_device_settings = 0;
11622 int prev_device_state = 0;
11623 clock_t start_time;
11624 uint8_t cport = sata_device->satadev_addr.cport;
11625 uint8_t pmport = sata_device->satadev_addr.pmport;
11626 int rval;
11627
11628 cportinfo = SATA_CPORT_INFO(sata_hba_inst, cport);
11629 pmportinfo = SATA_PMPORT_INFO(sata_hba_inst, cport, pmport);
11630 osdinfo = SATA_PMPORTINFO_DRV_INFO(pmportinfo);
11631
11632 if (osdinfo != NULL) {
11633 /*
11634 * We are re-probing port with a previously attached device.
11635 * Save previous device type and settings.
11636 */
11637 prev_device_type = pmportinfo->pmport_dev_type;
11638 prev_device_settings = osdinfo->satadrv_settings;
11639 prev_device_state = osdinfo->satadrv_state;
11640 }
11641
11642 start_time = ddi_get_lbolt();
11643
11644 /* check parent status */
11645 mutex_enter(&cportinfo->cport_mutex);
11646 if ((cportinfo->cport_state &
11647 (SATA_PSTATE_SHUTDOWN | SATA_PSTATE_FAILED)) ||
11648 (cportinfo->cport_scr.sstatus & SATA_PORT_DEVLINK_UP_MASK) !=
11649 SATA_PORT_DEVLINK_UP) {
11650 mutex_exit(&cportinfo->cport_mutex);
11651 return (SATA_FAILURE);
11652 }
11653 mutex_exit(&cportinfo->cport_mutex);
11654
11655 retry_probe_pmport:
11656
11657 /* probe port */
11658 mutex_enter(&pmportinfo->pmport_mutex);
11659 pmportinfo->pmport_state &= ~SATA_PORT_STATE_CLEAR_MASK;
11660 pmportinfo->pmport_state |= SATA_STATE_PROBING;
11661 mutex_exit(&pmportinfo->pmport_mutex);
11662
11663 rval = (*SATA_PROBE_PORT_FUNC(sata_hba_inst))
11664 (SATA_DIP(sata_hba_inst), sata_device);
11665
11666 /* might need retry because we cannot touch registers. */
11667 if (rval == SATA_FAILURE) {
11668 mutex_enter(&pmportinfo->pmport_mutex);
11669 pmportinfo->pmport_state = SATA_PSTATE_FAILED;
11670 mutex_exit(&pmportinfo->pmport_mutex);
11671 SATA_LOG_D((sata_hba_inst, CE_WARN, "sata_reprobe_pmport: "
11672 "SATA port %d:%d probing failed",
11673 cport, pmport));
11674 return (SATA_FAILURE);
11675 } else if (rval == SATA_RETRY) {
11676 SATA_LOG_D((sata_hba_inst, CE_WARN, "sata_reprobe_pmport: "
11677 "SATA port %d:%d probing failed, retrying...",
11678 cport, pmport));
11679 clock_t cur_time = ddi_get_lbolt();
11680 /*
11681 * A device was not successfully identified or initialized.
11682 * Track retry time for device identification.
11683 */
11684 if ((cur_time - start_time) <
11685 drv_usectohz(SATA_DEV_REPROBE_TIMEOUT)) {
11686 /* sleep for a while */
11687 delay(drv_usectohz(SATA_DEV_RETRY_DLY));
11688 goto retry_probe_pmport;
11689 } else {
11690 mutex_enter(&pmportinfo->pmport_mutex);
11691 if (SATA_PMPORTINFO_DRV_INFO(pmportinfo) != NULL)
11692 SATA_PMPORTINFO_DRV_INFO(pmportinfo)->
11693 satadrv_state = SATA_DSTATE_FAILED;
11694 mutex_exit(&pmportinfo->pmport_mutex);
11695 return (SATA_SUCCESS);
11696 }
11697 }
11698
11699 /*
11700 * Sanity check - Controller port is active? Is the link active?
11701 * Is it still a port multiplier?
11702 */
11703 if ((cportinfo->cport_state &
11704 (SATA_PSTATE_SHUTDOWN | SATA_PSTATE_FAILED)) ||
11705 (cportinfo->cport_scr.sstatus & SATA_PORT_DEVLINK_UP_MASK) !=
11706 SATA_PORT_DEVLINK_UP ||
11707 (cportinfo->cport_dev_type != SATA_DTYPE_PMULT)) {
11708 /*
11709 * Port in non-usable state or no link active/no
11710 * device. Free info structure.
11711 */
11712 cportinfo->cport_dev_type = SATA_DTYPE_UNKNOWN;
11713
11714 sdevice.satadev_addr.cport = cport;
11715 sdevice.satadev_addr.pmport = pmport;
11716 sdevice.satadev_addr.qual = SATA_ADDR_PMULT;
11717 mutex_exit(&cportinfo->cport_mutex);
11718
11719 sata_free_pmult(sata_hba_inst, &sdevice);
11720 return (SATA_FAILURE);
11721 }
11722
11723 /* SATA_SUCCESS NOW */
11724 /*
11725 * update sata port state and set device type
11726 */
11727 mutex_enter(&pmportinfo->pmport_mutex);
11728 sata_update_pmport_info(sata_hba_inst, sata_device);
11729 pmportinfo->pmport_state &= ~SATA_STATE_PROBING;
11730
11731 /*
11732 * Sanity check - Port is active? Is the link active?
11733 * Is there any device attached?
11734 */
11735 if ((pmportinfo->pmport_state &
11736 (SATA_PSTATE_SHUTDOWN | SATA_PSTATE_FAILED)) ||
11737 (pmportinfo->pmport_scr.sstatus & SATA_PORT_DEVLINK_UP_MASK) !=
11738 SATA_PORT_DEVLINK_UP) {
11739 /*
11740 * Port in non-usable state or no link active/no device.
11741 * Free info structure if necessary (direct attached drive
11742 * only, for now!
11743 */
11744 sdinfo = SATA_PMPORTINFO_DRV_INFO(pmportinfo);
11745 SATA_PMPORTINFO_DRV_INFO(pmportinfo) = NULL;
11746 /* Add here differentiation for device attached or not */
11747 pmportinfo->pmport_dev_type = SATA_DTYPE_NONE;
11748 mutex_exit(&pmportinfo->pmport_mutex);
11749 if (sdinfo != NULL)
11750 kmem_free(sdinfo, sizeof (sata_drive_info_t));
11751 return (SATA_SUCCESS);
11752 }
11753
11754 pmportinfo->pmport_state |= SATA_STATE_READY;
11755 pmportinfo->pmport_dev_type = sata_device->satadev_type;
11756 sdinfo = SATA_PMPORTINFO_DRV_INFO(pmportinfo);
11757
11758 /*
11759 * If we are re-probing the port, there may be
11760 * sata_drive_info structure attached
11761 * (or sata_pm_info, if PMult is supported).
11762 */
11763 if (sata_device->satadev_type == SATA_DTYPE_NONE) {
11764 /*
11765 * There is no device, so remove device info structure,
11766 * if necessary.
11767 */
11768 SATA_PMPORTINFO_DRV_INFO(pmportinfo) = NULL;
11769 pmportinfo->pmport_dev_type = SATA_DTYPE_NONE;
11770 if (sdinfo != NULL) {
11771 kmem_free(sdinfo, sizeof (sata_drive_info_t));
11772 sata_log(sata_hba_inst, CE_WARN,
11773 "SATA device detached from port %d:%d",
11774 cport, pmport);
11775 }
11776 mutex_exit(&pmportinfo->pmport_mutex);
11777 return (SATA_SUCCESS);
11778 }
11779
11780 /* this should not be a pmult */
11781 ASSERT(sata_device->satadev_type != SATA_DTYPE_PMULT);
11782 if (sdinfo == NULL) {
11783 /*
11784 * There is some device attached, but there is
11785 * no sata_drive_info structure - allocate one
11786 */
11787 mutex_exit(&pmportinfo->pmport_mutex);
11788 sdinfo = kmem_zalloc(sizeof (sata_drive_info_t),
11789 KM_SLEEP);
11790 mutex_enter(&pmportinfo->pmport_mutex);
11791 /*
11792 * Recheck, that the port state did not change when we
11793 * released mutex.
11794 */
11795 if (pmportinfo->pmport_state & SATA_STATE_READY) {
11796 SATA_PMPORTINFO_DRV_INFO(pmportinfo) = sdinfo;
11797 sdinfo->satadrv_addr = pmportinfo->pmport_addr;
11798 sdinfo->satadrv_addr.qual = SATA_ADDR_DPMPORT;
11799 sdinfo->satadrv_type = SATA_DTYPE_UNKNOWN;
11800 sdinfo->satadrv_state = SATA_STATE_UNKNOWN;
11801 } else {
11802 /*
11803 * Port is not in ready state, we
11804 * cannot attach a device.
11805 */
11806 mutex_exit(&pmportinfo->pmport_mutex);
11807 kmem_free(sdinfo, sizeof (sata_drive_info_t));
11808 return (SATA_SUCCESS);
11809 }
11810 /*
11811 * Since we are adding device, presumably new one,
11812 * indicate that it should be initalized,
11813 * as well as some internal framework states).
11814 */
11815 init_device = B_TRUE;
11816 }
11817
11818 pmportinfo->pmport_dev_type = SATA_DTYPE_UNKNOWN;
11819 sata_device->satadev_addr.qual = sdinfo->satadrv_addr.qual;
11820
11821 mutex_exit(&pmportinfo->pmport_mutex);
11822 /*
11823 * Figure out what kind of device we are really
11824 * dealing with.
11825 */
11826 rval = sata_probe_device(sata_hba_inst, sata_device);
11827
11828 mutex_enter(&pmportinfo->pmport_mutex);
11829 if (rval == SATA_SUCCESS) {
11830 /*
11831 * If we are dealing with the same type of a device as before,
11832 * restore its settings flags.
11833 */
11834 if (osdinfo != NULL &&
11835 sata_device->satadev_type == prev_device_type)
11836 sdinfo->satadrv_settings = prev_device_settings;
11837
11838 mutex_exit(&pmportinfo->pmport_mutex);
11839 /* Set initial device features, if necessary */
11840 if (init_device == B_TRUE) {
11841 rval = sata_initialize_device(sata_hba_inst, sdinfo);
11842 }
11843 if (rval == SATA_SUCCESS)
11844 return (rval);
11845 } else {
11846 /*
11847 * If there was some device info before we probe the device,
11848 * restore previous device setting, so we can retry from scratch
11849 * later. Providing, of course, that device has not disappeared
11850 * during probing process.
11851 */
11852 if (sata_device->satadev_type != SATA_DTYPE_NONE) {
11853 if (osdinfo != NULL) {
11854 pmportinfo->pmport_dev_type = prev_device_type;
11855 sdinfo->satadrv_type = prev_device_type;
11856 sdinfo->satadrv_state = prev_device_state;
11857 }
11858 } else {
11859 /* device is gone */
11860 kmem_free(sdinfo, sizeof (sata_drive_info_t));
11861 pmportinfo->pmport_dev_type = SATA_DTYPE_NONE;
11862 SATA_PMPORTINFO_DRV_INFO(pmportinfo) = NULL;
11863 mutex_exit(&pmportinfo->pmport_mutex);
11864 return (SATA_SUCCESS);
11865 }
11866 mutex_exit(&pmportinfo->pmport_mutex);
11867 }
11868
11869 if (flag == SATA_DEV_IDENTIFY_RETRY) {
11870 clock_t cur_time = ddi_get_lbolt();
11871 /*
11872 * A device was not successfully identified or initialized.
11873 * Track retry time for device identification.
11874 */
11875 if ((cur_time - start_time) <
11876 drv_usectohz(SATA_DEV_REPROBE_TIMEOUT)) {
11877 /* sleep for a while */
11878 delay(drv_usectohz(SATA_DEV_RETRY_DLY));
11879 goto retry_probe_pmport;
11880 } else {
11881 mutex_enter(&pmportinfo->pmport_mutex);
11882 if (SATA_PMPORTINFO_DRV_INFO(pmportinfo) != NULL)
11883 SATA_PMPORTINFO_DRV_INFO(pmportinfo)->
11884 satadrv_state = SATA_DSTATE_FAILED;
11885 mutex_exit(&pmportinfo->pmport_mutex);
11886 }
11887 }
11888 return (SATA_SUCCESS);
11889 }
11890
11891 /*
11892 * Allocated related structure for a port multiplier and its device ports
11893 *
11894 * Port multiplier should be ready and probed, and related information like
11895 * the number of the device ports should be store in sata_device_t.
11896 *
11897 * NOTE: No Mutex should be hold.
11898 */
11899 static int
11900 sata_alloc_pmult(sata_hba_inst_t *sata_hba_inst, sata_device_t *sata_device)
11901 {
11902 dev_info_t *dip = SATA_DIP(sata_hba_inst);
11903 sata_cport_info_t *cportinfo = NULL;
11904 sata_pmult_info_t *pmultinfo = NULL;
11905 sata_pmport_info_t *pmportinfo = NULL;
11906 sata_device_t sd;
11907 dev_t minor_number;
11908 char name[16];
11909 uint8_t cport = sata_device->satadev_addr.cport;
11910 int rval;
11911 int npmport;
11912
11913 cportinfo = SATA_CPORT_INFO(sata_hba_inst, cport);
11914
11915 /* This function might be called while a port-mult is hot-plugged. */
11916 mutex_enter(&cportinfo->cport_mutex);
11917
11918 /* dev_type's not updated when get called from sata_reprobe_port() */
11919 if (SATA_CPORTINFO_PMULT_INFO(cportinfo) == NULL) {
11920 /* Create a pmult_info structure */
11921 SATA_CPORTINFO_PMULT_INFO(cportinfo) =
11922 kmem_zalloc(sizeof (sata_pmult_info_t), KM_SLEEP);
11923 }
11924 pmultinfo = SATA_CPORTINFO_PMULT_INFO(cportinfo);
11925
11926 pmultinfo->pmult_addr = sata_device->satadev_addr;
11927 pmultinfo->pmult_addr.qual = SATA_ADDR_PMULT;
11928 pmultinfo->pmult_state = SATA_STATE_PROBING;
11929
11930 /*
11931 * Probe the port multiplier with qualifier SATA_ADDR_PMULT_SPEC,
11932 * The HBA driver should initialize and register the port multiplier,
11933 * sata_register_pmult() will fill following fields,
11934 * + sata_pmult_info.pmult_gscr
11935 * + sata_pmult_info.pmult_num_dev_ports
11936 */
11937 sd.satadev_addr = sata_device->satadev_addr;
11938 sd.satadev_addr.qual = SATA_ADDR_PMULT_SPEC;
11939 mutex_exit(&cportinfo->cport_mutex);
11940 rval = (*SATA_PROBE_PORT_FUNC(sata_hba_inst))
11941 (SATA_DIP(sata_hba_inst), &sd);
11942 mutex_enter(&cportinfo->cport_mutex);
11943
11944 if (rval != SATA_SUCCESS ||
11945 (sd.satadev_type != SATA_DTYPE_PMULT) ||
11946 !(sd.satadev_state & SATA_DSTATE_PMULT_INIT)) {
11947 SATA_CPORTINFO_PMULT_INFO(cportinfo) = NULL;
11948 kmem_free(pmultinfo, sizeof (sata_pmult_info_t));
11949 cportinfo->cport_state = SATA_PSTATE_FAILED;
11950 cportinfo->cport_dev_type = SATA_DTYPE_UNKNOWN;
11951 mutex_exit(&cportinfo->cport_mutex);
11952 SATADBG1(SATA_DBG_PMULT, sata_hba_inst,
11953 "sata_alloc_pmult: failed to initialize pmult "
11954 "at port %d.", cport)
11955 return (SATA_FAILURE);
11956 }
11957
11958 /* Initialize pmport_info structure */
11959 for (npmport = 0; npmport < pmultinfo->pmult_num_dev_ports;
11960 npmport++) {
11961
11962 /* if everything is allocated, skip */
11963 if (SATA_PMPORT_INFO(sata_hba_inst, cport, npmport) != NULL)
11964 continue;
11965
11966 pmportinfo = kmem_zalloc(sizeof (sata_pmport_info_t), KM_SLEEP);
11967 mutex_init(&pmportinfo->pmport_mutex, NULL, MUTEX_DRIVER, NULL);
11968 mutex_exit(&cportinfo->cport_mutex);
11969
11970 mutex_enter(&pmportinfo->pmport_mutex);
11971 pmportinfo->pmport_addr.cport = cport;
11972 pmportinfo->pmport_addr.pmport = (uint8_t)npmport;
11973 pmportinfo->pmport_addr.qual = SATA_ADDR_PMPORT;
11974 pmportinfo->pmport_state &= ~SATA_PORT_STATE_CLEAR_MASK;
11975 mutex_exit(&pmportinfo->pmport_mutex);
11976
11977 mutex_enter(&cportinfo->cport_mutex);
11978 SATA_PMPORT_INFO(sata_hba_inst, cport, npmport) = pmportinfo;
11979
11980 /* Create an attachment point */
11981 minor_number = SATA_MAKE_AP_MINOR(ddi_get_instance(dip),
11982 cport, (uint8_t)npmport, SATA_ADDR_PMPORT);
11983 (void) sprintf(name, "%d.%d", cport, npmport);
11984
11985 if (ddi_create_minor_node(dip, name, S_IFCHR, minor_number,
11986 DDI_NT_SATA_ATTACHMENT_POINT, 0) != DDI_SUCCESS) {
11987 sata_log(sata_hba_inst, CE_WARN, "sata_hba_attach: "
11988 "cannot create SATA attachment point for "
11989 "port %d:%d", cport, npmport);
11990 }
11991 }
11992
11993 pmultinfo->pmult_state &= ~SATA_STATE_PROBING;
11994 pmultinfo->pmult_state |= (SATA_STATE_PROBED|SATA_STATE_READY);
11995 cportinfo->cport_dev_type = SATA_DTYPE_PMULT;
11996
11997 mutex_exit(&cportinfo->cport_mutex);
11998 return (SATA_SUCCESS);
11999 }
12000
12001 /*
12002 * Free data structures when a port multiplier is removed.
12003 *
12004 * NOTE: No Mutex should be hold.
12005 */
12006 static void
12007 sata_free_pmult(sata_hba_inst_t *sata_hba_inst, sata_device_t *sata_device)
12008 {
12009 sata_cport_info_t *cportinfo;
12010 sata_pmult_info_t *pmultinfo;
12011 sata_pmport_info_t *pmportinfo;
12012 sata_device_t pmport_device;
12013 sata_drive_info_t *sdinfo;
12014 dev_info_t *tdip;
12015 char name[16];
12016 uint8_t cport = sata_device->satadev_addr.cport;
12017 int npmport;
12018
12019 cportinfo = SATA_CPORT_INFO(sata_hba_inst, cport);
12020
12021 /* This function might be called while port-mult is hot plugged. */
12022 mutex_enter(&cportinfo->cport_mutex);
12023
12024 cportinfo->cport_dev_type = SATA_DTYPE_NONE;
12025 pmultinfo = SATA_CPORTINFO_PMULT_INFO(cportinfo);
12026 ASSERT(pmultinfo != NULL);
12027
12028 /* Free pmport_info structure */
12029 for (npmport = 0; npmport < pmultinfo->pmult_num_dev_ports;
12030 npmport++) {
12031 pmportinfo = SATA_PMPORT_INFO(sata_hba_inst, cport, npmport);
12032 if (pmportinfo == NULL)
12033 continue;
12034 mutex_exit(&cportinfo->cport_mutex);
12035
12036 mutex_enter(&pmportinfo->pmport_mutex);
12037 sdinfo = pmportinfo->pmport_sata_drive;
12038 SATA_PMPORTINFO_DRV_INFO(pmportinfo) = NULL;
12039 mutex_exit(&pmportinfo->pmport_mutex);
12040
12041 /* Remove attachment point. */
12042 name[0] = '\0';
12043 (void) sprintf(name, "%d.%d", cport, npmport);
12044 ddi_remove_minor_node(SATA_DIP(sata_hba_inst), name);
12045 sata_log(sata_hba_inst, CE_NOTE,
12046 "Remove attachment point of port %d:%d",
12047 cport, npmport);
12048
12049 /*
12050 * Rumove target node
12051 */
12052 bzero(&pmport_device, sizeof (sata_device_t));
12053 pmport_device.satadev_rev = SATA_DEVICE_REV;
12054 pmport_device.satadev_addr.cport = cport;
12055 pmport_device.satadev_addr.pmport = (uint8_t)npmport;
12056 pmport_device.satadev_addr.qual = SATA_ADDR_DPMPORT;
12057
12058 tdip = sata_get_scsi_target_dip(SATA_DIP(sata_hba_inst),
12059 &(pmport_device.satadev_addr));
12060 if (tdip != NULL && ndi_devi_offline(tdip,
12061 NDI_DEVI_REMOVE) != NDI_SUCCESS) {
12062 /*
12063 * Problem :
12064 * The target node remained attached.
12065 * This happens when the device file was open
12066 * or a node was waiting for resources.
12067 * Cannot do anything about it.
12068 */
12069 SATA_LOG_D((sata_hba_inst, CE_WARN,
12070 "sata_free_pmult: could not unconfigure device "
12071 "before disconnecting the SATA port %d:%d",
12072 cport, npmport));
12073
12074 /*
12075 * Set DEVICE REMOVED state in the target
12076 * node. It will prevent access to the device
12077 * even when a new device is attached, until
12078 * the old target node is released, removed and
12079 * recreated for a new device.
12080 */
12081 sata_set_device_removed(tdip);
12082
12083 /*
12084 * Instruct event daemon to try the target
12085 * node cleanup later.
12086 */
12087 sata_set_target_node_cleanup(
12088 sata_hba_inst, &(pmport_device.satadev_addr));
12089
12090 }
12091 mutex_enter(&cportinfo->cport_mutex);
12092
12093 /*
12094 * Add here differentiation for device attached or not
12095 */
12096 if (sdinfo != NULL) {
12097 sata_log(sata_hba_inst, CE_WARN,
12098 "SATA device detached from port %d:%d",
12099 cport, npmport);
12100 kmem_free(sdinfo, sizeof (sata_drive_info_t));
12101 }
12102
12103 mutex_destroy(&pmportinfo->pmport_mutex);
12104 kmem_free(pmportinfo, sizeof (sata_pmport_info_t));
12105 }
12106
12107 kmem_free(pmultinfo, sizeof (sata_pmult_info_t));
12108
12109 cportinfo->cport_devp.cport_sata_pmult = NULL;
12110
12111 sata_log(sata_hba_inst, CE_WARN,
12112 "SATA port multiplier detached at port %d", cport);
12113
12114 mutex_exit(&cportinfo->cport_mutex);
12115 }
12116
12117 /*
12118 * Initialize device
12119 * Specified device is initialized to a default state.
12120 *
12121 * Returns SATA_SUCCESS if all device features are set successfully,
12122 * SATA_RETRY if device is accessible but device features were not set
12123 * successfully, and SATA_FAILURE otherwise.
12124 */
12125 static int
12126 sata_initialize_device(sata_hba_inst_t *sata_hba_inst,
12127 sata_drive_info_t *sdinfo)
12128 {
12129 int rval;
12130
12131 sata_save_drive_settings(sdinfo);
12132
12133 sdinfo->satadrv_settings |= SATA_DEV_READ_AHEAD;
12134
12135 sata_init_write_cache_mode(sdinfo);
12136
12137 rval = sata_set_drive_features(sata_hba_inst, sdinfo, 0);
12138
12139 /* Determine current data transfer mode */
12140 if ((sdinfo->satadrv_id.ai_cap & SATA_DMA_SUPPORT) == 0) {
12141 sdinfo->satadrv_settings &= ~SATA_DEV_DMA;
12142 } else if ((sdinfo->satadrv_id.ai_validinfo &
12143 SATA_VALIDINFO_88) != 0 &&
12144 (sdinfo->satadrv_id.ai_ultradma & SATA_UDMA_SEL_MASK) != 0) {
12145 sdinfo->satadrv_settings |= SATA_DEV_DMA;
12146 } else if ((sdinfo->satadrv_id.ai_dworddma &
12147 SATA_MDMA_SEL_MASK) != 0) {
12148 sdinfo->satadrv_settings |= SATA_DEV_DMA;
12149 } else
12150 /* DMA supported, not no DMA transfer mode is selected !? */
12151 sdinfo->satadrv_settings &= ~SATA_DEV_DMA;
12152
12153 if ((sdinfo->satadrv_id.ai_cmdset83 & 0x20) &&
12154 (sdinfo->satadrv_id.ai_features86 & 0x20))
12155 sdinfo->satadrv_power_level = SATA_POWER_STANDBY;
12156 else
12157 sdinfo->satadrv_power_level = SATA_POWER_ACTIVE;
12158
12159 return (rval);
12160 }
12161
12162
12163 /*
12164 * Initialize write cache mode.
12165 *
12166 * The default write cache setting for SATA HDD is provided by sata_write_cache
12167 * static variable. ATAPI CD/DVDs devices have write cache default is
12168 * determined by sata_atapicdvd_write_cache static variable.
12169 * ATAPI tape devices have write cache default is determined by
12170 * sata_atapitape_write_cache static variable.
12171 * ATAPI disk devices have write cache default is determined by
12172 * sata_atapidisk_write_cache static variable.
12173 * 1 - enable
12174 * 0 - disable
12175 * any other value - current drive setting
12176 *
12177 * Although there is not reason to disable write cache on CD/DVD devices,
12178 * tape devices and ATAPI disk devices, the default setting control is provided
12179 * for the maximun flexibility.
12180 *
12181 * In the future, it may be overridden by the
12182 * disk-write-cache-enable property setting, if it is defined.
12183 * Returns SATA_SUCCESS if all device features are set successfully,
12184 * SATA_FAILURE otherwise.
12185 */
12186 static void
12187 sata_init_write_cache_mode(sata_drive_info_t *sdinfo)
12188 {
12189 switch (sdinfo->satadrv_type) {
12190 case SATA_DTYPE_ATADISK:
12191 if (sata_write_cache == 1)
12192 sdinfo->satadrv_settings |= SATA_DEV_WRITE_CACHE;
12193 else if (sata_write_cache == 0)
12194 sdinfo->satadrv_settings &= ~SATA_DEV_WRITE_CACHE;
12195 /*
12196 * When sata_write_cache value is not 0 or 1,
12197 * a current setting of the drive's write cache is used.
12198 */
12199 break;
12200 case SATA_DTYPE_ATAPICD:
12201 if (sata_atapicdvd_write_cache == 1)
12202 sdinfo->satadrv_settings |= SATA_DEV_WRITE_CACHE;
12203 else if (sata_atapicdvd_write_cache == 0)
12204 sdinfo->satadrv_settings &= ~SATA_DEV_WRITE_CACHE;
12205 /*
12206 * When sata_atapicdvd_write_cache value is not 0 or 1,
12207 * a current setting of the drive's write cache is used.
12208 */
12209 break;
12210 case SATA_DTYPE_ATAPITAPE:
12211 if (sata_atapitape_write_cache == 1)
12212 sdinfo->satadrv_settings |= SATA_DEV_WRITE_CACHE;
12213 else if (sata_atapitape_write_cache == 0)
12214 sdinfo->satadrv_settings &= ~SATA_DEV_WRITE_CACHE;
12215 /*
12216 * When sata_atapitape_write_cache value is not 0 or 1,
12217 * a current setting of the drive's write cache is used.
12218 */
12219 break;
12220 case SATA_DTYPE_ATAPIDISK:
12221 if (sata_atapidisk_write_cache == 1)
12222 sdinfo->satadrv_settings |= SATA_DEV_WRITE_CACHE;
12223 else if (sata_atapidisk_write_cache == 0)
12224 sdinfo->satadrv_settings &= ~SATA_DEV_WRITE_CACHE;
12225 /*
12226 * When sata_atapidisk_write_cache value is not 0 or 1,
12227 * a current setting of the drive's write cache is used.
12228 */
12229 break;
12230 }
12231 }
12232
12233
12234 /*
12235 * Validate sata address.
12236 * Specified cport, pmport and qualifier has to match
12237 * passed sata_scsi configuration info.
12238 * The presence of an attached device is not verified.
12239 *
12240 * Returns 0 when address is valid, -1 otherwise.
12241 */
12242 static int
12243 sata_validate_sata_address(sata_hba_inst_t *sata_hba_inst, int cport,
12244 int pmport, int qual)
12245 {
12246 if (qual == SATA_ADDR_DCPORT && pmport != 0)
12247 goto invalid_address;
12248 if (cport >= SATA_NUM_CPORTS(sata_hba_inst))
12249 goto invalid_address;
12250 if ((qual == SATA_ADDR_DPMPORT || qual == SATA_ADDR_PMPORT) &&
12251 ((SATA_CPORT_DEV_TYPE(sata_hba_inst, cport) != SATA_DTYPE_PMULT) ||
12252 (SATA_PMULT_INFO(sata_hba_inst, cport) == NULL) ||
12253 (pmport >= SATA_NUM_PMPORTS(sata_hba_inst, cport))))
12254 goto invalid_address;
12255
12256 return (0);
12257
12258 invalid_address:
12259 return (-1);
12260
12261 }
12262
12263 /*
12264 * Validate scsi address
12265 * SCSI target address is translated into SATA cport/pmport and compared
12266 * with a controller port/device configuration. LUN has to be 0.
12267 * Returns 0 if a scsi target refers to an attached device,
12268 * returns 1 if address is valid but no valid device is attached,
12269 * returns 2 if address is valid but device type is unknown (not valid device),
12270 * returns -1 if bad address or device is of an unsupported type.
12271 * Upon return sata_device argument is set.
12272 *
12273 * Port multiplier is supported now.
12274 */
12275 static int
12276 sata_validate_scsi_address(sata_hba_inst_t *sata_hba_inst,
12277 struct scsi_address *ap, sata_device_t *sata_device)
12278 {
12279 int cport, pmport, qual, rval;
12280
12281 rval = -1; /* Invalid address */
12282 if (ap->a_lun != 0)
12283 goto out;
12284
12285 qual = SCSI_TO_SATA_ADDR_QUAL(ap->a_target);
12286 cport = SCSI_TO_SATA_CPORT(ap->a_target);
12287 pmport = SCSI_TO_SATA_PMPORT(ap->a_target);
12288
12289 if (qual != SATA_ADDR_DCPORT && qual != SATA_ADDR_DPMPORT)
12290 goto out;
12291
12292 if (sata_validate_sata_address(sata_hba_inst, cport, pmport, qual) ==
12293 0) {
12294
12295 sata_cport_info_t *cportinfo;
12296 sata_pmult_info_t *pmultinfo;
12297 sata_drive_info_t *sdinfo = NULL;
12298
12299 sata_device->satadev_addr.qual = qual;
12300 sata_device->satadev_addr.cport = cport;
12301 sata_device->satadev_addr.pmport = pmport;
12302 sata_device->satadev_rev = SATA_DEVICE_REV_1;
12303
12304 rval = 1; /* Valid sata address */
12305
12306 cportinfo = SATA_CPORT_INFO(sata_hba_inst, cport);
12307 if (qual == SATA_ADDR_DCPORT) {
12308 if (cportinfo == NULL ||
12309 cportinfo->cport_dev_type == SATA_DTYPE_NONE)
12310 goto out;
12311
12312 sdinfo = SATA_CPORTINFO_DRV_INFO(cportinfo);
12313 if (cportinfo->cport_dev_type == SATA_DTYPE_UNKNOWN &&
12314 sdinfo != NULL) {
12315 rval = 2;
12316 goto out;
12317 }
12318
12319 if ((cportinfo->cport_dev_type &
12320 SATA_VALID_DEV_TYPE) == 0) {
12321 rval = -1;
12322 goto out;
12323 }
12324
12325 } else if (qual == SATA_ADDR_DPMPORT) {
12326 pmultinfo = SATA_CPORTINFO_PMULT_INFO(cportinfo);
12327 if (pmultinfo == NULL) {
12328 rval = -1;
12329 goto out;
12330 }
12331 if (SATA_PMPORT_INFO(sata_hba_inst, cport, pmport) ==
12332 NULL ||
12333 SATA_PMPORT_DEV_TYPE(sata_hba_inst, cport,
12334 pmport) == SATA_DTYPE_NONE)
12335 goto out;
12336
12337 sdinfo = SATA_PMPORT_DRV_INFO(sata_hba_inst, cport,
12338 pmport);
12339 if (SATA_PMPORT_DEV_TYPE(sata_hba_inst, cport,
12340 pmport) == SATA_DTYPE_UNKNOWN && sdinfo != NULL) {
12341 rval = 2;
12342 goto out;
12343 }
12344
12345 if ((SATA_PMPORT_DEV_TYPE(sata_hba_inst, cport,
12346 pmport) & SATA_VALID_DEV_TYPE) == 0) {
12347 rval = -1;
12348 goto out;
12349 }
12350
12351 } else {
12352 rval = -1;
12353 goto out;
12354 }
12355 if ((sdinfo == NULL) ||
12356 (sdinfo->satadrv_type & SATA_VALID_DEV_TYPE) == 0)
12357 goto out;
12358
12359 sata_device->satadev_type = sdinfo->satadrv_type;
12360
12361 return (0);
12362 }
12363 out:
12364 if (rval > 0) {
12365 SATADBG2(SATA_DBG_SCSI_IF, sata_hba_inst,
12366 "sata_validate_scsi_address: no valid target %x lun %x",
12367 ap->a_target, ap->a_lun);
12368 }
12369 return (rval);
12370 }
12371
12372 /*
12373 * Find dip corresponding to passed device number
12374 *
12375 * Returns NULL if invalid device number is passed or device cannot be found,
12376 * Returns dip is device is found.
12377 */
12378 static dev_info_t *
12379 sata_devt_to_devinfo(dev_t dev)
12380 {
12381 dev_info_t *dip;
12382 #ifndef __lock_lint
12383 struct devnames *dnp;
12384 major_t major = getmajor(dev);
12385 int instance = SATA_MINOR2INSTANCE(getminor(dev));
12386
12387 if (major >= devcnt)
12388 return (NULL);
12389
12390 dnp = &devnamesp[major];
12391 LOCK_DEV_OPS(&(dnp->dn_lock));
12392 dip = dnp->dn_head;
12393 while (dip && (ddi_get_instance(dip) != instance)) {
12394 dip = ddi_get_next(dip);
12395 }
12396 UNLOCK_DEV_OPS(&(dnp->dn_lock));
12397 #endif
12398
12399 return (dip);
12400 }
12401
12402
12403 /*
12404 * Probe device.
12405 * This function issues Identify Device command and initializes local
12406 * sata_drive_info structure if the device can be identified.
12407 * The device type is determined by examining Identify Device
12408 * command response.
12409 * If the sata_hba_inst has linked drive info structure for this
12410 * device address, the Identify Device data is stored into sata_drive_info
12411 * structure linked to the port info structure.
12412 *
12413 * sata_device has to refer to the valid sata port(s) for HBA described
12414 * by sata_hba_inst structure.
12415 *
12416 * Returns:
12417 * SATA_SUCCESS if device type was successfully probed and port-linked
12418 * drive info structure was updated;
12419 * SATA_FAILURE if there is no device, or device was not probed
12420 * successully;
12421 * SATA_RETRY if device probe can be retried later.
12422 * If a device cannot be identified, sata_device's dev_state and dev_type
12423 * fields are set to unknown.
12424 * There are no retries in this function. Any retries should be managed by
12425 * the caller.
12426 */
12427
12428
12429 static int
12430 sata_probe_device(sata_hba_inst_t *sata_hba_inst, sata_device_t *sata_device)
12431 {
12432 sata_pmport_info_t *pmportinfo;
12433 sata_drive_info_t *sdinfo;
12434 sata_drive_info_t new_sdinfo; /* local drive info struct */
12435 int rval;
12436
12437 ASSERT((SATA_CPORT_STATE(sata_hba_inst,
12438 sata_device->satadev_addr.cport) &
12439 (SATA_STATE_PROBED | SATA_STATE_READY)) != 0);
12440
12441 sata_device->satadev_type = SATA_DTYPE_NONE;
12442
12443 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst,
12444 sata_device->satadev_addr.cport)));
12445
12446 if (sata_device->satadev_addr.qual == SATA_ADDR_DPMPORT) {
12447 pmportinfo = SATA_PMPORT_INFO(sata_hba_inst,
12448 sata_device->satadev_addr.cport,
12449 sata_device->satadev_addr.pmport);
12450 ASSERT(pmportinfo != NULL);
12451 }
12452
12453 /* Get pointer to port-linked sata device info structure */
12454 sdinfo = sata_get_device_info(sata_hba_inst, sata_device);
12455 if (sdinfo != NULL) {
12456 sdinfo->satadrv_state &=
12457 ~(SATA_STATE_PROBED | SATA_STATE_READY);
12458 sdinfo->satadrv_state |= SATA_STATE_PROBING;
12459 } else {
12460 /* No device to probe */
12461 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst,
12462 sata_device->satadev_addr.cport)));
12463 sata_device->satadev_type = SATA_DTYPE_NONE;
12464 sata_device->satadev_state = SATA_STATE_UNKNOWN;
12465 return (SATA_FAILURE);
12466 }
12467 /*
12468 * Need to issue both types of identify device command and
12469 * determine device type by examining retreived data/status.
12470 * First, ATA Identify Device.
12471 */
12472 bzero(&new_sdinfo, sizeof (sata_drive_info_t));
12473 new_sdinfo.satadrv_addr = sata_device->satadev_addr;
12474 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst,
12475 sata_device->satadev_addr.cport)));
12476 new_sdinfo.satadrv_type = SATA_DTYPE_ATADISK;
12477 rval = sata_identify_device(sata_hba_inst, &new_sdinfo);
12478 if (rval == SATA_RETRY) {
12479 /* We may try to check for ATAPI device */
12480 if (SATA_FEATURES(sata_hba_inst) & SATA_CTLF_ATAPI) {
12481 /*
12482 * HBA supports ATAPI - try to issue Identify Packet
12483 * Device command.
12484 */
12485 new_sdinfo.satadrv_type = SATA_DTYPE_ATAPI;
12486 rval = sata_identify_device(sata_hba_inst, &new_sdinfo);
12487 }
12488 }
12489 if (rval == SATA_SUCCESS) {
12490 /*
12491 * Got something responding positively to ATA Identify Device
12492 * or to Identify Packet Device cmd.
12493 * Save last used device type.
12494 */
12495 sata_device->satadev_type = new_sdinfo.satadrv_type;
12496
12497 /* save device info, if possible */
12498 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst,
12499 sata_device->satadev_addr.cport)));
12500 sdinfo = sata_get_device_info(sata_hba_inst, sata_device);
12501 if (sdinfo == NULL) {
12502 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst,
12503 sata_device->satadev_addr.cport)));
12504 return (SATA_FAILURE);
12505 }
12506 /*
12507 * Copy drive info into the port-linked drive info structure.
12508 */
12509 *sdinfo = new_sdinfo;
12510 sdinfo->satadrv_state &= ~SATA_STATE_PROBING;
12511 sdinfo->satadrv_state |= SATA_STATE_PROBED;
12512 if (sata_device->satadev_addr.qual == SATA_ADDR_DCPORT)
12513 SATA_CPORT_DEV_TYPE(sata_hba_inst,
12514 sata_device->satadev_addr.cport) =
12515 sdinfo->satadrv_type;
12516 else { /* SATA_ADDR_DPMPORT */
12517 mutex_enter(&pmportinfo->pmport_mutex);
12518 SATA_PMPORT_DEV_TYPE(sata_hba_inst,
12519 sata_device->satadev_addr.cport,
12520 sata_device->satadev_addr.pmport) =
12521 sdinfo->satadrv_type;
12522 mutex_exit(&pmportinfo->pmport_mutex);
12523 }
12524 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst,
12525 sata_device->satadev_addr.cport)));
12526 return (SATA_SUCCESS);
12527 }
12528
12529 /*
12530 * It may be SATA_RETRY or SATA_FAILURE return.
12531 * Looks like we cannot determine the device type at this time.
12532 */
12533 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst,
12534 sata_device->satadev_addr.cport)));
12535 sdinfo = sata_get_device_info(sata_hba_inst, sata_device);
12536 if (sdinfo != NULL) {
12537 sata_device->satadev_type = SATA_DTYPE_UNKNOWN;
12538 sdinfo->satadrv_type = SATA_DTYPE_UNKNOWN;
12539 sdinfo->satadrv_state &= ~SATA_STATE_PROBING;
12540 sdinfo->satadrv_state |= SATA_STATE_PROBED;
12541 if (sata_device->satadev_addr.qual == SATA_ADDR_DCPORT)
12542 SATA_CPORT_DEV_TYPE(sata_hba_inst,
12543 sata_device->satadev_addr.cport) =
12544 SATA_DTYPE_UNKNOWN;
12545 else {
12546 /* SATA_ADDR_DPMPORT */
12547 mutex_enter(&pmportinfo->pmport_mutex);
12548 if ((SATA_PMULT_INFO(sata_hba_inst,
12549 sata_device->satadev_addr.cport) != NULL) &&
12550 (SATA_PMPORT_INFO(sata_hba_inst,
12551 sata_device->satadev_addr.cport,
12552 sata_device->satadev_addr.pmport) != NULL))
12553 SATA_PMPORT_DEV_TYPE(sata_hba_inst,
12554 sata_device->satadev_addr.cport,
12555 sata_device->satadev_addr.pmport) =
12556 SATA_DTYPE_UNKNOWN;
12557 mutex_exit(&pmportinfo->pmport_mutex);
12558 }
12559 }
12560 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst,
12561 sata_device->satadev_addr.cport)));
12562 return (rval);
12563 }
12564
12565
12566 /*
12567 * Get pointer to sata_drive_info structure.
12568 *
12569 * The sata_device has to contain address (cport, pmport and qualifier) for
12570 * specified sata_scsi structure.
12571 *
12572 * Returns NULL if device address is not valid for this HBA configuration.
12573 * Otherwise, returns a pointer to sata_drive_info structure.
12574 *
12575 * This function should be called with a port mutex held.
12576 */
12577 static sata_drive_info_t *
12578 sata_get_device_info(sata_hba_inst_t *sata_hba_inst,
12579 sata_device_t *sata_device)
12580 {
12581 uint8_t cport = sata_device->satadev_addr.cport;
12582 uint8_t pmport = sata_device->satadev_addr.pmport;
12583 uint8_t qual = sata_device->satadev_addr.qual;
12584
12585 if (cport >= SATA_NUM_CPORTS(sata_hba_inst))
12586 return (NULL);
12587
12588 if (!(SATA_CPORT_STATE(sata_hba_inst, cport) &
12589 (SATA_STATE_PROBED | SATA_STATE_READY)))
12590 /* Port not probed yet */
12591 return (NULL);
12592
12593 if (SATA_CPORT_DEV_TYPE(sata_hba_inst, cport) == SATA_DTYPE_NONE)
12594 return (NULL);
12595
12596 if (qual == SATA_ADDR_DCPORT) {
12597 /* Request for a device on a controller port */
12598 if (SATA_CPORT_DEV_TYPE(sata_hba_inst, cport) ==
12599 SATA_DTYPE_PMULT)
12600 /* Port multiplier attached */
12601 return (NULL);
12602 return (SATA_CPORT_DRV_INFO(sata_hba_inst, cport));
12603 }
12604 if (qual == SATA_ADDR_DPMPORT) {
12605 if (SATA_CPORT_DEV_TYPE(sata_hba_inst, cport) !=
12606 SATA_DTYPE_PMULT)
12607 return (NULL);
12608
12609 if (pmport > SATA_NUM_PMPORTS(sata_hba_inst, cport))
12610 return (NULL);
12611
12612 if (!(SATA_PMPORT_STATE(sata_hba_inst, cport, pmport) &
12613 (SATA_STATE_PROBED | SATA_STATE_READY)))
12614 /* Port multiplier port not probed yet */
12615 return (NULL);
12616
12617 return (SATA_PMPORT_DRV_INFO(sata_hba_inst, cport, pmport));
12618 }
12619
12620 /* we should not get here */
12621 return (NULL);
12622 }
12623
12624
12625 /*
12626 * sata_identify_device.
12627 * Send Identify Device command to SATA HBA driver.
12628 * If command executes successfully, update sata_drive_info structure pointed
12629 * to by sdinfo argument, including Identify Device data.
12630 * If command fails, invalidate data in sata_drive_info.
12631 *
12632 * Cannot be called from interrupt level.
12633 *
12634 * Returns:
12635 * SATA_SUCCESS if the device was identified as a supported device,
12636 * SATA_RETRY if the device was not identified but could be retried,
12637 * SATA_FAILURE if the device was not identified and identify attempt
12638 * should not be retried.
12639 */
12640 static int
12641 sata_identify_device(sata_hba_inst_t *sata_hba_inst,
12642 sata_drive_info_t *sdinfo)
12643 {
12644 uint16_t cfg_word;
12645 int rval;
12646
12647 /* fetch device identify data */
12648 if ((rval = sata_fetch_device_identify_data(sata_hba_inst,
12649 sdinfo)) != SATA_SUCCESS)
12650 goto fail_unknown;
12651
12652 cfg_word = sdinfo->satadrv_id.ai_config;
12653
12654 /* Set the correct device type */
12655 if ((cfg_word & SATA_ATA_TYPE_MASK) == SATA_ATA_TYPE) {
12656 sdinfo->satadrv_type = SATA_DTYPE_ATADISK;
12657 } else if (cfg_word == SATA_CFA_TYPE) {
12658 /* It's a Compact Flash media via CF-to-SATA HDD adapter */
12659 sdinfo->satadrv_type = SATA_DTYPE_ATADISK;
12660 } else if ((cfg_word & SATA_ATAPI_TYPE_MASK) == SATA_ATAPI_TYPE) {
12661 switch (cfg_word & SATA_ATAPI_ID_DEV_TYPE) {
12662 case SATA_ATAPI_CDROM_DEV:
12663 sdinfo->satadrv_type = SATA_DTYPE_ATAPICD;
12664 break;
12665 case SATA_ATAPI_SQACC_DEV:
12666 sdinfo->satadrv_type = SATA_DTYPE_ATAPITAPE;
12667 break;
12668 case SATA_ATAPI_DIRACC_DEV:
12669 sdinfo->satadrv_type = SATA_DTYPE_ATAPIDISK;
12670 break;
12671 case SATA_ATAPI_PROC_DEV:
12672 sdinfo->satadrv_type = SATA_DTYPE_ATAPIPROC;
12673 break;
12674 default:
12675 sdinfo->satadrv_type = SATA_DTYPE_UNKNOWN;
12676 }
12677 } else {
12678 sdinfo->satadrv_type = SATA_DTYPE_UNKNOWN;
12679 }
12680
12681 if (sdinfo->satadrv_type == SATA_DTYPE_ATADISK) {
12682 if (sdinfo->satadrv_capacity == 0) {
12683 /* Non-LBA disk. Too bad... */
12684 sata_log(sata_hba_inst, CE_WARN,
12685 "SATA disk device at port %d does not support LBA",
12686 sdinfo->satadrv_addr.cport);
12687 rval = SATA_FAILURE;
12688 goto fail_unknown;
12689 }
12690 }
12691 #if 0
12692 /* Left for historical reason */
12693 /*
12694 * Some initial version of SATA spec indicated that at least
12695 * UDMA mode 4 has to be supported. It is not metioned in
12696 * SerialATA 2.6, so this restriction is removed.
12697 */
12698 /* Check for Ultra DMA modes 6 through 0 being supported */
12699 for (i = 6; i >= 0; --i) {
12700 if (sdinfo->satadrv_id.ai_ultradma & (1 << i))
12701 break;
12702 }
12703
12704 /*
12705 * At least UDMA 4 mode has to be supported. If mode 4 or
12706 * higher are not supported by the device, fail this
12707 * device.
12708 */
12709 if (i < 4) {
12710 /* No required Ultra DMA mode supported */
12711 sata_log(sata_hba_inst, CE_WARN,
12712 "SATA disk device at port %d does not support UDMA "
12713 "mode 4 or higher", sdinfo->satadrv_addr.cport);
12714 SATA_LOG_D((sata_hba_inst, CE_WARN,
12715 "mode 4 or higher required, %d supported", i));
12716 rval = SATA_FAILURE;
12717 goto fail_unknown;
12718 }
12719 #endif
12720
12721 /*
12722 * For Disk devices, if it doesn't support UDMA mode, we would
12723 * like to return failure directly.
12724 */
12725 if ((sdinfo->satadrv_type == SATA_DTYPE_ATADISK) &&
12726 !((sdinfo->satadrv_id.ai_validinfo & SATA_VALIDINFO_88) != 0 &&
12727 (sdinfo->satadrv_id.ai_ultradma & SATA_UDMA_SUP_MASK) != 0)) {
12728 sata_log(sata_hba_inst, CE_WARN,
12729 "SATA disk device at port %d does not support UDMA",
12730 sdinfo->satadrv_addr.cport);
12731 rval = SATA_FAILURE;
12732 goto fail_unknown;
12733 }
12734
12735 return (SATA_SUCCESS);
12736
12737 fail_unknown:
12738 /* Invalidate sata_drive_info ? */
12739 sdinfo->satadrv_type = SATA_DTYPE_UNKNOWN;
12740 sdinfo->satadrv_state = SATA_STATE_UNKNOWN;
12741 return (rval);
12742 }
12743
12744 /*
12745 * Log/display device information
12746 */
12747 static void
12748 sata_show_drive_info(sata_hba_inst_t *sata_hba_inst,
12749 sata_drive_info_t *sdinfo)
12750 {
12751 int valid_version;
12752 char msg_buf[MAXPATHLEN];
12753 int i;
12754
12755 /* Show HBA path */
12756 (void) ddi_pathname(SATA_DIP(sata_hba_inst), msg_buf);
12757
12758 cmn_err(CE_CONT, "?%s :\n", msg_buf);
12759
12760 switch (sdinfo->satadrv_type) {
12761 case SATA_DTYPE_ATADISK:
12762 (void) sprintf(msg_buf, "SATA disk device at");
12763 break;
12764
12765 case SATA_DTYPE_ATAPICD:
12766 (void) sprintf(msg_buf, "SATA CD/DVD (ATAPI) device at");
12767 break;
12768
12769 case SATA_DTYPE_ATAPITAPE:
12770 (void) sprintf(msg_buf, "SATA tape (ATAPI) device at");
12771 break;
12772
12773 case SATA_DTYPE_ATAPIDISK:
12774 (void) sprintf(msg_buf, "SATA disk (ATAPI) device at");
12775 break;
12776
12777 case SATA_DTYPE_ATAPIPROC:
12778 (void) sprintf(msg_buf, "SATA processor (ATAPI) device at");
12779 break;
12780
12781 case SATA_DTYPE_UNKNOWN:
12782 (void) sprintf(msg_buf,
12783 "Unsupported SATA device type (cfg 0x%x) at ",
12784 sdinfo->satadrv_id.ai_config);
12785 break;
12786 }
12787
12788 if (sdinfo->satadrv_addr.qual == SATA_ADDR_DCPORT)
12789 cmn_err(CE_CONT, "?\t%s port %d\n",
12790 msg_buf, sdinfo->satadrv_addr.cport);
12791 else
12792 cmn_err(CE_CONT, "?\t%s port %d:%d\n",
12793 msg_buf, sdinfo->satadrv_addr.cport,
12794 sdinfo->satadrv_addr.pmport);
12795
12796 bcopy(&sdinfo->satadrv_id.ai_model, msg_buf,
12797 sizeof (sdinfo->satadrv_id.ai_model));
12798 swab(msg_buf, msg_buf, sizeof (sdinfo->satadrv_id.ai_model));
12799 msg_buf[sizeof (sdinfo->satadrv_id.ai_model)] = '\0';
12800 cmn_err(CE_CONT, "?\tmodel %s\n", msg_buf);
12801
12802 bcopy(&sdinfo->satadrv_id.ai_fw, msg_buf,
12803 sizeof (sdinfo->satadrv_id.ai_fw));
12804 swab(msg_buf, msg_buf, sizeof (sdinfo->satadrv_id.ai_fw));
12805 msg_buf[sizeof (sdinfo->satadrv_id.ai_fw)] = '\0';
12806 cmn_err(CE_CONT, "?\tfirmware %s\n", msg_buf);
12807
12808 bcopy(&sdinfo->satadrv_id.ai_drvser, msg_buf,
12809 sizeof (sdinfo->satadrv_id.ai_drvser));
12810 swab(msg_buf, msg_buf, sizeof (sdinfo->satadrv_id.ai_drvser));
12811 msg_buf[sizeof (sdinfo->satadrv_id.ai_drvser)] = '\0';
12812 if (sdinfo->satadrv_type == SATA_DTYPE_ATADISK) {
12813 cmn_err(CE_CONT, "?\tserial number %s\n", msg_buf);
12814 } else {
12815 /*
12816 * Some drives do not implement serial number and may
12817 * violate the spec by providing spaces rather than zeros
12818 * in serial number field. Scan the buffer to detect it.
12819 */
12820 for (i = 0; i < sizeof (sdinfo->satadrv_id.ai_drvser); i++) {
12821 if (msg_buf[i] != '\0' && msg_buf[i] != ' ')
12822 break;
12823 }
12824 if (i == sizeof (sdinfo->satadrv_id.ai_drvser)) {
12825 cmn_err(CE_CONT, "?\tserial number - none\n");
12826 } else {
12827 cmn_err(CE_CONT, "?\tserial number %s\n", msg_buf);
12828 }
12829 }
12830
12831 #ifdef SATA_DEBUG
12832 if (sdinfo->satadrv_id.ai_majorversion != 0 &&
12833 sdinfo->satadrv_id.ai_majorversion != 0xffff) {
12834 int i;
12835 for (i = 14; i >= 2; i--) {
12836 if (sdinfo->satadrv_id.ai_majorversion & (1 << i)) {
12837 valid_version = i;
12838 break;
12839 }
12840 }
12841 cmn_err(CE_CONT,
12842 "?\tATA/ATAPI-%d supported, majver 0x%x minver 0x%x\n",
12843 valid_version,
12844 sdinfo->satadrv_id.ai_majorversion,
12845 sdinfo->satadrv_id.ai_minorversion);
12846 }
12847 #endif
12848 /* Log some info */
12849 cmn_err(CE_CONT, "?\tsupported features:\n");
12850 msg_buf[0] = '\0';
12851 if (sdinfo->satadrv_type == SATA_DTYPE_ATADISK) {
12852 if (sdinfo->satadrv_features_support & SATA_DEV_F_LBA48)
12853 (void) strlcat(msg_buf, "48-bit LBA, ", MAXPATHLEN);
12854 else if (sdinfo->satadrv_features_support & SATA_DEV_F_LBA28)
12855 (void) strlcat(msg_buf, "28-bit LBA, ", MAXPATHLEN);
12856 }
12857 if (sdinfo->satadrv_features_support & SATA_DEV_F_DMA)
12858 (void) strlcat(msg_buf, "DMA", MAXPATHLEN);
12859 if (sdinfo->satadrv_features_support & SATA_DEV_F_NCQ)
12860 (void) strlcat(msg_buf, ", Native Command Queueing",
12861 MAXPATHLEN);
12862 if (sdinfo->satadrv_features_support & SATA_DEV_F_TCQ)
12863 (void) strlcat(msg_buf, ", Legacy Tagged Queuing", MAXPATHLEN);
12864 if ((sdinfo->satadrv_id.ai_cmdset82 & SATA_SMART_SUPPORTED) &&
12865 (sdinfo->satadrv_id.ai_features85 & SATA_SMART_ENABLED))
12866 (void) strlcat(msg_buf, ", SMART", MAXPATHLEN);
12867 if ((sdinfo->satadrv_id.ai_cmdset84 & SATA_SMART_SELF_TEST_SUPPORTED) &&
12868 (sdinfo->satadrv_id.ai_features87 & SATA_SMART_SELF_TEST_SUPPORTED))
12869 (void) strlcat(msg_buf, ", SMART self-test", MAXPATHLEN);
12870 cmn_err(CE_CONT, "?\t %s\n", msg_buf);
12871 if (sdinfo->satadrv_features_support & SATA_DEV_F_SATA3)
12872 cmn_err(CE_CONT, "?\tSATA Gen3 signaling speed (6.0Gbps)\n");
12873 else if (sdinfo->satadrv_features_support & SATA_DEV_F_SATA2)
12874 cmn_err(CE_CONT, "?\tSATA Gen2 signaling speed (3.0Gbps)\n");
12875 else if (sdinfo->satadrv_features_support & SATA_DEV_F_SATA1)
12876 cmn_err(CE_CONT, "?\tSATA Gen1 signaling speed (1.5Gbps)\n");
12877 if (sdinfo->satadrv_features_support &
12878 (SATA_DEV_F_TCQ | SATA_DEV_F_NCQ)) {
12879 msg_buf[0] = '\0';
12880 (void) snprintf(msg_buf, MAXPATHLEN,
12881 "Supported queue depth %d",
12882 sdinfo->satadrv_queue_depth);
12883 if (!(sata_func_enable &
12884 (SATA_ENABLE_QUEUING | SATA_ENABLE_NCQ)))
12885 (void) strlcat(msg_buf,
12886 " - queueing disabled globally", MAXPATHLEN);
12887 else if (sdinfo->satadrv_queue_depth >
12888 sdinfo->satadrv_max_queue_depth) {
12889 (void) snprintf(&msg_buf[strlen(msg_buf)],
12890 MAXPATHLEN - strlen(msg_buf), ", limited to %d",
12891 (int)sdinfo->satadrv_max_queue_depth);
12892 }
12893 cmn_err(CE_CONT, "?\t%s\n", msg_buf);
12894 }
12895
12896 if (sdinfo->satadrv_type == SATA_DTYPE_ATADISK) {
12897 #ifdef __i386
12898 (void) sprintf(msg_buf, "\tcapacity = %llu sectors\n",
12899 sdinfo->satadrv_capacity);
12900 #else
12901 (void) sprintf(msg_buf, "\tcapacity = %lu sectors\n",
12902 sdinfo->satadrv_capacity);
12903 #endif
12904 cmn_err(CE_CONT, "?%s", msg_buf);
12905 }
12906 }
12907
12908 /*
12909 * Log/display port multiplier information
12910 * No Mutex should be hold.
12911 */
12912 static void
12913 sata_show_pmult_info(sata_hba_inst_t *sata_hba_inst,
12914 sata_device_t *sata_device)
12915 {
12916 _NOTE(ARGUNUSED(sata_hba_inst))
12917
12918 int cport = sata_device->satadev_addr.cport;
12919 sata_pmult_info_t *pmultinfo;
12920 char msg_buf[MAXPATHLEN];
12921 uint32_t gscr0, gscr1, gscr2, gscr64;
12922
12923 mutex_enter(&SATA_CPORT_MUTEX(sata_hba_inst, cport));
12924 pmultinfo = SATA_PMULT_INFO(sata_hba_inst, cport);
12925 if (pmultinfo == NULL) {
12926 mutex_exit(&SATA_CPORT_MUTEX(sata_hba_inst, cport));
12927 return;
12928 }
12929
12930 gscr0 = pmultinfo->pmult_gscr.gscr0;
12931 gscr1 = pmultinfo->pmult_gscr.gscr1;
12932 gscr2 = pmultinfo->pmult_gscr.gscr2;
12933 gscr64 = pmultinfo->pmult_gscr.gscr64;
12934 mutex_exit(&SATA_CPORT_MUTEX(sata_hba_inst, cport));
12935
12936 cmn_err(CE_CONT, "?Port Multiplier %d device-ports found at port %d",
12937 sata_device->satadev_add_info, sata_device->satadev_addr.cport);
12938
12939 (void) sprintf(msg_buf, "\tVendor_ID 0x%04x, Module_ID 0x%04x",
12940 gscr0 & 0xffff, (gscr0 >> 16) & 0xffff);
12941 cmn_err(CE_CONT, "?%s", msg_buf);
12942
12943 (void) strcpy(msg_buf, "\tSupport SATA PMP Spec ");
12944 if (gscr1 & (1 << 3))
12945 (void) strlcat(msg_buf, "1.2", MAXPATHLEN);
12946 else if (gscr1 & (1 << 2))
12947 (void) strlcat(msg_buf, "1.1", MAXPATHLEN);
12948 else if (gscr1 & (1 << 1))
12949 (void) strlcat(msg_buf, "1.0", MAXPATHLEN);
12950 else
12951 (void) strlcat(msg_buf, "unknown", MAXPATHLEN);
12952 cmn_err(CE_CONT, "?%s", msg_buf);
12953
12954 (void) strcpy(msg_buf, "\tSupport ");
12955 if (gscr64 & (1 << 3))
12956 (void) strlcat(msg_buf, "Asy-Notif, ",
12957 MAXPATHLEN);
12958 if (gscr64 & (1 << 2))
12959 (void) strlcat(msg_buf, "Dyn-SSC, ", MAXPATHLEN);
12960 if (gscr64 & (1 << 1))
12961 (void) strlcat(msg_buf, "Iss-PMREQ, ", MAXPATHLEN);
12962 if (gscr64 & (1 << 0))
12963 (void) strlcat(msg_buf, "BIST", MAXPATHLEN);
12964 if ((gscr64 & 0xf) == 0)
12965 (void) strlcat(msg_buf, "nothing", MAXPATHLEN);
12966 cmn_err(CE_CONT, "?%s", msg_buf);
12967
12968 (void) sprintf(msg_buf, "\tNumber of exposed device fan-out ports: %d",
12969 gscr2 & SATA_PMULT_PORTNUM_MASK);
12970 cmn_err(CE_CONT, "?%s", msg_buf);
12971 }
12972
12973 /*
12974 * sata_save_drive_settings extracts current setting of the device and stores
12975 * it for future reference, in case the device setup would need to be restored
12976 * after the device reset.
12977 *
12978 * For all devices read ahead and write cache settings are saved, if the
12979 * device supports these features at all.
12980 * For ATAPI devices the Removable Media Status Notification setting is saved.
12981 */
12982 static void
12983 sata_save_drive_settings(sata_drive_info_t *sdinfo)
12984 {
12985 if (SATA_READ_AHEAD_SUPPORTED(sdinfo->satadrv_id) ||
12986 SATA_WRITE_CACHE_SUPPORTED(sdinfo->satadrv_id)) {
12987
12988 /* Current setting of Read Ahead (and Read Cache) */
12989 if (SATA_READ_AHEAD_ENABLED(sdinfo->satadrv_id))
12990 sdinfo->satadrv_settings |= SATA_DEV_READ_AHEAD;
12991 else
12992 sdinfo->satadrv_settings &= ~SATA_DEV_READ_AHEAD;
12993
12994 /* Current setting of Write Cache */
12995 if (SATA_WRITE_CACHE_ENABLED(sdinfo->satadrv_id))
12996 sdinfo->satadrv_settings |= SATA_DEV_WRITE_CACHE;
12997 else
12998 sdinfo->satadrv_settings &= ~SATA_DEV_WRITE_CACHE;
12999 }
13000
13001 if (sdinfo->satadrv_type == SATA_DTYPE_ATAPICD) {
13002 if (SATA_RM_NOTIFIC_SUPPORTED(sdinfo->satadrv_id))
13003 sdinfo->satadrv_settings |= SATA_DEV_RMSN;
13004 else
13005 sdinfo->satadrv_settings &= ~SATA_DEV_RMSN;
13006 }
13007 }
13008
13009
13010 /*
13011 * sata_check_capacity function determines a disk capacity
13012 * and addressing mode (LBA28/LBA48) by examining a disk identify device data.
13013 *
13014 * NOTE: CHS mode is not supported! If a device does not support LBA,
13015 * this function is not called.
13016 *
13017 * Returns device capacity in number of blocks, i.e. largest addressable LBA+1
13018 */
13019 static uint64_t
13020 sata_check_capacity(sata_drive_info_t *sdinfo)
13021 {
13022 uint64_t capacity = 0;
13023 int i;
13024
13025 if (sdinfo->satadrv_type != SATA_DTYPE_ATADISK ||
13026 !sdinfo->satadrv_id.ai_cap & SATA_LBA_SUPPORT)
13027 /* Capacity valid only for LBA-addressable disk devices */
13028 return (0);
13029
13030 if ((sdinfo->satadrv_id.ai_validinfo & SATA_VALIDINFO_88) &&
13031 (sdinfo->satadrv_id.ai_cmdset83 & SATA_EXT48) &&
13032 (sdinfo->satadrv_id.ai_features86 & SATA_EXT48)) {
13033 /* LBA48 mode supported and enabled */
13034 sdinfo->satadrv_features_support |= SATA_DEV_F_LBA48 |
13035 SATA_DEV_F_LBA28;
13036 for (i = 3; i >= 0; --i) {
13037 capacity <<= 16;
13038 capacity += sdinfo->satadrv_id.ai_addrsecxt[i];
13039 }
13040 } else {
13041 capacity = sdinfo->satadrv_id.ai_addrsec[1];
13042 capacity <<= 16;
13043 capacity += sdinfo->satadrv_id.ai_addrsec[0];
13044 if (capacity >= 0x1000000)
13045 /* LBA28 mode */
13046 sdinfo->satadrv_features_support |= SATA_DEV_F_LBA28;
13047 }
13048 return (capacity);
13049 }
13050
13051
13052 /*
13053 * Allocate consistent buffer for DMA transfer
13054 *
13055 * Cannot be called from interrupt level or with mutex held - it may sleep.
13056 *
13057 * Returns pointer to allocated buffer structure, or NULL if allocation failed.
13058 */
13059 static struct buf *
13060 sata_alloc_local_buffer(sata_pkt_txlate_t *spx, int len)
13061 {
13062 struct scsi_address ap;
13063 struct buf *bp;
13064 ddi_dma_attr_t cur_dma_attr;
13065
13066 ASSERT(spx->txlt_sata_pkt != NULL);
13067 ap.a_hba_tran = spx->txlt_sata_hba_inst->satahba_scsi_tran;
13068 ap.a_target = SATA_TO_SCSI_TARGET(
13069 spx->txlt_sata_pkt->satapkt_device.satadev_addr.cport,
13070 spx->txlt_sata_pkt->satapkt_device.satadev_addr.pmport,
13071 spx->txlt_sata_pkt->satapkt_device.satadev_addr.qual);
13072 ap.a_lun = 0;
13073
13074 bp = scsi_alloc_consistent_buf(&ap, NULL, len,
13075 B_READ, SLEEP_FUNC, NULL);
13076
13077 if (bp != NULL) {
13078 /* Allocate DMA resources for this buffer */
13079 spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp = bp;
13080 /*
13081 * We use a local version of the dma_attr, to account
13082 * for a device addressing limitations.
13083 * sata_adjust_dma_attr() will handle sdinfo == NULL which
13084 * will cause dma attributes to be adjusted to a lowest
13085 * acceptable level.
13086 */
13087 sata_adjust_dma_attr(NULL,
13088 SATA_DMA_ATTR(spx->txlt_sata_hba_inst), &cur_dma_attr);
13089
13090 if (sata_dma_buf_setup(spx, PKT_CONSISTENT,
13091 SLEEP_FUNC, NULL, &cur_dma_attr) != DDI_SUCCESS) {
13092 scsi_free_consistent_buf(bp);
13093 spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp = NULL;
13094 bp = NULL;
13095 }
13096 }
13097 return (bp);
13098 }
13099
13100 /*
13101 * Release local buffer (consistent buffer for DMA transfer) allocated
13102 * via sata_alloc_local_buffer().
13103 */
13104 static void
13105 sata_free_local_buffer(sata_pkt_txlate_t *spx)
13106 {
13107 ASSERT(spx->txlt_sata_pkt != NULL);
13108 ASSERT(spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp != NULL);
13109
13110 spx->txlt_sata_pkt->satapkt_cmd.satacmd_num_dma_cookies = 0;
13111 spx->txlt_sata_pkt->satapkt_cmd.satacmd_dma_cookie_list = NULL;
13112
13113 sata_common_free_dma_rsrcs(spx);
13114
13115 /* Free buffer */
13116 scsi_free_consistent_buf(spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp);
13117 spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp = NULL;
13118 }
13119
13120 /*
13121 * Allocate sata_pkt
13122 * Pkt structure version and embedded strcutures version are initialized.
13123 * sata_pkt and sata_pkt_txlate structures are cross-linked.
13124 *
13125 * Since this may be called in interrupt context by sata_scsi_init_pkt,
13126 * callback argument determines if it can sleep or not.
13127 * Hence, it should not be called from interrupt context.
13128 *
13129 * If successful, non-NULL pointer to a sata pkt is returned.
13130 * Upon failure, NULL pointer is returned.
13131 */
13132 static sata_pkt_t *
13133 sata_pkt_alloc(sata_pkt_txlate_t *spx, int (*callback)(caddr_t))
13134 {
13135 sata_pkt_t *spkt;
13136 int kmsflag;
13137
13138 kmsflag = (callback == SLEEP_FUNC) ? KM_SLEEP : KM_NOSLEEP;
13139 spkt = kmem_zalloc(sizeof (sata_pkt_t), kmsflag);
13140 if (spkt == NULL) {
13141 SATA_LOG_D((spx->txlt_sata_hba_inst, CE_WARN,
13142 "sata_pkt_alloc: failed"));
13143 return (NULL);
13144 }
13145 spkt->satapkt_rev = SATA_PKT_REV;
13146 spkt->satapkt_cmd.satacmd_rev = SATA_CMD_REV;
13147 spkt->satapkt_device.satadev_rev = SATA_DEVICE_REV;
13148 spkt->satapkt_framework_private = spx;
13149 spx->txlt_sata_pkt = spkt;
13150 return (spkt);
13151 }
13152
13153 /*
13154 * Free sata pkt allocated via sata_pkt_alloc()
13155 */
13156 static void
13157 sata_pkt_free(sata_pkt_txlate_t *spx)
13158 {
13159 ASSERT(spx->txlt_sata_pkt != NULL);
13160 ASSERT(spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp == NULL);
13161 kmem_free(spx->txlt_sata_pkt, sizeof (sata_pkt_t));
13162 spx->txlt_sata_pkt = NULL;
13163 }
13164
13165
13166 /*
13167 * Adjust DMA attributes.
13168 * SCSI cmds block count is up to 24 bits, SATA cmd block count vary
13169 * from 8 bits to 16 bits, depending on a command being used.
13170 * Limiting max block count arbitrarily to 256 for all read/write
13171 * commands may affects performance, so check both the device and
13172 * controller capability before adjusting dma attributes.
13173 */
13174 void
13175 sata_adjust_dma_attr(sata_drive_info_t *sdinfo, ddi_dma_attr_t *dma_attr,
13176 ddi_dma_attr_t *adj_dma_attr)
13177 {
13178 uint32_t count_max;
13179
13180 /* Copy original attributes */
13181 *adj_dma_attr = *dma_attr;
13182 /*
13183 * Things to consider: device addressing capability,
13184 * "excessive" controller DMA capabilities.
13185 * If a device is being probed/initialized, there are
13186 * no device info - use default limits then.
13187 */
13188 if (sdinfo == NULL) {
13189 count_max = dma_attr->dma_attr_granular * 0x100;
13190 if (dma_attr->dma_attr_count_max > count_max)
13191 adj_dma_attr->dma_attr_count_max = count_max;
13192 if (dma_attr->dma_attr_maxxfer > count_max)
13193 adj_dma_attr->dma_attr_maxxfer = count_max;
13194 return;
13195 }
13196
13197 if (sdinfo->satadrv_type == SATA_DTYPE_ATADISK) {
13198 if (sdinfo->satadrv_features_support & (SATA_DEV_F_LBA48)) {
13199 /*
13200 * 16-bit sector count may be used - we rely on
13201 * the assumption that only read and write cmds
13202 * will request more than 256 sectors worth of data
13203 */
13204 count_max = adj_dma_attr->dma_attr_granular * 0x10000;
13205 } else {
13206 /*
13207 * 8-bit sector count will be used - default limits
13208 * for dma attributes
13209 */
13210 count_max = adj_dma_attr->dma_attr_granular * 0x100;
13211 }
13212 /*
13213 * Adjust controler dma attributes, if necessary
13214 */
13215 if (dma_attr->dma_attr_count_max > count_max)
13216 adj_dma_attr->dma_attr_count_max = count_max;
13217 if (dma_attr->dma_attr_maxxfer > count_max)
13218 adj_dma_attr->dma_attr_maxxfer = count_max;
13219 }
13220 }
13221
13222
13223 /*
13224 * Allocate DMA resources for the buffer
13225 * This function handles initial DMA resource allocation as well as
13226 * DMA window shift and may be called repeatedly for the same DMA window
13227 * until all DMA cookies in the DMA window are processed.
13228 * To guarantee that there is always a coherent set of cookies to process
13229 * by SATA HBA driver (observing alignment, device granularity, etc.),
13230 * the number of slots for DMA cookies is equal to lesser of a number of
13231 * cookies in a DMA window and a max number of scatter/gather entries.
13232 *
13233 * Returns DDI_SUCCESS upon successful operation.
13234 * Return failure code of a failing command or DDI_FAILURE when
13235 * internal cleanup failed.
13236 */
13237 static int
13238 sata_dma_buf_setup(sata_pkt_txlate_t *spx, int flags,
13239 int (*callback)(caddr_t), caddr_t arg,
13240 ddi_dma_attr_t *cur_dma_attr)
13241 {
13242 int rval;
13243 off_t offset;
13244 size_t size;
13245 int max_sg_len, req_len, i;
13246 uint_t dma_flags;
13247 struct buf *bp;
13248 uint64_t cur_txfer_len;
13249
13250
13251 ASSERT(spx->txlt_sata_pkt != NULL);
13252 bp = spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp;
13253 ASSERT(bp != NULL);
13254
13255
13256 if (spx->txlt_buf_dma_handle == NULL) {
13257 /*
13258 * No DMA resources allocated so far - this is a first call
13259 * for this sata pkt.
13260 */
13261 rval = ddi_dma_alloc_handle(SATA_DIP(spx->txlt_sata_hba_inst),
13262 cur_dma_attr, callback, arg, &spx->txlt_buf_dma_handle);
13263
13264 if (rval != DDI_SUCCESS) {
13265 SATA_LOG_D((spx->txlt_sata_hba_inst, CE_WARN,
13266 "sata_dma_buf_setup: no buf DMA resources %x",
13267 rval));
13268 return (rval);
13269 }
13270
13271 if (bp->b_flags & B_READ)
13272 dma_flags = DDI_DMA_READ;
13273 else
13274 dma_flags = DDI_DMA_WRITE;
13275
13276 if (flags & PKT_CONSISTENT)
13277 dma_flags |= DDI_DMA_CONSISTENT;
13278
13279 if (flags & PKT_DMA_PARTIAL)
13280 dma_flags |= DDI_DMA_PARTIAL;
13281
13282 /*
13283 * Check buffer alignment and size against dma attributes
13284 * Consider dma_attr_align only. There may be requests
13285 * with the size lower than device granularity, but they
13286 * will not read/write from/to the device, so no adjustment
13287 * is necessary. The dma_attr_minxfer theoretically should
13288 * be considered, but no HBA driver is checking it.
13289 */
13290 if (IS_P2ALIGNED(bp->b_un.b_addr,
13291 cur_dma_attr->dma_attr_align)) {
13292 rval = ddi_dma_buf_bind_handle(
13293 spx->txlt_buf_dma_handle,
13294 bp, dma_flags, callback, arg,
13295 &spx->txlt_dma_cookie,
13296 &spx->txlt_curwin_num_dma_cookies);
13297 } else { /* Buffer is not aligned */
13298
13299 int (*ddicallback)(caddr_t);
13300 size_t bufsz;
13301
13302 /* Check id sleeping is allowed */
13303 ddicallback = (callback == NULL_FUNC) ?
13304 DDI_DMA_DONTWAIT : DDI_DMA_SLEEP;
13305
13306 SATADBG2(SATA_DBG_DMA_SETUP, spx->txlt_sata_hba_inst,
13307 "mis-aligned buffer: addr=0x%p, cnt=%lu",
13308 (void *)bp->b_un.b_addr, bp->b_bcount);
13309
13310 if (bp->b_flags & (B_PAGEIO|B_PHYS))
13311 /*
13312 * CPU will need to access data in the buffer
13313 * (for copying) so map it.
13314 */
13315 bp_mapin(bp);
13316
13317 ASSERT(spx->txlt_tmp_buf == NULL);
13318
13319 /* Buffer may be padded by ddi_dma_mem_alloc()! */
13320 rval = ddi_dma_mem_alloc(
13321 spx->txlt_buf_dma_handle,
13322 bp->b_bcount,
13323 &sata_acc_attr,
13324 DDI_DMA_STREAMING,
13325 ddicallback, NULL,
13326 &spx->txlt_tmp_buf,
13327 &bufsz,
13328 &spx->txlt_tmp_buf_handle);
13329
13330 if (rval != DDI_SUCCESS) {
13331 /* DMA mapping failed */
13332 (void) ddi_dma_free_handle(
13333 &spx->txlt_buf_dma_handle);
13334 spx->txlt_buf_dma_handle = NULL;
13335 #ifdef SATA_DEBUG
13336 mbuffail_count++;
13337 #endif
13338 SATADBG1(SATA_DBG_DMA_SETUP,
13339 spx->txlt_sata_hba_inst,
13340 "sata_dma_buf_setup: "
13341 "buf dma mem alloc failed %x\n", rval);
13342 return (rval);
13343 }
13344 ASSERT(IS_P2ALIGNED(spx->txlt_tmp_buf,
13345 cur_dma_attr->dma_attr_align));
13346
13347 #ifdef SATA_DEBUG
13348 mbuf_count++;
13349
13350 if (bp->b_bcount != bufsz)
13351 /*
13352 * This will require special handling, because
13353 * DMA cookies will be based on the temporary
13354 * buffer size, not the original buffer
13355 * b_bcount, so the residue may have to
13356 * be counted differently.
13357 */
13358 SATADBG2(SATA_DBG_DMA_SETUP,
13359 spx->txlt_sata_hba_inst,
13360 "sata_dma_buf_setup: bp size %x != "
13361 "bufsz %x\n", bp->b_bcount, bufsz);
13362 #endif
13363 if (dma_flags & DDI_DMA_WRITE) {
13364 /*
13365 * Write operation - copy data into
13366 * an aligned temporary buffer. Buffer will be
13367 * synced for device by ddi_dma_addr_bind_handle
13368 */
13369 bcopy(bp->b_un.b_addr, spx->txlt_tmp_buf,
13370 bp->b_bcount);
13371 }
13372
13373 rval = ddi_dma_addr_bind_handle(
13374 spx->txlt_buf_dma_handle,
13375 NULL,
13376 spx->txlt_tmp_buf,
13377 bufsz, dma_flags, ddicallback, 0,
13378 &spx->txlt_dma_cookie,
13379 &spx->txlt_curwin_num_dma_cookies);
13380 }
13381
13382 switch (rval) {
13383 case DDI_DMA_PARTIAL_MAP:
13384 SATADBG1(SATA_DBG_DMA_SETUP, spx->txlt_sata_hba_inst,
13385 "sata_dma_buf_setup: DMA Partial Map\n", NULL);
13386 /*
13387 * Partial DMA mapping.
13388 * Retrieve number of DMA windows for this request.
13389 */
13390 if (ddi_dma_numwin(spx->txlt_buf_dma_handle,
13391 &spx->txlt_num_dma_win) != DDI_SUCCESS) {
13392 if (spx->txlt_tmp_buf != NULL) {
13393 ddi_dma_mem_free(
13394 &spx->txlt_tmp_buf_handle);
13395 spx->txlt_tmp_buf = NULL;
13396 }
13397 (void) ddi_dma_unbind_handle(
13398 spx->txlt_buf_dma_handle);
13399 (void) ddi_dma_free_handle(
13400 &spx->txlt_buf_dma_handle);
13401 spx->txlt_buf_dma_handle = NULL;
13402 SATA_LOG_D((spx->txlt_sata_hba_inst, CE_WARN,
13403 "sata_dma_buf_setup: numwin failed\n"));
13404 return (DDI_FAILURE);
13405 }
13406 SATADBG2(SATA_DBG_DMA_SETUP,
13407 spx->txlt_sata_hba_inst,
13408 "sata_dma_buf_setup: windows: %d, cookies: %d\n",
13409 spx->txlt_num_dma_win,
13410 spx->txlt_curwin_num_dma_cookies);
13411 spx->txlt_cur_dma_win = 0;
13412 break;
13413
13414 case DDI_DMA_MAPPED:
13415 /* DMA fully mapped */
13416 spx->txlt_num_dma_win = 1;
13417 spx->txlt_cur_dma_win = 0;
13418 SATADBG1(SATA_DBG_DMA_SETUP,
13419 spx->txlt_sata_hba_inst,
13420 "sata_dma_buf_setup: windows: 1 "
13421 "cookies: %d\n", spx->txlt_curwin_num_dma_cookies);
13422 break;
13423
13424 default:
13425 /* DMA mapping failed */
13426 if (spx->txlt_tmp_buf != NULL) {
13427 ddi_dma_mem_free(
13428 &spx->txlt_tmp_buf_handle);
13429 spx->txlt_tmp_buf = NULL;
13430 }
13431 (void) ddi_dma_free_handle(&spx->txlt_buf_dma_handle);
13432 spx->txlt_buf_dma_handle = NULL;
13433 SATA_LOG_D((spx->txlt_sata_hba_inst, CE_WARN,
13434 "sata_dma_buf_setup: buf dma handle binding "
13435 "failed %x\n", rval));
13436 return (rval);
13437 }
13438 spx->txlt_curwin_processed_dma_cookies = 0;
13439 spx->txlt_dma_cookie_list = NULL;
13440 } else {
13441 /*
13442 * DMA setup is reused. Check if we need to process more
13443 * cookies in current window, or to get next window, if any.
13444 */
13445
13446 ASSERT(spx->txlt_curwin_processed_dma_cookies <=
13447 spx->txlt_curwin_num_dma_cookies);
13448
13449 if (spx->txlt_curwin_processed_dma_cookies ==
13450 spx->txlt_curwin_num_dma_cookies) {
13451 /*
13452 * All cookies from current DMA window were processed.
13453 * Get next DMA window.
13454 */
13455 spx->txlt_cur_dma_win++;
13456 if (spx->txlt_cur_dma_win < spx->txlt_num_dma_win) {
13457 (void) ddi_dma_getwin(spx->txlt_buf_dma_handle,
13458 spx->txlt_cur_dma_win, &offset, &size,
13459 &spx->txlt_dma_cookie,
13460 &spx->txlt_curwin_num_dma_cookies);
13461 spx->txlt_curwin_processed_dma_cookies = 0;
13462 } else {
13463 /* No more windows! End of request! */
13464 /* What to do? - panic for now */
13465 ASSERT(spx->txlt_cur_dma_win >=
13466 spx->txlt_num_dma_win);
13467
13468 spx->txlt_curwin_num_dma_cookies = 0;
13469 spx->txlt_curwin_processed_dma_cookies = 0;
13470 spx->txlt_sata_pkt->
13471 satapkt_cmd.satacmd_num_dma_cookies = 0;
13472 return (DDI_SUCCESS);
13473 }
13474 }
13475 }
13476 /* There better be at least one DMA cookie outstanding */
13477 ASSERT((spx->txlt_curwin_num_dma_cookies -
13478 spx->txlt_curwin_processed_dma_cookies) > 0);
13479
13480 if (spx->txlt_dma_cookie_list == &spx->txlt_dma_cookie) {
13481 /* The default cookie slot was used in previous run */
13482 ASSERT(spx->txlt_curwin_processed_dma_cookies == 0);
13483 spx->txlt_dma_cookie_list = NULL;
13484 spx->txlt_dma_cookie_list_len = 0;
13485 }
13486 if (spx->txlt_curwin_processed_dma_cookies == 0) {
13487 /*
13488 * Processing a new DMA window - set-up dma cookies list.
13489 * We may reuse previously allocated cookie array if it is
13490 * possible.
13491 */
13492 if (spx->txlt_dma_cookie_list != NULL &&
13493 spx->txlt_dma_cookie_list_len <
13494 spx->txlt_curwin_num_dma_cookies) {
13495 /*
13496 * New DMA window contains more cookies than
13497 * the previous one. We need larger cookie list - free
13498 * the old one.
13499 */
13500 (void) kmem_free(spx->txlt_dma_cookie_list,
13501 spx->txlt_dma_cookie_list_len *
13502 sizeof (ddi_dma_cookie_t));
13503 spx->txlt_dma_cookie_list = NULL;
13504 spx->txlt_dma_cookie_list_len = 0;
13505 }
13506 if (spx->txlt_dma_cookie_list == NULL) {
13507 /*
13508 * Calculate lesser of number of cookies in this
13509 * DMA window and number of s/g entries.
13510 */
13511 max_sg_len = cur_dma_attr->dma_attr_sgllen;
13512 req_len = MIN(max_sg_len,
13513 spx->txlt_curwin_num_dma_cookies);
13514
13515 /* Allocate new dma cookie array if necessary */
13516 if (req_len == 1) {
13517 /* Only one cookie - no need for a list */
13518 spx->txlt_dma_cookie_list =
13519 &spx->txlt_dma_cookie;
13520 spx->txlt_dma_cookie_list_len = 1;
13521 } else {
13522 /*
13523 * More than one cookie - try to allocate space.
13524 */
13525 spx->txlt_dma_cookie_list = kmem_zalloc(
13526 sizeof (ddi_dma_cookie_t) * req_len,
13527 callback == NULL_FUNC ? KM_NOSLEEP :
13528 KM_SLEEP);
13529 if (spx->txlt_dma_cookie_list == NULL) {
13530 SATADBG1(SATA_DBG_DMA_SETUP,
13531 spx->txlt_sata_hba_inst,
13532 "sata_dma_buf_setup: cookie list "
13533 "allocation failed\n", NULL);
13534 /*
13535 * We could not allocate space for
13536 * neccessary number of dma cookies in
13537 * this window, so we fail this request.
13538 * Next invocation would try again to
13539 * allocate space for cookie list.
13540 * Note:Packet residue was not modified.
13541 */
13542 return (DDI_DMA_NORESOURCES);
13543 } else {
13544 spx->txlt_dma_cookie_list_len = req_len;
13545 }
13546 }
13547 }
13548 /*
13549 * Fetch DMA cookies into cookie list in sata_pkt_txlate.
13550 * First cookie was already fetched.
13551 */
13552 *(&spx->txlt_dma_cookie_list[0]) = spx->txlt_dma_cookie;
13553 cur_txfer_len =
13554 (uint64_t)spx->txlt_dma_cookie_list[0].dmac_size;
13555 spx->txlt_sata_pkt->satapkt_cmd.satacmd_num_dma_cookies = 1;
13556 spx->txlt_curwin_processed_dma_cookies++;
13557 for (i = 1; (i < spx->txlt_dma_cookie_list_len) &&
13558 (i < spx->txlt_curwin_num_dma_cookies); i++) {
13559 ddi_dma_nextcookie(spx->txlt_buf_dma_handle,
13560 &spx->txlt_dma_cookie_list[i]);
13561 cur_txfer_len +=
13562 (uint64_t)spx->txlt_dma_cookie_list[i].dmac_size;
13563 spx->txlt_curwin_processed_dma_cookies++;
13564 spx->txlt_sata_pkt->
13565 satapkt_cmd.satacmd_num_dma_cookies += 1;
13566 }
13567 } else {
13568 SATADBG2(SATA_DBG_DMA_SETUP, spx->txlt_sata_hba_inst,
13569 "sata_dma_buf_setup: sliding within DMA window, "
13570 "cur cookie %d, total cookies %d\n",
13571 spx->txlt_curwin_processed_dma_cookies,
13572 spx->txlt_curwin_num_dma_cookies);
13573
13574 /*
13575 * Not all cookies from the current dma window were used because
13576 * of s/g limitation.
13577 * There is no need to re-size the list - it was set at
13578 * optimal size, or only default entry is used (s/g = 1).
13579 */
13580 if (spx->txlt_dma_cookie_list == NULL) {
13581 spx->txlt_dma_cookie_list = &spx->txlt_dma_cookie;
13582 spx->txlt_dma_cookie_list_len = 1;
13583 }
13584 /*
13585 * Since we are processing remaining cookies in a DMA window,
13586 * there may be less of them than the number of entries in the
13587 * current dma cookie list.
13588 */
13589 req_len = MIN(spx->txlt_dma_cookie_list_len,
13590 (spx->txlt_curwin_num_dma_cookies -
13591 spx->txlt_curwin_processed_dma_cookies));
13592
13593 /* Fetch the next batch of cookies */
13594 for (i = 0, cur_txfer_len = 0; i < req_len; i++) {
13595 ddi_dma_nextcookie(spx->txlt_buf_dma_handle,
13596 &spx->txlt_dma_cookie_list[i]);
13597 cur_txfer_len +=
13598 (uint64_t)spx->txlt_dma_cookie_list[i].dmac_size;
13599 spx->txlt_sata_pkt->
13600 satapkt_cmd.satacmd_num_dma_cookies++;
13601 spx->txlt_curwin_processed_dma_cookies++;
13602 }
13603 }
13604
13605 ASSERT(spx->txlt_sata_pkt->satapkt_cmd.satacmd_num_dma_cookies > 0);
13606
13607 /* Point sata_cmd to the cookie list */
13608 spx->txlt_sata_pkt->satapkt_cmd.satacmd_dma_cookie_list =
13609 &spx->txlt_dma_cookie_list[0];
13610
13611 /* Remember number of DMA cookies passed in sata packet */
13612 spx->txlt_num_dma_cookies =
13613 spx->txlt_sata_pkt->satapkt_cmd.satacmd_num_dma_cookies;
13614
13615 ASSERT(cur_txfer_len != 0);
13616 if (cur_txfer_len <= bp->b_bcount)
13617 spx->txlt_total_residue -= cur_txfer_len;
13618 else {
13619 /*
13620 * Temporary DMA buffer has been padded by
13621 * ddi_dma_mem_alloc()!
13622 * This requires special handling, because DMA cookies are
13623 * based on the temporary buffer size, not the b_bcount,
13624 * and we have extra bytes to transfer - but the packet
13625 * residue has to stay correct because we will copy only
13626 * the requested number of bytes.
13627 */
13628 spx->txlt_total_residue -= bp->b_bcount;
13629 }
13630
13631 return (DDI_SUCCESS);
13632 }
13633
13634 /*
13635 * Common routine for releasing DMA resources
13636 */
13637 static void
13638 sata_common_free_dma_rsrcs(sata_pkt_txlate_t *spx)
13639 {
13640 if (spx->txlt_buf_dma_handle != NULL) {
13641 if (spx->txlt_tmp_buf != NULL) {
13642 /*
13643 * Intermediate DMA buffer was allocated.
13644 * Free allocated buffer and associated access handle.
13645 */
13646 ddi_dma_mem_free(&spx->txlt_tmp_buf_handle);
13647 spx->txlt_tmp_buf = NULL;
13648 }
13649 /*
13650 * Free DMA resources - cookies and handles
13651 */
13652 /* ASSERT(spx->txlt_dma_cookie_list != NULL); */
13653 if (spx->txlt_dma_cookie_list != NULL) {
13654 if (spx->txlt_dma_cookie_list !=
13655 &spx->txlt_dma_cookie) {
13656 (void) kmem_free(spx->txlt_dma_cookie_list,
13657 spx->txlt_dma_cookie_list_len *
13658 sizeof (ddi_dma_cookie_t));
13659 spx->txlt_dma_cookie_list = NULL;
13660 }
13661 }
13662 (void) ddi_dma_unbind_handle(spx->txlt_buf_dma_handle);
13663 (void) ddi_dma_free_handle(&spx->txlt_buf_dma_handle);
13664 spx->txlt_buf_dma_handle = NULL;
13665 }
13666 }
13667
13668 /*
13669 * Free DMA resources
13670 * Used by the HBA driver to release DMA resources that it does not use.
13671 *
13672 * Returns Void
13673 */
13674 void
13675 sata_free_dma_resources(sata_pkt_t *sata_pkt)
13676 {
13677 sata_pkt_txlate_t *spx;
13678
13679 if (sata_pkt == NULL)
13680 return;
13681
13682 spx = (sata_pkt_txlate_t *)sata_pkt->satapkt_framework_private;
13683
13684 sata_common_free_dma_rsrcs(spx);
13685 }
13686
13687 /*
13688 * Fetch Device Identify data.
13689 * Send DEVICE IDENTIFY or IDENTIFY PACKET DEVICE (depending on a device type)
13690 * command to a device and get the device identify data.
13691 * The device_info structure has to be set to device type (for selecting proper
13692 * device identify command).
13693 *
13694 * Returns:
13695 * SATA_SUCCESS if cmd succeeded
13696 * SATA_RETRY if cmd was rejected and could be retried,
13697 * SATA_FAILURE if cmd failed and should not be retried (port error)
13698 *
13699 * Cannot be called in an interrupt context.
13700 */
13701
13702 static int
13703 sata_fetch_device_identify_data(sata_hba_inst_t *sata_hba_inst,
13704 sata_drive_info_t *sdinfo)
13705 {
13706 struct buf *bp;
13707 sata_pkt_t *spkt;
13708 sata_cmd_t *scmd;
13709 sata_pkt_txlate_t *spx;
13710 int rval;
13711 dev_info_t *dip = SATA_DIP(sata_hba_inst);
13712
13713 spx = kmem_zalloc(sizeof (sata_pkt_txlate_t), KM_SLEEP);
13714 spx->txlt_sata_hba_inst = sata_hba_inst;
13715 spx->txlt_scsi_pkt = NULL; /* No scsi pkt involved */
13716 spkt = sata_pkt_alloc(spx, SLEEP_FUNC);
13717 if (spkt == NULL) {
13718 kmem_free(spx, sizeof (sata_pkt_txlate_t));
13719 return (SATA_RETRY); /* may retry later */
13720 }
13721 /* address is needed now */
13722 spkt->satapkt_device.satadev_addr = sdinfo->satadrv_addr;
13723
13724 /*
13725 * Allocate buffer for Identify Data return data
13726 */
13727 bp = sata_alloc_local_buffer(spx, sizeof (sata_id_t));
13728 if (bp == NULL) {
13729 sata_pkt_free(spx);
13730 kmem_free(spx, sizeof (sata_pkt_txlate_t));
13731 SATA_LOG_D((sata_hba_inst, CE_WARN,
13732 "sata_fetch_device_identify_data: "
13733 "cannot allocate buffer for ID"));
13734 return (SATA_RETRY); /* may retry later */
13735 }
13736
13737 /* Fill sata_pkt */
13738 sdinfo->satadrv_state = SATA_STATE_PROBING;
13739 spkt->satapkt_device.satadev_addr = sdinfo->satadrv_addr;
13740 spkt->satapkt_op_mode = SATA_OPMODE_SYNCH | SATA_OPMODE_INTERRUPTS;
13741 /* Synchronous mode, no callback */
13742 spkt->satapkt_comp = NULL;
13743 /* Timeout 30s */
13744 spkt->satapkt_time = sata_default_pkt_time;
13745
13746 scmd = &spkt->satapkt_cmd;
13747 scmd->satacmd_bp = bp;
13748 scmd->satacmd_flags.sata_data_direction = SATA_DIR_READ;
13749 scmd->satacmd_flags.sata_ignore_dev_reset = B_TRUE;
13750
13751 /* Build Identify Device cmd in the sata_pkt */
13752 scmd->satacmd_addr_type = 0; /* N/A */
13753 scmd->satacmd_sec_count_lsb = 0; /* N/A */
13754 scmd->satacmd_lba_low_lsb = 0; /* N/A */
13755 scmd->satacmd_lba_mid_lsb = 0; /* N/A */
13756 scmd->satacmd_lba_high_lsb = 0; /* N/A */
13757 scmd->satacmd_features_reg = 0; /* N/A */
13758 scmd->satacmd_device_reg = 0; /* Always device 0 */
13759 if (sdinfo->satadrv_type & SATA_DTYPE_ATAPI) {
13760 /* Identify Packet Device cmd */
13761 scmd->satacmd_cmd_reg = SATAC_ID_PACKET_DEVICE;
13762 } else {
13763 /* Identify Device cmd - mandatory for all other devices */
13764 scmd->satacmd_cmd_reg = SATAC_ID_DEVICE;
13765 }
13766
13767 /* Send pkt to SATA HBA driver */
13768 rval = (*SATA_START_FUNC(sata_hba_inst))(SATA_DIP(sata_hba_inst), spkt);
13769
13770 #ifdef SATA_INJECT_FAULTS
13771 sata_inject_pkt_fault(spkt, &rval, sata_fault_type);
13772 #endif
13773
13774 if (rval == SATA_TRAN_ACCEPTED &&
13775 spkt->satapkt_reason == SATA_PKT_COMPLETED) {
13776 if (spx->txlt_buf_dma_handle != NULL) {
13777 rval = ddi_dma_sync(spx->txlt_buf_dma_handle, 0, 0,
13778 DDI_DMA_SYNC_FORKERNEL);
13779 ASSERT(rval == DDI_SUCCESS);
13780 if (sata_check_for_dma_error(dip, spx)) {
13781 ddi_fm_service_impact(dip,
13782 DDI_SERVICE_UNAFFECTED);
13783 rval = SATA_RETRY;
13784 goto fail;
13785 }
13786
13787 }
13788 if ((((sata_id_t *)(bp->b_un.b_addr))->ai_config &
13789 SATA_INCOMPLETE_DATA) == SATA_INCOMPLETE_DATA) {
13790 SATA_LOG_D((sata_hba_inst, CE_WARN,
13791 "SATA disk device at port %d - "
13792 "partial Identify Data",
13793 sdinfo->satadrv_addr.cport));
13794 rval = SATA_RETRY; /* may retry later */
13795 goto fail;
13796 }
13797 /* Update sata_drive_info */
13798 bcopy(bp->b_un.b_addr, &sdinfo->satadrv_id,
13799 sizeof (sata_id_t));
13800
13801 sdinfo->satadrv_features_support = 0;
13802 if (sdinfo->satadrv_type == SATA_DTYPE_ATADISK) {
13803 /*
13804 * Retrieve capacity (disks only) and addressing mode
13805 */
13806 sdinfo->satadrv_capacity = sata_check_capacity(sdinfo);
13807 } else {
13808 /*
13809 * For ATAPI devices one would have to issue
13810 * Get Capacity cmd for media capacity. Not here.
13811 */
13812 sdinfo->satadrv_capacity = 0;
13813 /*
13814 * Check what cdb length is supported
13815 */
13816 if ((sdinfo->satadrv_id.ai_config &
13817 SATA_ATAPI_ID_PKT_SZ) == SATA_ATAPI_ID_PKT_16B)
13818 sdinfo->satadrv_atapi_cdb_len = 16;
13819 else
13820 sdinfo->satadrv_atapi_cdb_len = 12;
13821 }
13822 /* Setup supported features flags */
13823 if (sdinfo->satadrv_id.ai_cap & SATA_DMA_SUPPORT)
13824 sdinfo->satadrv_features_support |= SATA_DEV_F_DMA;
13825
13826 /* Check for SATA GEN and NCQ support */
13827 if (sdinfo->satadrv_id.ai_satacap != 0 &&
13828 sdinfo->satadrv_id.ai_satacap != 0xffff) {
13829 /* SATA compliance */
13830 if (sdinfo->satadrv_id.ai_satacap & SATA_NCQ)
13831 sdinfo->satadrv_features_support |=
13832 SATA_DEV_F_NCQ;
13833 if (sdinfo->satadrv_id.ai_satacap &
13834 (SATA_1_SPEED | SATA_2_SPEED | SATA_3_SPEED)) {
13835 if (sdinfo->satadrv_id.ai_satacap &
13836 SATA_3_SPEED)
13837 sdinfo->satadrv_features_support |=
13838 SATA_DEV_F_SATA3;
13839 if (sdinfo->satadrv_id.ai_satacap &
13840 SATA_2_SPEED)
13841 sdinfo->satadrv_features_support |=
13842 SATA_DEV_F_SATA2;
13843 if (sdinfo->satadrv_id.ai_satacap &
13844 SATA_1_SPEED)
13845 sdinfo->satadrv_features_support |=
13846 SATA_DEV_F_SATA1;
13847 } else {
13848 sdinfo->satadrv_features_support |=
13849 SATA_DEV_F_SATA1;
13850 }
13851 }
13852 if ((sdinfo->satadrv_id.ai_cmdset83 & SATA_RW_DMA_QUEUED_CMD) &&
13853 (sdinfo->satadrv_id.ai_features86 & SATA_RW_DMA_QUEUED_CMD))
13854 sdinfo->satadrv_features_support |= SATA_DEV_F_TCQ;
13855
13856 sdinfo->satadrv_queue_depth = sdinfo->satadrv_id.ai_qdepth;
13857 if ((sdinfo->satadrv_features_support & SATA_DEV_F_NCQ) ||
13858 (sdinfo->satadrv_features_support & SATA_DEV_F_TCQ)) {
13859 ++sdinfo->satadrv_queue_depth;
13860 /* Adjust according to controller capabilities */
13861 sdinfo->satadrv_max_queue_depth = MIN(
13862 sdinfo->satadrv_queue_depth,
13863 SATA_QDEPTH(sata_hba_inst));
13864 /* Adjust according to global queue depth limit */
13865 sdinfo->satadrv_max_queue_depth = MIN(
13866 sdinfo->satadrv_max_queue_depth,
13867 sata_current_max_qdepth);
13868 if (sdinfo->satadrv_max_queue_depth == 0)
13869 sdinfo->satadrv_max_queue_depth = 1;
13870 } else
13871 sdinfo->satadrv_max_queue_depth = 1;
13872
13873 rval = SATA_SUCCESS;
13874 } else {
13875 /*
13876 * Woops, no Identify Data.
13877 */
13878 if (rval == SATA_TRAN_BUSY || rval == SATA_TRAN_QUEUE_FULL) {
13879 rval = SATA_RETRY; /* may retry later */
13880 } else if (rval == SATA_TRAN_ACCEPTED) {
13881 if (spkt->satapkt_reason == SATA_PKT_DEV_ERROR ||
13882 spkt->satapkt_reason == SATA_PKT_ABORTED ||
13883 spkt->satapkt_reason == SATA_PKT_TIMEOUT ||
13884 spkt->satapkt_reason == SATA_PKT_RESET)
13885 rval = SATA_RETRY; /* may retry later */
13886 else
13887 rval = SATA_FAILURE;
13888 } else {
13889 rval = SATA_FAILURE;
13890 }
13891 }
13892 fail:
13893 /* Free allocated resources */
13894 sata_free_local_buffer(spx);
13895 sata_pkt_free(spx);
13896 kmem_free(spx, sizeof (sata_pkt_txlate_t));
13897
13898 return (rval);
13899 }
13900
13901
13902 /*
13903 * Some devices may not come-up with default DMA mode (UDMA or MWDMA).
13904 * UDMA mode is checked first, followed by MWDMA mode.
13905 * set correctly, so this function is setting it to the highest supported level.
13906 * Older SATA spec required that the device supports at least DMA 4 mode and
13907 * UDMA mode is selected. It is not mentioned in SerialATA 2.6, so this
13908 * restriction has been removed.
13909 *
13910 * Returns SATA_SUCCESS if proper DMA mode is selected or no DMA is supported.
13911 * Returns SATA_FAILURE if proper DMA mode could not be selected.
13912 *
13913 * NOTE: This function should be called only if DMA mode is supported.
13914 */
13915 static int
13916 sata_set_dma_mode(sata_hba_inst_t *sata_hba_inst, sata_drive_info_t *sdinfo)
13917 {
13918 sata_pkt_t *spkt;
13919 sata_cmd_t *scmd;
13920 sata_pkt_txlate_t *spx;
13921 int i, mode;
13922 uint8_t subcmd;
13923 int rval = SATA_SUCCESS;
13924
13925 ASSERT(sdinfo != NULL);
13926 ASSERT(sata_hba_inst != NULL);
13927
13928 if ((sdinfo->satadrv_id.ai_validinfo & SATA_VALIDINFO_88) != 0 &&
13929 (sdinfo->satadrv_id.ai_ultradma & SATA_UDMA_SUP_MASK) != 0) {
13930 /* Find highest Ultra DMA mode supported */
13931 for (mode = 6; mode >= 0; --mode) {
13932 if (sdinfo->satadrv_id.ai_ultradma & (1 << mode))
13933 break;
13934 }
13935 #if 0
13936 /* Left for historical reasons */
13937 /*
13938 * Some initial version of SATA spec indicated that at least
13939 * UDMA mode 4 has to be supported. It is not mentioned in
13940 * SerialATA 2.6, so this restriction is removed.
13941 */
13942 if (mode < 4)
13943 return (SATA_FAILURE);
13944 #endif
13945
13946 /*
13947 * For disk, we're still going to set DMA mode whatever is
13948 * selected by default
13949 *
13950 * We saw an old maxtor sata drive will select Ultra DMA and
13951 * Multi-Word DMA simultaneouly by default, which is going
13952 * to cause DMA command timed out, so we need to select DMA
13953 * mode even when it's already done by default
13954 */
13955 if (sdinfo->satadrv_type != SATA_DTYPE_ATADISK) {
13956
13957 /* Find UDMA mode currently selected */
13958 for (i = 6; i >= 0; --i) {
13959 if (sdinfo->satadrv_id.ai_ultradma &
13960 (1 << (i + 8)))
13961 break;
13962 }
13963 if (i >= mode)
13964 /* Nothing to do */
13965 return (SATA_SUCCESS);
13966 }
13967
13968 subcmd = SATAC_TRANSFER_MODE_ULTRA_DMA;
13969
13970 } else if ((sdinfo->satadrv_id.ai_dworddma & SATA_MDMA_SUP_MASK) != 0) {
13971 /* Find highest MultiWord DMA mode supported */
13972 for (mode = 2; mode >= 0; --mode) {
13973 if (sdinfo->satadrv_id.ai_dworddma & (1 << mode))
13974 break;
13975 }
13976
13977 /*
13978 * For disk, We're still going to set DMA mode whatever is
13979 * selected by default
13980 *
13981 * We saw an old maxtor sata drive will select Ultra DMA and
13982 * Multi-Word DMA simultaneouly by default, which is going
13983 * to cause DMA command timed out, so we need to select DMA
13984 * mode even when it's already done by default
13985 */
13986 if (sdinfo->satadrv_type != SATA_DTYPE_ATADISK) {
13987
13988 /* Find highest MultiWord DMA mode selected */
13989 for (i = 2; i >= 0; --i) {
13990 if (sdinfo->satadrv_id.ai_dworddma &
13991 (1 << (i + 8)))
13992 break;
13993 }
13994 if (i >= mode)
13995 /* Nothing to do */
13996 return (SATA_SUCCESS);
13997 }
13998
13999 subcmd = SATAC_TRANSFER_MODE_MULTI_WORD_DMA;
14000 } else
14001 return (SATA_SUCCESS);
14002
14003 /*
14004 * Set DMA mode via SET FEATURES COMMAND.
14005 * Prepare packet for SET FEATURES COMMAND.
14006 */
14007 spx = kmem_zalloc(sizeof (sata_pkt_txlate_t), KM_SLEEP);
14008 spx->txlt_sata_hba_inst = sata_hba_inst;
14009 spx->txlt_scsi_pkt = NULL; /* No scsi pkt involved */
14010 spkt = sata_pkt_alloc(spx, SLEEP_FUNC);
14011 if (spkt == NULL) {
14012 SATA_LOG_D((sata_hba_inst, CE_WARN,
14013 "sata_set_dma_mode: could not set DMA mode %d", mode));
14014 rval = SATA_FAILURE;
14015 goto done;
14016 }
14017 /* Fill sata_pkt */
14018 spkt->satapkt_device.satadev_addr = sdinfo->satadrv_addr;
14019 /* Timeout 30s */
14020 spkt->satapkt_time = sata_default_pkt_time;
14021 /* Synchronous mode, no callback, interrupts */
14022 spkt->satapkt_op_mode = SATA_OPMODE_SYNCH | SATA_OPMODE_INTERRUPTS;
14023 spkt->satapkt_comp = NULL;
14024 scmd = &spkt->satapkt_cmd;
14025 scmd->satacmd_flags.sata_data_direction = SATA_DIR_NODATA_XFER;
14026 scmd->satacmd_flags.sata_ignore_dev_reset = B_TRUE;
14027 scmd->satacmd_addr_type = 0;
14028 scmd->satacmd_device_reg = 0;
14029 scmd->satacmd_status_reg = 0;
14030 scmd->satacmd_error_reg = 0;
14031 scmd->satacmd_cmd_reg = SATAC_SET_FEATURES;
14032 scmd->satacmd_features_reg = SATAC_SF_TRANSFER_MODE;
14033 scmd->satacmd_sec_count_lsb = subcmd | mode;
14034
14035 /* Transfer command to HBA */
14036 if ((*SATA_START_FUNC(sata_hba_inst))(SATA_DIP(sata_hba_inst),
14037 spkt) != SATA_TRAN_ACCEPTED ||
14038 spkt->satapkt_reason != SATA_PKT_COMPLETED) {
14039 /* Pkt execution failed */
14040 rval = SATA_FAILURE;
14041 }
14042 done:
14043
14044 /* Free allocated resources */
14045 if (spkt != NULL)
14046 sata_pkt_free(spx);
14047 (void) kmem_free(spx, sizeof (sata_pkt_txlate_t));
14048
14049 return (rval);
14050 }
14051
14052
14053 /*
14054 * Set device caching mode.
14055 * One of the following operations should be specified:
14056 * SATAC_SF_ENABLE_READ_AHEAD
14057 * SATAC_SF_DISABLE_READ_AHEAD
14058 * SATAC_SF_ENABLE_WRITE_CACHE
14059 * SATAC_SF_DISABLE_WRITE_CACHE
14060 *
14061 * If operation fails, system log messgage is emitted.
14062 * Returns SATA_SUCCESS when the operation succeeds, SATA_RETRY if
14063 * command was sent but did not succeed, and SATA_FAILURE otherwise.
14064 */
14065
14066 static int
14067 sata_set_cache_mode(sata_hba_inst_t *sata_hba_inst, sata_drive_info_t *sdinfo,
14068 int cache_op)
14069 {
14070 sata_pkt_t *spkt;
14071 sata_cmd_t *scmd;
14072 sata_pkt_txlate_t *spx;
14073 int rval = SATA_SUCCESS;
14074 int hba_rval;
14075 char *infop;
14076
14077 ASSERT(sdinfo != NULL);
14078 ASSERT(sata_hba_inst != NULL);
14079 ASSERT(cache_op == SATAC_SF_ENABLE_READ_AHEAD ||
14080 cache_op == SATAC_SF_DISABLE_READ_AHEAD ||
14081 cache_op == SATAC_SF_ENABLE_WRITE_CACHE ||
14082 cache_op == SATAC_SF_DISABLE_WRITE_CACHE);
14083
14084
14085 /* Prepare packet for SET FEATURES COMMAND */
14086 spx = kmem_zalloc(sizeof (sata_pkt_txlate_t), KM_SLEEP);
14087 spx->txlt_sata_hba_inst = sata_hba_inst;
14088 spx->txlt_scsi_pkt = NULL; /* No scsi pkt involved */
14089 spkt = sata_pkt_alloc(spx, SLEEP_FUNC);
14090 if (spkt == NULL) {
14091 rval = SATA_FAILURE;
14092 goto failure;
14093 }
14094 /* Fill sata_pkt */
14095 spkt->satapkt_device.satadev_addr = sdinfo->satadrv_addr;
14096 /* Timeout 30s */
14097 spkt->satapkt_time = sata_default_pkt_time;
14098 /* Synchronous mode, no callback, interrupts */
14099 spkt->satapkt_op_mode =
14100 SATA_OPMODE_SYNCH | SATA_OPMODE_INTERRUPTS;
14101 spkt->satapkt_comp = NULL;
14102 scmd = &spkt->satapkt_cmd;
14103 scmd->satacmd_flags.sata_data_direction = SATA_DIR_NODATA_XFER;
14104 scmd->satacmd_flags.sata_ignore_dev_reset = B_TRUE;
14105 scmd->satacmd_addr_type = 0;
14106 scmd->satacmd_device_reg = 0;
14107 scmd->satacmd_status_reg = 0;
14108 scmd->satacmd_error_reg = 0;
14109 scmd->satacmd_cmd_reg = SATAC_SET_FEATURES;
14110 scmd->satacmd_features_reg = cache_op;
14111
14112 /* Transfer command to HBA */
14113 hba_rval = (*SATA_START_FUNC(sata_hba_inst))(
14114 SATA_DIP(sata_hba_inst), spkt);
14115
14116 #ifdef SATA_INJECT_FAULTS
14117 sata_inject_pkt_fault(spkt, &rval, sata_fault_type);
14118 #endif
14119
14120 if ((hba_rval != SATA_TRAN_ACCEPTED) ||
14121 (spkt->satapkt_reason != SATA_PKT_COMPLETED)) {
14122 /* Pkt execution failed */
14123 switch (cache_op) {
14124 case SATAC_SF_ENABLE_READ_AHEAD:
14125 infop = "enabling read ahead failed";
14126 break;
14127 case SATAC_SF_DISABLE_READ_AHEAD:
14128 infop = "disabling read ahead failed";
14129 break;
14130 case SATAC_SF_ENABLE_WRITE_CACHE:
14131 infop = "enabling write cache failed";
14132 break;
14133 case SATAC_SF_DISABLE_WRITE_CACHE:
14134 infop = "disabling write cache failed";
14135 break;
14136 }
14137 SATA_LOG_D((sata_hba_inst, CE_WARN, "%s", infop));
14138 rval = SATA_RETRY;
14139 }
14140 failure:
14141 /* Free allocated resources */
14142 if (spkt != NULL)
14143 sata_pkt_free(spx);
14144 (void) kmem_free(spx, sizeof (sata_pkt_txlate_t));
14145 return (rval);
14146 }
14147
14148 /*
14149 * Set Removable Media Status Notification (enable/disable)
14150 * state == 0 , disable
14151 * state != 0 , enable
14152 *
14153 * If operation fails, system log messgage is emitted.
14154 * Returns SATA_SUCCESS when the operation succeeds, SATA_FAILURE otherwise.
14155 */
14156
14157 static int
14158 sata_set_rmsn(sata_hba_inst_t *sata_hba_inst, sata_drive_info_t *sdinfo,
14159 int state)
14160 {
14161 sata_pkt_t *spkt;
14162 sata_cmd_t *scmd;
14163 sata_pkt_txlate_t *spx;
14164 int rval = SATA_SUCCESS;
14165 char *infop;
14166
14167 ASSERT(sdinfo != NULL);
14168 ASSERT(sata_hba_inst != NULL);
14169
14170 /* Prepare packet for SET FEATURES COMMAND */
14171 spx = kmem_zalloc(sizeof (sata_pkt_txlate_t), KM_SLEEP);
14172 spx->txlt_sata_hba_inst = sata_hba_inst;
14173 spx->txlt_scsi_pkt = NULL; /* No scsi pkt involved */
14174 spkt = sata_pkt_alloc(spx, SLEEP_FUNC);
14175 if (spkt == NULL) {
14176 rval = SATA_FAILURE;
14177 goto failure;
14178 }
14179 /* Fill sata_pkt */
14180 spkt->satapkt_device.satadev_addr = sdinfo->satadrv_addr;
14181 /* Timeout 30s */
14182 spkt->satapkt_time = sata_default_pkt_time;
14183 /* Synchronous mode, no callback, interrupts */
14184 spkt->satapkt_op_mode =
14185 SATA_OPMODE_SYNCH | SATA_OPMODE_INTERRUPTS;
14186 spkt->satapkt_comp = NULL;
14187 scmd = &spkt->satapkt_cmd;
14188 scmd->satacmd_flags.sata_data_direction = SATA_DIR_NODATA_XFER;
14189 scmd->satacmd_flags.sata_ignore_dev_reset = B_TRUE;
14190 scmd->satacmd_addr_type = 0;
14191 scmd->satacmd_device_reg = 0;
14192 scmd->satacmd_status_reg = 0;
14193 scmd->satacmd_error_reg = 0;
14194 scmd->satacmd_cmd_reg = SATAC_SET_FEATURES;
14195 if (state == 0)
14196 scmd->satacmd_features_reg = SATAC_SF_DISABLE_RMSN;
14197 else
14198 scmd->satacmd_features_reg = SATAC_SF_ENABLE_RMSN;
14199
14200 /* Transfer command to HBA */
14201 if (((*SATA_START_FUNC(sata_hba_inst))(
14202 SATA_DIP(sata_hba_inst), spkt) != SATA_TRAN_ACCEPTED) ||
14203 (spkt->satapkt_reason != SATA_PKT_COMPLETED)) {
14204 /* Pkt execution failed */
14205 if (state == 0)
14206 infop = "disabling Removable Media Status "
14207 "Notification failed";
14208 else
14209 infop = "enabling Removable Media Status "
14210 "Notification failed";
14211
14212 SATA_LOG_D((sata_hba_inst, CE_WARN, "%s", infop));
14213 rval = SATA_FAILURE;
14214 }
14215 failure:
14216 /* Free allocated resources */
14217 if (spkt != NULL)
14218 sata_pkt_free(spx);
14219 (void) kmem_free(spx, sizeof (sata_pkt_txlate_t));
14220 return (rval);
14221 }
14222
14223
14224 /*
14225 * Update state and copy port ss* values from passed sata_device structure.
14226 * sata_address is validated - if not valid, nothing is changed in sata_scsi
14227 * configuration struct.
14228 *
14229 * SATA_PSTATE_SHUTDOWN in port state is not reset to 0 by this function
14230 * regardless of the state in device argument.
14231 *
14232 * Port mutex should be held while calling this function.
14233 */
14234 static void
14235 sata_update_port_info(sata_hba_inst_t *sata_hba_inst,
14236 sata_device_t *sata_device)
14237 {
14238 sata_cport_info_t *cportinfo;
14239
14240 if (sata_device->satadev_addr.qual == SATA_ADDR_CPORT ||
14241 sata_device->satadev_addr.qual == SATA_ADDR_DCPORT) {
14242 if (SATA_NUM_CPORTS(sata_hba_inst) <=
14243 sata_device->satadev_addr.cport)
14244 return;
14245
14246 cportinfo = SATA_CPORT_INFO(sata_hba_inst,
14247 sata_device->satadev_addr.cport);
14248
14249 ASSERT(mutex_owned(&cportinfo->cport_mutex));
14250 cportinfo->cport_scr = sata_device->satadev_scr;
14251
14252 /* Preserve SATA_PSTATE_SHUTDOWN flag */
14253 cportinfo->cport_state &= ~(SATA_PSTATE_PWRON |
14254 SATA_PSTATE_PWROFF | SATA_PSTATE_FAILED);
14255 cportinfo->cport_state |=
14256 sata_device->satadev_state & SATA_PSTATE_VALID;
14257 }
14258 }
14259
14260 void
14261 sata_update_pmport_info(sata_hba_inst_t *sata_hba_inst,
14262 sata_device_t *sata_device)
14263 {
14264 sata_pmport_info_t *pmportinfo;
14265
14266 if ((sata_device->satadev_addr.qual != SATA_ADDR_PMPORT &&
14267 sata_device->satadev_addr.qual != SATA_ADDR_DPMPORT) ||
14268 SATA_NUM_PMPORTS(sata_hba_inst,
14269 sata_device->satadev_addr.cport) <
14270 sata_device->satadev_addr.pmport) {
14271 SATADBG1(SATA_DBG_PMULT, sata_hba_inst,
14272 "sata_update_port_info: error address %p.",
14273 &sata_device->satadev_addr);
14274 return;
14275 }
14276
14277 pmportinfo = SATA_PMPORT_INFO(sata_hba_inst,
14278 sata_device->satadev_addr.cport,
14279 sata_device->satadev_addr.pmport);
14280
14281 ASSERT(mutex_owned(&pmportinfo->pmport_mutex));
14282 pmportinfo->pmport_scr = sata_device->satadev_scr;
14283
14284 /* Preserve SATA_PSTATE_SHUTDOWN flag */
14285 pmportinfo->pmport_state &=
14286 ~(SATA_PSTATE_PWRON | SATA_PSTATE_PWROFF | SATA_PSTATE_FAILED);
14287 pmportinfo->pmport_state |=
14288 sata_device->satadev_state & SATA_PSTATE_VALID;
14289 }
14290
14291 /*
14292 * Extract SATA port specification from an IOCTL argument.
14293 *
14294 * This function return the port the user land send us as is, unless it
14295 * cannot retrieve port spec, then -1 is returned.
14296 *
14297 * Support port multiplier.
14298 */
14299 static int32_t
14300 sata_get_port_num(sata_hba_inst_t *sata_hba_inst, struct devctl_iocdata *dcp)
14301 {
14302 int32_t port;
14303
14304 /* Extract port number from nvpair in dca structure */
14305 if (nvlist_lookup_int32(ndi_dc_get_ap_data(dcp), "port", &port) != 0) {
14306 SATA_LOG_D((sata_hba_inst, CE_NOTE,
14307 "sata_get_port_num: invalid port spec 0x%x in ioctl",
14308 port));
14309 port = -1;
14310 }
14311
14312 return (port);
14313 }
14314
14315 /*
14316 * Get dev_info_t pointer to the device node pointed to by port argument.
14317 * NOTE: target argument is a value used in ioctls to identify
14318 * the AP - it is not a sata_address.
14319 * It is a combination of cport, pmport and address qualifier, encodded same
14320 * way as a scsi target number.
14321 * At this moment it carries only cport number.
14322 *
14323 * PMult hotplug is supported now.
14324 *
14325 * Returns dev_info_t pointer if target device was found, NULL otherwise.
14326 */
14327
14328 static dev_info_t *
14329 sata_get_target_dip(dev_info_t *dip, uint8_t cport, uint8_t pmport)
14330 {
14331 dev_info_t *cdip = NULL;
14332 int target, tgt;
14333 int circ;
14334 uint8_t qual;
14335
14336 sata_hba_inst_t *sata_hba_inst;
14337 scsi_hba_tran_t *scsi_hba_tran;
14338
14339 /* Get target id */
14340 scsi_hba_tran = ddi_get_driver_private(dip);
14341 if (scsi_hba_tran == NULL)
14342 return (NULL);
14343
14344 sata_hba_inst = scsi_hba_tran->tran_hba_private;
14345
14346 if (sata_hba_inst == NULL)
14347 return (NULL);
14348
14349 /* Identify a port-mult by cport_info.cport_dev_type */
14350 if (SATA_CPORT_DEV_TYPE(sata_hba_inst, cport) == SATA_DTYPE_PMULT)
14351 qual = SATA_ADDR_DPMPORT;
14352 else
14353 qual = SATA_ADDR_DCPORT;
14354
14355 target = SATA_TO_SCSI_TARGET(cport, pmport, qual);
14356
14357 /* Retrieve target dip */
14358 ndi_devi_enter(dip, &circ);
14359 for (cdip = ddi_get_child(dip); cdip != NULL; ) {
14360 dev_info_t *next = ddi_get_next_sibling(cdip);
14361
14362 tgt = ddi_prop_get_int(DDI_DEV_T_ANY, cdip,
14363 DDI_PROP_DONTPASS, "target", -1);
14364 if (tgt == -1) {
14365 /*
14366 * This is actually an error condition, but not
14367 * a fatal one. Just continue the search.
14368 */
14369 cdip = next;
14370 continue;
14371 }
14372
14373 if (tgt == target)
14374 break;
14375
14376 cdip = next;
14377 }
14378 ndi_devi_exit(dip, circ);
14379
14380 return (cdip);
14381 }
14382
14383 /*
14384 * Get dev_info_t pointer to the device node pointed to by port argument.
14385 * NOTE: target argument is a value used in ioctls to identify
14386 * the AP - it is not a sata_address.
14387 * It is a combination of cport, pmport and address qualifier, encoded same
14388 * way as a scsi target number.
14389 *
14390 * Returns dev_info_t pointer if target device was found, NULL otherwise.
14391 */
14392
14393 static dev_info_t *
14394 sata_get_scsi_target_dip(dev_info_t *dip, sata_address_t *saddr)
14395 {
14396 dev_info_t *cdip = NULL;
14397 int target, tgt;
14398 int circ;
14399
14400 target = SATA_TO_SCSI_TARGET(saddr->cport, saddr->pmport, saddr->qual);
14401
14402 ndi_devi_enter(dip, &circ);
14403 for (cdip = ddi_get_child(dip); cdip != NULL; ) {
14404 dev_info_t *next = ddi_get_next_sibling(cdip);
14405
14406 tgt = ddi_prop_get_int(DDI_DEV_T_ANY, cdip,
14407 DDI_PROP_DONTPASS, "target", -1);
14408 if (tgt == -1) {
14409 /*
14410 * This is actually an error condition, but not
14411 * a fatal one. Just continue the search.
14412 */
14413 cdip = next;
14414 continue;
14415 }
14416
14417 if (tgt == target)
14418 break;
14419
14420 cdip = next;
14421 }
14422 ndi_devi_exit(dip, circ);
14423
14424 return (cdip);
14425 }
14426
14427 /*
14428 * Process sata port disconnect request.
14429 * Normally, cfgadm sata plugin will try to offline (unconfigure) the device
14430 * before this request. Nevertheless, if a device is still configured,
14431 * we need to attempt to offline and unconfigure device.
14432 * Regardless of the unconfigure operation results the port is marked as
14433 * deactivated and no access to the attached device is possible.
14434 * If the target node remains because unconfigure operation failed, its state
14435 * will be set to DEVICE_REMOVED, preventing it to be used again when a device
14436 * is inserted/re-inserted. The event daemon will repeatedly try to unconfigure
14437 * the device and remove old target node.
14438 *
14439 * This function invokes sata_hba_inst->satahba_tran->
14440 * sata_tran_hotplug_ops->sata_tran_port_deactivate().
14441 * If successful, the device structure (if any) attached to the specified port
14442 * is removed and state of the port marked appropriately.
14443 * Failure of the port_deactivate may keep port in the physically active state,
14444 * or may fail the port.
14445 *
14446 * NOTE: Port multiplier is supported.
14447 */
14448
14449 static int
14450 sata_ioctl_disconnect(sata_hba_inst_t *sata_hba_inst,
14451 sata_device_t *sata_device)
14452 {
14453 sata_drive_info_t *sdinfo = NULL, *subsdinfo = NULL;
14454 sata_cport_info_t *cportinfo = NULL;
14455 sata_pmport_info_t *pmportinfo = NULL;
14456 sata_pmult_info_t *pmultinfo = NULL;
14457 sata_device_t subsdevice;
14458 int cport, pmport, qual;
14459 int rval = SATA_SUCCESS;
14460 int npmport = 0;
14461 int rv = 0;
14462
14463 cport = sata_device->satadev_addr.cport;
14464 pmport = sata_device->satadev_addr.pmport;
14465 qual = sata_device->satadev_addr.qual;
14466
14467 ASSERT(qual == SATA_ADDR_DCPORT || qual == SATA_ADDR_DPMPORT);
14468 if (qual == SATA_ADDR_DCPORT)
14469 qual = SATA_ADDR_CPORT;
14470 else
14471 qual = SATA_ADDR_PMPORT;
14472
14473 /*
14474 * DEVCTL_AP_DISCONNECT invokes sata_hba_inst->satahba_tran->
14475 * sata_tran_hotplug_ops->sata_tran_port_deactivate().
14476 * Do the sanity check.
14477 */
14478 if (SATA_PORT_DEACTIVATE_FUNC(sata_hba_inst) == NULL) {
14479 /* No physical port deactivation supported. */
14480 return (EINVAL);
14481 }
14482
14483 /* Check the current state of the port */
14484 rval = (*SATA_PROBE_PORT_FUNC(sata_hba_inst))
14485 (SATA_DIP(sata_hba_inst), sata_device);
14486
14487 cportinfo = SATA_CPORT_INFO(sata_hba_inst, cport);
14488
14489 /*
14490 * Processing port mulitiplier
14491 */
14492 if (qual == SATA_ADDR_CPORT &&
14493 SATA_CPORT_DEV_TYPE(sata_hba_inst, cport) == SATA_DTYPE_PMULT) {
14494 mutex_enter(&cportinfo->cport_mutex);
14495
14496 /* Check controller port status */
14497 sata_update_port_info(sata_hba_inst, sata_device);
14498 if (rval != SATA_SUCCESS ||
14499 (sata_device->satadev_state & SATA_PSTATE_FAILED) != 0) {
14500 /*
14501 * Device port status is unknown or it is in failed
14502 * state
14503 */
14504 SATA_CPORT_STATE(sata_hba_inst, cport) =
14505 SATA_PSTATE_FAILED;
14506 SATADBG1(SATA_DBG_IOCTL_IF, sata_hba_inst,
14507 "sata_hba_ioctl: connect: failed to deactivate "
14508 "SATA port %d", cport);
14509 mutex_exit(&cportinfo->cport_mutex);
14510 return (EIO);
14511 }
14512
14513 /* Disconnect all sub-devices. */
14514 pmultinfo = SATA_CPORTINFO_PMULT_INFO(cportinfo);
14515 if (pmultinfo != NULL) {
14516
14517 for (npmport = 0; npmport < SATA_NUM_PMPORTS(
14518 sata_hba_inst, cport); npmport ++) {
14519 subsdinfo = SATA_PMPORT_DRV_INFO(
14520 sata_hba_inst, cport, npmport);
14521 if (subsdinfo == NULL)
14522 continue;
14523
14524 subsdevice.satadev_addr = subsdinfo->
14525 satadrv_addr;
14526
14527 mutex_exit(&cportinfo->cport_mutex);
14528 if (sata_ioctl_disconnect(sata_hba_inst,
14529 &subsdevice) == SATA_SUCCESS) {
14530 SATADBG2(SATA_DBG_PMULT, sata_hba_inst,
14531 "[Remove] device at port %d:%d "
14532 "successfully.", cport, npmport);
14533 }
14534 mutex_enter(&cportinfo->cport_mutex);
14535 }
14536 }
14537
14538 /* Disconnect the port multiplier */
14539 cportinfo->cport_state &= ~SATA_STATE_READY;
14540 mutex_exit(&cportinfo->cport_mutex);
14541
14542 sata_device->satadev_addr.qual = qual;
14543 rval = (*SATA_PORT_DEACTIVATE_FUNC(sata_hba_inst))
14544 (SATA_DIP(sata_hba_inst), sata_device);
14545
14546 sata_gen_sysevent(sata_hba_inst, &sata_device->satadev_addr,
14547 SE_NO_HINT);
14548
14549 mutex_enter(&cportinfo->cport_mutex);
14550 sata_update_port_info(sata_hba_inst, sata_device);
14551 if (rval != SATA_SUCCESS &&
14552 sata_device->satadev_state & SATA_PSTATE_FAILED) {
14553 cportinfo->cport_state = SATA_PSTATE_FAILED;
14554 rv = EIO;
14555 } else {
14556 cportinfo->cport_state |= SATA_PSTATE_SHUTDOWN;
14557 }
14558 mutex_exit(&cportinfo->cport_mutex);
14559
14560 return (rv);
14561 }
14562
14563 /*
14564 * Process non-port-multiplier device - it could be a drive connected
14565 * to a port multiplier port or a controller port.
14566 */
14567 if (qual == SATA_ADDR_PMPORT) {
14568 pmportinfo = SATA_PMPORT_INFO(sata_hba_inst, cport, pmport);
14569 mutex_enter(&pmportinfo->pmport_mutex);
14570 sata_update_pmport_info(sata_hba_inst, sata_device);
14571 if (rval != SATA_SUCCESS ||
14572 (sata_device->satadev_state & SATA_PSTATE_FAILED) != 0) {
14573 SATA_PMPORT_STATE(sata_hba_inst, cport, pmport) =
14574 SATA_PSTATE_FAILED;
14575 SATADBG2(SATA_DBG_IOCTL_IF, sata_hba_inst,
14576 "sata_hba_ioctl: connect: failed to deactivate "
14577 "SATA port %d:%d", cport, pmport);
14578 mutex_exit(&pmportinfo->pmport_mutex);
14579 return (EIO);
14580 }
14581
14582 if (pmportinfo->pmport_dev_type != SATA_DTYPE_NONE) {
14583 sdinfo = pmportinfo->pmport_sata_drive;
14584 ASSERT(sdinfo != NULL);
14585 }
14586
14587 /*
14588 * Set port's dev_state to not ready - this will disable
14589 * an access to a potentially attached device.
14590 */
14591 pmportinfo->pmport_state &= ~SATA_STATE_READY;
14592
14593 /* Remove and release sata_drive info structure. */
14594 if (sdinfo != NULL) {
14595 if ((sdinfo->satadrv_type &
14596 SATA_VALID_DEV_TYPE) != 0) {
14597 /*
14598 * If a target node exists, try to offline
14599 * a device and remove target node.
14600 */
14601 mutex_exit(&pmportinfo->pmport_mutex);
14602 (void) sata_offline_device(sata_hba_inst,
14603 sata_device, sdinfo);
14604 mutex_enter(&pmportinfo->pmport_mutex);
14605 }
14606
14607 SATA_PMPORTINFO_DRV_INFO(pmportinfo) = NULL;
14608 pmportinfo->pmport_dev_type = SATA_DTYPE_NONE;
14609 (void) kmem_free((void *)sdinfo,
14610 sizeof (sata_drive_info_t));
14611 }
14612 mutex_exit(&pmportinfo->pmport_mutex);
14613
14614 } else if (qual == SATA_ADDR_CPORT) {
14615 mutex_enter(&cportinfo->cport_mutex);
14616 sata_update_port_info(sata_hba_inst, sata_device);
14617 if (rval != SATA_SUCCESS ||
14618 (sata_device->satadev_state & SATA_PSTATE_FAILED) != 0) {
14619 /*
14620 * Device port status is unknown or it is in failed
14621 * state
14622 */
14623 SATA_CPORT_STATE(sata_hba_inst, cport) =
14624 SATA_PSTATE_FAILED;
14625 SATADBG1(SATA_DBG_IOCTL_IF, sata_hba_inst,
14626 "sata_hba_ioctl: connect: failed to deactivate "
14627 "SATA port %d", cport);
14628 mutex_exit(&cportinfo->cport_mutex);
14629 return (EIO);
14630 }
14631
14632 if (cportinfo->cport_dev_type == SATA_DTYPE_PMULT) {
14633 pmultinfo = SATA_CPORTINFO_PMULT_INFO(cportinfo);
14634 ASSERT(pmultinfo != NULL);
14635 } else if (cportinfo->cport_dev_type != SATA_DTYPE_NONE) {
14636 sdinfo = SATA_CPORTINFO_DRV_INFO(cportinfo);
14637 ASSERT(sdinfo != NULL);
14638 }
14639 cportinfo->cport_state &= ~SATA_STATE_READY;
14640
14641 if (sdinfo != NULL) {
14642 if ((sdinfo->satadrv_type &
14643 SATA_VALID_DEV_TYPE) != 0) {
14644 /*
14645 * If a target node exists, try to offline
14646 * a device and remove target node.
14647 */
14648 mutex_exit(&cportinfo->cport_mutex);
14649 (void) sata_offline_device(sata_hba_inst,
14650 sata_device, sdinfo);
14651 mutex_enter(&cportinfo->cport_mutex);
14652 }
14653
14654 SATA_CPORTINFO_DRV_INFO(cportinfo) = NULL;
14655 cportinfo->cport_dev_type = SATA_DTYPE_NONE;
14656 (void) kmem_free((void *)sdinfo,
14657 sizeof (sata_drive_info_t));
14658 }
14659 mutex_exit(&cportinfo->cport_mutex);
14660 }
14661
14662 /* Just ask HBA driver to deactivate port */
14663 sata_device->satadev_addr.qual = qual;
14664
14665 rval = (*SATA_PORT_DEACTIVATE_FUNC(sata_hba_inst))
14666 (SATA_DIP(sata_hba_inst), sata_device);
14667
14668 /*
14669 * Generate sysevent - EC_DR / ESC_DR_AP_STATE_CHANGE
14670 * without the hint (to force listener to investivate the state).
14671 */
14672 sata_gen_sysevent(sata_hba_inst, &sata_device->satadev_addr,
14673 SE_NO_HINT);
14674
14675 if (qual == SATA_ADDR_PMPORT) {
14676 mutex_enter(&pmportinfo->pmport_mutex);
14677 sata_update_pmport_info(sata_hba_inst, sata_device);
14678
14679 if (rval != SATA_SUCCESS &&
14680 sata_device->satadev_state & SATA_PSTATE_FAILED) {
14681 /*
14682 * Port deactivation failure - do not change port
14683 * state unless the state returned by HBA indicates a
14684 * port failure.
14685 *
14686 * NOTE: device structures were released, so devices
14687 * now are invisible! Port reset is needed to
14688 * re-enumerate devices.
14689 */
14690 pmportinfo->pmport_state = SATA_PSTATE_FAILED;
14691 rv = EIO;
14692 } else {
14693 /*
14694 * Deactivation succeded. From now on the sata framework
14695 * will not care what is happening to the device, until
14696 * the port is activated again.
14697 */
14698 pmportinfo->pmport_state |= SATA_PSTATE_SHUTDOWN;
14699 }
14700 mutex_exit(&pmportinfo->pmport_mutex);
14701 } else if (qual == SATA_ADDR_CPORT) {
14702 mutex_enter(&cportinfo->cport_mutex);
14703 sata_update_port_info(sata_hba_inst, sata_device);
14704
14705 if (rval != SATA_SUCCESS &&
14706 sata_device->satadev_state & SATA_PSTATE_FAILED) {
14707 cportinfo->cport_state = SATA_PSTATE_FAILED;
14708 rv = EIO;
14709 } else {
14710 cportinfo->cport_state |= SATA_PSTATE_SHUTDOWN;
14711 }
14712 mutex_exit(&cportinfo->cport_mutex);
14713 }
14714
14715 return (rv);
14716 }
14717
14718
14719
14720 /*
14721 * Process sata port connect request
14722 * The sata cfgadm pluging will invoke this operation only if port was found
14723 * in the disconnect state (failed state is also treated as the disconnected
14724 * state).
14725 * DEVCTL_AP_CONNECT would invoke sata_hba_inst->satahba_tran->
14726 * sata_tran_hotplug_ops->sata_tran_port_activate().
14727 * If successful and a device is found attached to the port,
14728 * the initialization sequence is executed to attach a device structure to
14729 * a port structure. The state of the port and a device would be set
14730 * appropriately.
14731 * The device is not set in configured state (system-wise) by this operation.
14732 *
14733 * Note, that activating the port may generate link events,
14734 * so it is important that following processing and the
14735 * event processing does not interfere with each other!
14736 *
14737 * This operation may remove port failed state and will
14738 * try to make port active and in good standing.
14739 *
14740 * NOTE: Port multiplier is supported.
14741 */
14742
14743 static int
14744 sata_ioctl_connect(sata_hba_inst_t *sata_hba_inst,
14745 sata_device_t *sata_device)
14746 {
14747 sata_pmport_info_t *pmportinfo = NULL;
14748 uint8_t cport, pmport, qual;
14749 int rv = 0;
14750
14751 cport = sata_device->satadev_addr.cport;
14752 pmport = sata_device->satadev_addr.pmport;
14753 qual = sata_device->satadev_addr.qual;
14754
14755 ASSERT(qual == SATA_ADDR_DCPORT || qual == SATA_ADDR_DPMPORT);
14756 if (qual == SATA_ADDR_DCPORT)
14757 qual = SATA_ADDR_CPORT;
14758 else
14759 qual = SATA_ADDR_PMPORT;
14760
14761 if (qual == SATA_ADDR_PMPORT)
14762 pmportinfo = SATA_PMPORT_INFO(sata_hba_inst, cport, pmport);
14763
14764 /*
14765 * DEVCTL_AP_CONNECT would invoke sata_hba_inst->
14766 * satahba_tran->sata_tran_hotplug_ops->sata_tran_port_activate().
14767 * Perform sanity check now.
14768 */
14769 if (SATA_PORT_ACTIVATE_FUNC(sata_hba_inst) == NULL) {
14770 /* No physical port activation supported. */
14771 return (EINVAL);
14772 }
14773
14774 /* Just ask HBA driver to activate port */
14775 if ((*SATA_PORT_ACTIVATE_FUNC(sata_hba_inst))
14776 (SATA_DIP(sata_hba_inst), sata_device) != SATA_SUCCESS) {
14777 /*
14778 * Port activation failure.
14779 */
14780 if (qual == SATA_ADDR_CPORT) {
14781 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst,
14782 cport)->cport_mutex);
14783 sata_update_port_info(sata_hba_inst, sata_device);
14784 if (sata_device->satadev_state & SATA_PSTATE_FAILED) {
14785 SATA_CPORT_STATE(sata_hba_inst, cport) =
14786 SATA_PSTATE_FAILED;
14787 SATADBG1(SATA_DBG_IOCTL_IF, sata_hba_inst,
14788 "sata_hba_ioctl: connect: failed to "
14789 "activate SATA port %d", cport);
14790 }
14791 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst,
14792 cport)->cport_mutex);
14793 } else { /* port multiplier device port */
14794 mutex_enter(&pmportinfo->pmport_mutex);
14795 sata_update_pmport_info(sata_hba_inst, sata_device);
14796 if (sata_device->satadev_state & SATA_PSTATE_FAILED) {
14797 SATA_PMPORT_STATE(sata_hba_inst, cport,
14798 pmport) = SATA_PSTATE_FAILED;
14799 SATADBG2(SATA_DBG_IOCTL_IF, sata_hba_inst,
14800 "sata_hba_ioctl: connect: failed to "
14801 "activate SATA port %d:%d", cport, pmport);
14802 }
14803 mutex_exit(&pmportinfo->pmport_mutex);
14804 }
14805 return (EIO);
14806 }
14807
14808 /* Virgin port state - will be updated by the port re-probe. */
14809 if (qual == SATA_ADDR_CPORT) {
14810 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst,
14811 cport)->cport_mutex);
14812 SATA_CPORT_STATE(sata_hba_inst, cport) = 0;
14813 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst,
14814 cport)->cport_mutex);
14815 } else { /* port multiplier device port */
14816 mutex_enter(&pmportinfo->pmport_mutex);
14817 SATA_PMPORT_STATE(sata_hba_inst, cport, pmport) = 0;
14818 mutex_exit(&pmportinfo->pmport_mutex);
14819 }
14820
14821 /*
14822 * Probe the port to find its state and attached device.
14823 */
14824 if (sata_reprobe_port(sata_hba_inst, sata_device,
14825 SATA_DEV_IDENTIFY_RETRY) == SATA_FAILURE)
14826 rv = EIO;
14827
14828 /*
14829 * Generate sysevent - EC_DR / ESC_DR_AP_STATE_CHANGE
14830 * without the hint
14831 */
14832 sata_gen_sysevent(sata_hba_inst, &sata_device->satadev_addr,
14833 SE_NO_HINT);
14834
14835 /*
14836 * If there is a device attached to the port, emit
14837 * a message.
14838 */
14839 if (sata_device->satadev_type != SATA_DTYPE_NONE) {
14840
14841 if (qual == SATA_ADDR_CPORT) {
14842 if (sata_device->satadev_type == SATA_DTYPE_PMULT) {
14843 sata_log(sata_hba_inst, CE_WARN,
14844 "SATA port multiplier detected "
14845 "at port %d", cport);
14846 } else {
14847 sata_log(sata_hba_inst, CE_WARN,
14848 "SATA device detected at port %d", cport);
14849 if (sata_device->satadev_type ==
14850 SATA_DTYPE_UNKNOWN) {
14851 /*
14852 * A device was not successfully identified
14853 */
14854 sata_log(sata_hba_inst, CE_WARN,
14855 "Could not identify SATA "
14856 "device at port %d", cport);
14857 }
14858 }
14859 } else { /* port multiplier device port */
14860 sata_log(sata_hba_inst, CE_WARN,
14861 "SATA device detected at port %d:%d",
14862 cport, pmport);
14863 if (sata_device->satadev_type == SATA_DTYPE_UNKNOWN) {
14864 /*
14865 * A device was not successfully identified
14866 */
14867 sata_log(sata_hba_inst, CE_WARN,
14868 "Could not identify SATA "
14869 "device at port %d:%d", cport, pmport);
14870 }
14871 }
14872 }
14873
14874 return (rv);
14875 }
14876
14877
14878 /*
14879 * Process sata device unconfigure request.
14880 * The unconfigure operation uses generic nexus operation to
14881 * offline a device. It leaves a target device node attached.
14882 * and obviously sata_drive_info attached as well, because
14883 * from the hardware point of view nothing has changed.
14884 */
14885 static int
14886 sata_ioctl_unconfigure(sata_hba_inst_t *sata_hba_inst,
14887 sata_device_t *sata_device)
14888 {
14889 int rv = 0;
14890 dev_info_t *tdip;
14891
14892 /* We are addressing attached device, not a port */
14893 if (sata_device->satadev_addr.qual == SATA_ADDR_CPORT)
14894 sata_device->satadev_addr.qual = SATA_ADDR_DCPORT;
14895 else if (sata_device->satadev_addr.qual == SATA_ADDR_PMPORT)
14896 sata_device->satadev_addr.qual = SATA_ADDR_DPMPORT;
14897
14898 if ((tdip = sata_get_scsi_target_dip(SATA_DIP(sata_hba_inst),
14899 &sata_device->satadev_addr)) != NULL) {
14900
14901 if (ndi_devi_offline(tdip, NDI_UNCONFIG) != NDI_SUCCESS) {
14902 SATA_LOG_D((sata_hba_inst, CE_WARN,
14903 "sata_hba_ioctl: unconfigure: "
14904 "failed to unconfigure device at SATA port %d:%d",
14905 sata_device->satadev_addr.cport,
14906 sata_device->satadev_addr.pmport));
14907 rv = EIO;
14908 }
14909 /*
14910 * The target node devi_state should be marked with
14911 * DEVI_DEVICE_OFFLINE by ndi_devi_offline().
14912 * This would be the indication for cfgadm that
14913 * the AP node occupant state is 'unconfigured'.
14914 */
14915
14916 } else {
14917 /*
14918 * This would indicate a failure on the part of cfgadm
14919 * to detect correct state of the node prior to this
14920 * call - one cannot unconfigure non-existing device.
14921 */
14922 SATA_LOG_D((sata_hba_inst, CE_WARN,
14923 "sata_hba_ioctl: unconfigure: "
14924 "attempt to unconfigure non-existing device "
14925 "at SATA port %d:%d",
14926 sata_device->satadev_addr.cport,
14927 sata_device->satadev_addr.pmport));
14928 rv = ENXIO;
14929 }
14930 return (rv);
14931 }
14932
14933 /*
14934 * Process sata device configure request
14935 * If port is in a failed state, operation is aborted - one has to use
14936 * an explicit connect or port activate request to try to get a port into
14937 * non-failed mode. Port reset wil also work in such situation.
14938 * If the port is in disconnected (shutdown) state, the connect operation is
14939 * attempted prior to any other action.
14940 * When port is in the active state, there is a device attached and the target
14941 * node exists, a device was most likely offlined.
14942 * If target node does not exist, a new target node is created. In both cases
14943 * an attempt is made to online (configure) the device.
14944 *
14945 * NOTE: Port multiplier is supported.
14946 */
14947 static int
14948 sata_ioctl_configure(sata_hba_inst_t *sata_hba_inst,
14949 sata_device_t *sata_device)
14950 {
14951 int cport, pmport, qual;
14952 int rval;
14953 boolean_t target = B_TRUE;
14954 sata_cport_info_t *cportinfo;
14955 sata_pmport_info_t *pmportinfo = NULL;
14956 dev_info_t *tdip;
14957 sata_drive_info_t *sdinfo;
14958
14959 cport = sata_device->satadev_addr.cport;
14960 pmport = sata_device->satadev_addr.pmport;
14961 qual = sata_device->satadev_addr.qual;
14962
14963 /* Get current port state */
14964 rval = (*SATA_PROBE_PORT_FUNC(sata_hba_inst))
14965 (SATA_DIP(sata_hba_inst), sata_device);
14966
14967 cportinfo = SATA_CPORT_INFO(sata_hba_inst, cport);
14968 if (qual == SATA_ADDR_DPMPORT) {
14969 pmportinfo = SATA_PMPORT_INFO(sata_hba_inst, cport, pmport);
14970 mutex_enter(&pmportinfo->pmport_mutex);
14971 sata_update_pmport_info(sata_hba_inst, sata_device);
14972 if (rval != SATA_SUCCESS ||
14973 (sata_device->satadev_state & SATA_PSTATE_FAILED) != 0) {
14974 /*
14975 * Obviously, device on a failed port is not visible
14976 */
14977 mutex_exit(&pmportinfo->pmport_mutex);
14978 return (ENXIO);
14979 }
14980 mutex_exit(&pmportinfo->pmport_mutex);
14981 } else {
14982 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst,
14983 cport)->cport_mutex);
14984 sata_update_port_info(sata_hba_inst, sata_device);
14985 if (rval != SATA_SUCCESS ||
14986 (sata_device->satadev_state & SATA_PSTATE_FAILED) != 0) {
14987 /*
14988 * Obviously, device on a failed port is not visible
14989 */
14990 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst,
14991 cport)->cport_mutex);
14992 return (ENXIO);
14993 }
14994 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst,
14995 cport)->cport_mutex);
14996 }
14997
14998 if ((sata_device->satadev_state & SATA_PSTATE_SHUTDOWN) != 0) {
14999 /* need to activate port */
15000 target = B_FALSE;
15001
15002 /* Sanity check */
15003 if (SATA_PORT_ACTIVATE_FUNC(sata_hba_inst) == NULL)
15004 return (ENXIO);
15005
15006 /* Just let HBA driver to activate port */
15007 if ((*SATA_PORT_ACTIVATE_FUNC(sata_hba_inst))
15008 (SATA_DIP(sata_hba_inst), sata_device) != SATA_SUCCESS) {
15009 /*
15010 * Port activation failure - do not change port state
15011 * unless the state returned by HBA indicates a port
15012 * failure.
15013 */
15014 if (qual == SATA_ADDR_DPMPORT) {
15015 mutex_enter(&pmportinfo->pmport_mutex);
15016 sata_update_pmport_info(sata_hba_inst,
15017 sata_device);
15018 if (sata_device->satadev_state &
15019 SATA_PSTATE_FAILED)
15020 pmportinfo->pmport_state =
15021 SATA_PSTATE_FAILED;
15022 mutex_exit(&pmportinfo->pmport_mutex);
15023 } else {
15024 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst,
15025 cport)->cport_mutex);
15026 sata_update_port_info(sata_hba_inst,
15027 sata_device);
15028 if (sata_device->satadev_state &
15029 SATA_PSTATE_FAILED)
15030 cportinfo->cport_state =
15031 SATA_PSTATE_FAILED;
15032 mutex_exit(&SATA_CPORT_INFO(
15033 sata_hba_inst, cport)->cport_mutex);
15034 }
15035 }
15036 SATA_LOG_D((sata_hba_inst, CE_WARN,
15037 "sata_hba_ioctl: configure: "
15038 "failed to activate SATA port %d:%d",
15039 cport, pmport));
15040 return (EIO);
15041 }
15042 /*
15043 * Generate sysevent - EC_DR / ESC_DR_AP_STATE_CHANGE
15044 * without the hint.
15045 */
15046 sata_gen_sysevent(sata_hba_inst,
15047 &sata_device->satadev_addr, SE_NO_HINT);
15048
15049 /* Virgin port state */
15050 if (qual == SATA_ADDR_DPMPORT) {
15051 mutex_enter(&pmportinfo->pmport_mutex);
15052 pmportinfo->pmport_state = 0;
15053 mutex_exit(&pmportinfo->pmport_mutex);
15054 } else {
15055 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst,
15056 cport)-> cport_mutex);
15057 cportinfo->cport_state = 0;
15058 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst,
15059 cport)->cport_mutex);
15060 }
15061 /*
15062 * Always reprobe port, to get current device info.
15063 */
15064 if (sata_reprobe_port(sata_hba_inst, sata_device,
15065 SATA_DEV_IDENTIFY_RETRY) != SATA_SUCCESS)
15066 return (EIO);
15067
15068 if (sata_device->satadev_type != SATA_DTYPE_NONE && target == B_FALSE) {
15069 if (qual == SATA_ADDR_DPMPORT) {
15070 /*
15071 * That's the transition from "inactive" port
15072 * to active one with device attached.
15073 */
15074 sata_log(sata_hba_inst, CE_WARN,
15075 "SATA device detected at port %d:%d",
15076 cport, pmport);
15077 } else {
15078 /*
15079 * When PM is attached to the cport and cport is
15080 * activated, every PM device port needs to be reprobed.
15081 * We need to emit message for all devices detected
15082 * at port multiplier's device ports.
15083 * Add such code here.
15084 * For now, just inform about device attached to
15085 * cport.
15086 */
15087 sata_log(sata_hba_inst, CE_WARN,
15088 "SATA device detected at port %d", cport);
15089 }
15090 }
15091
15092 /*
15093 * This is where real configuration operation starts.
15094 *
15095 * When PM is attached to the cport and cport is activated,
15096 * devices attached PM device ports may have to be configured
15097 * explicitly. This may change when port multiplier is supported.
15098 * For now, configure only disks and other valid target devices.
15099 */
15100 if (!(sata_device->satadev_type & SATA_VALID_DEV_TYPE)) {
15101 if (qual == SATA_ADDR_DCPORT) {
15102 if (sata_device->satadev_type == SATA_DTYPE_UNKNOWN) {
15103 /*
15104 * A device was not successfully identified
15105 */
15106 sata_log(sata_hba_inst, CE_WARN,
15107 "Could not identify SATA "
15108 "device at port %d", cport);
15109 }
15110 } else { /* port multiplier device port */
15111 if (sata_device->satadev_type == SATA_DTYPE_UNKNOWN) {
15112 /*
15113 * A device was not successfully identified
15114 */
15115 sata_log(sata_hba_inst, CE_WARN,
15116 "Could not identify SATA "
15117 "device at port %d:%d", cport, pmport);
15118 }
15119 }
15120 return (ENXIO); /* No device to configure */
15121 }
15122
15123 /*
15124 * Here we may have a device in reset condition,
15125 * but because we are just configuring it, there is
15126 * no need to process the reset other than just
15127 * to clear device reset condition in the HBA driver.
15128 * Setting the flag SATA_EVNT_CLEAR_DEVICE_RESET will
15129 * cause a first command sent the HBA driver with the request
15130 * to clear device reset condition.
15131 */
15132 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex);
15133 if (qual == SATA_ADDR_DPMPORT)
15134 sata_device->satadev_addr.qual = SATA_ADDR_DPMPORT;
15135 else
15136 sata_device->satadev_addr.qual = SATA_ADDR_DCPORT;
15137 sdinfo = sata_get_device_info(sata_hba_inst, sata_device);
15138 if (sdinfo == NULL) {
15139 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex);
15140 return (ENXIO);
15141 }
15142 if (sdinfo->satadrv_event_flags &
15143 (SATA_EVNT_DEVICE_RESET | SATA_EVNT_INPROC_DEVICE_RESET)) {
15144 sdinfo->satadrv_event_flags = 0;
15145 }
15146 sdinfo->satadrv_event_flags |= SATA_EVNT_CLEAR_DEVICE_RESET;
15147 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex);
15148
15149 if ((tdip = sata_get_scsi_target_dip(SATA_DIP(sata_hba_inst),
15150 &sata_device->satadev_addr)) != NULL) {
15151 /*
15152 * Target node exists. Verify, that it belongs
15153 * to existing, attached device and not to
15154 * a removed device.
15155 */
15156 if (sata_check_device_removed(tdip) == B_TRUE) {
15157 if (qual == SATA_ADDR_DPMPORT)
15158 sata_log(sata_hba_inst, CE_WARN,
15159 "SATA device at port %d cannot be "
15160 "configured. "
15161 "Application(s) accessing "
15162 "previously attached device "
15163 "have to release it before newly "
15164 "inserted device can be made accessible.",
15165 cport);
15166 else
15167 sata_log(sata_hba_inst, CE_WARN,
15168 "SATA device at port %d:%d cannot be"
15169 "configured. "
15170 "Application(s) accessing "
15171 "previously attached device "
15172 "have to release it before newly "
15173 "inserted device can be made accessible.",
15174 cport, pmport);
15175 return (EIO);
15176 }
15177 /*
15178 * Device was not removed and re-inserted.
15179 * Try to online it.
15180 */
15181 if (ndi_devi_online(tdip, 0) != NDI_SUCCESS) {
15182 SATA_LOG_D((sata_hba_inst, CE_WARN,
15183 "sata_hba_ioctl: configure: "
15184 "onlining device at SATA port "
15185 "%d:%d failed", cport, pmport));
15186 return (EIO);
15187 }
15188
15189 if (qual == SATA_ADDR_DPMPORT) {
15190 mutex_enter(&pmportinfo->pmport_mutex);
15191 pmportinfo->pmport_tgtnode_clean = B_TRUE;
15192 mutex_exit(&pmportinfo->pmport_mutex);
15193 } else {
15194 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst,
15195 cport)->cport_mutex);
15196 cportinfo-> cport_tgtnode_clean = B_TRUE;
15197 mutex_exit(&SATA_CPORT_INFO(
15198 sata_hba_inst, cport)->cport_mutex);
15199 }
15200 } else {
15201 /*
15202 * No target node - need to create a new target node.
15203 */
15204 if (qual == SATA_ADDR_DPMPORT) {
15205 mutex_enter(&pmportinfo->pmport_mutex);
15206 pmportinfo->pmport_tgtnode_clean = B_TRUE;
15207 mutex_exit(&pmportinfo->pmport_mutex);
15208 } else {
15209 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, cport)->
15210 cport_mutex);
15211 cportinfo-> cport_tgtnode_clean = B_TRUE;
15212 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)->
15213 cport_mutex);
15214 }
15215
15216 tdip = sata_create_target_node(SATA_DIP(sata_hba_inst),
15217 sata_hba_inst, &sata_device->satadev_addr);
15218 if (tdip == NULL) {
15219 /* Configure operation failed */
15220 SATA_LOG_D((sata_hba_inst, CE_WARN,
15221 "sata_hba_ioctl: configure: "
15222 "configuring SATA device at port %d:%d "
15223 "failed", cport, pmport));
15224 return (EIO);
15225 }
15226 }
15227 return (0);
15228 }
15229
15230
15231 /*
15232 * Process ioctl deactivate port request.
15233 * Arbitrarily unconfigure attached device, if any.
15234 * Even if the unconfigure fails, proceed with the
15235 * port deactivation.
15236 *
15237 * NOTE: Port Multiplier is supported now.
15238 */
15239
15240 static int
15241 sata_ioctl_deactivate(sata_hba_inst_t *sata_hba_inst,
15242 sata_device_t *sata_device)
15243 {
15244 int cport, pmport, qual;
15245 int rval, rv = 0;
15246 int npmport;
15247 sata_cport_info_t *cportinfo;
15248 sata_pmport_info_t *pmportinfo;
15249 sata_pmult_info_t *pmultinfo;
15250 dev_info_t *tdip;
15251 sata_drive_info_t *sdinfo = NULL;
15252 sata_device_t subsdevice;
15253
15254 /* Sanity check */
15255 if (SATA_PORT_DEACTIVATE_FUNC(sata_hba_inst) == NULL)
15256 return (ENOTSUP);
15257
15258 cport = sata_device->satadev_addr.cport;
15259 pmport = sata_device->satadev_addr.pmport;
15260 qual = sata_device->satadev_addr.qual;
15261
15262 /* SCSI_TO_SATA_ADDR_QUAL() translate ap_id into a device qualifier */
15263 ASSERT(qual == SATA_ADDR_DCPORT || qual == SATA_ADDR_DPMPORT);
15264 if (qual == SATA_ADDR_DCPORT)
15265 qual = SATA_ADDR_CPORT;
15266 else
15267 qual = SATA_ADDR_PMPORT;
15268
15269 cportinfo = SATA_CPORT_INFO(sata_hba_inst, cport);
15270 if (qual == SATA_ADDR_PMPORT)
15271 pmportinfo = SATA_PMPORT_INFO(sata_hba_inst, cport, pmport);
15272
15273 /*
15274 * Processing port multiplier
15275 */
15276 if (qual == SATA_ADDR_CPORT &&
15277 SATA_CPORT_DEV_TYPE(sata_hba_inst, cport) == SATA_DTYPE_PMULT) {
15278 mutex_enter(&cportinfo->cport_mutex);
15279
15280 /* Deactivate all sub-deices */
15281 pmultinfo = SATA_CPORTINFO_PMULT_INFO(cportinfo);
15282 if (pmultinfo != NULL) {
15283 for (npmport = 0; npmport < SATA_NUM_PMPORTS(
15284 sata_hba_inst, cport); npmport++) {
15285
15286 subsdevice.satadev_addr.cport = cport;
15287 subsdevice.satadev_addr.pmport =
15288 (uint8_t)npmport;
15289 subsdevice.satadev_addr.qual =
15290 SATA_ADDR_DPMPORT;
15291
15292 SATADBG2(SATA_DBG_PMULT, sata_hba_inst,
15293 "sata_hba_ioctl: deactivate: trying to "
15294 "deactivate SATA port %d:%d",
15295 cport, npmport);
15296
15297 mutex_exit(&cportinfo->cport_mutex);
15298 if (sata_ioctl_deactivate(sata_hba_inst,
15299 &subsdevice) == SATA_SUCCESS) {
15300 SATADBG2(SATA_DBG_PMULT, sata_hba_inst,
15301 "[Deactivate] device at port %d:%d "
15302 "successfully.", cport, npmport);
15303 }
15304 mutex_enter(&cportinfo->cport_mutex);
15305 }
15306 }
15307
15308 /* Deactivate the port multiplier now. */
15309 cportinfo->cport_state &= ~SATA_STATE_READY;
15310 mutex_exit(&cportinfo->cport_mutex);
15311
15312 sata_device->satadev_addr.qual = qual;
15313 rval = (*SATA_PORT_DEACTIVATE_FUNC(sata_hba_inst))
15314 (SATA_DIP(sata_hba_inst), sata_device);
15315
15316 sata_gen_sysevent(sata_hba_inst, &sata_device->satadev_addr,
15317 SE_NO_HINT);
15318
15319 mutex_enter(&cportinfo->cport_mutex);
15320 sata_update_port_info(sata_hba_inst, sata_device);
15321 if (rval != SATA_SUCCESS) {
15322 if (sata_device->satadev_state & SATA_PSTATE_FAILED) {
15323 cportinfo->cport_state = SATA_PSTATE_FAILED;
15324 }
15325 rv = EIO;
15326 } else {
15327 cportinfo->cport_state |= SATA_PSTATE_SHUTDOWN;
15328 }
15329 mutex_exit(&cportinfo->cport_mutex);
15330
15331 return (rv);
15332 }
15333
15334 /*
15335 * Process non-port-multiplier device - it could be a drive connected
15336 * to a port multiplier port or a controller port.
15337 */
15338 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex);
15339 if (qual == SATA_ADDR_CPORT) {
15340 sata_device->satadev_addr.qual = SATA_ADDR_DCPORT;
15341 if (cportinfo->cport_dev_type != SATA_DTYPE_NONE) {
15342 /* deal only with valid devices */
15343 if ((cportinfo->cport_dev_type &
15344 SATA_VALID_DEV_TYPE) != 0)
15345 sdinfo = SATA_CPORTINFO_DRV_INFO(cportinfo);
15346 }
15347 cportinfo->cport_state &= ~SATA_STATE_READY;
15348 } else {
15349 /* Port multiplier device port */
15350 mutex_enter(&pmportinfo->pmport_mutex);
15351 sata_device->satadev_addr.qual = SATA_ADDR_DPMPORT;
15352 if (pmportinfo->pmport_dev_type != SATA_DTYPE_NONE &&
15353 (pmportinfo->pmport_dev_type & SATA_VALID_DEV_TYPE) != 0)
15354 sdinfo = SATA_PMPORTINFO_DRV_INFO(pmportinfo);
15355 pmportinfo->pmport_state &= ~SATA_STATE_READY;
15356 mutex_exit(&pmportinfo->pmport_mutex);
15357 }
15358
15359 if (sdinfo != NULL) {
15360 /*
15361 * If a target node exists, try to offline a device and
15362 * to remove a target node.
15363 */
15364 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)->
15365 cport_mutex);
15366 tdip = sata_get_scsi_target_dip(SATA_DIP(sata_hba_inst),
15367 &sata_device->satadev_addr);
15368 if (tdip != NULL) {
15369 /* target node exist */
15370 SATADBG1(SATA_DBG_IOCTL_IF, sata_hba_inst,
15371 "sata_hba_ioctl: port deactivate: "
15372 "target node exists.", NULL);
15373
15374 if (ndi_devi_offline(tdip, NDI_DEVI_REMOVE) !=
15375 NDI_SUCCESS) {
15376 SATA_LOG_D((sata_hba_inst, CE_WARN,
15377 "sata_hba_ioctl: port deactivate: "
15378 "failed to unconfigure device at port "
15379 "%d:%d before deactivating the port",
15380 cport, pmport));
15381 /*
15382 * Set DEVICE REMOVED state in the target
15383 * node. It will prevent an access to
15384 * the device even when a new device is
15385 * attached, until the old target node is
15386 * released, removed and recreated for a new
15387 * device.
15388 */
15389 sata_set_device_removed(tdip);
15390
15391 /*
15392 * Instruct the event daemon to try the
15393 * target node cleanup later.
15394 */
15395 sata_set_target_node_cleanup(sata_hba_inst,
15396 &sata_device->satadev_addr);
15397 }
15398 }
15399 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, cport)->
15400 cport_mutex);
15401 /*
15402 * In any case, remove and release sata_drive_info
15403 * structure.
15404 */
15405 if (qual == SATA_ADDR_CPORT) {
15406 SATA_CPORTINFO_DRV_INFO(cportinfo) = NULL;
15407 cportinfo->cport_dev_type = SATA_DTYPE_NONE;
15408 } else { /* port multiplier device port */
15409 mutex_enter(&pmportinfo->pmport_mutex);
15410 SATA_PMPORTINFO_DRV_INFO(pmportinfo) = NULL;
15411 pmportinfo->pmport_dev_type = SATA_DTYPE_NONE;
15412 mutex_exit(&pmportinfo->pmport_mutex);
15413 }
15414 (void) kmem_free((void *)sdinfo, sizeof (sata_drive_info_t));
15415 }
15416
15417 if (qual == SATA_ADDR_CPORT) {
15418 cportinfo->cport_state &= ~(SATA_STATE_PROBED |
15419 SATA_STATE_PROBING);
15420 } else if (qual == SATA_ADDR_PMPORT) {
15421 mutex_enter(&pmportinfo->pmport_mutex);
15422 pmportinfo->pmport_state &= ~(SATA_STATE_PROBED |
15423 SATA_STATE_PROBING);
15424 mutex_exit(&pmportinfo->pmport_mutex);
15425 }
15426 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex);
15427
15428 /* Just let HBA driver to deactivate port */
15429 sata_device->satadev_addr.qual = qual;
15430 rval = (*SATA_PORT_DEACTIVATE_FUNC(sata_hba_inst))
15431 (SATA_DIP(sata_hba_inst), sata_device);
15432
15433 /*
15434 * Generate sysevent - EC_DR / ESC_DR_AP_STATE_CHANGE
15435 * without the hint
15436 */
15437 sata_gen_sysevent(sata_hba_inst, &sata_device->satadev_addr,
15438 SE_NO_HINT);
15439
15440 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex);
15441 sata_update_port_info(sata_hba_inst, sata_device);
15442 if (qual == SATA_ADDR_CPORT) {
15443 if (rval != SATA_SUCCESS) {
15444 /*
15445 * Port deactivation failure - do not change port state
15446 * unless the state returned by HBA indicates a port
15447 * failure.
15448 */
15449 if (sata_device->satadev_state & SATA_PSTATE_FAILED) {
15450 SATA_CPORT_STATE(sata_hba_inst, cport) =
15451 SATA_PSTATE_FAILED;
15452 }
15453 SATA_LOG_D((sata_hba_inst, CE_WARN,
15454 "sata_hba_ioctl: port deactivate: "
15455 "cannot deactivate SATA port %d", cport));
15456 rv = EIO;
15457 } else {
15458 cportinfo->cport_state |= SATA_PSTATE_SHUTDOWN;
15459 }
15460 } else {
15461 mutex_enter(&pmportinfo->pmport_mutex);
15462 if (rval != SATA_SUCCESS) {
15463 if (sata_device->satadev_state & SATA_PSTATE_FAILED) {
15464 SATA_PMPORT_STATE(sata_hba_inst, cport,
15465 pmport) = SATA_PSTATE_FAILED;
15466 }
15467 SATA_LOG_D((sata_hba_inst, CE_WARN,
15468 "sata_hba_ioctl: port deactivate: "
15469 "cannot deactivate SATA port %d:%d",
15470 cport, pmport));
15471 rv = EIO;
15472 } else {
15473 pmportinfo->pmport_state |= SATA_PSTATE_SHUTDOWN;
15474 }
15475 mutex_exit(&pmportinfo->pmport_mutex);
15476 }
15477
15478 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex);
15479
15480 return (rv);
15481 }
15482
15483 /*
15484 * Process ioctl port activate request.
15485 *
15486 * NOTE: Port multiplier is supported now.
15487 */
15488 static int
15489 sata_ioctl_activate(sata_hba_inst_t *sata_hba_inst,
15490 sata_device_t *sata_device)
15491 {
15492 int cport, pmport, qual;
15493 sata_cport_info_t *cportinfo;
15494 sata_pmport_info_t *pmportinfo = NULL;
15495 boolean_t dev_existed = B_TRUE;
15496
15497 /* Sanity check */
15498 if (SATA_PORT_ACTIVATE_FUNC(sata_hba_inst) == NULL)
15499 return (ENOTSUP);
15500
15501 cport = sata_device->satadev_addr.cport;
15502 pmport = sata_device->satadev_addr.pmport;
15503 qual = sata_device->satadev_addr.qual;
15504
15505 cportinfo = SATA_CPORT_INFO(sata_hba_inst, cport);
15506
15507 /*
15508 * The qual translate from ap_id (by SCSI_TO_SATA_ADDR_QUAL())
15509 * is a device. But what we are dealing with is port/pmport.
15510 */
15511 ASSERT(qual == SATA_ADDR_DCPORT || qual == SATA_ADDR_DPMPORT);
15512 if (qual == SATA_ADDR_DCPORT)
15513 sata_device->satadev_addr.qual = qual = SATA_ADDR_CPORT;
15514 else
15515 sata_device->satadev_addr.qual = qual = SATA_ADDR_PMPORT;
15516
15517 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex);
15518 if (qual == SATA_ADDR_PMPORT) {
15519 pmportinfo = SATA_PMPORT_INFO(sata_hba_inst, cport, pmport);
15520 if (pmportinfo->pmport_state & SATA_PSTATE_SHUTDOWN ||
15521 pmportinfo->pmport_dev_type == SATA_DTYPE_NONE)
15522 dev_existed = B_FALSE;
15523 } else { /* cport */
15524 if (cportinfo->cport_state & SATA_PSTATE_SHUTDOWN ||
15525 cportinfo->cport_dev_type == SATA_DTYPE_NONE)
15526 dev_existed = B_FALSE;
15527 }
15528 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex);
15529
15530 /* Just let HBA driver to activate port, if necessary */
15531 if ((*SATA_PORT_ACTIVATE_FUNC(sata_hba_inst))
15532 (SATA_DIP(sata_hba_inst), sata_device) != SATA_SUCCESS) {
15533 /*
15534 * Port activation failure - do not change port state unless
15535 * the state returned by HBA indicates a port failure.
15536 */
15537 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst,
15538 cport)->cport_mutex);
15539 sata_update_port_info(sata_hba_inst, sata_device);
15540 if (sata_device->satadev_state & SATA_PSTATE_FAILED) {
15541 if (qual == SATA_ADDR_PMPORT) {
15542 mutex_enter(&pmportinfo->pmport_mutex);
15543 pmportinfo->pmport_state = SATA_PSTATE_FAILED;
15544 mutex_exit(&pmportinfo->pmport_mutex);
15545 } else
15546 cportinfo->cport_state = SATA_PSTATE_FAILED;
15547
15548 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst,
15549 cport)->cport_mutex);
15550 SATA_LOG_D((sata_hba_inst, CE_WARN,
15551 "sata_hba_ioctl: port activate: cannot activate "
15552 "SATA port %d:%d", cport, pmport));
15553 return (EIO);
15554 }
15555 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex);
15556 }
15557 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex);
15558 if (qual == SATA_ADDR_PMPORT) {
15559 mutex_enter(&pmportinfo->pmport_mutex);
15560 pmportinfo->pmport_state &= ~SATA_PSTATE_SHUTDOWN;
15561 mutex_exit(&pmportinfo->pmport_mutex);
15562 } else
15563 cportinfo->cport_state &= ~SATA_PSTATE_SHUTDOWN;
15564 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex);
15565
15566 /*
15567 * Re-probe port to find its current state and possibly attached device.
15568 * Port re-probing may change the cportinfo device type if device is
15569 * found attached.
15570 * If port probing failed, the device type would be set to
15571 * SATA_DTYPE_NONE.
15572 */
15573 (void) sata_reprobe_port(sata_hba_inst, sata_device,
15574 SATA_DEV_IDENTIFY_RETRY);
15575
15576 /*
15577 * Generate sysevent - EC_DR / ESC_DR_AP_STATE_CHANGE
15578 * without the hint.
15579 */
15580 sata_gen_sysevent(sata_hba_inst, &sata_device->satadev_addr,
15581 SE_NO_HINT);
15582
15583 if (dev_existed == B_FALSE) {
15584 if (qual == SATA_ADDR_PMPORT &&
15585 pmportinfo->pmport_dev_type != SATA_DTYPE_NONE) {
15586 /*
15587 * That's the transition from the "inactive" port state
15588 * or the active port without a device attached to the
15589 * active port state with a device attached.
15590 */
15591 sata_log(sata_hba_inst, CE_WARN,
15592 "SATA device detected at port %d:%d",
15593 cport, pmport);
15594 } else if (qual == SATA_ADDR_CPORT &&
15595 cportinfo->cport_dev_type != SATA_DTYPE_NONE) {
15596 /*
15597 * That's the transition from the "inactive" port state
15598 * or the active port without a device attached to the
15599 * active port state with a device attached.
15600 */
15601 if (cportinfo->cport_dev_type != SATA_DTYPE_PMULT) {
15602 sata_log(sata_hba_inst, CE_WARN,
15603 "SATA device detected at port %d", cport);
15604 } else {
15605 sata_log(sata_hba_inst, CE_WARN,
15606 "SATA port multiplier detected at port %d",
15607 cport);
15608 }
15609 }
15610 }
15611 return (0);
15612 }
15613
15614
15615
15616 /*
15617 * Process ioctl reset port request.
15618 *
15619 * NOTE: Port-Multiplier is supported.
15620 */
15621 static int
15622 sata_ioctl_reset_port(sata_hba_inst_t *sata_hba_inst,
15623 sata_device_t *sata_device)
15624 {
15625 int cport, pmport, qual;
15626 int rv = 0;
15627
15628 cport = sata_device->satadev_addr.cport;
15629 pmport = sata_device->satadev_addr.pmport;
15630 qual = sata_device->satadev_addr.qual;
15631
15632 /*
15633 * The qual translate from ap_id (by SCSI_TO_SATA_ADDR_QUAL())
15634 * is a device. But what we are dealing with is port/pmport.
15635 */
15636 if (qual == SATA_ADDR_DCPORT)
15637 sata_device->satadev_addr.qual = qual = SATA_ADDR_CPORT;
15638 else
15639 sata_device->satadev_addr.qual = qual = SATA_ADDR_PMPORT;
15640 ASSERT(qual == SATA_ADDR_CPORT || qual == SATA_ADDR_PMPORT);
15641
15642 /* Sanity check */
15643 if (SATA_RESET_DPORT_FUNC(sata_hba_inst) == NULL) {
15644 SATA_LOG_D((sata_hba_inst, CE_WARN,
15645 "sata_hba_ioctl: sata_hba_tran missing required "
15646 "function sata_tran_reset_dport"));
15647 return (ENOTSUP);
15648 }
15649
15650 /* Ask HBA to reset port */
15651 if ((*SATA_RESET_DPORT_FUNC(sata_hba_inst))(SATA_DIP(sata_hba_inst),
15652 sata_device) != SATA_SUCCESS) {
15653 SATA_LOG_D((sata_hba_inst, CE_WARN,
15654 "sata_hba_ioctl: reset port: failed %d:%d",
15655 cport, pmport));
15656 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, cport)->
15657 cport_mutex);
15658 sata_update_port_info(sata_hba_inst, sata_device);
15659 if (qual == SATA_ADDR_CPORT)
15660 SATA_CPORT_STATE(sata_hba_inst, cport) =
15661 SATA_PSTATE_FAILED;
15662 else {
15663 mutex_enter(&SATA_PMPORT_MUTEX(sata_hba_inst, cport,
15664 pmport));
15665 SATA_PMPORT_STATE(sata_hba_inst, cport, pmport) =
15666 SATA_PSTATE_FAILED;
15667 mutex_exit(&SATA_PMPORT_MUTEX(sata_hba_inst, cport,
15668 pmport));
15669 }
15670 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)->
15671 cport_mutex);
15672 rv = EIO;
15673 }
15674
15675 return (rv);
15676 }
15677
15678 /*
15679 * Process ioctl reset device request.
15680 *
15681 * NOTE: Port multiplier is supported.
15682 */
15683 static int
15684 sata_ioctl_reset_device(sata_hba_inst_t *sata_hba_inst,
15685 sata_device_t *sata_device)
15686 {
15687 sata_drive_info_t *sdinfo = NULL;
15688 sata_pmult_info_t *pmultinfo = NULL;
15689 int cport, pmport;
15690 int rv = 0;
15691
15692 /* Sanity check */
15693 if (SATA_RESET_DPORT_FUNC(sata_hba_inst) == NULL) {
15694 SATA_LOG_D((sata_hba_inst, CE_WARN,
15695 "sata_hba_ioctl: sata_hba_tran missing required "
15696 "function sata_tran_reset_dport"));
15697 return (ENOTSUP);
15698 }
15699
15700 cport = sata_device->satadev_addr.cport;
15701 pmport = sata_device->satadev_addr.pmport;
15702
15703 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex);
15704 if (sata_device->satadev_addr.qual == SATA_ADDR_DCPORT) {
15705 if (SATA_CPORT_DEV_TYPE(sata_hba_inst, cport) ==
15706 SATA_DTYPE_PMULT)
15707 pmultinfo = SATA_CPORT_INFO(sata_hba_inst, cport)->
15708 cport_devp.cport_sata_pmult;
15709 else
15710 sdinfo = SATA_CPORT_DRV_INFO(sata_hba_inst,
15711 sata_device->satadev_addr.cport);
15712 } else { /* port multiplier */
15713 sata_device->satadev_addr.qual = SATA_ADDR_DPMPORT;
15714 sdinfo = SATA_PMPORT_DRV_INFO(sata_hba_inst,
15715 sata_device->satadev_addr.cport,
15716 sata_device->satadev_addr.pmport);
15717 }
15718 if (sdinfo == NULL && pmultinfo == NULL) {
15719 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex);
15720 return (EINVAL);
15721 }
15722 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex);
15723
15724 /* Ask HBA to reset device */
15725 if ((*SATA_RESET_DPORT_FUNC(sata_hba_inst))
15726 (SATA_DIP(sata_hba_inst), sata_device) != SATA_SUCCESS) {
15727 SATA_LOG_D((sata_hba_inst, CE_WARN,
15728 "sata_hba_ioctl: reset device: failed at port %d:%d",
15729 cport, pmport));
15730 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, cport)->
15731 cport_mutex);
15732 sata_update_port_info(sata_hba_inst, sata_device);
15733 /*
15734 * Device info structure remains attached. Another device reset
15735 * or port disconnect/connect and re-probing is
15736 * needed to change it's state
15737 */
15738 if (sdinfo != NULL) {
15739 sdinfo->satadrv_state &= ~SATA_STATE_READY;
15740 sdinfo->satadrv_state |= SATA_DSTATE_FAILED;
15741 } else if (pmultinfo != NULL) {
15742 pmultinfo->pmult_state &= ~SATA_STATE_READY;
15743 pmultinfo->pmult_state |= SATA_DSTATE_FAILED;
15744 }
15745
15746 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex);
15747 rv = EIO;
15748 }
15749 /*
15750 * If attached device was a port multiplier, some extra processing
15751 * may be needed to bring it back. SATA specification requies a
15752 * mandatory software reset on host port to reliably enumerate a port
15753 * multiplier, the HBA driver should handle that after reset
15754 * operation.
15755 */
15756 return (rv);
15757 }
15758
15759
15760 /*
15761 * Process ioctl reset all request.
15762 */
15763 static int
15764 sata_ioctl_reset_all(sata_hba_inst_t *sata_hba_inst)
15765 {
15766 sata_device_t sata_device;
15767 int rv = 0;
15768 int tcport;
15769
15770 sata_device.satadev_rev = SATA_DEVICE_REV;
15771
15772 /*
15773 * There is no protection here for configured devices.
15774 */
15775 /* Sanity check */
15776 if (SATA_RESET_DPORT_FUNC(sata_hba_inst) == NULL) {
15777 SATA_LOG_D((sata_hba_inst, CE_WARN,
15778 "sata_hba_ioctl: sata_hba_tran missing required "
15779 "function sata_tran_reset_dport"));
15780 return (ENOTSUP);
15781 }
15782
15783 /*
15784 * Need to lock all ports, not just one.
15785 * If any port is locked by event processing, fail the whole operation.
15786 * One port is already locked, but for simplicity lock it again.
15787 */
15788 for (tcport = 0; tcport < SATA_NUM_CPORTS(sata_hba_inst); tcport++) {
15789 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, tcport)->
15790 cport_mutex);
15791 if (((SATA_CPORT_INFO(sata_hba_inst, tcport)->
15792 cport_event_flags) & SATA_EVNT_LOCK_PORT_BUSY) != 0) {
15793 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, tcport)->
15794 cport_mutex);
15795 rv = EBUSY;
15796 break;
15797 } else {
15798 /*
15799 * It is enough to lock cport in command-based
15800 * switching mode.
15801 */
15802 SATA_CPORT_INFO(sata_hba_inst, tcport)->
15803 cport_event_flags |= SATA_APCTL_LOCK_PORT_BUSY;
15804 }
15805 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, tcport)->
15806 cport_mutex);
15807 }
15808
15809 if (rv == 0) {
15810 /*
15811 * All cports were successfully locked.
15812 * Reset main SATA controller.
15813 * Set the device address to port 0, to have a valid device
15814 * address.
15815 */
15816 sata_device.satadev_addr.qual = SATA_ADDR_CNTRL;
15817 sata_device.satadev_addr.cport = 0;
15818 sata_device.satadev_addr.pmport = 0;
15819
15820 if ((*SATA_RESET_DPORT_FUNC(sata_hba_inst))
15821 (SATA_DIP(sata_hba_inst), &sata_device) != SATA_SUCCESS) {
15822 SATA_LOG_D((sata_hba_inst, CE_WARN,
15823 "sata_hba_ioctl: reset controller failed"));
15824 return (EIO);
15825 }
15826 }
15827 /*
15828 * Unlock all ports
15829 */
15830 for (tcport = 0; tcport < SATA_NUM_CPORTS(sata_hba_inst); tcport++) {
15831 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, tcport)->
15832 cport_mutex);
15833 SATA_CPORT_INFO(sata_hba_inst, tcport)->
15834 cport_event_flags &= ~SATA_APCTL_LOCK_PORT_BUSY;
15835 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, tcport)->
15836 cport_mutex);
15837 }
15838
15839 /*
15840 * This operation returns EFAULT if either reset
15841 * controller failed or a re-probing of any port failed.
15842 */
15843 return (rv);
15844 }
15845
15846
15847 /*
15848 * Process ioctl port self test request.
15849 *
15850 * NOTE: Port multiplier code is not completed nor tested.
15851 */
15852 static int
15853 sata_ioctl_port_self_test(sata_hba_inst_t *sata_hba_inst,
15854 sata_device_t *sata_device)
15855 {
15856 int cport, pmport, qual;
15857 int rv = 0;
15858
15859 /* Sanity check */
15860 if (SATA_SELFTEST_FUNC(sata_hba_inst) == NULL)
15861 return (ENOTSUP);
15862
15863 cport = sata_device->satadev_addr.cport;
15864 pmport = sata_device->satadev_addr.pmport;
15865 qual = sata_device->satadev_addr.qual;
15866
15867 /*
15868 * There is no protection here for a configured
15869 * device attached to this port.
15870 */
15871
15872 if ((*SATA_SELFTEST_FUNC(sata_hba_inst))
15873 (SATA_DIP(sata_hba_inst), sata_device) != SATA_SUCCESS) {
15874 SATA_LOG_D((sata_hba_inst, CE_WARN,
15875 "sata_hba_ioctl: port selftest: "
15876 "failed port %d:%d", cport, pmport));
15877 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, cport)->
15878 cport_mutex);
15879 sata_update_port_info(sata_hba_inst, sata_device);
15880 if (qual == SATA_ADDR_CPORT)
15881 SATA_CPORT_STATE(sata_hba_inst, cport) =
15882 SATA_PSTATE_FAILED;
15883 else { /* port multiplier device port */
15884 mutex_enter(&SATA_PMPORT_MUTEX(sata_hba_inst,
15885 cport, pmport));
15886 SATA_PMPORT_STATE(sata_hba_inst, cport, pmport) =
15887 SATA_PSTATE_FAILED;
15888 mutex_exit(&SATA_PMPORT_MUTEX(sata_hba_inst,
15889 cport, pmport));
15890 }
15891
15892 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)->
15893 cport_mutex);
15894 return (EIO);
15895 }
15896 /*
15897 * Beacuse the port was reset in the course of testing, it should be
15898 * re-probed and attached device state should be restored. At this
15899 * point the port state is unknown - it's state is HBA-specific.
15900 * Force port re-probing to get it into a known state.
15901 */
15902 if (sata_reprobe_port(sata_hba_inst, sata_device,
15903 SATA_DEV_IDENTIFY_RETRY) != SATA_SUCCESS)
15904 rv = EIO;
15905 return (rv);
15906 }
15907
15908
15909 /*
15910 * sata_cfgadm_state:
15911 * Use the sata port state and state of the target node to figure out
15912 * the cfgadm_state.
15913 *
15914 * The port argument is a value with encoded cport,
15915 * pmport and address qualifier, in the same manner as a scsi target number.
15916 * SCSI_TO_SATA_CPORT macro extracts cport number,
15917 * SCSI_TO_SATA_PMPORT extracts pmport number and
15918 * SCSI_TO_SATA_ADDR_QUAL extracts port mulitplier qualifier flag.
15919 *
15920 * Port multiplier is supported.
15921 */
15922
15923 static void
15924 sata_cfgadm_state(sata_hba_inst_t *sata_hba_inst, int32_t port,
15925 devctl_ap_state_t *ap_state)
15926 {
15927 uint8_t cport, pmport, qual;
15928 uint32_t port_state, pmult_state;
15929 uint32_t dev_type;
15930 sata_drive_info_t *sdinfo;
15931
15932 cport = SCSI_TO_SATA_CPORT(port);
15933 pmport = SCSI_TO_SATA_PMPORT(port);
15934 qual = SCSI_TO_SATA_ADDR_QUAL(port);
15935
15936 /* Check cport state */
15937 port_state = SATA_CPORT_STATE(sata_hba_inst, cport);
15938 if (port_state & SATA_PSTATE_SHUTDOWN ||
15939 port_state & SATA_PSTATE_FAILED) {
15940 ap_state->ap_rstate = AP_RSTATE_DISCONNECTED;
15941 ap_state->ap_ostate = AP_OSTATE_UNCONFIGURED;
15942 if (port_state & SATA_PSTATE_FAILED)
15943 ap_state->ap_condition = AP_COND_FAILED;
15944 else
15945 ap_state->ap_condition = AP_COND_UNKNOWN;
15946
15947 return;
15948 }
15949
15950 /* cport state is okay. Now check pmport state */
15951 if (qual == SATA_ADDR_DPMPORT || qual == SATA_ADDR_PMPORT) {
15952 /* Sanity check */
15953 if (SATA_CPORT_DEV_TYPE(sata_hba_inst, cport) !=
15954 SATA_DTYPE_PMULT || SATA_PMPORT_INFO(sata_hba_inst,
15955 cport, pmport) == NULL)
15956 return;
15957 port_state = SATA_PMPORT_STATE(sata_hba_inst, cport, pmport);
15958 if (port_state & SATA_PSTATE_SHUTDOWN ||
15959 port_state & SATA_PSTATE_FAILED) {
15960 ap_state->ap_rstate = AP_RSTATE_DISCONNECTED;
15961 ap_state->ap_ostate = AP_OSTATE_UNCONFIGURED;
15962 if (port_state & SATA_PSTATE_FAILED)
15963 ap_state->ap_condition = AP_COND_FAILED;
15964 else
15965 ap_state->ap_condition = AP_COND_UNKNOWN;
15966
15967 return;
15968 }
15969 }
15970
15971 /* Port is enabled and ready */
15972 if (qual == SATA_ADDR_DCPORT || qual == SATA_ADDR_CPORT)
15973 dev_type = SATA_CPORT_DEV_TYPE(sata_hba_inst, cport);
15974 else
15975 dev_type = SATA_PMPORT_DEV_TYPE(sata_hba_inst, cport, pmport);
15976
15977 switch (dev_type) {
15978 case SATA_DTYPE_NONE:
15979 {
15980 ap_state->ap_ostate = AP_OSTATE_UNCONFIGURED;
15981 ap_state->ap_condition = AP_COND_OK;
15982 /* No device attached */
15983 ap_state->ap_rstate = AP_RSTATE_EMPTY;
15984 break;
15985 }
15986 case SATA_DTYPE_PMULT:
15987 {
15988 /* Need to check port multiplier state */
15989 ASSERT(qual == SATA_ADDR_DCPORT);
15990 pmult_state = SATA_PMULT_INFO(sata_hba_inst, cport)->
15991 pmult_state;
15992 if (pmult_state & (SATA_PSTATE_SHUTDOWN|SATA_PSTATE_FAILED)) {
15993 ap_state->ap_rstate = AP_RSTATE_DISCONNECTED;
15994 ap_state->ap_ostate = AP_OSTATE_UNCONFIGURED;
15995 if (pmult_state & SATA_PSTATE_FAILED)
15996 ap_state->ap_condition = AP_COND_FAILED;
15997 else
15998 ap_state->ap_condition = AP_COND_UNKNOWN;
15999
16000 return;
16001 }
16002
16003 /* Port multiplier is not configurable */
16004 ap_state->ap_ostate = AP_OSTATE_CONFIGURED;
16005 ap_state->ap_rstate = AP_RSTATE_CONNECTED;
16006 ap_state->ap_condition = AP_COND_OK;
16007 break;
16008 }
16009
16010 case SATA_DTYPE_ATADISK:
16011 case SATA_DTYPE_ATAPICD:
16012 case SATA_DTYPE_ATAPITAPE:
16013 case SATA_DTYPE_ATAPIDISK:
16014 {
16015 dev_info_t *tdip = NULL;
16016 dev_info_t *dip = NULL;
16017 int circ;
16018
16019 dip = SATA_DIP(sata_hba_inst);
16020 tdip = sata_get_target_dip(dip, cport, pmport);
16021 ap_state->ap_rstate = AP_RSTATE_CONNECTED;
16022 if (tdip != NULL) {
16023 ndi_devi_enter(dip, &circ);
16024 mutex_enter(&(DEVI(tdip)->devi_lock));
16025 if (DEVI_IS_DEVICE_REMOVED(tdip)) {
16026 /*
16027 * There could be the case where previously
16028 * configured and opened device was removed
16029 * and unknown device was plugged.
16030 * In such case we want to show a device, and
16031 * its configured or unconfigured state but
16032 * indicate unusable condition untill the
16033 * old target node is released and removed.
16034 */
16035 ap_state->ap_condition = AP_COND_UNUSABLE;
16036 } else {
16037 mutex_enter(&SATA_CPORT_MUTEX(sata_hba_inst,
16038 cport));
16039 sdinfo = SATA_CPORT_DRV_INFO(sata_hba_inst,
16040 cport);
16041 if (sdinfo != NULL) {
16042 if ((sdinfo->satadrv_state &
16043 SATA_DSTATE_FAILED) != 0)
16044 ap_state->ap_condition =
16045 AP_COND_FAILED;
16046 else
16047 ap_state->ap_condition =
16048 AP_COND_OK;
16049 } else {
16050 ap_state->ap_condition =
16051 AP_COND_UNKNOWN;
16052 }
16053 mutex_exit(&SATA_CPORT_MUTEX(sata_hba_inst,
16054 cport));
16055 }
16056 if ((DEVI_IS_DEVICE_OFFLINE(tdip)) ||
16057 (DEVI_IS_DEVICE_DOWN(tdip))) {
16058 ap_state->ap_ostate =
16059 AP_OSTATE_UNCONFIGURED;
16060 } else {
16061 ap_state->ap_ostate =
16062 AP_OSTATE_CONFIGURED;
16063 }
16064 mutex_exit(&(DEVI(tdip)->devi_lock));
16065 ndi_devi_exit(dip, circ);
16066 } else {
16067 ap_state->ap_ostate = AP_OSTATE_UNCONFIGURED;
16068 ap_state->ap_condition = AP_COND_UNKNOWN;
16069 }
16070 break;
16071 }
16072 case SATA_DTYPE_ATAPIPROC:
16073 ap_state->ap_rstate = AP_RSTATE_CONNECTED;
16074 ap_state->ap_ostate = AP_OSTATE_UNCONFIGURED;
16075 ap_state->ap_condition = AP_COND_OK;
16076 break;
16077 default:
16078 ap_state->ap_rstate = AP_RSTATE_CONNECTED;
16079 ap_state->ap_ostate = AP_OSTATE_UNCONFIGURED;
16080 ap_state->ap_condition = AP_COND_UNKNOWN;
16081 /*
16082 * This is actually internal error condition (non fatal),
16083 * because we have already checked all defined device types.
16084 */
16085 SATA_LOG_D((sata_hba_inst, CE_WARN,
16086 "sata_cfgadm_state: Internal error: "
16087 "unknown device type"));
16088 break;
16089 }
16090 }
16091
16092
16093 /*
16094 * Process ioctl get device path request.
16095 *
16096 * NOTE: Port multiplier has no target dip. Devices connected to port
16097 * multiplier have target node attached to the HBA node. The only difference
16098 * between them and the directly-attached device node is a target address.
16099 */
16100 static int
16101 sata_ioctl_get_device_path(sata_hba_inst_t *sata_hba_inst,
16102 sata_device_t *sata_device, sata_ioctl_data_t *ioc, int mode)
16103 {
16104 char path[MAXPATHLEN];
16105 uint32_t size;
16106 dev_info_t *tdip;
16107
16108 (void) strcpy(path, "/devices");
16109 if ((tdip = sata_get_scsi_target_dip(SATA_DIP(sata_hba_inst),
16110 &sata_device->satadev_addr)) == NULL) {
16111 /*
16112 * No such device. If this is a request for a size, do not
16113 * return EINVAL for non-existing target, because cfgadm
16114 * will then indicate a meaningless ioctl failure.
16115 * If this is a request for a path, indicate invalid
16116 * argument.
16117 */
16118 if (ioc->get_size == 0)
16119 return (EINVAL);
16120 } else {
16121 (void) ddi_pathname(tdip, path + strlen(path));
16122 }
16123 size = strlen(path) + 1;
16124
16125 if (ioc->get_size != 0) {
16126 if (ddi_copyout((void *)&size, ioc->buf, ioc->bufsiz,
16127 mode) != 0)
16128 return (EFAULT);
16129 } else {
16130 if (ioc->bufsiz != size)
16131 return (EINVAL);
16132
16133 else if (ddi_copyout((void *)&path, ioc->buf, ioc->bufsiz,
16134 mode) != 0)
16135 return (EFAULT);
16136 }
16137 return (0);
16138 }
16139
16140 /*
16141 * Process ioctl get attachment point type request.
16142 *
16143 * NOTE: Port multiplier is supported.
16144 */
16145 static int
16146 sata_ioctl_get_ap_type(sata_hba_inst_t *sata_hba_inst,
16147 sata_device_t *sata_device, sata_ioctl_data_t *ioc, int mode)
16148 {
16149 uint32_t type_len;
16150 const char *ap_type;
16151 int dev_type;
16152
16153 if (sata_device->satadev_addr.qual == SATA_ADDR_DCPORT)
16154 dev_type = SATA_CPORT_DEV_TYPE(sata_hba_inst,
16155 sata_device->satadev_addr.cport);
16156 else /* pmport */
16157 dev_type = SATA_PMPORT_DEV_TYPE(sata_hba_inst,
16158 sata_device->satadev_addr.cport,
16159 sata_device->satadev_addr.pmport);
16160
16161 switch (dev_type) {
16162 case SATA_DTYPE_NONE:
16163 ap_type = "port";
16164 break;
16165
16166 case SATA_DTYPE_ATADISK:
16167 case SATA_DTYPE_ATAPIDISK:
16168 ap_type = "disk";
16169 break;
16170
16171 case SATA_DTYPE_ATAPICD:
16172 ap_type = "cd/dvd";
16173 break;
16174
16175 case SATA_DTYPE_ATAPITAPE:
16176 ap_type = "tape";
16177 break;
16178
16179 case SATA_DTYPE_ATAPIPROC:
16180 ap_type = "processor";
16181 break;
16182
16183 case SATA_DTYPE_PMULT:
16184 ap_type = "sata-pmult";
16185 break;
16186
16187 case SATA_DTYPE_UNKNOWN:
16188 ap_type = "unknown";
16189 break;
16190
16191 default:
16192 ap_type = "unsupported";
16193 break;
16194
16195 } /* end of dev_type switch */
16196
16197 type_len = strlen(ap_type) + 1;
16198
16199 if (ioc->get_size) {
16200 if (ddi_copyout((void *)&type_len, ioc->buf, ioc->bufsiz,
16201 mode) != 0)
16202 return (EFAULT);
16203 } else {
16204 if (ioc->bufsiz != type_len)
16205 return (EINVAL);
16206
16207 if (ddi_copyout((void *)ap_type, ioc->buf,
16208 ioc->bufsiz, mode) != 0)
16209 return (EFAULT);
16210 }
16211 return (0);
16212
16213 }
16214
16215 /*
16216 * Process ioctl get device model info request.
16217 * This operation should return to cfgadm the device model
16218 * information string
16219 *
16220 * NOTE: Port multiplier is supported.
16221 */
16222 static int
16223 sata_ioctl_get_model_info(sata_hba_inst_t *sata_hba_inst,
16224 sata_device_t *sata_device, sata_ioctl_data_t *ioc, int mode)
16225 {
16226 sata_drive_info_t *sdinfo;
16227 uint32_t info_len;
16228 char ap_info[SATA_ID_MODEL_LEN + 1];
16229
16230 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst,
16231 sata_device->satadev_addr.cport)->cport_mutex);
16232 if (sata_device->satadev_addr.qual == SATA_ADDR_DCPORT)
16233 sdinfo = SATA_CPORT_DRV_INFO(sata_hba_inst,
16234 sata_device->satadev_addr.cport);
16235 else /* port multiplier */
16236 sdinfo = SATA_PMPORT_DRV_INFO(sata_hba_inst,
16237 sata_device->satadev_addr.cport,
16238 sata_device->satadev_addr.pmport);
16239 if (sdinfo == NULL) {
16240 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst,
16241 sata_device->satadev_addr.cport)->cport_mutex);
16242 return (EINVAL);
16243 }
16244
16245 #ifdef _LITTLE_ENDIAN
16246 swab(sdinfo->satadrv_id.ai_model, ap_info, SATA_ID_MODEL_LEN);
16247 #else /* _LITTLE_ENDIAN */
16248 bcopy(sdinfo->satadrv_id.ai_model, ap_info, SATA_ID_MODEL_LEN);
16249 #endif /* _LITTLE_ENDIAN */
16250
16251 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst,
16252 sata_device->satadev_addr.cport)->cport_mutex);
16253
16254 ap_info[SATA_ID_MODEL_LEN] = '\0';
16255
16256 info_len = strlen(ap_info) + 1;
16257
16258 if (ioc->get_size) {
16259 if (ddi_copyout((void *)&info_len, ioc->buf, ioc->bufsiz,
16260 mode) != 0)
16261 return (EFAULT);
16262 } else {
16263 if (ioc->bufsiz < info_len)
16264 return (EINVAL);
16265 if (ddi_copyout((void *)ap_info, ioc->buf, ioc->bufsiz,
16266 mode) != 0)
16267 return (EFAULT);
16268 }
16269 return (0);
16270 }
16271
16272
16273 /*
16274 * Process ioctl get device firmware revision info request.
16275 * This operation should return to cfgadm the device firmware revision
16276 * information string
16277 *
16278 * Port multiplier is supported.
16279 */
16280 static int
16281 sata_ioctl_get_revfirmware_info(sata_hba_inst_t *sata_hba_inst,
16282 sata_device_t *sata_device, sata_ioctl_data_t *ioc, int mode)
16283 {
16284 sata_drive_info_t *sdinfo;
16285 uint32_t info_len;
16286 char ap_info[SATA_ID_FW_LEN + 1];
16287
16288 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst,
16289 sata_device->satadev_addr.cport)->cport_mutex);
16290 if (sata_device->satadev_addr.qual == SATA_ADDR_DCPORT)
16291 sdinfo = SATA_CPORT_DRV_INFO(sata_hba_inst,
16292 sata_device->satadev_addr.cport);
16293 else /* port multiplier */
16294 sdinfo = SATA_PMPORT_DRV_INFO(sata_hba_inst,
16295 sata_device->satadev_addr.cport,
16296 sata_device->satadev_addr.pmport);
16297 if (sdinfo == NULL) {
16298 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst,
16299 sata_device->satadev_addr.cport)->cport_mutex);
16300 return (EINVAL);
16301 }
16302
16303 #ifdef _LITTLE_ENDIAN
16304 swab(sdinfo->satadrv_id.ai_fw, ap_info, SATA_ID_FW_LEN);
16305 #else /* _LITTLE_ENDIAN */
16306 bcopy(sdinfo->satadrv_id.ai_fw, ap_info, SATA_ID_FW_LEN);
16307 #endif /* _LITTLE_ENDIAN */
16308
16309 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst,
16310 sata_device->satadev_addr.cport)->cport_mutex);
16311
16312 ap_info[SATA_ID_FW_LEN] = '\0';
16313
16314 info_len = strlen(ap_info) + 1;
16315
16316 if (ioc->get_size) {
16317 if (ddi_copyout((void *)&info_len, ioc->buf, ioc->bufsiz,
16318 mode) != 0)
16319 return (EFAULT);
16320 } else {
16321 if (ioc->bufsiz < info_len)
16322 return (EINVAL);
16323 if (ddi_copyout((void *)ap_info, ioc->buf, ioc->bufsiz,
16324 mode) != 0)
16325 return (EFAULT);
16326 }
16327 return (0);
16328 }
16329
16330
16331 /*
16332 * Process ioctl get device serial number info request.
16333 * This operation should return to cfgadm the device serial number string.
16334 *
16335 * NOTE: Port multiplier is supported.
16336 */
16337 static int
16338 sata_ioctl_get_serialnumber_info(sata_hba_inst_t *sata_hba_inst,
16339 sata_device_t *sata_device, sata_ioctl_data_t *ioc, int mode)
16340 {
16341 sata_drive_info_t *sdinfo;
16342 uint32_t info_len;
16343 char ap_info[SATA_ID_SERIAL_LEN + 1];
16344
16345 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst,
16346 sata_device->satadev_addr.cport)->cport_mutex);
16347 if (sata_device->satadev_addr.qual == SATA_ADDR_DCPORT)
16348 sdinfo = SATA_CPORT_DRV_INFO(sata_hba_inst,
16349 sata_device->satadev_addr.cport);
16350 else /* port multiplier */
16351 sdinfo = SATA_PMPORT_DRV_INFO(sata_hba_inst,
16352 sata_device->satadev_addr.cport,
16353 sata_device->satadev_addr.pmport);
16354 if (sdinfo == NULL) {
16355 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst,
16356 sata_device->satadev_addr.cport)->cport_mutex);
16357 return (EINVAL);
16358 }
16359
16360 #ifdef _LITTLE_ENDIAN
16361 swab(sdinfo->satadrv_id.ai_drvser, ap_info, SATA_ID_SERIAL_LEN);
16362 #else /* _LITTLE_ENDIAN */
16363 bcopy(sdinfo->satadrv_id.ai_drvser, ap_info, SATA_ID_SERIAL_LEN);
16364 #endif /* _LITTLE_ENDIAN */
16365
16366 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst,
16367 sata_device->satadev_addr.cport)->cport_mutex);
16368
16369 ap_info[SATA_ID_SERIAL_LEN] = '\0';
16370
16371 info_len = strlen(ap_info) + 1;
16372
16373 if (ioc->get_size) {
16374 if (ddi_copyout((void *)&info_len, ioc->buf, ioc->bufsiz,
16375 mode) != 0)
16376 return (EFAULT);
16377 } else {
16378 if (ioc->bufsiz < info_len)
16379 return (EINVAL);
16380 if (ddi_copyout((void *)ap_info, ioc->buf, ioc->bufsiz,
16381 mode) != 0)
16382 return (EFAULT);
16383 }
16384 return (0);
16385 }
16386
16387
16388 /*
16389 * Preset scsi extended sense data (to NO SENSE)
16390 * First 18 bytes of the sense data are preset to current valid sense
16391 * with a key NO SENSE data.
16392 *
16393 * Returns void
16394 */
16395 static void
16396 sata_fixed_sense_data_preset(struct scsi_extended_sense *sense)
16397 {
16398 sense->es_valid = 1; /* Valid sense */
16399 sense->es_class = CLASS_EXTENDED_SENSE; /* 0x70 - current err */
16400 sense->es_key = KEY_NO_SENSE;
16401 sense->es_info_1 = 0;
16402 sense->es_info_2 = 0;
16403 sense->es_info_3 = 0;
16404 sense->es_info_4 = 0;
16405 sense->es_add_len = 10; /* Additional length - replace with a def */
16406 sense->es_cmd_info[0] = 0;
16407 sense->es_cmd_info[1] = 0;
16408 sense->es_cmd_info[2] = 0;
16409 sense->es_cmd_info[3] = 0;
16410 sense->es_add_code = 0;
16411 sense->es_qual_code = 0;
16412 }
16413
16414 /*
16415 * Register a legacy cmdk-style devid for the target (disk) device.
16416 *
16417 * Note: This function is called only when the HBA devinfo node has the
16418 * property "use-cmdk-devid-format" set. This property indicates that
16419 * devid compatible with old cmdk (target) driver is to be generated
16420 * for any target device attached to this controller. This will take
16421 * precedence over the devid generated by sd (target) driver.
16422 * This function is derived from cmdk_devid_setup() function in cmdk.c.
16423 */
16424 static void
16425 sata_target_devid_register(dev_info_t *dip, sata_drive_info_t *sdinfo)
16426 {
16427 char *hwid;
16428 int modlen;
16429 int serlen;
16430 int rval;
16431 ddi_devid_t devid;
16432
16433 /*
16434 * device ID is a concatanation of model number, "=", serial number.
16435 */
16436 hwid = kmem_zalloc(LEGACY_HWID_LEN, KM_SLEEP);
16437 bcopy(&sdinfo->satadrv_id.ai_model, hwid,
16438 sizeof (sdinfo->satadrv_id.ai_model));
16439 swab(hwid, hwid, sizeof (sdinfo->satadrv_id.ai_model));
16440 modlen = sata_check_modser(hwid, sizeof (sdinfo->satadrv_id.ai_model));
16441 if (modlen == 0)
16442 goto err;
16443 hwid[modlen++] = '=';
16444 bcopy(&sdinfo->satadrv_id.ai_drvser, &hwid[modlen],
16445 sizeof (sdinfo->satadrv_id.ai_drvser));
16446 swab(&hwid[modlen], &hwid[modlen],
16447 sizeof (sdinfo->satadrv_id.ai_drvser));
16448 serlen = sata_check_modser(&hwid[modlen],
16449 sizeof (sdinfo->satadrv_id.ai_drvser));
16450 if (serlen == 0)
16451 goto err;
16452 hwid[modlen + serlen] = 0; /* terminate the hwid string */
16453
16454 /* initialize/register devid */
16455 if ((rval = ddi_devid_init(dip, DEVID_ATA_SERIAL,
16456 (ushort_t)(modlen + serlen), hwid, &devid)) == DDI_SUCCESS) {
16457 rval = ddi_devid_register(dip, devid);
16458 /*
16459 * Free up the allocated devid buffer.
16460 * NOTE: This doesn't mean unregistering devid.
16461 */
16462 ddi_devid_free(devid);
16463 }
16464
16465 if (rval != DDI_SUCCESS)
16466 cmn_err(CE_WARN, "sata: failed to create devid for the disk"
16467 " on port %d", sdinfo->satadrv_addr.cport);
16468 err:
16469 kmem_free(hwid, LEGACY_HWID_LEN);
16470 }
16471
16472 /*
16473 * valid model/serial string must contain a non-zero non-space characters.
16474 * trim trailing spaces/NULLs.
16475 */
16476 static int
16477 sata_check_modser(char *buf, int buf_len)
16478 {
16479 boolean_t ret;
16480 char *s;
16481 int i;
16482 int tb;
16483 char ch;
16484
16485 ret = B_FALSE;
16486 s = buf;
16487 for (i = 0; i < buf_len; i++) {
16488 ch = *s++;
16489 if (ch != ' ' && ch != '\0')
16490 tb = i + 1;
16491 if (ch != ' ' && ch != '\0' && ch != '0')
16492 ret = B_TRUE;
16493 }
16494
16495 if (ret == B_FALSE)
16496 return (0); /* invalid string */
16497
16498 return (tb); /* return length */
16499 }
16500
16501 /*
16502 * sata_set_drive_features function compares current device features setting
16503 * with the saved device features settings and, if there is a difference,
16504 * it restores device features setting to the previously saved state.
16505 * It also arbitrarily tries to select the highest supported DMA mode.
16506 * Device Identify or Identify Packet Device data has to be current.
16507 * At the moment read ahead and write cache are considered for all devices.
16508 * For atapi devices, Removable Media Status Notification is set in addition
16509 * to common features.
16510 *
16511 * This function cannot be called in the interrupt context (it may sleep).
16512 *
16513 * The input argument sdinfo should point to the drive info structure
16514 * to be updated after features are set. Note, that only
16515 * device (packet) identify data is updated, not the flags indicating the
16516 * supported features.
16517 *
16518 * Returns SATA_SUCCESS if successful or there was nothing to do.
16519 * Device Identify data in the drive info structure pointed to by the sdinfo
16520 * arguments is updated even when no features were set or changed.
16521 *
16522 * Returns SATA_FAILURE if device features could not be set or DMA mode
16523 * for a disk cannot be set and device identify data cannot be fetched.
16524 *
16525 * Returns SATA_RETRY if device features could not be set (other than disk
16526 * DMA mode) but the device identify data was fetched successfully.
16527 *
16528 * Note: This function may fail the port, making it inaccessible.
16529 * In such case the explicit port disconnect/connect or physical device
16530 * detach/attach is required to re-evaluate port state again.
16531 */
16532
16533 static int
16534 sata_set_drive_features(sata_hba_inst_t *sata_hba_inst,
16535 sata_drive_info_t *sdinfo, int restore)
16536 {
16537 int rval = SATA_SUCCESS;
16538 int rval_set;
16539 sata_drive_info_t new_sdinfo;
16540 char *finfo = "sata_set_drive_features: cannot";
16541 char *finfox;
16542 int cache_op;
16543
16544 bzero(&new_sdinfo, sizeof (sata_drive_info_t));
16545 new_sdinfo.satadrv_addr = sdinfo->satadrv_addr;
16546 new_sdinfo.satadrv_type = sdinfo->satadrv_type;
16547 if (sata_fetch_device_identify_data(sata_hba_inst, &new_sdinfo) != 0) {
16548 /*
16549 * Cannot get device identification - caller may retry later
16550 */
16551 SATADBG1(SATA_DBG_DEV_SETTINGS, sata_hba_inst,
16552 "%s fetch device identify data\n", finfo);
16553 return (SATA_FAILURE);
16554 }
16555 finfox = (restore != 0) ? " restore device features" :
16556 " initialize device features\n";
16557
16558 switch (sdinfo->satadrv_type) {
16559 case SATA_DTYPE_ATADISK:
16560 /* Arbitrarily set UDMA mode */
16561 if (sata_set_dma_mode(sata_hba_inst, &new_sdinfo) !=
16562 SATA_SUCCESS) {
16563 SATA_LOG_D((sata_hba_inst, CE_WARN,
16564 "%s set UDMA mode\n", finfo));
16565 return (SATA_FAILURE);
16566 }
16567 break;
16568 case SATA_DTYPE_ATAPICD:
16569 case SATA_DTYPE_ATAPITAPE:
16570 case SATA_DTYPE_ATAPIDISK:
16571 /* Set Removable Media Status Notification, if necessary */
16572 if (SATA_RM_NOTIFIC_SUPPORTED(new_sdinfo.satadrv_id) &&
16573 restore != 0) {
16574 if (((sdinfo->satadrv_settings & SATA_DEV_RMSN) &&
16575 (!SATA_RM_NOTIFIC_ENABLED(new_sdinfo.satadrv_id)))||
16576 ((!(sdinfo->satadrv_settings & SATA_DEV_RMSN)) &&
16577 SATA_RM_NOTIFIC_ENABLED(new_sdinfo.satadrv_id))) {
16578 /* Current setting does not match saved one */
16579 if (sata_set_rmsn(sata_hba_inst, sdinfo,
16580 sdinfo->satadrv_settings &
16581 SATA_DEV_RMSN) != SATA_SUCCESS)
16582 rval = SATA_FAILURE;
16583 }
16584 }
16585 /*
16586 * We have to set Multiword DMA or UDMA, if it is supported, as
16587 * we want to use DMA transfer mode whenever possible.
16588 * Some devices require explicit setting of the DMA mode.
16589 */
16590 if (new_sdinfo.satadrv_id.ai_cap & SATA_DMA_SUPPORT) {
16591 /* Set highest supported DMA mode */
16592 if (sata_set_dma_mode(sata_hba_inst, &new_sdinfo) !=
16593 SATA_SUCCESS) {
16594 SATA_LOG_D((sata_hba_inst, CE_WARN,
16595 "%s set UDMA mode\n", finfo));
16596 rval = SATA_FAILURE;
16597 }
16598 }
16599 break;
16600 }
16601
16602 if (!SATA_READ_AHEAD_SUPPORTED(new_sdinfo.satadrv_id) &&
16603 !SATA_WRITE_CACHE_SUPPORTED(new_sdinfo.satadrv_id)) {
16604 /*
16605 * neither READ AHEAD nor WRITE CACHE is supported
16606 * - do nothing
16607 */
16608 SATADBG1(SATA_DBG_DEV_SETTINGS, sata_hba_inst,
16609 "settable features not supported\n", NULL);
16610 goto update_sdinfo;
16611 }
16612
16613 if ((SATA_READ_AHEAD_ENABLED(new_sdinfo.satadrv_id) &&
16614 (sdinfo->satadrv_settings & SATA_DEV_READ_AHEAD)) &&
16615 (SATA_WRITE_CACHE_ENABLED(new_sdinfo.satadrv_id) &&
16616 (sdinfo->satadrv_settings & SATA_DEV_WRITE_CACHE))) {
16617 /*
16618 * both READ AHEAD and WRITE CACHE are enabled
16619 * - Nothing to do
16620 */
16621 SATADBG1(SATA_DBG_DEV_SETTINGS, sata_hba_inst,
16622 "no device features to set\n", NULL);
16623 goto update_sdinfo;
16624 }
16625
16626 cache_op = 0;
16627
16628 if (SATA_READ_AHEAD_SUPPORTED(new_sdinfo.satadrv_id)) {
16629 if ((sdinfo->satadrv_settings & SATA_DEV_READ_AHEAD) &&
16630 !SATA_READ_AHEAD_ENABLED(new_sdinfo.satadrv_id)) {
16631 /* Enable read ahead / read cache */
16632 cache_op = SATAC_SF_ENABLE_READ_AHEAD;
16633 SATADBG1(SATA_DBG_DEV_SETTINGS, sata_hba_inst,
16634 "enabling read cache\n", NULL);
16635 } else if (!(sdinfo->satadrv_settings & SATA_DEV_READ_AHEAD) &&
16636 SATA_READ_AHEAD_ENABLED(new_sdinfo.satadrv_id)) {
16637 /* Disable read ahead / read cache */
16638 cache_op = SATAC_SF_DISABLE_READ_AHEAD;
16639 SATADBG1(SATA_DBG_DEV_SETTINGS, sata_hba_inst,
16640 "disabling read cache\n", NULL);
16641 }
16642
16643 if (cache_op != 0) {
16644 /* Try to set read cache mode */
16645 rval_set = sata_set_cache_mode(sata_hba_inst,
16646 &new_sdinfo, cache_op);
16647 if (rval != SATA_FAILURE && rval_set != SATA_SUCCESS)
16648 rval = rval_set;
16649 }
16650 }
16651
16652 cache_op = 0;
16653
16654 if (SATA_WRITE_CACHE_SUPPORTED(new_sdinfo.satadrv_id)) {
16655 if ((sdinfo->satadrv_settings & SATA_DEV_WRITE_CACHE) &&
16656 !SATA_WRITE_CACHE_ENABLED(new_sdinfo.satadrv_id)) {
16657 /* Enable write cache */
16658 cache_op = SATAC_SF_ENABLE_WRITE_CACHE;
16659 SATADBG1(SATA_DBG_DEV_SETTINGS, sata_hba_inst,
16660 "enabling write cache\n", NULL);
16661 } else if (!(sdinfo->satadrv_settings & SATA_DEV_WRITE_CACHE) &&
16662 SATA_WRITE_CACHE_ENABLED(new_sdinfo.satadrv_id)) {
16663 /* Disable write cache */
16664 cache_op = SATAC_SF_DISABLE_WRITE_CACHE;
16665 SATADBG1(SATA_DBG_DEV_SETTINGS, sata_hba_inst,
16666 "disabling write cache\n", NULL);
16667 }
16668
16669 if (cache_op != 0) {
16670 /* Try to set write cache mode */
16671 rval_set = sata_set_cache_mode(sata_hba_inst,
16672 &new_sdinfo, cache_op);
16673 if (rval != SATA_FAILURE && rval_set != SATA_SUCCESS)
16674 rval = rval_set;
16675 }
16676 }
16677 if (rval != SATA_SUCCESS)
16678 SATA_LOG_D((sata_hba_inst, CE_WARN,
16679 "%s %s", finfo, finfox));
16680
16681 update_sdinfo:
16682 /*
16683 * We need to fetch Device Identify data again
16684 */
16685 if (sata_fetch_device_identify_data(sata_hba_inst, &new_sdinfo) != 0) {
16686 /*
16687 * Cannot get device identification - retry later
16688 */
16689 SATA_LOG_D((sata_hba_inst, CE_WARN,
16690 "%s re-fetch device identify data\n", finfo));
16691 rval = SATA_FAILURE;
16692 }
16693 /* Copy device sata info. */
16694 sdinfo->satadrv_id = new_sdinfo.satadrv_id;
16695
16696 return (rval);
16697 }
16698
16699
16700 /*
16701 *
16702 * Returns 1 if threshold exceeded, 0 if threshold not exceeded, -1 if
16703 * unable to determine.
16704 *
16705 * Cannot be called in an interrupt context.
16706 *
16707 * Called by sata_build_lsense_page_2f()
16708 */
16709
16710 static int
16711 sata_fetch_smart_return_status(sata_hba_inst_t *sata_hba_inst,
16712 sata_drive_info_t *sdinfo)
16713 {
16714 sata_pkt_t *spkt;
16715 sata_cmd_t *scmd;
16716 sata_pkt_txlate_t *spx;
16717 int rval;
16718
16719 spx = kmem_zalloc(sizeof (sata_pkt_txlate_t), KM_SLEEP);
16720 spx->txlt_sata_hba_inst = sata_hba_inst;
16721 spx->txlt_scsi_pkt = NULL; /* No scsi pkt involved */
16722 spkt = sata_pkt_alloc(spx, SLEEP_FUNC);
16723 if (spkt == NULL) {
16724 kmem_free(spx, sizeof (sata_pkt_txlate_t));
16725 return (-1);
16726 }
16727 /* address is needed now */
16728 spkt->satapkt_device.satadev_addr = sdinfo->satadrv_addr;
16729
16730
16731 /* Fill sata_pkt */
16732 spkt->satapkt_device.satadev_addr = sdinfo->satadrv_addr;
16733 spkt->satapkt_op_mode = SATA_OPMODE_SYNCH | SATA_OPMODE_INTERRUPTS;
16734 /* Synchronous mode, no callback */
16735 spkt->satapkt_comp = NULL;
16736 /* Timeout 30s */
16737 spkt->satapkt_time = sata_default_pkt_time;
16738
16739 scmd = &spkt->satapkt_cmd;
16740 scmd->satacmd_flags.sata_special_regs = B_TRUE;
16741 scmd->satacmd_flags.sata_data_direction = SATA_DIR_NODATA_XFER;
16742
16743 /* Set up which registers need to be returned */
16744 scmd->satacmd_flags.sata_copy_out_lba_mid_lsb = B_TRUE;
16745 scmd->satacmd_flags.sata_copy_out_lba_high_lsb = B_TRUE;
16746
16747 /* Build SMART_RETURN_STATUS cmd in the sata_pkt */
16748 scmd->satacmd_addr_type = 0; /* N/A */
16749 scmd->satacmd_sec_count_lsb = 0; /* N/A */
16750 scmd->satacmd_lba_low_lsb = 0; /* N/A */
16751 scmd->satacmd_lba_mid_lsb = SMART_MAGIC_VAL_1;
16752 scmd->satacmd_lba_high_lsb = SMART_MAGIC_VAL_2;
16753 scmd->satacmd_features_reg = SATA_SMART_RETURN_STATUS;
16754 scmd->satacmd_device_reg = 0; /* Always device 0 */
16755 scmd->satacmd_cmd_reg = SATAC_SMART;
16756 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst,
16757 sdinfo->satadrv_addr.cport)));
16758
16759
16760 /* Send pkt to SATA HBA driver */
16761 if ((*SATA_START_FUNC(sata_hba_inst))(SATA_DIP(sata_hba_inst), spkt) !=
16762 SATA_TRAN_ACCEPTED ||
16763 spkt->satapkt_reason != SATA_PKT_COMPLETED) {
16764 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst,
16765 sdinfo->satadrv_addr.cport)));
16766 /*
16767 * Whoops, no SMART RETURN STATUS
16768 */
16769 rval = -1;
16770 } else {
16771 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst,
16772 sdinfo->satadrv_addr.cport)));
16773 if (scmd->satacmd_error_reg & SATA_ERROR_ABORT) {
16774 rval = -1;
16775 goto fail;
16776 }
16777 if (scmd->satacmd_status_reg & SATA_STATUS_ERR) {
16778 rval = -1;
16779 goto fail;
16780 }
16781 if ((scmd->satacmd_lba_mid_lsb == SMART_MAGIC_VAL_1) &&
16782 (scmd->satacmd_lba_high_lsb == SMART_MAGIC_VAL_2))
16783 rval = 0;
16784 else if ((scmd->satacmd_lba_mid_lsb == SMART_MAGIC_VAL_3) &&
16785 (scmd->satacmd_lba_high_lsb == SMART_MAGIC_VAL_4))
16786 rval = 1;
16787 else {
16788 rval = -1;
16789 goto fail;
16790 }
16791 }
16792 fail:
16793 /* Free allocated resources */
16794 sata_pkt_free(spx);
16795 kmem_free(spx, sizeof (sata_pkt_txlate_t));
16796
16797 return (rval);
16798 }
16799
16800 /*
16801 *
16802 * Returns 0 if succeeded, -1 otherwise
16803 *
16804 * Cannot be called in an interrupt context.
16805 *
16806 */
16807 static int
16808 sata_fetch_smart_data(
16809 sata_hba_inst_t *sata_hba_inst,
16810 sata_drive_info_t *sdinfo,
16811 struct smart_data *smart_data)
16812 {
16813 sata_pkt_t *spkt;
16814 sata_cmd_t *scmd;
16815 sata_pkt_txlate_t *spx;
16816 int rval;
16817 dev_info_t *dip = SATA_DIP(sata_hba_inst);
16818
16819 #if ! defined(lint)
16820 ASSERT(sizeof (struct smart_data) == 512);
16821 #endif
16822
16823 spx = kmem_zalloc(sizeof (sata_pkt_txlate_t), KM_SLEEP);
16824 spx->txlt_sata_hba_inst = sata_hba_inst;
16825 spx->txlt_scsi_pkt = NULL; /* No scsi pkt involved */
16826 spkt = sata_pkt_alloc(spx, SLEEP_FUNC);
16827 if (spkt == NULL) {
16828 kmem_free(spx, sizeof (sata_pkt_txlate_t));
16829 return (-1);
16830 }
16831 /* address is needed now */
16832 spkt->satapkt_device.satadev_addr = sdinfo->satadrv_addr;
16833
16834
16835 /* Fill sata_pkt */
16836 spkt->satapkt_device.satadev_addr = sdinfo->satadrv_addr;
16837 spkt->satapkt_op_mode = SATA_OPMODE_SYNCH | SATA_OPMODE_INTERRUPTS;
16838 /* Synchronous mode, no callback */
16839 spkt->satapkt_comp = NULL;
16840 /* Timeout 30s */
16841 spkt->satapkt_time = sata_default_pkt_time;
16842
16843 scmd = &spkt->satapkt_cmd;
16844 scmd->satacmd_flags.sata_data_direction = SATA_DIR_READ;
16845
16846 /*
16847 * Allocate buffer for SMART data
16848 */
16849 scmd->satacmd_bp = sata_alloc_local_buffer(spx,
16850 sizeof (struct smart_data));
16851 if (scmd->satacmd_bp == NULL) {
16852 sata_pkt_free(spx);
16853 kmem_free(spx, sizeof (sata_pkt_txlate_t));
16854 SATA_LOG_D((sata_hba_inst, CE_WARN,
16855 "sata_fetch_smart_data: "
16856 "cannot allocate buffer"));
16857 return (-1);
16858 }
16859
16860
16861 /* Build SMART_READ_DATA cmd in the sata_pkt */
16862 scmd->satacmd_addr_type = 0; /* N/A */
16863 scmd->satacmd_sec_count_lsb = 0; /* N/A */
16864 scmd->satacmd_lba_low_lsb = 0; /* N/A */
16865 scmd->satacmd_lba_mid_lsb = SMART_MAGIC_VAL_1;
16866 scmd->satacmd_lba_high_lsb = SMART_MAGIC_VAL_2;
16867 scmd->satacmd_features_reg = SATA_SMART_READ_DATA;
16868 scmd->satacmd_device_reg = 0; /* Always device 0 */
16869 scmd->satacmd_cmd_reg = SATAC_SMART;
16870 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst,
16871 sdinfo->satadrv_addr.cport)));
16872
16873 /* Send pkt to SATA HBA driver */
16874 if ((*SATA_START_FUNC(sata_hba_inst))(SATA_DIP(sata_hba_inst), spkt) !=
16875 SATA_TRAN_ACCEPTED ||
16876 spkt->satapkt_reason != SATA_PKT_COMPLETED) {
16877 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst,
16878 sdinfo->satadrv_addr.cport)));
16879 /*
16880 * Whoops, no SMART DATA available
16881 */
16882 rval = -1;
16883 goto fail;
16884 } else {
16885 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst,
16886 sdinfo->satadrv_addr.cport)));
16887 if (spx->txlt_buf_dma_handle != NULL) {
16888 rval = ddi_dma_sync(spx->txlt_buf_dma_handle, 0, 0,
16889 DDI_DMA_SYNC_FORKERNEL);
16890 ASSERT(rval == DDI_SUCCESS);
16891 if (sata_check_for_dma_error(dip, spx)) {
16892 ddi_fm_service_impact(dip,
16893 DDI_SERVICE_UNAFFECTED);
16894 rval = -1;
16895 goto fail;
16896 }
16897 }
16898 bcopy(scmd->satacmd_bp->b_un.b_addr, (uint8_t *)smart_data,
16899 sizeof (struct smart_data));
16900 }
16901
16902 fail:
16903 /* Free allocated resources */
16904 sata_free_local_buffer(spx);
16905 sata_pkt_free(spx);
16906 kmem_free(spx, sizeof (sata_pkt_txlate_t));
16907
16908 return (rval);
16909 }
16910
16911 /*
16912 * Used by LOG SENSE page 0x10
16913 * Reads (in synchronous mode) the self test log data using Read Log Ext cmd.
16914 * Note: cannot be called in the interrupt context.
16915 *
16916 * return 0 for success, -1 otherwise
16917 *
16918 */
16919 static int
16920 sata_ext_smart_selftest_read_log(
16921 sata_hba_inst_t *sata_hba_inst,
16922 sata_drive_info_t *sdinfo,
16923 struct smart_ext_selftest_log *ext_selftest_log,
16924 uint16_t block_num)
16925 {
16926 sata_pkt_txlate_t *spx;
16927 sata_pkt_t *spkt;
16928 sata_cmd_t *scmd;
16929 int rval;
16930 dev_info_t *dip = SATA_DIP(sata_hba_inst);
16931
16932 #if ! defined(lint)
16933 ASSERT(sizeof (struct smart_ext_selftest_log) == 512);
16934 #endif
16935
16936 spx = kmem_zalloc(sizeof (sata_pkt_txlate_t), KM_SLEEP);
16937 spx->txlt_sata_hba_inst = sata_hba_inst;
16938 spx->txlt_scsi_pkt = NULL; /* No scsi pkt involved */
16939 spkt = sata_pkt_alloc(spx, SLEEP_FUNC);
16940 if (spkt == NULL) {
16941 kmem_free(spx, sizeof (sata_pkt_txlate_t));
16942 return (-1);
16943 }
16944 /* address is needed now */
16945 spkt->satapkt_device.satadev_addr = sdinfo->satadrv_addr;
16946
16947
16948 /* Fill sata_pkt */
16949 spkt->satapkt_device.satadev_addr = sdinfo->satadrv_addr;
16950 spkt->satapkt_op_mode = SATA_OPMODE_SYNCH | SATA_OPMODE_INTERRUPTS;
16951 /* Synchronous mode, no callback */
16952 spkt->satapkt_comp = NULL;
16953 /* Timeout 30s */
16954 spkt->satapkt_time = sata_default_pkt_time;
16955
16956 scmd = &spkt->satapkt_cmd;
16957 scmd->satacmd_flags.sata_data_direction = SATA_DIR_READ;
16958
16959 /*
16960 * Allocate buffer for SMART extended self-test log
16961 */
16962 scmd->satacmd_bp = sata_alloc_local_buffer(spx,
16963 sizeof (struct smart_ext_selftest_log));
16964 if (scmd->satacmd_bp == NULL) {
16965 sata_pkt_free(spx);
16966 kmem_free(spx, sizeof (sata_pkt_txlate_t));
16967 SATA_LOG_D((sata_hba_inst, CE_WARN,
16968 "sata_ext_smart_selftest_log: "
16969 "cannot allocate buffer"));
16970 return (-1);
16971 }
16972
16973 /* Build READ LOG EXT w/ extended self-test log cmd in the sata_pkt */
16974 scmd->satacmd_addr_type = ATA_ADDR_LBA48;
16975 scmd->satacmd_sec_count_lsb = 1; /* One sector of selftest log */
16976 scmd->satacmd_sec_count_msb = 0; /* One sector of selftest log */
16977 scmd->satacmd_lba_low_lsb = EXT_SMART_SELFTEST_LOG_PAGE;
16978 scmd->satacmd_lba_low_msb = 0;
16979 scmd->satacmd_lba_mid_lsb = block_num & 0xff;
16980 scmd->satacmd_lba_mid_msb = block_num >> 8;
16981 scmd->satacmd_device_reg = 0; /* Always device 0 */
16982 scmd->satacmd_cmd_reg = SATAC_READ_LOG_EXT;
16983
16984 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst,
16985 sdinfo->satadrv_addr.cport)));
16986
16987 /* Send pkt to SATA HBA driver */
16988 if ((*SATA_START_FUNC(sata_hba_inst))(SATA_DIP(sata_hba_inst), spkt) !=
16989 SATA_TRAN_ACCEPTED ||
16990 spkt->satapkt_reason != SATA_PKT_COMPLETED) {
16991 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst,
16992 sdinfo->satadrv_addr.cport)));
16993
16994 /*
16995 * Whoops, no SMART selftest log info available
16996 */
16997 rval = -1;
16998 goto fail;
16999 } else {
17000 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst,
17001 sdinfo->satadrv_addr.cport)));
17002
17003 if (spx->txlt_buf_dma_handle != NULL) {
17004 rval = ddi_dma_sync(spx->txlt_buf_dma_handle, 0, 0,
17005 DDI_DMA_SYNC_FORKERNEL);
17006 ASSERT(rval == DDI_SUCCESS);
17007 if (sata_check_for_dma_error(dip, spx)) {
17008 ddi_fm_service_impact(dip,
17009 DDI_SERVICE_UNAFFECTED);
17010 rval = -1;
17011 goto fail;
17012 }
17013 }
17014 bcopy(scmd->satacmd_bp->b_un.b_addr,
17015 (uint8_t *)ext_selftest_log,
17016 sizeof (struct smart_ext_selftest_log));
17017 rval = 0;
17018 }
17019
17020 fail:
17021 /* Free allocated resources */
17022 sata_free_local_buffer(spx);
17023 sata_pkt_free(spx);
17024 kmem_free(spx, sizeof (sata_pkt_txlate_t));
17025
17026 return (rval);
17027 }
17028
17029 /*
17030 * Returns 0 for success, -1 otherwise
17031 *
17032 * SMART self-test log data is returned in buffer pointed to by selftest_log
17033 */
17034 static int
17035 sata_smart_selftest_log(
17036 sata_hba_inst_t *sata_hba_inst,
17037 sata_drive_info_t *sdinfo,
17038 struct smart_selftest_log *selftest_log)
17039 {
17040 sata_pkt_t *spkt;
17041 sata_cmd_t *scmd;
17042 sata_pkt_txlate_t *spx;
17043 int rval;
17044 dev_info_t *dip = SATA_DIP(sata_hba_inst);
17045
17046 #if ! defined(lint)
17047 ASSERT(sizeof (struct smart_selftest_log) == 512);
17048 #endif
17049
17050 spx = kmem_zalloc(sizeof (sata_pkt_txlate_t), KM_SLEEP);
17051 spx->txlt_sata_hba_inst = sata_hba_inst;
17052 spx->txlt_scsi_pkt = NULL; /* No scsi pkt involved */
17053 spkt = sata_pkt_alloc(spx, SLEEP_FUNC);
17054 if (spkt == NULL) {
17055 kmem_free(spx, sizeof (sata_pkt_txlate_t));
17056 return (-1);
17057 }
17058 /* address is needed now */
17059 spkt->satapkt_device.satadev_addr = sdinfo->satadrv_addr;
17060
17061
17062 /* Fill sata_pkt */
17063 spkt->satapkt_device.satadev_addr = sdinfo->satadrv_addr;
17064 spkt->satapkt_op_mode = SATA_OPMODE_SYNCH | SATA_OPMODE_INTERRUPTS;
17065 /* Synchronous mode, no callback */
17066 spkt->satapkt_comp = NULL;
17067 /* Timeout 30s */
17068 spkt->satapkt_time = sata_default_pkt_time;
17069
17070 scmd = &spkt->satapkt_cmd;
17071 scmd->satacmd_flags.sata_data_direction = SATA_DIR_READ;
17072
17073 /*
17074 * Allocate buffer for SMART SELFTEST LOG
17075 */
17076 scmd->satacmd_bp = sata_alloc_local_buffer(spx,
17077 sizeof (struct smart_selftest_log));
17078 if (scmd->satacmd_bp == NULL) {
17079 sata_pkt_free(spx);
17080 kmem_free(spx, sizeof (sata_pkt_txlate_t));
17081 SATA_LOG_D((sata_hba_inst, CE_WARN,
17082 "sata_smart_selftest_log: "
17083 "cannot allocate buffer"));
17084 return (-1);
17085 }
17086
17087 /* Build SMART_READ_LOG cmd in the sata_pkt */
17088 scmd->satacmd_addr_type = 0; /* N/A */
17089 scmd->satacmd_sec_count_lsb = 1; /* One sector of SMART log */
17090 scmd->satacmd_lba_low_lsb = SMART_SELFTEST_LOG_PAGE;
17091 scmd->satacmd_lba_mid_lsb = SMART_MAGIC_VAL_1;
17092 scmd->satacmd_lba_high_lsb = SMART_MAGIC_VAL_2;
17093 scmd->satacmd_features_reg = SATA_SMART_READ_LOG;
17094 scmd->satacmd_device_reg = 0; /* Always device 0 */
17095 scmd->satacmd_cmd_reg = SATAC_SMART;
17096 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst,
17097 sdinfo->satadrv_addr.cport)));
17098
17099 /* Send pkt to SATA HBA driver */
17100 if ((*SATA_START_FUNC(sata_hba_inst))(SATA_DIP(sata_hba_inst), spkt) !=
17101 SATA_TRAN_ACCEPTED ||
17102 spkt->satapkt_reason != SATA_PKT_COMPLETED) {
17103 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst,
17104 sdinfo->satadrv_addr.cport)));
17105 /*
17106 * Whoops, no SMART DATA available
17107 */
17108 rval = -1;
17109 goto fail;
17110 } else {
17111 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst,
17112 sdinfo->satadrv_addr.cport)));
17113 if (spx->txlt_buf_dma_handle != NULL) {
17114 rval = ddi_dma_sync(spx->txlt_buf_dma_handle, 0, 0,
17115 DDI_DMA_SYNC_FORKERNEL);
17116 ASSERT(rval == DDI_SUCCESS);
17117 if (sata_check_for_dma_error(dip, spx)) {
17118 ddi_fm_service_impact(dip,
17119 DDI_SERVICE_UNAFFECTED);
17120 rval = -1;
17121 goto fail;
17122 }
17123 }
17124 bcopy(scmd->satacmd_bp->b_un.b_addr, (uint8_t *)selftest_log,
17125 sizeof (struct smart_selftest_log));
17126 rval = 0;
17127 }
17128
17129 fail:
17130 /* Free allocated resources */
17131 sata_free_local_buffer(spx);
17132 sata_pkt_free(spx);
17133 kmem_free(spx, sizeof (sata_pkt_txlate_t));
17134
17135 return (rval);
17136 }
17137
17138
17139 /*
17140 * Returns 0 for success, -1 otherwise
17141 *
17142 * SMART READ LOG data is returned in buffer pointed to by smart_log
17143 */
17144 static int
17145 sata_smart_read_log(
17146 sata_hba_inst_t *sata_hba_inst,
17147 sata_drive_info_t *sdinfo,
17148 uint8_t *smart_log, /* where the data should be returned */
17149 uint8_t which_log, /* which log should be returned */
17150 uint8_t log_size) /* # of 512 bytes in log */
17151 {
17152 sata_pkt_t *spkt;
17153 sata_cmd_t *scmd;
17154 sata_pkt_txlate_t *spx;
17155 int rval;
17156 dev_info_t *dip = SATA_DIP(sata_hba_inst);
17157
17158 spx = kmem_zalloc(sizeof (sata_pkt_txlate_t), KM_SLEEP);
17159 spx->txlt_sata_hba_inst = sata_hba_inst;
17160 spx->txlt_scsi_pkt = NULL; /* No scsi pkt involved */
17161 spkt = sata_pkt_alloc(spx, SLEEP_FUNC);
17162 if (spkt == NULL) {
17163 kmem_free(spx, sizeof (sata_pkt_txlate_t));
17164 return (-1);
17165 }
17166 /* address is needed now */
17167 spkt->satapkt_device.satadev_addr = sdinfo->satadrv_addr;
17168
17169
17170 /* Fill sata_pkt */
17171 spkt->satapkt_device.satadev_addr = sdinfo->satadrv_addr;
17172 spkt->satapkt_op_mode = SATA_OPMODE_SYNCH | SATA_OPMODE_INTERRUPTS;
17173 /* Synchronous mode, no callback */
17174 spkt->satapkt_comp = NULL;
17175 /* Timeout 30s */
17176 spkt->satapkt_time = sata_default_pkt_time;
17177
17178 scmd = &spkt->satapkt_cmd;
17179 scmd->satacmd_flags.sata_data_direction = SATA_DIR_READ;
17180
17181 /*
17182 * Allocate buffer for SMART READ LOG
17183 */
17184 scmd->satacmd_bp = sata_alloc_local_buffer(spx, log_size * 512);
17185 if (scmd->satacmd_bp == NULL) {
17186 sata_pkt_free(spx);
17187 kmem_free(spx, sizeof (sata_pkt_txlate_t));
17188 SATA_LOG_D((sata_hba_inst, CE_WARN,
17189 "sata_smart_read_log: " "cannot allocate buffer"));
17190 return (-1);
17191 }
17192
17193 /* Build SMART_READ_LOG cmd in the sata_pkt */
17194 scmd->satacmd_addr_type = 0; /* N/A */
17195 scmd->satacmd_sec_count_lsb = log_size; /* what the caller asked for */
17196 scmd->satacmd_lba_low_lsb = which_log; /* which log page */
17197 scmd->satacmd_lba_mid_lsb = SMART_MAGIC_VAL_1;
17198 scmd->satacmd_lba_high_lsb = SMART_MAGIC_VAL_2;
17199 scmd->satacmd_features_reg = SATA_SMART_READ_LOG;
17200 scmd->satacmd_device_reg = 0; /* Always device 0 */
17201 scmd->satacmd_cmd_reg = SATAC_SMART;
17202
17203 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst,
17204 sdinfo->satadrv_addr.cport)));
17205
17206 /* Send pkt to SATA HBA driver */
17207 if ((*SATA_START_FUNC(sata_hba_inst))(SATA_DIP(sata_hba_inst), spkt) !=
17208 SATA_TRAN_ACCEPTED ||
17209 spkt->satapkt_reason != SATA_PKT_COMPLETED) {
17210 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst,
17211 sdinfo->satadrv_addr.cport)));
17212
17213 /*
17214 * Whoops, no SMART DATA available
17215 */
17216 rval = -1;
17217 goto fail;
17218 } else {
17219 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst,
17220 sdinfo->satadrv_addr.cport)));
17221
17222 if (spx->txlt_buf_dma_handle != NULL) {
17223 rval = ddi_dma_sync(spx->txlt_buf_dma_handle, 0, 0,
17224 DDI_DMA_SYNC_FORKERNEL);
17225 ASSERT(rval == DDI_SUCCESS);
17226 if (sata_check_for_dma_error(dip, spx)) {
17227 ddi_fm_service_impact(dip,
17228 DDI_SERVICE_UNAFFECTED);
17229 rval = -1;
17230 goto fail;
17231 }
17232 }
17233 bcopy(scmd->satacmd_bp->b_un.b_addr, smart_log, log_size * 512);
17234 rval = 0;
17235 }
17236
17237 fail:
17238 /* Free allocated resources */
17239 sata_free_local_buffer(spx);
17240 sata_pkt_free(spx);
17241 kmem_free(spx, sizeof (sata_pkt_txlate_t));
17242
17243 return (rval);
17244 }
17245
17246 /*
17247 * Used by LOG SENSE page 0x10
17248 *
17249 * return 0 for success, -1 otherwise
17250 *
17251 */
17252 static int
17253 sata_read_log_ext_directory(
17254 sata_hba_inst_t *sata_hba_inst,
17255 sata_drive_info_t *sdinfo,
17256 struct read_log_ext_directory *logdir)
17257 {
17258 sata_pkt_txlate_t *spx;
17259 sata_pkt_t *spkt;
17260 sata_cmd_t *scmd;
17261 int rval;
17262 dev_info_t *dip = SATA_DIP(sata_hba_inst);
17263
17264 #if ! defined(lint)
17265 ASSERT(sizeof (struct read_log_ext_directory) == 512);
17266 #endif
17267
17268 spx = kmem_zalloc(sizeof (sata_pkt_txlate_t), KM_SLEEP);
17269 spx->txlt_sata_hba_inst = sata_hba_inst;
17270 spx->txlt_scsi_pkt = NULL; /* No scsi pkt involved */
17271 spkt = sata_pkt_alloc(spx, SLEEP_FUNC);
17272 if (spkt == NULL) {
17273 kmem_free(spx, sizeof (sata_pkt_txlate_t));
17274 return (-1);
17275 }
17276
17277 /* Fill sata_pkt */
17278 spkt->satapkt_device.satadev_addr = sdinfo->satadrv_addr;
17279 spkt->satapkt_op_mode = SATA_OPMODE_SYNCH | SATA_OPMODE_INTERRUPTS;
17280 /* Synchronous mode, no callback */
17281 spkt->satapkt_comp = NULL;
17282 /* Timeout 30s */
17283 spkt->satapkt_time = sata_default_pkt_time;
17284
17285 scmd = &spkt->satapkt_cmd;
17286 scmd->satacmd_flags.sata_data_direction = SATA_DIR_READ;
17287
17288 /*
17289 * Allocate buffer for SMART READ LOG EXTENDED command
17290 */
17291 scmd->satacmd_bp = sata_alloc_local_buffer(spx,
17292 sizeof (struct read_log_ext_directory));
17293 if (scmd->satacmd_bp == NULL) {
17294 sata_pkt_free(spx);
17295 kmem_free(spx, sizeof (sata_pkt_txlate_t));
17296 SATA_LOG_D((sata_hba_inst, CE_WARN,
17297 "sata_read_log_ext_directory: "
17298 "cannot allocate buffer"));
17299 return (-1);
17300 }
17301
17302 /* Build READ LOG EXT w/ log directory cmd in the sata_pkt */
17303 scmd->satacmd_addr_type = ATA_ADDR_LBA48;
17304 scmd->satacmd_sec_count_lsb = 1; /* One sector of directory */
17305 scmd->satacmd_sec_count_msb = 0; /* One sector of directory */
17306 scmd->satacmd_lba_low_lsb = READ_LOG_EXT_LOG_DIRECTORY;
17307 scmd->satacmd_lba_low_msb = 0;
17308 scmd->satacmd_lba_mid_lsb = 0;
17309 scmd->satacmd_lba_mid_msb = 0;
17310 scmd->satacmd_device_reg = 0; /* Always device 0 */
17311 scmd->satacmd_cmd_reg = SATAC_READ_LOG_EXT;
17312
17313 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst,
17314 sdinfo->satadrv_addr.cport)));
17315
17316 /* Send pkt to SATA HBA driver */
17317 if ((*SATA_START_FUNC(sata_hba_inst))(SATA_DIP(sata_hba_inst), spkt) !=
17318 SATA_TRAN_ACCEPTED ||
17319 spkt->satapkt_reason != SATA_PKT_COMPLETED) {
17320 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst,
17321 sdinfo->satadrv_addr.cport)));
17322 /*
17323 * Whoops, no SMART selftest log info available
17324 */
17325 rval = -1;
17326 goto fail;
17327 } else {
17328 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst,
17329 sdinfo->satadrv_addr.cport)));
17330 if (spx->txlt_buf_dma_handle != NULL) {
17331 rval = ddi_dma_sync(spx->txlt_buf_dma_handle, 0, 0,
17332 DDI_DMA_SYNC_FORKERNEL);
17333 ASSERT(rval == DDI_SUCCESS);
17334 if (sata_check_for_dma_error(dip, spx)) {
17335 ddi_fm_service_impact(dip,
17336 DDI_SERVICE_UNAFFECTED);
17337 rval = -1;
17338 goto fail;
17339 }
17340 }
17341 bcopy(scmd->satacmd_bp->b_un.b_addr, (uint8_t *)logdir,
17342 sizeof (struct read_log_ext_directory));
17343 rval = 0;
17344 }
17345
17346 fail:
17347 /* Free allocated resources */
17348 sata_free_local_buffer(spx);
17349 sata_pkt_free(spx);
17350 kmem_free(spx, sizeof (sata_pkt_txlate_t));
17351
17352 return (rval);
17353 }
17354
17355 /*
17356 * Set up error retrieval sata command for NCQ command error data
17357 * recovery.
17358 *
17359 * Returns SATA_SUCCESS when data buffer is allocated and packet set-up,
17360 * returns SATA_FAILURE otherwise.
17361 */
17362 static int
17363 sata_ncq_err_ret_cmd_setup(sata_pkt_txlate_t *spx, sata_drive_info_t *sdinfo)
17364 {
17365 #ifndef __lock_lint
17366 _NOTE(ARGUNUSED(sdinfo))
17367 #endif
17368
17369 sata_pkt_t *spkt = spx->txlt_sata_pkt;
17370 sata_cmd_t *scmd;
17371 struct buf *bp;
17372
17373 /* Operation modes are up to the caller */
17374 spkt->satapkt_op_mode = SATA_OPMODE_SYNCH | SATA_OPMODE_INTERRUPTS;
17375
17376 /* Synchronous mode, no callback - may be changed by the caller */
17377 spkt->satapkt_comp = NULL;
17378 spkt->satapkt_time = sata_default_pkt_time;
17379
17380 scmd = &spkt->satapkt_cmd;
17381 bcopy(&sata_rle_cmd, scmd, sizeof (sata_cmd_t));
17382 scmd->satacmd_flags.sata_ignore_dev_reset = B_TRUE;
17383
17384 /*
17385 * Allocate dma_able buffer error data.
17386 * Buffer allocation will take care of buffer alignment and other DMA
17387 * attributes.
17388 */
17389 bp = sata_alloc_local_buffer(spx,
17390 sizeof (struct sata_ncq_error_recovery_page));
17391 if (bp == NULL)
17392 return (SATA_FAILURE);
17393
17394 bp_mapin(bp); /* make data buffer accessible */
17395 scmd->satacmd_bp = bp;
17396
17397 /*
17398 * Set-up pointer to the buffer handle, so HBA can sync buffer
17399 * before accessing it. Handle is in usual place in translate struct.
17400 */
17401 scmd->satacmd_err_ret_buf_handle = &spx->txlt_buf_dma_handle;
17402
17403 ASSERT(scmd->satacmd_num_dma_cookies != 0);
17404 ASSERT(scmd->satacmd_dma_cookie_list != NULL);
17405
17406 return (SATA_SUCCESS);
17407 }
17408
17409 /*
17410 * sata_xlate_errors() is used to translate (S)ATA error
17411 * information to SCSI information returned in the SCSI
17412 * packet.
17413 */
17414 static void
17415 sata_xlate_errors(sata_pkt_txlate_t *spx)
17416 {
17417 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt;
17418 struct scsi_extended_sense *sense;
17419
17420 scsipkt->pkt_reason = CMD_INCOMPLETE;
17421 *scsipkt->pkt_scbp = STATUS_CHECK;
17422 sense = sata_arq_sense(spx);
17423
17424 switch (spx->txlt_sata_pkt->satapkt_reason) {
17425 case SATA_PKT_PORT_ERROR:
17426 /*
17427 * We have no device data. Assume no data transfered.
17428 */
17429 sense->es_key = KEY_HARDWARE_ERROR;
17430 break;
17431
17432 case SATA_PKT_DEV_ERROR:
17433 if (spx->txlt_sata_pkt->satapkt_cmd.satacmd_status_reg &
17434 SATA_STATUS_ERR) {
17435 /*
17436 * determine dev error reason from error
17437 * reg content
17438 */
17439 sata_decode_device_error(spx, sense);
17440 break;
17441 }
17442 /* No extended sense key - no info available */
17443 break;
17444
17445 case SATA_PKT_TIMEOUT:
17446 scsipkt->pkt_reason = CMD_TIMEOUT;
17447 scsipkt->pkt_statistics |= STAT_TIMEOUT | STAT_DEV_RESET;
17448 /* No extended sense key */
17449 break;
17450
17451 case SATA_PKT_ABORTED:
17452 scsipkt->pkt_reason = CMD_ABORTED;
17453 scsipkt->pkt_statistics |= STAT_ABORTED;
17454 /* No extended sense key */
17455 break;
17456
17457 case SATA_PKT_RESET:
17458 /*
17459 * pkt aborted either by an explicit reset request from
17460 * a host, or due to error recovery
17461 */
17462 scsipkt->pkt_reason = CMD_RESET;
17463 scsipkt->pkt_statistics |= STAT_DEV_RESET;
17464 break;
17465
17466 default:
17467 scsipkt->pkt_reason = CMD_TRAN_ERR;
17468 break;
17469 }
17470 }
17471
17472
17473
17474
17475 /*
17476 * Log sata message
17477 * dev pathname msg line preceeds the logged message.
17478 */
17479
17480 static void
17481 sata_log(sata_hba_inst_t *sata_hba_inst, uint_t level, char *fmt, ...)
17482 {
17483 char pathname[128];
17484 dev_info_t *dip = NULL;
17485 va_list ap;
17486
17487 mutex_enter(&sata_log_mutex);
17488
17489 va_start(ap, fmt);
17490 (void) vsprintf(sata_log_buf, fmt, ap);
17491 va_end(ap);
17492
17493 if (sata_hba_inst != NULL) {
17494 dip = SATA_DIP(sata_hba_inst);
17495 (void) ddi_pathname(dip, pathname);
17496 } else {
17497 pathname[0] = 0;
17498 }
17499 if (level == CE_CONT) {
17500 if (sata_debug_flags == 0)
17501 cmn_err(level, "?%s:\n %s\n", pathname, sata_log_buf);
17502 else
17503 cmn_err(level, "%s:\n %s\n", pathname, sata_log_buf);
17504 } else {
17505 if (level != CE_NOTE) {
17506 cmn_err(level, "%s:\n %s", pathname, sata_log_buf);
17507 } else if (sata_msg) {
17508 cmn_err(level, "%s:\n %s", pathname,
17509 sata_log_buf);
17510 }
17511 }
17512
17513 /* sata trace debug */
17514 sata_trace_debug(dip, sata_log_buf);
17515
17516 mutex_exit(&sata_log_mutex);
17517 }
17518
17519
17520 /* ******** Asynchronous HBA events handling & hotplugging support ******** */
17521
17522 /*
17523 * Start or terminate the thread, depending on flag arg and current state
17524 */
17525 static void
17526 sata_event_thread_control(int startstop)
17527 {
17528 static int sata_event_thread_terminating = 0;
17529 static int sata_event_thread_starting = 0;
17530 int i;
17531
17532 mutex_enter(&sata_event_mutex);
17533
17534 if (startstop == 0 && (sata_event_thread_starting == 1 ||
17535 sata_event_thread_terminating == 1)) {
17536 mutex_exit(&sata_event_mutex);
17537 return;
17538 }
17539 if (startstop == 1 && sata_event_thread_starting == 1) {
17540 mutex_exit(&sata_event_mutex);
17541 return;
17542 }
17543 if (startstop == 1 && sata_event_thread_terminating == 1) {
17544 sata_event_thread_starting = 1;
17545 /* wait til terminate operation completes */
17546 i = SATA_EVNT_DAEMON_TERM_WAIT/SATA_EVNT_DAEMON_TERM_TIMEOUT;
17547 while (sata_event_thread_terminating == 1) {
17548 if (i-- <= 0) {
17549 sata_event_thread_starting = 0;
17550 mutex_exit(&sata_event_mutex);
17551 #ifdef SATA_DEBUG
17552 cmn_err(CE_WARN, "sata_event_thread_control: "
17553 "timeout waiting for thread to terminate");
17554 #endif
17555 return;
17556 }
17557 mutex_exit(&sata_event_mutex);
17558 delay(drv_usectohz(SATA_EVNT_DAEMON_TERM_TIMEOUT));
17559 mutex_enter(&sata_event_mutex);
17560 }
17561 }
17562 if (startstop == 1) {
17563 if (sata_event_thread == NULL) {
17564 sata_event_thread = thread_create(NULL, 0,
17565 (void (*)())sata_event_daemon,
17566 &sata_hba_list, 0, &p0, TS_RUN, minclsyspri);
17567 }
17568 sata_event_thread_starting = 0;
17569 mutex_exit(&sata_event_mutex);
17570 return;
17571 }
17572
17573 /*
17574 * If we got here, thread may need to be terminated
17575 */
17576 if (sata_event_thread != NULL) {
17577 int i;
17578 /* Signal event thread to go away */
17579 sata_event_thread_terminating = 1;
17580 sata_event_thread_terminate = 1;
17581 cv_signal(&sata_event_cv);
17582 /*
17583 * Wait til daemon terminates.
17584 */
17585 i = SATA_EVNT_DAEMON_TERM_WAIT/SATA_EVNT_DAEMON_TERM_TIMEOUT;
17586 while (sata_event_thread_terminate == 1) {
17587 mutex_exit(&sata_event_mutex);
17588 if (i-- <= 0) {
17589 /* Daemon did not go away !!! */
17590 #ifdef SATA_DEBUG
17591 cmn_err(CE_WARN, "sata_event_thread_control: "
17592 "cannot terminate event daemon thread");
17593 #endif
17594 mutex_enter(&sata_event_mutex);
17595 break;
17596 }
17597 delay(drv_usectohz(SATA_EVNT_DAEMON_TERM_TIMEOUT));
17598 mutex_enter(&sata_event_mutex);
17599 }
17600 sata_event_thread_terminating = 0;
17601 }
17602 ASSERT(sata_event_thread_terminating == 0);
17603 ASSERT(sata_event_thread_starting == 0);
17604 mutex_exit(&sata_event_mutex);
17605 }
17606
17607
17608 /*
17609 * SATA HBA event notification function.
17610 * Events reported by SATA HBA drivers per HBA instance relate to a change in
17611 * a port and/or device state or a controller itself.
17612 * Events for different addresses/addr types cannot be combined.
17613 * A warning message is generated for each event type.
17614 * Events are not processed by this function, so only the
17615 * event flag(s)is set for an affected entity and the event thread is
17616 * waken up. Event daemon thread processes all events.
17617 *
17618 * NOTE: Since more than one event may be reported at the same time, one
17619 * cannot determine a sequence of events when opposite event are reported, eg.
17620 * LINK_LOST and LINK_ESTABLISHED. Actual port status during event processing
17621 * is taking precedence over reported events, i.e. may cause ignoring some
17622 * events.
17623 */
17624 #define SATA_EVENT_MAX_MSG_LENGTH 79
17625
17626 void
17627 sata_hba_event_notify(dev_info_t *dip, sata_device_t *sata_device, int event)
17628 {
17629 sata_hba_inst_t *sata_hba_inst = NULL;
17630 sata_address_t *saddr;
17631 sata_pmult_info_t *pmultinfo;
17632 sata_drive_info_t *sdinfo;
17633 sata_port_stats_t *pstats;
17634 sata_cport_info_t *cportinfo;
17635 sata_pmport_info_t *pmportinfo;
17636 int cport, pmport;
17637 char buf1[SATA_EVENT_MAX_MSG_LENGTH + 1];
17638 char buf2[SATA_EVENT_MAX_MSG_LENGTH + 1];
17639 char *lcp;
17640 static char *err_msg_evnt_1 =
17641 "sata_hba_event_notify: invalid port event 0x%x ";
17642 static char *err_msg_evnt_2 =
17643 "sata_hba_event_notify: invalid device event 0x%x ";
17644 int linkevent;
17645
17646 /*
17647 * There is a possibility that an event will be generated on HBA
17648 * that has not completed attachment or is detaching. We still want
17649 * to process events until HBA is detached.
17650 */
17651 mutex_enter(&sata_mutex);
17652 for (sata_hba_inst = sata_hba_list; sata_hba_inst != NULL;
17653 sata_hba_inst = sata_hba_inst->satahba_next) {
17654 if (SATA_DIP(sata_hba_inst) == dip)
17655 if (sata_hba_inst->satahba_attached == 1)
17656 break;
17657 }
17658 mutex_exit(&sata_mutex);
17659 if (sata_hba_inst == NULL)
17660 /* HBA not attached */
17661 return;
17662
17663 ASSERT(sata_device != NULL);
17664
17665 /*
17666 * Validate address before - do not proceed with invalid address.
17667 */
17668 saddr = &sata_device->satadev_addr;
17669 if (saddr->cport >= SATA_NUM_CPORTS(sata_hba_inst))
17670 return;
17671
17672 cport = saddr->cport;
17673 pmport = saddr->pmport;
17674
17675 buf1[0] = buf2[0] = '\0';
17676
17677 /*
17678 * If event relates to port or device, check port state.
17679 * Port has to be initialized, or we cannot accept an event.
17680 */
17681 if ((saddr->qual & (SATA_ADDR_CPORT | SATA_ADDR_PMPORT |
17682 SATA_ADDR_DCPORT | SATA_ADDR_DPMPORT | SATA_ADDR_PMULT)) != 0) {
17683 mutex_enter(&sata_hba_inst->satahba_mutex);
17684 cportinfo = SATA_CPORT_INFO(sata_hba_inst, cport);
17685 mutex_exit(&sata_hba_inst->satahba_mutex);
17686 if (cportinfo == NULL || cportinfo->cport_state == 0)
17687 return;
17688 }
17689
17690 if ((saddr->qual & (SATA_ADDR_PMULT | SATA_ADDR_PMPORT |
17691 SATA_ADDR_DPMPORT)) != 0) {
17692 if (cportinfo->cport_dev_type != SATA_DTYPE_PMULT) {
17693 SATA_LOG_D((sata_hba_inst, CE_WARN,
17694 "sata_hba_event_notify: Non-pmult device (0x%x)"
17695 "is attached to port %d, ignore pmult/pmport "
17696 "event 0x%x", cportinfo->cport_dev_type,
17697 cport, event));
17698 return;
17699 }
17700
17701 mutex_enter(&cportinfo->cport_mutex);
17702 pmultinfo = SATA_PMULT_INFO(sata_hba_inst, cport);
17703 mutex_exit(&cportinfo->cport_mutex);
17704
17705 /*
17706 * The daemon might be processing attachment of port
17707 * multiplier, in that case we should ignore events on its
17708 * sub-devices.
17709 *
17710 * NOTE: Only pmult_state is checked in sata_hba_event_notify.
17711 * The pmport_state is checked by sata daemon.
17712 */
17713 if (pmultinfo == NULL ||
17714 pmultinfo->pmult_state == SATA_STATE_UNKNOWN) {
17715 SATA_LOG_D((sata_hba_inst, CE_WARN,
17716 "sata_hba_event_notify: pmult is not"
17717 "available at port %d:%d, ignore event 0x%x",
17718 cport, pmport, event));
17719 return;
17720 }
17721 }
17722
17723 if ((saddr->qual &
17724 (SATA_ADDR_PMPORT | SATA_ADDR_DPMPORT)) != 0) {
17725
17726 mutex_enter(&cportinfo->cport_mutex);
17727 if (pmport > SATA_NUM_PMPORTS(sata_hba_inst, cport)) {
17728 SATA_LOG_D((sata_hba_inst, CE_WARN,
17729 "sata_hba_event_notify: invalid/"
17730 "un-implemented port %d:%d (%d ports), "
17731 "ignore event 0x%x", cport, pmport,
17732 SATA_NUM_PMPORTS(sata_hba_inst, cport), event));
17733 mutex_exit(&cportinfo->cport_mutex);
17734 return;
17735 }
17736 mutex_exit(&cportinfo->cport_mutex);
17737
17738 mutex_enter(&sata_hba_inst->satahba_mutex);
17739 pmportinfo = SATA_PMPORT_INFO(sata_hba_inst,
17740 cport, pmport);
17741 mutex_exit(&sata_hba_inst->satahba_mutex);
17742
17743 /* pmport is implemented/valid? */
17744 if (pmportinfo == NULL) {
17745 SATA_LOG_D((sata_hba_inst, CE_WARN,
17746 "sata_hba_event_notify: invalid/"
17747 "un-implemented port %d:%d, ignore "
17748 "event 0x%x", cport, pmport, event));
17749 return;
17750 }
17751 }
17752
17753 /*
17754 * Events refer to devices, ports and controllers - each has
17755 * unique address. Events for different addresses cannot be combined.
17756 */
17757 if (saddr->qual & (SATA_ADDR_CPORT | SATA_ADDR_PMPORT)) {
17758
17759 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, cport)));
17760
17761 /* qualify this event(s) */
17762 if ((event & SATA_EVNT_PORT_EVENTS) == 0) {
17763 /* Invalid event for the device port */
17764 (void) sprintf(buf2, err_msg_evnt_1,
17765 event & SATA_EVNT_PORT_EVENTS);
17766 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, cport)));
17767 goto event_info;
17768 }
17769 if (saddr->qual == SATA_ADDR_CPORT) {
17770 /* Controller's device port event */
17771
17772 (SATA_CPORT_INFO(sata_hba_inst, cport))->
17773 cport_event_flags |=
17774 event & SATA_EVNT_PORT_EVENTS;
17775 pstats =
17776 &(SATA_CPORT_INFO(sata_hba_inst, cport))->
17777 cport_stats;
17778 } else {
17779 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, cport)));
17780 mutex_enter(&pmportinfo->pmport_mutex);
17781 /* Port multiplier's device port event */
17782 (SATA_PMPORT_INFO(sata_hba_inst, cport, pmport))->
17783 pmport_event_flags |=
17784 event & SATA_EVNT_PORT_EVENTS;
17785 pstats =
17786 &(SATA_PMPORT_INFO(sata_hba_inst, cport, pmport))->
17787 pmport_stats;
17788 mutex_exit(&pmportinfo->pmport_mutex);
17789 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, cport)));
17790 }
17791
17792 /*
17793 * Add to statistics and log the message. We have to do it
17794 * here rather than in the event daemon, because there may be
17795 * multiple events occuring before they are processed.
17796 */
17797 linkevent = event &
17798 (SATA_EVNT_LINK_LOST | SATA_EVNT_LINK_ESTABLISHED);
17799 if (linkevent) {
17800 if (linkevent == (SATA_EVNT_LINK_LOST |
17801 SATA_EVNT_LINK_ESTABLISHED)) {
17802 /* This is likely event combination */
17803 (void) strlcat(buf1, "link lost/established, ",
17804 SATA_EVENT_MAX_MSG_LENGTH);
17805
17806 if (pstats->link_lost < 0xffffffffffffffffULL)
17807 pstats->link_lost++;
17808 if (pstats->link_established <
17809 0xffffffffffffffffULL)
17810 pstats->link_established++;
17811 linkevent = 0;
17812 } else if (linkevent & SATA_EVNT_LINK_LOST) {
17813 (void) strlcat(buf1, "link lost, ",
17814 SATA_EVENT_MAX_MSG_LENGTH);
17815
17816 if (pstats->link_lost < 0xffffffffffffffffULL)
17817 pstats->link_lost++;
17818 } else {
17819 (void) strlcat(buf1, "link established, ",
17820 SATA_EVENT_MAX_MSG_LENGTH);
17821 if (pstats->link_established <
17822 0xffffffffffffffffULL)
17823 pstats->link_established++;
17824 }
17825 }
17826 if (event & SATA_EVNT_DEVICE_ATTACHED) {
17827 (void) strlcat(buf1, "device attached, ",
17828 SATA_EVENT_MAX_MSG_LENGTH);
17829 if (pstats->device_attached < 0xffffffffffffffffULL)
17830 pstats->device_attached++;
17831 }
17832 if (event & SATA_EVNT_DEVICE_DETACHED) {
17833 (void) strlcat(buf1, "device detached, ",
17834 SATA_EVENT_MAX_MSG_LENGTH);
17835 if (pstats->device_detached < 0xffffffffffffffffULL)
17836 pstats->device_detached++;
17837 }
17838 if (event & SATA_EVNT_PWR_LEVEL_CHANGED) {
17839 SATADBG1(SATA_DBG_EVENTS, sata_hba_inst,
17840 "port %d power level changed", cport);
17841 if (pstats->port_pwr_changed < 0xffffffffffffffffULL)
17842 pstats->port_pwr_changed++;
17843 }
17844
17845 if ((event & ~SATA_EVNT_PORT_EVENTS) != 0) {
17846 /* There should be no other events for this address */
17847 (void) sprintf(buf2, err_msg_evnt_1,
17848 event & ~SATA_EVNT_PORT_EVENTS);
17849 }
17850 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, cport)));
17851
17852 } else if (saddr->qual & (SATA_ADDR_DCPORT | SATA_ADDR_DPMPORT)) {
17853 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, cport)));
17854
17855 /* qualify this event */
17856 if ((event & SATA_EVNT_DEVICE_RESET) == 0) {
17857 /* Invalid event for a device */
17858 (void) sprintf(buf2, err_msg_evnt_2,
17859 event & SATA_EVNT_DEVICE_RESET);
17860 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, cport)));
17861 goto event_info;
17862 }
17863 /* drive event */
17864 sdinfo = sata_get_device_info(sata_hba_inst, sata_device);
17865 if (sdinfo != NULL) {
17866 if (event & SATA_EVNT_DEVICE_RESET) {
17867 (void) strlcat(buf1, "device reset, ",
17868 SATA_EVENT_MAX_MSG_LENGTH);
17869 if (sdinfo->satadrv_stats.drive_reset <
17870 0xffffffffffffffffULL)
17871 sdinfo->satadrv_stats.drive_reset++;
17872 sdinfo->satadrv_event_flags |=
17873 SATA_EVNT_DEVICE_RESET;
17874 }
17875 }
17876 if ((event & ~SATA_EVNT_DEVICE_RESET) != 0) {
17877 /* Invalid event for a device */
17878 (void) sprintf(buf2, err_msg_evnt_2,
17879 event & ~SATA_EVNT_DRIVE_EVENTS);
17880 }
17881 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, cport)));
17882 } else if (saddr->qual == SATA_ADDR_PMULT) {
17883 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, cport)));
17884
17885 /* qualify this event */
17886 if ((event & (SATA_EVNT_DEVICE_RESET |
17887 SATA_EVNT_PMULT_LINK_CHANGED)) == 0) {
17888 /* Invalid event for a port multiplier */
17889 (void) sprintf(buf2, err_msg_evnt_2,
17890 event & SATA_EVNT_DEVICE_RESET);
17891 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, cport)));
17892 goto event_info;
17893 }
17894
17895 pmultinfo = SATA_PMULT_INFO(sata_hba_inst, cport);
17896
17897 if (event & SATA_EVNT_DEVICE_RESET) {
17898
17899 SATADBG1(SATA_DBG_PMULT, sata_hba_inst,
17900 "[Reset] port-mult on cport %d", cport);
17901 pmultinfo->pmult_event_flags |=
17902 SATA_EVNT_DEVICE_RESET;
17903 (void) strlcat(buf1, "pmult reset, ",
17904 SATA_EVENT_MAX_MSG_LENGTH);
17905 }
17906
17907 if (event & SATA_EVNT_PMULT_LINK_CHANGED) {
17908
17909 SATADBG1(SATA_DBG_PMULT, sata_hba_inst,
17910 "pmult link changed on cport %d", cport);
17911 pmultinfo->pmult_event_flags |=
17912 SATA_EVNT_PMULT_LINK_CHANGED;
17913 (void) strlcat(buf1, "pmult link changed, ",
17914 SATA_EVENT_MAX_MSG_LENGTH);
17915 }
17916 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, cport)));
17917
17918 } else {
17919 if (saddr->qual != SATA_ADDR_NULL) {
17920 /* Wrong address qualifier */
17921 SATA_LOG_D((sata_hba_inst, CE_WARN,
17922 "sata_hba_event_notify: invalid address 0x%x",
17923 *(uint32_t *)saddr));
17924 return;
17925 }
17926 if ((event & SATA_EVNT_CONTROLLER_EVENTS) == 0 ||
17927 (event & ~SATA_EVNT_CONTROLLER_EVENTS) != 0) {
17928 /* Invalid event for the controller */
17929 SATA_LOG_D((sata_hba_inst, CE_WARN,
17930 "sata_hba_event_notify: invalid event 0x%x for "
17931 "controller",
17932 event & SATA_EVNT_CONTROLLER_EVENTS));
17933 return;
17934 }
17935 buf1[0] = '\0';
17936 /* This may be a frequent and not interesting event */
17937 SATADBG1(SATA_DBG_EVENTS, sata_hba_inst,
17938 "controller power level changed\n", NULL);
17939
17940 mutex_enter(&sata_hba_inst->satahba_mutex);
17941 if (sata_hba_inst->satahba_stats.ctrl_pwr_change <
17942 0xffffffffffffffffULL)
17943 sata_hba_inst->satahba_stats.ctrl_pwr_change++;
17944
17945 sata_hba_inst->satahba_event_flags |=
17946 SATA_EVNT_PWR_LEVEL_CHANGED;
17947 mutex_exit(&sata_hba_inst->satahba_mutex);
17948 }
17949 /*
17950 * If we got here, there is something to do with this HBA
17951 * instance.
17952 */
17953 mutex_enter(&sata_hba_inst->satahba_mutex);
17954 sata_hba_inst->satahba_event_flags |= SATA_EVNT_MAIN;
17955 mutex_exit(&sata_hba_inst->satahba_mutex);
17956 mutex_enter(&sata_mutex);
17957 sata_event_pending |= SATA_EVNT_MAIN; /* global event indicator */
17958 mutex_exit(&sata_mutex);
17959
17960 /* Tickle event thread */
17961 mutex_enter(&sata_event_mutex);
17962 if (sata_event_thread_active == 0)
17963 cv_signal(&sata_event_cv);
17964 mutex_exit(&sata_event_mutex);
17965
17966 event_info:
17967 if (buf1[0] != '\0') {
17968 lcp = strrchr(buf1, ',');
17969 if (lcp != NULL)
17970 *lcp = '\0';
17971 }
17972 if (saddr->qual == SATA_ADDR_CPORT ||
17973 saddr->qual == SATA_ADDR_DCPORT) {
17974 if (buf1[0] != '\0') {
17975 sata_log(sata_hba_inst, CE_NOTE, "port %d: %s\n",
17976 cport, buf1);
17977 }
17978 if (buf2[0] != '\0') {
17979 sata_log(sata_hba_inst, CE_NOTE, "port %d: %s\n",
17980 cport, buf2);
17981 }
17982 } else if (saddr->qual == SATA_ADDR_PMPORT ||
17983 saddr->qual == SATA_ADDR_DPMPORT) {
17984 if (buf1[0] != '\0') {
17985 sata_log(sata_hba_inst, CE_NOTE,
17986 "port %d pmport %d: %s\n", cport, pmport, buf1);
17987 }
17988 if (buf2[0] != '\0') {
17989 sata_log(sata_hba_inst, CE_NOTE,
17990 "port %d pmport %d: %s\n", cport, pmport, buf2);
17991 }
17992 }
17993 }
17994
17995
17996 /*
17997 * Event processing thread.
17998 * Arg is a pointer to the sata_hba_list pointer.
17999 * It is not really needed, because sata_hba_list is global and static
18000 */
18001 static void
18002 sata_event_daemon(void *arg)
18003 {
18004 #ifndef __lock_lint
18005 _NOTE(ARGUNUSED(arg))
18006 #endif
18007 sata_hba_inst_t *sata_hba_inst;
18008 clock_t delta;
18009
18010 SATADBG1(SATA_DBG_EVENTS_DAEMON, NULL,
18011 "SATA event daemon started\n", NULL);
18012 loop:
18013 /*
18014 * Process events here. Walk through all registered HBAs
18015 */
18016 mutex_enter(&sata_mutex);
18017 for (sata_hba_inst = sata_hba_list; sata_hba_inst != NULL;
18018 sata_hba_inst = sata_hba_inst->satahba_next) {
18019 ASSERT(sata_hba_inst != NULL);
18020 mutex_enter(&sata_hba_inst->satahba_mutex);
18021 if (sata_hba_inst->satahba_attached == 0 ||
18022 (sata_hba_inst->satahba_event_flags &
18023 SATA_EVNT_SKIP) != 0) {
18024 mutex_exit(&sata_hba_inst->satahba_mutex);
18025 continue;
18026 }
18027 if (sata_hba_inst->satahba_event_flags & SATA_EVNT_MAIN) {
18028 sata_hba_inst->satahba_event_flags |= SATA_EVNT_SKIP;
18029 mutex_exit(&sata_hba_inst->satahba_mutex);
18030 mutex_exit(&sata_mutex);
18031 /* Got the controller with pending event */
18032 sata_process_controller_events(sata_hba_inst);
18033 /*
18034 * Since global mutex was released, there is a
18035 * possibility that HBA list has changed, so start
18036 * over from the top. Just processed controller
18037 * will be passed-over because of the SKIP flag.
18038 */
18039 goto loop;
18040 }
18041 mutex_exit(&sata_hba_inst->satahba_mutex);
18042 }
18043 /* Clear SKIP flag in all controllers */
18044 for (sata_hba_inst = sata_hba_list; sata_hba_inst != NULL;
18045 sata_hba_inst = sata_hba_inst->satahba_next) {
18046 mutex_enter(&sata_hba_inst->satahba_mutex);
18047 sata_hba_inst->satahba_event_flags &= ~SATA_EVNT_SKIP;
18048 mutex_exit(&sata_hba_inst->satahba_mutex);
18049 }
18050 mutex_exit(&sata_mutex);
18051
18052 SATADBG1(SATA_DBG_EVENTS_DAEMON, NULL,
18053 "SATA EVENT DAEMON suspending itself", NULL);
18054
18055 #ifdef SATA_DEBUG
18056 if ((sata_func_enable & SATA_ENABLE_PROCESS_EVENTS) == 0) {
18057 sata_log(sata_hba_inst, CE_WARN,
18058 "SATA EVENTS PROCESSING DISABLED\n");
18059 thread_exit(); /* Daemon will not run again */
18060 }
18061 #endif
18062 mutex_enter(&sata_event_mutex);
18063 sata_event_thread_active = 0;
18064 mutex_exit(&sata_event_mutex);
18065 /*
18066 * Go to sleep/suspend itself and wake up either because new event or
18067 * wait timeout. Exit if there is a termination request (driver
18068 * unload).
18069 */
18070 delta = drv_usectohz(SATA_EVNT_DAEMON_SLEEP_TIME);
18071 do {
18072 mutex_enter(&sata_event_mutex);
18073 (void) cv_reltimedwait(&sata_event_cv, &sata_event_mutex,
18074 delta, TR_CLOCK_TICK);
18075
18076 if (sata_event_thread_active != 0) {
18077 mutex_exit(&sata_event_mutex);
18078 continue;
18079 }
18080
18081 /* Check if it is time to go away */
18082 if (sata_event_thread_terminate == 1) {
18083 /*
18084 * It is up to the thread setting above flag to make
18085 * sure that this thread is not killed prematurely.
18086 */
18087 sata_event_thread_terminate = 0;
18088 sata_event_thread = NULL;
18089 mutex_exit(&sata_event_mutex);
18090 SATADBG1(SATA_DBG_EVENTS_DAEMON, NULL,
18091 "SATA_EVENT_DAEMON_TERMINATING", NULL);
18092 thread_exit(); { _NOTE(NOT_REACHED) }
18093 }
18094 mutex_exit(&sata_event_mutex);
18095 } while (!(sata_event_pending & SATA_EVNT_MAIN));
18096
18097 mutex_enter(&sata_event_mutex);
18098 sata_event_thread_active = 1;
18099 mutex_exit(&sata_event_mutex);
18100
18101 mutex_enter(&sata_mutex);
18102 sata_event_pending &= ~SATA_EVNT_MAIN;
18103 mutex_exit(&sata_mutex);
18104
18105 SATADBG1(SATA_DBG_EVENTS_DAEMON, NULL,
18106 "SATA EVENT DAEMON READY TO PROCESS EVENT", NULL);
18107
18108 goto loop;
18109 }
18110
18111 /*
18112 * Specific HBA instance event processing.
18113 *
18114 * NOTE: At the moment, device event processing is limited to hard disks
18115 * only.
18116 * Port multiplier is supported now.
18117 */
18118 static void
18119 sata_process_controller_events(sata_hba_inst_t *sata_hba_inst)
18120 {
18121 int ncport;
18122 uint32_t event_flags;
18123 sata_address_t *saddr;
18124 sata_cport_info_t *cportinfo;
18125 sata_pmult_info_t *pmultinfo;
18126
18127 SATADBG1(SATA_DBG_EVENTS_CNTRL, sata_hba_inst,
18128 "Processing controller %d event(s)",
18129 ddi_get_instance(SATA_DIP(sata_hba_inst)));
18130
18131 mutex_enter(&sata_hba_inst->satahba_mutex);
18132 sata_hba_inst->satahba_event_flags &= ~SATA_EVNT_MAIN;
18133 event_flags = sata_hba_inst->satahba_event_flags;
18134 mutex_exit(&sata_hba_inst->satahba_mutex);
18135 /*
18136 * Process controller power change first
18137 * HERE
18138 */
18139 if (event_flags & SATA_EVNT_PWR_LEVEL_CHANGED)
18140 sata_process_cntrl_pwr_level_change(sata_hba_inst);
18141
18142 /*
18143 * Search through ports/devices to identify affected port/device.
18144 * We may have to process events for more than one port/device.
18145 */
18146 for (ncport = 0; ncport < SATA_NUM_CPORTS(sata_hba_inst); ncport++) {
18147 /*
18148 * Not all ports may be processed in attach by the time we
18149 * get an event. Check if port info is initialized.
18150 */
18151 mutex_enter(&sata_hba_inst->satahba_mutex);
18152 cportinfo = SATA_CPORT_INFO(sata_hba_inst, ncport);
18153 mutex_exit(&sata_hba_inst->satahba_mutex);
18154 if (cportinfo == NULL || cportinfo->cport_state == NULL)
18155 continue;
18156
18157 /* We have initialized controller port info */
18158 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, ncport)));
18159 event_flags = (SATA_CPORT_INFO(sata_hba_inst, ncport))->
18160 cport_event_flags;
18161 /* Check if port was locked by IOCTL processing */
18162 if (event_flags & SATA_APCTL_LOCK_PORT_BUSY) {
18163 /*
18164 * We ignore port events because port is busy
18165 * with AP control processing. Set again
18166 * controller and main event flag, so that
18167 * events may be processed by the next daemon
18168 * run.
18169 */
18170 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, ncport)));
18171 mutex_enter(&sata_hba_inst->satahba_mutex);
18172 sata_hba_inst->satahba_event_flags |= SATA_EVNT_MAIN;
18173 mutex_exit(&sata_hba_inst->satahba_mutex);
18174 mutex_enter(&sata_mutex);
18175 sata_event_pending |= SATA_EVNT_MAIN;
18176 mutex_exit(&sata_mutex);
18177 SATADBG1(SATA_DBG_EVENTS_PROCPST, sata_hba_inst,
18178 "Event processing postponed until "
18179 "AP control processing completes",
18180 NULL);
18181 /* Check other ports */
18182 continue;
18183 } else {
18184 /*
18185 * Set BSY flag so that AP control would not
18186 * interfere with events processing for
18187 * this port.
18188 */
18189 (SATA_CPORT_INFO(sata_hba_inst, ncport))->
18190 cport_event_flags |= SATA_EVNT_LOCK_PORT_BUSY;
18191 }
18192 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, ncport)));
18193
18194 saddr = &(SATA_CPORT_INFO(sata_hba_inst, ncport))->cport_addr;
18195
18196 if ((event_flags &
18197 (SATA_EVNT_PORT_EVENTS | SATA_EVNT_DRIVE_EVENTS)) != 0) {
18198 /*
18199 * Got port event.
18200 * We need some hierarchy of event processing as they
18201 * are affecting each other:
18202 * 1. port failed
18203 * 2. device detached/attached
18204 * 3. link events - link events may trigger device
18205 * detached or device attached events in some
18206 * circumstances.
18207 * 4. port power level changed
18208 */
18209 if (event_flags & SATA_EVNT_PORT_FAILED) {
18210 sata_process_port_failed_event(sata_hba_inst,
18211 saddr);
18212 }
18213 if (event_flags & SATA_EVNT_DEVICE_DETACHED) {
18214 sata_process_device_detached(sata_hba_inst,
18215 saddr);
18216 }
18217 if (event_flags & SATA_EVNT_DEVICE_ATTACHED) {
18218 sata_process_device_attached(sata_hba_inst,
18219 saddr);
18220 }
18221 if (event_flags &
18222 (SATA_EVNT_LINK_ESTABLISHED |
18223 SATA_EVNT_LINK_LOST)) {
18224 sata_process_port_link_events(sata_hba_inst,
18225 saddr);
18226 }
18227 if (event_flags & SATA_EVNT_PWR_LEVEL_CHANGED) {
18228 sata_process_port_pwr_change(sata_hba_inst,
18229 saddr);
18230 }
18231 if (event_flags & SATA_EVNT_TARGET_NODE_CLEANUP) {
18232 sata_process_target_node_cleanup(
18233 sata_hba_inst, saddr);
18234 }
18235 if (event_flags & SATA_EVNT_AUTOONLINE_DEVICE) {
18236 sata_process_device_autoonline(
18237 sata_hba_inst, saddr);
18238 }
18239 }
18240
18241
18242 /*
18243 * Scan port multiplier and all its sub-ports event flags.
18244 * The events are marked by
18245 * (1) sata_pmult_info.pmult_event_flags
18246 * (2) sata_pmport_info.pmport_event_flags
18247 */
18248 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, ncport)));
18249 if (cportinfo->cport_dev_type == SATA_DTYPE_PMULT) {
18250 /*
18251 * There should be another extra check: this
18252 * port multiplier still exists?
18253 */
18254 pmultinfo = SATA_PMULT_INFO(sata_hba_inst,
18255 ncport);
18256
18257 if (pmultinfo != NULL) {
18258 mutex_exit(&(SATA_CPORT_MUTEX(
18259 sata_hba_inst, ncport)));
18260 sata_process_pmult_events(
18261 sata_hba_inst, ncport);
18262 mutex_enter(&(SATA_CPORT_MUTEX(
18263 sata_hba_inst, ncport)));
18264 } else {
18265 SATADBG1(SATA_DBG_PMULT, sata_hba_inst,
18266 "Port-multiplier is gone. "
18267 "Ignore all sub-device events "
18268 "at port %d.", ncport);
18269 }
18270 }
18271
18272 if ((SATA_CPORT_DEV_TYPE(sata_hba_inst, ncport) !=
18273 SATA_DTYPE_NONE) &&
18274 (SATA_CPORT_DRV_INFO(sata_hba_inst, ncport) != NULL)) {
18275 if (SATA_CPORT_DRV_INFO(sata_hba_inst, ncport)->
18276 satadrv_event_flags &
18277 (SATA_EVNT_DEVICE_RESET |
18278 SATA_EVNT_INPROC_DEVICE_RESET)) {
18279 /* Have device event */
18280 sata_process_device_reset(sata_hba_inst,
18281 saddr);
18282 }
18283 }
18284 /* Release PORT_BUSY flag */
18285 (SATA_CPORT_INFO(sata_hba_inst, ncport))->
18286 cport_event_flags &= ~SATA_EVNT_LOCK_PORT_BUSY;
18287 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, ncport)));
18288
18289 } /* End of loop through the controller SATA ports */
18290 }
18291
18292 /*
18293 * Specific port multiplier instance event processing. At the moment, device
18294 * event processing is limited to link/attach event only.
18295 *
18296 * NOTE: power management event is not supported yet.
18297 */
18298 static void
18299 sata_process_pmult_events(sata_hba_inst_t *sata_hba_inst, uint8_t cport)
18300 {
18301 sata_cport_info_t *cportinfo = SATA_CPORT_INFO(sata_hba_inst, cport);
18302 sata_pmult_info_t *pmultinfo;
18303 sata_pmport_info_t *pmportinfo;
18304 sata_address_t *saddr;
18305 sata_device_t sata_device;
18306 uint32_t event_flags;
18307 int npmport;
18308 int rval;
18309
18310 SATADBG2(SATA_DBG_EVENTS_CNTRL|SATA_DBG_PMULT, sata_hba_inst,
18311 "Processing pmult event(s) on cport %d of controller %d",
18312 cport, ddi_get_instance(SATA_DIP(sata_hba_inst)));
18313
18314 /* First process events on port multiplier */
18315 mutex_enter(&cportinfo->cport_mutex);
18316 pmultinfo = SATA_PMULT_INFO(sata_hba_inst, cport);
18317 event_flags = pmultinfo->pmult_event_flags;
18318
18319 /*
18320 * Reset event (of port multiplier) has higher priority because the
18321 * port multiplier itself might be failed or removed after reset.
18322 */
18323 if (event_flags & SATA_EVNT_DEVICE_RESET) {
18324 /*
18325 * The status of the sub-links are uncertain,
18326 * so mark all sub-ports as RESET
18327 */
18328 for (npmport = 0; npmport < SATA_NUM_PMPORTS(
18329 sata_hba_inst, cport); npmport ++) {
18330 pmportinfo = SATA_PMPORT_INFO(sata_hba_inst,
18331 cport, npmport);
18332 if (pmportinfo == NULL) {
18333 /* That's weird. */
18334 SATA_LOG_D((sata_hba_inst, CE_WARN,
18335 "sata_hba_event_notify: "
18336 "invalid/un-implemented "
18337 "port %d:%d (%d ports), ",
18338 cport, npmport, SATA_NUM_PMPORTS(
18339 sata_hba_inst, cport)));
18340 continue;
18341 }
18342
18343 mutex_enter(&pmportinfo->pmport_mutex);
18344
18345 /* Mark all pmport to unknow state. */
18346 pmportinfo->pmport_state = SATA_STATE_UNKNOWN;
18347 /* Mark all pmports with link events. */
18348 pmportinfo->pmport_event_flags =
18349 (SATA_EVNT_LINK_ESTABLISHED|SATA_EVNT_LINK_LOST);
18350 mutex_exit(&pmportinfo->pmport_mutex);
18351 }
18352
18353 } else if (event_flags & SATA_EVNT_PMULT_LINK_CHANGED) {
18354 /*
18355 * We need probe the port multiplier to know what has
18356 * happened.
18357 */
18358 bzero(&sata_device, sizeof (sata_device_t));
18359 sata_device.satadev_rev = SATA_DEVICE_REV;
18360 sata_device.satadev_addr.cport = cport;
18361 sata_device.satadev_addr.pmport = SATA_PMULT_HOSTPORT;
18362 sata_device.satadev_addr.qual = SATA_ADDR_PMULT;
18363
18364 mutex_exit(&cportinfo->cport_mutex);
18365 rval = (*SATA_PROBE_PORT_FUNC(sata_hba_inst))
18366 (SATA_DIP(sata_hba_inst), &sata_device);
18367 mutex_enter(&cportinfo->cport_mutex);
18368 if (rval != SATA_SUCCESS) {
18369 /* Something went wrong? Fail the port */
18370 cportinfo->cport_state = SATA_PSTATE_FAILED;
18371 mutex_exit(&cportinfo->cport_mutex);
18372 SATA_LOG_D((sata_hba_inst, CE_WARN,
18373 "SATA port %d probing failed", cport));
18374
18375 /* PMult structure must be released. */
18376 sata_free_pmult(sata_hba_inst, &sata_device);
18377 return;
18378 }
18379
18380 sata_update_port_info(sata_hba_inst, &sata_device);
18381
18382 /*
18383 * Sanity check - Port is active? Is the link active?
18384 * The device is still a port multiplier?
18385 */
18386 if ((cportinfo->cport_state &
18387 (SATA_PSTATE_SHUTDOWN | SATA_PSTATE_FAILED)) ||
18388 ((cportinfo->cport_scr.sstatus &
18389 SATA_PORT_DEVLINK_UP_MASK) != SATA_PORT_DEVLINK_UP) ||
18390 (cportinfo->cport_dev_type != SATA_DTYPE_PMULT)) {
18391 mutex_exit(&cportinfo->cport_mutex);
18392
18393 /* PMult structure must be released. */
18394 sata_free_pmult(sata_hba_inst, &sata_device);
18395 return;
18396 }
18397
18398 /* Probed succeed, set port ready. */
18399 cportinfo->cport_state |=
18400 SATA_STATE_PROBED | SATA_STATE_READY;
18401 }
18402
18403 /* Release port multiplier event flags. */
18404 pmultinfo->pmult_event_flags &=
18405 ~(SATA_EVNT_DEVICE_RESET|SATA_EVNT_PMULT_LINK_CHANGED);
18406 mutex_exit(&cportinfo->cport_mutex);
18407
18408 /*
18409 * Check all sub-links.
18410 */
18411 for (npmport = 0; npmport < SATA_NUM_PMPORTS(sata_hba_inst, cport);
18412 npmport ++) {
18413 pmportinfo = SATA_PMPORT_INFO(sata_hba_inst, cport, npmport);
18414 mutex_enter(&pmportinfo->pmport_mutex);
18415 event_flags = pmportinfo->pmport_event_flags;
18416 mutex_exit(&pmportinfo->pmport_mutex);
18417 saddr = &pmportinfo->pmport_addr;
18418
18419 if ((event_flags &
18420 (SATA_EVNT_PORT_EVENTS | SATA_EVNT_DRIVE_EVENTS)) != 0) {
18421 /*
18422 * Got port multiplier port event.
18423 * We need some hierarchy of event processing as they
18424 * are affecting each other:
18425 * 1. device detached/attached
18426 * 2. link events - link events may trigger device
18427 * detached or device attached events in some
18428 * circumstances.
18429 */
18430 if (event_flags & SATA_EVNT_DEVICE_DETACHED) {
18431 sata_process_pmdevice_detached(sata_hba_inst,
18432 saddr);
18433 }
18434 if (event_flags & SATA_EVNT_DEVICE_ATTACHED) {
18435 sata_process_pmdevice_attached(sata_hba_inst,
18436 saddr);
18437 }
18438 if (event_flags & SATA_EVNT_LINK_ESTABLISHED ||
18439 event_flags & SATA_EVNT_LINK_LOST) {
18440 sata_process_pmport_link_events(sata_hba_inst,
18441 saddr);
18442 }
18443 if (event_flags & SATA_EVNT_TARGET_NODE_CLEANUP) {
18444 sata_process_target_node_cleanup(
18445 sata_hba_inst, saddr);
18446 }
18447 }
18448
18449 /* Checking drive event(s). */
18450 mutex_enter(&pmportinfo->pmport_mutex);
18451 if (pmportinfo->pmport_dev_type != SATA_DTYPE_NONE &&
18452 pmportinfo->pmport_sata_drive != NULL) {
18453 event_flags = pmportinfo->pmport_sata_drive->
18454 satadrv_event_flags;
18455 if (event_flags & (SATA_EVNT_DEVICE_RESET |
18456 SATA_EVNT_INPROC_DEVICE_RESET)) {
18457
18458 /* Have device event */
18459 sata_process_pmdevice_reset(sata_hba_inst,
18460 saddr);
18461 }
18462 }
18463 mutex_exit(&pmportinfo->pmport_mutex);
18464
18465 /* Release PORT_BUSY flag */
18466 mutex_enter(&cportinfo->cport_mutex);
18467 cportinfo->cport_event_flags &= ~SATA_EVNT_LOCK_PORT_BUSY;
18468 mutex_exit(&cportinfo->cport_mutex);
18469 }
18470
18471 SATADBG2(SATA_DBG_EVENTS_CNTRL|SATA_DBG_PMULT, sata_hba_inst,
18472 "[DONE] pmult event(s) on cport %d of controller %d",
18473 cport, ddi_get_instance(SATA_DIP(sata_hba_inst)));
18474 }
18475
18476 /*
18477 * Process HBA power level change reported by HBA driver.
18478 * Not implemented at this time - event is ignored.
18479 */
18480 static void
18481 sata_process_cntrl_pwr_level_change(sata_hba_inst_t *sata_hba_inst)
18482 {
18483 SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst,
18484 "Processing controller power level change", NULL);
18485
18486 /* Ignoring it for now */
18487 mutex_enter(&sata_hba_inst->satahba_mutex);
18488 sata_hba_inst->satahba_event_flags &= ~SATA_EVNT_PWR_LEVEL_CHANGED;
18489 mutex_exit(&sata_hba_inst->satahba_mutex);
18490 }
18491
18492 /*
18493 * Process port power level change reported by HBA driver.
18494 * Not implemented at this time - event is ignored.
18495 */
18496 static void
18497 sata_process_port_pwr_change(sata_hba_inst_t *sata_hba_inst,
18498 sata_address_t *saddr)
18499 {
18500 sata_cport_info_t *cportinfo;
18501
18502 SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst,
18503 "Processing port power level change", NULL);
18504
18505 cportinfo = SATA_CPORT_INFO(sata_hba_inst, saddr->cport);
18506 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex);
18507 /* Reset event flag */
18508 cportinfo->cport_event_flags &= ~SATA_EVNT_PWR_LEVEL_CHANGED;
18509 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex);
18510 }
18511
18512 /*
18513 * Process port failure reported by HBA driver.
18514 * cports support only - no pmports.
18515 */
18516 static void
18517 sata_process_port_failed_event(sata_hba_inst_t *sata_hba_inst,
18518 sata_address_t *saddr)
18519 {
18520 sata_cport_info_t *cportinfo;
18521
18522 cportinfo = SATA_CPORT_INFO(sata_hba_inst, saddr->cport);
18523 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex);
18524 /* Reset event flag first */
18525 cportinfo->cport_event_flags &= ~SATA_EVNT_PORT_FAILED;
18526 /* If the port is in SHUTDOWN or FAILED state, ignore this event. */
18527 if ((cportinfo->cport_state &
18528 (SATA_PSTATE_SHUTDOWN | SATA_PSTATE_FAILED)) == 0) {
18529 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->
18530 cport_mutex);
18531 return;
18532 }
18533 /* Fail the port */
18534 cportinfo->cport_state = SATA_PSTATE_FAILED;
18535 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex);
18536 sata_log(sata_hba_inst, CE_WARN, "SATA port %d failed", saddr->cport);
18537 }
18538
18539 /*
18540 * Device Reset Event processing.
18541 * The sequence is managed by 3 stage flags:
18542 * - reset event reported,
18543 * - reset event being processed,
18544 * - request to clear device reset state.
18545 *
18546 * NOTE: This function has to be entered with cport mutex held. It exits with
18547 * mutex held as well, but can release mutex during the processing.
18548 */
18549 static void
18550 sata_process_device_reset(sata_hba_inst_t *sata_hba_inst,
18551 sata_address_t *saddr)
18552 {
18553 sata_drive_info_t old_sdinfo; /* local copy of the drive info */
18554 sata_drive_info_t *sdinfo;
18555 sata_cport_info_t *cportinfo;
18556 sata_device_t sata_device;
18557 int rval_probe, rval_set;
18558
18559 /* We only care about host sata cport for now */
18560 cportinfo = SATA_CPORT_INFO(sata_hba_inst, saddr->cport);
18561 sdinfo = SATA_CPORT_DRV_INFO(sata_hba_inst, saddr->cport);
18562 /*
18563 * If the port is in SHUTDOWN or FAILED state, or device is in FAILED
18564 * state, ignore reset event.
18565 */
18566 if (((cportinfo->cport_state &
18567 (SATA_PSTATE_SHUTDOWN | SATA_PSTATE_FAILED)) != 0) ||
18568 (sdinfo->satadrv_state & SATA_DSTATE_FAILED) != 0) {
18569 sdinfo->satadrv_event_flags &=
18570 ~(SATA_EVNT_DEVICE_RESET | SATA_EVNT_INPROC_DEVICE_RESET);
18571 return;
18572 }
18573
18574 if ((SATA_CPORT_DEV_TYPE(sata_hba_inst, saddr->cport) ==
18575 SATA_DTYPE_PMULT)) {
18576 /*
18577 * Should not happened: this is already handled in
18578 * sata_hba_event_notify()
18579 */
18580 mutex_exit(&cportinfo->cport_mutex);
18581 goto done;
18582 }
18583
18584 if ((SATA_CPORT_DEV_TYPE(sata_hba_inst, saddr->cport) &
18585 SATA_VALID_DEV_TYPE) == 0) {
18586 /*
18587 * This should not happen - coding error.
18588 * But we can recover, so do not panic, just clean up
18589 * and if in debug mode, log the message.
18590 */
18591 #ifdef SATA_DEBUG
18592 sata_log(sata_hba_inst, CE_WARN,
18593 "sata_process_device_reset: "
18594 "Invalid device type with sdinfo!", NULL);
18595 #endif
18596 sdinfo->satadrv_event_flags = 0;
18597 return;
18598 }
18599
18600 #ifdef SATA_DEBUG
18601 if ((sdinfo->satadrv_event_flags &
18602 (SATA_EVNT_DEVICE_RESET | SATA_EVNT_INPROC_DEVICE_RESET)) == 0) {
18603 /* Nothing to do */
18604 /* Something is weird - why we are processing dev reset? */
18605 SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst,
18606 "No device reset event!!!!", NULL);
18607
18608 return;
18609 }
18610 if ((sdinfo->satadrv_event_flags &
18611 (SATA_EVNT_DEVICE_RESET | SATA_EVNT_INPROC_DEVICE_RESET)) ==
18612 (SATA_EVNT_DEVICE_RESET | SATA_EVNT_INPROC_DEVICE_RESET)) {
18613 /* Something is weird - new device reset event */
18614 SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst,
18615 "Overlapping device reset events!", NULL);
18616 }
18617 #endif
18618 SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst,
18619 "Processing port %d device reset", saddr->cport);
18620
18621 /* Clear event flag */
18622 sdinfo->satadrv_event_flags &= ~SATA_EVNT_DEVICE_RESET;
18623
18624 /* It seems that we always need to check the port state first */
18625 sata_device.satadev_rev = SATA_DEVICE_REV;
18626 sata_device.satadev_addr = *saddr;
18627 /*
18628 * We have to exit mutex, because the HBA probe port function may
18629 * block on its own mutex.
18630 */
18631 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex);
18632 rval_probe = (*SATA_PROBE_PORT_FUNC(sata_hba_inst))
18633 (SATA_DIP(sata_hba_inst), &sata_device);
18634 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex);
18635 sata_update_port_info(sata_hba_inst, &sata_device);
18636 if (rval_probe != SATA_SUCCESS) {
18637 /* Something went wrong? Fail the port */
18638 cportinfo->cport_state = SATA_PSTATE_FAILED;
18639 sdinfo = SATA_CPORT_DRV_INFO(sata_hba_inst, saddr->cport);
18640 if (sdinfo != NULL)
18641 sdinfo->satadrv_event_flags = 0;
18642 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->
18643 cport_mutex);
18644 SATA_LOG_D((sata_hba_inst, CE_WARN,
18645 "SATA port %d probing failed",
18646 saddr->cport));
18647 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst,
18648 saddr->cport)->cport_mutex);
18649 return;
18650 }
18651 if ((sata_device.satadev_scr.sstatus &
18652 SATA_PORT_DEVLINK_UP_MASK) !=
18653 SATA_PORT_DEVLINK_UP ||
18654 sata_device.satadev_type == SATA_DTYPE_NONE) {
18655 /*
18656 * No device to process, anymore. Some other event processing
18657 * would or have already performed port info cleanup.
18658 * To be safe (HBA may need it), request clearing device
18659 * reset condition.
18660 */
18661 sdinfo = SATA_CPORT_DRV_INFO(sata_hba_inst, saddr->cport);
18662 if (sdinfo != NULL) {
18663 sdinfo->satadrv_event_flags &=
18664 ~SATA_EVNT_INPROC_DEVICE_RESET;
18665 sdinfo->satadrv_event_flags |=
18666 SATA_EVNT_CLEAR_DEVICE_RESET;
18667 }
18668 return;
18669 }
18670
18671 sdinfo = SATA_CPORT_DRV_INFO(sata_hba_inst, saddr->cport);
18672 if (sdinfo == NULL) {
18673 return;
18674 }
18675 if ((sdinfo->satadrv_event_flags &
18676 SATA_EVNT_INPROC_DEVICE_RESET) == 0) {
18677 /*
18678 * Start tracking time for device feature restoration and
18679 * identification. Save current time (lbolt value).
18680 */
18681 sdinfo->satadrv_reset_time = ddi_get_lbolt();
18682 }
18683 /* Mark device reset processing as active */
18684 sdinfo->satadrv_event_flags |= SATA_EVNT_INPROC_DEVICE_RESET;
18685
18686 old_sdinfo = *sdinfo; /* local copy of the drive info */
18687 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex);
18688
18689 rval_set = sata_set_drive_features(sata_hba_inst, &old_sdinfo, 1);
18690
18691 if (rval_set != SATA_SUCCESS) {
18692 /*
18693 * Restoring drive setting failed.
18694 * Probe the port first, to check if the port state has changed
18695 */
18696 sata_device.satadev_rev = SATA_DEVICE_REV;
18697 sata_device.satadev_addr = *saddr;
18698 sata_device.satadev_addr.qual = SATA_ADDR_CPORT;
18699 /* probe port */
18700 rval_probe = (*SATA_PROBE_PORT_FUNC(sata_hba_inst))
18701 (SATA_DIP(sata_hba_inst), &sata_device);
18702 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->
18703 cport_mutex);
18704 if (rval_probe == SATA_SUCCESS &&
18705 (sata_device.satadev_state &
18706 (SATA_PSTATE_SHUTDOWN | SATA_PSTATE_FAILED)) == 0 &&
18707 (sata_device.satadev_scr.sstatus &
18708 SATA_PORT_DEVLINK_UP_MASK) == SATA_PORT_DEVLINK_UP &&
18709 sata_device.satadev_type != SATA_DTYPE_NONE) {
18710 /*
18711 * We may retry this a bit later - in-process reset
18712 * condition should be already set.
18713 * Track retry time for device identification.
18714 */
18715 if ((cportinfo->cport_dev_type &
18716 SATA_VALID_DEV_TYPE) != 0 &&
18717 SATA_CPORTINFO_DRV_INFO(cportinfo) != NULL &&
18718 sdinfo->satadrv_reset_time != 0) {
18719 clock_t cur_time = ddi_get_lbolt();
18720 /*
18721 * If the retry time limit was not
18722 * exceeded, retry.
18723 */
18724 if ((cur_time - sdinfo->satadrv_reset_time) <
18725 drv_usectohz(SATA_DEV_REPROBE_TIMEOUT)) {
18726 mutex_enter(
18727 &sata_hba_inst->satahba_mutex);
18728 sata_hba_inst->satahba_event_flags |=
18729 SATA_EVNT_MAIN;
18730 mutex_exit(
18731 &sata_hba_inst->satahba_mutex);
18732 mutex_enter(&sata_mutex);
18733 sata_event_pending |= SATA_EVNT_MAIN;
18734 mutex_exit(&sata_mutex);
18735 return;
18736 }
18737 if (rval_set == SATA_RETRY) {
18738 /*
18739 * Setting drive features failed, but
18740 * the drive is still accessible,
18741 * so emit a warning message before
18742 * return.
18743 */
18744 mutex_exit(&SATA_CPORT_INFO(
18745 sata_hba_inst,
18746 saddr->cport)->cport_mutex);
18747 goto done;
18748 }
18749 }
18750 /* Fail the drive */
18751 sdinfo->satadrv_state = SATA_DSTATE_FAILED;
18752
18753 sata_log(sata_hba_inst, CE_WARN,
18754 "SATA device at port %d - device failed",
18755 saddr->cport);
18756
18757 DTRACE_PROBE(port_failed_f);
18758 }
18759 /*
18760 * No point of retrying - device failed or some other event
18761 * processing or already did or will do port info cleanup.
18762 * To be safe (HBA may need it),
18763 * request clearing device reset condition.
18764 */
18765 sdinfo->satadrv_event_flags |= SATA_EVNT_CLEAR_DEVICE_RESET;
18766 sdinfo->satadrv_event_flags &= ~SATA_EVNT_INPROC_DEVICE_RESET;
18767 sdinfo->satadrv_reset_time = 0;
18768 return;
18769 }
18770 done:
18771 /*
18772 * If setting of drive features failed, but the drive is still
18773 * accessible, emit a warning message.
18774 */
18775 if (rval_set == SATA_RETRY) {
18776 sata_log(sata_hba_inst, CE_WARN,
18777 "SATA device at port %d - desired setting could not be "
18778 "restored after reset. Device may not operate as expected.",
18779 saddr->cport);
18780 }
18781 /*
18782 * Raise the flag indicating that the next sata command could
18783 * be sent with SATA_CLEAR_DEV_RESET_STATE flag, if no new device
18784 * reset is reported.
18785 */
18786 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex);
18787 if (SATA_CPORTINFO_DRV_INFO(cportinfo) != NULL) {
18788 sdinfo->satadrv_reset_time = 0;
18789 if ((cportinfo->cport_dev_type & SATA_VALID_DEV_TYPE) != 0) {
18790 sdinfo = SATA_CPORTINFO_DRV_INFO(cportinfo);
18791 sdinfo->satadrv_event_flags &=
18792 ~SATA_EVNT_INPROC_DEVICE_RESET;
18793 sdinfo->satadrv_event_flags |=
18794 SATA_EVNT_CLEAR_DEVICE_RESET;
18795 }
18796 }
18797 }
18798
18799
18800 /*
18801 * Port Multiplier Port Device Reset Event processing.
18802 *
18803 * NOTE: This function has to be entered with pmport mutex held. It exits with
18804 * mutex held as well, but can release mutex during the processing.
18805 */
18806 static void
18807 sata_process_pmdevice_reset(sata_hba_inst_t *sata_hba_inst,
18808 sata_address_t *saddr)
18809 {
18810 sata_drive_info_t old_sdinfo; /* local copy of the drive info */
18811 sata_drive_info_t *sdinfo = NULL;
18812 sata_cport_info_t *cportinfo = NULL;
18813 sata_pmport_info_t *pmportinfo = NULL;
18814 sata_pmult_info_t *pminfo = NULL;
18815 sata_device_t sata_device;
18816 uint8_t cport = saddr->cport;
18817 uint8_t pmport = saddr->pmport;
18818 int rval;
18819
18820 SATADBG2(SATA_DBG_EVENTS_PROC, sata_hba_inst,
18821 "Processing drive reset at port %d:%d", cport, pmport);
18822
18823 cportinfo = SATA_CPORT_INFO(sata_hba_inst, cport);
18824 pmportinfo = SATA_PMPORT_INFO(sata_hba_inst, cport, pmport);
18825 sdinfo = SATA_PMPORT_DRV_INFO(sata_hba_inst, cport, pmport);
18826
18827 /*
18828 * If the port is in SHUTDOWN or FAILED state, or device is in FAILED
18829 * state, ignore reset event.
18830 */
18831 if (((cportinfo->cport_state &
18832 (SATA_PSTATE_SHUTDOWN | SATA_PSTATE_FAILED)) != 0) ||
18833 (sdinfo->satadrv_state & SATA_DSTATE_FAILED) != 0) {
18834 sdinfo->satadrv_event_flags &=
18835 ~(SATA_EVNT_DEVICE_RESET | SATA_EVNT_INPROC_DEVICE_RESET);
18836 return;
18837 }
18838
18839 if ((pmportinfo->pmport_dev_type & SATA_VALID_DEV_TYPE) == 0) {
18840 /*
18841 * This should not happen - coding error.
18842 * But we can recover, so do not panic, just clean up
18843 * and if in debug mode, log the message.
18844 */
18845 #ifdef SATA_DEBUG
18846 sata_log(sata_hba_inst, CE_WARN,
18847 "sata_process_pmdevice_reset: "
18848 "Invalid device type with sdinfo!", NULL);
18849 #endif
18850 sdinfo->satadrv_event_flags = 0;
18851 return;
18852 }
18853
18854 #ifdef SATA_DEBUG
18855 if ((sdinfo->satadrv_event_flags &
18856 (SATA_EVNT_DEVICE_RESET | SATA_EVNT_INPROC_DEVICE_RESET)) == 0) {
18857 /* Nothing to do */
18858 /* Something is weird - why we are processing dev reset? */
18859 SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst,
18860 "No device reset event!!!!", NULL);
18861
18862 return;
18863 }
18864 if ((sdinfo->satadrv_event_flags &
18865 (SATA_EVNT_DEVICE_RESET | SATA_EVNT_INPROC_DEVICE_RESET)) ==
18866 (SATA_EVNT_DEVICE_RESET | SATA_EVNT_INPROC_DEVICE_RESET)) {
18867 /* Something is weird - new device reset event */
18868 SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst,
18869 "Overlapping device reset events!", NULL);
18870 }
18871 #endif
18872 SATADBG2(SATA_DBG_EVENTS_PROC, sata_hba_inst,
18873 "Processing port %d:%d device reset", cport, pmport);
18874
18875 /* Clear event flag */
18876 sdinfo->satadrv_event_flags &= ~SATA_EVNT_DEVICE_RESET;
18877
18878 /* It seems that we always need to check the port state first */
18879 sata_device.satadev_rev = SATA_DEVICE_REV;
18880 sata_device.satadev_addr = *saddr;
18881 /*
18882 * We have to exit mutex, because the HBA probe port function may
18883 * block on its own mutex.
18884 */
18885 mutex_exit(&pmportinfo->pmport_mutex);
18886 rval = (*SATA_PROBE_PORT_FUNC(sata_hba_inst))
18887 (SATA_DIP(sata_hba_inst), &sata_device);
18888 mutex_enter(&pmportinfo->pmport_mutex);
18889
18890 sata_update_pmport_info(sata_hba_inst, &sata_device);
18891 if (rval != SATA_SUCCESS) {
18892 /* Something went wrong? Fail the port */
18893 pmportinfo->pmport_state = SATA_PSTATE_FAILED;
18894 sdinfo = SATA_PMPORT_DRV_INFO(sata_hba_inst, saddr->cport,
18895 saddr->pmport);
18896 if (sdinfo != NULL)
18897 sdinfo->satadrv_event_flags = 0;
18898 mutex_exit(&pmportinfo->pmport_mutex);
18899 SATA_LOG_D((sata_hba_inst, CE_WARN,
18900 "SATA port %d:%d probing failed",
18901 saddr->cport, saddr->pmport));
18902 mutex_enter(&pmportinfo->pmport_mutex);
18903 return;
18904 }
18905 if ((sata_device.satadev_scr.sstatus &
18906 SATA_PORT_DEVLINK_UP_MASK) !=
18907 SATA_PORT_DEVLINK_UP ||
18908 sata_device.satadev_type == SATA_DTYPE_NONE) {
18909 /*
18910 * No device to process, anymore. Some other event processing
18911 * would or have already performed port info cleanup.
18912 * To be safe (HBA may need it), request clearing device
18913 * reset condition.
18914 */
18915 sdinfo = SATA_PMPORT_DRV_INFO(sata_hba_inst, saddr->cport,
18916 saddr->pmport);
18917 if (sdinfo != NULL) {
18918 sdinfo->satadrv_event_flags &=
18919 ~SATA_EVNT_INPROC_DEVICE_RESET;
18920 /* must clear flags on cport */
18921 pminfo = SATA_PMULT_INFO(sata_hba_inst,
18922 saddr->cport);
18923 pminfo->pmult_event_flags |=
18924 SATA_EVNT_CLEAR_DEVICE_RESET;
18925 }
18926 return;
18927 }
18928
18929 sdinfo = SATA_PMPORT_DRV_INFO(sata_hba_inst, saddr->cport,
18930 saddr->pmport);
18931 if (sdinfo == NULL) {
18932 return;
18933 }
18934 if ((sdinfo->satadrv_event_flags &
18935 SATA_EVNT_INPROC_DEVICE_RESET) == 0) {
18936 /*
18937 * Start tracking time for device feature restoration and
18938 * identification. Save current time (lbolt value).
18939 */
18940 sdinfo->satadrv_reset_time = ddi_get_lbolt();
18941 }
18942 /* Mark device reset processing as active */
18943 sdinfo->satadrv_event_flags |= SATA_EVNT_INPROC_DEVICE_RESET;
18944
18945 old_sdinfo = *sdinfo; /* local copy of the drive info */
18946 mutex_exit(&pmportinfo->pmport_mutex);
18947
18948 if (sata_set_drive_features(sata_hba_inst, &old_sdinfo, 1) ==
18949 SATA_FAILURE) {
18950 /*
18951 * Restoring drive setting failed.
18952 * Probe the port first, to check if the port state has changed
18953 */
18954 sata_device.satadev_rev = SATA_DEVICE_REV;
18955 sata_device.satadev_addr = *saddr;
18956 sata_device.satadev_addr.qual = SATA_ADDR_PMPORT;
18957
18958 /* probe port */
18959 rval = (*SATA_PROBE_PORT_FUNC(sata_hba_inst))
18960 (SATA_DIP(sata_hba_inst), &sata_device);
18961 mutex_enter(&pmportinfo->pmport_mutex);
18962 if (rval == SATA_SUCCESS &&
18963 (sata_device.satadev_state &
18964 (SATA_PSTATE_SHUTDOWN | SATA_PSTATE_FAILED)) == 0 &&
18965 (sata_device.satadev_scr.sstatus &
18966 SATA_PORT_DEVLINK_UP_MASK) == SATA_PORT_DEVLINK_UP &&
18967 sata_device.satadev_type != SATA_DTYPE_NONE) {
18968 /*
18969 * We may retry this a bit later - in-process reset
18970 * condition should be already set.
18971 * Track retry time for device identification.
18972 */
18973 if ((pmportinfo->pmport_dev_type &
18974 SATA_VALID_DEV_TYPE) != 0 &&
18975 SATA_PMPORTINFO_DRV_INFO(pmportinfo) != NULL &&
18976 sdinfo->satadrv_reset_time != 0) {
18977 clock_t cur_time = ddi_get_lbolt();
18978 /*
18979 * If the retry time limit was not
18980 * exceeded, retry.
18981 */
18982 if ((cur_time - sdinfo->satadrv_reset_time) <
18983 drv_usectohz(SATA_DEV_REPROBE_TIMEOUT)) {
18984 mutex_enter(
18985 &sata_hba_inst->satahba_mutex);
18986 sata_hba_inst->satahba_event_flags |=
18987 SATA_EVNT_MAIN;
18988 mutex_exit(
18989 &sata_hba_inst->satahba_mutex);
18990 mutex_enter(&sata_mutex);
18991 sata_event_pending |= SATA_EVNT_MAIN;
18992 mutex_exit(&sata_mutex);
18993 return;
18994 }
18995 }
18996 /* Fail the drive */
18997 sdinfo->satadrv_state = SATA_DSTATE_FAILED;
18998
18999 sata_log(sata_hba_inst, CE_WARN,
19000 "SATA device at port %d:%d - device failed",
19001 saddr->cport, saddr->pmport);
19002 } else {
19003 /*
19004 * No point of retrying - some other event processing
19005 * would or already did port info cleanup.
19006 * To be safe (HBA may need it),
19007 * request clearing device reset condition.
19008 */
19009 sdinfo->satadrv_event_flags |=
19010 SATA_EVNT_CLEAR_DEVICE_RESET;
19011 }
19012 sdinfo->satadrv_event_flags &= ~SATA_EVNT_INPROC_DEVICE_RESET;
19013 sdinfo->satadrv_reset_time = 0;
19014 return;
19015 }
19016 /*
19017 * Raise the flag indicating that the next sata command could
19018 * be sent with SATA_CLEAR_DEV_RESET_STATE flag, if no new device
19019 * reset is reported.
19020 */
19021 mutex_enter(&pmportinfo->pmport_mutex);
19022 if (SATA_PMPORTINFO_DRV_INFO(pmportinfo) != NULL) {
19023 sdinfo->satadrv_reset_time = 0;
19024 if (pmportinfo->pmport_dev_type & SATA_VALID_DEV_TYPE) {
19025 sdinfo = SATA_PMPORTINFO_DRV_INFO(pmportinfo);
19026 sdinfo->satadrv_event_flags &=
19027 ~SATA_EVNT_INPROC_DEVICE_RESET;
19028 /* must clear flags on cport */
19029 pminfo = SATA_PMULT_INFO(sata_hba_inst,
19030 saddr->cport);
19031 pminfo->pmult_event_flags |=
19032 SATA_EVNT_CLEAR_DEVICE_RESET;
19033 }
19034 }
19035 }
19036
19037 /*
19038 * Port Link Events processing.
19039 * Every link established event may involve device reset (due to
19040 * COMRESET signal, equivalent of the hard reset) so arbitrarily
19041 * set device reset event for an attached device (if any).
19042 * If the port is in SHUTDOWN or FAILED state, ignore link events.
19043 *
19044 * The link established event processing varies, depending on the state
19045 * of the target node, HBA hotplugging capabilities, state of the port.
19046 * If the link is not active, the link established event is ignored.
19047 * If HBA cannot detect device attachment and there is no target node,
19048 * the link established event triggers device attach event processing.
19049 * Else, link established event triggers device reset event processing.
19050 *
19051 * The link lost event processing varies, depending on a HBA hotplugging
19052 * capability and the state of the port (link active or not active).
19053 * If the link is active, the lost link event is ignored.
19054 * If HBA cannot detect device removal, the lost link event triggers
19055 * device detached event processing after link lost timeout.
19056 * Else, the event is ignored.
19057 *
19058 * NOTE: Port multiplier ports events are handled by
19059 * sata_process_pmport_link_events();
19060 */
19061 static void
19062 sata_process_port_link_events(sata_hba_inst_t *sata_hba_inst,
19063 sata_address_t *saddr)
19064 {
19065 sata_device_t sata_device;
19066 sata_cport_info_t *cportinfo;
19067 sata_drive_info_t *sdinfo;
19068 uint32_t event_flags;
19069 int rval;
19070
19071 SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst,
19072 "Processing port %d link event(s)", saddr->cport);
19073
19074 cportinfo = SATA_CPORT_INFO(sata_hba_inst, saddr->cport);
19075 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex);
19076 event_flags = cportinfo->cport_event_flags;
19077
19078 /* Reset event flags first */
19079 cportinfo->cport_event_flags &=
19080 ~(SATA_EVNT_LINK_ESTABLISHED | SATA_EVNT_LINK_LOST);
19081
19082 /* If the port is in SHUTDOWN or FAILED state, ignore link events. */
19083 if ((cportinfo->cport_state &
19084 (SATA_PSTATE_SHUTDOWN | SATA_PSTATE_FAILED)) != 0) {
19085 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->
19086 cport_mutex);
19087 return;
19088 }
19089
19090 /*
19091 * For the sanity sake get current port state.
19092 * Set device address only. Other sata_device fields should be
19093 * set by HBA driver.
19094 */
19095 sata_device.satadev_rev = SATA_DEVICE_REV;
19096 sata_device.satadev_addr = *saddr;
19097 /*
19098 * We have to exit mutex, because the HBA probe port function may
19099 * block on its own mutex.
19100 */
19101 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex);
19102 rval = (*SATA_PROBE_PORT_FUNC(sata_hba_inst))
19103 (SATA_DIP(sata_hba_inst), &sata_device);
19104 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex);
19105 sata_update_port_info(sata_hba_inst, &sata_device);
19106 if (rval != SATA_SUCCESS) {
19107 /* Something went wrong? Fail the port */
19108 cportinfo->cport_state = SATA_PSTATE_FAILED;
19109 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->
19110 cport_mutex);
19111 SATA_LOG_D((sata_hba_inst, CE_WARN,
19112 "SATA port %d probing failed",
19113 saddr->cport));
19114 /*
19115 * We may want to release device info structure, but
19116 * it is not necessary.
19117 */
19118 return;
19119 } else {
19120 /* port probed successfully */
19121 cportinfo->cport_state |= SATA_STATE_PROBED | SATA_STATE_READY;
19122 }
19123 if (event_flags & SATA_EVNT_LINK_ESTABLISHED) {
19124
19125 if ((sata_device.satadev_scr.sstatus &
19126 SATA_PORT_DEVLINK_UP_MASK) != SATA_PORT_DEVLINK_UP) {
19127 /* Ignore event */
19128 SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst,
19129 "Ignoring port %d link established event - "
19130 "link down",
19131 saddr->cport);
19132 goto linklost;
19133 }
19134
19135 SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst,
19136 "Processing port %d link established event",
19137 saddr->cport);
19138
19139 /*
19140 * For the sanity sake check if a device is attached - check
19141 * return state of a port probing.
19142 */
19143 if (sata_device.satadev_type != SATA_DTYPE_NONE) {
19144 /*
19145 * HBA port probe indicated that there is a device
19146 * attached. Check if the framework had device info
19147 * structure attached for this device.
19148 */
19149 if (cportinfo->cport_dev_type != SATA_DTYPE_NONE) {
19150 ASSERT(SATA_CPORTINFO_DRV_INFO(cportinfo) !=
19151 NULL);
19152
19153 sdinfo = SATA_CPORTINFO_DRV_INFO(cportinfo);
19154 if ((sdinfo->satadrv_type &
19155 SATA_VALID_DEV_TYPE) != 0) {
19156 /*
19157 * Dev info structure is present.
19158 * If dev_type is set to known type in
19159 * the framework's drive info struct
19160 * then the device existed before and
19161 * the link was probably lost
19162 * momentarily - in such case
19163 * we may want to check device
19164 * identity.
19165 * Identity check is not supported now.
19166 *
19167 * Link established event
19168 * triggers device reset event.
19169 */
19170 (SATA_CPORTINFO_DRV_INFO(cportinfo))->
19171 satadrv_event_flags |=
19172 SATA_EVNT_DEVICE_RESET;
19173 }
19174 } else if (cportinfo->cport_dev_type ==
19175 SATA_DTYPE_NONE) {
19176 /*
19177 * We got new device attached! If HBA does not
19178 * generate device attached events, trigger it
19179 * here.
19180 */
19181 if (!(SATA_FEATURES(sata_hba_inst) &
19182 SATA_CTLF_HOTPLUG)) {
19183 cportinfo->cport_event_flags |=
19184 SATA_EVNT_DEVICE_ATTACHED;
19185 }
19186 }
19187 /* Reset link lost timeout */
19188 cportinfo->cport_link_lost_time = 0;
19189 }
19190 }
19191 linklost:
19192 if (event_flags & SATA_EVNT_LINK_LOST) {
19193 if ((sata_device.satadev_scr.sstatus &
19194 SATA_PORT_DEVLINK_UP_MASK) == SATA_PORT_DEVLINK_UP) {
19195 /* Ignore event */
19196 SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst,
19197 "Ignoring port %d link lost event - link is up",
19198 saddr->cport);
19199 goto done;
19200 }
19201 #ifdef SATA_DEBUG
19202 if (cportinfo->cport_link_lost_time == 0) {
19203 SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst,
19204 "Processing port %d link lost event",
19205 saddr->cport);
19206 }
19207 #endif
19208 /*
19209 * When HBA cannot generate device attached/detached events,
19210 * we need to track link lost time and eventually generate
19211 * device detach event.
19212 */
19213 if (!(SATA_FEATURES(sata_hba_inst) & SATA_CTLF_HOTPLUG)) {
19214 /* We are tracking link lost time */
19215 if (cportinfo->cport_link_lost_time == 0) {
19216 /* save current time (lbolt value) */
19217 cportinfo->cport_link_lost_time =
19218 ddi_get_lbolt();
19219 /* just keep link lost event */
19220 cportinfo->cport_event_flags |=
19221 SATA_EVNT_LINK_LOST;
19222 } else {
19223 clock_t cur_time = ddi_get_lbolt();
19224 if ((cur_time -
19225 cportinfo->cport_link_lost_time) >=
19226 drv_usectohz(
19227 SATA_EVNT_LINK_LOST_TIMEOUT)) {
19228 /* trigger device detach event */
19229 cportinfo->cport_event_flags |=
19230 SATA_EVNT_DEVICE_DETACHED;
19231 cportinfo->cport_link_lost_time = 0;
19232 SATADBG1(SATA_DBG_EVENTS,
19233 sata_hba_inst,
19234 "Triggering port %d "
19235 "device detached event",
19236 saddr->cport);
19237 } else {
19238 /* keep link lost event */
19239 cportinfo->cport_event_flags |=
19240 SATA_EVNT_LINK_LOST;
19241 }
19242 }
19243 }
19244 /*
19245 * We could change port state to disable/delay access to
19246 * the attached device until the link is recovered.
19247 */
19248 }
19249 done:
19250 event_flags = cportinfo->cport_event_flags;
19251 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex);
19252 if (event_flags != 0) {
19253 mutex_enter(&sata_hba_inst->satahba_mutex);
19254 sata_hba_inst->satahba_event_flags |= SATA_EVNT_MAIN;
19255 mutex_exit(&sata_hba_inst->satahba_mutex);
19256 mutex_enter(&sata_mutex);
19257 sata_event_pending |= SATA_EVNT_MAIN;
19258 mutex_exit(&sata_mutex);
19259 }
19260 }
19261
19262 /*
19263 * Port Multiplier Port Link Events processing.
19264 */
19265 static void
19266 sata_process_pmport_link_events(sata_hba_inst_t *sata_hba_inst,
19267 sata_address_t *saddr)
19268 {
19269 sata_device_t sata_device;
19270 sata_pmport_info_t *pmportinfo = NULL;
19271 sata_drive_info_t *sdinfo = NULL;
19272 uint32_t event_flags;
19273 uint8_t cport = saddr->cport;
19274 uint8_t pmport = saddr->pmport;
19275 int rval;
19276
19277 SATADBG2(SATA_DBG_EVENTS_PROC, sata_hba_inst,
19278 "Processing port %d:%d link event(s)",
19279 cport, pmport);
19280
19281 pmportinfo = SATA_PMPORT_INFO(sata_hba_inst, cport, pmport);
19282 mutex_enter(&pmportinfo->pmport_mutex);
19283 event_flags = pmportinfo->pmport_event_flags;
19284
19285 /* Reset event flags first */
19286 pmportinfo->pmport_event_flags &=
19287 ~(SATA_EVNT_LINK_ESTABLISHED | SATA_EVNT_LINK_LOST);
19288
19289 /* If the port is in SHUTDOWN or FAILED state, ignore link events. */
19290 if ((pmportinfo->pmport_state &
19291 (SATA_PSTATE_SHUTDOWN | SATA_PSTATE_FAILED)) != 0) {
19292 mutex_exit(&pmportinfo->pmport_mutex);
19293 return;
19294 }
19295
19296 /*
19297 * For the sanity sake get current port state.
19298 * Set device address only. Other sata_device fields should be
19299 * set by HBA driver.
19300 */
19301 sata_device.satadev_rev = SATA_DEVICE_REV;
19302 sata_device.satadev_addr = *saddr;
19303 /*
19304 * We have to exit mutex, because the HBA probe port function may
19305 * block on its own mutex.
19306 */
19307 mutex_exit(&SATA_PMPORT_MUTEX(sata_hba_inst, saddr->cport,
19308 saddr->pmport));
19309 rval = (*SATA_PROBE_PORT_FUNC(sata_hba_inst))
19310 (SATA_DIP(sata_hba_inst), &sata_device);
19311 mutex_enter(&SATA_PMPORT_MUTEX(sata_hba_inst, saddr->cport,
19312 saddr->pmport));
19313 sata_update_pmport_info(sata_hba_inst, &sata_device);
19314 if (rval != SATA_SUCCESS) {
19315 /* Something went wrong? Fail the port */
19316 pmportinfo->pmport_state = SATA_PSTATE_FAILED;
19317 mutex_exit(&SATA_PMPORT_MUTEX(sata_hba_inst, saddr->cport,
19318 saddr->pmport));
19319 SATA_LOG_D((sata_hba_inst, CE_WARN,
19320 "SATA port %d:%d probing failed",
19321 saddr->cport, saddr->pmport));
19322 /*
19323 * We may want to release device info structure, but
19324 * it is not necessary.
19325 */
19326 return;
19327 } else {
19328 /* port probed successfully */
19329 pmportinfo->pmport_state |=
19330 SATA_STATE_PROBED | SATA_STATE_READY;
19331 }
19332 mutex_exit(&SATA_PMPORT_MUTEX(sata_hba_inst,
19333 saddr->cport, saddr->pmport));
19334 mutex_enter(&SATA_PMPORT_MUTEX(sata_hba_inst,
19335 saddr->cport, saddr->pmport));
19336 if (event_flags & SATA_EVNT_LINK_ESTABLISHED) {
19337
19338 if ((sata_device.satadev_scr.sstatus &
19339 SATA_PORT_DEVLINK_UP_MASK) != SATA_PORT_DEVLINK_UP) {
19340 /* Ignore event */
19341 SATADBG2(SATA_DBG_EVENTS_PROC, sata_hba_inst,
19342 "Ignoring port %d:%d link established event - "
19343 "link down",
19344 saddr->cport, saddr->pmport);
19345 goto linklost;
19346 }
19347
19348 SATADBG2(SATA_DBG_EVENTS_PROC, sata_hba_inst,
19349 "Processing port %d:%d link established event",
19350 cport, pmport);
19351
19352 /*
19353 * For the sanity sake check if a device is attached - check
19354 * return state of a port probing.
19355 */
19356 if (sata_device.satadev_type != SATA_DTYPE_NONE &&
19357 sata_device.satadev_type != SATA_DTYPE_PMULT) {
19358 /*
19359 * HBA port probe indicated that there is a device
19360 * attached. Check if the framework had device info
19361 * structure attached for this device.
19362 */
19363 if (pmportinfo->pmport_dev_type != SATA_DTYPE_NONE) {
19364 ASSERT(SATA_PMPORTINFO_DRV_INFO(pmportinfo) !=
19365 NULL);
19366
19367 sdinfo = SATA_PMPORTINFO_DRV_INFO(pmportinfo);
19368 if ((sdinfo->satadrv_type &
19369 SATA_VALID_DEV_TYPE) != 0) {
19370 /*
19371 * Dev info structure is present.
19372 * If dev_type is set to known type in
19373 * the framework's drive info struct
19374 * then the device existed before and
19375 * the link was probably lost
19376 * momentarily - in such case
19377 * we may want to check device
19378 * identity.
19379 * Identity check is not supported now.
19380 *
19381 * Link established event
19382 * triggers device reset event.
19383 */
19384 (SATA_PMPORTINFO_DRV_INFO(pmportinfo))->
19385 satadrv_event_flags |=
19386 SATA_EVNT_DEVICE_RESET;
19387 }
19388 } else if (pmportinfo->pmport_dev_type ==
19389 SATA_DTYPE_NONE) {
19390 /*
19391 * We got new device attached! If HBA does not
19392 * generate device attached events, trigger it
19393 * here.
19394 */
19395 if (!(SATA_FEATURES(sata_hba_inst) &
19396 SATA_CTLF_HOTPLUG)) {
19397 pmportinfo->pmport_event_flags |=
19398 SATA_EVNT_DEVICE_ATTACHED;
19399 }
19400 }
19401 /* Reset link lost timeout */
19402 pmportinfo->pmport_link_lost_time = 0;
19403 }
19404 }
19405 linklost:
19406 if (event_flags & SATA_EVNT_LINK_LOST) {
19407 #ifdef SATA_DEBUG
19408 if (pmportinfo->pmport_link_lost_time == 0) {
19409 SATADBG2(SATA_DBG_EVENTS_PROC, sata_hba_inst,
19410 "Processing port %d:%d link lost event",
19411 saddr->cport, saddr->pmport);
19412 }
19413 #endif
19414 if ((sata_device.satadev_scr.sstatus &
19415 SATA_PORT_DEVLINK_UP_MASK) == SATA_PORT_DEVLINK_UP) {
19416 /* Ignore event */
19417 SATADBG2(SATA_DBG_EVENTS_PROC, sata_hba_inst,
19418 "Ignoring port %d:%d link lost event - link is up",
19419 saddr->cport, saddr->pmport);
19420 goto done;
19421 }
19422 /*
19423 * When HBA cannot generate device attached/detached events,
19424 * we need to track link lost time and eventually generate
19425 * device detach event.
19426 */
19427 if (!(SATA_FEATURES(sata_hba_inst) & SATA_CTLF_HOTPLUG)) {
19428 /* We are tracking link lost time */
19429 if (pmportinfo->pmport_link_lost_time == 0) {
19430 /* save current time (lbolt value) */
19431 pmportinfo->pmport_link_lost_time =
19432 ddi_get_lbolt();
19433 /* just keep link lost event */
19434 pmportinfo->pmport_event_flags |=
19435 SATA_EVNT_LINK_LOST;
19436 } else {
19437 clock_t cur_time = ddi_get_lbolt();
19438 if ((cur_time -
19439 pmportinfo->pmport_link_lost_time) >=
19440 drv_usectohz(
19441 SATA_EVNT_LINK_LOST_TIMEOUT)) {
19442 /* trigger device detach event */
19443 pmportinfo->pmport_event_flags |=
19444 SATA_EVNT_DEVICE_DETACHED;
19445 pmportinfo->pmport_link_lost_time = 0;
19446 SATADBG2(SATA_DBG_EVENTS,
19447 sata_hba_inst,
19448 "Triggering port %d:%d "
19449 "device detached event",
19450 saddr->cport, saddr->pmport);
19451 } else {
19452 /* keep link lost event */
19453 pmportinfo->pmport_event_flags |=
19454 SATA_EVNT_LINK_LOST;
19455 }
19456 }
19457 }
19458 /*
19459 * We could change port state to disable/delay access to
19460 * the attached device until the link is recovered.
19461 */
19462 }
19463 done:
19464 event_flags = pmportinfo->pmport_event_flags;
19465 mutex_exit(&SATA_PMPORT_MUTEX(sata_hba_inst, saddr->cport,
19466 saddr->pmport));
19467 if (event_flags != 0) {
19468 mutex_enter(&sata_hba_inst->satahba_mutex);
19469 sata_hba_inst->satahba_event_flags |= SATA_EVNT_MAIN;
19470 mutex_exit(&sata_hba_inst->satahba_mutex);
19471 mutex_enter(&sata_mutex);
19472 sata_event_pending |= SATA_EVNT_MAIN;
19473 mutex_exit(&sata_mutex);
19474 }
19475 }
19476
19477 /*
19478 * Device Detached Event processing.
19479 * Port is probed to find if a device is really gone. If so,
19480 * the device info structure is detached from the SATA port info structure
19481 * and released.
19482 * Port status is updated.
19483 *
19484 * NOTE: Port multiplier ports events are handled by
19485 * sata_process_pmdevice_detached()
19486 */
19487 static void
19488 sata_process_device_detached(sata_hba_inst_t *sata_hba_inst,
19489 sata_address_t *saddr)
19490 {
19491 sata_cport_info_t *cportinfo;
19492 sata_pmport_info_t *pmportinfo;
19493 sata_drive_info_t *sdevinfo;
19494 sata_device_t sata_device;
19495 sata_address_t pmport_addr;
19496 char name[16];
19497 uint8_t cport = saddr->cport;
19498 int npmport;
19499 int rval;
19500
19501 SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst,
19502 "Processing port %d device detached", saddr->cport);
19503
19504 cportinfo = SATA_CPORT_INFO(sata_hba_inst, saddr->cport);
19505 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex);
19506 /* Clear event flag */
19507 cportinfo->cport_event_flags &= ~SATA_EVNT_DEVICE_DETACHED;
19508
19509 /* If the port is in SHUTDOWN or FAILED state, ignore detach event. */
19510 if ((cportinfo->cport_state &
19511 (SATA_PSTATE_SHUTDOWN | SATA_PSTATE_FAILED)) != 0) {
19512 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->
19513 cport_mutex);
19514 return;
19515 }
19516 /* For sanity, re-probe the port */
19517 sata_device.satadev_rev = SATA_DEVICE_REV;
19518 sata_device.satadev_addr = *saddr;
19519
19520 /*
19521 * We have to exit mutex, because the HBA probe port function may
19522 * block on its own mutex.
19523 */
19524 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex);
19525 rval = (*SATA_PROBE_PORT_FUNC(sata_hba_inst))
19526 (SATA_DIP(sata_hba_inst), &sata_device);
19527 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex);
19528 sata_update_port_info(sata_hba_inst, &sata_device);
19529 if (rval != SATA_SUCCESS) {
19530 /* Something went wrong? Fail the port */
19531 cportinfo->cport_state = SATA_PSTATE_FAILED;
19532 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->
19533 cport_mutex);
19534 SATA_LOG_D((sata_hba_inst, CE_WARN,
19535 "SATA port %d probing failed",
19536 saddr->cport));
19537 /*
19538 * We may want to release device info structure, but
19539 * it is not necessary.
19540 */
19541 return;
19542 } else {
19543 /* port probed successfully */
19544 cportinfo->cport_state |= SATA_STATE_PROBED | SATA_STATE_READY;
19545 }
19546 /*
19547 * Check if a device is still attached. For sanity, check also
19548 * link status - if no link, there is no device.
19549 */
19550 if ((sata_device.satadev_scr.sstatus & SATA_PORT_DEVLINK_UP_MASK) ==
19551 SATA_PORT_DEVLINK_UP && sata_device.satadev_type !=
19552 SATA_DTYPE_NONE) {
19553 /*
19554 * Device is still attached - ignore detach event.
19555 */
19556 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->
19557 cport_mutex);
19558 SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst,
19559 "Ignoring detach - device still attached to port %d",
19560 sata_device.satadev_addr.cport);
19561 return;
19562 }
19563 /*
19564 * We need to detach and release device info structure here
19565 */
19566 if (cportinfo->cport_dev_type == SATA_DTYPE_PMULT) {
19567 /*
19568 * A port-multiplier is removed.
19569 *
19570 * Calling sata_process_pmdevice_detached() does not work
19571 * here. The port multiplier is gone, so we cannot probe
19572 * sub-port any more and all pmult-related data structure must
19573 * be de-allocated immediately. Following structure of every
19574 * implemented sub-port behind the pmult are required to
19575 * released.
19576 *
19577 * - attachment point
19578 * - target node
19579 * - sata_drive_info
19580 * - sata_pmport_info
19581 */
19582 for (npmport = 0; npmport < SATA_NUM_PMPORTS(sata_hba_inst,
19583 cport); npmport ++) {
19584 SATADBG2(SATA_DBG_PMULT|SATA_DBG_EVENTS_PROC,
19585 sata_hba_inst,
19586 "Detaching target node at port %d:%d",
19587 cport, npmport);
19588
19589 mutex_exit(&SATA_CPORT_MUTEX(sata_hba_inst, cport));
19590
19591 /* Remove attachment point. */
19592 name[0] = '\0';
19593 (void) sprintf(name, "%d.%d", cport, npmport);
19594 ddi_remove_minor_node(SATA_DIP(sata_hba_inst), name);
19595 sata_log(sata_hba_inst, CE_NOTE,
19596 "Remove attachment point of port %d:%d",
19597 cport, npmport);
19598
19599 /* Remove target node */
19600 pmport_addr.cport = cport;
19601 pmport_addr.pmport = (uint8_t)npmport;
19602 pmport_addr.qual = SATA_ADDR_PMPORT;
19603 sata_remove_target_node(sata_hba_inst, &pmport_addr);
19604
19605 mutex_enter(&SATA_CPORT_MUTEX(sata_hba_inst, cport));
19606
19607 /* Release sata_pmport_info & sata_drive_info. */
19608 pmportinfo = SATA_PMPORT_INFO(sata_hba_inst,
19609 cport, npmport);
19610 ASSERT(pmportinfo != NULL);
19611
19612 sdevinfo = SATA_PMPORTINFO_DRV_INFO(pmportinfo);
19613 if (sdevinfo != NULL) {
19614 (void) kmem_free((void *) sdevinfo,
19615 sizeof (sata_drive_info_t));
19616 }
19617
19618 /* Release sata_pmport_info at last */
19619 (void) kmem_free((void *) pmportinfo,
19620 sizeof (sata_pmport_info_t));
19621 }
19622
19623 /* Finally, release sata_pmult_info */
19624 (void) kmem_free((void *)
19625 SATA_CPORTINFO_PMULT_INFO(cportinfo),
19626 sizeof (sata_pmult_info_t));
19627 SATA_CPORTINFO_PMULT_INFO(cportinfo) = NULL;
19628
19629 sata_log(sata_hba_inst, CE_WARN,
19630 "SATA port-multiplier detached at port %d", cport);
19631
19632 cportinfo->cport_dev_type = SATA_DTYPE_NONE;
19633 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst,
19634 saddr->cport)->cport_mutex);
19635 } else {
19636 if (SATA_CPORTINFO_DRV_INFO(cportinfo) != NULL) {
19637 sdevinfo = SATA_CPORTINFO_DRV_INFO(cportinfo);
19638 SATA_CPORTINFO_DRV_INFO(cportinfo) = NULL;
19639 (void) kmem_free((void *)sdevinfo,
19640 sizeof (sata_drive_info_t));
19641 }
19642 sata_log(sata_hba_inst, CE_WARN,
19643 "SATA device detached at port %d", cport);
19644
19645 cportinfo->cport_dev_type = SATA_DTYPE_NONE;
19646 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst,
19647 saddr->cport)->cport_mutex);
19648
19649 /*
19650 * Try to offline a device and remove target node
19651 * if it still exists
19652 */
19653 sata_remove_target_node(sata_hba_inst, saddr);
19654 }
19655
19656
19657 /*
19658 * Generate sysevent - EC_DR / ESC_DR_AP_STATE_CHANGE
19659 * with the hint: SE_HINT_REMOVE
19660 */
19661 sata_gen_sysevent(sata_hba_inst, saddr, SE_HINT_REMOVE);
19662 }
19663
19664 /*
19665 * Port Multiplier Port Device Deattached Event processing.
19666 *
19667 * NOTE: No Mutex should be hold.
19668 */
19669 static void
19670 sata_process_pmdevice_detached(sata_hba_inst_t *sata_hba_inst,
19671 sata_address_t *saddr)
19672 {
19673 sata_pmport_info_t *pmportinfo;
19674 sata_drive_info_t *sdevinfo;
19675 sata_device_t sata_device;
19676 int rval;
19677 uint8_t cport, pmport;
19678
19679 cport = saddr->cport;
19680 pmport = saddr->pmport;
19681
19682 SATADBG2(SATA_DBG_EVENTS_PROC, sata_hba_inst,
19683 "Processing port %d:%d device detached",
19684 cport, pmport);
19685
19686 pmportinfo = SATA_PMPORT_INFO(sata_hba_inst, cport, pmport);
19687 mutex_enter(&SATA_PMPORT_MUTEX(sata_hba_inst, cport, pmport));
19688
19689 /* Clear event flag */
19690 pmportinfo->pmport_event_flags &= ~SATA_EVNT_DEVICE_DETACHED;
19691
19692 /* If the port is in SHUTDOWN or FAILED state, ignore detach event. */
19693 if ((pmportinfo->pmport_state &
19694 (SATA_PSTATE_SHUTDOWN | SATA_PSTATE_FAILED)) != 0) {
19695 mutex_exit(&SATA_PMPORT_MUTEX(sata_hba_inst, cport, pmport));
19696 return;
19697 }
19698 /* For sanity, re-probe the port */
19699 sata_device.satadev_rev = SATA_DEVICE_REV;
19700 sata_device.satadev_addr = *saddr;
19701
19702 /*
19703 * We have to exit mutex, because the HBA probe port function may
19704 * block on its own mutex.
19705 */
19706 mutex_exit(&SATA_PMPORT_MUTEX(sata_hba_inst, cport, pmport));
19707 rval = (*SATA_PROBE_PORT_FUNC(sata_hba_inst))
19708 (SATA_DIP(sata_hba_inst), &sata_device);
19709 mutex_enter(&SATA_PMPORT_MUTEX(sata_hba_inst, cport, pmport));
19710 sata_update_pmport_info(sata_hba_inst, &sata_device);
19711 if (rval != SATA_SUCCESS) {
19712 /* Something went wrong? Fail the port */
19713 pmportinfo->pmport_state = SATA_PSTATE_FAILED;
19714 mutex_exit(&SATA_PMPORT_MUTEX(sata_hba_inst, cport, pmport));
19715 SATA_LOG_D((sata_hba_inst, CE_WARN,
19716 "SATA port %d:%d probing failed",
19717 saddr->pmport));
19718 /*
19719 * We may want to release device info structure, but
19720 * it is not necessary.
19721 */
19722 return;
19723 } else {
19724 /* port probed successfully */
19725 pmportinfo->pmport_state |=
19726 SATA_STATE_PROBED | SATA_STATE_READY;
19727 }
19728 /*
19729 * Check if a device is still attached. For sanity, check also
19730 * link status - if no link, there is no device.
19731 */
19732 if ((sata_device.satadev_scr.sstatus & SATA_PORT_DEVLINK_UP_MASK) ==
19733 SATA_PORT_DEVLINK_UP && sata_device.satadev_type !=
19734 SATA_DTYPE_NONE) {
19735 /*
19736 * Device is still attached - ignore detach event.
19737 */
19738 mutex_exit(&SATA_PMPORT_MUTEX(sata_hba_inst, cport, pmport));
19739 SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst,
19740 "Ignoring detach - device still attached to port %d",
19741 sata_device.satadev_addr.pmport);
19742 return;
19743 }
19744 /*
19745 * We need to detach and release device info structure here
19746 */
19747 if (SATA_PMPORTINFO_DRV_INFO(pmportinfo) != NULL) {
19748 sdevinfo = SATA_PMPORTINFO_DRV_INFO(pmportinfo);
19749 SATA_PMPORTINFO_DRV_INFO(pmportinfo) = NULL;
19750 (void) kmem_free((void *)sdevinfo,
19751 sizeof (sata_drive_info_t));
19752 }
19753 pmportinfo->pmport_dev_type = SATA_DTYPE_NONE;
19754 /*
19755 * Device cannot be reached anymore, even if the target node may be
19756 * still present.
19757 */
19758 mutex_exit(&SATA_PMPORT_MUTEX(sata_hba_inst, cport, pmport));
19759
19760 /*
19761 * Try to offline a device and remove target node if it still exists
19762 */
19763 sata_remove_target_node(sata_hba_inst, saddr);
19764
19765 /*
19766 * Generate sysevent - EC_DR / ESC_DR_AP_STATE_CHANGE
19767 * with the hint: SE_HINT_REMOVE
19768 */
19769 sata_gen_sysevent(sata_hba_inst, saddr, SE_HINT_REMOVE);
19770 }
19771
19772
19773 /*
19774 * Device Attached Event processing.
19775 * Port state is checked to verify that a device is really attached. If so,
19776 * the device info structure is created and attached to the SATA port info
19777 * structure.
19778 *
19779 * If attached device cannot be identified or set-up, the retry for the
19780 * attach processing is set-up. Subsequent daemon run would try again to
19781 * identify the device, until the time limit is reached
19782 * (SATA_DEV_IDENTIFY_TIMEOUT).
19783 *
19784 * This function cannot be called in interrupt context (it may sleep).
19785 *
19786 * NOTE: Port multiplier ports events are handled by
19787 * sata_process_pmdevice_attached()
19788 */
19789 static void
19790 sata_process_device_attached(sata_hba_inst_t *sata_hba_inst,
19791 sata_address_t *saddr)
19792 {
19793 sata_cport_info_t *cportinfo = NULL;
19794 sata_drive_info_t *sdevinfo = NULL;
19795 sata_pmult_info_t *pmultinfo = NULL;
19796 sata_pmport_info_t *pmportinfo = NULL;
19797 sata_device_t sata_device;
19798 dev_info_t *tdip;
19799 uint32_t event_flags = 0, pmult_event_flags = 0;
19800 int rval;
19801 int npmport;
19802
19803 SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst,
19804 "Processing port %d device attached", saddr->cport);
19805
19806 cportinfo = SATA_CPORT_INFO(sata_hba_inst, saddr->cport);
19807 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex);
19808
19809 /* Clear attach event flag first */
19810 cportinfo->cport_event_flags &= ~SATA_EVNT_DEVICE_ATTACHED;
19811
19812 /* If the port is in SHUTDOWN or FAILED state, ignore event. */
19813 if ((cportinfo->cport_state &
19814 (SATA_PSTATE_SHUTDOWN | SATA_PSTATE_FAILED)) != 0) {
19815 cportinfo->cport_dev_attach_time = 0;
19816 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->
19817 cport_mutex);
19818 return;
19819 }
19820
19821 /*
19822 * If the sata_drive_info structure is found attached to the port info,
19823 * despite the fact the device was removed and now it is re-attached,
19824 * the old drive info structure was not removed.
19825 * Arbitrarily release device info structure.
19826 */
19827 if (SATA_CPORTINFO_DRV_INFO(cportinfo) != NULL) {
19828 sdevinfo = SATA_CPORTINFO_DRV_INFO(cportinfo);
19829 SATA_CPORTINFO_DRV_INFO(cportinfo) = NULL;
19830 (void) kmem_free((void *)sdevinfo,
19831 sizeof (sata_drive_info_t));
19832 SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst,
19833 "Arbitrarily detaching old device info.", NULL);
19834 }
19835 cportinfo->cport_dev_type = SATA_DTYPE_NONE;
19836
19837 /* For sanity, re-probe the port */
19838 sata_device.satadev_rev = SATA_DEVICE_REV;
19839 sata_device.satadev_addr = *saddr;
19840
19841 /*
19842 * We have to exit mutex, because the HBA probe port function may
19843 * block on its own mutex.
19844 */
19845 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex);
19846 rval = (*SATA_PROBE_PORT_FUNC(sata_hba_inst))
19847 (SATA_DIP(sata_hba_inst), &sata_device);
19848 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex);
19849 sata_update_port_info(sata_hba_inst, &sata_device);
19850 if (rval != SATA_SUCCESS) {
19851 /* Something went wrong? Fail the port */
19852 cportinfo->cport_state = SATA_PSTATE_FAILED;
19853 cportinfo->cport_dev_attach_time = 0;
19854 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->
19855 cport_mutex);
19856 SATA_LOG_D((sata_hba_inst, CE_WARN,
19857 "SATA port %d probing failed",
19858 saddr->cport));
19859 return;
19860 } else {
19861 /* port probed successfully */
19862 cportinfo->cport_state |= SATA_STATE_PROBED | SATA_STATE_READY;
19863 }
19864 /*
19865 * Check if a device is still attached. For sanity, check also
19866 * link status - if no link, there is no device.
19867 */
19868 if ((sata_device.satadev_scr.sstatus & SATA_PORT_DEVLINK_UP_MASK) !=
19869 SATA_PORT_DEVLINK_UP || sata_device.satadev_type ==
19870 SATA_DTYPE_NONE) {
19871 /*
19872 * No device - ignore attach event.
19873 */
19874 cportinfo->cport_dev_attach_time = 0;
19875 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->
19876 cport_mutex);
19877 SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst,
19878 "Ignoring attach - no device connected to port %d",
19879 sata_device.satadev_addr.cport);
19880 return;
19881 }
19882
19883 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex);
19884 /*
19885 * Generate sysevent - EC_DR / ESC_DR_AP_STATE_CHANGE
19886 * with the hint: SE_HINT_INSERT
19887 */
19888 sata_gen_sysevent(sata_hba_inst, saddr, SE_HINT_INSERT);
19889
19890 /*
19891 * Port reprobing will take care of the creation of the device
19892 * info structure and determination of the device type.
19893 */
19894 sata_device.satadev_addr = *saddr;
19895 (void) sata_reprobe_port(sata_hba_inst, &sata_device,
19896 SATA_DEV_IDENTIFY_NORETRY);
19897
19898 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->
19899 cport_mutex);
19900 if ((cportinfo->cport_state & SATA_STATE_READY) &&
19901 (cportinfo->cport_dev_type != SATA_DTYPE_NONE)) {
19902 /* Some device is attached to the port */
19903 if (cportinfo->cport_dev_type == SATA_DTYPE_UNKNOWN) {
19904 /*
19905 * A device was not successfully attached.
19906 * Track retry time for device identification.
19907 */
19908 if (cportinfo->cport_dev_attach_time != 0) {
19909 clock_t cur_time = ddi_get_lbolt();
19910 /*
19911 * If the retry time limit was not exceeded,
19912 * reinstate attach event.
19913 */
19914 if ((cur_time -
19915 cportinfo->cport_dev_attach_time) <
19916 drv_usectohz(
19917 SATA_DEV_IDENTIFY_TIMEOUT)) {
19918 /* OK, restore attach event */
19919 cportinfo->cport_event_flags |=
19920 SATA_EVNT_DEVICE_ATTACHED;
19921 } else {
19922 /* Timeout - cannot identify device */
19923 cportinfo->cport_dev_attach_time = 0;
19924 sata_log(sata_hba_inst,
19925 CE_WARN,
19926 "Could not identify SATA device "
19927 "at port %d",
19928 saddr->cport);
19929 }
19930 } else {
19931 /*
19932 * Start tracking time for device
19933 * identification.
19934 * Save current time (lbolt value).
19935 */
19936 cportinfo->cport_dev_attach_time =
19937 ddi_get_lbolt();
19938 /* Restore attach event */
19939 cportinfo->cport_event_flags |=
19940 SATA_EVNT_DEVICE_ATTACHED;
19941 }
19942 } else if (cportinfo->cport_dev_type == SATA_DTYPE_PMULT) {
19943 cportinfo->cport_dev_attach_time = 0;
19944 sata_log(sata_hba_inst, CE_NOTE,
19945 "SATA port-multiplier detected at port %d",
19946 saddr->cport);
19947
19948 if (SATA_CPORTINFO_PMULT_INFO(cportinfo) != NULL) {
19949 /* Log the info of new port multiplier */
19950 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst,
19951 saddr->cport)->cport_mutex);
19952 sata_show_pmult_info(sata_hba_inst,
19953 &sata_device);
19954 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst,
19955 saddr->cport)->cport_mutex);
19956 }
19957
19958 ASSERT(SATA_CPORTINFO_PMULT_INFO(cportinfo) != NULL);
19959 pmultinfo = SATA_CPORTINFO_PMULT_INFO(cportinfo);
19960 for (npmport = 0; npmport <
19961 pmultinfo->pmult_num_dev_ports; npmport++) {
19962 pmportinfo = SATA_PMPORT_INFO(sata_hba_inst,
19963 saddr->cport, npmport);
19964 ASSERT(pmportinfo != NULL);
19965
19966 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst,
19967 saddr->cport)->cport_mutex);
19968 mutex_enter(&pmportinfo->pmport_mutex);
19969 /* Marked all pmports with link events. */
19970 pmportinfo->pmport_event_flags =
19971 SATA_EVNT_LINK_ESTABLISHED;
19972 pmult_event_flags |=
19973 pmportinfo->pmport_event_flags;
19974 mutex_exit(&pmportinfo->pmport_mutex);
19975 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst,
19976 saddr->cport)->cport_mutex);
19977 }
19978 /* Auto-online is not available for PMult now. */
19979
19980 } else {
19981 /*
19982 * If device was successfully attached, the subsequent
19983 * action depends on a state of the
19984 * sata_auto_online variable. If it is set to zero.
19985 * an explicit 'configure' command will be needed to
19986 * configure it. If its value is non-zero, we will
19987 * attempt to online (configure) the device.
19988 * First, log the message indicating that a device
19989 * was attached.
19990 */
19991 cportinfo->cport_dev_attach_time = 0;
19992 sata_log(sata_hba_inst, CE_WARN,
19993 "SATA device detected at port %d", saddr->cport);
19994
19995 if (SATA_CPORTINFO_DRV_INFO(cportinfo) != NULL) {
19996 sata_drive_info_t new_sdinfo;
19997
19998 /* Log device info data */
19999 new_sdinfo = *(SATA_CPORTINFO_DRV_INFO(
20000 cportinfo));
20001 sata_show_drive_info(sata_hba_inst,
20002 &new_sdinfo);
20003 }
20004
20005 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst,
20006 saddr->cport)->cport_mutex);
20007
20008 /*
20009 * Make sure that there is no target node for that
20010 * device. If so, release it. It should not happen,
20011 * unless we had problem removing the node when
20012 * device was detached.
20013 */
20014 tdip = sata_get_target_dip(SATA_DIP(sata_hba_inst),
20015 saddr->cport, saddr->pmport);
20016 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst,
20017 saddr->cport)->cport_mutex);
20018 if (tdip != NULL) {
20019
20020 #ifdef SATA_DEBUG
20021 if ((cportinfo->cport_event_flags &
20022 SATA_EVNT_TARGET_NODE_CLEANUP) == 0)
20023 sata_log(sata_hba_inst, CE_WARN,
20024 "sata_process_device_attached: "
20025 "old device target node exists!");
20026 #endif
20027 /*
20028 * target node exists - try to unconfigure
20029 * device and remove the node.
20030 */
20031 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst,
20032 saddr->cport)->cport_mutex);
20033 rval = ndi_devi_offline(tdip,
20034 NDI_DEVI_REMOVE);
20035 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst,
20036 saddr->cport)->cport_mutex);
20037
20038 if (rval == NDI_SUCCESS) {
20039 cportinfo->cport_event_flags &=
20040 ~SATA_EVNT_TARGET_NODE_CLEANUP;
20041 cportinfo->cport_tgtnode_clean = B_TRUE;
20042 } else {
20043 /*
20044 * PROBLEM - the target node remained
20045 * and it belongs to a previously
20046 * attached device.
20047 * This happens when the file was open
20048 * or the node was waiting for
20049 * resources at the time the
20050 * associated device was removed.
20051 * Instruct event daemon to retry the
20052 * cleanup later.
20053 */
20054 sata_log(sata_hba_inst,
20055 CE_WARN,
20056 "Application(s) accessing "
20057 "previously attached SATA "
20058 "device have to release "
20059 "it before newly inserted "
20060 "device can be made accessible.",
20061 saddr->cport);
20062 cportinfo->cport_event_flags |=
20063 SATA_EVNT_TARGET_NODE_CLEANUP;
20064 cportinfo->cport_tgtnode_clean =
20065 B_FALSE;
20066 }
20067 }
20068 if (sata_auto_online != 0) {
20069 cportinfo->cport_event_flags |=
20070 SATA_EVNT_AUTOONLINE_DEVICE;
20071 }
20072
20073 }
20074 } else {
20075 cportinfo->cport_dev_attach_time = 0;
20076 }
20077
20078 event_flags = cportinfo->cport_event_flags;
20079 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex);
20080 if (event_flags != 0 || pmult_event_flags != 0) {
20081 mutex_enter(&sata_hba_inst->satahba_mutex);
20082 sata_hba_inst->satahba_event_flags |= SATA_EVNT_MAIN;
20083 mutex_exit(&sata_hba_inst->satahba_mutex);
20084 mutex_enter(&sata_mutex);
20085 sata_event_pending |= SATA_EVNT_MAIN;
20086 mutex_exit(&sata_mutex);
20087 }
20088 }
20089
20090 /*
20091 * Port Multiplier Port Device Attached Event processing.
20092 *
20093 * NOTE: No Mutex should be hold.
20094 */
20095 static void
20096 sata_process_pmdevice_attached(sata_hba_inst_t *sata_hba_inst,
20097 sata_address_t *saddr)
20098 {
20099 sata_pmport_info_t *pmportinfo;
20100 sata_drive_info_t *sdinfo;
20101 sata_device_t sata_device;
20102 dev_info_t *tdip;
20103 uint32_t event_flags;
20104 uint8_t cport = saddr->cport;
20105 uint8_t pmport = saddr->pmport;
20106 int rval;
20107
20108 SATADBG2(SATA_DBG_EVENTS_PROC, sata_hba_inst,
20109 "Processing port %d:%d device attached", cport, pmport);
20110
20111 pmportinfo = SATA_PMPORT_INFO(sata_hba_inst, cport, pmport);
20112
20113 mutex_enter(&pmportinfo->pmport_mutex);
20114
20115 /* Clear attach event flag first */
20116 pmportinfo->pmport_event_flags &= ~SATA_EVNT_DEVICE_ATTACHED;
20117
20118 /* If the port is in SHUTDOWN or FAILED state, ignore event. */
20119 if ((pmportinfo->pmport_state &
20120 (SATA_PSTATE_SHUTDOWN | SATA_PSTATE_FAILED)) != 0) {
20121 pmportinfo->pmport_dev_attach_time = 0;
20122 mutex_exit(&pmportinfo->pmport_mutex);
20123 return;
20124 }
20125
20126 /*
20127 * If the sata_drive_info structure is found attached to the port info,
20128 * despite the fact the device was removed and now it is re-attached,
20129 * the old drive info structure was not removed.
20130 * Arbitrarily release device info structure.
20131 */
20132 if (SATA_PMPORTINFO_DRV_INFO(pmportinfo) != NULL) {
20133 sdinfo = SATA_PMPORTINFO_DRV_INFO(pmportinfo);
20134 SATA_PMPORTINFO_DRV_INFO(pmportinfo) = NULL;
20135 (void) kmem_free((void *)sdinfo,
20136 sizeof (sata_drive_info_t));
20137 SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst,
20138 "Arbitrarily detaching old device info.", NULL);
20139 }
20140 pmportinfo->pmport_dev_type = SATA_DTYPE_NONE;
20141
20142 /* For sanity, re-probe the port */
20143 sata_device.satadev_rev = SATA_DEVICE_REV;
20144 sata_device.satadev_addr = *saddr;
20145
20146 /*
20147 * We have to exit mutex, because the HBA probe port function may
20148 * block on its own mutex.
20149 */
20150 mutex_exit(&pmportinfo->pmport_mutex);
20151 rval = (*SATA_PROBE_PORT_FUNC(sata_hba_inst))
20152 (SATA_DIP(sata_hba_inst), &sata_device);
20153 mutex_enter(&pmportinfo->pmport_mutex);
20154
20155 sata_update_pmport_info(sata_hba_inst, &sata_device);
20156 if (rval != SATA_SUCCESS) {
20157 /* Something went wrong? Fail the port */
20158 pmportinfo->pmport_state = SATA_PSTATE_FAILED;
20159 pmportinfo->pmport_dev_attach_time = 0;
20160 mutex_exit(&pmportinfo->pmport_mutex);
20161 SATA_LOG_D((sata_hba_inst, CE_WARN,
20162 "SATA port %d:%d probing failed", cport, pmport));
20163 return;
20164 } else {
20165 /* pmport probed successfully */
20166 pmportinfo->pmport_state |=
20167 SATA_STATE_PROBED | SATA_STATE_READY;
20168 }
20169 /*
20170 * Check if a device is still attached. For sanity, check also
20171 * link status - if no link, there is no device.
20172 */
20173 if ((sata_device.satadev_scr.sstatus & SATA_PORT_DEVLINK_UP_MASK) !=
20174 SATA_PORT_DEVLINK_UP || sata_device.satadev_type ==
20175 SATA_DTYPE_NONE) {
20176 /*
20177 * No device - ignore attach event.
20178 */
20179 pmportinfo->pmport_dev_attach_time = 0;
20180 mutex_exit(&pmportinfo->pmport_mutex);
20181 SATADBG2(SATA_DBG_EVENTS_PROC, sata_hba_inst,
20182 "Ignoring attach - no device connected to port %d:%d",
20183 cport, pmport);
20184 return;
20185 }
20186
20187 mutex_exit(&pmportinfo->pmport_mutex);
20188 /*
20189 * Generate sysevent - EC_DR / ESC_DR_AP_STATE_CHANGE
20190 * with the hint: SE_HINT_INSERT
20191 */
20192 sata_gen_sysevent(sata_hba_inst, saddr, SE_HINT_INSERT);
20193
20194 /*
20195 * Port reprobing will take care of the creation of the device
20196 * info structure and determination of the device type.
20197 */
20198 sata_device.satadev_addr = *saddr;
20199 (void) sata_reprobe_port(sata_hba_inst, &sata_device,
20200 SATA_DEV_IDENTIFY_NORETRY);
20201
20202 mutex_enter(&pmportinfo->pmport_mutex);
20203 if ((pmportinfo->pmport_state & SATA_STATE_READY) &&
20204 (pmportinfo->pmport_dev_type != SATA_DTYPE_NONE)) {
20205 /* Some device is attached to the port */
20206 if (pmportinfo->pmport_dev_type == SATA_DTYPE_UNKNOWN) {
20207 /*
20208 * A device was not successfully attached.
20209 * Track retry time for device identification.
20210 */
20211 if (pmportinfo->pmport_dev_attach_time != 0) {
20212 clock_t cur_time = ddi_get_lbolt();
20213 /*
20214 * If the retry time limit was not exceeded,
20215 * reinstate attach event.
20216 */
20217 if ((cur_time -
20218 pmportinfo->pmport_dev_attach_time) <
20219 drv_usectohz(
20220 SATA_DEV_IDENTIFY_TIMEOUT)) {
20221 /* OK, restore attach event */
20222 pmportinfo->pmport_event_flags |=
20223 SATA_EVNT_DEVICE_ATTACHED;
20224 } else {
20225 /* Timeout - cannot identify device */
20226 pmportinfo->pmport_dev_attach_time = 0;
20227 sata_log(sata_hba_inst, CE_WARN,
20228 "Could not identify SATA device "
20229 "at port %d:%d",
20230 cport, pmport);
20231 }
20232 } else {
20233 /*
20234 * Start tracking time for device
20235 * identification.
20236 * Save current time (lbolt value).
20237 */
20238 pmportinfo->pmport_dev_attach_time =
20239 ddi_get_lbolt();
20240 /* Restore attach event */
20241 pmportinfo->pmport_event_flags |=
20242 SATA_EVNT_DEVICE_ATTACHED;
20243 }
20244 } else {
20245 /*
20246 * If device was successfully attached, the subsequent
20247 * action depends on a state of the
20248 * sata_auto_online variable. If it is set to zero.
20249 * an explicit 'configure' command will be needed to
20250 * configure it. If its value is non-zero, we will
20251 * attempt to online (configure) the device.
20252 * First, log the message indicating that a device
20253 * was attached.
20254 */
20255 pmportinfo->pmport_dev_attach_time = 0;
20256 sata_log(sata_hba_inst, CE_WARN,
20257 "SATA device detected at port %d:%d",
20258 cport, pmport);
20259
20260 if (SATA_PMPORTINFO_DRV_INFO(pmportinfo) != NULL) {
20261 sata_drive_info_t new_sdinfo;
20262
20263 /* Log device info data */
20264 new_sdinfo = *(SATA_PMPORTINFO_DRV_INFO(
20265 pmportinfo));
20266 sata_show_drive_info(sata_hba_inst,
20267 &new_sdinfo);
20268 }
20269
20270 mutex_exit(&pmportinfo->pmport_mutex);
20271
20272 /*
20273 * Make sure that there is no target node for that
20274 * device. If so, release it. It should not happen,
20275 * unless we had problem removing the node when
20276 * device was detached.
20277 */
20278 tdip = sata_get_target_dip(SATA_DIP(sata_hba_inst),
20279 saddr->cport, saddr->pmport);
20280 mutex_enter(&pmportinfo->pmport_mutex);
20281 if (tdip != NULL) {
20282
20283 #ifdef SATA_DEBUG
20284 if ((pmportinfo->pmport_event_flags &
20285 SATA_EVNT_TARGET_NODE_CLEANUP) == 0)
20286 sata_log(sata_hba_inst, CE_WARN,
20287 "sata_process_device_attached: "
20288 "old device target node exists!");
20289 #endif
20290 /*
20291 * target node exists - try to unconfigure
20292 * device and remove the node.
20293 */
20294 mutex_exit(&pmportinfo->pmport_mutex);
20295 rval = ndi_devi_offline(tdip,
20296 NDI_DEVI_REMOVE);
20297 mutex_enter(&pmportinfo->pmport_mutex);
20298
20299 if (rval == NDI_SUCCESS) {
20300 pmportinfo->pmport_event_flags &=
20301 ~SATA_EVNT_TARGET_NODE_CLEANUP;
20302 pmportinfo->pmport_tgtnode_clean =
20303 B_TRUE;
20304 } else {
20305 /*
20306 * PROBLEM - the target node remained
20307 * and it belongs to a previously
20308 * attached device.
20309 * This happens when the file was open
20310 * or the node was waiting for
20311 * resources at the time the
20312 * associated device was removed.
20313 * Instruct event daemon to retry the
20314 * cleanup later.
20315 */
20316 sata_log(sata_hba_inst,
20317 CE_WARN,
20318 "Application(s) accessing "
20319 "previously attached SATA "
20320 "device have to release "
20321 "it before newly inserted "
20322 "device can be made accessible."
20323 "at port %d:%d",
20324 cport, pmport);
20325 pmportinfo->pmport_event_flags |=
20326 SATA_EVNT_TARGET_NODE_CLEANUP;
20327 pmportinfo->pmport_tgtnode_clean =
20328 B_FALSE;
20329 }
20330 }
20331 if (sata_auto_online != 0) {
20332 pmportinfo->pmport_event_flags |=
20333 SATA_EVNT_AUTOONLINE_DEVICE;
20334 }
20335
20336 }
20337 } else {
20338 pmportinfo->pmport_dev_attach_time = 0;
20339 }
20340
20341 event_flags = pmportinfo->pmport_event_flags;
20342 mutex_exit(&pmportinfo->pmport_mutex);
20343 if (event_flags != 0) {
20344 mutex_enter(&sata_hba_inst->satahba_mutex);
20345 sata_hba_inst->satahba_event_flags |= SATA_EVNT_MAIN;
20346 mutex_exit(&sata_hba_inst->satahba_mutex);
20347 mutex_enter(&sata_mutex);
20348 sata_event_pending |= SATA_EVNT_MAIN;
20349 mutex_exit(&sata_mutex);
20350 }
20351
20352 /* clear the reset_in_progress events */
20353 if (SATA_PMPORTINFO_DRV_INFO(pmportinfo) != NULL) {
20354 if (pmportinfo->pmport_dev_type & SATA_VALID_DEV_TYPE) {
20355 /* must clear flags on cport */
20356 sata_pmult_info_t *pminfo =
20357 SATA_PMULT_INFO(sata_hba_inst,
20358 saddr->cport);
20359 pminfo->pmult_event_flags |=
20360 SATA_EVNT_CLEAR_DEVICE_RESET;
20361 }
20362 }
20363 }
20364
20365 /*
20366 * Device Target Node Cleanup Event processing.
20367 * If the target node associated with a sata port device is in
20368 * DEVI_DEVICE_REMOVED state, an attempt is made to remove it.
20369 * If the target node cannot be removed, the event flag is left intact,
20370 * so that event daemon may re-run this function later.
20371 *
20372 * This function cannot be called in interrupt context (it may sleep).
20373 *
20374 * NOTE: Processes cport events only, not port multiplier ports.
20375 */
20376 static void
20377 sata_process_target_node_cleanup(sata_hba_inst_t *sata_hba_inst,
20378 sata_address_t *saddr)
20379 {
20380 sata_cport_info_t *cportinfo;
20381 dev_info_t *tdip;
20382
20383 SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst,
20384 "Processing port %d device target node cleanup", saddr->cport);
20385
20386 cportinfo = SATA_CPORT_INFO(sata_hba_inst, saddr->cport);
20387
20388 /*
20389 * Check if there is target node for that device and it is in the
20390 * DEVI_DEVICE_REMOVED state. If so, release it.
20391 */
20392 tdip = sata_get_target_dip(SATA_DIP(sata_hba_inst), saddr->cport,
20393 saddr->pmport);
20394 if (tdip != NULL) {
20395 /*
20396 * target node exists - check if it is target node of
20397 * a removed device.
20398 */
20399 if (sata_check_device_removed(tdip) == B_TRUE) {
20400 SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst,
20401 "sata_process_target_node_cleanup: "
20402 "old device target node exists!", NULL);
20403 /*
20404 * Unconfigure and remove the target node
20405 */
20406 if (ndi_devi_offline(tdip, NDI_DEVI_REMOVE) ==
20407 NDI_SUCCESS) {
20408 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst,
20409 saddr->cport)->cport_mutex);
20410 cportinfo->cport_event_flags &=
20411 ~SATA_EVNT_TARGET_NODE_CLEANUP;
20412 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst,
20413 saddr->cport)->cport_mutex);
20414 return;
20415 }
20416 /*
20417 * Event daemon will retry the cleanup later.
20418 */
20419 mutex_enter(&sata_hba_inst->satahba_mutex);
20420 sata_hba_inst->satahba_event_flags |= SATA_EVNT_MAIN;
20421 mutex_exit(&sata_hba_inst->satahba_mutex);
20422 mutex_enter(&sata_mutex);
20423 sata_event_pending |= SATA_EVNT_MAIN;
20424 mutex_exit(&sata_mutex);
20425 }
20426 } else {
20427 if (saddr->qual == SATA_ADDR_CPORT ||
20428 saddr->qual == SATA_ADDR_DCPORT) {
20429 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst,
20430 saddr->cport)->cport_mutex);
20431 cportinfo->cport_event_flags &=
20432 ~SATA_EVNT_TARGET_NODE_CLEANUP;
20433 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst,
20434 saddr->cport)->cport_mutex);
20435 } else {
20436 /* sanity check */
20437 if (SATA_CPORT_DEV_TYPE(sata_hba_inst, saddr->cport) !=
20438 SATA_DTYPE_PMULT || SATA_PMULT_INFO(sata_hba_inst,
20439 saddr->cport) == NULL)
20440 return;
20441 if (SATA_PMPORT_INFO(sata_hba_inst, saddr->cport,
20442 saddr->pmport) == NULL)
20443 return;
20444
20445 mutex_enter(&SATA_PMPORT_INFO(sata_hba_inst,
20446 saddr->cport, saddr->pmport)->pmport_mutex);
20447 SATA_PMPORT_INFO(sata_hba_inst, saddr->cport,
20448 saddr->pmport)->pmport_event_flags &=
20449 ~SATA_EVNT_TARGET_NODE_CLEANUP;
20450 mutex_exit(&SATA_PMPORT_INFO(sata_hba_inst,
20451 saddr->cport, saddr->pmport)->pmport_mutex);
20452 }
20453 }
20454 }
20455
20456 /*
20457 * Device AutoOnline Event processing.
20458 * If attached device is to be onlined, an attempt is made to online this
20459 * device, but only if there is no lingering (old) target node present.
20460 * If the device cannot be onlined, the event flag is left intact,
20461 * so that event daemon may re-run this function later.
20462 *
20463 * This function cannot be called in interrupt context (it may sleep).
20464 *
20465 * NOTE: Processes cport events only, not port multiplier ports.
20466 */
20467 static void
20468 sata_process_device_autoonline(sata_hba_inst_t *sata_hba_inst,
20469 sata_address_t *saddr)
20470 {
20471 sata_cport_info_t *cportinfo;
20472 sata_drive_info_t *sdinfo;
20473 sata_device_t sata_device;
20474 dev_info_t *tdip;
20475
20476 SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst,
20477 "Processing port %d attached device auto-onlining", saddr->cport);
20478
20479 cportinfo = SATA_CPORT_INFO(sata_hba_inst, saddr->cport);
20480
20481 /*
20482 * Check if device is present and recognized. If not, reset event.
20483 */
20484 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex);
20485 if ((cportinfo->cport_dev_type & SATA_VALID_DEV_TYPE) == 0) {
20486 /* Nothing to online */
20487 cportinfo->cport_event_flags &= ~SATA_EVNT_AUTOONLINE_DEVICE;
20488 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst,
20489 saddr->cport)->cport_mutex);
20490 return;
20491 }
20492 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex);
20493
20494 /*
20495 * Check if there is target node for this device and if it is in the
20496 * DEVI_DEVICE_REMOVED state. If so, abort onlining but keep
20497 * the event for later processing.
20498 */
20499 tdip = sata_get_target_dip(SATA_DIP(sata_hba_inst), saddr->cport,
20500 saddr->pmport);
20501 if (tdip != NULL) {
20502 /*
20503 * target node exists - check if it is target node of
20504 * a removed device.
20505 */
20506 if (sata_check_device_removed(tdip) == B_TRUE) {
20507 SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst,
20508 "sata_process_device_autoonline: "
20509 "old device target node exists!", NULL);
20510 /*
20511 * Event daemon will retry device onlining later.
20512 */
20513 mutex_enter(&sata_hba_inst->satahba_mutex);
20514 sata_hba_inst->satahba_event_flags |= SATA_EVNT_MAIN;
20515 mutex_exit(&sata_hba_inst->satahba_mutex);
20516 mutex_enter(&sata_mutex);
20517 sata_event_pending |= SATA_EVNT_MAIN;
20518 mutex_exit(&sata_mutex);
20519 return;
20520 }
20521 /*
20522 * If the target node is not in the 'removed" state, assume
20523 * that it belongs to this device. There is nothing more to do,
20524 * but reset the event.
20525 */
20526 } else {
20527
20528 /*
20529 * Try to online the device
20530 * If there is any reset-related event, remove it. We are
20531 * configuring the device and no state restoring is needed.
20532 */
20533 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst,
20534 saddr->cport)->cport_mutex);
20535 sata_device.satadev_addr = *saddr;
20536 if (saddr->qual == SATA_ADDR_CPORT)
20537 sata_device.satadev_addr.qual = SATA_ADDR_DCPORT;
20538 else
20539 sata_device.satadev_addr.qual = SATA_ADDR_DPMPORT;
20540 sdinfo = sata_get_device_info(sata_hba_inst, &sata_device);
20541 if (sdinfo != NULL) {
20542 if (sdinfo->satadrv_event_flags &
20543 (SATA_EVNT_DEVICE_RESET |
20544 SATA_EVNT_INPROC_DEVICE_RESET))
20545 sdinfo->satadrv_event_flags = 0;
20546 sdinfo->satadrv_event_flags |=
20547 SATA_EVNT_CLEAR_DEVICE_RESET;
20548
20549 /* Need to create a new target node. */
20550 cportinfo->cport_tgtnode_clean = B_TRUE;
20551 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst,
20552 saddr->cport)->cport_mutex);
20553 tdip = sata_create_target_node(SATA_DIP(sata_hba_inst),
20554 sata_hba_inst, &sata_device.satadev_addr);
20555 if (tdip == NULL) {
20556 /*
20557 * Configure (onlining) failed.
20558 * We will NOT retry
20559 */
20560 SATA_LOG_D((sata_hba_inst, CE_WARN,
20561 "sata_process_device_autoonline: "
20562 "configuring SATA device at port %d failed",
20563 saddr->cport));
20564 }
20565 } else {
20566 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst,
20567 saddr->cport)->cport_mutex);
20568 }
20569
20570 }
20571 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex);
20572 cportinfo->cport_event_flags &= ~SATA_EVNT_AUTOONLINE_DEVICE;
20573 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst,
20574 saddr->cport)->cport_mutex);
20575 }
20576
20577
20578 static void
20579 sata_gen_sysevent(sata_hba_inst_t *sata_hba_inst, sata_address_t *saddr,
20580 int hint)
20581 {
20582 char ap[MAXPATHLEN];
20583 nvlist_t *ev_attr_list = NULL;
20584 int err;
20585
20586 /* Allocate and build sysevent attribute list */
20587 err = nvlist_alloc(&ev_attr_list, NV_UNIQUE_NAME_TYPE, DDI_NOSLEEP);
20588 if (err != 0) {
20589 SATA_LOG_D((sata_hba_inst, CE_WARN,
20590 "sata_gen_sysevent: "
20591 "cannot allocate memory for sysevent attributes\n"));
20592 return;
20593 }
20594 /* Add hint attribute */
20595 err = nvlist_add_string(ev_attr_list, DR_HINT, SE_HINT2STR(hint));
20596 if (err != 0) {
20597 SATA_LOG_D((sata_hba_inst, CE_WARN,
20598 "sata_gen_sysevent: "
20599 "failed to add DR_HINT attr for sysevent"));
20600 nvlist_free(ev_attr_list);
20601 return;
20602 }
20603 /*
20604 * Add AP attribute.
20605 * Get controller pathname and convert it into AP pathname by adding
20606 * a target number.
20607 */
20608 (void) snprintf(ap, MAXPATHLEN, "/devices");
20609 (void) ddi_pathname(SATA_DIP(sata_hba_inst), ap + strlen(ap));
20610 (void) snprintf(ap + strlen(ap), MAXPATHLEN - strlen(ap), ":%d",
20611 SATA_MAKE_AP_NUMBER(saddr->cport, saddr->pmport, saddr->qual));
20612
20613 err = nvlist_add_string(ev_attr_list, DR_AP_ID, ap);
20614 if (err != 0) {
20615 SATA_LOG_D((sata_hba_inst, CE_WARN,
20616 "sata_gen_sysevent: "
20617 "failed to add DR_AP_ID attr for sysevent"));
20618 nvlist_free(ev_attr_list);
20619 return;
20620 }
20621
20622 /* Generate/log sysevent */
20623 err = ddi_log_sysevent(SATA_DIP(sata_hba_inst), DDI_VENDOR_SUNW, EC_DR,
20624 ESC_DR_AP_STATE_CHANGE, ev_attr_list, NULL, DDI_NOSLEEP);
20625 if (err != DDI_SUCCESS) {
20626 SATA_LOG_D((sata_hba_inst, CE_WARN,
20627 "sata_gen_sysevent: "
20628 "cannot log sysevent, err code %x\n", err));
20629 }
20630
20631 nvlist_free(ev_attr_list);
20632 }
20633
20634
20635
20636
20637 /*
20638 * Set DEVI_DEVICE_REMOVED state in the SATA device target node.
20639 */
20640 static void
20641 sata_set_device_removed(dev_info_t *tdip)
20642 {
20643 int circ;
20644
20645 ASSERT(tdip != NULL);
20646
20647 ndi_devi_enter(tdip, &circ);
20648 mutex_enter(&DEVI(tdip)->devi_lock);
20649 DEVI_SET_DEVICE_REMOVED(tdip);
20650 mutex_exit(&DEVI(tdip)->devi_lock);
20651 ndi_devi_exit(tdip, circ);
20652 }
20653
20654
20655 /*
20656 * Set internal event instructing event daemon to try
20657 * to perform the target node cleanup.
20658 */
20659 static void
20660 sata_set_target_node_cleanup(sata_hba_inst_t *sata_hba_inst,
20661 sata_address_t *saddr)
20662 {
20663 if (saddr->qual == SATA_ADDR_CPORT ||
20664 saddr->qual == SATA_ADDR_DCPORT) {
20665 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst,
20666 saddr->cport)->cport_mutex);
20667 SATA_CPORT_EVENT_FLAGS(sata_hba_inst, saddr->cport) |=
20668 SATA_EVNT_TARGET_NODE_CLEANUP;
20669 SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->
20670 cport_tgtnode_clean = B_FALSE;
20671 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst,
20672 saddr->cport)->cport_mutex);
20673 } else {
20674 mutex_enter(&SATA_PMPORT_INFO(sata_hba_inst,
20675 saddr->cport, saddr->pmport)->pmport_mutex);
20676 SATA_PMPORT_EVENT_FLAGS(sata_hba_inst, saddr->cport,
20677 saddr->pmport) |= SATA_EVNT_TARGET_NODE_CLEANUP;
20678 SATA_PMPORT_INFO(sata_hba_inst, saddr->cport, saddr->pmport)->
20679 pmport_tgtnode_clean = B_FALSE;
20680 mutex_exit(&SATA_PMPORT_INFO(sata_hba_inst,
20681 saddr->cport, saddr->pmport)->pmport_mutex);
20682 }
20683 mutex_enter(&sata_hba_inst->satahba_mutex);
20684 sata_hba_inst->satahba_event_flags |= SATA_EVNT_MAIN;
20685 mutex_exit(&sata_hba_inst->satahba_mutex);
20686 mutex_enter(&sata_mutex);
20687 sata_event_pending |= SATA_EVNT_MAIN;
20688 mutex_exit(&sata_mutex);
20689 }
20690
20691
20692 /*
20693 * Check if the SATA device target node is in DEVI_DEVICE_REMOVED state,
20694 * i.e. check if the target node state indicates that it belongs to a removed
20695 * device.
20696 *
20697 * Returns B_TRUE if the target node is in DEVI_DEVICE_REMOVED state,
20698 * B_FALSE otherwise.
20699 */
20700 static boolean_t
20701 sata_check_device_removed(dev_info_t *tdip)
20702 {
20703 ASSERT(tdip != NULL);
20704
20705 if (DEVI_IS_DEVICE_REMOVED(tdip))
20706 return (B_TRUE);
20707 else
20708 return (B_FALSE);
20709 }
20710
20711
20712 /*
20713 * Check for DMA error. Return B_TRUE if error, B_FALSE otherwise.
20714 */
20715 static boolean_t
20716 sata_check_for_dma_error(dev_info_t *dip, sata_pkt_txlate_t *spx)
20717 {
20718 int fm_capability = ddi_fm_capable(dip);
20719 ddi_fm_error_t de;
20720
20721 if (fm_capability & DDI_FM_DMACHK_CAPABLE) {
20722 if (spx->txlt_buf_dma_handle != NULL) {
20723 ddi_fm_dma_err_get(spx->txlt_buf_dma_handle, &de,
20724 DDI_FME_VERSION);
20725 if (de.fme_status != DDI_SUCCESS)
20726 return (B_TRUE);
20727 }
20728 }
20729 return (B_FALSE);
20730 }
20731
20732
20733 /* ************************ FAULT INJECTTION **************************** */
20734
20735 #ifdef SATA_INJECT_FAULTS
20736
20737 static uint32_t sata_fault_count = 0;
20738 static uint32_t sata_fault_suspend_count = 0;
20739
20740 /*
20741 * Inject sata pkt fault
20742 * It modifies returned values of the sata packet.
20743 * It returns immediately if:
20744 * pkt fault injection is not enabled (via sata_inject_fault,
20745 * sata_inject_fault_count), or invalid fault is specified (sata_fault_type),
20746 * or pkt does not contain command to be faulted (set in sata_fault_cmd), or
20747 * pkt is not directed to specified fault controller/device
20748 * (sata_fault_ctrl_dev and sata_fault_device).
20749 * If fault controller is not specified, fault injection applies to all
20750 * controllers and devices.
20751 *
20752 * First argument is the pointer to the executed sata packet.
20753 * Second argument is a pointer to a value returned by the HBA tran_start
20754 * function.
20755 * Third argument specifies injected error. Injected sata packet faults
20756 * are the satapkt_reason values.
20757 * SATA_PKT_BUSY -1 Not completed, busy
20758 * SATA_PKT_DEV_ERROR 1 Device reported error
20759 * SATA_PKT_QUEUE_FULL 2 Not accepted, queue full
20760 * SATA_PKT_PORT_ERROR 3 Not completed, port error
20761 * SATA_PKT_CMD_UNSUPPORTED 4 Cmd unsupported
20762 * SATA_PKT_ABORTED 5 Aborted by request
20763 * SATA_PKT_TIMEOUT 6 Operation timeut
20764 * SATA_PKT_RESET 7 Aborted by reset request
20765 *
20766 * Additional global variables affecting the execution:
20767 *
20768 * sata_inject_fault_count variable specifies number of times in row the
20769 * error is injected. Value of -1 specifies permanent fault, ie. every time
20770 * the fault injection point is reached, the fault is injected and a pause
20771 * between fault injection specified by sata_inject_fault_pause_count is
20772 * ignored). Fault injection routine decrements sata_inject_fault_count
20773 * (if greater than zero) until it reaches 0. No fault is injected when
20774 * sata_inject_fault_count is 0 (zero).
20775 *
20776 * sata_inject_fault_pause_count variable specifies number of times a fault
20777 * injection is bypassed (pause between fault injections).
20778 * If set to 0, a fault is injected only a number of times specified by
20779 * sata_inject_fault_count.
20780 *
20781 * The fault counts are static, so for periodic errors they have to be manually
20782 * reset to start repetition sequence from scratch.
20783 * If the original value returned by the HBA tran_start function is not
20784 * SATA_TRAN_ACCEPTED and pkt reason is not SATA_PKT_COMPLETED, no error
20785 * is injected (to avoid masking real problems);
20786 *
20787 * NOTE: In its current incarnation, this function should be invoked only for
20788 * commands executed in SYNCHRONOUS mode.
20789 */
20790
20791
20792 static void
20793 sata_inject_pkt_fault(sata_pkt_t *spkt, int *rval, int fault)
20794 {
20795
20796 if (sata_inject_fault != SATA_INJECT_PKT_FAULT)
20797 return;
20798
20799 if (sata_inject_fault_count == 0)
20800 return;
20801
20802 if (fault == 0)
20803 return;
20804
20805 if (sata_fault_cmd != spkt->satapkt_cmd.satacmd_cmd_reg)
20806 return;
20807
20808 if (sata_fault_ctrl != NULL) {
20809 sata_pkt_txlate_t *spx =
20810 (sata_pkt_txlate_t *)spkt->satapkt_framework_private;
20811
20812 if (sata_fault_ctrl != NULL && sata_fault_ctrl !=
20813 spx->txlt_sata_hba_inst->satahba_dip)
20814 return;
20815
20816 if (sata_fault_device.satadev_addr.cport !=
20817 spkt->satapkt_device.satadev_addr.cport ||
20818 sata_fault_device.satadev_addr.pmport !=
20819 spkt->satapkt_device.satadev_addr.pmport ||
20820 sata_fault_device.satadev_addr.qual !=
20821 spkt->satapkt_device.satadev_addr.qual)
20822 return;
20823 }
20824
20825 /* Modify pkt return parameters */
20826 if (*rval != SATA_TRAN_ACCEPTED ||
20827 spkt->satapkt_reason != SATA_PKT_COMPLETED) {
20828 sata_fault_count = 0;
20829 sata_fault_suspend_count = 0;
20830 return;
20831 }
20832 if (sata_fault_count == 0 && sata_fault_suspend_count != 0) {
20833 /* Pause in the injection */
20834 sata_fault_suspend_count -= 1;
20835 return;
20836 }
20837
20838 if (sata_fault_count == 0 && sata_fault_suspend_count == 0) {
20839 /*
20840 * Init inject fault cycle. If fault count is set to -1,
20841 * it is a permanent fault.
20842 */
20843 if (sata_inject_fault_count != -1) {
20844 sata_fault_count = sata_inject_fault_count;
20845 sata_fault_suspend_count =
20846 sata_inject_fault_pause_count;
20847 if (sata_fault_suspend_count == 0)
20848 sata_inject_fault_count = 0;
20849 }
20850 }
20851
20852 if (sata_fault_count != 0)
20853 sata_fault_count -= 1;
20854
20855 switch (fault) {
20856 case SATA_PKT_BUSY:
20857 *rval = SATA_TRAN_BUSY;
20858 spkt->satapkt_reason = SATA_PKT_BUSY;
20859 break;
20860
20861 case SATA_PKT_QUEUE_FULL:
20862 *rval = SATA_TRAN_QUEUE_FULL;
20863 spkt->satapkt_reason = SATA_PKT_QUEUE_FULL;
20864 break;
20865
20866 case SATA_PKT_CMD_UNSUPPORTED:
20867 *rval = SATA_TRAN_CMD_UNSUPPORTED;
20868 spkt->satapkt_reason = SATA_PKT_CMD_UNSUPPORTED;
20869 break;
20870
20871 case SATA_PKT_PORT_ERROR:
20872 /* This is "rejected" command */
20873 *rval = SATA_TRAN_PORT_ERROR;
20874 spkt->satapkt_reason = SATA_PKT_PORT_ERROR;
20875 /* Additional error setup could be done here - port state */
20876 break;
20877
20878 case SATA_PKT_DEV_ERROR:
20879 spkt->satapkt_reason = SATA_PKT_DEV_ERROR;
20880 /*
20881 * Additional error setup could be done here
20882 */
20883 break;
20884
20885 case SATA_PKT_ABORTED:
20886 spkt->satapkt_reason = SATA_PKT_ABORTED;
20887 break;
20888
20889 case SATA_PKT_TIMEOUT:
20890 spkt->satapkt_reason = SATA_PKT_TIMEOUT;
20891 /* Additional error setup could be done here */
20892 break;
20893
20894 case SATA_PKT_RESET:
20895 spkt->satapkt_reason = SATA_PKT_RESET;
20896 /*
20897 * Additional error setup could be done here - device reset
20898 */
20899 break;
20900
20901 default:
20902 break;
20903 }
20904 }
20905
20906 #endif
20907
20908 /*
20909 * SATA Trace Ring Buffer
20910 * ----------------------
20911 *
20912 * Overview
20913 *
20914 * The SATA trace ring buffer is a ring buffer created and managed by
20915 * the SATA framework module that can be used by any module or driver
20916 * within the SATA framework to store debug messages.
20917 *
20918 * Ring Buffer Interfaces:
20919 *
20920 * sata_vtrace_debug() <-- Adds debug message to ring buffer
20921 * sata_trace_debug() <-- Wraps varargs into sata_vtrace_debug()
20922 *
20923 * Note that the sata_trace_debug() interface was created to give
20924 * consumers the flexibilty of sending debug messages to ring buffer
20925 * as variable arguments. Consumers can send type va_list debug
20926 * messages directly to sata_vtrace_debug(). The sata_trace_debug()
20927 * and sata_vtrace_debug() relationship is similar to that of
20928 * cmn_err(9F) and vcmn_err(9F).
20929 *
20930 * Below is a diagram of the SATA trace ring buffer interfaces and
20931 * sample consumers:
20932 *
20933 * +---------------------------------+
20934 * | o o SATA Framework Module |
20935 * | o SATA o +------------------+ +------------------+
20936 * |o Trace o <--|sata_vtrace_debug/|<-----|SATA HBA Driver #1|
20937 * |o R-Buf o |sata_trace_debug |<--+ +------------------+
20938 * | o o +------------------+ | +------------------+
20939 * | o o ^ | +--|SATA HBA Driver #2|
20940 * | | | +------------------+
20941 * | +------------------+ |
20942 * | |SATA Debug Message| |
20943 * | +------------------+ |
20944 * +---------------------------------+
20945 *
20946 * Supporting Routines:
20947 *
20948 * sata_trace_rbuf_alloc() <-- Initializes ring buffer
20949 * sata_trace_rbuf_free() <-- Destroys ring buffer
20950 * sata_trace_dmsg_alloc() <-- Creates or reuses buffer in ring buffer
20951 * sata_trace_dmsg_free() <-- Destroys content of ring buffer
20952 *
20953 * The default SATA trace ring buffer size is defined by DMSG_RING_SIZE.
20954 * The ring buffer size can be adjusted by setting dmsg_ring_size in
20955 * /etc/system to desired size in unit of bytes.
20956 *
20957 * The individual debug message size in the ring buffer is restricted
20958 * to DMSG_BUF_SIZE.
20959 */
20960 void
20961 sata_vtrace_debug(dev_info_t *dip, const char *fmt, va_list ap)
20962 {
20963 sata_trace_dmsg_t *dmsg;
20964
20965 if (sata_debug_rbuf == NULL) {
20966 return;
20967 }
20968
20969 /*
20970 * If max size of ring buffer is smaller than size
20971 * required for one debug message then just return
20972 * since we have no room for the debug message.
20973 */
20974 if (sata_debug_rbuf->maxsize < (sizeof (sata_trace_dmsg_t))) {
20975 return;
20976 }
20977
20978 mutex_enter(&sata_debug_rbuf->lock);
20979
20980 /* alloc or reuse on ring buffer */
20981 dmsg = sata_trace_dmsg_alloc();
20982
20983 if (dmsg == NULL) {
20984 /* resource allocation failed */
20985 mutex_exit(&sata_debug_rbuf->lock);
20986 return;
20987 }
20988
20989 dmsg->dip = dip;
20990 gethrestime(&dmsg->timestamp);
20991
20992 (void) vsnprintf(dmsg->buf, sizeof (dmsg->buf), fmt, ap);
20993
20994 mutex_exit(&sata_debug_rbuf->lock);
20995 }
20996
20997 void
20998 sata_trace_debug(dev_info_t *dip, const char *fmt, ...)
20999 {
21000 va_list ap;
21001
21002 va_start(ap, fmt);
21003 sata_vtrace_debug(dip, fmt, ap);
21004 va_end(ap);
21005 }
21006
21007 /*
21008 * This routine is used to manage debug messages
21009 * on ring buffer.
21010 */
21011 static sata_trace_dmsg_t *
21012 sata_trace_dmsg_alloc(void)
21013 {
21014 sata_trace_dmsg_t *dmsg_alloc, *dmsg = sata_debug_rbuf->dmsgp;
21015
21016 if (sata_debug_rbuf->looped == TRUE) {
21017 sata_debug_rbuf->dmsgp = dmsg->next;
21018 return (sata_debug_rbuf->dmsgp);
21019 }
21020
21021 /*
21022 * If we're looping for the first time,
21023 * connect the ring.
21024 */
21025 if (((sata_debug_rbuf->size + (sizeof (sata_trace_dmsg_t))) >
21026 sata_debug_rbuf->maxsize) && (sata_debug_rbuf->dmsgh != NULL)) {
21027 dmsg->next = sata_debug_rbuf->dmsgh;
21028 sata_debug_rbuf->dmsgp = sata_debug_rbuf->dmsgh;
21029 sata_debug_rbuf->looped = TRUE;
21030 return (sata_debug_rbuf->dmsgp);
21031 }
21032
21033 /* If we've gotten this far then memory allocation is needed */
21034 dmsg_alloc = kmem_zalloc(sizeof (sata_trace_dmsg_t), KM_NOSLEEP);
21035 if (dmsg_alloc == NULL) {
21036 sata_debug_rbuf->allocfailed++;
21037 return (dmsg_alloc);
21038 } else {
21039 sata_debug_rbuf->size += sizeof (sata_trace_dmsg_t);
21040 }
21041
21042 if (sata_debug_rbuf->dmsgp != NULL) {
21043 dmsg->next = dmsg_alloc;
21044 sata_debug_rbuf->dmsgp = dmsg->next;
21045 return (sata_debug_rbuf->dmsgp);
21046 } else {
21047 /*
21048 * We should only be here if we're initializing
21049 * the ring buffer.
21050 */
21051 if (sata_debug_rbuf->dmsgh == NULL) {
21052 sata_debug_rbuf->dmsgh = dmsg_alloc;
21053 } else {
21054 /* Something is wrong */
21055 kmem_free(dmsg_alloc, sizeof (sata_trace_dmsg_t));
21056 return (NULL);
21057 }
21058
21059 sata_debug_rbuf->dmsgp = dmsg_alloc;
21060 return (sata_debug_rbuf->dmsgp);
21061 }
21062 }
21063
21064
21065 /*
21066 * Free all messages on debug ring buffer.
21067 */
21068 static void
21069 sata_trace_dmsg_free(void)
21070 {
21071 sata_trace_dmsg_t *dmsg_next, *dmsg = sata_debug_rbuf->dmsgh;
21072
21073 while (dmsg != NULL) {
21074 dmsg_next = dmsg->next;
21075 kmem_free(dmsg, sizeof (sata_trace_dmsg_t));
21076
21077 /*
21078 * If we've looped around the ring than we're done.
21079 */
21080 if (dmsg_next == sata_debug_rbuf->dmsgh) {
21081 break;
21082 } else {
21083 dmsg = dmsg_next;
21084 }
21085 }
21086 }
21087
21088
21089 /*
21090 * This function can block
21091 */
21092 static void
21093 sata_trace_rbuf_alloc(void)
21094 {
21095 sata_debug_rbuf = kmem_zalloc(sizeof (sata_trace_rbuf_t), KM_SLEEP);
21096
21097 mutex_init(&sata_debug_rbuf->lock, NULL, MUTEX_DRIVER, NULL);
21098
21099 if (dmsg_ring_size > 0) {
21100 sata_debug_rbuf->maxsize = (size_t)dmsg_ring_size;
21101 }
21102 }
21103
21104
21105 static void
21106 sata_trace_rbuf_free(void)
21107 {
21108 sata_trace_dmsg_free();
21109 mutex_destroy(&sata_debug_rbuf->lock);
21110 kmem_free(sata_debug_rbuf, sizeof (sata_trace_rbuf_t));
21111 }
21112
21113 /*
21114 * If SATA_DEBUG is not defined then this routine is called instead
21115 * of sata_log() via the SATA_LOG_D macro.
21116 */
21117 static void
21118 sata_trace_log(sata_hba_inst_t *sata_hba_inst, uint_t level,
21119 const char *fmt, ...)
21120 {
21121 #ifndef __lock_lint
21122 _NOTE(ARGUNUSED(level))
21123 #endif
21124
21125 dev_info_t *dip = NULL;
21126 va_list ap;
21127
21128 if (sata_hba_inst != NULL) {
21129 dip = SATA_DIP(sata_hba_inst);
21130 }
21131
21132 va_start(ap, fmt);
21133 sata_vtrace_debug(dip, fmt, ap);
21134 va_end(ap);
21135 }