1 /*
2 * CDDL HEADER START
3 *
4 * The contents of this file are subject to the terms of the
5 * Common Development and Distribution License (the "License").
6 * You may not use this file except in compliance with the License.
7 *
8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9 * or http://www.opensolaris.org/os/licensing.
10 * See the License for the specific language governing permissions
11 * and limitations under the License.
12 *
13 * When distributing Covered Code, include this CDDL HEADER in each
14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15 * If applicable, add the following below this CDDL HEADER, with the
16 * fields enclosed by brackets "[]" replaced with your own identifying
17 * information: Portions Copyright [yyyy] [name of copyright owner]
18 *
19 * CDDL HEADER END
20 */
21
22 /*
23 * Copyright (c) 2006, 2010, Oracle and/or its affiliates. All rights reserved.
24 */
25 /*
26 * Copyright 2015 Nexenta Systems, Inc. All rights reserved.
27 * Copyright 2016 Argo Technologies SA
28 */
29
30 /*
31 * SATA Framework
32 * Generic SATA Host Adapter Implementation
33 */
34
35 #include <sys/conf.h>
36 #include <sys/file.h>
37 #include <sys/ddi.h>
38 #include <sys/sunddi.h>
39 #include <sys/modctl.h>
40 #include <sys/cmn_err.h>
41 #include <sys/errno.h>
42 #include <sys/thread.h>
43 #include <sys/kstat.h>
44 #include <sys/note.h>
45 #include <sys/sysevent.h>
46 #include <sys/sysevent/eventdefs.h>
47 #include <sys/sysevent/dr.h>
48 #include <sys/taskq.h>
49 #include <sys/disp.h>
50 #include <sys/sdt.h>
51
52 #include <sys/sata/impl/sata.h>
53 #include <sys/sata/sata_hba.h>
54 #include <sys/sata/sata_defs.h>
55 #include <sys/sata/sata_cfgadm.h>
56 #include <sys/sata/sata_blacklist.h>
57 #include <sys/sata/sata_satl.h>
58
59 #include <sys/scsi/impl/spc3_types.h>
60
61 /*
62 * FMA header files
63 */
64 #include <sys/ddifm.h>
65 #include <sys/fm/protocol.h>
66 #include <sys/fm/util.h>
67 #include <sys/fm/io/ddi.h>
68
69 /* Debug flags - defined in sata.h */
70 int sata_debug_flags = 0;
71 int sata_msg = 0;
72
73 /*
74 * Flags enabling selected SATA HBA framework functionality
75 */
76 #define SATA_ENABLE_QUEUING 1
77 #define SATA_ENABLE_NCQ 2
78 #define SATA_ENABLE_PROCESS_EVENTS 4
79 #define SATA_ENABLE_PMULT_FBS 8 /* FIS-Based Switching */
80 int sata_func_enable =
81 SATA_ENABLE_PROCESS_EVENTS | SATA_ENABLE_QUEUING | SATA_ENABLE_NCQ;
82
83 /*
84 * Global variable setting default maximum queue depth (NCQ or TCQ)
85 * Note:minimum queue depth is 1
86 */
87 int sata_max_queue_depth = SATA_MAX_QUEUE_DEPTH; /* max NCQ/TCQ queue depth */
88
89 /*
90 * Currently used default NCQ/TCQ queue depth. It is set-up during the driver
91 * initialization, using value from sata_max_queue_depth
92 * It is adjusted to minimum supported by the controller and by the device,
93 * if queueing is enabled.
94 */
95 static int sata_current_max_qdepth;
96
97 /*
98 * Global variable determining the default behavior after device hotpluggin.
99 * If non-zero, the hotplugged device is onlined (if possible) without explicit
100 * IOCTL request (AP_CONFIGURE).
101 * If zero, hotplugged device is identified, but not onlined.
102 * Enabling (AP_CONNECT) device port with an attached device does not result
103 * in device onlining regardless of the flag setting
104 */
105 int sata_auto_online = 0;
106
107 #ifdef SATA_DEBUG
108
109 #define SATA_LOG_D(args) sata_log args
110 uint64_t mbuf_count = 0;
111 uint64_t mbuffail_count = 0;
112
113 sata_atapi_cmd_t sata_atapi_trace[64];
114 uint32_t sata_atapi_trace_index = 0;
115 int sata_atapi_trace_save = 1;
116 static void sata_save_atapi_trace(sata_pkt_txlate_t *, int);
117 #define SATAATAPITRACE(spx, count) if (sata_atapi_trace_save) \
118 sata_save_atapi_trace(spx, count);
119
120 #else
121 #define SATA_LOG_D(args) sata_trace_log args
122 #define SATAATAPITRACE(spx, count)
123 #endif
124
125 #if 0
126 static void
127 sata_test_atapi_packet_command(sata_hba_inst_t *, int);
128 #endif
129
130 #ifdef SATA_INJECT_FAULTS
131
132 #define SATA_INJECT_PKT_FAULT 1
133 uint32_t sata_inject_fault = 0;
134
135 uint32_t sata_inject_fault_count = 0;
136 uint32_t sata_inject_fault_pause_count = 0;
137 uint32_t sata_fault_type = 0;
138 uint32_t sata_fault_cmd = 0;
139 dev_info_t *sata_fault_ctrl = NULL;
140 sata_device_t sata_fault_device;
141
142 static void sata_inject_pkt_fault(sata_pkt_t *, int *, int);
143
144 #endif
145
146 #define LEGACY_HWID_LEN 64 /* Model (40) + Serial (20) + pad */
147
148 static char sata_rev_tag[] = {"1.46"};
149
150 /*
151 * SATA cb_ops functions
152 */
153 static int sata_hba_open(dev_t *, int, int, cred_t *);
154 static int sata_hba_close(dev_t, int, int, cred_t *);
155 static int sata_hba_ioctl(dev_t, int, intptr_t, int, cred_t *, int *);
156
157 /*
158 * SCSA required entry points
159 */
160 static int sata_scsi_tgt_init(dev_info_t *, dev_info_t *,
161 scsi_hba_tran_t *, struct scsi_device *);
162 static int sata_scsi_tgt_probe(struct scsi_device *,
163 int (*callback)(void));
164 static void sata_scsi_tgt_free(dev_info_t *, dev_info_t *,
165 scsi_hba_tran_t *, struct scsi_device *);
166 static int sata_scsi_start(struct scsi_address *, struct scsi_pkt *);
167 static int sata_scsi_abort(struct scsi_address *, struct scsi_pkt *);
168 static int sata_scsi_reset(struct scsi_address *, int);
169 static int sata_scsi_getcap(struct scsi_address *, char *, int);
170 static int sata_scsi_setcap(struct scsi_address *, char *, int, int);
171 static struct scsi_pkt *sata_scsi_init_pkt(struct scsi_address *,
172 struct scsi_pkt *, struct buf *, int, int, int, int, int (*)(caddr_t),
173 caddr_t);
174 static void sata_scsi_destroy_pkt(struct scsi_address *, struct scsi_pkt *);
175 static void sata_scsi_dmafree(struct scsi_address *, struct scsi_pkt *);
176 static void sata_scsi_sync_pkt(struct scsi_address *, struct scsi_pkt *);
177
178 /*
179 * SATA HBA interface functions are defined in sata_hba.h header file
180 */
181
182 /* Event processing functions */
183 static void sata_event_daemon(void *);
184 static void sata_event_thread_control(int);
185 static void sata_process_controller_events(sata_hba_inst_t *sata_hba_inst);
186 static void sata_process_pmult_events(sata_hba_inst_t *, uint8_t);
187 static void sata_process_device_reset(sata_hba_inst_t *, sata_address_t *);
188 static void sata_process_pmdevice_reset(sata_hba_inst_t *, sata_address_t *);
189 static void sata_process_port_failed_event(sata_hba_inst_t *,
190 sata_address_t *);
191 static void sata_process_port_link_events(sata_hba_inst_t *,
192 sata_address_t *);
193 static void sata_process_pmport_link_events(sata_hba_inst_t *,
194 sata_address_t *);
195 static void sata_process_device_detached(sata_hba_inst_t *, sata_address_t *);
196 static void sata_process_pmdevice_detached(sata_hba_inst_t *,
197 sata_address_t *);
198 static void sata_process_device_attached(sata_hba_inst_t *, sata_address_t *);
199 static void sata_process_pmdevice_attached(sata_hba_inst_t *,
200 sata_address_t *);
201 static void sata_process_port_pwr_change(sata_hba_inst_t *, sata_address_t *);
202 static void sata_process_cntrl_pwr_level_change(sata_hba_inst_t *);
203 static void sata_process_target_node_cleanup(sata_hba_inst_t *,
204 sata_address_t *);
205 static void sata_process_device_autoonline(sata_hba_inst_t *,
206 sata_address_t *saddr);
207
208 /*
209 * Local translation functions
210 */
211 static int sata_txlt_inquiry(sata_pkt_txlate_t *);
212 static int sata_txlt_test_unit_ready(sata_pkt_txlate_t *);
213 static int sata_txlt_start_stop_unit(sata_pkt_txlate_t *);
214 static int sata_txlt_read_capacity(sata_pkt_txlate_t *);
215 static int sata_txlt_read_capacity16(sata_pkt_txlate_t *);
216 static int sata_txlt_unmap(sata_pkt_txlate_t *);
217 static int sata_txlt_request_sense(sata_pkt_txlate_t *);
218 static int sata_txlt_read(sata_pkt_txlate_t *);
219 static int sata_txlt_write(sata_pkt_txlate_t *);
220 static int sata_txlt_log_sense(sata_pkt_txlate_t *);
221 static int sata_txlt_log_select(sata_pkt_txlate_t *);
222 static int sata_txlt_mode_sense(sata_pkt_txlate_t *);
223 static int sata_txlt_mode_select(sata_pkt_txlate_t *);
224 static int sata_txlt_ata_pass_thru(sata_pkt_txlate_t *);
225 static int sata_txlt_synchronize_cache(sata_pkt_txlate_t *);
226 static int sata_txlt_write_buffer(sata_pkt_txlate_t *);
227 static int sata_txlt_nodata_cmd_immediate(sata_pkt_txlate_t *);
228
229 static int sata_hba_start(sata_pkt_txlate_t *, int *);
230 static int sata_txlt_invalid_command(sata_pkt_txlate_t *);
231 static int sata_txlt_check_condition(sata_pkt_txlate_t *, uchar_t, uchar_t);
232 static int sata_txlt_lba_out_of_range(sata_pkt_txlate_t *);
233 static int sata_txlt_ata_pass_thru_illegal_cmd(sata_pkt_txlate_t *);
234 static int sata_txlt_unmap_nodata_cmd(sata_pkt_txlate_t *);
235 static void sata_txlt_rw_completion(sata_pkt_t *);
236 static void sata_txlt_nodata_cmd_completion(sata_pkt_t *);
237 static void sata_txlt_apt_completion(sata_pkt_t *sata_pkt);
238 static void sata_txlt_unmap_completion(sata_pkt_t *sata_pkt);
239 static void sata_txlt_download_mcode_cmd_completion(sata_pkt_t *);
240 static int sata_emul_rw_completion(sata_pkt_txlate_t *);
241 static void sata_fill_ata_return_desc(sata_pkt_t *, uint8_t, uint8_t,
242 uint8_t);
243 static struct scsi_extended_sense *sata_immediate_error_response(
244 sata_pkt_txlate_t *, int);
245 static struct scsi_extended_sense *sata_arq_sense(sata_pkt_txlate_t *);
246
247 static int sata_txlt_atapi(sata_pkt_txlate_t *);
248 static void sata_txlt_atapi_completion(sata_pkt_t *);
249
250 /*
251 * Local functions for ioctl
252 */
253 static int32_t sata_get_port_num(sata_hba_inst_t *, struct devctl_iocdata *);
254 static void sata_cfgadm_state(sata_hba_inst_t *, int32_t,
255 devctl_ap_state_t *);
256 static dev_info_t *sata_get_target_dip(dev_info_t *, uint8_t, uint8_t);
257 static dev_info_t *sata_get_scsi_target_dip(dev_info_t *, sata_address_t *);
258 static dev_info_t *sata_devt_to_devinfo(dev_t);
259 static int sata_ioctl_connect(sata_hba_inst_t *, sata_device_t *);
260 static int sata_ioctl_disconnect(sata_hba_inst_t *, sata_device_t *);
261 static int sata_ioctl_configure(sata_hba_inst_t *, sata_device_t *);
262 static int sata_ioctl_unconfigure(sata_hba_inst_t *, sata_device_t *);
263 static int sata_ioctl_activate(sata_hba_inst_t *, sata_device_t *);
264 static int sata_ioctl_deactivate(sata_hba_inst_t *, sata_device_t *);
265 static int sata_ioctl_reset_port(sata_hba_inst_t *, sata_device_t *);
266 static int sata_ioctl_reset_device(sata_hba_inst_t *, sata_device_t *);
267 static int sata_ioctl_reset_all(sata_hba_inst_t *);
268 static int sata_ioctl_port_self_test(sata_hba_inst_t *, sata_device_t *);
269 static int sata_ioctl_get_device_path(sata_hba_inst_t *, sata_device_t *,
270 sata_ioctl_data_t *, int mode);
271 static int sata_ioctl_get_ap_type(sata_hba_inst_t *, sata_device_t *,
272 sata_ioctl_data_t *, int mode);
273 static int sata_ioctl_get_model_info(sata_hba_inst_t *, sata_device_t *,
274 sata_ioctl_data_t *, int mode);
275 static int sata_ioctl_get_revfirmware_info(sata_hba_inst_t *, sata_device_t *,
276 sata_ioctl_data_t *, int mode);
277 static int sata_ioctl_get_serialnumber_info(sata_hba_inst_t *,
278 sata_device_t *, sata_ioctl_data_t *, int mode);
279
280 /*
281 * Local functions
282 */
283 static void sata_remove_hba_instance(dev_info_t *);
284 static int sata_validate_sata_hba_tran(dev_info_t *, sata_hba_tran_t *);
285 static void sata_probe_ports(sata_hba_inst_t *);
286 static void sata_probe_pmports(sata_hba_inst_t *, uint8_t);
287 static int sata_reprobe_port(sata_hba_inst_t *, sata_device_t *, int);
288 static int sata_reprobe_pmult(sata_hba_inst_t *, sata_device_t *, int);
289 static int sata_reprobe_pmport(sata_hba_inst_t *, sata_device_t *, int);
290 static int sata_alloc_pmult(sata_hba_inst_t *, sata_device_t *);
291 static void sata_free_pmult(sata_hba_inst_t *, sata_device_t *);
292 static int sata_add_device(dev_info_t *, sata_hba_inst_t *, sata_device_t *);
293 static int sata_offline_device(sata_hba_inst_t *, sata_device_t *,
294 sata_drive_info_t *);
295 static dev_info_t *sata_create_target_node(dev_info_t *, sata_hba_inst_t *,
296 sata_address_t *);
297 static void sata_remove_target_node(sata_hba_inst_t *,
298 sata_address_t *);
299 static int sata_validate_scsi_address(sata_hba_inst_t *,
300 struct scsi_address *, sata_device_t *);
301 static int sata_validate_sata_address(sata_hba_inst_t *, int, int, int);
302 static sata_pkt_t *sata_pkt_alloc(sata_pkt_txlate_t *, int (*)(caddr_t));
303 static void sata_pkt_free(sata_pkt_txlate_t *);
304 static int sata_dma_buf_setup(sata_pkt_txlate_t *, int, int (*)(caddr_t),
305 caddr_t, ddi_dma_attr_t *);
306 static void sata_common_free_dma_rsrcs(sata_pkt_txlate_t *);
307 static int sata_probe_device(sata_hba_inst_t *, sata_device_t *);
308 static sata_drive_info_t *sata_get_device_info(sata_hba_inst_t *,
309 sata_device_t *);
310 static int sata_identify_device(sata_hba_inst_t *, sata_drive_info_t *);
311 static void sata_reidentify_device(sata_pkt_txlate_t *);
312 static struct buf *sata_alloc_local_buffer(sata_pkt_txlate_t *, int);
313 static void sata_free_local_buffer(sata_pkt_txlate_t *);
314 static uint64_t sata_check_capacity(sata_drive_info_t *);
315 void sata_adjust_dma_attr(sata_drive_info_t *, ddi_dma_attr_t *,
316 ddi_dma_attr_t *);
317 static int sata_fetch_device_identify_data(sata_hba_inst_t *,
318 sata_drive_info_t *);
319 static void sata_update_port_info(sata_hba_inst_t *, sata_device_t *);
320 static void sata_update_pmport_info(sata_hba_inst_t *, sata_device_t *);
321 static void sata_update_port_scr(sata_port_scr_t *, sata_device_t *);
322 static int sata_set_dma_mode(sata_hba_inst_t *, sata_drive_info_t *);
323 static int sata_set_cache_mode(sata_hba_inst_t *, sata_drive_info_t *, int);
324 static int sata_set_rmsn(sata_hba_inst_t *, sata_drive_info_t *, int);
325 static int sata_set_drive_features(sata_hba_inst_t *,
326 sata_drive_info_t *, int flag);
327 static void sata_init_write_cache_mode(sata_drive_info_t *sdinfo);
328 static int sata_initialize_device(sata_hba_inst_t *, sata_drive_info_t *);
329 static void sata_identdev_to_inquiry(sata_hba_inst_t *, sata_drive_info_t *,
330 uint8_t *);
331 static int sata_get_atapi_inquiry_data(sata_hba_inst_t *, sata_address_t *,
332 struct scsi_inquiry *);
333 static int sata_build_msense_page_1(sata_drive_info_t *, int, uint8_t *);
334 static int sata_build_msense_page_8(sata_drive_info_t *, int, uint8_t *);
335 static int sata_build_msense_page_1a(sata_drive_info_t *, int, uint8_t *);
336 static int sata_build_msense_page_1c(sata_drive_info_t *, int, uint8_t *);
337 static int sata_build_msense_page_30(sata_drive_info_t *, int, uint8_t *);
338 static int sata_mode_select_page_8(sata_pkt_txlate_t *,
339 struct mode_cache_scsi3 *, int, int *, int *, int *);
340 static int sata_mode_select_page_1a(sata_pkt_txlate_t *,
341 struct mode_info_power_cond *, int, int *, int *, int *);
342 static int sata_mode_select_page_1c(sata_pkt_txlate_t *,
343 struct mode_info_excpt_page *, int, int *, int *, int *);
344 static int sata_mode_select_page_30(sata_pkt_txlate_t *,
345 struct mode_acoustic_management *, int, int *, int *, int *);
346
347 static int sata_build_lsense_page_0(sata_drive_info_t *, uint8_t *);
348 static int sata_build_lsense_page_10(sata_drive_info_t *, uint8_t *,
349 sata_hba_inst_t *);
350 static int sata_build_lsense_page_2f(sata_drive_info_t *, uint8_t *,
351 sata_hba_inst_t *);
352 static int sata_build_lsense_page_30(sata_drive_info_t *, uint8_t *,
353 sata_hba_inst_t *);
354 static int sata_build_lsense_page_0e(sata_drive_info_t *, uint8_t *,
355 sata_pkt_txlate_t *);
356
357 static void sata_set_arq_data(sata_pkt_t *);
358 static void sata_build_read_verify_cmd(sata_cmd_t *, uint16_t, uint64_t);
359 static void sata_build_generic_cmd(sata_cmd_t *, uint8_t);
360 static uint8_t sata_get_standby_timer(uint8_t *timer);
361
362 static void sata_save_drive_settings(sata_drive_info_t *);
363 static void sata_show_drive_info(sata_hba_inst_t *, sata_drive_info_t *);
364 static void sata_show_pmult_info(sata_hba_inst_t *, sata_device_t *);
365 static void sata_log(sata_hba_inst_t *, uint_t, char *fmt, ...);
366 static void sata_trace_log(sata_hba_inst_t *, uint_t, const char *fmt, ...);
367 static int sata_fetch_smart_return_status(sata_hba_inst_t *,
368 sata_drive_info_t *);
369 static int sata_fetch_smart_data(sata_hba_inst_t *, sata_drive_info_t *,
370 struct smart_data *);
371 static int sata_smart_selftest_log(sata_hba_inst_t *,
372 sata_drive_info_t *,
373 struct smart_selftest_log *);
374 static int sata_ext_smart_selftest_read_log(sata_hba_inst_t *,
375 sata_drive_info_t *, struct smart_ext_selftest_log *, uint16_t);
376 static int sata_smart_read_log(sata_hba_inst_t *, sata_drive_info_t *,
377 uint8_t *, uint8_t, uint8_t);
378 static int sata_read_log_ext_directory(sata_hba_inst_t *, sata_drive_info_t *,
379 struct read_log_ext_directory *);
380 static void sata_gen_sysevent(sata_hba_inst_t *, sata_address_t *, int);
381 static void sata_xlate_errors(sata_pkt_txlate_t *);
382 static void sata_decode_device_error(sata_pkt_txlate_t *,
383 struct scsi_extended_sense *);
384 static void sata_set_device_removed(dev_info_t *);
385 static boolean_t sata_check_device_removed(dev_info_t *);
386 static void sata_set_target_node_cleanup(sata_hba_inst_t *, sata_address_t *);
387 static int sata_ncq_err_ret_cmd_setup(sata_pkt_txlate_t *,
388 sata_drive_info_t *);
389 static int sata_atapi_err_ret_cmd_setup(sata_pkt_txlate_t *,
390 sata_drive_info_t *);
391 static void sata_atapi_packet_cmd_setup(sata_cmd_t *, sata_drive_info_t *);
392 static void sata_fixed_sense_data_preset(struct scsi_extended_sense *);
393 static void sata_target_devid_register(dev_info_t *, sata_drive_info_t *);
394 static int sata_check_modser(char *, int);
395
396 /*
397 * FMA
398 */
399 static boolean_t sata_check_for_dma_error(dev_info_t *, sata_pkt_txlate_t *);
400
401
402 /*
403 * SATA Framework will ignore SATA HBA driver cb_ops structure and
404 * register following one with SCSA framework.
405 * Open & close are provided, so scsi framework will not use its own
406 */
407 static struct cb_ops sata_cb_ops = {
408 sata_hba_open, /* open */
409 sata_hba_close, /* close */
410 nodev, /* strategy */
411 nodev, /* print */
412 nodev, /* dump */
413 nodev, /* read */
414 nodev, /* write */
415 sata_hba_ioctl, /* ioctl */
416 nodev, /* devmap */
417 nodev, /* mmap */
418 nodev, /* segmap */
419 nochpoll, /* chpoll */
420 ddi_prop_op, /* cb_prop_op */
421 0, /* streamtab */
422 D_NEW | D_MP, /* cb_flag */
423 CB_REV, /* rev */
424 nodev, /* aread */
425 nodev /* awrite */
426 };
427
428
429 extern struct mod_ops mod_miscops;
430 extern uchar_t scsi_cdb_size[];
431
432 static struct modlmisc modlmisc = {
433 &mod_miscops, /* Type of module */
434 "SATA Module" /* module name */
435 };
436
437
438 static struct modlinkage modlinkage = {
439 MODREV_1,
440 (void *)&modlmisc,
441 NULL
442 };
443
444 /*
445 * Default sata pkt timeout. Used when a target driver scsi_pkt time is zero,
446 * i.e. when scsi_pkt has not timeout specified.
447 */
448 static int sata_default_pkt_time = 60; /* 60 seconds */
449
450 /*
451 * Intermediate buffer device access attributes - they are required,
452 * but not necessarily used.
453 */
454 static ddi_device_acc_attr_t sata_acc_attr = {
455 DDI_DEVICE_ATTR_V0,
456 DDI_STRUCTURE_LE_ACC,
457 DDI_STRICTORDER_ACC
458 };
459
460
461 /*
462 * Mutexes protecting structures in multithreaded operations.
463 * Because events are relatively rare, a single global mutex protecting
464 * data structures should be sufficient. To increase performance, add
465 * separate mutex per each sata port and use global mutex only to protect
466 * common data structures.
467 */
468 static kmutex_t sata_mutex; /* protects sata_hba_list */
469 static kmutex_t sata_log_mutex; /* protects log */
470
471 static char sata_log_buf[256];
472
473 /*
474 * sata trace debug
475 */
476 static sata_trace_rbuf_t *sata_debug_rbuf;
477 static sata_trace_dmsg_t *sata_trace_dmsg_alloc(void);
478 static void sata_trace_dmsg_free(void);
479 static void sata_trace_rbuf_alloc(void);
480 static void sata_trace_rbuf_free(void);
481
482 int dmsg_ring_size = DMSG_RING_SIZE;
483
484 /* Default write cache setting for SATA hard disks */
485 int sata_write_cache = 1; /* enabled */
486
487 /* Default write cache setting for SATA ATAPI CD/DVD */
488 int sata_atapicdvd_write_cache = 1; /* enabled */
489
490 /* Default write cache setting for SATA ATAPI tape */
491 int sata_atapitape_write_cache = 1; /* enabled */
492
493 /* Default write cache setting for SATA ATAPI disk */
494 int sata_atapidisk_write_cache = 1; /* enabled */
495
496 /*
497 * Linked list of HBA instances
498 */
499 static sata_hba_inst_t *sata_hba_list = NULL;
500 static sata_hba_inst_t *sata_hba_list_tail = NULL;
501 /*
502 * Pointer to per-instance SATA HBA soft structure is stored in sata_hba_tran
503 * structure and in sata soft state.
504 */
505
506 /*
507 * Event daemon related variables
508 */
509 static kmutex_t sata_event_mutex;
510 static kcondvar_t sata_event_cv;
511 static kthread_t *sata_event_thread = NULL;
512 static int sata_event_thread_terminate = 0;
513 static int sata_event_pending = 0;
514 static int sata_event_thread_active = 0;
515 extern pri_t minclsyspri;
516
517 /*
518 * NCQ error recovery command
519 */
520 static const sata_cmd_t sata_rle_cmd = {
521 SATA_CMD_REV,
522 NULL,
523 {
524 SATA_DIR_READ
525 },
526 ATA_ADDR_LBA48,
527 0,
528 0,
529 0,
530 0,
531 0,
532 1,
533 READ_LOG_EXT_NCQ_ERROR_RECOVERY,
534 0,
535 0,
536 0,
537 SATAC_READ_LOG_EXT,
538 0,
539 0,
540 0,
541 };
542
543 /*
544 * ATAPI error recovery CDB
545 */
546 static const uint8_t sata_rqsense_cdb[SATA_ATAPI_RQSENSE_CDB_LEN] = {
547 SCMD_REQUEST_SENSE,
548 0, /* Only fixed RQ format is supported */
549 0,
550 0,
551 SATA_ATAPI_MIN_RQSENSE_LEN, /* Less data may be returned */
552 0
553 };
554
555
556 /* Warlock directives */
557
558 _NOTE(SCHEME_PROTECTS_DATA("No Mutex Needed", scsi_hba_tran))
559 _NOTE(SCHEME_PROTECTS_DATA("No Mutex Needed", scsi_device))
560 _NOTE(SCHEME_PROTECTS_DATA("No Mutex Needed", dev_ops))
561 _NOTE(SCHEME_PROTECTS_DATA("No Mutex Needed", scsi_extended_sense))
562 _NOTE(SCHEME_PROTECTS_DATA("No Mutex Needed", scsi_arq_status))
563 _NOTE(SCHEME_PROTECTS_DATA("No Mutex Needed", ddi_dma_attr))
564 _NOTE(SCHEME_PROTECTS_DATA("No Mutex Needed", ddi_dma_cookie_t))
565 _NOTE(SCHEME_PROTECTS_DATA("No Mutex Needed", devctl_ap_state))
566 _NOTE(SCHEME_PROTECTS_DATA("No Mutex Needed", dev_info::devi_state))
567 _NOTE(MUTEX_PROTECTS_DATA(sata_mutex, sata_hba_list))
568 _NOTE(DATA_READABLE_WITHOUT_LOCK(sata_hba_list))
569 _NOTE(MUTEX_PROTECTS_DATA(sata_mutex, sata_hba_inst::satahba_next))
570 _NOTE(MUTEX_PROTECTS_DATA(sata_mutex, sata_hba_inst::satahba_prev))
571 _NOTE(SCHEME_PROTECTS_DATA("No Mutex Needed", \
572 sata_hba_inst::satahba_scsi_tran))
573 _NOTE(SCHEME_PROTECTS_DATA("No Mutex Needed", sata_hba_inst::satahba_tran))
574 _NOTE(SCHEME_PROTECTS_DATA("No Mutex Needed", sata_hba_inst::satahba_dip))
575 _NOTE(SCHEME_PROTECTS_DATA("Scheme", sata_hba_inst::satahba_attached))
576 _NOTE(DATA_READABLE_WITHOUT_LOCK(sata_hba_inst::satahba_dev_port))
577 _NOTE(MUTEX_PROTECTS_DATA(sata_hba_inst::satahba_mutex,
578 sata_hba_inst::satahba_event_flags))
579 _NOTE(MUTEX_PROTECTS_DATA(sata_cport_info::cport_mutex, \
580 sata_cport_info::cport_devp))
581 _NOTE(DATA_READABLE_WITHOUT_LOCK(sata_cport_info::cport_devp))
582 _NOTE(SCHEME_PROTECTS_DATA("Scheme", sata_cport_info::cport_addr))
583 _NOTE(MUTEX_PROTECTS_DATA(sata_cport_info::cport_mutex, \
584 sata_cport_info::cport_dev_type))
585 _NOTE(DATA_READABLE_WITHOUT_LOCK(sata_cport_info::cport_dev_type))
586 _NOTE(MUTEX_PROTECTS_DATA(sata_cport_info::cport_mutex, \
587 sata_cport_info::cport_state))
588 _NOTE(DATA_READABLE_WITHOUT_LOCK(sata_cport_info::cport_state))
589 _NOTE(MUTEX_PROTECTS_DATA(sata_pmport_info::pmport_mutex, \
590 sata_pmport_info::pmport_state))
591 _NOTE(DATA_READABLE_WITHOUT_LOCK(sata_pmport_info::pmport_state))
592 _NOTE(MUTEX_PROTECTS_DATA(sata_pmport_info::pmport_mutex, \
593 sata_pmport_info::pmport_dev_type))
594 _NOTE(DATA_READABLE_WITHOUT_LOCK(sata_pmport_info::pmport_dev_type))
595 _NOTE(MUTEX_PROTECTS_DATA(sata_pmport_info::pmport_mutex, \
596 sata_pmport_info::pmport_sata_drive))
597 _NOTE(MUTEX_PROTECTS_DATA(sata_pmport_info::pmport_mutex, \
598 sata_pmport_info::pmport_tgtnode_clean))
599 _NOTE(MUTEX_PROTECTS_DATA(sata_pmport_info::pmport_mutex, \
600 sata_pmport_info::pmport_event_flags))
601 _NOTE(DATA_READABLE_WITHOUT_LOCK(sata_pmport_info::pmport_sata_drive))
602 _NOTE(DATA_READABLE_WITHOUT_LOCK(sata_pmult_info::pmult_dev_port))
603 _NOTE(DATA_READABLE_WITHOUT_LOCK(sata_pmult_info::pmult_num_dev_ports))
604 #ifdef SATA_DEBUG
605 _NOTE(SCHEME_PROTECTS_DATA("No Mutex Needed", mbuf_count))
606 _NOTE(SCHEME_PROTECTS_DATA("No Mutex Needed", mbuffail_count))
607 _NOTE(SCHEME_PROTECTS_DATA("No Mutex Needed", sata_atapi_trace))
608 _NOTE(SCHEME_PROTECTS_DATA("No Mutex Needed", sata_atapi_trace_index))
609 #endif
610
611 /* End of warlock directives */
612
613 /* ************** loadable module configuration functions ************** */
614
615 int
616 _init()
617 {
618 int rval;
619
620 mutex_init(&sata_mutex, NULL, MUTEX_DRIVER, NULL);
621 mutex_init(&sata_event_mutex, NULL, MUTEX_DRIVER, NULL);
622 mutex_init(&sata_log_mutex, NULL, MUTEX_DRIVER, NULL);
623 cv_init(&sata_event_cv, NULL, CV_DRIVER, NULL);
624 sata_trace_rbuf_alloc();
625 if ((rval = mod_install(&modlinkage)) != 0) {
626 #ifdef SATA_DEBUG
627 cmn_err(CE_WARN, "sata: _init: mod_install failed\n");
628 #endif
629 sata_trace_rbuf_free();
630 mutex_destroy(&sata_log_mutex);
631 cv_destroy(&sata_event_cv);
632 mutex_destroy(&sata_event_mutex);
633 mutex_destroy(&sata_mutex);
634 }
635 return (rval);
636 }
637
638 int
639 _fini()
640 {
641 int rval;
642
643 if ((rval = mod_remove(&modlinkage)) != 0)
644 return (rval);
645
646 sata_trace_rbuf_free();
647 mutex_destroy(&sata_log_mutex);
648 cv_destroy(&sata_event_cv);
649 mutex_destroy(&sata_event_mutex);
650 mutex_destroy(&sata_mutex);
651 return (rval);
652 }
653
654 int
655 _info(struct modinfo *modinfop)
656 {
657 return (mod_info(&modlinkage, modinfop));
658 }
659
660
661
662 /* ********************* SATA HBA entry points ********************* */
663
664
665 /*
666 * Called by SATA HBA from _init().
667 * Registers HBA driver instance/sata framework pair with scsi framework, by
668 * calling scsi_hba_init().
669 *
670 * SATA HBA driver cb_ops are ignored - SATA HBA framework cb_ops are used
671 * instead. SATA HBA framework cb_ops pointer overwrites SATA HBA driver
672 * cb_ops pointer in SATA HBA driver dev_ops structure.
673 * SATA HBA framework cb_ops supplies cb_open cb_close and cb_ioctl vectors.
674 *
675 * Return status of the scsi_hba_init() is returned to a calling SATA HBA
676 * driver.
677 */
678 int
679 sata_hba_init(struct modlinkage *modlp)
680 {
681 int rval;
682 struct dev_ops *hba_ops;
683
684 SATADBG1(SATA_DBG_HBA_IF, NULL,
685 "sata_hba_init: name %s \n",
686 ((struct modldrv *)(modlp->ml_linkage[0]))->drv_linkinfo);
687 /*
688 * Fill-up cb_ops and dev_ops when necessary
689 */
690 hba_ops = ((struct modldrv *)(modlp->ml_linkage[0]))->drv_dev_ops;
691 /*
692 * Provide pointer to SATA dev_ops
693 */
694 hba_ops->devo_cb_ops = &sata_cb_ops;
695
696 /*
697 * Register SATA HBA with SCSI framework
698 */
699 if ((rval = scsi_hba_init(modlp)) != 0) {
700 SATADBG1(SATA_DBG_HBA_IF, NULL,
701 "sata_hba_init: scsi hba init failed\n", NULL);
702 return (rval);
703 }
704
705 return (0);
706 }
707
708
709 /* HBA attach stages */
710 #define HBA_ATTACH_STAGE_SATA_HBA_INST 1
711 #define HBA_ATTACH_STAGE_SCSI_ATTACHED 2
712 #define HBA_ATTACH_STAGE_SETUP 4
713 #define HBA_ATTACH_STAGE_LINKED 8
714
715
716 /*
717 *
718 * Called from SATA HBA driver's attach routine to attach an instance of
719 * the HBA.
720 *
721 * For DDI_ATTACH command:
722 * sata_hba_inst structure is allocated here and initialized with pointers to
723 * SATA framework implementation of required scsi tran functions.
724 * The scsi_tran's tran_hba_private field is used by SATA Framework to point
725 * to the soft structure (sata_hba_inst) allocated by SATA framework for
726 * SATA HBA instance related data.
727 * The scsi_tran's tran_hba_private field is used by SATA framework to
728 * store a pointer to per-HBA-instance of sata_hba_inst structure.
729 * The sata_hba_inst structure is cross-linked to scsi tran structure.
730 * Among other info, a pointer to sata_hba_tran structure is stored in
731 * sata_hba_inst. The sata_hba_inst structures for different HBA instances are
732 * linked together into the list, pointed to by sata_hba_list.
733 * On the first HBA instance attach the sata event thread is initialized.
734 * Attachment points are created for all SATA ports of the HBA being attached.
735 * All HBA instance's SATA ports are probed and type of plugged devices is
736 * determined. For each device of a supported type, a target node is created.
737 *
738 * DDI_SUCCESS is returned when attachment process is successful,
739 * DDI_FAILURE is returned otherwise.
740 *
741 * For DDI_RESUME command:
742 * Not implemented at this time (postponed until phase 2 of the development).
743 */
744 int
745 sata_hba_attach(dev_info_t *dip, sata_hba_tran_t *sata_tran,
746 ddi_attach_cmd_t cmd)
747 {
748 sata_hba_inst_t *sata_hba_inst;
749 scsi_hba_tran_t *scsi_tran = NULL;
750 int hba_attach_state = 0;
751 char taskq_name[MAXPATHLEN];
752
753 SATADBG3(SATA_DBG_HBA_IF, NULL,
754 "sata_hba_attach: node %s (%s%d)\n",
755 ddi_node_name(dip), ddi_driver_name(dip),
756 ddi_get_instance(dip));
757
758 if (cmd == DDI_RESUME) {
759 /*
760 * Postponed until phase 2 of the development
761 */
762 return (DDI_FAILURE);
763 }
764
765 if (cmd != DDI_ATTACH) {
766 return (DDI_FAILURE);
767 }
768
769 /* cmd == DDI_ATTACH */
770
771 if (sata_validate_sata_hba_tran(dip, sata_tran) != SATA_SUCCESS) {
772 SATA_LOG_D((NULL, CE_WARN,
773 "sata_hba_attach: invalid sata_hba_tran"));
774 return (DDI_FAILURE);
775 }
776 /*
777 * Allocate and initialize SCSI tran structure.
778 * SATA copy of tran_bus_config is provided to create port nodes.
779 */
780 scsi_tran = scsi_hba_tran_alloc(dip, SCSI_HBA_CANSLEEP);
781 if (scsi_tran == NULL)
782 return (DDI_FAILURE);
783 /*
784 * Allocate soft structure for SATA HBA instance.
785 * There is a separate softstate for each HBA instance.
786 */
787 sata_hba_inst = kmem_zalloc(sizeof (struct sata_hba_inst), KM_SLEEP);
788 ASSERT(sata_hba_inst != NULL); /* this should not fail */
789 mutex_init(&sata_hba_inst->satahba_mutex, NULL, MUTEX_DRIVER, NULL);
790 hba_attach_state |= HBA_ATTACH_STAGE_SATA_HBA_INST;
791
792 /*
793 * scsi_trans's tran_hba_private is used by SATA Framework to point to
794 * soft structure allocated by SATA framework for
795 * SATA HBA instance related data.
796 */
797 scsi_tran->tran_hba_private = sata_hba_inst;
798 scsi_tran->tran_tgt_private = NULL;
799
800 scsi_tran->tran_tgt_init = sata_scsi_tgt_init;
801 scsi_tran->tran_tgt_probe = sata_scsi_tgt_probe;
802 scsi_tran->tran_tgt_free = sata_scsi_tgt_free;
803
804 scsi_tran->tran_start = sata_scsi_start;
805 scsi_tran->tran_reset = sata_scsi_reset;
806 scsi_tran->tran_abort = sata_scsi_abort;
807 scsi_tran->tran_getcap = sata_scsi_getcap;
808 scsi_tran->tran_setcap = sata_scsi_setcap;
809 scsi_tran->tran_init_pkt = sata_scsi_init_pkt;
810 scsi_tran->tran_destroy_pkt = sata_scsi_destroy_pkt;
811
812 scsi_tran->tran_dmafree = sata_scsi_dmafree;
813 scsi_tran->tran_sync_pkt = sata_scsi_sync_pkt;
814
815 scsi_tran->tran_reset_notify = NULL;
816 scsi_tran->tran_get_bus_addr = NULL;
817 scsi_tran->tran_quiesce = NULL;
818 scsi_tran->tran_unquiesce = NULL;
819 scsi_tran->tran_bus_reset = NULL;
820
821 if (scsi_hba_attach_setup(dip, sata_tran->sata_tran_hba_dma_attr,
822 scsi_tran, 0) != DDI_SUCCESS) {
823 #ifdef SATA_DEBUG
824 cmn_err(CE_WARN, "?SATA: %s%d hba scsi attach failed",
825 ddi_driver_name(dip), ddi_get_instance(dip));
826 #endif
827 goto fail;
828 }
829 hba_attach_state |= HBA_ATTACH_STAGE_SCSI_ATTACHED;
830
831 if (!ddi_prop_exists(DDI_DEV_T_ANY, dip, DDI_PROP_DONTPASS, "sata")) {
832 if (ddi_prop_update_int(DDI_DEV_T_NONE, dip,
833 "sata", 1) != DDI_PROP_SUCCESS) {
834 SATA_LOG_D((NULL, CE_WARN, "sata_hba_attach: "
835 "failed to create hba sata prop"));
836 goto fail;
837 }
838 }
839
840 /*
841 * Save pointers in hba instance soft state.
842 */
843 sata_hba_inst->satahba_scsi_tran = scsi_tran;
844 sata_hba_inst->satahba_tran = sata_tran;
845 sata_hba_inst->satahba_dip = dip;
846
847 /*
848 * Create a task queue to handle emulated commands completion
849 * Use node name, dash, instance number as the queue name.
850 */
851 taskq_name[0] = '\0';
852 (void) strlcat(taskq_name, DEVI(dip)->devi_node_name,
853 sizeof (taskq_name));
854 (void) snprintf(taskq_name + strlen(taskq_name),
855 sizeof (taskq_name) - strlen(taskq_name),
856 "-%d", DEVI(dip)->devi_instance);
857 sata_hba_inst->satahba_taskq = taskq_create(taskq_name, 1,
858 minclsyspri, 1, sata_tran->sata_tran_hba_num_cports * 4,
859 TASKQ_DYNAMIC);
860
861 hba_attach_state |= HBA_ATTACH_STAGE_SETUP;
862
863 /*
864 * Create events thread if not created yet.
865 */
866 sata_event_thread_control(1);
867
868 /*
869 * Link this hba instance into the list.
870 */
871 mutex_enter(&sata_mutex);
872
873 if (sata_hba_list == NULL) {
874 /*
875 * The first instance of HBA is attached.
876 * Set current/active default maximum NCQ/TCQ queue depth for
877 * all SATA devices. It is done here and now, to eliminate the
878 * possibility of the dynamic, programatic modification of the
879 * queue depth via global (and public) sata_max_queue_depth
880 * variable (this would require special handling in HBA drivers)
881 */
882 sata_current_max_qdepth = sata_max_queue_depth;
883 if (sata_current_max_qdepth > 32)
884 sata_current_max_qdepth = 32;
885 else if (sata_current_max_qdepth < 1)
886 sata_current_max_qdepth = 1;
887 }
888
889 sata_hba_inst->satahba_next = NULL;
890 sata_hba_inst->satahba_prev = sata_hba_list_tail;
891 if (sata_hba_list == NULL) {
892 sata_hba_list = sata_hba_inst;
893 }
894 if (sata_hba_list_tail != NULL) {
895 sata_hba_list_tail->satahba_next = sata_hba_inst;
896 }
897 sata_hba_list_tail = sata_hba_inst;
898 mutex_exit(&sata_mutex);
899 hba_attach_state |= HBA_ATTACH_STAGE_LINKED;
900
901 /*
902 * Create SATA HBA devctl minor node for sata_hba_open, close, ioctl
903 * SATA HBA driver should not use its own open/close entry points.
904 *
905 * Make sure that instance number doesn't overflow
906 * when forming minor numbers.
907 */
908 ASSERT(ddi_get_instance(dip) <= (L_MAXMIN >> INST_MINOR_SHIFT));
909 if (ddi_create_minor_node(dip, "devctl", S_IFCHR,
910 INST2DEVCTL(ddi_get_instance(dip)),
911 DDI_NT_SATA_NEXUS, 0) != DDI_SUCCESS) {
912 #ifdef SATA_DEBUG
913 cmn_err(CE_WARN, "sata_hba_attach: "
914 "cannot create devctl minor node");
915 #endif
916 goto fail;
917 }
918
919
920 /*
921 * Set-up kstats here, if necessary.
922 * (postponed until future phase of the development).
923 */
924
925 /*
926 * Indicate that HBA is attached. This will enable events processing
927 * for this HBA.
928 */
929 sata_hba_inst->satahba_attached = 1;
930 /*
931 * Probe controller ports. This operation will describe a current
932 * controller/port/multipliers/device configuration and will create
933 * attachment points.
934 * We may end-up with just a controller with no devices attached.
935 * For the ports with a supported device attached, device target nodes
936 * are created and devices are initialized.
937 */
938 sata_probe_ports(sata_hba_inst);
939
940 return (DDI_SUCCESS);
941
942 fail:
943 if (hba_attach_state & HBA_ATTACH_STAGE_LINKED) {
944 (void) sata_remove_hba_instance(dip);
945 if (sata_hba_list == NULL)
946 sata_event_thread_control(0);
947 }
948
949 if (hba_attach_state & HBA_ATTACH_STAGE_SETUP) {
950 (void) ddi_prop_remove(DDI_DEV_T_ANY, dip, "sata");
951 taskq_destroy(sata_hba_inst->satahba_taskq);
952 }
953
954 if (hba_attach_state & HBA_ATTACH_STAGE_SCSI_ATTACHED)
955 (void) scsi_hba_detach(dip);
956
957 if (hba_attach_state & HBA_ATTACH_STAGE_SATA_HBA_INST) {
958 mutex_destroy(&sata_hba_inst->satahba_mutex);
959 kmem_free((void *)sata_hba_inst,
960 sizeof (struct sata_hba_inst));
961 scsi_hba_tran_free(scsi_tran);
962 }
963
964 sata_log(NULL, CE_WARN, "?SATA: %s%d hba attach failed",
965 ddi_driver_name(dip), ddi_get_instance(dip));
966
967 return (DDI_FAILURE);
968 }
969
970
971 /*
972 * Called by SATA HBA from to detach an instance of the driver.
973 *
974 * For DDI_DETACH command:
975 * Free local structures allocated for SATA HBA instance during
976 * sata_hba_attach processing.
977 *
978 * Returns DDI_SUCCESS when HBA was detached, DDI_FAILURE otherwise.
979 *
980 * For DDI_SUSPEND command:
981 * Not implemented at this time (postponed until phase 2 of the development)
982 * Returnd DDI_SUCCESS.
983 *
984 * When the last HBA instance is detached, the event daemon is terminated.
985 *
986 * NOTE: Port multiplier is supported.
987 */
988 int
989 sata_hba_detach(dev_info_t *dip, ddi_detach_cmd_t cmd)
990 {
991 dev_info_t *tdip;
992 sata_hba_inst_t *sata_hba_inst;
993 scsi_hba_tran_t *scsi_hba_tran;
994 sata_cport_info_t *cportinfo;
995 sata_pmult_info_t *pminfo;
996 sata_drive_info_t *sdinfo;
997 sata_device_t sdevice;
998 int ncport, npmport;
999
1000 SATADBG3(SATA_DBG_HBA_IF, NULL, "sata_hba_detach: node %s (%s%d)\n",
1001 ddi_node_name(dip), ddi_driver_name(dip), ddi_get_instance(dip));
1002
1003 switch (cmd) {
1004 case DDI_DETACH:
1005
1006 if ((scsi_hba_tran = ddi_get_driver_private(dip)) == NULL)
1007 return (DDI_FAILURE);
1008
1009 sata_hba_inst = scsi_hba_tran->tran_hba_private;
1010 if (sata_hba_inst == NULL)
1011 return (DDI_FAILURE);
1012
1013 if (scsi_hba_detach(dip) == DDI_FAILURE) {
1014 sata_hba_inst->satahba_attached = 1;
1015 return (DDI_FAILURE);
1016 }
1017
1018 /*
1019 * Free all target nodes - at this point
1020 * devices should be at least offlined
1021 * otherwise scsi_hba_detach() should not be called.
1022 */
1023 for (ncport = 0; ncport < SATA_NUM_CPORTS(sata_hba_inst);
1024 ncport++) {
1025 cportinfo = SATA_CPORT_INFO(sata_hba_inst, ncport);
1026 if (cportinfo->cport_dev_type != SATA_DTYPE_PMULT) {
1027 sdinfo = SATA_CPORTINFO_DRV_INFO(cportinfo);
1028 if (sdinfo != NULL) {
1029 tdip = sata_get_target_dip(dip,
1030 ncport, 0);
1031 if (tdip != NULL) {
1032 if (ndi_devi_offline(tdip,
1033 NDI_DEVI_REMOVE) !=
1034 NDI_SUCCESS) {
1035 SATA_LOG_D((
1036 sata_hba_inst,
1037 CE_WARN,
1038 "sata_hba_detach: "
1039 "Target node not "
1040 "removed !"));
1041 return (DDI_FAILURE);
1042 }
1043 }
1044 }
1045 } else { /* SATA_DTYPE_PMULT */
1046 mutex_enter(&cportinfo->cport_mutex);
1047 pminfo = SATA_CPORTINFO_PMULT_INFO(cportinfo);
1048
1049 if (pminfo == NULL) {
1050 SATA_LOG_D((sata_hba_inst, CE_WARN,
1051 "sata_hba_detach: Port multiplier "
1052 "not ready yet!"));
1053 mutex_exit(&cportinfo->cport_mutex);
1054 return (DDI_FAILURE);
1055 }
1056
1057 /*
1058 * Detach would fail if removal of any of the
1059 * target nodes is failed - albeit in that
1060 * case some of them may have been removed.
1061 */
1062 for (npmport = 0; npmport < SATA_NUM_PMPORTS(
1063 sata_hba_inst, ncport); npmport++) {
1064 tdip = sata_get_target_dip(dip, ncport,
1065 npmport);
1066 if (tdip != NULL) {
1067 if (ndi_devi_offline(tdip,
1068 NDI_DEVI_REMOVE) !=
1069 NDI_SUCCESS) {
1070 SATA_LOG_D((
1071 sata_hba_inst,
1072 CE_WARN,
1073 "sata_hba_detach: "
1074 "Target node not "
1075 "removed !"));
1076 mutex_exit(&cportinfo->
1077 cport_mutex);
1078 return (DDI_FAILURE);
1079 }
1080 }
1081 }
1082 mutex_exit(&cportinfo->cport_mutex);
1083 }
1084 }
1085 /*
1086 * Disable sata event daemon processing for this HBA
1087 */
1088 sata_hba_inst->satahba_attached = 0;
1089
1090 /*
1091 * Remove event daemon thread, if it is last HBA instance.
1092 */
1093
1094 mutex_enter(&sata_mutex);
1095 if (sata_hba_list->satahba_next == NULL) {
1096 mutex_exit(&sata_mutex);
1097 sata_event_thread_control(0);
1098 mutex_enter(&sata_mutex);
1099 }
1100 mutex_exit(&sata_mutex);
1101
1102 /* Remove this HBA instance from the HBA list */
1103 sata_remove_hba_instance(dip);
1104
1105 /*
1106 * At this point there should be no target nodes attached.
1107 * Detach and destroy device and port info structures.
1108 */
1109 for (ncport = 0; ncport < SATA_NUM_CPORTS(sata_hba_inst);
1110 ncport++) {
1111 cportinfo = SATA_CPORT_INFO(sata_hba_inst, ncport);
1112 if (cportinfo->cport_dev_type != SATA_DTYPE_PMULT) {
1113 sdinfo =
1114 cportinfo->cport_devp.cport_sata_drive;
1115 if (sdinfo != NULL) {
1116 /* Release device structure */
1117 kmem_free(sdinfo,
1118 sizeof (sata_drive_info_t));
1119 }
1120 /* Release cport info */
1121 mutex_destroy(&cportinfo->cport_mutex);
1122 kmem_free(cportinfo,
1123 sizeof (sata_cport_info_t));
1124 } else { /* SATA_DTYPE_PMULT */
1125 sdevice.satadev_addr.cport = (uint8_t)ncport;
1126 sdevice.satadev_addr.qual = SATA_ADDR_PMULT;
1127 sata_free_pmult(sata_hba_inst, &sdevice);
1128 }
1129 }
1130
1131 scsi_hba_tran_free(sata_hba_inst->satahba_scsi_tran);
1132
1133 (void) ddi_prop_remove(DDI_DEV_T_ANY, dip, "sata");
1134
1135 taskq_destroy(sata_hba_inst->satahba_taskq);
1136
1137 mutex_destroy(&sata_hba_inst->satahba_mutex);
1138 kmem_free((void *)sata_hba_inst,
1139 sizeof (struct sata_hba_inst));
1140
1141 return (DDI_SUCCESS);
1142
1143 case DDI_SUSPEND:
1144 /*
1145 * Postponed until phase 2
1146 */
1147 return (DDI_FAILURE);
1148
1149 default:
1150 return (DDI_FAILURE);
1151 }
1152 }
1153
1154
1155 /*
1156 * Called by an HBA drive from _fini() routine.
1157 * Unregisters SATA HBA instance/SATA framework pair from the scsi framework.
1158 */
1159 void
1160 sata_hba_fini(struct modlinkage *modlp)
1161 {
1162 SATADBG1(SATA_DBG_HBA_IF, NULL,
1163 "sata_hba_fini: name %s\n",
1164 ((struct modldrv *)(modlp->ml_linkage[0]))->drv_linkinfo);
1165
1166 scsi_hba_fini(modlp);
1167 }
1168
1169
1170 /*
1171 * Default open and close routine for sata_hba framework.
1172 *
1173 */
1174 /*
1175 * Open devctl node.
1176 *
1177 * Returns:
1178 * 0 if node was open successfully, error code otherwise.
1179 *
1180 *
1181 */
1182
1183 static int
1184 sata_hba_open(dev_t *devp, int flags, int otyp, cred_t *credp)
1185 {
1186 #ifndef __lock_lint
1187 _NOTE(ARGUNUSED(credp))
1188 #endif
1189 int rv = 0;
1190 dev_info_t *dip;
1191 scsi_hba_tran_t *scsi_hba_tran;
1192 sata_hba_inst_t *sata_hba_inst;
1193
1194 SATADBG1(SATA_DBG_IOCTL_IF, NULL, "sata_hba_open: entered", NULL);
1195
1196 if (otyp != OTYP_CHR)
1197 return (EINVAL);
1198
1199 dip = sata_devt_to_devinfo(*devp);
1200 if (dip == NULL)
1201 return (ENXIO);
1202
1203 if ((scsi_hba_tran = ddi_get_driver_private(dip)) == NULL)
1204 return (ENXIO);
1205
1206 sata_hba_inst = scsi_hba_tran->tran_hba_private;
1207 if (sata_hba_inst == NULL || sata_hba_inst->satahba_attached == 0)
1208 return (ENXIO);
1209
1210 mutex_enter(&sata_mutex);
1211 if (flags & FEXCL) {
1212 if (sata_hba_inst->satahba_open_flag != 0) {
1213 rv = EBUSY;
1214 } else {
1215 sata_hba_inst->satahba_open_flag =
1216 SATA_DEVCTL_EXOPENED;
1217 }
1218 } else {
1219 if (sata_hba_inst->satahba_open_flag == SATA_DEVCTL_EXOPENED) {
1220 rv = EBUSY;
1221 } else {
1222 sata_hba_inst->satahba_open_flag =
1223 SATA_DEVCTL_SOPENED;
1224 }
1225 }
1226 mutex_exit(&sata_mutex);
1227
1228 return (rv);
1229 }
1230
1231
1232 /*
1233 * Close devctl node.
1234 * Returns:
1235 * 0 if node was closed successfully, error code otherwise.
1236 *
1237 */
1238
1239 static int
1240 sata_hba_close(dev_t dev, int flag, int otyp, cred_t *credp)
1241 {
1242 #ifndef __lock_lint
1243 _NOTE(ARGUNUSED(credp))
1244 _NOTE(ARGUNUSED(flag))
1245 #endif
1246 dev_info_t *dip;
1247 scsi_hba_tran_t *scsi_hba_tran;
1248 sata_hba_inst_t *sata_hba_inst;
1249
1250 SATADBG1(SATA_DBG_IOCTL_IF, NULL, "sata_hba_close: entered", NULL);
1251
1252 if (otyp != OTYP_CHR)
1253 return (EINVAL);
1254
1255 dip = sata_devt_to_devinfo(dev);
1256 if (dip == NULL)
1257 return (ENXIO);
1258
1259 if ((scsi_hba_tran = ddi_get_driver_private(dip)) == NULL)
1260 return (ENXIO);
1261
1262 sata_hba_inst = scsi_hba_tran->tran_hba_private;
1263 if (sata_hba_inst == NULL || sata_hba_inst->satahba_attached == 0)
1264 return (ENXIO);
1265
1266 mutex_enter(&sata_mutex);
1267 sata_hba_inst->satahba_open_flag = 0;
1268 mutex_exit(&sata_mutex);
1269 return (0);
1270 }
1271
1272
1273
1274 /*
1275 * Standard IOCTL commands for SATA hotplugging.
1276 * Implemented DEVCTL_AP commands:
1277 * DEVCTL_AP_CONNECT
1278 * DEVCTL_AP_DISCONNECT
1279 * DEVCTL_AP_CONFIGURE
1280 * DEVCTL_UNCONFIGURE
1281 * DEVCTL_AP_CONTROL
1282 *
1283 * Commands passed to default ndi ioctl handler:
1284 * DEVCTL_DEVICE_GETSTATE
1285 * DEVCTL_DEVICE_ONLINE
1286 * DEVCTL_DEVICE_OFFLINE
1287 * DEVCTL_DEVICE_REMOVE
1288 * DEVCTL_DEVICE_INSERT
1289 * DEVCTL_BUS_GETSTATE
1290 *
1291 * All other cmds are passed to HBA if it provide ioctl handler, or failed
1292 * if not.
1293 *
1294 * Returns:
1295 * 0 if successful,
1296 * error code if operation failed.
1297 *
1298 * Port Multiplier support is supported now.
1299 *
1300 * NOTE: qual should be SATA_ADDR_DCPORT or SATA_ADDR_DPMPORT
1301 */
1302
1303 static int
1304 sata_hba_ioctl(dev_t dev, int cmd, intptr_t arg, int mode, cred_t *credp,
1305 int *rvalp)
1306 {
1307 #ifndef __lock_lint
1308 _NOTE(ARGUNUSED(credp))
1309 _NOTE(ARGUNUSED(rvalp))
1310 #endif
1311 int rv = 0;
1312 int32_t comp_port = -1;
1313 dev_info_t *dip;
1314 devctl_ap_state_t ap_state;
1315 struct devctl_iocdata *dcp = NULL;
1316 scsi_hba_tran_t *scsi_hba_tran;
1317 sata_hba_inst_t *sata_hba_inst;
1318 sata_device_t sata_device;
1319 sata_cport_info_t *cportinfo;
1320 int cport, pmport, qual;
1321 int rval = SATA_SUCCESS;
1322
1323 dip = sata_devt_to_devinfo(dev);
1324 if (dip == NULL)
1325 return (ENXIO);
1326
1327 if ((scsi_hba_tran = ddi_get_driver_private(dip)) == NULL)
1328 return (ENXIO);
1329
1330 sata_hba_inst = scsi_hba_tran->tran_hba_private;
1331 if (sata_hba_inst == NULL)
1332 return (ENXIO);
1333
1334 if (sata_hba_inst->satahba_tran == NULL)
1335 return (ENXIO);
1336
1337 switch (cmd) {
1338
1339 case DEVCTL_DEVICE_GETSTATE:
1340 case DEVCTL_DEVICE_ONLINE:
1341 case DEVCTL_DEVICE_OFFLINE:
1342 case DEVCTL_DEVICE_REMOVE:
1343 case DEVCTL_BUS_GETSTATE:
1344 /*
1345 * There may be more cases that we want to pass to default
1346 * handler rather than fail them.
1347 */
1348 return (ndi_devctl_ioctl(dip, cmd, arg, mode, 0));
1349 }
1350
1351 /* read devctl ioctl data */
1352 if (cmd != DEVCTL_AP_CONTROL) {
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 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex);
1681 cportinfo->cport_event_flags &= ~SATA_APCTL_LOCK_PORT_BUSY;
1682 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex);
1683
1684 return (rv);
1685 }
1686
1687
1688 /*
1689 * Create error retrieval sata packet
1690 *
1691 * A sata packet is allocated and set-up to contain specified error retrieval
1692 * command and appropriate dma-able data buffer.
1693 * No association with any scsi packet is made and no callback routine is
1694 * specified.
1695 *
1696 * Returns a pointer to sata packet upon successful packet creation.
1697 * Returns NULL, if packet cannot be created.
1698 */
1699 sata_pkt_t *
1700 sata_get_error_retrieval_pkt(dev_info_t *dip, sata_device_t *sata_device,
1701 int pkt_type)
1702 {
1703 sata_hba_inst_t *sata_hba_inst;
1704 sata_pkt_txlate_t *spx;
1705 sata_pkt_t *spkt;
1706 sata_drive_info_t *sdinfo;
1707
1708 mutex_enter(&sata_mutex);
1709 for (sata_hba_inst = sata_hba_list; sata_hba_inst != NULL;
1710 sata_hba_inst = sata_hba_inst->satahba_next) {
1711 if (SATA_DIP(sata_hba_inst) == dip)
1712 break;
1713 }
1714 mutex_exit(&sata_mutex);
1715 ASSERT(sata_hba_inst != NULL);
1716
1717 sdinfo = sata_get_device_info(sata_hba_inst, sata_device);
1718 if (sdinfo == NULL) {
1719 sata_log(sata_hba_inst, CE_WARN,
1720 "sata: error recovery request for non-attached device at "
1721 "cport %d", sata_device->satadev_addr.cport);
1722 return (NULL);
1723 }
1724
1725 spx = kmem_zalloc(sizeof (sata_pkt_txlate_t), KM_SLEEP);
1726 spx->txlt_sata_hba_inst = sata_hba_inst;
1727 spx->txlt_scsi_pkt = NULL; /* No scsi pkt involved */
1728 spkt = sata_pkt_alloc(spx, NULL);
1729 if (spkt == NULL) {
1730 kmem_free(spx, sizeof (sata_pkt_txlate_t));
1731 return (NULL);
1732 }
1733 /* address is needed now */
1734 spkt->satapkt_device.satadev_addr = sata_device->satadev_addr;
1735
1736 switch (pkt_type) {
1737 case SATA_ERR_RETR_PKT_TYPE_NCQ:
1738 if (sata_ncq_err_ret_cmd_setup(spx, sdinfo) == SATA_SUCCESS) {
1739 if (sata_check_for_dma_error(dip, spx)) {
1740 ddi_fm_service_impact(dip,
1741 DDI_SERVICE_UNAFFECTED);
1742 break;
1743 }
1744 return (spkt);
1745 }
1746 break;
1747
1748 case SATA_ERR_RETR_PKT_TYPE_ATAPI:
1749 if (sata_atapi_err_ret_cmd_setup(spx, sdinfo) == SATA_SUCCESS) {
1750 if (sata_check_for_dma_error(dip, spx)) {
1751 ddi_fm_service_impact(dip,
1752 DDI_SERVICE_UNAFFECTED);
1753 break;
1754 }
1755 return (spkt);
1756 }
1757 break;
1758
1759 default:
1760 break;
1761 }
1762
1763 sata_pkt_free(spx);
1764 kmem_free(spx, sizeof (sata_pkt_txlate_t));
1765 return (NULL);
1766
1767 }
1768
1769
1770 /*
1771 * Free error retrieval sata packet
1772 *
1773 * Free sata packet and any associated resources allocated previously by
1774 * sata_get_error_retrieval_pkt().
1775 *
1776 * Void return.
1777 */
1778 void
1779 sata_free_error_retrieval_pkt(sata_pkt_t *sata_pkt)
1780 {
1781 sata_pkt_txlate_t *spx =
1782 (sata_pkt_txlate_t *)sata_pkt->satapkt_framework_private;
1783
1784 ASSERT(sata_pkt != NULL);
1785
1786 sata_free_local_buffer(spx);
1787 sata_pkt_free(spx);
1788 kmem_free(spx, sizeof (sata_pkt_txlate_t));
1789
1790 }
1791
1792 /*
1793 * Create READ PORT MULTIPLIER and WRITE PORT MULTIPLIER sata packet
1794 *
1795 * No association with any scsi packet is made and no callback routine is
1796 * specified.
1797 *
1798 * Returns a pointer to sata packet upon successful packet creation.
1799 * Returns NULL, if packet cannot be created.
1800 *
1801 * NOTE: Input/Output value includes 64 bits accoring to SATA Spec 2.6,
1802 * only lower 32 bits are available currently.
1803 */
1804 sata_pkt_t *
1805 sata_get_rdwr_pmult_pkt(dev_info_t *dip, sata_device_t *sd,
1806 uint8_t regn, uint32_t regv, uint32_t type)
1807 {
1808 sata_hba_inst_t *sata_hba_inst;
1809 sata_pkt_txlate_t *spx;
1810 sata_pkt_t *spkt;
1811 sata_cmd_t *scmd;
1812
1813 /* Only READ/WRITE commands are accepted. */
1814 ASSERT(type == SATA_RDWR_PMULT_PKT_TYPE_READ ||
1815 type == SATA_RDWR_PMULT_PKT_TYPE_WRITE);
1816
1817 mutex_enter(&sata_mutex);
1818 for (sata_hba_inst = sata_hba_list; sata_hba_inst != NULL;
1819 sata_hba_inst = sata_hba_inst->satahba_next) {
1820 if (SATA_DIP(sata_hba_inst) == dip)
1821 break;
1822 }
1823 mutex_exit(&sata_mutex);
1824 ASSERT(sata_hba_inst != NULL);
1825
1826 spx = kmem_zalloc(sizeof (sata_pkt_txlate_t), KM_SLEEP);
1827 spx->txlt_sata_hba_inst = sata_hba_inst;
1828 spx->txlt_scsi_pkt = NULL; /* No scsi pkt involved */
1829 spkt = sata_pkt_alloc(spx, SLEEP_FUNC);
1830 if (spkt == NULL) {
1831 kmem_free(spx, sizeof (sata_pkt_txlate_t));
1832 return (NULL);
1833 }
1834
1835 /*
1836 * NOTE: We need to send this command to the port multiplier,
1837 * that means send to SATA_PMULT_HOSTPORT(0xf) pmport
1838 *
1839 * sata_device contains the address of actual target device, and the
1840 * pmport number in the command comes from the sata_device structure.
1841 */
1842 spkt->satapkt_device.satadev_addr = sd->satadev_addr;
1843 spkt->satapkt_device.satadev_addr.pmport = SATA_PMULT_HOSTPORT;
1844 spkt->satapkt_device.satadev_addr.qual = SATA_ADDR_PMULT;
1845
1846 /* Fill sata_pkt */
1847 spkt->satapkt_op_mode = SATA_OPMODE_SYNCH | SATA_OPMODE_POLLING;
1848 spkt->satapkt_comp = NULL; /* Synchronous mode, no callback */
1849 spkt->satapkt_time = 10; /* Timeout 10s */
1850
1851 /* Build READ PORT MULTIPLIER cmd in the sata_pkt */
1852 scmd = &spkt->satapkt_cmd;
1853 scmd->satacmd_features_reg = regn & 0xff;
1854 scmd->satacmd_features_reg_ext = (regn >> 8) & 0xff;
1855 scmd->satacmd_device_reg = sd->satadev_addr.pmport;
1856 scmd->satacmd_addr_type = 0; /* N/A */
1857
1858 scmd->satacmd_flags.sata_ignore_dev_reset = B_TRUE;
1859
1860 if (type == SATA_RDWR_PMULT_PKT_TYPE_READ) {
1861 scmd->satacmd_cmd_reg = SATAC_READ_PORTMULT;
1862 scmd->satacmd_flags.sata_data_direction = SATA_DIR_READ;
1863 scmd->satacmd_flags.sata_special_regs = 1;
1864 scmd->satacmd_flags.sata_copy_out_lba_high_lsb = 1;
1865 scmd->satacmd_flags.sata_copy_out_lba_mid_lsb = 1;
1866 scmd->satacmd_flags.sata_copy_out_lba_low_lsb = 1;
1867 scmd->satacmd_flags.sata_copy_out_sec_count_lsb = 1;
1868 } else if (type == SATA_RDWR_PMULT_PKT_TYPE_WRITE) {
1869 scmd->satacmd_cmd_reg = SATAC_WRITE_PORTMULT;
1870 scmd->satacmd_flags.sata_data_direction = SATA_DIR_WRITE;
1871 scmd->satacmd_sec_count_lsb = regv & 0xff;
1872 scmd->satacmd_lba_low_lsb = regv >> 8 & 0xff;
1873 scmd->satacmd_lba_mid_lsb = regv >> 16 & 0xff;
1874 scmd->satacmd_lba_high_lsb = regv >> 24 & 0xff;
1875 }
1876
1877 return (spkt);
1878 }
1879
1880 /*
1881 * Free sata packet and any associated resources allocated previously by
1882 * sata_get_rdwr_pmult_pkt().
1883 *
1884 * Void return.
1885 */
1886 void
1887 sata_free_rdwr_pmult_pkt(sata_pkt_t *sata_pkt)
1888 {
1889 sata_pkt_txlate_t *spx =
1890 (sata_pkt_txlate_t *)sata_pkt->satapkt_framework_private;
1891
1892 /* Free allocated resources */
1893 sata_pkt_free(spx);
1894 kmem_free(spx, sizeof (sata_pkt_txlate_t));
1895 }
1896
1897 /*
1898 * Register a port multiplier to framework.
1899 * 1) Store the GSCR values in the previous allocated pmult_info strctures.
1900 * 2) Search in the blacklist and update the number of the device ports of the
1901 * port multiplier.
1902 *
1903 * Void return.
1904 */
1905 void
1906 sata_register_pmult(dev_info_t *dip, sata_device_t *sd, sata_pmult_gscr_t *sg)
1907 {
1908 sata_hba_inst_t *sata_hba_inst = NULL;
1909 sata_pmult_info_t *pmultinfo;
1910 sata_pmult_bl_t *blp;
1911 int cport = sd->satadev_addr.cport;
1912
1913 mutex_enter(&sata_mutex);
1914 for (sata_hba_inst = sata_hba_list; sata_hba_inst != NULL;
1915 sata_hba_inst = sata_hba_inst->satahba_next) {
1916 if (SATA_DIP(sata_hba_inst) == dip)
1917 if (sata_hba_inst->satahba_attached == 1)
1918 break;
1919 }
1920 mutex_exit(&sata_mutex);
1921 /* HBA not attached? */
1922 if (sata_hba_inst == NULL)
1923 return;
1924
1925 /* Number of pmports */
1926 sd->satadev_add_info = sg->gscr2 & SATA_PMULT_PORTNUM_MASK;
1927
1928 /* Check the blacklist */
1929 for (blp = sata_pmult_blacklist; blp->bl_gscr0; blp++) {
1930 if (sg->gscr0 != blp->bl_gscr0 && blp->bl_gscr0)
1931 continue;
1932 if (sg->gscr1 != blp->bl_gscr1 && blp->bl_gscr1)
1933 continue;
1934 if (sg->gscr2 != blp->bl_gscr2 && blp->bl_gscr2)
1935 continue;
1936
1937 cmn_err(CE_WARN, "!Port multiplier is on the blacklist.");
1938 sd->satadev_add_info = blp->bl_flags;
1939 break;
1940 }
1941
1942 /* Register the port multiplier GSCR */
1943 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, cport)));
1944 pmultinfo = SATA_PMULT_INFO(sata_hba_inst, cport);
1945 if (pmultinfo != NULL) {
1946 pmultinfo->pmult_gscr = *sg;
1947 pmultinfo->pmult_num_dev_ports =
1948 sd->satadev_add_info & SATA_PMULT_PORTNUM_MASK;
1949 SATADBG1(SATA_DBG_PMULT, sata_hba_inst,
1950 "Port multiplier registered at port %d", cport);
1951 }
1952 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, cport)));
1953 }
1954
1955 /*
1956 * sata_split_model splits the model ID into vendor and product IDs.
1957 * It assumes that a vendor ID cannot be longer than 8 characters, and
1958 * that vendor and product ID are separated by a whitespace.
1959 */
1960 void
1961 sata_split_model(char *model, char **vendor, char **product)
1962 {
1963 int i, modlen;
1964 char *vid, *pid;
1965
1966 /*
1967 * remove whitespace at the end of model
1968 */
1969 for (i = SATA_ID_MODEL_LEN; i > 0; i--)
1970 if (model[i] == ' ' || model[i] == '\t' || model[i] == '\0')
1971 model[i] = '\0';
1972 else
1973 break;
1974
1975 /*
1976 * try to split model into into vid/pid
1977 */
1978 modlen = strlen(model);
1979 for (i = 0, pid = model; i < modlen; i++, pid++)
1980 if ((*pid == ' ') || (*pid == '\t'))
1981 break;
1982
1983 /*
1984 * only use vid if it is less than 8 chars (as in SCSI)
1985 */
1986 if (i < modlen && i <= 8) {
1987 vid = model;
1988 /*
1989 * terminate vid, establish pid
1990 */
1991 *pid++ = '\0';
1992 } else {
1993 /*
1994 * vid will stay "ATA "
1995 */
1996 vid = NULL;
1997 /*
1998 * model is all pid
1999 */
2000 pid = model;
2001 }
2002
2003 *vendor = vid;
2004 *product = pid;
2005 }
2006
2007 /*
2008 * sata_name_child is for composing the name of the node
2009 * the format of the name is "target,0".
2010 */
2011 static int
2012 sata_name_child(dev_info_t *dip, char *name, int namelen)
2013 {
2014 int target;
2015
2016 target = ddi_prop_get_int(DDI_DEV_T_ANY, dip,
2017 DDI_PROP_DONTPASS, "target", -1);
2018 if (target == -1)
2019 return (DDI_FAILURE);
2020 (void) snprintf(name, namelen, "%x,0", target);
2021 return (DDI_SUCCESS);
2022 }
2023
2024
2025
2026 /* ****************** SCSA required entry points *********************** */
2027
2028 /*
2029 * Implementation of scsi tran_tgt_init.
2030 * sata_scsi_tgt_init() initializes scsi_device structure
2031 *
2032 * If successful, DDI_SUCCESS is returned.
2033 * DDI_FAILURE is returned if addressed device does not exist
2034 */
2035
2036 static int
2037 sata_scsi_tgt_init(dev_info_t *hba_dip, dev_info_t *tgt_dip,
2038 scsi_hba_tran_t *hba_tran, struct scsi_device *sd)
2039 {
2040 #ifndef __lock_lint
2041 _NOTE(ARGUNUSED(hba_dip))
2042 _NOTE(ARGUNUSED(tgt_dip))
2043 #endif
2044 sata_device_t sata_device;
2045 sata_drive_info_t *sdinfo;
2046 struct sata_id *sid;
2047 sata_hba_inst_t *sata_hba_inst;
2048 char model[SATA_ID_MODEL_LEN + 1];
2049 char fw[SATA_ID_FW_LEN + 1];
2050 char *vid, *pid;
2051
2052 /*
2053 * Fail tran_tgt_init for .conf stub node
2054 */
2055 if (ndi_dev_is_persistent_node(tgt_dip) == 0) {
2056 (void) ndi_merge_node(tgt_dip, sata_name_child);
2057 ddi_set_name_addr(tgt_dip, NULL);
2058 return (DDI_FAILURE);
2059 }
2060
2061 sata_hba_inst = (sata_hba_inst_t *)(hba_tran->tran_hba_private);
2062
2063 /* Validate scsi device address */
2064 if (sata_validate_scsi_address(sata_hba_inst, &sd->sd_address,
2065 &sata_device) != 0)
2066 return (DDI_FAILURE);
2067
2068 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst,
2069 sata_device.satadev_addr.cport)));
2070
2071 /* sata_device now contains a valid sata address */
2072 sdinfo = sata_get_device_info(sata_hba_inst, &sata_device);
2073 if (sdinfo == NULL) {
2074 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst,
2075 sata_device.satadev_addr.cport)));
2076 return (DDI_FAILURE);
2077 }
2078 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst,
2079 sata_device.satadev_addr.cport)));
2080
2081 /*
2082 * Check if we need to create a legacy devid (i.e cmdk style) for
2083 * the target disks.
2084 *
2085 * HBA devinfo node will have the property "use-cmdk-devid-format"
2086 * if we need to create cmdk-style devid for all the disk devices
2087 * attached to this controller. This property may have been set
2088 * from HBA driver's .conf file or by the HBA driver in its
2089 * attach(9F) function.
2090 */
2091 if ((sdinfo->satadrv_type == SATA_DTYPE_ATADISK) &&
2092 (ddi_getprop(DDI_DEV_T_ANY, hba_dip, DDI_PROP_DONTPASS,
2093 "use-cmdk-devid-format", 0) == 1)) {
2094 /* register a legacy devid for this target node */
2095 sata_target_devid_register(tgt_dip, sdinfo);
2096 }
2097
2098
2099 /*
2100 * 'Identify Device Data' does not always fit in standard SCSI
2101 * INQUIRY data, so establish INQUIRY_* properties with full-form
2102 * of information.
2103 */
2104 sid = &sdinfo->satadrv_id;
2105 #ifdef _LITTLE_ENDIAN
2106 swab(sid->ai_model, model, SATA_ID_MODEL_LEN);
2107 swab(sid->ai_fw, fw, SATA_ID_FW_LEN);
2108 #else /* _LITTLE_ENDIAN */
2109 bcopy(sid->ai_model, model, SATA_ID_MODEL_LEN);
2110 bcopy(sid->ai_fw, fw, SATA_ID_FW_LEN);
2111 #endif /* _LITTLE_ENDIAN */
2112 model[SATA_ID_MODEL_LEN] = 0;
2113 fw[SATA_ID_FW_LEN] = 0;
2114
2115 sata_split_model(model, &vid, &pid);
2116
2117 if (vid)
2118 (void) scsi_device_prop_update_inqstring(sd, INQUIRY_VENDOR_ID,
2119 vid, strlen(vid));
2120 if (pid)
2121 (void) scsi_device_prop_update_inqstring(sd, INQUIRY_PRODUCT_ID,
2122 pid, strlen(pid));
2123 (void) scsi_device_prop_update_inqstring(sd, INQUIRY_REVISION_ID,
2124 fw, strlen(fw));
2125
2126 return (DDI_SUCCESS);
2127 }
2128
2129 /*
2130 * Implementation of scsi tran_tgt_probe.
2131 * Probe target, by calling default scsi routine scsi_hba_probe()
2132 */
2133 static int
2134 sata_scsi_tgt_probe(struct scsi_device *sd, int (*callback)(void))
2135 {
2136 sata_hba_inst_t *sata_hba_inst =
2137 (sata_hba_inst_t *)(sd->sd_address.a_hba_tran->tran_hba_private);
2138 int rval;
2139 uint32_t pm_cap;
2140
2141 rval = scsi_hba_probe(sd, callback);
2142 pm_cap = SATA_CAP_POWER_CONDITON | SATA_CAP_SMART_PAGE |
2143 SATA_CAP_LOG_SENSE;
2144
2145 if (rval == SCSIPROBE_EXISTS) {
2146 /*
2147 * Set property "pm-capable" on the target device node, so that
2148 * the target driver will not try to fetch scsi cycle counters
2149 * before enabling device power-management.
2150 */
2151 if ((ddi_prop_update_int(DDI_DEV_T_NONE, sd->sd_dev,
2152 "pm-capable", pm_cap)) != DDI_PROP_SUCCESS) {
2153 sata_log(sata_hba_inst, CE_WARN,
2154 "SATA device at port %d: "
2155 "will not be power-managed ",
2156 SCSI_TO_SATA_CPORT(sd->sd_address.a_target));
2157 SATA_LOG_D((sata_hba_inst, CE_WARN,
2158 "failure updating pm-capable property"));
2159 }
2160 }
2161 return (rval);
2162 }
2163
2164 /*
2165 * Implementation of scsi tran_tgt_free.
2166 * Release all resources allocated for scsi_device
2167 */
2168 static void
2169 sata_scsi_tgt_free(dev_info_t *hba_dip, dev_info_t *tgt_dip,
2170 scsi_hba_tran_t *hba_tran, struct scsi_device *sd)
2171 {
2172 #ifndef __lock_lint
2173 _NOTE(ARGUNUSED(hba_dip))
2174 #endif
2175 sata_device_t sata_device;
2176 sata_drive_info_t *sdinfo;
2177 sata_hba_inst_t *sata_hba_inst;
2178 ddi_devid_t devid;
2179
2180 sata_hba_inst = (sata_hba_inst_t *)(hba_tran->tran_hba_private);
2181
2182 /* Validate scsi device address */
2183 /*
2184 * Note: tgt_free relates to the SCSA view of a device. If called, there
2185 * was a device at this address, so even if the sata framework internal
2186 * resources were alredy released because a device was detached,
2187 * this function should be executed as long as its actions do
2188 * not require the internal sata view of a device and the address
2189 * refers to a valid sata address.
2190 * Validating the address here means that we do not trust SCSA...
2191 */
2192 if (sata_validate_scsi_address(sata_hba_inst, &sd->sd_address,
2193 &sata_device) == -1)
2194 return;
2195
2196 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst,
2197 sata_device.satadev_addr.cport)));
2198
2199 /* sata_device now should contain a valid sata address */
2200 sdinfo = sata_get_device_info(sata_hba_inst, &sata_device);
2201 if (sdinfo == NULL) {
2202 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst,
2203 sata_device.satadev_addr.cport)));
2204 return;
2205 }
2206 /*
2207 * We did not allocate any resources in sata_scsi_tgt_init()
2208 * other than few properties.
2209 * Free them.
2210 */
2211 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst,
2212 sata_device.satadev_addr.cport)));
2213 (void) ndi_prop_remove(DDI_DEV_T_NONE, tgt_dip, "pm-capable");
2214
2215 /*
2216 * If devid was previously created but not freed up from
2217 * sd(7D) driver (i.e during detach(9F)) then do it here.
2218 */
2219 if ((sdinfo->satadrv_type == SATA_DTYPE_ATADISK) &&
2220 (ddi_getprop(DDI_DEV_T_ANY, hba_dip, DDI_PROP_DONTPASS,
2221 "use-cmdk-devid-format", 0) == 1) &&
2222 (ddi_devid_get(tgt_dip, &devid) == DDI_SUCCESS)) {
2223 ddi_devid_unregister(tgt_dip);
2224 ddi_devid_free(devid);
2225 }
2226 }
2227
2228 /*
2229 * Implementation of scsi tran_init_pkt
2230 * Upon successful return, scsi pkt buffer has DMA resources allocated.
2231 *
2232 * It seems that we should always allocate pkt, even if the address is
2233 * for non-existing device - just use some default for dma_attr.
2234 * The reason is that there is no way to communicate this to a caller here.
2235 * Subsequent call to sata_scsi_start may fail appropriately.
2236 * Simply returning NULL does not seem to discourage a target driver...
2237 *
2238 * Returns a pointer to initialized scsi_pkt, or NULL otherwise.
2239 */
2240 static struct scsi_pkt *
2241 sata_scsi_init_pkt(struct scsi_address *ap, struct scsi_pkt *pkt,
2242 struct buf *bp, int cmdlen, int statuslen, int tgtlen, int flags,
2243 int (*callback)(caddr_t), caddr_t arg)
2244 {
2245 sata_hba_inst_t *sata_hba_inst =
2246 (sata_hba_inst_t *)(ap->a_hba_tran->tran_hba_private);
2247 dev_info_t *dip = SATA_DIP(sata_hba_inst);
2248 sata_device_t sata_device;
2249 sata_drive_info_t *sdinfo;
2250 sata_pkt_txlate_t *spx;
2251 ddi_dma_attr_t cur_dma_attr;
2252 int rval;
2253 boolean_t new_pkt = B_TRUE;
2254
2255 ASSERT(ap->a_hba_tran->tran_hba_dip == dip);
2256
2257 /*
2258 * We need to translate the address, even if it could be
2259 * a bogus one, for a non-existing device
2260 */
2261 sata_device.satadev_addr.qual = SCSI_TO_SATA_ADDR_QUAL(ap->a_target);
2262 sata_device.satadev_addr.cport = SCSI_TO_SATA_CPORT(ap->a_target);
2263 sata_device.satadev_addr.pmport = SCSI_TO_SATA_PMPORT(ap->a_target);
2264 sata_device.satadev_rev = SATA_DEVICE_REV;
2265
2266 if (pkt == NULL) {
2267 /*
2268 * Have to allocate a brand new scsi packet.
2269 * We need to operate with auto request sense enabled.
2270 */
2271 pkt = scsi_hba_pkt_alloc(dip, ap, cmdlen,
2272 MAX(statuslen, SATA_MAX_SENSE_LEN),
2273 tgtlen, sizeof (sata_pkt_txlate_t), callback, arg);
2274
2275 if (pkt == NULL)
2276 return (NULL);
2277
2278 /* Fill scsi packet structure */
2279 pkt->pkt_comp = (void (*)())NULL;
2280 pkt->pkt_time = 0;
2281 pkt->pkt_resid = 0;
2282 pkt->pkt_statistics = 0;
2283 pkt->pkt_reason = 0;
2284
2285 /*
2286 * pkt_hba_private will point to sata pkt txlate structure
2287 */
2288 spx = (sata_pkt_txlate_t *)pkt->pkt_ha_private;
2289 bzero(spx, sizeof (sata_pkt_txlate_t));
2290
2291 spx->txlt_scsi_pkt = pkt;
2292 spx->txlt_sata_hba_inst = sata_hba_inst;
2293
2294 /* Allocate sata_pkt */
2295 spx->txlt_sata_pkt = sata_pkt_alloc(spx, callback);
2296 if (spx->txlt_sata_pkt == NULL) {
2297 /* Could not allocate sata pkt */
2298 scsi_hba_pkt_free(ap, pkt);
2299 return (NULL);
2300 }
2301 /* Set sata address */
2302 spx->txlt_sata_pkt->satapkt_device.satadev_addr =
2303 sata_device.satadev_addr;
2304 spx->txlt_sata_pkt->satapkt_device.satadev_rev =
2305 sata_device.satadev_rev;
2306
2307 if ((bp == NULL) || (bp->b_bcount == 0))
2308 return (pkt);
2309
2310 spx->txlt_total_residue = bp->b_bcount;
2311 } else {
2312 new_pkt = B_FALSE;
2313 /*
2314 * Packet was preallocated/initialized by previous call
2315 */
2316 spx = (sata_pkt_txlate_t *)pkt->pkt_ha_private;
2317
2318 if ((bp == NULL) || (bp->b_bcount == 0)) {
2319 return (pkt);
2320 }
2321
2322 /* Pkt is available already: spx->txlt_scsi_pkt == pkt; */
2323 }
2324
2325 spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp = bp;
2326
2327 /*
2328 * We use an adjusted version of the dma_attr, to account
2329 * for device addressing limitations.
2330 * sata_adjust_dma_attr() will handle sdinfo == NULL which may
2331 * happen when a device is not yet configured.
2332 */
2333 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst,
2334 sata_device.satadev_addr.cport)));
2335 sdinfo = sata_get_device_info(spx->txlt_sata_hba_inst,
2336 &spx->txlt_sata_pkt->satapkt_device);
2337 /* NULL sdinfo may be passsed to sata_adjust_dma_attr() */
2338 sata_adjust_dma_attr(sdinfo,
2339 SATA_DMA_ATTR(spx->txlt_sata_hba_inst), &cur_dma_attr);
2340 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst,
2341 sata_device.satadev_addr.cport)));
2342 /*
2343 * Allocate necessary DMA resources for the packet's data buffer
2344 * NOTE:
2345 * In case of read/write commands, DMA resource allocation here is
2346 * based on the premise that the transfer length specified in
2347 * the read/write scsi cdb will match exactly DMA resources -
2348 * returning correct packet residue is crucial.
2349 */
2350 if ((rval = sata_dma_buf_setup(spx, flags, callback, arg,
2351 &cur_dma_attr)) != DDI_SUCCESS) {
2352 /*
2353 * If a DMA allocation request fails with
2354 * DDI_DMA_NOMAPPING, indicate the error by calling
2355 * bioerror(9F) with bp and an error code of EFAULT.
2356 * If a DMA allocation request fails with
2357 * DDI_DMA_TOOBIG, indicate the error by calling
2358 * bioerror(9F) with bp and an error code of EINVAL.
2359 * For DDI_DMA_NORESOURCES, we may have some of them allocated.
2360 * Request may be repeated later - there is no real error.
2361 */
2362 switch (rval) {
2363 case DDI_DMA_NORESOURCES:
2364 bioerror(bp, 0);
2365 break;
2366 case DDI_DMA_NOMAPPING:
2367 case DDI_DMA_BADATTR:
2368 bioerror(bp, EFAULT);
2369 break;
2370 case DDI_DMA_TOOBIG:
2371 default:
2372 bioerror(bp, EINVAL);
2373 break;
2374 }
2375 goto fail;
2376 }
2377
2378 if (sata_check_for_dma_error(dip, spx)) {
2379 ddi_fm_service_impact(dip, DDI_SERVICE_UNAFFECTED);
2380 bioerror(bp, EFAULT);
2381 goto fail;
2382 }
2383
2384 success:
2385 /* Set number of bytes that are not yet accounted for */
2386 pkt->pkt_resid = spx->txlt_total_residue;
2387 ASSERT(pkt->pkt_resid >= 0);
2388
2389 return (pkt);
2390
2391 fail:
2392 if (new_pkt == B_TRUE) {
2393 /*
2394 * Since this is a new packet, we can clean-up
2395 * everything
2396 */
2397 sata_scsi_destroy_pkt(ap, pkt);
2398 } else {
2399 /*
2400 * This is a re-used packet. It will be target driver's
2401 * responsibility to eventually destroy it (which
2402 * will free allocated resources).
2403 * Here, we just "complete" the request, leaving
2404 * allocated resources intact, so the request may
2405 * be retried.
2406 */
2407 spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp = NULL;
2408 sata_pkt_free(spx);
2409 }
2410 return (NULL);
2411 }
2412
2413 /*
2414 * Implementation of scsi tran_start.
2415 * Translate scsi cmd into sata operation and return status.
2416 * ATAPI CDBs are passed to ATAPI devices - the device determines what commands
2417 * are supported.
2418 * For SATA hard disks, supported scsi commands:
2419 * SCMD_INQUIRY
2420 * SCMD_TEST_UNIT_READY
2421 * SCMD_START_STOP
2422 * SCMD_READ_CAPACITY
2423 * SCMD_SVC_ACTION_IN_G4 (READ CAPACITY (16))
2424 * SCMD_REQUEST_SENSE
2425 * SCMD_LOG_SENSE_G1
2426 * SCMD_LOG_SELECT_G1
2427 * SCMD_MODE_SENSE (specific pages)
2428 * SCMD_MODE_SENSE_G1 (specific pages)
2429 * SCMD_MODE_SELECT (specific pages)
2430 * SCMD_MODE_SELECT_G1 (specific pages)
2431 * SCMD_SYNCHRONIZE_CACHE
2432 * SCMD_SYNCHRONIZE_CACHE_G1
2433 * SCMD_READ
2434 * SCMD_READ_G1
2435 * SCMD_READ_G4
2436 * SCMD_READ_G5
2437 * SCMD_WRITE
2438 * SCMD_WRITE_BUFFER
2439 * SCMD_WRITE_G1
2440 * SCMD_WRITE_G4
2441 * SCMD_WRITE_G5
2442 * SCMD_SEEK (noop)
2443 * SCMD_SDIAG
2444 *
2445 * All other commands are rejected as unsupported.
2446 *
2447 * Returns:
2448 * TRAN_ACCEPT if command was executed successfully or accepted by HBA driver
2449 * for execution. TRAN_ACCEPT may be returned also if device was removed but
2450 * a callback could be scheduled.
2451 * TRAN_BADPKT if cmd was directed to invalid address.
2452 * TRAN_FATAL_ERROR is command was rejected due to hardware error, including
2453 * some unspecified error. TRAN_FATAL_ERROR may be also returned if a device
2454 * was removed and there was no callback specified in scsi pkt.
2455 * TRAN_BUSY if command could not be executed becasue HBA driver or SATA
2456 * framework was busy performing some other operation(s).
2457 *
2458 */
2459 static int
2460 sata_scsi_start(struct scsi_address *ap, struct scsi_pkt *pkt)
2461 {
2462 sata_hba_inst_t *sata_hba_inst =
2463 (sata_hba_inst_t *)(ap->a_hba_tran->tran_hba_private);
2464 sata_pkt_txlate_t *spx = (sata_pkt_txlate_t *)pkt->pkt_ha_private;
2465 sata_device_t *sdevice = &spx->txlt_sata_pkt->satapkt_device;
2466 sata_drive_info_t *sdinfo;
2467 struct buf *bp;
2468 uint8_t cport, pmport;
2469 boolean_t dev_gone = B_FALSE;
2470 int rval;
2471
2472 SATADBG1(SATA_DBG_SCSI_IF, sata_hba_inst,
2473 "sata_scsi_start: cmd 0x%02x\n", pkt->pkt_cdbp[0]);
2474
2475 ASSERT(spx != NULL &&
2476 spx->txlt_scsi_pkt == pkt && spx->txlt_sata_pkt != NULL);
2477
2478 cport = SCSI_TO_SATA_CPORT(ap->a_target);
2479 pmport = SCSI_TO_SATA_PMPORT(ap->a_target);
2480
2481 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, cport)));
2482
2483 if (sdevice->satadev_addr.qual == SATA_ADDR_DCPORT) {
2484 sdinfo = sata_get_device_info(sata_hba_inst, sdevice);
2485 if (sdinfo == NULL ||
2486 SATA_CPORT_INFO(sata_hba_inst, cport)->
2487 cport_tgtnode_clean == B_FALSE ||
2488 (sdinfo->satadrv_state & SATA_DSTATE_FAILED) != 0) {
2489 dev_gone = B_TRUE;
2490 }
2491 } else if (sdevice->satadev_addr.qual == SATA_ADDR_DPMPORT) {
2492 if (SATA_CPORT_DEV_TYPE(sata_hba_inst, cport) !=
2493 SATA_DTYPE_PMULT || SATA_PMULT_INFO(sata_hba_inst,
2494 cport) == NULL) {
2495 dev_gone = B_TRUE;
2496 } else if (SATA_PMPORT_INFO(sata_hba_inst, cport,
2497 pmport) == NULL) {
2498 dev_gone = B_TRUE;
2499 } else {
2500 mutex_enter(&(SATA_PMPORT_MUTEX(sata_hba_inst,
2501 cport, pmport)));
2502 sdinfo = sata_get_device_info(sata_hba_inst, sdevice);
2503 if (sdinfo == NULL ||
2504 SATA_PMPORT_INFO(sata_hba_inst, cport, pmport)->
2505 pmport_tgtnode_clean == B_FALSE ||
2506 (sdinfo->satadrv_state & SATA_DSTATE_FAILED) != 0) {
2507 dev_gone = B_TRUE;
2508 }
2509 mutex_exit(&(SATA_PMPORT_MUTEX(sata_hba_inst,
2510 cport, pmport)));
2511 }
2512 }
2513
2514 if (dev_gone == B_TRUE) {
2515 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, cport)));
2516 pkt->pkt_reason = CMD_DEV_GONE;
2517 /*
2518 * The sd target driver is checking CMD_DEV_GONE pkt_reason
2519 * only in callback function (for normal requests) and
2520 * in the dump code path.
2521 * So, if the callback is available, we need to do
2522 * the callback rather than returning TRAN_FATAL_ERROR here.
2523 */
2524 if (pkt->pkt_comp != NULL) {
2525 /* scsi callback required */
2526 if (servicing_interrupt()) {
2527 if (taskq_dispatch(SATA_TXLT_TASKQ(spx),
2528 (task_func_t *)spx->txlt_scsi_pkt->pkt_comp,
2529 (void *)spx->txlt_scsi_pkt, TQ_NOSLEEP) ==
2530 NULL) {
2531 return (TRAN_BUSY);
2532 }
2533 } else if (taskq_dispatch(SATA_TXLT_TASKQ(spx),
2534 (task_func_t *)spx->txlt_scsi_pkt->pkt_comp,
2535 (void *)spx->txlt_scsi_pkt, TQ_SLEEP) == NULL) {
2536 /* Scheduling the callback failed */
2537 return (TRAN_BUSY);
2538 }
2539 return (TRAN_ACCEPT);
2540 }
2541 /* No callback available */
2542 return (TRAN_FATAL_ERROR);
2543 }
2544
2545 if (sdinfo->satadrv_type & SATA_DTYPE_ATAPI) {
2546 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, cport)));
2547 rval = sata_txlt_atapi(spx);
2548 SATADBG1(SATA_DBG_SCSI_IF, sata_hba_inst,
2549 "sata_scsi_start atapi: rval %d\n", rval);
2550 return (rval);
2551 }
2552 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, cport)));
2553
2554 /*
2555 * Checking for power state, if it was on
2556 * STOPPED state, then the drive is not capable
2557 * of processing media access command. And
2558 * TEST_UNIT_READY, REQUEST_SENSE has special handling
2559 * in the function for different power state.
2560 */
2561 if (((sdinfo->satadrv_power_level == SATA_POWER_STANDBY) ||
2562 (sdinfo->satadrv_power_level == SATA_POWER_STOPPED)) &&
2563 (SATA_IS_MEDIUM_ACCESS_CMD(pkt->pkt_cdbp[0]))) {
2564 return (sata_txlt_check_condition(spx, KEY_NOT_READY,
2565 SD_SCSI_ASC_LU_NOT_READY));
2566 }
2567
2568 /* ATA Disk commands processing starts here */
2569
2570 bp = spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp;
2571
2572 switch (pkt->pkt_cdbp[0]) {
2573
2574 case SCMD_INQUIRY:
2575 /* Mapped to identify device */
2576 if (bp != NULL && (bp->b_flags & (B_PHYS | B_PAGEIO)))
2577 bp_mapin(bp);
2578 rval = sata_txlt_inquiry(spx);
2579 break;
2580
2581 case SCMD_TEST_UNIT_READY:
2582 /*
2583 * SAT "SATA to ATA Translation" doc specifies translation
2584 * to ATA CHECK POWER MODE.
2585 */
2586 rval = sata_txlt_test_unit_ready(spx);
2587 break;
2588
2589 case SCMD_START_STOP:
2590 /* Mapping depends on the command */
2591 rval = sata_txlt_start_stop_unit(spx);
2592 break;
2593
2594 case SCMD_READ_CAPACITY:
2595 if (bp != NULL && (bp->b_flags & (B_PHYS | B_PAGEIO)))
2596 bp_mapin(bp);
2597 rval = sata_txlt_read_capacity(spx);
2598 break;
2599
2600 case SCMD_SVC_ACTION_IN_G4: /* READ CAPACITY (16) */
2601 if (bp != NULL && (bp->b_flags & (B_PHYS | B_PAGEIO)))
2602 bp_mapin(bp);
2603 rval = sata_txlt_read_capacity16(spx);
2604 break;
2605
2606 case SCMD_REQUEST_SENSE:
2607 /*
2608 * Always No Sense, since we force ARQ
2609 */
2610 if (bp != NULL && (bp->b_flags & (B_PHYS | B_PAGEIO)))
2611 bp_mapin(bp);
2612 rval = sata_txlt_request_sense(spx);
2613 break;
2614
2615 case SCMD_LOG_SENSE_G1:
2616 if (bp != NULL && (bp->b_flags & (B_PHYS | B_PAGEIO)))
2617 bp_mapin(bp);
2618 rval = sata_txlt_log_sense(spx);
2619 break;
2620
2621 case SCMD_LOG_SELECT_G1:
2622 if (bp != NULL && (bp->b_flags & (B_PHYS | B_PAGEIO)))
2623 bp_mapin(bp);
2624 rval = sata_txlt_log_select(spx);
2625 break;
2626
2627 case SCMD_MODE_SENSE:
2628 case SCMD_MODE_SENSE_G1:
2629 if (bp != NULL && (bp->b_flags & (B_PHYS | B_PAGEIO)))
2630 bp_mapin(bp);
2631 rval = sata_txlt_mode_sense(spx);
2632 break;
2633
2634
2635 case SCMD_MODE_SELECT:
2636 case SCMD_MODE_SELECT_G1:
2637 if (bp != NULL && (bp->b_flags & (B_PHYS | B_PAGEIO)))
2638 bp_mapin(bp);
2639 rval = sata_txlt_mode_select(spx);
2640 break;
2641
2642 case SCMD_SYNCHRONIZE_CACHE:
2643 case SCMD_SYNCHRONIZE_CACHE_G1:
2644 rval = sata_txlt_synchronize_cache(spx);
2645 break;
2646
2647 case SCMD_READ:
2648 case SCMD_READ_G1:
2649 case SCMD_READ_G4:
2650 case SCMD_READ_G5:
2651 rval = sata_txlt_read(spx);
2652 break;
2653 case SCMD_WRITE_BUFFER:
2654 if (bp != NULL && (bp->b_flags & (B_PHYS | B_PAGEIO)))
2655 bp_mapin(bp);
2656 rval = sata_txlt_write_buffer(spx);
2657 break;
2658
2659 case SCMD_WRITE:
2660 case SCMD_WRITE_G1:
2661 case SCMD_WRITE_G4:
2662 case SCMD_WRITE_G5:
2663 rval = sata_txlt_write(spx);
2664 break;
2665
2666 case SCMD_SEEK:
2667 rval = sata_txlt_nodata_cmd_immediate(spx);
2668 break;
2669
2670 case SPC3_CMD_ATA_COMMAND_PASS_THROUGH12:
2671 case SPC3_CMD_ATA_COMMAND_PASS_THROUGH16:
2672 if (bp != NULL && (bp->b_flags & (B_PHYS | B_PAGEIO)))
2673 bp_mapin(bp);
2674 rval = sata_txlt_ata_pass_thru(spx);
2675 break;
2676
2677 /* Other cases will be filed later */
2678 /* postponed until phase 2 of the development */
2679 case SPC3_CMD_UNMAP:
2680 if (bp != NULL && (bp->b_flags & (B_PHYS | B_PAGEIO)))
2681 bp_mapin(bp);
2682 rval = sata_txlt_unmap(spx);
2683 break;
2684 default:
2685 rval = sata_txlt_invalid_command(spx);
2686 break;
2687 }
2688
2689 SATADBG1(SATA_DBG_SCSI_IF, sata_hba_inst,
2690 "sata_scsi_start: rval %d\n", rval);
2691
2692 return (rval);
2693 }
2694
2695 /*
2696 * Implementation of scsi tran_abort.
2697 * Abort specific pkt or all packets.
2698 *
2699 * Returns 1 if one or more packets were aborted, returns 0 otherwise
2700 *
2701 * May be called from an interrupt level.
2702 */
2703 static int
2704 sata_scsi_abort(struct scsi_address *ap, struct scsi_pkt *scsi_pkt)
2705 {
2706 sata_hba_inst_t *sata_hba_inst =
2707 (sata_hba_inst_t *)(ap->a_hba_tran->tran_hba_private);
2708 sata_device_t sata_device;
2709 sata_pkt_t *sata_pkt;
2710
2711 SATADBG2(SATA_DBG_SCSI_IF, sata_hba_inst,
2712 "sata_scsi_abort: %s at target: 0x%x\n",
2713 scsi_pkt == NULL ? "all packets" : "one pkt", ap->a_target);
2714
2715 /* Validate address */
2716 if (sata_validate_scsi_address(sata_hba_inst, ap, &sata_device) != 0)
2717 /* Invalid address */
2718 return (0);
2719
2720 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst,
2721 sata_device.satadev_addr.cport)));
2722 if (sata_get_device_info(sata_hba_inst, &sata_device) == NULL) {
2723 /* invalid address */
2724 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst,
2725 sata_device.satadev_addr.cport)));
2726 return (0);
2727 }
2728 if (scsi_pkt == NULL) {
2729 /*
2730 * Abort all packets.
2731 * Although we do not have specific packet, we still need
2732 * dummy packet structure to pass device address to HBA.
2733 * Allocate one, without sleeping. Fail if pkt cannot be
2734 * allocated.
2735 */
2736 sata_pkt = kmem_zalloc(sizeof (sata_pkt_t), KM_NOSLEEP);
2737 if (sata_pkt == NULL) {
2738 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst,
2739 sata_device.satadev_addr.cport)));
2740 SATA_LOG_D((sata_hba_inst, CE_WARN, "sata_pkt_abort: "
2741 "could not allocate sata_pkt"));
2742 return (0);
2743 }
2744 sata_pkt->satapkt_rev = SATA_PKT_REV;
2745 sata_pkt->satapkt_device = sata_device;
2746 sata_pkt->satapkt_device.satadev_rev = SATA_DEVICE_REV;
2747 } else {
2748 if (scsi_pkt->pkt_ha_private == NULL) {
2749 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst,
2750 sata_device.satadev_addr.cport)));
2751 return (0); /* Bad scsi pkt */
2752 }
2753 /* extract pointer to sata pkt */
2754 sata_pkt = ((sata_pkt_txlate_t *)scsi_pkt->pkt_ha_private)->
2755 txlt_sata_pkt;
2756 }
2757
2758 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst,
2759 sata_device.satadev_addr.cport)));
2760 /* Send abort request to HBA */
2761 if ((*SATA_ABORT_FUNC(sata_hba_inst))
2762 (SATA_DIP(sata_hba_inst), sata_pkt,
2763 scsi_pkt == NULL ? SATA_ABORT_ALL_PACKETS : SATA_ABORT_PACKET) ==
2764 SATA_SUCCESS) {
2765 if (scsi_pkt == NULL)
2766 kmem_free(sata_pkt, sizeof (sata_pkt_t));
2767 /* Success */
2768 return (1);
2769 }
2770 /* Else, something did not go right */
2771 if (scsi_pkt == NULL)
2772 kmem_free(sata_pkt, sizeof (sata_pkt_t));
2773 /* Failure */
2774 return (0);
2775 }
2776
2777
2778 /*
2779 * Implementation of scsi tran_reset.
2780 * RESET_ALL request is translated into port reset.
2781 * RESET_TARGET requests is translated into a device reset,
2782 * RESET_LUN request is accepted only for LUN 0 and translated into
2783 * device reset.
2784 * The target reset should cause all HBA active and queued packets to
2785 * be terminated and returned with pkt reason SATA_PKT_RESET prior to
2786 * the return. HBA should report reset event for the device.
2787 *
2788 * Returns 1 upon success, 0 upon failure.
2789 */
2790 static int
2791 sata_scsi_reset(struct scsi_address *ap, int level)
2792 {
2793 sata_hba_inst_t *sata_hba_inst =
2794 (sata_hba_inst_t *)(ap->a_hba_tran->tran_hba_private);
2795 sata_device_t sata_device;
2796 int val;
2797
2798 SATADBG2(SATA_DBG_SCSI_IF, sata_hba_inst,
2799 "sata_scsi_reset: level %d target: 0x%x\n",
2800 level, ap->a_target);
2801
2802 /* Validate address */
2803 val = sata_validate_scsi_address(sata_hba_inst, ap, &sata_device);
2804 if (val == -1)
2805 /* Invalid address */
2806 return (0);
2807
2808 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst,
2809 sata_device.satadev_addr.cport)));
2810 if (sata_get_device_info(sata_hba_inst, &sata_device) == NULL) {
2811 /* invalid address */
2812 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst,
2813 sata_device.satadev_addr.cport)));
2814 return (0);
2815 }
2816 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst,
2817 sata_device.satadev_addr.cport)));
2818 if (level == RESET_ALL) {
2819 /* port reset */
2820 if (sata_device.satadev_addr.qual == SATA_ADDR_DCPORT)
2821 sata_device.satadev_addr.qual = SATA_ADDR_CPORT;
2822 else
2823 sata_device.satadev_addr.qual = SATA_ADDR_PMPORT;
2824
2825 if ((*SATA_RESET_DPORT_FUNC(sata_hba_inst))
2826 (SATA_DIP(sata_hba_inst), &sata_device) == SATA_SUCCESS)
2827 return (1);
2828 else
2829 return (0);
2830
2831 } else if (val == 0 &&
2832 (level == RESET_TARGET || level == RESET_LUN)) {
2833 /* reset device (device attached) */
2834 if ((*SATA_RESET_DPORT_FUNC(sata_hba_inst))
2835 (SATA_DIP(sata_hba_inst), &sata_device) == SATA_SUCCESS)
2836 return (1);
2837 else
2838 return (0);
2839 }
2840 return (0);
2841 }
2842
2843
2844 /*
2845 * Implementation of scsi tran_getcap (get transport/device capabilities).
2846 * Supported capabilities for SATA hard disks:
2847 * auto-rqsense (always supported)
2848 * tagged-qing (supported if HBA supports it)
2849 * untagged-qing (could be supported if disk supports it, but because
2850 * caching behavior allowing untagged queuing actually
2851 * results in reduced performance. sd tries to throttle
2852 * back to only 3 outstanding commands, which may
2853 * work for real SCSI disks, but with read ahead
2854 * caching, having more than 1 outstanding command
2855 * results in cache thrashing.)
2856 * sector_size
2857 * dma_max
2858 * interconnect-type (INTERCONNECT_SATA)
2859 *
2860 * Supported capabilities for ATAPI CD/DVD devices:
2861 * auto-rqsense (always supported)
2862 * sector_size
2863 * dma_max
2864 * max-cdb-length
2865 * interconnect-type (INTERCONNECT_SATA)
2866 *
2867 * Supported capabilities for ATAPI TAPE devices:
2868 * auto-rqsense (always supported)
2869 * dma_max
2870 * max-cdb-length
2871 *
2872 * Supported capabilities for SATA ATAPI hard disks:
2873 * auto-rqsense (always supported)
2874 * interconnect-type (INTERCONNECT_SATA)
2875 * max-cdb-length
2876 *
2877 * Request for other capabilities is rejected as unsupported.
2878 *
2879 * Returns supported capability value, or -1 if capability is unsuppported or
2880 * the address is invalid - no device.
2881 */
2882
2883 static int
2884 sata_scsi_getcap(struct scsi_address *ap, char *cap, int whom)
2885 {
2886
2887 sata_hba_inst_t *sata_hba_inst =
2888 (sata_hba_inst_t *)(ap->a_hba_tran->tran_hba_private);
2889 sata_device_t sata_device;
2890 sata_drive_info_t *sdinfo;
2891 ddi_dma_attr_t adj_dma_attr;
2892 int rval;
2893
2894 SATADBG2(SATA_DBG_SCSI_IF, sata_hba_inst,
2895 "sata_scsi_getcap: target: 0x%x, cap: %s\n",
2896 ap->a_target, cap);
2897
2898 /*
2899 * We want to process the capabilities on per port granularity.
2900 * So, we are specifically restricting ourselves to whom != 0
2901 * to exclude the controller wide handling.
2902 */
2903 if (cap == NULL || whom == 0)
2904 return (-1);
2905
2906 if (sata_validate_scsi_address(sata_hba_inst, ap, &sata_device) != 0) {
2907 /* Invalid address */
2908 return (-1);
2909 }
2910 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst,
2911 sata_device.satadev_addr.cport)));
2912 if ((sdinfo = sata_get_device_info(sata_hba_inst, &sata_device)) ==
2913 NULL) {
2914 /* invalid address */
2915 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst,
2916 sata_device.satadev_addr.cport)));
2917 return (-1);
2918 }
2919
2920 switch (scsi_hba_lookup_capstr(cap)) {
2921 case SCSI_CAP_ARQ:
2922 rval = 1; /* ARQ supported, turned on */
2923 break;
2924
2925 case SCSI_CAP_SECTOR_SIZE:
2926 if (sdinfo->satadrv_type == SATA_DTYPE_ATADISK)
2927 rval = SATA_DISK_SECTOR_SIZE; /* fixed size */
2928 else if (sdinfo->satadrv_type == SATA_DTYPE_ATAPICD)
2929 rval = SATA_ATAPI_SECTOR_SIZE;
2930 else rval = -1;
2931 break;
2932
2933 /*
2934 * untagged queuing cause a performance inversion because of
2935 * the way sd operates. Because of this reason we do not
2936 * use it when available.
2937 */
2938 case SCSI_CAP_UNTAGGED_QING:
2939 if (sdinfo->satadrv_features_enabled &
2940 SATA_DEV_F_E_UNTAGGED_QING)
2941 rval = 1; /* Untagged queuing available */
2942 else
2943 rval = -1; /* Untagged queuing not available */
2944 break;
2945
2946 case SCSI_CAP_TAGGED_QING:
2947 if ((sdinfo->satadrv_features_enabled &
2948 SATA_DEV_F_E_TAGGED_QING) &&
2949 (sdinfo->satadrv_max_queue_depth > 1))
2950 rval = 1; /* Tagged queuing available */
2951 else
2952 rval = -1; /* Tagged queuing not available */
2953 break;
2954
2955 case SCSI_CAP_DMA_MAX:
2956 sata_adjust_dma_attr(sdinfo, SATA_DMA_ATTR(sata_hba_inst),
2957 &adj_dma_attr);
2958 rval = (int)adj_dma_attr.dma_attr_maxxfer;
2959 /* We rely on the fact that dma_attr_maxxfer < 0x80000000 */
2960 break;
2961
2962 case SCSI_CAP_INTERCONNECT_TYPE:
2963 rval = INTERCONNECT_SATA; /* SATA interconnect type */
2964 break;
2965
2966 case SCSI_CAP_CDB_LEN:
2967 if (sdinfo->satadrv_type & SATA_DTYPE_ATAPI)
2968 rval = sdinfo->satadrv_atapi_cdb_len;
2969 else
2970 rval = -1;
2971 break;
2972
2973 default:
2974 rval = -1;
2975 break;
2976 }
2977 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst,
2978 sata_device.satadev_addr.cport)));
2979 return (rval);
2980 }
2981
2982 /*
2983 * Implementation of scsi tran_setcap
2984 *
2985 * Only SCSI_CAP_UNTAGGED_QING and SCSI_CAP_TAGGED_QING are changeable.
2986 *
2987 */
2988 static int
2989 sata_scsi_setcap(struct scsi_address *ap, char *cap, int value, int whom)
2990 {
2991 sata_hba_inst_t *sata_hba_inst =
2992 (sata_hba_inst_t *)(ap->a_hba_tran->tran_hba_private);
2993 sata_device_t sata_device;
2994 sata_drive_info_t *sdinfo;
2995 int rval;
2996
2997 SATADBG2(SATA_DBG_SCSI_IF, sata_hba_inst,
2998 "sata_scsi_setcap: target: 0x%x, cap: %s\n", ap->a_target, cap);
2999
3000 /*
3001 * We want to process the capabilities on per port granularity.
3002 * So, we are specifically restricting ourselves to whom != 0
3003 * to exclude the controller wide handling.
3004 */
3005 if (cap == NULL || whom == 0) {
3006 return (-1);
3007 }
3008
3009 if (sata_validate_scsi_address(sata_hba_inst, ap, &sata_device) != 0) {
3010 /* Invalid address */
3011 return (-1);
3012 }
3013 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst,
3014 sata_device.satadev_addr.cport)));
3015 if ((sdinfo = sata_get_device_info(sata_hba_inst,
3016 &sata_device)) == NULL) {
3017 /* invalid address */
3018 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst,
3019 sata_device.satadev_addr.cport)));
3020 return (-1);
3021 }
3022 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst,
3023 sata_device.satadev_addr.cport)));
3024
3025 switch (scsi_hba_lookup_capstr(cap)) {
3026 case SCSI_CAP_ARQ:
3027 case SCSI_CAP_SECTOR_SIZE:
3028 case SCSI_CAP_DMA_MAX:
3029 case SCSI_CAP_INTERCONNECT_TYPE:
3030 rval = 0;
3031 break;
3032 case SCSI_CAP_UNTAGGED_QING:
3033 if (SATA_QDEPTH(sata_hba_inst) > 1) {
3034 rval = 1;
3035 if (value == 1) {
3036 sdinfo->satadrv_features_enabled |=
3037 SATA_DEV_F_E_UNTAGGED_QING;
3038 } else if (value == 0) {
3039 sdinfo->satadrv_features_enabled &=
3040 ~SATA_DEV_F_E_UNTAGGED_QING;
3041 } else {
3042 rval = -1;
3043 }
3044 } else {
3045 rval = 0;
3046 }
3047 break;
3048 case SCSI_CAP_TAGGED_QING:
3049 /* This can TCQ or NCQ */
3050 if (sata_func_enable & SATA_ENABLE_QUEUING &&
3051 ((sdinfo->satadrv_features_support & SATA_DEV_F_TCQ &&
3052 SATA_FEATURES(sata_hba_inst) & SATA_CTLF_QCMD) ||
3053 (sata_func_enable & SATA_ENABLE_NCQ &&
3054 sdinfo->satadrv_features_support & SATA_DEV_F_NCQ &&
3055 SATA_FEATURES(sata_hba_inst) & SATA_CTLF_NCQ)) &&
3056 (sdinfo->satadrv_max_queue_depth > 1)) {
3057 rval = 1;
3058 if (value == 1) {
3059 sdinfo->satadrv_features_enabled |=
3060 SATA_DEV_F_E_TAGGED_QING;
3061 } else if (value == 0) {
3062 sdinfo->satadrv_features_enabled &=
3063 ~SATA_DEV_F_E_TAGGED_QING;
3064 } else {
3065 rval = -1;
3066 }
3067 } else {
3068 rval = 0;
3069 }
3070 break;
3071 default:
3072 rval = -1;
3073 break;
3074 }
3075 return (rval);
3076 }
3077
3078 /*
3079 * Implementations of scsi tran_destroy_pkt.
3080 * Free resources allocated by sata_scsi_init_pkt()
3081 */
3082 static void
3083 sata_scsi_destroy_pkt(struct scsi_address *ap, struct scsi_pkt *pkt)
3084 {
3085 sata_pkt_txlate_t *spx;
3086
3087 spx = (sata_pkt_txlate_t *)pkt->pkt_ha_private;
3088
3089 sata_common_free_dma_rsrcs(spx);
3090
3091 spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp = NULL;
3092 sata_pkt_free(spx);
3093
3094 scsi_hba_pkt_free(ap, pkt);
3095 }
3096
3097 /*
3098 * Implementation of scsi tran_dmafree.
3099 * Free DMA resources allocated by sata_scsi_init_pkt()
3100 */
3101
3102 static void
3103 sata_scsi_dmafree(struct scsi_address *ap, struct scsi_pkt *pkt)
3104 {
3105 #ifndef __lock_lint
3106 _NOTE(ARGUNUSED(ap))
3107 #endif
3108 sata_pkt_txlate_t *spx;
3109
3110 ASSERT(pkt != NULL);
3111 spx = (sata_pkt_txlate_t *)pkt->pkt_ha_private;
3112
3113 sata_common_free_dma_rsrcs(spx);
3114 }
3115
3116 /*
3117 * Implementation of scsi tran_sync_pkt.
3118 *
3119 * The assumption below is that pkt is unique - there is no need to check ap
3120 *
3121 * Synchronize DMA buffer and, if the intermediate buffer is used, copy data
3122 * into/from the real buffer.
3123 */
3124 static void
3125 sata_scsi_sync_pkt(struct scsi_address *ap, struct scsi_pkt *pkt)
3126 {
3127 #ifndef __lock_lint
3128 _NOTE(ARGUNUSED(ap))
3129 #endif
3130 int rval;
3131 sata_pkt_txlate_t *spx = (sata_pkt_txlate_t *)pkt->pkt_ha_private;
3132 struct buf *bp;
3133 int direction;
3134
3135 ASSERT(spx != NULL);
3136 if (spx->txlt_buf_dma_handle != NULL) {
3137 direction = spx->txlt_sata_pkt->
3138 satapkt_cmd.satacmd_flags.sata_data_direction;
3139 if (spx->txlt_sata_pkt != NULL &&
3140 direction != SATA_DIR_NODATA_XFER) {
3141 if (spx->txlt_tmp_buf != NULL) {
3142 /* Intermediate DMA buffer used */
3143 bp = spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp;
3144
3145 if (direction & SATA_DIR_WRITE) {
3146 bcopy(bp->b_un.b_addr,
3147 spx->txlt_tmp_buf, bp->b_bcount);
3148 }
3149 }
3150 /* Sync the buffer for device or for CPU */
3151 rval = ddi_dma_sync(spx->txlt_buf_dma_handle, 0, 0,
3152 (direction & SATA_DIR_WRITE) ?
3153 DDI_DMA_SYNC_FORDEV : DDI_DMA_SYNC_FORCPU);
3154 ASSERT(rval == DDI_SUCCESS);
3155 if (spx->txlt_tmp_buf != NULL &&
3156 !(direction & SATA_DIR_WRITE)) {
3157 /* Intermediate DMA buffer used for read */
3158 bcopy(spx->txlt_tmp_buf,
3159 bp->b_un.b_addr, bp->b_bcount);
3160 }
3161
3162 }
3163 }
3164 }
3165
3166
3167
3168 /* ******************* SATA - SCSI Translation functions **************** */
3169 /*
3170 * SCSI to SATA pkt and command translation and SATA to SCSI status/error
3171 * translation.
3172 */
3173
3174 /*
3175 * Checks if a device exists and can be access and translates common
3176 * scsi_pkt data to sata_pkt data.
3177 *
3178 * Flag argument indicates that a non-read/write ATA command may be sent
3179 * to HBA in arbitrary SYNC mode to execute this packet.
3180 *
3181 * Returns TRAN_ACCEPT and scsi pkt_reason CMD_CMPLT if device exists and
3182 * sata_pkt was set-up.
3183 * Returns TRAN_ACCEPT and scsi pkt_reason CMD_DEV_GONE if device does not
3184 * exist and pkt_comp callback was scheduled.
3185 * Returns other TRAN_XXXXX values when error occured and command should be
3186 * rejected with the returned TRAN_XXXXX value.
3187 *
3188 * This function should be called with port mutex held.
3189 */
3190 static int
3191 sata_txlt_generic_pkt_info(sata_pkt_txlate_t *spx, int *reason, int flag)
3192 {
3193 sata_drive_info_t *sdinfo;
3194 sata_device_t sata_device;
3195 const struct sata_cmd_flags sata_initial_cmd_flags = {
3196 SATA_DIR_NODATA_XFER,
3197 /* all other values to 0/FALSE */
3198 };
3199 /*
3200 * Pkt_reason has to be set if the pkt_comp callback is invoked,
3201 * and that implies TRAN_ACCEPT return value. Any other returned value
3202 * indicates that the scsi packet was not accepted (the reason will not
3203 * be checked by the scsi target driver).
3204 * To make debugging easier, we set pkt_reason to know value here.
3205 * It may be changed later when different completion reason is
3206 * determined.
3207 */
3208 spx->txlt_scsi_pkt->pkt_reason = CMD_TRAN_ERR;
3209 *reason = CMD_TRAN_ERR;
3210
3211 /* Validate address */
3212 switch (sata_validate_scsi_address(spx->txlt_sata_hba_inst,
3213 &spx->txlt_scsi_pkt->pkt_address, &sata_device)) {
3214
3215 case -1:
3216 /* Invalid address or invalid device type */
3217 return (TRAN_BADPKT);
3218 case 2:
3219 /*
3220 * Valid address but device type is unknown - Chack if it is
3221 * in the reset state and therefore in an indeterminate state.
3222 */
3223 sdinfo = sata_get_device_info(spx->txlt_sata_hba_inst,
3224 &spx->txlt_sata_pkt->satapkt_device);
3225 if (sdinfo != NULL && (sdinfo->satadrv_event_flags &
3226 (SATA_EVNT_DEVICE_RESET |
3227 SATA_EVNT_INPROC_DEVICE_RESET)) != 0) {
3228 if (!ddi_in_panic()) {
3229 spx->txlt_scsi_pkt->pkt_reason = CMD_INCOMPLETE;
3230 *reason = CMD_INCOMPLETE;
3231 SATADBG1(SATA_DBG_SCSI_IF,
3232 spx->txlt_sata_hba_inst,
3233 "sata_scsi_start: rejecting command "
3234 "because of device reset state\n", NULL);
3235 return (TRAN_BUSY);
3236 }
3237 }
3238 /* FALLTHROUGH */
3239 case 1:
3240 /* valid address but no valid device - it has disappeared */
3241 spx->txlt_scsi_pkt->pkt_reason = CMD_DEV_GONE;
3242 *reason = CMD_DEV_GONE;
3243 /*
3244 * The sd target driver is checking CMD_DEV_GONE pkt_reason
3245 * only in callback function (for normal requests) and
3246 * in the dump code path.
3247 * So, if the callback is available, we need to do
3248 * the callback rather than returning TRAN_FATAL_ERROR here.
3249 */
3250 if (spx->txlt_scsi_pkt->pkt_comp != NULL) {
3251 /* scsi callback required */
3252 if (servicing_interrupt()) {
3253 if (taskq_dispatch(SATA_TXLT_TASKQ(spx),
3254 (task_func_t *)spx->txlt_scsi_pkt->pkt_comp,
3255 (void *)spx->txlt_scsi_pkt, TQ_NOSLEEP) ==
3256 NULL) {
3257 return (TRAN_BUSY);
3258 }
3259 } else if (taskq_dispatch(SATA_TXLT_TASKQ(spx),
3260 (task_func_t *)spx->txlt_scsi_pkt->pkt_comp,
3261 (void *)spx->txlt_scsi_pkt, TQ_SLEEP) == NULL) {
3262 /* Scheduling the callback failed */
3263 return (TRAN_BUSY);
3264 }
3265
3266 return (TRAN_ACCEPT);
3267 }
3268 return (TRAN_FATAL_ERROR);
3269 default:
3270 /* all OK; pkt reason will be overwritten later */
3271 break;
3272 }
3273 /*
3274 * If pkt is to be executed in polling mode and a command will not be
3275 * emulated in SATA module (requires sending a non-read/write ATA
3276 * command to HBA driver in arbitrary SYNC mode) and we are in the
3277 * interrupt context and not in the panic dump, then reject the packet
3278 * to avoid a possible interrupt stack overrun or hang caused by
3279 * a potentially blocked interrupt.
3280 */
3281 if (((spx->txlt_scsi_pkt->pkt_flags & FLAG_NOINTR) != 0 || flag != 0) &&
3282 servicing_interrupt() && !ddi_in_panic()) {
3283 SATADBG1(SATA_DBG_INTR_CTX, spx->txlt_sata_hba_inst,
3284 "sata_scsi_start: rejecting synchronous command because "
3285 "of interrupt context\n", NULL);
3286 return (TRAN_BUSY);
3287 }
3288
3289 sdinfo = sata_get_device_info(spx->txlt_sata_hba_inst,
3290 &spx->txlt_sata_pkt->satapkt_device);
3291
3292 /*
3293 * If device is in reset condition, reject the packet with
3294 * TRAN_BUSY, unless:
3295 * 1. system is panicking (dumping)
3296 * In such case only one thread is running and there is no way to
3297 * process reset.
3298 * 2. cfgadm operation is is progress (internal APCTL lock is set)
3299 * Some cfgadm operations involve drive commands, so reset condition
3300 * needs to be ignored for IOCTL operations.
3301 */
3302 if ((sdinfo->satadrv_event_flags &
3303 (SATA_EVNT_DEVICE_RESET | SATA_EVNT_INPROC_DEVICE_RESET)) != 0) {
3304
3305 if (!ddi_in_panic() &&
3306 ((SATA_CPORT_EVENT_FLAGS(spx->txlt_sata_hba_inst,
3307 sata_device.satadev_addr.cport) &
3308 SATA_APCTL_LOCK_PORT_BUSY) == 0)) {
3309 spx->txlt_scsi_pkt->pkt_reason = CMD_INCOMPLETE;
3310 *reason = CMD_INCOMPLETE;
3311 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst,
3312 "sata_scsi_start: rejecting command because "
3313 "of device reset state\n", NULL);
3314 return (TRAN_BUSY);
3315 }
3316 }
3317
3318 /*
3319 * Fix the dev_type in the sata_pkt->satapkt_device. It was not set by
3320 * sata_scsi_pkt_init() because pkt init had to work also with
3321 * non-existing devices.
3322 * Now we know that the packet was set-up for a real device, so its
3323 * type is known.
3324 */
3325 spx->txlt_sata_pkt->satapkt_device.satadev_type = sdinfo->satadrv_type;
3326
3327 spx->txlt_sata_pkt->satapkt_cmd.satacmd_flags = sata_initial_cmd_flags;
3328 if ((SATA_CPORT_INFO(spx->txlt_sata_hba_inst,
3329 sata_device.satadev_addr.cport)->cport_event_flags &
3330 SATA_APCTL_LOCK_PORT_BUSY) != 0) {
3331 spx->txlt_sata_pkt->satapkt_cmd.satacmd_flags.
3332 sata_ignore_dev_reset = B_TRUE;
3333 }
3334 /*
3335 * At this point the generic translation routine determined that the
3336 * scsi packet should be accepted. Packet completion reason may be
3337 * changed later when a different completion reason is determined.
3338 */
3339 spx->txlt_scsi_pkt->pkt_reason = CMD_CMPLT;
3340 *reason = CMD_CMPLT;
3341
3342 if ((spx->txlt_scsi_pkt->pkt_flags & FLAG_NOINTR) != 0) {
3343 /* Synchronous execution */
3344 spx->txlt_sata_pkt->satapkt_op_mode = SATA_OPMODE_SYNCH |
3345 SATA_OPMODE_POLLING;
3346 spx->txlt_sata_pkt->satapkt_cmd.satacmd_flags.
3347 sata_ignore_dev_reset = ddi_in_panic();
3348 } else {
3349 /* Asynchronous execution */
3350 spx->txlt_sata_pkt->satapkt_op_mode = SATA_OPMODE_ASYNCH |
3351 SATA_OPMODE_INTERRUPTS;
3352 }
3353 /* Convert queuing information */
3354 if (spx->txlt_scsi_pkt->pkt_flags & FLAG_STAG)
3355 spx->txlt_sata_pkt->satapkt_cmd.satacmd_flags.sata_queue_stag =
3356 B_TRUE;
3357 else if (spx->txlt_scsi_pkt->pkt_flags &
3358 (FLAG_OTAG | FLAG_HTAG | FLAG_HEAD))
3359 spx->txlt_sata_pkt->satapkt_cmd.satacmd_flags.sata_queue_otag =
3360 B_TRUE;
3361
3362 /* Always limit pkt time */
3363 if (spx->txlt_scsi_pkt->pkt_time == 0)
3364 spx->txlt_sata_pkt->satapkt_time = sata_default_pkt_time;
3365 else
3366 /* Pass on scsi_pkt time */
3367 spx->txlt_sata_pkt->satapkt_time =
3368 spx->txlt_scsi_pkt->pkt_time;
3369
3370 return (TRAN_ACCEPT);
3371 }
3372
3373
3374 /*
3375 * Translate ATA Identify Device data to SCSI Inquiry data.
3376 * This function may be called only for ATA devices.
3377 * This function should not be called for ATAPI devices - they
3378 * respond directly to SCSI Inquiry command.
3379 *
3380 * SATA Identify Device data has to be valid in sata_drive_info.
3381 * Buffer has to accomodate the inquiry length (36 bytes).
3382 *
3383 * This function should be called with a port mutex held.
3384 */
3385 static void
3386 sata_identdev_to_inquiry(sata_hba_inst_t *sata_hba_inst,
3387 sata_drive_info_t *sdinfo, uint8_t *buf)
3388 {
3389
3390 struct scsi_inquiry *inq = (struct scsi_inquiry *)buf;
3391 struct sata_id *sid = &sdinfo->satadrv_id;
3392
3393 /* Start with a nice clean slate */
3394 bzero((void *)inq, sizeof (struct scsi_inquiry));
3395
3396 /*
3397 * Rely on the dev_type for setting paripheral qualifier.
3398 * Assume that DTYPE_RODIRECT applies to CD/DVD R/W devices.
3399 * It could be that DTYPE_OPTICAL could also qualify in the future.
3400 * ATAPI Inquiry may provide more data to the target driver.
3401 */
3402 inq->inq_dtype = sdinfo->satadrv_type == SATA_DTYPE_ATADISK ?
3403 DTYPE_DIRECT : DTYPE_RODIRECT; /* DTYPE_UNKNOWN; */
3404
3405 /* CFA type device is not a removable media device */
3406 inq->inq_rmb = ((sid->ai_config != SATA_CFA_TYPE) &&
3407 (sid->ai_config & SATA_REM_MEDIA)) ? 1 : 0;
3408 inq->inq_qual = 0; /* Device type qualifier (obsolete in SCSI3? */
3409 inq->inq_iso = 0; /* ISO version */
3410 inq->inq_ecma = 0; /* ECMA version */
3411 inq->inq_ansi = 3; /* ANSI version - SCSI 3 */
3412 inq->inq_aenc = 0; /* Async event notification cap. */
3413 inq->inq_trmiop = 0; /* Supports TERMINATE I/O PROC msg - NO */
3414 inq->inq_normaca = 0; /* setting NACA bit supported - NO */
3415 inq->inq_rdf = RDF_SCSI2; /* Response data format- SPC-3 */
3416 inq->inq_len = 31; /* Additional length */
3417 inq->inq_dualp = 0; /* dual port device - NO */
3418 inq->inq_reladdr = 0; /* Supports relative addressing - NO */
3419 inq->inq_sync = 0; /* Supports synchronous data xfers - NO */
3420 inq->inq_linked = 0; /* Supports linked commands - NO */
3421 /*
3422 * Queuing support - controller has to
3423 * support some sort of command queuing.
3424 */
3425 if (SATA_QDEPTH(sata_hba_inst) > 1)
3426 inq->inq_cmdque = 1; /* Supports command queueing - YES */
3427 else
3428 inq->inq_cmdque = 0; /* Supports command queueing - NO */
3429 inq->inq_sftre = 0; /* Supports Soft Reset option - NO ??? */
3430 inq->inq_wbus32 = 0; /* Supports 32 bit wide data xfers - NO */
3431 inq->inq_wbus16 = 0; /* Supports 16 bit wide data xfers - NO */
3432
3433 #ifdef _LITTLE_ENDIAN
3434 /* Swap text fields to match SCSI format */
3435 bcopy("ATA ", inq->inq_vid, 8); /* Vendor ID */
3436 swab(sid->ai_model, inq->inq_pid, 16); /* Product ID */
3437 if (strncmp(&sid->ai_fw[4], " ", 4) == 0)
3438 swab(sid->ai_fw, inq->inq_revision, 4); /* Revision level */
3439 else
3440 swab(&sid->ai_fw[4], inq->inq_revision, 4); /* Rev. level */
3441 #else /* _LITTLE_ENDIAN */
3442 bcopy("ATA ", inq->inq_vid, 8); /* Vendor ID */
3443 bcopy(sid->ai_model, inq->inq_pid, 16); /* Product ID */
3444 if (strncmp(&sid->ai_fw[4], " ", 4) == 0)
3445 bcopy(sid->ai_fw, inq->inq_revision, 4); /* Revision level */
3446 else
3447 bcopy(&sid->ai_fw[4], inq->inq_revision, 4); /* Rev. level */
3448 #endif /* _LITTLE_ENDIAN */
3449 }
3450
3451
3452 /*
3453 * Scsi response set up for invalid command (command not supported)
3454 *
3455 * Returns TRAN_ACCEPT and appropriate values in scsi_pkt fields.
3456 */
3457 static int
3458 sata_txlt_invalid_command(sata_pkt_txlate_t *spx)
3459 {
3460 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt;
3461 struct scsi_extended_sense *sense;
3462
3463 scsipkt->pkt_reason = CMD_CMPLT;
3464 scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET |
3465 STATE_SENT_CMD | STATE_GOT_STATUS;
3466
3467 *scsipkt->pkt_scbp = STATUS_CHECK;
3468
3469 sense = sata_arq_sense(spx);
3470 sense->es_key = KEY_ILLEGAL_REQUEST;
3471 sense->es_add_code = SD_SCSI_ASC_INVALID_COMMAND_CODE;
3472
3473 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst,
3474 "Scsi_pkt completion reason %x\n", scsipkt->pkt_reason);
3475
3476 if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0 &&
3477 scsipkt->pkt_comp != NULL) {
3478 /* scsi callback required */
3479 if (servicing_interrupt()) {
3480 if (taskq_dispatch(SATA_TXLT_TASKQ(spx),
3481 (task_func_t *)spx->txlt_scsi_pkt->pkt_comp,
3482 (void *)spx->txlt_scsi_pkt, TQ_NOSLEEP) == NULL) {
3483 return (TRAN_BUSY);
3484 }
3485 } else if (taskq_dispatch(SATA_TXLT_TASKQ(spx),
3486 (task_func_t *)spx->txlt_scsi_pkt->pkt_comp,
3487 (void *)spx->txlt_scsi_pkt, TQ_SLEEP) == NULL) {
3488 /* Scheduling the callback failed */
3489 return (TRAN_BUSY);
3490 }
3491 }
3492 return (TRAN_ACCEPT);
3493 }
3494
3495 /*
3496 * Scsi response set up for check condition with special sense key
3497 * and additional sense code.
3498 *
3499 * Returns TRAN_ACCEPT and appropriate values in scsi_pkt fields.
3500 */
3501 static int
3502 sata_txlt_check_condition(sata_pkt_txlate_t *spx, uchar_t key, uchar_t code)
3503 {
3504 sata_hba_inst_t *shi = SATA_TXLT_HBA_INST(spx);
3505 int cport = SATA_TXLT_CPORT(spx);
3506 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt;
3507 struct scsi_extended_sense *sense;
3508
3509 mutex_enter(&SATA_CPORT_MUTEX(shi, cport));
3510 scsipkt->pkt_reason = CMD_CMPLT;
3511 scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET |
3512 STATE_SENT_CMD | STATE_GOT_STATUS;
3513
3514 *scsipkt->pkt_scbp = STATUS_CHECK;
3515
3516 sense = sata_arq_sense(spx);
3517 sense->es_key = key;
3518 sense->es_add_code = code;
3519
3520 mutex_exit(&SATA_CPORT_MUTEX(shi, cport));
3521
3522 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst,
3523 "Scsi_pkt completion reason %x\n", scsipkt->pkt_reason);
3524
3525 if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0 &&
3526 scsipkt->pkt_comp != NULL) {
3527 /* scsi callback required */
3528 if (servicing_interrupt()) {
3529 if (taskq_dispatch(SATA_TXLT_TASKQ(spx),
3530 (task_func_t *)spx->txlt_scsi_pkt->pkt_comp,
3531 (void *)spx->txlt_scsi_pkt, TQ_NOSLEEP) == NULL) {
3532 return (TRAN_BUSY);
3533 }
3534 } else if (taskq_dispatch(SATA_TXLT_TASKQ(spx),
3535 (task_func_t *)spx->txlt_scsi_pkt->pkt_comp,
3536 (void *)spx->txlt_scsi_pkt, TQ_SLEEP) == NULL) {
3537 /* Scheduling the callback failed */
3538 return (TRAN_BUSY);
3539 }
3540 }
3541 return (TRAN_ACCEPT);
3542 }
3543
3544 /*
3545 * Scsi response setup for
3546 * emulated non-data command that requires no action/return data
3547 *
3548 * Returns TRAN_ACCEPT and appropriate values in scsi_pkt fields.
3549 */
3550 static int
3551 sata_txlt_nodata_cmd_immediate(sata_pkt_txlate_t *spx)
3552 {
3553 int rval;
3554 int reason;
3555 kmutex_t *cport_mutex = &(SATA_TXLT_CPORT_MUTEX(spx));
3556
3557 mutex_enter(cport_mutex);
3558
3559 if (((rval = sata_txlt_generic_pkt_info(spx, &reason, 0)) !=
3560 TRAN_ACCEPT) || (reason == CMD_DEV_GONE)) {
3561 mutex_exit(cport_mutex);
3562 return (rval);
3563 }
3564 mutex_exit(cport_mutex);
3565
3566 spx->txlt_scsi_pkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET |
3567 STATE_SENT_CMD | STATE_GOT_STATUS;
3568 spx->txlt_scsi_pkt->pkt_reason = CMD_CMPLT;
3569 *(spx->txlt_scsi_pkt->pkt_scbp) = STATUS_GOOD;
3570
3571 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst,
3572 "Scsi_pkt completion reason %x\n",
3573 spx->txlt_scsi_pkt->pkt_reason);
3574
3575 if ((spx->txlt_scsi_pkt->pkt_flags & FLAG_NOINTR) == 0 &&
3576 spx->txlt_scsi_pkt->pkt_comp != NULL) {
3577 /* scsi callback required */
3578 if (servicing_interrupt()) {
3579 if (taskq_dispatch(SATA_TXLT_TASKQ(spx),
3580 (task_func_t *)spx->txlt_scsi_pkt->pkt_comp,
3581 (void *)spx->txlt_scsi_pkt, TQ_NOSLEEP) == NULL) {
3582 return (TRAN_BUSY);
3583 }
3584 } else if (taskq_dispatch(SATA_TXLT_TASKQ(spx),
3585 (task_func_t *)spx->txlt_scsi_pkt->pkt_comp,
3586 (void *)spx->txlt_scsi_pkt, TQ_SLEEP) == NULL) {
3587 /* Scheduling the callback failed */
3588 return (TRAN_BUSY);
3589 }
3590 }
3591 return (TRAN_ACCEPT);
3592 }
3593
3594
3595 /*
3596 * SATA translate command: Inquiry / Identify Device
3597 * Use cached Identify Device data for now, rather than issuing actual
3598 * Device Identify cmd request. If device is detached and re-attached,
3599 * asynchronous event processing should fetch and refresh Identify Device
3600 * data.
3601 * VPD pages supported now:
3602 * Vital Product Data page
3603 * Unit Serial Number page
3604 * Block Device Characteristics Page
3605 * ATA Information Page
3606 *
3607 * Returns TRAN_ACCEPT and appropriate values in scsi_pkt fields.
3608 */
3609
3610 #define EVPD 1 /* Extended Vital Product Data flag */
3611 #define CMDDT 2 /* Command Support Data - Obsolete */
3612 #define INQUIRY_SUP_VPD_PAGE 0 /* Supported VPD Pages Page Code */
3613 #define INQUIRY_USN_PAGE 0x80 /* Unit Serial Number Page Code */
3614 #define INQUIRY_BDC_PAGE 0xB1 /* Block Device Characteristics Page */
3615 /* Code */
3616 #define INQUIRY_ATA_INFO_PAGE 0x89 /* ATA Information Page Code */
3617 #define INQUIRY_DEV_IDENTIFICATION_PAGE 0x83 /* Not needed yet */
3618
3619 static int
3620 sata_txlt_inquiry(sata_pkt_txlate_t *spx)
3621 {
3622 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt;
3623 struct buf *bp = spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp;
3624 sata_drive_info_t *sdinfo;
3625 struct scsi_extended_sense *sense;
3626 int count;
3627 uint8_t *p;
3628 int i, j;
3629 uint8_t page_buf[1024]; /* Max length */
3630 int rval, reason;
3631 ushort_t rate;
3632 kmutex_t *cport_mutex = &(SATA_TXLT_CPORT_MUTEX(spx));
3633
3634 mutex_enter(cport_mutex);
3635
3636 if (((rval = sata_txlt_generic_pkt_info(spx, &reason, 0)) !=
3637 TRAN_ACCEPT) || (reason == CMD_DEV_GONE)) {
3638 mutex_exit(cport_mutex);
3639 return (rval);
3640 }
3641
3642 sdinfo = sata_get_device_info(spx->txlt_sata_hba_inst,
3643 &spx->txlt_sata_pkt->satapkt_device);
3644
3645 ASSERT(sdinfo != NULL);
3646
3647 scsipkt->pkt_reason = CMD_CMPLT;
3648 scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET |
3649 STATE_SENT_CMD | STATE_GOT_STATUS;
3650
3651 /* Reject not supported request */
3652 if (scsipkt->pkt_cdbp[1] & CMDDT) { /* No support for this bit */
3653 *scsipkt->pkt_scbp = STATUS_CHECK;
3654 sense = sata_arq_sense(spx);
3655 sense->es_key = KEY_ILLEGAL_REQUEST;
3656 sense->es_add_code = SD_SCSI_ASC_INVALID_FIELD_IN_CDB;
3657 goto done;
3658 }
3659
3660 /* Valid Inquiry request */
3661 *scsipkt->pkt_scbp = STATUS_GOOD;
3662
3663 if (bp != NULL && bp->b_un.b_addr && bp->b_bcount) {
3664
3665 /*
3666 * Because it is fully emulated command storing data
3667 * programatically in the specified buffer, release
3668 * preallocated DMA resources before storing data in the buffer,
3669 * so no unwanted DMA sync would take place.
3670 */
3671 sata_scsi_dmafree(NULL, scsipkt);
3672
3673 if (!(scsipkt->pkt_cdbp[1] & EVPD)) {
3674 /* Standard Inquiry Data request */
3675 struct scsi_inquiry inq;
3676 unsigned int bufsize;
3677
3678 sata_identdev_to_inquiry(spx->txlt_sata_hba_inst,
3679 sdinfo, (uint8_t *)&inq);
3680 /* Copy no more than requested */
3681 count = MIN(bp->b_bcount,
3682 sizeof (struct scsi_inquiry));
3683 bufsize = scsipkt->pkt_cdbp[4];
3684 bufsize |= scsipkt->pkt_cdbp[3] << 8;
3685 count = MIN(count, bufsize);
3686 bcopy(&inq, bp->b_un.b_addr, count);
3687
3688 scsipkt->pkt_state |= STATE_XFERRED_DATA;
3689 scsipkt->pkt_resid = scsipkt->pkt_cdbp[4] > count ?
3690 bufsize - count : 0;
3691 } else {
3692 /*
3693 * peripheral_qualifier = 0;
3694 *
3695 * We are dealing only with HD and will be
3696 * dealing with CD/DVD devices soon
3697 */
3698 uint8_t peripheral_device_type =
3699 sdinfo->satadrv_type == SATA_DTYPE_ATADISK ?
3700 DTYPE_DIRECT : DTYPE_RODIRECT;
3701
3702 bzero(page_buf, sizeof (page_buf));
3703
3704 switch ((uint_t)scsipkt->pkt_cdbp[2]) {
3705 case INQUIRY_SUP_VPD_PAGE:
3706 /*
3707 * Request for supported Vital Product Data
3708 * pages.
3709 */
3710 page_buf[0] = peripheral_device_type;
3711 page_buf[1] = INQUIRY_SUP_VPD_PAGE;
3712 page_buf[2] = 0;
3713 page_buf[3] = 4; /* page length */
3714 page_buf[4] = INQUIRY_SUP_VPD_PAGE;
3715 page_buf[5] = INQUIRY_USN_PAGE;
3716 page_buf[6] = INQUIRY_BDC_PAGE;
3717 page_buf[7] = INQUIRY_ATA_INFO_PAGE;
3718 /* Copy no more than requested */
3719 count = MIN(bp->b_bcount, 8);
3720 bcopy(page_buf, bp->b_un.b_addr, count);
3721 break;
3722
3723 case INQUIRY_USN_PAGE:
3724 /*
3725 * Request for Unit Serial Number page.
3726 * Set-up the page.
3727 */
3728 page_buf[0] = peripheral_device_type;
3729 page_buf[1] = INQUIRY_USN_PAGE;
3730 page_buf[2] = 0;
3731 /* remaining page length */
3732 page_buf[3] = SATA_ID_SERIAL_LEN;
3733
3734 /*
3735 * Copy serial number from Identify Device data
3736 * words into the inquiry page and swap bytes
3737 * when necessary.
3738 */
3739 p = (uint8_t *)(sdinfo->satadrv_id.ai_drvser);
3740 #ifdef _LITTLE_ENDIAN
3741 swab(p, &page_buf[4], SATA_ID_SERIAL_LEN);
3742 #else
3743 bcopy(p, &page_buf[4], SATA_ID_SERIAL_LEN);
3744 #endif
3745 /*
3746 * Least significant character of the serial
3747 * number shall appear as the last byte,
3748 * according to SBC-3 spec.
3749 * Count trailing spaces to determine the
3750 * necessary shift length.
3751 */
3752 p = &page_buf[SATA_ID_SERIAL_LEN + 4 - 1];
3753 for (j = 0; j < SATA_ID_SERIAL_LEN; j++) {
3754 if (*(p - j) != '\0' &&
3755 *(p - j) != '\040')
3756 break;
3757 }
3758
3759 /*
3760 * Shift SN string right, so that the last
3761 * non-blank character would appear in last
3762 * byte of SN field in the page.
3763 * 'j' is the shift length.
3764 */
3765 for (i = 0;
3766 i < (SATA_ID_SERIAL_LEN - j) && j != 0;
3767 i++, p--)
3768 *p = *(p - j);
3769
3770 /*
3771 * Add leading spaces - same number as the
3772 * shift size
3773 */
3774 for (; j > 0; j--)
3775 page_buf[4 + j - 1] = '\040';
3776
3777 count = MIN(bp->b_bcount,
3778 SATA_ID_SERIAL_LEN + 4);
3779 bcopy(page_buf, bp->b_un.b_addr, count);
3780 break;
3781
3782 case INQUIRY_BDC_PAGE:
3783 /*
3784 * Request for Block Device Characteristics
3785 * page. Set-up the page.
3786 */
3787 page_buf[0] = peripheral_device_type;
3788 page_buf[1] = INQUIRY_BDC_PAGE;
3789 page_buf[2] = 0;
3790 /* remaining page length */
3791 page_buf[3] = SATA_ID_BDC_LEN;
3792
3793 rate = sdinfo->satadrv_id.ai_medrotrate;
3794 page_buf[4] = (rate >> 8) & 0xff;
3795 page_buf[5] = rate & 0xff;
3796 page_buf[6] = 0;
3797 page_buf[7] = sdinfo->satadrv_id.
3798 ai_nomformfactor & 0xf;
3799
3800 count = MIN(bp->b_bcount,
3801 SATA_ID_BDC_LEN + 4);
3802 bcopy(page_buf, bp->b_un.b_addr, count);
3803 break;
3804
3805 case INQUIRY_ATA_INFO_PAGE:
3806 /*
3807 * Request for ATA Information page.
3808 */
3809 page_buf[0] = peripheral_device_type;
3810 page_buf[1] = INQUIRY_ATA_INFO_PAGE;
3811 page_buf[2] = (SATA_ID_ATA_INFO_LEN >> 8) &
3812 0xff;
3813 page_buf[3] = SATA_ID_ATA_INFO_LEN & 0xff;
3814 /* page_buf[4-7] reserved */
3815 #ifdef _LITTLE_ENDIAN
3816 bcopy("ATA ", &page_buf[8], 8);
3817 swab(sdinfo->satadrv_id.ai_model,
3818 &page_buf[16], 16);
3819 if (strncmp(&sdinfo->satadrv_id.ai_fw[4],
3820 " ", 4) == 0) {
3821 swab(sdinfo->satadrv_id.ai_fw,
3822 &page_buf[32], 4);
3823 } else {
3824 swab(&sdinfo->satadrv_id.ai_fw[4],
3825 &page_buf[32], 4);
3826 }
3827 #else /* _LITTLE_ENDIAN */
3828 bcopy("ATA ", &page_buf[8], 8);
3829 bcopy(sdinfo->satadrv_id.ai_model,
3830 &page_buf[16], 16);
3831 if (strncmp(&sdinfo->satadrv_id.ai_fw[4],
3832 " ", 4) == 0) {
3833 bcopy(sdinfo->satadrv_id.ai_fw,
3834 &page_buf[32], 4);
3835 } else {
3836 bcopy(&sdinfo->satadrv_id.ai_fw[4],
3837 &page_buf[32], 4);
3838 }
3839 #endif /* _LITTLE_ENDIAN */
3840 /*
3841 * page_buf[36-55] which defines the device
3842 * signature is not defined at this
3843 * time.
3844 */
3845
3846 /* Set the command code */
3847 if (sdinfo->satadrv_type ==
3848 SATA_DTYPE_ATADISK) {
3849 page_buf[56] = SATAC_ID_DEVICE;
3850 } else if (sdinfo->satadrv_type ==
3851 SATA_DTYPE_ATAPI) {
3852 page_buf[56] = SATAC_ID_PACKET_DEVICE;
3853 }
3854 /*
3855 * If the command code, page_buf[56], is not
3856 * zero and if one of the identify commands
3857 * succeeds, return the identify data.
3858 */
3859 if ((page_buf[56] != 0) &&
3860 (sata_fetch_device_identify_data(
3861 spx->txlt_sata_hba_inst, sdinfo) ==
3862 SATA_SUCCESS)) {
3863 bcopy(&sdinfo->satadrv_id,
3864 &page_buf[60], sizeof (sata_id_t));
3865 }
3866
3867 /* Need to copy out the page_buf to bp */
3868 count = MIN(bp->b_bcount,
3869 SATA_ID_ATA_INFO_LEN + 4);
3870 bcopy(page_buf, bp->b_un.b_addr, count);
3871 break;
3872
3873 case INQUIRY_DEV_IDENTIFICATION_PAGE:
3874 /*
3875 * We may want to implement this page, when
3876 * identifiers are common for SATA devices
3877 * But not now.
3878 */
3879 /*FALLTHROUGH*/
3880
3881 default:
3882 /* Request for unsupported VPD page */
3883 *scsipkt->pkt_scbp = STATUS_CHECK;
3884 sense = sata_arq_sense(spx);
3885 sense->es_key = KEY_ILLEGAL_REQUEST;
3886 sense->es_add_code =
3887 SD_SCSI_ASC_INVALID_FIELD_IN_CDB;
3888 goto done;
3889 }
3890 }
3891 scsipkt->pkt_state |= STATE_XFERRED_DATA;
3892 scsipkt->pkt_resid = scsipkt->pkt_cdbp[4] > count ?
3893 scsipkt->pkt_cdbp[4] - count : 0;
3894 }
3895 done:
3896 mutex_exit(cport_mutex);
3897
3898 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst,
3899 "Scsi_pkt completion reason %x\n",
3900 scsipkt->pkt_reason);
3901
3902 if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0 &&
3903 scsipkt->pkt_comp != NULL) {
3904 /* scsi callback required */
3905 if (servicing_interrupt()) {
3906 if (taskq_dispatch(SATA_TXLT_TASKQ(spx),
3907 (task_func_t *)spx->txlt_scsi_pkt->pkt_comp,
3908 (void *)spx->txlt_scsi_pkt, TQ_NOSLEEP) == NULL) {
3909 return (TRAN_BUSY);
3910 }
3911 } else if (taskq_dispatch(SATA_TXLT_TASKQ(spx),
3912 (task_func_t *)spx->txlt_scsi_pkt->pkt_comp,
3913 (void *)spx->txlt_scsi_pkt, TQ_SLEEP) == NULL) {
3914 /* Scheduling the callback failed */
3915 return (TRAN_BUSY);
3916 }
3917 }
3918 return (TRAN_ACCEPT);
3919 }
3920
3921 /*
3922 * SATA translate command: Request Sense.
3923 *
3924 * Returns TRAN_ACCEPT and appropriate values in scsi_pkt fields.
3925 * At the moment this is an emulated command (ATA version for SATA hard disks).
3926 * May be translated into Check Power Mode command in the future.
3927 *
3928 * Note: There is a mismatch between already implemented Informational
3929 * Exception Mode Select page 0x1C and this function.
3930 * When MRIE bit is set in page 0x1C, Request Sense is supposed to return
3931 * NO SENSE and set additional sense code to the exception code - this is not
3932 * implemented here.
3933 */
3934 static int
3935 sata_txlt_request_sense(sata_pkt_txlate_t *spx)
3936 {
3937 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt;
3938 struct scsi_extended_sense sense;
3939 struct buf *bp = spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp;
3940 sata_drive_info_t *sdinfo;
3941 sata_cmd_t *scmd = &spx->txlt_sata_pkt->satapkt_cmd;
3942 int rval, reason, power_state = 0;
3943 kmutex_t *cport_mutex;
3944
3945 cport_mutex = &(SATA_TXLT_CPORT_MUTEX(spx));
3946 mutex_enter(cport_mutex);
3947
3948 if (((rval = sata_txlt_generic_pkt_info(spx, &reason, 1)) !=
3949 TRAN_ACCEPT) || (reason == CMD_DEV_GONE)) {
3950 mutex_exit(cport_mutex);
3951 return (rval);
3952 }
3953
3954 scsipkt->pkt_reason = CMD_CMPLT;
3955 scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET |
3956 STATE_SENT_CMD | STATE_GOT_STATUS;
3957 *scsipkt->pkt_scbp = STATUS_GOOD;
3958
3959 /*
3960 * when CONTROL field's NACA bit == 1
3961 * return ILLEGAL_REQUEST
3962 */
3963 if (scsipkt->pkt_cdbp[5] & CTL_BYTE_NACA_MASK) {
3964 mutex_exit(cport_mutex);
3965 return (sata_txlt_check_condition(spx, KEY_ILLEGAL_REQUEST,
3966 SD_SCSI_ASC_CMD_SEQUENCE_ERR));
3967 }
3968
3969 sdinfo = sata_get_device_info(spx->txlt_sata_hba_inst,
3970 &spx->txlt_sata_pkt->satapkt_device);
3971 ASSERT(sdinfo != NULL);
3972
3973 spx->txlt_sata_pkt->satapkt_op_mode |= SATA_OPMODE_SYNCH;
3974
3975 sata_build_generic_cmd(scmd, SATAC_CHECK_POWER_MODE);
3976 scmd->satacmd_flags.sata_copy_out_sec_count_lsb = B_TRUE;
3977 scmd->satacmd_flags.sata_copy_out_error_reg = B_TRUE;
3978 if (sata_hba_start(spx, &rval) != 0) {
3979 mutex_exit(cport_mutex);
3980 return (rval);
3981 }
3982 if (scmd->satacmd_error_reg != 0) {
3983 mutex_exit(cport_mutex);
3984 return (sata_txlt_check_condition(spx, KEY_NO_SENSE,
3985 SD_SCSI_ASC_NO_ADD_SENSE));
3986 }
3987
3988 switch (scmd->satacmd_sec_count_lsb) {
3989 case SATA_PWRMODE_STANDBY: /* device in standby mode */
3990 if (sdinfo->satadrv_power_level == SATA_POWER_STOPPED)
3991 power_state = SATA_POWER_STOPPED;
3992 else {
3993 power_state = SATA_POWER_STANDBY;
3994 sdinfo->satadrv_power_level = SATA_POWER_STANDBY;
3995 }
3996 break;
3997 case SATA_PWRMODE_IDLE: /* device in idle mode */
3998 power_state = SATA_POWER_IDLE;
3999 sdinfo->satadrv_power_level = SATA_POWER_IDLE;
4000 break;
4001 case SATA_PWRMODE_ACTIVE: /* device in active or idle mode */
4002 default: /* 0x40, 0x41 active mode */
4003 if (sdinfo->satadrv_power_level == SATA_POWER_IDLE)
4004 power_state = SATA_POWER_IDLE;
4005 else {
4006 power_state = SATA_POWER_ACTIVE;
4007 sdinfo->satadrv_power_level = SATA_POWER_ACTIVE;
4008 }
4009 break;
4010 }
4011
4012 mutex_exit(cport_mutex);
4013
4014 if (bp != NULL && bp->b_un.b_addr && bp->b_bcount) {
4015 /*
4016 * Because it is fully emulated command storing data
4017 * programatically in the specified buffer, release
4018 * preallocated DMA resources before storing data in the buffer,
4019 * so no unwanted DMA sync would take place.
4020 */
4021 int count = MIN(bp->b_bcount,
4022 sizeof (struct scsi_extended_sense));
4023 sata_scsi_dmafree(NULL, scsipkt);
4024 bzero(&sense, sizeof (struct scsi_extended_sense));
4025 sense.es_valid = 0; /* Valid LBA */
4026 sense.es_class = 7; /* Response code 0x70 - current err */
4027 sense.es_key = KEY_NO_SENSE;
4028 sense.es_add_len = 6; /* Additional length */
4029 /* Copy no more than requested */
4030 bcopy(&sense, bp->b_un.b_addr, count);
4031 scsipkt->pkt_state |= STATE_XFERRED_DATA;
4032 scsipkt->pkt_resid = 0;
4033 switch (power_state) {
4034 case SATA_POWER_IDLE:
4035 case SATA_POWER_STANDBY:
4036 sense.es_add_code =
4037 SD_SCSI_ASC_LOW_POWER_CONDITION_ON;
4038 break;
4039 case SATA_POWER_STOPPED:
4040 sense.es_add_code = SD_SCSI_ASC_NO_ADD_SENSE;
4041 break;
4042 case SATA_POWER_ACTIVE:
4043 default:
4044 break;
4045 }
4046 }
4047
4048 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst,
4049 "Scsi_pkt completion reason %x\n",
4050 scsipkt->pkt_reason);
4051
4052 if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0 &&
4053 scsipkt->pkt_comp != NULL) {
4054 /* scsi callback required */
4055 if (servicing_interrupt()) {
4056 if (taskq_dispatch(SATA_TXLT_TASKQ(spx),
4057 (task_func_t *)spx->txlt_scsi_pkt->pkt_comp,
4058 (void *)spx->txlt_scsi_pkt, TQ_NOSLEEP) == NULL) {
4059 return (TRAN_BUSY);
4060 }
4061 } else if (taskq_dispatch(SATA_TXLT_TASKQ(spx),
4062 (task_func_t *)spx->txlt_scsi_pkt->pkt_comp,
4063 (void *)spx->txlt_scsi_pkt, TQ_SLEEP) == NULL) {
4064 /* Scheduling the callback failed */
4065 return (TRAN_BUSY);
4066 }
4067 }
4068 return (TRAN_ACCEPT);
4069 }
4070
4071 /*
4072 * SATA translate command: Test Unit Ready
4073 * (ATA version for SATA hard disks).
4074 * It is translated into the Check Power Mode command.
4075 *
4076 * Returns TRAN_ACCEPT and appropriate values in scsi_pkt fields.
4077 */
4078 static int
4079 sata_txlt_test_unit_ready(sata_pkt_txlate_t *spx)
4080 {
4081 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt;
4082 struct scsi_extended_sense *sense;
4083 sata_cmd_t *scmd = &spx->txlt_sata_pkt->satapkt_cmd;
4084 sata_drive_info_t *sdinfo;
4085 int power_state;
4086 int rval, reason;
4087 kmutex_t *cport_mutex = &(SATA_TXLT_CPORT_MUTEX(spx));
4088
4089 mutex_enter(cport_mutex);
4090
4091 if (((rval = sata_txlt_generic_pkt_info(spx, &reason, 1)) !=
4092 TRAN_ACCEPT) || (reason == CMD_DEV_GONE)) {
4093 mutex_exit(cport_mutex);
4094 return (rval);
4095 }
4096
4097 sdinfo = sata_get_device_info(spx->txlt_sata_hba_inst,
4098 &spx->txlt_sata_pkt->satapkt_device);
4099 ASSERT(sdinfo != NULL);
4100
4101 spx->txlt_sata_pkt->satapkt_op_mode |= SATA_OPMODE_SYNCH;
4102
4103 /* send CHECK POWER MODE command */
4104 sata_build_generic_cmd(scmd, SATAC_CHECK_POWER_MODE);
4105 scmd->satacmd_flags.sata_copy_out_sec_count_lsb = B_TRUE;
4106 scmd->satacmd_flags.sata_copy_out_error_reg = B_TRUE;
4107 if (sata_hba_start(spx, &rval) != 0) {
4108 mutex_exit(cport_mutex);
4109 return (rval);
4110 }
4111
4112 if (scmd->satacmd_error_reg != 0) {
4113 mutex_exit(cport_mutex);
4114 return (sata_txlt_check_condition(spx, KEY_NOT_READY,
4115 SD_SCSI_ASC_LU_NOT_RESPONSE));
4116 }
4117
4118 power_state = scmd->satacmd_sec_count_lsb;
4119
4120 /*
4121 * return NOT READY when device in STOPPED mode
4122 */
4123 if (power_state == SATA_PWRMODE_STANDBY &&
4124 sdinfo->satadrv_power_level == SATA_POWER_STOPPED) {
4125 *scsipkt->pkt_scbp = STATUS_CHECK;
4126 sense = sata_arq_sense(spx);
4127 sense->es_key = KEY_NOT_READY;
4128 sense->es_add_code = SD_SCSI_ASC_LU_NOT_READY;
4129 } else {
4130 /*
4131 * For other power mode, return GOOD status
4132 */
4133 *scsipkt->pkt_scbp = STATUS_GOOD;
4134 }
4135
4136 scsipkt->pkt_reason = CMD_CMPLT;
4137 scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET |
4138 STATE_SENT_CMD | STATE_GOT_STATUS;
4139
4140 mutex_exit(cport_mutex);
4141
4142 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst,
4143 "Scsi_pkt completion reason %x\n", scsipkt->pkt_reason);
4144
4145 if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0 &&
4146 scsipkt->pkt_comp != NULL) {
4147 /* scsi callback required */
4148 if (servicing_interrupt()) {
4149 if (taskq_dispatch(SATA_TXLT_TASKQ(spx),
4150 (task_func_t *)spx->txlt_scsi_pkt->pkt_comp,
4151 (void *)spx->txlt_scsi_pkt, TQ_NOSLEEP) == NULL) {
4152 return (TRAN_BUSY);
4153 }
4154 } else if (taskq_dispatch(SATA_TXLT_TASKQ(spx),
4155 (task_func_t *)spx->txlt_scsi_pkt->pkt_comp,
4156 (void *)spx->txlt_scsi_pkt, TQ_SLEEP) == NULL) {
4157 /* Scheduling the callback failed */
4158 return (TRAN_BUSY);
4159 }
4160 }
4161
4162 return (TRAN_ACCEPT);
4163 }
4164
4165 /*
4166 * SATA translate command: Start Stop Unit
4167 * Translation depends on a command:
4168 *
4169 * Power condition bits will be supported
4170 * and the power level should be maintained by SATL,
4171 * When SATL received a command, it will check the
4172 * power level firstly, and return the status according
4173 * to SAT2 v2.6 and SAT-2 Standby Modifications
4174 *
4175 * SPC-4/SBC-3 SATL ATA power condition SATL SPC/SBC
4176 * -----------------------------------------------------------------------
4177 * SSU_PC1 Active <==> ATA Active <==> SSU:start_bit =1
4178 * SSU_PC2 Idle <==> ATA Idle <==> N/A
4179 * SSU_PC3 Standby <==> ATA Standby <==> N/A
4180 * SSU_PC4 Stopped <==> ATA Standby <==> SSU:start_bit = 0
4181 *
4182 * Unload Media / NOT SUPPORTED YET
4183 * Load Media / NOT SUPPROTED YET
4184 * Immediate bit / NOT SUPPORTED YET (deferred error)
4185 *
4186 * Returns TRAN_ACCEPT or code returned by sata_hba_start() and
4187 * appropriate values in scsi_pkt fields.
4188 */
4189 static int
4190 sata_txlt_start_stop_unit(sata_pkt_txlate_t *spx)
4191 {
4192 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt;
4193 sata_cmd_t *scmd = &spx->txlt_sata_pkt->satapkt_cmd;
4194 int rval, reason;
4195 sata_drive_info_t *sdinfo;
4196 sata_id_t *sata_id;
4197 kmutex_t *cport_mutex = &(SATA_TXLT_CPORT_MUTEX(spx));
4198
4199 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst,
4200 "sata_txlt_start_stop_unit: %d\n", scsipkt->pkt_scbp[4] & 1);
4201
4202 mutex_enter(cport_mutex);
4203
4204 if (((rval = sata_txlt_generic_pkt_info(spx, &reason, 1)) !=
4205 TRAN_ACCEPT) || (reason == CMD_DEV_GONE)) {
4206 mutex_exit(cport_mutex);
4207 return (rval);
4208 }
4209
4210 if (scsipkt->pkt_cdbp[1] & START_STOP_IMMED_MASK) {
4211 /* IMMED bit - not supported */
4212 mutex_exit(cport_mutex);
4213 return (sata_txlt_check_condition(spx, KEY_ILLEGAL_REQUEST,
4214 SD_SCSI_ASC_INVALID_FIELD_IN_CDB));
4215 }
4216
4217 spx->txlt_sata_pkt->satapkt_op_mode |= SATA_OPMODE_SYNCH;
4218 spx->txlt_sata_pkt->satapkt_comp = NULL;
4219
4220 sdinfo = sata_get_device_info(spx->txlt_sata_hba_inst,
4221 &spx->txlt_sata_pkt->satapkt_device);
4222 ASSERT(sdinfo != NULL);
4223 sata_id = &sdinfo->satadrv_id;
4224
4225 switch ((scsipkt->pkt_cdbp[4] & START_STOP_POWER_COND_MASK) >> 4) {
4226 case 0:
4227 if (scsipkt->pkt_cdbp[4] & START_STOP_LOEJ_MASK) {
4228 /* Load/Unload Media - invalid request */
4229 goto err_out;
4230 }
4231 if (scsipkt->pkt_cdbp[4] & START_STOP_START_MASK) {
4232 /* Start Unit */
4233 sata_build_read_verify_cmd(scmd, 1, 5);
4234 scmd->satacmd_flags.sata_copy_out_error_reg = B_TRUE;
4235 /* Transfer command to HBA */
4236 if (sata_hba_start(spx, &rval) != 0) {
4237 /* Pkt not accepted for execution */
4238 mutex_exit(cport_mutex);
4239 return (rval);
4240 }
4241 if (scmd->satacmd_error_reg != 0) {
4242 goto err_out;
4243 }
4244 sdinfo->satadrv_power_level = SATA_POWER_ACTIVE;
4245 } else {
4246 /* Stop Unit */
4247 sata_build_generic_cmd(scmd, SATAC_FLUSH_CACHE);
4248 scmd->satacmd_flags.sata_copy_out_error_reg = B_TRUE;
4249 if (sata_hba_start(spx, &rval) != 0) {
4250 mutex_exit(cport_mutex);
4251 return (rval);
4252 } else {
4253 if (scmd->satacmd_error_reg != 0) {
4254 goto err_out;
4255 }
4256 }
4257 /* ata standby immediate command */
4258 sata_build_generic_cmd(scmd, SATAC_STANDBY_IM);
4259 scmd->satacmd_flags.sata_copy_out_error_reg = B_TRUE;
4260 if (sata_hba_start(spx, &rval) != 0) {
4261 mutex_exit(cport_mutex);
4262 return (rval);
4263 }
4264 if (scmd->satacmd_error_reg != 0) {
4265 goto err_out;
4266 }
4267 sdinfo->satadrv_power_level = SATA_POWER_STOPPED;
4268 }
4269 break;
4270 case 0x1:
4271 sata_build_generic_cmd(scmd, SATAC_IDLE);
4272 scmd->satacmd_flags.sata_copy_out_error_reg = B_TRUE;
4273 if (sata_hba_start(spx, &rval) != 0) {
4274 mutex_exit(cport_mutex);
4275 return (rval);
4276 }
4277 if (scmd->satacmd_error_reg != 0) {
4278 goto err_out;
4279 }
4280 sata_build_read_verify_cmd(scmd, 1, 5);
4281 scmd->satacmd_flags.sata_copy_out_error_reg = B_TRUE;
4282 /* Transfer command to HBA */
4283 if (sata_hba_start(spx, &rval) != 0) {
4284 /* Pkt not accepted for execution */
4285 mutex_exit(cport_mutex);
4286 return (rval);
4287 } else {
4288 if (scmd->satacmd_error_reg != 0) {
4289 goto err_out;
4290 }
4291 }
4292 sdinfo->satadrv_power_level = SATA_POWER_ACTIVE;
4293 break;
4294 case 0x2:
4295 sata_build_generic_cmd(scmd, SATAC_FLUSH_CACHE);
4296 scmd->satacmd_flags.sata_copy_out_error_reg = B_TRUE;
4297 if (!(scsipkt->pkt_cdbp[4] & START_STOP_NOFLUSH_MASK)) {
4298 if (sata_hba_start(spx, &rval) != 0) {
4299 mutex_exit(cport_mutex);
4300 return (rval);
4301 }
4302 if (scmd->satacmd_error_reg != 0) {
4303 goto err_out;
4304 }
4305 }
4306 sata_build_generic_cmd(scmd, SATAC_IDLE);
4307 scmd->satacmd_flags.sata_copy_out_error_reg = B_TRUE;
4308 if (sata_hba_start(spx, &rval) != 0) {
4309 mutex_exit(cport_mutex);
4310 return (rval);
4311 }
4312 if (scmd->satacmd_error_reg != 0) {
4313 goto err_out;
4314 }
4315 if ((scsipkt->pkt_cdbp[3] & START_STOP_MODIFIER_MASK)) {
4316 /*
4317 * POWER CONDITION MODIFIER bit set
4318 * to 0x1 or larger it will be handled
4319 * on the same way as bit = 0x1
4320 */
4321 if (!(sata_id->ai_cmdset84 &
4322 SATA_IDLE_UNLOAD_SUPPORTED)) {
4323 sdinfo->satadrv_power_level = SATA_POWER_IDLE;
4324 break;
4325 }
4326 sata_build_generic_cmd(scmd, SATAC_IDLE_IM);
4327 scmd->satacmd_features_reg = 0x44;
4328 scmd->satacmd_lba_low_lsb = 0x4c;
4329 scmd->satacmd_lba_mid_lsb = 0x4e;
4330 scmd->satacmd_lba_high_lsb = 0x55;
4331 scmd->satacmd_flags.sata_copy_out_error_reg = B_TRUE;
4332 if (sata_hba_start(spx, &rval) != 0) {
4333 mutex_exit(cport_mutex);
4334 return (rval);
4335 }
4336 if (scmd->satacmd_error_reg != 0) {
4337 goto err_out;
4338 }
4339 }
4340 sdinfo->satadrv_power_level = SATA_POWER_IDLE;
4341 break;
4342 case 0x3:
4343 sata_build_generic_cmd(scmd, SATAC_FLUSH_CACHE);
4344 scmd->satacmd_flags.sata_copy_out_error_reg = B_TRUE;
4345 if (!(scsipkt->pkt_cdbp[4] & START_STOP_NOFLUSH_MASK)) {
4346 if (sata_hba_start(spx, &rval) != 0) {
4347 mutex_exit(cport_mutex);
4348 return (rval);
4349 }
4350 if (scmd->satacmd_error_reg != 0) {
4351 goto err_out;
4352 }
4353 }
4354 sata_build_generic_cmd(scmd, SATAC_STANDBY);
4355 scmd->satacmd_flags.sata_copy_out_error_reg = B_TRUE;
4356 if (sata_hba_start(spx, &rval) != 0) {
4357 mutex_exit(cport_mutex);
4358 return (rval);
4359 }
4360 if (scmd->satacmd_error_reg != 0) {
4361 goto err_out;
4362 }
4363 sdinfo->satadrv_power_level = SATA_POWER_STANDBY;
4364 break;
4365 case 0x7:
4366 sata_build_generic_cmd(scmd, SATAC_CHECK_POWER_MODE);
4367 scmd->satacmd_flags.sata_copy_out_sec_count_lsb = B_TRUE;
4368 scmd->satacmd_flags.sata_copy_out_error_reg = B_TRUE;
4369 if (sata_hba_start(spx, &rval) != 0) {
4370 mutex_exit(cport_mutex);
4371 return (rval);
4372 }
4373 if (scmd->satacmd_error_reg != 0) {
4374 goto err_out;
4375 }
4376 switch (scmd->satacmd_sec_count_lsb) {
4377 case SATA_PWRMODE_STANDBY:
4378 sata_build_generic_cmd(scmd, SATAC_STANDBY);
4379 scmd->satacmd_sec_count_msb = sata_get_standby_timer(
4380 sdinfo->satadrv_standby_timer);
4381 scmd->satacmd_flags.sata_copy_out_error_reg = B_TRUE;
4382 if (sata_hba_start(spx, &rval) != 0) {
4383 mutex_exit(cport_mutex);
4384 return (rval);
4385 } else {
4386 if (scmd->satacmd_error_reg != 0) {
4387 goto err_out;
4388 }
4389 }
4390 break;
4391 case SATA_PWRMODE_IDLE:
4392 sata_build_generic_cmd(scmd, SATAC_IDLE);
4393 scmd->satacmd_sec_count_msb = sata_get_standby_timer(
4394 sdinfo->satadrv_standby_timer);
4395 scmd->satacmd_flags.sata_copy_out_error_reg = B_TRUE;
4396 if (sata_hba_start(spx, &rval) != 0) {
4397 mutex_exit(cport_mutex);
4398 return (rval);
4399 } else {
4400 if (scmd->satacmd_error_reg != 0) {
4401 goto err_out;
4402 }
4403 }
4404 break;
4405 case SATA_PWRMODE_ACTIVE_SPINDOWN:
4406 case SATA_PWRMODE_ACTIVE_SPINUP:
4407 case SATA_PWRMODE_ACTIVE:
4408 sata_build_generic_cmd(scmd, SATAC_IDLE);
4409 scmd->satacmd_sec_count_msb = sata_get_standby_timer(
4410 sdinfo->satadrv_standby_timer);
4411 scmd->satacmd_flags.sata_copy_out_error_reg = B_TRUE;
4412 if (sata_hba_start(spx, &rval) != 0) {
4413 mutex_exit(cport_mutex);
4414 return (rval);
4415 }
4416 if (scmd->satacmd_error_reg != 0) {
4417 goto err_out;
4418 }
4419 sata_build_read_verify_cmd(scmd, 1, 5);
4420 scmd->satacmd_flags.sata_copy_out_error_reg = B_TRUE;
4421 if (sata_hba_start(spx, &rval) != 0) {
4422 mutex_exit(cport_mutex);
4423 return (rval);
4424 }
4425 if (scmd->satacmd_error_reg != 0) {
4426 goto err_out;
4427 }
4428 break;
4429 default:
4430 goto err_out;
4431 }
4432 break;
4433 case 0xb:
4434 if ((sata_get_standby_timer(sdinfo->satadrv_standby_timer) ==
4435 0) || (!(sata_id->ai_cap & SATA_STANDBYTIMER))) {
4436 mutex_exit(cport_mutex);
4437 return (sata_txlt_check_condition(spx,
4438 KEY_ILLEGAL_REQUEST,
4439 SD_SCSI_ASC_INVALID_FIELD_IN_CDB));
4440 }
4441 sata_build_generic_cmd(scmd, SATAC_FLUSH_CACHE);
4442 scmd->satacmd_flags.sata_copy_out_error_reg = B_TRUE;
4443 if (!(scsipkt->pkt_cdbp[4] & START_STOP_NOFLUSH_MASK)) {
4444 if (sata_hba_start(spx, &rval) != 0) {
4445 mutex_exit(cport_mutex);
4446 return (rval);
4447 }
4448 if (scmd->satacmd_error_reg != 0) {
4449 goto err_out;
4450 }
4451 sata_build_generic_cmd(scmd, SATAC_STANDBY_IM);
4452 scmd->satacmd_flags.sata_copy_out_error_reg = B_TRUE;
4453 if (sata_hba_start(spx, &rval) != 0) {
4454 mutex_exit(cport_mutex);
4455 return (rval);
4456 }
4457 if (scmd->satacmd_error_reg != 0) {
4458 goto err_out;
4459 }
4460 }
4461 bzero(sdinfo->satadrv_standby_timer, sizeof (uchar_t) * 4);
4462 break;
4463 default:
4464 err_out:
4465 mutex_exit(cport_mutex);
4466 return (sata_txlt_check_condition(spx, KEY_ILLEGAL_REQUEST,
4467 SD_SCSI_ASC_INVALID_FIELD_IN_CDB));
4468 }
4469
4470 /*
4471 * Since it was a synchronous command,
4472 * a callback function will be called directly.
4473 */
4474 mutex_exit(cport_mutex);
4475 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst,
4476 "synchronous execution status %x\n",
4477 spx->txlt_sata_pkt->satapkt_reason);
4478
4479 if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0 &&
4480 scsipkt->pkt_comp != NULL) {
4481 sata_set_arq_data(spx->txlt_sata_pkt);
4482 if (servicing_interrupt()) {
4483 if (taskq_dispatch(SATA_TXLT_TASKQ(spx),
4484 (task_func_t *)spx->txlt_scsi_pkt->pkt_comp,
4485 (void *)spx->txlt_scsi_pkt, TQ_NOSLEEP) == NULL) {
4486 return (TRAN_BUSY);
4487 }
4488 } else if (taskq_dispatch(SATA_TXLT_TASKQ(spx),
4489 (task_func_t *)spx->txlt_scsi_pkt->pkt_comp,
4490 (void *)spx->txlt_scsi_pkt, TQ_SLEEP) == NULL) {
4491 /* Scheduling the callback failed */
4492 return (TRAN_BUSY);
4493 }
4494 }
4495 else
4496
4497 sata_txlt_nodata_cmd_completion(spx->txlt_sata_pkt);
4498
4499 return (TRAN_ACCEPT);
4500
4501 }
4502
4503 /*
4504 * SATA translate command: Read Capacity.
4505 * Emulated command for SATA disks.
4506 * Capacity is retrieved from cached Idenifty Device data.
4507 * Identify Device data shows effective disk capacity, not the native
4508 * capacity, which may be limitted by Set Max Address command.
4509 * This is ATA version for SATA hard disks.
4510 *
4511 * Returns TRAN_ACCEPT and appropriate values in scsi_pkt fields.
4512 */
4513 static int
4514 sata_txlt_read_capacity(sata_pkt_txlate_t *spx)
4515 {
4516 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt;
4517 struct buf *bp = spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp;
4518 sata_drive_info_t *sdinfo;
4519 uint64_t val;
4520 uint32_t lbsize = DEV_BSIZE;
4521 uchar_t *rbuf;
4522 int rval, reason;
4523 kmutex_t *cport_mutex = &(SATA_TXLT_CPORT_MUTEX(spx));
4524
4525 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst,
4526 "sata_txlt_read_capacity: ", NULL);
4527
4528 mutex_enter(cport_mutex);
4529
4530 if (((rval = sata_txlt_generic_pkt_info(spx, &reason, 0)) !=
4531 TRAN_ACCEPT) || (reason == CMD_DEV_GONE)) {
4532 mutex_exit(cport_mutex);
4533 return (rval);
4534 }
4535
4536 scsipkt->pkt_reason = CMD_CMPLT;
4537 scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET |
4538 STATE_SENT_CMD | STATE_GOT_STATUS;
4539 *scsipkt->pkt_scbp = STATUS_GOOD;
4540 if (bp != NULL && bp->b_un.b_addr && bp->b_bcount) {
4541 /*
4542 * Because it is fully emulated command storing data
4543 * programatically in the specified buffer, release
4544 * preallocated DMA resources before storing data in the buffer,
4545 * so no unwanted DMA sync would take place.
4546 */
4547 sata_scsi_dmafree(NULL, scsipkt);
4548
4549 sdinfo = sata_get_device_info(
4550 spx->txlt_sata_hba_inst,
4551 &spx->txlt_sata_pkt->satapkt_device);
4552
4553 /*
4554 * As per SBC-3, the "returned LBA" is either the highest
4555 * addressable LBA or 0xffffffff, whichever is smaller.
4556 */
4557 val = MIN(sdinfo->satadrv_capacity - 1, UINT32_MAX);
4558
4559 if (sdinfo->satadrv_id.ai_phys_sect_sz & SATA_L2PS_CHECK_BIT) {
4560 /* physical/logical sector size word is valid */
4561
4562 if (sdinfo->satadrv_id.ai_phys_sect_sz &
4563 SATA_L2PS_BIG_SECTORS) {
4564 /* if this set 117-118 words are valid */
4565 lbsize = sdinfo->satadrv_id.ai_words_lsec[0] |
4566 (sdinfo->satadrv_id.ai_words_lsec[1] << 16);
4567 lbsize <<= 1; /* convert from words to bytes */
4568 }
4569 }
4570 rbuf = (uchar_t *)bp->b_un.b_addr;
4571 /* Need to swap endians to match scsi format */
4572 rbuf[0] = (val >> 24) & 0xff;
4573 rbuf[1] = (val >> 16) & 0xff;
4574 rbuf[2] = (val >> 8) & 0xff;
4575 rbuf[3] = val & 0xff;
4576 rbuf[4] = (lbsize >> 24) & 0xff;
4577 rbuf[5] = (lbsize >> 16) & 0xff;
4578 rbuf[6] = (lbsize >> 8) & 0xff;
4579 rbuf[7] = lbsize & 0xff;
4580
4581 scsipkt->pkt_state |= STATE_XFERRED_DATA;
4582 scsipkt->pkt_resid = 0;
4583
4584 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst, "%d\n",
4585 sdinfo->satadrv_capacity -1);
4586 }
4587 mutex_exit(cport_mutex);
4588 /*
4589 * If a callback was requested, do it now.
4590 */
4591 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst,
4592 "Scsi_pkt completion reason %x\n", scsipkt->pkt_reason);
4593
4594 if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0 &&
4595 scsipkt->pkt_comp != NULL) {
4596 /* scsi callback required */
4597 if (servicing_interrupt()) {
4598 if (taskq_dispatch(SATA_TXLT_TASKQ(spx),
4599 (task_func_t *)spx->txlt_scsi_pkt->pkt_comp,
4600 (void *)spx->txlt_scsi_pkt, TQ_NOSLEEP) == NULL) {
4601 return (TRAN_BUSY);
4602 }
4603 } else if (taskq_dispatch(SATA_TXLT_TASKQ(spx),
4604 (task_func_t *)spx->txlt_scsi_pkt->pkt_comp,
4605 (void *)spx->txlt_scsi_pkt, TQ_SLEEP) == NULL) {
4606 /* Scheduling the callback failed */
4607 return (TRAN_BUSY);
4608 }
4609 }
4610
4611 return (TRAN_ACCEPT);
4612 }
4613
4614 /*
4615 * SATA translate command: Read Capacity (16).
4616 * Emulated command for SATA disks.
4617 * Info is retrieved from cached Identify Device data.
4618 * Implemented to SBC-3 (draft 21) and SAT-2 (final) specifications.
4619 *
4620 * Returns TRAN_ACCEPT and appropriate values in scsi_pkt fields.
4621 */
4622 static int
4623 sata_txlt_read_capacity16(sata_pkt_txlate_t *spx)
4624 {
4625 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt;
4626 struct buf *bp = spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp;
4627 sata_drive_info_t *sdinfo;
4628 uint64_t val;
4629 uint16_t l2p_exp;
4630 uint32_t lbsize = DEV_BSIZE;
4631 uchar_t *rbuf;
4632 int rval, reason;
4633 #define TPE 0x80
4634 #define TPRZ 0x40
4635 kmutex_t *cport_mutex = &(SATA_TXLT_CPORT_MUTEX(spx));
4636
4637 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst,
4638 "sata_txlt_read_capacity: ", NULL);
4639
4640 mutex_enter(cport_mutex);
4641
4642 if (((rval = sata_txlt_generic_pkt_info(spx, &reason, 0)) !=
4643 TRAN_ACCEPT) || (reason == CMD_DEV_GONE)) {
4644 mutex_exit(cport_mutex);
4645 return (rval);
4646 }
4647
4648 scsipkt->pkt_reason = CMD_CMPLT;
4649 scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET |
4650 STATE_SENT_CMD | STATE_GOT_STATUS;
4651 if (bp != NULL && bp->b_un.b_addr && bp->b_bcount) {
4652 /*
4653 * Because it is fully emulated command storing data
4654 * programatically in the specified buffer, release
4655 * preallocated DMA resources before storing data in the buffer,
4656 * so no unwanted DMA sync would take place.
4657 */
4658 sata_scsi_dmafree(NULL, scsipkt);
4659
4660 /* Check SERVICE ACTION field */
4661 if ((scsipkt->pkt_cdbp[1] & 0x1f) !=
4662 SSVC_ACTION_READ_CAPACITY_G4) {
4663 mutex_exit(cport_mutex);
4664 return (sata_txlt_check_condition(spx,
4665 KEY_ILLEGAL_REQUEST,
4666 SD_SCSI_ASC_INVALID_FIELD_IN_CDB));
4667 }
4668
4669 /* Check LBA field */
4670 if ((scsipkt->pkt_cdbp[2] != 0) ||
4671 (scsipkt->pkt_cdbp[3] != 0) ||
4672 (scsipkt->pkt_cdbp[4] != 0) ||
4673 (scsipkt->pkt_cdbp[5] != 0) ||
4674 (scsipkt->pkt_cdbp[6] != 0) ||
4675 (scsipkt->pkt_cdbp[7] != 0) ||
4676 (scsipkt->pkt_cdbp[8] != 0) ||
4677 (scsipkt->pkt_cdbp[9] != 0)) {
4678 mutex_exit(cport_mutex);
4679 return (sata_txlt_check_condition(spx,
4680 KEY_ILLEGAL_REQUEST,
4681 SD_SCSI_ASC_INVALID_FIELD_IN_CDB));
4682 }
4683
4684 /* Check PMI bit */
4685 if (scsipkt->pkt_cdbp[14] & 0x1) {
4686 mutex_exit(cport_mutex);
4687 return (sata_txlt_check_condition(spx,
4688 KEY_ILLEGAL_REQUEST,
4689 SD_SCSI_ASC_INVALID_FIELD_IN_CDB));
4690 }
4691
4692 *scsipkt->pkt_scbp = STATUS_GOOD;
4693
4694 sdinfo = sata_get_device_info(
4695 spx->txlt_sata_hba_inst,
4696 &spx->txlt_sata_pkt->satapkt_device);
4697
4698 /* last logical block address */
4699 val = MIN(sdinfo->satadrv_capacity - 1,
4700 SCSI_READ_CAPACITY16_MAX_LBA);
4701
4702 /* logical to physical block size exponent */
4703 l2p_exp = 0;
4704 if (sdinfo->satadrv_id.ai_phys_sect_sz & SATA_L2PS_CHECK_BIT) {
4705 /* physical/logical sector size word is valid */
4706
4707 if (sdinfo->satadrv_id.ai_phys_sect_sz &
4708 SATA_L2PS_HAS_MULT) {
4709 /* multiple logical sectors per phys sectors */
4710 l2p_exp =
4711 sdinfo->satadrv_id.ai_phys_sect_sz &
4712 SATA_L2PS_EXP_MASK;
4713 }
4714
4715 if (sdinfo->satadrv_id.ai_phys_sect_sz &
4716 SATA_L2PS_BIG_SECTORS) {
4717 /* if this set 117-118 words are valid */
4718 lbsize = sdinfo->satadrv_id.ai_words_lsec[0] |
4719 (sdinfo->satadrv_id.ai_words_lsec[1] << 16);
4720 lbsize <<= 1; /* convert from words to bytes */
4721 }
4722 }
4723
4724 rbuf = (uchar_t *)bp->b_un.b_addr;
4725 bzero(rbuf, bp->b_bcount);
4726
4727 /* returned logical block address */
4728 rbuf[0] = (val >> 56) & 0xff;
4729 rbuf[1] = (val >> 48) & 0xff;
4730 rbuf[2] = (val >> 40) & 0xff;
4731 rbuf[3] = (val >> 32) & 0xff;
4732 rbuf[4] = (val >> 24) & 0xff;
4733 rbuf[5] = (val >> 16) & 0xff;
4734 rbuf[6] = (val >> 8) & 0xff;
4735 rbuf[7] = val & 0xff;
4736 rbuf[8] = (lbsize >> 24) & 0xff;
4737 rbuf[9] = (lbsize >> 16) & 0xff;
4738 rbuf[10] = (lbsize >> 8) & 0xff;
4739 rbuf[11] = lbsize & 0xff;
4740
4741 /* p_type, prot_en, unspecified by SAT-2 */
4742 /* rbuf[12] = 0; */
4743
4744 /* p_i_exponent, undefined by SAT-2 */
4745 /* logical blocks per physical block exponent */
4746 rbuf[13] = l2p_exp;
4747
4748 /* lowest aligned logical block address = 0 (for now) */
4749 /* tpe and tprz as defined in T10/10-079 r0 */
4750 if (sdinfo->satadrv_id.ai_addsupported &
4751 SATA_DETERMINISTIC_READ) {
4752 if (sdinfo->satadrv_id.ai_addsupported &
4753 SATA_READ_ZERO) {
4754 rbuf[14] |= TPRZ;
4755 } else {
4756 rbuf[14] |= TPE;
4757 }
4758 }
4759 /* rbuf[15] = 0; */
4760
4761 scsipkt->pkt_state |= STATE_XFERRED_DATA;
4762 scsipkt->pkt_resid = 0;
4763
4764 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst, "%llu\n",
4765 sdinfo->satadrv_capacity -1);
4766 }
4767
4768 mutex_exit(cport_mutex);
4769
4770 /*
4771 * If a callback was requested, do it now.
4772 */
4773 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst,
4774 "Scsi_pkt completion reason %x\n", scsipkt->pkt_reason);
4775
4776 if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0 &&
4777 scsipkt->pkt_comp != NULL) {
4778 /* scsi callback required */
4779 if (servicing_interrupt()) {
4780 if (taskq_dispatch(SATA_TXLT_TASKQ(spx),
4781 (task_func_t *)spx->txlt_scsi_pkt->pkt_comp,
4782 (void *)spx->txlt_scsi_pkt, TQ_NOSLEEP) == NULL) {
4783 return (TRAN_BUSY);
4784 }
4785 } else if (taskq_dispatch(SATA_TXLT_TASKQ(spx),
4786 (task_func_t *)spx->txlt_scsi_pkt->pkt_comp,
4787 (void *)spx->txlt_scsi_pkt, TQ_SLEEP) == NULL) {
4788 /* Scheduling the callback failed */
4789 return (TRAN_BUSY);
4790 }
4791 }
4792
4793 return (TRAN_ACCEPT);
4794 }
4795
4796 /*
4797 * Translate command: UNMAP
4798 *
4799 * The function cannot be called in interrupt context since it may sleep.
4800 */
4801 static int
4802 sata_txlt_unmap(sata_pkt_txlate_t *spx)
4803 {
4804 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt;
4805 sata_cmd_t *scmd = &spx->txlt_sata_pkt->satapkt_cmd;
4806 struct buf *bp = spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp;
4807 uint16_t count = 0;
4808 int synch;
4809 int rval, reason;
4810 int i, x;
4811 int bdlen = 0;
4812 int ranges = 0;
4813 int paramlen = 8;
4814 uint8_t *data, *tmpbd;
4815 sata_drive_info_t *sdinfo;
4816 kmutex_t *cport_mutex = &(SATA_TXLT_CPORT_MUTEX(spx));
4817 #define TRIM 0x1
4818
4819 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst,
4820 "sata_txlt_unmap: ", NULL);
4821
4822 mutex_enter(cport_mutex);
4823
4824 sdinfo = sata_get_device_info(spx->txlt_sata_hba_inst,
4825 &spx->txlt_sata_pkt->satapkt_device);
4826 if (sdinfo != NULL) {
4827 SATADBG2(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst,
4828 "DSM support 0x%x, max number of 512 byte blocks of LBA "
4829 "range entries 0x%x\n", sdinfo->satadrv_id.ai_dsm,
4830 sdinfo->satadrv_id.ai_maxcount);
4831 }
4832
4833 rval = sata_txlt_generic_pkt_info(spx, &reason, 1);
4834 if ((rval != TRAN_ACCEPT) || (reason == CMD_DEV_GONE)) {
4835 mutex_exit(cport_mutex);
4836 return (rval);
4837 }
4838
4839 /*
4840 * Need to modify bp to have TRIM data instead of UNMAP data.
4841 * Start by getting the block descriptor data length by subtracting
4842 * the 8 byte parameter list header from the parameter list length.
4843 * The block descriptor size has to be a multiple of 16 bytes.
4844 */
4845 bdlen = scsipkt->pkt_cdbp[7];
4846 bdlen = (bdlen << 8) + scsipkt->pkt_cdbp[8] - paramlen;
4847 if ((bdlen < 0) || ((bdlen % 16) != 0) ||
4848 (bdlen > (bp->b_bcount - paramlen))) {
4849 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst,
4850 "sata_txlt_unmap: invalid block descriptor length", NULL);
4851 mutex_exit(cport_mutex);
4852 return ((sata_txlt_check_condition(spx, KEY_ILLEGAL_REQUEST,
4853 SD_SCSI_ASC_INVALID_FIELD_IN_CDB)));
4854 }
4855 /*
4856 * If there are no parameter data or block descriptors, it is not
4857 * considered an error so just complete the command without sending
4858 * TRIM.
4859 */
4860 if ((bdlen == 0) || (bp == NULL) || (bp->b_un.b_addr == NULL) ||
4861 (bp->b_bcount == 0)) {
4862 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst,
4863 "sata_txlt_unmap: no parameter data or block descriptors",
4864 NULL);
4865 mutex_exit(cport_mutex);
4866 return (sata_txlt_unmap_nodata_cmd(spx));
4867 }
4868 tmpbd = (uint8_t *)bp->b_un.b_addr + paramlen;
4869 data = kmem_zalloc(bdlen, KM_SLEEP);
4870
4871 /*
4872 * Loop through all the UNMAP block descriptors and convert the data
4873 * into TRIM format.
4874 */
4875 for (i = 0, x = 0; i < bdlen; i += 16, x += 8) {
4876 /* get range length */
4877 data[x] = tmpbd[i+7];
4878 data[x+1] = tmpbd[i+6];
4879 /* get LBA */
4880 data[x+2] = tmpbd[i+5];
4881 data[x+3] = tmpbd[i+4];
4882 data[x+4] = tmpbd[i+3];
4883 data[x+5] = tmpbd[i+2];
4884 data[x+6] = tmpbd[i+11];
4885 data[x+7] = tmpbd[i+10];
4886
4887 ranges++;
4888 }
4889
4890 /*
4891 * The TRIM command expects the data buffer to be a multiple of
4892 * 512-byte blocks of range entries. This means that the UNMAP buffer
4893 * may be too small. Free the original DMA resources and create a
4894 * local buffer.
4895 */
4896 sata_common_free_dma_rsrcs(spx);
4897
4898 /*
4899 * Get count of 512-byte blocks of range entries. The length
4900 * of a range entry is 8 bytes which means one count has 64 range
4901 * entries.
4902 */
4903 count = (ranges + 63)/64;
4904
4905 /* Allocate a buffer that is a multiple of 512 bytes. */
4906 mutex_exit(cport_mutex);
4907 bp = sata_alloc_local_buffer(spx, count * 512);
4908 if (bp == NULL) {
4909 SATADBG1(SATA_DBG_ATAPI, spx->txlt_sata_hba_inst,
4910 "sata_txlt_unmap: "
4911 "cannot allocate buffer for TRIM command", NULL);
4912 kmem_free(data, bdlen);
4913 return (TRAN_BUSY);
4914 }
4915 bp_mapin(bp); /* make data buffer accessible */
4916 mutex_enter(cport_mutex);
4917
4918 bzero(bp->b_un.b_addr, bp->b_bcount);
4919 bcopy(data, bp->b_un.b_addr, x);
4920 kmem_free(data, bdlen);
4921 rval = ddi_dma_sync(spx->txlt_buf_dma_handle, 0, 0,
4922 DDI_DMA_SYNC_FORDEV);
4923 ASSERT(rval == DDI_SUCCESS);
4924
4925 scmd->satacmd_flags.sata_data_direction = SATA_DIR_WRITE;
4926 scmd->satacmd_addr_type = ATA_ADDR_LBA48;
4927 scmd->satacmd_cmd_reg = SATAC_DSM;
4928 scmd->satacmd_sec_count_msb = (count >> 8) & 0xff;
4929 scmd->satacmd_sec_count_lsb = count & 0xff;
4930 scmd->satacmd_features_reg = TRIM;
4931 scmd->satacmd_device_reg = SATA_ADH_LBA;
4932 scmd->satacmd_status_reg = 0;
4933 scmd->satacmd_error_reg = 0;
4934
4935 /* Start processing command */
4936 if (!(spx->txlt_sata_pkt->satapkt_op_mode & SATA_OPMODE_SYNCH)) {
4937 spx->txlt_sata_pkt->satapkt_comp =
4938 sata_txlt_unmap_completion;
4939 synch = FALSE;
4940 } else {
4941 synch = TRUE;
4942 }
4943
4944 if (sata_hba_start(spx, &rval) != 0) {
4945 mutex_exit(cport_mutex);
4946 return (rval);
4947 }
4948
4949 mutex_exit(cport_mutex);
4950
4951 if (synch) {
4952 sata_txlt_unmap_completion(spx->txlt_sata_pkt);
4953 }
4954
4955 return (TRAN_ACCEPT);
4956 }
4957
4958 /*
4959 * SATA translate command: Mode Sense.
4960 * Translated into appropriate SATA command or emulated.
4961 * Saved Values Page Control (03) are not supported.
4962 *
4963 * NOTE: only caching mode sense page is currently implemented.
4964 *
4965 * Returns TRAN_ACCEPT and appropriate values in scsi_pkt fields.
4966 */
4967
4968 #define LLBAA 0x10 /* Long LBA Accepted */
4969
4970 static int
4971 sata_txlt_mode_sense(sata_pkt_txlate_t *spx)
4972 {
4973 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt;
4974 struct buf *bp = spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp;
4975 sata_drive_info_t *sdinfo;
4976 sata_id_t *sata_id;
4977 struct scsi_extended_sense *sense;
4978 int len, bdlen, count, alc_len;
4979 int pc; /* Page Control code */
4980 uint8_t *buf; /* mode sense buffer */
4981 int rval, reason;
4982 kmutex_t *cport_mutex = &(SATA_TXLT_CPORT_MUTEX(spx));
4983
4984 SATADBG2(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst,
4985 "sata_txlt_mode_sense, pc %x page code 0x%02x\n",
4986 spx->txlt_scsi_pkt->pkt_cdbp[2] >> 6,
4987 spx->txlt_scsi_pkt->pkt_cdbp[2] & 0x3f);
4988
4989 if (servicing_interrupt()) {
4990 buf = kmem_zalloc(1024, KM_NOSLEEP);
4991 if (buf == NULL) {
4992 return (TRAN_BUSY);
4993 }
4994 } else {
4995 buf = kmem_zalloc(1024, KM_SLEEP);
4996 }
4997
4998 mutex_enter(cport_mutex);
4999
5000 if (((rval = sata_txlt_generic_pkt_info(spx, &reason, 0)) !=
5001 TRAN_ACCEPT) || (reason == CMD_DEV_GONE)) {
5002 mutex_exit(cport_mutex);
5003 kmem_free(buf, 1024);
5004 return (rval);
5005 }
5006
5007 scsipkt->pkt_reason = CMD_CMPLT;
5008 scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET |
5009 STATE_SENT_CMD | STATE_GOT_STATUS;
5010
5011 pc = scsipkt->pkt_cdbp[2] >> 6;
5012
5013 if (bp != NULL && bp->b_un.b_addr && bp->b_bcount) {
5014 /*
5015 * Because it is fully emulated command storing data
5016 * programatically in the specified buffer, release
5017 * preallocated DMA resources before storing data in the buffer,
5018 * so no unwanted DMA sync would take place.
5019 */
5020 sata_scsi_dmafree(NULL, scsipkt);
5021
5022 len = 0;
5023 bdlen = 0;
5024 if (!(scsipkt->pkt_cdbp[1] & 8)) {
5025 if (scsipkt->pkt_cdbp[0] == SCMD_MODE_SENSE_G1 &&
5026 (scsipkt->pkt_cdbp[1] & LLBAA))
5027 bdlen = 16;
5028 else
5029 bdlen = 8;
5030 }
5031 /* Build mode parameter header */
5032 if (spx->txlt_scsi_pkt->pkt_cdbp[0] == SCMD_MODE_SENSE) {
5033 /* 4-byte mode parameter header */
5034 buf[len++] = 0; /* mode data length */
5035 buf[len++] = 0; /* medium type */
5036 buf[len++] = 0; /* dev-specific param */
5037 buf[len++] = bdlen; /* Block Descriptor length */
5038 } else {
5039 /* 8-byte mode parameter header */
5040 buf[len++] = 0; /* mode data length */
5041 buf[len++] = 0;
5042 buf[len++] = 0; /* medium type */
5043 buf[len++] = 0; /* dev-specific param */
5044 if (bdlen == 16)
5045 buf[len++] = 1; /* long lba descriptor */
5046 else
5047 buf[len++] = 0;
5048 buf[len++] = 0;
5049 buf[len++] = 0; /* Block Descriptor length */
5050 buf[len++] = bdlen;
5051 }
5052
5053 sdinfo = sata_get_device_info(
5054 spx->txlt_sata_hba_inst,
5055 &spx->txlt_sata_pkt->satapkt_device);
5056
5057 /* Build block descriptor only if not disabled (DBD) */
5058 if ((scsipkt->pkt_cdbp[1] & 0x08) == 0) {
5059 /* Block descriptor - direct-access device format */
5060 if (bdlen == 8) {
5061 /* build regular block descriptor */
5062 buf[len++] =
5063 (sdinfo->satadrv_capacity >> 24) & 0xff;
5064 buf[len++] =
5065 (sdinfo->satadrv_capacity >> 16) & 0xff;
5066 buf[len++] =
5067 (sdinfo->satadrv_capacity >> 8) & 0xff;
5068 buf[len++] = sdinfo->satadrv_capacity & 0xff;
5069 buf[len++] = 0; /* density code */
5070 buf[len++] = 0;
5071 if (sdinfo->satadrv_type ==
5072 SATA_DTYPE_ATADISK)
5073 buf[len++] = 2;
5074 else
5075 /* ATAPI */
5076 buf[len++] = 8;
5077 buf[len++] = 0;
5078 } else if (bdlen == 16) {
5079 /* Long LBA Accepted */
5080 /* build long lba block descriptor */
5081 #ifndef __lock_lint
5082 buf[len++] =
5083 (sdinfo->satadrv_capacity >> 56) & 0xff;
5084 buf[len++] =
5085 (sdinfo->satadrv_capacity >> 48) & 0xff;
5086 buf[len++] =
5087 (sdinfo->satadrv_capacity >> 40) & 0xff;
5088 buf[len++] =
5089 (sdinfo->satadrv_capacity >> 32) & 0xff;
5090 #endif
5091 buf[len++] =
5092 (sdinfo->satadrv_capacity >> 24) & 0xff;
5093 buf[len++] =
5094 (sdinfo->satadrv_capacity >> 16) & 0xff;
5095 buf[len++] =
5096 (sdinfo->satadrv_capacity >> 8) & 0xff;
5097 buf[len++] = sdinfo->satadrv_capacity & 0xff;
5098 buf[len++] = 0;
5099 buf[len++] = 0; /* density code */
5100 buf[len++] = 0;
5101 buf[len++] = 0;
5102 if (sdinfo->satadrv_type ==
5103 SATA_DTYPE_ATADISK)
5104 buf[len++] = 2;
5105 else
5106 /* ATAPI */
5107 buf[len++] = 8;
5108 buf[len++] = 0;
5109 }
5110 }
5111
5112 sata_id = &sdinfo->satadrv_id;
5113
5114 /*
5115 * Add requested pages.
5116 * Page 3 and 4 are obsolete and we are not supporting them.
5117 * We deal now with:
5118 * caching (read/write cache control).
5119 * We should eventually deal with following mode pages:
5120 * error recovery (0x01),
5121 * power condition (0x1a),
5122 * exception control page (enables SMART) (0x1c),
5123 * enclosure management (ses),
5124 * protocol-specific port mode (port control).
5125 */
5126 switch (scsipkt->pkt_cdbp[2] & 0x3f) {
5127 case MODEPAGE_RW_ERRRECOV:
5128 /* DAD_MODE_ERR_RECOV */
5129 /* R/W recovery */
5130 len += sata_build_msense_page_1(sdinfo, pc, buf+len);
5131 break;
5132 case MODEPAGE_CACHING:
5133 /* DAD_MODE_CACHE */
5134 /* Reject not supported request for saved parameters */
5135 if (pc == 3) {
5136 *scsipkt->pkt_scbp = STATUS_CHECK;
5137 sense = sata_arq_sense(spx);
5138 sense->es_key = KEY_ILLEGAL_REQUEST;
5139 sense->es_add_code =
5140 SD_SCSI_ASC_SAVING_PARAMS_NOT_SUPPORTED;
5141 goto done;
5142 }
5143
5144 /* caching */
5145 len += sata_build_msense_page_8(sdinfo, pc, buf+len);
5146 break;
5147 case MODEPAGE_INFO_EXCPT:
5148 /* exception cntrl */
5149 if (sata_id->ai_cmdset82 & SATA_SMART_SUPPORTED) {
5150 len += sata_build_msense_page_1c(sdinfo, pc,
5151 buf+len);
5152 }
5153 else
5154 goto err;
5155 break;
5156 case MODEPAGE_POWER_COND:
5157 /* DAD_MODE_POWER_COND */
5158 /* power condition */
5159 len += sata_build_msense_page_1a(sdinfo, pc, buf+len);
5160 break;
5161
5162 case MODEPAGE_ACOUSTIC_MANAG:
5163 /* acoustic management */
5164 len += sata_build_msense_page_30(sdinfo, pc, buf+len);
5165 break;
5166 case MODEPAGE_ALLPAGES:
5167 /* all pages */
5168 len += sata_build_msense_page_1(sdinfo, pc, buf+len);
5169 len += sata_build_msense_page_8(sdinfo, pc, buf+len);
5170 len += sata_build_msense_page_1a(sdinfo, pc, buf+len);
5171 if (sata_id->ai_cmdset82 & SATA_SMART_SUPPORTED) {
5172 len += sata_build_msense_page_1c(sdinfo, pc,
5173 buf+len);
5174 }
5175 len += sata_build_msense_page_30(sdinfo, pc, buf+len);
5176 break;
5177 default:
5178 err:
5179 /* Invalid request */
5180 *scsipkt->pkt_scbp = STATUS_CHECK;
5181 sense = sata_arq_sense(spx);
5182 sense->es_key = KEY_ILLEGAL_REQUEST;
5183 sense->es_add_code = SD_SCSI_ASC_INVALID_FIELD_IN_CDB;
5184 goto done;
5185 }
5186
5187 /* fix total mode data length */
5188 if (spx->txlt_scsi_pkt->pkt_cdbp[0] == SCMD_MODE_SENSE) {
5189 /* 4-byte mode parameter header */
5190 buf[0] = len - 1; /* mode data length */
5191 } else {
5192 buf[0] = (len -2) >> 8;
5193 buf[1] = (len -2) & 0xff;
5194 }
5195
5196
5197 /* Check allocation length */
5198 if (scsipkt->pkt_cdbp[0] == SCMD_MODE_SENSE) {
5199 alc_len = scsipkt->pkt_cdbp[4];
5200 } else {
5201 alc_len = scsipkt->pkt_cdbp[7];
5202 alc_len = (len << 8) | scsipkt->pkt_cdbp[8];
5203 }
5204 /*
5205 * We do not check for possible parameters truncation
5206 * (alc_len < len) assuming that the target driver works
5207 * correctly. Just avoiding overrun.
5208 * Copy no more than requested and possible, buffer-wise.
5209 */
5210 count = MIN(alc_len, len);
5211 count = MIN(bp->b_bcount, count);
5212 bcopy(buf, bp->b_un.b_addr, count);
5213
5214 scsipkt->pkt_state |= STATE_XFERRED_DATA;
5215 scsipkt->pkt_resid = alc_len > count ? alc_len - count : 0;
5216 }
5217 *scsipkt->pkt_scbp = STATUS_GOOD;
5218 done:
5219 mutex_exit(cport_mutex);
5220 (void) kmem_free(buf, 1024);
5221
5222 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst,
5223 "Scsi_pkt completion reason %x\n", scsipkt->pkt_reason);
5224
5225 if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0 &&
5226 scsipkt->pkt_comp != NULL) {
5227 /* scsi callback required */
5228 if (servicing_interrupt()) {
5229 if (taskq_dispatch(SATA_TXLT_TASKQ(spx),
5230 (task_func_t *)spx->txlt_scsi_pkt->pkt_comp,
5231 (void *)spx->txlt_scsi_pkt, TQ_NOSLEEP) == NULL) {
5232 return (TRAN_BUSY);
5233 }
5234 } else if (taskq_dispatch(SATA_TXLT_TASKQ(spx),
5235 (task_func_t *)spx->txlt_scsi_pkt->pkt_comp,
5236 (void *)spx->txlt_scsi_pkt, TQ_SLEEP) == NULL) {
5237 /* Scheduling the callback failed */
5238 return (TRAN_BUSY);
5239 }
5240 }
5241
5242 return (TRAN_ACCEPT);
5243 }
5244
5245
5246 /*
5247 * SATA translate command: Mode Select.
5248 * Translated into appropriate SATA command or emulated.
5249 * Saving parameters is not supported.
5250 * Changing device capacity is not supported (although theoretically
5251 * possible by executing SET FEATURES/SET MAX ADDRESS)
5252 *
5253 * Assumption is that the target driver is working correctly.
5254 *
5255 * More than one SATA command may be executed to perform operations specified
5256 * by mode select pages. The first error terminates further execution.
5257 * Operations performed successully are not backed-up in such case.
5258 *
5259 * NOTE: Implemented pages:
5260 * - caching page
5261 * - informational exception page
5262 * - acoustic management page
5263 * - power condition page
5264 * Caching setup is remembered so it could be re-stored in case of
5265 * an unexpected device reset.
5266 *
5267 * Returns TRAN_XXXX.
5268 * If TRAN_ACCEPT is returned, appropriate values are set in scsi_pkt fields.
5269 */
5270
5271 static int
5272 sata_txlt_mode_select(sata_pkt_txlate_t *spx)
5273 {
5274 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt;
5275 struct buf *bp = spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp;
5276 struct scsi_extended_sense *sense;
5277 int len, pagelen, count, pllen;
5278 uint8_t *buf; /* mode select buffer */
5279 int rval, stat, reason;
5280 uint_t nointr_flag;
5281 int dmod = 0;
5282 kmutex_t *cport_mutex = &(SATA_TXLT_CPORT_MUTEX(spx));
5283
5284 SATADBG2(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst,
5285 "sata_txlt_mode_select, pc %x page code 0x%02x\n",
5286 spx->txlt_scsi_pkt->pkt_cdbp[2] >> 6,
5287 spx->txlt_scsi_pkt->pkt_cdbp[2] & 0x3f);
5288
5289 mutex_enter(cport_mutex);
5290
5291 if (((rval = sata_txlt_generic_pkt_info(spx, &reason, 1)) !=
5292 TRAN_ACCEPT) || (reason == CMD_DEV_GONE)) {
5293 mutex_exit(cport_mutex);
5294 return (rval);
5295 }
5296
5297 rval = TRAN_ACCEPT;
5298
5299 scsipkt->pkt_reason = CMD_CMPLT;
5300 scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET |
5301 STATE_SENT_CMD | STATE_GOT_STATUS;
5302 nointr_flag = scsipkt->pkt_flags & FLAG_NOINTR;
5303
5304 /* Reject not supported request */
5305 if (! (scsipkt->pkt_cdbp[1] & 0x10)) { /* No support for PF bit = 0 */
5306 *scsipkt->pkt_scbp = STATUS_CHECK;
5307 sense = sata_arq_sense(spx);
5308 sense->es_key = KEY_ILLEGAL_REQUEST;
5309 sense->es_add_code = SD_SCSI_ASC_INVALID_FIELD_IN_CDB;
5310 goto done;
5311 }
5312
5313 if (scsipkt->pkt_cdbp[0] == SCMD_MODE_SELECT) {
5314 pllen = scsipkt->pkt_cdbp[4];
5315 } else {
5316 pllen = scsipkt->pkt_cdbp[7];
5317 pllen = (pllen << 8) | scsipkt->pkt_cdbp[7];
5318 }
5319
5320 *scsipkt->pkt_scbp = STATUS_GOOD; /* Presumed outcome */
5321
5322 if (bp != NULL && bp->b_un.b_addr && bp->b_bcount && pllen != 0) {
5323 buf = (uint8_t *)bp->b_un.b_addr;
5324 count = MIN(bp->b_bcount, pllen);
5325 scsipkt->pkt_state |= STATE_XFERRED_DATA;
5326 scsipkt->pkt_resid = 0;
5327 pllen = count;
5328
5329 /*
5330 * Check the header to skip the block descriptor(s) - we
5331 * do not support setting device capacity.
5332 * Existing macros do not recognize long LBA dscriptor,
5333 * hence manual calculation.
5334 */
5335 if (scsipkt->pkt_cdbp[0] == SCMD_MODE_SELECT) {
5336 /* 6-bytes CMD, 4 bytes header */
5337 if (count <= 4)
5338 goto done; /* header only */
5339 len = buf[3] + 4;
5340 } else {
5341 /* 10-bytes CMD, 8 bytes header */
5342 if (count <= 8)
5343 goto done; /* header only */
5344 len = buf[6];
5345 len = (len << 8) + buf[7] + 8;
5346 }
5347 if (len >= count)
5348 goto done; /* header + descriptor(s) only */
5349
5350 pllen -= len; /* remaining data length */
5351
5352 /*
5353 * We may be executing SATA command and want to execute it
5354 * in SYNCH mode, regardless of scsi_pkt setting.
5355 * Save scsi_pkt setting and indicate SYNCH mode
5356 */
5357 if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0 &&
5358 scsipkt->pkt_comp != NULL) {
5359 scsipkt->pkt_flags |= FLAG_NOINTR;
5360 }
5361 spx->txlt_sata_pkt->satapkt_op_mode = SATA_OPMODE_SYNCH;
5362
5363 /*
5364 * len is now the offset to a first mode select page
5365 * Process all pages
5366 */
5367 while (pllen > 0) {
5368 switch ((int)buf[len]) {
5369 case MODEPAGE_CACHING:
5370 /* No support for SP (saving) */
5371 if (scsipkt->pkt_cdbp[1] & 0x01) {
5372 *scsipkt->pkt_scbp = STATUS_CHECK;
5373 sense = sata_arq_sense(spx);
5374 sense->es_key = KEY_ILLEGAL_REQUEST;
5375 sense->es_add_code =
5376 SD_SCSI_ASC_INVALID_FIELD_IN_CDB;
5377 goto done;
5378 }
5379 stat = sata_mode_select_page_8(spx,
5380 (struct mode_cache_scsi3 *)&buf[len],
5381 pllen, &pagelen, &rval, &dmod);
5382 /*
5383 * The pagelen value indicates the number of
5384 * parameter bytes already processed.
5385 * The rval is the return value from
5386 * sata_tran_start().
5387 * The stat indicates the overall status of
5388 * the operation(s).
5389 */
5390 if (stat != SATA_SUCCESS)
5391 /*
5392 * Page processing did not succeed -
5393 * all error info is already set-up,
5394 * just return
5395 */
5396 pllen = 0; /* this breaks the loop */
5397 else {
5398 len += pagelen;
5399 pllen -= pagelen;
5400 }
5401 break;
5402
5403 case MODEPAGE_INFO_EXCPT:
5404 stat = sata_mode_select_page_1c(spx,
5405 (struct mode_info_excpt_page *)&buf[len],
5406 pllen, &pagelen, &rval, &dmod);
5407 /*
5408 * The pagelen value indicates the number of
5409 * parameter bytes already processed.
5410 * The rval is the return value from
5411 * sata_tran_start().
5412 * The stat indicates the overall status of
5413 * the operation(s).
5414 */
5415 if (stat != SATA_SUCCESS)
5416 /*
5417 * Page processing did not succeed -
5418 * all error info is already set-up,
5419 * just return
5420 */
5421 pllen = 0; /* this breaks the loop */
5422 else {
5423 len += pagelen;
5424 pllen -= pagelen;
5425 }
5426 break;
5427
5428 case MODEPAGE_ACOUSTIC_MANAG:
5429 stat = sata_mode_select_page_30(spx,
5430 (struct mode_acoustic_management *)
5431 &buf[len], pllen, &pagelen, &rval, &dmod);
5432 /*
5433 * The pagelen value indicates the number of
5434 * parameter bytes already processed.
5435 * The rval is the return value from
5436 * sata_tran_start().
5437 * The stat indicates the overall status of
5438 * the operation(s).
5439 */
5440 if (stat != SATA_SUCCESS)
5441 /*
5442 * Page processing did not succeed -
5443 * all error info is already set-up,
5444 * just return
5445 */
5446 pllen = 0; /* this breaks the loop */
5447 else {
5448 len += pagelen;
5449 pllen -= pagelen;
5450 }
5451
5452 break;
5453 case MODEPAGE_POWER_COND:
5454 stat = sata_mode_select_page_1a(spx,
5455 (struct mode_info_power_cond *)&buf[len],
5456 pllen, &pagelen, &rval, &dmod);
5457 /*
5458 * The pagelen value indicates the number of
5459 * parameter bytes already processed.
5460 * The rval is the return value from
5461 * sata_tran_start().
5462 * The stat indicates the overall status of
5463 * the operation(s).
5464 */
5465 if (stat != SATA_SUCCESS)
5466 /*
5467 * Page processing did not succeed -
5468 * all error info is already set-up,
5469 * just return
5470 */
5471 pllen = 0; /* this breaks the loop */
5472 else {
5473 len += pagelen;
5474 pllen -= pagelen;
5475 }
5476 break;
5477 default:
5478 *scsipkt->pkt_scbp = STATUS_CHECK;
5479 sense = sata_arq_sense(spx);
5480 sense->es_key = KEY_ILLEGAL_REQUEST;
5481 sense->es_add_code =
5482 SD_SCSI_ASC_INVALID_FIELD_IN_PARAMS_LIST;
5483 goto done;
5484 }
5485 }
5486 }
5487 done:
5488 mutex_exit(cport_mutex);
5489 /*
5490 * If device parameters were modified, fetch and store the new
5491 * Identify Device data. Since port mutex could have been released
5492 * for accessing HBA driver, we need to re-check device existence.
5493 */
5494 if (dmod != 0) {
5495 sata_drive_info_t new_sdinfo, *sdinfo;
5496 int rv = 0;
5497
5498 /*
5499 * Following statement has to be changed if this function is
5500 * used for devices other than SATA hard disks.
5501 */
5502 new_sdinfo.satadrv_type = SATA_DTYPE_ATADISK;
5503
5504 new_sdinfo.satadrv_addr =
5505 spx->txlt_sata_pkt->satapkt_device.satadev_addr;
5506 rv = sata_fetch_device_identify_data(spx->txlt_sata_hba_inst,
5507 &new_sdinfo);
5508
5509 mutex_enter(cport_mutex);
5510 /*
5511 * Since port mutex could have been released when
5512 * accessing HBA driver, we need to re-check that the
5513 * framework still holds the device info structure.
5514 */
5515 sdinfo = sata_get_device_info(spx->txlt_sata_hba_inst,
5516 &spx->txlt_sata_pkt->satapkt_device);
5517 if (sdinfo != NULL) {
5518 /*
5519 * Device still has info structure in the
5520 * sata framework. Copy newly fetched info
5521 */
5522 if (rv == 0) {
5523 sdinfo->satadrv_id = new_sdinfo.satadrv_id;
5524 sata_save_drive_settings(sdinfo);
5525 } else {
5526 /*
5527 * Could not fetch new data - invalidate
5528 * sata_drive_info. That makes device
5529 * unusable.
5530 */
5531 sdinfo->satadrv_type = SATA_DTYPE_UNKNOWN;
5532 sdinfo->satadrv_state = SATA_STATE_UNKNOWN;
5533 }
5534 }
5535 if (rv != 0 || sdinfo == NULL) {
5536 /*
5537 * This changes the overall mode select completion
5538 * reason to a failed one !!!!!
5539 */
5540 *scsipkt->pkt_scbp = STATUS_CHECK;
5541 sense = sata_arq_sense(spx);
5542 scsipkt->pkt_reason = CMD_INCOMPLETE;
5543 rval = TRAN_ACCEPT;
5544 }
5545 mutex_exit(cport_mutex);
5546 }
5547 /* Restore the scsi pkt flags */
5548 scsipkt->pkt_flags &= ~FLAG_NOINTR;
5549 scsipkt->pkt_flags |= nointr_flag;
5550
5551 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst,
5552 "Scsi_pkt completion reason %x\n", scsipkt->pkt_reason);
5553
5554 if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0 &&
5555 scsipkt->pkt_comp != NULL) {
5556 /* scsi callback required */
5557 if (servicing_interrupt()) {
5558 if (taskq_dispatch(SATA_TXLT_TASKQ(spx),
5559 (task_func_t *)spx->txlt_scsi_pkt->pkt_comp,
5560 (void *)spx->txlt_scsi_pkt, TQ_NOSLEEP) == NULL) {
5561 return (TRAN_BUSY);
5562 }
5563 } else if (taskq_dispatch(SATA_TXLT_TASKQ(spx),
5564 (task_func_t *)spx->txlt_scsi_pkt->pkt_comp,
5565 (void *)spx->txlt_scsi_pkt, TQ_SLEEP) == NULL) {
5566 /* Scheduling the callback failed */
5567 return (TRAN_BUSY);
5568 }
5569 }
5570
5571 return (rval);
5572 }
5573
5574 /*
5575 * Translate command: ATA Pass Through
5576 * Incomplete implementation. Only supports No-Data, PIO Data-In, and
5577 * PIO Data-Out protocols. Also supports CK_COND bit.
5578 *
5579 * Mapping of the incoming CDB bytes to the outgoing satacmd bytes is
5580 * described in Table 111 of SAT-2 (Draft 9).
5581 */
5582 static int
5583 sata_txlt_ata_pass_thru(sata_pkt_txlate_t *spx)
5584 {
5585 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt;
5586 sata_cmd_t *scmd = &spx->txlt_sata_pkt->satapkt_cmd;
5587 struct buf *bp = spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp;
5588 int extend;
5589 uint64_t lba;
5590 uint16_t feature, sec_count;
5591 int t_len, synch;
5592 int rval, reason;
5593 kmutex_t *cport_mutex = &(SATA_TXLT_CPORT_MUTEX(spx));
5594
5595 mutex_enter(cport_mutex);
5596
5597 rval = sata_txlt_generic_pkt_info(spx, &reason, 1);
5598 if ((rval != TRAN_ACCEPT) || (reason == CMD_DEV_GONE)) {
5599 mutex_exit(cport_mutex);
5600 return (rval);
5601 }
5602
5603 /* T_DIR bit */
5604 if (scsipkt->pkt_cdbp[2] & SATL_APT_BM_T_DIR)
5605 scmd->satacmd_flags.sata_data_direction = SATA_DIR_READ;
5606 else
5607 scmd->satacmd_flags.sata_data_direction = SATA_DIR_WRITE;
5608
5609 /* MULTIPLE_COUNT field. If non-zero, invalid command (for now). */
5610 if (((scsipkt->pkt_cdbp[1] >> 5) & 0x7) != 0) {
5611 mutex_exit(cport_mutex);
5612 return (sata_txlt_ata_pass_thru_illegal_cmd(spx));
5613 }
5614
5615 /* OFFLINE field. If non-zero, invalid command (for now). */
5616 if (((scsipkt->pkt_cdbp[2] >> 6) & 0x3) != 0) {
5617 mutex_exit(cport_mutex);
5618 return (sata_txlt_ata_pass_thru_illegal_cmd(spx));
5619 }
5620
5621 /* PROTOCOL field */
5622 switch ((scsipkt->pkt_cdbp[1] >> 1) & 0xf) {
5623 case SATL_APT_P_HW_RESET:
5624 case SATL_APT_P_SRST:
5625 case SATL_APT_P_DMA:
5626 case SATL_APT_P_DMA_QUEUED:
5627 case SATL_APT_P_DEV_DIAG:
5628 case SATL_APT_P_DEV_RESET:
5629 case SATL_APT_P_UDMA_IN:
5630 case SATL_APT_P_UDMA_OUT:
5631 case SATL_APT_P_FPDMA:
5632 case SATL_APT_P_RET_RESP:
5633 /* Not yet implemented */
5634 default:
5635 mutex_exit(cport_mutex);
5636 return (sata_txlt_ata_pass_thru_illegal_cmd(spx));
5637
5638 case SATL_APT_P_NON_DATA:
5639 scmd->satacmd_flags.sata_data_direction = SATA_DIR_NODATA_XFER;
5640 break;
5641
5642 case SATL_APT_P_PIO_DATA_IN:
5643 /* If PROTOCOL disagrees with T_DIR, invalid command */
5644 if (scmd->satacmd_flags.sata_data_direction == SATA_DIR_WRITE) {
5645 mutex_exit(cport_mutex);
5646 return (sata_txlt_ata_pass_thru_illegal_cmd(spx));
5647 }
5648
5649 /* if there is a buffer, release its DMA resources */
5650 if ((bp != NULL) && bp->b_un.b_addr && bp->b_bcount) {
5651 sata_scsi_dmafree(NULL, scsipkt);
5652 } else {
5653 /* if there is no buffer, how do you PIO in? */
5654 mutex_exit(cport_mutex);
5655 return (sata_txlt_ata_pass_thru_illegal_cmd(spx));
5656 }
5657
5658 break;
5659
5660 case SATL_APT_P_PIO_DATA_OUT:
5661 /* If PROTOCOL disagrees with T_DIR, invalid command */
5662 if (scmd->satacmd_flags.sata_data_direction == SATA_DIR_READ) {
5663 mutex_exit(cport_mutex);
5664 return (sata_txlt_ata_pass_thru_illegal_cmd(spx));
5665 }
5666
5667 /* if there is a buffer, release its DMA resources */
5668 if ((bp != NULL) && bp->b_un.b_addr && bp->b_bcount) {
5669 sata_scsi_dmafree(NULL, scsipkt);
5670 } else {
5671 /* if there is no buffer, how do you PIO out? */
5672 mutex_exit(cport_mutex);
5673 return (sata_txlt_ata_pass_thru_illegal_cmd(spx));
5674 }
5675
5676 break;
5677 }
5678
5679 /* Parse the ATA cmd fields, transfer some straight to the satacmd */
5680 switch ((uint_t)scsipkt->pkt_cdbp[0]) {
5681 case SPC3_CMD_ATA_COMMAND_PASS_THROUGH12:
5682 feature = scsipkt->pkt_cdbp[3];
5683
5684 sec_count = scsipkt->pkt_cdbp[4];
5685
5686 lba = scsipkt->pkt_cdbp[8] & 0xf;
5687 lba = (lba << 8) | scsipkt->pkt_cdbp[7];
5688 lba = (lba << 8) | scsipkt->pkt_cdbp[6];
5689 lba = (lba << 8) | scsipkt->pkt_cdbp[5];
5690
5691 scmd->satacmd_device_reg = scsipkt->pkt_cdbp[13] & 0xf0;
5692 scmd->satacmd_cmd_reg = scsipkt->pkt_cdbp[9];
5693
5694 break;
5695
5696 case SPC3_CMD_ATA_COMMAND_PASS_THROUGH16:
5697 if (scsipkt->pkt_cdbp[1] & SATL_APT_BM_EXTEND) {
5698 extend = 1;
5699
5700 feature = scsipkt->pkt_cdbp[3];
5701 feature = (feature << 8) | scsipkt->pkt_cdbp[4];
5702
5703 sec_count = scsipkt->pkt_cdbp[5];
5704 sec_count = (sec_count << 8) | scsipkt->pkt_cdbp[6];
5705
5706 lba = scsipkt->pkt_cdbp[11];
5707 lba = (lba << 8) | scsipkt->pkt_cdbp[12];
5708 lba = (lba << 8) | scsipkt->pkt_cdbp[9];
5709 lba = (lba << 8) | scsipkt->pkt_cdbp[10];
5710 lba = (lba << 8) | scsipkt->pkt_cdbp[7];
5711 lba = (lba << 8) | scsipkt->pkt_cdbp[8];
5712
5713 scmd->satacmd_device_reg = scsipkt->pkt_cdbp[13];
5714 scmd->satacmd_cmd_reg = scsipkt->pkt_cdbp[14];
5715 } else {
5716 feature = scsipkt->pkt_cdbp[3];
5717
5718 sec_count = scsipkt->pkt_cdbp[5];
5719
5720 lba = scsipkt->pkt_cdbp[13] & 0xf;
5721 lba = (lba << 8) | scsipkt->pkt_cdbp[12];
5722 lba = (lba << 8) | scsipkt->pkt_cdbp[10];
5723 lba = (lba << 8) | scsipkt->pkt_cdbp[8];
5724
5725 scmd->satacmd_device_reg = scsipkt->pkt_cdbp[13] &
5726 0xf0;
5727 scmd->satacmd_cmd_reg = scsipkt->pkt_cdbp[14];
5728 }
5729
5730 break;
5731 }
5732
5733 /* CK_COND bit */
5734 if (scsipkt->pkt_cdbp[2] & SATL_APT_BM_CK_COND) {
5735 if (extend) {
5736 scmd->satacmd_flags.sata_copy_out_sec_count_msb = 1;
5737 scmd->satacmd_flags.sata_copy_out_lba_low_msb = 1;
5738 scmd->satacmd_flags.sata_copy_out_lba_mid_msb = 1;
5739 scmd->satacmd_flags.sata_copy_out_lba_high_msb = 1;
5740 }
5741
5742 scmd->satacmd_flags.sata_copy_out_sec_count_lsb = 1;
5743 scmd->satacmd_flags.sata_copy_out_lba_low_lsb = 1;
5744 scmd->satacmd_flags.sata_copy_out_lba_mid_lsb = 1;
5745 scmd->satacmd_flags.sata_copy_out_lba_high_lsb = 1;
5746 scmd->satacmd_flags.sata_copy_out_device_reg = 1;
5747 scmd->satacmd_flags.sata_copy_out_error_reg = 1;
5748 }
5749
5750 /* Transfer remaining parsed ATA cmd values to the satacmd */
5751 if (extend) {
5752 scmd->satacmd_addr_type = ATA_ADDR_LBA48;
5753
5754 scmd->satacmd_features_reg_ext = (feature >> 8) & 0xff;
5755 scmd->satacmd_sec_count_msb = (sec_count >> 8) & 0xff;
5756 scmd->satacmd_lba_low_msb = (lba >> 8) & 0xff;
5757 scmd->satacmd_lba_mid_msb = (lba >> 8) & 0xff;
5758 scmd->satacmd_lba_high_msb = lba >> 40;
5759 } else {
5760 scmd->satacmd_addr_type = ATA_ADDR_LBA28;
5761
5762 scmd->satacmd_features_reg_ext = 0;
5763 scmd->satacmd_sec_count_msb = 0;
5764 scmd->satacmd_lba_low_msb = 0;
5765 scmd->satacmd_lba_mid_msb = 0;
5766 scmd->satacmd_lba_high_msb = 0;
5767 }
5768
5769 scmd->satacmd_features_reg = feature & 0xff;
5770 scmd->satacmd_sec_count_lsb = sec_count & 0xff;
5771 scmd->satacmd_lba_low_lsb = lba & 0xff;
5772 scmd->satacmd_lba_mid_lsb = (lba >> 8) & 0xff;
5773 scmd->satacmd_lba_high_lsb = (lba >> 16) & 0xff;
5774
5775 /* Determine transfer length */
5776 switch (scsipkt->pkt_cdbp[2] & 0x3) { /* T_LENGTH field */
5777 case 1:
5778 t_len = feature;
5779 break;
5780 case 2:
5781 t_len = sec_count;
5782 break;
5783 default:
5784 t_len = 0;
5785 break;
5786 }
5787
5788 /* Adjust transfer length for the Byte Block bit */
5789 if ((scsipkt->pkt_cdbp[2] >> 2) & 1)
5790 t_len *= SATA_DISK_SECTOR_SIZE;
5791
5792 /* Start processing command */
5793 if (!(spx->txlt_sata_pkt->satapkt_op_mode & SATA_OPMODE_SYNCH)) {
5794 spx->txlt_sata_pkt->satapkt_comp = sata_txlt_apt_completion;
5795 synch = FALSE;
5796 } else {
5797 synch = TRUE;
5798 }
5799
5800 if (sata_hba_start(spx, &rval) != 0) {
5801 mutex_exit(cport_mutex);
5802 return (rval);
5803 }
5804
5805 mutex_exit(cport_mutex);
5806
5807 if (synch) {
5808 sata_txlt_apt_completion(spx->txlt_sata_pkt);
5809 }
5810
5811 return (TRAN_ACCEPT);
5812 }
5813
5814 /*
5815 * Translate command: Log Sense
5816 */
5817 static int
5818 sata_txlt_log_sense(sata_pkt_txlate_t *spx)
5819 {
5820 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt;
5821 struct buf *bp = spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp;
5822 sata_drive_info_t *sdinfo;
5823 struct scsi_extended_sense *sense;
5824 int len, count, alc_len;
5825 int pc; /* Page Control code */
5826 int page_code; /* Page code */
5827 uint8_t *buf; /* log sense buffer */
5828 int rval, reason;
5829 #define MAX_LOG_SENSE_PAGE_SIZE 512
5830 kmutex_t *cport_mutex = &(SATA_TXLT_CPORT_MUTEX(spx));
5831
5832 SATADBG2(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst,
5833 "sata_txlt_log_sense, pc 0x%x, page code 0x%x\n",
5834 spx->txlt_scsi_pkt->pkt_cdbp[2] >> 6,
5835 spx->txlt_scsi_pkt->pkt_cdbp[2] & 0x3f);
5836
5837 if (servicing_interrupt()) {
5838 buf = kmem_zalloc(MAX_LOG_SENSE_PAGE_SIZE, KM_NOSLEEP);
5839 if (buf == NULL) {
5840 return (TRAN_BUSY);
5841 }
5842 } else {
5843 buf = kmem_zalloc(MAX_LOG_SENSE_PAGE_SIZE, KM_SLEEP);
5844 }
5845
5846 mutex_enter(cport_mutex);
5847
5848 if (((rval = sata_txlt_generic_pkt_info(spx, &reason, 1)) !=
5849 TRAN_ACCEPT) || (reason == CMD_DEV_GONE)) {
5850 mutex_exit(cport_mutex);
5851 kmem_free(buf, MAX_LOG_SENSE_PAGE_SIZE);
5852 return (rval);
5853 }
5854
5855 scsipkt->pkt_reason = CMD_CMPLT;
5856 scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET |
5857 STATE_SENT_CMD | STATE_GOT_STATUS;
5858
5859 pc = scsipkt->pkt_cdbp[2] >> 6;
5860 page_code = scsipkt->pkt_cdbp[2] & 0x3f;
5861
5862 /* Reject not supported request for all but cumulative values */
5863 switch (pc) {
5864 case PC_CUMULATIVE_VALUES:
5865 break;
5866 default:
5867 *scsipkt->pkt_scbp = STATUS_CHECK;
5868 sense = sata_arq_sense(spx);
5869 sense->es_key = KEY_ILLEGAL_REQUEST;
5870 sense->es_add_code = SD_SCSI_ASC_INVALID_FIELD_IN_CDB;
5871 goto done;
5872 }
5873
5874 switch (page_code) {
5875 case PAGE_CODE_GET_SUPPORTED_LOG_PAGES:
5876 case PAGE_CODE_SELF_TEST_RESULTS:
5877 case PAGE_CODE_INFORMATION_EXCEPTIONS:
5878 case PAGE_CODE_SMART_READ_DATA:
5879 case PAGE_CODE_START_STOP_CYCLE_COUNTER:
5880 break;
5881 default:
5882 *scsipkt->pkt_scbp = STATUS_CHECK;
5883 sense = sata_arq_sense(spx);
5884 sense->es_key = KEY_ILLEGAL_REQUEST;
5885 sense->es_add_code = SD_SCSI_ASC_INVALID_FIELD_IN_CDB;
5886 goto done;
5887 }
5888
5889 if (bp != NULL && bp->b_un.b_addr && bp->b_bcount) {
5890 /*
5891 * Because log sense uses local buffers for data retrieval from
5892 * the devices and sets the data programatically in the
5893 * original specified buffer, release preallocated DMA
5894 * resources before storing data in the original buffer,
5895 * so no unwanted DMA sync would take place.
5896 */
5897 sata_id_t *sata_id;
5898
5899 sata_scsi_dmafree(NULL, scsipkt);
5900
5901 len = 0;
5902
5903 /* Build log parameter header */
5904 buf[len++] = page_code; /* page code as in the CDB */
5905 buf[len++] = 0; /* reserved */
5906 buf[len++] = 0; /* Zero out page length for now (MSB) */
5907 buf[len++] = 0; /* (LSB) */
5908
5909 sdinfo = sata_get_device_info(
5910 spx->txlt_sata_hba_inst,
5911 &spx->txlt_sata_pkt->satapkt_device);
5912
5913 /*
5914 * Add requested pages.
5915 */
5916 switch (page_code) {
5917 case PAGE_CODE_GET_SUPPORTED_LOG_PAGES:
5918 len = sata_build_lsense_page_0(sdinfo, buf + len);
5919 break;
5920 case PAGE_CODE_SELF_TEST_RESULTS:
5921 sata_id = &sdinfo->satadrv_id;
5922 if ((! (sata_id->ai_cmdset84 &
5923 SATA_SMART_SELF_TEST_SUPPORTED)) ||
5924 (! (sata_id->ai_features87 &
5925 SATA_SMART_SELF_TEST_SUPPORTED))) {
5926 *scsipkt->pkt_scbp = STATUS_CHECK;
5927 sense = sata_arq_sense(spx);
5928 sense->es_key = KEY_ILLEGAL_REQUEST;
5929 sense->es_add_code =
5930 SD_SCSI_ASC_INVALID_FIELD_IN_CDB;
5931
5932 goto done;
5933 }
5934 len = sata_build_lsense_page_10(sdinfo, buf + len,
5935 spx->txlt_sata_hba_inst);
5936 break;
5937 case PAGE_CODE_INFORMATION_EXCEPTIONS:
5938 sata_id = &sdinfo->satadrv_id;
5939 if (! (sata_id->ai_cmdset82 & SATA_SMART_SUPPORTED)) {
5940 *scsipkt->pkt_scbp = STATUS_CHECK;
5941 sense = sata_arq_sense(spx);
5942 sense->es_key = KEY_ILLEGAL_REQUEST;
5943 sense->es_add_code =
5944 SD_SCSI_ASC_INVALID_FIELD_IN_CDB;
5945
5946 goto done;
5947 }
5948 if (! (sata_id->ai_features85 & SATA_SMART_ENABLED)) {
5949 *scsipkt->pkt_scbp = STATUS_CHECK;
5950 sense = sata_arq_sense(spx);
5951 sense->es_key = KEY_ABORTED_COMMAND;
5952 sense->es_add_code =
5953 SCSI_ASC_ATA_DEV_FEAT_NOT_ENABLED;
5954 sense->es_qual_code =
5955 SCSI_ASCQ_ATA_DEV_FEAT_NOT_ENABLED;
5956
5957 goto done;
5958 }
5959
5960 len = sata_build_lsense_page_2f(sdinfo, buf + len,
5961 spx->txlt_sata_hba_inst);
5962 break;
5963 case PAGE_CODE_SMART_READ_DATA:
5964 sata_id = &sdinfo->satadrv_id;
5965 if (! (sata_id->ai_cmdset82 & SATA_SMART_SUPPORTED)) {
5966 *scsipkt->pkt_scbp = STATUS_CHECK;
5967 sense = sata_arq_sense(spx);
5968 sense->es_key = KEY_ILLEGAL_REQUEST;
5969 sense->es_add_code =
5970 SD_SCSI_ASC_INVALID_FIELD_IN_CDB;
5971
5972 goto done;
5973 }
5974 if (! (sata_id->ai_features85 & SATA_SMART_ENABLED)) {
5975 *scsipkt->pkt_scbp = STATUS_CHECK;
5976 sense = sata_arq_sense(spx);
5977 sense->es_key = KEY_ABORTED_COMMAND;
5978 sense->es_add_code =
5979 SCSI_ASC_ATA_DEV_FEAT_NOT_ENABLED;
5980 sense->es_qual_code =
5981 SCSI_ASCQ_ATA_DEV_FEAT_NOT_ENABLED;
5982
5983 goto done;
5984 }
5985
5986 /* This page doesn't include a page header */
5987 len = sata_build_lsense_page_30(sdinfo, buf,
5988 spx->txlt_sata_hba_inst);
5989 goto no_header;
5990 case PAGE_CODE_START_STOP_CYCLE_COUNTER:
5991 sata_id = &sdinfo->satadrv_id;
5992 if (! (sata_id->ai_cmdset82 & SATA_SMART_SUPPORTED)) {
5993 *scsipkt->pkt_scbp = STATUS_CHECK;
5994 sense = sata_arq_sense(spx);
5995 sense->es_key = KEY_ILLEGAL_REQUEST;
5996 sense->es_add_code =
5997 SD_SCSI_ASC_INVALID_FIELD_IN_CDB;
5998
5999 goto done;
6000 }
6001 if (! (sata_id->ai_features85 & SATA_SMART_ENABLED)) {
6002 *scsipkt->pkt_scbp = STATUS_CHECK;
6003 sense = sata_arq_sense(spx);
6004 sense->es_key = KEY_ABORTED_COMMAND;
6005 sense->es_add_code =
6006 SCSI_ASC_ATA_DEV_FEAT_NOT_ENABLED;
6007 sense->es_qual_code =
6008 SCSI_ASCQ_ATA_DEV_FEAT_NOT_ENABLED;
6009
6010 goto done;
6011 }
6012 len = sata_build_lsense_page_0e(sdinfo, buf, spx);
6013 goto no_header;
6014 default:
6015 /* Invalid request */
6016 *scsipkt->pkt_scbp = STATUS_CHECK;
6017 sense = sata_arq_sense(spx);
6018 sense->es_key = KEY_ILLEGAL_REQUEST;
6019 sense->es_add_code = SD_SCSI_ASC_INVALID_FIELD_IN_CDB;
6020 goto done;
6021 }
6022
6023 /* set parameter log sense data length */
6024 buf[2] = len >> 8; /* log sense length (MSB) */
6025 buf[3] = len & 0xff; /* log sense length (LSB) */
6026
6027 len += SCSI_LOG_PAGE_HDR_LEN;
6028 ASSERT(len <= MAX_LOG_SENSE_PAGE_SIZE);
6029
6030 no_header:
6031 /* Check allocation length */
6032 alc_len = scsipkt->pkt_cdbp[7];
6033 alc_len = (len << 8) | scsipkt->pkt_cdbp[8];
6034
6035 /*
6036 * We do not check for possible parameters truncation
6037 * (alc_len < len) assuming that the target driver works
6038 * correctly. Just avoiding overrun.
6039 * Copy no more than requested and possible, buffer-wise.
6040 */
6041 count = MIN(alc_len, len);
6042 count = MIN(bp->b_bcount, count);
6043 bcopy(buf, bp->b_un.b_addr, count);
6044
6045 scsipkt->pkt_state |= STATE_XFERRED_DATA;
6046 scsipkt->pkt_resid = alc_len > count ? alc_len - count : 0;
6047 }
6048 *scsipkt->pkt_scbp = STATUS_GOOD;
6049 done:
6050 mutex_exit(cport_mutex);
6051 (void) kmem_free(buf, MAX_LOG_SENSE_PAGE_SIZE);
6052
6053 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst,
6054 "Scsi_pkt completion reason %x\n", scsipkt->pkt_reason);
6055
6056 if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0 &&
6057 scsipkt->pkt_comp != NULL) {
6058 /* scsi callback required */
6059 if (servicing_interrupt()) {
6060 if (taskq_dispatch(SATA_TXLT_TASKQ(spx),
6061 (task_func_t *)spx->txlt_scsi_pkt->pkt_comp,
6062 (void *)spx->txlt_scsi_pkt, TQ_NOSLEEP) == NULL) {
6063 return (TRAN_BUSY);
6064 }
6065 } else if (taskq_dispatch(SATA_TXLT_TASKQ(spx),
6066 (task_func_t *)spx->txlt_scsi_pkt->pkt_comp,
6067 (void *)spx->txlt_scsi_pkt, TQ_SLEEP) == NULL) {
6068 /* Scheduling the callback failed */
6069 return (TRAN_BUSY);
6070 }
6071 }
6072
6073 return (TRAN_ACCEPT);
6074 }
6075
6076 /*
6077 * Translate command: Log Select
6078 * Not implemented at this time - returns invalid command response.
6079 */
6080 static int
6081 sata_txlt_log_select(sata_pkt_txlate_t *spx)
6082 {
6083 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst,
6084 "sata_txlt_log_select\n", NULL);
6085
6086 return (sata_txlt_invalid_command(spx));
6087 }
6088
6089
6090 /*
6091 * Translate command: Read (various types).
6092 * Translated into appropriate type of ATA READ command
6093 * for SATA hard disks.
6094 * Both the device capabilities and requested operation mode are
6095 * considered.
6096 *
6097 * Following scsi cdb fields are ignored:
6098 * rdprotect, dpo, fua, fua_nv, group_number.
6099 *
6100 * If SATA_ENABLE_QUEUING flag is set (in the global SATA HBA framework
6101 * enable variable sata_func_enable), the capability of the controller and
6102 * capability of a device are checked and if both support queueing, read
6103 * request will be translated to READ_DMA_QUEUEING or READ_DMA_QUEUEING_EXT
6104 * command rather than plain READ_XXX command.
6105 * If SATA_ENABLE_NCQ flag is set in addition to SATA_ENABLE_QUEUING flag and
6106 * both the controller and device suport such functionality, the read
6107 * request will be translated to READ_FPDMA_QUEUED command.
6108 * In both cases the maximum queue depth is derived as minimum of:
6109 * HBA capability,device capability and sata_max_queue_depth variable setting.
6110 * The value passed to HBA driver is decremented by 1, because only 5 bits are
6111 * used to pass max queue depth value, and the maximum possible queue depth
6112 * is 32.
6113 *
6114 * Returns TRAN_ACCEPT or code returned by sata_hba_start() and
6115 * appropriate values in scsi_pkt fields.
6116 */
6117 static int
6118 sata_txlt_read(sata_pkt_txlate_t *spx)
6119 {
6120 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt;
6121 sata_cmd_t *scmd = &spx->txlt_sata_pkt->satapkt_cmd;
6122 sata_drive_info_t *sdinfo;
6123 sata_hba_inst_t *shi = SATA_TXLT_HBA_INST(spx);
6124 kmutex_t *cport_mutex = &(SATA_TXLT_CPORT_MUTEX(spx));
6125 uint16_t sec_count;
6126 uint64_t lba;
6127 int rval, reason;
6128 int synch;
6129
6130 mutex_enter(cport_mutex);
6131
6132 if (((rval = sata_txlt_generic_pkt_info(spx, &reason, 0)) !=
6133 TRAN_ACCEPT) || (reason == CMD_DEV_GONE)) {
6134 mutex_exit(cport_mutex);
6135 return (rval);
6136 }
6137
6138 sdinfo = sata_get_device_info(spx->txlt_sata_hba_inst,
6139 &spx->txlt_sata_pkt->satapkt_device);
6140
6141 scmd->satacmd_flags.sata_data_direction = SATA_DIR_READ;
6142 /*
6143 * Extract LBA and sector count from scsi CDB.
6144 */
6145 switch ((uint_t)scsipkt->pkt_cdbp[0]) {
6146 case SCMD_READ:
6147 /* 6-byte scsi read cmd : 0x08 */
6148 lba = (scsipkt->pkt_cdbp[1] & 0x1f);
6149 lba = (lba << 8) | scsipkt->pkt_cdbp[2];
6150 lba = (lba << 8) | scsipkt->pkt_cdbp[3];
6151 sec_count = scsipkt->pkt_cdbp[4];
6152 /* sec_count 0 will be interpreted as 256 by a device */
6153 break;
6154 case SCMD_READ_G1:
6155 /* 10-bytes scsi read command : 0x28 */
6156 lba = scsipkt->pkt_cdbp[2];
6157 lba = (lba << 8) | scsipkt->pkt_cdbp[3];
6158 lba = (lba << 8) | scsipkt->pkt_cdbp[4];
6159 lba = (lba << 8) | scsipkt->pkt_cdbp[5];
6160 sec_count = scsipkt->pkt_cdbp[7];
6161 sec_count = (sec_count << 8) | scsipkt->pkt_cdbp[8];
6162 break;
6163 case SCMD_READ_G5:
6164 /* 12-bytes scsi read command : 0xA8 */
6165 lba = scsipkt->pkt_cdbp[2];
6166 lba = (lba << 8) | scsipkt->pkt_cdbp[3];
6167 lba = (lba << 8) | scsipkt->pkt_cdbp[4];
6168 lba = (lba << 8) | scsipkt->pkt_cdbp[5];
6169 sec_count = scsipkt->pkt_cdbp[6];
6170 sec_count = (sec_count << 8) | scsipkt->pkt_cdbp[7];
6171 sec_count = (sec_count << 8) | scsipkt->pkt_cdbp[8];
6172 sec_count = (sec_count << 8) | scsipkt->pkt_cdbp[9];
6173 break;
6174 case SCMD_READ_G4:
6175 /* 16-bytes scsi read command : 0x88 */
6176 lba = scsipkt->pkt_cdbp[2];
6177 lba = (lba << 8) | scsipkt->pkt_cdbp[3];
6178 lba = (lba << 8) | scsipkt->pkt_cdbp[4];
6179 lba = (lba << 8) | scsipkt->pkt_cdbp[5];
6180 lba = (lba << 8) | scsipkt->pkt_cdbp[6];
6181 lba = (lba << 8) | scsipkt->pkt_cdbp[7];
6182 lba = (lba << 8) | scsipkt->pkt_cdbp[8];
6183 lba = (lba << 8) | scsipkt->pkt_cdbp[9];
6184 sec_count = scsipkt->pkt_cdbp[10];
6185 sec_count = (sec_count << 8) | scsipkt->pkt_cdbp[11];
6186 sec_count = (sec_count << 8) | scsipkt->pkt_cdbp[12];
6187 sec_count = (sec_count << 8) | scsipkt->pkt_cdbp[13];
6188 break;
6189 default:
6190 /* Unsupported command */
6191 mutex_exit(cport_mutex);
6192 return (sata_txlt_invalid_command(spx));
6193 }
6194
6195 /*
6196 * Check if specified address exceeds device capacity
6197 */
6198 if ((lba >= sdinfo->satadrv_capacity) ||
6199 ((lba + sec_count) > sdinfo->satadrv_capacity)) {
6200 /* LBA out of range */
6201 mutex_exit(cport_mutex);
6202 return (sata_txlt_lba_out_of_range(spx));
6203 }
6204
6205 /*
6206 * For zero-length transfer, emulate good completion of the command
6207 * (reasons for rejecting the command were already checked).
6208 * No DMA resources were allocated.
6209 */
6210 if (spx->txlt_dma_cookie_list == NULL) {
6211 mutex_exit(cport_mutex);
6212 return (sata_emul_rw_completion(spx));
6213 }
6214
6215 /*
6216 * Build cmd block depending on the device capability and
6217 * requested operation mode.
6218 * Do not bother with non-dma mode - we are working only with
6219 * devices supporting DMA.
6220 */
6221 scmd->satacmd_addr_type = ATA_ADDR_LBA;
6222 scmd->satacmd_device_reg = SATA_ADH_LBA;
6223 scmd->satacmd_cmd_reg = SATAC_READ_DMA;
6224 if (sdinfo->satadrv_features_support & SATA_DEV_F_LBA48) {
6225 scmd->satacmd_addr_type = ATA_ADDR_LBA48;
6226 scmd->satacmd_cmd_reg = SATAC_READ_DMA_EXT;
6227 scmd->satacmd_sec_count_msb = sec_count >> 8;
6228 #ifndef __lock_lint
6229 scmd->satacmd_lba_low_msb = (lba >> 24) & 0xff;
6230 scmd->satacmd_lba_mid_msb = (lba >> 32) & 0xff;
6231 scmd->satacmd_lba_high_msb = lba >> 40;
6232 #endif
6233 } else if (sdinfo->satadrv_features_support & SATA_DEV_F_LBA28) {
6234 scmd->satacmd_addr_type = ATA_ADDR_LBA28;
6235 scmd->satacmd_device_reg = SATA_ADH_LBA | ((lba >> 24) & 0xf);
6236 }
6237 scmd->satacmd_sec_count_lsb = sec_count & 0xff;
6238 scmd->satacmd_lba_low_lsb = lba & 0xff;
6239 scmd->satacmd_lba_mid_lsb = (lba >> 8) & 0xff;
6240 scmd->satacmd_lba_high_lsb = (lba >> 16) & 0xff;
6241 scmd->satacmd_features_reg = 0;
6242 scmd->satacmd_status_reg = 0;
6243 scmd->satacmd_error_reg = 0;
6244
6245 /*
6246 * Check if queueing commands should be used and switch
6247 * to appropriate command if possible
6248 */
6249 if (sata_func_enable & SATA_ENABLE_QUEUING) {
6250 boolean_t using_queuing;
6251
6252 /* Queuing supported by controller and device? */
6253 if ((sata_func_enable & SATA_ENABLE_NCQ) &&
6254 (sdinfo->satadrv_features_support &
6255 SATA_DEV_F_NCQ) &&
6256 (SATA_FEATURES(spx->txlt_sata_hba_inst) &
6257 SATA_CTLF_NCQ)) {
6258 using_queuing = B_TRUE;
6259
6260 /* NCQ supported - use FPDMA READ */
6261 scmd->satacmd_cmd_reg =
6262 SATAC_READ_FPDMA_QUEUED;
6263 scmd->satacmd_features_reg_ext =
6264 scmd->satacmd_sec_count_msb;
6265 scmd->satacmd_sec_count_msb = 0;
6266 } else if ((sdinfo->satadrv_features_support &
6267 SATA_DEV_F_TCQ) &&
6268 (SATA_FEATURES(spx->txlt_sata_hba_inst) &
6269 SATA_CTLF_QCMD)) {
6270 using_queuing = B_TRUE;
6271
6272 /* Legacy queueing */
6273 if (sdinfo->satadrv_features_support &
6274 SATA_DEV_F_LBA48) {
6275 scmd->satacmd_cmd_reg =
6276 SATAC_READ_DMA_QUEUED_EXT;
6277 scmd->satacmd_features_reg_ext =
6278 scmd->satacmd_sec_count_msb;
6279 scmd->satacmd_sec_count_msb = 0;
6280 } else {
6281 scmd->satacmd_cmd_reg =
6282 SATAC_READ_DMA_QUEUED;
6283 }
6284 } else /* NCQ nor legacy queuing not supported */
6285 using_queuing = B_FALSE;
6286
6287 /*
6288 * If queuing, the sector count goes in the features register
6289 * and the secount count will contain the tag.
6290 */
6291 if (using_queuing) {
6292 scmd->satacmd_features_reg =
6293 scmd->satacmd_sec_count_lsb;
6294 scmd->satacmd_sec_count_lsb = 0;
6295 scmd->satacmd_flags.sata_queued = B_TRUE;
6296
6297 /* Set-up maximum queue depth */
6298 scmd->satacmd_flags.sata_max_queue_depth =
6299 sdinfo->satadrv_max_queue_depth - 1;
6300 } else if (sdinfo->satadrv_features_enabled &
6301 SATA_DEV_F_E_UNTAGGED_QING) {
6302 /*
6303 * Although NCQ/TCQ is not enabled, untagged queuing
6304 * may be still used.
6305 * Set-up the maximum untagged queue depth.
6306 * Use controller's queue depth from sata_hba_tran.
6307 * SATA HBA drivers may ignore this value and rely on
6308 * the internal limits.For drivers that do not
6309 * ignore untaged queue depth, limit the value to
6310 * SATA_MAX_QUEUE_DEPTH (32), as this is the
6311 * largest value that can be passed via
6312 * satacmd_flags.sata_max_queue_depth.
6313 */
6314 scmd->satacmd_flags.sata_max_queue_depth =
6315 SATA_QDEPTH(shi) <= SATA_MAX_QUEUE_DEPTH ?
6316 SATA_QDEPTH(shi) - 1: SATA_MAX_QUEUE_DEPTH - 1;
6317
6318 } else {
6319 scmd->satacmd_flags.sata_max_queue_depth = 0;
6320 }
6321 } else
6322 scmd->satacmd_flags.sata_max_queue_depth = 0;
6323
6324 SATADBG3(SATA_DBG_HBA_IF, spx->txlt_sata_hba_inst,
6325 "sata_txlt_read cmd 0x%2x, lba %llx, sec count %x\n",
6326 scmd->satacmd_cmd_reg, lba, sec_count);
6327
6328 if (!(spx->txlt_sata_pkt->satapkt_op_mode & SATA_OPMODE_SYNCH)) {
6329 /* Need callback function */
6330 spx->txlt_sata_pkt->satapkt_comp = sata_txlt_rw_completion;
6331 synch = FALSE;
6332 } else
6333 synch = TRUE;
6334
6335 /* Transfer command to HBA */
6336 if (sata_hba_start(spx, &rval) != 0) {
6337 /* Pkt not accepted for execution */
6338 mutex_exit(cport_mutex);
6339 return (rval);
6340 }
6341 mutex_exit(cport_mutex);
6342 /*
6343 * If execution is non-synchronous,
6344 * a callback function will handle potential errors, translate
6345 * the response and will do a callback to a target driver.
6346 * If it was synchronous, check execution status using the same
6347 * framework callback.
6348 */
6349 if (synch) {
6350 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst,
6351 "synchronous execution status %x\n",
6352 spx->txlt_sata_pkt->satapkt_reason);
6353 sata_txlt_rw_completion(spx->txlt_sata_pkt);
6354 }
6355 return (TRAN_ACCEPT);
6356 }
6357
6358
6359 /*
6360 * SATA translate command: Write (various types)
6361 * Translated into appropriate type of ATA WRITE command
6362 * for SATA hard disks.
6363 * Both the device capabilities and requested operation mode are
6364 * considered.
6365 *
6366 * Following scsi cdb fields are ignored:
6367 * rwprotect, dpo, fua, fua_nv, group_number.
6368 *
6369 * If SATA_ENABLE_QUEUING flag is set (in the global SATA HBA framework
6370 * enable variable sata_func_enable), the capability of the controller and
6371 * capability of a device are checked and if both support queueing, write
6372 * request will be translated to WRITE_DMA_QUEUEING or WRITE_DMA_QUEUEING_EXT
6373 * command rather than plain WRITE_XXX command.
6374 * If SATA_ENABLE_NCQ flag is set in addition to SATA_ENABLE_QUEUING flag and
6375 * both the controller and device suport such functionality, the write
6376 * request will be translated to WRITE_FPDMA_QUEUED command.
6377 * In both cases the maximum queue depth is derived as minimum of:
6378 * HBA capability,device capability and sata_max_queue_depth variable setting.
6379 * The value passed to HBA driver is decremented by 1, because only 5 bits are
6380 * used to pass max queue depth value, and the maximum possible queue depth
6381 * is 32.
6382 *
6383 * Returns TRAN_ACCEPT or code returned by sata_hba_start() and
6384 * appropriate values in scsi_pkt fields.
6385 */
6386 static int
6387 sata_txlt_write(sata_pkt_txlate_t *spx)
6388 {
6389 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt;
6390 sata_cmd_t *scmd = &spx->txlt_sata_pkt->satapkt_cmd;
6391 sata_drive_info_t *sdinfo;
6392 sata_hba_inst_t *shi = SATA_TXLT_HBA_INST(spx);
6393 uint16_t sec_count;
6394 uint64_t lba;
6395 int rval, reason;
6396 int synch;
6397 kmutex_t *cport_mutex = &(SATA_TXLT_CPORT_MUTEX(spx));
6398
6399 mutex_enter(cport_mutex);
6400
6401 if (((rval = sata_txlt_generic_pkt_info(spx, &reason, 0)) !=
6402 TRAN_ACCEPT) || (reason == CMD_DEV_GONE)) {
6403 mutex_exit(cport_mutex);
6404 return (rval);
6405 }
6406
6407 sdinfo = sata_get_device_info(spx->txlt_sata_hba_inst,
6408 &spx->txlt_sata_pkt->satapkt_device);
6409
6410 scmd->satacmd_flags.sata_data_direction = SATA_DIR_WRITE;
6411 /*
6412 * Extract LBA and sector count from scsi CDB
6413 */
6414 switch ((uint_t)scsipkt->pkt_cdbp[0]) {
6415 case SCMD_WRITE:
6416 /* 6-byte scsi read cmd : 0x0A */
6417 lba = (scsipkt->pkt_cdbp[1] & 0x1f);
6418 lba = (lba << 8) | scsipkt->pkt_cdbp[2];
6419 lba = (lba << 8) | scsipkt->pkt_cdbp[3];
6420 sec_count = scsipkt->pkt_cdbp[4];
6421 /* sec_count 0 will be interpreted as 256 by a device */
6422 break;
6423 case SCMD_WRITE_G1:
6424 /* 10-bytes scsi write command : 0x2A */
6425 lba = scsipkt->pkt_cdbp[2];
6426 lba = (lba << 8) | scsipkt->pkt_cdbp[3];
6427 lba = (lba << 8) | scsipkt->pkt_cdbp[4];
6428 lba = (lba << 8) | scsipkt->pkt_cdbp[5];
6429 sec_count = scsipkt->pkt_cdbp[7];
6430 sec_count = (sec_count << 8) | scsipkt->pkt_cdbp[8];
6431 break;
6432 case SCMD_WRITE_G5:
6433 /* 12-bytes scsi read command : 0xAA */
6434 lba = scsipkt->pkt_cdbp[2];
6435 lba = (lba << 8) | scsipkt->pkt_cdbp[3];
6436 lba = (lba << 8) | scsipkt->pkt_cdbp[4];
6437 lba = (lba << 8) | scsipkt->pkt_cdbp[5];
6438 sec_count = scsipkt->pkt_cdbp[6];
6439 sec_count = (sec_count << 8) | scsipkt->pkt_cdbp[7];
6440 sec_count = (sec_count << 8) | scsipkt->pkt_cdbp[8];
6441 sec_count = (sec_count << 8) | scsipkt->pkt_cdbp[9];
6442 break;
6443 case SCMD_WRITE_G4:
6444 /* 16-bytes scsi write command : 0x8A */
6445 lba = scsipkt->pkt_cdbp[2];
6446 lba = (lba << 8) | scsipkt->pkt_cdbp[3];
6447 lba = (lba << 8) | scsipkt->pkt_cdbp[4];
6448 lba = (lba << 8) | scsipkt->pkt_cdbp[5];
6449 lba = (lba << 8) | scsipkt->pkt_cdbp[6];
6450 lba = (lba << 8) | scsipkt->pkt_cdbp[7];
6451 lba = (lba << 8) | scsipkt->pkt_cdbp[8];
6452 lba = (lba << 8) | scsipkt->pkt_cdbp[9];
6453 sec_count = scsipkt->pkt_cdbp[10];
6454 sec_count = (sec_count << 8) | scsipkt->pkt_cdbp[11];
6455 sec_count = (sec_count << 8) | scsipkt->pkt_cdbp[12];
6456 sec_count = (sec_count << 8) | scsipkt->pkt_cdbp[13];
6457 break;
6458 default:
6459 /* Unsupported command */
6460 mutex_exit(cport_mutex);
6461 return (sata_txlt_invalid_command(spx));
6462 }
6463
6464 /*
6465 * Check if specified address and length exceeds device capacity
6466 */
6467 if ((lba >= sdinfo->satadrv_capacity) ||
6468 ((lba + sec_count) > sdinfo->satadrv_capacity)) {
6469 /* LBA out of range */
6470 mutex_exit(cport_mutex);
6471 return (sata_txlt_lba_out_of_range(spx));
6472 }
6473
6474 /*
6475 * For zero-length transfer, emulate good completion of the command
6476 * (reasons for rejecting the command were already checked).
6477 * No DMA resources were allocated.
6478 */
6479 if (spx->txlt_dma_cookie_list == NULL) {
6480 mutex_exit(cport_mutex);
6481 return (sata_emul_rw_completion(spx));
6482 }
6483
6484 /*
6485 * Build cmd block depending on the device capability and
6486 * requested operation mode.
6487 * Do not bother with non-dma mode- we are working only with
6488 * devices supporting DMA.
6489 */
6490 scmd->satacmd_addr_type = ATA_ADDR_LBA;
6491 scmd->satacmd_device_reg = SATA_ADH_LBA;
6492 scmd->satacmd_cmd_reg = SATAC_WRITE_DMA;
6493 if (sdinfo->satadrv_features_support & SATA_DEV_F_LBA48) {
6494 scmd->satacmd_addr_type = ATA_ADDR_LBA48;
6495 scmd->satacmd_cmd_reg = SATAC_WRITE_DMA_EXT;
6496 scmd->satacmd_sec_count_msb = sec_count >> 8;
6497 scmd->satacmd_lba_low_msb = (lba >> 24) & 0xff;
6498 #ifndef __lock_lint
6499 scmd->satacmd_lba_mid_msb = (lba >> 32) & 0xff;
6500 scmd->satacmd_lba_high_msb = lba >> 40;
6501 #endif
6502 } else if (sdinfo->satadrv_features_support & SATA_DEV_F_LBA28) {
6503 scmd->satacmd_addr_type = ATA_ADDR_LBA28;
6504 scmd->satacmd_device_reg = SATA_ADH_LBA | ((lba >> 24) & 0xf);
6505 }
6506 scmd->satacmd_sec_count_lsb = sec_count & 0xff;
6507 scmd->satacmd_lba_low_lsb = lba & 0xff;
6508 scmd->satacmd_lba_mid_lsb = (lba >> 8) & 0xff;
6509 scmd->satacmd_lba_high_lsb = (lba >> 16) & 0xff;
6510 scmd->satacmd_features_reg = 0;
6511 scmd->satacmd_status_reg = 0;
6512 scmd->satacmd_error_reg = 0;
6513
6514 /*
6515 * Check if queueing commands should be used and switch
6516 * to appropriate command if possible
6517 */
6518 if (sata_func_enable & SATA_ENABLE_QUEUING) {
6519 boolean_t using_queuing;
6520
6521 /* Queuing supported by controller and device? */
6522 if ((sata_func_enable & SATA_ENABLE_NCQ) &&
6523 (sdinfo->satadrv_features_support &
6524 SATA_DEV_F_NCQ) &&
6525 (SATA_FEATURES(spx->txlt_sata_hba_inst) &
6526 SATA_CTLF_NCQ)) {
6527 using_queuing = B_TRUE;
6528
6529 /* NCQ supported - use FPDMA WRITE */
6530 scmd->satacmd_cmd_reg =
6531 SATAC_WRITE_FPDMA_QUEUED;
6532 scmd->satacmd_features_reg_ext =
6533 scmd->satacmd_sec_count_msb;
6534 scmd->satacmd_sec_count_msb = 0;
6535 } else if ((sdinfo->satadrv_features_support &
6536 SATA_DEV_F_TCQ) &&
6537 (SATA_FEATURES(spx->txlt_sata_hba_inst) &
6538 SATA_CTLF_QCMD)) {
6539 using_queuing = B_TRUE;
6540
6541 /* Legacy queueing */
6542 if (sdinfo->satadrv_features_support &
6543 SATA_DEV_F_LBA48) {
6544 scmd->satacmd_cmd_reg =
6545 SATAC_WRITE_DMA_QUEUED_EXT;
6546 scmd->satacmd_features_reg_ext =
6547 scmd->satacmd_sec_count_msb;
6548 scmd->satacmd_sec_count_msb = 0;
6549 } else {
6550 scmd->satacmd_cmd_reg =
6551 SATAC_WRITE_DMA_QUEUED;
6552 }
6553 } else /* NCQ nor legacy queuing not supported */
6554 using_queuing = B_FALSE;
6555
6556 if (using_queuing) {
6557 scmd->satacmd_features_reg =
6558 scmd->satacmd_sec_count_lsb;
6559 scmd->satacmd_sec_count_lsb = 0;
6560 scmd->satacmd_flags.sata_queued = B_TRUE;
6561 /* Set-up maximum queue depth */
6562 scmd->satacmd_flags.sata_max_queue_depth =
6563 sdinfo->satadrv_max_queue_depth - 1;
6564 } else if (sdinfo->satadrv_features_enabled &
6565 SATA_DEV_F_E_UNTAGGED_QING) {
6566 /*
6567 * Although NCQ/TCQ is not enabled, untagged queuing
6568 * may be still used.
6569 * Set-up the maximum untagged queue depth.
6570 * Use controller's queue depth from sata_hba_tran.
6571 * SATA HBA drivers may ignore this value and rely on
6572 * the internal limits. For drivera that do not
6573 * ignore untaged queue depth, limit the value to
6574 * SATA_MAX_QUEUE_DEPTH (32), as this is the
6575 * largest value that can be passed via
6576 * satacmd_flags.sata_max_queue_depth.
6577 */
6578 scmd->satacmd_flags.sata_max_queue_depth =
6579 SATA_QDEPTH(shi) <= SATA_MAX_QUEUE_DEPTH ?
6580 SATA_QDEPTH(shi) - 1: SATA_MAX_QUEUE_DEPTH - 1;
6581
6582 } else {
6583 scmd->satacmd_flags.sata_max_queue_depth = 0;
6584 }
6585 } else
6586 scmd->satacmd_flags.sata_max_queue_depth = 0;
6587
6588 SATADBG3(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst,
6589 "sata_txlt_write cmd 0x%2x, lba %llx, sec count %x\n",
6590 scmd->satacmd_cmd_reg, lba, sec_count);
6591
6592 if (!(spx->txlt_sata_pkt->satapkt_op_mode & SATA_OPMODE_SYNCH)) {
6593 /* Need callback function */
6594 spx->txlt_sata_pkt->satapkt_comp = sata_txlt_rw_completion;
6595 synch = FALSE;
6596 } else
6597 synch = TRUE;
6598
6599 /* Transfer command to HBA */
6600 if (sata_hba_start(spx, &rval) != 0) {
6601 /* Pkt not accepted for execution */
6602 mutex_exit(cport_mutex);
6603 return (rval);
6604 }
6605 mutex_exit(cport_mutex);
6606
6607 /*
6608 * If execution is non-synchronous,
6609 * a callback function will handle potential errors, translate
6610 * the response and will do a callback to a target driver.
6611 * If it was synchronous, check execution status using the same
6612 * framework callback.
6613 */
6614 if (synch) {
6615 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst,
6616 "synchronous execution status %x\n",
6617 spx->txlt_sata_pkt->satapkt_reason);
6618 sata_txlt_rw_completion(spx->txlt_sata_pkt);
6619 }
6620 return (TRAN_ACCEPT);
6621 }
6622
6623
6624 /*
6625 * Implements SCSI SBC WRITE BUFFER command download microcode option
6626 */
6627 static int
6628 sata_txlt_write_buffer(sata_pkt_txlate_t *spx)
6629 {
6630 #define WB_DOWNLOAD_MICROCODE_AND_REVERT_MODE 4
6631 #define WB_DOWNLOAD_MICROCODE_AND_SAVE_MODE 5
6632
6633 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt;
6634 struct sata_pkt *sata_pkt = spx->txlt_sata_pkt;
6635 sata_cmd_t *scmd = &spx->txlt_sata_pkt->satapkt_cmd;
6636
6637 struct buf *bp = spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp;
6638 struct scsi_extended_sense *sense;
6639 int rval, mode, sector_count, reason;
6640 kmutex_t *cport_mutex = &(SATA_TXLT_CPORT_MUTEX(spx));
6641
6642 mode = scsipkt->pkt_cdbp[1] & 0x1f;
6643
6644 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst,
6645 "sata_txlt_write_buffer, mode 0x%x\n", mode);
6646
6647 mutex_enter(cport_mutex);
6648
6649 if ((rval = sata_txlt_generic_pkt_info(spx, &reason, 1)) !=
6650 TRAN_ACCEPT) {
6651 mutex_exit(cport_mutex);
6652 return (rval);
6653 }
6654
6655 /* Use synchronous mode */
6656 spx->txlt_sata_pkt->satapkt_op_mode
6657 |= SATA_OPMODE_SYNCH | SATA_OPMODE_INTERRUPTS;
6658
6659 scmd->satacmd_flags.sata_data_direction = SATA_DIR_WRITE;
6660
6661 scsipkt->pkt_reason = CMD_CMPLT;
6662 scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET |
6663 STATE_SENT_CMD | STATE_GOT_STATUS;
6664
6665 /*
6666 * The SCSI to ATA translation specification only calls
6667 * for WB_DOWNLOAD_MICROCODE_AND_SAVE_MODE.
6668 * WB_DOWNLOAD_MICROC_AND_REVERT_MODE is implemented, but
6669 * ATA 8 (draft) got rid of download microcode for temp
6670 * and it is even optional for ATA 7, so it may be aborted.
6671 * WB_DOWNLOAD_MICROCODE_WITH_OFFSET is not implemented as
6672 * it is not specified and the buffer offset for SCSI is a 16-bit
6673 * value in bytes, but for ATA it is a 16-bit offset in 512 byte
6674 * sectors. Thus the offset really doesn't buy us anything.
6675 * If and when ATA 8 is stabilized and the SCSI to ATA specification
6676 * is revised, this can be revisisted.
6677 */
6678 /* Reject not supported request */
6679 switch (mode) {
6680 case WB_DOWNLOAD_MICROCODE_AND_REVERT_MODE:
6681 scmd->satacmd_features_reg = SATA_DOWNLOAD_MCODE_TEMP;
6682 break;
6683 case WB_DOWNLOAD_MICROCODE_AND_SAVE_MODE:
6684 scmd->satacmd_features_reg = SATA_DOWNLOAD_MCODE_SAVE;
6685 break;
6686 default:
6687 goto bad_param;
6688 }
6689
6690 *scsipkt->pkt_scbp = STATUS_GOOD; /* Presumed outcome */
6691
6692 scmd->satacmd_cmd_reg = SATAC_DOWNLOAD_MICROCODE;
6693 if ((bp->b_bcount % SATA_DISK_SECTOR_SIZE) != 0)
6694 goto bad_param;
6695 sector_count = bp->b_bcount / SATA_DISK_SECTOR_SIZE;
6696 scmd->satacmd_sec_count_lsb = (uint8_t)sector_count;
6697 scmd->satacmd_lba_low_lsb = ((uint16_t)sector_count) >> 8;
6698 scmd->satacmd_lba_mid_lsb = 0;
6699 scmd->satacmd_lba_high_lsb = 0;
6700 scmd->satacmd_device_reg = 0;
6701 spx->txlt_sata_pkt->satapkt_comp = NULL;
6702 scmd->satacmd_addr_type = 0;
6703
6704 /* Transfer command to HBA */
6705 if (sata_hba_start(spx, &rval) != 0) {
6706 /* Pkt not accepted for execution */
6707 mutex_exit(cport_mutex);
6708 return (rval);
6709 }
6710
6711 mutex_exit(cport_mutex);
6712
6713 /* Then we need synchronous check the status of the disk */
6714 scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET |
6715 STATE_SENT_CMD | STATE_XFERRED_DATA | STATE_GOT_STATUS;
6716 if (sata_pkt->satapkt_reason == SATA_PKT_COMPLETED) {
6717 scsipkt->pkt_reason = CMD_CMPLT;
6718
6719 /* Download commmand succeed, so probe and identify device */
6720 sata_reidentify_device(spx);
6721 } else {
6722 /* Something went wrong, microcode download command failed */
6723 scsipkt->pkt_reason = CMD_INCOMPLETE;
6724 *scsipkt->pkt_scbp = STATUS_CHECK;
6725 sense = sata_arq_sense(spx);
6726 switch (sata_pkt->satapkt_reason) {
6727 case SATA_PKT_PORT_ERROR:
6728 /*
6729 * We have no device data. Assume no data transfered.
6730 */
6731 sense->es_key = KEY_HARDWARE_ERROR;
6732 break;
6733
6734 case SATA_PKT_DEV_ERROR:
6735 if (sata_pkt->satapkt_cmd.satacmd_status_reg &
6736 SATA_STATUS_ERR) {
6737 /*
6738 * determine dev error reason from error
6739 * reg content
6740 */
6741 sata_decode_device_error(spx, sense);
6742 break;
6743 }
6744 /* No extended sense key - no info available */
6745 break;
6746
6747 case SATA_PKT_TIMEOUT:
6748 scsipkt->pkt_reason = CMD_TIMEOUT;
6749 scsipkt->pkt_statistics |=
6750 STAT_TIMEOUT | STAT_DEV_RESET;
6751 /* No extended sense key ? */
6752 break;
6753
6754 case SATA_PKT_ABORTED:
6755 scsipkt->pkt_reason = CMD_ABORTED;
6756 scsipkt->pkt_statistics |= STAT_ABORTED;
6757 /* No extended sense key ? */
6758 break;
6759
6760 case SATA_PKT_RESET:
6761 /* pkt aborted by an explicit reset from a host */
6762 scsipkt->pkt_reason = CMD_RESET;
6763 scsipkt->pkt_statistics |= STAT_DEV_RESET;
6764 break;
6765
6766 default:
6767 SATA_LOG_D((spx->txlt_sata_hba_inst, CE_WARN,
6768 "sata_txlt_nodata_cmd_completion: "
6769 "invalid packet completion reason %d",
6770 sata_pkt->satapkt_reason));
6771 scsipkt->pkt_reason = CMD_TRAN_ERR;
6772 break;
6773 }
6774
6775 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst,
6776 "scsi_pkt completion reason %x\n", scsipkt->pkt_reason);
6777
6778 if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0)
6779 /* scsi callback required */
6780 scsi_hba_pkt_comp(scsipkt);
6781 }
6782 return (TRAN_ACCEPT);
6783
6784 bad_param:
6785 mutex_exit(cport_mutex);
6786 *scsipkt->pkt_scbp = STATUS_CHECK;
6787 sense = sata_arq_sense(spx);
6788 sense->es_key = KEY_ILLEGAL_REQUEST;
6789 sense->es_add_code = SD_SCSI_ASC_INVALID_FIELD_IN_CDB;
6790 if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0 &&
6791 scsipkt->pkt_comp != NULL) {
6792 /* scsi callback required */
6793 if (servicing_interrupt()) {
6794 if (taskq_dispatch(SATA_TXLT_TASKQ(spx),
6795 (task_func_t *)spx->txlt_scsi_pkt->pkt_comp,
6796 (void *)spx->txlt_scsi_pkt, TQ_NOSLEEP) == NULL) {
6797 return (TRAN_BUSY);
6798 }
6799 } else if (taskq_dispatch(SATA_TXLT_TASKQ(spx),
6800 (task_func_t *)spx->txlt_scsi_pkt->pkt_comp,
6801 (void *)spx->txlt_scsi_pkt, TQ_SLEEP) == NULL) {
6802 /* Scheduling the callback failed */
6803 return (TRAN_BUSY);
6804 }
6805 }
6806 return (rval);
6807 }
6808
6809 /*
6810 * Re-identify device after doing a firmware download.
6811 */
6812 static void
6813 sata_reidentify_device(sata_pkt_txlate_t *spx)
6814 {
6815 #define DOWNLOAD_WAIT_TIME_SECS 60
6816 #define DOWNLOAD_WAIT_INTERVAL_SECS 1
6817 int rval;
6818 int retry_cnt;
6819 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt;
6820 sata_hba_inst_t *sata_hba_inst = spx->txlt_sata_hba_inst;
6821 sata_device_t sata_device = spx->txlt_sata_pkt->satapkt_device;
6822 sata_drive_info_t *sdinfo;
6823
6824 /*
6825 * Before returning good status, probe device.
6826 * Device probing will get IDENTIFY DEVICE data, if possible.
6827 * The assumption is that the new microcode is applied by the
6828 * device. It is a caller responsibility to verify this.
6829 */
6830 for (retry_cnt = 0;
6831 retry_cnt < DOWNLOAD_WAIT_TIME_SECS / DOWNLOAD_WAIT_INTERVAL_SECS;
6832 retry_cnt++) {
6833 rval = sata_probe_device(sata_hba_inst, &sata_device);
6834
6835 if (rval == SATA_SUCCESS) { /* Set default features */
6836 sdinfo = sata_get_device_info(sata_hba_inst,
6837 &sata_device);
6838 if (sata_initialize_device(sata_hba_inst, sdinfo) !=
6839 SATA_SUCCESS) {
6840 /* retry */
6841 rval = sata_initialize_device(sata_hba_inst,
6842 sdinfo);
6843 if (rval == SATA_RETRY)
6844 sata_log(sata_hba_inst, CE_WARN,
6845 "SATA device at port %d pmport %d -"
6846 " default device features could not"
6847 " be set. Device may not operate "
6848 "as expected.",
6849 sata_device.satadev_addr.cport,
6850 sata_device.satadev_addr.pmport);
6851 }
6852 if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0)
6853 scsi_hba_pkt_comp(scsipkt);
6854 return;
6855 } else if (rval == SATA_RETRY) {
6856 delay(drv_usectohz(1000000 *
6857 DOWNLOAD_WAIT_INTERVAL_SECS));
6858 continue;
6859 } else /* failed - no reason to retry */
6860 break;
6861 }
6862
6863 /*
6864 * Something went wrong, device probing failed.
6865 */
6866 SATA_LOG_D((sata_hba_inst, CE_WARN,
6867 "Cannot probe device after downloading microcode\n"));
6868
6869 /* Reset device to force retrying the probe. */
6870 (void) (*SATA_RESET_DPORT_FUNC(sata_hba_inst))
6871 (SATA_DIP(sata_hba_inst), &sata_device);
6872
6873 if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0)
6874 scsi_hba_pkt_comp(scsipkt);
6875 }
6876
6877
6878 /*
6879 * Translate command: Synchronize Cache.
6880 * Translates into Flush Cache command for SATA hard disks.
6881 *
6882 * Returns TRAN_ACCEPT or code returned by sata_hba_start() and
6883 * appropriate values in scsi_pkt fields.
6884 */
6885 static int
6886 sata_txlt_synchronize_cache(sata_pkt_txlate_t *spx)
6887 {
6888 sata_cmd_t *scmd = &spx->txlt_sata_pkt->satapkt_cmd;
6889 kmutex_t *cport_mutex = &(SATA_TXLT_CPORT_MUTEX(spx));
6890 int rval, reason;
6891 int synch;
6892
6893 mutex_enter(cport_mutex);
6894
6895 if (((rval = sata_txlt_generic_pkt_info(spx, &reason, 1)) !=
6896 TRAN_ACCEPT) || (reason == CMD_DEV_GONE)) {
6897 mutex_exit(cport_mutex);
6898 return (rval);
6899 }
6900
6901 scmd->satacmd_addr_type = 0;
6902 scmd->satacmd_cmd_reg = SATAC_FLUSH_CACHE;
6903 scmd->satacmd_device_reg = 0;
6904 scmd->satacmd_sec_count_lsb = 0;
6905 scmd->satacmd_lba_low_lsb = 0;
6906 scmd->satacmd_lba_mid_lsb = 0;
6907 scmd->satacmd_lba_high_lsb = 0;
6908 scmd->satacmd_features_reg = 0;
6909 scmd->satacmd_status_reg = 0;
6910 scmd->satacmd_error_reg = 0;
6911
6912 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst,
6913 "sata_txlt_synchronize_cache\n", NULL);
6914
6915 if (!(spx->txlt_sata_pkt->satapkt_op_mode & SATA_OPMODE_SYNCH)) {
6916 /* Need to set-up a callback function */
6917 spx->txlt_sata_pkt->satapkt_comp =
6918 sata_txlt_nodata_cmd_completion;
6919 synch = FALSE;
6920 } else
6921 synch = TRUE;
6922
6923 /* Transfer command to HBA */
6924 if (sata_hba_start(spx, &rval) != 0) {
6925 /* Pkt not accepted for execution */
6926 mutex_exit(cport_mutex);
6927 return (rval);
6928 }
6929 mutex_exit(cport_mutex);
6930
6931 /*
6932 * If execution non-synchronous, it had to be completed
6933 * a callback function will handle potential errors, translate
6934 * the response and will do a callback to a target driver.
6935 * If it was synchronous, check status, using the same
6936 * framework callback.
6937 */
6938 if (synch) {
6939 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst,
6940 "synchronous execution status %x\n",
6941 spx->txlt_sata_pkt->satapkt_reason);
6942 sata_txlt_nodata_cmd_completion(spx->txlt_sata_pkt);
6943 }
6944 return (TRAN_ACCEPT);
6945 }
6946
6947
6948 /*
6949 * Send pkt to SATA HBA driver
6950 *
6951 * This function may be called only if the operation is requested by scsi_pkt,
6952 * i.e. scsi_pkt is not NULL.
6953 *
6954 * This function has to be called with cport mutex held. It does release
6955 * the mutex when it calls HBA driver sata_tran_start function and
6956 * re-acquires it afterwards.
6957 *
6958 * If return value is 0, pkt was accepted, -1 otherwise
6959 * rval is set to appropriate sata_scsi_start return value.
6960 *
6961 * Note 1:If HBA driver returns value other than TRAN_ACCEPT, it should not
6962 * have called the sata_pkt callback function for this packet.
6963 *
6964 * The scsi callback has to be performed by the caller of this routine.
6965 */
6966 static int
6967 sata_hba_start(sata_pkt_txlate_t *spx, int *rval)
6968 {
6969 int stat;
6970 uint8_t cport = SATA_TXLT_CPORT(spx);
6971 uint8_t pmport = SATA_TXLT_PMPORT(spx);
6972 sata_hba_inst_t *sata_hba_inst = spx->txlt_sata_hba_inst;
6973 sata_drive_info_t *sdinfo;
6974 sata_pmult_info_t *pminfo;
6975 sata_pmport_info_t *pmportinfo = NULL;
6976 sata_device_t *sata_device = NULL;
6977 uint8_t cmd;
6978 struct sata_cmd_flags cmd_flags;
6979
6980 ASSERT(spx->txlt_sata_pkt != NULL);
6981
6982 ASSERT(mutex_owned(&SATA_CPORT_MUTEX(sata_hba_inst, cport)));
6983
6984 sdinfo = sata_get_device_info(sata_hba_inst,
6985 &spx->txlt_sata_pkt->satapkt_device);
6986 ASSERT(sdinfo != NULL);
6987
6988 /* Clear device reset state? */
6989 /* qual should be XXX_DPMPORT, but add XXX_PMPORT in case */
6990 if (sdinfo->satadrv_addr.qual == SATA_ADDR_DPMPORT ||
6991 sdinfo->satadrv_addr.qual == SATA_ADDR_PMPORT) {
6992
6993 /*
6994 * Get the pmult_info of the its parent port multiplier, all
6995 * sub-devices share a common device reset flags on in
6996 * pmult_info.
6997 */
6998 pminfo = SATA_PMULT_INFO(sata_hba_inst, cport);
6999 pmportinfo = pminfo->pmult_dev_port[pmport];
7000 ASSERT(pminfo != NULL);
7001 if (pminfo->pmult_event_flags & SATA_EVNT_CLEAR_DEVICE_RESET) {
7002 spx->txlt_sata_pkt->satapkt_cmd.satacmd_flags.
7003 sata_clear_dev_reset = B_TRUE;
7004 pminfo->pmult_event_flags &=
7005 ~SATA_EVNT_CLEAR_DEVICE_RESET;
7006 SATADBG1(SATA_DBG_EVENTS, sata_hba_inst,
7007 "sata_hba_start: clearing device reset state"
7008 "on pmult.\n", NULL);
7009 }
7010 } else {
7011 if (sdinfo->satadrv_event_flags &
7012 SATA_EVNT_CLEAR_DEVICE_RESET) {
7013 spx->txlt_sata_pkt->satapkt_cmd.satacmd_flags.
7014 sata_clear_dev_reset = B_TRUE;
7015 sdinfo->satadrv_event_flags &=
7016 ~SATA_EVNT_CLEAR_DEVICE_RESET;
7017 SATADBG1(SATA_DBG_EVENTS, sata_hba_inst,
7018 "sata_hba_start: clearing device reset state\n",
7019 NULL);
7020 }
7021 }
7022
7023 cmd = spx->txlt_sata_pkt->satapkt_cmd.satacmd_cmd_reg;
7024 cmd_flags = spx->txlt_sata_pkt->satapkt_cmd.satacmd_flags;
7025 sata_device = &spx->txlt_sata_pkt->satapkt_device;
7026
7027 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, cport)));
7028
7029 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst,
7030 "Sata cmd 0x%2x\n", cmd);
7031
7032 stat = (*SATA_START_FUNC(sata_hba_inst))(SATA_DIP(sata_hba_inst),
7033 spx->txlt_sata_pkt);
7034 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, cport)));
7035 /*
7036 * If sata pkt was accepted and executed in asynchronous mode, i.e.
7037 * with the sata callback, the sata_pkt could be already destroyed
7038 * by the time we check ther return status from the hba_start()
7039 * function, because sata_scsi_destroy_pkt() could have been already
7040 * called (perhaps in the interrupt context). So, in such case, there
7041 * should be no references to it. In other cases, sata_pkt still
7042 * exists.
7043 */
7044 if (stat == SATA_TRAN_ACCEPTED) {
7045 /*
7046 * pkt accepted for execution.
7047 * If it was executed synchronously, it is already completed
7048 * and pkt completion_reason indicates completion status.
7049 */
7050 *rval = TRAN_ACCEPT;
7051 return (0);
7052 }
7053
7054 sdinfo = sata_get_device_info(sata_hba_inst, sata_device);
7055 switch (stat) {
7056 case SATA_TRAN_QUEUE_FULL:
7057 /*
7058 * Controller detected queue full condition.
7059 */
7060 SATADBG1(SATA_DBG_HBA_IF, sata_hba_inst,
7061 "sata_hba_start: queue full\n", NULL);
7062
7063 spx->txlt_scsi_pkt->pkt_reason = CMD_INCOMPLETE;
7064 *spx->txlt_scsi_pkt->pkt_scbp = STATUS_QFULL;
7065
7066 *rval = TRAN_BUSY;
7067 break;
7068
7069 case SATA_TRAN_PORT_ERROR:
7070 /*
7071 * Communication/link with device or general port error
7072 * detected before pkt execution begun.
7073 */
7074 if (spx->txlt_sata_pkt->satapkt_device.satadev_addr.qual ==
7075 SATA_ADDR_CPORT ||
7076 spx->txlt_sata_pkt->satapkt_device.satadev_addr.qual ==
7077 SATA_ADDR_DCPORT)
7078 sata_log(sata_hba_inst, CE_CONT,
7079 "SATA port %d error",
7080 sata_device->satadev_addr.cport);
7081 else
7082 sata_log(sata_hba_inst, CE_CONT,
7083 "SATA port %d:%d error\n",
7084 sata_device->satadev_addr.cport,
7085 sata_device->satadev_addr.pmport);
7086
7087 /*
7088 * Update the port/device structure.
7089 * sata_pkt should be still valid. Since port error is
7090 * returned, sata_device content should reflect port
7091 * state - it means, that sata address have been changed,
7092 * because original packet's sata address refered to a device
7093 * attached to some port.
7094 */
7095 if (sata_device->satadev_addr.qual == SATA_ADDR_DPMPORT ||
7096 sata_device->satadev_addr.qual == SATA_ADDR_PMPORT) {
7097 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, cport)));
7098 mutex_enter(&pmportinfo->pmport_mutex);
7099 sata_update_pmport_info(sata_hba_inst, sata_device);
7100 mutex_exit(&pmportinfo->pmport_mutex);
7101 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, cport)));
7102 } else {
7103 sata_update_port_info(sata_hba_inst, sata_device);
7104 }
7105
7106 spx->txlt_scsi_pkt->pkt_reason = CMD_TRAN_ERR;
7107 *rval = TRAN_FATAL_ERROR;
7108 break;
7109
7110 case SATA_TRAN_CMD_UNSUPPORTED:
7111 /*
7112 * Command rejected by HBA as unsupported. It was HBA driver
7113 * that rejected the command, command was not sent to
7114 * an attached device.
7115 */
7116 if ((sdinfo != NULL) &&
7117 (sdinfo->satadrv_state & SATA_DSTATE_RESET))
7118 SATADBG1(SATA_DBG_EVENTS, sata_hba_inst,
7119 "sat_hba_start: cmd 0x%2x rejected "
7120 "with SATA_TRAN_CMD_UNSUPPORTED status\n", cmd);
7121
7122 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, cport)));
7123 (void) sata_txlt_invalid_command(spx);
7124 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, cport)));
7125
7126 *rval = TRAN_ACCEPT;
7127 break;
7128
7129 case SATA_TRAN_BUSY:
7130 /*
7131 * Command rejected by HBA because other operation prevents
7132 * accepting the packet, or device is in RESET condition.
7133 */
7134 if (sdinfo != NULL) {
7135 sdinfo->satadrv_state =
7136 spx->txlt_sata_pkt->satapkt_device.satadev_state;
7137
7138 if (sdinfo->satadrv_state & SATA_DSTATE_RESET) {
7139 SATADBG1(SATA_DBG_EVENTS, sata_hba_inst,
7140 "sata_hba_start: cmd 0x%2x rejected "
7141 "because of device reset condition\n",
7142 cmd);
7143 } else {
7144 SATADBG1(SATA_DBG_EVENTS, sata_hba_inst,
7145 "sata_hba_start: cmd 0x%2x rejected "
7146 "with SATA_TRAN_BUSY status\n",
7147 cmd);
7148 }
7149 }
7150 spx->txlt_scsi_pkt->pkt_reason = CMD_INCOMPLETE;
7151 *rval = TRAN_BUSY;
7152 break;
7153
7154 default:
7155 /* Unrecognized HBA response */
7156 SATA_LOG_D((sata_hba_inst, CE_WARN,
7157 "sata_hba_start: unrecognized HBA response "
7158 "to cmd : 0x%2x resp 0x%x", cmd, rval));
7159 spx->txlt_scsi_pkt->pkt_reason = CMD_TRAN_ERR;
7160 *rval = TRAN_FATAL_ERROR;
7161 break;
7162 }
7163
7164 /*
7165 * If we got here, the packet was rejected.
7166 * Check if we need to remember reset state clearing request
7167 */
7168 if (cmd_flags.sata_clear_dev_reset) {
7169 /*
7170 * Check if device is still configured - it may have
7171 * disapeared from the configuration
7172 */
7173 sdinfo = sata_get_device_info(sata_hba_inst, sata_device);
7174 if (sdinfo != NULL) {
7175 /*
7176 * Restore the flag that requests clearing of
7177 * the device reset state,
7178 * so the next sata packet may carry it to HBA.
7179 */
7180 if (sdinfo->satadrv_addr.qual == SATA_ADDR_PMPORT ||
7181 sdinfo->satadrv_addr.qual == SATA_ADDR_DPMPORT) {
7182 pminfo->pmult_event_flags |=
7183 SATA_EVNT_CLEAR_DEVICE_RESET;
7184 } else {
7185 sdinfo->satadrv_event_flags |=
7186 SATA_EVNT_CLEAR_DEVICE_RESET;
7187 }
7188 }
7189 }
7190 return (-1);
7191 }
7192
7193 /*
7194 * Scsi response setup for invalid LBA
7195 *
7196 * Returns TRAN_ACCEPT and appropriate values in scsi_pkt fields.
7197 */
7198 static int
7199 sata_txlt_lba_out_of_range(sata_pkt_txlate_t *spx)
7200 {
7201 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt;
7202 struct scsi_extended_sense *sense;
7203
7204 scsipkt->pkt_reason = CMD_CMPLT;
7205 scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET |
7206 STATE_SENT_CMD | STATE_GOT_STATUS;
7207 *scsipkt->pkt_scbp = STATUS_CHECK;
7208
7209 *scsipkt->pkt_scbp = STATUS_CHECK;
7210 sense = sata_arq_sense(spx);
7211 sense->es_key = KEY_ILLEGAL_REQUEST;
7212 sense->es_add_code = SD_SCSI_ASC_LBA_OUT_OF_RANGE;
7213
7214 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst,
7215 "Scsi_pkt completion reason %x\n", scsipkt->pkt_reason);
7216
7217 if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0 &&
7218 scsipkt->pkt_comp != NULL) {
7219 /* scsi callback required */
7220 if (servicing_interrupt()) {
7221 if (taskq_dispatch(SATA_TXLT_TASKQ(spx),
7222 (task_func_t *)spx->txlt_scsi_pkt->pkt_comp,
7223 (void *)spx->txlt_scsi_pkt, TQ_NOSLEEP) == NULL) {
7224 return (TRAN_BUSY);
7225 }
7226 } else if (taskq_dispatch(SATA_TXLT_TASKQ(spx),
7227 (task_func_t *)spx->txlt_scsi_pkt->pkt_comp,
7228 (void *)spx->txlt_scsi_pkt, TQ_SLEEP) == NULL) {
7229 /* Scheduling the callback failed */
7230 return (TRAN_BUSY);
7231 }
7232 }
7233 return (TRAN_ACCEPT);
7234 }
7235
7236
7237 /*
7238 * Analyze device status and error registers and translate them into
7239 * appropriate scsi sense codes.
7240 * NOTE: non-packet commands only for now
7241 */
7242 static void
7243 sata_decode_device_error(sata_pkt_txlate_t *spx,
7244 struct scsi_extended_sense *sense)
7245 {
7246 uint8_t err_reg = spx->txlt_sata_pkt->satapkt_cmd.satacmd_error_reg;
7247
7248 ASSERT(sense != NULL);
7249 ASSERT(spx->txlt_sata_pkt->satapkt_cmd.satacmd_status_reg &
7250 SATA_STATUS_ERR);
7251
7252
7253 if (err_reg & SATA_ERROR_ICRC) {
7254 sense->es_key = KEY_ABORTED_COMMAND;
7255 sense->es_add_code = 0x08; /* Communication failure */
7256 return;
7257 }
7258
7259 if (err_reg & SATA_ERROR_UNC) {
7260 sense->es_key = KEY_MEDIUM_ERROR;
7261 /* Information bytes (LBA) need to be set by a caller */
7262 return;
7263 }
7264
7265 /* ADD HERE: MC error bit handling for ATAPI CD/DVD */
7266 if (err_reg & (SATA_ERROR_MCR | SATA_ERROR_NM)) {
7267 sense->es_key = KEY_UNIT_ATTENTION;
7268 sense->es_add_code = 0x3a; /* No media present */
7269 return;
7270 }
7271
7272 if (err_reg & SATA_ERROR_IDNF) {
7273 if (err_reg & SATA_ERROR_ABORT) {
7274 sense->es_key = KEY_ABORTED_COMMAND;
7275 } else {
7276 sense->es_key = KEY_ILLEGAL_REQUEST;
7277 sense->es_add_code = 0x21; /* LBA out of range */
7278 }
7279 return;
7280 }
7281
7282 if (err_reg & SATA_ERROR_ABORT) {
7283 ASSERT(spx->txlt_sata_pkt != NULL);
7284 sense->es_key = KEY_ABORTED_COMMAND;
7285 return;
7286 }
7287 }
7288
7289 /*
7290 * Extract error LBA from sata_pkt.satapkt_cmd register fields
7291 */
7292 static void
7293 sata_extract_error_lba(sata_pkt_txlate_t *spx, uint64_t *lba)
7294 {
7295 sata_cmd_t *sata_cmd = &spx->txlt_sata_pkt->satapkt_cmd;
7296
7297 *lba = 0;
7298 if (sata_cmd->satacmd_addr_type == ATA_ADDR_LBA48) {
7299 *lba = sata_cmd->satacmd_lba_high_msb;
7300 *lba = (*lba << 8) | sata_cmd->satacmd_lba_mid_msb;
7301 *lba = (*lba << 8) | sata_cmd->satacmd_lba_low_msb;
7302 } else if (sata_cmd->satacmd_addr_type == ATA_ADDR_LBA28) {
7303 *lba = sata_cmd->satacmd_device_reg & 0xf;
7304 }
7305 *lba = (*lba << 8) | sata_cmd->satacmd_lba_high_lsb;
7306 *lba = (*lba << 8) | sata_cmd->satacmd_lba_mid_lsb;
7307 *lba = (*lba << 8) | sata_cmd->satacmd_lba_low_lsb;
7308 }
7309
7310 /*
7311 * This is fixed sense format - if LBA exceeds the info field size,
7312 * no valid info will be returned (valid bit in extended sense will
7313 * be set to 0).
7314 */
7315 static struct scsi_extended_sense *
7316 sata_arq_sense(sata_pkt_txlate_t *spx)
7317 {
7318 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt;
7319 struct scsi_arq_status *arqs;
7320 struct scsi_extended_sense *sense;
7321
7322 /* Fill ARQ sense data */
7323 scsipkt->pkt_state |= STATE_ARQ_DONE;
7324 arqs = (struct scsi_arq_status *)scsipkt->pkt_scbp;
7325 *(uchar_t *)&arqs->sts_status = STATUS_CHECK;
7326 *(uchar_t *)&arqs->sts_rqpkt_status = STATUS_GOOD;
7327 arqs->sts_rqpkt_reason = CMD_CMPLT;
7328 arqs->sts_rqpkt_state = STATE_GOT_BUS | STATE_GOT_TARGET |
7329 STATE_XFERRED_DATA | STATE_SENT_CMD | STATE_GOT_STATUS;
7330 arqs->sts_rqpkt_resid = 0;
7331 sense = &arqs->sts_sensedata;
7332 bzero(sense, sizeof (struct scsi_extended_sense));
7333 sata_fixed_sense_data_preset(sense);
7334 return (sense);
7335 }
7336
7337 /*
7338 * ATA Pass Through support
7339 * Sets flags indicating that an invalid value was found in some
7340 * field in the command. It could be something illegal according to
7341 * the SAT-2 spec or it could be a feature that is not (yet?)
7342 * supported.
7343 */
7344 static int
7345 sata_txlt_ata_pass_thru_illegal_cmd(sata_pkt_txlate_t *spx)
7346 {
7347 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt;
7348 struct scsi_extended_sense *sense = sata_arq_sense(spx);
7349
7350 scsipkt->pkt_reason = CMD_CMPLT;
7351 *scsipkt->pkt_scbp = STATUS_CHECK;
7352 scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET |
7353 STATE_SENT_CMD | STATE_GOT_STATUS;
7354
7355 sense = sata_arq_sense(spx);
7356 sense->es_key = KEY_ILLEGAL_REQUEST;
7357 sense->es_add_code = SD_SCSI_ASC_INVALID_FIELD_IN_CDB;
7358
7359 if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0 &&
7360 scsipkt->pkt_comp != NULL) {
7361 /* scsi callback required */
7362 if (servicing_interrupt()) {
7363 if (taskq_dispatch(SATA_TXLT_TASKQ(spx),
7364 (task_func_t *)spx->txlt_scsi_pkt->pkt_comp,
7365 (void *)spx->txlt_scsi_pkt, TQ_NOSLEEP) == NULL) {
7366 return (TRAN_BUSY);
7367 }
7368 } else if (taskq_dispatch(SATA_TXLT_TASKQ(spx),
7369 (task_func_t *)spx->txlt_scsi_pkt->pkt_comp,
7370 (void *)spx->txlt_scsi_pkt, TQ_SLEEP) == NULL) {
7371 /* Scheduling the callback failed */
7372 return (TRAN_BUSY);
7373 }
7374 }
7375
7376 return (TRAN_ACCEPT);
7377 }
7378
7379 /*
7380 * The UNMAP command considers it not to be an error if the parameter length
7381 * or block descriptor length is 0. For this case, there is nothing for TRIM
7382 * to do so just complete the command.
7383 */
7384 static int
7385 sata_txlt_unmap_nodata_cmd(sata_pkt_txlate_t *spx)
7386 {
7387 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt;
7388
7389 scsipkt->pkt_reason = CMD_CMPLT;
7390 *scsipkt->pkt_scbp = STATUS_GOOD;
7391 scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET |
7392 STATE_SENT_CMD | STATE_GOT_STATUS;
7393
7394 if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0 &&
7395 scsipkt->pkt_comp != NULL) {
7396 /* scsi callback required */
7397 if (taskq_dispatch(SATA_TXLT_TASKQ(spx),
7398 (task_func_t *)spx->txlt_scsi_pkt->pkt_comp,
7399 (void *)spx->txlt_scsi_pkt, TQ_SLEEP) == NULL) {
7400 /* Scheduling the callback failed */
7401 return (TRAN_BUSY);
7402 }
7403 }
7404
7405 return (TRAN_ACCEPT);
7406 }
7407
7408 /*
7409 * Emulated SATA Read/Write command completion for zero-length requests.
7410 * This request always succedes, so in synchronous mode it always returns
7411 * TRAN_ACCEPT, and in non-synchronous mode it may return TRAN_BUSY if the
7412 * callback cannot be scheduled.
7413 */
7414 static int
7415 sata_emul_rw_completion(sata_pkt_txlate_t *spx)
7416 {
7417 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt;
7418
7419 scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET |
7420 STATE_SENT_CMD | STATE_GOT_STATUS;
7421 scsipkt->pkt_reason = CMD_CMPLT;
7422 *scsipkt->pkt_scbp = STATUS_GOOD;
7423 if (!(spx->txlt_sata_pkt->satapkt_op_mode & SATA_OPMODE_SYNCH)) {
7424 /* scsi callback required - have to schedule it */
7425 if (servicing_interrupt()) {
7426 if (taskq_dispatch(SATA_TXLT_TASKQ(spx),
7427 (task_func_t *)spx->txlt_scsi_pkt->pkt_comp,
7428 (void *)spx->txlt_scsi_pkt, TQ_NOSLEEP) == NULL) {
7429 return (TRAN_BUSY);
7430 }
7431 } else if (taskq_dispatch(SATA_TXLT_TASKQ(spx),
7432 (task_func_t *)spx->txlt_scsi_pkt->pkt_comp,
7433 (void *)spx->txlt_scsi_pkt, TQ_SLEEP) == NULL) {
7434 /* Scheduling the callback failed */
7435 return (TRAN_BUSY);
7436 }
7437 }
7438 return (TRAN_ACCEPT);
7439 }
7440
7441
7442 /*
7443 * Translate completion status of SATA read/write commands into scsi response.
7444 * pkt completion_reason is checked to determine the completion status.
7445 * Do scsi callback if necessary.
7446 *
7447 * Note: this function may be called also for synchronously executed
7448 * commands.
7449 * This function may be used only if scsi_pkt is non-NULL.
7450 */
7451 static void
7452 sata_txlt_rw_completion(sata_pkt_t *sata_pkt)
7453 {
7454 sata_pkt_txlate_t *spx =
7455 (sata_pkt_txlate_t *)sata_pkt->satapkt_framework_private;
7456 sata_cmd_t *scmd = &sata_pkt->satapkt_cmd;
7457 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt;
7458 struct scsi_extended_sense *sense;
7459 uint64_t lba;
7460 struct buf *bp;
7461 int rval;
7462 if (sata_pkt->satapkt_reason == SATA_PKT_COMPLETED) {
7463 /* Normal completion */
7464 scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET |
7465 STATE_SENT_CMD | STATE_XFERRED_DATA | STATE_GOT_STATUS;
7466 scsipkt->pkt_reason = CMD_CMPLT;
7467 *scsipkt->pkt_scbp = STATUS_GOOD;
7468 if (spx->txlt_tmp_buf != NULL) {
7469 /* Temporary buffer was used */
7470 bp = spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp;
7471 if (bp->b_flags & B_READ) {
7472 rval = ddi_dma_sync(
7473 spx->txlt_buf_dma_handle, 0, 0,
7474 DDI_DMA_SYNC_FORCPU);
7475 ASSERT(rval == DDI_SUCCESS);
7476 bcopy(spx->txlt_tmp_buf, bp->b_un.b_addr,
7477 bp->b_bcount);
7478 }
7479 }
7480 } else {
7481 /*
7482 * Something went wrong - analyze return
7483 */
7484 scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET |
7485 STATE_SENT_CMD | STATE_GOT_STATUS;
7486 scsipkt->pkt_reason = CMD_INCOMPLETE;
7487 *scsipkt->pkt_scbp = STATUS_CHECK;
7488 sense = sata_arq_sense(spx);
7489 ASSERT(sense != NULL);
7490
7491 /*
7492 * SATA_PKT_DEV_ERROR is the only case where we may be able to
7493 * extract from device registers the failing LBA.
7494 */
7495 if (sata_pkt->satapkt_reason == SATA_PKT_DEV_ERROR) {
7496 if ((scmd->satacmd_addr_type == ATA_ADDR_LBA48) &&
7497 (scmd->satacmd_lba_mid_msb != 0 ||
7498 scmd->satacmd_lba_high_msb != 0)) {
7499 /*
7500 * We have problem reporting this cmd LBA
7501 * in fixed sense data format, because of
7502 * the size of the scsi LBA fields.
7503 */
7504 sense->es_valid = 0;
7505 } else {
7506 sata_extract_error_lba(spx, &lba);
7507 sense->es_info_1 = (lba & 0xFF000000) >> 24;
7508 sense->es_info_2 = (lba & 0xFF0000) >> 16;
7509 sense->es_info_3 = (lba & 0xFF00) >> 8;
7510 sense->es_info_4 = lba & 0xFF;
7511 }
7512 } else {
7513 /* Invalid extended sense info */
7514 sense->es_valid = 0;
7515 }
7516
7517 switch (sata_pkt->satapkt_reason) {
7518 case SATA_PKT_PORT_ERROR:
7519 /* We may want to handle DEV GONE state as well */
7520 /*
7521 * We have no device data. Assume no data transfered.
7522 */
7523 sense->es_key = KEY_HARDWARE_ERROR;
7524 break;
7525
7526 case SATA_PKT_DEV_ERROR:
7527 if (sata_pkt->satapkt_cmd.satacmd_status_reg &
7528 SATA_STATUS_ERR) {
7529 /*
7530 * determine dev error reason from error
7531 * reg content
7532 */
7533 sata_decode_device_error(spx, sense);
7534 if (sense->es_key == KEY_MEDIUM_ERROR) {
7535 switch (scmd->satacmd_cmd_reg) {
7536 case SATAC_READ_DMA:
7537 case SATAC_READ_DMA_EXT:
7538 case SATAC_READ_DMA_QUEUED:
7539 case SATAC_READ_DMA_QUEUED_EXT:
7540 case SATAC_READ_FPDMA_QUEUED:
7541 /* Unrecovered read error */
7542 sense->es_add_code =
7543 SD_SCSI_ASC_UNREC_READ_ERR;
7544 break;
7545 case SATAC_WRITE_DMA:
7546 case SATAC_WRITE_DMA_EXT:
7547 case SATAC_WRITE_DMA_QUEUED:
7548 case SATAC_WRITE_DMA_QUEUED_EXT:
7549 case SATAC_WRITE_FPDMA_QUEUED:
7550 /* Write error */
7551 sense->es_add_code =
7552 SD_SCSI_ASC_WRITE_ERR;
7553 break;
7554 default:
7555 /* Internal error */
7556 SATA_LOG_D((
7557 spx->txlt_sata_hba_inst,
7558 CE_WARN,
7559 "sata_txlt_rw_completion :"
7560 "internal error - invalid "
7561 "command 0x%2x",
7562 scmd->satacmd_cmd_reg));
7563 break;
7564 }
7565 }
7566 break;
7567 }
7568 /* No extended sense key - no info available */
7569 scsipkt->pkt_reason = CMD_INCOMPLETE;
7570 break;
7571
7572 case SATA_PKT_TIMEOUT:
7573 scsipkt->pkt_reason = CMD_TIMEOUT;
7574 scsipkt->pkt_statistics |=
7575 STAT_TIMEOUT | STAT_DEV_RESET;
7576 sense->es_key = KEY_ABORTED_COMMAND;
7577 break;
7578
7579 case SATA_PKT_ABORTED:
7580 scsipkt->pkt_reason = CMD_ABORTED;
7581 scsipkt->pkt_statistics |= STAT_ABORTED;
7582 sense->es_key = KEY_ABORTED_COMMAND;
7583 break;
7584
7585 case SATA_PKT_RESET:
7586 scsipkt->pkt_reason = CMD_RESET;
7587 scsipkt->pkt_statistics |= STAT_DEV_RESET;
7588 sense->es_key = KEY_ABORTED_COMMAND;
7589 break;
7590
7591 default:
7592 SATA_LOG_D((spx->txlt_sata_hba_inst, CE_WARN,
7593 "sata_txlt_rw_completion: "
7594 "invalid packet completion reason"));
7595 scsipkt->pkt_reason = CMD_TRAN_ERR;
7596 break;
7597 }
7598 }
7599 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst,
7600 "Scsi_pkt completion reason %x\n", scsipkt->pkt_reason);
7601
7602 if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0)
7603 /* scsi callback required */
7604 scsi_hba_pkt_comp(scsipkt);
7605 }
7606
7607
7608 /*
7609 * Translate completion status of non-data commands (i.e. commands returning
7610 * no data).
7611 * pkt completion_reason is checked to determine the completion status.
7612 * Do scsi callback if necessary (FLAG_NOINTR == 0)
7613 *
7614 * Note: this function may be called also for synchronously executed
7615 * commands.
7616 * This function may be used only if scsi_pkt is non-NULL.
7617 */
7618
7619 static void
7620 sata_txlt_nodata_cmd_completion(sata_pkt_t *sata_pkt)
7621 {
7622 sata_pkt_txlate_t *spx =
7623 (sata_pkt_txlate_t *)sata_pkt->satapkt_framework_private;
7624 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt;
7625
7626 sata_set_arq_data(sata_pkt);
7627
7628 if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0)
7629 /* scsi callback required */
7630 scsi_hba_pkt_comp(scsipkt);
7631 }
7632
7633 /*
7634 * Completion handler for ATA Pass Through command
7635 */
7636 static void
7637 sata_txlt_apt_completion(sata_pkt_t *sata_pkt)
7638 {
7639 sata_pkt_txlate_t *spx =
7640 (sata_pkt_txlate_t *)sata_pkt->satapkt_framework_private;
7641 sata_cmd_t *scmd = &sata_pkt->satapkt_cmd;
7642 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt;
7643 struct buf *bp;
7644 uint8_t sense_key = 0, addl_sense_code = 0, addl_sense_qual = 0;
7645
7646 if (sata_pkt->satapkt_reason == SATA_PKT_COMPLETED) {
7647 /* Normal completion */
7648 scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET |
7649 STATE_SENT_CMD | STATE_XFERRED_DATA | STATE_GOT_STATUS;
7650 scsipkt->pkt_reason = CMD_CMPLT;
7651 *scsipkt->pkt_scbp = STATUS_GOOD;
7652
7653 /*
7654 * If the command has CK_COND set
7655 */
7656 if (scsipkt->pkt_cdbp[2] & SATL_APT_BM_CK_COND) {
7657 *scsipkt->pkt_scbp = STATUS_CHECK;
7658 sata_fill_ata_return_desc(sata_pkt,
7659 KEY_RECOVERABLE_ERROR,
7660 SD_SCSI_ASC_APT_INFO_AVAIL, 0x1d);
7661 }
7662
7663 if (spx->txlt_tmp_buf != NULL) {
7664 /* Temporary buffer was used */
7665 bp = spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp;
7666 if (bp->b_flags & B_READ) {
7667 bcopy(spx->txlt_tmp_buf, bp->b_un.b_addr,
7668 bp->b_bcount);
7669 }
7670 }
7671 } else {
7672 scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET |
7673 STATE_SENT_CMD | STATE_GOT_STATUS;
7674 scsipkt->pkt_reason = CMD_INCOMPLETE;
7675 *scsipkt->pkt_scbp = STATUS_CHECK;
7676
7677 /*
7678 * If DF or ERR was set, the HBA should have copied out the
7679 * status and error registers to the satacmd structure.
7680 */
7681 if (scmd->satacmd_status_reg & SATA_STATUS_DF) {
7682 sense_key = KEY_HARDWARE_ERROR;
7683 addl_sense_code = SD_SCSI_ASC_INTERNAL_TARGET_FAILURE;
7684 addl_sense_qual = 0;
7685 } else if (scmd->satacmd_status_reg & SATA_STATUS_ERR) {
7686 if (scmd->satacmd_error_reg & SATA_ERROR_NM) {
7687 sense_key = KEY_NOT_READY;
7688 addl_sense_code =
7689 SD_SCSI_ASC_MEDIUM_NOT_PRESENT;
7690 addl_sense_qual = 0;
7691 } else if (scmd->satacmd_error_reg & SATA_ERROR_UNC) {
7692 sense_key = KEY_MEDIUM_ERROR;
7693 addl_sense_code = SD_SCSI_ASC_UNREC_READ_ERR;
7694 addl_sense_qual = 0;
7695 } else if (scmd->satacmd_error_reg & SATA_ERROR_ILI) {
7696 sense_key = KEY_DATA_PROTECT;
7697 addl_sense_code = SD_SCSI_ASC_WRITE_PROTECTED;
7698 addl_sense_qual = 0;
7699 } else if (scmd->satacmd_error_reg & SATA_ERROR_IDNF) {
7700 sense_key = KEY_ILLEGAL_REQUEST;
7701 addl_sense_code = SD_SCSI_ASC_LBA_OUT_OF_RANGE;
7702 addl_sense_qual = 0;
7703 } else if (scmd->satacmd_error_reg & SATA_ERROR_ABORT) {
7704 sense_key = KEY_ABORTED_COMMAND;
7705 addl_sense_code = SD_SCSI_ASC_NO_ADD_SENSE;
7706 addl_sense_qual = 0;
7707 } else if (scmd->satacmd_error_reg & SATA_ERROR_MC) {
7708 sense_key = KEY_UNIT_ATTENTION;
7709 addl_sense_code =
7710 SD_SCSI_ASC_MEDIUM_MAY_HAVE_CHANGED;
7711 addl_sense_qual = 0;
7712 } else if (scmd->satacmd_error_reg & SATA_ERROR_MCR) {
7713 sense_key = KEY_UNIT_ATTENTION;
7714 addl_sense_code = SD_SCSI_ASC_OP_MEDIUM_REM_REQ;
7715 addl_sense_qual = 0;
7716 } else if (scmd->satacmd_error_reg & SATA_ERROR_ICRC) {
7717 sense_key = KEY_ABORTED_COMMAND;
7718 addl_sense_code =
7719 SD_SCSI_ASC_INFO_UNIT_IUCRC_ERR;
7720 addl_sense_qual = 0;
7721 }
7722 }
7723
7724 sata_fill_ata_return_desc(sata_pkt, sense_key, addl_sense_code,
7725 addl_sense_qual);
7726 }
7727
7728 if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0)
7729 /* scsi callback required */
7730 scsi_hba_pkt_comp(scsipkt);
7731 }
7732
7733 /*
7734 * Completion handler for unmap translation command
7735 */
7736 static void
7737 sata_txlt_unmap_completion(sata_pkt_t *sata_pkt)
7738 {
7739 sata_pkt_txlate_t *spx =
7740 (sata_pkt_txlate_t *)sata_pkt->satapkt_framework_private;
7741 sata_cmd_t *scmd = &sata_pkt->satapkt_cmd;
7742 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt;
7743 struct buf *bp;
7744 uint8_t sense_key = 0, addl_sense_code = 0, addl_sense_qual = 0;
7745
7746 if (sata_pkt->satapkt_reason == SATA_PKT_COMPLETED) {
7747 /* Normal completion */
7748 scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET |
7749 STATE_SENT_CMD | STATE_XFERRED_DATA | STATE_GOT_STATUS;
7750 scsipkt->pkt_reason = CMD_CMPLT;
7751 *scsipkt->pkt_scbp = STATUS_GOOD;
7752
7753 if (spx->txlt_tmp_buf != NULL) {
7754 /* Temporary buffer was used */
7755 bp = spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp;
7756 if (bp->b_flags & B_READ) {
7757 bcopy(spx->txlt_tmp_buf, bp->b_un.b_addr,
7758 bp->b_bcount);
7759 }
7760 }
7761 } else {
7762 scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET |
7763 STATE_SENT_CMD | STATE_GOT_STATUS;
7764 scsipkt->pkt_reason = CMD_INCOMPLETE;
7765 *scsipkt->pkt_scbp = STATUS_CHECK;
7766
7767 /*
7768 * If DF or ERR was set, the HBA should have copied out the
7769 * status and error registers to the satacmd structure.
7770 */
7771 if (scmd->satacmd_status_reg & SATA_STATUS_DF) {
7772 sense_key = KEY_HARDWARE_ERROR;
7773 addl_sense_code = SD_SCSI_ASC_INTERNAL_TARGET_FAILURE;
7774 addl_sense_qual = 0;
7775 } else if (scmd->satacmd_status_reg & SATA_STATUS_ERR) {
7776 if (scmd->satacmd_error_reg & SATA_ERROR_NM) {
7777 sense_key = KEY_NOT_READY;
7778 addl_sense_code =
7779 SD_SCSI_ASC_MEDIUM_NOT_PRESENT;
7780 addl_sense_qual = 0;
7781 } else if (scmd->satacmd_error_reg & SATA_ERROR_UNC) {
7782 sense_key = KEY_MEDIUM_ERROR;
7783 addl_sense_code = SD_SCSI_ASC_WRITE_ERR;
7784 addl_sense_qual = 0;
7785 } else if (scmd->satacmd_error_reg & SATA_ERROR_ILI) {
7786 sense_key = KEY_DATA_PROTECT;
7787 addl_sense_code = SD_SCSI_ASC_WRITE_PROTECTED;
7788 addl_sense_qual = 0;
7789 } else if (scmd->satacmd_error_reg & SATA_ERROR_IDNF) {
7790 sense_key = KEY_ILLEGAL_REQUEST;
7791 addl_sense_code = SD_SCSI_ASC_LBA_OUT_OF_RANGE;
7792 addl_sense_qual = 0;
7793 } else if (scmd->satacmd_error_reg & SATA_ERROR_ABORT) {
7794 sense_key = KEY_ABORTED_COMMAND;
7795 addl_sense_code = SD_SCSI_ASC_NO_ADD_SENSE;
7796 addl_sense_qual = 0;
7797 } else if (scmd->satacmd_error_reg & SATA_ERROR_MC) {
7798 sense_key = KEY_UNIT_ATTENTION;
7799 addl_sense_code =
7800 SD_SCSI_ASC_MEDIUM_MAY_HAVE_CHANGED;
7801 addl_sense_qual = 0;
7802 } else if (scmd->satacmd_error_reg & SATA_ERROR_MCR) {
7803 sense_key = KEY_UNIT_ATTENTION;
7804 addl_sense_code = SD_SCSI_ASC_OP_MEDIUM_REM_REQ;
7805 addl_sense_qual = 0;
7806 } else if (scmd->satacmd_error_reg & SATA_ERROR_ICRC) {
7807 sense_key = KEY_ABORTED_COMMAND;
7808 addl_sense_code =
7809 SD_SCSI_ASC_INFO_UNIT_IUCRC_ERR;
7810 addl_sense_qual = 0;
7811 }
7812 }
7813
7814 sata_fill_ata_return_desc(sata_pkt, sense_key, addl_sense_code,
7815 addl_sense_qual);
7816 }
7817
7818 sata_free_local_buffer(spx);
7819
7820 if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0)
7821 /* scsi callback required */
7822 scsi_hba_pkt_comp(scsipkt);
7823 }
7824
7825 /*
7826 *
7827 */
7828 static void
7829 sata_fill_ata_return_desc(sata_pkt_t *sata_pkt, uint8_t sense_key,
7830 uint8_t addl_sense_code, uint8_t addl_sense_qual)
7831 {
7832 sata_pkt_txlate_t *spx =
7833 (sata_pkt_txlate_t *)sata_pkt->satapkt_framework_private;
7834 sata_cmd_t *scmd = &sata_pkt->satapkt_cmd;
7835 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt;
7836 struct sata_apt_sense_data *apt_sd =
7837 (struct sata_apt_sense_data *)scsipkt->pkt_scbp;
7838 struct scsi_descr_sense_hdr *sds = &(apt_sd->apt_sd_hdr);
7839 struct scsi_ata_status_ret_sense_descr *ata_ret_desc =
7840 &(apt_sd->apt_sd_sense);
7841 int extend = 0;
7842
7843 if ((scsipkt->pkt_cdbp[0] == SPC3_CMD_ATA_COMMAND_PASS_THROUGH16) &&
7844 (scsipkt->pkt_cdbp[2] & SATL_APT_BM_EXTEND))
7845 extend = 1;
7846
7847 scsipkt->pkt_state |= STATE_ARQ_DONE;
7848
7849 /* update the residual count */
7850 *(uchar_t *)&apt_sd->apt_status = STATUS_CHECK;
7851 *(uchar_t *)&apt_sd->apt_rqpkt_status = STATUS_GOOD;
7852 apt_sd->apt_rqpkt_reason = CMD_CMPLT;
7853 apt_sd->apt_rqpkt_state = STATE_GOT_BUS | STATE_GOT_TARGET |
7854 STATE_XFERRED_DATA | STATE_SENT_CMD | STATE_GOT_STATUS;
7855 apt_sd->apt_rqpkt_resid = scsipkt->pkt_scblen -
7856 sizeof (struct sata_apt_sense_data);
7857
7858 /*
7859 * Fill in the Descriptor sense header
7860 */
7861 bzero(sds, sizeof (struct scsi_descr_sense_hdr));
7862 sds->ds_code = CODE_FMT_DESCR_CURRENT;
7863 sds->ds_class = CLASS_EXTENDED_SENSE;
7864 sds->ds_key = sense_key & 0xf;
7865 sds->ds_add_code = addl_sense_code;
7866 sds->ds_qual_code = addl_sense_qual;
7867 sds->ds_addl_sense_length =
7868 sizeof (struct scsi_ata_status_ret_sense_descr);
7869
7870 /*
7871 * Fill in the ATA Return descriptor sense data
7872 */
7873 bzero(ata_ret_desc, sizeof (struct scsi_ata_status_ret_sense_descr));
7874 ata_ret_desc->ars_descr_type = DESCR_ATA_STATUS_RETURN;
7875 ata_ret_desc->ars_addl_length = 0xc;
7876 ata_ret_desc->ars_error = scmd->satacmd_error_reg;
7877 ata_ret_desc->ars_sec_count_lsb = scmd->satacmd_sec_count_lsb;
7878 ata_ret_desc->ars_lba_low_lsb = scmd->satacmd_lba_low_lsb;
7879 ata_ret_desc->ars_lba_mid_lsb = scmd->satacmd_lba_mid_lsb;
7880 ata_ret_desc->ars_lba_high_lsb = scmd->satacmd_lba_high_lsb;
7881 ata_ret_desc->ars_device = scmd->satacmd_device_reg;
7882 ata_ret_desc->ars_status = scmd->satacmd_status_reg;
7883
7884 if (extend == 1) {
7885 ata_ret_desc->ars_extend = 1;
7886 ata_ret_desc->ars_sec_count_msb = scmd->satacmd_sec_count_msb;
7887 ata_ret_desc->ars_lba_low_msb = scmd->satacmd_lba_low_msb;
7888 ata_ret_desc->ars_lba_mid_msb = scmd->satacmd_lba_mid_msb;
7889 ata_ret_desc->ars_lba_high_msb = scmd->satacmd_lba_high_msb;
7890 } else {
7891 ata_ret_desc->ars_extend = 0;
7892 ata_ret_desc->ars_sec_count_msb = 0;
7893 ata_ret_desc->ars_lba_low_msb = 0;
7894 ata_ret_desc->ars_lba_mid_msb = 0;
7895 ata_ret_desc->ars_lba_high_msb = 0;
7896 }
7897 }
7898
7899 static void
7900 sata_set_arq_data(sata_pkt_t *sata_pkt)
7901 {
7902 sata_pkt_txlate_t *spx =
7903 (sata_pkt_txlate_t *)sata_pkt->satapkt_framework_private;
7904 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt;
7905 struct scsi_extended_sense *sense;
7906
7907 scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET |
7908 STATE_SENT_CMD | STATE_GOT_STATUS;
7909 if (sata_pkt->satapkt_reason == SATA_PKT_COMPLETED) {
7910 /* Normal completion */
7911 scsipkt->pkt_reason = CMD_CMPLT;
7912 *scsipkt->pkt_scbp = STATUS_GOOD;
7913 } else {
7914 /* Something went wrong */
7915 scsipkt->pkt_reason = CMD_INCOMPLETE;
7916 *scsipkt->pkt_scbp = STATUS_CHECK;
7917 sense = sata_arq_sense(spx);
7918 switch (sata_pkt->satapkt_reason) {
7919 case SATA_PKT_PORT_ERROR:
7920 /*
7921 * We have no device data. Assume no data transfered.
7922 */
7923 sense->es_key = KEY_HARDWARE_ERROR;
7924 break;
7925
7926 case SATA_PKT_DEV_ERROR:
7927 if (sata_pkt->satapkt_cmd.satacmd_status_reg &
7928 SATA_STATUS_ERR) {
7929 /*
7930 * determine dev error reason from error
7931 * reg content
7932 */
7933 sata_decode_device_error(spx, sense);
7934 break;
7935 }
7936 /* No extended sense key - no info available */
7937 break;
7938
7939 case SATA_PKT_TIMEOUT:
7940 scsipkt->pkt_reason = CMD_TIMEOUT;
7941 scsipkt->pkt_statistics |=
7942 STAT_TIMEOUT | STAT_DEV_RESET;
7943 /* No extended sense key ? */
7944 break;
7945
7946 case SATA_PKT_ABORTED:
7947 scsipkt->pkt_reason = CMD_ABORTED;
7948 scsipkt->pkt_statistics |= STAT_ABORTED;
7949 /* No extended sense key ? */
7950 break;
7951
7952 case SATA_PKT_RESET:
7953 /* pkt aborted by an explicit reset from a host */
7954 scsipkt->pkt_reason = CMD_RESET;
7955 scsipkt->pkt_statistics |= STAT_DEV_RESET;
7956 break;
7957
7958 default:
7959 SATA_LOG_D((spx->txlt_sata_hba_inst, CE_WARN,
7960 "sata_txlt_nodata_cmd_completion: "
7961 "invalid packet completion reason %d",
7962 sata_pkt->satapkt_reason));
7963 scsipkt->pkt_reason = CMD_TRAN_ERR;
7964 break;
7965 }
7966
7967 }
7968 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst,
7969 "Scsi_pkt completion reason %x\n", scsipkt->pkt_reason);
7970 }
7971
7972
7973 /*
7974 * Build Mode sense R/W recovery page
7975 * NOT IMPLEMENTED
7976 */
7977
7978 static int
7979 sata_build_msense_page_1(sata_drive_info_t *sdinfo, int pcntrl, uint8_t *buf)
7980 {
7981 #ifndef __lock_lint
7982 _NOTE(ARGUNUSED(sdinfo))
7983 _NOTE(ARGUNUSED(pcntrl))
7984 _NOTE(ARGUNUSED(buf))
7985 #endif
7986 return (0);
7987 }
7988
7989 /*
7990 * Build Mode sense caching page - scsi-3 implementation.
7991 * Page length distinguishes previous format from scsi-3 format.
7992 * buf must have space for 0x12 bytes.
7993 * Only DRA (disable read ahead ) and WCE (write cache enable) are changeable.
7994 *
7995 */
7996 static int
7997 sata_build_msense_page_8(sata_drive_info_t *sdinfo, int pcntrl, uint8_t *buf)
7998 {
7999 struct mode_cache_scsi3 *page = (struct mode_cache_scsi3 *)buf;
8000 sata_id_t *sata_id = &sdinfo->satadrv_id;
8001
8002 /*
8003 * Most of the fields are set to 0, being not supported and/or disabled
8004 */
8005 bzero(buf, PAGELENGTH_DAD_MODE_CACHE_SCSI3);
8006
8007 /* Saved paramters not supported */
8008 if (pcntrl == 3)
8009 return (0);
8010 if (pcntrl == 0 || pcntrl == 2) {
8011 /*
8012 * For now treat current and default parameters as same
8013 * That may have to change, if target driver will complain
8014 */
8015 page->mode_page.code = MODEPAGE_CACHING; /* PS = 0 */
8016 page->mode_page.length = PAGELENGTH_DAD_MODE_CACHE_SCSI3;
8017
8018 if (SATA_READ_AHEAD_SUPPORTED(*sata_id) &&
8019 !SATA_READ_AHEAD_ENABLED(*sata_id)) {
8020 page->dra = 1; /* Read Ahead disabled */
8021 page->rcd = 1; /* Read Cache disabled */
8022 }
8023 if (SATA_WRITE_CACHE_SUPPORTED(*sata_id) &&
8024 SATA_WRITE_CACHE_ENABLED(*sata_id))
8025 page->wce = 1; /* Write Cache enabled */
8026 } else {
8027 /* Changeable parameters */
8028 page->mode_page.code = MODEPAGE_CACHING;
8029 page->mode_page.length = PAGELENGTH_DAD_MODE_CACHE_SCSI3;
8030 if (SATA_READ_AHEAD_SUPPORTED(*sata_id)) {
8031 page->dra = 1;
8032 page->rcd = 1;
8033 }
8034 if (SATA_WRITE_CACHE_SUPPORTED(*sata_id))
8035 page->wce = 1;
8036 }
8037 return (PAGELENGTH_DAD_MODE_CACHE_SCSI3 +
8038 sizeof (struct mode_page));
8039 }
8040
8041 /*
8042 * Build Mode sense exception cntrl page
8043 */
8044 static int
8045 sata_build_msense_page_1c(sata_drive_info_t *sdinfo, int pcntrl, uint8_t *buf)
8046 {
8047 struct mode_info_excpt_page *page = (struct mode_info_excpt_page *)buf;
8048 sata_id_t *sata_id = &sdinfo->satadrv_id;
8049
8050 /*
8051 * Most of the fields are set to 0, being not supported and/or disabled
8052 */
8053 bzero(buf, PAGELENGTH_INFO_EXCPT);
8054
8055 page->mode_page.code = MODEPAGE_INFO_EXCPT;
8056 page->mode_page.length = PAGELENGTH_INFO_EXCPT;
8057
8058 /* Indicate that this is page is saveable */
8059 page->mode_page.ps = 1;
8060
8061 /*
8062 * We will return the same data for default, current and saved page.
8063 * The only changeable bit is dexcpt and that bit is required
8064 * by the ATA specification to be preserved across power cycles.
8065 */
8066 if (pcntrl != 1) {
8067 page->dexcpt = !(sata_id->ai_features85 & SATA_SMART_SUPPORTED);
8068 page->mrie = MRIE_ONLY_ON_REQUEST;
8069 }
8070 else
8071 page->dexcpt = 1; /* Only changeable parameter */
8072
8073 return (PAGELENGTH_INFO_EXCPT + sizeof (struct mode_page));
8074 }
8075
8076
8077 static int
8078 sata_build_msense_page_30(sata_drive_info_t *sdinfo, int pcntrl, uint8_t *buf)
8079 {
8080 struct mode_acoustic_management *page =
8081 (struct mode_acoustic_management *)buf;
8082 sata_id_t *sata_id = &sdinfo->satadrv_id;
8083
8084 /*
8085 * Most of the fields are set to 0, being not supported and/or disabled
8086 */
8087 bzero(buf, PAGELENGTH_DAD_MODE_ACOUSTIC_MANAGEMENT);
8088
8089 switch (pcntrl) {
8090 case P_CNTRL_DEFAULT:
8091 /* default paramters not supported */
8092 return (0);
8093
8094 case P_CNTRL_CURRENT:
8095 case P_CNTRL_SAVED:
8096 /* Saved and current are supported and are identical */
8097 page->mode_page.code = MODEPAGE_ACOUSTIC_MANAG;
8098 page->mode_page.length =
8099 PAGELENGTH_DAD_MODE_ACOUSTIC_MANAGEMENT;
8100 page->mode_page.ps = 1;
8101
8102 /* Word 83 indicates if feature is supported */
8103 /* If feature is not supported */
8104 if (!(sata_id->ai_cmdset83 & SATA_ACOUSTIC_MGMT)) {
8105 page->acoustic_manag_enable =
8106 ACOUSTIC_DISABLED;
8107 } else {
8108 page->acoustic_manag_enable =
8109 ((sata_id->ai_features86 & SATA_ACOUSTIC_MGMT)
8110 != 0);
8111 /* Word 94 inidicates the value */
8112 #ifdef _LITTLE_ENDIAN
8113 page->acoustic_manag_level =
8114 (uchar_t)sata_id->ai_acoustic;
8115 page->vendor_recommended_value =
8116 sata_id->ai_acoustic >> 8;
8117 #else
8118 page->acoustic_manag_level =
8119 sata_id->ai_acoustic >> 8;
8120 page->vendor_recommended_value =
8121 (uchar_t)sata_id->ai_acoustic;
8122 #endif
8123 }
8124 break;
8125
8126 case P_CNTRL_CHANGEABLE:
8127 page->mode_page.code = MODEPAGE_ACOUSTIC_MANAG;
8128 page->mode_page.length =
8129 PAGELENGTH_DAD_MODE_ACOUSTIC_MANAGEMENT;
8130 page->mode_page.ps = 1;
8131
8132 /* Word 83 indicates if the feature is supported */
8133 if (sata_id->ai_cmdset83 & SATA_ACOUSTIC_MGMT) {
8134 page->acoustic_manag_enable =
8135 ACOUSTIC_ENABLED;
8136 page->acoustic_manag_level = 0xff;
8137 }
8138 break;
8139 }
8140 return (PAGELENGTH_DAD_MODE_ACOUSTIC_MANAGEMENT +
8141 sizeof (struct mode_page));
8142 }
8143
8144
8145 /*
8146 * Build Mode sense power condition page.
8147 */
8148 static int
8149 sata_build_msense_page_1a(sata_drive_info_t *sdinfo, int pcntrl, uint8_t *buf)
8150 {
8151 struct mode_info_power_cond *page = (struct mode_info_power_cond *)buf;
8152 sata_id_t *sata_id = &sdinfo->satadrv_id;
8153
8154 /*
8155 * Most of the fields are set to 0, being not supported and/or disabled
8156 * power condition page length was 0x0a
8157 */
8158 bzero(buf, sizeof (struct mode_info_power_cond));
8159
8160 if (pcntrl == P_CNTRL_DEFAULT) {
8161 /* default paramters not supported */
8162 return (0);
8163 }
8164
8165 page->mode_page.code = MODEPAGE_POWER_COND;
8166 page->mode_page.length = sizeof (struct mode_info_power_cond);
8167
8168 if (sata_id->ai_cap & SATA_STANDBYTIMER) {
8169 page->standby = 1;
8170 bcopy(sdinfo->satadrv_standby_timer, page->standby_cond_timer,
8171 sizeof (uchar_t) * 4);
8172 }
8173
8174 return (sizeof (struct mode_info_power_cond));
8175 }
8176
8177 /*
8178 * Process mode select caching page 8 (scsi3 format only).
8179 * Read Ahead (same as read cache) and Write Cache may be turned on and off
8180 * if these features are supported by the device. If these features are not
8181 * supported, the command will be terminated with STATUS_CHECK.
8182 * This function fails only if the SET FEATURE command sent to
8183 * the device fails. The page format is not verified, assuming that the
8184 * target driver operates correctly - if parameters length is too short,
8185 * we just drop the page.
8186 * Two command may be sent if both Read Cache/Read Ahead and Write Cache
8187 * setting have to be changed.
8188 * SET FEATURE command is executed synchronously, i.e. we wait here until
8189 * it is completed, regardless of the scsi pkt directives.
8190 *
8191 * Note: Mode Select Caching page RCD and DRA bits are tied together, i.e.
8192 * changing DRA will change RCD.
8193 *
8194 * More than one SATA command may be executed to perform operations specified
8195 * by mode select pages. The first error terminates further execution.
8196 * Operations performed successully are not backed-up in such case.
8197 *
8198 * Return SATA_SUCCESS if operation succeeded, SATA_FAILURE otherwise.
8199 * If operation resulted in changing device setup, dmod flag should be set to
8200 * one (1). If parameters were not changed, dmod flag should be set to 0.
8201 * Upon return, if operation required sending command to the device, the rval
8202 * should be set to the value returned by sata_hba_start. If operation
8203 * did not require device access, rval should be set to TRAN_ACCEPT.
8204 * The pagelen should be set to the length of the page.
8205 *
8206 * This function has to be called with a port mutex held.
8207 *
8208 * Returns SATA_SUCCESS if operation was successful, SATA_FAILURE otherwise.
8209 */
8210 int
8211 sata_mode_select_page_8(sata_pkt_txlate_t *spx, struct mode_cache_scsi3 *page,
8212 int parmlen, int *pagelen, int *rval, int *dmod)
8213 {
8214 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt;
8215 sata_drive_info_t *sdinfo;
8216 sata_cmd_t *scmd = &spx->txlt_sata_pkt->satapkt_cmd;
8217 sata_id_t *sata_id;
8218 struct scsi_extended_sense *sense;
8219 int wce, dra; /* Current settings */
8220
8221 sdinfo = sata_get_device_info(spx->txlt_sata_hba_inst,
8222 &spx->txlt_sata_pkt->satapkt_device);
8223 sata_id = &sdinfo->satadrv_id;
8224 *dmod = 0;
8225
8226 /* Verify parameters length. If too short, drop it */
8227 if ((PAGELENGTH_DAD_MODE_CACHE_SCSI3 +
8228 sizeof (struct mode_page)) > parmlen) {
8229 *scsipkt->pkt_scbp = STATUS_CHECK;
8230 sense = sata_arq_sense(spx);
8231 sense->es_key = KEY_ILLEGAL_REQUEST;
8232 sense->es_add_code = SD_SCSI_ASC_INVALID_FIELD_IN_PARAMS_LIST;
8233 *pagelen = parmlen;
8234 *rval = TRAN_ACCEPT;
8235 return (SATA_FAILURE);
8236 }
8237
8238 *pagelen = PAGELENGTH_DAD_MODE_CACHE_SCSI3 + sizeof (struct mode_page);
8239
8240 /* Current setting of Read Ahead (and Read Cache) */
8241 if (SATA_READ_AHEAD_ENABLED(*sata_id))
8242 dra = 0; /* 0 == not disabled */
8243 else
8244 dra = 1;
8245 /* Current setting of Write Cache */
8246 if (SATA_WRITE_CACHE_ENABLED(*sata_id))
8247 wce = 1;
8248 else
8249 wce = 0;
8250
8251 if (page->dra == dra && page->wce == wce && page->rcd == dra) {
8252 /* nothing to do */
8253 *rval = TRAN_ACCEPT;
8254 return (SATA_SUCCESS);
8255 }
8256
8257 /*
8258 * Need to flip some setting
8259 * Set-up Internal SET FEATURES command(s)
8260 */
8261 scmd->satacmd_flags.sata_data_direction = SATA_DIR_NODATA_XFER;
8262 scmd->satacmd_addr_type = 0;
8263 scmd->satacmd_device_reg = 0;
8264 scmd->satacmd_status_reg = 0;
8265 scmd->satacmd_error_reg = 0;
8266 scmd->satacmd_cmd_reg = SATAC_SET_FEATURES;
8267 if (page->dra != dra || page->rcd != dra) {
8268 if (SATA_READ_AHEAD_SUPPORTED(*sata_id)) {
8269 /* Need to flip read ahead setting */
8270 if (dra == 0)
8271 /* Disable read ahead / read cache */
8272 scmd->satacmd_features_reg =
8273 SATAC_SF_DISABLE_READ_AHEAD;
8274 else
8275 /* Enable read ahead / read cache */
8276 scmd->satacmd_features_reg =
8277 SATAC_SF_ENABLE_READ_AHEAD;
8278
8279 /* Transfer command to HBA */
8280 if (sata_hba_start(spx, rval) != 0)
8281 /*
8282 * Pkt not accepted for execution.
8283 */
8284 return (SATA_FAILURE);
8285
8286 *dmod = 1;
8287
8288 /* Now process return */
8289 if (spx->txlt_sata_pkt->satapkt_reason !=
8290 SATA_PKT_COMPLETED) {
8291 goto failure; /* Terminate */
8292 }
8293 } else {
8294 *scsipkt->pkt_scbp = STATUS_CHECK;
8295 sense = sata_arq_sense(spx);
8296 sense->es_key = KEY_ILLEGAL_REQUEST;
8297 sense->es_add_code =
8298 SD_SCSI_ASC_INVALID_FIELD_IN_PARAMS_LIST;
8299 *pagelen = parmlen;
8300 *rval = TRAN_ACCEPT;
8301 return (SATA_FAILURE);
8302 }
8303 }
8304
8305 /* Note that the packet is not removed, so it could be re-used */
8306 if (page->wce != wce) {
8307 if (SATA_WRITE_CACHE_SUPPORTED(*sata_id)) {
8308 /* Need to flip Write Cache setting */
8309 if (page->wce == 1)
8310 /* Enable write cache */
8311 scmd->satacmd_features_reg =
8312 SATAC_SF_ENABLE_WRITE_CACHE;
8313 else
8314 /* Disable write cache */
8315 scmd->satacmd_features_reg =
8316 SATAC_SF_DISABLE_WRITE_CACHE;
8317
8318 /* Transfer command to HBA */
8319 if (sata_hba_start(spx, rval) != 0)
8320 /*
8321 * Pkt not accepted for execution.
8322 */
8323 return (SATA_FAILURE);
8324
8325 *dmod = 1;
8326
8327 /* Now process return */
8328 if (spx->txlt_sata_pkt->satapkt_reason !=
8329 SATA_PKT_COMPLETED) {
8330 goto failure;
8331 }
8332 } else {
8333 *scsipkt->pkt_scbp = STATUS_CHECK;
8334 sense = sata_arq_sense(spx);
8335 sense->es_key = KEY_ILLEGAL_REQUEST;
8336 sense->es_add_code =
8337 SD_SCSI_ASC_INVALID_FIELD_IN_PARAMS_LIST;
8338 *pagelen = parmlen;
8339 *rval = TRAN_ACCEPT;
8340 return (SATA_FAILURE);
8341 }
8342 }
8343 return (SATA_SUCCESS);
8344
8345 failure:
8346 sata_xlate_errors(spx);
8347
8348 return (SATA_FAILURE);
8349 }
8350
8351 /*
8352 * Process mode select informational exceptions control page 0x1c
8353 *
8354 * The only changeable bit is dexcpt (disable exceptions).
8355 * MRIE (method of reporting informational exceptions) must be
8356 * "only on request".
8357 * This page applies to informational exceptions that report
8358 * additional sense codes with the ADDITIONAL SENSE CODE field set to 5Dh
8359 * (e.g.,FAILURE PREDICTION THRESHOLD EXCEEDED) or 0Bh (e.g., WARNING_).
8360 * Informational exception conditions occur as the result of background scan
8361 * errors, background self-test errors, or vendor specific events within a
8362 * logical unit. An informational exception condition may occur asynchronous
8363 * to any commands.
8364 *
8365 * Returns: SATA_SUCCESS if operation succeeded, SATA_FAILURE otherwise.
8366 * If operation resulted in changing device setup, dmod flag should be set to
8367 * one (1). If parameters were not changed, dmod flag should be set to 0.
8368 * Upon return, if operation required sending command to the device, the rval
8369 * should be set to the value returned by sata_hba_start. If operation
8370 * did not require device access, rval should be set to TRAN_ACCEPT.
8371 * The pagelen should be set to the length of the page.
8372 *
8373 * This function has to be called with a port mutex held.
8374 *
8375 * Returns SATA_SUCCESS if operation was successful, SATA_FAILURE otherwise.
8376 *
8377 * Cannot be called in the interrupt context.
8378 */
8379 static int
8380 sata_mode_select_page_1c(
8381 sata_pkt_txlate_t *spx,
8382 struct mode_info_excpt_page *page,
8383 int parmlen,
8384 int *pagelen,
8385 int *rval,
8386 int *dmod)
8387 {
8388 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt;
8389 sata_cmd_t *scmd = &spx->txlt_sata_pkt->satapkt_cmd;
8390 sata_drive_info_t *sdinfo;
8391 sata_id_t *sata_id;
8392 struct scsi_extended_sense *sense;
8393
8394 sdinfo = sata_get_device_info(spx->txlt_sata_hba_inst,
8395 &spx->txlt_sata_pkt->satapkt_device);
8396 sata_id = &sdinfo->satadrv_id;
8397
8398 *dmod = 0;
8399
8400 /* Verify parameters length. If too short, drop it */
8401 if (((PAGELENGTH_INFO_EXCPT + sizeof (struct mode_page)) > parmlen) ||
8402 page->perf || page->test || (page->mrie != MRIE_ONLY_ON_REQUEST)) {
8403 *scsipkt->pkt_scbp = STATUS_CHECK;
8404 sense = sata_arq_sense(spx);
8405 sense->es_key = KEY_ILLEGAL_REQUEST;
8406 sense->es_add_code = SD_SCSI_ASC_INVALID_FIELD_IN_PARAMS_LIST;
8407 *pagelen = parmlen;
8408 *rval = TRAN_ACCEPT;
8409 return (SATA_FAILURE);
8410 }
8411
8412 *pagelen = PAGELENGTH_INFO_EXCPT + sizeof (struct mode_page);
8413
8414 if (! (sata_id->ai_cmdset82 & SATA_SMART_SUPPORTED)) {
8415 *scsipkt->pkt_scbp = STATUS_CHECK;
8416 sense = sata_arq_sense(spx);
8417 sense->es_key = KEY_ILLEGAL_REQUEST;
8418 sense->es_add_code = SD_SCSI_ASC_INVALID_FIELD_IN_CDB;
8419 *pagelen = parmlen;
8420 *rval = TRAN_ACCEPT;
8421 return (SATA_FAILURE);
8422 }
8423
8424 /* If already in the state requested, we are done */
8425 if (page->dexcpt == ! (sata_id->ai_features85 & SATA_SMART_ENABLED)) {
8426 /* nothing to do */
8427 *rval = TRAN_ACCEPT;
8428 return (SATA_SUCCESS);
8429 }
8430
8431 scmd->satacmd_flags.sata_data_direction = SATA_DIR_NODATA_XFER;
8432
8433 /* Build SMART_ENABLE or SMART_DISABLE command */
8434 scmd->satacmd_addr_type = 0; /* N/A */
8435 scmd->satacmd_lba_mid_lsb = SMART_MAGIC_VAL_1;
8436 scmd->satacmd_lba_high_lsb = SMART_MAGIC_VAL_2;
8437 scmd->satacmd_features_reg = page->dexcpt ?
8438 SATA_SMART_DISABLE_OPS : SATA_SMART_ENABLE_OPS;
8439 scmd->satacmd_device_reg = 0; /* Always device 0 */
8440 scmd->satacmd_cmd_reg = SATAC_SMART;
8441
8442 /* Transfer command to HBA */
8443 if (sata_hba_start(spx, rval) != 0)
8444 /*
8445 * Pkt not accepted for execution.
8446 */
8447 return (SATA_FAILURE);
8448
8449 *dmod = 1; /* At least may have been modified */
8450
8451 /* Now process return */
8452 if (spx->txlt_sata_pkt->satapkt_reason == SATA_PKT_COMPLETED)
8453 return (SATA_SUCCESS);
8454
8455 /* Packet did not complete successfully */
8456 sata_xlate_errors(spx);
8457
8458 return (SATA_FAILURE);
8459 }
8460
8461 /*
8462 * Process mode select acoustic management control page 0x30
8463 *
8464 *
8465 * This function has to be called with a port mutex held.
8466 *
8467 * Returns SATA_SUCCESS if operation was successful, SATA_FAILURE otherwise.
8468 *
8469 * Cannot be called in the interrupt context.
8470 */
8471 int
8472 sata_mode_select_page_30(sata_pkt_txlate_t *spx, struct
8473 mode_acoustic_management *page, int parmlen, int *pagelen,
8474 int *rval, int *dmod)
8475 {
8476 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt;
8477 sata_drive_info_t *sdinfo;
8478 sata_cmd_t *scmd = &spx->txlt_sata_pkt->satapkt_cmd;
8479 sata_id_t *sata_id;
8480 struct scsi_extended_sense *sense;
8481
8482 sdinfo = sata_get_device_info(spx->txlt_sata_hba_inst,
8483 &spx->txlt_sata_pkt->satapkt_device);
8484 sata_id = &sdinfo->satadrv_id;
8485 *dmod = 0;
8486
8487 /* If parmlen is too short or the feature is not supported, drop it */
8488 if (((PAGELENGTH_DAD_MODE_ACOUSTIC_MANAGEMENT +
8489 sizeof (struct mode_page)) > parmlen) ||
8490 (! (sata_id->ai_cmdset83 & SATA_ACOUSTIC_MGMT))) {
8491 *scsipkt->pkt_scbp = STATUS_CHECK;
8492 sense = sata_arq_sense(spx);
8493 sense->es_key = KEY_ILLEGAL_REQUEST;
8494 sense->es_add_code = SD_SCSI_ASC_INVALID_FIELD_IN_PARAMS_LIST;
8495 *pagelen = parmlen;
8496 *rval = TRAN_ACCEPT;
8497 return (SATA_FAILURE);
8498 }
8499
8500 *pagelen = PAGELENGTH_DAD_MODE_ACOUSTIC_MANAGEMENT +
8501 sizeof (struct mode_page);
8502
8503 /*
8504 * We can enable and disable acoustice management and
8505 * set the acoustic management level.
8506 */
8507
8508 /*
8509 * Set-up Internal SET FEATURES command(s)
8510 */
8511 scmd->satacmd_flags.sata_data_direction = SATA_DIR_NODATA_XFER;
8512 scmd->satacmd_addr_type = 0;
8513 scmd->satacmd_device_reg = 0;
8514 scmd->satacmd_status_reg = 0;
8515 scmd->satacmd_error_reg = 0;
8516 scmd->satacmd_cmd_reg = SATAC_SET_FEATURES;
8517 if (page->acoustic_manag_enable) {
8518 scmd->satacmd_features_reg = SATAC_SF_ENABLE_ACOUSTIC;
8519 scmd->satacmd_sec_count_lsb = page->acoustic_manag_level;
8520 } else { /* disabling acoustic management */
8521 scmd->satacmd_features_reg = SATAC_SF_DISABLE_ACOUSTIC;
8522 }
8523
8524 /* Transfer command to HBA */
8525 if (sata_hba_start(spx, rval) != 0)
8526 /*
8527 * Pkt not accepted for execution.
8528 */
8529 return (SATA_FAILURE);
8530
8531 /* Now process return */
8532 if (spx->txlt_sata_pkt->satapkt_reason != SATA_PKT_COMPLETED) {
8533 sata_xlate_errors(spx);
8534 return (SATA_FAILURE);
8535 }
8536
8537 *dmod = 1;
8538
8539 return (SATA_SUCCESS);
8540 }
8541
8542 /*
8543 * Process mode select power condition page 0x1a
8544 *
8545 * This function has to be called with a port mutex held.
8546 *
8547 * Returns SATA_SUCCESS if operation was successful, SATA_FAILURE otherwise.
8548 *
8549 * Cannot be called in the interrupt context.
8550 */
8551 int
8552 sata_mode_select_page_1a(sata_pkt_txlate_t *spx, struct
8553 mode_info_power_cond *page, int parmlen, int *pagelen,
8554 int *rval, int *dmod)
8555 {
8556 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt;
8557 sata_drive_info_t *sdinfo;
8558 sata_cmd_t *scmd = &spx->txlt_sata_pkt->satapkt_cmd;
8559 sata_id_t *sata_id;
8560 struct scsi_extended_sense *sense;
8561 uint8_t ata_count;
8562 int i, len;
8563
8564 sdinfo = sata_get_device_info(spx->txlt_sata_hba_inst,
8565 &spx->txlt_sata_pkt->satapkt_device);
8566 sata_id = &sdinfo->satadrv_id;
8567 *dmod = 0;
8568
8569 len = sizeof (struct mode_info_power_cond);
8570 len += sizeof (struct mode_page);
8571
8572 /* If parmlen is too short or the feature is not supported, drop it */
8573 if ((len < parmlen) || (page->idle == 1) ||
8574 (!(sata_id->ai_cap & SATA_STANDBYTIMER) && page->standby == 1)) {
8575 *scsipkt->pkt_scbp = STATUS_CHECK;
8576 sense = sata_arq_sense(spx);
8577 sense->es_key = KEY_ILLEGAL_REQUEST;
8578 sense->es_add_code = SD_SCSI_ASC_INVALID_FIELD_IN_PARAMS_LIST;
8579 *pagelen = parmlen;
8580 *rval = TRAN_ACCEPT;
8581 return (SATA_FAILURE);
8582 }
8583
8584 *pagelen = len;
8585
8586 /*
8587 * Set-up Internal STANDBY command(s)
8588 */
8589 if (page->standby == 0)
8590 goto out;
8591
8592 ata_count = sata_get_standby_timer(page->standby_cond_timer);
8593
8594 scmd->satacmd_addr_type = 0;
8595 scmd->satacmd_sec_count_lsb = ata_count;
8596 scmd->satacmd_lba_low_lsb = 0;
8597 scmd->satacmd_lba_mid_lsb = 0;
8598 scmd->satacmd_lba_high_lsb = 0;
8599 scmd->satacmd_features_reg = 0;
8600 scmd->satacmd_device_reg = 0;
8601 scmd->satacmd_status_reg = 0;
8602 scmd->satacmd_cmd_reg = SATAC_STANDBY;
8603 scmd->satacmd_flags.sata_special_regs = B_TRUE;
8604 scmd->satacmd_flags.sata_copy_out_error_reg = B_TRUE;
8605
8606 /* Transfer command to HBA */
8607 if (sata_hba_start(spx, rval) != 0) {
8608 return (SATA_FAILURE);
8609 } else {
8610 if ((scmd->satacmd_error_reg != 0) ||
8611 (spx->txlt_sata_pkt->satapkt_reason !=
8612 SATA_PKT_COMPLETED)) {
8613 sata_xlate_errors(spx);
8614 return (SATA_FAILURE);
8615 }
8616 }
8617
8618 for (i = 0; i < 4; i++) {
8619 sdinfo->satadrv_standby_timer[i] = page->standby_cond_timer[i];
8620 }
8621 out:
8622 *dmod = 1;
8623 return (SATA_SUCCESS);
8624 }
8625
8626 /*
8627 * sata_build_lsense_page0() is used to create the
8628 * SCSI LOG SENSE page 0 (supported log pages)
8629 *
8630 * Currently supported pages are 0, 0x10, 0x2f, 0x30 and 0x0e
8631 * (supported log pages, self-test results, informational exceptions
8632 * Sun vendor specific ATA SMART data, and start stop cycle counter).
8633 *
8634 * Takes a sata_drive_info t * and the address of a buffer
8635 * in which to create the page information.
8636 *
8637 * Returns the number of bytes valid in the buffer.
8638 */
8639 static int
8640 sata_build_lsense_page_0(sata_drive_info_t *sdinfo, uint8_t *buf)
8641 {
8642 struct log_parameter *lpp = (struct log_parameter *)buf;
8643 uint8_t *page_ptr = (uint8_t *)lpp->param_values;
8644 int num_pages_supported = 1; /* Always have GET_SUPPORTED_LOG_PAGES */
8645 sata_id_t *sata_id = &sdinfo->satadrv_id;
8646
8647 lpp->param_code[0] = 0;
8648 lpp->param_code[1] = 0;
8649 lpp->param_ctrl_flags = LOG_CTRL_LP | LOG_CTRL_LBIN;
8650 *page_ptr++ = PAGE_CODE_GET_SUPPORTED_LOG_PAGES;
8651
8652 if (sata_id->ai_cmdset82 & SATA_SMART_SUPPORTED) {
8653 if (sata_id->ai_cmdset84 & SATA_SMART_SELF_TEST_SUPPORTED) {
8654 *page_ptr++ = PAGE_CODE_SELF_TEST_RESULTS;
8655 ++num_pages_supported;
8656 }
8657 *page_ptr++ = PAGE_CODE_INFORMATION_EXCEPTIONS;
8658 ++num_pages_supported;
8659 *page_ptr++ = PAGE_CODE_SMART_READ_DATA;
8660 ++num_pages_supported;
8661 *page_ptr++ = PAGE_CODE_START_STOP_CYCLE_COUNTER;
8662 ++num_pages_supported;
8663 }
8664
8665 lpp->param_len = num_pages_supported;
8666
8667 return ((&lpp->param_values[0] - (uint8_t *)lpp) +
8668 num_pages_supported);
8669 }
8670
8671 /*
8672 * sata_build_lsense_page_10() is used to create the
8673 * SCSI LOG SENSE page 0x10 (self-test results)
8674 *
8675 * Takes a sata_drive_info t * and the address of a buffer
8676 * in which to create the page information as well as a sata_hba_inst_t *.
8677 *
8678 * Returns the number of bytes valid in the buffer.
8679 *
8680 * Note: Self test and SMART data is accessible in device log pages.
8681 * The log pages can be accessed by SMART READ/WRITE LOG (up to 255 sectors
8682 * of data can be transferred by a single command), or by the General Purpose
8683 * Logging commands (GPL) READ LOG EXT and WRITE LOG EXT (up to 65,535 sectors
8684 * - approximately 33MB - can be transferred by a single command.
8685 * The SCT Command response (either error or command) is the same for both
8686 * the SMART and GPL methods of issuing commands.
8687 * This function uses READ LOG EXT command when drive supports LBA48, and
8688 * SMART READ command otherwise.
8689 *
8690 * Since above commands are executed in a synchronous mode, this function
8691 * should not be called in an interrupt context.
8692 */
8693 static int
8694 sata_build_lsense_page_10(
8695 sata_drive_info_t *sdinfo,
8696 uint8_t *buf,
8697 sata_hba_inst_t *sata_hba_inst)
8698 {
8699 struct log_parameter *lpp = (struct log_parameter *)buf;
8700 int rval;
8701
8702 if (sdinfo->satadrv_features_support & SATA_DEV_F_LBA48) {
8703 struct smart_ext_selftest_log *ext_selftest_log;
8704
8705 ext_selftest_log = kmem_zalloc(
8706 sizeof (struct smart_ext_selftest_log), KM_SLEEP);
8707
8708 rval = sata_ext_smart_selftest_read_log(sata_hba_inst, sdinfo,
8709 ext_selftest_log, 0);
8710 if (rval == 0) {
8711 int index, start_index;
8712 struct smart_ext_selftest_log_entry *entry;
8713 static const struct smart_ext_selftest_log_entry empty =
8714 {0};
8715 uint16_t block_num;
8716 int count;
8717 boolean_t only_one_block = B_FALSE;
8718
8719 index = ext_selftest_log->
8720 smart_ext_selftest_log_index[0];
8721 index |= ext_selftest_log->
8722 smart_ext_selftest_log_index[1] << 8;
8723 if (index == 0)
8724 goto out;
8725
8726 --index; /* Correct for 0 origin */
8727 start_index = index; /* remember where we started */
8728 block_num = index / ENTRIES_PER_EXT_SELFTEST_LOG_BLK;
8729 if (block_num != 0) {
8730 rval = sata_ext_smart_selftest_read_log(
8731 sata_hba_inst, sdinfo, ext_selftest_log,
8732 block_num);
8733 if (rval != 0)
8734 goto out;
8735 }
8736 index %= ENTRIES_PER_EXT_SELFTEST_LOG_BLK;
8737 entry =
8738 &ext_selftest_log->
8739 smart_ext_selftest_log_entries[index];
8740
8741 for (count = 1;
8742 count <= SCSI_ENTRIES_IN_LOG_SENSE_SELFTEST_RESULTS;
8743 ++count) {
8744 uint8_t status;
8745 uint8_t code;
8746 uint8_t sense_key;
8747 uint8_t add_sense_code;
8748 uint8_t add_sense_code_qual;
8749
8750 /* If this is an unused entry, we are done */
8751 if (bcmp(entry, &empty, sizeof (empty)) == 0) {
8752 /* Broken firmware on some disks */
8753 if (index + 1 ==
8754 ENTRIES_PER_EXT_SELFTEST_LOG_BLK) {
8755 --entry;
8756 --index;
8757 if (bcmp(entry, &empty,
8758 sizeof (empty)) == 0)
8759 goto out;
8760 } else
8761 goto out;
8762 }
8763
8764 if (only_one_block &&
8765 start_index == index)
8766 goto out;
8767
8768 lpp->param_code[0] = 0;
8769 lpp->param_code[1] = count;
8770 lpp->param_ctrl_flags =
8771 LOG_CTRL_LP | LOG_CTRL_LBIN;
8772 lpp->param_len =
8773 SCSI_LOG_SENSE_SELFTEST_PARAM_LEN;
8774
8775 status = entry->smart_ext_selftest_log_status;
8776 status >>= 4;
8777 switch (status) {
8778 case 0:
8779 default:
8780 sense_key = KEY_NO_SENSE;
8781 add_sense_code =
8782 SD_SCSI_ASC_NO_ADD_SENSE;
8783 add_sense_code_qual = 0;
8784 break;
8785 case 1:
8786 sense_key = KEY_ABORTED_COMMAND;
8787 add_sense_code =
8788 DIAGNOSTIC_FAILURE_ON_COMPONENT;
8789 add_sense_code_qual = SCSI_COMPONENT_81;
8790 break;
8791 case 2:
8792 sense_key = KEY_ABORTED_COMMAND;
8793 add_sense_code =
8794 DIAGNOSTIC_FAILURE_ON_COMPONENT;
8795 add_sense_code_qual = SCSI_COMPONENT_82;
8796 break;
8797 case 3:
8798 sense_key = KEY_ABORTED_COMMAND;
8799 add_sense_code =
8800 DIAGNOSTIC_FAILURE_ON_COMPONENT;
8801 add_sense_code_qual = SCSI_COMPONENT_83;
8802 break;
8803 case 4:
8804 sense_key = KEY_HARDWARE_ERROR;
8805 add_sense_code =
8806 DIAGNOSTIC_FAILURE_ON_COMPONENT;
8807 add_sense_code_qual = SCSI_COMPONENT_84;
8808 break;
8809 case 5:
8810 sense_key = KEY_HARDWARE_ERROR;
8811 add_sense_code =
8812 DIAGNOSTIC_FAILURE_ON_COMPONENT;
8813 add_sense_code_qual = SCSI_COMPONENT_85;
8814 break;
8815 case 6:
8816 sense_key = KEY_HARDWARE_ERROR;
8817 add_sense_code =
8818 DIAGNOSTIC_FAILURE_ON_COMPONENT;
8819 add_sense_code_qual = SCSI_COMPONENT_86;
8820 break;
8821 case 7:
8822 sense_key = KEY_MEDIUM_ERROR;
8823 add_sense_code =
8824 DIAGNOSTIC_FAILURE_ON_COMPONENT;
8825 add_sense_code_qual = SCSI_COMPONENT_87;
8826 break;
8827 case 8:
8828 sense_key = KEY_HARDWARE_ERROR;
8829 add_sense_code =
8830 DIAGNOSTIC_FAILURE_ON_COMPONENT;
8831 add_sense_code_qual = SCSI_COMPONENT_88;
8832 break;
8833 }
8834 code = 0; /* unspecified */
8835 status |= (code << 4);
8836 lpp->param_values[0] = status;
8837 lpp->param_values[1] = 0; /* unspecified */
8838 lpp->param_values[2] = entry->
8839 smart_ext_selftest_log_timestamp[1];
8840 lpp->param_values[3] = entry->
8841 smart_ext_selftest_log_timestamp[0];
8842 if (status != 0) {
8843 lpp->param_values[4] = 0;
8844 lpp->param_values[5] = 0;
8845 lpp->param_values[6] = entry->
8846 smart_ext_selftest_log_failing_lba
8847 [5];
8848 lpp->param_values[7] = entry->
8849 smart_ext_selftest_log_failing_lba
8850 [4];
8851 lpp->param_values[8] = entry->
8852 smart_ext_selftest_log_failing_lba
8853 [3];
8854 lpp->param_values[9] = entry->
8855 smart_ext_selftest_log_failing_lba
8856 [2];
8857 lpp->param_values[10] = entry->
8858 smart_ext_selftest_log_failing_lba
8859 [1];
8860 lpp->param_values[11] = entry->
8861 smart_ext_selftest_log_failing_lba
8862 [0];
8863 } else { /* No bad block address */
8864 lpp->param_values[4] = 0xff;
8865 lpp->param_values[5] = 0xff;
8866 lpp->param_values[6] = 0xff;
8867 lpp->param_values[7] = 0xff;
8868 lpp->param_values[8] = 0xff;
8869 lpp->param_values[9] = 0xff;
8870 lpp->param_values[10] = 0xff;
8871 lpp->param_values[11] = 0xff;
8872 }
8873
8874 lpp->param_values[12] = sense_key;
8875 lpp->param_values[13] = add_sense_code;
8876 lpp->param_values[14] = add_sense_code_qual;
8877 lpp->param_values[15] = 0; /* undefined */
8878
8879 lpp = (struct log_parameter *)
8880 (((uint8_t *)lpp) +
8881 SCSI_LOG_PARAM_HDR_LEN +
8882 SCSI_LOG_SENSE_SELFTEST_PARAM_LEN);
8883
8884 --index; /* Back up to previous entry */
8885 if (index < 0) {
8886 if (block_num > 0) {
8887 --block_num;
8888 } else {
8889 struct read_log_ext_directory
8890 logdir;
8891
8892 rval =
8893 sata_read_log_ext_directory(
8894 sata_hba_inst, sdinfo,
8895 &logdir);
8896 if (rval == -1)
8897 goto out;
8898 if ((logdir.read_log_ext_vers
8899 [0] == 0) &&
8900 (logdir.read_log_ext_vers
8901 [1] == 0))
8902 goto out;
8903 block_num =
8904 logdir.read_log_ext_nblks
8905 [EXT_SMART_SELFTEST_LOG_PAGE
8906 - 1][0];
8907 block_num |= logdir.
8908 read_log_ext_nblks
8909 [EXT_SMART_SELFTEST_LOG_PAGE
8910 - 1][1] << 8;
8911 --block_num;
8912 only_one_block =
8913 (block_num == 0);
8914 }
8915 rval = sata_ext_smart_selftest_read_log(
8916 sata_hba_inst, sdinfo,
8917 ext_selftest_log, block_num);
8918 if (rval != 0)
8919 goto out;
8920
8921 index =
8922 ENTRIES_PER_EXT_SELFTEST_LOG_BLK -
8923 1;
8924 }
8925 index %= ENTRIES_PER_EXT_SELFTEST_LOG_BLK;
8926 entry = &ext_selftest_log->
8927 smart_ext_selftest_log_entries[index];
8928 }
8929 }
8930 out:
8931 kmem_free(ext_selftest_log,
8932 sizeof (struct smart_ext_selftest_log));
8933 } else {
8934 struct smart_selftest_log *selftest_log;
8935
8936 selftest_log = kmem_zalloc(sizeof (struct smart_selftest_log),
8937 KM_SLEEP);
8938
8939 rval = sata_smart_selftest_log(sata_hba_inst, sdinfo,
8940 selftest_log);
8941
8942 if (rval == 0) {
8943 int index;
8944 int count;
8945 struct smart_selftest_log_entry *entry;
8946 static const struct smart_selftest_log_entry empty =
8947 { 0 };
8948
8949 index = selftest_log->smart_selftest_log_index;
8950 if (index == 0)
8951 goto done;
8952 --index; /* Correct for 0 origin */
8953 entry = &selftest_log->
8954 smart_selftest_log_entries[index];
8955 for (count = 1;
8956 count <= SCSI_ENTRIES_IN_LOG_SENSE_SELFTEST_RESULTS;
8957 ++count) {
8958 uint8_t status;
8959 uint8_t code;
8960 uint8_t sense_key;
8961 uint8_t add_sense_code;
8962 uint8_t add_sense_code_qual;
8963
8964 if (bcmp(entry, &empty, sizeof (empty)) == 0)
8965 goto done;
8966
8967 lpp->param_code[0] = 0;
8968 lpp->param_code[1] = count;
8969 lpp->param_ctrl_flags =
8970 LOG_CTRL_LP | LOG_CTRL_LBIN;
8971 lpp->param_len =
8972 SCSI_LOG_SENSE_SELFTEST_PARAM_LEN;
8973
8974 status = entry->smart_selftest_log_status;
8975 status >>= 4;
8976 switch (status) {
8977 case 0:
8978 default:
8979 sense_key = KEY_NO_SENSE;
8980 add_sense_code =
8981 SD_SCSI_ASC_NO_ADD_SENSE;
8982 break;
8983 case 1:
8984 sense_key = KEY_ABORTED_COMMAND;
8985 add_sense_code =
8986 DIAGNOSTIC_FAILURE_ON_COMPONENT;
8987 add_sense_code_qual = SCSI_COMPONENT_81;
8988 break;
8989 case 2:
8990 sense_key = KEY_ABORTED_COMMAND;
8991 add_sense_code =
8992 DIAGNOSTIC_FAILURE_ON_COMPONENT;
8993 add_sense_code_qual = SCSI_COMPONENT_82;
8994 break;
8995 case 3:
8996 sense_key = KEY_ABORTED_COMMAND;
8997 add_sense_code =
8998 DIAGNOSTIC_FAILURE_ON_COMPONENT;
8999 add_sense_code_qual = SCSI_COMPONENT_83;
9000 break;
9001 case 4:
9002 sense_key = KEY_HARDWARE_ERROR;
9003 add_sense_code =
9004 DIAGNOSTIC_FAILURE_ON_COMPONENT;
9005 add_sense_code_qual = SCSI_COMPONENT_84;
9006 break;
9007 case 5:
9008 sense_key = KEY_HARDWARE_ERROR;
9009 add_sense_code =
9010 DIAGNOSTIC_FAILURE_ON_COMPONENT;
9011 add_sense_code_qual = SCSI_COMPONENT_85;
9012 break;
9013 case 6:
9014 sense_key = KEY_HARDWARE_ERROR;
9015 add_sense_code =
9016 DIAGNOSTIC_FAILURE_ON_COMPONENT;
9017 add_sense_code_qual = SCSI_COMPONENT_86;
9018 break;
9019 case 7:
9020 sense_key = KEY_MEDIUM_ERROR;
9021 add_sense_code =
9022 DIAGNOSTIC_FAILURE_ON_COMPONENT;
9023 add_sense_code_qual = SCSI_COMPONENT_87;
9024 break;
9025 case 8:
9026 sense_key = KEY_HARDWARE_ERROR;
9027 add_sense_code =
9028 DIAGNOSTIC_FAILURE_ON_COMPONENT;
9029 add_sense_code_qual = SCSI_COMPONENT_88;
9030 break;
9031 }
9032 code = 0; /* unspecified */
9033 status |= (code << 4);
9034 lpp->param_values[0] = status;
9035 lpp->param_values[1] = 0; /* unspecified */
9036 lpp->param_values[2] = entry->
9037 smart_selftest_log_timestamp[1];
9038 lpp->param_values[3] = entry->
9039 smart_selftest_log_timestamp[0];
9040 if (status != 0) {
9041 lpp->param_values[4] = 0;
9042 lpp->param_values[5] = 0;
9043 lpp->param_values[6] = 0;
9044 lpp->param_values[7] = 0;
9045 lpp->param_values[8] = entry->
9046 smart_selftest_log_failing_lba[3];
9047 lpp->param_values[9] = entry->
9048 smart_selftest_log_failing_lba[2];
9049 lpp->param_values[10] = entry->
9050 smart_selftest_log_failing_lba[1];
9051 lpp->param_values[11] = entry->
9052 smart_selftest_log_failing_lba[0];
9053 } else { /* No block address */
9054 lpp->param_values[4] = 0xff;
9055 lpp->param_values[5] = 0xff;
9056 lpp->param_values[6] = 0xff;
9057 lpp->param_values[7] = 0xff;
9058 lpp->param_values[8] = 0xff;
9059 lpp->param_values[9] = 0xff;
9060 lpp->param_values[10] = 0xff;
9061 lpp->param_values[11] = 0xff;
9062 }
9063 lpp->param_values[12] = sense_key;
9064 lpp->param_values[13] = add_sense_code;
9065 lpp->param_values[14] = add_sense_code_qual;
9066 lpp->param_values[15] = 0; /* undefined */
9067
9068 lpp = (struct log_parameter *)
9069 (((uint8_t *)lpp) +
9070 SCSI_LOG_PARAM_HDR_LEN +
9071 SCSI_LOG_SENSE_SELFTEST_PARAM_LEN);
9072 --index; /* back up to previous entry */
9073 if (index < 0) {
9074 index =
9075 NUM_SMART_SELFTEST_LOG_ENTRIES - 1;
9076 }
9077 entry = &selftest_log->
9078 smart_selftest_log_entries[index];
9079 }
9080 }
9081 done:
9082 kmem_free(selftest_log, sizeof (struct smart_selftest_log));
9083 }
9084
9085 return ((SCSI_LOG_PARAM_HDR_LEN + SCSI_LOG_SENSE_SELFTEST_PARAM_LEN) *
9086 SCSI_ENTRIES_IN_LOG_SENSE_SELFTEST_RESULTS);
9087 }
9088
9089 /*
9090 * sata_build_lsense_page_2f() is used to create the
9091 * SCSI LOG SENSE page 0x2f (informational exceptions)
9092 *
9093 * Takes a sata_drive_info t * and the address of a buffer
9094 * in which to create the page information as well as a sata_hba_inst_t *.
9095 *
9096 * Returns the number of bytes valid in the buffer.
9097 *
9098 * Because it invokes function(s) that send synchronously executed command
9099 * to the HBA, it cannot be called in the interrupt context.
9100 */
9101 static int
9102 sata_build_lsense_page_2f(
9103 sata_drive_info_t *sdinfo,
9104 uint8_t *buf,
9105 sata_hba_inst_t *sata_hba_inst)
9106 {
9107 struct log_parameter *lpp = (struct log_parameter *)buf;
9108 int rval;
9109 uint8_t *smart_data;
9110 uint8_t temp;
9111 sata_id_t *sata_id;
9112 #define SMART_NO_TEMP 0xff
9113
9114 lpp->param_code[0] = 0;
9115 lpp->param_code[1] = 0;
9116 lpp->param_ctrl_flags = LOG_CTRL_LP | LOG_CTRL_LBIN;
9117
9118 /* Now get the SMART status w.r.t. threshold exceeded */
9119 rval = sata_fetch_smart_return_status(sata_hba_inst, sdinfo);
9120 switch (rval) {
9121 case 1:
9122 lpp->param_values[0] = SCSI_PREDICTED_FAILURE;
9123 lpp->param_values[1] = SCSI_GENERAL_HD_FAILURE;
9124 break;
9125 case 0:
9126 case -1: /* failed to get data */
9127 lpp->param_values[0] = 0; /* No failure predicted */
9128 lpp->param_values[1] = 0;
9129 break;
9130 #if defined(SATA_DEBUG)
9131 default:
9132 cmn_err(CE_PANIC, "sata_build_lsense_page_2f bad return value");
9133 /* NOTREACHED */
9134 #endif
9135 }
9136
9137 sata_id = &sdinfo->satadrv_id;
9138 if (! (sata_id->ai_sctsupport & SATA_SCT_CMD_TRANS_SUP))
9139 temp = SMART_NO_TEMP;
9140 else {
9141 /* Now get the temperature */
9142 smart_data = kmem_zalloc(512, KM_SLEEP);
9143 rval = sata_smart_read_log(sata_hba_inst, sdinfo, smart_data,
9144 SCT_STATUS_LOG_PAGE, 1);
9145 if (rval == -1)
9146 temp = SMART_NO_TEMP;
9147 else {
9148 temp = smart_data[200];
9149 if (temp & 0x80) {
9150 if (temp & 0x7f)
9151 temp = 0;
9152 else
9153 temp = SMART_NO_TEMP;
9154 }
9155 }
9156 kmem_free(smart_data, 512);
9157 }
9158
9159 lpp->param_values[2] = temp; /* most recent temperature */
9160 lpp->param_values[3] = 0; /* required vendor specific byte */
9161
9162 lpp->param_len = SCSI_INFO_EXCEPTIONS_PARAM_LEN;
9163
9164
9165 return (SCSI_INFO_EXCEPTIONS_PARAM_LEN + SCSI_LOG_PARAM_HDR_LEN);
9166 }
9167
9168 /*
9169 * sata_build_lsense_page_30() is used to create the
9170 * SCSI LOG SENSE page 0x30 (Sun's vendor specific page for ATA SMART data).
9171 *
9172 * Takes a sata_drive_info t * and the address of a buffer
9173 * in which to create the page information as well as a sata_hba_inst_t *.
9174 *
9175 * Returns the number of bytes valid in the buffer.
9176 */
9177 static int
9178 sata_build_lsense_page_30(
9179 sata_drive_info_t *sdinfo,
9180 uint8_t *buf,
9181 sata_hba_inst_t *sata_hba_inst)
9182 {
9183 struct smart_data *smart_data = (struct smart_data *)buf;
9184 int rval;
9185
9186 /* Now do the SMART READ DATA */
9187 rval = sata_fetch_smart_data(sata_hba_inst, sdinfo, smart_data);
9188 if (rval == -1)
9189 return (0);
9190
9191 return (sizeof (struct smart_data));
9192 }
9193
9194 /*
9195 * sata_build_lsense_page_0e() is used to create the
9196 * SCSI LOG SENSE page 0e (start-stop cycle counter page)
9197 *
9198 * Date of Manufacture (0x0001)
9199 * YEAR = "0000"
9200 * WEEK = "00"
9201 * Accounting Date (0x0002)
9202 * 6 ASCII space character(20h)
9203 * Specified cycle count over device lifetime
9204 * VALUE - THRESH - the delta between max and min;
9205 * Accumulated start-stop cycles
9206 * VALUE - WORST - the accumulated cycles;
9207 *
9208 * ID FLAG THRESH VALUE WORST RAW on start/stop counter attribute
9209 *
9210 * Takes a sata_drive_info t * and the address of a buffer
9211 * in which to create the page information as well as a sata_hba_inst_t *.
9212 *
9213 * Returns the number of bytes valid in the buffer.
9214 */
9215 static int
9216 sata_build_lsense_page_0e(sata_drive_info_t *sdinfo, uint8_t *buf,
9217 sata_pkt_txlate_t *spx)
9218 {
9219 struct start_stop_cycle_counter_log *log_page;
9220 int i, rval, index;
9221 uint8_t smart_data[512], id, value, worst, thresh;
9222 uint32_t max_count, cycles;
9223
9224 /* Now do the SMART READ DATA */
9225 rval = sata_fetch_smart_data(spx->txlt_sata_hba_inst, sdinfo,
9226 (struct smart_data *)smart_data);
9227 if (rval == -1)
9228 return (0);
9229 for (i = 0, id = 0; i < SMART_START_STOP_COUNT_ID * 2; i++) {
9230 index = (i * 12) + 2;
9231 id = smart_data[index];
9232 if (id != SMART_START_STOP_COUNT_ID)
9233 continue;
9234 else {
9235 thresh = smart_data[index + 2];
9236 value = smart_data[index + 3];
9237 worst = smart_data[index + 4];
9238 break;
9239 }
9240 }
9241 if (id != SMART_START_STOP_COUNT_ID)
9242 return (0);
9243 max_count = value - thresh;
9244 cycles = value - worst;
9245
9246 log_page = (struct start_stop_cycle_counter_log *)buf;
9247 bzero(log_page, sizeof (struct start_stop_cycle_counter_log));
9248 log_page->code = 0x0e;
9249 log_page->page_len_low = 0x24;
9250
9251 log_page->manufactor_date_low = 0x1;
9252 log_page->param_1.fmt_link = 0x1; /* 01b */
9253 log_page->param_len_1 = 0x06;
9254 for (i = 0; i < 4; i++) {
9255 log_page->year_manu[i] = 0x30;
9256 if (i < 2)
9257 log_page->week_manu[i] = 0x30;
9258 }
9259
9260 log_page->account_date_low = 0x02;
9261 log_page->param_2.fmt_link = 0x01; /* 01b */
9262 log_page->param_len_2 = 0x06;
9263 for (i = 0; i < 4; i++) {
9264 log_page->year_account[i] = 0x20;
9265 if (i < 2)
9266 log_page->week_account[i] = 0x20;
9267 }
9268
9269 log_page->lifetime_code_low = 0x03;
9270 log_page->param_3.fmt_link = 0x03; /* 11b */
9271 log_page->param_len_3 = 0x04;
9272 /* VALUE - THRESH - the delta between max and min */
9273 log_page->cycle_code_low = 0x04;
9274 log_page->param_4.fmt_link = 0x03; /* 11b */
9275 log_page->param_len_4 = 0x04;
9276 /* WORST - THRESH - the distance from 'now' to min */
9277
9278 for (i = 0; i < 4; i++) {
9279 log_page->cycle_lifetime[i] =
9280 (max_count >> (8 * (3 - i))) & 0xff;
9281 log_page->cycle_accumulated[i] =
9282 (cycles >> (8 * (3 - i))) & 0xff;
9283 }
9284
9285 return (sizeof (struct start_stop_cycle_counter_log));
9286 }
9287
9288 /*
9289 * This function was used for build a ATA read verify sector command
9290 */
9291 static void
9292 sata_build_read_verify_cmd(sata_cmd_t *scmd, uint16_t sec, uint64_t lba)
9293 {
9294 scmd->satacmd_cmd_reg = SATAC_RDVER;
9295 scmd->satacmd_addr_type = ATA_ADDR_LBA28;
9296 scmd->satacmd_flags.sata_special_regs = B_TRUE;
9297
9298 scmd->satacmd_sec_count_lsb = sec & 0xff;
9299 scmd->satacmd_lba_low_lsb = lba & 0xff;
9300 scmd->satacmd_lba_mid_lsb = (lba >> 8) & 0xff;
9301 scmd->satacmd_lba_high_lsb = (lba >> 16) & 0xff;
9302 scmd->satacmd_device_reg = (SATA_ADH_LBA | (lba >> 24) & 0xf);
9303 scmd->satacmd_features_reg = 0;
9304 scmd->satacmd_status_reg = 0;
9305 scmd->satacmd_error_reg = 0;
9306 }
9307
9308 /*
9309 * This function was used for building an ATA
9310 * command, and only command register need to
9311 * be defined, other register will be zero or na.
9312 */
9313 static void
9314 sata_build_generic_cmd(sata_cmd_t *scmd, uint8_t cmd)
9315 {
9316 scmd->satacmd_addr_type = 0;
9317 scmd->satacmd_cmd_reg = cmd;
9318 scmd->satacmd_device_reg = 0;
9319 scmd->satacmd_sec_count_lsb = 0;
9320 scmd->satacmd_lba_low_lsb = 0;
9321 scmd->satacmd_lba_mid_lsb = 0;
9322 scmd->satacmd_lba_high_lsb = 0;
9323 scmd->satacmd_features_reg = 0;
9324 scmd->satacmd_status_reg = 0;
9325 scmd->satacmd_error_reg = 0;
9326 scmd->satacmd_flags.sata_special_regs = B_TRUE;
9327 }
9328
9329 /*
9330 * This function was used for changing the standby
9331 * timer format from SCSI to ATA.
9332 */
9333 static uint8_t
9334 sata_get_standby_timer(uint8_t *timer)
9335 {
9336 uint32_t i = 0, count = 0;
9337 uint8_t ata_count;
9338
9339 for (i = 0; i < 4; i++) {
9340 count = count << 8 | timer[i];
9341 }
9342
9343 if (count == 0)
9344 return (0);
9345
9346 if (count >= 1 && count <= 12000)
9347 ata_count = (count -1) / 50 + 1;
9348 else if (count > 12000 && count <= 12600)
9349 ata_count = 0xfc;
9350 else if (count > 12601 && count <= 12750)
9351 ata_count = 0xff;
9352 else if (count > 12750 && count <= 17999)
9353 ata_count = 0xf1;
9354 else if (count > 18000 && count <= 198000)
9355 ata_count = count / 18000 + 240;
9356 else
9357 ata_count = 0xfd;
9358 return (ata_count);
9359 }
9360
9361 /* ************************** ATAPI-SPECIFIC FUNCTIONS ********************** */
9362
9363 /*
9364 * Start command for ATAPI device.
9365 * This function processes scsi_pkt requests.
9366 * Now CD/DVD, tape and ATAPI disk devices are supported.
9367 * Most commands are packet without any translation into Packet Command.
9368 * Some may be trapped and executed as SATA commands (not clear which one).
9369 *
9370 * Returns TRAN_ACCEPT if command is accepted for execution (or completed
9371 * execution).
9372 * Returns other TRAN_XXXX codes if command is not accepted or completed
9373 * (see return values for sata_hba_start()).
9374 *
9375 * Note:
9376 * Inquiry cdb format differs between transport version 2 and 3.
9377 * However, the transport version 3 devices that were checked did not adhere
9378 * to the specification (ignored MSB of the allocation length). Therefore,
9379 * the transport version is not checked, but Inquiry allocation length is
9380 * truncated to 255 bytes if the original allocation length set-up by the
9381 * target driver is greater than 255 bytes.
9382 */
9383 static int
9384 sata_txlt_atapi(sata_pkt_txlate_t *spx)
9385 {
9386 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt;
9387 sata_cmd_t *scmd = &spx->txlt_sata_pkt->satapkt_cmd;
9388 struct buf *bp = spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp;
9389 sata_hba_inst_t *sata_hba = SATA_TXLT_HBA_INST(spx);
9390 sata_drive_info_t *sdinfo = sata_get_device_info(sata_hba,
9391 &spx->txlt_sata_pkt->satapkt_device);
9392 kmutex_t *cport_mutex = &(SATA_TXLT_CPORT_MUTEX(spx));
9393 int cdblen;
9394 int rval, reason;
9395 int synch;
9396 union scsi_cdb *cdbp = (union scsi_cdb *)scsipkt->pkt_cdbp;
9397
9398 mutex_enter(cport_mutex);
9399
9400 if (((rval = sata_txlt_generic_pkt_info(spx, &reason, 0)) !=
9401 TRAN_ACCEPT) || (reason == CMD_DEV_GONE)) {
9402 mutex_exit(cport_mutex);
9403 return (rval);
9404 }
9405
9406 /*
9407 * ATAPI device executes some ATA commands in addition to those
9408 * commands sent via PACKET command. These ATA commands may be
9409 * executed by the regular SATA translation functions. None needs
9410 * to be captured now.
9411 *
9412 * Commands sent via PACKET command include:
9413 * MMC command set for ATAPI CD/DVD device
9414 * SSC command set for ATAPI TAPE device
9415 * SBC command set for ATAPI disk device
9416 *
9417 */
9418
9419 /* Check the size of cdb */
9420
9421 switch (GETGROUP(cdbp)) {
9422 case CDB_GROUPID_3: /* Reserved, per SPC-4 */
9423 /*
9424 * opcodes 0x7e and 0x7f identify variable-length CDBs and
9425 * therefore require special handling. Return failure, for now.
9426 */
9427 mutex_exit(cport_mutex);
9428 return (TRAN_BADPKT);
9429
9430 case CDB_GROUPID_6: /* Vendor-specific, per SPC-4 */
9431 case CDB_GROUPID_7: /* Vendor-specific, per SPC-4 */
9432 /* obtain length from the scsi_pkt */
9433 cdblen = scsipkt->pkt_cdblen;
9434 break;
9435
9436 default:
9437 /* CDB's length is statically known, per SPC-4 */
9438 cdblen = scsi_cdb_size[GETGROUP(cdbp)];
9439 break;
9440 }
9441
9442 if (cdblen <= 0 || cdblen > sdinfo->satadrv_atapi_cdb_len) {
9443 sata_log(NULL, CE_WARN,
9444 "sata: invalid ATAPI cdb length %d",
9445 cdblen);
9446 mutex_exit(cport_mutex);
9447 return (TRAN_BADPKT);
9448 }
9449
9450 SATAATAPITRACE(spx, cdblen);
9451
9452 /*
9453 * For non-read/write commands we need to
9454 * map buffer
9455 */
9456 switch ((uint_t)scsipkt->pkt_cdbp[0]) {
9457 case SCMD_READ:
9458 case SCMD_READ_G1:
9459 case SCMD_READ_G5:
9460 case SCMD_READ_G4:
9461 case SCMD_WRITE:
9462 case SCMD_WRITE_G1:
9463 case SCMD_WRITE_G5:
9464 case SCMD_WRITE_G4:
9465 break;
9466 default:
9467 if (bp != NULL) {
9468 if (bp->b_flags & (B_PHYS | B_PAGEIO))
9469 bp_mapin(bp);
9470 }
9471 break;
9472 }
9473 /*
9474 * scmd->satacmd_flags.sata_data_direction default -
9475 * SATA_DIR_NODATA_XFER - is set by
9476 * sata_txlt_generic_pkt_info().
9477 */
9478 if (scmd->satacmd_bp) {
9479 if (scmd->satacmd_bp->b_flags & B_READ) {
9480 scmd->satacmd_flags.sata_data_direction = SATA_DIR_READ;
9481 } else {
9482 scmd->satacmd_flags.sata_data_direction =
9483 SATA_DIR_WRITE;
9484 }
9485 }
9486
9487 /*
9488 * Set up ATAPI packet command.
9489 */
9490
9491 sata_atapi_packet_cmd_setup(scmd, sdinfo);
9492
9493 /* Copy cdb into sata_cmd */
9494 scmd->satacmd_acdb_len = sdinfo->satadrv_atapi_cdb_len;
9495 bzero(scmd->satacmd_acdb, SATA_ATAPI_MAX_CDB_LEN);
9496 bcopy(cdbp, scmd->satacmd_acdb, cdblen);
9497
9498 /* See note in the command header */
9499 if (scmd->satacmd_acdb[0] == SCMD_INQUIRY) {
9500 if (scmd->satacmd_acdb[3] != 0)
9501 scmd->satacmd_acdb[4] = 255;
9502 }
9503
9504 #ifdef SATA_DEBUG
9505 if (sata_debug_flags & SATA_DBG_ATAPI) {
9506 uint8_t *p = scmd->satacmd_acdb;
9507 char buf[3 * SATA_ATAPI_MAX_CDB_LEN];
9508
9509 (void) snprintf(buf, SATA_ATAPI_MAX_CDB_LEN,
9510 "%02x %02x %02x %02x %02x %02x %02x %02x "
9511 "%2x %02x %02x %02x %02x %02x %02x %02x",
9512 p[0], p[1], p[2], p[3], p[4], p[5], p[6], p[7],
9513 p[8], p[9], p[10], p[11], p[12], p[13], p[14], p[15]);
9514 buf[(3 * SATA_ATAPI_MAX_CDB_LEN) - 1] = '\0';
9515 cmn_err(CE_NOTE, "ATAPI cdb: %s\n", buf);
9516 }
9517 #endif
9518
9519 /*
9520 * Preset request sense data to NO SENSE.
9521 * If there is no way to get error information via Request Sense,
9522 * the packet request sense data would not have to be modified by HBA,
9523 * but it could be returned as is.
9524 */
9525 bzero(scmd->satacmd_rqsense, SATA_ATAPI_RQSENSE_LEN);
9526 sata_fixed_sense_data_preset(
9527 (struct scsi_extended_sense *)scmd->satacmd_rqsense);
9528
9529 if (!(spx->txlt_sata_pkt->satapkt_op_mode & SATA_OPMODE_SYNCH)) {
9530 /* Need callback function */
9531 spx->txlt_sata_pkt->satapkt_comp = sata_txlt_atapi_completion;
9532 synch = FALSE;
9533 } else
9534 synch = TRUE;
9535
9536 /* Transfer command to HBA */
9537 if (sata_hba_start(spx, &rval) != 0) {
9538 /* Pkt not accepted for execution */
9539 mutex_exit(cport_mutex);
9540 return (rval);
9541 }
9542 mutex_exit(cport_mutex);
9543 /*
9544 * If execution is non-synchronous,
9545 * a callback function will handle potential errors, translate
9546 * the response and will do a callback to a target driver.
9547 * If it was synchronous, use the same framework callback to check
9548 * an execution status.
9549 */
9550 if (synch) {
9551 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst,
9552 "synchronous execution status %x\n",
9553 spx->txlt_sata_pkt->satapkt_reason);
9554 sata_txlt_atapi_completion(spx->txlt_sata_pkt);
9555 }
9556 return (TRAN_ACCEPT);
9557 }
9558
9559
9560 /*
9561 * ATAPI Packet command completion.
9562 *
9563 * Failure of the command passed via Packet command are considered device
9564 * error. SATA HBA driver would have to retrieve error data (via Request
9565 * Sense command delivered via error retrieval sata packet) and copy it
9566 * to satacmd_rqsense array. From there, it is moved into scsi pkt sense data.
9567 */
9568 static void
9569 sata_txlt_atapi_completion(sata_pkt_t *sata_pkt)
9570 {
9571 sata_pkt_txlate_t *spx =
9572 (sata_pkt_txlate_t *)sata_pkt->satapkt_framework_private;
9573 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt;
9574 struct scsi_extended_sense *sense;
9575 struct buf *bp;
9576 int rval;
9577
9578 #ifdef SATA_DEBUG
9579 uint8_t *rqsp = sata_pkt->satapkt_cmd.satacmd_rqsense;
9580 #endif
9581
9582 scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET |
9583 STATE_SENT_CMD | STATE_GOT_STATUS;
9584
9585 if (sata_pkt->satapkt_reason == SATA_PKT_COMPLETED) {
9586 /* Normal completion */
9587 if (sata_pkt->satapkt_cmd.satacmd_bp != NULL)
9588 scsipkt->pkt_state |= STATE_XFERRED_DATA;
9589 scsipkt->pkt_reason = CMD_CMPLT;
9590 *scsipkt->pkt_scbp = STATUS_GOOD;
9591 if (spx->txlt_tmp_buf != NULL) {
9592 /* Temporary buffer was used */
9593 bp = spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp;
9594 if (bp->b_flags & B_READ) {
9595 rval = ddi_dma_sync(
9596 spx->txlt_buf_dma_handle, 0, 0,
9597 DDI_DMA_SYNC_FORCPU);
9598 ASSERT(rval == DDI_SUCCESS);
9599 bcopy(spx->txlt_tmp_buf, bp->b_un.b_addr,
9600 bp->b_bcount);
9601 }
9602 }
9603 } else {
9604 /*
9605 * Something went wrong - analyze return
9606 */
9607 *scsipkt->pkt_scbp = STATUS_CHECK;
9608 sense = sata_arq_sense(spx);
9609
9610 if (sata_pkt->satapkt_reason == SATA_PKT_DEV_ERROR) {
9611 /*
9612 * pkt_reason should be CMD_CMPLT for DEVICE ERROR.
9613 * Under this condition ERR bit is set for ATA command,
9614 * and CHK bit set for ATAPI command.
9615 *
9616 * Please check st_intr & sdintr about how pkt_reason
9617 * is used.
9618 */
9619 scsipkt->pkt_reason = CMD_CMPLT;
9620
9621 /*
9622 * We may not have ARQ data if there was a double
9623 * error. But sense data in sata packet was pre-set
9624 * with NO SENSE so it is valid even if HBA could
9625 * not retrieve a real sense data.
9626 * Just copy this sense data into scsi pkt sense area.
9627 */
9628 bcopy(sata_pkt->satapkt_cmd.satacmd_rqsense, sense,
9629 SATA_ATAPI_MIN_RQSENSE_LEN);
9630 #ifdef SATA_DEBUG
9631 if (sata_debug_flags & SATA_DBG_SCSI_IF) {
9632 sata_log(spx->txlt_sata_hba_inst, CE_WARN,
9633 "sata_txlt_atapi_completion: %02x\n"
9634 "RQSENSE: %02x %02x %02x %02x %02x %02x "
9635 " %02x %02x %02x %02x %02x %02x "
9636 " %02x %02x %02x %02x %02x %02x\n",
9637 scsipkt->pkt_reason,
9638 rqsp[0], rqsp[1], rqsp[2], rqsp[3],
9639 rqsp[4], rqsp[5], rqsp[6], rqsp[7],
9640 rqsp[8], rqsp[9], rqsp[10], rqsp[11],
9641 rqsp[12], rqsp[13], rqsp[14], rqsp[15],
9642 rqsp[16], rqsp[17]);
9643 }
9644 #endif
9645 } else {
9646 switch (sata_pkt->satapkt_reason) {
9647 case SATA_PKT_PORT_ERROR:
9648 /*
9649 * We have no device data.
9650 */
9651 scsipkt->pkt_reason = CMD_INCOMPLETE;
9652 scsipkt->pkt_state &= ~(STATE_GOT_BUS |
9653 STATE_GOT_TARGET | STATE_SENT_CMD |
9654 STATE_GOT_STATUS);
9655 sense->es_key = KEY_HARDWARE_ERROR;
9656 break;
9657
9658 case SATA_PKT_TIMEOUT:
9659 scsipkt->pkt_reason = CMD_TIMEOUT;
9660 scsipkt->pkt_statistics |=
9661 STAT_TIMEOUT | STAT_DEV_RESET;
9662 /*
9663 * Need to check if HARDWARE_ERROR/
9664 * TIMEOUT_ON_LOGICAL_UNIT 4/3E/2 would be more
9665 * appropriate.
9666 */
9667 break;
9668
9669 case SATA_PKT_ABORTED:
9670 scsipkt->pkt_reason = CMD_ABORTED;
9671 scsipkt->pkt_statistics |= STAT_ABORTED;
9672 /* Should we set key COMMAND_ABPRTED? */
9673 break;
9674
9675 case SATA_PKT_RESET:
9676 scsipkt->pkt_reason = CMD_RESET;
9677 scsipkt->pkt_statistics |= STAT_DEV_RESET;
9678 /*
9679 * May be we should set Unit Attention /
9680 * Reset. Perhaps the same should be
9681 * returned for disks....
9682 */
9683 sense->es_key = KEY_UNIT_ATTENTION;
9684 sense->es_add_code = SD_SCSI_ASC_RESET;
9685 break;
9686
9687 default:
9688 SATA_LOG_D((spx->txlt_sata_hba_inst, CE_WARN,
9689 "sata_txlt_atapi_completion: "
9690 "invalid packet completion reason"));
9691 scsipkt->pkt_reason = CMD_TRAN_ERR;
9692 scsipkt->pkt_state &= ~(STATE_GOT_BUS |
9693 STATE_GOT_TARGET | STATE_SENT_CMD |
9694 STATE_GOT_STATUS);
9695 break;
9696 }
9697 }
9698 }
9699
9700 SATAATAPITRACE(spx, 0);
9701
9702 if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0 &&
9703 scsipkt->pkt_comp != NULL) {
9704 /* scsi callback required */
9705 (*scsipkt->pkt_comp)(scsipkt);
9706 }
9707 }
9708
9709 /*
9710 * Set up error retrieval sata command for ATAPI Packet Command error data
9711 * recovery.
9712 *
9713 * Returns SATA_SUCCESS when data buffer is allocated and packet set-up,
9714 * returns SATA_FAILURE otherwise.
9715 */
9716
9717 static int
9718 sata_atapi_err_ret_cmd_setup(sata_pkt_txlate_t *spx, sata_drive_info_t *sdinfo)
9719 {
9720 sata_pkt_t *spkt = spx->txlt_sata_pkt;
9721 sata_cmd_t *scmd;
9722 struct buf *bp;
9723
9724 /*
9725 * Allocate dma-able buffer error data.
9726 * Buffer allocation will take care of buffer alignment and other DMA
9727 * attributes.
9728 */
9729 bp = sata_alloc_local_buffer(spx, SATA_ATAPI_MIN_RQSENSE_LEN);
9730 if (bp == NULL) {
9731 SATADBG1(SATA_DBG_ATAPI, spx->txlt_sata_hba_inst,
9732 "sata_get_err_retrieval_pkt: "
9733 "cannot allocate buffer for error data", NULL);
9734 return (SATA_FAILURE);
9735 }
9736 bp_mapin(bp); /* make data buffer accessible */
9737
9738 /* Operation modes are up to the caller */
9739 spkt->satapkt_op_mode = SATA_OPMODE_SYNCH | SATA_OPMODE_INTERRUPTS;
9740
9741 /* Synchronous mode, no callback - may be changed by the caller */
9742 spkt->satapkt_comp = NULL;
9743 spkt->satapkt_time = sata_default_pkt_time;
9744
9745 scmd = &spkt->satapkt_cmd;
9746 scmd->satacmd_flags.sata_data_direction = SATA_DIR_READ;
9747 scmd->satacmd_flags.sata_ignore_dev_reset = B_TRUE;
9748
9749 sata_atapi_packet_cmd_setup(scmd, sdinfo);
9750
9751 /*
9752 * Set-up acdb. Request Sense CDB (packet command content) is
9753 * not in DMA-able buffer. Its handling is HBA-specific (how
9754 * it is transfered into packet FIS).
9755 */
9756 scmd->satacmd_acdb_len = sdinfo->satadrv_atapi_cdb_len;
9757 bcopy(sata_rqsense_cdb, scmd->satacmd_acdb, SATA_ATAPI_RQSENSE_CDB_LEN);
9758 /* Following zeroing of pad bytes may not be necessary */
9759 bzero(&scmd->satacmd_acdb[SATA_ATAPI_RQSENSE_CDB_LEN],
9760 sdinfo->satadrv_atapi_cdb_len - SATA_ATAPI_RQSENSE_CDB_LEN);
9761
9762 /*
9763 * Set-up pointer to the buffer handle, so HBA can sync buffer
9764 * before accessing it. Handle is in usual place in translate struct.
9765 */
9766 scmd->satacmd_err_ret_buf_handle = &spx->txlt_buf_dma_handle;
9767
9768 /*
9769 * Preset request sense data to NO SENSE.
9770 * Here it is redundant, only for a symetry with scsi-originated
9771 * packets. It should not be used for anything but debugging.
9772 */
9773 bzero(scmd->satacmd_rqsense, SATA_ATAPI_RQSENSE_LEN);
9774 sata_fixed_sense_data_preset(
9775 (struct scsi_extended_sense *)scmd->satacmd_rqsense);
9776
9777 ASSERT(scmd->satacmd_num_dma_cookies != 0);
9778 ASSERT(scmd->satacmd_dma_cookie_list != NULL);
9779
9780 return (SATA_SUCCESS);
9781 }
9782
9783 /*
9784 * Set-up ATAPI packet command.
9785 * Data transfer direction has to be set-up in sata_cmd structure prior to
9786 * calling this function.
9787 *
9788 * Returns void
9789 */
9790
9791 static void
9792 sata_atapi_packet_cmd_setup(sata_cmd_t *scmd, sata_drive_info_t *sdinfo)
9793 {
9794 scmd->satacmd_addr_type = 0; /* N/A */
9795 scmd->satacmd_sec_count_lsb = 0; /* no tag */
9796 scmd->satacmd_lba_low_lsb = 0; /* N/A */
9797 scmd->satacmd_lba_mid_lsb = (uint8_t)SATA_ATAPI_MAX_BYTES_PER_DRQ;
9798 scmd->satacmd_lba_high_lsb =
9799 (uint8_t)(SATA_ATAPI_MAX_BYTES_PER_DRQ >> 8);
9800 scmd->satacmd_cmd_reg = SATAC_PACKET; /* Command */
9801
9802 /*
9803 * We want all data to be transfered via DMA.
9804 * But specify it only if drive supports DMA and DMA mode is
9805 * selected - some drives are sensitive about it.
9806 * Hopefully it wil work for all drives....
9807 */
9808 if (sdinfo->satadrv_settings & SATA_DEV_DMA)
9809 scmd->satacmd_features_reg = SATA_ATAPI_F_DMA;
9810
9811 /*
9812 * Features register requires special care for devices that use
9813 * Serial ATA bridge - they need an explicit specification of
9814 * the data transfer direction for Packet DMA commands.
9815 * Setting this bit is harmless if DMA is not used.
9816 *
9817 * Many drives do not implement word 80, specifying what ATA/ATAPI
9818 * spec they follow.
9819 * We are arbitrarily following the latest SerialATA 2.6 spec,
9820 * which uses ATA/ATAPI 6 specification for Identify Data, unless
9821 * ATA/ATAPI-7 support is explicitly indicated.
9822 */
9823 if (sdinfo->satadrv_id.ai_majorversion != 0 &&
9824 sdinfo->satadrv_id.ai_majorversion != 0xffff &&
9825 (sdinfo->satadrv_id.ai_majorversion & SATA_MAJVER_7) != 0) {
9826 /*
9827 * Specification of major version is valid and version 7
9828 * is supported. It does automatically imply that all
9829 * spec features are supported. For now, we assume that
9830 * DMADIR setting is valid. ATA/ATAPI7 spec is incomplete.
9831 */
9832 if ((sdinfo->satadrv_id.ai_dirdma &
9833 SATA_ATAPI_ID_DMADIR_REQ) != 0) {
9834 if (scmd->satacmd_flags.sata_data_direction ==
9835 SATA_DIR_READ)
9836 scmd->satacmd_features_reg |=
9837 SATA_ATAPI_F_DATA_DIR_READ;
9838 }
9839 }
9840 }
9841
9842
9843 #ifdef SATA_DEBUG
9844
9845 /* Display 18 bytes of Inquiry data */
9846 static void
9847 sata_show_inqry_data(uint8_t *buf)
9848 {
9849 struct scsi_inquiry *inq = (struct scsi_inquiry *)buf;
9850 uint8_t *p;
9851
9852 cmn_err(CE_NOTE, "Inquiry data:");
9853 cmn_err(CE_NOTE, "device type %x", inq->inq_dtype);
9854 cmn_err(CE_NOTE, "removable media %x", inq->inq_rmb);
9855 cmn_err(CE_NOTE, "version %x", inq->inq_ansi);
9856 cmn_err(CE_NOTE, "ATAPI transport version %d",
9857 SATA_ATAPI_TRANS_VERSION(inq));
9858 cmn_err(CE_NOTE, "response data format %d, aenc %d",
9859 inq->inq_rdf, inq->inq_aenc);
9860 cmn_err(CE_NOTE, " additional length %d", inq->inq_len);
9861 cmn_err(CE_NOTE, "tpgs %d", inq->inq_tpgs);
9862 p = (uint8_t *)inq->inq_vid;
9863 cmn_err(CE_NOTE, "vendor id (binary): %02x %02x %02x %02x "
9864 "%02x %02x %02x %02x",
9865 p[0], p[1], p[2], p[3], p[4], p[5], p[6], p[7]);
9866 p = (uint8_t *)inq->inq_vid;
9867 cmn_err(CE_NOTE, "vendor id: %c %c %c %c %c %c %c %c",
9868 p[0], p[1], p[2], p[3], p[4], p[5], p[6], p[7]);
9869
9870 p = (uint8_t *)inq->inq_pid;
9871 cmn_err(CE_NOTE, "product id (binary): %02x %02x %02x %02x "
9872 "%02x %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x",
9873 p[0], p[1], p[2], p[3], p[4], p[5], p[6], p[7],
9874 p[8], p[9], p[10], p[11], p[12], p[13], p[14], p[15]);
9875 p = (uint8_t *)inq->inq_pid;
9876 cmn_err(CE_NOTE, "product id: %c %c %c %c %c %c %c %c "
9877 "%c %c %c %c %c %c %c %c",
9878 p[0], p[1], p[2], p[3], p[4], p[5], p[6], p[7],
9879 p[8], p[9], p[10], p[11], p[12], p[13], p[14], p[15]);
9880
9881 p = (uint8_t *)inq->inq_revision;
9882 cmn_err(CE_NOTE, "revision (binary): %02x %02x %02x %02x",
9883 p[0], p[1], p[2], p[3]);
9884 p = (uint8_t *)inq->inq_revision;
9885 cmn_err(CE_NOTE, "revision: %c %c %c %c",
9886 p[0], p[1], p[2], p[3]);
9887
9888 }
9889
9890
9891 static void
9892 sata_save_atapi_trace(sata_pkt_txlate_t *spx, int count)
9893 {
9894 struct scsi_pkt *scsi_pkt = spx->txlt_scsi_pkt;
9895
9896 if (scsi_pkt == NULL)
9897 return;
9898 if (count != 0) {
9899 /* saving cdb */
9900 bzero(sata_atapi_trace[sata_atapi_trace_index].acdb,
9901 SATA_ATAPI_MAX_CDB_LEN);
9902 bcopy(scsi_pkt->pkt_cdbp,
9903 sata_atapi_trace[sata_atapi_trace_index].acdb, count);
9904 } else {
9905 bcopy(&((struct scsi_arq_status *)scsi_pkt->pkt_scbp)->
9906 sts_sensedata,
9907 sata_atapi_trace[sata_atapi_trace_index].arqs,
9908 SATA_ATAPI_MIN_RQSENSE_LEN);
9909 sata_atapi_trace[sata_atapi_trace_index].scsi_pkt_reason =
9910 scsi_pkt->pkt_reason;
9911 sata_atapi_trace[sata_atapi_trace_index].sata_pkt_reason =
9912 spx->txlt_sata_pkt->satapkt_reason;
9913
9914 if (++sata_atapi_trace_index >= 64)
9915 sata_atapi_trace_index = 0;
9916 }
9917 }
9918
9919 #endif
9920
9921 /*
9922 * Fetch inquiry data from ATAPI device
9923 * Returns SATA_SUCCESS if operation was successful, SATA_FAILURE otherwise.
9924 *
9925 * Note:
9926 * inqb pointer does not point to a DMA-able buffer. It is a local buffer
9927 * where the caller expects to see the inquiry data.
9928 *
9929 */
9930
9931 static int
9932 sata_get_atapi_inquiry_data(sata_hba_inst_t *sata_hba,
9933 sata_address_t *saddr, struct scsi_inquiry *inq)
9934 {
9935 sata_pkt_txlate_t *spx;
9936 sata_pkt_t *spkt;
9937 struct buf *bp;
9938 sata_drive_info_t *sdinfo;
9939 sata_cmd_t *scmd;
9940 int rval;
9941 uint8_t *rqsp;
9942 dev_info_t *dip = SATA_DIP(sata_hba);
9943 #ifdef SATA_DEBUG
9944 char msg_buf[MAXPATHLEN];
9945 #endif
9946 kmutex_t *cport_mutex;
9947
9948 ASSERT(sata_hba != NULL);
9949
9950 spx = kmem_zalloc(sizeof (sata_pkt_txlate_t), KM_SLEEP);
9951 spx->txlt_sata_hba_inst = sata_hba;
9952 spx->txlt_scsi_pkt = NULL; /* No scsi pkt involved */
9953 spkt = sata_pkt_alloc(spx, NULL);
9954 if (spkt == NULL) {
9955 kmem_free(spx, sizeof (sata_pkt_txlate_t));
9956 return (SATA_FAILURE);
9957 }
9958 /* address is needed now */
9959 spkt->satapkt_device.satadev_addr = *saddr;
9960
9961 /* scsi_inquiry size buffer */
9962 bp = sata_alloc_local_buffer(spx, sizeof (struct scsi_inquiry));
9963 if (bp == NULL) {
9964 sata_pkt_free(spx);
9965 kmem_free(spx, sizeof (sata_pkt_txlate_t));
9966 SATA_LOG_D((sata_hba, CE_WARN,
9967 "sata_get_atapi_inquiry_data: "
9968 "cannot allocate data buffer"));
9969 return (SATA_FAILURE);
9970 }
9971 bp_mapin(bp); /* make data buffer accessible */
9972
9973 scmd = &spkt->satapkt_cmd;
9974 ASSERT(scmd->satacmd_num_dma_cookies != 0);
9975 ASSERT(scmd->satacmd_dma_cookie_list != NULL);
9976
9977 /* Use synchronous mode */
9978 spkt->satapkt_op_mode = SATA_OPMODE_SYNCH | SATA_OPMODE_INTERRUPTS;
9979 spkt->satapkt_comp = NULL;
9980 spkt->satapkt_time = sata_default_pkt_time;
9981
9982 /* Issue inquiry command - 6 bytes cdb, data transfer, read */
9983
9984 scmd->satacmd_flags.sata_data_direction = SATA_DIR_READ;
9985 scmd->satacmd_flags.sata_ignore_dev_reset = B_TRUE;
9986
9987 cport_mutex = &(SATA_CPORT_MUTEX(sata_hba, saddr->cport));
9988 mutex_enter(cport_mutex);
9989 sdinfo = sata_get_device_info(sata_hba,
9990 &spx->txlt_sata_pkt->satapkt_device);
9991 if (sdinfo == NULL) {
9992 /* we have to be carefull about the disapearing device */
9993 mutex_exit(cport_mutex);
9994 rval = SATA_FAILURE;
9995 goto cleanup;
9996 }
9997 sata_atapi_packet_cmd_setup(scmd, sdinfo);
9998
9999 /*
10000 * Set-up acdb. This works for atapi transport version 2 and later.
10001 */
10002 scmd->satacmd_acdb_len = sdinfo->satadrv_atapi_cdb_len;
10003 bzero(scmd->satacmd_acdb, SATA_ATAPI_MAX_CDB_LEN);
10004 scmd->satacmd_acdb[0] = 0x12; /* Inquiry */
10005 scmd->satacmd_acdb[1] = 0x00;
10006 scmd->satacmd_acdb[2] = 0x00;
10007 scmd->satacmd_acdb[3] = 0x00;
10008 scmd->satacmd_acdb[4] = sizeof (struct scsi_inquiry);
10009 scmd->satacmd_acdb[5] = 0x00;
10010
10011 sata_fixed_sense_data_preset(
10012 (struct scsi_extended_sense *)scmd->satacmd_rqsense);
10013
10014 /* Transfer command to HBA */
10015 if (sata_hba_start(spx, &rval) != 0) {
10016 /* Pkt not accepted for execution */
10017 SATADBG1(SATA_DBG_ATAPI, sata_hba,
10018 "sata_get_atapi_inquiry_data: "
10019 "Packet not accepted for execution - ret: %02x", rval);
10020 mutex_exit(cport_mutex);
10021 rval = SATA_FAILURE;
10022 goto cleanup;
10023 }
10024 mutex_exit(cport_mutex);
10025
10026 if (spkt->satapkt_reason == SATA_PKT_COMPLETED) {
10027 SATADBG1(SATA_DBG_ATAPI, sata_hba,
10028 "sata_get_atapi_inquiry_data: "
10029 "Packet completed successfully - ret: %02x", rval);
10030 if (spx->txlt_buf_dma_handle != NULL) {
10031 /*
10032 * Sync buffer. Handle is in usual place in translate
10033 * struct.
10034 */
10035 rval = ddi_dma_sync(spx->txlt_buf_dma_handle, 0, 0,
10036 DDI_DMA_SYNC_FORCPU);
10037 ASSERT(rval == DDI_SUCCESS);
10038 }
10039
10040 if (sata_check_for_dma_error(dip, spx)) {
10041 ddi_fm_service_impact(dip, DDI_SERVICE_UNAFFECTED);
10042 rval = SATA_FAILURE;
10043 } else {
10044 /*
10045 * Normal completion - copy data into caller's buffer
10046 */
10047 bcopy(bp->b_un.b_addr, (uint8_t *)inq,
10048 sizeof (struct scsi_inquiry));
10049 #ifdef SATA_DEBUG
10050 if (sata_debug_flags & SATA_DBG_ATAPI) {
10051 sata_show_inqry_data((uint8_t *)inq);
10052 }
10053 #endif
10054 rval = SATA_SUCCESS;
10055 }
10056 } else {
10057 /*
10058 * Something went wrong - analyze return - check rqsense data
10059 */
10060 rval = SATA_FAILURE;
10061 if (spkt->satapkt_reason == SATA_PKT_DEV_ERROR) {
10062 /*
10063 * ARQ data hopefull show something other than NO SENSE
10064 */
10065 rqsp = scmd->satacmd_rqsense;
10066 #ifdef SATA_DEBUG
10067 if (sata_debug_flags & SATA_DBG_ATAPI) {
10068 msg_buf[0] = '\0';
10069 (void) snprintf(msg_buf, MAXPATHLEN,
10070 "ATAPI packet completion reason: %02x\n"
10071 "RQSENSE: %02x %02x %02x %02x %02x %02x\n"
10072 " %02x %02x %02x %02x %02x %02x\n"
10073 " %02x %02x %02x %02x %02x %02x",
10074 spkt->satapkt_reason,
10075 rqsp[0], rqsp[1], rqsp[2], rqsp[3],
10076 rqsp[4], rqsp[5], rqsp[6], rqsp[7],
10077 rqsp[8], rqsp[9], rqsp[10], rqsp[11],
10078 rqsp[12], rqsp[13], rqsp[14], rqsp[15],
10079 rqsp[16], rqsp[17]);
10080 sata_log(spx->txlt_sata_hba_inst, CE_WARN,
10081 "%s", msg_buf);
10082 }
10083 #endif
10084 } else {
10085 switch (spkt->satapkt_reason) {
10086 case SATA_PKT_PORT_ERROR:
10087 SATADBG1(SATA_DBG_ATAPI, sata_hba,
10088 "sata_get_atapi_inquiry_data: "
10089 "packet reason: port error", NULL);
10090 break;
10091
10092 case SATA_PKT_TIMEOUT:
10093 SATADBG1(SATA_DBG_ATAPI, sata_hba,
10094 "sata_get_atapi_inquiry_data: "
10095 "packet reason: timeout", NULL);
10096 break;
10097
10098 case SATA_PKT_ABORTED:
10099 SATADBG1(SATA_DBG_ATAPI, sata_hba,
10100 "sata_get_atapi_inquiry_data: "
10101 "packet reason: aborted", NULL);
10102 break;
10103
10104 case SATA_PKT_RESET:
10105 SATADBG1(SATA_DBG_ATAPI, sata_hba,
10106 "sata_get_atapi_inquiry_data: "
10107 "packet reason: reset\n", NULL);
10108 break;
10109 default:
10110 SATADBG1(SATA_DBG_ATAPI, sata_hba,
10111 "sata_get_atapi_inquiry_data: "
10112 "invalid packet reason: %02x\n",
10113 spkt->satapkt_reason);
10114 break;
10115 }
10116 }
10117 }
10118 cleanup:
10119 sata_free_local_buffer(spx);
10120 sata_pkt_free(spx);
10121 kmem_free(spx, sizeof (sata_pkt_txlate_t));
10122 return (rval);
10123 }
10124
10125
10126
10127
10128
10129 #if 0
10130 #ifdef SATA_DEBUG
10131
10132 /*
10133 * Test ATAPI packet command.
10134 * Single threaded test: send packet command in synch mode, process completion
10135 *
10136 */
10137 static void
10138 sata_test_atapi_packet_command(sata_hba_inst_t *sata_hba_inst, int cport)
10139 {
10140 sata_pkt_txlate_t *spx;
10141 sata_pkt_t *spkt;
10142 struct buf *bp;
10143 sata_device_t sata_device;
10144 sata_drive_info_t *sdinfo;
10145 sata_cmd_t *scmd;
10146 int rval;
10147 uint8_t *rqsp;
10148
10149 ASSERT(sata_hba_inst != NULL);
10150 sata_device.satadev_addr.cport = cport;
10151 sata_device.satadev_addr.pmport = 0;
10152 sata_device.satadev_addr.qual = SATA_ADDR_DCPORT;
10153 sata_device.satadev_rev = SATA_DEVICE_REV;
10154 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex);
10155 sdinfo = sata_get_device_info(sata_hba_inst, &sata_device);
10156 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex);
10157 if (sdinfo == NULL) {
10158 sata_log(sata_hba_inst, CE_WARN,
10159 "sata_test_atapi_packet_command: "
10160 "no device info for cport %d",
10161 sata_device.satadev_addr.cport);
10162 return;
10163 }
10164
10165 spx = kmem_zalloc(sizeof (sata_pkt_txlate_t), KM_SLEEP);
10166 spx->txlt_sata_hba_inst = sata_hba_inst;
10167 spx->txlt_scsi_pkt = NULL; /* No scsi pkt involved */
10168 spkt = sata_pkt_alloc(spx, NULL);
10169 if (spkt == NULL) {
10170 kmem_free(spx, sizeof (sata_pkt_txlate_t));
10171 return;
10172 }
10173 /* address is needed now */
10174 spkt->satapkt_device.satadev_addr = sata_device.satadev_addr;
10175
10176 /* 1024k buffer */
10177 bp = sata_alloc_local_buffer(spx, 1024);
10178 if (bp == NULL) {
10179 sata_pkt_free(spx);
10180 kmem_free(spx, sizeof (sata_pkt_txlate_t));
10181 sata_log(sata_hba_inst, CE_WARN,
10182 "sata_test_atapi_packet_command: "
10183 "cannot allocate data buffer");
10184 return;
10185 }
10186 bp_mapin(bp); /* make data buffer accessible */
10187
10188 scmd = &spkt->satapkt_cmd;
10189 ASSERT(scmd->satacmd_num_dma_cookies != 0);
10190 ASSERT(scmd->satacmd_dma_cookie_list != NULL);
10191
10192 /* Use synchronous mode */
10193 spkt->satapkt_op_mode = SATA_OPMODE_SYNCH | SATA_OPMODE_INTERRUPTS;
10194
10195 /* Synchronous mode, no callback - may be changed by the caller */
10196 spkt->satapkt_comp = NULL;
10197 spkt->satapkt_time = sata_default_pkt_time;
10198
10199 /* Issue inquiry command - 6 bytes cdb, data transfer, read */
10200
10201 scmd->satacmd_flags.sata_data_direction = SATA_DIR_READ;
10202 scmd->satacmd_flags.sata_ignore_dev_reset = B_TRUE;
10203
10204 sata_atapi_packet_cmd_setup(scmd, sdinfo);
10205
10206 /* Set-up acdb. */
10207 scmd->satacmd_acdb_len = sdinfo->satadrv_atapi_cdb_len;
10208 bzero(scmd->satacmd_acdb, SATA_ATAPI_MAX_CDB_LEN);
10209 scmd->satacmd_acdb[0] = 0x12; /* Inquiry */
10210 scmd->satacmd_acdb[1] = 0x00;
10211 scmd->satacmd_acdb[2] = 0x00;
10212 scmd->satacmd_acdb[3] = 0x00;
10213 scmd->satacmd_acdb[4] = sizeof (struct scsi_inquiry);
10214 scmd->satacmd_acdb[5] = 0x00;
10215
10216 sata_fixed_sense_data_preset(
10217 (struct scsi_extended_sense *)scmd->satacmd_rqsense);
10218
10219 /* Transfer command to HBA */
10220 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex);
10221 if (sata_hba_start(spx, &rval) != 0) {
10222 /* Pkt not accepted for execution */
10223 sata_log(sata_hba_inst, CE_WARN,
10224 "sata_test_atapi_packet_command: "
10225 "Packet not accepted for execution - ret: %02x", rval);
10226 mutex_exit(
10227 &SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex);
10228 goto cleanup;
10229 }
10230 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex);
10231
10232 if (spx->txlt_buf_dma_handle != NULL) {
10233 /*
10234 * Sync buffer. Handle is in usual place in translate struct.
10235 */
10236 rval = ddi_dma_sync(spx->txlt_buf_dma_handle, 0, 0,
10237 DDI_DMA_SYNC_FORCPU);
10238 ASSERT(rval == DDI_SUCCESS);
10239 }
10240 if (spkt->satapkt_reason == SATA_PKT_COMPLETED) {
10241 sata_log(sata_hba_inst, CE_WARN,
10242 "sata_test_atapi_packet_command: "
10243 "Packet completed successfully");
10244 /*
10245 * Normal completion - show inquiry data
10246 */
10247 sata_show_inqry_data((uint8_t *)bp->b_un.b_addr);
10248 } else {
10249 /*
10250 * Something went wrong - analyze return - check rqsense data
10251 */
10252 if (spkt->satapkt_reason == SATA_PKT_DEV_ERROR) {
10253 /*
10254 * ARQ data hopefull show something other than NO SENSE
10255 */
10256 rqsp = scmd->satacmd_rqsense;
10257 sata_log(spx->txlt_sata_hba_inst, CE_WARN,
10258 "ATAPI packet completion reason: %02x\n"
10259 "RQSENSE: %02x %02x %02x %02x %02x %02x "
10260 " %02x %02x %02x %02x %02x %02x "
10261 " %02x %02x %02x %02x %02x %02x\n",
10262 spkt->satapkt_reason,
10263 rqsp[0], rqsp[1], rqsp[2], rqsp[3],
10264 rqsp[4], rqsp[5], rqsp[6], rqsp[7],
10265 rqsp[8], rqsp[9], rqsp[10], rqsp[11],
10266 rqsp[12], rqsp[13], rqsp[14], rqsp[15],
10267 rqsp[16], rqsp[17]);
10268 } else {
10269 switch (spkt->satapkt_reason) {
10270 case SATA_PKT_PORT_ERROR:
10271 sata_log(sata_hba_inst, CE_WARN,
10272 "sata_test_atapi_packet_command: "
10273 "packet reason: port error\n");
10274 break;
10275
10276 case SATA_PKT_TIMEOUT:
10277 sata_log(sata_hba_inst, CE_WARN,
10278 "sata_test_atapi_packet_command: "
10279 "packet reason: timeout\n");
10280 break;
10281
10282 case SATA_PKT_ABORTED:
10283 sata_log(sata_hba_inst, CE_WARN,
10284 "sata_test_atapi_packet_command: "
10285 "packet reason: aborted\n");
10286 break;
10287
10288 case SATA_PKT_RESET:
10289 sata_log(sata_hba_inst, CE_WARN,
10290 "sata_test_atapi_packet_command: "
10291 "packet reason: reset\n");
10292 break;
10293 default:
10294 sata_log(sata_hba_inst, CE_WARN,
10295 "sata_test_atapi_packet_command: "
10296 "invalid packet reason: %02x\n",
10297 spkt->satapkt_reason);
10298 break;
10299 }
10300 }
10301 }
10302 cleanup:
10303 sata_free_local_buffer(spx);
10304 sata_pkt_free(spx);
10305 kmem_free(spx, sizeof (sata_pkt_txlate_t));
10306 }
10307
10308 #endif /* SATA_DEBUG */
10309 #endif /* 1 */
10310
10311
10312 /* ************************** LOCAL HELPER FUNCTIONS *********************** */
10313
10314 /*
10315 * Validate sata_tran info
10316 * SATA_FAILURE returns if structure is inconsistent or structure revision
10317 * does not match one used by the framework.
10318 *
10319 * Returns SATA_SUCCESS if sata_hba_tran has matching revision and contains
10320 * required function pointers.
10321 * Returns SATA_FAILURE otherwise.
10322 */
10323 static int
10324 sata_validate_sata_hba_tran(dev_info_t *dip, sata_hba_tran_t *sata_tran)
10325 {
10326 /*
10327 * SATA_TRAN_HBA_REV is the current (highest) revision number
10328 * of the SATA interface.
10329 */
10330 if (sata_tran->sata_tran_hba_rev > SATA_TRAN_HBA_REV) {
10331 sata_log(NULL, CE_WARN,
10332 "sata: invalid sata_hba_tran version %d for driver %s",
10333 sata_tran->sata_tran_hba_rev, ddi_driver_name(dip));
10334 return (SATA_FAILURE);
10335 }
10336
10337 if (dip != sata_tran->sata_tran_hba_dip) {
10338 SATA_LOG_D((NULL, CE_WARN,
10339 "sata: inconsistent sata_tran_hba_dip "
10340 "%p / %p", sata_tran->sata_tran_hba_dip, dip));
10341 return (SATA_FAILURE);
10342 }
10343
10344 if (sata_tran->sata_tran_probe_port == NULL ||
10345 sata_tran->sata_tran_start == NULL ||
10346 sata_tran->sata_tran_abort == NULL ||
10347 sata_tran->sata_tran_reset_dport == NULL ||
10348 sata_tran->sata_tran_hotplug_ops == NULL ||
10349 sata_tran->sata_tran_hotplug_ops->sata_tran_port_activate == NULL ||
10350 sata_tran->sata_tran_hotplug_ops->sata_tran_port_deactivate ==
10351 NULL) {
10352 SATA_LOG_D((NULL, CE_WARN, "sata: sata_hba_tran missing "
10353 "required functions"));
10354 }
10355 return (SATA_SUCCESS);
10356 }
10357
10358 /*
10359 * Remove HBA instance from sata_hba_list.
10360 */
10361 static void
10362 sata_remove_hba_instance(dev_info_t *dip)
10363 {
10364 sata_hba_inst_t *sata_hba_inst;
10365
10366 mutex_enter(&sata_mutex);
10367 for (sata_hba_inst = sata_hba_list;
10368 sata_hba_inst != (struct sata_hba_inst *)NULL;
10369 sata_hba_inst = sata_hba_inst->satahba_next) {
10370 if (sata_hba_inst->satahba_dip == dip)
10371 break;
10372 }
10373
10374 if (sata_hba_inst == (struct sata_hba_inst *)NULL) {
10375 #ifdef SATA_DEBUG
10376 cmn_err(CE_WARN, "sata_remove_hba_instance: "
10377 "unknown HBA instance\n");
10378 #endif
10379 ASSERT(FALSE);
10380 }
10381 if (sata_hba_inst == sata_hba_list) {
10382 sata_hba_list = sata_hba_inst->satahba_next;
10383 if (sata_hba_list) {
10384 sata_hba_list->satahba_prev =
10385 (struct sata_hba_inst *)NULL;
10386 }
10387 if (sata_hba_inst == sata_hba_list_tail) {
10388 sata_hba_list_tail = NULL;
10389 }
10390 } else if (sata_hba_inst == sata_hba_list_tail) {
10391 sata_hba_list_tail = sata_hba_inst->satahba_prev;
10392 if (sata_hba_list_tail) {
10393 sata_hba_list_tail->satahba_next =
10394 (struct sata_hba_inst *)NULL;
10395 }
10396 } else {
10397 sata_hba_inst->satahba_prev->satahba_next =
10398 sata_hba_inst->satahba_next;
10399 sata_hba_inst->satahba_next->satahba_prev =
10400 sata_hba_inst->satahba_prev;
10401 }
10402 mutex_exit(&sata_mutex);
10403 }
10404
10405 /*
10406 * Probe all SATA ports of the specified HBA instance.
10407 * The assumption is that there are no target and attachment point minor nodes
10408 * created by the boot subsystems, so we do not need to prune device tree.
10409 *
10410 * This function is called only from sata_hba_attach(). It does not have to
10411 * be protected by controller mutex, because the hba_attached flag is not set
10412 * yet and no one would be touching this HBA instance other than this thread.
10413 * Determines if port is active and what type of the device is attached
10414 * (if any). Allocates necessary structures for each port.
10415 *
10416 * An AP (Attachement Point) node is created for each SATA device port even
10417 * when there is no device attached.
10418 */
10419
10420 static void
10421 sata_probe_ports(sata_hba_inst_t *sata_hba_inst)
10422 {
10423 dev_info_t *dip = SATA_DIP(sata_hba_inst);
10424 int ncport;
10425 sata_cport_info_t *cportinfo;
10426 sata_drive_info_t *drive;
10427 sata_device_t sata_device;
10428 int rval;
10429 dev_t minor_number;
10430 char name[16];
10431 clock_t start_time, cur_time;
10432
10433 /*
10434 * Probe controller ports first, to find port status and
10435 * any port multiplier attached.
10436 */
10437 for (ncport = 0; ncport < SATA_NUM_CPORTS(sata_hba_inst); ncport++) {
10438 /* allocate cport structure */
10439 cportinfo = kmem_zalloc(sizeof (sata_cport_info_t), KM_SLEEP);
10440 ASSERT(cportinfo != NULL);
10441 mutex_init(&cportinfo->cport_mutex, NULL, MUTEX_DRIVER, NULL);
10442
10443 mutex_enter(&cportinfo->cport_mutex);
10444
10445 cportinfo->cport_addr.cport = ncport;
10446 cportinfo->cport_addr.pmport = 0;
10447 cportinfo->cport_addr.qual = SATA_ADDR_CPORT;
10448 cportinfo->cport_state &= ~SATA_PORT_STATE_CLEAR_MASK;
10449 cportinfo->cport_state |= SATA_STATE_PROBING;
10450 SATA_CPORT_INFO(sata_hba_inst, ncport) = cportinfo;
10451
10452 /*
10453 * Regardless if a port is usable or not, create
10454 * an attachment point
10455 */
10456 mutex_exit(&cportinfo->cport_mutex);
10457 minor_number = SATA_MAKE_AP_MINOR(ddi_get_instance(dip),
10458 ncport, 0, SATA_ADDR_CPORT);
10459 (void) sprintf(name, "%d", ncport);
10460 if (ddi_create_minor_node(dip, name, S_IFCHR,
10461 minor_number, DDI_NT_SATA_ATTACHMENT_POINT, 0) !=
10462 DDI_SUCCESS) {
10463 sata_log(sata_hba_inst, CE_WARN, "sata_hba_attach: "
10464 "cannot create SATA attachment point for port %d",
10465 ncport);
10466 }
10467
10468 /* Probe port */
10469 start_time = ddi_get_lbolt();
10470 reprobe_cport:
10471 sata_device.satadev_addr.cport = ncport;
10472 sata_device.satadev_addr.pmport = 0;
10473 sata_device.satadev_addr.qual = SATA_ADDR_CPORT;
10474 sata_device.satadev_rev = SATA_DEVICE_REV;
10475
10476 rval = (*SATA_PROBE_PORT_FUNC(sata_hba_inst))
10477 (dip, &sata_device);
10478
10479 mutex_enter(&cportinfo->cport_mutex);
10480 cportinfo->cport_scr = sata_device.satadev_scr;
10481 if (rval != SATA_SUCCESS) {
10482 /* Something went wrong? Fail the port */
10483 cportinfo->cport_state = SATA_PSTATE_FAILED;
10484 mutex_exit(&cportinfo->cport_mutex);
10485 continue;
10486 }
10487 cportinfo->cport_state &= ~SATA_STATE_PROBING;
10488 cportinfo->cport_state |= SATA_STATE_PROBED;
10489 cportinfo->cport_dev_type = sata_device.satadev_type;
10490
10491 cportinfo->cport_state |= SATA_STATE_READY;
10492 if (cportinfo->cport_dev_type == SATA_DTYPE_NONE) {
10493 mutex_exit(&cportinfo->cport_mutex);
10494 continue;
10495 }
10496 if (cportinfo->cport_dev_type != SATA_DTYPE_PMULT) {
10497 /*
10498 * There is some device attached.
10499 * Allocate device info structure
10500 */
10501 if (SATA_CPORTINFO_DRV_INFO(cportinfo) == NULL) {
10502 mutex_exit(&cportinfo->cport_mutex);
10503 SATA_CPORTINFO_DRV_INFO(cportinfo) =
10504 kmem_zalloc(sizeof (sata_drive_info_t),
10505 KM_SLEEP);
10506 mutex_enter(&cportinfo->cport_mutex);
10507 }
10508 drive = SATA_CPORTINFO_DRV_INFO(cportinfo);
10509 drive->satadrv_addr = cportinfo->cport_addr;
10510 drive->satadrv_addr.qual = SATA_ADDR_DCPORT;
10511 drive->satadrv_type = cportinfo->cport_dev_type;
10512 drive->satadrv_state = SATA_STATE_UNKNOWN;
10513
10514 mutex_exit(&cportinfo->cport_mutex);
10515 if (sata_add_device(dip, sata_hba_inst, &sata_device) !=
10516 SATA_SUCCESS) {
10517 /*
10518 * Plugged device was not correctly identified.
10519 * Retry, within a SATA_DEV_IDENTIFY_TIMEOUT
10520 */
10521 cur_time = ddi_get_lbolt();
10522 if ((cur_time - start_time) <
10523 drv_usectohz(SATA_DEV_IDENTIFY_TIMEOUT)) {
10524 /* sleep for a while */
10525 delay(drv_usectohz(
10526 SATA_DEV_RETRY_DLY));
10527 goto reprobe_cport;
10528 }
10529 }
10530 } else { /* SATA_DTYPE_PMULT */
10531 mutex_exit(&cportinfo->cport_mutex);
10532
10533 /* Allocate sata_pmult_info and sata_pmport_info */
10534 if (sata_alloc_pmult(sata_hba_inst, &sata_device) !=
10535 SATA_SUCCESS)
10536 continue;
10537
10538 /* Log the information of the port multiplier */
10539 sata_show_pmult_info(sata_hba_inst, &sata_device);
10540
10541 /* Probe its pmports */
10542 sata_probe_pmports(sata_hba_inst, ncport);
10543 }
10544 }
10545 }
10546
10547 /*
10548 * Probe all device ports behind a port multiplier.
10549 *
10550 * PMult-related structure should be allocated before by sata_alloc_pmult().
10551 *
10552 * NOTE1: Only called from sata_probe_ports()
10553 * NOTE2: No mutex should be hold.
10554 */
10555 static void
10556 sata_probe_pmports(sata_hba_inst_t *sata_hba_inst, uint8_t ncport)
10557 {
10558 dev_info_t *dip = SATA_DIP(sata_hba_inst);
10559 sata_pmult_info_t *pmultinfo = NULL;
10560 sata_pmport_info_t *pmportinfo = NULL;
10561 sata_drive_info_t *drive = NULL;
10562 sata_device_t sata_device;
10563
10564 clock_t start_time, cur_time;
10565 int npmport;
10566 int rval;
10567
10568 pmultinfo = SATA_PMULT_INFO(sata_hba_inst, ncport);
10569
10570 /* Probe Port Multiplier ports */
10571 for (npmport = 0; npmport < pmultinfo->pmult_num_dev_ports; npmport++) {
10572 pmportinfo = pmultinfo->pmult_dev_port[npmport];
10573 start_time = ddi_get_lbolt();
10574 reprobe_pmport:
10575 sata_device.satadev_addr.cport = ncport;
10576 sata_device.satadev_addr.pmport = npmport;
10577 sata_device.satadev_addr.qual = SATA_ADDR_PMPORT;
10578 sata_device.satadev_rev = SATA_DEVICE_REV;
10579
10580 /* Let HBA driver probe it. */
10581 rval = (*SATA_PROBE_PORT_FUNC(sata_hba_inst))
10582 (dip, &sata_device);
10583 mutex_enter(&pmportinfo->pmport_mutex);
10584
10585 pmportinfo->pmport_scr = sata_device.satadev_scr;
10586
10587 if (rval != SATA_SUCCESS) {
10588 pmportinfo->pmport_state =
10589 SATA_PSTATE_FAILED;
10590 mutex_exit(&pmportinfo->pmport_mutex);
10591 continue;
10592 }
10593 pmportinfo->pmport_state &= ~SATA_STATE_PROBING;
10594 pmportinfo->pmport_state |= SATA_STATE_PROBED;
10595 pmportinfo->pmport_dev_type = sata_device.satadev_type;
10596
10597 pmportinfo->pmport_state |= SATA_STATE_READY;
10598 if (pmportinfo->pmport_dev_type ==
10599 SATA_DTYPE_NONE) {
10600 SATADBG2(SATA_DBG_PMULT, sata_hba_inst,
10601 "no device found at port %d:%d", ncport, npmport);
10602 mutex_exit(&pmportinfo->pmport_mutex);
10603 continue;
10604 }
10605 /* Port multipliers cannot be chained */
10606 ASSERT(pmportinfo->pmport_dev_type != SATA_DTYPE_PMULT);
10607 /*
10608 * There is something attached to Port
10609 * Multiplier device port
10610 * Allocate device info structure
10611 */
10612 if (pmportinfo->pmport_sata_drive == NULL) {
10613 mutex_exit(&pmportinfo->pmport_mutex);
10614 pmportinfo->pmport_sata_drive =
10615 kmem_zalloc(sizeof (sata_drive_info_t), KM_SLEEP);
10616 mutex_enter(&pmportinfo->pmport_mutex);
10617 }
10618 drive = pmportinfo->pmport_sata_drive;
10619 drive->satadrv_addr.cport = pmportinfo->pmport_addr.cport;
10620 drive->satadrv_addr.pmport = npmport;
10621 drive->satadrv_addr.qual = SATA_ADDR_DPMPORT;
10622 drive->satadrv_type = pmportinfo-> pmport_dev_type;
10623 drive->satadrv_state = SATA_STATE_UNKNOWN;
10624
10625 mutex_exit(&pmportinfo->pmport_mutex);
10626 rval = sata_add_device(dip, sata_hba_inst, &sata_device);
10627
10628 if (rval != SATA_SUCCESS) {
10629 /*
10630 * Plugged device was not correctly identified.
10631 * Retry, within the SATA_DEV_IDENTIFY_TIMEOUT
10632 */
10633 cur_time = ddi_get_lbolt();
10634 if ((cur_time - start_time) < drv_usectohz(
10635 SATA_DEV_IDENTIFY_TIMEOUT)) {
10636 /* sleep for a while */
10637 delay(drv_usectohz(SATA_DEV_RETRY_DLY));
10638 goto reprobe_pmport;
10639 }
10640 }
10641 }
10642 }
10643
10644 /*
10645 * Add SATA device for specified HBA instance & port (SCSI target
10646 * device nodes).
10647 * This function is called (indirectly) only from sata_hba_attach().
10648 * A target node is created when there is a supported type device attached,
10649 * but may be removed if it cannot be put online.
10650 *
10651 * This function cannot be called from an interrupt context.
10652 *
10653 * Create target nodes for disk, CD/DVD, Tape and ATAPI disk devices
10654 *
10655 * Returns SATA_SUCCESS when port/device was fully processed, SATA_FAILURE when
10656 * device identification failed - adding a device could be retried.
10657 *
10658 */
10659 static int
10660 sata_add_device(dev_info_t *pdip, sata_hba_inst_t *sata_hba_inst,
10661 sata_device_t *sata_device)
10662 {
10663 sata_cport_info_t *cportinfo;
10664 sata_pmult_info_t *pminfo;
10665 sata_pmport_info_t *pmportinfo;
10666 dev_info_t *cdip; /* child dip */
10667 sata_address_t *saddr = &sata_device->satadev_addr;
10668 uint8_t cport, pmport;
10669 int rval;
10670
10671 cport = saddr->cport;
10672 pmport = saddr->pmport;
10673 cportinfo = SATA_CPORT_INFO(sata_hba_inst, cport);
10674 ASSERT(cportinfo->cport_dev_type != SATA_DTYPE_NONE);
10675
10676 /*
10677 * Some device is attached to a controller port.
10678 * We rely on controllers distinquishing between no-device,
10679 * attached port multiplier and other kind of attached device.
10680 * We need to get Identify Device data and determine
10681 * positively the dev type before trying to attach
10682 * the target driver.
10683 */
10684 sata_device->satadev_rev = SATA_DEVICE_REV;
10685 switch (saddr->qual) {
10686 case SATA_ADDR_CPORT:
10687 /*
10688 * Add a non-port-multiplier device at controller port.
10689 */
10690 saddr->qual = SATA_ADDR_DCPORT;
10691
10692 rval = sata_probe_device(sata_hba_inst, sata_device);
10693 if (rval != SATA_SUCCESS ||
10694 sata_device->satadev_type == SATA_DTYPE_UNKNOWN)
10695 return (SATA_FAILURE);
10696
10697 mutex_enter(&cportinfo->cport_mutex);
10698 sata_show_drive_info(sata_hba_inst,
10699 SATA_CPORTINFO_DRV_INFO(cportinfo));
10700
10701 if ((sata_device->satadev_type & SATA_VALID_DEV_TYPE) == 0) {
10702 /*
10703 * Could not determine device type or
10704 * a device is not supported.
10705 * Degrade this device to unknown.
10706 */
10707 cportinfo->cport_dev_type = SATA_DTYPE_UNKNOWN;
10708 mutex_exit(&cportinfo->cport_mutex);
10709 return (SATA_SUCCESS);
10710 }
10711 cportinfo->cport_dev_type = sata_device->satadev_type;
10712 cportinfo->cport_tgtnode_clean = B_TRUE;
10713 mutex_exit(&cportinfo->cport_mutex);
10714
10715 /*
10716 * Initialize device to the desired state. Even if it
10717 * fails, the device will still attach but syslog
10718 * will show the warning.
10719 */
10720 if (sata_initialize_device(sata_hba_inst,
10721 SATA_CPORTINFO_DRV_INFO(cportinfo)) != SATA_SUCCESS) {
10722 /* Retry */
10723 rval = sata_initialize_device(sata_hba_inst,
10724 SATA_CPORTINFO_DRV_INFO(cportinfo));
10725
10726 if (rval == SATA_RETRY)
10727 sata_log(sata_hba_inst, CE_WARN,
10728 "SATA device at port %d - "
10729 "default device features could not be set."
10730 " Device may not operate as expected.",
10731 cport);
10732 }
10733
10734 cdip = sata_create_target_node(pdip, sata_hba_inst, saddr);
10735 if (cdip == NULL) {
10736 /*
10737 * Attaching target node failed.
10738 * We retain sata_drive_info structure...
10739 */
10740 return (SATA_SUCCESS);
10741 }
10742
10743 mutex_enter(&cportinfo->cport_mutex);
10744 (SATA_CPORTINFO_DRV_INFO(cportinfo))->
10745 satadrv_state = SATA_STATE_READY;
10746 mutex_exit(&cportinfo->cport_mutex);
10747
10748 break;
10749
10750 case SATA_ADDR_PMPORT:
10751 saddr->qual = SATA_ADDR_DPMPORT;
10752
10753 mutex_enter(&cportinfo->cport_mutex);
10754 /* It must be a Port Multiplier at the controller port */
10755 ASSERT(cportinfo->cport_dev_type == SATA_DTYPE_PMULT);
10756
10757 pminfo = SATA_CPORTINFO_PMULT_INFO(cportinfo);
10758 pmportinfo = pminfo->pmult_dev_port[saddr->pmport];
10759 mutex_exit(&cportinfo->cport_mutex);
10760
10761 rval = sata_probe_device(sata_hba_inst, sata_device);
10762 if (rval != SATA_SUCCESS ||
10763 sata_device->satadev_type == SATA_DTYPE_UNKNOWN) {
10764 return (SATA_FAILURE);
10765 }
10766
10767 mutex_enter(&pmportinfo->pmport_mutex);
10768 sata_show_drive_info(sata_hba_inst,
10769 SATA_PMPORTINFO_DRV_INFO(pmportinfo));
10770
10771 if ((sata_device->satadev_type & SATA_VALID_DEV_TYPE) == 0) {
10772 /*
10773 * Could not determine device type.
10774 * Degrade this device to unknown.
10775 */
10776 pmportinfo->pmport_dev_type = SATA_DTYPE_UNKNOWN;
10777 mutex_exit(&pmportinfo->pmport_mutex);
10778 return (SATA_SUCCESS);
10779 }
10780 pmportinfo->pmport_dev_type = sata_device->satadev_type;
10781 pmportinfo->pmport_tgtnode_clean = B_TRUE;
10782 mutex_exit(&pmportinfo->pmport_mutex);
10783
10784 /*
10785 * Initialize device to the desired state.
10786 * Even if it fails, the device will still
10787 * attach but syslog will show the warning.
10788 */
10789 if (sata_initialize_device(sata_hba_inst,
10790 pmportinfo->pmport_sata_drive) != SATA_SUCCESS) {
10791 /* Retry */
10792 rval = sata_initialize_device(sata_hba_inst,
10793 pmportinfo->pmport_sata_drive);
10794
10795 if (rval == SATA_RETRY)
10796 sata_log(sata_hba_inst, CE_WARN,
10797 "SATA device at port %d:%d - "
10798 "default device features could not be set."
10799 " Device may not operate as expected.",
10800 cport, pmport);
10801 }
10802
10803 cdip = sata_create_target_node(pdip, sata_hba_inst, saddr);
10804 if (cdip == NULL) {
10805 /*
10806 * Attaching target node failed.
10807 * We retain sata_drive_info structure...
10808 */
10809 return (SATA_SUCCESS);
10810 }
10811 mutex_enter(&pmportinfo->pmport_mutex);
10812 pmportinfo->pmport_sata_drive->satadrv_state |=
10813 SATA_STATE_READY;
10814 mutex_exit(&pmportinfo->pmport_mutex);
10815
10816 break;
10817
10818 default:
10819 return (SATA_FAILURE);
10820 }
10821
10822 return (SATA_SUCCESS);
10823 }
10824
10825 /*
10826 * Clean up target node at specific address.
10827 *
10828 * NOTE: No Mutex should be hold.
10829 */
10830 static int
10831 sata_offline_device(sata_hba_inst_t *sata_hba_inst,
10832 sata_device_t *sata_device, sata_drive_info_t *sdinfo)
10833 {
10834 uint8_t cport, pmport, qual;
10835 dev_info_t *tdip;
10836
10837 cport = sata_device->satadev_addr.cport;
10838 pmport = sata_device->satadev_addr.pmport;
10839 qual = sata_device->satadev_addr.qual;
10840
10841 if (qual == SATA_ADDR_DCPORT) {
10842 SATA_LOG_D((sata_hba_inst, CE_WARN,
10843 "sata_hba_ioctl: disconnect device at port %d", cport));
10844 } else {
10845 SATA_LOG_D((sata_hba_inst, CE_WARN,
10846 "sata_hba_ioctl: disconnect device at port %d:%d",
10847 cport, pmport));
10848 }
10849
10850 /* We are addressing attached device, not a port */
10851 sata_device->satadev_addr.qual =
10852 sdinfo->satadrv_addr.qual;
10853 tdip = sata_get_scsi_target_dip(SATA_DIP(sata_hba_inst),
10854 &sata_device->satadev_addr);
10855 if (tdip != NULL && ndi_devi_offline(tdip,
10856 NDI_DEVI_REMOVE) != NDI_SUCCESS) {
10857 /*
10858 * Problem :
10859 * The target node remained attached.
10860 * This happens when the device file was open
10861 * or a node was waiting for resources.
10862 * Cannot do anything about it.
10863 */
10864 if (qual == SATA_ADDR_DCPORT) {
10865 SATA_LOG_D((sata_hba_inst, CE_WARN,
10866 "sata_hba_ioctl: disconnect: could "
10867 "not unconfigure device before "
10868 "disconnecting the SATA port %d",
10869 cport));
10870 } else {
10871 SATA_LOG_D((sata_hba_inst, CE_WARN,
10872 "sata_hba_ioctl: disconnect: could "
10873 "not unconfigure device before "
10874 "disconnecting the SATA port %d:%d",
10875 cport, pmport));
10876 }
10877 /*
10878 * Set DEVICE REMOVED state in the target
10879 * node. It will prevent access to the device
10880 * even when a new device is attached, until
10881 * the old target node is released, removed and
10882 * recreated for a new device.
10883 */
10884 sata_set_device_removed(tdip);
10885
10886 /*
10887 * Instruct event daemon to try the target
10888 * node cleanup later.
10889 */
10890 sata_set_target_node_cleanup(
10891 sata_hba_inst, &sata_device->satadev_addr);
10892 }
10893
10894
10895 return (SATA_SUCCESS);
10896 }
10897
10898
10899 /*
10900 * Create scsi target node for attached device, create node properties and
10901 * attach the node.
10902 * The node could be removed if the device onlining fails.
10903 *
10904 * A dev_info_t pointer is returned if operation is successful, NULL is
10905 * returned otherwise.
10906 */
10907
10908 static dev_info_t *
10909 sata_create_target_node(dev_info_t *dip, sata_hba_inst_t *sata_hba_inst,
10910 sata_address_t *sata_addr)
10911 {
10912 dev_info_t *cdip = NULL;
10913 int rval;
10914 char *nname = NULL;
10915 char **compatible = NULL;
10916 int ncompatible;
10917 struct scsi_inquiry inq;
10918 sata_device_t sata_device;
10919 sata_drive_info_t *sdinfo;
10920 int target;
10921 int i;
10922
10923 sata_device.satadev_rev = SATA_DEVICE_REV;
10924 sata_device.satadev_addr = *sata_addr;
10925
10926 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, sata_addr->cport)));
10927
10928 sdinfo = sata_get_device_info(sata_hba_inst, &sata_device);
10929
10930 target = SATA_TO_SCSI_TARGET(sata_addr->cport,
10931 sata_addr->pmport, sata_addr->qual);
10932
10933 if (sdinfo == NULL) {
10934 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst,
10935 sata_addr->cport)));
10936 SATA_LOG_D((sata_hba_inst, CE_WARN,
10937 "sata_create_target_node: no sdinfo for target %x",
10938 target));
10939 return (NULL);
10940 }
10941
10942 /*
10943 * create or get scsi inquiry data, expected by
10944 * scsi_hba_nodename_compatible_get()
10945 * SATA hard disks get Identify Data translated into Inguiry Data.
10946 * ATAPI devices respond directly to Inquiry request.
10947 */
10948 if (sdinfo->satadrv_type == SATA_DTYPE_ATADISK) {
10949 sata_identdev_to_inquiry(sata_hba_inst, sdinfo,
10950 (uint8_t *)&inq);
10951 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst,
10952 sata_addr->cport)));
10953 } else { /* Assume supported ATAPI device */
10954 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst,
10955 sata_addr->cport)));
10956 if (sata_get_atapi_inquiry_data(sata_hba_inst, sata_addr,
10957 &inq) == SATA_FAILURE)
10958 return (NULL);
10959 /*
10960 * Save supported ATAPI transport version
10961 */
10962 sdinfo->satadrv_atapi_trans_ver =
10963 SATA_ATAPI_TRANS_VERSION(&inq);
10964 }
10965
10966 /* determine the node name and compatible */
10967 scsi_hba_nodename_compatible_get(&inq, NULL,
10968 inq.inq_dtype, NULL, &nname, &compatible, &ncompatible);
10969
10970 #ifdef SATA_DEBUG
10971 if (sata_debug_flags & SATA_DBG_NODES) {
10972 if (nname == NULL) {
10973 cmn_err(CE_NOTE, "sata_create_target_node: "
10974 "cannot determine nodename for target %d\n",
10975 target);
10976 } else {
10977 cmn_err(CE_WARN, "sata_create_target_node: "
10978 "target %d nodename: %s\n", target, nname);
10979 }
10980 if (compatible == NULL) {
10981 cmn_err(CE_WARN,
10982 "sata_create_target_node: no compatible name\n");
10983 } else {
10984 for (i = 0; i < ncompatible; i++) {
10985 cmn_err(CE_WARN, "sata_create_target_node: "
10986 "compatible name: %s\n", compatible[i]);
10987 }
10988 }
10989 }
10990 #endif
10991
10992 /* if nodename can't be determined, log error and exit */
10993 if (nname == NULL) {
10994 SATA_LOG_D((sata_hba_inst, CE_WARN,
10995 "sata_create_target_node: cannot determine nodename "
10996 "for target %d\n", target));
10997 scsi_hba_nodename_compatible_free(nname, compatible);
10998 return (NULL);
10999 }
11000 /*
11001 * Create scsi target node
11002 */
11003 ndi_devi_alloc_sleep(dip, nname, (pnode_t)DEVI_SID_NODEID, &cdip);
11004 rval = ndi_prop_update_string(DDI_DEV_T_NONE, cdip,
11005 "device-type", "scsi");
11006
11007 if (rval != DDI_PROP_SUCCESS) {
11008 SATA_LOG_D((sata_hba_inst, CE_WARN, "sata_create_target_node: "
11009 "updating device_type prop failed %d", rval));
11010 goto fail;
11011 }
11012
11013 /*
11014 * Create target node properties: target & lun
11015 */
11016 rval = ndi_prop_update_int(DDI_DEV_T_NONE, cdip, "target", target);
11017 if (rval != DDI_PROP_SUCCESS) {
11018 SATA_LOG_D((sata_hba_inst, CE_WARN, "sata_create_target_node: "
11019 "updating target prop failed %d", rval));
11020 goto fail;
11021 }
11022 rval = ndi_prop_update_int(DDI_DEV_T_NONE, cdip, "lun", 0);
11023 if (rval != DDI_PROP_SUCCESS) {
11024 SATA_LOG_D((sata_hba_inst, CE_WARN, "sata_create_target_node: "
11025 "updating target prop failed %d", rval));
11026 goto fail;
11027 }
11028
11029 if (sdinfo->satadrv_type & SATA_DTYPE_ATAPI) {
11030 /*
11031 * Add "variant" property
11032 */
11033 rval = ndi_prop_update_string(DDI_DEV_T_NONE, cdip,
11034 "variant", "atapi");
11035 if (rval != DDI_PROP_SUCCESS) {
11036 SATA_LOG_D((sata_hba_inst, CE_WARN,
11037 "sata_create_target_node: variant atapi "
11038 "property could not be created: %d", rval));
11039 goto fail;
11040 }
11041 }
11042 /* decorate the node with compatible */
11043 if (ndi_prop_update_string_array(DDI_DEV_T_NONE, cdip, "compatible",
11044 compatible, ncompatible) != DDI_PROP_SUCCESS) {
11045 SATA_LOG_D((sata_hba_inst, CE_WARN,
11046 "sata_create_target_node: FAIL compatible props cdip 0x%p",
11047 (void *)cdip));
11048 goto fail;
11049 }
11050
11051 if (sdinfo->satadrv_type == SATA_DTYPE_ATADISK) {
11052 /*
11053 * Add "sata-phy" property
11054 */
11055 if (ndi_prop_update_int(DDI_DEV_T_NONE, cdip, "sata-phy",
11056 (int)sata_addr->cport) != DDI_PROP_SUCCESS) {
11057 SATA_LOG_D((sata_hba_inst, CE_WARN,
11058 "sata_create_target_node: failed to create "
11059 "\"sata-phy\" property: port %d",
11060 sata_addr->cport));
11061 }
11062 }
11063
11064
11065 /*
11066 * Now, try to attach the driver. If probing of the device fails,
11067 * the target node may be removed
11068 */
11069 rval = ndi_devi_online(cdip, NDI_ONLINE_ATTACH);
11070
11071 scsi_hba_nodename_compatible_free(nname, compatible);
11072
11073 if (rval == NDI_SUCCESS)
11074 return (cdip);
11075
11076 /* target node was removed - are we sure? */
11077 return (NULL);
11078
11079 fail:
11080 scsi_hba_nodename_compatible_free(nname, compatible);
11081 ddi_prop_remove_all(cdip);
11082 rval = ndi_devi_free(cdip);
11083 if (rval != NDI_SUCCESS) {
11084 SATA_LOG_D((sata_hba_inst, CE_WARN, "sata_create_target_node: "
11085 "node removal failed %d", rval));
11086 }
11087 sata_log(sata_hba_inst, CE_WARN, "sata_create_target_node: "
11088 "cannot create target node for SATA device at port %d",
11089 sata_addr->cport);
11090 return (NULL);
11091 }
11092
11093 /*
11094 * Remove a target node.
11095 */
11096 static void
11097 sata_remove_target_node(sata_hba_inst_t *sata_hba_inst,
11098 sata_address_t *sata_addr)
11099 {
11100 dev_info_t *tdip;
11101 uint8_t cport = sata_addr->cport;
11102 uint8_t pmport = sata_addr->pmport;
11103 uint8_t qual = sata_addr->qual;
11104
11105 /* Note the sata daemon uses the address of the port/pmport */
11106 ASSERT(qual == SATA_ADDR_CPORT || qual == SATA_ADDR_PMPORT);
11107
11108 /* Remove target node */
11109 tdip = sata_get_target_dip(SATA_DIP(sata_hba_inst), cport, pmport);
11110 if (tdip != NULL) {
11111 /*
11112 * Target node exists. Unconfigure device
11113 * then remove the target node (one ndi
11114 * operation).
11115 */
11116 if (ndi_devi_offline(tdip, NDI_DEVI_REMOVE) != NDI_SUCCESS) {
11117 /*
11118 * PROBLEM - no device, but target node remained. This
11119 * happens when the file was open or node was waiting
11120 * for resources.
11121 */
11122 SATA_LOG_D((sata_hba_inst, CE_WARN,
11123 "sata_remove_target_node: "
11124 "Failed to remove target node for "
11125 "detached SATA device."));
11126 /*
11127 * Set target node state to DEVI_DEVICE_REMOVED. But
11128 * re-check first that the node still exists.
11129 */
11130 tdip = sata_get_target_dip(SATA_DIP(sata_hba_inst),
11131 cport, pmport);
11132 if (tdip != NULL) {
11133 sata_set_device_removed(tdip);
11134 /*
11135 * Instruct event daemon to retry the cleanup
11136 * later.
11137 */
11138 sata_set_target_node_cleanup(sata_hba_inst,
11139 sata_addr);
11140 }
11141 }
11142
11143 if (qual == SATA_ADDR_CPORT)
11144 sata_log(sata_hba_inst, CE_WARN,
11145 "SATA device detached at port %d", cport);
11146 else
11147 sata_log(sata_hba_inst, CE_WARN,
11148 "SATA device detached at port %d:%d",
11149 cport, pmport);
11150 }
11151 #ifdef SATA_DEBUG
11152 else {
11153 if (qual == SATA_ADDR_CPORT)
11154 sata_log(sata_hba_inst, CE_WARN,
11155 "target node not found at port %d", cport);
11156 else
11157 sata_log(sata_hba_inst, CE_WARN,
11158 "target node not found at port %d:%d",
11159 cport, pmport);
11160 }
11161 #endif
11162 }
11163
11164
11165 /*
11166 * Re-probe sata port, check for a device and attach info
11167 * structures when necessary. Identify Device data is fetched, if possible.
11168 * Assumption: sata address is already validated.
11169 * SATA_SUCCESS is returned if port is re-probed sucessfully, regardless of
11170 * the presence of a device and its type.
11171 *
11172 * flag arg specifies that the function should try multiple times to identify
11173 * device type and to initialize it, or it should return immediately on failure.
11174 * SATA_DEV_IDENTIFY_RETRY - retry
11175 * SATA_DEV_IDENTIFY_NORETRY - no retry
11176 *
11177 * SATA_FAILURE is returned if one of the operations failed.
11178 *
11179 * This function cannot be called in interrupt context - it may sleep.
11180 *
11181 * Note: Port multiplier is supported.
11182 */
11183 static int
11184 sata_reprobe_port(sata_hba_inst_t *sata_hba_inst, sata_device_t *sata_device,
11185 int flag)
11186 {
11187 sata_cport_info_t *cportinfo;
11188 sata_pmult_info_t *pmultinfo;
11189 sata_drive_info_t *sdinfo, *osdinfo;
11190 boolean_t init_device = B_FALSE;
11191 int prev_device_type = SATA_DTYPE_NONE;
11192 int prev_device_settings = 0;
11193 int prev_device_state = 0;
11194 clock_t start_time;
11195 int retry = B_FALSE;
11196 uint8_t cport = sata_device->satadev_addr.cport;
11197 int rval_probe, rval_init;
11198
11199 /*
11200 * If target is pmport, sata_reprobe_pmport() will handle it.
11201 */
11202 if (sata_device->satadev_addr.qual == SATA_ADDR_PMPORT ||
11203 sata_device->satadev_addr.qual == SATA_ADDR_DPMPORT)
11204 return (sata_reprobe_pmport(sata_hba_inst, sata_device, flag));
11205
11206 /* We only care about host sata cport for now */
11207 cportinfo = SATA_CPORT_INFO(sata_hba_inst,
11208 sata_device->satadev_addr.cport);
11209
11210 /*
11211 * If a port multiplier was previously attached (we have no idea it
11212 * still there or not), sata_reprobe_pmult() will handle it.
11213 */
11214 if (cportinfo->cport_dev_type == SATA_DTYPE_PMULT)
11215 return (sata_reprobe_pmult(sata_hba_inst, sata_device, flag));
11216
11217 /* Store sata_drive_info when a non-pmult device was attached. */
11218 osdinfo = SATA_CPORTINFO_DRV_INFO(cportinfo);
11219 if (osdinfo != NULL) {
11220 /*
11221 * We are re-probing port with a previously attached device.
11222 * Save previous device type and settings.
11223 */
11224 prev_device_type = cportinfo->cport_dev_type;
11225 prev_device_settings = osdinfo->satadrv_settings;
11226 prev_device_state = osdinfo->satadrv_state;
11227 }
11228 if (flag == SATA_DEV_IDENTIFY_RETRY) {
11229 start_time = ddi_get_lbolt();
11230 retry = B_TRUE;
11231 }
11232 retry_probe:
11233
11234 /* probe port */
11235 mutex_enter(&cportinfo->cport_mutex);
11236 cportinfo->cport_state &= ~SATA_PORT_STATE_CLEAR_MASK;
11237 cportinfo->cport_state |= SATA_STATE_PROBING;
11238 mutex_exit(&cportinfo->cport_mutex);
11239
11240 rval_probe = (*SATA_PROBE_PORT_FUNC(sata_hba_inst))
11241 (SATA_DIP(sata_hba_inst), sata_device);
11242
11243 mutex_enter(&cportinfo->cport_mutex);
11244 if (rval_probe != SATA_SUCCESS) {
11245 cportinfo->cport_state = SATA_PSTATE_FAILED;
11246 mutex_exit(&cportinfo->cport_mutex);
11247 SATA_LOG_D((sata_hba_inst, CE_WARN, "sata_reprobe_port: "
11248 "SATA port %d probing failed",
11249 cportinfo->cport_addr.cport));
11250 return (SATA_FAILURE);
11251 }
11252
11253 /*
11254 * update sata port state and set device type
11255 */
11256 sata_update_port_info(sata_hba_inst, sata_device);
11257 cportinfo->cport_state &= ~SATA_STATE_PROBING;
11258
11259 /*
11260 * Sanity check - Port is active? Is the link active?
11261 * Is there any device attached?
11262 */
11263 if ((cportinfo->cport_state &
11264 (SATA_PSTATE_SHUTDOWN | SATA_PSTATE_FAILED)) ||
11265 (cportinfo->cport_scr.sstatus & SATA_PORT_DEVLINK_UP_MASK) !=
11266 SATA_PORT_DEVLINK_UP) {
11267 /*
11268 * Port in non-usable state or no link active/no device.
11269 * Free info structure if necessary (direct attached drive
11270 * only, for now!
11271 */
11272 sdinfo = SATA_CPORTINFO_DRV_INFO(cportinfo);
11273 SATA_CPORTINFO_DRV_INFO(cportinfo) = NULL;
11274 /* Add here differentiation for device attached or not */
11275 cportinfo->cport_dev_type = SATA_DTYPE_NONE;
11276 mutex_exit(&cportinfo->cport_mutex);
11277 if (sdinfo != NULL)
11278 kmem_free(sdinfo, sizeof (sata_drive_info_t));
11279 return (SATA_SUCCESS);
11280 }
11281
11282 cportinfo->cport_state |= SATA_STATE_READY;
11283 cportinfo->cport_state |= SATA_STATE_PROBED;
11284
11285 cportinfo->cport_dev_type = sata_device->satadev_type;
11286 sdinfo = SATA_CPORTINFO_DRV_INFO(cportinfo);
11287
11288 /*
11289 * If we are re-probing the port, there may be
11290 * sata_drive_info structure attached
11291 */
11292 if (sata_device->satadev_type == SATA_DTYPE_NONE) {
11293
11294 /*
11295 * There is no device, so remove device info structure,
11296 * if necessary.
11297 */
11298 /* Device change: Drive -> None */
11299 SATA_CPORTINFO_DRV_INFO(cportinfo) = NULL;
11300 cportinfo->cport_dev_type = SATA_DTYPE_NONE;
11301 if (sdinfo != NULL) {
11302 kmem_free(sdinfo, sizeof (sata_drive_info_t));
11303 sata_log(sata_hba_inst, CE_WARN,
11304 "SATA device detached "
11305 "from port %d", cportinfo->cport_addr.cport);
11306 }
11307 mutex_exit(&cportinfo->cport_mutex);
11308 return (SATA_SUCCESS);
11309
11310 }
11311
11312 if (sata_device->satadev_type != SATA_DTYPE_PMULT) {
11313
11314 /* Device (may) change: Drive -> Drive */
11315 if (sdinfo == NULL) {
11316 /*
11317 * There is some device attached, but there is
11318 * no sata_drive_info structure - allocate one
11319 */
11320 mutex_exit(&cportinfo->cport_mutex);
11321 sdinfo = kmem_zalloc(
11322 sizeof (sata_drive_info_t), KM_SLEEP);
11323 mutex_enter(&cportinfo->cport_mutex);
11324 /*
11325 * Recheck, that the port state did not change when we
11326 * released mutex.
11327 */
11328 if (cportinfo->cport_state & SATA_STATE_READY) {
11329 SATA_CPORTINFO_DRV_INFO(cportinfo) = sdinfo;
11330 sdinfo->satadrv_addr = cportinfo->cport_addr;
11331 sdinfo->satadrv_addr.qual = SATA_ADDR_DCPORT;
11332 sdinfo->satadrv_type = SATA_DTYPE_UNKNOWN;
11333 sdinfo->satadrv_state = SATA_STATE_UNKNOWN;
11334 } else {
11335 /*
11336 * Port is not in ready state, we
11337 * cannot attach a device.
11338 */
11339 mutex_exit(&cportinfo->cport_mutex);
11340 kmem_free(sdinfo, sizeof (sata_drive_info_t));
11341 return (SATA_SUCCESS);
11342 }
11343 /*
11344 * Since we are adding device, presumably new one,
11345 * indicate that it should be initalized,
11346 * as well as some internal framework states).
11347 */
11348 init_device = B_TRUE;
11349 }
11350 cportinfo->cport_dev_type = SATA_DTYPE_UNKNOWN;
11351 sata_device->satadev_addr.qual = sdinfo->satadrv_addr.qual;
11352 } else {
11353 /* Device change: Drive -> PMult */
11354 SATA_CPORTINFO_DRV_INFO(cportinfo) = NULL;
11355 if (sdinfo != NULL) {
11356 kmem_free(sdinfo, sizeof (sata_drive_info_t));
11357 sata_log(sata_hba_inst, CE_WARN,
11358 "SATA device detached "
11359 "from port %d", cportinfo->cport_addr.cport);
11360 }
11361
11362 sata_log(sata_hba_inst, CE_WARN,
11363 "SATA port multiplier detected at port %d",
11364 cportinfo->cport_addr.cport);
11365
11366 mutex_exit(&cportinfo->cport_mutex);
11367 if (sata_alloc_pmult(sata_hba_inst, sata_device) !=
11368 SATA_SUCCESS)
11369 return (SATA_FAILURE);
11370 sata_show_pmult_info(sata_hba_inst, sata_device);
11371 mutex_enter(&cportinfo->cport_mutex);
11372
11373 /*
11374 * Mark all the port multiplier port behind the port
11375 * multiplier behind with link events, so that the sata daemon
11376 * will update their status.
11377 */
11378 pmultinfo = SATA_PMULT_INFO(sata_hba_inst, cport);
11379 pmultinfo->pmult_event_flags |= SATA_EVNT_DEVICE_RESET;
11380 mutex_exit(&cportinfo->cport_mutex);
11381 return (SATA_SUCCESS);
11382 }
11383 mutex_exit(&cportinfo->cport_mutex);
11384
11385 /*
11386 * Figure out what kind of device we are really
11387 * dealing with. Failure of identifying device does not fail this
11388 * function.
11389 */
11390 rval_probe = sata_probe_device(sata_hba_inst, sata_device);
11391 rval_init = SATA_FAILURE;
11392 mutex_enter(&cportinfo->cport_mutex);
11393 if (rval_probe == SATA_SUCCESS) {
11394 /*
11395 * If we are dealing with the same type of a device as before,
11396 * restore its settings flags.
11397 */
11398 if (osdinfo != NULL &&
11399 sata_device->satadev_type == prev_device_type)
11400 sdinfo->satadrv_settings = prev_device_settings;
11401
11402 mutex_exit(&cportinfo->cport_mutex);
11403 rval_init = SATA_SUCCESS;
11404 /* Set initial device features, if necessary */
11405 if (init_device == B_TRUE) {
11406 rval_init = sata_initialize_device(sata_hba_inst,
11407 sdinfo);
11408 }
11409 if (rval_init == SATA_SUCCESS)
11410 return (rval_init);
11411 /* else we will retry if retry was asked for */
11412
11413 } else {
11414 /*
11415 * If there was some device info before we probe the device,
11416 * restore previous device setting, so we can retry from scratch
11417 * later. Providing, of course, that device has not disapear
11418 * during probing process.
11419 */
11420 if (sata_device->satadev_type != SATA_DTYPE_NONE) {
11421 if (osdinfo != NULL) {
11422 cportinfo->cport_dev_type = prev_device_type;
11423 sdinfo->satadrv_type = prev_device_type;
11424 sdinfo->satadrv_state = prev_device_state;
11425 }
11426 } else {
11427 /* device is gone */
11428 kmem_free(sdinfo, sizeof (sata_drive_info_t));
11429 cportinfo->cport_dev_type = SATA_DTYPE_NONE;
11430 SATA_CPORTINFO_DRV_INFO(cportinfo) = NULL;
11431 mutex_exit(&cportinfo->cport_mutex);
11432 return (SATA_SUCCESS);
11433 }
11434 mutex_exit(&cportinfo->cport_mutex);
11435 }
11436
11437 if (retry) {
11438 clock_t cur_time = ddi_get_lbolt();
11439 /*
11440 * A device was not successfully identified or initialized.
11441 * Track retry time for device identification.
11442 */
11443 if ((cur_time - start_time) <
11444 drv_usectohz(SATA_DEV_REPROBE_TIMEOUT)) {
11445 /* sleep for a while */
11446 delay(drv_usectohz(SATA_DEV_RETRY_DLY));
11447 goto retry_probe;
11448 }
11449 /* else no more retries */
11450 mutex_enter(&cportinfo->cport_mutex);
11451 if (SATA_CPORTINFO_DRV_INFO(cportinfo) != NULL) {
11452 if (rval_init == SATA_RETRY) {
11453 /*
11454 * Setting drive features have failed, but
11455 * because the drive is still accessible,
11456 * keep it and emit a warning message.
11457 */
11458 sata_log(sata_hba_inst, CE_WARN,
11459 "SATA device at port %d - desired "
11460 "drive features could not be set. "
11461 "Device may not operate as expected.",
11462 cportinfo->cport_addr.cport);
11463 } else {
11464 SATA_CPORTINFO_DRV_INFO(cportinfo)->
11465 satadrv_state = SATA_DSTATE_FAILED;
11466 }
11467 }
11468 mutex_exit(&cportinfo->cport_mutex);
11469 }
11470 return (SATA_SUCCESS);
11471 }
11472
11473 /*
11474 * Reprobe a controller port that connected to a port multiplier.
11475 *
11476 * NOTE: No Mutex should be hold.
11477 */
11478 static int
11479 sata_reprobe_pmult(sata_hba_inst_t *sata_hba_inst, sata_device_t *sata_device,
11480 int flag)
11481 {
11482 _NOTE(ARGUNUSED(flag))
11483 sata_cport_info_t *cportinfo;
11484 sata_pmult_info_t *pmultinfo;
11485 uint8_t cport = sata_device->satadev_addr.cport;
11486 int rval_probe;
11487
11488 cportinfo = SATA_CPORT_INFO(sata_hba_inst, cport);
11489 pmultinfo = SATA_PMULT_INFO(sata_hba_inst, cport);
11490
11491 /* probe port */
11492 mutex_enter(&cportinfo->cport_mutex);
11493 cportinfo->cport_state &= ~SATA_PORT_STATE_CLEAR_MASK;
11494 cportinfo->cport_state |= SATA_STATE_PROBING;
11495 mutex_exit(&cportinfo->cport_mutex);
11496
11497 rval_probe = (*SATA_PROBE_PORT_FUNC(sata_hba_inst))
11498 (SATA_DIP(sata_hba_inst), sata_device);
11499
11500 mutex_enter(&cportinfo->cport_mutex);
11501 if (rval_probe != SATA_SUCCESS) {
11502 cportinfo->cport_state = SATA_PSTATE_FAILED;
11503 SATA_LOG_D((sata_hba_inst, CE_WARN, "sata_reprobe_pmult: "
11504 "SATA port %d probing failed", cport));
11505 sata_log(sata_hba_inst, CE_WARN,
11506 "SATA port multiplier detached at port %d", cport);
11507 mutex_exit(&cportinfo->cport_mutex);
11508 sata_free_pmult(sata_hba_inst, sata_device);
11509 return (SATA_FAILURE);
11510 }
11511
11512 /*
11513 * update sata port state and set device type
11514 */
11515 sata_update_port_info(sata_hba_inst, sata_device);
11516 cportinfo->cport_state &= ~SATA_STATE_PROBING;
11517 cportinfo->cport_state |= SATA_STATE_PROBED;
11518
11519 /*
11520 * Sanity check - Port is active? Is the link active?
11521 * Is there any device attached?
11522 */
11523 if ((cportinfo->cport_state &
11524 (SATA_PSTATE_SHUTDOWN | SATA_PSTATE_FAILED)) ||
11525 (cportinfo->cport_scr.sstatus & SATA_PORT_DEVLINK_UP_MASK) !=
11526 SATA_PORT_DEVLINK_UP ||
11527 (sata_device->satadev_type == SATA_DTYPE_NONE)) {
11528 cportinfo->cport_dev_type = SATA_DTYPE_NONE;
11529 mutex_exit(&cportinfo->cport_mutex);
11530 sata_free_pmult(sata_hba_inst, sata_device);
11531 sata_log(sata_hba_inst, CE_WARN,
11532 "SATA port multiplier detached at port %d", cport);
11533 return (SATA_SUCCESS);
11534 }
11535
11536 /*
11537 * Device changed: PMult -> Non-PMult
11538 *
11539 * This situation is uncommon, most possibly being caused by errors
11540 * after which the port multiplier is not correct initialized and
11541 * recognized. In that case the new device will be marked as unknown
11542 * and will not be automatically probed in this routine. Instead
11543 * system administrator could manually restart it via cfgadm(1M).
11544 */
11545 if (sata_device->satadev_type != SATA_DTYPE_PMULT) {
11546 cportinfo->cport_dev_type = SATA_DTYPE_UNKNOWN;
11547 mutex_exit(&cportinfo->cport_mutex);
11548 sata_free_pmult(sata_hba_inst, sata_device);
11549 sata_log(sata_hba_inst, CE_WARN,
11550 "SATA port multiplier detached at port %d", cport);
11551 return (SATA_FAILURE);
11552 }
11553
11554 /*
11555 * Now we know it is a port multiplier. However, if this is not the
11556 * previously attached port multiplier - they may have different
11557 * pmport numbers - we need to re-allocate data structures for every
11558 * pmport and drive.
11559 *
11560 * Port multipliers of the same model have identical values in these
11561 * registers, so it is still necessary to update the information of
11562 * all drives attached to the previous port multiplier afterwards.
11563 */
11564 /* Device changed: PMult -> another PMult */
11565 mutex_exit(&cportinfo->cport_mutex);
11566 sata_free_pmult(sata_hba_inst, sata_device);
11567 if (sata_alloc_pmult(sata_hba_inst, sata_device) != SATA_SUCCESS)
11568 return (SATA_FAILURE);
11569 mutex_enter(&cportinfo->cport_mutex);
11570
11571 SATADBG1(SATA_DBG_PMULT, sata_hba_inst,
11572 "SATA port multiplier [changed] at port %d", cport);
11573 sata_log(sata_hba_inst, CE_WARN,
11574 "SATA port multiplier detected at port %d", cport);
11575
11576 /*
11577 * Mark all the port multiplier port behind the port
11578 * multiplier behind with link events, so that the sata daemon
11579 * will update their status.
11580 */
11581 pmultinfo->pmult_event_flags |= SATA_EVNT_DEVICE_RESET;
11582 mutex_exit(&cportinfo->cport_mutex);
11583
11584 return (SATA_SUCCESS);
11585 }
11586
11587 /*
11588 * Re-probe a port multiplier port, check for a device and attach info
11589 * structures when necessary. Identify Device data is fetched, if possible.
11590 * Assumption: sata address is already validated as port multiplier port.
11591 * SATA_SUCCESS is returned if port is re-probed sucessfully, regardless of
11592 * the presence of a device and its type.
11593 *
11594 * flag arg specifies that the function should try multiple times to identify
11595 * device type and to initialize it, or it should return immediately on failure.
11596 * SATA_DEV_IDENTIFY_RETRY - retry
11597 * SATA_DEV_IDENTIFY_NORETRY - no retry
11598 *
11599 * SATA_FAILURE is returned if one of the operations failed.
11600 *
11601 * This function cannot be called in interrupt context - it may sleep.
11602 *
11603 * NOTE: Should be only called by sata_probe_port() in case target port is a
11604 * port multiplier port.
11605 * NOTE: No Mutex should be hold.
11606 */
11607 static int
11608 sata_reprobe_pmport(sata_hba_inst_t *sata_hba_inst, sata_device_t *sata_device,
11609 int flag)
11610 {
11611 sata_cport_info_t *cportinfo = NULL;
11612 sata_pmport_info_t *pmportinfo = NULL;
11613 sata_drive_info_t *sdinfo, *osdinfo;
11614 sata_device_t sdevice;
11615 boolean_t init_device = B_FALSE;
11616 int prev_device_type = SATA_DTYPE_NONE;
11617 int prev_device_settings = 0;
11618 int prev_device_state = 0;
11619 clock_t start_time;
11620 uint8_t cport = sata_device->satadev_addr.cport;
11621 uint8_t pmport = sata_device->satadev_addr.pmport;
11622 int rval;
11623
11624 cportinfo = SATA_CPORT_INFO(sata_hba_inst, cport);
11625 pmportinfo = SATA_PMPORT_INFO(sata_hba_inst, cport, pmport);
11626 osdinfo = SATA_PMPORTINFO_DRV_INFO(pmportinfo);
11627
11628 if (osdinfo != NULL) {
11629 /*
11630 * We are re-probing port with a previously attached device.
11631 * Save previous device type and settings.
11632 */
11633 prev_device_type = pmportinfo->pmport_dev_type;
11634 prev_device_settings = osdinfo->satadrv_settings;
11635 prev_device_state = osdinfo->satadrv_state;
11636 }
11637
11638 start_time = ddi_get_lbolt();
11639
11640 /* check parent status */
11641 mutex_enter(&cportinfo->cport_mutex);
11642 if ((cportinfo->cport_state &
11643 (SATA_PSTATE_SHUTDOWN | SATA_PSTATE_FAILED)) ||
11644 (cportinfo->cport_scr.sstatus & SATA_PORT_DEVLINK_UP_MASK) !=
11645 SATA_PORT_DEVLINK_UP) {
11646 mutex_exit(&cportinfo->cport_mutex);
11647 return (SATA_FAILURE);
11648 }
11649 mutex_exit(&cportinfo->cport_mutex);
11650
11651 retry_probe_pmport:
11652
11653 /* probe port */
11654 mutex_enter(&pmportinfo->pmport_mutex);
11655 pmportinfo->pmport_state &= ~SATA_PORT_STATE_CLEAR_MASK;
11656 pmportinfo->pmport_state |= SATA_STATE_PROBING;
11657 mutex_exit(&pmportinfo->pmport_mutex);
11658
11659 rval = (*SATA_PROBE_PORT_FUNC(sata_hba_inst))
11660 (SATA_DIP(sata_hba_inst), sata_device);
11661
11662 /* might need retry because we cannot touch registers. */
11663 if (rval == SATA_FAILURE) {
11664 mutex_enter(&pmportinfo->pmport_mutex);
11665 pmportinfo->pmport_state = SATA_PSTATE_FAILED;
11666 mutex_exit(&pmportinfo->pmport_mutex);
11667 SATA_LOG_D((sata_hba_inst, CE_WARN, "sata_reprobe_pmport: "
11668 "SATA port %d:%d probing failed",
11669 cport, pmport));
11670 return (SATA_FAILURE);
11671 } else if (rval == SATA_RETRY) {
11672 SATA_LOG_D((sata_hba_inst, CE_WARN, "sata_reprobe_pmport: "
11673 "SATA port %d:%d probing failed, retrying...",
11674 cport, pmport));
11675 clock_t cur_time = ddi_get_lbolt();
11676 /*
11677 * A device was not successfully identified or initialized.
11678 * Track retry time for device identification.
11679 */
11680 if ((cur_time - start_time) <
11681 drv_usectohz(SATA_DEV_REPROBE_TIMEOUT)) {
11682 /* sleep for a while */
11683 delay(drv_usectohz(SATA_DEV_RETRY_DLY));
11684 goto retry_probe_pmport;
11685 } else {
11686 mutex_enter(&pmportinfo->pmport_mutex);
11687 if (SATA_PMPORTINFO_DRV_INFO(pmportinfo) != NULL)
11688 SATA_PMPORTINFO_DRV_INFO(pmportinfo)->
11689 satadrv_state = SATA_DSTATE_FAILED;
11690 mutex_exit(&pmportinfo->pmport_mutex);
11691 return (SATA_SUCCESS);
11692 }
11693 }
11694
11695 /*
11696 * Sanity check - Controller port is active? Is the link active?
11697 * Is it still a port multiplier?
11698 */
11699 if ((cportinfo->cport_state &
11700 (SATA_PSTATE_SHUTDOWN | SATA_PSTATE_FAILED)) ||
11701 (cportinfo->cport_scr.sstatus & SATA_PORT_DEVLINK_UP_MASK) !=
11702 SATA_PORT_DEVLINK_UP ||
11703 (cportinfo->cport_dev_type != SATA_DTYPE_PMULT)) {
11704 /*
11705 * Port in non-usable state or no link active/no
11706 * device. Free info structure.
11707 */
11708 cportinfo->cport_dev_type = SATA_DTYPE_UNKNOWN;
11709
11710 sdevice.satadev_addr.cport = cport;
11711 sdevice.satadev_addr.pmport = pmport;
11712 sdevice.satadev_addr.qual = SATA_ADDR_PMULT;
11713 mutex_exit(&cportinfo->cport_mutex);
11714
11715 sata_free_pmult(sata_hba_inst, &sdevice);
11716 return (SATA_FAILURE);
11717 }
11718
11719 /* SATA_SUCCESS NOW */
11720 /*
11721 * update sata port state and set device type
11722 */
11723 mutex_enter(&pmportinfo->pmport_mutex);
11724 sata_update_pmport_info(sata_hba_inst, sata_device);
11725 pmportinfo->pmport_state &= ~SATA_STATE_PROBING;
11726
11727 /*
11728 * Sanity check - Port is active? Is the link active?
11729 * Is there any device attached?
11730 */
11731 if ((pmportinfo->pmport_state &
11732 (SATA_PSTATE_SHUTDOWN | SATA_PSTATE_FAILED)) ||
11733 (pmportinfo->pmport_scr.sstatus & SATA_PORT_DEVLINK_UP_MASK) !=
11734 SATA_PORT_DEVLINK_UP) {
11735 /*
11736 * Port in non-usable state or no link active/no device.
11737 * Free info structure if necessary (direct attached drive
11738 * only, for now!
11739 */
11740 sdinfo = SATA_PMPORTINFO_DRV_INFO(pmportinfo);
11741 SATA_PMPORTINFO_DRV_INFO(pmportinfo) = NULL;
11742 /* Add here differentiation for device attached or not */
11743 pmportinfo->pmport_dev_type = SATA_DTYPE_NONE;
11744 mutex_exit(&pmportinfo->pmport_mutex);
11745 if (sdinfo != NULL)
11746 kmem_free(sdinfo, sizeof (sata_drive_info_t));
11747 return (SATA_SUCCESS);
11748 }
11749
11750 pmportinfo->pmport_state |= SATA_STATE_READY;
11751 pmportinfo->pmport_dev_type = sata_device->satadev_type;
11752 sdinfo = SATA_PMPORTINFO_DRV_INFO(pmportinfo);
11753
11754 /*
11755 * If we are re-probing the port, there may be
11756 * sata_drive_info structure attached
11757 * (or sata_pm_info, if PMult is supported).
11758 */
11759 if (sata_device->satadev_type == SATA_DTYPE_NONE) {
11760 /*
11761 * There is no device, so remove device info structure,
11762 * if necessary.
11763 */
11764 SATA_PMPORTINFO_DRV_INFO(pmportinfo) = NULL;
11765 pmportinfo->pmport_dev_type = SATA_DTYPE_NONE;
11766 if (sdinfo != NULL) {
11767 kmem_free(sdinfo, sizeof (sata_drive_info_t));
11768 sata_log(sata_hba_inst, CE_WARN,
11769 "SATA device detached from port %d:%d",
11770 cport, pmport);
11771 }
11772 mutex_exit(&pmportinfo->pmport_mutex);
11773 return (SATA_SUCCESS);
11774 }
11775
11776 /* this should not be a pmult */
11777 ASSERT(sata_device->satadev_type != SATA_DTYPE_PMULT);
11778 if (sdinfo == NULL) {
11779 /*
11780 * There is some device attached, but there is
11781 * no sata_drive_info structure - allocate one
11782 */
11783 mutex_exit(&pmportinfo->pmport_mutex);
11784 sdinfo = kmem_zalloc(sizeof (sata_drive_info_t),
11785 KM_SLEEP);
11786 mutex_enter(&pmportinfo->pmport_mutex);
11787 /*
11788 * Recheck, that the port state did not change when we
11789 * released mutex.
11790 */
11791 if (pmportinfo->pmport_state & SATA_STATE_READY) {
11792 SATA_PMPORTINFO_DRV_INFO(pmportinfo) = sdinfo;
11793 sdinfo->satadrv_addr = pmportinfo->pmport_addr;
11794 sdinfo->satadrv_addr.qual = SATA_ADDR_DPMPORT;
11795 sdinfo->satadrv_type = SATA_DTYPE_UNKNOWN;
11796 sdinfo->satadrv_state = SATA_STATE_UNKNOWN;
11797 } else {
11798 /*
11799 * Port is not in ready state, we
11800 * cannot attach a device.
11801 */
11802 mutex_exit(&pmportinfo->pmport_mutex);
11803 kmem_free(sdinfo, sizeof (sata_drive_info_t));
11804 return (SATA_SUCCESS);
11805 }
11806 /*
11807 * Since we are adding device, presumably new one,
11808 * indicate that it should be initalized,
11809 * as well as some internal framework states).
11810 */
11811 init_device = B_TRUE;
11812 }
11813
11814 pmportinfo->pmport_dev_type = SATA_DTYPE_UNKNOWN;
11815 sata_device->satadev_addr.qual = sdinfo->satadrv_addr.qual;
11816
11817 mutex_exit(&pmportinfo->pmport_mutex);
11818 /*
11819 * Figure out what kind of device we are really
11820 * dealing with.
11821 */
11822 rval = sata_probe_device(sata_hba_inst, sata_device);
11823
11824 mutex_enter(&pmportinfo->pmport_mutex);
11825 if (rval == SATA_SUCCESS) {
11826 /*
11827 * If we are dealing with the same type of a device as before,
11828 * restore its settings flags.
11829 */
11830 if (osdinfo != NULL &&
11831 sata_device->satadev_type == prev_device_type)
11832 sdinfo->satadrv_settings = prev_device_settings;
11833
11834 mutex_exit(&pmportinfo->pmport_mutex);
11835 /* Set initial device features, if necessary */
11836 if (init_device == B_TRUE) {
11837 rval = sata_initialize_device(sata_hba_inst, sdinfo);
11838 }
11839 if (rval == SATA_SUCCESS)
11840 return (rval);
11841 } else {
11842 /*
11843 * If there was some device info before we probe the device,
11844 * restore previous device setting, so we can retry from scratch
11845 * later. Providing, of course, that device has not disappeared
11846 * during probing process.
11847 */
11848 if (sata_device->satadev_type != SATA_DTYPE_NONE) {
11849 if (osdinfo != NULL) {
11850 pmportinfo->pmport_dev_type = prev_device_type;
11851 sdinfo->satadrv_type = prev_device_type;
11852 sdinfo->satadrv_state = prev_device_state;
11853 }
11854 } else {
11855 /* device is gone */
11856 kmem_free(sdinfo, sizeof (sata_drive_info_t));
11857 pmportinfo->pmport_dev_type = SATA_DTYPE_NONE;
11858 SATA_PMPORTINFO_DRV_INFO(pmportinfo) = NULL;
11859 mutex_exit(&pmportinfo->pmport_mutex);
11860 return (SATA_SUCCESS);
11861 }
11862 mutex_exit(&pmportinfo->pmport_mutex);
11863 }
11864
11865 if (flag == SATA_DEV_IDENTIFY_RETRY) {
11866 clock_t cur_time = ddi_get_lbolt();
11867 /*
11868 * A device was not successfully identified or initialized.
11869 * Track retry time for device identification.
11870 */
11871 if ((cur_time - start_time) <
11872 drv_usectohz(SATA_DEV_REPROBE_TIMEOUT)) {
11873 /* sleep for a while */
11874 delay(drv_usectohz(SATA_DEV_RETRY_DLY));
11875 goto retry_probe_pmport;
11876 } else {
11877 mutex_enter(&pmportinfo->pmport_mutex);
11878 if (SATA_PMPORTINFO_DRV_INFO(pmportinfo) != NULL)
11879 SATA_PMPORTINFO_DRV_INFO(pmportinfo)->
11880 satadrv_state = SATA_DSTATE_FAILED;
11881 mutex_exit(&pmportinfo->pmport_mutex);
11882 }
11883 }
11884 return (SATA_SUCCESS);
11885 }
11886
11887 /*
11888 * Allocated related structure for a port multiplier and its device ports
11889 *
11890 * Port multiplier should be ready and probed, and related information like
11891 * the number of the device ports should be store in sata_device_t.
11892 *
11893 * NOTE: No Mutex should be hold.
11894 */
11895 static int
11896 sata_alloc_pmult(sata_hba_inst_t *sata_hba_inst, sata_device_t *sata_device)
11897 {
11898 dev_info_t *dip = SATA_DIP(sata_hba_inst);
11899 sata_cport_info_t *cportinfo = NULL;
11900 sata_pmult_info_t *pmultinfo = NULL;
11901 sata_pmport_info_t *pmportinfo = NULL;
11902 sata_device_t sd;
11903 dev_t minor_number;
11904 char name[16];
11905 uint8_t cport = sata_device->satadev_addr.cport;
11906 int rval;
11907 int npmport;
11908
11909 cportinfo = SATA_CPORT_INFO(sata_hba_inst, cport);
11910
11911 /* This function might be called while a port-mult is hot-plugged. */
11912 mutex_enter(&cportinfo->cport_mutex);
11913
11914 /* dev_type's not updated when get called from sata_reprobe_port() */
11915 if (SATA_CPORTINFO_PMULT_INFO(cportinfo) == NULL) {
11916 /* Create a pmult_info structure */
11917 SATA_CPORTINFO_PMULT_INFO(cportinfo) =
11918 kmem_zalloc(sizeof (sata_pmult_info_t), KM_SLEEP);
11919 }
11920 pmultinfo = SATA_CPORTINFO_PMULT_INFO(cportinfo);
11921
11922 pmultinfo->pmult_addr = sata_device->satadev_addr;
11923 pmultinfo->pmult_addr.qual = SATA_ADDR_PMULT;
11924 pmultinfo->pmult_state = SATA_STATE_PROBING;
11925
11926 /*
11927 * Probe the port multiplier with qualifier SATA_ADDR_PMULT_SPEC,
11928 * The HBA driver should initialize and register the port multiplier,
11929 * sata_register_pmult() will fill following fields,
11930 * + sata_pmult_info.pmult_gscr
11931 * + sata_pmult_info.pmult_num_dev_ports
11932 */
11933 sd.satadev_addr = sata_device->satadev_addr;
11934 sd.satadev_addr.qual = SATA_ADDR_PMULT_SPEC;
11935 mutex_exit(&cportinfo->cport_mutex);
11936 rval = (*SATA_PROBE_PORT_FUNC(sata_hba_inst))
11937 (SATA_DIP(sata_hba_inst), &sd);
11938 mutex_enter(&cportinfo->cport_mutex);
11939
11940 if (rval != SATA_SUCCESS ||
11941 (sd.satadev_type != SATA_DTYPE_PMULT) ||
11942 !(sd.satadev_state & SATA_DSTATE_PMULT_INIT)) {
11943 SATA_CPORTINFO_PMULT_INFO(cportinfo) = NULL;
11944 kmem_free(pmultinfo, sizeof (sata_pmult_info_t));
11945 cportinfo->cport_state = SATA_PSTATE_FAILED;
11946 cportinfo->cport_dev_type = SATA_DTYPE_UNKNOWN;
11947 mutex_exit(&cportinfo->cport_mutex);
11948 SATADBG1(SATA_DBG_PMULT, sata_hba_inst,
11949 "sata_alloc_pmult: failed to initialize pmult "
11950 "at port %d.", cport)
11951 return (SATA_FAILURE);
11952 }
11953
11954 /* Initialize pmport_info structure */
11955 for (npmport = 0; npmport < pmultinfo->pmult_num_dev_ports;
11956 npmport++) {
11957
11958 /* if everything is allocated, skip */
11959 if (SATA_PMPORT_INFO(sata_hba_inst, cport, npmport) != NULL)
11960 continue;
11961
11962 pmportinfo = kmem_zalloc(sizeof (sata_pmport_info_t), KM_SLEEP);
11963 mutex_init(&pmportinfo->pmport_mutex, NULL, MUTEX_DRIVER, NULL);
11964 mutex_exit(&cportinfo->cport_mutex);
11965
11966 mutex_enter(&pmportinfo->pmport_mutex);
11967 pmportinfo->pmport_addr.cport = cport;
11968 pmportinfo->pmport_addr.pmport = (uint8_t)npmport;
11969 pmportinfo->pmport_addr.qual = SATA_ADDR_PMPORT;
11970 pmportinfo->pmport_state &= ~SATA_PORT_STATE_CLEAR_MASK;
11971 mutex_exit(&pmportinfo->pmport_mutex);
11972
11973 mutex_enter(&cportinfo->cport_mutex);
11974 SATA_PMPORT_INFO(sata_hba_inst, cport, npmport) = pmportinfo;
11975
11976 /* Create an attachment point */
11977 minor_number = SATA_MAKE_AP_MINOR(ddi_get_instance(dip),
11978 cport, (uint8_t)npmport, SATA_ADDR_PMPORT);
11979 (void) sprintf(name, "%d.%d", cport, npmport);
11980
11981 if (ddi_create_minor_node(dip, name, S_IFCHR, minor_number,
11982 DDI_NT_SATA_ATTACHMENT_POINT, 0) != DDI_SUCCESS) {
11983 sata_log(sata_hba_inst, CE_WARN, "sata_hba_attach: "
11984 "cannot create SATA attachment point for "
11985 "port %d:%d", cport, npmport);
11986 }
11987 }
11988
11989 pmultinfo->pmult_state &= ~SATA_STATE_PROBING;
11990 pmultinfo->pmult_state |= (SATA_STATE_PROBED|SATA_STATE_READY);
11991 cportinfo->cport_dev_type = SATA_DTYPE_PMULT;
11992
11993 mutex_exit(&cportinfo->cport_mutex);
11994 return (SATA_SUCCESS);
11995 }
11996
11997 /*
11998 * Free data structures when a port multiplier is removed.
11999 *
12000 * NOTE: No Mutex should be hold.
12001 */
12002 static void
12003 sata_free_pmult(sata_hba_inst_t *sata_hba_inst, sata_device_t *sata_device)
12004 {
12005 sata_cport_info_t *cportinfo;
12006 sata_pmult_info_t *pmultinfo;
12007 sata_pmport_info_t *pmportinfo;
12008 sata_device_t pmport_device;
12009 sata_drive_info_t *sdinfo;
12010 dev_info_t *tdip;
12011 char name[16];
12012 uint8_t cport = sata_device->satadev_addr.cport;
12013 int npmport;
12014
12015 cportinfo = SATA_CPORT_INFO(sata_hba_inst, cport);
12016
12017 /* This function might be called while port-mult is hot plugged. */
12018 mutex_enter(&cportinfo->cport_mutex);
12019
12020 cportinfo->cport_dev_type = SATA_DTYPE_NONE;
12021 pmultinfo = SATA_CPORTINFO_PMULT_INFO(cportinfo);
12022 ASSERT(pmultinfo != NULL);
12023
12024 /* Free pmport_info structure */
12025 for (npmport = 0; npmport < pmultinfo->pmult_num_dev_ports;
12026 npmport++) {
12027 pmportinfo = SATA_PMPORT_INFO(sata_hba_inst, cport, npmport);
12028 if (pmportinfo == NULL)
12029 continue;
12030 mutex_exit(&cportinfo->cport_mutex);
12031
12032 mutex_enter(&pmportinfo->pmport_mutex);
12033 sdinfo = pmportinfo->pmport_sata_drive;
12034 SATA_PMPORTINFO_DRV_INFO(pmportinfo) = NULL;
12035 mutex_exit(&pmportinfo->pmport_mutex);
12036
12037 /* Remove attachment point. */
12038 name[0] = '\0';
12039 (void) sprintf(name, "%d.%d", cport, npmport);
12040 ddi_remove_minor_node(SATA_DIP(sata_hba_inst), name);
12041 sata_log(sata_hba_inst, CE_NOTE,
12042 "Remove attachment point of port %d:%d",
12043 cport, npmport);
12044
12045 /*
12046 * Rumove target node
12047 */
12048 bzero(&pmport_device, sizeof (sata_device_t));
12049 pmport_device.satadev_rev = SATA_DEVICE_REV;
12050 pmport_device.satadev_addr.cport = cport;
12051 pmport_device.satadev_addr.pmport = (uint8_t)npmport;
12052 pmport_device.satadev_addr.qual = SATA_ADDR_DPMPORT;
12053
12054 tdip = sata_get_scsi_target_dip(SATA_DIP(sata_hba_inst),
12055 &(pmport_device.satadev_addr));
12056 if (tdip != NULL && ndi_devi_offline(tdip,
12057 NDI_DEVI_REMOVE) != NDI_SUCCESS) {
12058 /*
12059 * Problem :
12060 * The target node remained attached.
12061 * This happens when the device file was open
12062 * or a node was waiting for resources.
12063 * Cannot do anything about it.
12064 */
12065 SATA_LOG_D((sata_hba_inst, CE_WARN,
12066 "sata_free_pmult: could not unconfigure device "
12067 "before disconnecting the SATA port %d:%d",
12068 cport, npmport));
12069
12070 /*
12071 * Set DEVICE REMOVED state in the target
12072 * node. It will prevent access to the device
12073 * even when a new device is attached, until
12074 * the old target node is released, removed and
12075 * recreated for a new device.
12076 */
12077 sata_set_device_removed(tdip);
12078
12079 /*
12080 * Instruct event daemon to try the target
12081 * node cleanup later.
12082 */
12083 sata_set_target_node_cleanup(
12084 sata_hba_inst, &(pmport_device.satadev_addr));
12085
12086 }
12087 mutex_enter(&cportinfo->cport_mutex);
12088
12089 /*
12090 * Add here differentiation for device attached or not
12091 */
12092 if (sdinfo != NULL) {
12093 sata_log(sata_hba_inst, CE_WARN,
12094 "SATA device detached from port %d:%d",
12095 cport, npmport);
12096 kmem_free(sdinfo, sizeof (sata_drive_info_t));
12097 }
12098
12099 mutex_destroy(&pmportinfo->pmport_mutex);
12100 kmem_free(pmportinfo, sizeof (sata_pmport_info_t));
12101 }
12102
12103 kmem_free(pmultinfo, sizeof (sata_pmult_info_t));
12104
12105 cportinfo->cport_devp.cport_sata_pmult = NULL;
12106
12107 sata_log(sata_hba_inst, CE_WARN,
12108 "SATA port multiplier detached at port %d", cport);
12109
12110 mutex_exit(&cportinfo->cport_mutex);
12111 }
12112
12113 /*
12114 * Initialize device
12115 * Specified device is initialized to a default state.
12116 *
12117 * Returns SATA_SUCCESS if all device features are set successfully,
12118 * SATA_RETRY if device is accessible but device features were not set
12119 * successfully, and SATA_FAILURE otherwise.
12120 */
12121 static int
12122 sata_initialize_device(sata_hba_inst_t *sata_hba_inst,
12123 sata_drive_info_t *sdinfo)
12124 {
12125 int rval;
12126
12127 sata_save_drive_settings(sdinfo);
12128
12129 sdinfo->satadrv_settings |= SATA_DEV_READ_AHEAD;
12130
12131 sata_init_write_cache_mode(sdinfo);
12132
12133 rval = sata_set_drive_features(sata_hba_inst, sdinfo, 0);
12134
12135 /* Determine current data transfer mode */
12136 if ((sdinfo->satadrv_id.ai_cap & SATA_DMA_SUPPORT) == 0) {
12137 sdinfo->satadrv_settings &= ~SATA_DEV_DMA;
12138 } else if ((sdinfo->satadrv_id.ai_validinfo &
12139 SATA_VALIDINFO_88) != 0 &&
12140 (sdinfo->satadrv_id.ai_ultradma & SATA_UDMA_SEL_MASK) != 0) {
12141 sdinfo->satadrv_settings |= SATA_DEV_DMA;
12142 } else if ((sdinfo->satadrv_id.ai_dworddma &
12143 SATA_MDMA_SEL_MASK) != 0) {
12144 sdinfo->satadrv_settings |= SATA_DEV_DMA;
12145 } else
12146 /* DMA supported, not no DMA transfer mode is selected !? */
12147 sdinfo->satadrv_settings &= ~SATA_DEV_DMA;
12148
12149 if ((sdinfo->satadrv_id.ai_cmdset83 & 0x20) &&
12150 (sdinfo->satadrv_id.ai_features86 & 0x20))
12151 sdinfo->satadrv_power_level = SATA_POWER_STANDBY;
12152 else
12153 sdinfo->satadrv_power_level = SATA_POWER_ACTIVE;
12154
12155 return (rval);
12156 }
12157
12158
12159 /*
12160 * Initialize write cache mode.
12161 *
12162 * The default write cache setting for SATA HDD is provided by sata_write_cache
12163 * static variable. ATAPI CD/DVDs devices have write cache default is
12164 * determined by sata_atapicdvd_write_cache static variable.
12165 * ATAPI tape devices have write cache default is determined by
12166 * sata_atapitape_write_cache static variable.
12167 * ATAPI disk devices have write cache default is determined by
12168 * sata_atapidisk_write_cache static variable.
12169 * 1 - enable
12170 * 0 - disable
12171 * any other value - current drive setting
12172 *
12173 * Although there is not reason to disable write cache on CD/DVD devices,
12174 * tape devices and ATAPI disk devices, the default setting control is provided
12175 * for the maximun flexibility.
12176 *
12177 * In the future, it may be overridden by the
12178 * disk-write-cache-enable property setting, if it is defined.
12179 * Returns SATA_SUCCESS if all device features are set successfully,
12180 * SATA_FAILURE otherwise.
12181 */
12182 static void
12183 sata_init_write_cache_mode(sata_drive_info_t *sdinfo)
12184 {
12185 switch (sdinfo->satadrv_type) {
12186 case SATA_DTYPE_ATADISK:
12187 if (sata_write_cache == 1)
12188 sdinfo->satadrv_settings |= SATA_DEV_WRITE_CACHE;
12189 else if (sata_write_cache == 0)
12190 sdinfo->satadrv_settings &= ~SATA_DEV_WRITE_CACHE;
12191 /*
12192 * When sata_write_cache value is not 0 or 1,
12193 * a current setting of the drive's write cache is used.
12194 */
12195 break;
12196 case SATA_DTYPE_ATAPICD:
12197 if (sata_atapicdvd_write_cache == 1)
12198 sdinfo->satadrv_settings |= SATA_DEV_WRITE_CACHE;
12199 else if (sata_atapicdvd_write_cache == 0)
12200 sdinfo->satadrv_settings &= ~SATA_DEV_WRITE_CACHE;
12201 /*
12202 * When sata_atapicdvd_write_cache value is not 0 or 1,
12203 * a current setting of the drive's write cache is used.
12204 */
12205 break;
12206 case SATA_DTYPE_ATAPITAPE:
12207 if (sata_atapitape_write_cache == 1)
12208 sdinfo->satadrv_settings |= SATA_DEV_WRITE_CACHE;
12209 else if (sata_atapitape_write_cache == 0)
12210 sdinfo->satadrv_settings &= ~SATA_DEV_WRITE_CACHE;
12211 /*
12212 * When sata_atapitape_write_cache value is not 0 or 1,
12213 * a current setting of the drive's write cache is used.
12214 */
12215 break;
12216 case SATA_DTYPE_ATAPIDISK:
12217 if (sata_atapidisk_write_cache == 1)
12218 sdinfo->satadrv_settings |= SATA_DEV_WRITE_CACHE;
12219 else if (sata_atapidisk_write_cache == 0)
12220 sdinfo->satadrv_settings &= ~SATA_DEV_WRITE_CACHE;
12221 /*
12222 * When sata_atapidisk_write_cache value is not 0 or 1,
12223 * a current setting of the drive's write cache is used.
12224 */
12225 break;
12226 }
12227 }
12228
12229
12230 /*
12231 * Validate sata address.
12232 * Specified cport, pmport and qualifier has to match
12233 * passed sata_scsi configuration info.
12234 * The presence of an attached device is not verified.
12235 *
12236 * Returns 0 when address is valid, -1 otherwise.
12237 */
12238 static int
12239 sata_validate_sata_address(sata_hba_inst_t *sata_hba_inst, int cport,
12240 int pmport, int qual)
12241 {
12242 if (qual == SATA_ADDR_DCPORT && pmport != 0)
12243 goto invalid_address;
12244 if (cport >= SATA_NUM_CPORTS(sata_hba_inst))
12245 goto invalid_address;
12246 if ((qual == SATA_ADDR_DPMPORT || qual == SATA_ADDR_PMPORT) &&
12247 ((SATA_CPORT_DEV_TYPE(sata_hba_inst, cport) != SATA_DTYPE_PMULT) ||
12248 (SATA_PMULT_INFO(sata_hba_inst, cport) == NULL) ||
12249 (pmport >= SATA_NUM_PMPORTS(sata_hba_inst, cport))))
12250 goto invalid_address;
12251
12252 return (0);
12253
12254 invalid_address:
12255 return (-1);
12256
12257 }
12258
12259 /*
12260 * Validate scsi address
12261 * SCSI target address is translated into SATA cport/pmport and compared
12262 * with a controller port/device configuration. LUN has to be 0.
12263 * Returns 0 if a scsi target refers to an attached device,
12264 * returns 1 if address is valid but no valid device is attached,
12265 * returns 2 if address is valid but device type is unknown (not valid device),
12266 * returns -1 if bad address or device is of an unsupported type.
12267 * Upon return sata_device argument is set.
12268 *
12269 * Port multiplier is supported now.
12270 */
12271 static int
12272 sata_validate_scsi_address(sata_hba_inst_t *sata_hba_inst,
12273 struct scsi_address *ap, sata_device_t *sata_device)
12274 {
12275 int cport, pmport, qual, rval;
12276
12277 rval = -1; /* Invalid address */
12278 if (ap->a_lun != 0)
12279 goto out;
12280
12281 qual = SCSI_TO_SATA_ADDR_QUAL(ap->a_target);
12282 cport = SCSI_TO_SATA_CPORT(ap->a_target);
12283 pmport = SCSI_TO_SATA_PMPORT(ap->a_target);
12284
12285 if (qual != SATA_ADDR_DCPORT && qual != SATA_ADDR_DPMPORT)
12286 goto out;
12287
12288 if (sata_validate_sata_address(sata_hba_inst, cport, pmport, qual) ==
12289 0) {
12290
12291 sata_cport_info_t *cportinfo;
12292 sata_pmult_info_t *pmultinfo;
12293 sata_drive_info_t *sdinfo = NULL;
12294
12295 sata_device->satadev_addr.qual = qual;
12296 sata_device->satadev_addr.cport = cport;
12297 sata_device->satadev_addr.pmport = pmport;
12298 sata_device->satadev_rev = SATA_DEVICE_REV_1;
12299
12300 rval = 1; /* Valid sata address */
12301
12302 cportinfo = SATA_CPORT_INFO(sata_hba_inst, cport);
12303 if (qual == SATA_ADDR_DCPORT) {
12304 if (cportinfo == NULL ||
12305 cportinfo->cport_dev_type == SATA_DTYPE_NONE)
12306 goto out;
12307
12308 sdinfo = SATA_CPORTINFO_DRV_INFO(cportinfo);
12309 if (cportinfo->cport_dev_type == SATA_DTYPE_UNKNOWN &&
12310 sdinfo != NULL) {
12311 rval = 2;
12312 goto out;
12313 }
12314
12315 if ((cportinfo->cport_dev_type &
12316 SATA_VALID_DEV_TYPE) == 0) {
12317 rval = -1;
12318 goto out;
12319 }
12320
12321 } else if (qual == SATA_ADDR_DPMPORT) {
12322 pmultinfo = SATA_CPORTINFO_PMULT_INFO(cportinfo);
12323 if (pmultinfo == NULL) {
12324 rval = -1;
12325 goto out;
12326 }
12327 if (SATA_PMPORT_INFO(sata_hba_inst, cport, pmport) ==
12328 NULL ||
12329 SATA_PMPORT_DEV_TYPE(sata_hba_inst, cport,
12330 pmport) == SATA_DTYPE_NONE)
12331 goto out;
12332
12333 sdinfo = SATA_PMPORT_DRV_INFO(sata_hba_inst, cport,
12334 pmport);
12335 if (SATA_PMPORT_DEV_TYPE(sata_hba_inst, cport,
12336 pmport) == SATA_DTYPE_UNKNOWN && sdinfo != NULL) {
12337 rval = 2;
12338 goto out;
12339 }
12340
12341 if ((SATA_PMPORT_DEV_TYPE(sata_hba_inst, cport,
12342 pmport) & SATA_VALID_DEV_TYPE) == 0) {
12343 rval = -1;
12344 goto out;
12345 }
12346
12347 } else {
12348 rval = -1;
12349 goto out;
12350 }
12351 if ((sdinfo == NULL) ||
12352 (sdinfo->satadrv_type & SATA_VALID_DEV_TYPE) == 0)
12353 goto out;
12354
12355 sata_device->satadev_type = sdinfo->satadrv_type;
12356
12357 return (0);
12358 }
12359 out:
12360 if (rval > 0) {
12361 SATADBG2(SATA_DBG_SCSI_IF, sata_hba_inst,
12362 "sata_validate_scsi_address: no valid target %x lun %x",
12363 ap->a_target, ap->a_lun);
12364 }
12365 return (rval);
12366 }
12367
12368 /*
12369 * Find dip corresponding to passed device number
12370 *
12371 * Returns NULL if invalid device number is passed or device cannot be found,
12372 * Returns dip is device is found.
12373 */
12374 static dev_info_t *
12375 sata_devt_to_devinfo(dev_t dev)
12376 {
12377 dev_info_t *dip;
12378 #ifndef __lock_lint
12379 struct devnames *dnp;
12380 major_t major = getmajor(dev);
12381 int instance = SATA_MINOR2INSTANCE(getminor(dev));
12382
12383 if (major >= devcnt)
12384 return (NULL);
12385
12386 dnp = &devnamesp[major];
12387 LOCK_DEV_OPS(&(dnp->dn_lock));
12388 dip = dnp->dn_head;
12389 while (dip && (ddi_get_instance(dip) != instance)) {
12390 dip = ddi_get_next(dip);
12391 }
12392 UNLOCK_DEV_OPS(&(dnp->dn_lock));
12393 #endif
12394
12395 return (dip);
12396 }
12397
12398
12399 /*
12400 * Probe device.
12401 * This function issues Identify Device command and initializes local
12402 * sata_drive_info structure if the device can be identified.
12403 * The device type is determined by examining Identify Device
12404 * command response.
12405 * If the sata_hba_inst has linked drive info structure for this
12406 * device address, the Identify Device data is stored into sata_drive_info
12407 * structure linked to the port info structure.
12408 *
12409 * sata_device has to refer to the valid sata port(s) for HBA described
12410 * by sata_hba_inst structure.
12411 *
12412 * Returns:
12413 * SATA_SUCCESS if device type was successfully probed and port-linked
12414 * drive info structure was updated;
12415 * SATA_FAILURE if there is no device, or device was not probed
12416 * successully;
12417 * SATA_RETRY if device probe can be retried later.
12418 * If a device cannot be identified, sata_device's dev_state and dev_type
12419 * fields are set to unknown.
12420 * There are no retries in this function. Any retries should be managed by
12421 * the caller.
12422 */
12423
12424
12425 static int
12426 sata_probe_device(sata_hba_inst_t *sata_hba_inst, sata_device_t *sata_device)
12427 {
12428 sata_pmport_info_t *pmportinfo;
12429 sata_drive_info_t *sdinfo;
12430 sata_drive_info_t new_sdinfo; /* local drive info struct */
12431 int rval;
12432
12433 ASSERT((SATA_CPORT_STATE(sata_hba_inst,
12434 sata_device->satadev_addr.cport) &
12435 (SATA_STATE_PROBED | SATA_STATE_READY)) != 0);
12436
12437 sata_device->satadev_type = SATA_DTYPE_NONE;
12438
12439 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst,
12440 sata_device->satadev_addr.cport)));
12441
12442 if (sata_device->satadev_addr.qual == SATA_ADDR_DPMPORT) {
12443 pmportinfo = SATA_PMPORT_INFO(sata_hba_inst,
12444 sata_device->satadev_addr.cport,
12445 sata_device->satadev_addr.pmport);
12446 ASSERT(pmportinfo != NULL);
12447 }
12448
12449 /* Get pointer to port-linked sata device info structure */
12450 sdinfo = sata_get_device_info(sata_hba_inst, sata_device);
12451 if (sdinfo != NULL) {
12452 sdinfo->satadrv_state &=
12453 ~(SATA_STATE_PROBED | SATA_STATE_READY);
12454 sdinfo->satadrv_state |= SATA_STATE_PROBING;
12455 } else {
12456 /* No device to probe */
12457 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst,
12458 sata_device->satadev_addr.cport)));
12459 sata_device->satadev_type = SATA_DTYPE_NONE;
12460 sata_device->satadev_state = SATA_STATE_UNKNOWN;
12461 return (SATA_FAILURE);
12462 }
12463 /*
12464 * Need to issue both types of identify device command and
12465 * determine device type by examining retreived data/status.
12466 * First, ATA Identify Device.
12467 */
12468 bzero(&new_sdinfo, sizeof (sata_drive_info_t));
12469 new_sdinfo.satadrv_addr = sata_device->satadev_addr;
12470 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst,
12471 sata_device->satadev_addr.cport)));
12472 new_sdinfo.satadrv_type = SATA_DTYPE_ATADISK;
12473 rval = sata_identify_device(sata_hba_inst, &new_sdinfo);
12474 if (rval == SATA_RETRY) {
12475 /* We may try to check for ATAPI device */
12476 if (SATA_FEATURES(sata_hba_inst) & SATA_CTLF_ATAPI) {
12477 /*
12478 * HBA supports ATAPI - try to issue Identify Packet
12479 * Device command.
12480 */
12481 new_sdinfo.satadrv_type = SATA_DTYPE_ATAPI;
12482 rval = sata_identify_device(sata_hba_inst, &new_sdinfo);
12483 }
12484 }
12485 if (rval == SATA_SUCCESS) {
12486 /*
12487 * Got something responding positively to ATA Identify Device
12488 * or to Identify Packet Device cmd.
12489 * Save last used device type.
12490 */
12491 sata_device->satadev_type = new_sdinfo.satadrv_type;
12492
12493 /* save device info, if possible */
12494 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst,
12495 sata_device->satadev_addr.cport)));
12496 sdinfo = sata_get_device_info(sata_hba_inst, sata_device);
12497 if (sdinfo == NULL) {
12498 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst,
12499 sata_device->satadev_addr.cport)));
12500 return (SATA_FAILURE);
12501 }
12502 /*
12503 * Copy drive info into the port-linked drive info structure.
12504 */
12505 *sdinfo = new_sdinfo;
12506 sdinfo->satadrv_state &= ~SATA_STATE_PROBING;
12507 sdinfo->satadrv_state |= SATA_STATE_PROBED;
12508 if (sata_device->satadev_addr.qual == SATA_ADDR_DCPORT)
12509 SATA_CPORT_DEV_TYPE(sata_hba_inst,
12510 sata_device->satadev_addr.cport) =
12511 sdinfo->satadrv_type;
12512 else { /* SATA_ADDR_DPMPORT */
12513 mutex_enter(&pmportinfo->pmport_mutex);
12514 SATA_PMPORT_DEV_TYPE(sata_hba_inst,
12515 sata_device->satadev_addr.cport,
12516 sata_device->satadev_addr.pmport) =
12517 sdinfo->satadrv_type;
12518 mutex_exit(&pmportinfo->pmport_mutex);
12519 }
12520 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst,
12521 sata_device->satadev_addr.cport)));
12522 return (SATA_SUCCESS);
12523 }
12524
12525 /*
12526 * It may be SATA_RETRY or SATA_FAILURE return.
12527 * Looks like we cannot determine the device type at this time.
12528 */
12529 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst,
12530 sata_device->satadev_addr.cport)));
12531 sdinfo = sata_get_device_info(sata_hba_inst, sata_device);
12532 if (sdinfo != NULL) {
12533 sata_device->satadev_type = SATA_DTYPE_UNKNOWN;
12534 sdinfo->satadrv_type = SATA_DTYPE_UNKNOWN;
12535 sdinfo->satadrv_state &= ~SATA_STATE_PROBING;
12536 sdinfo->satadrv_state |= SATA_STATE_PROBED;
12537 if (sata_device->satadev_addr.qual == SATA_ADDR_DCPORT)
12538 SATA_CPORT_DEV_TYPE(sata_hba_inst,
12539 sata_device->satadev_addr.cport) =
12540 SATA_DTYPE_UNKNOWN;
12541 else {
12542 /* SATA_ADDR_DPMPORT */
12543 mutex_enter(&pmportinfo->pmport_mutex);
12544 if ((SATA_PMULT_INFO(sata_hba_inst,
12545 sata_device->satadev_addr.cport) != NULL) &&
12546 (SATA_PMPORT_INFO(sata_hba_inst,
12547 sata_device->satadev_addr.cport,
12548 sata_device->satadev_addr.pmport) != NULL))
12549 SATA_PMPORT_DEV_TYPE(sata_hba_inst,
12550 sata_device->satadev_addr.cport,
12551 sata_device->satadev_addr.pmport) =
12552 SATA_DTYPE_UNKNOWN;
12553 mutex_exit(&pmportinfo->pmport_mutex);
12554 }
12555 }
12556 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst,
12557 sata_device->satadev_addr.cport)));
12558 return (rval);
12559 }
12560
12561
12562 /*
12563 * Get pointer to sata_drive_info structure.
12564 *
12565 * The sata_device has to contain address (cport, pmport and qualifier) for
12566 * specified sata_scsi structure.
12567 *
12568 * Returns NULL if device address is not valid for this HBA configuration.
12569 * Otherwise, returns a pointer to sata_drive_info structure.
12570 *
12571 * This function should be called with a port mutex held.
12572 */
12573 static sata_drive_info_t *
12574 sata_get_device_info(sata_hba_inst_t *sata_hba_inst,
12575 sata_device_t *sata_device)
12576 {
12577 uint8_t cport = sata_device->satadev_addr.cport;
12578 uint8_t pmport = sata_device->satadev_addr.pmport;
12579 uint8_t qual = sata_device->satadev_addr.qual;
12580
12581 if (cport >= SATA_NUM_CPORTS(sata_hba_inst))
12582 return (NULL);
12583
12584 if (!(SATA_CPORT_STATE(sata_hba_inst, cport) &
12585 (SATA_STATE_PROBED | SATA_STATE_READY)))
12586 /* Port not probed yet */
12587 return (NULL);
12588
12589 if (SATA_CPORT_DEV_TYPE(sata_hba_inst, cport) == SATA_DTYPE_NONE)
12590 return (NULL);
12591
12592 if (qual == SATA_ADDR_DCPORT) {
12593 /* Request for a device on a controller port */
12594 if (SATA_CPORT_DEV_TYPE(sata_hba_inst, cport) ==
12595 SATA_DTYPE_PMULT)
12596 /* Port multiplier attached */
12597 return (NULL);
12598 return (SATA_CPORT_DRV_INFO(sata_hba_inst, cport));
12599 }
12600 if (qual == SATA_ADDR_DPMPORT) {
12601 if (SATA_CPORT_DEV_TYPE(sata_hba_inst, cport) !=
12602 SATA_DTYPE_PMULT)
12603 return (NULL);
12604
12605 if (pmport > SATA_NUM_PMPORTS(sata_hba_inst, cport))
12606 return (NULL);
12607
12608 if (!(SATA_PMPORT_STATE(sata_hba_inst, cport, pmport) &
12609 (SATA_STATE_PROBED | SATA_STATE_READY)))
12610 /* Port multiplier port not probed yet */
12611 return (NULL);
12612
12613 return (SATA_PMPORT_DRV_INFO(sata_hba_inst, cport, pmport));
12614 }
12615
12616 /* we should not get here */
12617 return (NULL);
12618 }
12619
12620
12621 /*
12622 * sata_identify_device.
12623 * Send Identify Device command to SATA HBA driver.
12624 * If command executes successfully, update sata_drive_info structure pointed
12625 * to by sdinfo argument, including Identify Device data.
12626 * If command fails, invalidate data in sata_drive_info.
12627 *
12628 * Cannot be called from interrupt level.
12629 *
12630 * Returns:
12631 * SATA_SUCCESS if the device was identified as a supported device,
12632 * SATA_RETRY if the device was not identified but could be retried,
12633 * SATA_FAILURE if the device was not identified and identify attempt
12634 * should not be retried.
12635 */
12636 static int
12637 sata_identify_device(sata_hba_inst_t *sata_hba_inst,
12638 sata_drive_info_t *sdinfo)
12639 {
12640 uint16_t cfg_word;
12641 int rval;
12642
12643 /* fetch device identify data */
12644 if ((rval = sata_fetch_device_identify_data(sata_hba_inst,
12645 sdinfo)) != SATA_SUCCESS)
12646 goto fail_unknown;
12647
12648 cfg_word = sdinfo->satadrv_id.ai_config;
12649
12650 /* Set the correct device type */
12651 if ((cfg_word & SATA_ATA_TYPE_MASK) == SATA_ATA_TYPE) {
12652 sdinfo->satadrv_type = SATA_DTYPE_ATADISK;
12653 } else if (cfg_word == SATA_CFA_TYPE) {
12654 /* It's a Compact Flash media via CF-to-SATA HDD adapter */
12655 sdinfo->satadrv_type = SATA_DTYPE_ATADISK;
12656 } else if ((cfg_word & SATA_ATAPI_TYPE_MASK) == SATA_ATAPI_TYPE) {
12657 switch (cfg_word & SATA_ATAPI_ID_DEV_TYPE) {
12658 case SATA_ATAPI_CDROM_DEV:
12659 sdinfo->satadrv_type = SATA_DTYPE_ATAPICD;
12660 break;
12661 case SATA_ATAPI_SQACC_DEV:
12662 sdinfo->satadrv_type = SATA_DTYPE_ATAPITAPE;
12663 break;
12664 case SATA_ATAPI_DIRACC_DEV:
12665 sdinfo->satadrv_type = SATA_DTYPE_ATAPIDISK;
12666 break;
12667 case SATA_ATAPI_PROC_DEV:
12668 sdinfo->satadrv_type = SATA_DTYPE_ATAPIPROC;
12669 break;
12670 default:
12671 sdinfo->satadrv_type = SATA_DTYPE_UNKNOWN;
12672 }
12673 } else {
12674 sdinfo->satadrv_type = SATA_DTYPE_UNKNOWN;
12675 }
12676
12677 if (sdinfo->satadrv_type == SATA_DTYPE_ATADISK) {
12678 if (sdinfo->satadrv_capacity == 0) {
12679 /* Non-LBA disk. Too bad... */
12680 sata_log(sata_hba_inst, CE_WARN,
12681 "SATA disk device at port %d does not support LBA",
12682 sdinfo->satadrv_addr.cport);
12683 rval = SATA_FAILURE;
12684 goto fail_unknown;
12685 }
12686 }
12687 #if 0
12688 /* Left for historical reason */
12689 /*
12690 * Some initial version of SATA spec indicated that at least
12691 * UDMA mode 4 has to be supported. It is not metioned in
12692 * SerialATA 2.6, so this restriction is removed.
12693 */
12694 /* Check for Ultra DMA modes 6 through 0 being supported */
12695 for (i = 6; i >= 0; --i) {
12696 if (sdinfo->satadrv_id.ai_ultradma & (1 << i))
12697 break;
12698 }
12699
12700 /*
12701 * At least UDMA 4 mode has to be supported. If mode 4 or
12702 * higher are not supported by the device, fail this
12703 * device.
12704 */
12705 if (i < 4) {
12706 /* No required Ultra DMA mode supported */
12707 sata_log(sata_hba_inst, CE_WARN,
12708 "SATA disk device at port %d does not support UDMA "
12709 "mode 4 or higher", sdinfo->satadrv_addr.cport);
12710 SATA_LOG_D((sata_hba_inst, CE_WARN,
12711 "mode 4 or higher required, %d supported", i));
12712 rval = SATA_FAILURE;
12713 goto fail_unknown;
12714 }
12715 #endif
12716
12717 /*
12718 * For Disk devices, if it doesn't support UDMA mode, we would
12719 * like to return failure directly.
12720 */
12721 if ((sdinfo->satadrv_type == SATA_DTYPE_ATADISK) &&
12722 !((sdinfo->satadrv_id.ai_validinfo & SATA_VALIDINFO_88) != 0 &&
12723 (sdinfo->satadrv_id.ai_ultradma & SATA_UDMA_SUP_MASK) != 0)) {
12724 sata_log(sata_hba_inst, CE_WARN,
12725 "SATA disk device at port %d does not support UDMA",
12726 sdinfo->satadrv_addr.cport);
12727 rval = SATA_FAILURE;
12728 goto fail_unknown;
12729 }
12730
12731 return (SATA_SUCCESS);
12732
12733 fail_unknown:
12734 /* Invalidate sata_drive_info ? */
12735 sdinfo->satadrv_type = SATA_DTYPE_UNKNOWN;
12736 sdinfo->satadrv_state = SATA_STATE_UNKNOWN;
12737 return (rval);
12738 }
12739
12740 /*
12741 * Log/display device information
12742 */
12743 static void
12744 sata_show_drive_info(sata_hba_inst_t *sata_hba_inst,
12745 sata_drive_info_t *sdinfo)
12746 {
12747 int valid_version;
12748 char msg_buf[MAXPATHLEN];
12749 int i;
12750
12751 /* Show HBA path */
12752 (void) ddi_pathname(SATA_DIP(sata_hba_inst), msg_buf);
12753
12754 cmn_err(CE_CONT, "?%s :\n", msg_buf);
12755
12756 switch (sdinfo->satadrv_type) {
12757 case SATA_DTYPE_ATADISK:
12758 (void) sprintf(msg_buf, "SATA disk device at");
12759 break;
12760
12761 case SATA_DTYPE_ATAPICD:
12762 (void) sprintf(msg_buf, "SATA CD/DVD (ATAPI) device at");
12763 break;
12764
12765 case SATA_DTYPE_ATAPITAPE:
12766 (void) sprintf(msg_buf, "SATA tape (ATAPI) device at");
12767 break;
12768
12769 case SATA_DTYPE_ATAPIDISK:
12770 (void) sprintf(msg_buf, "SATA disk (ATAPI) device at");
12771 break;
12772
12773 case SATA_DTYPE_ATAPIPROC:
12774 (void) sprintf(msg_buf, "SATA processor (ATAPI) device at");
12775 break;
12776
12777 case SATA_DTYPE_UNKNOWN:
12778 (void) sprintf(msg_buf,
12779 "Unsupported SATA device type (cfg 0x%x) at ",
12780 sdinfo->satadrv_id.ai_config);
12781 break;
12782 }
12783
12784 if (sdinfo->satadrv_addr.qual == SATA_ADDR_DCPORT)
12785 cmn_err(CE_CONT, "?\t%s port %d\n",
12786 msg_buf, sdinfo->satadrv_addr.cport);
12787 else
12788 cmn_err(CE_CONT, "?\t%s port %d:%d\n",
12789 msg_buf, sdinfo->satadrv_addr.cport,
12790 sdinfo->satadrv_addr.pmport);
12791
12792 bcopy(&sdinfo->satadrv_id.ai_model, msg_buf,
12793 sizeof (sdinfo->satadrv_id.ai_model));
12794 swab(msg_buf, msg_buf, sizeof (sdinfo->satadrv_id.ai_model));
12795 msg_buf[sizeof (sdinfo->satadrv_id.ai_model)] = '\0';
12796 cmn_err(CE_CONT, "?\tmodel %s\n", msg_buf);
12797
12798 bcopy(&sdinfo->satadrv_id.ai_fw, msg_buf,
12799 sizeof (sdinfo->satadrv_id.ai_fw));
12800 swab(msg_buf, msg_buf, sizeof (sdinfo->satadrv_id.ai_fw));
12801 msg_buf[sizeof (sdinfo->satadrv_id.ai_fw)] = '\0';
12802 cmn_err(CE_CONT, "?\tfirmware %s\n", msg_buf);
12803
12804 bcopy(&sdinfo->satadrv_id.ai_drvser, msg_buf,
12805 sizeof (sdinfo->satadrv_id.ai_drvser));
12806 swab(msg_buf, msg_buf, sizeof (sdinfo->satadrv_id.ai_drvser));
12807 msg_buf[sizeof (sdinfo->satadrv_id.ai_drvser)] = '\0';
12808 if (sdinfo->satadrv_type == SATA_DTYPE_ATADISK) {
12809 cmn_err(CE_CONT, "?\tserial number %s\n", msg_buf);
12810 } else {
12811 /*
12812 * Some drives do not implement serial number and may
12813 * violate the spec by providing spaces rather than zeros
12814 * in serial number field. Scan the buffer to detect it.
12815 */
12816 for (i = 0; i < sizeof (sdinfo->satadrv_id.ai_drvser); i++) {
12817 if (msg_buf[i] != '\0' && msg_buf[i] != ' ')
12818 break;
12819 }
12820 if (i == sizeof (sdinfo->satadrv_id.ai_drvser)) {
12821 cmn_err(CE_CONT, "?\tserial number - none\n");
12822 } else {
12823 cmn_err(CE_CONT, "?\tserial number %s\n", msg_buf);
12824 }
12825 }
12826
12827 #ifdef SATA_DEBUG
12828 if (sdinfo->satadrv_id.ai_majorversion != 0 &&
12829 sdinfo->satadrv_id.ai_majorversion != 0xffff) {
12830 int i;
12831 for (i = 14; i >= 2; i--) {
12832 if (sdinfo->satadrv_id.ai_majorversion & (1 << i)) {
12833 valid_version = i;
12834 break;
12835 }
12836 }
12837 cmn_err(CE_CONT,
12838 "?\tATA/ATAPI-%d supported, majver 0x%x minver 0x%x\n",
12839 valid_version,
12840 sdinfo->satadrv_id.ai_majorversion,
12841 sdinfo->satadrv_id.ai_minorversion);
12842 }
12843 #endif
12844 /* Log some info */
12845 cmn_err(CE_CONT, "?\tsupported features:\n");
12846 msg_buf[0] = '\0';
12847 if (sdinfo->satadrv_type == SATA_DTYPE_ATADISK) {
12848 if (sdinfo->satadrv_features_support & SATA_DEV_F_LBA48)
12849 (void) strlcat(msg_buf, "48-bit LBA, ", MAXPATHLEN);
12850 else if (sdinfo->satadrv_features_support & SATA_DEV_F_LBA28)
12851 (void) strlcat(msg_buf, "28-bit LBA, ", MAXPATHLEN);
12852 }
12853 if (sdinfo->satadrv_features_support & SATA_DEV_F_DMA)
12854 (void) strlcat(msg_buf, "DMA", MAXPATHLEN);
12855 if (sdinfo->satadrv_features_support & SATA_DEV_F_NCQ)
12856 (void) strlcat(msg_buf, ", Native Command Queueing",
12857 MAXPATHLEN);
12858 if (sdinfo->satadrv_features_support & SATA_DEV_F_TCQ)
12859 (void) strlcat(msg_buf, ", Legacy Tagged Queuing", MAXPATHLEN);
12860 if ((sdinfo->satadrv_id.ai_cmdset82 & SATA_SMART_SUPPORTED) &&
12861 (sdinfo->satadrv_id.ai_features85 & SATA_SMART_ENABLED))
12862 (void) strlcat(msg_buf, ", SMART", MAXPATHLEN);
12863 if ((sdinfo->satadrv_id.ai_cmdset84 & SATA_SMART_SELF_TEST_SUPPORTED) &&
12864 (sdinfo->satadrv_id.ai_features87 & SATA_SMART_SELF_TEST_SUPPORTED))
12865 (void) strlcat(msg_buf, ", SMART self-test", MAXPATHLEN);
12866 cmn_err(CE_CONT, "?\t %s\n", msg_buf);
12867 if (sdinfo->satadrv_features_support & SATA_DEV_F_SATA3)
12868 cmn_err(CE_CONT, "?\tSATA Gen3 signaling speed (6.0Gbps)\n");
12869 else if (sdinfo->satadrv_features_support & SATA_DEV_F_SATA2)
12870 cmn_err(CE_CONT, "?\tSATA Gen2 signaling speed (3.0Gbps)\n");
12871 else if (sdinfo->satadrv_features_support & SATA_DEV_F_SATA1)
12872 cmn_err(CE_CONT, "?\tSATA Gen1 signaling speed (1.5Gbps)\n");
12873 if (sdinfo->satadrv_features_support &
12874 (SATA_DEV_F_TCQ | SATA_DEV_F_NCQ)) {
12875 msg_buf[0] = '\0';
12876 (void) snprintf(msg_buf, MAXPATHLEN,
12877 "Supported queue depth %d",
12878 sdinfo->satadrv_queue_depth);
12879 if (!(sata_func_enable &
12880 (SATA_ENABLE_QUEUING | SATA_ENABLE_NCQ)))
12881 (void) strlcat(msg_buf,
12882 " - queueing disabled globally", MAXPATHLEN);
12883 else if (sdinfo->satadrv_queue_depth >
12884 sdinfo->satadrv_max_queue_depth) {
12885 (void) snprintf(&msg_buf[strlen(msg_buf)],
12886 MAXPATHLEN - strlen(msg_buf), ", limited to %d",
12887 (int)sdinfo->satadrv_max_queue_depth);
12888 }
12889 cmn_err(CE_CONT, "?\t%s\n", msg_buf);
12890 }
12891
12892 if (sdinfo->satadrv_type == SATA_DTYPE_ATADISK) {
12893 #ifdef __i386
12894 (void) sprintf(msg_buf, "\tcapacity = %llu sectors\n",
12895 sdinfo->satadrv_capacity);
12896 #else
12897 (void) sprintf(msg_buf, "\tcapacity = %lu sectors\n",
12898 sdinfo->satadrv_capacity);
12899 #endif
12900 cmn_err(CE_CONT, "?%s", msg_buf);
12901 }
12902 }
12903
12904 /*
12905 * Log/display port multiplier information
12906 * No Mutex should be hold.
12907 */
12908 static void
12909 sata_show_pmult_info(sata_hba_inst_t *sata_hba_inst,
12910 sata_device_t *sata_device)
12911 {
12912 _NOTE(ARGUNUSED(sata_hba_inst))
12913
12914 int cport = sata_device->satadev_addr.cport;
12915 sata_pmult_info_t *pmultinfo;
12916 char msg_buf[MAXPATHLEN];
12917 uint32_t gscr0, gscr1, gscr2, gscr64;
12918
12919 mutex_enter(&SATA_CPORT_MUTEX(sata_hba_inst, cport));
12920 pmultinfo = SATA_PMULT_INFO(sata_hba_inst, cport);
12921 if (pmultinfo == NULL) {
12922 mutex_exit(&SATA_CPORT_MUTEX(sata_hba_inst, cport));
12923 return;
12924 }
12925
12926 gscr0 = pmultinfo->pmult_gscr.gscr0;
12927 gscr1 = pmultinfo->pmult_gscr.gscr1;
12928 gscr2 = pmultinfo->pmult_gscr.gscr2;
12929 gscr64 = pmultinfo->pmult_gscr.gscr64;
12930 mutex_exit(&SATA_CPORT_MUTEX(sata_hba_inst, cport));
12931
12932 cmn_err(CE_CONT, "?Port Multiplier %d device-ports found at port %d",
12933 sata_device->satadev_add_info, sata_device->satadev_addr.cport);
12934
12935 (void) sprintf(msg_buf, "\tVendor_ID 0x%04x, Module_ID 0x%04x",
12936 gscr0 & 0xffff, (gscr0 >> 16) & 0xffff);
12937 cmn_err(CE_CONT, "?%s", msg_buf);
12938
12939 (void) strcpy(msg_buf, "\tSupport SATA PMP Spec ");
12940 if (gscr1 & (1 << 3))
12941 (void) strlcat(msg_buf, "1.2", MAXPATHLEN);
12942 else if (gscr1 & (1 << 2))
12943 (void) strlcat(msg_buf, "1.1", MAXPATHLEN);
12944 else if (gscr1 & (1 << 1))
12945 (void) strlcat(msg_buf, "1.0", MAXPATHLEN);
12946 else
12947 (void) strlcat(msg_buf, "unknown", MAXPATHLEN);
12948 cmn_err(CE_CONT, "?%s", msg_buf);
12949
12950 (void) strcpy(msg_buf, "\tSupport ");
12951 if (gscr64 & (1 << 3))
12952 (void) strlcat(msg_buf, "Asy-Notif, ",
12953 MAXPATHLEN);
12954 if (gscr64 & (1 << 2))
12955 (void) strlcat(msg_buf, "Dyn-SSC, ", MAXPATHLEN);
12956 if (gscr64 & (1 << 1))
12957 (void) strlcat(msg_buf, "Iss-PMREQ, ", MAXPATHLEN);
12958 if (gscr64 & (1 << 0))
12959 (void) strlcat(msg_buf, "BIST", MAXPATHLEN);
12960 if ((gscr64 & 0xf) == 0)
12961 (void) strlcat(msg_buf, "nothing", MAXPATHLEN);
12962 cmn_err(CE_CONT, "?%s", msg_buf);
12963
12964 (void) sprintf(msg_buf, "\tNumber of exposed device fan-out ports: %d",
12965 gscr2 & SATA_PMULT_PORTNUM_MASK);
12966 cmn_err(CE_CONT, "?%s", msg_buf);
12967 }
12968
12969 /*
12970 * sata_save_drive_settings extracts current setting of the device and stores
12971 * it for future reference, in case the device setup would need to be restored
12972 * after the device reset.
12973 *
12974 * For all devices read ahead and write cache settings are saved, if the
12975 * device supports these features at all.
12976 * For ATAPI devices the Removable Media Status Notification setting is saved.
12977 */
12978 static void
12979 sata_save_drive_settings(sata_drive_info_t *sdinfo)
12980 {
12981 if (SATA_READ_AHEAD_SUPPORTED(sdinfo->satadrv_id) ||
12982 SATA_WRITE_CACHE_SUPPORTED(sdinfo->satadrv_id)) {
12983
12984 /* Current setting of Read Ahead (and Read Cache) */
12985 if (SATA_READ_AHEAD_ENABLED(sdinfo->satadrv_id))
12986 sdinfo->satadrv_settings |= SATA_DEV_READ_AHEAD;
12987 else
12988 sdinfo->satadrv_settings &= ~SATA_DEV_READ_AHEAD;
12989
12990 /* Current setting of Write Cache */
12991 if (SATA_WRITE_CACHE_ENABLED(sdinfo->satadrv_id))
12992 sdinfo->satadrv_settings |= SATA_DEV_WRITE_CACHE;
12993 else
12994 sdinfo->satadrv_settings &= ~SATA_DEV_WRITE_CACHE;
12995 }
12996
12997 if (sdinfo->satadrv_type == SATA_DTYPE_ATAPICD) {
12998 if (SATA_RM_NOTIFIC_SUPPORTED(sdinfo->satadrv_id))
12999 sdinfo->satadrv_settings |= SATA_DEV_RMSN;
13000 else
13001 sdinfo->satadrv_settings &= ~SATA_DEV_RMSN;
13002 }
13003 }
13004
13005
13006 /*
13007 * sata_check_capacity function determines a disk capacity
13008 * and addressing mode (LBA28/LBA48) by examining a disk identify device data.
13009 *
13010 * NOTE: CHS mode is not supported! If a device does not support LBA,
13011 * this function is not called.
13012 *
13013 * Returns device capacity in number of blocks, i.e. largest addressable LBA+1
13014 */
13015 static uint64_t
13016 sata_check_capacity(sata_drive_info_t *sdinfo)
13017 {
13018 uint64_t capacity = 0;
13019 int i;
13020
13021 if (sdinfo->satadrv_type != SATA_DTYPE_ATADISK ||
13022 !sdinfo->satadrv_id.ai_cap & SATA_LBA_SUPPORT)
13023 /* Capacity valid only for LBA-addressable disk devices */
13024 return (0);
13025
13026 if ((sdinfo->satadrv_id.ai_validinfo & SATA_VALIDINFO_88) &&
13027 (sdinfo->satadrv_id.ai_cmdset83 & SATA_EXT48) &&
13028 (sdinfo->satadrv_id.ai_features86 & SATA_EXT48)) {
13029 /* LBA48 mode supported and enabled */
13030 sdinfo->satadrv_features_support |= SATA_DEV_F_LBA48 |
13031 SATA_DEV_F_LBA28;
13032 for (i = 3; i >= 0; --i) {
13033 capacity <<= 16;
13034 capacity += sdinfo->satadrv_id.ai_addrsecxt[i];
13035 }
13036 } else {
13037 capacity = sdinfo->satadrv_id.ai_addrsec[1];
13038 capacity <<= 16;
13039 capacity += sdinfo->satadrv_id.ai_addrsec[0];
13040 if (capacity >= 0x1000000)
13041 /* LBA28 mode */
13042 sdinfo->satadrv_features_support |= SATA_DEV_F_LBA28;
13043 }
13044 return (capacity);
13045 }
13046
13047
13048 /*
13049 * Allocate consistent buffer for DMA transfer
13050 *
13051 * Cannot be called from interrupt level or with mutex held - it may sleep.
13052 *
13053 * Returns pointer to allocated buffer structure, or NULL if allocation failed.
13054 */
13055 static struct buf *
13056 sata_alloc_local_buffer(sata_pkt_txlate_t *spx, int len)
13057 {
13058 struct scsi_address ap;
13059 struct buf *bp;
13060 ddi_dma_attr_t cur_dma_attr;
13061
13062 ASSERT(spx->txlt_sata_pkt != NULL);
13063 ap.a_hba_tran = spx->txlt_sata_hba_inst->satahba_scsi_tran;
13064 ap.a_target = SATA_TO_SCSI_TARGET(
13065 spx->txlt_sata_pkt->satapkt_device.satadev_addr.cport,
13066 spx->txlt_sata_pkt->satapkt_device.satadev_addr.pmport,
13067 spx->txlt_sata_pkt->satapkt_device.satadev_addr.qual);
13068 ap.a_lun = 0;
13069
13070 bp = scsi_alloc_consistent_buf(&ap, NULL, len,
13071 B_READ, SLEEP_FUNC, NULL);
13072
13073 if (bp != NULL) {
13074 /* Allocate DMA resources for this buffer */
13075 spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp = bp;
13076 /*
13077 * We use a local version of the dma_attr, to account
13078 * for a device addressing limitations.
13079 * sata_adjust_dma_attr() will handle sdinfo == NULL which
13080 * will cause dma attributes to be adjusted to a lowest
13081 * acceptable level.
13082 */
13083 sata_adjust_dma_attr(NULL,
13084 SATA_DMA_ATTR(spx->txlt_sata_hba_inst), &cur_dma_attr);
13085
13086 if (sata_dma_buf_setup(spx, PKT_CONSISTENT,
13087 SLEEP_FUNC, NULL, &cur_dma_attr) != DDI_SUCCESS) {
13088 scsi_free_consistent_buf(bp);
13089 spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp = NULL;
13090 bp = NULL;
13091 }
13092 }
13093 return (bp);
13094 }
13095
13096 /*
13097 * Release local buffer (consistent buffer for DMA transfer) allocated
13098 * via sata_alloc_local_buffer().
13099 */
13100 static void
13101 sata_free_local_buffer(sata_pkt_txlate_t *spx)
13102 {
13103 ASSERT(spx->txlt_sata_pkt != NULL);
13104 ASSERT(spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp != NULL);
13105
13106 spx->txlt_sata_pkt->satapkt_cmd.satacmd_num_dma_cookies = 0;
13107 spx->txlt_sata_pkt->satapkt_cmd.satacmd_dma_cookie_list = NULL;
13108
13109 sata_common_free_dma_rsrcs(spx);
13110
13111 /* Free buffer */
13112 scsi_free_consistent_buf(spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp);
13113 spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp = NULL;
13114 }
13115
13116 /*
13117 * Allocate sata_pkt
13118 * Pkt structure version and embedded strcutures version are initialized.
13119 * sata_pkt and sata_pkt_txlate structures are cross-linked.
13120 *
13121 * Since this may be called in interrupt context by sata_scsi_init_pkt,
13122 * callback argument determines if it can sleep or not.
13123 * Hence, it should not be called from interrupt context.
13124 *
13125 * If successful, non-NULL pointer to a sata pkt is returned.
13126 * Upon failure, NULL pointer is returned.
13127 */
13128 static sata_pkt_t *
13129 sata_pkt_alloc(sata_pkt_txlate_t *spx, int (*callback)(caddr_t))
13130 {
13131 sata_pkt_t *spkt;
13132 int kmsflag;
13133
13134 kmsflag = (callback == SLEEP_FUNC) ? KM_SLEEP : KM_NOSLEEP;
13135 spkt = kmem_zalloc(sizeof (sata_pkt_t), kmsflag);
13136 if (spkt == NULL) {
13137 SATA_LOG_D((spx->txlt_sata_hba_inst, CE_WARN,
13138 "sata_pkt_alloc: failed"));
13139 return (NULL);
13140 }
13141 spkt->satapkt_rev = SATA_PKT_REV;
13142 spkt->satapkt_cmd.satacmd_rev = SATA_CMD_REV;
13143 spkt->satapkt_device.satadev_rev = SATA_DEVICE_REV;
13144 spkt->satapkt_framework_private = spx;
13145 spx->txlt_sata_pkt = spkt;
13146 return (spkt);
13147 }
13148
13149 /*
13150 * Free sata pkt allocated via sata_pkt_alloc()
13151 */
13152 static void
13153 sata_pkt_free(sata_pkt_txlate_t *spx)
13154 {
13155 ASSERT(spx->txlt_sata_pkt != NULL);
13156 ASSERT(spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp == NULL);
13157 kmem_free(spx->txlt_sata_pkt, sizeof (sata_pkt_t));
13158 spx->txlt_sata_pkt = NULL;
13159 }
13160
13161
13162 /*
13163 * Adjust DMA attributes.
13164 * SCSI cmds block count is up to 24 bits, SATA cmd block count vary
13165 * from 8 bits to 16 bits, depending on a command being used.
13166 * Limiting max block count arbitrarily to 256 for all read/write
13167 * commands may affects performance, so check both the device and
13168 * controller capability before adjusting dma attributes.
13169 */
13170 void
13171 sata_adjust_dma_attr(sata_drive_info_t *sdinfo, ddi_dma_attr_t *dma_attr,
13172 ddi_dma_attr_t *adj_dma_attr)
13173 {
13174 uint32_t count_max;
13175
13176 /* Copy original attributes */
13177 *adj_dma_attr = *dma_attr;
13178 /*
13179 * Things to consider: device addressing capability,
13180 * "excessive" controller DMA capabilities.
13181 * If a device is being probed/initialized, there are
13182 * no device info - use default limits then.
13183 */
13184 if (sdinfo == NULL) {
13185 count_max = dma_attr->dma_attr_granular * 0x100;
13186 if (dma_attr->dma_attr_count_max > count_max)
13187 adj_dma_attr->dma_attr_count_max = count_max;
13188 if (dma_attr->dma_attr_maxxfer > count_max)
13189 adj_dma_attr->dma_attr_maxxfer = count_max;
13190 return;
13191 }
13192
13193 if (sdinfo->satadrv_type == SATA_DTYPE_ATADISK) {
13194 if (sdinfo->satadrv_features_support & (SATA_DEV_F_LBA48)) {
13195 /*
13196 * 16-bit sector count may be used - we rely on
13197 * the assumption that only read and write cmds
13198 * will request more than 256 sectors worth of data
13199 */
13200 count_max = adj_dma_attr->dma_attr_granular * 0x10000;
13201 } else {
13202 /*
13203 * 8-bit sector count will be used - default limits
13204 * for dma attributes
13205 */
13206 count_max = adj_dma_attr->dma_attr_granular * 0x100;
13207 }
13208 /*
13209 * Adjust controler dma attributes, if necessary
13210 */
13211 if (dma_attr->dma_attr_count_max > count_max)
13212 adj_dma_attr->dma_attr_count_max = count_max;
13213 if (dma_attr->dma_attr_maxxfer > count_max)
13214 adj_dma_attr->dma_attr_maxxfer = count_max;
13215 }
13216 }
13217
13218
13219 /*
13220 * Allocate DMA resources for the buffer
13221 * This function handles initial DMA resource allocation as well as
13222 * DMA window shift and may be called repeatedly for the same DMA window
13223 * until all DMA cookies in the DMA window are processed.
13224 * To guarantee that there is always a coherent set of cookies to process
13225 * by SATA HBA driver (observing alignment, device granularity, etc.),
13226 * the number of slots for DMA cookies is equal to lesser of a number of
13227 * cookies in a DMA window and a max number of scatter/gather entries.
13228 *
13229 * Returns DDI_SUCCESS upon successful operation.
13230 * Return failure code of a failing command or DDI_FAILURE when
13231 * internal cleanup failed.
13232 */
13233 static int
13234 sata_dma_buf_setup(sata_pkt_txlate_t *spx, int flags,
13235 int (*callback)(caddr_t), caddr_t arg,
13236 ddi_dma_attr_t *cur_dma_attr)
13237 {
13238 int rval;
13239 off_t offset;
13240 size_t size;
13241 int max_sg_len, req_len, i;
13242 uint_t dma_flags;
13243 struct buf *bp;
13244 uint64_t cur_txfer_len;
13245
13246
13247 ASSERT(spx->txlt_sata_pkt != NULL);
13248 bp = spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp;
13249 ASSERT(bp != NULL);
13250
13251
13252 if (spx->txlt_buf_dma_handle == NULL) {
13253 /*
13254 * No DMA resources allocated so far - this is a first call
13255 * for this sata pkt.
13256 */
13257 rval = ddi_dma_alloc_handle(SATA_DIP(spx->txlt_sata_hba_inst),
13258 cur_dma_attr, callback, arg, &spx->txlt_buf_dma_handle);
13259
13260 if (rval != DDI_SUCCESS) {
13261 SATA_LOG_D((spx->txlt_sata_hba_inst, CE_WARN,
13262 "sata_dma_buf_setup: no buf DMA resources %x",
13263 rval));
13264 return (rval);
13265 }
13266
13267 if (bp->b_flags & B_READ)
13268 dma_flags = DDI_DMA_READ;
13269 else
13270 dma_flags = DDI_DMA_WRITE;
13271
13272 if (flags & PKT_CONSISTENT)
13273 dma_flags |= DDI_DMA_CONSISTENT;
13274
13275 if (flags & PKT_DMA_PARTIAL)
13276 dma_flags |= DDI_DMA_PARTIAL;
13277
13278 /*
13279 * Check buffer alignment and size against dma attributes
13280 * Consider dma_attr_align only. There may be requests
13281 * with the size lower than device granularity, but they
13282 * will not read/write from/to the device, so no adjustment
13283 * is necessary. The dma_attr_minxfer theoretically should
13284 * be considered, but no HBA driver is checking it.
13285 */
13286 if (IS_P2ALIGNED(bp->b_un.b_addr,
13287 cur_dma_attr->dma_attr_align)) {
13288 rval = ddi_dma_buf_bind_handle(
13289 spx->txlt_buf_dma_handle,
13290 bp, dma_flags, callback, arg,
13291 &spx->txlt_dma_cookie,
13292 &spx->txlt_curwin_num_dma_cookies);
13293 } else { /* Buffer is not aligned */
13294
13295 int (*ddicallback)(caddr_t);
13296 size_t bufsz;
13297
13298 /* Check id sleeping is allowed */
13299 ddicallback = (callback == NULL_FUNC) ?
13300 DDI_DMA_DONTWAIT : DDI_DMA_SLEEP;
13301
13302 SATADBG2(SATA_DBG_DMA_SETUP, spx->txlt_sata_hba_inst,
13303 "mis-aligned buffer: addr=0x%p, cnt=%lu",
13304 (void *)bp->b_un.b_addr, bp->b_bcount);
13305
13306 if (bp->b_flags & (B_PAGEIO|B_PHYS))
13307 /*
13308 * CPU will need to access data in the buffer
13309 * (for copying) so map it.
13310 */
13311 bp_mapin(bp);
13312
13313 ASSERT(spx->txlt_tmp_buf == NULL);
13314
13315 /* Buffer may be padded by ddi_dma_mem_alloc()! */
13316 rval = ddi_dma_mem_alloc(
13317 spx->txlt_buf_dma_handle,
13318 bp->b_bcount,
13319 &sata_acc_attr,
13320 DDI_DMA_STREAMING,
13321 ddicallback, NULL,
13322 &spx->txlt_tmp_buf,
13323 &bufsz,
13324 &spx->txlt_tmp_buf_handle);
13325
13326 if (rval != DDI_SUCCESS) {
13327 /* DMA mapping failed */
13328 (void) ddi_dma_free_handle(
13329 &spx->txlt_buf_dma_handle);
13330 spx->txlt_buf_dma_handle = NULL;
13331 #ifdef SATA_DEBUG
13332 mbuffail_count++;
13333 #endif
13334 SATADBG1(SATA_DBG_DMA_SETUP,
13335 spx->txlt_sata_hba_inst,
13336 "sata_dma_buf_setup: "
13337 "buf dma mem alloc failed %x\n", rval);
13338 return (rval);
13339 }
13340 ASSERT(IS_P2ALIGNED(spx->txlt_tmp_buf,
13341 cur_dma_attr->dma_attr_align));
13342
13343 #ifdef SATA_DEBUG
13344 mbuf_count++;
13345
13346 if (bp->b_bcount != bufsz)
13347 /*
13348 * This will require special handling, because
13349 * DMA cookies will be based on the temporary
13350 * buffer size, not the original buffer
13351 * b_bcount, so the residue may have to
13352 * be counted differently.
13353 */
13354 SATADBG2(SATA_DBG_DMA_SETUP,
13355 spx->txlt_sata_hba_inst,
13356 "sata_dma_buf_setup: bp size %x != "
13357 "bufsz %x\n", bp->b_bcount, bufsz);
13358 #endif
13359 if (dma_flags & DDI_DMA_WRITE) {
13360 /*
13361 * Write operation - copy data into
13362 * an aligned temporary buffer. Buffer will be
13363 * synced for device by ddi_dma_addr_bind_handle
13364 */
13365 bcopy(bp->b_un.b_addr, spx->txlt_tmp_buf,
13366 bp->b_bcount);
13367 }
13368
13369 rval = ddi_dma_addr_bind_handle(
13370 spx->txlt_buf_dma_handle,
13371 NULL,
13372 spx->txlt_tmp_buf,
13373 bufsz, dma_flags, ddicallback, 0,
13374 &spx->txlt_dma_cookie,
13375 &spx->txlt_curwin_num_dma_cookies);
13376 }
13377
13378 switch (rval) {
13379 case DDI_DMA_PARTIAL_MAP:
13380 SATADBG1(SATA_DBG_DMA_SETUP, spx->txlt_sata_hba_inst,
13381 "sata_dma_buf_setup: DMA Partial Map\n", NULL);
13382 /*
13383 * Partial DMA mapping.
13384 * Retrieve number of DMA windows for this request.
13385 */
13386 if (ddi_dma_numwin(spx->txlt_buf_dma_handle,
13387 &spx->txlt_num_dma_win) != DDI_SUCCESS) {
13388 if (spx->txlt_tmp_buf != NULL) {
13389 ddi_dma_mem_free(
13390 &spx->txlt_tmp_buf_handle);
13391 spx->txlt_tmp_buf = NULL;
13392 }
13393 (void) ddi_dma_unbind_handle(
13394 spx->txlt_buf_dma_handle);
13395 (void) ddi_dma_free_handle(
13396 &spx->txlt_buf_dma_handle);
13397 spx->txlt_buf_dma_handle = NULL;
13398 SATA_LOG_D((spx->txlt_sata_hba_inst, CE_WARN,
13399 "sata_dma_buf_setup: numwin failed\n"));
13400 return (DDI_FAILURE);
13401 }
13402 SATADBG2(SATA_DBG_DMA_SETUP,
13403 spx->txlt_sata_hba_inst,
13404 "sata_dma_buf_setup: windows: %d, cookies: %d\n",
13405 spx->txlt_num_dma_win,
13406 spx->txlt_curwin_num_dma_cookies);
13407 spx->txlt_cur_dma_win = 0;
13408 break;
13409
13410 case DDI_DMA_MAPPED:
13411 /* DMA fully mapped */
13412 spx->txlt_num_dma_win = 1;
13413 spx->txlt_cur_dma_win = 0;
13414 SATADBG1(SATA_DBG_DMA_SETUP,
13415 spx->txlt_sata_hba_inst,
13416 "sata_dma_buf_setup: windows: 1 "
13417 "cookies: %d\n", spx->txlt_curwin_num_dma_cookies);
13418 break;
13419
13420 default:
13421 /* DMA mapping failed */
13422 if (spx->txlt_tmp_buf != NULL) {
13423 ddi_dma_mem_free(
13424 &spx->txlt_tmp_buf_handle);
13425 spx->txlt_tmp_buf = NULL;
13426 }
13427 (void) ddi_dma_free_handle(&spx->txlt_buf_dma_handle);
13428 spx->txlt_buf_dma_handle = NULL;
13429 SATA_LOG_D((spx->txlt_sata_hba_inst, CE_WARN,
13430 "sata_dma_buf_setup: buf dma handle binding "
13431 "failed %x\n", rval));
13432 return (rval);
13433 }
13434 spx->txlt_curwin_processed_dma_cookies = 0;
13435 spx->txlt_dma_cookie_list = NULL;
13436 } else {
13437 /*
13438 * DMA setup is reused. Check if we need to process more
13439 * cookies in current window, or to get next window, if any.
13440 */
13441
13442 ASSERT(spx->txlt_curwin_processed_dma_cookies <=
13443 spx->txlt_curwin_num_dma_cookies);
13444
13445 if (spx->txlt_curwin_processed_dma_cookies ==
13446 spx->txlt_curwin_num_dma_cookies) {
13447 /*
13448 * All cookies from current DMA window were processed.
13449 * Get next DMA window.
13450 */
13451 spx->txlt_cur_dma_win++;
13452 if (spx->txlt_cur_dma_win < spx->txlt_num_dma_win) {
13453 (void) ddi_dma_getwin(spx->txlt_buf_dma_handle,
13454 spx->txlt_cur_dma_win, &offset, &size,
13455 &spx->txlt_dma_cookie,
13456 &spx->txlt_curwin_num_dma_cookies);
13457 spx->txlt_curwin_processed_dma_cookies = 0;
13458 } else {
13459 /* No more windows! End of request! */
13460 /* What to do? - panic for now */
13461 ASSERT(spx->txlt_cur_dma_win >=
13462 spx->txlt_num_dma_win);
13463
13464 spx->txlt_curwin_num_dma_cookies = 0;
13465 spx->txlt_curwin_processed_dma_cookies = 0;
13466 spx->txlt_sata_pkt->
13467 satapkt_cmd.satacmd_num_dma_cookies = 0;
13468 return (DDI_SUCCESS);
13469 }
13470 }
13471 }
13472 /* There better be at least one DMA cookie outstanding */
13473 ASSERT((spx->txlt_curwin_num_dma_cookies -
13474 spx->txlt_curwin_processed_dma_cookies) > 0);
13475
13476 if (spx->txlt_dma_cookie_list == &spx->txlt_dma_cookie) {
13477 /* The default cookie slot was used in previous run */
13478 ASSERT(spx->txlt_curwin_processed_dma_cookies == 0);
13479 spx->txlt_dma_cookie_list = NULL;
13480 spx->txlt_dma_cookie_list_len = 0;
13481 }
13482 if (spx->txlt_curwin_processed_dma_cookies == 0) {
13483 /*
13484 * Processing a new DMA window - set-up dma cookies list.
13485 * We may reuse previously allocated cookie array if it is
13486 * possible.
13487 */
13488 if (spx->txlt_dma_cookie_list != NULL &&
13489 spx->txlt_dma_cookie_list_len <
13490 spx->txlt_curwin_num_dma_cookies) {
13491 /*
13492 * New DMA window contains more cookies than
13493 * the previous one. We need larger cookie list - free
13494 * the old one.
13495 */
13496 (void) kmem_free(spx->txlt_dma_cookie_list,
13497 spx->txlt_dma_cookie_list_len *
13498 sizeof (ddi_dma_cookie_t));
13499 spx->txlt_dma_cookie_list = NULL;
13500 spx->txlt_dma_cookie_list_len = 0;
13501 }
13502 if (spx->txlt_dma_cookie_list == NULL) {
13503 /*
13504 * Calculate lesser of number of cookies in this
13505 * DMA window and number of s/g entries.
13506 */
13507 max_sg_len = cur_dma_attr->dma_attr_sgllen;
13508 req_len = MIN(max_sg_len,
13509 spx->txlt_curwin_num_dma_cookies);
13510
13511 /* Allocate new dma cookie array if necessary */
13512 if (req_len == 1) {
13513 /* Only one cookie - no need for a list */
13514 spx->txlt_dma_cookie_list =
13515 &spx->txlt_dma_cookie;
13516 spx->txlt_dma_cookie_list_len = 1;
13517 } else {
13518 /*
13519 * More than one cookie - try to allocate space.
13520 */
13521 spx->txlt_dma_cookie_list = kmem_zalloc(
13522 sizeof (ddi_dma_cookie_t) * req_len,
13523 callback == NULL_FUNC ? KM_NOSLEEP :
13524 KM_SLEEP);
13525 if (spx->txlt_dma_cookie_list == NULL) {
13526 SATADBG1(SATA_DBG_DMA_SETUP,
13527 spx->txlt_sata_hba_inst,
13528 "sata_dma_buf_setup: cookie list "
13529 "allocation failed\n", NULL);
13530 /*
13531 * We could not allocate space for
13532 * neccessary number of dma cookies in
13533 * this window, so we fail this request.
13534 * Next invocation would try again to
13535 * allocate space for cookie list.
13536 * Note:Packet residue was not modified.
13537 */
13538 return (DDI_DMA_NORESOURCES);
13539 } else {
13540 spx->txlt_dma_cookie_list_len = req_len;
13541 }
13542 }
13543 }
13544 /*
13545 * Fetch DMA cookies into cookie list in sata_pkt_txlate.
13546 * First cookie was already fetched.
13547 */
13548 *(&spx->txlt_dma_cookie_list[0]) = spx->txlt_dma_cookie;
13549 cur_txfer_len =
13550 (uint64_t)spx->txlt_dma_cookie_list[0].dmac_size;
13551 spx->txlt_sata_pkt->satapkt_cmd.satacmd_num_dma_cookies = 1;
13552 spx->txlt_curwin_processed_dma_cookies++;
13553 for (i = 1; (i < spx->txlt_dma_cookie_list_len) &&
13554 (i < spx->txlt_curwin_num_dma_cookies); i++) {
13555 ddi_dma_nextcookie(spx->txlt_buf_dma_handle,
13556 &spx->txlt_dma_cookie_list[i]);
13557 cur_txfer_len +=
13558 (uint64_t)spx->txlt_dma_cookie_list[i].dmac_size;
13559 spx->txlt_curwin_processed_dma_cookies++;
13560 spx->txlt_sata_pkt->
13561 satapkt_cmd.satacmd_num_dma_cookies += 1;
13562 }
13563 } else {
13564 SATADBG2(SATA_DBG_DMA_SETUP, spx->txlt_sata_hba_inst,
13565 "sata_dma_buf_setup: sliding within DMA window, "
13566 "cur cookie %d, total cookies %d\n",
13567 spx->txlt_curwin_processed_dma_cookies,
13568 spx->txlt_curwin_num_dma_cookies);
13569
13570 /*
13571 * Not all cookies from the current dma window were used because
13572 * of s/g limitation.
13573 * There is no need to re-size the list - it was set at
13574 * optimal size, or only default entry is used (s/g = 1).
13575 */
13576 if (spx->txlt_dma_cookie_list == NULL) {
13577 spx->txlt_dma_cookie_list = &spx->txlt_dma_cookie;
13578 spx->txlt_dma_cookie_list_len = 1;
13579 }
13580 /*
13581 * Since we are processing remaining cookies in a DMA window,
13582 * there may be less of them than the number of entries in the
13583 * current dma cookie list.
13584 */
13585 req_len = MIN(spx->txlt_dma_cookie_list_len,
13586 (spx->txlt_curwin_num_dma_cookies -
13587 spx->txlt_curwin_processed_dma_cookies));
13588
13589 /* Fetch the next batch of cookies */
13590 for (i = 0, cur_txfer_len = 0; i < req_len; i++) {
13591 ddi_dma_nextcookie(spx->txlt_buf_dma_handle,
13592 &spx->txlt_dma_cookie_list[i]);
13593 cur_txfer_len +=
13594 (uint64_t)spx->txlt_dma_cookie_list[i].dmac_size;
13595 spx->txlt_sata_pkt->
13596 satapkt_cmd.satacmd_num_dma_cookies++;
13597 spx->txlt_curwin_processed_dma_cookies++;
13598 }
13599 }
13600
13601 ASSERT(spx->txlt_sata_pkt->satapkt_cmd.satacmd_num_dma_cookies > 0);
13602
13603 /* Point sata_cmd to the cookie list */
13604 spx->txlt_sata_pkt->satapkt_cmd.satacmd_dma_cookie_list =
13605 &spx->txlt_dma_cookie_list[0];
13606
13607 /* Remember number of DMA cookies passed in sata packet */
13608 spx->txlt_num_dma_cookies =
13609 spx->txlt_sata_pkt->satapkt_cmd.satacmd_num_dma_cookies;
13610
13611 ASSERT(cur_txfer_len != 0);
13612 if (cur_txfer_len <= bp->b_bcount)
13613 spx->txlt_total_residue -= cur_txfer_len;
13614 else {
13615 /*
13616 * Temporary DMA buffer has been padded by
13617 * ddi_dma_mem_alloc()!
13618 * This requires special handling, because DMA cookies are
13619 * based on the temporary buffer size, not the b_bcount,
13620 * and we have extra bytes to transfer - but the packet
13621 * residue has to stay correct because we will copy only
13622 * the requested number of bytes.
13623 */
13624 spx->txlt_total_residue -= bp->b_bcount;
13625 }
13626
13627 return (DDI_SUCCESS);
13628 }
13629
13630 /*
13631 * Common routine for releasing DMA resources
13632 */
13633 static void
13634 sata_common_free_dma_rsrcs(sata_pkt_txlate_t *spx)
13635 {
13636 if (spx->txlt_buf_dma_handle != NULL) {
13637 if (spx->txlt_tmp_buf != NULL) {
13638 /*
13639 * Intermediate DMA buffer was allocated.
13640 * Free allocated buffer and associated access handle.
13641 */
13642 ddi_dma_mem_free(&spx->txlt_tmp_buf_handle);
13643 spx->txlt_tmp_buf = NULL;
13644 }
13645 /*
13646 * Free DMA resources - cookies and handles
13647 */
13648 /* ASSERT(spx->txlt_dma_cookie_list != NULL); */
13649 if (spx->txlt_dma_cookie_list != NULL) {
13650 if (spx->txlt_dma_cookie_list !=
13651 &spx->txlt_dma_cookie) {
13652 (void) kmem_free(spx->txlt_dma_cookie_list,
13653 spx->txlt_dma_cookie_list_len *
13654 sizeof (ddi_dma_cookie_t));
13655 spx->txlt_dma_cookie_list = NULL;
13656 }
13657 }
13658 (void) ddi_dma_unbind_handle(spx->txlt_buf_dma_handle);
13659 (void) ddi_dma_free_handle(&spx->txlt_buf_dma_handle);
13660 spx->txlt_buf_dma_handle = NULL;
13661 }
13662 }
13663
13664 /*
13665 * Free DMA resources
13666 * Used by the HBA driver to release DMA resources that it does not use.
13667 *
13668 * Returns Void
13669 */
13670 void
13671 sata_free_dma_resources(sata_pkt_t *sata_pkt)
13672 {
13673 sata_pkt_txlate_t *spx;
13674
13675 if (sata_pkt == NULL)
13676 return;
13677
13678 spx = (sata_pkt_txlate_t *)sata_pkt->satapkt_framework_private;
13679
13680 sata_common_free_dma_rsrcs(spx);
13681 }
13682
13683 /*
13684 * Fetch Device Identify data.
13685 * Send DEVICE IDENTIFY or IDENTIFY PACKET DEVICE (depending on a device type)
13686 * command to a device and get the device identify data.
13687 * The device_info structure has to be set to device type (for selecting proper
13688 * device identify command).
13689 *
13690 * Returns:
13691 * SATA_SUCCESS if cmd succeeded
13692 * SATA_RETRY if cmd was rejected and could be retried,
13693 * SATA_FAILURE if cmd failed and should not be retried (port error)
13694 *
13695 * Cannot be called in an interrupt context.
13696 */
13697
13698 static int
13699 sata_fetch_device_identify_data(sata_hba_inst_t *sata_hba_inst,
13700 sata_drive_info_t *sdinfo)
13701 {
13702 struct buf *bp;
13703 sata_pkt_t *spkt;
13704 sata_cmd_t *scmd;
13705 sata_pkt_txlate_t *spx;
13706 int rval;
13707 dev_info_t *dip = SATA_DIP(sata_hba_inst);
13708
13709 spx = kmem_zalloc(sizeof (sata_pkt_txlate_t), KM_SLEEP);
13710 spx->txlt_sata_hba_inst = sata_hba_inst;
13711 spx->txlt_scsi_pkt = NULL; /* No scsi pkt involved */
13712 spkt = sata_pkt_alloc(spx, SLEEP_FUNC);
13713 if (spkt == NULL) {
13714 kmem_free(spx, sizeof (sata_pkt_txlate_t));
13715 return (SATA_RETRY); /* may retry later */
13716 }
13717 /* address is needed now */
13718 spkt->satapkt_device.satadev_addr = sdinfo->satadrv_addr;
13719
13720 /*
13721 * Allocate buffer for Identify Data return data
13722 */
13723 bp = sata_alloc_local_buffer(spx, sizeof (sata_id_t));
13724 if (bp == NULL) {
13725 sata_pkt_free(spx);
13726 kmem_free(spx, sizeof (sata_pkt_txlate_t));
13727 SATA_LOG_D((sata_hba_inst, CE_WARN,
13728 "sata_fetch_device_identify_data: "
13729 "cannot allocate buffer for ID"));
13730 return (SATA_RETRY); /* may retry later */
13731 }
13732
13733 /* Fill sata_pkt */
13734 sdinfo->satadrv_state = SATA_STATE_PROBING;
13735 spkt->satapkt_device.satadev_addr = sdinfo->satadrv_addr;
13736 spkt->satapkt_op_mode = SATA_OPMODE_SYNCH | SATA_OPMODE_INTERRUPTS;
13737 /* Synchronous mode, no callback */
13738 spkt->satapkt_comp = NULL;
13739 /* Timeout 30s */
13740 spkt->satapkt_time = sata_default_pkt_time;
13741
13742 scmd = &spkt->satapkt_cmd;
13743 scmd->satacmd_bp = bp;
13744 scmd->satacmd_flags.sata_data_direction = SATA_DIR_READ;
13745 scmd->satacmd_flags.sata_ignore_dev_reset = B_TRUE;
13746
13747 /* Build Identify Device cmd in the sata_pkt */
13748 scmd->satacmd_addr_type = 0; /* N/A */
13749 scmd->satacmd_sec_count_lsb = 0; /* N/A */
13750 scmd->satacmd_lba_low_lsb = 0; /* N/A */
13751 scmd->satacmd_lba_mid_lsb = 0; /* N/A */
13752 scmd->satacmd_lba_high_lsb = 0; /* N/A */
13753 scmd->satacmd_features_reg = 0; /* N/A */
13754 scmd->satacmd_device_reg = 0; /* Always device 0 */
13755 if (sdinfo->satadrv_type & SATA_DTYPE_ATAPI) {
13756 /* Identify Packet Device cmd */
13757 scmd->satacmd_cmd_reg = SATAC_ID_PACKET_DEVICE;
13758 } else {
13759 /* Identify Device cmd - mandatory for all other devices */
13760 scmd->satacmd_cmd_reg = SATAC_ID_DEVICE;
13761 }
13762
13763 /* Send pkt to SATA HBA driver */
13764 rval = (*SATA_START_FUNC(sata_hba_inst))(SATA_DIP(sata_hba_inst), spkt);
13765
13766 #ifdef SATA_INJECT_FAULTS
13767 sata_inject_pkt_fault(spkt, &rval, sata_fault_type);
13768 #endif
13769
13770 if (rval == SATA_TRAN_ACCEPTED &&
13771 spkt->satapkt_reason == SATA_PKT_COMPLETED) {
13772 if (spx->txlt_buf_dma_handle != NULL) {
13773 rval = ddi_dma_sync(spx->txlt_buf_dma_handle, 0, 0,
13774 DDI_DMA_SYNC_FORKERNEL);
13775 ASSERT(rval == DDI_SUCCESS);
13776 if (sata_check_for_dma_error(dip, spx)) {
13777 ddi_fm_service_impact(dip,
13778 DDI_SERVICE_UNAFFECTED);
13779 rval = SATA_RETRY;
13780 goto fail;
13781 }
13782
13783 }
13784 if ((((sata_id_t *)(bp->b_un.b_addr))->ai_config &
13785 SATA_INCOMPLETE_DATA) == SATA_INCOMPLETE_DATA) {
13786 SATA_LOG_D((sata_hba_inst, CE_WARN,
13787 "SATA disk device at port %d - "
13788 "partial Identify Data",
13789 sdinfo->satadrv_addr.cport));
13790 rval = SATA_RETRY; /* may retry later */
13791 goto fail;
13792 }
13793 /* Update sata_drive_info */
13794 bcopy(bp->b_un.b_addr, &sdinfo->satadrv_id,
13795 sizeof (sata_id_t));
13796
13797 sdinfo->satadrv_features_support = 0;
13798 if (sdinfo->satadrv_type == SATA_DTYPE_ATADISK) {
13799 /*
13800 * Retrieve capacity (disks only) and addressing mode
13801 */
13802 sdinfo->satadrv_capacity = sata_check_capacity(sdinfo);
13803 } else {
13804 /*
13805 * For ATAPI devices one would have to issue
13806 * Get Capacity cmd for media capacity. Not here.
13807 */
13808 sdinfo->satadrv_capacity = 0;
13809 /*
13810 * Check what cdb length is supported
13811 */
13812 if ((sdinfo->satadrv_id.ai_config &
13813 SATA_ATAPI_ID_PKT_SZ) == SATA_ATAPI_ID_PKT_16B)
13814 sdinfo->satadrv_atapi_cdb_len = 16;
13815 else
13816 sdinfo->satadrv_atapi_cdb_len = 12;
13817 }
13818 /* Setup supported features flags */
13819 if (sdinfo->satadrv_id.ai_cap & SATA_DMA_SUPPORT)
13820 sdinfo->satadrv_features_support |= SATA_DEV_F_DMA;
13821
13822 /* Check for SATA GEN and NCQ support */
13823 if (sdinfo->satadrv_id.ai_satacap != 0 &&
13824 sdinfo->satadrv_id.ai_satacap != 0xffff) {
13825 /* SATA compliance */
13826 if (sdinfo->satadrv_id.ai_satacap & SATA_NCQ)
13827 sdinfo->satadrv_features_support |=
13828 SATA_DEV_F_NCQ;
13829 if (sdinfo->satadrv_id.ai_satacap &
13830 (SATA_1_SPEED | SATA_2_SPEED | SATA_3_SPEED)) {
13831 if (sdinfo->satadrv_id.ai_satacap &
13832 SATA_3_SPEED)
13833 sdinfo->satadrv_features_support |=
13834 SATA_DEV_F_SATA3;
13835 if (sdinfo->satadrv_id.ai_satacap &
13836 SATA_2_SPEED)
13837 sdinfo->satadrv_features_support |=
13838 SATA_DEV_F_SATA2;
13839 if (sdinfo->satadrv_id.ai_satacap &
13840 SATA_1_SPEED)
13841 sdinfo->satadrv_features_support |=
13842 SATA_DEV_F_SATA1;
13843 } else {
13844 sdinfo->satadrv_features_support |=
13845 SATA_DEV_F_SATA1;
13846 }
13847 }
13848 if ((sdinfo->satadrv_id.ai_cmdset83 & SATA_RW_DMA_QUEUED_CMD) &&
13849 (sdinfo->satadrv_id.ai_features86 & SATA_RW_DMA_QUEUED_CMD))
13850 sdinfo->satadrv_features_support |= SATA_DEV_F_TCQ;
13851
13852 sdinfo->satadrv_queue_depth = sdinfo->satadrv_id.ai_qdepth;
13853 if ((sdinfo->satadrv_features_support & SATA_DEV_F_NCQ) ||
13854 (sdinfo->satadrv_features_support & SATA_DEV_F_TCQ)) {
13855 ++sdinfo->satadrv_queue_depth;
13856 /* Adjust according to controller capabilities */
13857 sdinfo->satadrv_max_queue_depth = MIN(
13858 sdinfo->satadrv_queue_depth,
13859 SATA_QDEPTH(sata_hba_inst));
13860 /* Adjust according to global queue depth limit */
13861 sdinfo->satadrv_max_queue_depth = MIN(
13862 sdinfo->satadrv_max_queue_depth,
13863 sata_current_max_qdepth);
13864 if (sdinfo->satadrv_max_queue_depth == 0)
13865 sdinfo->satadrv_max_queue_depth = 1;
13866 } else
13867 sdinfo->satadrv_max_queue_depth = 1;
13868
13869 rval = SATA_SUCCESS;
13870 } else {
13871 /*
13872 * Woops, no Identify Data.
13873 */
13874 if (rval == SATA_TRAN_BUSY || rval == SATA_TRAN_QUEUE_FULL) {
13875 rval = SATA_RETRY; /* may retry later */
13876 } else if (rval == SATA_TRAN_ACCEPTED) {
13877 if (spkt->satapkt_reason == SATA_PKT_DEV_ERROR ||
13878 spkt->satapkt_reason == SATA_PKT_ABORTED ||
13879 spkt->satapkt_reason == SATA_PKT_TIMEOUT ||
13880 spkt->satapkt_reason == SATA_PKT_RESET)
13881 rval = SATA_RETRY; /* may retry later */
13882 else
13883 rval = SATA_FAILURE;
13884 } else {
13885 rval = SATA_FAILURE;
13886 }
13887 }
13888 fail:
13889 /* Free allocated resources */
13890 sata_free_local_buffer(spx);
13891 sata_pkt_free(spx);
13892 kmem_free(spx, sizeof (sata_pkt_txlate_t));
13893
13894 return (rval);
13895 }
13896
13897
13898 /*
13899 * Some devices may not come-up with default DMA mode (UDMA or MWDMA).
13900 * UDMA mode is checked first, followed by MWDMA mode.
13901 * set correctly, so this function is setting it to the highest supported level.
13902 * Older SATA spec required that the device supports at least DMA 4 mode and
13903 * UDMA mode is selected. It is not mentioned in SerialATA 2.6, so this
13904 * restriction has been removed.
13905 *
13906 * Returns SATA_SUCCESS if proper DMA mode is selected or no DMA is supported.
13907 * Returns SATA_FAILURE if proper DMA mode could not be selected.
13908 *
13909 * NOTE: This function should be called only if DMA mode is supported.
13910 */
13911 static int
13912 sata_set_dma_mode(sata_hba_inst_t *sata_hba_inst, sata_drive_info_t *sdinfo)
13913 {
13914 sata_pkt_t *spkt;
13915 sata_cmd_t *scmd;
13916 sata_pkt_txlate_t *spx;
13917 int i, mode;
13918 uint8_t subcmd;
13919 int rval = SATA_SUCCESS;
13920
13921 ASSERT(sdinfo != NULL);
13922 ASSERT(sata_hba_inst != NULL);
13923
13924 if ((sdinfo->satadrv_id.ai_validinfo & SATA_VALIDINFO_88) != 0 &&
13925 (sdinfo->satadrv_id.ai_ultradma & SATA_UDMA_SUP_MASK) != 0) {
13926 /* Find highest Ultra DMA mode supported */
13927 for (mode = 6; mode >= 0; --mode) {
13928 if (sdinfo->satadrv_id.ai_ultradma & (1 << mode))
13929 break;
13930 }
13931 #if 0
13932 /* Left for historical reasons */
13933 /*
13934 * Some initial version of SATA spec indicated that at least
13935 * UDMA mode 4 has to be supported. It is not mentioned in
13936 * SerialATA 2.6, so this restriction is removed.
13937 */
13938 if (mode < 4)
13939 return (SATA_FAILURE);
13940 #endif
13941
13942 /*
13943 * For disk, we're still going to set DMA mode whatever is
13944 * selected by default
13945 *
13946 * We saw an old maxtor sata drive will select Ultra DMA and
13947 * Multi-Word DMA simultaneouly by default, which is going
13948 * to cause DMA command timed out, so we need to select DMA
13949 * mode even when it's already done by default
13950 */
13951 if (sdinfo->satadrv_type != SATA_DTYPE_ATADISK) {
13952
13953 /* Find UDMA mode currently selected */
13954 for (i = 6; i >= 0; --i) {
13955 if (sdinfo->satadrv_id.ai_ultradma &
13956 (1 << (i + 8)))
13957 break;
13958 }
13959 if (i >= mode)
13960 /* Nothing to do */
13961 return (SATA_SUCCESS);
13962 }
13963
13964 subcmd = SATAC_TRANSFER_MODE_ULTRA_DMA;
13965
13966 } else if ((sdinfo->satadrv_id.ai_dworddma & SATA_MDMA_SUP_MASK) != 0) {
13967 /* Find highest MultiWord DMA mode supported */
13968 for (mode = 2; mode >= 0; --mode) {
13969 if (sdinfo->satadrv_id.ai_dworddma & (1 << mode))
13970 break;
13971 }
13972
13973 /*
13974 * For disk, We're still going to set DMA mode whatever is
13975 * selected by default
13976 *
13977 * We saw an old maxtor sata drive will select Ultra DMA and
13978 * Multi-Word DMA simultaneouly by default, which is going
13979 * to cause DMA command timed out, so we need to select DMA
13980 * mode even when it's already done by default
13981 */
13982 if (sdinfo->satadrv_type != SATA_DTYPE_ATADISK) {
13983
13984 /* Find highest MultiWord DMA mode selected */
13985 for (i = 2; i >= 0; --i) {
13986 if (sdinfo->satadrv_id.ai_dworddma &
13987 (1 << (i + 8)))
13988 break;
13989 }
13990 if (i >= mode)
13991 /* Nothing to do */
13992 return (SATA_SUCCESS);
13993 }
13994
13995 subcmd = SATAC_TRANSFER_MODE_MULTI_WORD_DMA;
13996 } else
13997 return (SATA_SUCCESS);
13998
13999 /*
14000 * Set DMA mode via SET FEATURES COMMAND.
14001 * Prepare packet for SET FEATURES COMMAND.
14002 */
14003 spx = kmem_zalloc(sizeof (sata_pkt_txlate_t), KM_SLEEP);
14004 spx->txlt_sata_hba_inst = sata_hba_inst;
14005 spx->txlt_scsi_pkt = NULL; /* No scsi pkt involved */
14006 spkt = sata_pkt_alloc(spx, SLEEP_FUNC);
14007 if (spkt == NULL) {
14008 SATA_LOG_D((sata_hba_inst, CE_WARN,
14009 "sata_set_dma_mode: could not set DMA mode %d", mode));
14010 rval = SATA_FAILURE;
14011 goto done;
14012 }
14013 /* Fill sata_pkt */
14014 spkt->satapkt_device.satadev_addr = sdinfo->satadrv_addr;
14015 /* Timeout 30s */
14016 spkt->satapkt_time = sata_default_pkt_time;
14017 /* Synchronous mode, no callback, interrupts */
14018 spkt->satapkt_op_mode = SATA_OPMODE_SYNCH | SATA_OPMODE_INTERRUPTS;
14019 spkt->satapkt_comp = NULL;
14020 scmd = &spkt->satapkt_cmd;
14021 scmd->satacmd_flags.sata_data_direction = SATA_DIR_NODATA_XFER;
14022 scmd->satacmd_flags.sata_ignore_dev_reset = B_TRUE;
14023 scmd->satacmd_addr_type = 0;
14024 scmd->satacmd_device_reg = 0;
14025 scmd->satacmd_status_reg = 0;
14026 scmd->satacmd_error_reg = 0;
14027 scmd->satacmd_cmd_reg = SATAC_SET_FEATURES;
14028 scmd->satacmd_features_reg = SATAC_SF_TRANSFER_MODE;
14029 scmd->satacmd_sec_count_lsb = subcmd | mode;
14030
14031 /* Transfer command to HBA */
14032 if ((*SATA_START_FUNC(sata_hba_inst))(SATA_DIP(sata_hba_inst),
14033 spkt) != SATA_TRAN_ACCEPTED ||
14034 spkt->satapkt_reason != SATA_PKT_COMPLETED) {
14035 /* Pkt execution failed */
14036 rval = SATA_FAILURE;
14037 }
14038 done:
14039
14040 /* Free allocated resources */
14041 if (spkt != NULL)
14042 sata_pkt_free(spx);
14043 (void) kmem_free(spx, sizeof (sata_pkt_txlate_t));
14044
14045 return (rval);
14046 }
14047
14048
14049 /*
14050 * Set device caching mode.
14051 * One of the following operations should be specified:
14052 * SATAC_SF_ENABLE_READ_AHEAD
14053 * SATAC_SF_DISABLE_READ_AHEAD
14054 * SATAC_SF_ENABLE_WRITE_CACHE
14055 * SATAC_SF_DISABLE_WRITE_CACHE
14056 *
14057 * If operation fails, system log messgage is emitted.
14058 * Returns SATA_SUCCESS when the operation succeeds, SATA_RETRY if
14059 * command was sent but did not succeed, and SATA_FAILURE otherwise.
14060 */
14061
14062 static int
14063 sata_set_cache_mode(sata_hba_inst_t *sata_hba_inst, sata_drive_info_t *sdinfo,
14064 int cache_op)
14065 {
14066 sata_pkt_t *spkt;
14067 sata_cmd_t *scmd;
14068 sata_pkt_txlate_t *spx;
14069 int rval = SATA_SUCCESS;
14070 int hba_rval;
14071 char *infop;
14072
14073 ASSERT(sdinfo != NULL);
14074 ASSERT(sata_hba_inst != NULL);
14075 ASSERT(cache_op == SATAC_SF_ENABLE_READ_AHEAD ||
14076 cache_op == SATAC_SF_DISABLE_READ_AHEAD ||
14077 cache_op == SATAC_SF_ENABLE_WRITE_CACHE ||
14078 cache_op == SATAC_SF_DISABLE_WRITE_CACHE);
14079
14080
14081 /* Prepare packet for SET FEATURES COMMAND */
14082 spx = kmem_zalloc(sizeof (sata_pkt_txlate_t), KM_SLEEP);
14083 spx->txlt_sata_hba_inst = sata_hba_inst;
14084 spx->txlt_scsi_pkt = NULL; /* No scsi pkt involved */
14085 spkt = sata_pkt_alloc(spx, SLEEP_FUNC);
14086 if (spkt == NULL) {
14087 rval = SATA_FAILURE;
14088 goto failure;
14089 }
14090 /* Fill sata_pkt */
14091 spkt->satapkt_device.satadev_addr = sdinfo->satadrv_addr;
14092 /* Timeout 30s */
14093 spkt->satapkt_time = sata_default_pkt_time;
14094 /* Synchronous mode, no callback, interrupts */
14095 spkt->satapkt_op_mode =
14096 SATA_OPMODE_SYNCH | SATA_OPMODE_INTERRUPTS;
14097 spkt->satapkt_comp = NULL;
14098 scmd = &spkt->satapkt_cmd;
14099 scmd->satacmd_flags.sata_data_direction = SATA_DIR_NODATA_XFER;
14100 scmd->satacmd_flags.sata_ignore_dev_reset = B_TRUE;
14101 scmd->satacmd_addr_type = 0;
14102 scmd->satacmd_device_reg = 0;
14103 scmd->satacmd_status_reg = 0;
14104 scmd->satacmd_error_reg = 0;
14105 scmd->satacmd_cmd_reg = SATAC_SET_FEATURES;
14106 scmd->satacmd_features_reg = cache_op;
14107
14108 /* Transfer command to HBA */
14109 hba_rval = (*SATA_START_FUNC(sata_hba_inst))(
14110 SATA_DIP(sata_hba_inst), spkt);
14111
14112 #ifdef SATA_INJECT_FAULTS
14113 sata_inject_pkt_fault(spkt, &rval, sata_fault_type);
14114 #endif
14115
14116 if ((hba_rval != SATA_TRAN_ACCEPTED) ||
14117 (spkt->satapkt_reason != SATA_PKT_COMPLETED)) {
14118 /* Pkt execution failed */
14119 switch (cache_op) {
14120 case SATAC_SF_ENABLE_READ_AHEAD:
14121 infop = "enabling read ahead failed";
14122 break;
14123 case SATAC_SF_DISABLE_READ_AHEAD:
14124 infop = "disabling read ahead failed";
14125 break;
14126 case SATAC_SF_ENABLE_WRITE_CACHE:
14127 infop = "enabling write cache failed";
14128 break;
14129 case SATAC_SF_DISABLE_WRITE_CACHE:
14130 infop = "disabling write cache failed";
14131 break;
14132 }
14133 SATA_LOG_D((sata_hba_inst, CE_WARN, "%s", infop));
14134 rval = SATA_RETRY;
14135 }
14136 failure:
14137 /* Free allocated resources */
14138 if (spkt != NULL)
14139 sata_pkt_free(spx);
14140 (void) kmem_free(spx, sizeof (sata_pkt_txlate_t));
14141 return (rval);
14142 }
14143
14144 /*
14145 * Set Removable Media Status Notification (enable/disable)
14146 * state == 0 , disable
14147 * state != 0 , enable
14148 *
14149 * If operation fails, system log messgage is emitted.
14150 * Returns SATA_SUCCESS when the operation succeeds, SATA_FAILURE otherwise.
14151 */
14152
14153 static int
14154 sata_set_rmsn(sata_hba_inst_t *sata_hba_inst, sata_drive_info_t *sdinfo,
14155 int state)
14156 {
14157 sata_pkt_t *spkt;
14158 sata_cmd_t *scmd;
14159 sata_pkt_txlate_t *spx;
14160 int rval = SATA_SUCCESS;
14161 char *infop;
14162
14163 ASSERT(sdinfo != NULL);
14164 ASSERT(sata_hba_inst != NULL);
14165
14166 /* Prepare packet for SET FEATURES COMMAND */
14167 spx = kmem_zalloc(sizeof (sata_pkt_txlate_t), KM_SLEEP);
14168 spx->txlt_sata_hba_inst = sata_hba_inst;
14169 spx->txlt_scsi_pkt = NULL; /* No scsi pkt involved */
14170 spkt = sata_pkt_alloc(spx, SLEEP_FUNC);
14171 if (spkt == NULL) {
14172 rval = SATA_FAILURE;
14173 goto failure;
14174 }
14175 /* Fill sata_pkt */
14176 spkt->satapkt_device.satadev_addr = sdinfo->satadrv_addr;
14177 /* Timeout 30s */
14178 spkt->satapkt_time = sata_default_pkt_time;
14179 /* Synchronous mode, no callback, interrupts */
14180 spkt->satapkt_op_mode =
14181 SATA_OPMODE_SYNCH | SATA_OPMODE_INTERRUPTS;
14182 spkt->satapkt_comp = NULL;
14183 scmd = &spkt->satapkt_cmd;
14184 scmd->satacmd_flags.sata_data_direction = SATA_DIR_NODATA_XFER;
14185 scmd->satacmd_flags.sata_ignore_dev_reset = B_TRUE;
14186 scmd->satacmd_addr_type = 0;
14187 scmd->satacmd_device_reg = 0;
14188 scmd->satacmd_status_reg = 0;
14189 scmd->satacmd_error_reg = 0;
14190 scmd->satacmd_cmd_reg = SATAC_SET_FEATURES;
14191 if (state == 0)
14192 scmd->satacmd_features_reg = SATAC_SF_DISABLE_RMSN;
14193 else
14194 scmd->satacmd_features_reg = SATAC_SF_ENABLE_RMSN;
14195
14196 /* Transfer command to HBA */
14197 if (((*SATA_START_FUNC(sata_hba_inst))(
14198 SATA_DIP(sata_hba_inst), spkt) != SATA_TRAN_ACCEPTED) ||
14199 (spkt->satapkt_reason != SATA_PKT_COMPLETED)) {
14200 /* Pkt execution failed */
14201 if (state == 0)
14202 infop = "disabling Removable Media Status "
14203 "Notification failed";
14204 else
14205 infop = "enabling Removable Media Status "
14206 "Notification failed";
14207
14208 SATA_LOG_D((sata_hba_inst, CE_WARN, "%s", infop));
14209 rval = SATA_FAILURE;
14210 }
14211 failure:
14212 /* Free allocated resources */
14213 if (spkt != NULL)
14214 sata_pkt_free(spx);
14215 (void) kmem_free(spx, sizeof (sata_pkt_txlate_t));
14216 return (rval);
14217 }
14218
14219
14220 /*
14221 * Update state and copy port ss* values from passed sata_device structure.
14222 * sata_address is validated - if not valid, nothing is changed in sata_scsi
14223 * configuration struct.
14224 *
14225 * SATA_PSTATE_SHUTDOWN in port state is not reset to 0 by this function
14226 * regardless of the state in device argument.
14227 *
14228 * Port mutex should be held while calling this function.
14229 */
14230 static void
14231 sata_update_port_info(sata_hba_inst_t *sata_hba_inst,
14232 sata_device_t *sata_device)
14233 {
14234 sata_cport_info_t *cportinfo;
14235
14236 if (sata_device->satadev_addr.qual == SATA_ADDR_CPORT ||
14237 sata_device->satadev_addr.qual == SATA_ADDR_DCPORT) {
14238 if (SATA_NUM_CPORTS(sata_hba_inst) <=
14239 sata_device->satadev_addr.cport)
14240 return;
14241
14242 cportinfo = SATA_CPORT_INFO(sata_hba_inst,
14243 sata_device->satadev_addr.cport);
14244
14245 ASSERT(mutex_owned(&cportinfo->cport_mutex));
14246 cportinfo->cport_scr = sata_device->satadev_scr;
14247
14248 /* Preserve SATA_PSTATE_SHUTDOWN flag */
14249 cportinfo->cport_state &= ~(SATA_PSTATE_PWRON |
14250 SATA_PSTATE_PWROFF | SATA_PSTATE_FAILED);
14251 cportinfo->cport_state |=
14252 sata_device->satadev_state & SATA_PSTATE_VALID;
14253 }
14254 }
14255
14256 void
14257 sata_update_pmport_info(sata_hba_inst_t *sata_hba_inst,
14258 sata_device_t *sata_device)
14259 {
14260 sata_pmport_info_t *pmportinfo;
14261
14262 if ((sata_device->satadev_addr.qual != SATA_ADDR_PMPORT &&
14263 sata_device->satadev_addr.qual != SATA_ADDR_DPMPORT) ||
14264 SATA_NUM_PMPORTS(sata_hba_inst,
14265 sata_device->satadev_addr.cport) <
14266 sata_device->satadev_addr.pmport) {
14267 SATADBG1(SATA_DBG_PMULT, sata_hba_inst,
14268 "sata_update_port_info: error address %p.",
14269 &sata_device->satadev_addr);
14270 return;
14271 }
14272
14273 pmportinfo = SATA_PMPORT_INFO(sata_hba_inst,
14274 sata_device->satadev_addr.cport,
14275 sata_device->satadev_addr.pmport);
14276
14277 ASSERT(mutex_owned(&pmportinfo->pmport_mutex));
14278 pmportinfo->pmport_scr = sata_device->satadev_scr;
14279
14280 /* Preserve SATA_PSTATE_SHUTDOWN flag */
14281 pmportinfo->pmport_state &=
14282 ~(SATA_PSTATE_PWRON | SATA_PSTATE_PWROFF | SATA_PSTATE_FAILED);
14283 pmportinfo->pmport_state |=
14284 sata_device->satadev_state & SATA_PSTATE_VALID;
14285 }
14286
14287 /*
14288 * Extract SATA port specification from an IOCTL argument.
14289 *
14290 * This function return the port the user land send us as is, unless it
14291 * cannot retrieve port spec, then -1 is returned.
14292 *
14293 * Support port multiplier.
14294 */
14295 static int32_t
14296 sata_get_port_num(sata_hba_inst_t *sata_hba_inst, struct devctl_iocdata *dcp)
14297 {
14298 int32_t port;
14299
14300 /* Extract port number from nvpair in dca structure */
14301 if (nvlist_lookup_int32(ndi_dc_get_ap_data(dcp), "port", &port) != 0) {
14302 SATA_LOG_D((sata_hba_inst, CE_NOTE,
14303 "sata_get_port_num: invalid port spec 0x%x in ioctl",
14304 port));
14305 port = -1;
14306 }
14307
14308 return (port);
14309 }
14310
14311 /*
14312 * Get dev_info_t pointer to the device node pointed to by port argument.
14313 * NOTE: target argument is a value used in ioctls to identify
14314 * the AP - it is not a sata_address.
14315 * It is a combination of cport, pmport and address qualifier, encodded same
14316 * way as a scsi target number.
14317 * At this moment it carries only cport number.
14318 *
14319 * PMult hotplug is supported now.
14320 *
14321 * Returns dev_info_t pointer if target device was found, NULL otherwise.
14322 */
14323
14324 static dev_info_t *
14325 sata_get_target_dip(dev_info_t *dip, uint8_t cport, uint8_t pmport)
14326 {
14327 dev_info_t *cdip = NULL;
14328 int target, tgt;
14329 int circ;
14330 uint8_t qual;
14331
14332 sata_hba_inst_t *sata_hba_inst;
14333 scsi_hba_tran_t *scsi_hba_tran;
14334
14335 /* Get target id */
14336 scsi_hba_tran = ddi_get_driver_private(dip);
14337 if (scsi_hba_tran == NULL)
14338 return (NULL);
14339
14340 sata_hba_inst = scsi_hba_tran->tran_hba_private;
14341
14342 if (sata_hba_inst == NULL)
14343 return (NULL);
14344
14345 /* Identify a port-mult by cport_info.cport_dev_type */
14346 if (SATA_CPORT_DEV_TYPE(sata_hba_inst, cport) == SATA_DTYPE_PMULT)
14347 qual = SATA_ADDR_DPMPORT;
14348 else
14349 qual = SATA_ADDR_DCPORT;
14350
14351 target = SATA_TO_SCSI_TARGET(cport, pmport, qual);
14352
14353 /* Retrieve target dip */
14354 ndi_devi_enter(dip, &circ);
14355 for (cdip = ddi_get_child(dip); cdip != NULL; ) {
14356 dev_info_t *next = ddi_get_next_sibling(cdip);
14357
14358 tgt = ddi_prop_get_int(DDI_DEV_T_ANY, cdip,
14359 DDI_PROP_DONTPASS, "target", -1);
14360 if (tgt == -1) {
14361 /*
14362 * This is actually an error condition, but not
14363 * a fatal one. Just continue the search.
14364 */
14365 cdip = next;
14366 continue;
14367 }
14368
14369 if (tgt == target)
14370 break;
14371
14372 cdip = next;
14373 }
14374 ndi_devi_exit(dip, circ);
14375
14376 return (cdip);
14377 }
14378
14379 /*
14380 * Get dev_info_t pointer to the device node pointed to by port argument.
14381 * NOTE: target argument is a value used in ioctls to identify
14382 * the AP - it is not a sata_address.
14383 * It is a combination of cport, pmport and address qualifier, encoded same
14384 * way as a scsi target number.
14385 *
14386 * Returns dev_info_t pointer if target device was found, NULL otherwise.
14387 */
14388
14389 static dev_info_t *
14390 sata_get_scsi_target_dip(dev_info_t *dip, sata_address_t *saddr)
14391 {
14392 dev_info_t *cdip = NULL;
14393 int target, tgt;
14394 int circ;
14395
14396 target = SATA_TO_SCSI_TARGET(saddr->cport, saddr->pmport, saddr->qual);
14397
14398 ndi_devi_enter(dip, &circ);
14399 for (cdip = ddi_get_child(dip); cdip != NULL; ) {
14400 dev_info_t *next = ddi_get_next_sibling(cdip);
14401
14402 tgt = ddi_prop_get_int(DDI_DEV_T_ANY, cdip,
14403 DDI_PROP_DONTPASS, "target", -1);
14404 if (tgt == -1) {
14405 /*
14406 * This is actually an error condition, but not
14407 * a fatal one. Just continue the search.
14408 */
14409 cdip = next;
14410 continue;
14411 }
14412
14413 if (tgt == target)
14414 break;
14415
14416 cdip = next;
14417 }
14418 ndi_devi_exit(dip, circ);
14419
14420 return (cdip);
14421 }
14422
14423 /*
14424 * Process sata port disconnect request.
14425 * Normally, cfgadm sata plugin will try to offline (unconfigure) the device
14426 * before this request. Nevertheless, if a device is still configured,
14427 * we need to attempt to offline and unconfigure device.
14428 * Regardless of the unconfigure operation results the port is marked as
14429 * deactivated and no access to the attached device is possible.
14430 * If the target node remains because unconfigure operation failed, its state
14431 * will be set to DEVICE_REMOVED, preventing it to be used again when a device
14432 * is inserted/re-inserted. The event daemon will repeatedly try to unconfigure
14433 * the device and remove old target node.
14434 *
14435 * This function invokes sata_hba_inst->satahba_tran->
14436 * sata_tran_hotplug_ops->sata_tran_port_deactivate().
14437 * If successful, the device structure (if any) attached to the specified port
14438 * is removed and state of the port marked appropriately.
14439 * Failure of the port_deactivate may keep port in the physically active state,
14440 * or may fail the port.
14441 *
14442 * NOTE: Port multiplier is supported.
14443 */
14444
14445 static int
14446 sata_ioctl_disconnect(sata_hba_inst_t *sata_hba_inst,
14447 sata_device_t *sata_device)
14448 {
14449 sata_drive_info_t *sdinfo = NULL, *subsdinfo = NULL;
14450 sata_cport_info_t *cportinfo = NULL;
14451 sata_pmport_info_t *pmportinfo = NULL;
14452 sata_pmult_info_t *pmultinfo = NULL;
14453 sata_device_t subsdevice;
14454 int cport, pmport, qual;
14455 int rval = SATA_SUCCESS;
14456 int npmport = 0;
14457 int rv = 0;
14458
14459 cport = sata_device->satadev_addr.cport;
14460 pmport = sata_device->satadev_addr.pmport;
14461 qual = sata_device->satadev_addr.qual;
14462
14463 ASSERT(qual == SATA_ADDR_DCPORT || qual == SATA_ADDR_DPMPORT);
14464 if (qual == SATA_ADDR_DCPORT)
14465 qual = SATA_ADDR_CPORT;
14466 else
14467 qual = SATA_ADDR_PMPORT;
14468
14469 /*
14470 * DEVCTL_AP_DISCONNECT invokes sata_hba_inst->satahba_tran->
14471 * sata_tran_hotplug_ops->sata_tran_port_deactivate().
14472 * Do the sanity check.
14473 */
14474 if (SATA_PORT_DEACTIVATE_FUNC(sata_hba_inst) == NULL) {
14475 /* No physical port deactivation supported. */
14476 return (EINVAL);
14477 }
14478
14479 /* Check the current state of the port */
14480 rval = (*SATA_PROBE_PORT_FUNC(sata_hba_inst))
14481 (SATA_DIP(sata_hba_inst), sata_device);
14482
14483 cportinfo = SATA_CPORT_INFO(sata_hba_inst, cport);
14484
14485 /*
14486 * Processing port mulitiplier
14487 */
14488 if (qual == SATA_ADDR_CPORT &&
14489 SATA_CPORT_DEV_TYPE(sata_hba_inst, cport) == SATA_DTYPE_PMULT) {
14490 mutex_enter(&cportinfo->cport_mutex);
14491
14492 /* Check controller port status */
14493 sata_update_port_info(sata_hba_inst, sata_device);
14494 if (rval != SATA_SUCCESS ||
14495 (sata_device->satadev_state & SATA_PSTATE_FAILED) != 0) {
14496 /*
14497 * Device port status is unknown or it is in failed
14498 * state
14499 */
14500 SATA_CPORT_STATE(sata_hba_inst, cport) =
14501 SATA_PSTATE_FAILED;
14502 SATADBG1(SATA_DBG_IOCTL_IF, sata_hba_inst,
14503 "sata_hba_ioctl: connect: failed to deactivate "
14504 "SATA port %d", cport);
14505 mutex_exit(&cportinfo->cport_mutex);
14506 return (EIO);
14507 }
14508
14509 /* Disconnect all sub-devices. */
14510 pmultinfo = SATA_CPORTINFO_PMULT_INFO(cportinfo);
14511 if (pmultinfo != NULL) {
14512
14513 for (npmport = 0; npmport < SATA_NUM_PMPORTS(
14514 sata_hba_inst, cport); npmport ++) {
14515 subsdinfo = SATA_PMPORT_DRV_INFO(
14516 sata_hba_inst, cport, npmport);
14517 if (subsdinfo == NULL)
14518 continue;
14519
14520 subsdevice.satadev_addr = subsdinfo->
14521 satadrv_addr;
14522
14523 mutex_exit(&cportinfo->cport_mutex);
14524 if (sata_ioctl_disconnect(sata_hba_inst,
14525 &subsdevice) == SATA_SUCCESS) {
14526 SATADBG2(SATA_DBG_PMULT, sata_hba_inst,
14527 "[Remove] device at port %d:%d "
14528 "successfully.", cport, npmport);
14529 }
14530 mutex_enter(&cportinfo->cport_mutex);
14531 }
14532 }
14533
14534 /* Disconnect the port multiplier */
14535 cportinfo->cport_state &= ~SATA_STATE_READY;
14536 mutex_exit(&cportinfo->cport_mutex);
14537
14538 sata_device->satadev_addr.qual = qual;
14539 rval = (*SATA_PORT_DEACTIVATE_FUNC(sata_hba_inst))
14540 (SATA_DIP(sata_hba_inst), sata_device);
14541
14542 sata_gen_sysevent(sata_hba_inst, &sata_device->satadev_addr,
14543 SE_NO_HINT);
14544
14545 mutex_enter(&cportinfo->cport_mutex);
14546 sata_update_port_info(sata_hba_inst, sata_device);
14547 if (rval != SATA_SUCCESS &&
14548 sata_device->satadev_state & SATA_PSTATE_FAILED) {
14549 cportinfo->cport_state = SATA_PSTATE_FAILED;
14550 rv = EIO;
14551 } else {
14552 cportinfo->cport_state |= SATA_PSTATE_SHUTDOWN;
14553 }
14554 mutex_exit(&cportinfo->cport_mutex);
14555
14556 return (rv);
14557 }
14558
14559 /*
14560 * Process non-port-multiplier device - it could be a drive connected
14561 * to a port multiplier port or a controller port.
14562 */
14563 if (qual == SATA_ADDR_PMPORT) {
14564 pmportinfo = SATA_PMPORT_INFO(sata_hba_inst, cport, pmport);
14565 mutex_enter(&pmportinfo->pmport_mutex);
14566 sata_update_pmport_info(sata_hba_inst, sata_device);
14567 if (rval != SATA_SUCCESS ||
14568 (sata_device->satadev_state & SATA_PSTATE_FAILED) != 0) {
14569 SATA_PMPORT_STATE(sata_hba_inst, cport, pmport) =
14570 SATA_PSTATE_FAILED;
14571 SATADBG2(SATA_DBG_IOCTL_IF, sata_hba_inst,
14572 "sata_hba_ioctl: connect: failed to deactivate "
14573 "SATA port %d:%d", cport, pmport);
14574 mutex_exit(&pmportinfo->pmport_mutex);
14575 return (EIO);
14576 }
14577
14578 if (pmportinfo->pmport_dev_type != SATA_DTYPE_NONE) {
14579 sdinfo = pmportinfo->pmport_sata_drive;
14580 ASSERT(sdinfo != NULL);
14581 }
14582
14583 /*
14584 * Set port's dev_state to not ready - this will disable
14585 * an access to a potentially attached device.
14586 */
14587 pmportinfo->pmport_state &= ~SATA_STATE_READY;
14588
14589 /* Remove and release sata_drive info structure. */
14590 if (sdinfo != NULL) {
14591 if ((sdinfo->satadrv_type &
14592 SATA_VALID_DEV_TYPE) != 0) {
14593 /*
14594 * If a target node exists, try to offline
14595 * a device and remove target node.
14596 */
14597 mutex_exit(&pmportinfo->pmport_mutex);
14598 (void) sata_offline_device(sata_hba_inst,
14599 sata_device, sdinfo);
14600 mutex_enter(&pmportinfo->pmport_mutex);
14601 }
14602
14603 SATA_PMPORTINFO_DRV_INFO(pmportinfo) = NULL;
14604 pmportinfo->pmport_dev_type = SATA_DTYPE_NONE;
14605 (void) kmem_free((void *)sdinfo,
14606 sizeof (sata_drive_info_t));
14607 }
14608 mutex_exit(&pmportinfo->pmport_mutex);
14609
14610 } else if (qual == SATA_ADDR_CPORT) {
14611 mutex_enter(&cportinfo->cport_mutex);
14612 sata_update_port_info(sata_hba_inst, sata_device);
14613 if (rval != SATA_SUCCESS ||
14614 (sata_device->satadev_state & SATA_PSTATE_FAILED) != 0) {
14615 /*
14616 * Device port status is unknown or it is in failed
14617 * state
14618 */
14619 SATA_CPORT_STATE(sata_hba_inst, cport) =
14620 SATA_PSTATE_FAILED;
14621 SATADBG1(SATA_DBG_IOCTL_IF, sata_hba_inst,
14622 "sata_hba_ioctl: connect: failed to deactivate "
14623 "SATA port %d", cport);
14624 mutex_exit(&cportinfo->cport_mutex);
14625 return (EIO);
14626 }
14627
14628 if (cportinfo->cport_dev_type == SATA_DTYPE_PMULT) {
14629 pmultinfo = SATA_CPORTINFO_PMULT_INFO(cportinfo);
14630 ASSERT(pmultinfo != NULL);
14631 } else if (cportinfo->cport_dev_type != SATA_DTYPE_NONE) {
14632 sdinfo = SATA_CPORTINFO_DRV_INFO(cportinfo);
14633 ASSERT(sdinfo != NULL);
14634 }
14635 cportinfo->cport_state &= ~SATA_STATE_READY;
14636
14637 if (sdinfo != NULL) {
14638 if ((sdinfo->satadrv_type &
14639 SATA_VALID_DEV_TYPE) != 0) {
14640 /*
14641 * If a target node exists, try to offline
14642 * a device and remove target node.
14643 */
14644 mutex_exit(&cportinfo->cport_mutex);
14645 (void) sata_offline_device(sata_hba_inst,
14646 sata_device, sdinfo);
14647 mutex_enter(&cportinfo->cport_mutex);
14648 }
14649
14650 SATA_CPORTINFO_DRV_INFO(cportinfo) = NULL;
14651 cportinfo->cport_dev_type = SATA_DTYPE_NONE;
14652 (void) kmem_free((void *)sdinfo,
14653 sizeof (sata_drive_info_t));
14654 }
14655 mutex_exit(&cportinfo->cport_mutex);
14656 }
14657
14658 /* Just ask HBA driver to deactivate port */
14659 sata_device->satadev_addr.qual = qual;
14660
14661 rval = (*SATA_PORT_DEACTIVATE_FUNC(sata_hba_inst))
14662 (SATA_DIP(sata_hba_inst), sata_device);
14663
14664 /*
14665 * Generate sysevent - EC_DR / ESC_DR_AP_STATE_CHANGE
14666 * without the hint (to force listener to investivate the state).
14667 */
14668 sata_gen_sysevent(sata_hba_inst, &sata_device->satadev_addr,
14669 SE_NO_HINT);
14670
14671 if (qual == SATA_ADDR_PMPORT) {
14672 mutex_enter(&pmportinfo->pmport_mutex);
14673 sata_update_pmport_info(sata_hba_inst, sata_device);
14674
14675 if (rval != SATA_SUCCESS &&
14676 sata_device->satadev_state & SATA_PSTATE_FAILED) {
14677 /*
14678 * Port deactivation failure - do not change port
14679 * state unless the state returned by HBA indicates a
14680 * port failure.
14681 *
14682 * NOTE: device structures were released, so devices
14683 * now are invisible! Port reset is needed to
14684 * re-enumerate devices.
14685 */
14686 pmportinfo->pmport_state = SATA_PSTATE_FAILED;
14687 rv = EIO;
14688 } else {
14689 /*
14690 * Deactivation succeded. From now on the sata framework
14691 * will not care what is happening to the device, until
14692 * the port is activated again.
14693 */
14694 pmportinfo->pmport_state |= SATA_PSTATE_SHUTDOWN;
14695 }
14696 mutex_exit(&pmportinfo->pmport_mutex);
14697 } else if (qual == SATA_ADDR_CPORT) {
14698 mutex_enter(&cportinfo->cport_mutex);
14699 sata_update_port_info(sata_hba_inst, sata_device);
14700
14701 if (rval != SATA_SUCCESS &&
14702 sata_device->satadev_state & SATA_PSTATE_FAILED) {
14703 cportinfo->cport_state = SATA_PSTATE_FAILED;
14704 rv = EIO;
14705 } else {
14706 cportinfo->cport_state |= SATA_PSTATE_SHUTDOWN;
14707 }
14708 mutex_exit(&cportinfo->cport_mutex);
14709 }
14710
14711 return (rv);
14712 }
14713
14714
14715
14716 /*
14717 * Process sata port connect request
14718 * The sata cfgadm pluging will invoke this operation only if port was found
14719 * in the disconnect state (failed state is also treated as the disconnected
14720 * state).
14721 * DEVCTL_AP_CONNECT would invoke sata_hba_inst->satahba_tran->
14722 * sata_tran_hotplug_ops->sata_tran_port_activate().
14723 * If successful and a device is found attached to the port,
14724 * the initialization sequence is executed to attach a device structure to
14725 * a port structure. The state of the port and a device would be set
14726 * appropriately.
14727 * The device is not set in configured state (system-wise) by this operation.
14728 *
14729 * Note, that activating the port may generate link events,
14730 * so it is important that following processing and the
14731 * event processing does not interfere with each other!
14732 *
14733 * This operation may remove port failed state and will
14734 * try to make port active and in good standing.
14735 *
14736 * NOTE: Port multiplier is supported.
14737 */
14738
14739 static int
14740 sata_ioctl_connect(sata_hba_inst_t *sata_hba_inst,
14741 sata_device_t *sata_device)
14742 {
14743 sata_pmport_info_t *pmportinfo = NULL;
14744 uint8_t cport, pmport, qual;
14745 int rv = 0;
14746
14747 cport = sata_device->satadev_addr.cport;
14748 pmport = sata_device->satadev_addr.pmport;
14749 qual = sata_device->satadev_addr.qual;
14750
14751 ASSERT(qual == SATA_ADDR_DCPORT || qual == SATA_ADDR_DPMPORT);
14752 if (qual == SATA_ADDR_DCPORT)
14753 qual = SATA_ADDR_CPORT;
14754 else
14755 qual = SATA_ADDR_PMPORT;
14756
14757 if (qual == SATA_ADDR_PMPORT)
14758 pmportinfo = SATA_PMPORT_INFO(sata_hba_inst, cport, pmport);
14759
14760 /*
14761 * DEVCTL_AP_CONNECT would invoke sata_hba_inst->
14762 * satahba_tran->sata_tran_hotplug_ops->sata_tran_port_activate().
14763 * Perform sanity check now.
14764 */
14765 if (SATA_PORT_ACTIVATE_FUNC(sata_hba_inst) == NULL) {
14766 /* No physical port activation supported. */
14767 return (EINVAL);
14768 }
14769
14770 /* Just ask HBA driver to activate port */
14771 if ((*SATA_PORT_ACTIVATE_FUNC(sata_hba_inst))
14772 (SATA_DIP(sata_hba_inst), sata_device) != SATA_SUCCESS) {
14773 /*
14774 * Port activation failure.
14775 */
14776 if (qual == SATA_ADDR_CPORT) {
14777 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst,
14778 cport)->cport_mutex);
14779 sata_update_port_info(sata_hba_inst, sata_device);
14780 if (sata_device->satadev_state & SATA_PSTATE_FAILED) {
14781 SATA_CPORT_STATE(sata_hba_inst, cport) =
14782 SATA_PSTATE_FAILED;
14783 SATADBG1(SATA_DBG_IOCTL_IF, sata_hba_inst,
14784 "sata_hba_ioctl: connect: failed to "
14785 "activate SATA port %d", cport);
14786 }
14787 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst,
14788 cport)->cport_mutex);
14789 } else { /* port multiplier device port */
14790 mutex_enter(&pmportinfo->pmport_mutex);
14791 sata_update_pmport_info(sata_hba_inst, sata_device);
14792 if (sata_device->satadev_state & SATA_PSTATE_FAILED) {
14793 SATA_PMPORT_STATE(sata_hba_inst, cport,
14794 pmport) = SATA_PSTATE_FAILED;
14795 SATADBG2(SATA_DBG_IOCTL_IF, sata_hba_inst,
14796 "sata_hba_ioctl: connect: failed to "
14797 "activate SATA port %d:%d", cport, pmport);
14798 }
14799 mutex_exit(&pmportinfo->pmport_mutex);
14800 }
14801 return (EIO);
14802 }
14803
14804 /* Virgin port state - will be updated by the port re-probe. */
14805 if (qual == SATA_ADDR_CPORT) {
14806 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst,
14807 cport)->cport_mutex);
14808 SATA_CPORT_STATE(sata_hba_inst, cport) = 0;
14809 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst,
14810 cport)->cport_mutex);
14811 } else { /* port multiplier device port */
14812 mutex_enter(&pmportinfo->pmport_mutex);
14813 SATA_PMPORT_STATE(sata_hba_inst, cport, pmport) = 0;
14814 mutex_exit(&pmportinfo->pmport_mutex);
14815 }
14816
14817 /*
14818 * Probe the port to find its state and attached device.
14819 */
14820 if (sata_reprobe_port(sata_hba_inst, sata_device,
14821 SATA_DEV_IDENTIFY_RETRY) == SATA_FAILURE)
14822 rv = EIO;
14823
14824 /*
14825 * Generate sysevent - EC_DR / ESC_DR_AP_STATE_CHANGE
14826 * without the hint
14827 */
14828 sata_gen_sysevent(sata_hba_inst, &sata_device->satadev_addr,
14829 SE_NO_HINT);
14830
14831 /*
14832 * If there is a device attached to the port, emit
14833 * a message.
14834 */
14835 if (sata_device->satadev_type != SATA_DTYPE_NONE) {
14836
14837 if (qual == SATA_ADDR_CPORT) {
14838 if (sata_device->satadev_type == SATA_DTYPE_PMULT) {
14839 sata_log(sata_hba_inst, CE_WARN,
14840 "SATA port multiplier detected "
14841 "at port %d", cport);
14842 } else {
14843 sata_log(sata_hba_inst, CE_WARN,
14844 "SATA device detected at port %d", cport);
14845 if (sata_device->satadev_type ==
14846 SATA_DTYPE_UNKNOWN) {
14847 /*
14848 * A device was not successfully identified
14849 */
14850 sata_log(sata_hba_inst, CE_WARN,
14851 "Could not identify SATA "
14852 "device at port %d", cport);
14853 }
14854 }
14855 } else { /* port multiplier device port */
14856 sata_log(sata_hba_inst, CE_WARN,
14857 "SATA device detected at port %d:%d",
14858 cport, pmport);
14859 if (sata_device->satadev_type == SATA_DTYPE_UNKNOWN) {
14860 /*
14861 * A device was not successfully identified
14862 */
14863 sata_log(sata_hba_inst, CE_WARN,
14864 "Could not identify SATA "
14865 "device at port %d:%d", cport, pmport);
14866 }
14867 }
14868 }
14869
14870 return (rv);
14871 }
14872
14873
14874 /*
14875 * Process sata device unconfigure request.
14876 * The unconfigure operation uses generic nexus operation to
14877 * offline a device. It leaves a target device node attached.
14878 * and obviously sata_drive_info attached as well, because
14879 * from the hardware point of view nothing has changed.
14880 */
14881 static int
14882 sata_ioctl_unconfigure(sata_hba_inst_t *sata_hba_inst,
14883 sata_device_t *sata_device)
14884 {
14885 int rv = 0;
14886 dev_info_t *tdip;
14887
14888 /* We are addressing attached device, not a port */
14889 if (sata_device->satadev_addr.qual == SATA_ADDR_CPORT)
14890 sata_device->satadev_addr.qual = SATA_ADDR_DCPORT;
14891 else if (sata_device->satadev_addr.qual == SATA_ADDR_PMPORT)
14892 sata_device->satadev_addr.qual = SATA_ADDR_DPMPORT;
14893
14894 if ((tdip = sata_get_scsi_target_dip(SATA_DIP(sata_hba_inst),
14895 &sata_device->satadev_addr)) != NULL) {
14896
14897 if (ndi_devi_offline(tdip, NDI_UNCONFIG) != NDI_SUCCESS) {
14898 SATA_LOG_D((sata_hba_inst, CE_WARN,
14899 "sata_hba_ioctl: unconfigure: "
14900 "failed to unconfigure device at SATA port %d:%d",
14901 sata_device->satadev_addr.cport,
14902 sata_device->satadev_addr.pmport));
14903 rv = EIO;
14904 }
14905 /*
14906 * The target node devi_state should be marked with
14907 * DEVI_DEVICE_OFFLINE by ndi_devi_offline().
14908 * This would be the indication for cfgadm that
14909 * the AP node occupant state is 'unconfigured'.
14910 */
14911
14912 } else {
14913 /*
14914 * This would indicate a failure on the part of cfgadm
14915 * to detect correct state of the node prior to this
14916 * call - one cannot unconfigure non-existing device.
14917 */
14918 SATA_LOG_D((sata_hba_inst, CE_WARN,
14919 "sata_hba_ioctl: unconfigure: "
14920 "attempt to unconfigure non-existing device "
14921 "at SATA port %d:%d",
14922 sata_device->satadev_addr.cport,
14923 sata_device->satadev_addr.pmport));
14924 rv = ENXIO;
14925 }
14926 return (rv);
14927 }
14928
14929 /*
14930 * Process sata device configure request
14931 * If port is in a failed state, operation is aborted - one has to use
14932 * an explicit connect or port activate request to try to get a port into
14933 * non-failed mode. Port reset wil also work in such situation.
14934 * If the port is in disconnected (shutdown) state, the connect operation is
14935 * attempted prior to any other action.
14936 * When port is in the active state, there is a device attached and the target
14937 * node exists, a device was most likely offlined.
14938 * If target node does not exist, a new target node is created. In both cases
14939 * an attempt is made to online (configure) the device.
14940 *
14941 * NOTE: Port multiplier is supported.
14942 */
14943 static int
14944 sata_ioctl_configure(sata_hba_inst_t *sata_hba_inst,
14945 sata_device_t *sata_device)
14946 {
14947 int cport, pmport, qual;
14948 int rval;
14949 boolean_t target = B_TRUE;
14950 sata_cport_info_t *cportinfo;
14951 sata_pmport_info_t *pmportinfo = NULL;
14952 dev_info_t *tdip;
14953 sata_drive_info_t *sdinfo;
14954
14955 cport = sata_device->satadev_addr.cport;
14956 pmport = sata_device->satadev_addr.pmport;
14957 qual = sata_device->satadev_addr.qual;
14958
14959 /* Get current port state */
14960 rval = (*SATA_PROBE_PORT_FUNC(sata_hba_inst))
14961 (SATA_DIP(sata_hba_inst), sata_device);
14962
14963 cportinfo = SATA_CPORT_INFO(sata_hba_inst, cport);
14964 if (qual == SATA_ADDR_DPMPORT) {
14965 pmportinfo = SATA_PMPORT_INFO(sata_hba_inst, cport, pmport);
14966 mutex_enter(&pmportinfo->pmport_mutex);
14967 sata_update_pmport_info(sata_hba_inst, sata_device);
14968 if (rval != SATA_SUCCESS ||
14969 (sata_device->satadev_state & SATA_PSTATE_FAILED) != 0) {
14970 /*
14971 * Obviously, device on a failed port is not visible
14972 */
14973 mutex_exit(&pmportinfo->pmport_mutex);
14974 return (ENXIO);
14975 }
14976 mutex_exit(&pmportinfo->pmport_mutex);
14977 } else {
14978 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst,
14979 cport)->cport_mutex);
14980 sata_update_port_info(sata_hba_inst, sata_device);
14981 if (rval != SATA_SUCCESS ||
14982 (sata_device->satadev_state & SATA_PSTATE_FAILED) != 0) {
14983 /*
14984 * Obviously, device on a failed port is not visible
14985 */
14986 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst,
14987 cport)->cport_mutex);
14988 return (ENXIO);
14989 }
14990 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst,
14991 cport)->cport_mutex);
14992 }
14993
14994 if ((sata_device->satadev_state & SATA_PSTATE_SHUTDOWN) != 0) {
14995 /* need to activate port */
14996 target = B_FALSE;
14997
14998 /* Sanity check */
14999 if (SATA_PORT_ACTIVATE_FUNC(sata_hba_inst) == NULL)
15000 return (ENXIO);
15001
15002 /* Just let HBA driver to activate port */
15003 if ((*SATA_PORT_ACTIVATE_FUNC(sata_hba_inst))
15004 (SATA_DIP(sata_hba_inst), sata_device) != SATA_SUCCESS) {
15005 /*
15006 * Port activation failure - do not change port state
15007 * unless the state returned by HBA indicates a port
15008 * failure.
15009 */
15010 if (qual == SATA_ADDR_DPMPORT) {
15011 mutex_enter(&pmportinfo->pmport_mutex);
15012 sata_update_pmport_info(sata_hba_inst,
15013 sata_device);
15014 if (sata_device->satadev_state &
15015 SATA_PSTATE_FAILED)
15016 pmportinfo->pmport_state =
15017 SATA_PSTATE_FAILED;
15018 mutex_exit(&pmportinfo->pmport_mutex);
15019 } else {
15020 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst,
15021 cport)->cport_mutex);
15022 sata_update_port_info(sata_hba_inst,
15023 sata_device);
15024 if (sata_device->satadev_state &
15025 SATA_PSTATE_FAILED)
15026 cportinfo->cport_state =
15027 SATA_PSTATE_FAILED;
15028 mutex_exit(&SATA_CPORT_INFO(
15029 sata_hba_inst, cport)->cport_mutex);
15030 }
15031 }
15032 SATA_LOG_D((sata_hba_inst, CE_WARN,
15033 "sata_hba_ioctl: configure: "
15034 "failed to activate SATA port %d:%d",
15035 cport, pmport));
15036 return (EIO);
15037 }
15038 /*
15039 * Generate sysevent - EC_DR / ESC_DR_AP_STATE_CHANGE
15040 * without the hint.
15041 */
15042 sata_gen_sysevent(sata_hba_inst,
15043 &sata_device->satadev_addr, SE_NO_HINT);
15044
15045 /* Virgin port state */
15046 if (qual == SATA_ADDR_DPMPORT) {
15047 mutex_enter(&pmportinfo->pmport_mutex);
15048 pmportinfo->pmport_state = 0;
15049 mutex_exit(&pmportinfo->pmport_mutex);
15050 } else {
15051 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst,
15052 cport)-> cport_mutex);
15053 cportinfo->cport_state = 0;
15054 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst,
15055 cport)->cport_mutex);
15056 }
15057 /*
15058 * Always reprobe port, to get current device info.
15059 */
15060 if (sata_reprobe_port(sata_hba_inst, sata_device,
15061 SATA_DEV_IDENTIFY_RETRY) != SATA_SUCCESS)
15062 return (EIO);
15063
15064 if (sata_device->satadev_type != SATA_DTYPE_NONE && target == B_FALSE) {
15065 if (qual == SATA_ADDR_DPMPORT) {
15066 /*
15067 * That's the transition from "inactive" port
15068 * to active one with device attached.
15069 */
15070 sata_log(sata_hba_inst, CE_WARN,
15071 "SATA device detected at port %d:%d",
15072 cport, pmport);
15073 } else {
15074 /*
15075 * When PM is attached to the cport and cport is
15076 * activated, every PM device port needs to be reprobed.
15077 * We need to emit message for all devices detected
15078 * at port multiplier's device ports.
15079 * Add such code here.
15080 * For now, just inform about device attached to
15081 * cport.
15082 */
15083 sata_log(sata_hba_inst, CE_WARN,
15084 "SATA device detected at port %d", cport);
15085 }
15086 }
15087
15088 /*
15089 * This is where real configuration operation starts.
15090 *
15091 * When PM is attached to the cport and cport is activated,
15092 * devices attached PM device ports may have to be configured
15093 * explicitly. This may change when port multiplier is supported.
15094 * For now, configure only disks and other valid target devices.
15095 */
15096 if (!(sata_device->satadev_type & SATA_VALID_DEV_TYPE)) {
15097 if (qual == SATA_ADDR_DCPORT) {
15098 if (sata_device->satadev_type == SATA_DTYPE_UNKNOWN) {
15099 /*
15100 * A device was not successfully identified
15101 */
15102 sata_log(sata_hba_inst, CE_WARN,
15103 "Could not identify SATA "
15104 "device at port %d", cport);
15105 }
15106 } else { /* port multiplier device port */
15107 if (sata_device->satadev_type == SATA_DTYPE_UNKNOWN) {
15108 /*
15109 * A device was not successfully identified
15110 */
15111 sata_log(sata_hba_inst, CE_WARN,
15112 "Could not identify SATA "
15113 "device at port %d:%d", cport, pmport);
15114 }
15115 }
15116 return (ENXIO); /* No device to configure */
15117 }
15118
15119 /*
15120 * Here we may have a device in reset condition,
15121 * but because we are just configuring it, there is
15122 * no need to process the reset other than just
15123 * to clear device reset condition in the HBA driver.
15124 * Setting the flag SATA_EVNT_CLEAR_DEVICE_RESET will
15125 * cause a first command sent the HBA driver with the request
15126 * to clear device reset condition.
15127 */
15128 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex);
15129 if (qual == SATA_ADDR_DPMPORT)
15130 sata_device->satadev_addr.qual = SATA_ADDR_DPMPORT;
15131 else
15132 sata_device->satadev_addr.qual = SATA_ADDR_DCPORT;
15133 sdinfo = sata_get_device_info(sata_hba_inst, sata_device);
15134 if (sdinfo == NULL) {
15135 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex);
15136 return (ENXIO);
15137 }
15138 if (sdinfo->satadrv_event_flags &
15139 (SATA_EVNT_DEVICE_RESET | SATA_EVNT_INPROC_DEVICE_RESET)) {
15140 sdinfo->satadrv_event_flags = 0;
15141 }
15142 sdinfo->satadrv_event_flags |= SATA_EVNT_CLEAR_DEVICE_RESET;
15143 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex);
15144
15145 if ((tdip = sata_get_scsi_target_dip(SATA_DIP(sata_hba_inst),
15146 &sata_device->satadev_addr)) != NULL) {
15147 /*
15148 * Target node exists. Verify, that it belongs
15149 * to existing, attached device and not to
15150 * a removed device.
15151 */
15152 if (sata_check_device_removed(tdip) == B_TRUE) {
15153 if (qual == SATA_ADDR_DPMPORT)
15154 sata_log(sata_hba_inst, CE_WARN,
15155 "SATA device at port %d cannot be "
15156 "configured. "
15157 "Application(s) accessing "
15158 "previously attached device "
15159 "have to release it before newly "
15160 "inserted device can be made accessible.",
15161 cport);
15162 else
15163 sata_log(sata_hba_inst, CE_WARN,
15164 "SATA device at port %d:%d cannot be"
15165 "configured. "
15166 "Application(s) accessing "
15167 "previously attached device "
15168 "have to release it before newly "
15169 "inserted device can be made accessible.",
15170 cport, pmport);
15171 return (EIO);
15172 }
15173 /*
15174 * Device was not removed and re-inserted.
15175 * Try to online it.
15176 */
15177 if (ndi_devi_online(tdip, 0) != NDI_SUCCESS) {
15178 SATA_LOG_D((sata_hba_inst, CE_WARN,
15179 "sata_hba_ioctl: configure: "
15180 "onlining device at SATA port "
15181 "%d:%d failed", cport, pmport));
15182 return (EIO);
15183 }
15184
15185 if (qual == SATA_ADDR_DPMPORT) {
15186 mutex_enter(&pmportinfo->pmport_mutex);
15187 pmportinfo->pmport_tgtnode_clean = B_TRUE;
15188 mutex_exit(&pmportinfo->pmport_mutex);
15189 } else {
15190 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst,
15191 cport)->cport_mutex);
15192 cportinfo-> cport_tgtnode_clean = B_TRUE;
15193 mutex_exit(&SATA_CPORT_INFO(
15194 sata_hba_inst, cport)->cport_mutex);
15195 }
15196 } else {
15197 /*
15198 * No target node - need to create a new target node.
15199 */
15200 if (qual == SATA_ADDR_DPMPORT) {
15201 mutex_enter(&pmportinfo->pmport_mutex);
15202 pmportinfo->pmport_tgtnode_clean = B_TRUE;
15203 mutex_exit(&pmportinfo->pmport_mutex);
15204 } else {
15205 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, cport)->
15206 cport_mutex);
15207 cportinfo-> cport_tgtnode_clean = B_TRUE;
15208 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)->
15209 cport_mutex);
15210 }
15211
15212 tdip = sata_create_target_node(SATA_DIP(sata_hba_inst),
15213 sata_hba_inst, &sata_device->satadev_addr);
15214 if (tdip == NULL) {
15215 /* Configure operation failed */
15216 SATA_LOG_D((sata_hba_inst, CE_WARN,
15217 "sata_hba_ioctl: configure: "
15218 "configuring SATA device at port %d:%d "
15219 "failed", cport, pmport));
15220 return (EIO);
15221 }
15222 }
15223 return (0);
15224 }
15225
15226
15227 /*
15228 * Process ioctl deactivate port request.
15229 * Arbitrarily unconfigure attached device, if any.
15230 * Even if the unconfigure fails, proceed with the
15231 * port deactivation.
15232 *
15233 * NOTE: Port Multiplier is supported now.
15234 */
15235
15236 static int
15237 sata_ioctl_deactivate(sata_hba_inst_t *sata_hba_inst,
15238 sata_device_t *sata_device)
15239 {
15240 int cport, pmport, qual;
15241 int rval, rv = 0;
15242 int npmport;
15243 sata_cport_info_t *cportinfo;
15244 sata_pmport_info_t *pmportinfo;
15245 sata_pmult_info_t *pmultinfo;
15246 dev_info_t *tdip;
15247 sata_drive_info_t *sdinfo = NULL;
15248 sata_device_t subsdevice;
15249
15250 /* Sanity check */
15251 if (SATA_PORT_DEACTIVATE_FUNC(sata_hba_inst) == NULL)
15252 return (ENOTSUP);
15253
15254 cport = sata_device->satadev_addr.cport;
15255 pmport = sata_device->satadev_addr.pmport;
15256 qual = sata_device->satadev_addr.qual;
15257
15258 /* SCSI_TO_SATA_ADDR_QUAL() translate ap_id into a device qualifier */
15259 ASSERT(qual == SATA_ADDR_DCPORT || qual == SATA_ADDR_DPMPORT);
15260 if (qual == SATA_ADDR_DCPORT)
15261 qual = SATA_ADDR_CPORT;
15262 else
15263 qual = SATA_ADDR_PMPORT;
15264
15265 cportinfo = SATA_CPORT_INFO(sata_hba_inst, cport);
15266 if (qual == SATA_ADDR_PMPORT)
15267 pmportinfo = SATA_PMPORT_INFO(sata_hba_inst, cport, pmport);
15268
15269 /*
15270 * Processing port multiplier
15271 */
15272 if (qual == SATA_ADDR_CPORT &&
15273 SATA_CPORT_DEV_TYPE(sata_hba_inst, cport) == SATA_DTYPE_PMULT) {
15274 mutex_enter(&cportinfo->cport_mutex);
15275
15276 /* Deactivate all sub-deices */
15277 pmultinfo = SATA_CPORTINFO_PMULT_INFO(cportinfo);
15278 if (pmultinfo != NULL) {
15279 for (npmport = 0; npmport < SATA_NUM_PMPORTS(
15280 sata_hba_inst, cport); npmport++) {
15281
15282 subsdevice.satadev_addr.cport = cport;
15283 subsdevice.satadev_addr.pmport =
15284 (uint8_t)npmport;
15285 subsdevice.satadev_addr.qual =
15286 SATA_ADDR_DPMPORT;
15287
15288 SATADBG2(SATA_DBG_PMULT, sata_hba_inst,
15289 "sata_hba_ioctl: deactivate: trying to "
15290 "deactivate SATA port %d:%d",
15291 cport, npmport);
15292
15293 mutex_exit(&cportinfo->cport_mutex);
15294 if (sata_ioctl_deactivate(sata_hba_inst,
15295 &subsdevice) == SATA_SUCCESS) {
15296 SATADBG2(SATA_DBG_PMULT, sata_hba_inst,
15297 "[Deactivate] device at port %d:%d "
15298 "successfully.", cport, npmport);
15299 }
15300 mutex_enter(&cportinfo->cport_mutex);
15301 }
15302 }
15303
15304 /* Deactivate the port multiplier now. */
15305 cportinfo->cport_state &= ~SATA_STATE_READY;
15306 mutex_exit(&cportinfo->cport_mutex);
15307
15308 sata_device->satadev_addr.qual = qual;
15309 rval = (*SATA_PORT_DEACTIVATE_FUNC(sata_hba_inst))
15310 (SATA_DIP(sata_hba_inst), sata_device);
15311
15312 sata_gen_sysevent(sata_hba_inst, &sata_device->satadev_addr,
15313 SE_NO_HINT);
15314
15315 mutex_enter(&cportinfo->cport_mutex);
15316 sata_update_port_info(sata_hba_inst, sata_device);
15317 if (rval != SATA_SUCCESS) {
15318 if (sata_device->satadev_state & SATA_PSTATE_FAILED) {
15319 cportinfo->cport_state = SATA_PSTATE_FAILED;
15320 }
15321 rv = EIO;
15322 } else {
15323 cportinfo->cport_state |= SATA_PSTATE_SHUTDOWN;
15324 }
15325 mutex_exit(&cportinfo->cport_mutex);
15326
15327 return (rv);
15328 }
15329
15330 /*
15331 * Process non-port-multiplier device - it could be a drive connected
15332 * to a port multiplier port or a controller port.
15333 */
15334 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex);
15335 if (qual == SATA_ADDR_CPORT) {
15336 sata_device->satadev_addr.qual = SATA_ADDR_DCPORT;
15337 if (cportinfo->cport_dev_type != SATA_DTYPE_NONE) {
15338 /* deal only with valid devices */
15339 if ((cportinfo->cport_dev_type &
15340 SATA_VALID_DEV_TYPE) != 0)
15341 sdinfo = SATA_CPORTINFO_DRV_INFO(cportinfo);
15342 }
15343 cportinfo->cport_state &= ~SATA_STATE_READY;
15344 } else {
15345 /* Port multiplier device port */
15346 mutex_enter(&pmportinfo->pmport_mutex);
15347 sata_device->satadev_addr.qual = SATA_ADDR_DPMPORT;
15348 if (pmportinfo->pmport_dev_type != SATA_DTYPE_NONE &&
15349 (pmportinfo->pmport_dev_type & SATA_VALID_DEV_TYPE) != 0)
15350 sdinfo = SATA_PMPORTINFO_DRV_INFO(pmportinfo);
15351 pmportinfo->pmport_state &= ~SATA_STATE_READY;
15352 mutex_exit(&pmportinfo->pmport_mutex);
15353 }
15354
15355 if (sdinfo != NULL) {
15356 /*
15357 * If a target node exists, try to offline a device and
15358 * to remove a target node.
15359 */
15360 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)->
15361 cport_mutex);
15362 tdip = sata_get_scsi_target_dip(SATA_DIP(sata_hba_inst),
15363 &sata_device->satadev_addr);
15364 if (tdip != NULL) {
15365 /* target node exist */
15366 SATADBG1(SATA_DBG_IOCTL_IF, sata_hba_inst,
15367 "sata_hba_ioctl: port deactivate: "
15368 "target node exists.", NULL);
15369
15370 if (ndi_devi_offline(tdip, NDI_DEVI_REMOVE) !=
15371 NDI_SUCCESS) {
15372 SATA_LOG_D((sata_hba_inst, CE_WARN,
15373 "sata_hba_ioctl: port deactivate: "
15374 "failed to unconfigure device at port "
15375 "%d:%d before deactivating the port",
15376 cport, pmport));
15377 /*
15378 * Set DEVICE REMOVED state in the target
15379 * node. It will prevent an access to
15380 * the device even when a new device is
15381 * attached, until the old target node is
15382 * released, removed and recreated for a new
15383 * device.
15384 */
15385 sata_set_device_removed(tdip);
15386
15387 /*
15388 * Instruct the event daemon to try the
15389 * target node cleanup later.
15390 */
15391 sata_set_target_node_cleanup(sata_hba_inst,
15392 &sata_device->satadev_addr);
15393 }
15394 }
15395 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, cport)->
15396 cport_mutex);
15397 /*
15398 * In any case, remove and release sata_drive_info
15399 * structure.
15400 */
15401 if (qual == SATA_ADDR_CPORT) {
15402 SATA_CPORTINFO_DRV_INFO(cportinfo) = NULL;
15403 cportinfo->cport_dev_type = SATA_DTYPE_NONE;
15404 } else { /* port multiplier device port */
15405 mutex_enter(&pmportinfo->pmport_mutex);
15406 SATA_PMPORTINFO_DRV_INFO(pmportinfo) = NULL;
15407 pmportinfo->pmport_dev_type = SATA_DTYPE_NONE;
15408 mutex_exit(&pmportinfo->pmport_mutex);
15409 }
15410 (void) kmem_free((void *)sdinfo, sizeof (sata_drive_info_t));
15411 }
15412
15413 if (qual == SATA_ADDR_CPORT) {
15414 cportinfo->cport_state &= ~(SATA_STATE_PROBED |
15415 SATA_STATE_PROBING);
15416 } else if (qual == SATA_ADDR_PMPORT) {
15417 mutex_enter(&pmportinfo->pmport_mutex);
15418 pmportinfo->pmport_state &= ~(SATA_STATE_PROBED |
15419 SATA_STATE_PROBING);
15420 mutex_exit(&pmportinfo->pmport_mutex);
15421 }
15422 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex);
15423
15424 /* Just let HBA driver to deactivate port */
15425 sata_device->satadev_addr.qual = qual;
15426 rval = (*SATA_PORT_DEACTIVATE_FUNC(sata_hba_inst))
15427 (SATA_DIP(sata_hba_inst), sata_device);
15428
15429 /*
15430 * Generate sysevent - EC_DR / ESC_DR_AP_STATE_CHANGE
15431 * without the hint
15432 */
15433 sata_gen_sysevent(sata_hba_inst, &sata_device->satadev_addr,
15434 SE_NO_HINT);
15435
15436 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex);
15437 sata_update_port_info(sata_hba_inst, sata_device);
15438 if (qual == SATA_ADDR_CPORT) {
15439 if (rval != SATA_SUCCESS) {
15440 /*
15441 * Port deactivation failure - do not change port state
15442 * unless the state returned by HBA indicates a port
15443 * failure.
15444 */
15445 if (sata_device->satadev_state & SATA_PSTATE_FAILED) {
15446 SATA_CPORT_STATE(sata_hba_inst, cport) =
15447 SATA_PSTATE_FAILED;
15448 }
15449 SATA_LOG_D((sata_hba_inst, CE_WARN,
15450 "sata_hba_ioctl: port deactivate: "
15451 "cannot deactivate SATA port %d", cport));
15452 rv = EIO;
15453 } else {
15454 cportinfo->cport_state |= SATA_PSTATE_SHUTDOWN;
15455 }
15456 } else {
15457 mutex_enter(&pmportinfo->pmport_mutex);
15458 if (rval != SATA_SUCCESS) {
15459 if (sata_device->satadev_state & SATA_PSTATE_FAILED) {
15460 SATA_PMPORT_STATE(sata_hba_inst, cport,
15461 pmport) = SATA_PSTATE_FAILED;
15462 }
15463 SATA_LOG_D((sata_hba_inst, CE_WARN,
15464 "sata_hba_ioctl: port deactivate: "
15465 "cannot deactivate SATA port %d:%d",
15466 cport, pmport));
15467 rv = EIO;
15468 } else {
15469 pmportinfo->pmport_state |= SATA_PSTATE_SHUTDOWN;
15470 }
15471 mutex_exit(&pmportinfo->pmport_mutex);
15472 }
15473
15474 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex);
15475
15476 return (rv);
15477 }
15478
15479 /*
15480 * Process ioctl port activate request.
15481 *
15482 * NOTE: Port multiplier is supported now.
15483 */
15484 static int
15485 sata_ioctl_activate(sata_hba_inst_t *sata_hba_inst,
15486 sata_device_t *sata_device)
15487 {
15488 int cport, pmport, qual;
15489 sata_cport_info_t *cportinfo;
15490 sata_pmport_info_t *pmportinfo = NULL;
15491 boolean_t dev_existed = B_TRUE;
15492
15493 /* Sanity check */
15494 if (SATA_PORT_ACTIVATE_FUNC(sata_hba_inst) == NULL)
15495 return (ENOTSUP);
15496
15497 cport = sata_device->satadev_addr.cport;
15498 pmport = sata_device->satadev_addr.pmport;
15499 qual = sata_device->satadev_addr.qual;
15500
15501 cportinfo = SATA_CPORT_INFO(sata_hba_inst, cport);
15502
15503 /*
15504 * The qual translate from ap_id (by SCSI_TO_SATA_ADDR_QUAL())
15505 * is a device. But what we are dealing with is port/pmport.
15506 */
15507 ASSERT(qual == SATA_ADDR_DCPORT || qual == SATA_ADDR_DPMPORT);
15508 if (qual == SATA_ADDR_DCPORT)
15509 sata_device->satadev_addr.qual = qual = SATA_ADDR_CPORT;
15510 else
15511 sata_device->satadev_addr.qual = qual = SATA_ADDR_PMPORT;
15512
15513 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex);
15514 if (qual == SATA_ADDR_PMPORT) {
15515 pmportinfo = SATA_PMPORT_INFO(sata_hba_inst, cport, pmport);
15516 if (pmportinfo->pmport_state & SATA_PSTATE_SHUTDOWN ||
15517 pmportinfo->pmport_dev_type == SATA_DTYPE_NONE)
15518 dev_existed = B_FALSE;
15519 } else { /* cport */
15520 if (cportinfo->cport_state & SATA_PSTATE_SHUTDOWN ||
15521 cportinfo->cport_dev_type == SATA_DTYPE_NONE)
15522 dev_existed = B_FALSE;
15523 }
15524 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex);
15525
15526 /* Just let HBA driver to activate port, if necessary */
15527 if ((*SATA_PORT_ACTIVATE_FUNC(sata_hba_inst))
15528 (SATA_DIP(sata_hba_inst), sata_device) != SATA_SUCCESS) {
15529 /*
15530 * Port activation failure - do not change port state unless
15531 * the state returned by HBA indicates a port failure.
15532 */
15533 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst,
15534 cport)->cport_mutex);
15535 sata_update_port_info(sata_hba_inst, sata_device);
15536 if (sata_device->satadev_state & SATA_PSTATE_FAILED) {
15537 if (qual == SATA_ADDR_PMPORT) {
15538 mutex_enter(&pmportinfo->pmport_mutex);
15539 pmportinfo->pmport_state = SATA_PSTATE_FAILED;
15540 mutex_exit(&pmportinfo->pmport_mutex);
15541 } else
15542 cportinfo->cport_state = SATA_PSTATE_FAILED;
15543
15544 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst,
15545 cport)->cport_mutex);
15546 SATA_LOG_D((sata_hba_inst, CE_WARN,
15547 "sata_hba_ioctl: port activate: cannot activate "
15548 "SATA port %d:%d", cport, pmport));
15549 return (EIO);
15550 }
15551 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex);
15552 }
15553 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex);
15554 if (qual == SATA_ADDR_PMPORT) {
15555 mutex_enter(&pmportinfo->pmport_mutex);
15556 pmportinfo->pmport_state &= ~SATA_PSTATE_SHUTDOWN;
15557 mutex_exit(&pmportinfo->pmport_mutex);
15558 } else
15559 cportinfo->cport_state &= ~SATA_PSTATE_SHUTDOWN;
15560 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex);
15561
15562 /*
15563 * Re-probe port to find its current state and possibly attached device.
15564 * Port re-probing may change the cportinfo device type if device is
15565 * found attached.
15566 * If port probing failed, the device type would be set to
15567 * SATA_DTYPE_NONE.
15568 */
15569 (void) sata_reprobe_port(sata_hba_inst, sata_device,
15570 SATA_DEV_IDENTIFY_RETRY);
15571
15572 /*
15573 * Generate sysevent - EC_DR / ESC_DR_AP_STATE_CHANGE
15574 * without the hint.
15575 */
15576 sata_gen_sysevent(sata_hba_inst, &sata_device->satadev_addr,
15577 SE_NO_HINT);
15578
15579 if (dev_existed == B_FALSE) {
15580 if (qual == SATA_ADDR_PMPORT &&
15581 pmportinfo->pmport_dev_type != SATA_DTYPE_NONE) {
15582 /*
15583 * That's the transition from the "inactive" port state
15584 * or the active port without a device attached to the
15585 * active port state with a device attached.
15586 */
15587 sata_log(sata_hba_inst, CE_WARN,
15588 "SATA device detected at port %d:%d",
15589 cport, pmport);
15590 } else if (qual == SATA_ADDR_CPORT &&
15591 cportinfo->cport_dev_type != SATA_DTYPE_NONE) {
15592 /*
15593 * That's the transition from the "inactive" port state
15594 * or the active port without a device attached to the
15595 * active port state with a device attached.
15596 */
15597 if (cportinfo->cport_dev_type != SATA_DTYPE_PMULT) {
15598 sata_log(sata_hba_inst, CE_WARN,
15599 "SATA device detected at port %d", cport);
15600 } else {
15601 sata_log(sata_hba_inst, CE_WARN,
15602 "SATA port multiplier detected at port %d",
15603 cport);
15604 }
15605 }
15606 }
15607 return (0);
15608 }
15609
15610
15611
15612 /*
15613 * Process ioctl reset port request.
15614 *
15615 * NOTE: Port-Multiplier is supported.
15616 */
15617 static int
15618 sata_ioctl_reset_port(sata_hba_inst_t *sata_hba_inst,
15619 sata_device_t *sata_device)
15620 {
15621 int cport, pmport, qual;
15622 int rv = 0;
15623
15624 cport = sata_device->satadev_addr.cport;
15625 pmport = sata_device->satadev_addr.pmport;
15626 qual = sata_device->satadev_addr.qual;
15627
15628 /*
15629 * The qual translate from ap_id (by SCSI_TO_SATA_ADDR_QUAL())
15630 * is a device. But what we are dealing with is port/pmport.
15631 */
15632 if (qual == SATA_ADDR_DCPORT)
15633 sata_device->satadev_addr.qual = qual = SATA_ADDR_CPORT;
15634 else
15635 sata_device->satadev_addr.qual = qual = SATA_ADDR_PMPORT;
15636 ASSERT(qual == SATA_ADDR_CPORT || qual == SATA_ADDR_PMPORT);
15637
15638 /* Sanity check */
15639 if (SATA_RESET_DPORT_FUNC(sata_hba_inst) == NULL) {
15640 SATA_LOG_D((sata_hba_inst, CE_WARN,
15641 "sata_hba_ioctl: sata_hba_tran missing required "
15642 "function sata_tran_reset_dport"));
15643 return (ENOTSUP);
15644 }
15645
15646 /* Ask HBA to reset port */
15647 if ((*SATA_RESET_DPORT_FUNC(sata_hba_inst))(SATA_DIP(sata_hba_inst),
15648 sata_device) != SATA_SUCCESS) {
15649 SATA_LOG_D((sata_hba_inst, CE_WARN,
15650 "sata_hba_ioctl: reset port: failed %d:%d",
15651 cport, pmport));
15652 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, cport)->
15653 cport_mutex);
15654 sata_update_port_info(sata_hba_inst, sata_device);
15655 if (qual == SATA_ADDR_CPORT)
15656 SATA_CPORT_STATE(sata_hba_inst, cport) =
15657 SATA_PSTATE_FAILED;
15658 else {
15659 mutex_enter(&SATA_PMPORT_MUTEX(sata_hba_inst, cport,
15660 pmport));
15661 SATA_PMPORT_STATE(sata_hba_inst, cport, pmport) =
15662 SATA_PSTATE_FAILED;
15663 mutex_exit(&SATA_PMPORT_MUTEX(sata_hba_inst, cport,
15664 pmport));
15665 }
15666 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)->
15667 cport_mutex);
15668 rv = EIO;
15669 }
15670
15671 return (rv);
15672 }
15673
15674 /*
15675 * Process ioctl reset device request.
15676 *
15677 * NOTE: Port multiplier is supported.
15678 */
15679 static int
15680 sata_ioctl_reset_device(sata_hba_inst_t *sata_hba_inst,
15681 sata_device_t *sata_device)
15682 {
15683 sata_drive_info_t *sdinfo = NULL;
15684 sata_pmult_info_t *pmultinfo = NULL;
15685 int cport, pmport;
15686 int rv = 0;
15687
15688 /* Sanity check */
15689 if (SATA_RESET_DPORT_FUNC(sata_hba_inst) == NULL) {
15690 SATA_LOG_D((sata_hba_inst, CE_WARN,
15691 "sata_hba_ioctl: sata_hba_tran missing required "
15692 "function sata_tran_reset_dport"));
15693 return (ENOTSUP);
15694 }
15695
15696 cport = sata_device->satadev_addr.cport;
15697 pmport = sata_device->satadev_addr.pmport;
15698
15699 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex);
15700 if (sata_device->satadev_addr.qual == SATA_ADDR_DCPORT) {
15701 if (SATA_CPORT_DEV_TYPE(sata_hba_inst, cport) ==
15702 SATA_DTYPE_PMULT)
15703 pmultinfo = SATA_CPORT_INFO(sata_hba_inst, cport)->
15704 cport_devp.cport_sata_pmult;
15705 else
15706 sdinfo = SATA_CPORT_DRV_INFO(sata_hba_inst,
15707 sata_device->satadev_addr.cport);
15708 } else { /* port multiplier */
15709 sata_device->satadev_addr.qual = SATA_ADDR_DPMPORT;
15710 sdinfo = SATA_PMPORT_DRV_INFO(sata_hba_inst,
15711 sata_device->satadev_addr.cport,
15712 sata_device->satadev_addr.pmport);
15713 }
15714 if (sdinfo == NULL && pmultinfo == NULL) {
15715 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex);
15716 return (EINVAL);
15717 }
15718 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex);
15719
15720 /* Ask HBA to reset device */
15721 if ((*SATA_RESET_DPORT_FUNC(sata_hba_inst))
15722 (SATA_DIP(sata_hba_inst), sata_device) != SATA_SUCCESS) {
15723 SATA_LOG_D((sata_hba_inst, CE_WARN,
15724 "sata_hba_ioctl: reset device: failed at port %d:%d",
15725 cport, pmport));
15726 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, cport)->
15727 cport_mutex);
15728 sata_update_port_info(sata_hba_inst, sata_device);
15729 /*
15730 * Device info structure remains attached. Another device reset
15731 * or port disconnect/connect and re-probing is
15732 * needed to change it's state
15733 */
15734 if (sdinfo != NULL) {
15735 sdinfo->satadrv_state &= ~SATA_STATE_READY;
15736 sdinfo->satadrv_state |= SATA_DSTATE_FAILED;
15737 } else if (pmultinfo != NULL) {
15738 pmultinfo->pmult_state &= ~SATA_STATE_READY;
15739 pmultinfo->pmult_state |= SATA_DSTATE_FAILED;
15740 }
15741
15742 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex);
15743 rv = EIO;
15744 }
15745 /*
15746 * If attached device was a port multiplier, some extra processing
15747 * may be needed to bring it back. SATA specification requies a
15748 * mandatory software reset on host port to reliably enumerate a port
15749 * multiplier, the HBA driver should handle that after reset
15750 * operation.
15751 */
15752 return (rv);
15753 }
15754
15755
15756 /*
15757 * Process ioctl reset all request.
15758 */
15759 static int
15760 sata_ioctl_reset_all(sata_hba_inst_t *sata_hba_inst)
15761 {
15762 sata_device_t sata_device;
15763 int rv = 0;
15764 int tcport;
15765
15766 sata_device.satadev_rev = SATA_DEVICE_REV;
15767
15768 /*
15769 * There is no protection here for configured devices.
15770 */
15771 /* Sanity check */
15772 if (SATA_RESET_DPORT_FUNC(sata_hba_inst) == NULL) {
15773 SATA_LOG_D((sata_hba_inst, CE_WARN,
15774 "sata_hba_ioctl: sata_hba_tran missing required "
15775 "function sata_tran_reset_dport"));
15776 return (ENOTSUP);
15777 }
15778
15779 /*
15780 * Need to lock all ports, not just one.
15781 * If any port is locked by event processing, fail the whole operation.
15782 * One port is already locked, but for simplicity lock it again.
15783 */
15784 for (tcport = 0; tcport < SATA_NUM_CPORTS(sata_hba_inst); tcport++) {
15785 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, tcport)->
15786 cport_mutex);
15787 if (((SATA_CPORT_INFO(sata_hba_inst, tcport)->
15788 cport_event_flags) & SATA_EVNT_LOCK_PORT_BUSY) != 0) {
15789 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, tcport)->
15790 cport_mutex);
15791 rv = EBUSY;
15792 break;
15793 } else {
15794 /*
15795 * It is enough to lock cport in command-based
15796 * switching mode.
15797 */
15798 SATA_CPORT_INFO(sata_hba_inst, tcport)->
15799 cport_event_flags |= SATA_APCTL_LOCK_PORT_BUSY;
15800 }
15801 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, tcport)->
15802 cport_mutex);
15803 }
15804
15805 if (rv == 0) {
15806 /*
15807 * All cports were successfully locked.
15808 * Reset main SATA controller.
15809 * Set the device address to port 0, to have a valid device
15810 * address.
15811 */
15812 sata_device.satadev_addr.qual = SATA_ADDR_CNTRL;
15813 sata_device.satadev_addr.cport = 0;
15814 sata_device.satadev_addr.pmport = 0;
15815
15816 if ((*SATA_RESET_DPORT_FUNC(sata_hba_inst))
15817 (SATA_DIP(sata_hba_inst), &sata_device) != SATA_SUCCESS) {
15818 SATA_LOG_D((sata_hba_inst, CE_WARN,
15819 "sata_hba_ioctl: reset controller failed"));
15820 return (EIO);
15821 }
15822 }
15823 /*
15824 * Unlock all ports
15825 */
15826 for (tcport = 0; tcport < SATA_NUM_CPORTS(sata_hba_inst); tcport++) {
15827 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, tcport)->
15828 cport_mutex);
15829 SATA_CPORT_INFO(sata_hba_inst, tcport)->
15830 cport_event_flags &= ~SATA_APCTL_LOCK_PORT_BUSY;
15831 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, tcport)->
15832 cport_mutex);
15833 }
15834
15835 /*
15836 * This operation returns EFAULT if either reset
15837 * controller failed or a re-probing of any port failed.
15838 */
15839 return (rv);
15840 }
15841
15842
15843 /*
15844 * Process ioctl port self test request.
15845 *
15846 * NOTE: Port multiplier code is not completed nor tested.
15847 */
15848 static int
15849 sata_ioctl_port_self_test(sata_hba_inst_t *sata_hba_inst,
15850 sata_device_t *sata_device)
15851 {
15852 int cport, pmport, qual;
15853 int rv = 0;
15854
15855 /* Sanity check */
15856 if (SATA_SELFTEST_FUNC(sata_hba_inst) == NULL)
15857 return (ENOTSUP);
15858
15859 cport = sata_device->satadev_addr.cport;
15860 pmport = sata_device->satadev_addr.pmport;
15861 qual = sata_device->satadev_addr.qual;
15862
15863 /*
15864 * There is no protection here for a configured
15865 * device attached to this port.
15866 */
15867
15868 if ((*SATA_SELFTEST_FUNC(sata_hba_inst))
15869 (SATA_DIP(sata_hba_inst), sata_device) != SATA_SUCCESS) {
15870 SATA_LOG_D((sata_hba_inst, CE_WARN,
15871 "sata_hba_ioctl: port selftest: "
15872 "failed port %d:%d", cport, pmport));
15873 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, cport)->
15874 cport_mutex);
15875 sata_update_port_info(sata_hba_inst, sata_device);
15876 if (qual == SATA_ADDR_CPORT)
15877 SATA_CPORT_STATE(sata_hba_inst, cport) =
15878 SATA_PSTATE_FAILED;
15879 else { /* port multiplier device port */
15880 mutex_enter(&SATA_PMPORT_MUTEX(sata_hba_inst,
15881 cport, pmport));
15882 SATA_PMPORT_STATE(sata_hba_inst, cport, pmport) =
15883 SATA_PSTATE_FAILED;
15884 mutex_exit(&SATA_PMPORT_MUTEX(sata_hba_inst,
15885 cport, pmport));
15886 }
15887
15888 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)->
15889 cport_mutex);
15890 return (EIO);
15891 }
15892 /*
15893 * Beacuse the port was reset in the course of testing, it should be
15894 * re-probed and attached device state should be restored. At this
15895 * point the port state is unknown - it's state is HBA-specific.
15896 * Force port re-probing to get it into a known state.
15897 */
15898 if (sata_reprobe_port(sata_hba_inst, sata_device,
15899 SATA_DEV_IDENTIFY_RETRY) != SATA_SUCCESS)
15900 rv = EIO;
15901 return (rv);
15902 }
15903
15904
15905 /*
15906 * sata_cfgadm_state:
15907 * Use the sata port state and state of the target node to figure out
15908 * the cfgadm_state.
15909 *
15910 * The port argument is a value with encoded cport,
15911 * pmport and address qualifier, in the same manner as a scsi target number.
15912 * SCSI_TO_SATA_CPORT macro extracts cport number,
15913 * SCSI_TO_SATA_PMPORT extracts pmport number and
15914 * SCSI_TO_SATA_ADDR_QUAL extracts port mulitplier qualifier flag.
15915 *
15916 * Port multiplier is supported.
15917 */
15918
15919 static void
15920 sata_cfgadm_state(sata_hba_inst_t *sata_hba_inst, int32_t port,
15921 devctl_ap_state_t *ap_state)
15922 {
15923 uint8_t cport, pmport, qual;
15924 uint32_t port_state, pmult_state;
15925 uint32_t dev_type;
15926 sata_drive_info_t *sdinfo;
15927
15928 cport = SCSI_TO_SATA_CPORT(port);
15929 pmport = SCSI_TO_SATA_PMPORT(port);
15930 qual = SCSI_TO_SATA_ADDR_QUAL(port);
15931
15932 /* Check cport state */
15933 port_state = SATA_CPORT_STATE(sata_hba_inst, cport);
15934 if (port_state & SATA_PSTATE_SHUTDOWN ||
15935 port_state & SATA_PSTATE_FAILED) {
15936 ap_state->ap_rstate = AP_RSTATE_DISCONNECTED;
15937 ap_state->ap_ostate = AP_OSTATE_UNCONFIGURED;
15938 if (port_state & SATA_PSTATE_FAILED)
15939 ap_state->ap_condition = AP_COND_FAILED;
15940 else
15941 ap_state->ap_condition = AP_COND_UNKNOWN;
15942
15943 return;
15944 }
15945
15946 /* cport state is okay. Now check pmport state */
15947 if (qual == SATA_ADDR_DPMPORT || qual == SATA_ADDR_PMPORT) {
15948 /* Sanity check */
15949 if (SATA_CPORT_DEV_TYPE(sata_hba_inst, cport) !=
15950 SATA_DTYPE_PMULT || SATA_PMPORT_INFO(sata_hba_inst,
15951 cport, pmport) == NULL)
15952 return;
15953 port_state = SATA_PMPORT_STATE(sata_hba_inst, cport, pmport);
15954 if (port_state & SATA_PSTATE_SHUTDOWN ||
15955 port_state & SATA_PSTATE_FAILED) {
15956 ap_state->ap_rstate = AP_RSTATE_DISCONNECTED;
15957 ap_state->ap_ostate = AP_OSTATE_UNCONFIGURED;
15958 if (port_state & SATA_PSTATE_FAILED)
15959 ap_state->ap_condition = AP_COND_FAILED;
15960 else
15961 ap_state->ap_condition = AP_COND_UNKNOWN;
15962
15963 return;
15964 }
15965 }
15966
15967 /* Port is enabled and ready */
15968 if (qual == SATA_ADDR_DCPORT || qual == SATA_ADDR_CPORT)
15969 dev_type = SATA_CPORT_DEV_TYPE(sata_hba_inst, cport);
15970 else
15971 dev_type = SATA_PMPORT_DEV_TYPE(sata_hba_inst, cport, pmport);
15972
15973 switch (dev_type) {
15974 case SATA_DTYPE_NONE:
15975 {
15976 ap_state->ap_ostate = AP_OSTATE_UNCONFIGURED;
15977 ap_state->ap_condition = AP_COND_OK;
15978 /* No device attached */
15979 ap_state->ap_rstate = AP_RSTATE_EMPTY;
15980 break;
15981 }
15982 case SATA_DTYPE_PMULT:
15983 {
15984 /* Need to check port multiplier state */
15985 ASSERT(qual == SATA_ADDR_DCPORT);
15986 pmult_state = SATA_PMULT_INFO(sata_hba_inst, cport)->
15987 pmult_state;
15988 if (pmult_state & (SATA_PSTATE_SHUTDOWN|SATA_PSTATE_FAILED)) {
15989 ap_state->ap_rstate = AP_RSTATE_DISCONNECTED;
15990 ap_state->ap_ostate = AP_OSTATE_UNCONFIGURED;
15991 if (pmult_state & SATA_PSTATE_FAILED)
15992 ap_state->ap_condition = AP_COND_FAILED;
15993 else
15994 ap_state->ap_condition = AP_COND_UNKNOWN;
15995
15996 return;
15997 }
15998
15999 /* Port multiplier is not configurable */
16000 ap_state->ap_ostate = AP_OSTATE_CONFIGURED;
16001 ap_state->ap_rstate = AP_RSTATE_CONNECTED;
16002 ap_state->ap_condition = AP_COND_OK;
16003 break;
16004 }
16005
16006 case SATA_DTYPE_ATADISK:
16007 case SATA_DTYPE_ATAPICD:
16008 case SATA_DTYPE_ATAPITAPE:
16009 case SATA_DTYPE_ATAPIDISK:
16010 {
16011 dev_info_t *tdip = NULL;
16012 dev_info_t *dip = NULL;
16013 int circ;
16014
16015 dip = SATA_DIP(sata_hba_inst);
16016 tdip = sata_get_target_dip(dip, cport, pmport);
16017 ap_state->ap_rstate = AP_RSTATE_CONNECTED;
16018 if (tdip != NULL) {
16019 ndi_devi_enter(dip, &circ);
16020 mutex_enter(&(DEVI(tdip)->devi_lock));
16021 if (DEVI_IS_DEVICE_REMOVED(tdip)) {
16022 /*
16023 * There could be the case where previously
16024 * configured and opened device was removed
16025 * and unknown device was plugged.
16026 * In such case we want to show a device, and
16027 * its configured or unconfigured state but
16028 * indicate unusable condition untill the
16029 * old target node is released and removed.
16030 */
16031 ap_state->ap_condition = AP_COND_UNUSABLE;
16032 } else {
16033 mutex_enter(&SATA_CPORT_MUTEX(sata_hba_inst,
16034 cport));
16035 sdinfo = SATA_CPORT_DRV_INFO(sata_hba_inst,
16036 cport);
16037 if (sdinfo != NULL) {
16038 if ((sdinfo->satadrv_state &
16039 SATA_DSTATE_FAILED) != 0)
16040 ap_state->ap_condition =
16041 AP_COND_FAILED;
16042 else
16043 ap_state->ap_condition =
16044 AP_COND_OK;
16045 } else {
16046 ap_state->ap_condition =
16047 AP_COND_UNKNOWN;
16048 }
16049 mutex_exit(&SATA_CPORT_MUTEX(sata_hba_inst,
16050 cport));
16051 }
16052 if ((DEVI_IS_DEVICE_OFFLINE(tdip)) ||
16053 (DEVI_IS_DEVICE_DOWN(tdip))) {
16054 ap_state->ap_ostate =
16055 AP_OSTATE_UNCONFIGURED;
16056 } else {
16057 ap_state->ap_ostate =
16058 AP_OSTATE_CONFIGURED;
16059 }
16060 mutex_exit(&(DEVI(tdip)->devi_lock));
16061 ndi_devi_exit(dip, circ);
16062 } else {
16063 ap_state->ap_ostate = AP_OSTATE_UNCONFIGURED;
16064 ap_state->ap_condition = AP_COND_UNKNOWN;
16065 }
16066 break;
16067 }
16068 case SATA_DTYPE_ATAPIPROC:
16069 ap_state->ap_rstate = AP_RSTATE_CONNECTED;
16070 ap_state->ap_ostate = AP_OSTATE_UNCONFIGURED;
16071 ap_state->ap_condition = AP_COND_OK;
16072 break;
16073 default:
16074 ap_state->ap_rstate = AP_RSTATE_CONNECTED;
16075 ap_state->ap_ostate = AP_OSTATE_UNCONFIGURED;
16076 ap_state->ap_condition = AP_COND_UNKNOWN;
16077 /*
16078 * This is actually internal error condition (non fatal),
16079 * because we have already checked all defined device types.
16080 */
16081 SATA_LOG_D((sata_hba_inst, CE_WARN,
16082 "sata_cfgadm_state: Internal error: "
16083 "unknown device type"));
16084 break;
16085 }
16086 }
16087
16088
16089 /*
16090 * Process ioctl get device path request.
16091 *
16092 * NOTE: Port multiplier has no target dip. Devices connected to port
16093 * multiplier have target node attached to the HBA node. The only difference
16094 * between them and the directly-attached device node is a target address.
16095 */
16096 static int
16097 sata_ioctl_get_device_path(sata_hba_inst_t *sata_hba_inst,
16098 sata_device_t *sata_device, sata_ioctl_data_t *ioc, int mode)
16099 {
16100 char path[MAXPATHLEN];
16101 uint32_t size;
16102 dev_info_t *tdip;
16103
16104 (void) strcpy(path, "/devices");
16105 if ((tdip = sata_get_scsi_target_dip(SATA_DIP(sata_hba_inst),
16106 &sata_device->satadev_addr)) == NULL) {
16107 /*
16108 * No such device. If this is a request for a size, do not
16109 * return EINVAL for non-existing target, because cfgadm
16110 * will then indicate a meaningless ioctl failure.
16111 * If this is a request for a path, indicate invalid
16112 * argument.
16113 */
16114 if (ioc->get_size == 0)
16115 return (EINVAL);
16116 } else {
16117 (void) ddi_pathname(tdip, path + strlen(path));
16118 }
16119 size = strlen(path) + 1;
16120
16121 if (ioc->get_size != 0) {
16122 if (ddi_copyout((void *)&size, ioc->buf, ioc->bufsiz,
16123 mode) != 0)
16124 return (EFAULT);
16125 } else {
16126 if (ioc->bufsiz != size)
16127 return (EINVAL);
16128
16129 else if (ddi_copyout((void *)&path, ioc->buf, ioc->bufsiz,
16130 mode) != 0)
16131 return (EFAULT);
16132 }
16133 return (0);
16134 }
16135
16136 /*
16137 * Process ioctl get attachment point type request.
16138 *
16139 * NOTE: Port multiplier is supported.
16140 */
16141 static int
16142 sata_ioctl_get_ap_type(sata_hba_inst_t *sata_hba_inst,
16143 sata_device_t *sata_device, sata_ioctl_data_t *ioc, int mode)
16144 {
16145 uint32_t type_len;
16146 const char *ap_type;
16147 int dev_type;
16148
16149 if (sata_device->satadev_addr.qual == SATA_ADDR_DCPORT)
16150 dev_type = SATA_CPORT_DEV_TYPE(sata_hba_inst,
16151 sata_device->satadev_addr.cport);
16152 else /* pmport */
16153 dev_type = SATA_PMPORT_DEV_TYPE(sata_hba_inst,
16154 sata_device->satadev_addr.cport,
16155 sata_device->satadev_addr.pmport);
16156
16157 switch (dev_type) {
16158 case SATA_DTYPE_NONE:
16159 ap_type = "port";
16160 break;
16161
16162 case SATA_DTYPE_ATADISK:
16163 case SATA_DTYPE_ATAPIDISK:
16164 ap_type = "disk";
16165 break;
16166
16167 case SATA_DTYPE_ATAPICD:
16168 ap_type = "cd/dvd";
16169 break;
16170
16171 case SATA_DTYPE_ATAPITAPE:
16172 ap_type = "tape";
16173 break;
16174
16175 case SATA_DTYPE_ATAPIPROC:
16176 ap_type = "processor";
16177 break;
16178
16179 case SATA_DTYPE_PMULT:
16180 ap_type = "sata-pmult";
16181 break;
16182
16183 case SATA_DTYPE_UNKNOWN:
16184 ap_type = "unknown";
16185 break;
16186
16187 default:
16188 ap_type = "unsupported";
16189 break;
16190
16191 } /* end of dev_type switch */
16192
16193 type_len = strlen(ap_type) + 1;
16194
16195 if (ioc->get_size) {
16196 if (ddi_copyout((void *)&type_len, ioc->buf, ioc->bufsiz,
16197 mode) != 0)
16198 return (EFAULT);
16199 } else {
16200 if (ioc->bufsiz != type_len)
16201 return (EINVAL);
16202
16203 if (ddi_copyout((void *)ap_type, ioc->buf,
16204 ioc->bufsiz, mode) != 0)
16205 return (EFAULT);
16206 }
16207 return (0);
16208
16209 }
16210
16211 /*
16212 * Process ioctl get device model info request.
16213 * This operation should return to cfgadm the device model
16214 * information string
16215 *
16216 * NOTE: Port multiplier is supported.
16217 */
16218 static int
16219 sata_ioctl_get_model_info(sata_hba_inst_t *sata_hba_inst,
16220 sata_device_t *sata_device, sata_ioctl_data_t *ioc, int mode)
16221 {
16222 sata_drive_info_t *sdinfo;
16223 uint32_t info_len;
16224 char ap_info[SATA_ID_MODEL_LEN + 1];
16225
16226 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst,
16227 sata_device->satadev_addr.cport)->cport_mutex);
16228 if (sata_device->satadev_addr.qual == SATA_ADDR_DCPORT)
16229 sdinfo = SATA_CPORT_DRV_INFO(sata_hba_inst,
16230 sata_device->satadev_addr.cport);
16231 else /* port multiplier */
16232 sdinfo = SATA_PMPORT_DRV_INFO(sata_hba_inst,
16233 sata_device->satadev_addr.cport,
16234 sata_device->satadev_addr.pmport);
16235 if (sdinfo == NULL) {
16236 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst,
16237 sata_device->satadev_addr.cport)->cport_mutex);
16238 return (EINVAL);
16239 }
16240
16241 #ifdef _LITTLE_ENDIAN
16242 swab(sdinfo->satadrv_id.ai_model, ap_info, SATA_ID_MODEL_LEN);
16243 #else /* _LITTLE_ENDIAN */
16244 bcopy(sdinfo->satadrv_id.ai_model, ap_info, SATA_ID_MODEL_LEN);
16245 #endif /* _LITTLE_ENDIAN */
16246
16247 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst,
16248 sata_device->satadev_addr.cport)->cport_mutex);
16249
16250 ap_info[SATA_ID_MODEL_LEN] = '\0';
16251
16252 info_len = strlen(ap_info) + 1;
16253
16254 if (ioc->get_size) {
16255 if (ddi_copyout((void *)&info_len, ioc->buf, ioc->bufsiz,
16256 mode) != 0)
16257 return (EFAULT);
16258 } else {
16259 if (ioc->bufsiz < info_len)
16260 return (EINVAL);
16261 if (ddi_copyout((void *)ap_info, ioc->buf, ioc->bufsiz,
16262 mode) != 0)
16263 return (EFAULT);
16264 }
16265 return (0);
16266 }
16267
16268
16269 /*
16270 * Process ioctl get device firmware revision info request.
16271 * This operation should return to cfgadm the device firmware revision
16272 * information string
16273 *
16274 * Port multiplier is supported.
16275 */
16276 static int
16277 sata_ioctl_get_revfirmware_info(sata_hba_inst_t *sata_hba_inst,
16278 sata_device_t *sata_device, sata_ioctl_data_t *ioc, int mode)
16279 {
16280 sata_drive_info_t *sdinfo;
16281 uint32_t info_len;
16282 char ap_info[SATA_ID_FW_LEN + 1];
16283
16284 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst,
16285 sata_device->satadev_addr.cport)->cport_mutex);
16286 if (sata_device->satadev_addr.qual == SATA_ADDR_DCPORT)
16287 sdinfo = SATA_CPORT_DRV_INFO(sata_hba_inst,
16288 sata_device->satadev_addr.cport);
16289 else /* port multiplier */
16290 sdinfo = SATA_PMPORT_DRV_INFO(sata_hba_inst,
16291 sata_device->satadev_addr.cport,
16292 sata_device->satadev_addr.pmport);
16293 if (sdinfo == NULL) {
16294 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst,
16295 sata_device->satadev_addr.cport)->cport_mutex);
16296 return (EINVAL);
16297 }
16298
16299 #ifdef _LITTLE_ENDIAN
16300 swab(sdinfo->satadrv_id.ai_fw, ap_info, SATA_ID_FW_LEN);
16301 #else /* _LITTLE_ENDIAN */
16302 bcopy(sdinfo->satadrv_id.ai_fw, ap_info, SATA_ID_FW_LEN);
16303 #endif /* _LITTLE_ENDIAN */
16304
16305 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst,
16306 sata_device->satadev_addr.cport)->cport_mutex);
16307
16308 ap_info[SATA_ID_FW_LEN] = '\0';
16309
16310 info_len = strlen(ap_info) + 1;
16311
16312 if (ioc->get_size) {
16313 if (ddi_copyout((void *)&info_len, ioc->buf, ioc->bufsiz,
16314 mode) != 0)
16315 return (EFAULT);
16316 } else {
16317 if (ioc->bufsiz < info_len)
16318 return (EINVAL);
16319 if (ddi_copyout((void *)ap_info, ioc->buf, ioc->bufsiz,
16320 mode) != 0)
16321 return (EFAULT);
16322 }
16323 return (0);
16324 }
16325
16326
16327 /*
16328 * Process ioctl get device serial number info request.
16329 * This operation should return to cfgadm the device serial number string.
16330 *
16331 * NOTE: Port multiplier is supported.
16332 */
16333 static int
16334 sata_ioctl_get_serialnumber_info(sata_hba_inst_t *sata_hba_inst,
16335 sata_device_t *sata_device, sata_ioctl_data_t *ioc, int mode)
16336 {
16337 sata_drive_info_t *sdinfo;
16338 uint32_t info_len;
16339 char ap_info[SATA_ID_SERIAL_LEN + 1];
16340
16341 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst,
16342 sata_device->satadev_addr.cport)->cport_mutex);
16343 if (sata_device->satadev_addr.qual == SATA_ADDR_DCPORT)
16344 sdinfo = SATA_CPORT_DRV_INFO(sata_hba_inst,
16345 sata_device->satadev_addr.cport);
16346 else /* port multiplier */
16347 sdinfo = SATA_PMPORT_DRV_INFO(sata_hba_inst,
16348 sata_device->satadev_addr.cport,
16349 sata_device->satadev_addr.pmport);
16350 if (sdinfo == NULL) {
16351 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst,
16352 sata_device->satadev_addr.cport)->cport_mutex);
16353 return (EINVAL);
16354 }
16355
16356 #ifdef _LITTLE_ENDIAN
16357 swab(sdinfo->satadrv_id.ai_drvser, ap_info, SATA_ID_SERIAL_LEN);
16358 #else /* _LITTLE_ENDIAN */
16359 bcopy(sdinfo->satadrv_id.ai_drvser, ap_info, SATA_ID_SERIAL_LEN);
16360 #endif /* _LITTLE_ENDIAN */
16361
16362 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst,
16363 sata_device->satadev_addr.cport)->cport_mutex);
16364
16365 ap_info[SATA_ID_SERIAL_LEN] = '\0';
16366
16367 info_len = strlen(ap_info) + 1;
16368
16369 if (ioc->get_size) {
16370 if (ddi_copyout((void *)&info_len, ioc->buf, ioc->bufsiz,
16371 mode) != 0)
16372 return (EFAULT);
16373 } else {
16374 if (ioc->bufsiz < info_len)
16375 return (EINVAL);
16376 if (ddi_copyout((void *)ap_info, ioc->buf, ioc->bufsiz,
16377 mode) != 0)
16378 return (EFAULT);
16379 }
16380 return (0);
16381 }
16382
16383
16384 /*
16385 * Preset scsi extended sense data (to NO SENSE)
16386 * First 18 bytes of the sense data are preset to current valid sense
16387 * with a key NO SENSE data.
16388 *
16389 * Returns void
16390 */
16391 static void
16392 sata_fixed_sense_data_preset(struct scsi_extended_sense *sense)
16393 {
16394 sense->es_valid = 1; /* Valid sense */
16395 sense->es_class = CLASS_EXTENDED_SENSE; /* 0x70 - current err */
16396 sense->es_key = KEY_NO_SENSE;
16397 sense->es_info_1 = 0;
16398 sense->es_info_2 = 0;
16399 sense->es_info_3 = 0;
16400 sense->es_info_4 = 0;
16401 sense->es_add_len = 10; /* Additional length - replace with a def */
16402 sense->es_cmd_info[0] = 0;
16403 sense->es_cmd_info[1] = 0;
16404 sense->es_cmd_info[2] = 0;
16405 sense->es_cmd_info[3] = 0;
16406 sense->es_add_code = 0;
16407 sense->es_qual_code = 0;
16408 }
16409
16410 /*
16411 * Register a legacy cmdk-style devid for the target (disk) device.
16412 *
16413 * Note: This function is called only when the HBA devinfo node has the
16414 * property "use-cmdk-devid-format" set. This property indicates that
16415 * devid compatible with old cmdk (target) driver is to be generated
16416 * for any target device attached to this controller. This will take
16417 * precedence over the devid generated by sd (target) driver.
16418 * This function is derived from cmdk_devid_setup() function in cmdk.c.
16419 */
16420 static void
16421 sata_target_devid_register(dev_info_t *dip, sata_drive_info_t *sdinfo)
16422 {
16423 char *hwid;
16424 int modlen;
16425 int serlen;
16426 int rval;
16427 ddi_devid_t devid;
16428
16429 /*
16430 * device ID is a concatanation of model number, "=", serial number.
16431 */
16432 hwid = kmem_zalloc(LEGACY_HWID_LEN, KM_SLEEP);
16433 bcopy(&sdinfo->satadrv_id.ai_model, hwid,
16434 sizeof (sdinfo->satadrv_id.ai_model));
16435 swab(hwid, hwid, sizeof (sdinfo->satadrv_id.ai_model));
16436 modlen = sata_check_modser(hwid, sizeof (sdinfo->satadrv_id.ai_model));
16437 if (modlen == 0)
16438 goto err;
16439 hwid[modlen++] = '=';
16440 bcopy(&sdinfo->satadrv_id.ai_drvser, &hwid[modlen],
16441 sizeof (sdinfo->satadrv_id.ai_drvser));
16442 swab(&hwid[modlen], &hwid[modlen],
16443 sizeof (sdinfo->satadrv_id.ai_drvser));
16444 serlen = sata_check_modser(&hwid[modlen],
16445 sizeof (sdinfo->satadrv_id.ai_drvser));
16446 if (serlen == 0)
16447 goto err;
16448 hwid[modlen + serlen] = 0; /* terminate the hwid string */
16449
16450 /* initialize/register devid */
16451 if ((rval = ddi_devid_init(dip, DEVID_ATA_SERIAL,
16452 (ushort_t)(modlen + serlen), hwid, &devid)) == DDI_SUCCESS) {
16453 rval = ddi_devid_register(dip, devid);
16454 /*
16455 * Free up the allocated devid buffer.
16456 * NOTE: This doesn't mean unregistering devid.
16457 */
16458 ddi_devid_free(devid);
16459 }
16460
16461 if (rval != DDI_SUCCESS)
16462 cmn_err(CE_WARN, "sata: failed to create devid for the disk"
16463 " on port %d", sdinfo->satadrv_addr.cport);
16464 err:
16465 kmem_free(hwid, LEGACY_HWID_LEN);
16466 }
16467
16468 /*
16469 * valid model/serial string must contain a non-zero non-space characters.
16470 * trim trailing spaces/NULLs.
16471 */
16472 static int
16473 sata_check_modser(char *buf, int buf_len)
16474 {
16475 boolean_t ret;
16476 char *s;
16477 int i;
16478 int tb;
16479 char ch;
16480
16481 ret = B_FALSE;
16482 s = buf;
16483 for (i = 0; i < buf_len; i++) {
16484 ch = *s++;
16485 if (ch != ' ' && ch != '\0')
16486 tb = i + 1;
16487 if (ch != ' ' && ch != '\0' && ch != '0')
16488 ret = B_TRUE;
16489 }
16490
16491 if (ret == B_FALSE)
16492 return (0); /* invalid string */
16493
16494 return (tb); /* return length */
16495 }
16496
16497 /*
16498 * sata_set_drive_features function compares current device features setting
16499 * with the saved device features settings and, if there is a difference,
16500 * it restores device features setting to the previously saved state.
16501 * It also arbitrarily tries to select the highest supported DMA mode.
16502 * Device Identify or Identify Packet Device data has to be current.
16503 * At the moment read ahead and write cache are considered for all devices.
16504 * For atapi devices, Removable Media Status Notification is set in addition
16505 * to common features.
16506 *
16507 * This function cannot be called in the interrupt context (it may sleep).
16508 *
16509 * The input argument sdinfo should point to the drive info structure
16510 * to be updated after features are set. Note, that only
16511 * device (packet) identify data is updated, not the flags indicating the
16512 * supported features.
16513 *
16514 * Returns SATA_SUCCESS if successful or there was nothing to do.
16515 * Device Identify data in the drive info structure pointed to by the sdinfo
16516 * arguments is updated even when no features were set or changed.
16517 *
16518 * Returns SATA_FAILURE if device features could not be set or DMA mode
16519 * for a disk cannot be set and device identify data cannot be fetched.
16520 *
16521 * Returns SATA_RETRY if device features could not be set (other than disk
16522 * DMA mode) but the device identify data was fetched successfully.
16523 *
16524 * Note: This function may fail the port, making it inaccessible.
16525 * In such case the explicit port disconnect/connect or physical device
16526 * detach/attach is required to re-evaluate port state again.
16527 */
16528
16529 static int
16530 sata_set_drive_features(sata_hba_inst_t *sata_hba_inst,
16531 sata_drive_info_t *sdinfo, int restore)
16532 {
16533 int rval = SATA_SUCCESS;
16534 int rval_set;
16535 sata_drive_info_t new_sdinfo;
16536 char *finfo = "sata_set_drive_features: cannot";
16537 char *finfox;
16538 int cache_op;
16539
16540 bzero(&new_sdinfo, sizeof (sata_drive_info_t));
16541 new_sdinfo.satadrv_addr = sdinfo->satadrv_addr;
16542 new_sdinfo.satadrv_type = sdinfo->satadrv_type;
16543 if (sata_fetch_device_identify_data(sata_hba_inst, &new_sdinfo) != 0) {
16544 /*
16545 * Cannot get device identification - caller may retry later
16546 */
16547 SATADBG1(SATA_DBG_DEV_SETTINGS, sata_hba_inst,
16548 "%s fetch device identify data\n", finfo);
16549 return (SATA_FAILURE);
16550 }
16551 finfox = (restore != 0) ? " restore device features" :
16552 " initialize device features\n";
16553
16554 switch (sdinfo->satadrv_type) {
16555 case SATA_DTYPE_ATADISK:
16556 /* Arbitrarily set UDMA mode */
16557 if (sata_set_dma_mode(sata_hba_inst, &new_sdinfo) !=
16558 SATA_SUCCESS) {
16559 SATA_LOG_D((sata_hba_inst, CE_WARN,
16560 "%s set UDMA mode\n", finfo));
16561 return (SATA_FAILURE);
16562 }
16563 break;
16564 case SATA_DTYPE_ATAPICD:
16565 case SATA_DTYPE_ATAPITAPE:
16566 case SATA_DTYPE_ATAPIDISK:
16567 /* Set Removable Media Status Notification, if necessary */
16568 if (SATA_RM_NOTIFIC_SUPPORTED(new_sdinfo.satadrv_id) &&
16569 restore != 0) {
16570 if (((sdinfo->satadrv_settings & SATA_DEV_RMSN) &&
16571 (!SATA_RM_NOTIFIC_ENABLED(new_sdinfo.satadrv_id)))||
16572 ((!(sdinfo->satadrv_settings & SATA_DEV_RMSN)) &&
16573 SATA_RM_NOTIFIC_ENABLED(new_sdinfo.satadrv_id))) {
16574 /* Current setting does not match saved one */
16575 if (sata_set_rmsn(sata_hba_inst, sdinfo,
16576 sdinfo->satadrv_settings &
16577 SATA_DEV_RMSN) != SATA_SUCCESS)
16578 rval = SATA_FAILURE;
16579 }
16580 }
16581 /*
16582 * We have to set Multiword DMA or UDMA, if it is supported, as
16583 * we want to use DMA transfer mode whenever possible.
16584 * Some devices require explicit setting of the DMA mode.
16585 */
16586 if (new_sdinfo.satadrv_id.ai_cap & SATA_DMA_SUPPORT) {
16587 /* Set highest supported DMA mode */
16588 if (sata_set_dma_mode(sata_hba_inst, &new_sdinfo) !=
16589 SATA_SUCCESS) {
16590 SATA_LOG_D((sata_hba_inst, CE_WARN,
16591 "%s set UDMA mode\n", finfo));
16592 rval = SATA_FAILURE;
16593 }
16594 }
16595 break;
16596 }
16597
16598 if (!SATA_READ_AHEAD_SUPPORTED(new_sdinfo.satadrv_id) &&
16599 !SATA_WRITE_CACHE_SUPPORTED(new_sdinfo.satadrv_id)) {
16600 /*
16601 * neither READ AHEAD nor WRITE CACHE is supported
16602 * - do nothing
16603 */
16604 SATADBG1(SATA_DBG_DEV_SETTINGS, sata_hba_inst,
16605 "settable features not supported\n", NULL);
16606 goto update_sdinfo;
16607 }
16608
16609 if ((SATA_READ_AHEAD_ENABLED(new_sdinfo.satadrv_id) &&
16610 (sdinfo->satadrv_settings & SATA_DEV_READ_AHEAD)) &&
16611 (SATA_WRITE_CACHE_ENABLED(new_sdinfo.satadrv_id) &&
16612 (sdinfo->satadrv_settings & SATA_DEV_WRITE_CACHE))) {
16613 /*
16614 * both READ AHEAD and WRITE CACHE are enabled
16615 * - Nothing to do
16616 */
16617 SATADBG1(SATA_DBG_DEV_SETTINGS, sata_hba_inst,
16618 "no device features to set\n", NULL);
16619 goto update_sdinfo;
16620 }
16621
16622 cache_op = 0;
16623
16624 if (SATA_READ_AHEAD_SUPPORTED(new_sdinfo.satadrv_id)) {
16625 if ((sdinfo->satadrv_settings & SATA_DEV_READ_AHEAD) &&
16626 !SATA_READ_AHEAD_ENABLED(new_sdinfo.satadrv_id)) {
16627 /* Enable read ahead / read cache */
16628 cache_op = SATAC_SF_ENABLE_READ_AHEAD;
16629 SATADBG1(SATA_DBG_DEV_SETTINGS, sata_hba_inst,
16630 "enabling read cache\n", NULL);
16631 } else if (!(sdinfo->satadrv_settings & SATA_DEV_READ_AHEAD) &&
16632 SATA_READ_AHEAD_ENABLED(new_sdinfo.satadrv_id)) {
16633 /* Disable read ahead / read cache */
16634 cache_op = SATAC_SF_DISABLE_READ_AHEAD;
16635 SATADBG1(SATA_DBG_DEV_SETTINGS, sata_hba_inst,
16636 "disabling read cache\n", NULL);
16637 }
16638
16639 if (cache_op != 0) {
16640 /* Try to set read cache mode */
16641 rval_set = sata_set_cache_mode(sata_hba_inst,
16642 &new_sdinfo, cache_op);
16643 if (rval != SATA_FAILURE && rval_set != SATA_SUCCESS)
16644 rval = rval_set;
16645 }
16646 }
16647
16648 cache_op = 0;
16649
16650 if (SATA_WRITE_CACHE_SUPPORTED(new_sdinfo.satadrv_id)) {
16651 if ((sdinfo->satadrv_settings & SATA_DEV_WRITE_CACHE) &&
16652 !SATA_WRITE_CACHE_ENABLED(new_sdinfo.satadrv_id)) {
16653 /* Enable write cache */
16654 cache_op = SATAC_SF_ENABLE_WRITE_CACHE;
16655 SATADBG1(SATA_DBG_DEV_SETTINGS, sata_hba_inst,
16656 "enabling write cache\n", NULL);
16657 } else if (!(sdinfo->satadrv_settings & SATA_DEV_WRITE_CACHE) &&
16658 SATA_WRITE_CACHE_ENABLED(new_sdinfo.satadrv_id)) {
16659 /* Disable write cache */
16660 cache_op = SATAC_SF_DISABLE_WRITE_CACHE;
16661 SATADBG1(SATA_DBG_DEV_SETTINGS, sata_hba_inst,
16662 "disabling write cache\n", NULL);
16663 }
16664
16665 if (cache_op != 0) {
16666 /* Try to set write cache mode */
16667 rval_set = sata_set_cache_mode(sata_hba_inst,
16668 &new_sdinfo, cache_op);
16669 if (rval != SATA_FAILURE && rval_set != SATA_SUCCESS)
16670 rval = rval_set;
16671 }
16672 }
16673 if (rval != SATA_SUCCESS)
16674 SATA_LOG_D((sata_hba_inst, CE_WARN,
16675 "%s %s", finfo, finfox));
16676
16677 update_sdinfo:
16678 /*
16679 * We need to fetch Device Identify data again
16680 */
16681 if (sata_fetch_device_identify_data(sata_hba_inst, &new_sdinfo) != 0) {
16682 /*
16683 * Cannot get device identification - retry later
16684 */
16685 SATA_LOG_D((sata_hba_inst, CE_WARN,
16686 "%s re-fetch device identify data\n", finfo));
16687 rval = SATA_FAILURE;
16688 }
16689 /* Copy device sata info. */
16690 sdinfo->satadrv_id = new_sdinfo.satadrv_id;
16691
16692 return (rval);
16693 }
16694
16695
16696 /*
16697 *
16698 * Returns 1 if threshold exceeded, 0 if threshold not exceeded, -1 if
16699 * unable to determine.
16700 *
16701 * Cannot be called in an interrupt context.
16702 *
16703 * Called by sata_build_lsense_page_2f()
16704 */
16705
16706 static int
16707 sata_fetch_smart_return_status(sata_hba_inst_t *sata_hba_inst,
16708 sata_drive_info_t *sdinfo)
16709 {
16710 sata_pkt_t *spkt;
16711 sata_cmd_t *scmd;
16712 sata_pkt_txlate_t *spx;
16713 int rval;
16714
16715 spx = kmem_zalloc(sizeof (sata_pkt_txlate_t), KM_SLEEP);
16716 spx->txlt_sata_hba_inst = sata_hba_inst;
16717 spx->txlt_scsi_pkt = NULL; /* No scsi pkt involved */
16718 spkt = sata_pkt_alloc(spx, SLEEP_FUNC);
16719 if (spkt == NULL) {
16720 kmem_free(spx, sizeof (sata_pkt_txlate_t));
16721 return (-1);
16722 }
16723 /* address is needed now */
16724 spkt->satapkt_device.satadev_addr = sdinfo->satadrv_addr;
16725
16726
16727 /* Fill sata_pkt */
16728 spkt->satapkt_device.satadev_addr = sdinfo->satadrv_addr;
16729 spkt->satapkt_op_mode = SATA_OPMODE_SYNCH | SATA_OPMODE_INTERRUPTS;
16730 /* Synchronous mode, no callback */
16731 spkt->satapkt_comp = NULL;
16732 /* Timeout 30s */
16733 spkt->satapkt_time = sata_default_pkt_time;
16734
16735 scmd = &spkt->satapkt_cmd;
16736 scmd->satacmd_flags.sata_special_regs = B_TRUE;
16737 scmd->satacmd_flags.sata_data_direction = SATA_DIR_NODATA_XFER;
16738
16739 /* Set up which registers need to be returned */
16740 scmd->satacmd_flags.sata_copy_out_lba_mid_lsb = B_TRUE;
16741 scmd->satacmd_flags.sata_copy_out_lba_high_lsb = B_TRUE;
16742
16743 /* Build SMART_RETURN_STATUS cmd in the sata_pkt */
16744 scmd->satacmd_addr_type = 0; /* N/A */
16745 scmd->satacmd_sec_count_lsb = 0; /* N/A */
16746 scmd->satacmd_lba_low_lsb = 0; /* N/A */
16747 scmd->satacmd_lba_mid_lsb = SMART_MAGIC_VAL_1;
16748 scmd->satacmd_lba_high_lsb = SMART_MAGIC_VAL_2;
16749 scmd->satacmd_features_reg = SATA_SMART_RETURN_STATUS;
16750 scmd->satacmd_device_reg = 0; /* Always device 0 */
16751 scmd->satacmd_cmd_reg = SATAC_SMART;
16752 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst,
16753 sdinfo->satadrv_addr.cport)));
16754
16755
16756 /* Send pkt to SATA HBA driver */
16757 if ((*SATA_START_FUNC(sata_hba_inst))(SATA_DIP(sata_hba_inst), spkt) !=
16758 SATA_TRAN_ACCEPTED ||
16759 spkt->satapkt_reason != SATA_PKT_COMPLETED) {
16760 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst,
16761 sdinfo->satadrv_addr.cport)));
16762 /*
16763 * Whoops, no SMART RETURN STATUS
16764 */
16765 rval = -1;
16766 } else {
16767 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst,
16768 sdinfo->satadrv_addr.cport)));
16769 if (scmd->satacmd_error_reg & SATA_ERROR_ABORT) {
16770 rval = -1;
16771 goto fail;
16772 }
16773 if (scmd->satacmd_status_reg & SATA_STATUS_ERR) {
16774 rval = -1;
16775 goto fail;
16776 }
16777 if ((scmd->satacmd_lba_mid_lsb == SMART_MAGIC_VAL_1) &&
16778 (scmd->satacmd_lba_high_lsb == SMART_MAGIC_VAL_2))
16779 rval = 0;
16780 else if ((scmd->satacmd_lba_mid_lsb == SMART_MAGIC_VAL_3) &&
16781 (scmd->satacmd_lba_high_lsb == SMART_MAGIC_VAL_4))
16782 rval = 1;
16783 else {
16784 rval = -1;
16785 goto fail;
16786 }
16787 }
16788 fail:
16789 /* Free allocated resources */
16790 sata_pkt_free(spx);
16791 kmem_free(spx, sizeof (sata_pkt_txlate_t));
16792
16793 return (rval);
16794 }
16795
16796 /*
16797 *
16798 * Returns 0 if succeeded, -1 otherwise
16799 *
16800 * Cannot be called in an interrupt context.
16801 *
16802 */
16803 static int
16804 sata_fetch_smart_data(
16805 sata_hba_inst_t *sata_hba_inst,
16806 sata_drive_info_t *sdinfo,
16807 struct smart_data *smart_data)
16808 {
16809 sata_pkt_t *spkt;
16810 sata_cmd_t *scmd;
16811 sata_pkt_txlate_t *spx;
16812 int rval;
16813 dev_info_t *dip = SATA_DIP(sata_hba_inst);
16814
16815 #if ! defined(lint)
16816 ASSERT(sizeof (struct smart_data) == 512);
16817 #endif
16818
16819 spx = kmem_zalloc(sizeof (sata_pkt_txlate_t), KM_SLEEP);
16820 spx->txlt_sata_hba_inst = sata_hba_inst;
16821 spx->txlt_scsi_pkt = NULL; /* No scsi pkt involved */
16822 spkt = sata_pkt_alloc(spx, SLEEP_FUNC);
16823 if (spkt == NULL) {
16824 kmem_free(spx, sizeof (sata_pkt_txlate_t));
16825 return (-1);
16826 }
16827 /* address is needed now */
16828 spkt->satapkt_device.satadev_addr = sdinfo->satadrv_addr;
16829
16830
16831 /* Fill sata_pkt */
16832 spkt->satapkt_device.satadev_addr = sdinfo->satadrv_addr;
16833 spkt->satapkt_op_mode = SATA_OPMODE_SYNCH | SATA_OPMODE_INTERRUPTS;
16834 /* Synchronous mode, no callback */
16835 spkt->satapkt_comp = NULL;
16836 /* Timeout 30s */
16837 spkt->satapkt_time = sata_default_pkt_time;
16838
16839 scmd = &spkt->satapkt_cmd;
16840 scmd->satacmd_flags.sata_data_direction = SATA_DIR_READ;
16841
16842 /*
16843 * Allocate buffer for SMART data
16844 */
16845 scmd->satacmd_bp = sata_alloc_local_buffer(spx,
16846 sizeof (struct smart_data));
16847 if (scmd->satacmd_bp == NULL) {
16848 sata_pkt_free(spx);
16849 kmem_free(spx, sizeof (sata_pkt_txlate_t));
16850 SATA_LOG_D((sata_hba_inst, CE_WARN,
16851 "sata_fetch_smart_data: "
16852 "cannot allocate buffer"));
16853 return (-1);
16854 }
16855
16856
16857 /* Build SMART_READ_DATA cmd in the sata_pkt */
16858 scmd->satacmd_addr_type = 0; /* N/A */
16859 scmd->satacmd_sec_count_lsb = 0; /* N/A */
16860 scmd->satacmd_lba_low_lsb = 0; /* N/A */
16861 scmd->satacmd_lba_mid_lsb = SMART_MAGIC_VAL_1;
16862 scmd->satacmd_lba_high_lsb = SMART_MAGIC_VAL_2;
16863 scmd->satacmd_features_reg = SATA_SMART_READ_DATA;
16864 scmd->satacmd_device_reg = 0; /* Always device 0 */
16865 scmd->satacmd_cmd_reg = SATAC_SMART;
16866 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst,
16867 sdinfo->satadrv_addr.cport)));
16868
16869 /* Send pkt to SATA HBA driver */
16870 if ((*SATA_START_FUNC(sata_hba_inst))(SATA_DIP(sata_hba_inst), spkt) !=
16871 SATA_TRAN_ACCEPTED ||
16872 spkt->satapkt_reason != SATA_PKT_COMPLETED) {
16873 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst,
16874 sdinfo->satadrv_addr.cport)));
16875 /*
16876 * Whoops, no SMART DATA available
16877 */
16878 rval = -1;
16879 goto fail;
16880 } else {
16881 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst,
16882 sdinfo->satadrv_addr.cport)));
16883 if (spx->txlt_buf_dma_handle != NULL) {
16884 rval = ddi_dma_sync(spx->txlt_buf_dma_handle, 0, 0,
16885 DDI_DMA_SYNC_FORKERNEL);
16886 ASSERT(rval == DDI_SUCCESS);
16887 if (sata_check_for_dma_error(dip, spx)) {
16888 ddi_fm_service_impact(dip,
16889 DDI_SERVICE_UNAFFECTED);
16890 rval = -1;
16891 goto fail;
16892 }
16893 }
16894 bcopy(scmd->satacmd_bp->b_un.b_addr, (uint8_t *)smart_data,
16895 sizeof (struct smart_data));
16896 }
16897
16898 fail:
16899 /* Free allocated resources */
16900 sata_free_local_buffer(spx);
16901 sata_pkt_free(spx);
16902 kmem_free(spx, sizeof (sata_pkt_txlate_t));
16903
16904 return (rval);
16905 }
16906
16907 /*
16908 * Used by LOG SENSE page 0x10
16909 * Reads (in synchronous mode) the self test log data using Read Log Ext cmd.
16910 * Note: cannot be called in the interrupt context.
16911 *
16912 * return 0 for success, -1 otherwise
16913 *
16914 */
16915 static int
16916 sata_ext_smart_selftest_read_log(
16917 sata_hba_inst_t *sata_hba_inst,
16918 sata_drive_info_t *sdinfo,
16919 struct smart_ext_selftest_log *ext_selftest_log,
16920 uint16_t block_num)
16921 {
16922 sata_pkt_txlate_t *spx;
16923 sata_pkt_t *spkt;
16924 sata_cmd_t *scmd;
16925 int rval;
16926 dev_info_t *dip = SATA_DIP(sata_hba_inst);
16927
16928 #if ! defined(lint)
16929 ASSERT(sizeof (struct smart_ext_selftest_log) == 512);
16930 #endif
16931
16932 spx = kmem_zalloc(sizeof (sata_pkt_txlate_t), KM_SLEEP);
16933 spx->txlt_sata_hba_inst = sata_hba_inst;
16934 spx->txlt_scsi_pkt = NULL; /* No scsi pkt involved */
16935 spkt = sata_pkt_alloc(spx, SLEEP_FUNC);
16936 if (spkt == NULL) {
16937 kmem_free(spx, sizeof (sata_pkt_txlate_t));
16938 return (-1);
16939 }
16940 /* address is needed now */
16941 spkt->satapkt_device.satadev_addr = sdinfo->satadrv_addr;
16942
16943
16944 /* Fill sata_pkt */
16945 spkt->satapkt_device.satadev_addr = sdinfo->satadrv_addr;
16946 spkt->satapkt_op_mode = SATA_OPMODE_SYNCH | SATA_OPMODE_INTERRUPTS;
16947 /* Synchronous mode, no callback */
16948 spkt->satapkt_comp = NULL;
16949 /* Timeout 30s */
16950 spkt->satapkt_time = sata_default_pkt_time;
16951
16952 scmd = &spkt->satapkt_cmd;
16953 scmd->satacmd_flags.sata_data_direction = SATA_DIR_READ;
16954
16955 /*
16956 * Allocate buffer for SMART extended self-test log
16957 */
16958 scmd->satacmd_bp = sata_alloc_local_buffer(spx,
16959 sizeof (struct smart_ext_selftest_log));
16960 if (scmd->satacmd_bp == NULL) {
16961 sata_pkt_free(spx);
16962 kmem_free(spx, sizeof (sata_pkt_txlate_t));
16963 SATA_LOG_D((sata_hba_inst, CE_WARN,
16964 "sata_ext_smart_selftest_log: "
16965 "cannot allocate buffer"));
16966 return (-1);
16967 }
16968
16969 /* Build READ LOG EXT w/ extended self-test log cmd in the sata_pkt */
16970 scmd->satacmd_addr_type = ATA_ADDR_LBA48;
16971 scmd->satacmd_sec_count_lsb = 1; /* One sector of selftest log */
16972 scmd->satacmd_sec_count_msb = 0; /* One sector of selftest log */
16973 scmd->satacmd_lba_low_lsb = EXT_SMART_SELFTEST_LOG_PAGE;
16974 scmd->satacmd_lba_low_msb = 0;
16975 scmd->satacmd_lba_mid_lsb = block_num & 0xff;
16976 scmd->satacmd_lba_mid_msb = block_num >> 8;
16977 scmd->satacmd_device_reg = 0; /* Always device 0 */
16978 scmd->satacmd_cmd_reg = SATAC_READ_LOG_EXT;
16979
16980 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst,
16981 sdinfo->satadrv_addr.cport)));
16982
16983 /* Send pkt to SATA HBA driver */
16984 if ((*SATA_START_FUNC(sata_hba_inst))(SATA_DIP(sata_hba_inst), spkt) !=
16985 SATA_TRAN_ACCEPTED ||
16986 spkt->satapkt_reason != SATA_PKT_COMPLETED) {
16987 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst,
16988 sdinfo->satadrv_addr.cport)));
16989
16990 /*
16991 * Whoops, no SMART selftest log info available
16992 */
16993 rval = -1;
16994 goto fail;
16995 } else {
16996 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst,
16997 sdinfo->satadrv_addr.cport)));
16998
16999 if (spx->txlt_buf_dma_handle != NULL) {
17000 rval = ddi_dma_sync(spx->txlt_buf_dma_handle, 0, 0,
17001 DDI_DMA_SYNC_FORKERNEL);
17002 ASSERT(rval == DDI_SUCCESS);
17003 if (sata_check_for_dma_error(dip, spx)) {
17004 ddi_fm_service_impact(dip,
17005 DDI_SERVICE_UNAFFECTED);
17006 rval = -1;
17007 goto fail;
17008 }
17009 }
17010 bcopy(scmd->satacmd_bp->b_un.b_addr,
17011 (uint8_t *)ext_selftest_log,
17012 sizeof (struct smart_ext_selftest_log));
17013 rval = 0;
17014 }
17015
17016 fail:
17017 /* Free allocated resources */
17018 sata_free_local_buffer(spx);
17019 sata_pkt_free(spx);
17020 kmem_free(spx, sizeof (sata_pkt_txlate_t));
17021
17022 return (rval);
17023 }
17024
17025 /*
17026 * Returns 0 for success, -1 otherwise
17027 *
17028 * SMART self-test log data is returned in buffer pointed to by selftest_log
17029 */
17030 static int
17031 sata_smart_selftest_log(
17032 sata_hba_inst_t *sata_hba_inst,
17033 sata_drive_info_t *sdinfo,
17034 struct smart_selftest_log *selftest_log)
17035 {
17036 sata_pkt_t *spkt;
17037 sata_cmd_t *scmd;
17038 sata_pkt_txlate_t *spx;
17039 int rval;
17040 dev_info_t *dip = SATA_DIP(sata_hba_inst);
17041
17042 #if ! defined(lint)
17043 ASSERT(sizeof (struct smart_selftest_log) == 512);
17044 #endif
17045
17046 spx = kmem_zalloc(sizeof (sata_pkt_txlate_t), KM_SLEEP);
17047 spx->txlt_sata_hba_inst = sata_hba_inst;
17048 spx->txlt_scsi_pkt = NULL; /* No scsi pkt involved */
17049 spkt = sata_pkt_alloc(spx, SLEEP_FUNC);
17050 if (spkt == NULL) {
17051 kmem_free(spx, sizeof (sata_pkt_txlate_t));
17052 return (-1);
17053 }
17054 /* address is needed now */
17055 spkt->satapkt_device.satadev_addr = sdinfo->satadrv_addr;
17056
17057
17058 /* Fill sata_pkt */
17059 spkt->satapkt_device.satadev_addr = sdinfo->satadrv_addr;
17060 spkt->satapkt_op_mode = SATA_OPMODE_SYNCH | SATA_OPMODE_INTERRUPTS;
17061 /* Synchronous mode, no callback */
17062 spkt->satapkt_comp = NULL;
17063 /* Timeout 30s */
17064 spkt->satapkt_time = sata_default_pkt_time;
17065
17066 scmd = &spkt->satapkt_cmd;
17067 scmd->satacmd_flags.sata_data_direction = SATA_DIR_READ;
17068
17069 /*
17070 * Allocate buffer for SMART SELFTEST LOG
17071 */
17072 scmd->satacmd_bp = sata_alloc_local_buffer(spx,
17073 sizeof (struct smart_selftest_log));
17074 if (scmd->satacmd_bp == NULL) {
17075 sata_pkt_free(spx);
17076 kmem_free(spx, sizeof (sata_pkt_txlate_t));
17077 SATA_LOG_D((sata_hba_inst, CE_WARN,
17078 "sata_smart_selftest_log: "
17079 "cannot allocate buffer"));
17080 return (-1);
17081 }
17082
17083 /* Build SMART_READ_LOG cmd in the sata_pkt */
17084 scmd->satacmd_addr_type = 0; /* N/A */
17085 scmd->satacmd_sec_count_lsb = 1; /* One sector of SMART log */
17086 scmd->satacmd_lba_low_lsb = SMART_SELFTEST_LOG_PAGE;
17087 scmd->satacmd_lba_mid_lsb = SMART_MAGIC_VAL_1;
17088 scmd->satacmd_lba_high_lsb = SMART_MAGIC_VAL_2;
17089 scmd->satacmd_features_reg = SATA_SMART_READ_LOG;
17090 scmd->satacmd_device_reg = 0; /* Always device 0 */
17091 scmd->satacmd_cmd_reg = SATAC_SMART;
17092 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst,
17093 sdinfo->satadrv_addr.cport)));
17094
17095 /* Send pkt to SATA HBA driver */
17096 if ((*SATA_START_FUNC(sata_hba_inst))(SATA_DIP(sata_hba_inst), spkt) !=
17097 SATA_TRAN_ACCEPTED ||
17098 spkt->satapkt_reason != SATA_PKT_COMPLETED) {
17099 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst,
17100 sdinfo->satadrv_addr.cport)));
17101 /*
17102 * Whoops, no SMART DATA available
17103 */
17104 rval = -1;
17105 goto fail;
17106 } else {
17107 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst,
17108 sdinfo->satadrv_addr.cport)));
17109 if (spx->txlt_buf_dma_handle != NULL) {
17110 rval = ddi_dma_sync(spx->txlt_buf_dma_handle, 0, 0,
17111 DDI_DMA_SYNC_FORKERNEL);
17112 ASSERT(rval == DDI_SUCCESS);
17113 if (sata_check_for_dma_error(dip, spx)) {
17114 ddi_fm_service_impact(dip,
17115 DDI_SERVICE_UNAFFECTED);
17116 rval = -1;
17117 goto fail;
17118 }
17119 }
17120 bcopy(scmd->satacmd_bp->b_un.b_addr, (uint8_t *)selftest_log,
17121 sizeof (struct smart_selftest_log));
17122 rval = 0;
17123 }
17124
17125 fail:
17126 /* Free allocated resources */
17127 sata_free_local_buffer(spx);
17128 sata_pkt_free(spx);
17129 kmem_free(spx, sizeof (sata_pkt_txlate_t));
17130
17131 return (rval);
17132 }
17133
17134
17135 /*
17136 * Returns 0 for success, -1 otherwise
17137 *
17138 * SMART READ LOG data is returned in buffer pointed to by smart_log
17139 */
17140 static int
17141 sata_smart_read_log(
17142 sata_hba_inst_t *sata_hba_inst,
17143 sata_drive_info_t *sdinfo,
17144 uint8_t *smart_log, /* where the data should be returned */
17145 uint8_t which_log, /* which log should be returned */
17146 uint8_t log_size) /* # of 512 bytes in log */
17147 {
17148 sata_pkt_t *spkt;
17149 sata_cmd_t *scmd;
17150 sata_pkt_txlate_t *spx;
17151 int rval;
17152 dev_info_t *dip = SATA_DIP(sata_hba_inst);
17153
17154 spx = kmem_zalloc(sizeof (sata_pkt_txlate_t), KM_SLEEP);
17155 spx->txlt_sata_hba_inst = sata_hba_inst;
17156 spx->txlt_scsi_pkt = NULL; /* No scsi pkt involved */
17157 spkt = sata_pkt_alloc(spx, SLEEP_FUNC);
17158 if (spkt == NULL) {
17159 kmem_free(spx, sizeof (sata_pkt_txlate_t));
17160 return (-1);
17161 }
17162 /* address is needed now */
17163 spkt->satapkt_device.satadev_addr = sdinfo->satadrv_addr;
17164
17165
17166 /* Fill sata_pkt */
17167 spkt->satapkt_device.satadev_addr = sdinfo->satadrv_addr;
17168 spkt->satapkt_op_mode = SATA_OPMODE_SYNCH | SATA_OPMODE_INTERRUPTS;
17169 /* Synchronous mode, no callback */
17170 spkt->satapkt_comp = NULL;
17171 /* Timeout 30s */
17172 spkt->satapkt_time = sata_default_pkt_time;
17173
17174 scmd = &spkt->satapkt_cmd;
17175 scmd->satacmd_flags.sata_data_direction = SATA_DIR_READ;
17176
17177 /*
17178 * Allocate buffer for SMART READ LOG
17179 */
17180 scmd->satacmd_bp = sata_alloc_local_buffer(spx, log_size * 512);
17181 if (scmd->satacmd_bp == NULL) {
17182 sata_pkt_free(spx);
17183 kmem_free(spx, sizeof (sata_pkt_txlate_t));
17184 SATA_LOG_D((sata_hba_inst, CE_WARN,
17185 "sata_smart_read_log: " "cannot allocate buffer"));
17186 return (-1);
17187 }
17188
17189 /* Build SMART_READ_LOG cmd in the sata_pkt */
17190 scmd->satacmd_addr_type = 0; /* N/A */
17191 scmd->satacmd_sec_count_lsb = log_size; /* what the caller asked for */
17192 scmd->satacmd_lba_low_lsb = which_log; /* which log page */
17193 scmd->satacmd_lba_mid_lsb = SMART_MAGIC_VAL_1;
17194 scmd->satacmd_lba_high_lsb = SMART_MAGIC_VAL_2;
17195 scmd->satacmd_features_reg = SATA_SMART_READ_LOG;
17196 scmd->satacmd_device_reg = 0; /* Always device 0 */
17197 scmd->satacmd_cmd_reg = SATAC_SMART;
17198
17199 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst,
17200 sdinfo->satadrv_addr.cport)));
17201
17202 /* Send pkt to SATA HBA driver */
17203 if ((*SATA_START_FUNC(sata_hba_inst))(SATA_DIP(sata_hba_inst), spkt) !=
17204 SATA_TRAN_ACCEPTED ||
17205 spkt->satapkt_reason != SATA_PKT_COMPLETED) {
17206 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst,
17207 sdinfo->satadrv_addr.cport)));
17208
17209 /*
17210 * Whoops, no SMART DATA available
17211 */
17212 rval = -1;
17213 goto fail;
17214 } else {
17215 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst,
17216 sdinfo->satadrv_addr.cport)));
17217
17218 if (spx->txlt_buf_dma_handle != NULL) {
17219 rval = ddi_dma_sync(spx->txlt_buf_dma_handle, 0, 0,
17220 DDI_DMA_SYNC_FORKERNEL);
17221 ASSERT(rval == DDI_SUCCESS);
17222 if (sata_check_for_dma_error(dip, spx)) {
17223 ddi_fm_service_impact(dip,
17224 DDI_SERVICE_UNAFFECTED);
17225 rval = -1;
17226 goto fail;
17227 }
17228 }
17229 bcopy(scmd->satacmd_bp->b_un.b_addr, smart_log, log_size * 512);
17230 rval = 0;
17231 }
17232
17233 fail:
17234 /* Free allocated resources */
17235 sata_free_local_buffer(spx);
17236 sata_pkt_free(spx);
17237 kmem_free(spx, sizeof (sata_pkt_txlate_t));
17238
17239 return (rval);
17240 }
17241
17242 /*
17243 * Used by LOG SENSE page 0x10
17244 *
17245 * return 0 for success, -1 otherwise
17246 *
17247 */
17248 static int
17249 sata_read_log_ext_directory(
17250 sata_hba_inst_t *sata_hba_inst,
17251 sata_drive_info_t *sdinfo,
17252 struct read_log_ext_directory *logdir)
17253 {
17254 sata_pkt_txlate_t *spx;
17255 sata_pkt_t *spkt;
17256 sata_cmd_t *scmd;
17257 int rval;
17258 dev_info_t *dip = SATA_DIP(sata_hba_inst);
17259
17260 #if ! defined(lint)
17261 ASSERT(sizeof (struct read_log_ext_directory) == 512);
17262 #endif
17263
17264 spx = kmem_zalloc(sizeof (sata_pkt_txlate_t), KM_SLEEP);
17265 spx->txlt_sata_hba_inst = sata_hba_inst;
17266 spx->txlt_scsi_pkt = NULL; /* No scsi pkt involved */
17267 spkt = sata_pkt_alloc(spx, SLEEP_FUNC);
17268 if (spkt == NULL) {
17269 kmem_free(spx, sizeof (sata_pkt_txlate_t));
17270 return (-1);
17271 }
17272
17273 /* Fill sata_pkt */
17274 spkt->satapkt_device.satadev_addr = sdinfo->satadrv_addr;
17275 spkt->satapkt_op_mode = SATA_OPMODE_SYNCH | SATA_OPMODE_INTERRUPTS;
17276 /* Synchronous mode, no callback */
17277 spkt->satapkt_comp = NULL;
17278 /* Timeout 30s */
17279 spkt->satapkt_time = sata_default_pkt_time;
17280
17281 scmd = &spkt->satapkt_cmd;
17282 scmd->satacmd_flags.sata_data_direction = SATA_DIR_READ;
17283
17284 /*
17285 * Allocate buffer for SMART READ LOG EXTENDED command
17286 */
17287 scmd->satacmd_bp = sata_alloc_local_buffer(spx,
17288 sizeof (struct read_log_ext_directory));
17289 if (scmd->satacmd_bp == NULL) {
17290 sata_pkt_free(spx);
17291 kmem_free(spx, sizeof (sata_pkt_txlate_t));
17292 SATA_LOG_D((sata_hba_inst, CE_WARN,
17293 "sata_read_log_ext_directory: "
17294 "cannot allocate buffer"));
17295 return (-1);
17296 }
17297
17298 /* Build READ LOG EXT w/ log directory cmd in the sata_pkt */
17299 scmd->satacmd_addr_type = ATA_ADDR_LBA48;
17300 scmd->satacmd_sec_count_lsb = 1; /* One sector of directory */
17301 scmd->satacmd_sec_count_msb = 0; /* One sector of directory */
17302 scmd->satacmd_lba_low_lsb = READ_LOG_EXT_LOG_DIRECTORY;
17303 scmd->satacmd_lba_low_msb = 0;
17304 scmd->satacmd_lba_mid_lsb = 0;
17305 scmd->satacmd_lba_mid_msb = 0;
17306 scmd->satacmd_device_reg = 0; /* Always device 0 */
17307 scmd->satacmd_cmd_reg = SATAC_READ_LOG_EXT;
17308
17309 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst,
17310 sdinfo->satadrv_addr.cport)));
17311
17312 /* Send pkt to SATA HBA driver */
17313 if ((*SATA_START_FUNC(sata_hba_inst))(SATA_DIP(sata_hba_inst), spkt) !=
17314 SATA_TRAN_ACCEPTED ||
17315 spkt->satapkt_reason != SATA_PKT_COMPLETED) {
17316 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst,
17317 sdinfo->satadrv_addr.cport)));
17318 /*
17319 * Whoops, no SMART selftest log info available
17320 */
17321 rval = -1;
17322 goto fail;
17323 } else {
17324 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst,
17325 sdinfo->satadrv_addr.cport)));
17326 if (spx->txlt_buf_dma_handle != NULL) {
17327 rval = ddi_dma_sync(spx->txlt_buf_dma_handle, 0, 0,
17328 DDI_DMA_SYNC_FORKERNEL);
17329 ASSERT(rval == DDI_SUCCESS);
17330 if (sata_check_for_dma_error(dip, spx)) {
17331 ddi_fm_service_impact(dip,
17332 DDI_SERVICE_UNAFFECTED);
17333 rval = -1;
17334 goto fail;
17335 }
17336 }
17337 bcopy(scmd->satacmd_bp->b_un.b_addr, (uint8_t *)logdir,
17338 sizeof (struct read_log_ext_directory));
17339 rval = 0;
17340 }
17341
17342 fail:
17343 /* Free allocated resources */
17344 sata_free_local_buffer(spx);
17345 sata_pkt_free(spx);
17346 kmem_free(spx, sizeof (sata_pkt_txlate_t));
17347
17348 return (rval);
17349 }
17350
17351 /*
17352 * Set up error retrieval sata command for NCQ command error data
17353 * recovery.
17354 *
17355 * Returns SATA_SUCCESS when data buffer is allocated and packet set-up,
17356 * returns SATA_FAILURE otherwise.
17357 */
17358 static int
17359 sata_ncq_err_ret_cmd_setup(sata_pkt_txlate_t *spx, sata_drive_info_t *sdinfo)
17360 {
17361 #ifndef __lock_lint
17362 _NOTE(ARGUNUSED(sdinfo))
17363 #endif
17364
17365 sata_pkt_t *spkt = spx->txlt_sata_pkt;
17366 sata_cmd_t *scmd;
17367 struct buf *bp;
17368
17369 /* Operation modes are up to the caller */
17370 spkt->satapkt_op_mode = SATA_OPMODE_SYNCH | SATA_OPMODE_INTERRUPTS;
17371
17372 /* Synchronous mode, no callback - may be changed by the caller */
17373 spkt->satapkt_comp = NULL;
17374 spkt->satapkt_time = sata_default_pkt_time;
17375
17376 scmd = &spkt->satapkt_cmd;
17377 bcopy(&sata_rle_cmd, scmd, sizeof (sata_cmd_t));
17378 scmd->satacmd_flags.sata_ignore_dev_reset = B_TRUE;
17379
17380 /*
17381 * Allocate dma_able buffer error data.
17382 * Buffer allocation will take care of buffer alignment and other DMA
17383 * attributes.
17384 */
17385 bp = sata_alloc_local_buffer(spx,
17386 sizeof (struct sata_ncq_error_recovery_page));
17387 if (bp == NULL)
17388 return (SATA_FAILURE);
17389
17390 bp_mapin(bp); /* make data buffer accessible */
17391 scmd->satacmd_bp = bp;
17392
17393 /*
17394 * Set-up pointer to the buffer handle, so HBA can sync buffer
17395 * before accessing it. Handle is in usual place in translate struct.
17396 */
17397 scmd->satacmd_err_ret_buf_handle = &spx->txlt_buf_dma_handle;
17398
17399 ASSERT(scmd->satacmd_num_dma_cookies != 0);
17400 ASSERT(scmd->satacmd_dma_cookie_list != NULL);
17401
17402 return (SATA_SUCCESS);
17403 }
17404
17405 /*
17406 * sata_xlate_errors() is used to translate (S)ATA error
17407 * information to SCSI information returned in the SCSI
17408 * packet.
17409 */
17410 static void
17411 sata_xlate_errors(sata_pkt_txlate_t *spx)
17412 {
17413 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt;
17414 struct scsi_extended_sense *sense;
17415
17416 scsipkt->pkt_reason = CMD_INCOMPLETE;
17417 *scsipkt->pkt_scbp = STATUS_CHECK;
17418 sense = sata_arq_sense(spx);
17419
17420 switch (spx->txlt_sata_pkt->satapkt_reason) {
17421 case SATA_PKT_PORT_ERROR:
17422 /*
17423 * We have no device data. Assume no data transfered.
17424 */
17425 sense->es_key = KEY_HARDWARE_ERROR;
17426 break;
17427
17428 case SATA_PKT_DEV_ERROR:
17429 if (spx->txlt_sata_pkt->satapkt_cmd.satacmd_status_reg &
17430 SATA_STATUS_ERR) {
17431 /*
17432 * determine dev error reason from error
17433 * reg content
17434 */
17435 sata_decode_device_error(spx, sense);
17436 break;
17437 }
17438 /* No extended sense key - no info available */
17439 break;
17440
17441 case SATA_PKT_TIMEOUT:
17442 scsipkt->pkt_reason = CMD_TIMEOUT;
17443 scsipkt->pkt_statistics |= STAT_TIMEOUT | STAT_DEV_RESET;
17444 /* No extended sense key */
17445 break;
17446
17447 case SATA_PKT_ABORTED:
17448 scsipkt->pkt_reason = CMD_ABORTED;
17449 scsipkt->pkt_statistics |= STAT_ABORTED;
17450 /* No extended sense key */
17451 break;
17452
17453 case SATA_PKT_RESET:
17454 /*
17455 * pkt aborted either by an explicit reset request from
17456 * a host, or due to error recovery
17457 */
17458 scsipkt->pkt_reason = CMD_RESET;
17459 scsipkt->pkt_statistics |= STAT_DEV_RESET;
17460 break;
17461
17462 default:
17463 scsipkt->pkt_reason = CMD_TRAN_ERR;
17464 break;
17465 }
17466 }
17467
17468
17469
17470
17471 /*
17472 * Log sata message
17473 * dev pathname msg line preceeds the logged message.
17474 */
17475
17476 static void
17477 sata_log(sata_hba_inst_t *sata_hba_inst, uint_t level, char *fmt, ...)
17478 {
17479 char pathname[128];
17480 dev_info_t *dip = NULL;
17481 va_list ap;
17482
17483 mutex_enter(&sata_log_mutex);
17484
17485 va_start(ap, fmt);
17486 (void) vsprintf(sata_log_buf, fmt, ap);
17487 va_end(ap);
17488
17489 if (sata_hba_inst != NULL) {
17490 dip = SATA_DIP(sata_hba_inst);
17491 (void) ddi_pathname(dip, pathname);
17492 } else {
17493 pathname[0] = 0;
17494 }
17495 if (level == CE_CONT) {
17496 if (sata_debug_flags == 0)
17497 cmn_err(level, "?%s:\n %s\n", pathname, sata_log_buf);
17498 else
17499 cmn_err(level, "%s:\n %s\n", pathname, sata_log_buf);
17500 } else {
17501 if (level != CE_NOTE) {
17502 cmn_err(level, "%s:\n %s", pathname, sata_log_buf);
17503 } else if (sata_msg) {
17504 cmn_err(level, "%s:\n %s", pathname,
17505 sata_log_buf);
17506 }
17507 }
17508
17509 /* sata trace debug */
17510 sata_trace_debug(dip, sata_log_buf);
17511
17512 mutex_exit(&sata_log_mutex);
17513 }
17514
17515
17516 /* ******** Asynchronous HBA events handling & hotplugging support ******** */
17517
17518 /*
17519 * Start or terminate the thread, depending on flag arg and current state
17520 */
17521 static void
17522 sata_event_thread_control(int startstop)
17523 {
17524 static int sata_event_thread_terminating = 0;
17525 static int sata_event_thread_starting = 0;
17526 int i;
17527
17528 mutex_enter(&sata_event_mutex);
17529
17530 if (startstop == 0 && (sata_event_thread_starting == 1 ||
17531 sata_event_thread_terminating == 1)) {
17532 mutex_exit(&sata_event_mutex);
17533 return;
17534 }
17535 if (startstop == 1 && sata_event_thread_starting == 1) {
17536 mutex_exit(&sata_event_mutex);
17537 return;
17538 }
17539 if (startstop == 1 && sata_event_thread_terminating == 1) {
17540 sata_event_thread_starting = 1;
17541 /* wait til terminate operation completes */
17542 i = SATA_EVNT_DAEMON_TERM_WAIT/SATA_EVNT_DAEMON_TERM_TIMEOUT;
17543 while (sata_event_thread_terminating == 1) {
17544 if (i-- <= 0) {
17545 sata_event_thread_starting = 0;
17546 mutex_exit(&sata_event_mutex);
17547 #ifdef SATA_DEBUG
17548 cmn_err(CE_WARN, "sata_event_thread_control: "
17549 "timeout waiting for thread to terminate");
17550 #endif
17551 return;
17552 }
17553 mutex_exit(&sata_event_mutex);
17554 delay(drv_usectohz(SATA_EVNT_DAEMON_TERM_TIMEOUT));
17555 mutex_enter(&sata_event_mutex);
17556 }
17557 }
17558 if (startstop == 1) {
17559 if (sata_event_thread == NULL) {
17560 sata_event_thread = thread_create(NULL, 0,
17561 (void (*)())sata_event_daemon,
17562 &sata_hba_list, 0, &p0, TS_RUN, minclsyspri);
17563 }
17564 sata_event_thread_starting = 0;
17565 mutex_exit(&sata_event_mutex);
17566 return;
17567 }
17568
17569 /*
17570 * If we got here, thread may need to be terminated
17571 */
17572 if (sata_event_thread != NULL) {
17573 int i;
17574 /* Signal event thread to go away */
17575 sata_event_thread_terminating = 1;
17576 sata_event_thread_terminate = 1;
17577 cv_signal(&sata_event_cv);
17578 /*
17579 * Wait til daemon terminates.
17580 */
17581 i = SATA_EVNT_DAEMON_TERM_WAIT/SATA_EVNT_DAEMON_TERM_TIMEOUT;
17582 while (sata_event_thread_terminate == 1) {
17583 mutex_exit(&sata_event_mutex);
17584 if (i-- <= 0) {
17585 /* Daemon did not go away !!! */
17586 #ifdef SATA_DEBUG
17587 cmn_err(CE_WARN, "sata_event_thread_control: "
17588 "cannot terminate event daemon thread");
17589 #endif
17590 mutex_enter(&sata_event_mutex);
17591 break;
17592 }
17593 delay(drv_usectohz(SATA_EVNT_DAEMON_TERM_TIMEOUT));
17594 mutex_enter(&sata_event_mutex);
17595 }
17596 sata_event_thread_terminating = 0;
17597 }
17598 ASSERT(sata_event_thread_terminating == 0);
17599 ASSERT(sata_event_thread_starting == 0);
17600 mutex_exit(&sata_event_mutex);
17601 }
17602
17603
17604 /*
17605 * SATA HBA event notification function.
17606 * Events reported by SATA HBA drivers per HBA instance relate to a change in
17607 * a port and/or device state or a controller itself.
17608 * Events for different addresses/addr types cannot be combined.
17609 * A warning message is generated for each event type.
17610 * Events are not processed by this function, so only the
17611 * event flag(s)is set for an affected entity and the event thread is
17612 * waken up. Event daemon thread processes all events.
17613 *
17614 * NOTE: Since more than one event may be reported at the same time, one
17615 * cannot determine a sequence of events when opposite event are reported, eg.
17616 * LINK_LOST and LINK_ESTABLISHED. Actual port status during event processing
17617 * is taking precedence over reported events, i.e. may cause ignoring some
17618 * events.
17619 */
17620 #define SATA_EVENT_MAX_MSG_LENGTH 79
17621
17622 void
17623 sata_hba_event_notify(dev_info_t *dip, sata_device_t *sata_device, int event)
17624 {
17625 sata_hba_inst_t *sata_hba_inst = NULL;
17626 sata_address_t *saddr;
17627 sata_pmult_info_t *pmultinfo;
17628 sata_drive_info_t *sdinfo;
17629 sata_port_stats_t *pstats;
17630 sata_cport_info_t *cportinfo;
17631 sata_pmport_info_t *pmportinfo;
17632 int cport, pmport;
17633 char buf1[SATA_EVENT_MAX_MSG_LENGTH + 1];
17634 char buf2[SATA_EVENT_MAX_MSG_LENGTH + 1];
17635 char *lcp;
17636 static char *err_msg_evnt_1 =
17637 "sata_hba_event_notify: invalid port event 0x%x ";
17638 static char *err_msg_evnt_2 =
17639 "sata_hba_event_notify: invalid device event 0x%x ";
17640 int linkevent;
17641
17642 /*
17643 * There is a possibility that an event will be generated on HBA
17644 * that has not completed attachment or is detaching. We still want
17645 * to process events until HBA is detached.
17646 */
17647 mutex_enter(&sata_mutex);
17648 for (sata_hba_inst = sata_hba_list; sata_hba_inst != NULL;
17649 sata_hba_inst = sata_hba_inst->satahba_next) {
17650 if (SATA_DIP(sata_hba_inst) == dip)
17651 if (sata_hba_inst->satahba_attached == 1)
17652 break;
17653 }
17654 mutex_exit(&sata_mutex);
17655 if (sata_hba_inst == NULL)
17656 /* HBA not attached */
17657 return;
17658
17659 ASSERT(sata_device != NULL);
17660
17661 /*
17662 * Validate address before - do not proceed with invalid address.
17663 */
17664 saddr = &sata_device->satadev_addr;
17665 if (saddr->cport >= SATA_NUM_CPORTS(sata_hba_inst))
17666 return;
17667
17668 cport = saddr->cport;
17669 pmport = saddr->pmport;
17670
17671 buf1[0] = buf2[0] = '\0';
17672
17673 /*
17674 * If event relates to port or device, check port state.
17675 * Port has to be initialized, or we cannot accept an event.
17676 */
17677 if ((saddr->qual & (SATA_ADDR_CPORT | SATA_ADDR_PMPORT |
17678 SATA_ADDR_DCPORT | SATA_ADDR_DPMPORT | SATA_ADDR_PMULT)) != 0) {
17679 mutex_enter(&sata_hba_inst->satahba_mutex);
17680 cportinfo = SATA_CPORT_INFO(sata_hba_inst, cport);
17681 mutex_exit(&sata_hba_inst->satahba_mutex);
17682 if (cportinfo == NULL || cportinfo->cport_state == 0)
17683 return;
17684 }
17685
17686 if ((saddr->qual & (SATA_ADDR_PMULT | SATA_ADDR_PMPORT |
17687 SATA_ADDR_DPMPORT)) != 0) {
17688 if (cportinfo->cport_dev_type != SATA_DTYPE_PMULT) {
17689 SATA_LOG_D((sata_hba_inst, CE_WARN,
17690 "sata_hba_event_notify: Non-pmult device (0x%x)"
17691 "is attached to port %d, ignore pmult/pmport "
17692 "event 0x%x", cportinfo->cport_dev_type,
17693 cport, event));
17694 return;
17695 }
17696
17697 mutex_enter(&cportinfo->cport_mutex);
17698 pmultinfo = SATA_PMULT_INFO(sata_hba_inst, cport);
17699 mutex_exit(&cportinfo->cport_mutex);
17700
17701 /*
17702 * The daemon might be processing attachment of port
17703 * multiplier, in that case we should ignore events on its
17704 * sub-devices.
17705 *
17706 * NOTE: Only pmult_state is checked in sata_hba_event_notify.
17707 * The pmport_state is checked by sata daemon.
17708 */
17709 if (pmultinfo == NULL ||
17710 pmultinfo->pmult_state == SATA_STATE_UNKNOWN) {
17711 SATA_LOG_D((sata_hba_inst, CE_WARN,
17712 "sata_hba_event_notify: pmult is not"
17713 "available at port %d:%d, ignore event 0x%x",
17714 cport, pmport, event));
17715 return;
17716 }
17717 }
17718
17719 if ((saddr->qual &
17720 (SATA_ADDR_PMPORT | SATA_ADDR_DPMPORT)) != 0) {
17721
17722 mutex_enter(&cportinfo->cport_mutex);
17723 if (pmport > SATA_NUM_PMPORTS(sata_hba_inst, cport)) {
17724 SATA_LOG_D((sata_hba_inst, CE_WARN,
17725 "sata_hba_event_notify: invalid/"
17726 "un-implemented port %d:%d (%d ports), "
17727 "ignore event 0x%x", cport, pmport,
17728 SATA_NUM_PMPORTS(sata_hba_inst, cport), event));
17729 mutex_exit(&cportinfo->cport_mutex);
17730 return;
17731 }
17732 mutex_exit(&cportinfo->cport_mutex);
17733
17734 mutex_enter(&sata_hba_inst->satahba_mutex);
17735 pmportinfo = SATA_PMPORT_INFO(sata_hba_inst,
17736 cport, pmport);
17737 mutex_exit(&sata_hba_inst->satahba_mutex);
17738
17739 /* pmport is implemented/valid? */
17740 if (pmportinfo == NULL) {
17741 SATA_LOG_D((sata_hba_inst, CE_WARN,
17742 "sata_hba_event_notify: invalid/"
17743 "un-implemented port %d:%d, ignore "
17744 "event 0x%x", cport, pmport, event));
17745 return;
17746 }
17747 }
17748
17749 /*
17750 * Events refer to devices, ports and controllers - each has
17751 * unique address. Events for different addresses cannot be combined.
17752 */
17753 if (saddr->qual & (SATA_ADDR_CPORT | SATA_ADDR_PMPORT)) {
17754
17755 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, cport)));
17756
17757 /* qualify this event(s) */
17758 if ((event & SATA_EVNT_PORT_EVENTS) == 0) {
17759 /* Invalid event for the device port */
17760 (void) sprintf(buf2, err_msg_evnt_1,
17761 event & SATA_EVNT_PORT_EVENTS);
17762 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, cport)));
17763 goto event_info;
17764 }
17765 if (saddr->qual == SATA_ADDR_CPORT) {
17766 /* Controller's device port event */
17767
17768 (SATA_CPORT_INFO(sata_hba_inst, cport))->
17769 cport_event_flags |=
17770 event & SATA_EVNT_PORT_EVENTS;
17771 pstats =
17772 &(SATA_CPORT_INFO(sata_hba_inst, cport))->
17773 cport_stats;
17774 } else {
17775 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, cport)));
17776 mutex_enter(&pmportinfo->pmport_mutex);
17777 /* Port multiplier's device port event */
17778 (SATA_PMPORT_INFO(sata_hba_inst, cport, pmport))->
17779 pmport_event_flags |=
17780 event & SATA_EVNT_PORT_EVENTS;
17781 pstats =
17782 &(SATA_PMPORT_INFO(sata_hba_inst, cport, pmport))->
17783 pmport_stats;
17784 mutex_exit(&pmportinfo->pmport_mutex);
17785 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, cport)));
17786 }
17787
17788 /*
17789 * Add to statistics and log the message. We have to do it
17790 * here rather than in the event daemon, because there may be
17791 * multiple events occuring before they are processed.
17792 */
17793 linkevent = event &
17794 (SATA_EVNT_LINK_LOST | SATA_EVNT_LINK_ESTABLISHED);
17795 if (linkevent) {
17796 if (linkevent == (SATA_EVNT_LINK_LOST |
17797 SATA_EVNT_LINK_ESTABLISHED)) {
17798 /* This is likely event combination */
17799 (void) strlcat(buf1, "link lost/established, ",
17800 SATA_EVENT_MAX_MSG_LENGTH);
17801
17802 if (pstats->link_lost < 0xffffffffffffffffULL)
17803 pstats->link_lost++;
17804 if (pstats->link_established <
17805 0xffffffffffffffffULL)
17806 pstats->link_established++;
17807 linkevent = 0;
17808 } else if (linkevent & SATA_EVNT_LINK_LOST) {
17809 (void) strlcat(buf1, "link lost, ",
17810 SATA_EVENT_MAX_MSG_LENGTH);
17811
17812 if (pstats->link_lost < 0xffffffffffffffffULL)
17813 pstats->link_lost++;
17814 } else {
17815 (void) strlcat(buf1, "link established, ",
17816 SATA_EVENT_MAX_MSG_LENGTH);
17817 if (pstats->link_established <
17818 0xffffffffffffffffULL)
17819 pstats->link_established++;
17820 }
17821 }
17822 if (event & SATA_EVNT_DEVICE_ATTACHED) {
17823 (void) strlcat(buf1, "device attached, ",
17824 SATA_EVENT_MAX_MSG_LENGTH);
17825 if (pstats->device_attached < 0xffffffffffffffffULL)
17826 pstats->device_attached++;
17827 }
17828 if (event & SATA_EVNT_DEVICE_DETACHED) {
17829 (void) strlcat(buf1, "device detached, ",
17830 SATA_EVENT_MAX_MSG_LENGTH);
17831 if (pstats->device_detached < 0xffffffffffffffffULL)
17832 pstats->device_detached++;
17833 }
17834 if (event & SATA_EVNT_PWR_LEVEL_CHANGED) {
17835 SATADBG1(SATA_DBG_EVENTS, sata_hba_inst,
17836 "port %d power level changed", cport);
17837 if (pstats->port_pwr_changed < 0xffffffffffffffffULL)
17838 pstats->port_pwr_changed++;
17839 }
17840
17841 if ((event & ~SATA_EVNT_PORT_EVENTS) != 0) {
17842 /* There should be no other events for this address */
17843 (void) sprintf(buf2, err_msg_evnt_1,
17844 event & ~SATA_EVNT_PORT_EVENTS);
17845 }
17846 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, cport)));
17847
17848 } else if (saddr->qual & (SATA_ADDR_DCPORT | SATA_ADDR_DPMPORT)) {
17849 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, cport)));
17850
17851 /* qualify this event */
17852 if ((event & SATA_EVNT_DEVICE_RESET) == 0) {
17853 /* Invalid event for a device */
17854 (void) sprintf(buf2, err_msg_evnt_2,
17855 event & SATA_EVNT_DEVICE_RESET);
17856 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, cport)));
17857 goto event_info;
17858 }
17859 /* drive event */
17860 sdinfo = sata_get_device_info(sata_hba_inst, sata_device);
17861 if (sdinfo != NULL) {
17862 if (event & SATA_EVNT_DEVICE_RESET) {
17863 (void) strlcat(buf1, "device reset, ",
17864 SATA_EVENT_MAX_MSG_LENGTH);
17865 if (sdinfo->satadrv_stats.drive_reset <
17866 0xffffffffffffffffULL)
17867 sdinfo->satadrv_stats.drive_reset++;
17868 sdinfo->satadrv_event_flags |=
17869 SATA_EVNT_DEVICE_RESET;
17870 }
17871 }
17872 if ((event & ~SATA_EVNT_DEVICE_RESET) != 0) {
17873 /* Invalid event for a device */
17874 (void) sprintf(buf2, err_msg_evnt_2,
17875 event & ~SATA_EVNT_DRIVE_EVENTS);
17876 }
17877 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, cport)));
17878 } else if (saddr->qual == SATA_ADDR_PMULT) {
17879 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, cport)));
17880
17881 /* qualify this event */
17882 if ((event & (SATA_EVNT_DEVICE_RESET |
17883 SATA_EVNT_PMULT_LINK_CHANGED)) == 0) {
17884 /* Invalid event for a port multiplier */
17885 (void) sprintf(buf2, err_msg_evnt_2,
17886 event & SATA_EVNT_DEVICE_RESET);
17887 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, cport)));
17888 goto event_info;
17889 }
17890
17891 pmultinfo = SATA_PMULT_INFO(sata_hba_inst, cport);
17892
17893 if (event & SATA_EVNT_DEVICE_RESET) {
17894
17895 SATADBG1(SATA_DBG_PMULT, sata_hba_inst,
17896 "[Reset] port-mult on cport %d", cport);
17897 pmultinfo->pmult_event_flags |=
17898 SATA_EVNT_DEVICE_RESET;
17899 (void) strlcat(buf1, "pmult reset, ",
17900 SATA_EVENT_MAX_MSG_LENGTH);
17901 }
17902
17903 if (event & SATA_EVNT_PMULT_LINK_CHANGED) {
17904
17905 SATADBG1(SATA_DBG_PMULT, sata_hba_inst,
17906 "pmult link changed on cport %d", cport);
17907 pmultinfo->pmult_event_flags |=
17908 SATA_EVNT_PMULT_LINK_CHANGED;
17909 (void) strlcat(buf1, "pmult link changed, ",
17910 SATA_EVENT_MAX_MSG_LENGTH);
17911 }
17912 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, cport)));
17913
17914 } else {
17915 if (saddr->qual != SATA_ADDR_NULL) {
17916 /* Wrong address qualifier */
17917 SATA_LOG_D((sata_hba_inst, CE_WARN,
17918 "sata_hba_event_notify: invalid address 0x%x",
17919 *(uint32_t *)saddr));
17920 return;
17921 }
17922 if ((event & SATA_EVNT_CONTROLLER_EVENTS) == 0 ||
17923 (event & ~SATA_EVNT_CONTROLLER_EVENTS) != 0) {
17924 /* Invalid event for the controller */
17925 SATA_LOG_D((sata_hba_inst, CE_WARN,
17926 "sata_hba_event_notify: invalid event 0x%x for "
17927 "controller",
17928 event & SATA_EVNT_CONTROLLER_EVENTS));
17929 return;
17930 }
17931 buf1[0] = '\0';
17932 /* This may be a frequent and not interesting event */
17933 SATADBG1(SATA_DBG_EVENTS, sata_hba_inst,
17934 "controller power level changed\n", NULL);
17935
17936 mutex_enter(&sata_hba_inst->satahba_mutex);
17937 if (sata_hba_inst->satahba_stats.ctrl_pwr_change <
17938 0xffffffffffffffffULL)
17939 sata_hba_inst->satahba_stats.ctrl_pwr_change++;
17940
17941 sata_hba_inst->satahba_event_flags |=
17942 SATA_EVNT_PWR_LEVEL_CHANGED;
17943 mutex_exit(&sata_hba_inst->satahba_mutex);
17944 }
17945 /*
17946 * If we got here, there is something to do with this HBA
17947 * instance.
17948 */
17949 mutex_enter(&sata_hba_inst->satahba_mutex);
17950 sata_hba_inst->satahba_event_flags |= SATA_EVNT_MAIN;
17951 mutex_exit(&sata_hba_inst->satahba_mutex);
17952 mutex_enter(&sata_mutex);
17953 sata_event_pending |= SATA_EVNT_MAIN; /* global event indicator */
17954 mutex_exit(&sata_mutex);
17955
17956 /* Tickle event thread */
17957 mutex_enter(&sata_event_mutex);
17958 if (sata_event_thread_active == 0)
17959 cv_signal(&sata_event_cv);
17960 mutex_exit(&sata_event_mutex);
17961
17962 event_info:
17963 if (buf1[0] != '\0') {
17964 lcp = strrchr(buf1, ',');
17965 if (lcp != NULL)
17966 *lcp = '\0';
17967 }
17968 if (saddr->qual == SATA_ADDR_CPORT ||
17969 saddr->qual == SATA_ADDR_DCPORT) {
17970 if (buf1[0] != '\0') {
17971 sata_log(sata_hba_inst, CE_NOTE, "port %d: %s\n",
17972 cport, buf1);
17973 }
17974 if (buf2[0] != '\0') {
17975 sata_log(sata_hba_inst, CE_NOTE, "port %d: %s\n",
17976 cport, buf2);
17977 }
17978 } else if (saddr->qual == SATA_ADDR_PMPORT ||
17979 saddr->qual == SATA_ADDR_DPMPORT) {
17980 if (buf1[0] != '\0') {
17981 sata_log(sata_hba_inst, CE_NOTE,
17982 "port %d pmport %d: %s\n", cport, pmport, buf1);
17983 }
17984 if (buf2[0] != '\0') {
17985 sata_log(sata_hba_inst, CE_NOTE,
17986 "port %d pmport %d: %s\n", cport, pmport, buf2);
17987 }
17988 }
17989 }
17990
17991
17992 /*
17993 * Event processing thread.
17994 * Arg is a pointer to the sata_hba_list pointer.
17995 * It is not really needed, because sata_hba_list is global and static
17996 */
17997 static void
17998 sata_event_daemon(void *arg)
17999 {
18000 #ifndef __lock_lint
18001 _NOTE(ARGUNUSED(arg))
18002 #endif
18003 sata_hba_inst_t *sata_hba_inst;
18004 clock_t delta;
18005
18006 SATADBG1(SATA_DBG_EVENTS_DAEMON, NULL,
18007 "SATA event daemon started\n", NULL);
18008 loop:
18009 /*
18010 * Process events here. Walk through all registered HBAs
18011 */
18012 mutex_enter(&sata_mutex);
18013 for (sata_hba_inst = sata_hba_list; sata_hba_inst != NULL;
18014 sata_hba_inst = sata_hba_inst->satahba_next) {
18015 ASSERT(sata_hba_inst != NULL);
18016 mutex_enter(&sata_hba_inst->satahba_mutex);
18017 if (sata_hba_inst->satahba_attached == 0 ||
18018 (sata_hba_inst->satahba_event_flags &
18019 SATA_EVNT_SKIP) != 0) {
18020 mutex_exit(&sata_hba_inst->satahba_mutex);
18021 continue;
18022 }
18023 if (sata_hba_inst->satahba_event_flags & SATA_EVNT_MAIN) {
18024 sata_hba_inst->satahba_event_flags |= SATA_EVNT_SKIP;
18025 mutex_exit(&sata_hba_inst->satahba_mutex);
18026 mutex_exit(&sata_mutex);
18027 /* Got the controller with pending event */
18028 sata_process_controller_events(sata_hba_inst);
18029 /*
18030 * Since global mutex was released, there is a
18031 * possibility that HBA list has changed, so start
18032 * over from the top. Just processed controller
18033 * will be passed-over because of the SKIP flag.
18034 */
18035 goto loop;
18036 }
18037 mutex_exit(&sata_hba_inst->satahba_mutex);
18038 }
18039 /* Clear SKIP flag in all controllers */
18040 for (sata_hba_inst = sata_hba_list; sata_hba_inst != NULL;
18041 sata_hba_inst = sata_hba_inst->satahba_next) {
18042 mutex_enter(&sata_hba_inst->satahba_mutex);
18043 sata_hba_inst->satahba_event_flags &= ~SATA_EVNT_SKIP;
18044 mutex_exit(&sata_hba_inst->satahba_mutex);
18045 }
18046 mutex_exit(&sata_mutex);
18047
18048 SATADBG1(SATA_DBG_EVENTS_DAEMON, NULL,
18049 "SATA EVENT DAEMON suspending itself", NULL);
18050
18051 #ifdef SATA_DEBUG
18052 if ((sata_func_enable & SATA_ENABLE_PROCESS_EVENTS) == 0) {
18053 sata_log(sata_hba_inst, CE_WARN,
18054 "SATA EVENTS PROCESSING DISABLED\n");
18055 thread_exit(); /* Daemon will not run again */
18056 }
18057 #endif
18058 mutex_enter(&sata_event_mutex);
18059 sata_event_thread_active = 0;
18060 mutex_exit(&sata_event_mutex);
18061 /*
18062 * Go to sleep/suspend itself and wake up either because new event or
18063 * wait timeout. Exit if there is a termination request (driver
18064 * unload).
18065 */
18066 delta = drv_usectohz(SATA_EVNT_DAEMON_SLEEP_TIME);
18067 do {
18068 mutex_enter(&sata_event_mutex);
18069 (void) cv_reltimedwait(&sata_event_cv, &sata_event_mutex,
18070 delta, TR_CLOCK_TICK);
18071
18072 if (sata_event_thread_active != 0) {
18073 mutex_exit(&sata_event_mutex);
18074 continue;
18075 }
18076
18077 /* Check if it is time to go away */
18078 if (sata_event_thread_terminate == 1) {
18079 /*
18080 * It is up to the thread setting above flag to make
18081 * sure that this thread is not killed prematurely.
18082 */
18083 sata_event_thread_terminate = 0;
18084 sata_event_thread = NULL;
18085 mutex_exit(&sata_event_mutex);
18086 SATADBG1(SATA_DBG_EVENTS_DAEMON, NULL,
18087 "SATA_EVENT_DAEMON_TERMINATING", NULL);
18088 thread_exit(); { _NOTE(NOT_REACHED) }
18089 }
18090 mutex_exit(&sata_event_mutex);
18091 } while (!(sata_event_pending & SATA_EVNT_MAIN));
18092
18093 mutex_enter(&sata_event_mutex);
18094 sata_event_thread_active = 1;
18095 mutex_exit(&sata_event_mutex);
18096
18097 mutex_enter(&sata_mutex);
18098 sata_event_pending &= ~SATA_EVNT_MAIN;
18099 mutex_exit(&sata_mutex);
18100
18101 SATADBG1(SATA_DBG_EVENTS_DAEMON, NULL,
18102 "SATA EVENT DAEMON READY TO PROCESS EVENT", NULL);
18103
18104 goto loop;
18105 }
18106
18107 /*
18108 * Specific HBA instance event processing.
18109 *
18110 * NOTE: At the moment, device event processing is limited to hard disks
18111 * only.
18112 * Port multiplier is supported now.
18113 */
18114 static void
18115 sata_process_controller_events(sata_hba_inst_t *sata_hba_inst)
18116 {
18117 int ncport;
18118 uint32_t event_flags;
18119 sata_address_t *saddr;
18120 sata_cport_info_t *cportinfo;
18121 sata_pmult_info_t *pmultinfo;
18122
18123 SATADBG1(SATA_DBG_EVENTS_CNTRL, sata_hba_inst,
18124 "Processing controller %d event(s)",
18125 ddi_get_instance(SATA_DIP(sata_hba_inst)));
18126
18127 mutex_enter(&sata_hba_inst->satahba_mutex);
18128 sata_hba_inst->satahba_event_flags &= ~SATA_EVNT_MAIN;
18129 event_flags = sata_hba_inst->satahba_event_flags;
18130 mutex_exit(&sata_hba_inst->satahba_mutex);
18131 /*
18132 * Process controller power change first
18133 * HERE
18134 */
18135 if (event_flags & SATA_EVNT_PWR_LEVEL_CHANGED)
18136 sata_process_cntrl_pwr_level_change(sata_hba_inst);
18137
18138 /*
18139 * Search through ports/devices to identify affected port/device.
18140 * We may have to process events for more than one port/device.
18141 */
18142 for (ncport = 0; ncport < SATA_NUM_CPORTS(sata_hba_inst); ncport++) {
18143 /*
18144 * Not all ports may be processed in attach by the time we
18145 * get an event. Check if port info is initialized.
18146 */
18147 mutex_enter(&sata_hba_inst->satahba_mutex);
18148 cportinfo = SATA_CPORT_INFO(sata_hba_inst, ncport);
18149 mutex_exit(&sata_hba_inst->satahba_mutex);
18150 if (cportinfo == NULL || cportinfo->cport_state == NULL)
18151 continue;
18152
18153 /* We have initialized controller port info */
18154 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, ncport)));
18155 event_flags = (SATA_CPORT_INFO(sata_hba_inst, ncport))->
18156 cport_event_flags;
18157 /* Check if port was locked by IOCTL processing */
18158 if (event_flags & SATA_APCTL_LOCK_PORT_BUSY) {
18159 /*
18160 * We ignore port events because port is busy
18161 * with AP control processing. Set again
18162 * controller and main event flag, so that
18163 * events may be processed by the next daemon
18164 * run.
18165 */
18166 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, ncport)));
18167 mutex_enter(&sata_hba_inst->satahba_mutex);
18168 sata_hba_inst->satahba_event_flags |= SATA_EVNT_MAIN;
18169 mutex_exit(&sata_hba_inst->satahba_mutex);
18170 mutex_enter(&sata_mutex);
18171 sata_event_pending |= SATA_EVNT_MAIN;
18172 mutex_exit(&sata_mutex);
18173 SATADBG1(SATA_DBG_EVENTS_PROCPST, sata_hba_inst,
18174 "Event processing postponed until "
18175 "AP control processing completes",
18176 NULL);
18177 /* Check other ports */
18178 continue;
18179 } else {
18180 /*
18181 * Set BSY flag so that AP control would not
18182 * interfere with events processing for
18183 * this port.
18184 */
18185 (SATA_CPORT_INFO(sata_hba_inst, ncport))->
18186 cport_event_flags |= SATA_EVNT_LOCK_PORT_BUSY;
18187 }
18188 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, ncport)));
18189
18190 saddr = &(SATA_CPORT_INFO(sata_hba_inst, ncport))->cport_addr;
18191
18192 if ((event_flags &
18193 (SATA_EVNT_PORT_EVENTS | SATA_EVNT_DRIVE_EVENTS)) != 0) {
18194 /*
18195 * Got port event.
18196 * We need some hierarchy of event processing as they
18197 * are affecting each other:
18198 * 1. port failed
18199 * 2. device detached/attached
18200 * 3. link events - link events may trigger device
18201 * detached or device attached events in some
18202 * circumstances.
18203 * 4. port power level changed
18204 */
18205 if (event_flags & SATA_EVNT_PORT_FAILED) {
18206 sata_process_port_failed_event(sata_hba_inst,
18207 saddr);
18208 }
18209 if (event_flags & SATA_EVNT_DEVICE_DETACHED) {
18210 sata_process_device_detached(sata_hba_inst,
18211 saddr);
18212 }
18213 if (event_flags & SATA_EVNT_DEVICE_ATTACHED) {
18214 sata_process_device_attached(sata_hba_inst,
18215 saddr);
18216 }
18217 if (event_flags &
18218 (SATA_EVNT_LINK_ESTABLISHED |
18219 SATA_EVNT_LINK_LOST)) {
18220 sata_process_port_link_events(sata_hba_inst,
18221 saddr);
18222 }
18223 if (event_flags & SATA_EVNT_PWR_LEVEL_CHANGED) {
18224 sata_process_port_pwr_change(sata_hba_inst,
18225 saddr);
18226 }
18227 if (event_flags & SATA_EVNT_TARGET_NODE_CLEANUP) {
18228 sata_process_target_node_cleanup(
18229 sata_hba_inst, saddr);
18230 }
18231 if (event_flags & SATA_EVNT_AUTOONLINE_DEVICE) {
18232 sata_process_device_autoonline(
18233 sata_hba_inst, saddr);
18234 }
18235 }
18236
18237
18238 /*
18239 * Scan port multiplier and all its sub-ports event flags.
18240 * The events are marked by
18241 * (1) sata_pmult_info.pmult_event_flags
18242 * (2) sata_pmport_info.pmport_event_flags
18243 */
18244 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, ncport)));
18245 if (cportinfo->cport_dev_type == SATA_DTYPE_PMULT) {
18246 /*
18247 * There should be another extra check: this
18248 * port multiplier still exists?
18249 */
18250 pmultinfo = SATA_PMULT_INFO(sata_hba_inst,
18251 ncport);
18252
18253 if (pmultinfo != NULL) {
18254 mutex_exit(&(SATA_CPORT_MUTEX(
18255 sata_hba_inst, ncport)));
18256 sata_process_pmult_events(
18257 sata_hba_inst, ncport);
18258 mutex_enter(&(SATA_CPORT_MUTEX(
18259 sata_hba_inst, ncport)));
18260 } else {
18261 SATADBG1(SATA_DBG_PMULT, sata_hba_inst,
18262 "Port-multiplier is gone. "
18263 "Ignore all sub-device events "
18264 "at port %d.", ncport);
18265 }
18266 }
18267
18268 if ((SATA_CPORT_DEV_TYPE(sata_hba_inst, ncport) !=
18269 SATA_DTYPE_NONE) &&
18270 (SATA_CPORT_DRV_INFO(sata_hba_inst, ncport) != NULL)) {
18271 if (SATA_CPORT_DRV_INFO(sata_hba_inst, ncport)->
18272 satadrv_event_flags &
18273 (SATA_EVNT_DEVICE_RESET |
18274 SATA_EVNT_INPROC_DEVICE_RESET)) {
18275 /* Have device event */
18276 sata_process_device_reset(sata_hba_inst,
18277 saddr);
18278 }
18279 }
18280 /* Release PORT_BUSY flag */
18281 (SATA_CPORT_INFO(sata_hba_inst, ncport))->
18282 cport_event_flags &= ~SATA_EVNT_LOCK_PORT_BUSY;
18283 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, ncport)));
18284
18285 } /* End of loop through the controller SATA ports */
18286 }
18287
18288 /*
18289 * Specific port multiplier instance event processing. At the moment, device
18290 * event processing is limited to link/attach event only.
18291 *
18292 * NOTE: power management event is not supported yet.
18293 */
18294 static void
18295 sata_process_pmult_events(sata_hba_inst_t *sata_hba_inst, uint8_t cport)
18296 {
18297 sata_cport_info_t *cportinfo = SATA_CPORT_INFO(sata_hba_inst, cport);
18298 sata_pmult_info_t *pmultinfo;
18299 sata_pmport_info_t *pmportinfo;
18300 sata_address_t *saddr;
18301 sata_device_t sata_device;
18302 uint32_t event_flags;
18303 int npmport;
18304 int rval;
18305
18306 SATADBG2(SATA_DBG_EVENTS_CNTRL|SATA_DBG_PMULT, sata_hba_inst,
18307 "Processing pmult event(s) on cport %d of controller %d",
18308 cport, ddi_get_instance(SATA_DIP(sata_hba_inst)));
18309
18310 /* First process events on port multiplier */
18311 mutex_enter(&cportinfo->cport_mutex);
18312 pmultinfo = SATA_PMULT_INFO(sata_hba_inst, cport);
18313 event_flags = pmultinfo->pmult_event_flags;
18314
18315 /*
18316 * Reset event (of port multiplier) has higher priority because the
18317 * port multiplier itself might be failed or removed after reset.
18318 */
18319 if (event_flags & SATA_EVNT_DEVICE_RESET) {
18320 /*
18321 * The status of the sub-links are uncertain,
18322 * so mark all sub-ports as RESET
18323 */
18324 for (npmport = 0; npmport < SATA_NUM_PMPORTS(
18325 sata_hba_inst, cport); npmport ++) {
18326 pmportinfo = SATA_PMPORT_INFO(sata_hba_inst,
18327 cport, npmport);
18328 if (pmportinfo == NULL) {
18329 /* That's weird. */
18330 SATA_LOG_D((sata_hba_inst, CE_WARN,
18331 "sata_hba_event_notify: "
18332 "invalid/un-implemented "
18333 "port %d:%d (%d ports), ",
18334 cport, npmport, SATA_NUM_PMPORTS(
18335 sata_hba_inst, cport)));
18336 continue;
18337 }
18338
18339 mutex_enter(&pmportinfo->pmport_mutex);
18340
18341 /* Mark all pmport to unknow state. */
18342 pmportinfo->pmport_state = SATA_STATE_UNKNOWN;
18343 /* Mark all pmports with link events. */
18344 pmportinfo->pmport_event_flags =
18345 (SATA_EVNT_LINK_ESTABLISHED|SATA_EVNT_LINK_LOST);
18346 mutex_exit(&pmportinfo->pmport_mutex);
18347 }
18348
18349 } else if (event_flags & SATA_EVNT_PMULT_LINK_CHANGED) {
18350 /*
18351 * We need probe the port multiplier to know what has
18352 * happened.
18353 */
18354 bzero(&sata_device, sizeof (sata_device_t));
18355 sata_device.satadev_rev = SATA_DEVICE_REV;
18356 sata_device.satadev_addr.cport = cport;
18357 sata_device.satadev_addr.pmport = SATA_PMULT_HOSTPORT;
18358 sata_device.satadev_addr.qual = SATA_ADDR_PMULT;
18359
18360 mutex_exit(&cportinfo->cport_mutex);
18361 rval = (*SATA_PROBE_PORT_FUNC(sata_hba_inst))
18362 (SATA_DIP(sata_hba_inst), &sata_device);
18363 mutex_enter(&cportinfo->cport_mutex);
18364 if (rval != SATA_SUCCESS) {
18365 /* Something went wrong? Fail the port */
18366 cportinfo->cport_state = SATA_PSTATE_FAILED;
18367 mutex_exit(&cportinfo->cport_mutex);
18368 SATA_LOG_D((sata_hba_inst, CE_WARN,
18369 "SATA port %d probing failed", cport));
18370
18371 /* PMult structure must be released. */
18372 sata_free_pmult(sata_hba_inst, &sata_device);
18373 return;
18374 }
18375
18376 sata_update_port_info(sata_hba_inst, &sata_device);
18377
18378 /*
18379 * Sanity check - Port is active? Is the link active?
18380 * The device is still a port multiplier?
18381 */
18382 if ((cportinfo->cport_state &
18383 (SATA_PSTATE_SHUTDOWN | SATA_PSTATE_FAILED)) ||
18384 ((cportinfo->cport_scr.sstatus &
18385 SATA_PORT_DEVLINK_UP_MASK) != SATA_PORT_DEVLINK_UP) ||
18386 (cportinfo->cport_dev_type != SATA_DTYPE_PMULT)) {
18387 mutex_exit(&cportinfo->cport_mutex);
18388
18389 /* PMult structure must be released. */
18390 sata_free_pmult(sata_hba_inst, &sata_device);
18391 return;
18392 }
18393
18394 /* Probed succeed, set port ready. */
18395 cportinfo->cport_state |=
18396 SATA_STATE_PROBED | SATA_STATE_READY;
18397 }
18398
18399 /* Release port multiplier event flags. */
18400 pmultinfo->pmult_event_flags &=
18401 ~(SATA_EVNT_DEVICE_RESET|SATA_EVNT_PMULT_LINK_CHANGED);
18402 mutex_exit(&cportinfo->cport_mutex);
18403
18404 /*
18405 * Check all sub-links.
18406 */
18407 for (npmport = 0; npmport < SATA_NUM_PMPORTS(sata_hba_inst, cport);
18408 npmport ++) {
18409 pmportinfo = SATA_PMPORT_INFO(sata_hba_inst, cport, npmport);
18410 mutex_enter(&pmportinfo->pmport_mutex);
18411 event_flags = pmportinfo->pmport_event_flags;
18412 mutex_exit(&pmportinfo->pmport_mutex);
18413 saddr = &pmportinfo->pmport_addr;
18414
18415 if ((event_flags &
18416 (SATA_EVNT_PORT_EVENTS | SATA_EVNT_DRIVE_EVENTS)) != 0) {
18417 /*
18418 * Got port multiplier port event.
18419 * We need some hierarchy of event processing as they
18420 * are affecting each other:
18421 * 1. device detached/attached
18422 * 2. link events - link events may trigger device
18423 * detached or device attached events in some
18424 * circumstances.
18425 */
18426 if (event_flags & SATA_EVNT_DEVICE_DETACHED) {
18427 sata_process_pmdevice_detached(sata_hba_inst,
18428 saddr);
18429 }
18430 if (event_flags & SATA_EVNT_DEVICE_ATTACHED) {
18431 sata_process_pmdevice_attached(sata_hba_inst,
18432 saddr);
18433 }
18434 if (event_flags & SATA_EVNT_LINK_ESTABLISHED ||
18435 event_flags & SATA_EVNT_LINK_LOST) {
18436 sata_process_pmport_link_events(sata_hba_inst,
18437 saddr);
18438 }
18439 if (event_flags & SATA_EVNT_TARGET_NODE_CLEANUP) {
18440 sata_process_target_node_cleanup(
18441 sata_hba_inst, saddr);
18442 }
18443 }
18444
18445 /* Checking drive event(s). */
18446 mutex_enter(&pmportinfo->pmport_mutex);
18447 if (pmportinfo->pmport_dev_type != SATA_DTYPE_NONE &&
18448 pmportinfo->pmport_sata_drive != NULL) {
18449 event_flags = pmportinfo->pmport_sata_drive->
18450 satadrv_event_flags;
18451 if (event_flags & (SATA_EVNT_DEVICE_RESET |
18452 SATA_EVNT_INPROC_DEVICE_RESET)) {
18453
18454 /* Have device event */
18455 sata_process_pmdevice_reset(sata_hba_inst,
18456 saddr);
18457 }
18458 }
18459 mutex_exit(&pmportinfo->pmport_mutex);
18460
18461 /* Release PORT_BUSY flag */
18462 mutex_enter(&cportinfo->cport_mutex);
18463 cportinfo->cport_event_flags &= ~SATA_EVNT_LOCK_PORT_BUSY;
18464 mutex_exit(&cportinfo->cport_mutex);
18465 }
18466
18467 SATADBG2(SATA_DBG_EVENTS_CNTRL|SATA_DBG_PMULT, sata_hba_inst,
18468 "[DONE] pmult event(s) on cport %d of controller %d",
18469 cport, ddi_get_instance(SATA_DIP(sata_hba_inst)));
18470 }
18471
18472 /*
18473 * Process HBA power level change reported by HBA driver.
18474 * Not implemented at this time - event is ignored.
18475 */
18476 static void
18477 sata_process_cntrl_pwr_level_change(sata_hba_inst_t *sata_hba_inst)
18478 {
18479 SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst,
18480 "Processing controller power level change", NULL);
18481
18482 /* Ignoring it for now */
18483 mutex_enter(&sata_hba_inst->satahba_mutex);
18484 sata_hba_inst->satahba_event_flags &= ~SATA_EVNT_PWR_LEVEL_CHANGED;
18485 mutex_exit(&sata_hba_inst->satahba_mutex);
18486 }
18487
18488 /*
18489 * Process port power level change reported by HBA driver.
18490 * Not implemented at this time - event is ignored.
18491 */
18492 static void
18493 sata_process_port_pwr_change(sata_hba_inst_t *sata_hba_inst,
18494 sata_address_t *saddr)
18495 {
18496 sata_cport_info_t *cportinfo;
18497
18498 SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst,
18499 "Processing port power level change", NULL);
18500
18501 cportinfo = SATA_CPORT_INFO(sata_hba_inst, saddr->cport);
18502 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex);
18503 /* Reset event flag */
18504 cportinfo->cport_event_flags &= ~SATA_EVNT_PWR_LEVEL_CHANGED;
18505 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex);
18506 }
18507
18508 /*
18509 * Process port failure reported by HBA driver.
18510 * cports support only - no pmports.
18511 */
18512 static void
18513 sata_process_port_failed_event(sata_hba_inst_t *sata_hba_inst,
18514 sata_address_t *saddr)
18515 {
18516 sata_cport_info_t *cportinfo;
18517
18518 cportinfo = SATA_CPORT_INFO(sata_hba_inst, saddr->cport);
18519 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex);
18520 /* Reset event flag first */
18521 cportinfo->cport_event_flags &= ~SATA_EVNT_PORT_FAILED;
18522 /* If the port is in SHUTDOWN or FAILED state, ignore this event. */
18523 if ((cportinfo->cport_state &
18524 (SATA_PSTATE_SHUTDOWN | SATA_PSTATE_FAILED)) == 0) {
18525 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->
18526 cport_mutex);
18527 return;
18528 }
18529 /* Fail the port */
18530 cportinfo->cport_state = SATA_PSTATE_FAILED;
18531 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex);
18532 sata_log(sata_hba_inst, CE_WARN, "SATA port %d failed", saddr->cport);
18533 }
18534
18535 /*
18536 * Device Reset Event processing.
18537 * The sequence is managed by 3 stage flags:
18538 * - reset event reported,
18539 * - reset event being processed,
18540 * - request to clear device reset state.
18541 *
18542 * NOTE: This function has to be entered with cport mutex held. It exits with
18543 * mutex held as well, but can release mutex during the processing.
18544 */
18545 static void
18546 sata_process_device_reset(sata_hba_inst_t *sata_hba_inst,
18547 sata_address_t *saddr)
18548 {
18549 sata_drive_info_t old_sdinfo; /* local copy of the drive info */
18550 sata_drive_info_t *sdinfo;
18551 sata_cport_info_t *cportinfo;
18552 sata_device_t sata_device;
18553 int rval_probe, rval_set;
18554
18555 /* We only care about host sata cport for now */
18556 cportinfo = SATA_CPORT_INFO(sata_hba_inst, saddr->cport);
18557 sdinfo = SATA_CPORT_DRV_INFO(sata_hba_inst, saddr->cport);
18558 /*
18559 * If the port is in SHUTDOWN or FAILED state, or device is in FAILED
18560 * state, ignore reset event.
18561 */
18562 if (((cportinfo->cport_state &
18563 (SATA_PSTATE_SHUTDOWN | SATA_PSTATE_FAILED)) != 0) ||
18564 (sdinfo->satadrv_state & SATA_DSTATE_FAILED) != 0) {
18565 sdinfo->satadrv_event_flags &=
18566 ~(SATA_EVNT_DEVICE_RESET | SATA_EVNT_INPROC_DEVICE_RESET);
18567 return;
18568 }
18569
18570 if ((SATA_CPORT_DEV_TYPE(sata_hba_inst, saddr->cport) ==
18571 SATA_DTYPE_PMULT)) {
18572 /*
18573 * Should not happened: this is already handled in
18574 * sata_hba_event_notify()
18575 */
18576 mutex_exit(&cportinfo->cport_mutex);
18577 goto done;
18578 }
18579
18580 if ((SATA_CPORT_DEV_TYPE(sata_hba_inst, saddr->cport) &
18581 SATA_VALID_DEV_TYPE) == 0) {
18582 /*
18583 * This should not happen - coding error.
18584 * But we can recover, so do not panic, just clean up
18585 * and if in debug mode, log the message.
18586 */
18587 #ifdef SATA_DEBUG
18588 sata_log(sata_hba_inst, CE_WARN,
18589 "sata_process_device_reset: "
18590 "Invalid device type with sdinfo!", NULL);
18591 #endif
18592 sdinfo->satadrv_event_flags = 0;
18593 return;
18594 }
18595
18596 #ifdef SATA_DEBUG
18597 if ((sdinfo->satadrv_event_flags &
18598 (SATA_EVNT_DEVICE_RESET | SATA_EVNT_INPROC_DEVICE_RESET)) == 0) {
18599 /* Nothing to do */
18600 /* Something is weird - why we are processing dev reset? */
18601 SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst,
18602 "No device reset event!!!!", NULL);
18603
18604 return;
18605 }
18606 if ((sdinfo->satadrv_event_flags &
18607 (SATA_EVNT_DEVICE_RESET | SATA_EVNT_INPROC_DEVICE_RESET)) ==
18608 (SATA_EVNT_DEVICE_RESET | SATA_EVNT_INPROC_DEVICE_RESET)) {
18609 /* Something is weird - new device reset event */
18610 SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst,
18611 "Overlapping device reset events!", NULL);
18612 }
18613 #endif
18614 SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst,
18615 "Processing port %d device reset", saddr->cport);
18616
18617 /* Clear event flag */
18618 sdinfo->satadrv_event_flags &= ~SATA_EVNT_DEVICE_RESET;
18619
18620 /* It seems that we always need to check the port state first */
18621 sata_device.satadev_rev = SATA_DEVICE_REV;
18622 sata_device.satadev_addr = *saddr;
18623 /*
18624 * We have to exit mutex, because the HBA probe port function may
18625 * block on its own mutex.
18626 */
18627 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex);
18628 rval_probe = (*SATA_PROBE_PORT_FUNC(sata_hba_inst))
18629 (SATA_DIP(sata_hba_inst), &sata_device);
18630 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex);
18631 sata_update_port_info(sata_hba_inst, &sata_device);
18632 if (rval_probe != SATA_SUCCESS) {
18633 /* Something went wrong? Fail the port */
18634 cportinfo->cport_state = SATA_PSTATE_FAILED;
18635 sdinfo = SATA_CPORT_DRV_INFO(sata_hba_inst, saddr->cport);
18636 if (sdinfo != NULL)
18637 sdinfo->satadrv_event_flags = 0;
18638 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->
18639 cport_mutex);
18640 SATA_LOG_D((sata_hba_inst, CE_WARN,
18641 "SATA port %d probing failed",
18642 saddr->cport));
18643 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst,
18644 saddr->cport)->cport_mutex);
18645 return;
18646 }
18647 if ((sata_device.satadev_scr.sstatus &
18648 SATA_PORT_DEVLINK_UP_MASK) !=
18649 SATA_PORT_DEVLINK_UP ||
18650 sata_device.satadev_type == SATA_DTYPE_NONE) {
18651 /*
18652 * No device to process, anymore. Some other event processing
18653 * would or have already performed port info cleanup.
18654 * To be safe (HBA may need it), request clearing device
18655 * reset condition.
18656 */
18657 sdinfo = SATA_CPORT_DRV_INFO(sata_hba_inst, saddr->cport);
18658 if (sdinfo != NULL) {
18659 sdinfo->satadrv_event_flags &=
18660 ~SATA_EVNT_INPROC_DEVICE_RESET;
18661 sdinfo->satadrv_event_flags |=
18662 SATA_EVNT_CLEAR_DEVICE_RESET;
18663 }
18664 return;
18665 }
18666
18667 sdinfo = SATA_CPORT_DRV_INFO(sata_hba_inst, saddr->cport);
18668 if (sdinfo == NULL) {
18669 return;
18670 }
18671 if ((sdinfo->satadrv_event_flags &
18672 SATA_EVNT_INPROC_DEVICE_RESET) == 0) {
18673 /*
18674 * Start tracking time for device feature restoration and
18675 * identification. Save current time (lbolt value).
18676 */
18677 sdinfo->satadrv_reset_time = ddi_get_lbolt();
18678 }
18679 /* Mark device reset processing as active */
18680 sdinfo->satadrv_event_flags |= SATA_EVNT_INPROC_DEVICE_RESET;
18681
18682 old_sdinfo = *sdinfo; /* local copy of the drive info */
18683 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex);
18684
18685 rval_set = sata_set_drive_features(sata_hba_inst, &old_sdinfo, 1);
18686
18687 if (rval_set != SATA_SUCCESS) {
18688 /*
18689 * Restoring drive setting failed.
18690 * Probe the port first, to check if the port state has changed
18691 */
18692 sata_device.satadev_rev = SATA_DEVICE_REV;
18693 sata_device.satadev_addr = *saddr;
18694 sata_device.satadev_addr.qual = SATA_ADDR_CPORT;
18695 /* probe port */
18696 rval_probe = (*SATA_PROBE_PORT_FUNC(sata_hba_inst))
18697 (SATA_DIP(sata_hba_inst), &sata_device);
18698 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->
18699 cport_mutex);
18700 if (rval_probe == SATA_SUCCESS &&
18701 (sata_device.satadev_state &
18702 (SATA_PSTATE_SHUTDOWN | SATA_PSTATE_FAILED)) == 0 &&
18703 (sata_device.satadev_scr.sstatus &
18704 SATA_PORT_DEVLINK_UP_MASK) == SATA_PORT_DEVLINK_UP &&
18705 sata_device.satadev_type != SATA_DTYPE_NONE) {
18706 /*
18707 * We may retry this a bit later - in-process reset
18708 * condition should be already set.
18709 * Track retry time for device identification.
18710 */
18711 if ((cportinfo->cport_dev_type &
18712 SATA_VALID_DEV_TYPE) != 0 &&
18713 SATA_CPORTINFO_DRV_INFO(cportinfo) != NULL &&
18714 sdinfo->satadrv_reset_time != 0) {
18715 clock_t cur_time = ddi_get_lbolt();
18716 /*
18717 * If the retry time limit was not
18718 * exceeded, retry.
18719 */
18720 if ((cur_time - sdinfo->satadrv_reset_time) <
18721 drv_usectohz(SATA_DEV_REPROBE_TIMEOUT)) {
18722 mutex_enter(
18723 &sata_hba_inst->satahba_mutex);
18724 sata_hba_inst->satahba_event_flags |=
18725 SATA_EVNT_MAIN;
18726 mutex_exit(
18727 &sata_hba_inst->satahba_mutex);
18728 mutex_enter(&sata_mutex);
18729 sata_event_pending |= SATA_EVNT_MAIN;
18730 mutex_exit(&sata_mutex);
18731 return;
18732 }
18733 if (rval_set == SATA_RETRY) {
18734 /*
18735 * Setting drive features failed, but
18736 * the drive is still accessible,
18737 * so emit a warning message before
18738 * return.
18739 */
18740 mutex_exit(&SATA_CPORT_INFO(
18741 sata_hba_inst,
18742 saddr->cport)->cport_mutex);
18743 goto done;
18744 }
18745 }
18746 /* Fail the drive */
18747 sdinfo->satadrv_state = SATA_DSTATE_FAILED;
18748
18749 sata_log(sata_hba_inst, CE_WARN,
18750 "SATA device at port %d - device failed",
18751 saddr->cport);
18752
18753 DTRACE_PROBE(port_failed_f);
18754 }
18755 /*
18756 * No point of retrying - device failed or some other event
18757 * processing or already did or will do port info cleanup.
18758 * To be safe (HBA may need it),
18759 * request clearing device reset condition.
18760 */
18761 sdinfo->satadrv_event_flags |= SATA_EVNT_CLEAR_DEVICE_RESET;
18762 sdinfo->satadrv_event_flags &= ~SATA_EVNT_INPROC_DEVICE_RESET;
18763 sdinfo->satadrv_reset_time = 0;
18764 return;
18765 }
18766 done:
18767 /*
18768 * If setting of drive features failed, but the drive is still
18769 * accessible, emit a warning message.
18770 */
18771 if (rval_set == SATA_RETRY) {
18772 sata_log(sata_hba_inst, CE_WARN,
18773 "SATA device at port %d - desired setting could not be "
18774 "restored after reset. Device may not operate as expected.",
18775 saddr->cport);
18776 }
18777 /*
18778 * Raise the flag indicating that the next sata command could
18779 * be sent with SATA_CLEAR_DEV_RESET_STATE flag, if no new device
18780 * reset is reported.
18781 */
18782 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex);
18783 if (SATA_CPORTINFO_DRV_INFO(cportinfo) != NULL) {
18784 sdinfo->satadrv_reset_time = 0;
18785 if ((cportinfo->cport_dev_type & SATA_VALID_DEV_TYPE) != 0) {
18786 sdinfo = SATA_CPORTINFO_DRV_INFO(cportinfo);
18787 sdinfo->satadrv_event_flags &=
18788 ~SATA_EVNT_INPROC_DEVICE_RESET;
18789 sdinfo->satadrv_event_flags |=
18790 SATA_EVNT_CLEAR_DEVICE_RESET;
18791 }
18792 }
18793 }
18794
18795
18796 /*
18797 * Port Multiplier Port Device Reset Event processing.
18798 *
18799 * NOTE: This function has to be entered with pmport mutex held. It exits with
18800 * mutex held as well, but can release mutex during the processing.
18801 */
18802 static void
18803 sata_process_pmdevice_reset(sata_hba_inst_t *sata_hba_inst,
18804 sata_address_t *saddr)
18805 {
18806 sata_drive_info_t old_sdinfo; /* local copy of the drive info */
18807 sata_drive_info_t *sdinfo = NULL;
18808 sata_cport_info_t *cportinfo = NULL;
18809 sata_pmport_info_t *pmportinfo = NULL;
18810 sata_pmult_info_t *pminfo = NULL;
18811 sata_device_t sata_device;
18812 uint8_t cport = saddr->cport;
18813 uint8_t pmport = saddr->pmport;
18814 int rval;
18815
18816 SATADBG2(SATA_DBG_EVENTS_PROC, sata_hba_inst,
18817 "Processing drive reset at port %d:%d", cport, pmport);
18818
18819 cportinfo = SATA_CPORT_INFO(sata_hba_inst, cport);
18820 pmportinfo = SATA_PMPORT_INFO(sata_hba_inst, cport, pmport);
18821 sdinfo = SATA_PMPORT_DRV_INFO(sata_hba_inst, cport, pmport);
18822
18823 /*
18824 * If the port is in SHUTDOWN or FAILED state, or device is in FAILED
18825 * state, ignore reset event.
18826 */
18827 if (((cportinfo->cport_state &
18828 (SATA_PSTATE_SHUTDOWN | SATA_PSTATE_FAILED)) != 0) ||
18829 (sdinfo->satadrv_state & SATA_DSTATE_FAILED) != 0) {
18830 sdinfo->satadrv_event_flags &=
18831 ~(SATA_EVNT_DEVICE_RESET | SATA_EVNT_INPROC_DEVICE_RESET);
18832 return;
18833 }
18834
18835 if ((pmportinfo->pmport_dev_type & SATA_VALID_DEV_TYPE) == 0) {
18836 /*
18837 * This should not happen - coding error.
18838 * But we can recover, so do not panic, just clean up
18839 * and if in debug mode, log the message.
18840 */
18841 #ifdef SATA_DEBUG
18842 sata_log(sata_hba_inst, CE_WARN,
18843 "sata_process_pmdevice_reset: "
18844 "Invalid device type with sdinfo!", NULL);
18845 #endif
18846 sdinfo->satadrv_event_flags = 0;
18847 return;
18848 }
18849
18850 #ifdef SATA_DEBUG
18851 if ((sdinfo->satadrv_event_flags &
18852 (SATA_EVNT_DEVICE_RESET | SATA_EVNT_INPROC_DEVICE_RESET)) == 0) {
18853 /* Nothing to do */
18854 /* Something is weird - why we are processing dev reset? */
18855 SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst,
18856 "No device reset event!!!!", NULL);
18857
18858 return;
18859 }
18860 if ((sdinfo->satadrv_event_flags &
18861 (SATA_EVNT_DEVICE_RESET | SATA_EVNT_INPROC_DEVICE_RESET)) ==
18862 (SATA_EVNT_DEVICE_RESET | SATA_EVNT_INPROC_DEVICE_RESET)) {
18863 /* Something is weird - new device reset event */
18864 SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst,
18865 "Overlapping device reset events!", NULL);
18866 }
18867 #endif
18868 SATADBG2(SATA_DBG_EVENTS_PROC, sata_hba_inst,
18869 "Processing port %d:%d device reset", cport, pmport);
18870
18871 /* Clear event flag */
18872 sdinfo->satadrv_event_flags &= ~SATA_EVNT_DEVICE_RESET;
18873
18874 /* It seems that we always need to check the port state first */
18875 sata_device.satadev_rev = SATA_DEVICE_REV;
18876 sata_device.satadev_addr = *saddr;
18877 /*
18878 * We have to exit mutex, because the HBA probe port function may
18879 * block on its own mutex.
18880 */
18881 mutex_exit(&pmportinfo->pmport_mutex);
18882 rval = (*SATA_PROBE_PORT_FUNC(sata_hba_inst))
18883 (SATA_DIP(sata_hba_inst), &sata_device);
18884 mutex_enter(&pmportinfo->pmport_mutex);
18885
18886 sata_update_pmport_info(sata_hba_inst, &sata_device);
18887 if (rval != SATA_SUCCESS) {
18888 /* Something went wrong? Fail the port */
18889 pmportinfo->pmport_state = SATA_PSTATE_FAILED;
18890 sdinfo = SATA_PMPORT_DRV_INFO(sata_hba_inst, saddr->cport,
18891 saddr->pmport);
18892 if (sdinfo != NULL)
18893 sdinfo->satadrv_event_flags = 0;
18894 mutex_exit(&pmportinfo->pmport_mutex);
18895 SATA_LOG_D((sata_hba_inst, CE_WARN,
18896 "SATA port %d:%d probing failed",
18897 saddr->cport, saddr->pmport));
18898 mutex_enter(&pmportinfo->pmport_mutex);
18899 return;
18900 }
18901 if ((sata_device.satadev_scr.sstatus &
18902 SATA_PORT_DEVLINK_UP_MASK) !=
18903 SATA_PORT_DEVLINK_UP ||
18904 sata_device.satadev_type == SATA_DTYPE_NONE) {
18905 /*
18906 * No device to process, anymore. Some other event processing
18907 * would or have already performed port info cleanup.
18908 * To be safe (HBA may need it), request clearing device
18909 * reset condition.
18910 */
18911 sdinfo = SATA_PMPORT_DRV_INFO(sata_hba_inst, saddr->cport,
18912 saddr->pmport);
18913 if (sdinfo != NULL) {
18914 sdinfo->satadrv_event_flags &=
18915 ~SATA_EVNT_INPROC_DEVICE_RESET;
18916 /* must clear flags on cport */
18917 pminfo = SATA_PMULT_INFO(sata_hba_inst,
18918 saddr->cport);
18919 pminfo->pmult_event_flags |=
18920 SATA_EVNT_CLEAR_DEVICE_RESET;
18921 }
18922 return;
18923 }
18924
18925 sdinfo = SATA_PMPORT_DRV_INFO(sata_hba_inst, saddr->cport,
18926 saddr->pmport);
18927 if (sdinfo == NULL) {
18928 return;
18929 }
18930 if ((sdinfo->satadrv_event_flags &
18931 SATA_EVNT_INPROC_DEVICE_RESET) == 0) {
18932 /*
18933 * Start tracking time for device feature restoration and
18934 * identification. Save current time (lbolt value).
18935 */
18936 sdinfo->satadrv_reset_time = ddi_get_lbolt();
18937 }
18938 /* Mark device reset processing as active */
18939 sdinfo->satadrv_event_flags |= SATA_EVNT_INPROC_DEVICE_RESET;
18940
18941 old_sdinfo = *sdinfo; /* local copy of the drive info */
18942 mutex_exit(&pmportinfo->pmport_mutex);
18943
18944 if (sata_set_drive_features(sata_hba_inst, &old_sdinfo, 1) ==
18945 SATA_FAILURE) {
18946 /*
18947 * Restoring drive setting failed.
18948 * Probe the port first, to check if the port state has changed
18949 */
18950 sata_device.satadev_rev = SATA_DEVICE_REV;
18951 sata_device.satadev_addr = *saddr;
18952 sata_device.satadev_addr.qual = SATA_ADDR_PMPORT;
18953
18954 /* probe port */
18955 rval = (*SATA_PROBE_PORT_FUNC(sata_hba_inst))
18956 (SATA_DIP(sata_hba_inst), &sata_device);
18957 mutex_enter(&pmportinfo->pmport_mutex);
18958 if (rval == SATA_SUCCESS &&
18959 (sata_device.satadev_state &
18960 (SATA_PSTATE_SHUTDOWN | SATA_PSTATE_FAILED)) == 0 &&
18961 (sata_device.satadev_scr.sstatus &
18962 SATA_PORT_DEVLINK_UP_MASK) == SATA_PORT_DEVLINK_UP &&
18963 sata_device.satadev_type != SATA_DTYPE_NONE) {
18964 /*
18965 * We may retry this a bit later - in-process reset
18966 * condition should be already set.
18967 * Track retry time for device identification.
18968 */
18969 if ((pmportinfo->pmport_dev_type &
18970 SATA_VALID_DEV_TYPE) != 0 &&
18971 SATA_PMPORTINFO_DRV_INFO(pmportinfo) != NULL &&
18972 sdinfo->satadrv_reset_time != 0) {
18973 clock_t cur_time = ddi_get_lbolt();
18974 /*
18975 * If the retry time limit was not
18976 * exceeded, retry.
18977 */
18978 if ((cur_time - sdinfo->satadrv_reset_time) <
18979 drv_usectohz(SATA_DEV_REPROBE_TIMEOUT)) {
18980 mutex_enter(
18981 &sata_hba_inst->satahba_mutex);
18982 sata_hba_inst->satahba_event_flags |=
18983 SATA_EVNT_MAIN;
18984 mutex_exit(
18985 &sata_hba_inst->satahba_mutex);
18986 mutex_enter(&sata_mutex);
18987 sata_event_pending |= SATA_EVNT_MAIN;
18988 mutex_exit(&sata_mutex);
18989 return;
18990 }
18991 }
18992 /* Fail the drive */
18993 sdinfo->satadrv_state = SATA_DSTATE_FAILED;
18994
18995 sata_log(sata_hba_inst, CE_WARN,
18996 "SATA device at port %d:%d - device failed",
18997 saddr->cport, saddr->pmport);
18998 } else {
18999 /*
19000 * No point of retrying - some other event processing
19001 * would or already did port info cleanup.
19002 * To be safe (HBA may need it),
19003 * request clearing device reset condition.
19004 */
19005 sdinfo->satadrv_event_flags |=
19006 SATA_EVNT_CLEAR_DEVICE_RESET;
19007 }
19008 sdinfo->satadrv_event_flags &= ~SATA_EVNT_INPROC_DEVICE_RESET;
19009 sdinfo->satadrv_reset_time = 0;
19010 return;
19011 }
19012 /*
19013 * Raise the flag indicating that the next sata command could
19014 * be sent with SATA_CLEAR_DEV_RESET_STATE flag, if no new device
19015 * reset is reported.
19016 */
19017 mutex_enter(&pmportinfo->pmport_mutex);
19018 if (SATA_PMPORTINFO_DRV_INFO(pmportinfo) != NULL) {
19019 sdinfo->satadrv_reset_time = 0;
19020 if (pmportinfo->pmport_dev_type & SATA_VALID_DEV_TYPE) {
19021 sdinfo = SATA_PMPORTINFO_DRV_INFO(pmportinfo);
19022 sdinfo->satadrv_event_flags &=
19023 ~SATA_EVNT_INPROC_DEVICE_RESET;
19024 /* must clear flags on cport */
19025 pminfo = SATA_PMULT_INFO(sata_hba_inst,
19026 saddr->cport);
19027 pminfo->pmult_event_flags |=
19028 SATA_EVNT_CLEAR_DEVICE_RESET;
19029 }
19030 }
19031 }
19032
19033 /*
19034 * Port Link Events processing.
19035 * Every link established event may involve device reset (due to
19036 * COMRESET signal, equivalent of the hard reset) so arbitrarily
19037 * set device reset event for an attached device (if any).
19038 * If the port is in SHUTDOWN or FAILED state, ignore link events.
19039 *
19040 * The link established event processing varies, depending on the state
19041 * of the target node, HBA hotplugging capabilities, state of the port.
19042 * If the link is not active, the link established event is ignored.
19043 * If HBA cannot detect device attachment and there is no target node,
19044 * the link established event triggers device attach event processing.
19045 * Else, link established event triggers device reset event processing.
19046 *
19047 * The link lost event processing varies, depending on a HBA hotplugging
19048 * capability and the state of the port (link active or not active).
19049 * If the link is active, the lost link event is ignored.
19050 * If HBA cannot detect device removal, the lost link event triggers
19051 * device detached event processing after link lost timeout.
19052 * Else, the event is ignored.
19053 *
19054 * NOTE: Port multiplier ports events are handled by
19055 * sata_process_pmport_link_events();
19056 */
19057 static void
19058 sata_process_port_link_events(sata_hba_inst_t *sata_hba_inst,
19059 sata_address_t *saddr)
19060 {
19061 sata_device_t sata_device;
19062 sata_cport_info_t *cportinfo;
19063 sata_drive_info_t *sdinfo;
19064 uint32_t event_flags;
19065 int rval;
19066
19067 SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst,
19068 "Processing port %d link event(s)", saddr->cport);
19069
19070 cportinfo = SATA_CPORT_INFO(sata_hba_inst, saddr->cport);
19071 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex);
19072 event_flags = cportinfo->cport_event_flags;
19073
19074 /* Reset event flags first */
19075 cportinfo->cport_event_flags &=
19076 ~(SATA_EVNT_LINK_ESTABLISHED | SATA_EVNT_LINK_LOST);
19077
19078 /* If the port is in SHUTDOWN or FAILED state, ignore link events. */
19079 if ((cportinfo->cport_state &
19080 (SATA_PSTATE_SHUTDOWN | SATA_PSTATE_FAILED)) != 0) {
19081 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->
19082 cport_mutex);
19083 return;
19084 }
19085
19086 /*
19087 * For the sanity sake get current port state.
19088 * Set device address only. Other sata_device fields should be
19089 * set by HBA driver.
19090 */
19091 sata_device.satadev_rev = SATA_DEVICE_REV;
19092 sata_device.satadev_addr = *saddr;
19093 /*
19094 * We have to exit mutex, because the HBA probe port function may
19095 * block on its own mutex.
19096 */
19097 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex);
19098 rval = (*SATA_PROBE_PORT_FUNC(sata_hba_inst))
19099 (SATA_DIP(sata_hba_inst), &sata_device);
19100 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex);
19101 sata_update_port_info(sata_hba_inst, &sata_device);
19102 if (rval != SATA_SUCCESS) {
19103 /* Something went wrong? Fail the port */
19104 cportinfo->cport_state = SATA_PSTATE_FAILED;
19105 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->
19106 cport_mutex);
19107 SATA_LOG_D((sata_hba_inst, CE_WARN,
19108 "SATA port %d probing failed",
19109 saddr->cport));
19110 /*
19111 * We may want to release device info structure, but
19112 * it is not necessary.
19113 */
19114 return;
19115 } else {
19116 /* port probed successfully */
19117 cportinfo->cport_state |= SATA_STATE_PROBED | SATA_STATE_READY;
19118 }
19119 if (event_flags & SATA_EVNT_LINK_ESTABLISHED) {
19120
19121 if ((sata_device.satadev_scr.sstatus &
19122 SATA_PORT_DEVLINK_UP_MASK) != SATA_PORT_DEVLINK_UP) {
19123 /* Ignore event */
19124 SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst,
19125 "Ignoring port %d link established event - "
19126 "link down",
19127 saddr->cport);
19128 goto linklost;
19129 }
19130
19131 SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst,
19132 "Processing port %d link established event",
19133 saddr->cport);
19134
19135 /*
19136 * For the sanity sake check if a device is attached - check
19137 * return state of a port probing.
19138 */
19139 if (sata_device.satadev_type != SATA_DTYPE_NONE) {
19140 /*
19141 * HBA port probe indicated that there is a device
19142 * attached. Check if the framework had device info
19143 * structure attached for this device.
19144 */
19145 if (cportinfo->cport_dev_type != SATA_DTYPE_NONE) {
19146 ASSERT(SATA_CPORTINFO_DRV_INFO(cportinfo) !=
19147 NULL);
19148
19149 sdinfo = SATA_CPORTINFO_DRV_INFO(cportinfo);
19150 if ((sdinfo->satadrv_type &
19151 SATA_VALID_DEV_TYPE) != 0) {
19152 /*
19153 * Dev info structure is present.
19154 * If dev_type is set to known type in
19155 * the framework's drive info struct
19156 * then the device existed before and
19157 * the link was probably lost
19158 * momentarily - in such case
19159 * we may want to check device
19160 * identity.
19161 * Identity check is not supported now.
19162 *
19163 * Link established event
19164 * triggers device reset event.
19165 */
19166 (SATA_CPORTINFO_DRV_INFO(cportinfo))->
19167 satadrv_event_flags |=
19168 SATA_EVNT_DEVICE_RESET;
19169 }
19170 } else if (cportinfo->cport_dev_type ==
19171 SATA_DTYPE_NONE) {
19172 /*
19173 * We got new device attached! If HBA does not
19174 * generate device attached events, trigger it
19175 * here.
19176 */
19177 if (!(SATA_FEATURES(sata_hba_inst) &
19178 SATA_CTLF_HOTPLUG)) {
19179 cportinfo->cport_event_flags |=
19180 SATA_EVNT_DEVICE_ATTACHED;
19181 }
19182 }
19183 /* Reset link lost timeout */
19184 cportinfo->cport_link_lost_time = 0;
19185 }
19186 }
19187 linklost:
19188 if (event_flags & SATA_EVNT_LINK_LOST) {
19189 if ((sata_device.satadev_scr.sstatus &
19190 SATA_PORT_DEVLINK_UP_MASK) == SATA_PORT_DEVLINK_UP) {
19191 /* Ignore event */
19192 SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst,
19193 "Ignoring port %d link lost event - link is up",
19194 saddr->cport);
19195 goto done;
19196 }
19197 #ifdef SATA_DEBUG
19198 if (cportinfo->cport_link_lost_time == 0) {
19199 SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst,
19200 "Processing port %d link lost event",
19201 saddr->cport);
19202 }
19203 #endif
19204 /*
19205 * When HBA cannot generate device attached/detached events,
19206 * we need to track link lost time and eventually generate
19207 * device detach event.
19208 */
19209 if (!(SATA_FEATURES(sata_hba_inst) & SATA_CTLF_HOTPLUG)) {
19210 /* We are tracking link lost time */
19211 if (cportinfo->cport_link_lost_time == 0) {
19212 /* save current time (lbolt value) */
19213 cportinfo->cport_link_lost_time =
19214 ddi_get_lbolt();
19215 /* just keep link lost event */
19216 cportinfo->cport_event_flags |=
19217 SATA_EVNT_LINK_LOST;
19218 } else {
19219 clock_t cur_time = ddi_get_lbolt();
19220 if ((cur_time -
19221 cportinfo->cport_link_lost_time) >=
19222 drv_usectohz(
19223 SATA_EVNT_LINK_LOST_TIMEOUT)) {
19224 /* trigger device detach event */
19225 cportinfo->cport_event_flags |=
19226 SATA_EVNT_DEVICE_DETACHED;
19227 cportinfo->cport_link_lost_time = 0;
19228 SATADBG1(SATA_DBG_EVENTS,
19229 sata_hba_inst,
19230 "Triggering port %d "
19231 "device detached event",
19232 saddr->cport);
19233 } else {
19234 /* keep link lost event */
19235 cportinfo->cport_event_flags |=
19236 SATA_EVNT_LINK_LOST;
19237 }
19238 }
19239 }
19240 /*
19241 * We could change port state to disable/delay access to
19242 * the attached device until the link is recovered.
19243 */
19244 }
19245 done:
19246 event_flags = cportinfo->cport_event_flags;
19247 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex);
19248 if (event_flags != 0) {
19249 mutex_enter(&sata_hba_inst->satahba_mutex);
19250 sata_hba_inst->satahba_event_flags |= SATA_EVNT_MAIN;
19251 mutex_exit(&sata_hba_inst->satahba_mutex);
19252 mutex_enter(&sata_mutex);
19253 sata_event_pending |= SATA_EVNT_MAIN;
19254 mutex_exit(&sata_mutex);
19255 }
19256 }
19257
19258 /*
19259 * Port Multiplier Port Link Events processing.
19260 */
19261 static void
19262 sata_process_pmport_link_events(sata_hba_inst_t *sata_hba_inst,
19263 sata_address_t *saddr)
19264 {
19265 sata_device_t sata_device;
19266 sata_pmport_info_t *pmportinfo = NULL;
19267 sata_drive_info_t *sdinfo = NULL;
19268 uint32_t event_flags;
19269 uint8_t cport = saddr->cport;
19270 uint8_t pmport = saddr->pmport;
19271 int rval;
19272
19273 SATADBG2(SATA_DBG_EVENTS_PROC, sata_hba_inst,
19274 "Processing port %d:%d link event(s)",
19275 cport, pmport);
19276
19277 pmportinfo = SATA_PMPORT_INFO(sata_hba_inst, cport, pmport);
19278 mutex_enter(&pmportinfo->pmport_mutex);
19279 event_flags = pmportinfo->pmport_event_flags;
19280
19281 /* Reset event flags first */
19282 pmportinfo->pmport_event_flags &=
19283 ~(SATA_EVNT_LINK_ESTABLISHED | SATA_EVNT_LINK_LOST);
19284
19285 /* If the port is in SHUTDOWN or FAILED state, ignore link events. */
19286 if ((pmportinfo->pmport_state &
19287 (SATA_PSTATE_SHUTDOWN | SATA_PSTATE_FAILED)) != 0) {
19288 mutex_exit(&pmportinfo->pmport_mutex);
19289 return;
19290 }
19291
19292 /*
19293 * For the sanity sake get current port state.
19294 * Set device address only. Other sata_device fields should be
19295 * set by HBA driver.
19296 */
19297 sata_device.satadev_rev = SATA_DEVICE_REV;
19298 sata_device.satadev_addr = *saddr;
19299 /*
19300 * We have to exit mutex, because the HBA probe port function may
19301 * block on its own mutex.
19302 */
19303 mutex_exit(&SATA_PMPORT_MUTEX(sata_hba_inst, saddr->cport,
19304 saddr->pmport));
19305 rval = (*SATA_PROBE_PORT_FUNC(sata_hba_inst))
19306 (SATA_DIP(sata_hba_inst), &sata_device);
19307 mutex_enter(&SATA_PMPORT_MUTEX(sata_hba_inst, saddr->cport,
19308 saddr->pmport));
19309 sata_update_pmport_info(sata_hba_inst, &sata_device);
19310 if (rval != SATA_SUCCESS) {
19311 /* Something went wrong? Fail the port */
19312 pmportinfo->pmport_state = SATA_PSTATE_FAILED;
19313 mutex_exit(&SATA_PMPORT_MUTEX(sata_hba_inst, saddr->cport,
19314 saddr->pmport));
19315 SATA_LOG_D((sata_hba_inst, CE_WARN,
19316 "SATA port %d:%d probing failed",
19317 saddr->cport, saddr->pmport));
19318 /*
19319 * We may want to release device info structure, but
19320 * it is not necessary.
19321 */
19322 return;
19323 } else {
19324 /* port probed successfully */
19325 pmportinfo->pmport_state |=
19326 SATA_STATE_PROBED | SATA_STATE_READY;
19327 }
19328 mutex_exit(&SATA_PMPORT_MUTEX(sata_hba_inst,
19329 saddr->cport, saddr->pmport));
19330 mutex_enter(&SATA_PMPORT_MUTEX(sata_hba_inst,
19331 saddr->cport, saddr->pmport));
19332 if (event_flags & SATA_EVNT_LINK_ESTABLISHED) {
19333
19334 if ((sata_device.satadev_scr.sstatus &
19335 SATA_PORT_DEVLINK_UP_MASK) != SATA_PORT_DEVLINK_UP) {
19336 /* Ignore event */
19337 SATADBG2(SATA_DBG_EVENTS_PROC, sata_hba_inst,
19338 "Ignoring port %d:%d link established event - "
19339 "link down",
19340 saddr->cport, saddr->pmport);
19341 goto linklost;
19342 }
19343
19344 SATADBG2(SATA_DBG_EVENTS_PROC, sata_hba_inst,
19345 "Processing port %d:%d link established event",
19346 cport, pmport);
19347
19348 /*
19349 * For the sanity sake check if a device is attached - check
19350 * return state of a port probing.
19351 */
19352 if (sata_device.satadev_type != SATA_DTYPE_NONE &&
19353 sata_device.satadev_type != SATA_DTYPE_PMULT) {
19354 /*
19355 * HBA port probe indicated that there is a device
19356 * attached. Check if the framework had device info
19357 * structure attached for this device.
19358 */
19359 if (pmportinfo->pmport_dev_type != SATA_DTYPE_NONE) {
19360 ASSERT(SATA_PMPORTINFO_DRV_INFO(pmportinfo) !=
19361 NULL);
19362
19363 sdinfo = SATA_PMPORTINFO_DRV_INFO(pmportinfo);
19364 if ((sdinfo->satadrv_type &
19365 SATA_VALID_DEV_TYPE) != 0) {
19366 /*
19367 * Dev info structure is present.
19368 * If dev_type is set to known type in
19369 * the framework's drive info struct
19370 * then the device existed before and
19371 * the link was probably lost
19372 * momentarily - in such case
19373 * we may want to check device
19374 * identity.
19375 * Identity check is not supported now.
19376 *
19377 * Link established event
19378 * triggers device reset event.
19379 */
19380 (SATA_PMPORTINFO_DRV_INFO(pmportinfo))->
19381 satadrv_event_flags |=
19382 SATA_EVNT_DEVICE_RESET;
19383 }
19384 } else if (pmportinfo->pmport_dev_type ==
19385 SATA_DTYPE_NONE) {
19386 /*
19387 * We got new device attached! If HBA does not
19388 * generate device attached events, trigger it
19389 * here.
19390 */
19391 if (!(SATA_FEATURES(sata_hba_inst) &
19392 SATA_CTLF_HOTPLUG)) {
19393 pmportinfo->pmport_event_flags |=
19394 SATA_EVNT_DEVICE_ATTACHED;
19395 }
19396 }
19397 /* Reset link lost timeout */
19398 pmportinfo->pmport_link_lost_time = 0;
19399 }
19400 }
19401 linklost:
19402 if (event_flags & SATA_EVNT_LINK_LOST) {
19403 #ifdef SATA_DEBUG
19404 if (pmportinfo->pmport_link_lost_time == 0) {
19405 SATADBG2(SATA_DBG_EVENTS_PROC, sata_hba_inst,
19406 "Processing port %d:%d link lost event",
19407 saddr->cport, saddr->pmport);
19408 }
19409 #endif
19410 if ((sata_device.satadev_scr.sstatus &
19411 SATA_PORT_DEVLINK_UP_MASK) == SATA_PORT_DEVLINK_UP) {
19412 /* Ignore event */
19413 SATADBG2(SATA_DBG_EVENTS_PROC, sata_hba_inst,
19414 "Ignoring port %d:%d link lost event - link is up",
19415 saddr->cport, saddr->pmport);
19416 goto done;
19417 }
19418 /*
19419 * When HBA cannot generate device attached/detached events,
19420 * we need to track link lost time and eventually generate
19421 * device detach event.
19422 */
19423 if (!(SATA_FEATURES(sata_hba_inst) & SATA_CTLF_HOTPLUG)) {
19424 /* We are tracking link lost time */
19425 if (pmportinfo->pmport_link_lost_time == 0) {
19426 /* save current time (lbolt value) */
19427 pmportinfo->pmport_link_lost_time =
19428 ddi_get_lbolt();
19429 /* just keep link lost event */
19430 pmportinfo->pmport_event_flags |=
19431 SATA_EVNT_LINK_LOST;
19432 } else {
19433 clock_t cur_time = ddi_get_lbolt();
19434 if ((cur_time -
19435 pmportinfo->pmport_link_lost_time) >=
19436 drv_usectohz(
19437 SATA_EVNT_LINK_LOST_TIMEOUT)) {
19438 /* trigger device detach event */
19439 pmportinfo->pmport_event_flags |=
19440 SATA_EVNT_DEVICE_DETACHED;
19441 pmportinfo->pmport_link_lost_time = 0;
19442 SATADBG2(SATA_DBG_EVENTS,
19443 sata_hba_inst,
19444 "Triggering port %d:%d "
19445 "device detached event",
19446 saddr->cport, saddr->pmport);
19447 } else {
19448 /* keep link lost event */
19449 pmportinfo->pmport_event_flags |=
19450 SATA_EVNT_LINK_LOST;
19451 }
19452 }
19453 }
19454 /*
19455 * We could change port state to disable/delay access to
19456 * the attached device until the link is recovered.
19457 */
19458 }
19459 done:
19460 event_flags = pmportinfo->pmport_event_flags;
19461 mutex_exit(&SATA_PMPORT_MUTEX(sata_hba_inst, saddr->cport,
19462 saddr->pmport));
19463 if (event_flags != 0) {
19464 mutex_enter(&sata_hba_inst->satahba_mutex);
19465 sata_hba_inst->satahba_event_flags |= SATA_EVNT_MAIN;
19466 mutex_exit(&sata_hba_inst->satahba_mutex);
19467 mutex_enter(&sata_mutex);
19468 sata_event_pending |= SATA_EVNT_MAIN;
19469 mutex_exit(&sata_mutex);
19470 }
19471 }
19472
19473 /*
19474 * Device Detached Event processing.
19475 * Port is probed to find if a device is really gone. If so,
19476 * the device info structure is detached from the SATA port info structure
19477 * and released.
19478 * Port status is updated.
19479 *
19480 * NOTE: Port multiplier ports events are handled by
19481 * sata_process_pmdevice_detached()
19482 */
19483 static void
19484 sata_process_device_detached(sata_hba_inst_t *sata_hba_inst,
19485 sata_address_t *saddr)
19486 {
19487 sata_cport_info_t *cportinfo;
19488 sata_pmport_info_t *pmportinfo;
19489 sata_drive_info_t *sdevinfo;
19490 sata_device_t sata_device;
19491 sata_address_t pmport_addr;
19492 char name[16];
19493 uint8_t cport = saddr->cport;
19494 int npmport;
19495 int rval;
19496
19497 SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst,
19498 "Processing port %d device detached", saddr->cport);
19499
19500 cportinfo = SATA_CPORT_INFO(sata_hba_inst, saddr->cport);
19501 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex);
19502 /* Clear event flag */
19503 cportinfo->cport_event_flags &= ~SATA_EVNT_DEVICE_DETACHED;
19504
19505 /* If the port is in SHUTDOWN or FAILED state, ignore detach event. */
19506 if ((cportinfo->cport_state &
19507 (SATA_PSTATE_SHUTDOWN | SATA_PSTATE_FAILED)) != 0) {
19508 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->
19509 cport_mutex);
19510 return;
19511 }
19512 /* For sanity, re-probe the port */
19513 sata_device.satadev_rev = SATA_DEVICE_REV;
19514 sata_device.satadev_addr = *saddr;
19515
19516 /*
19517 * We have to exit mutex, because the HBA probe port function may
19518 * block on its own mutex.
19519 */
19520 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex);
19521 rval = (*SATA_PROBE_PORT_FUNC(sata_hba_inst))
19522 (SATA_DIP(sata_hba_inst), &sata_device);
19523 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex);
19524 sata_update_port_info(sata_hba_inst, &sata_device);
19525 if (rval != SATA_SUCCESS) {
19526 /* Something went wrong? Fail the port */
19527 cportinfo->cport_state = SATA_PSTATE_FAILED;
19528 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->
19529 cport_mutex);
19530 SATA_LOG_D((sata_hba_inst, CE_WARN,
19531 "SATA port %d probing failed",
19532 saddr->cport));
19533 /*
19534 * We may want to release device info structure, but
19535 * it is not necessary.
19536 */
19537 return;
19538 } else {
19539 /* port probed successfully */
19540 cportinfo->cport_state |= SATA_STATE_PROBED | SATA_STATE_READY;
19541 }
19542 /*
19543 * Check if a device is still attached. For sanity, check also
19544 * link status - if no link, there is no device.
19545 */
19546 if ((sata_device.satadev_scr.sstatus & SATA_PORT_DEVLINK_UP_MASK) ==
19547 SATA_PORT_DEVLINK_UP && sata_device.satadev_type !=
19548 SATA_DTYPE_NONE) {
19549 /*
19550 * Device is still attached - ignore detach event.
19551 */
19552 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->
19553 cport_mutex);
19554 SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst,
19555 "Ignoring detach - device still attached to port %d",
19556 sata_device.satadev_addr.cport);
19557 return;
19558 }
19559 /*
19560 * We need to detach and release device info structure here
19561 */
19562 if (cportinfo->cport_dev_type == SATA_DTYPE_PMULT) {
19563 /*
19564 * A port-multiplier is removed.
19565 *
19566 * Calling sata_process_pmdevice_detached() does not work
19567 * here. The port multiplier is gone, so we cannot probe
19568 * sub-port any more and all pmult-related data structure must
19569 * be de-allocated immediately. Following structure of every
19570 * implemented sub-port behind the pmult are required to
19571 * released.
19572 *
19573 * - attachment point
19574 * - target node
19575 * - sata_drive_info
19576 * - sata_pmport_info
19577 */
19578 for (npmport = 0; npmport < SATA_NUM_PMPORTS(sata_hba_inst,
19579 cport); npmport ++) {
19580 SATADBG2(SATA_DBG_PMULT|SATA_DBG_EVENTS_PROC,
19581 sata_hba_inst,
19582 "Detaching target node at port %d:%d",
19583 cport, npmport);
19584
19585 mutex_exit(&SATA_CPORT_MUTEX(sata_hba_inst, cport));
19586
19587 /* Remove attachment point. */
19588 name[0] = '\0';
19589 (void) sprintf(name, "%d.%d", cport, npmport);
19590 ddi_remove_minor_node(SATA_DIP(sata_hba_inst), name);
19591 sata_log(sata_hba_inst, CE_NOTE,
19592 "Remove attachment point of port %d:%d",
19593 cport, npmport);
19594
19595 /* Remove target node */
19596 pmport_addr.cport = cport;
19597 pmport_addr.pmport = (uint8_t)npmport;
19598 pmport_addr.qual = SATA_ADDR_PMPORT;
19599 sata_remove_target_node(sata_hba_inst, &pmport_addr);
19600
19601 mutex_enter(&SATA_CPORT_MUTEX(sata_hba_inst, cport));
19602
19603 /* Release sata_pmport_info & sata_drive_info. */
19604 pmportinfo = SATA_PMPORT_INFO(sata_hba_inst,
19605 cport, npmport);
19606 ASSERT(pmportinfo != NULL);
19607
19608 sdevinfo = SATA_PMPORTINFO_DRV_INFO(pmportinfo);
19609 if (sdevinfo != NULL) {
19610 (void) kmem_free((void *) sdevinfo,
19611 sizeof (sata_drive_info_t));
19612 }
19613
19614 /* Release sata_pmport_info at last */
19615 (void) kmem_free((void *) pmportinfo,
19616 sizeof (sata_pmport_info_t));
19617 }
19618
19619 /* Finally, release sata_pmult_info */
19620 (void) kmem_free((void *)
19621 SATA_CPORTINFO_PMULT_INFO(cportinfo),
19622 sizeof (sata_pmult_info_t));
19623 SATA_CPORTINFO_PMULT_INFO(cportinfo) = NULL;
19624
19625 sata_log(sata_hba_inst, CE_WARN,
19626 "SATA port-multiplier detached at port %d", cport);
19627
19628 cportinfo->cport_dev_type = SATA_DTYPE_NONE;
19629 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst,
19630 saddr->cport)->cport_mutex);
19631 } else {
19632 if (SATA_CPORTINFO_DRV_INFO(cportinfo) != NULL) {
19633 sdevinfo = SATA_CPORTINFO_DRV_INFO(cportinfo);
19634 SATA_CPORTINFO_DRV_INFO(cportinfo) = NULL;
19635 (void) kmem_free((void *)sdevinfo,
19636 sizeof (sata_drive_info_t));
19637 }
19638 sata_log(sata_hba_inst, CE_WARN,
19639 "SATA device detached at port %d", cport);
19640
19641 cportinfo->cport_dev_type = SATA_DTYPE_NONE;
19642 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst,
19643 saddr->cport)->cport_mutex);
19644
19645 /*
19646 * Try to offline a device and remove target node
19647 * if it still exists
19648 */
19649 sata_remove_target_node(sata_hba_inst, saddr);
19650 }
19651
19652
19653 /*
19654 * Generate sysevent - EC_DR / ESC_DR_AP_STATE_CHANGE
19655 * with the hint: SE_HINT_REMOVE
19656 */
19657 sata_gen_sysevent(sata_hba_inst, saddr, SE_HINT_REMOVE);
19658 }
19659
19660 /*
19661 * Port Multiplier Port Device Deattached Event processing.
19662 *
19663 * NOTE: No Mutex should be hold.
19664 */
19665 static void
19666 sata_process_pmdevice_detached(sata_hba_inst_t *sata_hba_inst,
19667 sata_address_t *saddr)
19668 {
19669 sata_pmport_info_t *pmportinfo;
19670 sata_drive_info_t *sdevinfo;
19671 sata_device_t sata_device;
19672 int rval;
19673 uint8_t cport, pmport;
19674
19675 cport = saddr->cport;
19676 pmport = saddr->pmport;
19677
19678 SATADBG2(SATA_DBG_EVENTS_PROC, sata_hba_inst,
19679 "Processing port %d:%d device detached",
19680 cport, pmport);
19681
19682 pmportinfo = SATA_PMPORT_INFO(sata_hba_inst, cport, pmport);
19683 mutex_enter(&SATA_PMPORT_MUTEX(sata_hba_inst, cport, pmport));
19684
19685 /* Clear event flag */
19686 pmportinfo->pmport_event_flags &= ~SATA_EVNT_DEVICE_DETACHED;
19687
19688 /* If the port is in SHUTDOWN or FAILED state, ignore detach event. */
19689 if ((pmportinfo->pmport_state &
19690 (SATA_PSTATE_SHUTDOWN | SATA_PSTATE_FAILED)) != 0) {
19691 mutex_exit(&SATA_PMPORT_MUTEX(sata_hba_inst, cport, pmport));
19692 return;
19693 }
19694 /* For sanity, re-probe the port */
19695 sata_device.satadev_rev = SATA_DEVICE_REV;
19696 sata_device.satadev_addr = *saddr;
19697
19698 /*
19699 * We have to exit mutex, because the HBA probe port function may
19700 * block on its own mutex.
19701 */
19702 mutex_exit(&SATA_PMPORT_MUTEX(sata_hba_inst, cport, pmport));
19703 rval = (*SATA_PROBE_PORT_FUNC(sata_hba_inst))
19704 (SATA_DIP(sata_hba_inst), &sata_device);
19705 mutex_enter(&SATA_PMPORT_MUTEX(sata_hba_inst, cport, pmport));
19706 sata_update_pmport_info(sata_hba_inst, &sata_device);
19707 if (rval != SATA_SUCCESS) {
19708 /* Something went wrong? Fail the port */
19709 pmportinfo->pmport_state = SATA_PSTATE_FAILED;
19710 mutex_exit(&SATA_PMPORT_MUTEX(sata_hba_inst, cport, pmport));
19711 SATA_LOG_D((sata_hba_inst, CE_WARN,
19712 "SATA port %d:%d probing failed",
19713 saddr->pmport));
19714 /*
19715 * We may want to release device info structure, but
19716 * it is not necessary.
19717 */
19718 return;
19719 } else {
19720 /* port probed successfully */
19721 pmportinfo->pmport_state |=
19722 SATA_STATE_PROBED | SATA_STATE_READY;
19723 }
19724 /*
19725 * Check if a device is still attached. For sanity, check also
19726 * link status - if no link, there is no device.
19727 */
19728 if ((sata_device.satadev_scr.sstatus & SATA_PORT_DEVLINK_UP_MASK) ==
19729 SATA_PORT_DEVLINK_UP && sata_device.satadev_type !=
19730 SATA_DTYPE_NONE) {
19731 /*
19732 * Device is still attached - ignore detach event.
19733 */
19734 mutex_exit(&SATA_PMPORT_MUTEX(sata_hba_inst, cport, pmport));
19735 SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst,
19736 "Ignoring detach - device still attached to port %d",
19737 sata_device.satadev_addr.pmport);
19738 return;
19739 }
19740 /*
19741 * We need to detach and release device info structure here
19742 */
19743 if (SATA_PMPORTINFO_DRV_INFO(pmportinfo) != NULL) {
19744 sdevinfo = SATA_PMPORTINFO_DRV_INFO(pmportinfo);
19745 SATA_PMPORTINFO_DRV_INFO(pmportinfo) = NULL;
19746 (void) kmem_free((void *)sdevinfo,
19747 sizeof (sata_drive_info_t));
19748 }
19749 pmportinfo->pmport_dev_type = SATA_DTYPE_NONE;
19750 /*
19751 * Device cannot be reached anymore, even if the target node may be
19752 * still present.
19753 */
19754 mutex_exit(&SATA_PMPORT_MUTEX(sata_hba_inst, cport, pmport));
19755
19756 /*
19757 * Try to offline a device and remove target node if it still exists
19758 */
19759 sata_remove_target_node(sata_hba_inst, saddr);
19760
19761 /*
19762 * Generate sysevent - EC_DR / ESC_DR_AP_STATE_CHANGE
19763 * with the hint: SE_HINT_REMOVE
19764 */
19765 sata_gen_sysevent(sata_hba_inst, saddr, SE_HINT_REMOVE);
19766 }
19767
19768
19769 /*
19770 * Device Attached Event processing.
19771 * Port state is checked to verify that a device is really attached. If so,
19772 * the device info structure is created and attached to the SATA port info
19773 * structure.
19774 *
19775 * If attached device cannot be identified or set-up, the retry for the
19776 * attach processing is set-up. Subsequent daemon run would try again to
19777 * identify the device, until the time limit is reached
19778 * (SATA_DEV_IDENTIFY_TIMEOUT).
19779 *
19780 * This function cannot be called in interrupt context (it may sleep).
19781 *
19782 * NOTE: Port multiplier ports events are handled by
19783 * sata_process_pmdevice_attached()
19784 */
19785 static void
19786 sata_process_device_attached(sata_hba_inst_t *sata_hba_inst,
19787 sata_address_t *saddr)
19788 {
19789 sata_cport_info_t *cportinfo = NULL;
19790 sata_drive_info_t *sdevinfo = NULL;
19791 sata_pmult_info_t *pmultinfo = NULL;
19792 sata_pmport_info_t *pmportinfo = NULL;
19793 sata_device_t sata_device;
19794 dev_info_t *tdip;
19795 uint32_t event_flags = 0, pmult_event_flags = 0;
19796 int rval;
19797 int npmport;
19798
19799 SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst,
19800 "Processing port %d device attached", saddr->cport);
19801
19802 cportinfo = SATA_CPORT_INFO(sata_hba_inst, saddr->cport);
19803 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex);
19804
19805 /* Clear attach event flag first */
19806 cportinfo->cport_event_flags &= ~SATA_EVNT_DEVICE_ATTACHED;
19807
19808 /* If the port is in SHUTDOWN or FAILED state, ignore event. */
19809 if ((cportinfo->cport_state &
19810 (SATA_PSTATE_SHUTDOWN | SATA_PSTATE_FAILED)) != 0) {
19811 cportinfo->cport_dev_attach_time = 0;
19812 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->
19813 cport_mutex);
19814 return;
19815 }
19816
19817 /*
19818 * If the sata_drive_info structure is found attached to the port info,
19819 * despite the fact the device was removed and now it is re-attached,
19820 * the old drive info structure was not removed.
19821 * Arbitrarily release device info structure.
19822 */
19823 if (SATA_CPORTINFO_DRV_INFO(cportinfo) != NULL) {
19824 sdevinfo = SATA_CPORTINFO_DRV_INFO(cportinfo);
19825 SATA_CPORTINFO_DRV_INFO(cportinfo) = NULL;
19826 (void) kmem_free((void *)sdevinfo,
19827 sizeof (sata_drive_info_t));
19828 SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst,
19829 "Arbitrarily detaching old device info.", NULL);
19830 }
19831 cportinfo->cport_dev_type = SATA_DTYPE_NONE;
19832
19833 /* For sanity, re-probe the port */
19834 sata_device.satadev_rev = SATA_DEVICE_REV;
19835 sata_device.satadev_addr = *saddr;
19836
19837 /*
19838 * We have to exit mutex, because the HBA probe port function may
19839 * block on its own mutex.
19840 */
19841 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex);
19842 rval = (*SATA_PROBE_PORT_FUNC(sata_hba_inst))
19843 (SATA_DIP(sata_hba_inst), &sata_device);
19844 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex);
19845 sata_update_port_info(sata_hba_inst, &sata_device);
19846 if (rval != SATA_SUCCESS) {
19847 /* Something went wrong? Fail the port */
19848 cportinfo->cport_state = SATA_PSTATE_FAILED;
19849 cportinfo->cport_dev_attach_time = 0;
19850 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->
19851 cport_mutex);
19852 SATA_LOG_D((sata_hba_inst, CE_WARN,
19853 "SATA port %d probing failed",
19854 saddr->cport));
19855 return;
19856 } else {
19857 /* port probed successfully */
19858 cportinfo->cport_state |= SATA_STATE_PROBED | SATA_STATE_READY;
19859 }
19860 /*
19861 * Check if a device is still attached. For sanity, check also
19862 * link status - if no link, there is no device.
19863 */
19864 if ((sata_device.satadev_scr.sstatus & SATA_PORT_DEVLINK_UP_MASK) !=
19865 SATA_PORT_DEVLINK_UP || sata_device.satadev_type ==
19866 SATA_DTYPE_NONE) {
19867 /*
19868 * No device - ignore attach event.
19869 */
19870 cportinfo->cport_dev_attach_time = 0;
19871 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->
19872 cport_mutex);
19873 SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst,
19874 "Ignoring attach - no device connected to port %d",
19875 sata_device.satadev_addr.cport);
19876 return;
19877 }
19878
19879 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex);
19880 /*
19881 * Generate sysevent - EC_DR / ESC_DR_AP_STATE_CHANGE
19882 * with the hint: SE_HINT_INSERT
19883 */
19884 sata_gen_sysevent(sata_hba_inst, saddr, SE_HINT_INSERT);
19885
19886 /*
19887 * Port reprobing will take care of the creation of the device
19888 * info structure and determination of the device type.
19889 */
19890 sata_device.satadev_addr = *saddr;
19891 (void) sata_reprobe_port(sata_hba_inst, &sata_device,
19892 SATA_DEV_IDENTIFY_NORETRY);
19893
19894 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->
19895 cport_mutex);
19896 if ((cportinfo->cport_state & SATA_STATE_READY) &&
19897 (cportinfo->cport_dev_type != SATA_DTYPE_NONE)) {
19898 /* Some device is attached to the port */
19899 if (cportinfo->cport_dev_type == SATA_DTYPE_UNKNOWN) {
19900 /*
19901 * A device was not successfully attached.
19902 * Track retry time for device identification.
19903 */
19904 if (cportinfo->cport_dev_attach_time != 0) {
19905 clock_t cur_time = ddi_get_lbolt();
19906 /*
19907 * If the retry time limit was not exceeded,
19908 * reinstate attach event.
19909 */
19910 if ((cur_time -
19911 cportinfo->cport_dev_attach_time) <
19912 drv_usectohz(
19913 SATA_DEV_IDENTIFY_TIMEOUT)) {
19914 /* OK, restore attach event */
19915 cportinfo->cport_event_flags |=
19916 SATA_EVNT_DEVICE_ATTACHED;
19917 } else {
19918 /* Timeout - cannot identify device */
19919 cportinfo->cport_dev_attach_time = 0;
19920 sata_log(sata_hba_inst,
19921 CE_WARN,
19922 "Could not identify SATA device "
19923 "at port %d",
19924 saddr->cport);
19925 }
19926 } else {
19927 /*
19928 * Start tracking time for device
19929 * identification.
19930 * Save current time (lbolt value).
19931 */
19932 cportinfo->cport_dev_attach_time =
19933 ddi_get_lbolt();
19934 /* Restore attach event */
19935 cportinfo->cport_event_flags |=
19936 SATA_EVNT_DEVICE_ATTACHED;
19937 }
19938 } else if (cportinfo->cport_dev_type == SATA_DTYPE_PMULT) {
19939 cportinfo->cport_dev_attach_time = 0;
19940 sata_log(sata_hba_inst, CE_NOTE,
19941 "SATA port-multiplier detected at port %d",
19942 saddr->cport);
19943
19944 if (SATA_CPORTINFO_PMULT_INFO(cportinfo) != NULL) {
19945 /* Log the info of new port multiplier */
19946 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst,
19947 saddr->cport)->cport_mutex);
19948 sata_show_pmult_info(sata_hba_inst,
19949 &sata_device);
19950 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst,
19951 saddr->cport)->cport_mutex);
19952 }
19953
19954 ASSERT(SATA_CPORTINFO_PMULT_INFO(cportinfo) != NULL);
19955 pmultinfo = SATA_CPORTINFO_PMULT_INFO(cportinfo);
19956 for (npmport = 0; npmport <
19957 pmultinfo->pmult_num_dev_ports; npmport++) {
19958 pmportinfo = SATA_PMPORT_INFO(sata_hba_inst,
19959 saddr->cport, npmport);
19960 ASSERT(pmportinfo != NULL);
19961
19962 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst,
19963 saddr->cport)->cport_mutex);
19964 mutex_enter(&pmportinfo->pmport_mutex);
19965 /* Marked all pmports with link events. */
19966 pmportinfo->pmport_event_flags =
19967 SATA_EVNT_LINK_ESTABLISHED;
19968 pmult_event_flags |=
19969 pmportinfo->pmport_event_flags;
19970 mutex_exit(&pmportinfo->pmport_mutex);
19971 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst,
19972 saddr->cport)->cport_mutex);
19973 }
19974 /* Auto-online is not available for PMult now. */
19975
19976 } else {
19977 /*
19978 * If device was successfully attached, the subsequent
19979 * action depends on a state of the
19980 * sata_auto_online variable. If it is set to zero.
19981 * an explicit 'configure' command will be needed to
19982 * configure it. If its value is non-zero, we will
19983 * attempt to online (configure) the device.
19984 * First, log the message indicating that a device
19985 * was attached.
19986 */
19987 cportinfo->cport_dev_attach_time = 0;
19988 sata_log(sata_hba_inst, CE_WARN,
19989 "SATA device detected at port %d", saddr->cport);
19990
19991 if (SATA_CPORTINFO_DRV_INFO(cportinfo) != NULL) {
19992 sata_drive_info_t new_sdinfo;
19993
19994 /* Log device info data */
19995 new_sdinfo = *(SATA_CPORTINFO_DRV_INFO(
19996 cportinfo));
19997 sata_show_drive_info(sata_hba_inst,
19998 &new_sdinfo);
19999 }
20000
20001 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst,
20002 saddr->cport)->cport_mutex);
20003
20004 /*
20005 * Make sure that there is no target node for that
20006 * device. If so, release it. It should not happen,
20007 * unless we had problem removing the node when
20008 * device was detached.
20009 */
20010 tdip = sata_get_target_dip(SATA_DIP(sata_hba_inst),
20011 saddr->cport, saddr->pmport);
20012 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst,
20013 saddr->cport)->cport_mutex);
20014 if (tdip != NULL) {
20015
20016 #ifdef SATA_DEBUG
20017 if ((cportinfo->cport_event_flags &
20018 SATA_EVNT_TARGET_NODE_CLEANUP) == 0)
20019 sata_log(sata_hba_inst, CE_WARN,
20020 "sata_process_device_attached: "
20021 "old device target node exists!");
20022 #endif
20023 /*
20024 * target node exists - try to unconfigure
20025 * device and remove the node.
20026 */
20027 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst,
20028 saddr->cport)->cport_mutex);
20029 rval = ndi_devi_offline(tdip,
20030 NDI_DEVI_REMOVE);
20031 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst,
20032 saddr->cport)->cport_mutex);
20033
20034 if (rval == NDI_SUCCESS) {
20035 cportinfo->cport_event_flags &=
20036 ~SATA_EVNT_TARGET_NODE_CLEANUP;
20037 cportinfo->cport_tgtnode_clean = B_TRUE;
20038 } else {
20039 /*
20040 * PROBLEM - the target node remained
20041 * and it belongs to a previously
20042 * attached device.
20043 * This happens when the file was open
20044 * or the node was waiting for
20045 * resources at the time the
20046 * associated device was removed.
20047 * Instruct event daemon to retry the
20048 * cleanup later.
20049 */
20050 sata_log(sata_hba_inst,
20051 CE_WARN,
20052 "Application(s) accessing "
20053 "previously attached SATA "
20054 "device have to release "
20055 "it before newly inserted "
20056 "device can be made accessible.",
20057 saddr->cport);
20058 cportinfo->cport_event_flags |=
20059 SATA_EVNT_TARGET_NODE_CLEANUP;
20060 cportinfo->cport_tgtnode_clean =
20061 B_FALSE;
20062 }
20063 }
20064 if (sata_auto_online != 0) {
20065 cportinfo->cport_event_flags |=
20066 SATA_EVNT_AUTOONLINE_DEVICE;
20067 }
20068
20069 }
20070 } else {
20071 cportinfo->cport_dev_attach_time = 0;
20072 }
20073
20074 event_flags = cportinfo->cport_event_flags;
20075 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex);
20076 if (event_flags != 0 || pmult_event_flags != 0) {
20077 mutex_enter(&sata_hba_inst->satahba_mutex);
20078 sata_hba_inst->satahba_event_flags |= SATA_EVNT_MAIN;
20079 mutex_exit(&sata_hba_inst->satahba_mutex);
20080 mutex_enter(&sata_mutex);
20081 sata_event_pending |= SATA_EVNT_MAIN;
20082 mutex_exit(&sata_mutex);
20083 }
20084 }
20085
20086 /*
20087 * Port Multiplier Port Device Attached Event processing.
20088 *
20089 * NOTE: No Mutex should be hold.
20090 */
20091 static void
20092 sata_process_pmdevice_attached(sata_hba_inst_t *sata_hba_inst,
20093 sata_address_t *saddr)
20094 {
20095 sata_pmport_info_t *pmportinfo;
20096 sata_drive_info_t *sdinfo;
20097 sata_device_t sata_device;
20098 dev_info_t *tdip;
20099 uint32_t event_flags;
20100 uint8_t cport = saddr->cport;
20101 uint8_t pmport = saddr->pmport;
20102 int rval;
20103
20104 SATADBG2(SATA_DBG_EVENTS_PROC, sata_hba_inst,
20105 "Processing port %d:%d device attached", cport, pmport);
20106
20107 pmportinfo = SATA_PMPORT_INFO(sata_hba_inst, cport, pmport);
20108
20109 mutex_enter(&pmportinfo->pmport_mutex);
20110
20111 /* Clear attach event flag first */
20112 pmportinfo->pmport_event_flags &= ~SATA_EVNT_DEVICE_ATTACHED;
20113
20114 /* If the port is in SHUTDOWN or FAILED state, ignore event. */
20115 if ((pmportinfo->pmport_state &
20116 (SATA_PSTATE_SHUTDOWN | SATA_PSTATE_FAILED)) != 0) {
20117 pmportinfo->pmport_dev_attach_time = 0;
20118 mutex_exit(&pmportinfo->pmport_mutex);
20119 return;
20120 }
20121
20122 /*
20123 * If the sata_drive_info structure is found attached to the port info,
20124 * despite the fact the device was removed and now it is re-attached,
20125 * the old drive info structure was not removed.
20126 * Arbitrarily release device info structure.
20127 */
20128 if (SATA_PMPORTINFO_DRV_INFO(pmportinfo) != NULL) {
20129 sdinfo = SATA_PMPORTINFO_DRV_INFO(pmportinfo);
20130 SATA_PMPORTINFO_DRV_INFO(pmportinfo) = NULL;
20131 (void) kmem_free((void *)sdinfo,
20132 sizeof (sata_drive_info_t));
20133 SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst,
20134 "Arbitrarily detaching old device info.", NULL);
20135 }
20136 pmportinfo->pmport_dev_type = SATA_DTYPE_NONE;
20137
20138 /* For sanity, re-probe the port */
20139 sata_device.satadev_rev = SATA_DEVICE_REV;
20140 sata_device.satadev_addr = *saddr;
20141
20142 /*
20143 * We have to exit mutex, because the HBA probe port function may
20144 * block on its own mutex.
20145 */
20146 mutex_exit(&pmportinfo->pmport_mutex);
20147 rval = (*SATA_PROBE_PORT_FUNC(sata_hba_inst))
20148 (SATA_DIP(sata_hba_inst), &sata_device);
20149 mutex_enter(&pmportinfo->pmport_mutex);
20150
20151 sata_update_pmport_info(sata_hba_inst, &sata_device);
20152 if (rval != SATA_SUCCESS) {
20153 /* Something went wrong? Fail the port */
20154 pmportinfo->pmport_state = SATA_PSTATE_FAILED;
20155 pmportinfo->pmport_dev_attach_time = 0;
20156 mutex_exit(&pmportinfo->pmport_mutex);
20157 SATA_LOG_D((sata_hba_inst, CE_WARN,
20158 "SATA port %d:%d probing failed", cport, pmport));
20159 return;
20160 } else {
20161 /* pmport probed successfully */
20162 pmportinfo->pmport_state |=
20163 SATA_STATE_PROBED | SATA_STATE_READY;
20164 }
20165 /*
20166 * Check if a device is still attached. For sanity, check also
20167 * link status - if no link, there is no device.
20168 */
20169 if ((sata_device.satadev_scr.sstatus & SATA_PORT_DEVLINK_UP_MASK) !=
20170 SATA_PORT_DEVLINK_UP || sata_device.satadev_type ==
20171 SATA_DTYPE_NONE) {
20172 /*
20173 * No device - ignore attach event.
20174 */
20175 pmportinfo->pmport_dev_attach_time = 0;
20176 mutex_exit(&pmportinfo->pmport_mutex);
20177 SATADBG2(SATA_DBG_EVENTS_PROC, sata_hba_inst,
20178 "Ignoring attach - no device connected to port %d:%d",
20179 cport, pmport);
20180 return;
20181 }
20182
20183 mutex_exit(&pmportinfo->pmport_mutex);
20184 /*
20185 * Generate sysevent - EC_DR / ESC_DR_AP_STATE_CHANGE
20186 * with the hint: SE_HINT_INSERT
20187 */
20188 sata_gen_sysevent(sata_hba_inst, saddr, SE_HINT_INSERT);
20189
20190 /*
20191 * Port reprobing will take care of the creation of the device
20192 * info structure and determination of the device type.
20193 */
20194 sata_device.satadev_addr = *saddr;
20195 (void) sata_reprobe_port(sata_hba_inst, &sata_device,
20196 SATA_DEV_IDENTIFY_NORETRY);
20197
20198 mutex_enter(&pmportinfo->pmport_mutex);
20199 if ((pmportinfo->pmport_state & SATA_STATE_READY) &&
20200 (pmportinfo->pmport_dev_type != SATA_DTYPE_NONE)) {
20201 /* Some device is attached to the port */
20202 if (pmportinfo->pmport_dev_type == SATA_DTYPE_UNKNOWN) {
20203 /*
20204 * A device was not successfully attached.
20205 * Track retry time for device identification.
20206 */
20207 if (pmportinfo->pmport_dev_attach_time != 0) {
20208 clock_t cur_time = ddi_get_lbolt();
20209 /*
20210 * If the retry time limit was not exceeded,
20211 * reinstate attach event.
20212 */
20213 if ((cur_time -
20214 pmportinfo->pmport_dev_attach_time) <
20215 drv_usectohz(
20216 SATA_DEV_IDENTIFY_TIMEOUT)) {
20217 /* OK, restore attach event */
20218 pmportinfo->pmport_event_flags |=
20219 SATA_EVNT_DEVICE_ATTACHED;
20220 } else {
20221 /* Timeout - cannot identify device */
20222 pmportinfo->pmport_dev_attach_time = 0;
20223 sata_log(sata_hba_inst, CE_WARN,
20224 "Could not identify SATA device "
20225 "at port %d:%d",
20226 cport, pmport);
20227 }
20228 } else {
20229 /*
20230 * Start tracking time for device
20231 * identification.
20232 * Save current time (lbolt value).
20233 */
20234 pmportinfo->pmport_dev_attach_time =
20235 ddi_get_lbolt();
20236 /* Restore attach event */
20237 pmportinfo->pmport_event_flags |=
20238 SATA_EVNT_DEVICE_ATTACHED;
20239 }
20240 } else {
20241 /*
20242 * If device was successfully attached, the subsequent
20243 * action depends on a state of the
20244 * sata_auto_online variable. If it is set to zero.
20245 * an explicit 'configure' command will be needed to
20246 * configure it. If its value is non-zero, we will
20247 * attempt to online (configure) the device.
20248 * First, log the message indicating that a device
20249 * was attached.
20250 */
20251 pmportinfo->pmport_dev_attach_time = 0;
20252 sata_log(sata_hba_inst, CE_WARN,
20253 "SATA device detected at port %d:%d",
20254 cport, pmport);
20255
20256 if (SATA_PMPORTINFO_DRV_INFO(pmportinfo) != NULL) {
20257 sata_drive_info_t new_sdinfo;
20258
20259 /* Log device info data */
20260 new_sdinfo = *(SATA_PMPORTINFO_DRV_INFO(
20261 pmportinfo));
20262 sata_show_drive_info(sata_hba_inst,
20263 &new_sdinfo);
20264 }
20265
20266 mutex_exit(&pmportinfo->pmport_mutex);
20267
20268 /*
20269 * Make sure that there is no target node for that
20270 * device. If so, release it. It should not happen,
20271 * unless we had problem removing the node when
20272 * device was detached.
20273 */
20274 tdip = sata_get_target_dip(SATA_DIP(sata_hba_inst),
20275 saddr->cport, saddr->pmport);
20276 mutex_enter(&pmportinfo->pmport_mutex);
20277 if (tdip != NULL) {
20278
20279 #ifdef SATA_DEBUG
20280 if ((pmportinfo->pmport_event_flags &
20281 SATA_EVNT_TARGET_NODE_CLEANUP) == 0)
20282 sata_log(sata_hba_inst, CE_WARN,
20283 "sata_process_device_attached: "
20284 "old device target node exists!");
20285 #endif
20286 /*
20287 * target node exists - try to unconfigure
20288 * device and remove the node.
20289 */
20290 mutex_exit(&pmportinfo->pmport_mutex);
20291 rval = ndi_devi_offline(tdip,
20292 NDI_DEVI_REMOVE);
20293 mutex_enter(&pmportinfo->pmport_mutex);
20294
20295 if (rval == NDI_SUCCESS) {
20296 pmportinfo->pmport_event_flags &=
20297 ~SATA_EVNT_TARGET_NODE_CLEANUP;
20298 pmportinfo->pmport_tgtnode_clean =
20299 B_TRUE;
20300 } else {
20301 /*
20302 * PROBLEM - the target node remained
20303 * and it belongs to a previously
20304 * attached device.
20305 * This happens when the file was open
20306 * or the node was waiting for
20307 * resources at the time the
20308 * associated device was removed.
20309 * Instruct event daemon to retry the
20310 * cleanup later.
20311 */
20312 sata_log(sata_hba_inst,
20313 CE_WARN,
20314 "Application(s) accessing "
20315 "previously attached SATA "
20316 "device have to release "
20317 "it before newly inserted "
20318 "device can be made accessible."
20319 "at port %d:%d",
20320 cport, pmport);
20321 pmportinfo->pmport_event_flags |=
20322 SATA_EVNT_TARGET_NODE_CLEANUP;
20323 pmportinfo->pmport_tgtnode_clean =
20324 B_FALSE;
20325 }
20326 }
20327 if (sata_auto_online != 0) {
20328 pmportinfo->pmport_event_flags |=
20329 SATA_EVNT_AUTOONLINE_DEVICE;
20330 }
20331
20332 }
20333 } else {
20334 pmportinfo->pmport_dev_attach_time = 0;
20335 }
20336
20337 event_flags = pmportinfo->pmport_event_flags;
20338 mutex_exit(&pmportinfo->pmport_mutex);
20339 if (event_flags != 0) {
20340 mutex_enter(&sata_hba_inst->satahba_mutex);
20341 sata_hba_inst->satahba_event_flags |= SATA_EVNT_MAIN;
20342 mutex_exit(&sata_hba_inst->satahba_mutex);
20343 mutex_enter(&sata_mutex);
20344 sata_event_pending |= SATA_EVNT_MAIN;
20345 mutex_exit(&sata_mutex);
20346 }
20347
20348 /* clear the reset_in_progress events */
20349 if (SATA_PMPORTINFO_DRV_INFO(pmportinfo) != NULL) {
20350 if (pmportinfo->pmport_dev_type & SATA_VALID_DEV_TYPE) {
20351 /* must clear flags on cport */
20352 sata_pmult_info_t *pminfo =
20353 SATA_PMULT_INFO(sata_hba_inst,
20354 saddr->cport);
20355 pminfo->pmult_event_flags |=
20356 SATA_EVNT_CLEAR_DEVICE_RESET;
20357 }
20358 }
20359 }
20360
20361 /*
20362 * Device Target Node Cleanup Event processing.
20363 * If the target node associated with a sata port device is in
20364 * DEVI_DEVICE_REMOVED state, an attempt is made to remove it.
20365 * If the target node cannot be removed, the event flag is left intact,
20366 * so that event daemon may re-run this function later.
20367 *
20368 * This function cannot be called in interrupt context (it may sleep).
20369 *
20370 * NOTE: Processes cport events only, not port multiplier ports.
20371 */
20372 static void
20373 sata_process_target_node_cleanup(sata_hba_inst_t *sata_hba_inst,
20374 sata_address_t *saddr)
20375 {
20376 sata_cport_info_t *cportinfo;
20377 dev_info_t *tdip;
20378
20379 SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst,
20380 "Processing port %d device target node cleanup", saddr->cport);
20381
20382 cportinfo = SATA_CPORT_INFO(sata_hba_inst, saddr->cport);
20383
20384 /*
20385 * Check if there is target node for that device and it is in the
20386 * DEVI_DEVICE_REMOVED state. If so, release it.
20387 */
20388 tdip = sata_get_target_dip(SATA_DIP(sata_hba_inst), saddr->cport,
20389 saddr->pmport);
20390 if (tdip != NULL) {
20391 /*
20392 * target node exists - check if it is target node of
20393 * a removed device.
20394 */
20395 if (sata_check_device_removed(tdip) == B_TRUE) {
20396 SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst,
20397 "sata_process_target_node_cleanup: "
20398 "old device target node exists!", NULL);
20399 /*
20400 * Unconfigure and remove the target node
20401 */
20402 if (ndi_devi_offline(tdip, NDI_DEVI_REMOVE) ==
20403 NDI_SUCCESS) {
20404 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst,
20405 saddr->cport)->cport_mutex);
20406 cportinfo->cport_event_flags &=
20407 ~SATA_EVNT_TARGET_NODE_CLEANUP;
20408 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst,
20409 saddr->cport)->cport_mutex);
20410 return;
20411 }
20412 /*
20413 * Event daemon will retry the cleanup later.
20414 */
20415 mutex_enter(&sata_hba_inst->satahba_mutex);
20416 sata_hba_inst->satahba_event_flags |= SATA_EVNT_MAIN;
20417 mutex_exit(&sata_hba_inst->satahba_mutex);
20418 mutex_enter(&sata_mutex);
20419 sata_event_pending |= SATA_EVNT_MAIN;
20420 mutex_exit(&sata_mutex);
20421 }
20422 } else {
20423 if (saddr->qual == SATA_ADDR_CPORT ||
20424 saddr->qual == SATA_ADDR_DCPORT) {
20425 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst,
20426 saddr->cport)->cport_mutex);
20427 cportinfo->cport_event_flags &=
20428 ~SATA_EVNT_TARGET_NODE_CLEANUP;
20429 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst,
20430 saddr->cport)->cport_mutex);
20431 } else {
20432 /* sanity check */
20433 if (SATA_CPORT_DEV_TYPE(sata_hba_inst, saddr->cport) !=
20434 SATA_DTYPE_PMULT || SATA_PMULT_INFO(sata_hba_inst,
20435 saddr->cport) == NULL)
20436 return;
20437 if (SATA_PMPORT_INFO(sata_hba_inst, saddr->cport,
20438 saddr->pmport) == NULL)
20439 return;
20440
20441 mutex_enter(&SATA_PMPORT_INFO(sata_hba_inst,
20442 saddr->cport, saddr->pmport)->pmport_mutex);
20443 SATA_PMPORT_INFO(sata_hba_inst, saddr->cport,
20444 saddr->pmport)->pmport_event_flags &=
20445 ~SATA_EVNT_TARGET_NODE_CLEANUP;
20446 mutex_exit(&SATA_PMPORT_INFO(sata_hba_inst,
20447 saddr->cport, saddr->pmport)->pmport_mutex);
20448 }
20449 }
20450 }
20451
20452 /*
20453 * Device AutoOnline Event processing.
20454 * If attached device is to be onlined, an attempt is made to online this
20455 * device, but only if there is no lingering (old) target node present.
20456 * If the device cannot be onlined, the event flag is left intact,
20457 * so that event daemon may re-run this function later.
20458 *
20459 * This function cannot be called in interrupt context (it may sleep).
20460 *
20461 * NOTE: Processes cport events only, not port multiplier ports.
20462 */
20463 static void
20464 sata_process_device_autoonline(sata_hba_inst_t *sata_hba_inst,
20465 sata_address_t *saddr)
20466 {
20467 sata_cport_info_t *cportinfo;
20468 sata_drive_info_t *sdinfo;
20469 sata_device_t sata_device;
20470 dev_info_t *tdip;
20471
20472 SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst,
20473 "Processing port %d attached device auto-onlining", saddr->cport);
20474
20475 cportinfo = SATA_CPORT_INFO(sata_hba_inst, saddr->cport);
20476
20477 /*
20478 * Check if device is present and recognized. If not, reset event.
20479 */
20480 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex);
20481 if ((cportinfo->cport_dev_type & SATA_VALID_DEV_TYPE) == 0) {
20482 /* Nothing to online */
20483 cportinfo->cport_event_flags &= ~SATA_EVNT_AUTOONLINE_DEVICE;
20484 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst,
20485 saddr->cport)->cport_mutex);
20486 return;
20487 }
20488 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex);
20489
20490 /*
20491 * Check if there is target node for this device and if it is in the
20492 * DEVI_DEVICE_REMOVED state. If so, abort onlining but keep
20493 * the event for later processing.
20494 */
20495 tdip = sata_get_target_dip(SATA_DIP(sata_hba_inst), saddr->cport,
20496 saddr->pmport);
20497 if (tdip != NULL) {
20498 /*
20499 * target node exists - check if it is target node of
20500 * a removed device.
20501 */
20502 if (sata_check_device_removed(tdip) == B_TRUE) {
20503 SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst,
20504 "sata_process_device_autoonline: "
20505 "old device target node exists!", NULL);
20506 /*
20507 * Event daemon will retry device onlining later.
20508 */
20509 mutex_enter(&sata_hba_inst->satahba_mutex);
20510 sata_hba_inst->satahba_event_flags |= SATA_EVNT_MAIN;
20511 mutex_exit(&sata_hba_inst->satahba_mutex);
20512 mutex_enter(&sata_mutex);
20513 sata_event_pending |= SATA_EVNT_MAIN;
20514 mutex_exit(&sata_mutex);
20515 return;
20516 }
20517 /*
20518 * If the target node is not in the 'removed" state, assume
20519 * that it belongs to this device. There is nothing more to do,
20520 * but reset the event.
20521 */
20522 } else {
20523
20524 /*
20525 * Try to online the device
20526 * If there is any reset-related event, remove it. We are
20527 * configuring the device and no state restoring is needed.
20528 */
20529 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst,
20530 saddr->cport)->cport_mutex);
20531 sata_device.satadev_addr = *saddr;
20532 if (saddr->qual == SATA_ADDR_CPORT)
20533 sata_device.satadev_addr.qual = SATA_ADDR_DCPORT;
20534 else
20535 sata_device.satadev_addr.qual = SATA_ADDR_DPMPORT;
20536 sdinfo = sata_get_device_info(sata_hba_inst, &sata_device);
20537 if (sdinfo != NULL) {
20538 if (sdinfo->satadrv_event_flags &
20539 (SATA_EVNT_DEVICE_RESET |
20540 SATA_EVNT_INPROC_DEVICE_RESET))
20541 sdinfo->satadrv_event_flags = 0;
20542 sdinfo->satadrv_event_flags |=
20543 SATA_EVNT_CLEAR_DEVICE_RESET;
20544
20545 /* Need to create a new target node. */
20546 cportinfo->cport_tgtnode_clean = B_TRUE;
20547 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst,
20548 saddr->cport)->cport_mutex);
20549 tdip = sata_create_target_node(SATA_DIP(sata_hba_inst),
20550 sata_hba_inst, &sata_device.satadev_addr);
20551 if (tdip == NULL) {
20552 /*
20553 * Configure (onlining) failed.
20554 * We will NOT retry
20555 */
20556 SATA_LOG_D((sata_hba_inst, CE_WARN,
20557 "sata_process_device_autoonline: "
20558 "configuring SATA device at port %d failed",
20559 saddr->cport));
20560 }
20561 } else {
20562 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst,
20563 saddr->cport)->cport_mutex);
20564 }
20565
20566 }
20567 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex);
20568 cportinfo->cport_event_flags &= ~SATA_EVNT_AUTOONLINE_DEVICE;
20569 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst,
20570 saddr->cport)->cport_mutex);
20571 }
20572
20573
20574 static void
20575 sata_gen_sysevent(sata_hba_inst_t *sata_hba_inst, sata_address_t *saddr,
20576 int hint)
20577 {
20578 char ap[MAXPATHLEN];
20579 nvlist_t *ev_attr_list = NULL;
20580 int err;
20581
20582 /* Allocate and build sysevent attribute list */
20583 err = nvlist_alloc(&ev_attr_list, NV_UNIQUE_NAME_TYPE, DDI_NOSLEEP);
20584 if (err != 0) {
20585 SATA_LOG_D((sata_hba_inst, CE_WARN,
20586 "sata_gen_sysevent: "
20587 "cannot allocate memory for sysevent attributes\n"));
20588 return;
20589 }
20590 /* Add hint attribute */
20591 err = nvlist_add_string(ev_attr_list, DR_HINT, SE_HINT2STR(hint));
20592 if (err != 0) {
20593 SATA_LOG_D((sata_hba_inst, CE_WARN,
20594 "sata_gen_sysevent: "
20595 "failed to add DR_HINT attr for sysevent"));
20596 nvlist_free(ev_attr_list);
20597 return;
20598 }
20599 /*
20600 * Add AP attribute.
20601 * Get controller pathname and convert it into AP pathname by adding
20602 * a target number.
20603 */
20604 (void) snprintf(ap, MAXPATHLEN, "/devices");
20605 (void) ddi_pathname(SATA_DIP(sata_hba_inst), ap + strlen(ap));
20606 (void) snprintf(ap + strlen(ap), MAXPATHLEN - strlen(ap), ":%d",
20607 SATA_MAKE_AP_NUMBER(saddr->cport, saddr->pmport, saddr->qual));
20608
20609 err = nvlist_add_string(ev_attr_list, DR_AP_ID, ap);
20610 if (err != 0) {
20611 SATA_LOG_D((sata_hba_inst, CE_WARN,
20612 "sata_gen_sysevent: "
20613 "failed to add DR_AP_ID attr for sysevent"));
20614 nvlist_free(ev_attr_list);
20615 return;
20616 }
20617
20618 /* Generate/log sysevent */
20619 err = ddi_log_sysevent(SATA_DIP(sata_hba_inst), DDI_VENDOR_SUNW, EC_DR,
20620 ESC_DR_AP_STATE_CHANGE, ev_attr_list, NULL, DDI_NOSLEEP);
20621 if (err != DDI_SUCCESS) {
20622 SATA_LOG_D((sata_hba_inst, CE_WARN,
20623 "sata_gen_sysevent: "
20624 "cannot log sysevent, err code %x\n", err));
20625 }
20626
20627 nvlist_free(ev_attr_list);
20628 }
20629
20630
20631
20632
20633 /*
20634 * Set DEVI_DEVICE_REMOVED state in the SATA device target node.
20635 */
20636 static void
20637 sata_set_device_removed(dev_info_t *tdip)
20638 {
20639 int circ;
20640
20641 ASSERT(tdip != NULL);
20642
20643 ndi_devi_enter(tdip, &circ);
20644 mutex_enter(&DEVI(tdip)->devi_lock);
20645 DEVI_SET_DEVICE_REMOVED(tdip);
20646 mutex_exit(&DEVI(tdip)->devi_lock);
20647 ndi_devi_exit(tdip, circ);
20648 }
20649
20650
20651 /*
20652 * Set internal event instructing event daemon to try
20653 * to perform the target node cleanup.
20654 */
20655 static void
20656 sata_set_target_node_cleanup(sata_hba_inst_t *sata_hba_inst,
20657 sata_address_t *saddr)
20658 {
20659 if (saddr->qual == SATA_ADDR_CPORT ||
20660 saddr->qual == SATA_ADDR_DCPORT) {
20661 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst,
20662 saddr->cport)->cport_mutex);
20663 SATA_CPORT_EVENT_FLAGS(sata_hba_inst, saddr->cport) |=
20664 SATA_EVNT_TARGET_NODE_CLEANUP;
20665 SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->
20666 cport_tgtnode_clean = B_FALSE;
20667 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst,
20668 saddr->cport)->cport_mutex);
20669 } else {
20670 mutex_enter(&SATA_PMPORT_INFO(sata_hba_inst,
20671 saddr->cport, saddr->pmport)->pmport_mutex);
20672 SATA_PMPORT_EVENT_FLAGS(sata_hba_inst, saddr->cport,
20673 saddr->pmport) |= SATA_EVNT_TARGET_NODE_CLEANUP;
20674 SATA_PMPORT_INFO(sata_hba_inst, saddr->cport, saddr->pmport)->
20675 pmport_tgtnode_clean = B_FALSE;
20676 mutex_exit(&SATA_PMPORT_INFO(sata_hba_inst,
20677 saddr->cport, saddr->pmport)->pmport_mutex);
20678 }
20679 mutex_enter(&sata_hba_inst->satahba_mutex);
20680 sata_hba_inst->satahba_event_flags |= SATA_EVNT_MAIN;
20681 mutex_exit(&sata_hba_inst->satahba_mutex);
20682 mutex_enter(&sata_mutex);
20683 sata_event_pending |= SATA_EVNT_MAIN;
20684 mutex_exit(&sata_mutex);
20685 }
20686
20687
20688 /*
20689 * Check if the SATA device target node is in DEVI_DEVICE_REMOVED state,
20690 * i.e. check if the target node state indicates that it belongs to a removed
20691 * device.
20692 *
20693 * Returns B_TRUE if the target node is in DEVI_DEVICE_REMOVED state,
20694 * B_FALSE otherwise.
20695 */
20696 static boolean_t
20697 sata_check_device_removed(dev_info_t *tdip)
20698 {
20699 ASSERT(tdip != NULL);
20700
20701 if (DEVI_IS_DEVICE_REMOVED(tdip))
20702 return (B_TRUE);
20703 else
20704 return (B_FALSE);
20705 }
20706
20707
20708 /*
20709 * Check for DMA error. Return B_TRUE if error, B_FALSE otherwise.
20710 */
20711 static boolean_t
20712 sata_check_for_dma_error(dev_info_t *dip, sata_pkt_txlate_t *spx)
20713 {
20714 int fm_capability = ddi_fm_capable(dip);
20715 ddi_fm_error_t de;
20716
20717 if (fm_capability & DDI_FM_DMACHK_CAPABLE) {
20718 if (spx->txlt_buf_dma_handle != NULL) {
20719 ddi_fm_dma_err_get(spx->txlt_buf_dma_handle, &de,
20720 DDI_FME_VERSION);
20721 if (de.fme_status != DDI_SUCCESS)
20722 return (B_TRUE);
20723 }
20724 }
20725 return (B_FALSE);
20726 }
20727
20728
20729 /* ************************ FAULT INJECTTION **************************** */
20730
20731 #ifdef SATA_INJECT_FAULTS
20732
20733 static uint32_t sata_fault_count = 0;
20734 static uint32_t sata_fault_suspend_count = 0;
20735
20736 /*
20737 * Inject sata pkt fault
20738 * It modifies returned values of the sata packet.
20739 * It returns immediately if:
20740 * pkt fault injection is not enabled (via sata_inject_fault,
20741 * sata_inject_fault_count), or invalid fault is specified (sata_fault_type),
20742 * or pkt does not contain command to be faulted (set in sata_fault_cmd), or
20743 * pkt is not directed to specified fault controller/device
20744 * (sata_fault_ctrl_dev and sata_fault_device).
20745 * If fault controller is not specified, fault injection applies to all
20746 * controllers and devices.
20747 *
20748 * First argument is the pointer to the executed sata packet.
20749 * Second argument is a pointer to a value returned by the HBA tran_start
20750 * function.
20751 * Third argument specifies injected error. Injected sata packet faults
20752 * are the satapkt_reason values.
20753 * SATA_PKT_BUSY -1 Not completed, busy
20754 * SATA_PKT_DEV_ERROR 1 Device reported error
20755 * SATA_PKT_QUEUE_FULL 2 Not accepted, queue full
20756 * SATA_PKT_PORT_ERROR 3 Not completed, port error
20757 * SATA_PKT_CMD_UNSUPPORTED 4 Cmd unsupported
20758 * SATA_PKT_ABORTED 5 Aborted by request
20759 * SATA_PKT_TIMEOUT 6 Operation timeut
20760 * SATA_PKT_RESET 7 Aborted by reset request
20761 *
20762 * Additional global variables affecting the execution:
20763 *
20764 * sata_inject_fault_count variable specifies number of times in row the
20765 * error is injected. Value of -1 specifies permanent fault, ie. every time
20766 * the fault injection point is reached, the fault is injected and a pause
20767 * between fault injection specified by sata_inject_fault_pause_count is
20768 * ignored). Fault injection routine decrements sata_inject_fault_count
20769 * (if greater than zero) until it reaches 0. No fault is injected when
20770 * sata_inject_fault_count is 0 (zero).
20771 *
20772 * sata_inject_fault_pause_count variable specifies number of times a fault
20773 * injection is bypassed (pause between fault injections).
20774 * If set to 0, a fault is injected only a number of times specified by
20775 * sata_inject_fault_count.
20776 *
20777 * The fault counts are static, so for periodic errors they have to be manually
20778 * reset to start repetition sequence from scratch.
20779 * If the original value returned by the HBA tran_start function is not
20780 * SATA_TRAN_ACCEPTED and pkt reason is not SATA_PKT_COMPLETED, no error
20781 * is injected (to avoid masking real problems);
20782 *
20783 * NOTE: In its current incarnation, this function should be invoked only for
20784 * commands executed in SYNCHRONOUS mode.
20785 */
20786
20787
20788 static void
20789 sata_inject_pkt_fault(sata_pkt_t *spkt, int *rval, int fault)
20790 {
20791
20792 if (sata_inject_fault != SATA_INJECT_PKT_FAULT)
20793 return;
20794
20795 if (sata_inject_fault_count == 0)
20796 return;
20797
20798 if (fault == 0)
20799 return;
20800
20801 if (sata_fault_cmd != spkt->satapkt_cmd.satacmd_cmd_reg)
20802 return;
20803
20804 if (sata_fault_ctrl != NULL) {
20805 sata_pkt_txlate_t *spx =
20806 (sata_pkt_txlate_t *)spkt->satapkt_framework_private;
20807
20808 if (sata_fault_ctrl != NULL && sata_fault_ctrl !=
20809 spx->txlt_sata_hba_inst->satahba_dip)
20810 return;
20811
20812 if (sata_fault_device.satadev_addr.cport !=
20813 spkt->satapkt_device.satadev_addr.cport ||
20814 sata_fault_device.satadev_addr.pmport !=
20815 spkt->satapkt_device.satadev_addr.pmport ||
20816 sata_fault_device.satadev_addr.qual !=
20817 spkt->satapkt_device.satadev_addr.qual)
20818 return;
20819 }
20820
20821 /* Modify pkt return parameters */
20822 if (*rval != SATA_TRAN_ACCEPTED ||
20823 spkt->satapkt_reason != SATA_PKT_COMPLETED) {
20824 sata_fault_count = 0;
20825 sata_fault_suspend_count = 0;
20826 return;
20827 }
20828 if (sata_fault_count == 0 && sata_fault_suspend_count != 0) {
20829 /* Pause in the injection */
20830 sata_fault_suspend_count -= 1;
20831 return;
20832 }
20833
20834 if (sata_fault_count == 0 && sata_fault_suspend_count == 0) {
20835 /*
20836 * Init inject fault cycle. If fault count is set to -1,
20837 * it is a permanent fault.
20838 */
20839 if (sata_inject_fault_count != -1) {
20840 sata_fault_count = sata_inject_fault_count;
20841 sata_fault_suspend_count =
20842 sata_inject_fault_pause_count;
20843 if (sata_fault_suspend_count == 0)
20844 sata_inject_fault_count = 0;
20845 }
20846 }
20847
20848 if (sata_fault_count != 0)
20849 sata_fault_count -= 1;
20850
20851 switch (fault) {
20852 case SATA_PKT_BUSY:
20853 *rval = SATA_TRAN_BUSY;
20854 spkt->satapkt_reason = SATA_PKT_BUSY;
20855 break;
20856
20857 case SATA_PKT_QUEUE_FULL:
20858 *rval = SATA_TRAN_QUEUE_FULL;
20859 spkt->satapkt_reason = SATA_PKT_QUEUE_FULL;
20860 break;
20861
20862 case SATA_PKT_CMD_UNSUPPORTED:
20863 *rval = SATA_TRAN_CMD_UNSUPPORTED;
20864 spkt->satapkt_reason = SATA_PKT_CMD_UNSUPPORTED;
20865 break;
20866
20867 case SATA_PKT_PORT_ERROR:
20868 /* This is "rejected" command */
20869 *rval = SATA_TRAN_PORT_ERROR;
20870 spkt->satapkt_reason = SATA_PKT_PORT_ERROR;
20871 /* Additional error setup could be done here - port state */
20872 break;
20873
20874 case SATA_PKT_DEV_ERROR:
20875 spkt->satapkt_reason = SATA_PKT_DEV_ERROR;
20876 /*
20877 * Additional error setup could be done here
20878 */
20879 break;
20880
20881 case SATA_PKT_ABORTED:
20882 spkt->satapkt_reason = SATA_PKT_ABORTED;
20883 break;
20884
20885 case SATA_PKT_TIMEOUT:
20886 spkt->satapkt_reason = SATA_PKT_TIMEOUT;
20887 /* Additional error setup could be done here */
20888 break;
20889
20890 case SATA_PKT_RESET:
20891 spkt->satapkt_reason = SATA_PKT_RESET;
20892 /*
20893 * Additional error setup could be done here - device reset
20894 */
20895 break;
20896
20897 default:
20898 break;
20899 }
20900 }
20901
20902 #endif
20903
20904 /*
20905 * SATA Trace Ring Buffer
20906 * ----------------------
20907 *
20908 * Overview
20909 *
20910 * The SATA trace ring buffer is a ring buffer created and managed by
20911 * the SATA framework module that can be used by any module or driver
20912 * within the SATA framework to store debug messages.
20913 *
20914 * Ring Buffer Interfaces:
20915 *
20916 * sata_vtrace_debug() <-- Adds debug message to ring buffer
20917 * sata_trace_debug() <-- Wraps varargs into sata_vtrace_debug()
20918 *
20919 * Note that the sata_trace_debug() interface was created to give
20920 * consumers the flexibilty of sending debug messages to ring buffer
20921 * as variable arguments. Consumers can send type va_list debug
20922 * messages directly to sata_vtrace_debug(). The sata_trace_debug()
20923 * and sata_vtrace_debug() relationship is similar to that of
20924 * cmn_err(9F) and vcmn_err(9F).
20925 *
20926 * Below is a diagram of the SATA trace ring buffer interfaces and
20927 * sample consumers:
20928 *
20929 * +---------------------------------+
20930 * | o o SATA Framework Module |
20931 * | o SATA o +------------------+ +------------------+
20932 * |o Trace o <--|sata_vtrace_debug/|<-----|SATA HBA Driver #1|
20933 * |o R-Buf o |sata_trace_debug |<--+ +------------------+
20934 * | o o +------------------+ | +------------------+
20935 * | o o ^ | +--|SATA HBA Driver #2|
20936 * | | | +------------------+
20937 * | +------------------+ |
20938 * | |SATA Debug Message| |
20939 * | +------------------+ |
20940 * +---------------------------------+
20941 *
20942 * Supporting Routines:
20943 *
20944 * sata_trace_rbuf_alloc() <-- Initializes ring buffer
20945 * sata_trace_rbuf_free() <-- Destroys ring buffer
20946 * sata_trace_dmsg_alloc() <-- Creates or reuses buffer in ring buffer
20947 * sata_trace_dmsg_free() <-- Destroys content of ring buffer
20948 *
20949 * The default SATA trace ring buffer size is defined by DMSG_RING_SIZE.
20950 * The ring buffer size can be adjusted by setting dmsg_ring_size in
20951 * /etc/system to desired size in unit of bytes.
20952 *
20953 * The individual debug message size in the ring buffer is restricted
20954 * to DMSG_BUF_SIZE.
20955 */
20956 void
20957 sata_vtrace_debug(dev_info_t *dip, const char *fmt, va_list ap)
20958 {
20959 sata_trace_dmsg_t *dmsg;
20960
20961 if (sata_debug_rbuf == NULL) {
20962 return;
20963 }
20964
20965 /*
20966 * If max size of ring buffer is smaller than size
20967 * required for one debug message then just return
20968 * since we have no room for the debug message.
20969 */
20970 if (sata_debug_rbuf->maxsize < (sizeof (sata_trace_dmsg_t))) {
20971 return;
20972 }
20973
20974 mutex_enter(&sata_debug_rbuf->lock);
20975
20976 /* alloc or reuse on ring buffer */
20977 dmsg = sata_trace_dmsg_alloc();
20978
20979 if (dmsg == NULL) {
20980 /* resource allocation failed */
20981 mutex_exit(&sata_debug_rbuf->lock);
20982 return;
20983 }
20984
20985 dmsg->dip = dip;
20986 gethrestime(&dmsg->timestamp);
20987
20988 (void) vsnprintf(dmsg->buf, sizeof (dmsg->buf), fmt, ap);
20989
20990 mutex_exit(&sata_debug_rbuf->lock);
20991 }
20992
20993 void
20994 sata_trace_debug(dev_info_t *dip, const char *fmt, ...)
20995 {
20996 va_list ap;
20997
20998 va_start(ap, fmt);
20999 sata_vtrace_debug(dip, fmt, ap);
21000 va_end(ap);
21001 }
21002
21003 /*
21004 * This routine is used to manage debug messages
21005 * on ring buffer.
21006 */
21007 static sata_trace_dmsg_t *
21008 sata_trace_dmsg_alloc(void)
21009 {
21010 sata_trace_dmsg_t *dmsg_alloc, *dmsg = sata_debug_rbuf->dmsgp;
21011
21012 if (sata_debug_rbuf->looped == TRUE) {
21013 sata_debug_rbuf->dmsgp = dmsg->next;
21014 return (sata_debug_rbuf->dmsgp);
21015 }
21016
21017 /*
21018 * If we're looping for the first time,
21019 * connect the ring.
21020 */
21021 if (((sata_debug_rbuf->size + (sizeof (sata_trace_dmsg_t))) >
21022 sata_debug_rbuf->maxsize) && (sata_debug_rbuf->dmsgh != NULL)) {
21023 dmsg->next = sata_debug_rbuf->dmsgh;
21024 sata_debug_rbuf->dmsgp = sata_debug_rbuf->dmsgh;
21025 sata_debug_rbuf->looped = TRUE;
21026 return (sata_debug_rbuf->dmsgp);
21027 }
21028
21029 /* If we've gotten this far then memory allocation is needed */
21030 dmsg_alloc = kmem_zalloc(sizeof (sata_trace_dmsg_t), KM_NOSLEEP);
21031 if (dmsg_alloc == NULL) {
21032 sata_debug_rbuf->allocfailed++;
21033 return (dmsg_alloc);
21034 } else {
21035 sata_debug_rbuf->size += sizeof (sata_trace_dmsg_t);
21036 }
21037
21038 if (sata_debug_rbuf->dmsgp != NULL) {
21039 dmsg->next = dmsg_alloc;
21040 sata_debug_rbuf->dmsgp = dmsg->next;
21041 return (sata_debug_rbuf->dmsgp);
21042 } else {
21043 /*
21044 * We should only be here if we're initializing
21045 * the ring buffer.
21046 */
21047 if (sata_debug_rbuf->dmsgh == NULL) {
21048 sata_debug_rbuf->dmsgh = dmsg_alloc;
21049 } else {
21050 /* Something is wrong */
21051 kmem_free(dmsg_alloc, sizeof (sata_trace_dmsg_t));
21052 return (NULL);
21053 }
21054
21055 sata_debug_rbuf->dmsgp = dmsg_alloc;
21056 return (sata_debug_rbuf->dmsgp);
21057 }
21058 }
21059
21060
21061 /*
21062 * Free all messages on debug ring buffer.
21063 */
21064 static void
21065 sata_trace_dmsg_free(void)
21066 {
21067 sata_trace_dmsg_t *dmsg_next, *dmsg = sata_debug_rbuf->dmsgh;
21068
21069 while (dmsg != NULL) {
21070 dmsg_next = dmsg->next;
21071 kmem_free(dmsg, sizeof (sata_trace_dmsg_t));
21072
21073 /*
21074 * If we've looped around the ring than we're done.
21075 */
21076 if (dmsg_next == sata_debug_rbuf->dmsgh) {
21077 break;
21078 } else {
21079 dmsg = dmsg_next;
21080 }
21081 }
21082 }
21083
21084
21085 /*
21086 * This function can block
21087 */
21088 static void
21089 sata_trace_rbuf_alloc(void)
21090 {
21091 sata_debug_rbuf = kmem_zalloc(sizeof (sata_trace_rbuf_t), KM_SLEEP);
21092
21093 mutex_init(&sata_debug_rbuf->lock, NULL, MUTEX_DRIVER, NULL);
21094
21095 if (dmsg_ring_size > 0) {
21096 sata_debug_rbuf->maxsize = (size_t)dmsg_ring_size;
21097 }
21098 }
21099
21100
21101 static void
21102 sata_trace_rbuf_free(void)
21103 {
21104 sata_trace_dmsg_free();
21105 mutex_destroy(&sata_debug_rbuf->lock);
21106 kmem_free(sata_debug_rbuf, sizeof (sata_trace_rbuf_t));
21107 }
21108
21109 /*
21110 * If SATA_DEBUG is not defined then this routine is called instead
21111 * of sata_log() via the SATA_LOG_D macro.
21112 */
21113 static void
21114 sata_trace_log(sata_hba_inst_t *sata_hba_inst, uint_t level,
21115 const char *fmt, ...)
21116 {
21117 #ifndef __lock_lint
21118 _NOTE(ARGUNUSED(level))
21119 #endif
21120
21121 dev_info_t *dip = NULL;
21122 va_list ap;
21123
21124 if (sata_hba_inst != NULL) {
21125 dip = SATA_DIP(sata_hba_inst);
21126 }
21127
21128 va_start(ap, fmt);
21129 sata_vtrace_debug(dip, fmt, ap);
21130 va_end(ap);
21131 }