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 2017 Nexenta Systems, Inc. All rights reserved.
27 * Copyright 2016 Argo Technologies SA
28 * Copyright 2019 Joyent, Inc.
29 * Copyright 2024 RackTop Systems, Inc.
30 * Copyright 2023 Oxide Computer Company
31 * Copyright 2023 Jason King
32 */
33
34 /*
35 * SATA Framework
36 * Generic SATA Host Adapter Implementation
37 */
38
39 #include <sys/conf.h>
40 #include <sys/file.h>
41 #include <sys/ddi.h>
42 #include <sys/sunddi.h>
43 #include <sys/modctl.h>
44 #include <sys/cmn_err.h>
45 #include <sys/errno.h>
46 #include <sys/thread.h>
47 #include <sys/kstat.h>
48 #include <sys/note.h>
49 #include <sys/sysevent.h>
50 #include <sys/sysevent/eventdefs.h>
51 #include <sys/sysevent/dr.h>
52 #include <sys/taskq.h>
53 #include <sys/disp.h>
54 #include <sys/sdt.h>
55
56 #include <sys/sata/impl/sata.h>
57 #include <sys/sata/sata_hba.h>
58 #include <sys/sata/sata_defs.h>
59 #include <sys/sata/sata_cfgadm.h>
60 #include <sys/sata/sata_blacklist.h>
61 #include <sys/sata/sata_satl.h>
62
63 #include <sys/scsi/impl/spc3_types.h>
64
65 /*
66 * FMA header files
67 */
68 #include <sys/ddifm.h>
69 #include <sys/fm/protocol.h>
70 #include <sys/fm/util.h>
71 #include <sys/fm/io/ddi.h>
72
73 /* Debug flags - defined in sata.h */
74 int sata_debug_flags = 0;
75 int sata_msg = 0;
76
77 /*
78 * Flags enabling selected SATA HBA framework functionality
79 */
80 #define SATA_ENABLE_QUEUING 1
81 #define SATA_ENABLE_NCQ 2
82 #define SATA_ENABLE_PROCESS_EVENTS 4
83 #define SATA_ENABLE_PMULT_FBS 8 /* FIS-Based Switching */
84 int sata_func_enable =
85 SATA_ENABLE_PROCESS_EVENTS | SATA_ENABLE_QUEUING | SATA_ENABLE_NCQ;
86
87 /*
88 * Global variable setting default maximum queue depth (NCQ or TCQ)
89 * Note:minimum queue depth is 1
90 */
91 int sata_max_queue_depth = SATA_MAX_QUEUE_DEPTH; /* max NCQ/TCQ queue depth */
92
93 /*
94 * Currently used default NCQ/TCQ queue depth. It is set-up during the driver
95 * initialization, using value from sata_max_queue_depth
96 * It is adjusted to minimum supported by the controller and by the device,
97 * if queueing is enabled.
98 */
99 static int sata_current_max_qdepth;
100
101 /*
102 * Global variable determining the default behavior after device hotpluggin.
103 * If non-zero, the hotplugged device is onlined (if possible) without explicit
104 * IOCTL request (AP_CONFIGURE).
105 * If zero, hotplugged device is identified, but not onlined.
106 * Enabling (AP_CONNECT) device port with an attached device does not result
107 * in device onlining regardless of the flag setting
108 */
109 int sata_auto_online = 0;
110
111 #ifdef SATA_DEBUG
112
113 #define SATA_LOG_D(args) sata_log args
114 uint64_t mbuf_count = 0;
115 uint64_t mbuffail_count = 0;
116
117 sata_atapi_cmd_t sata_atapi_trace[64];
118 uint32_t sata_atapi_trace_index = 0;
119 int sata_atapi_trace_save = 1;
120 static void sata_save_atapi_trace(sata_pkt_txlate_t *, int);
121 #define SATAATAPITRACE(spx, count) \
122 if (sata_atapi_trace_save) \
123 sata_save_atapi_trace(spx, count)
124
125 #else
126 #define SATA_LOG_D(args) sata_trace_log args
127 #define SATAATAPITRACE(spx, count)
128 #endif
129
130 #if 0
131 static void
132 sata_test_atapi_packet_command(sata_hba_inst_t *, int);
133 #endif
134
135 #ifdef SATA_INJECT_FAULTS
136
137 #define SATA_INJECT_PKT_FAULT 1
138 uint32_t sata_inject_fault = 0;
139
140 uint32_t sata_inject_fault_count = 0;
141 uint32_t sata_inject_fault_pause_count = 0;
142 uint32_t sata_fault_type = 0;
143 uint32_t sata_fault_cmd = 0;
144 dev_info_t *sata_fault_ctrl = NULL;
145 sata_device_t sata_fault_device;
146
147 static void sata_inject_pkt_fault(sata_pkt_t *, int *, int);
148
149 #endif
150
151 #define LEGACY_HWID_LEN 64 /* Model (40) + Serial (20) + pad */
152
153 /*
154 * SATA cb_ops functions
155 */
156 static int sata_hba_open(dev_t *, int, int, cred_t *);
157 static int sata_hba_close(dev_t, int, int, cred_t *);
158 static int sata_hba_ioctl(dev_t, int, intptr_t, int, cred_t *, int *);
159
160 /*
161 * SCSA required entry points
162 */
163 static int sata_scsi_tgt_init(dev_info_t *, dev_info_t *,
164 scsi_hba_tran_t *, struct scsi_device *);
165 static int sata_scsi_tgt_probe(struct scsi_device *,
166 int (*callback)(void));
167 static void sata_scsi_tgt_free(dev_info_t *, dev_info_t *,
168 scsi_hba_tran_t *, struct scsi_device *);
169 static int sata_scsi_start(struct scsi_address *, struct scsi_pkt *);
170 static int sata_scsi_abort(struct scsi_address *, struct scsi_pkt *);
171 static int sata_scsi_reset(struct scsi_address *, int);
172 static int sata_scsi_getcap(struct scsi_address *, char *, int);
173 static int sata_scsi_setcap(struct scsi_address *, char *, int, int);
174 static struct scsi_pkt *sata_scsi_init_pkt(struct scsi_address *,
175 struct scsi_pkt *, struct buf *, int, int, int, int, int (*)(caddr_t),
176 caddr_t);
177 static void sata_scsi_destroy_pkt(struct scsi_address *, struct scsi_pkt *);
178 static void sata_scsi_dmafree(struct scsi_address *, struct scsi_pkt *);
179 static void sata_scsi_sync_pkt(struct scsi_address *, struct scsi_pkt *);
180
181 /*
182 * SATA HBA interface functions are defined in sata_hba.h header file
183 */
184
185 /* Event processing functions */
186 static void sata_event_daemon(void *);
187 static void sata_event_thread_control(int);
188 static void sata_process_controller_events(sata_hba_inst_t *sata_hba_inst);
189 static void sata_process_pmult_events(sata_hba_inst_t *, uint8_t);
190 static void sata_process_device_reset(sata_hba_inst_t *, sata_address_t *);
191 static void sata_process_pmdevice_reset(sata_hba_inst_t *, sata_address_t *);
192 static void sata_process_port_failed_event(sata_hba_inst_t *,
193 sata_address_t *);
194 static void sata_process_port_link_events(sata_hba_inst_t *,
195 sata_address_t *);
196 static void sata_process_pmport_link_events(sata_hba_inst_t *,
197 sata_address_t *);
198 static void sata_process_device_detached(sata_hba_inst_t *, sata_address_t *);
199 static void sata_process_pmdevice_detached(sata_hba_inst_t *,
200 sata_address_t *);
201 static void sata_process_device_attached(sata_hba_inst_t *, sata_address_t *);
202 static void sata_process_pmdevice_attached(sata_hba_inst_t *,
203 sata_address_t *);
204 static void sata_process_port_pwr_change(sata_hba_inst_t *, sata_address_t *);
205 static void sata_process_cntrl_pwr_level_change(sata_hba_inst_t *);
206 static void sata_process_target_node_cleanup(sata_hba_inst_t *,
207 sata_address_t *);
208 static void sata_process_device_autoonline(sata_hba_inst_t *,
209 sata_address_t *saddr);
210
211 /*
212 * Local translation functions
213 */
214 static int sata_txlt_inquiry(sata_pkt_txlate_t *);
215 static int sata_txlt_test_unit_ready(sata_pkt_txlate_t *);
216 static int sata_txlt_start_stop_unit(sata_pkt_txlate_t *);
217 static int sata_txlt_read_capacity(sata_pkt_txlate_t *);
218 static int sata_txlt_read_capacity16(sata_pkt_txlate_t *);
219 static int sata_txlt_unmap(sata_pkt_txlate_t *);
220 static int sata_txlt_request_sense(sata_pkt_txlate_t *);
221 static int sata_txlt_read(sata_pkt_txlate_t *);
222 static int sata_txlt_write(sata_pkt_txlate_t *);
223 static int sata_txlt_log_sense(sata_pkt_txlate_t *);
224 static int sata_txlt_log_select(sata_pkt_txlate_t *);
225 static int sata_txlt_mode_sense(sata_pkt_txlate_t *);
226 static int sata_txlt_mode_select(sata_pkt_txlate_t *);
227 static int sata_txlt_ata_pass_thru(sata_pkt_txlate_t *);
228 static int sata_txlt_synchronize_cache(sata_pkt_txlate_t *);
229 static int sata_txlt_write_buffer(sata_pkt_txlate_t *);
230 static int sata_txlt_nodata_cmd_immediate(sata_pkt_txlate_t *);
231
232 static int sata_hba_start(sata_pkt_txlate_t *, int *);
233 static int sata_txlt_invalid_command(sata_pkt_txlate_t *);
234 static int sata_txlt_check_condition(sata_pkt_txlate_t *, uchar_t, uchar_t);
235 static int sata_txlt_lba_out_of_range(sata_pkt_txlate_t *);
236 static int sata_txlt_ata_pass_thru_illegal_cmd(sata_pkt_txlate_t *);
237 static int sata_txlt_unmap_nodata_cmd(sata_pkt_txlate_t *);
238 static void sata_txlt_rw_completion(sata_pkt_t *);
239 static void sata_txlt_nodata_cmd_completion(sata_pkt_t *);
240 static void sata_txlt_apt_completion(sata_pkt_t *sata_pkt);
241 static void sata_txlt_unmap_completion(sata_pkt_t *sata_pkt);
242 static int sata_emul_rw_completion(sata_pkt_txlate_t *);
243 static void sata_fill_ata_return_desc(sata_pkt_t *, uint8_t, uint8_t,
244 uint8_t);
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 int sata_set_dma_mode(sata_hba_inst_t *, sata_drive_info_t *);
322 static int sata_set_cache_mode(sata_hba_inst_t *, sata_drive_info_t *, int);
323 static int sata_set_rmsn(sata_hba_inst_t *, sata_drive_info_t *, int);
324 static int sata_set_drive_features(sata_hba_inst_t *,
325 sata_drive_info_t *, int flag);
326 static void sata_init_write_cache_mode(sata_drive_info_t *sdinfo);
327 static int sata_initialize_device(sata_hba_inst_t *, sata_drive_info_t *);
328 static void sata_identdev_to_inquiry(sata_hba_inst_t *, sata_drive_info_t *,
329 uint8_t *);
330 static int sata_get_atapi_inquiry_data(sata_hba_inst_t *, sata_address_t *,
331 struct scsi_inquiry *);
332 static int sata_build_msense_page_1(sata_drive_info_t *, int, uint8_t *);
333 static int sata_build_msense_page_8(sata_drive_info_t *, int, uint8_t *);
334 static int sata_build_msense_page_1a(sata_drive_info_t *, int, uint8_t *);
335 static int sata_build_msense_page_1c(sata_drive_info_t *, int, uint8_t *);
336 static int sata_build_msense_page_30(sata_drive_info_t *, int, uint8_t *);
337 static int sata_mode_select_page_8(sata_pkt_txlate_t *,
338 struct mode_cache_scsi3 *, int, int *, int *, int *);
339 static int sata_mode_select_page_1a(sata_pkt_txlate_t *,
340 struct mode_info_power_cond *, int, int *, int *, int *);
341 static int sata_mode_select_page_1c(sata_pkt_txlate_t *,
342 struct mode_info_excpt_page *, int, int *, int *, int *);
343 static int sata_mode_select_page_30(sata_pkt_txlate_t *,
344 struct mode_acoustic_management *, int, int *, int *, int *);
345
346 static int sata_build_lsense_page_0(sata_drive_info_t *, uint8_t *);
347 static int sata_build_lsense_page_10(sata_drive_info_t *, uint8_t *,
348 sata_hba_inst_t *);
349 static int sata_build_lsense_page_2f(sata_drive_info_t *, uint8_t *,
350 sata_hba_inst_t *);
351 static int sata_build_lsense_page_30(sata_drive_info_t *, uint8_t *,
352 sata_hba_inst_t *);
353 static int sata_build_lsense_page_0e(sata_drive_info_t *, uint8_t *,
354 sata_pkt_txlate_t *);
355
356 static void sata_set_arq_data(sata_pkt_t *);
357 static void sata_build_read_verify_cmd(sata_cmd_t *, uint16_t, uint64_t);
358 static void sata_build_generic_cmd(sata_cmd_t *, uint8_t);
359 static uint8_t sata_get_standby_timer(uint8_t *timer);
360
361 static void sata_save_drive_settings(sata_drive_info_t *);
362 static void sata_show_drive_info(sata_hba_inst_t *, sata_drive_info_t *);
363 static void sata_show_pmult_info(sata_hba_inst_t *, sata_device_t *);
364 static void sata_log(sata_hba_inst_t *, uint_t, char *fmt, ...);
365 #ifndef SATA_DEBUG
366 static void sata_trace_log(sata_hba_inst_t *, uint_t, const char *fmt, ...);
367 #endif
368 static int sata_fetch_smart_return_status(sata_hba_inst_t *,
369 sata_drive_info_t *);
370 static int sata_fetch_smart_data(sata_hba_inst_t *, sata_drive_info_t *,
371 struct smart_data *);
372 static int sata_smart_selftest_log(sata_hba_inst_t *,
373 sata_drive_info_t *,
374 struct smart_selftest_log *);
375 static int sata_ext_smart_selftest_read_log(sata_hba_inst_t *,
376 sata_drive_info_t *, struct smart_ext_selftest_log *, uint16_t);
377 static int sata_smart_read_log(sata_hba_inst_t *, sata_drive_info_t *,
378 uint8_t *, uint8_t, uint8_t);
379 static int sata_read_log_ext_directory(sata_hba_inst_t *, sata_drive_info_t *,
380 struct read_log_ext_directory *);
381 static void sata_gen_sysevent(sata_hba_inst_t *, sata_address_t *, int);
382 static void sata_xlate_errors(sata_pkt_txlate_t *);
383 static void sata_decode_device_error(sata_pkt_txlate_t *,
384 struct scsi_extended_sense *);
385 static void sata_set_device_removed(dev_info_t *);
386 static boolean_t sata_check_device_removed(dev_info_t *);
387 static void sata_set_target_node_cleanup(sata_hba_inst_t *, sata_address_t *);
388 static int sata_ncq_err_ret_cmd_setup(sata_pkt_txlate_t *,
389 sata_drive_info_t *);
390 static int sata_atapi_err_ret_cmd_setup(sata_pkt_txlate_t *,
391 sata_drive_info_t *);
392 static void sata_atapi_packet_cmd_setup(sata_cmd_t *, sata_drive_info_t *);
393 static void sata_fixed_sense_data_preset(struct scsi_extended_sense *);
394 static void sata_target_devid_register(dev_info_t *, sata_drive_info_t *);
395 static int sata_check_modser(char *, int);
396
397 /*
398 * FMA
399 */
400 static boolean_t sata_check_for_dma_error(dev_info_t *, sata_pkt_txlate_t *);
401
402
403 /*
404 * SATA Framework will ignore SATA HBA driver cb_ops structure and
405 * register following one with SCSA framework.
406 * Open & close are provided, so scsi framework will not use its own
407 */
408 static struct cb_ops sata_cb_ops = {
409 sata_hba_open, /* open */
410 sata_hba_close, /* close */
411 nodev, /* strategy */
412 nodev, /* print */
413 nodev, /* dump */
414 nodev, /* read */
415 nodev, /* write */
416 sata_hba_ioctl, /* ioctl */
417 nodev, /* devmap */
418 nodev, /* mmap */
419 nodev, /* segmap */
420 nochpoll, /* chpoll */
421 ddi_prop_op, /* cb_prop_op */
422 0, /* streamtab */
423 D_NEW | D_MP, /* cb_flag */
424 CB_REV, /* rev */
425 nodev, /* aread */
426 nodev /* awrite */
427 };
428
429
430 extern struct mod_ops mod_miscops;
431 extern uchar_t scsi_cdb_size[];
432
433 static struct modlmisc modlmisc = {
434 &mod_miscops, /* Type of module */
435 "SATA Module" /* module name */
436 };
437
438
439 static struct modlinkage modlinkage = {
440 MODREV_1,
441 (void *)&modlmisc,
442 NULL
443 };
444
445 /*
446 * Default sata pkt timeout. Used when a target driver scsi_pkt time is zero,
447 * i.e. when scsi_pkt has not timeout specified.
448 */
449 static int sata_default_pkt_time = 60; /* 60 seconds */
450
451 /*
452 * Intermediate buffer device access attributes - they are required,
453 * but not necessarily used.
454 */
455 static ddi_device_acc_attr_t sata_acc_attr = {
456 DDI_DEVICE_ATTR_V0,
457 DDI_STRUCTURE_LE_ACC,
458 DDI_STRICTORDER_ACC
459 };
460
461
462 /*
463 * Mutexes protecting structures in multithreaded operations.
464 * Because events are relatively rare, a single global mutex protecting
465 * data structures should be sufficient. To increase performance, add
466 * separate mutex per each sata port and use global mutex only to protect
467 * common data structures.
468 */
469 static kmutex_t sata_mutex; /* protects sata_hba_list */
470 static kmutex_t sata_log_mutex; /* protects log */
471
472 static char sata_log_buf[256];
473
474 /*
475 * sata trace debug
476 */
477 static sata_trace_rbuf_t *sata_debug_rbuf;
478 static sata_trace_dmsg_t *sata_trace_dmsg_alloc(void);
479 static void sata_trace_dmsg_free(void);
480 static void sata_trace_rbuf_alloc(void);
481 static void sata_trace_rbuf_free(void);
482
483 int dmsg_ring_size = DMSG_RING_SIZE;
484
485 /* Default write cache setting for SATA hard disks */
486 int sata_write_cache = 1; /* enabled */
487
488 /* Default write cache setting for SATA ATAPI CD/DVD */
489 int sata_atapicdvd_write_cache = 1; /* enabled */
490
491 /* Default write cache setting for SATA ATAPI tape */
492 int sata_atapitape_write_cache = 1; /* enabled */
493
494 /* Default write cache setting for SATA ATAPI disk */
495 int sata_atapidisk_write_cache = 1; /* enabled */
496
497 /*
498 * Linked list of HBA instances
499 */
500 static sata_hba_inst_t *sata_hba_list = NULL;
501 static sata_hba_inst_t *sata_hba_list_tail = NULL;
502 /*
503 * Pointer to per-instance SATA HBA soft structure is stored in sata_hba_tran
504 * structure and in sata soft state.
505 */
506
507 /*
508 * Event daemon related variables
509 */
510 static kmutex_t sata_event_mutex;
511 static kcondvar_t sata_event_cv;
512 static kthread_t *sata_event_thread = NULL;
513 static int sata_event_thread_terminate = 0;
514 static int sata_event_pending = 0;
515 static int sata_event_thread_active = 0;
516 extern pri_t minclsyspri;
517
518 /*
519 * NCQ error recovery command
520 */
521 static const sata_cmd_t sata_rle_cmd = {
522 SATA_CMD_REV,
523 NULL,
524 {
525 SATA_DIR_READ
526 },
527 ATA_ADDR_LBA48,
528 0,
529 0,
530 0,
531 0,
532 0,
533 1,
534 READ_LOG_EXT_NCQ_ERROR_RECOVERY,
535 0,
536 0,
537 0,
538 SATAC_READ_LOG_EXT,
539 0,
540 0,
541 0,
542 };
543
544 /*
545 * ATAPI error recovery CDB
546 */
547 static const uint8_t sata_rqsense_cdb[SATA_ATAPI_RQSENSE_CDB_LEN] = {
548 SCMD_REQUEST_SENSE,
549 0, /* Only fixed RQ format is supported */
550 0,
551 0,
552 SATA_ATAPI_MIN_RQSENSE_LEN, /* Less data may be returned */
553 0
554 };
555
556
557 /* Warlock directives */
558
559 _NOTE(SCHEME_PROTECTS_DATA("No Mutex Needed", scsi_hba_tran))
560 _NOTE(SCHEME_PROTECTS_DATA("No Mutex Needed", scsi_device))
561 _NOTE(SCHEME_PROTECTS_DATA("No Mutex Needed", dev_ops))
562 _NOTE(SCHEME_PROTECTS_DATA("No Mutex Needed", scsi_extended_sense))
563 _NOTE(SCHEME_PROTECTS_DATA("No Mutex Needed", scsi_arq_status))
564 _NOTE(SCHEME_PROTECTS_DATA("No Mutex Needed", ddi_dma_attr))
565 _NOTE(SCHEME_PROTECTS_DATA("No Mutex Needed", ddi_dma_cookie_t))
566 _NOTE(SCHEME_PROTECTS_DATA("No Mutex Needed", devctl_ap_state))
567 _NOTE(SCHEME_PROTECTS_DATA("No Mutex Needed", dev_info::devi_state))
_NOTE(MUTEX_PROTECTS_DATA (sata_mutex,sata_hba_list))568 _NOTE(MUTEX_PROTECTS_DATA(sata_mutex, sata_hba_list))
569 _NOTE(DATA_READABLE_WITHOUT_LOCK(sata_hba_list))
570 _NOTE(MUTEX_PROTECTS_DATA(sata_mutex, sata_hba_inst::satahba_next))
571 _NOTE(MUTEX_PROTECTS_DATA(sata_mutex, sata_hba_inst::satahba_prev))
572 _NOTE(SCHEME_PROTECTS_DATA("No Mutex Needed", \
573 sata_hba_inst::satahba_scsi_tran))
574 _NOTE(SCHEME_PROTECTS_DATA("No Mutex Needed", sata_hba_inst::satahba_tran))
575 _NOTE(SCHEME_PROTECTS_DATA("No Mutex Needed", sata_hba_inst::satahba_dip))
576 _NOTE(SCHEME_PROTECTS_DATA("Scheme", sata_hba_inst::satahba_attached))
577 _NOTE(DATA_READABLE_WITHOUT_LOCK(sata_hba_inst::satahba_dev_port))
578 _NOTE(MUTEX_PROTECTS_DATA(sata_hba_inst::satahba_mutex,
579 sata_hba_inst::satahba_event_flags))
580 _NOTE(MUTEX_PROTECTS_DATA(sata_cport_info::cport_mutex, \
581 sata_cport_info::cport_devp))
582 _NOTE(DATA_READABLE_WITHOUT_LOCK(sata_cport_info::cport_devp))
583 _NOTE(SCHEME_PROTECTS_DATA("Scheme", sata_cport_info::cport_addr))
584 _NOTE(MUTEX_PROTECTS_DATA(sata_cport_info::cport_mutex, \
585 sata_cport_info::cport_dev_type))
586 _NOTE(DATA_READABLE_WITHOUT_LOCK(sata_cport_info::cport_dev_type))
587 _NOTE(MUTEX_PROTECTS_DATA(sata_cport_info::cport_mutex, \
588 sata_cport_info::cport_state))
589 _NOTE(DATA_READABLE_WITHOUT_LOCK(sata_cport_info::cport_state))
590 _NOTE(MUTEX_PROTECTS_DATA(sata_pmport_info::pmport_mutex, \
591 sata_pmport_info::pmport_state))
592 _NOTE(DATA_READABLE_WITHOUT_LOCK(sata_pmport_info::pmport_state))
593 _NOTE(MUTEX_PROTECTS_DATA(sata_pmport_info::pmport_mutex, \
594 sata_pmport_info::pmport_dev_type))
595 _NOTE(DATA_READABLE_WITHOUT_LOCK(sata_pmport_info::pmport_dev_type))
596 _NOTE(MUTEX_PROTECTS_DATA(sata_pmport_info::pmport_mutex, \
597 sata_pmport_info::pmport_sata_drive))
598 _NOTE(MUTEX_PROTECTS_DATA(sata_pmport_info::pmport_mutex, \
599 sata_pmport_info::pmport_tgtnode_clean))
600 _NOTE(MUTEX_PROTECTS_DATA(sata_pmport_info::pmport_mutex, \
601 sata_pmport_info::pmport_event_flags))
602 _NOTE(DATA_READABLE_WITHOUT_LOCK(sata_pmport_info::pmport_sata_drive))
603 _NOTE(DATA_READABLE_WITHOUT_LOCK(sata_pmult_info::pmult_dev_port))
604 _NOTE(DATA_READABLE_WITHOUT_LOCK(sata_pmult_info::pmult_num_dev_ports))
605 #ifdef SATA_DEBUG
606 _NOTE(SCHEME_PROTECTS_DATA("No Mutex Needed", mbuf_count))
607 _NOTE(SCHEME_PROTECTS_DATA("No Mutex Needed", mbuffail_count))
608 _NOTE(SCHEME_PROTECTS_DATA("No Mutex Needed", sata_atapi_trace))
609 _NOTE(SCHEME_PROTECTS_DATA("No Mutex Needed", sata_atapi_trace_index))
610 #endif
611
612 /* End of warlock directives */
613
614 /* ************** loadable module configuration functions ************** */
615
616 int
617 _init()
618 {
619 int rval;
620
621 mutex_init(&sata_mutex, NULL, MUTEX_DRIVER, NULL);
622 mutex_init(&sata_event_mutex, NULL, MUTEX_DRIVER, NULL);
623 mutex_init(&sata_log_mutex, NULL, MUTEX_DRIVER, NULL);
624 cv_init(&sata_event_cv, NULL, CV_DRIVER, NULL);
625 sata_trace_rbuf_alloc();
626 if ((rval = mod_install(&modlinkage)) != 0) {
627 #ifdef SATA_DEBUG
628 cmn_err(CE_WARN, "sata: _init: mod_install failed\n");
629 #endif
630 sata_trace_rbuf_free();
631 mutex_destroy(&sata_log_mutex);
632 cv_destroy(&sata_event_cv);
633 mutex_destroy(&sata_event_mutex);
634 mutex_destroy(&sata_mutex);
635 }
636 return (rval);
637 }
638
639 int
_fini()640 _fini()
641 {
642 int rval;
643
644 if ((rval = mod_remove(&modlinkage)) != 0)
645 return (rval);
646
647 sata_trace_rbuf_free();
648 mutex_destroy(&sata_log_mutex);
649 cv_destroy(&sata_event_cv);
650 mutex_destroy(&sata_event_mutex);
651 mutex_destroy(&sata_mutex);
652 return (rval);
653 }
654
655 int
_info(struct modinfo * modinfop)656 _info(struct modinfo *modinfop)
657 {
658 return (mod_info(&modlinkage, modinfop));
659 }
660
661
662
663 /* ********************* SATA HBA entry points ********************* */
664
665
666 /*
667 * Called by SATA HBA from _init().
668 * Registers HBA driver instance/sata framework pair with scsi framework, by
669 * calling scsi_hba_init().
670 *
671 * SATA HBA driver cb_ops are ignored - SATA HBA framework cb_ops are used
672 * instead. SATA HBA framework cb_ops pointer overwrites SATA HBA driver
673 * cb_ops pointer in SATA HBA driver dev_ops structure.
674 * SATA HBA framework cb_ops supplies cb_open cb_close and cb_ioctl vectors.
675 *
676 * Return status of the scsi_hba_init() is returned to a calling SATA HBA
677 * driver.
678 */
679 int
sata_hba_init(struct modlinkage * modlp)680 sata_hba_init(struct modlinkage *modlp)
681 {
682 int rval;
683 struct dev_ops *hba_ops;
684
685 SATADBG1(SATA_DBG_HBA_IF, NULL,
686 "sata_hba_init: name %s \n",
687 ((struct modldrv *)(modlp->ml_linkage[0]))->drv_linkinfo);
688 /*
689 * Fill-up cb_ops and dev_ops when necessary
690 */
691 hba_ops = ((struct modldrv *)(modlp->ml_linkage[0]))->drv_dev_ops;
692 /*
693 * Provide pointer to SATA dev_ops
694 */
695 hba_ops->devo_cb_ops = &sata_cb_ops;
696
697 /*
698 * Register SATA HBA with SCSI framework
699 */
700 if ((rval = scsi_hba_init(modlp)) != 0) {
701 SATADBG1(SATA_DBG_HBA_IF, NULL,
702 "sata_hba_init: scsi hba init failed\n", NULL);
703 return (rval);
704 }
705
706 return (0);
707 }
708
709
710 /* HBA attach stages */
711 #define HBA_ATTACH_STAGE_SATA_HBA_INST 1
712 #define HBA_ATTACH_STAGE_SCSI_ATTACHED 2
713 #define HBA_ATTACH_STAGE_SETUP 4
714 #define HBA_ATTACH_STAGE_LINKED 8
715
716
717 /*
718 *
719 * Called from SATA HBA driver's attach routine to attach an instance of
720 * the HBA.
721 *
722 * For DDI_ATTACH command:
723 * sata_hba_inst structure is allocated here and initialized with pointers to
724 * SATA framework implementation of required scsi tran functions.
725 * The scsi_tran's tran_hba_private field is used by SATA Framework to point
726 * to the soft structure (sata_hba_inst) allocated by SATA framework for
727 * SATA HBA instance related data.
728 * The scsi_tran's tran_hba_private field is used by SATA framework to
729 * store a pointer to per-HBA-instance of sata_hba_inst structure.
730 * The sata_hba_inst structure is cross-linked to scsi tran structure.
731 * Among other info, a pointer to sata_hba_tran structure is stored in
732 * sata_hba_inst. The sata_hba_inst structures for different HBA instances are
733 * linked together into the list, pointed to by sata_hba_list.
734 * On the first HBA instance attach the sata event thread is initialized.
735 * Attachment points are created for all SATA ports of the HBA being attached.
736 * All HBA instance's SATA ports are probed and type of plugged devices is
737 * determined. For each device of a supported type, a target node is created.
738 *
739 * DDI_SUCCESS is returned when attachment process is successful,
740 * DDI_FAILURE is returned otherwise.
741 *
742 * For DDI_RESUME command:
743 * Not implemented at this time (postponed until phase 2 of the development).
744 */
745 int
sata_hba_attach(dev_info_t * dip,sata_hba_tran_t * sata_tran,ddi_attach_cmd_t cmd)746 sata_hba_attach(dev_info_t *dip, sata_hba_tran_t *sata_tran,
747 ddi_attach_cmd_t cmd)
748 {
749 sata_hba_inst_t *sata_hba_inst;
750 scsi_hba_tran_t *scsi_tran = NULL;
751 int hba_attach_state = 0;
752 char taskq_name[MAXPATHLEN];
753
754 SATADBG3(SATA_DBG_HBA_IF, NULL,
755 "sata_hba_attach: node %s (%s%d)\n",
756 ddi_node_name(dip), ddi_driver_name(dip),
757 ddi_get_instance(dip));
758
759 if (cmd == DDI_RESUME) {
760 /*
761 * Postponed until phase 2 of the development
762 */
763 return (DDI_FAILURE);
764 }
765
766 if (cmd != DDI_ATTACH) {
767 return (DDI_FAILURE);
768 }
769
770 /* cmd == DDI_ATTACH */
771
772 if (sata_validate_sata_hba_tran(dip, sata_tran) != SATA_SUCCESS) {
773 SATA_LOG_D((NULL, CE_WARN,
774 "sata_hba_attach: invalid sata_hba_tran"));
775 return (DDI_FAILURE);
776 }
777 /*
778 * Allocate and initialize SCSI tran structure.
779 * SATA copy of tran_bus_config is provided to create port nodes.
780 */
781 scsi_tran = scsi_hba_tran_alloc(dip, SCSI_HBA_CANSLEEP);
782 if (scsi_tran == NULL)
783 return (DDI_FAILURE);
784 /*
785 * Allocate soft structure for SATA HBA instance.
786 * There is a separate softstate for each HBA instance.
787 */
788 sata_hba_inst = kmem_zalloc(sizeof (struct sata_hba_inst), KM_SLEEP);
789 ASSERT(sata_hba_inst != NULL); /* this should not fail */
790 mutex_init(&sata_hba_inst->satahba_mutex, NULL, MUTEX_DRIVER, NULL);
791 hba_attach_state |= HBA_ATTACH_STAGE_SATA_HBA_INST;
792
793 /*
794 * scsi_trans's tran_hba_private is used by SATA Framework to point to
795 * soft structure allocated by SATA framework for
796 * SATA HBA instance related data.
797 */
798 scsi_tran->tran_hba_private = sata_hba_inst;
799 scsi_tran->tran_tgt_private = NULL;
800
801 scsi_tran->tran_tgt_init = sata_scsi_tgt_init;
802 scsi_tran->tran_tgt_probe = sata_scsi_tgt_probe;
803 scsi_tran->tran_tgt_free = sata_scsi_tgt_free;
804
805 scsi_tran->tran_start = sata_scsi_start;
806 scsi_tran->tran_reset = sata_scsi_reset;
807 scsi_tran->tran_abort = sata_scsi_abort;
808 scsi_tran->tran_getcap = sata_scsi_getcap;
809 scsi_tran->tran_setcap = sata_scsi_setcap;
810 scsi_tran->tran_init_pkt = sata_scsi_init_pkt;
811 scsi_tran->tran_destroy_pkt = sata_scsi_destroy_pkt;
812
813 scsi_tran->tran_dmafree = sata_scsi_dmafree;
814 scsi_tran->tran_sync_pkt = sata_scsi_sync_pkt;
815
816 scsi_tran->tran_reset_notify = NULL;
817 scsi_tran->tran_get_bus_addr = NULL;
818 scsi_tran->tran_quiesce = NULL;
819 scsi_tran->tran_unquiesce = NULL;
820 scsi_tran->tran_bus_reset = NULL;
821
822 if (scsi_hba_attach_setup(dip, sata_tran->sata_tran_hba_dma_attr,
823 scsi_tran, 0) != DDI_SUCCESS) {
824 #ifdef SATA_DEBUG
825 cmn_err(CE_WARN, "?SATA: %s%d hba scsi attach failed",
826 ddi_driver_name(dip), ddi_get_instance(dip));
827 #endif
828 goto fail;
829 }
830 hba_attach_state |= HBA_ATTACH_STAGE_SCSI_ATTACHED;
831
832 if (!ddi_prop_exists(DDI_DEV_T_ANY, dip, DDI_PROP_DONTPASS, "sata")) {
833 if (ddi_prop_update_int(DDI_DEV_T_NONE, dip,
834 "sata", 1) != DDI_PROP_SUCCESS) {
835 SATA_LOG_D((NULL, CE_WARN, "sata_hba_attach: "
836 "failed to create hba sata prop"));
837 goto fail;
838 }
839 }
840
841 /*
842 * Save pointers in hba instance soft state.
843 */
844 sata_hba_inst->satahba_scsi_tran = scsi_tran;
845 sata_hba_inst->satahba_tran = sata_tran;
846 sata_hba_inst->satahba_dip = dip;
847
848 /*
849 * Create a task queue to handle emulated commands completion
850 * Use node name, dash, instance number as the queue name.
851 */
852 taskq_name[0] = '\0';
853 (void) strlcat(taskq_name, DEVI(dip)->devi_node_name,
854 sizeof (taskq_name));
855 (void) snprintf(taskq_name + strlen(taskq_name),
856 sizeof (taskq_name) - strlen(taskq_name),
857 "-%d", DEVI(dip)->devi_instance);
858 sata_hba_inst->satahba_taskq = taskq_create(taskq_name, 1,
859 minclsyspri, 1, sata_tran->sata_tran_hba_num_cports * 4,
860 TASKQ_DYNAMIC);
861
862 hba_attach_state |= HBA_ATTACH_STAGE_SETUP;
863
864 /*
865 * Create events thread if not created yet.
866 */
867 sata_event_thread_control(1);
868
869 /*
870 * Link this hba instance into the list.
871 */
872 mutex_enter(&sata_mutex);
873
874 if (sata_hba_list == NULL) {
875 /*
876 * The first instance of HBA is attached.
877 * Set current/active default maximum NCQ/TCQ queue depth for
878 * all SATA devices. It is done here and now, to eliminate the
879 * possibility of the dynamic, programatic modification of the
880 * queue depth via global (and public) sata_max_queue_depth
881 * variable (this would require special handling in HBA drivers)
882 */
883 sata_current_max_qdepth = sata_max_queue_depth;
884 if (sata_current_max_qdepth > 32)
885 sata_current_max_qdepth = 32;
886 else if (sata_current_max_qdepth < 1)
887 sata_current_max_qdepth = 1;
888 }
889
890 sata_hba_inst->satahba_next = NULL;
891 sata_hba_inst->satahba_prev = sata_hba_list_tail;
892 if (sata_hba_list == NULL) {
893 sata_hba_list = sata_hba_inst;
894 }
895 if (sata_hba_list_tail != NULL) {
896 sata_hba_list_tail->satahba_next = sata_hba_inst;
897 }
898 sata_hba_list_tail = sata_hba_inst;
899 mutex_exit(&sata_mutex);
900 hba_attach_state |= HBA_ATTACH_STAGE_LINKED;
901
902 /*
903 * Create SATA HBA devctl minor node for sata_hba_open, close, ioctl
904 * SATA HBA driver should not use its own open/close entry points.
905 *
906 * Make sure that instance number doesn't overflow
907 * when forming minor numbers.
908 */
909 ASSERT(ddi_get_instance(dip) <= (L_MAXMIN >> INST_MINOR_SHIFT));
910 if (ddi_create_minor_node(dip, "devctl", S_IFCHR,
911 INST2DEVCTL(ddi_get_instance(dip)),
912 DDI_NT_SATA_NEXUS, 0) != DDI_SUCCESS) {
913 #ifdef SATA_DEBUG
914 cmn_err(CE_WARN, "sata_hba_attach: "
915 "cannot create devctl minor node");
916 #endif
917 goto fail;
918 }
919
920
921 /*
922 * Set-up kstats here, if necessary.
923 * (postponed until future phase of the development).
924 */
925
926 /*
927 * Indicate that HBA is attached. This will enable events processing
928 * for this HBA.
929 */
930 sata_hba_inst->satahba_attached = 1;
931 /*
932 * Probe controller ports. This operation will describe a current
933 * controller/port/multipliers/device configuration and will create
934 * attachment points.
935 * We may end-up with just a controller with no devices attached.
936 * For the ports with a supported device attached, device target nodes
937 * are created and devices are initialized.
938 */
939 sata_probe_ports(sata_hba_inst);
940
941 return (DDI_SUCCESS);
942
943 fail:
944 if (hba_attach_state & HBA_ATTACH_STAGE_LINKED) {
945 (void) sata_remove_hba_instance(dip);
946 if (sata_hba_list == NULL)
947 sata_event_thread_control(0);
948 }
949
950 if (hba_attach_state & HBA_ATTACH_STAGE_SETUP) {
951 (void) ddi_prop_remove(DDI_DEV_T_ANY, dip, "sata");
952 taskq_destroy(sata_hba_inst->satahba_taskq);
953 }
954
955 if (hba_attach_state & HBA_ATTACH_STAGE_SCSI_ATTACHED)
956 (void) scsi_hba_detach(dip);
957
958 if (hba_attach_state & HBA_ATTACH_STAGE_SATA_HBA_INST) {
959 mutex_destroy(&sata_hba_inst->satahba_mutex);
960 kmem_free((void *)sata_hba_inst,
961 sizeof (struct sata_hba_inst));
962 scsi_hba_tran_free(scsi_tran);
963 }
964
965 sata_log(NULL, CE_WARN, "?SATA: %s%d hba attach failed",
966 ddi_driver_name(dip), ddi_get_instance(dip));
967
968 return (DDI_FAILURE);
969 }
970
971
972 /*
973 * Called by SATA HBA from to detach an instance of the driver.
974 *
975 * For DDI_DETACH command:
976 * Free local structures allocated for SATA HBA instance during
977 * sata_hba_attach processing.
978 *
979 * Returns DDI_SUCCESS when HBA was detached, DDI_FAILURE otherwise.
980 *
981 * For DDI_SUSPEND command:
982 * Not implemented at this time (postponed until phase 2 of the development)
983 * Returnd DDI_SUCCESS.
984 *
985 * When the last HBA instance is detached, the event daemon is terminated.
986 *
987 * NOTE: Port multiplier is supported.
988 */
989 int
sata_hba_detach(dev_info_t * dip,ddi_detach_cmd_t cmd)990 sata_hba_detach(dev_info_t *dip, ddi_detach_cmd_t cmd)
991 {
992 dev_info_t *tdip;
993 sata_hba_inst_t *sata_hba_inst;
994 scsi_hba_tran_t *scsi_hba_tran;
995 sata_cport_info_t *cportinfo;
996 sata_pmult_info_t *pminfo;
997 sata_drive_info_t *sdinfo;
998 sata_device_t sdevice;
999 int ncport, npmport;
1000
1001 SATADBG3(SATA_DBG_HBA_IF, NULL, "sata_hba_detach: node %s (%s%d)\n",
1002 ddi_node_name(dip), ddi_driver_name(dip), ddi_get_instance(dip));
1003
1004 switch (cmd) {
1005 case DDI_DETACH:
1006
1007 if ((scsi_hba_tran = ddi_get_driver_private(dip)) == NULL)
1008 return (DDI_FAILURE);
1009
1010 sata_hba_inst = scsi_hba_tran->tran_hba_private;
1011 if (sata_hba_inst == NULL)
1012 return (DDI_FAILURE);
1013
1014 if (scsi_hba_detach(dip) == DDI_FAILURE) {
1015 sata_hba_inst->satahba_attached = 1;
1016 return (DDI_FAILURE);
1017 }
1018
1019 /*
1020 * Free all target nodes - at this point
1021 * devices should be at least offlined
1022 * otherwise scsi_hba_detach() should not be called.
1023 */
1024 for (ncport = 0; ncport < SATA_NUM_CPORTS(sata_hba_inst);
1025 ncport++) {
1026 cportinfo = SATA_CPORT_INFO(sata_hba_inst, ncport);
1027 if (cportinfo->cport_dev_type != SATA_DTYPE_PMULT) {
1028 sdinfo = SATA_CPORTINFO_DRV_INFO(cportinfo);
1029 if (sdinfo != NULL) {
1030 tdip = sata_get_target_dip(dip,
1031 ncport, 0);
1032 if (tdip != NULL) {
1033 if (ndi_devi_offline(tdip,
1034 NDI_DEVI_REMOVE) !=
1035 NDI_SUCCESS) {
1036 SATA_LOG_D((
1037 sata_hba_inst,
1038 CE_WARN,
1039 "sata_hba_detach: "
1040 "Target node not "
1041 "removed !"));
1042 return (DDI_FAILURE);
1043 }
1044 }
1045 }
1046 } else { /* SATA_DTYPE_PMULT */
1047 mutex_enter(&cportinfo->cport_mutex);
1048 pminfo = SATA_CPORTINFO_PMULT_INFO(cportinfo);
1049
1050 if (pminfo == NULL) {
1051 SATA_LOG_D((sata_hba_inst, CE_WARN,
1052 "sata_hba_detach: Port multiplier "
1053 "not ready yet!"));
1054 mutex_exit(&cportinfo->cport_mutex);
1055 return (DDI_FAILURE);
1056 }
1057
1058 /*
1059 * Detach would fail if removal of any of the
1060 * target nodes is failed - albeit in that
1061 * case some of them may have been removed.
1062 */
1063 for (npmport = 0; npmport < SATA_NUM_PMPORTS(
1064 sata_hba_inst, ncport); npmport++) {
1065 tdip = sata_get_target_dip(dip, ncport,
1066 npmport);
1067 if (tdip != NULL) {
1068 if (ndi_devi_offline(tdip,
1069 NDI_DEVI_REMOVE) !=
1070 NDI_SUCCESS) {
1071 SATA_LOG_D((
1072 sata_hba_inst,
1073 CE_WARN,
1074 "sata_hba_detach: "
1075 "Target node not "
1076 "removed !"));
1077 mutex_exit(&cportinfo->
1078 cport_mutex);
1079 return (DDI_FAILURE);
1080 }
1081 }
1082 }
1083 mutex_exit(&cportinfo->cport_mutex);
1084 }
1085 }
1086 /*
1087 * Disable sata event daemon processing for this HBA
1088 */
1089 sata_hba_inst->satahba_attached = 0;
1090
1091 /*
1092 * Remove event daemon thread, if it is last HBA instance.
1093 */
1094
1095 mutex_enter(&sata_mutex);
1096 if (sata_hba_list->satahba_next == NULL) {
1097 mutex_exit(&sata_mutex);
1098 sata_event_thread_control(0);
1099 mutex_enter(&sata_mutex);
1100 }
1101 mutex_exit(&sata_mutex);
1102
1103 /* Remove this HBA instance from the HBA list */
1104 sata_remove_hba_instance(dip);
1105
1106 /*
1107 * At this point there should be no target nodes attached.
1108 * Detach and destroy device and port info structures.
1109 */
1110 for (ncport = 0; ncport < SATA_NUM_CPORTS(sata_hba_inst);
1111 ncport++) {
1112 cportinfo = SATA_CPORT_INFO(sata_hba_inst, ncport);
1113 if (cportinfo->cport_dev_type != SATA_DTYPE_PMULT) {
1114 sdinfo =
1115 cportinfo->cport_devp.cport_sata_drive;
1116 if (sdinfo != NULL) {
1117 /* Release device structure */
1118 kmem_free(sdinfo,
1119 sizeof (sata_drive_info_t));
1120 }
1121 /* Release cport info */
1122 mutex_destroy(&cportinfo->cport_mutex);
1123 kmem_free(cportinfo,
1124 sizeof (sata_cport_info_t));
1125 } else { /* SATA_DTYPE_PMULT */
1126 sdevice.satadev_addr.cport = (uint8_t)ncport;
1127 sdevice.satadev_addr.qual = SATA_ADDR_PMULT;
1128 sata_free_pmult(sata_hba_inst, &sdevice);
1129 }
1130 }
1131
1132 scsi_hba_tran_free(sata_hba_inst->satahba_scsi_tran);
1133
1134 (void) ddi_prop_remove(DDI_DEV_T_ANY, dip, "sata");
1135
1136 taskq_destroy(sata_hba_inst->satahba_taskq);
1137
1138 mutex_destroy(&sata_hba_inst->satahba_mutex);
1139 kmem_free((void *)sata_hba_inst,
1140 sizeof (struct sata_hba_inst));
1141
1142 return (DDI_SUCCESS);
1143
1144 case DDI_SUSPEND:
1145 /*
1146 * Postponed until phase 2
1147 */
1148 return (DDI_FAILURE);
1149
1150 default:
1151 return (DDI_FAILURE);
1152 }
1153 }
1154
1155
1156 /*
1157 * Called by an HBA drive from _fini() routine.
1158 * Unregisters SATA HBA instance/SATA framework pair from the scsi framework.
1159 */
1160 void
sata_hba_fini(struct modlinkage * modlp)1161 sata_hba_fini(struct modlinkage *modlp)
1162 {
1163 SATADBG1(SATA_DBG_HBA_IF, NULL,
1164 "sata_hba_fini: name %s\n",
1165 ((struct modldrv *)(modlp->ml_linkage[0]))->drv_linkinfo);
1166
1167 scsi_hba_fini(modlp);
1168 }
1169
1170
1171 /*
1172 * Default open and close routine for sata_hba framework.
1173 *
1174 */
1175 /*
1176 * Open devctl node.
1177 *
1178 * Returns:
1179 * 0 if node was open successfully, error code otherwise.
1180 *
1181 *
1182 */
1183
1184 static int
sata_hba_open(dev_t * devp,int flags,int otyp,cred_t * credp)1185 sata_hba_open(dev_t *devp, int flags, int otyp, cred_t *credp)
1186 {
1187 #ifndef __lock_lint
1188 _NOTE(ARGUNUSED(credp))
1189 #endif
1190 int rv = 0;
1191 dev_info_t *dip;
1192 scsi_hba_tran_t *scsi_hba_tran;
1193 sata_hba_inst_t *sata_hba_inst;
1194
1195 SATADBG1(SATA_DBG_IOCTL_IF, NULL, "sata_hba_open: entered", NULL);
1196
1197 if (otyp != OTYP_CHR)
1198 return (EINVAL);
1199
1200 dip = sata_devt_to_devinfo(*devp);
1201 if (dip == NULL)
1202 return (ENXIO);
1203
1204 if ((scsi_hba_tran = ddi_get_driver_private(dip)) == NULL)
1205 return (ENXIO);
1206
1207 sata_hba_inst = scsi_hba_tran->tran_hba_private;
1208 if (sata_hba_inst == NULL || sata_hba_inst->satahba_attached == 0)
1209 return (ENXIO);
1210
1211 mutex_enter(&sata_mutex);
1212 if (flags & FEXCL) {
1213 if (sata_hba_inst->satahba_open_flag != 0) {
1214 rv = EBUSY;
1215 } else {
1216 sata_hba_inst->satahba_open_flag =
1217 SATA_DEVCTL_EXOPENED;
1218 }
1219 } else {
1220 if (sata_hba_inst->satahba_open_flag == SATA_DEVCTL_EXOPENED) {
1221 rv = EBUSY;
1222 } else {
1223 sata_hba_inst->satahba_open_flag =
1224 SATA_DEVCTL_SOPENED;
1225 }
1226 }
1227 mutex_exit(&sata_mutex);
1228
1229 return (rv);
1230 }
1231
1232
1233 /*
1234 * Close devctl node.
1235 * Returns:
1236 * 0 if node was closed successfully, error code otherwise.
1237 *
1238 */
1239
1240 static int
sata_hba_close(dev_t dev,int flag,int otyp,cred_t * credp)1241 sata_hba_close(dev_t dev, int flag, int otyp, cred_t *credp)
1242 {
1243 #ifndef __lock_lint
1244 _NOTE(ARGUNUSED(credp))
1245 _NOTE(ARGUNUSED(flag))
1246 #endif
1247 dev_info_t *dip;
1248 scsi_hba_tran_t *scsi_hba_tran;
1249 sata_hba_inst_t *sata_hba_inst;
1250
1251 SATADBG1(SATA_DBG_IOCTL_IF, NULL, "sata_hba_close: entered", NULL);
1252
1253 if (otyp != OTYP_CHR)
1254 return (EINVAL);
1255
1256 dip = sata_devt_to_devinfo(dev);
1257 if (dip == NULL)
1258 return (ENXIO);
1259
1260 if ((scsi_hba_tran = ddi_get_driver_private(dip)) == NULL)
1261 return (ENXIO);
1262
1263 sata_hba_inst = scsi_hba_tran->tran_hba_private;
1264 if (sata_hba_inst == NULL || sata_hba_inst->satahba_attached == 0)
1265 return (ENXIO);
1266
1267 mutex_enter(&sata_mutex);
1268 sata_hba_inst->satahba_open_flag = 0;
1269 mutex_exit(&sata_mutex);
1270 return (0);
1271 }
1272
1273
1274
1275 /*
1276 * Standard IOCTL commands for SATA hotplugging.
1277 * Implemented DEVCTL_AP commands:
1278 * DEVCTL_AP_CONNECT
1279 * DEVCTL_AP_DISCONNECT
1280 * DEVCTL_AP_CONFIGURE
1281 * DEVCTL_UNCONFIGURE
1282 * DEVCTL_AP_CONTROL
1283 *
1284 * Commands passed to default ndi ioctl handler:
1285 * DEVCTL_DEVICE_GETSTATE
1286 * DEVCTL_DEVICE_ONLINE
1287 * DEVCTL_DEVICE_OFFLINE
1288 * DEVCTL_DEVICE_REMOVE
1289 * DEVCTL_DEVICE_INSERT
1290 * DEVCTL_BUS_GETSTATE
1291 *
1292 * All other cmds are passed to HBA if it provide ioctl handler, or failed
1293 * if not.
1294 *
1295 * Returns:
1296 * 0 if successful,
1297 * error code if operation failed.
1298 *
1299 * Port Multiplier support is supported now.
1300 *
1301 * NOTE: qual should be SATA_ADDR_DCPORT or SATA_ADDR_DPMPORT
1302 */
1303
1304 static int
sata_hba_ioctl(dev_t dev,int cmd,intptr_t arg,int mode,cred_t * credp,int * rvalp)1305 sata_hba_ioctl(dev_t dev, int cmd, intptr_t arg, int mode, cred_t *credp,
1306 int *rvalp)
1307 {
1308 #ifndef __lock_lint
1309 _NOTE(ARGUNUSED(credp))
1310 _NOTE(ARGUNUSED(rvalp))
1311 #endif
1312 int rv = 0;
1313 int32_t comp_port = -1;
1314 dev_info_t *dip;
1315 devctl_ap_state_t ap_state;
1316 struct devctl_iocdata *dcp = NULL;
1317 scsi_hba_tran_t *scsi_hba_tran;
1318 sata_hba_inst_t *sata_hba_inst;
1319 sata_device_t sata_device;
1320 sata_cport_info_t *cportinfo;
1321 int cport, pmport, qual;
1322 int rval = SATA_SUCCESS;
1323
1324 dip = sata_devt_to_devinfo(dev);
1325 if (dip == NULL)
1326 return (ENXIO);
1327
1328 if ((scsi_hba_tran = ddi_get_driver_private(dip)) == NULL)
1329 return (ENXIO);
1330
1331 sata_hba_inst = scsi_hba_tran->tran_hba_private;
1332 if (sata_hba_inst == NULL)
1333 return (ENXIO);
1334
1335 if (sata_hba_inst->satahba_tran == NULL)
1336 return (ENXIO);
1337
1338 switch (cmd) {
1339
1340 case DEVCTL_DEVICE_GETSTATE:
1341 case DEVCTL_DEVICE_ONLINE:
1342 case DEVCTL_DEVICE_OFFLINE:
1343 case DEVCTL_DEVICE_REMOVE:
1344 case DEVCTL_BUS_GETSTATE:
1345 /*
1346 * There may be more cases that we want to pass to default
1347 * handler rather than fail them.
1348 */
1349 return (ndi_devctl_ioctl(dip, cmd, arg, mode, 0));
1350 }
1351
1352 cport = pmport = qual = 0;
1353 cportinfo = NULL;
1354
1355 /* read devctl ioctl data */
1356 if (cmd != DEVCTL_AP_CONTROL && IS_DEVCTL(cmd)) {
1357 if (ndi_dc_allochdl((void *)arg, &dcp) != NDI_SUCCESS)
1358 return (EFAULT);
1359
1360 if ((comp_port = sata_get_port_num(sata_hba_inst, dcp)) ==
1361 -1) {
1362 if (dcp)
1363 ndi_dc_freehdl(dcp);
1364 return (EINVAL);
1365 }
1366
1367 /*
1368 * According to SCSI_TO_SATA_ADDR_QUAL, qual should be either
1369 * SATA_ADDR_DCPORT or SATA_ADDR_DPMPORT.
1370 */
1371 cport = SCSI_TO_SATA_CPORT(comp_port);
1372 pmport = SCSI_TO_SATA_PMPORT(comp_port);
1373 qual = SCSI_TO_SATA_ADDR_QUAL(comp_port);
1374
1375 if (sata_validate_sata_address(sata_hba_inst, cport, pmport,
1376 qual) != 0) {
1377 ndi_dc_freehdl(dcp);
1378 return (EINVAL);
1379 }
1380
1381 cportinfo = SATA_CPORT_INFO(sata_hba_inst, cport);
1382 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, cport)->
1383 cport_mutex);
1384 if (cportinfo->cport_event_flags & SATA_EVNT_LOCK_PORT_BUSY) {
1385 /*
1386 * Cannot process ioctl request now. Come back later.
1387 */
1388 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)->
1389 cport_mutex);
1390 ndi_dc_freehdl(dcp);
1391 return (EBUSY);
1392 }
1393 /* Block event processing for this port */
1394 cportinfo->cport_event_flags |= SATA_APCTL_LOCK_PORT_BUSY;
1395 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex);
1396
1397 sata_device.satadev_addr.cport = cport;
1398 sata_device.satadev_addr.pmport = pmport;
1399 sata_device.satadev_addr.qual = qual;
1400 sata_device.satadev_rev = SATA_DEVICE_REV;
1401 }
1402
1403 switch (cmd) {
1404
1405 case DEVCTL_AP_DISCONNECT:
1406
1407 /*
1408 * Normally, cfgadm sata plugin will try to offline
1409 * (unconfigure) device before this request. Nevertheless,
1410 * if a device is still configured, we need to
1411 * attempt to offline and unconfigure device first, and we will
1412 * deactivate the port regardless of the unconfigure
1413 * operation results.
1414 *
1415 */
1416 rv = sata_ioctl_disconnect(sata_hba_inst, &sata_device);
1417
1418 break;
1419
1420 case DEVCTL_AP_UNCONFIGURE:
1421
1422 /*
1423 * The unconfigure operation uses generic nexus operation to
1424 * offline a device. It leaves a target device node attached.
1425 * and obviously sata_drive_info attached as well, because
1426 * from the hardware point of view nothing has changed.
1427 */
1428 rv = sata_ioctl_unconfigure(sata_hba_inst, &sata_device);
1429 break;
1430
1431 case DEVCTL_AP_CONNECT:
1432 {
1433 /*
1434 * The sata cfgadm pluging will invoke this operation only if
1435 * port was found in the disconnect state (failed state
1436 * is also treated as the disconnected state).
1437 * If port activation is successful and a device is found
1438 * attached to the port, the initialization sequence is
1439 * executed to probe the port and attach
1440 * a device structure to a port structure. The device is not
1441 * set in configured state (system-wise) by this operation.
1442 */
1443
1444 rv = sata_ioctl_connect(sata_hba_inst, &sata_device);
1445
1446 break;
1447 }
1448
1449 case DEVCTL_AP_CONFIGURE:
1450 {
1451 /*
1452 * A port may be in an active or shutdown state.
1453 * If port is in a failed state, operation is aborted.
1454 * If a port is in a shutdown state, sata_tran_port_activate()
1455 * is invoked prior to any other operation.
1456 *
1457 * Onlining the device involves creating a new target node.
1458 * If there is an old target node present (belonging to
1459 * previously removed device), the operation is aborted - the
1460 * old node has to be released and removed before configure
1461 * operation is attempted.
1462 */
1463
1464 rv = sata_ioctl_configure(sata_hba_inst, &sata_device);
1465
1466 break;
1467 }
1468
1469 case DEVCTL_AP_GETSTATE:
1470
1471 sata_cfgadm_state(sata_hba_inst, comp_port, &ap_state);
1472
1473 ap_state.ap_last_change = (time_t)-1;
1474 ap_state.ap_error_code = 0;
1475 ap_state.ap_in_transition = 0;
1476
1477 /* Copy the return AP-state information to the user space */
1478 if (ndi_dc_return_ap_state(&ap_state, dcp) != NDI_SUCCESS) {
1479 rv = EFAULT;
1480 }
1481 break;
1482
1483 case DEVCTL_AP_CONTROL:
1484 {
1485 /*
1486 * Generic devctl for hardware specific functionality
1487 */
1488 sata_ioctl_data_t ioc;
1489
1490 ASSERT(dcp == NULL);
1491
1492 /* Copy in user ioctl data first */
1493 #ifdef _MULTI_DATAMODEL
1494 if (ddi_model_convert_from(mode & FMODELS) ==
1495 DDI_MODEL_ILP32) {
1496
1497 sata_ioctl_data_32_t ioc32;
1498
1499 if (ddi_copyin((void *)arg, (void *)&ioc32,
1500 sizeof (ioc32), mode) != 0) {
1501 rv = EFAULT;
1502 break;
1503 }
1504 ioc.cmd = (uint_t)ioc32.cmd;
1505 ioc.port = (uint_t)ioc32.port;
1506 ioc.get_size = (uint_t)ioc32.get_size;
1507 ioc.buf = (caddr_t)(uintptr_t)ioc32.buf;
1508 ioc.bufsiz = (uint_t)ioc32.bufsiz;
1509 ioc.misc_arg = (uint_t)ioc32.misc_arg;
1510 } else
1511 #endif /* _MULTI_DATAMODEL */
1512 if (ddi_copyin((void *)arg, (void *)&ioc, sizeof (ioc),
1513 mode) != 0) {
1514 return (EFAULT);
1515 }
1516
1517 SATADBG2(SATA_DBG_IOCTL_IF, sata_hba_inst,
1518 "sata_hba_ioctl: DEVCTL_AP_CONTROL "
1519 "cmd 0x%x, port 0x%x", ioc.cmd, ioc.port);
1520
1521 /*
1522 * To avoid BE/LE and 32/64 issues, a get_size always returns
1523 * a 32-bit number.
1524 */
1525 if (ioc.get_size != 0 && ioc.bufsiz != (sizeof (uint32_t))) {
1526 return (EINVAL);
1527 }
1528 /* validate address */
1529 cport = SCSI_TO_SATA_CPORT(ioc.port);
1530 pmport = SCSI_TO_SATA_PMPORT(ioc.port);
1531 qual = SCSI_TO_SATA_ADDR_QUAL(ioc.port);
1532
1533 SATADBG3(SATA_DBG_IOCTL_IF, sata_hba_inst,
1534 "sata_hba_ioctl: target port is %d:%d (%d)",
1535 cport, pmport, qual);
1536
1537 if (sata_validate_sata_address(sata_hba_inst, cport,
1538 pmport, qual) != 0)
1539 return (EINVAL);
1540
1541 cportinfo = SATA_CPORT_INFO(sata_hba_inst, cport);
1542 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, cport)->
1543 cport_mutex);
1544 /* Is the port locked by event processing daemon ? */
1545 if (cportinfo->cport_event_flags & SATA_EVNT_LOCK_PORT_BUSY) {
1546 /*
1547 * Cannot process ioctl request now. Come back later
1548 */
1549 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)->
1550 cport_mutex);
1551 return (EBUSY);
1552 }
1553 /* Block event processing for this port */
1554 cportinfo->cport_event_flags |= SATA_APCTL_LOCK_PORT_BUSY;
1555 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex);
1556
1557
1558 sata_device.satadev_addr.cport = cport;
1559 sata_device.satadev_addr.pmport = pmport;
1560 sata_device.satadev_addr.qual = qual;
1561 sata_device.satadev_rev = SATA_DEVICE_REV;
1562
1563 switch (ioc.cmd) {
1564
1565 case SATA_CFGA_RESET_PORT:
1566 /*
1567 * There is no protection for configured device.
1568 */
1569 rv = sata_ioctl_reset_port(sata_hba_inst, &sata_device);
1570 break;
1571
1572 case SATA_CFGA_RESET_DEVICE:
1573 /*
1574 * There is no protection for configured device.
1575 */
1576 rv = sata_ioctl_reset_device(sata_hba_inst,
1577 &sata_device);
1578 break;
1579
1580 case SATA_CFGA_RESET_ALL:
1581 /*
1582 * There is no protection for configured devices.
1583 */
1584 rv = sata_ioctl_reset_all(sata_hba_inst);
1585 /*
1586 * We return here, because common return is for
1587 * a single port operation - we have already unlocked
1588 * all ports and no dc handle was allocated.
1589 */
1590 return (rv);
1591
1592 case SATA_CFGA_PORT_DEACTIVATE:
1593 /*
1594 * Arbitrarily unconfigure attached device, if any.
1595 * Even if the unconfigure fails, proceed with the
1596 * port deactivation.
1597 */
1598 rv = sata_ioctl_deactivate(sata_hba_inst, &sata_device);
1599
1600 break;
1601
1602 case SATA_CFGA_PORT_ACTIVATE:
1603
1604 rv = sata_ioctl_activate(sata_hba_inst, &sata_device);
1605 break;
1606
1607 case SATA_CFGA_PORT_SELF_TEST:
1608
1609 rv = sata_ioctl_port_self_test(sata_hba_inst,
1610 &sata_device);
1611 break;
1612
1613 case SATA_CFGA_GET_DEVICE_PATH:
1614
1615 rv = sata_ioctl_get_device_path(sata_hba_inst,
1616 &sata_device, &ioc, mode);
1617 break;
1618
1619 case SATA_CFGA_GET_AP_TYPE:
1620
1621 rv = sata_ioctl_get_ap_type(sata_hba_inst,
1622 &sata_device, &ioc, mode);
1623 break;
1624
1625 case SATA_CFGA_GET_MODEL_INFO:
1626
1627 rv = sata_ioctl_get_model_info(sata_hba_inst,
1628 &sata_device, &ioc, mode);
1629 break;
1630
1631 case SATA_CFGA_GET_REVFIRMWARE_INFO:
1632
1633 rv = sata_ioctl_get_revfirmware_info(sata_hba_inst,
1634 &sata_device, &ioc, mode);
1635 break;
1636
1637 case SATA_CFGA_GET_SERIALNUMBER_INFO:
1638
1639 rv = sata_ioctl_get_serialnumber_info(sata_hba_inst,
1640 &sata_device, &ioc, mode);
1641 break;
1642
1643 default:
1644 rv = EINVAL;
1645 break;
1646
1647 } /* End of DEVCTL_AP_CONTROL cmd switch */
1648
1649 break;
1650 }
1651
1652 default:
1653 {
1654 /*
1655 * If we got here, we got an IOCTL that SATA HBA Framework
1656 * does not recognize. Pass ioctl to HBA driver, in case
1657 * it could process it.
1658 */
1659 sata_hba_tran_t *sata_tran = sata_hba_inst->satahba_tran;
1660 dev_info_t *mydip = SATA_DIP(sata_hba_inst);
1661
1662 SATADBG1(SATA_DBG_IOCTL_IF, sata_hba_inst,
1663 "IOCTL 0x%2x not supported in SATA framework, "
1664 "passthrough to HBA", cmd);
1665
1666 if (sata_tran->sata_tran_ioctl == NULL) {
1667 rv = EINVAL;
1668 break;
1669 }
1670 rval = (*sata_tran->sata_tran_ioctl)(mydip, cmd, arg);
1671 if (rval != 0) {
1672 SATADBG1(SATA_DBG_IOCTL_IF, sata_hba_inst,
1673 "IOCTL 0x%2x failed in HBA", cmd);
1674 rv = rval;
1675 }
1676 break;
1677 }
1678
1679 } /* End of main IOCTL switch */
1680
1681 if (dcp) {
1682 ndi_dc_freehdl(dcp);
1683 }
1684
1685 if (IS_DEVCTL(cmd)) {
1686 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst,
1687 cport)->cport_mutex);
1688 cportinfo->cport_event_flags &= ~SATA_APCTL_LOCK_PORT_BUSY;
1689 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex);
1690 }
1691
1692 return (rv);
1693 }
1694
1695
1696 /*
1697 * Create error retrieval sata packet
1698 *
1699 * A sata packet is allocated and set-up to contain specified error retrieval
1700 * command and appropriate dma-able data buffer.
1701 * No association with any scsi packet is made and no callback routine is
1702 * specified.
1703 *
1704 * Returns a pointer to sata packet upon successful packet creation.
1705 * Returns NULL, if packet cannot be created.
1706 */
1707 sata_pkt_t *
sata_get_error_retrieval_pkt(dev_info_t * dip,sata_device_t * sata_device,int pkt_type)1708 sata_get_error_retrieval_pkt(dev_info_t *dip, sata_device_t *sata_device,
1709 int pkt_type)
1710 {
1711 sata_hba_inst_t *sata_hba_inst;
1712 sata_pkt_txlate_t *spx;
1713 sata_pkt_t *spkt;
1714 sata_drive_info_t *sdinfo;
1715
1716 mutex_enter(&sata_mutex);
1717 for (sata_hba_inst = sata_hba_list; sata_hba_inst != NULL;
1718 sata_hba_inst = sata_hba_inst->satahba_next) {
1719 if (SATA_DIP(sata_hba_inst) == dip)
1720 break;
1721 }
1722 mutex_exit(&sata_mutex);
1723 ASSERT(sata_hba_inst != NULL);
1724
1725 sdinfo = sata_get_device_info(sata_hba_inst, sata_device);
1726 if (sdinfo == NULL) {
1727 sata_log(sata_hba_inst, CE_WARN,
1728 "sata: error recovery request for non-attached device at "
1729 "cport %d", sata_device->satadev_addr.cport);
1730 return (NULL);
1731 }
1732
1733 spx = kmem_zalloc(sizeof (sata_pkt_txlate_t), KM_SLEEP);
1734 spx->txlt_sata_hba_inst = sata_hba_inst;
1735 spx->txlt_scsi_pkt = NULL; /* No scsi pkt involved */
1736 spkt = sata_pkt_alloc(spx, NULL);
1737 if (spkt == NULL) {
1738 kmem_free(spx, sizeof (sata_pkt_txlate_t));
1739 return (NULL);
1740 }
1741 /* address is needed now */
1742 spkt->satapkt_device.satadev_addr = sata_device->satadev_addr;
1743
1744 switch (pkt_type) {
1745 case SATA_ERR_RETR_PKT_TYPE_NCQ:
1746 if (sata_ncq_err_ret_cmd_setup(spx, sdinfo) == SATA_SUCCESS) {
1747 if (sata_check_for_dma_error(dip, spx)) {
1748 ddi_fm_service_impact(dip,
1749 DDI_SERVICE_UNAFFECTED);
1750 break;
1751 }
1752 return (spkt);
1753 }
1754 break;
1755
1756 case SATA_ERR_RETR_PKT_TYPE_ATAPI:
1757 if (sata_atapi_err_ret_cmd_setup(spx, sdinfo) == SATA_SUCCESS) {
1758 if (sata_check_for_dma_error(dip, spx)) {
1759 ddi_fm_service_impact(dip,
1760 DDI_SERVICE_UNAFFECTED);
1761 break;
1762 }
1763 return (spkt);
1764 }
1765 break;
1766
1767 default:
1768 break;
1769 }
1770
1771 sata_pkt_free(spx);
1772 kmem_free(spx, sizeof (sata_pkt_txlate_t));
1773 return (NULL);
1774
1775 }
1776
1777
1778 /*
1779 * Free error retrieval sata packet
1780 *
1781 * Free sata packet and any associated resources allocated previously by
1782 * sata_get_error_retrieval_pkt().
1783 *
1784 * Void return.
1785 */
1786 void
sata_free_error_retrieval_pkt(sata_pkt_t * sata_pkt)1787 sata_free_error_retrieval_pkt(sata_pkt_t *sata_pkt)
1788 {
1789 sata_pkt_txlate_t *spx =
1790 (sata_pkt_txlate_t *)sata_pkt->satapkt_framework_private;
1791
1792 ASSERT(sata_pkt != NULL);
1793
1794 sata_free_local_buffer(spx);
1795 sata_pkt_free(spx);
1796 kmem_free(spx, sizeof (sata_pkt_txlate_t));
1797
1798 }
1799
1800 /*
1801 * Create READ PORT MULTIPLIER and WRITE PORT MULTIPLIER sata packet
1802 *
1803 * No association with any scsi packet is made and no callback routine is
1804 * specified.
1805 *
1806 * Returns a pointer to sata packet upon successful packet creation.
1807 * Returns NULL, if packet cannot be created.
1808 *
1809 * NOTE: Input/Output value includes 64 bits accoring to SATA Spec 2.6,
1810 * only lower 32 bits are available currently.
1811 */
1812 sata_pkt_t *
sata_get_rdwr_pmult_pkt(dev_info_t * dip,sata_device_t * sd,uint16_t regn,uint32_t regv,uint32_t type)1813 sata_get_rdwr_pmult_pkt(dev_info_t *dip, sata_device_t *sd,
1814 uint16_t regn, uint32_t regv, uint32_t type)
1815 {
1816 sata_hba_inst_t *sata_hba_inst;
1817 sata_pkt_txlate_t *spx;
1818 sata_pkt_t *spkt;
1819 sata_cmd_t *scmd;
1820
1821 /* Only READ/WRITE commands are accepted. */
1822 ASSERT(type == SATA_RDWR_PMULT_PKT_TYPE_READ ||
1823 type == SATA_RDWR_PMULT_PKT_TYPE_WRITE);
1824
1825 mutex_enter(&sata_mutex);
1826 for (sata_hba_inst = sata_hba_list; sata_hba_inst != NULL;
1827 sata_hba_inst = sata_hba_inst->satahba_next) {
1828 if (SATA_DIP(sata_hba_inst) == dip)
1829 break;
1830 }
1831 mutex_exit(&sata_mutex);
1832 ASSERT(sata_hba_inst != NULL);
1833
1834 spx = kmem_zalloc(sizeof (sata_pkt_txlate_t), KM_SLEEP);
1835 spx->txlt_sata_hba_inst = sata_hba_inst;
1836 spx->txlt_scsi_pkt = NULL; /* No scsi pkt involved */
1837 spkt = sata_pkt_alloc(spx, SLEEP_FUNC);
1838 if (spkt == NULL) {
1839 kmem_free(spx, sizeof (sata_pkt_txlate_t));
1840 return (NULL);
1841 }
1842
1843 /*
1844 * NOTE: We need to send this command to the port multiplier,
1845 * that means send to SATA_PMULT_HOSTPORT(0xf) pmport
1846 *
1847 * sata_device contains the address of actual target device, and the
1848 * pmport number in the command comes from the sata_device structure.
1849 */
1850 spkt->satapkt_device.satadev_addr = sd->satadev_addr;
1851 spkt->satapkt_device.satadev_addr.pmport = SATA_PMULT_HOSTPORT;
1852 spkt->satapkt_device.satadev_addr.qual = SATA_ADDR_PMULT;
1853
1854 /* Fill sata_pkt */
1855 spkt->satapkt_op_mode = SATA_OPMODE_SYNCH | SATA_OPMODE_POLLING;
1856 spkt->satapkt_comp = NULL; /* Synchronous mode, no callback */
1857 spkt->satapkt_time = 10; /* Timeout 10s */
1858
1859 /* Build READ PORT MULTIPLIER cmd in the sata_pkt */
1860 scmd = &spkt->satapkt_cmd;
1861 scmd->satacmd_features_reg = regn & 0xff;
1862 scmd->satacmd_features_reg_ext = (regn >> 8) & 0xff;
1863 scmd->satacmd_device_reg = sd->satadev_addr.pmport;
1864 scmd->satacmd_addr_type = 0; /* N/A */
1865
1866 scmd->satacmd_flags.sata_ignore_dev_reset = B_TRUE;
1867
1868 if (type == SATA_RDWR_PMULT_PKT_TYPE_READ) {
1869 scmd->satacmd_cmd_reg = SATAC_READ_PORTMULT;
1870 scmd->satacmd_flags.sata_data_direction = SATA_DIR_READ;
1871 scmd->satacmd_flags.sata_special_regs = 1;
1872 scmd->satacmd_flags.sata_copy_out_lba_high_lsb = 1;
1873 scmd->satacmd_flags.sata_copy_out_lba_mid_lsb = 1;
1874 scmd->satacmd_flags.sata_copy_out_lba_low_lsb = 1;
1875 scmd->satacmd_flags.sata_copy_out_sec_count_lsb = 1;
1876 } else if (type == SATA_RDWR_PMULT_PKT_TYPE_WRITE) {
1877 scmd->satacmd_cmd_reg = SATAC_WRITE_PORTMULT;
1878 scmd->satacmd_flags.sata_data_direction = SATA_DIR_WRITE;
1879 scmd->satacmd_sec_count_lsb = regv & 0xff;
1880 scmd->satacmd_lba_low_lsb = regv >> 8 & 0xff;
1881 scmd->satacmd_lba_mid_lsb = regv >> 16 & 0xff;
1882 scmd->satacmd_lba_high_lsb = regv >> 24 & 0xff;
1883 }
1884
1885 return (spkt);
1886 }
1887
1888 /*
1889 * Free sata packet and any associated resources allocated previously by
1890 * sata_get_rdwr_pmult_pkt().
1891 *
1892 * Void return.
1893 */
1894 void
sata_free_rdwr_pmult_pkt(sata_pkt_t * sata_pkt)1895 sata_free_rdwr_pmult_pkt(sata_pkt_t *sata_pkt)
1896 {
1897 sata_pkt_txlate_t *spx =
1898 (sata_pkt_txlate_t *)sata_pkt->satapkt_framework_private;
1899
1900 /* Free allocated resources */
1901 sata_pkt_free(spx);
1902 kmem_free(spx, sizeof (sata_pkt_txlate_t));
1903 }
1904
1905 /*
1906 * Register a port multiplier to framework.
1907 * 1) Store the GSCR values in the previous allocated pmult_info strctures.
1908 * 2) Search in the blacklist and update the number of the device ports of the
1909 * port multiplier.
1910 *
1911 * Void return.
1912 */
1913 void
sata_register_pmult(dev_info_t * dip,sata_device_t * sd,sata_pmult_gscr_t * sg)1914 sata_register_pmult(dev_info_t *dip, sata_device_t *sd, sata_pmult_gscr_t *sg)
1915 {
1916 sata_hba_inst_t *sata_hba_inst = NULL;
1917 sata_pmult_info_t *pmultinfo;
1918 sata_pmult_bl_t *blp;
1919 int cport = sd->satadev_addr.cport;
1920
1921 mutex_enter(&sata_mutex);
1922 for (sata_hba_inst = sata_hba_list; sata_hba_inst != NULL;
1923 sata_hba_inst = sata_hba_inst->satahba_next) {
1924 if (SATA_DIP(sata_hba_inst) == dip)
1925 if (sata_hba_inst->satahba_attached == 1)
1926 break;
1927 }
1928 mutex_exit(&sata_mutex);
1929 /* HBA not attached? */
1930 if (sata_hba_inst == NULL)
1931 return;
1932
1933 /* Number of pmports */
1934 sd->satadev_add_info = sg->gscr2 & SATA_PMULT_PORTNUM_MASK;
1935
1936 /* Check the blacklist */
1937 for (blp = sata_pmult_blacklist; blp->bl_gscr0; blp++) {
1938 if (sg->gscr0 != blp->bl_gscr0 && blp->bl_gscr0)
1939 continue;
1940 if (sg->gscr1 != blp->bl_gscr1 && blp->bl_gscr1)
1941 continue;
1942 if (sg->gscr2 != blp->bl_gscr2 && blp->bl_gscr2)
1943 continue;
1944
1945 cmn_err(CE_WARN, "!Port multiplier is on the blacklist.");
1946 sd->satadev_add_info = blp->bl_flags;
1947 break;
1948 }
1949
1950 /* Register the port multiplier GSCR */
1951 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, cport)));
1952 pmultinfo = SATA_PMULT_INFO(sata_hba_inst, cport);
1953 if (pmultinfo != NULL) {
1954 pmultinfo->pmult_gscr = *sg;
1955 pmultinfo->pmult_num_dev_ports =
1956 sd->satadev_add_info & SATA_PMULT_PORTNUM_MASK;
1957 SATADBG1(SATA_DBG_PMULT, sata_hba_inst,
1958 "Port multiplier registered at port %d", cport);
1959 }
1960 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, cport)));
1961 }
1962
1963 /*
1964 * sata_split_model splits the model ID into vendor and product IDs.
1965 * It assumes that a vendor ID cannot be longer than 8 characters, and
1966 * that vendor and product ID are separated by a whitespace.
1967 */
1968 void
sata_split_model(char * model,char ** vendor,char ** product)1969 sata_split_model(char *model, char **vendor, char **product)
1970 {
1971 int i, modlen;
1972 char *vid, *pid;
1973
1974 /*
1975 * remove whitespace at the end of model
1976 */
1977 for (i = SATA_ID_MODEL_LEN; i > 0; i--)
1978 if (model[i] == ' ' || model[i] == '\t' || model[i] == '\0')
1979 model[i] = '\0';
1980 else
1981 break;
1982
1983 /*
1984 * try to split model into into vid/pid
1985 */
1986 modlen = strlen(model);
1987 for (i = 0, pid = model; i < modlen; i++, pid++)
1988 if ((*pid == ' ') || (*pid == '\t'))
1989 break;
1990
1991 /*
1992 * only use vid if it is less than 8 chars (as in SCSI)
1993 */
1994 if (i < modlen && i <= 8) {
1995 vid = model;
1996 /*
1997 * terminate vid, establish pid
1998 */
1999 *pid++ = '\0';
2000 } else {
2001 /*
2002 * vid will stay "ATA "
2003 */
2004 vid = NULL;
2005 /*
2006 * model is all pid
2007 */
2008 pid = model;
2009 }
2010
2011 *vendor = vid;
2012 *product = pid;
2013 }
2014
2015 /*
2016 * sata_name_child is for composing the name of the node
2017 * the format of the name is "target,0".
2018 */
2019 static int
sata_name_child(dev_info_t * dip,char * name,int namelen)2020 sata_name_child(dev_info_t *dip, char *name, int namelen)
2021 {
2022 int target;
2023
2024 target = ddi_prop_get_int(DDI_DEV_T_ANY, dip,
2025 DDI_PROP_DONTPASS, "target", -1);
2026 if (target == -1)
2027 return (DDI_FAILURE);
2028 (void) snprintf(name, namelen, "%x,0", target);
2029 return (DDI_SUCCESS);
2030 }
2031
2032
2033
2034 /* ****************** SCSA required entry points *********************** */
2035
2036 /*
2037 * Implementation of scsi tran_tgt_init.
2038 * sata_scsi_tgt_init() initializes scsi_device structure
2039 *
2040 * If successful, DDI_SUCCESS is returned.
2041 * DDI_FAILURE is returned if addressed device does not exist
2042 */
2043
2044 static int
sata_scsi_tgt_init(dev_info_t * hba_dip,dev_info_t * tgt_dip,scsi_hba_tran_t * hba_tran,struct scsi_device * sd)2045 sata_scsi_tgt_init(dev_info_t *hba_dip, dev_info_t *tgt_dip,
2046 scsi_hba_tran_t *hba_tran, struct scsi_device *sd)
2047 {
2048 #ifndef __lock_lint
2049 _NOTE(ARGUNUSED(hba_dip))
2050 _NOTE(ARGUNUSED(tgt_dip))
2051 #endif
2052 sata_device_t sata_device;
2053 sata_drive_info_t *sdinfo;
2054 struct sata_id *sid;
2055 sata_hba_inst_t *sata_hba_inst;
2056 char model[SATA_ID_MODEL_LEN + 1];
2057 char fw[SATA_ID_FW_LEN + 1];
2058 char *vid, *pid;
2059
2060 /*
2061 * Fail tran_tgt_init for .conf stub node
2062 */
2063 if (ndi_dev_is_persistent_node(tgt_dip) == 0) {
2064 (void) ndi_merge_node(tgt_dip, sata_name_child);
2065 ddi_set_name_addr(tgt_dip, NULL);
2066 return (DDI_FAILURE);
2067 }
2068
2069 sata_hba_inst = (sata_hba_inst_t *)(hba_tran->tran_hba_private);
2070
2071 /* Validate scsi device address */
2072 if (sata_validate_scsi_address(sata_hba_inst, &sd->sd_address,
2073 &sata_device) != 0)
2074 return (DDI_FAILURE);
2075
2076 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst,
2077 sata_device.satadev_addr.cport)));
2078
2079 /* sata_device now contains a valid sata address */
2080 sdinfo = sata_get_device_info(sata_hba_inst, &sata_device);
2081 if (sdinfo == NULL) {
2082 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst,
2083 sata_device.satadev_addr.cport)));
2084 return (DDI_FAILURE);
2085 }
2086 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst,
2087 sata_device.satadev_addr.cport)));
2088
2089 /*
2090 * Check if we need to create a legacy devid (i.e cmdk style) for
2091 * the target disks.
2092 *
2093 * HBA devinfo node will have the property "use-cmdk-devid-format"
2094 * if we need to create cmdk-style devid for all the disk devices
2095 * attached to this controller. This property may have been set
2096 * from HBA driver's .conf file or by the HBA driver in its
2097 * attach(9F) function.
2098 */
2099 if ((sdinfo->satadrv_type == SATA_DTYPE_ATADISK) &&
2100 (ddi_getprop(DDI_DEV_T_ANY, hba_dip, DDI_PROP_DONTPASS,
2101 "use-cmdk-devid-format", 0) == 1)) {
2102 /* register a legacy devid for this target node */
2103 sata_target_devid_register(tgt_dip, sdinfo);
2104 }
2105
2106
2107 /*
2108 * 'Identify Device Data' does not always fit in standard SCSI
2109 * INQUIRY data, so establish INQUIRY_* properties with full-form
2110 * of information.
2111 */
2112 sid = &sdinfo->satadrv_id;
2113 #ifdef _LITTLE_ENDIAN
2114 swab(sid->ai_model, model, SATA_ID_MODEL_LEN);
2115 swab(sid->ai_fw, fw, SATA_ID_FW_LEN);
2116 #else /* _LITTLE_ENDIAN */
2117 bcopy(sid->ai_model, model, SATA_ID_MODEL_LEN);
2118 bcopy(sid->ai_fw, fw, SATA_ID_FW_LEN);
2119 #endif /* _LITTLE_ENDIAN */
2120 model[SATA_ID_MODEL_LEN] = 0;
2121 fw[SATA_ID_FW_LEN] = 0;
2122
2123 sata_split_model(model, &vid, &pid);
2124
2125 if (vid)
2126 (void) scsi_device_prop_update_inqstring(sd, INQUIRY_VENDOR_ID,
2127 vid, strlen(vid));
2128 if (pid)
2129 (void) scsi_device_prop_update_inqstring(sd, INQUIRY_PRODUCT_ID,
2130 pid, strlen(pid));
2131 (void) scsi_device_prop_update_inqstring(sd, INQUIRY_REVISION_ID,
2132 fw, strlen(fw));
2133
2134 return (DDI_SUCCESS);
2135 }
2136
2137 /*
2138 * Implementation of scsi tran_tgt_probe.
2139 * Probe target, by calling default scsi routine scsi_hba_probe()
2140 */
2141 static int
sata_scsi_tgt_probe(struct scsi_device * sd,int (* callback)(void))2142 sata_scsi_tgt_probe(struct scsi_device *sd, int (*callback)(void))
2143 {
2144 sata_hba_inst_t *sata_hba_inst =
2145 (sata_hba_inst_t *)(sd->sd_address.a_hba_tran->tran_hba_private);
2146 int rval;
2147 uint32_t pm_cap;
2148
2149 rval = scsi_hba_probe(sd, callback);
2150 pm_cap = SATA_CAP_POWER_CONDITON | SATA_CAP_SMART_PAGE |
2151 SATA_CAP_LOG_SENSE;
2152
2153 if (rval == SCSIPROBE_EXISTS) {
2154 /*
2155 * Set property "pm-capable" on the target device node, so that
2156 * the target driver will not try to fetch scsi cycle counters
2157 * before enabling device power-management.
2158 */
2159 if ((ddi_prop_update_int(DDI_DEV_T_NONE, sd->sd_dev,
2160 "pm-capable", pm_cap)) != DDI_PROP_SUCCESS) {
2161 sata_log(sata_hba_inst, CE_WARN,
2162 "SATA device at port %d: "
2163 "will not be power-managed ",
2164 SCSI_TO_SATA_CPORT(sd->sd_address.a_target));
2165 SATA_LOG_D((sata_hba_inst, CE_WARN,
2166 "failure updating pm-capable property"));
2167 }
2168 }
2169 return (rval);
2170 }
2171
2172 /*
2173 * Implementation of scsi tran_tgt_free.
2174 * Release all resources allocated for scsi_device
2175 */
2176 static void
sata_scsi_tgt_free(dev_info_t * hba_dip,dev_info_t * tgt_dip,scsi_hba_tran_t * hba_tran,struct scsi_device * sd)2177 sata_scsi_tgt_free(dev_info_t *hba_dip, dev_info_t *tgt_dip,
2178 scsi_hba_tran_t *hba_tran, struct scsi_device *sd)
2179 {
2180 #ifndef __lock_lint
2181 _NOTE(ARGUNUSED(hba_dip))
2182 #endif
2183 sata_device_t sata_device;
2184 sata_drive_info_t *sdinfo;
2185 sata_hba_inst_t *sata_hba_inst;
2186 ddi_devid_t devid;
2187
2188 sata_hba_inst = (sata_hba_inst_t *)(hba_tran->tran_hba_private);
2189
2190 /* Validate scsi device address */
2191 /*
2192 * Note: tgt_free relates to the SCSA view of a device. If called, there
2193 * was a device at this address, so even if the sata framework internal
2194 * resources were alredy released because a device was detached,
2195 * this function should be executed as long as its actions do
2196 * not require the internal sata view of a device and the address
2197 * refers to a valid sata address.
2198 * Validating the address here means that we do not trust SCSA...
2199 */
2200 if (sata_validate_scsi_address(sata_hba_inst, &sd->sd_address,
2201 &sata_device) == -1)
2202 return;
2203
2204 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst,
2205 sata_device.satadev_addr.cport)));
2206
2207 /* sata_device now should contain a valid sata address */
2208 sdinfo = sata_get_device_info(sata_hba_inst, &sata_device);
2209 if (sdinfo == NULL) {
2210 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst,
2211 sata_device.satadev_addr.cport)));
2212 return;
2213 }
2214 /*
2215 * We did not allocate any resources in sata_scsi_tgt_init()
2216 * other than few properties.
2217 * Free them.
2218 */
2219 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst,
2220 sata_device.satadev_addr.cport)));
2221 (void) ndi_prop_remove(DDI_DEV_T_NONE, tgt_dip, "pm-capable");
2222
2223 /*
2224 * If devid was previously created but not freed up from
2225 * sd(4D) driver (i.e during detach(9F)) then do it here.
2226 */
2227 if ((sdinfo->satadrv_type == SATA_DTYPE_ATADISK) &&
2228 (ddi_getprop(DDI_DEV_T_ANY, hba_dip, DDI_PROP_DONTPASS,
2229 "use-cmdk-devid-format", 0) == 1) &&
2230 (ddi_devid_get(tgt_dip, &devid) == DDI_SUCCESS)) {
2231 ddi_devid_unregister(tgt_dip);
2232 ddi_devid_free(devid);
2233 }
2234 }
2235
2236 /*
2237 * Implementation of scsi tran_init_pkt
2238 * Upon successful return, scsi pkt buffer has DMA resources allocated.
2239 *
2240 * It seems that we should always allocate pkt, even if the address is
2241 * for non-existing device - just use some default for dma_attr.
2242 * The reason is that there is no way to communicate this to a caller here.
2243 * Subsequent call to sata_scsi_start may fail appropriately.
2244 * Simply returning NULL does not seem to discourage a target driver...
2245 *
2246 * Returns a pointer to initialized scsi_pkt, or NULL otherwise.
2247 */
2248 static struct scsi_pkt *
sata_scsi_init_pkt(struct scsi_address * ap,struct scsi_pkt * pkt,struct buf * bp,int cmdlen,int statuslen,int tgtlen,int flags,int (* callback)(caddr_t),caddr_t arg)2249 sata_scsi_init_pkt(struct scsi_address *ap, struct scsi_pkt *pkt,
2250 struct buf *bp, int cmdlen, int statuslen, int tgtlen, int flags,
2251 int (*callback)(caddr_t), caddr_t arg)
2252 {
2253 sata_hba_inst_t *sata_hba_inst =
2254 (sata_hba_inst_t *)(ap->a_hba_tran->tran_hba_private);
2255 dev_info_t *dip = SATA_DIP(sata_hba_inst);
2256 sata_device_t sata_device;
2257 sata_drive_info_t *sdinfo;
2258 sata_pkt_txlate_t *spx;
2259 ddi_dma_attr_t cur_dma_attr;
2260 int rval;
2261 boolean_t new_pkt = B_TRUE;
2262
2263 ASSERT(ap->a_hba_tran->tran_hba_dip == dip);
2264
2265 /*
2266 * We need to translate the address, even if it could be
2267 * a bogus one, for a non-existing device
2268 */
2269 sata_device.satadev_addr.qual = SCSI_TO_SATA_ADDR_QUAL(ap->a_target);
2270 sata_device.satadev_addr.cport = SCSI_TO_SATA_CPORT(ap->a_target);
2271 sata_device.satadev_addr.pmport = SCSI_TO_SATA_PMPORT(ap->a_target);
2272 sata_device.satadev_rev = SATA_DEVICE_REV;
2273
2274 if (pkt == NULL) {
2275 /*
2276 * Have to allocate a brand new scsi packet.
2277 * We need to operate with auto request sense enabled.
2278 */
2279 pkt = scsi_hba_pkt_alloc(dip, ap, cmdlen,
2280 MAX(statuslen, SATA_MAX_SENSE_LEN),
2281 tgtlen, sizeof (sata_pkt_txlate_t), callback, arg);
2282
2283 if (pkt == NULL)
2284 return (NULL);
2285
2286 /* Fill scsi packet structure */
2287 pkt->pkt_comp = (void (*)())NULL;
2288 pkt->pkt_time = 0;
2289 pkt->pkt_resid = 0;
2290 pkt->pkt_statistics = 0;
2291 pkt->pkt_reason = 0;
2292
2293 /*
2294 * pkt_hba_private will point to sata pkt txlate structure
2295 */
2296 spx = (sata_pkt_txlate_t *)pkt->pkt_ha_private;
2297 bzero(spx, sizeof (sata_pkt_txlate_t));
2298
2299 spx->txlt_scsi_pkt = pkt;
2300 spx->txlt_sata_hba_inst = sata_hba_inst;
2301
2302 /* Allocate sata_pkt */
2303 spx->txlt_sata_pkt = sata_pkt_alloc(spx, callback);
2304 if (spx->txlt_sata_pkt == NULL) {
2305 /* Could not allocate sata pkt */
2306 scsi_hba_pkt_free(ap, pkt);
2307 return (NULL);
2308 }
2309 /* Set sata address */
2310 spx->txlt_sata_pkt->satapkt_device.satadev_addr =
2311 sata_device.satadev_addr;
2312 spx->txlt_sata_pkt->satapkt_device.satadev_rev =
2313 sata_device.satadev_rev;
2314
2315 if ((bp == NULL) || (bp->b_bcount == 0))
2316 return (pkt);
2317
2318 spx->txlt_total_residue = bp->b_bcount;
2319 } else {
2320 new_pkt = B_FALSE;
2321 /*
2322 * Packet was preallocated/initialized by previous call
2323 */
2324 spx = (sata_pkt_txlate_t *)pkt->pkt_ha_private;
2325
2326 if ((bp == NULL) || (bp->b_bcount == 0)) {
2327 return (pkt);
2328 }
2329
2330 /* Pkt is available already: spx->txlt_scsi_pkt == pkt; */
2331 }
2332
2333 spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp = bp;
2334
2335 /*
2336 * We use an adjusted version of the dma_attr, to account
2337 * for device addressing limitations.
2338 * sata_adjust_dma_attr() will handle sdinfo == NULL which may
2339 * happen when a device is not yet configured.
2340 */
2341 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst,
2342 sata_device.satadev_addr.cport)));
2343 sdinfo = sata_get_device_info(spx->txlt_sata_hba_inst,
2344 &spx->txlt_sata_pkt->satapkt_device);
2345 /* NULL sdinfo may be passsed to sata_adjust_dma_attr() */
2346 sata_adjust_dma_attr(sdinfo,
2347 SATA_DMA_ATTR(spx->txlt_sata_hba_inst), &cur_dma_attr);
2348 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst,
2349 sata_device.satadev_addr.cport)));
2350 /*
2351 * Allocate necessary DMA resources for the packet's data buffer
2352 * NOTE:
2353 * In case of read/write commands, DMA resource allocation here is
2354 * based on the premise that the transfer length specified in
2355 * the read/write scsi cdb will match exactly DMA resources -
2356 * returning correct packet residue is crucial.
2357 */
2358 if ((rval = sata_dma_buf_setup(spx, flags, callback, arg,
2359 &cur_dma_attr)) != DDI_SUCCESS) {
2360 /*
2361 * If a DMA allocation request fails with
2362 * DDI_DMA_NOMAPPING, indicate the error by calling
2363 * bioerror(9F) with bp and an error code of EFAULT.
2364 * If a DMA allocation request fails with
2365 * DDI_DMA_TOOBIG, indicate the error by calling
2366 * bioerror(9F) with bp and an error code of EINVAL.
2367 * For DDI_DMA_NORESOURCES, we may have some of them allocated.
2368 * Request may be repeated later - there is no real error.
2369 */
2370 switch (rval) {
2371 case DDI_DMA_NORESOURCES:
2372 bioerror(bp, 0);
2373 break;
2374 case DDI_DMA_NOMAPPING:
2375 case DDI_DMA_BADATTR:
2376 bioerror(bp, EFAULT);
2377 break;
2378 case DDI_DMA_TOOBIG:
2379 default:
2380 bioerror(bp, EINVAL);
2381 break;
2382 }
2383 goto fail;
2384 }
2385
2386 if (sata_check_for_dma_error(dip, spx)) {
2387 ddi_fm_service_impact(dip, DDI_SERVICE_UNAFFECTED);
2388 bioerror(bp, EFAULT);
2389 goto fail;
2390 }
2391
2392 /* Set number of bytes that are not yet accounted for */
2393 pkt->pkt_resid = spx->txlt_total_residue;
2394 ASSERT(pkt->pkt_resid >= 0);
2395
2396 return (pkt);
2397
2398 fail:
2399 if (new_pkt == B_TRUE) {
2400 /*
2401 * Since this is a new packet, we can clean-up
2402 * everything
2403 */
2404 sata_scsi_destroy_pkt(ap, pkt);
2405 } else {
2406 /*
2407 * This is a re-used packet. It will be target driver's
2408 * responsibility to eventually destroy it (which
2409 * will free allocated resources).
2410 * Here, we just "complete" the request, leaving
2411 * allocated resources intact, so the request may
2412 * be retried.
2413 */
2414 spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp = NULL;
2415 sata_pkt_free(spx);
2416 }
2417 return (NULL);
2418 }
2419
2420 /*
2421 * Implementation of scsi tran_start.
2422 * Translate scsi cmd into sata operation and return status.
2423 * ATAPI CDBs are passed to ATAPI devices - the device determines what commands
2424 * are supported.
2425 * For SATA hard disks, supported scsi commands:
2426 * SCMD_INQUIRY
2427 * SCMD_TEST_UNIT_READY
2428 * SCMD_START_STOP
2429 * SCMD_READ_CAPACITY
2430 * SCMD_SVC_ACTION_IN_G4 (READ CAPACITY (16))
2431 * SCMD_REQUEST_SENSE
2432 * SCMD_LOG_SENSE_G1
2433 * SCMD_LOG_SELECT_G1
2434 * SCMD_MODE_SENSE (specific pages)
2435 * SCMD_MODE_SENSE_G1 (specific pages)
2436 * SCMD_MODE_SELECT (specific pages)
2437 * SCMD_MODE_SELECT_G1 (specific pages)
2438 * SCMD_SYNCHRONIZE_CACHE
2439 * SCMD_SYNCHRONIZE_CACHE_G1
2440 * SCMD_READ
2441 * SCMD_READ_G1
2442 * SCMD_READ_G4
2443 * SCMD_READ_G5
2444 * SCMD_WRITE
2445 * SCMD_WRITE_BUFFER
2446 * SCMD_WRITE_G1
2447 * SCMD_WRITE_G4
2448 * SCMD_WRITE_G5
2449 * SCMD_SEEK (noop)
2450 * SCMD_SDIAG
2451 *
2452 * All other commands are rejected as unsupported.
2453 *
2454 * Returns:
2455 * TRAN_ACCEPT if command was executed successfully or accepted by HBA driver
2456 * for execution. TRAN_ACCEPT may be returned also if device was removed but
2457 * a callback could be scheduled.
2458 * TRAN_BADPKT if cmd was directed to invalid address.
2459 * TRAN_FATAL_ERROR is command was rejected due to hardware error, including
2460 * some unspecified error. TRAN_FATAL_ERROR may be also returned if a device
2461 * was removed and there was no callback specified in scsi pkt.
2462 * TRAN_BUSY if command could not be executed becasue HBA driver or SATA
2463 * framework was busy performing some other operation(s).
2464 *
2465 */
2466 static int
sata_scsi_start(struct scsi_address * ap,struct scsi_pkt * pkt)2467 sata_scsi_start(struct scsi_address *ap, struct scsi_pkt *pkt)
2468 {
2469 sata_hba_inst_t *sata_hba_inst =
2470 (sata_hba_inst_t *)(ap->a_hba_tran->tran_hba_private);
2471 sata_pkt_txlate_t *spx = (sata_pkt_txlate_t *)pkt->pkt_ha_private;
2472 sata_device_t *sdevice = &spx->txlt_sata_pkt->satapkt_device;
2473 sata_drive_info_t *sdinfo = NULL;
2474 struct buf *bp;
2475 uint8_t cport, pmport;
2476 boolean_t dev_gone = B_FALSE;
2477 int rval;
2478
2479 SATADBG1(SATA_DBG_SCSI_IF, sata_hba_inst,
2480 "sata_scsi_start: cmd 0x%02x\n", pkt->pkt_cdbp[0]);
2481
2482 ASSERT(spx != NULL &&
2483 spx->txlt_scsi_pkt == pkt && spx->txlt_sata_pkt != NULL);
2484
2485 cport = SCSI_TO_SATA_CPORT(ap->a_target);
2486 pmport = SCSI_TO_SATA_PMPORT(ap->a_target);
2487
2488 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, cport)));
2489
2490 if (sdevice->satadev_addr.qual == SATA_ADDR_DCPORT) {
2491 sdinfo = sata_get_device_info(sata_hba_inst, sdevice);
2492 if (sdinfo == NULL ||
2493 SATA_CPORT_INFO(sata_hba_inst, cport)->
2494 cport_tgtnode_clean == B_FALSE ||
2495 (sdinfo->satadrv_state & SATA_DSTATE_FAILED) != 0) {
2496 dev_gone = B_TRUE;
2497 }
2498 } else if (sdevice->satadev_addr.qual == SATA_ADDR_DPMPORT) {
2499 if (SATA_CPORT_DEV_TYPE(sata_hba_inst, cport) !=
2500 SATA_DTYPE_PMULT || SATA_PMULT_INFO(sata_hba_inst,
2501 cport) == NULL) {
2502 dev_gone = B_TRUE;
2503 } else if (SATA_PMPORT_INFO(sata_hba_inst, cport,
2504 pmport) == NULL) {
2505 dev_gone = B_TRUE;
2506 } else {
2507 mutex_enter(&(SATA_PMPORT_MUTEX(sata_hba_inst,
2508 cport, pmport)));
2509 sdinfo = sata_get_device_info(sata_hba_inst, sdevice);
2510 if (sdinfo == NULL ||
2511 SATA_PMPORT_INFO(sata_hba_inst, cport, pmport)->
2512 pmport_tgtnode_clean == B_FALSE ||
2513 (sdinfo->satadrv_state & SATA_DSTATE_FAILED) != 0) {
2514 dev_gone = B_TRUE;
2515 }
2516 mutex_exit(&(SATA_PMPORT_MUTEX(sata_hba_inst,
2517 cport, pmport)));
2518 }
2519 }
2520
2521 if (dev_gone == B_TRUE) {
2522 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, cport)));
2523 pkt->pkt_reason = CMD_DEV_GONE;
2524 /*
2525 * The sd target driver is checking CMD_DEV_GONE pkt_reason
2526 * only in callback function (for normal requests) and
2527 * in the dump code path.
2528 * So, if the callback is available, we need to do
2529 * the callback rather than returning TRAN_FATAL_ERROR here.
2530 */
2531 if (pkt->pkt_comp != NULL) {
2532 /* scsi callback required */
2533 if (servicing_interrupt()) {
2534 if (taskq_dispatch(SATA_TXLT_TASKQ(spx),
2535 (task_func_t *)spx->txlt_scsi_pkt->pkt_comp,
2536 (void *)spx->txlt_scsi_pkt, TQ_NOSLEEP) ==
2537 TASKQID_INVALID) {
2538 return (TRAN_BUSY);
2539 }
2540 } else if (taskq_dispatch(SATA_TXLT_TASKQ(spx),
2541 (task_func_t *)spx->txlt_scsi_pkt->pkt_comp,
2542 spx->txlt_scsi_pkt, TQ_SLEEP) == TASKQID_INVALID) {
2543 /* Scheduling the callback failed */
2544 return (TRAN_BUSY);
2545 }
2546 return (TRAN_ACCEPT);
2547 }
2548 /* No callback available */
2549 return (TRAN_FATAL_ERROR);
2550 }
2551
2552 if (sdinfo->satadrv_type & SATA_DTYPE_ATAPI) {
2553 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, cport)));
2554 rval = sata_txlt_atapi(spx);
2555 SATADBG1(SATA_DBG_SCSI_IF, sata_hba_inst,
2556 "sata_scsi_start atapi: rval %d\n", rval);
2557 return (rval);
2558 }
2559 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, cport)));
2560
2561 /*
2562 * Checking for power state, if it was on
2563 * STOPPED state, then the drive is not capable
2564 * of processing media access command. And
2565 * TEST_UNIT_READY, REQUEST_SENSE has special handling
2566 * in the function for different power state.
2567 */
2568 if (((sdinfo->satadrv_power_level == SATA_POWER_STANDBY) ||
2569 (sdinfo->satadrv_power_level == SATA_POWER_STOPPED)) &&
2570 (SATA_IS_MEDIUM_ACCESS_CMD(pkt->pkt_cdbp[0]))) {
2571 return (sata_txlt_check_condition(spx, KEY_NOT_READY,
2572 SD_SCSI_ASC_LU_NOT_READY));
2573 }
2574
2575 /* ATA Disk commands processing starts here */
2576
2577 bp = spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp;
2578
2579 switch (pkt->pkt_cdbp[0]) {
2580
2581 case SCMD_INQUIRY:
2582 /* Mapped to identify device */
2583 if (bp != NULL && (bp->b_flags & (B_PHYS | B_PAGEIO)))
2584 bp_mapin(bp);
2585 rval = sata_txlt_inquiry(spx);
2586 break;
2587
2588 case SCMD_TEST_UNIT_READY:
2589 /*
2590 * SAT "SATA to ATA Translation" doc specifies translation
2591 * to ATA CHECK POWER MODE.
2592 */
2593 rval = sata_txlt_test_unit_ready(spx);
2594 break;
2595
2596 case SCMD_START_STOP:
2597 /* Mapping depends on the command */
2598 rval = sata_txlt_start_stop_unit(spx);
2599 break;
2600
2601 case SCMD_READ_CAPACITY:
2602 if (bp != NULL && (bp->b_flags & (B_PHYS | B_PAGEIO)))
2603 bp_mapin(bp);
2604 rval = sata_txlt_read_capacity(spx);
2605 break;
2606
2607 case SCMD_SVC_ACTION_IN_G4: /* READ CAPACITY (16) */
2608 if (bp != NULL && (bp->b_flags & (B_PHYS | B_PAGEIO)))
2609 bp_mapin(bp);
2610 rval = sata_txlt_read_capacity16(spx);
2611 break;
2612
2613 case SCMD_REQUEST_SENSE:
2614 /*
2615 * Always No Sense, since we force ARQ
2616 */
2617 if (bp != NULL && (bp->b_flags & (B_PHYS | B_PAGEIO)))
2618 bp_mapin(bp);
2619 rval = sata_txlt_request_sense(spx);
2620 break;
2621
2622 case SCMD_LOG_SENSE_G1:
2623 if (bp != NULL && (bp->b_flags & (B_PHYS | B_PAGEIO)))
2624 bp_mapin(bp);
2625 rval = sata_txlt_log_sense(spx);
2626 break;
2627
2628 case SCMD_LOG_SELECT_G1:
2629 if (bp != NULL && (bp->b_flags & (B_PHYS | B_PAGEIO)))
2630 bp_mapin(bp);
2631 rval = sata_txlt_log_select(spx);
2632 break;
2633
2634 case SCMD_MODE_SENSE:
2635 case SCMD_MODE_SENSE_G1:
2636 if (bp != NULL && (bp->b_flags & (B_PHYS | B_PAGEIO)))
2637 bp_mapin(bp);
2638 rval = sata_txlt_mode_sense(spx);
2639 break;
2640
2641
2642 case SCMD_MODE_SELECT:
2643 case SCMD_MODE_SELECT_G1:
2644 if (bp != NULL && (bp->b_flags & (B_PHYS | B_PAGEIO)))
2645 bp_mapin(bp);
2646 rval = sata_txlt_mode_select(spx);
2647 break;
2648
2649 case SCMD_SYNCHRONIZE_CACHE:
2650 case SCMD_SYNCHRONIZE_CACHE_G1:
2651 rval = sata_txlt_synchronize_cache(spx);
2652 break;
2653
2654 case SCMD_READ:
2655 case SCMD_READ_G1:
2656 case SCMD_READ_G4:
2657 case SCMD_READ_G5:
2658 rval = sata_txlt_read(spx);
2659 break;
2660 case SCMD_WRITE_BUFFER:
2661 if (bp != NULL && (bp->b_flags & (B_PHYS | B_PAGEIO)))
2662 bp_mapin(bp);
2663 rval = sata_txlt_write_buffer(spx);
2664 break;
2665
2666 case SCMD_WRITE:
2667 case SCMD_WRITE_G1:
2668 case SCMD_WRITE_G4:
2669 case SCMD_WRITE_G5:
2670 rval = sata_txlt_write(spx);
2671 break;
2672
2673 case SCMD_SEEK:
2674 rval = sata_txlt_nodata_cmd_immediate(spx);
2675 break;
2676
2677 case SPC3_CMD_ATA_COMMAND_PASS_THROUGH12:
2678 case SPC3_CMD_ATA_COMMAND_PASS_THROUGH16:
2679 if (bp != NULL && (bp->b_flags & (B_PHYS | B_PAGEIO)))
2680 bp_mapin(bp);
2681 rval = sata_txlt_ata_pass_thru(spx);
2682 break;
2683
2684 /* Other cases will be filed later */
2685 /* postponed until phase 2 of the development */
2686 case SPC3_CMD_UNMAP:
2687 if (bp != NULL && (bp->b_flags & (B_PHYS | B_PAGEIO)))
2688 bp_mapin(bp);
2689 rval = sata_txlt_unmap(spx);
2690 break;
2691 default:
2692 rval = sata_txlt_invalid_command(spx);
2693 break;
2694 }
2695
2696 SATADBG1(SATA_DBG_SCSI_IF, sata_hba_inst,
2697 "sata_scsi_start: rval %d\n", rval);
2698
2699 return (rval);
2700 }
2701
2702 /*
2703 * Implementation of scsi tran_abort.
2704 * Abort specific pkt or all packets.
2705 *
2706 * Returns 1 if one or more packets were aborted, returns 0 otherwise
2707 *
2708 * May be called from an interrupt level.
2709 */
2710 static int
sata_scsi_abort(struct scsi_address * ap,struct scsi_pkt * scsi_pkt)2711 sata_scsi_abort(struct scsi_address *ap, struct scsi_pkt *scsi_pkt)
2712 {
2713 sata_hba_inst_t *sata_hba_inst =
2714 (sata_hba_inst_t *)(ap->a_hba_tran->tran_hba_private);
2715 sata_device_t sata_device;
2716 sata_pkt_t *sata_pkt;
2717
2718 SATADBG2(SATA_DBG_SCSI_IF, sata_hba_inst,
2719 "sata_scsi_abort: %s at target: 0x%x\n",
2720 scsi_pkt == NULL ? "all packets" : "one pkt", ap->a_target);
2721
2722 /* Validate address */
2723 if (sata_validate_scsi_address(sata_hba_inst, ap, &sata_device) != 0)
2724 /* Invalid address */
2725 return (0);
2726
2727 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst,
2728 sata_device.satadev_addr.cport)));
2729 if (sata_get_device_info(sata_hba_inst, &sata_device) == NULL) {
2730 /* invalid address */
2731 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst,
2732 sata_device.satadev_addr.cport)));
2733 return (0);
2734 }
2735 if (scsi_pkt == NULL) {
2736 /*
2737 * Abort all packets.
2738 * Although we do not have specific packet, we still need
2739 * dummy packet structure to pass device address to HBA.
2740 * Allocate one, without sleeping. Fail if pkt cannot be
2741 * allocated.
2742 */
2743 sata_pkt = kmem_zalloc(sizeof (sata_pkt_t), KM_NOSLEEP);
2744 if (sata_pkt == NULL) {
2745 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst,
2746 sata_device.satadev_addr.cport)));
2747 SATA_LOG_D((sata_hba_inst, CE_WARN, "sata_pkt_abort: "
2748 "could not allocate sata_pkt"));
2749 return (0);
2750 }
2751 sata_pkt->satapkt_rev = SATA_PKT_REV;
2752 sata_pkt->satapkt_device = sata_device;
2753 sata_pkt->satapkt_device.satadev_rev = SATA_DEVICE_REV;
2754 } else {
2755 if (scsi_pkt->pkt_ha_private == NULL) {
2756 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst,
2757 sata_device.satadev_addr.cport)));
2758 return (0); /* Bad scsi pkt */
2759 }
2760 /* extract pointer to sata pkt */
2761 sata_pkt = ((sata_pkt_txlate_t *)scsi_pkt->pkt_ha_private)->
2762 txlt_sata_pkt;
2763 }
2764
2765 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst,
2766 sata_device.satadev_addr.cport)));
2767 /* Send abort request to HBA */
2768 if ((*SATA_ABORT_FUNC(sata_hba_inst))
2769 (SATA_DIP(sata_hba_inst), sata_pkt,
2770 scsi_pkt == NULL ? SATA_ABORT_ALL_PACKETS : SATA_ABORT_PACKET) ==
2771 SATA_SUCCESS) {
2772 if (scsi_pkt == NULL)
2773 kmem_free(sata_pkt, sizeof (sata_pkt_t));
2774 /* Success */
2775 return (1);
2776 }
2777 /* Else, something did not go right */
2778 if (scsi_pkt == NULL)
2779 kmem_free(sata_pkt, sizeof (sata_pkt_t));
2780 /* Failure */
2781 return (0);
2782 }
2783
2784
2785 /*
2786 * Implementation of scsi tran_reset.
2787 * RESET_ALL request is translated into port reset.
2788 * RESET_TARGET requests is translated into a device reset,
2789 * RESET_LUN request is accepted only for LUN 0 and translated into
2790 * device reset.
2791 * The target reset should cause all HBA active and queued packets to
2792 * be terminated and returned with pkt reason SATA_PKT_RESET prior to
2793 * the return. HBA should report reset event for the device.
2794 *
2795 * Returns 1 upon success, 0 upon failure.
2796 */
2797 static int
sata_scsi_reset(struct scsi_address * ap,int level)2798 sata_scsi_reset(struct scsi_address *ap, int level)
2799 {
2800 sata_hba_inst_t *sata_hba_inst =
2801 (sata_hba_inst_t *)(ap->a_hba_tran->tran_hba_private);
2802 sata_device_t sata_device;
2803 int val;
2804
2805 SATADBG2(SATA_DBG_SCSI_IF, sata_hba_inst,
2806 "sata_scsi_reset: level %d target: 0x%x\n",
2807 level, ap->a_target);
2808
2809 /* Validate address */
2810 val = sata_validate_scsi_address(sata_hba_inst, ap, &sata_device);
2811 if (val == -1)
2812 /* Invalid address */
2813 return (0);
2814
2815 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst,
2816 sata_device.satadev_addr.cport)));
2817 if (sata_get_device_info(sata_hba_inst, &sata_device) == NULL) {
2818 /* invalid address */
2819 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst,
2820 sata_device.satadev_addr.cport)));
2821 return (0);
2822 }
2823 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst,
2824 sata_device.satadev_addr.cport)));
2825 if (level == RESET_ALL) {
2826 /* port reset */
2827 if (sata_device.satadev_addr.qual == SATA_ADDR_DCPORT)
2828 sata_device.satadev_addr.qual = SATA_ADDR_CPORT;
2829 else
2830 sata_device.satadev_addr.qual = SATA_ADDR_PMPORT;
2831
2832 if ((*SATA_RESET_DPORT_FUNC(sata_hba_inst))
2833 (SATA_DIP(sata_hba_inst), &sata_device) == SATA_SUCCESS)
2834 return (1);
2835 else
2836 return (0);
2837
2838 } else if (val == 0 &&
2839 (level == RESET_TARGET || level == RESET_LUN)) {
2840 /* reset device (device attached) */
2841 if ((*SATA_RESET_DPORT_FUNC(sata_hba_inst))
2842 (SATA_DIP(sata_hba_inst), &sata_device) == SATA_SUCCESS)
2843 return (1);
2844 else
2845 return (0);
2846 }
2847 return (0);
2848 }
2849
2850
2851 /*
2852 * Implementation of scsi tran_getcap (get transport/device capabilities).
2853 * Supported capabilities for SATA hard disks:
2854 * auto-rqsense (always supported)
2855 * tagged-qing (supported if HBA supports it)
2856 * untagged-qing (could be supported if disk supports it, but because
2857 * caching behavior allowing untagged queuing actually
2858 * results in reduced performance. sd tries to throttle
2859 * back to only 3 outstanding commands, which may
2860 * work for real SCSI disks, but with read ahead
2861 * caching, having more than 1 outstanding command
2862 * results in cache thrashing.)
2863 * sector_size
2864 * dma_max
2865 * interconnect-type (INTERCONNECT_SATA)
2866 *
2867 * Supported capabilities for ATAPI CD/DVD devices:
2868 * auto-rqsense (always supported)
2869 * sector_size
2870 * dma_max
2871 * max-cdb-length
2872 * interconnect-type (INTERCONNECT_SATA)
2873 *
2874 * Supported capabilities for ATAPI TAPE devices:
2875 * auto-rqsense (always supported)
2876 * dma_max
2877 * max-cdb-length
2878 *
2879 * Supported capabilities for SATA ATAPI hard disks:
2880 * auto-rqsense (always supported)
2881 * interconnect-type (INTERCONNECT_SATA)
2882 * max-cdb-length
2883 *
2884 * Request for other capabilities is rejected as unsupported.
2885 *
2886 * Returns supported capability value, or -1 if capability is unsuppported or
2887 * the address is invalid - no device.
2888 */
2889
2890 static int
sata_scsi_getcap(struct scsi_address * ap,char * cap,int whom)2891 sata_scsi_getcap(struct scsi_address *ap, char *cap, int whom)
2892 {
2893
2894 sata_hba_inst_t *sata_hba_inst =
2895 (sata_hba_inst_t *)(ap->a_hba_tran->tran_hba_private);
2896 sata_device_t sata_device;
2897 sata_drive_info_t *sdinfo;
2898 ddi_dma_attr_t adj_dma_attr;
2899 int rval;
2900
2901 SATADBG2(SATA_DBG_SCSI_IF, sata_hba_inst,
2902 "sata_scsi_getcap: target: 0x%x, cap: %s\n",
2903 ap->a_target, cap);
2904
2905 /*
2906 * We want to process the capabilities on per port granularity.
2907 * So, we are specifically restricting ourselves to whom != 0
2908 * to exclude the controller wide handling.
2909 */
2910 if (cap == NULL || whom == 0)
2911 return (-1);
2912
2913 if (sata_validate_scsi_address(sata_hba_inst, ap, &sata_device) != 0) {
2914 /* Invalid address */
2915 return (-1);
2916 }
2917 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst,
2918 sata_device.satadev_addr.cport)));
2919 if ((sdinfo = sata_get_device_info(sata_hba_inst, &sata_device)) ==
2920 NULL) {
2921 /* invalid address */
2922 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst,
2923 sata_device.satadev_addr.cport)));
2924 return (-1);
2925 }
2926
2927 switch (scsi_hba_lookup_capstr(cap)) {
2928 case SCSI_CAP_ARQ:
2929 rval = 1; /* ARQ supported, turned on */
2930 break;
2931
2932 case SCSI_CAP_SECTOR_SIZE:
2933 if (sdinfo->satadrv_type == SATA_DTYPE_ATADISK)
2934 rval = SATA_DISK_SECTOR_SIZE; /* fixed size */
2935 else if (sdinfo->satadrv_type == SATA_DTYPE_ATAPICD)
2936 rval = SATA_ATAPI_SECTOR_SIZE;
2937 else rval = -1;
2938 break;
2939
2940 /*
2941 * untagged queuing cause a performance inversion because of
2942 * the way sd operates. Because of this reason we do not
2943 * use it when available.
2944 */
2945 case SCSI_CAP_UNTAGGED_QING:
2946 if (sdinfo->satadrv_features_enabled &
2947 SATA_DEV_F_E_UNTAGGED_QING)
2948 rval = 1; /* Untagged queuing available */
2949 else
2950 rval = -1; /* Untagged queuing not available */
2951 break;
2952
2953 case SCSI_CAP_TAGGED_QING:
2954 if ((sdinfo->satadrv_features_enabled &
2955 SATA_DEV_F_E_TAGGED_QING) &&
2956 (sdinfo->satadrv_max_queue_depth > 1))
2957 rval = 1; /* Tagged queuing available */
2958 else
2959 rval = -1; /* Tagged queuing not available */
2960 break;
2961
2962 case SCSI_CAP_DMA_MAX:
2963 sata_adjust_dma_attr(sdinfo, SATA_DMA_ATTR(sata_hba_inst),
2964 &adj_dma_attr);
2965 rval = (int)adj_dma_attr.dma_attr_maxxfer;
2966 /* We rely on the fact that dma_attr_maxxfer < 0x80000000 */
2967 break;
2968
2969 case SCSI_CAP_INTERCONNECT_TYPE:
2970 rval = INTERCONNECT_SATA; /* SATA interconnect type */
2971 break;
2972
2973 case SCSI_CAP_CDB_LEN:
2974 if (sdinfo->satadrv_type & SATA_DTYPE_ATAPI)
2975 rval = sdinfo->satadrv_atapi_cdb_len;
2976 else
2977 rval = -1;
2978 break;
2979
2980 default:
2981 rval = -1;
2982 break;
2983 }
2984 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst,
2985 sata_device.satadev_addr.cport)));
2986 return (rval);
2987 }
2988
2989 /*
2990 * Implementation of scsi tran_setcap
2991 *
2992 * Only SCSI_CAP_UNTAGGED_QING and SCSI_CAP_TAGGED_QING are changeable.
2993 *
2994 */
2995 static int
sata_scsi_setcap(struct scsi_address * ap,char * cap,int value,int whom)2996 sata_scsi_setcap(struct scsi_address *ap, char *cap, int value, int whom)
2997 {
2998 sata_hba_inst_t *sata_hba_inst =
2999 (sata_hba_inst_t *)(ap->a_hba_tran->tran_hba_private);
3000 sata_device_t sata_device;
3001 sata_drive_info_t *sdinfo;
3002 int rval;
3003
3004 SATADBG2(SATA_DBG_SCSI_IF, sata_hba_inst,
3005 "sata_scsi_setcap: target: 0x%x, cap: %s\n", ap->a_target, cap);
3006
3007 /*
3008 * We want to process the capabilities on per port granularity.
3009 * So, we are specifically restricting ourselves to whom != 0
3010 * to exclude the controller wide handling.
3011 */
3012 if (cap == NULL || whom == 0) {
3013 return (-1);
3014 }
3015
3016 if (sata_validate_scsi_address(sata_hba_inst, ap, &sata_device) != 0) {
3017 /* Invalid address */
3018 return (-1);
3019 }
3020 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst,
3021 sata_device.satadev_addr.cport)));
3022 if ((sdinfo = sata_get_device_info(sata_hba_inst,
3023 &sata_device)) == NULL) {
3024 /* invalid address */
3025 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst,
3026 sata_device.satadev_addr.cport)));
3027 return (-1);
3028 }
3029 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst,
3030 sata_device.satadev_addr.cport)));
3031
3032 switch (scsi_hba_lookup_capstr(cap)) {
3033 case SCSI_CAP_ARQ:
3034 case SCSI_CAP_SECTOR_SIZE:
3035 case SCSI_CAP_DMA_MAX:
3036 case SCSI_CAP_INTERCONNECT_TYPE:
3037 rval = 0;
3038 break;
3039 case SCSI_CAP_UNTAGGED_QING:
3040 if (SATA_QDEPTH(sata_hba_inst) > 1) {
3041 rval = 1;
3042 if (value == 1) {
3043 sdinfo->satadrv_features_enabled |=
3044 SATA_DEV_F_E_UNTAGGED_QING;
3045 } else if (value == 0) {
3046 sdinfo->satadrv_features_enabled &=
3047 ~SATA_DEV_F_E_UNTAGGED_QING;
3048 } else {
3049 rval = -1;
3050 }
3051 } else {
3052 rval = 0;
3053 }
3054 break;
3055 case SCSI_CAP_TAGGED_QING:
3056 /* This can TCQ or NCQ */
3057 if (sata_func_enable & SATA_ENABLE_QUEUING &&
3058 ((sdinfo->satadrv_features_support & SATA_DEV_F_TCQ &&
3059 SATA_FEATURES(sata_hba_inst) & SATA_CTLF_QCMD) ||
3060 (sata_func_enable & SATA_ENABLE_NCQ &&
3061 sdinfo->satadrv_features_support & SATA_DEV_F_NCQ &&
3062 SATA_FEATURES(sata_hba_inst) & SATA_CTLF_NCQ)) &&
3063 (sdinfo->satadrv_max_queue_depth > 1)) {
3064 rval = 1;
3065 if (value == 1) {
3066 sdinfo->satadrv_features_enabled |=
3067 SATA_DEV_F_E_TAGGED_QING;
3068 } else if (value == 0) {
3069 sdinfo->satadrv_features_enabled &=
3070 ~SATA_DEV_F_E_TAGGED_QING;
3071 } else {
3072 rval = -1;
3073 }
3074 } else {
3075 rval = 0;
3076 }
3077 break;
3078 default:
3079 rval = -1;
3080 break;
3081 }
3082 return (rval);
3083 }
3084
3085 /*
3086 * Implementations of scsi tran_destroy_pkt.
3087 * Free resources allocated by sata_scsi_init_pkt()
3088 */
3089 static void
sata_scsi_destroy_pkt(struct scsi_address * ap,struct scsi_pkt * pkt)3090 sata_scsi_destroy_pkt(struct scsi_address *ap, struct scsi_pkt *pkt)
3091 {
3092 sata_pkt_txlate_t *spx;
3093
3094 spx = (sata_pkt_txlate_t *)pkt->pkt_ha_private;
3095
3096 sata_common_free_dma_rsrcs(spx);
3097
3098 spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp = NULL;
3099 sata_pkt_free(spx);
3100
3101 scsi_hba_pkt_free(ap, pkt);
3102 }
3103
3104 /*
3105 * Implementation of scsi tran_dmafree.
3106 * Free DMA resources allocated by sata_scsi_init_pkt()
3107 */
3108
3109 static void
sata_scsi_dmafree(struct scsi_address * ap,struct scsi_pkt * pkt)3110 sata_scsi_dmafree(struct scsi_address *ap, struct scsi_pkt *pkt)
3111 {
3112 #ifndef __lock_lint
3113 _NOTE(ARGUNUSED(ap))
3114 #endif
3115 sata_pkt_txlate_t *spx;
3116
3117 ASSERT(pkt != NULL);
3118 spx = (sata_pkt_txlate_t *)pkt->pkt_ha_private;
3119
3120 sata_common_free_dma_rsrcs(spx);
3121 }
3122
3123 /*
3124 * Implementation of scsi tran_sync_pkt.
3125 *
3126 * The assumption below is that pkt is unique - there is no need to check ap
3127 *
3128 * Synchronize DMA buffer and, if the intermediate buffer is used, copy data
3129 * into/from the real buffer.
3130 */
3131 static void
sata_scsi_sync_pkt(struct scsi_address * ap __unused,struct scsi_pkt * pkt)3132 sata_scsi_sync_pkt(struct scsi_address *ap __unused, struct scsi_pkt *pkt)
3133 {
3134 sata_pkt_txlate_t *spx = (sata_pkt_txlate_t *)pkt->pkt_ha_private;
3135 struct buf *bp;
3136 int direction;
3137 int rval;
3138
3139 ASSERT(spx != NULL);
3140 if (spx->txlt_buf_dma_handle == NULL)
3141 return;
3142
3143 if (spx->txlt_sata_pkt == NULL)
3144 return;
3145
3146 direction = spx->txlt_sata_pkt->
3147 satapkt_cmd.satacmd_flags.sata_data_direction;
3148
3149 if (direction == SATA_DIR_NODATA_XFER)
3150 return;
3151
3152 bp = spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp;
3153
3154 if (spx->txlt_tmp_buf != NULL && (direction & SATA_DIR_WRITE) != 0) {
3155 /* Intermediate DMA buffer used */
3156 bcopy(bp->b_un.b_addr, spx->txlt_tmp_buf, bp->b_bcount);
3157 }
3158
3159 /* Sync the buffer for device or for CPU */
3160 rval = ddi_dma_sync(spx->txlt_buf_dma_handle, 0, 0,
3161 (direction & SATA_DIR_WRITE) ?
3162 DDI_DMA_SYNC_FORDEV : DDI_DMA_SYNC_FORCPU);
3163 ASSERT3S(rval, ==, DDI_SUCCESS);
3164
3165 if (spx->txlt_tmp_buf != NULL && !(direction & SATA_DIR_WRITE)) {
3166 /* Intermediate DMA buffer used for read */
3167 bcopy(spx->txlt_tmp_buf, bp->b_un.b_addr, bp->b_bcount);
3168 }
3169 }
3170
3171
3172
3173 /* ******************* SATA - SCSI Translation functions **************** */
3174 /*
3175 * SCSI to SATA pkt and command translation and SATA to SCSI status/error
3176 * translation.
3177 */
3178
3179 /*
3180 * Checks if a device exists and can be access and translates common
3181 * scsi_pkt data to sata_pkt data.
3182 *
3183 * Flag argument indicates that a non-read/write ATA command may be sent
3184 * to HBA in arbitrary SYNC mode to execute this packet.
3185 *
3186 * Returns TRAN_ACCEPT and scsi pkt_reason CMD_CMPLT if device exists and
3187 * sata_pkt was set-up.
3188 * Returns TRAN_ACCEPT and scsi pkt_reason CMD_DEV_GONE if device does not
3189 * exist and pkt_comp callback was scheduled.
3190 * Returns other TRAN_XXXXX values when error occured and command should be
3191 * rejected with the returned TRAN_XXXXX value.
3192 *
3193 * This function should be called with port mutex held.
3194 */
3195 static int
sata_txlt_generic_pkt_info(sata_pkt_txlate_t * spx,int * reason,int flag)3196 sata_txlt_generic_pkt_info(sata_pkt_txlate_t *spx, int *reason, int flag)
3197 {
3198 sata_drive_info_t *sdinfo;
3199 sata_device_t sata_device;
3200 const struct sata_cmd_flags sata_initial_cmd_flags = {
3201 SATA_DIR_NODATA_XFER,
3202 /* all other values to 0/FALSE */
3203 };
3204 /*
3205 * Pkt_reason has to be set if the pkt_comp callback is invoked,
3206 * and that implies TRAN_ACCEPT return value. Any other returned value
3207 * indicates that the scsi packet was not accepted (the reason will not
3208 * be checked by the scsi target driver).
3209 * To make debugging easier, we set pkt_reason to know value here.
3210 * It may be changed later when different completion reason is
3211 * determined.
3212 */
3213 spx->txlt_scsi_pkt->pkt_reason = CMD_TRAN_ERR;
3214 *reason = CMD_TRAN_ERR;
3215
3216 /* Validate address */
3217 switch (sata_validate_scsi_address(spx->txlt_sata_hba_inst,
3218 &spx->txlt_scsi_pkt->pkt_address, &sata_device)) {
3219
3220 case -1:
3221 /* Invalid address or invalid device type */
3222 return (TRAN_BADPKT);
3223 case 2:
3224 /*
3225 * Valid address but device type is unknown - Chack if it is
3226 * in the reset state and therefore in an indeterminate state.
3227 */
3228 sdinfo = sata_get_device_info(spx->txlt_sata_hba_inst,
3229 &spx->txlt_sata_pkt->satapkt_device);
3230 if (sdinfo != NULL && (sdinfo->satadrv_event_flags &
3231 (SATA_EVNT_DEVICE_RESET |
3232 SATA_EVNT_INPROC_DEVICE_RESET)) != 0) {
3233 if (!ddi_in_panic()) {
3234 spx->txlt_scsi_pkt->pkt_reason = CMD_INCOMPLETE;
3235 *reason = CMD_INCOMPLETE;
3236 SATADBG1(SATA_DBG_SCSI_IF,
3237 spx->txlt_sata_hba_inst,
3238 "sata_scsi_start: rejecting command "
3239 "because of device reset state\n", NULL);
3240 return (TRAN_BUSY);
3241 }
3242 }
3243 /* FALLTHROUGH */
3244 case 1:
3245 /* valid address but no valid device - it has disappeared */
3246 spx->txlt_scsi_pkt->pkt_reason = CMD_DEV_GONE;
3247 *reason = CMD_DEV_GONE;
3248 /*
3249 * The sd target driver is checking CMD_DEV_GONE pkt_reason
3250 * only in callback function (for normal requests) and
3251 * in the dump code path.
3252 * So, if the callback is available, we need to do
3253 * the callback rather than returning TRAN_FATAL_ERROR here.
3254 */
3255 if (spx->txlt_scsi_pkt->pkt_comp != NULL) {
3256 /* scsi callback required */
3257 if (servicing_interrupt()) {
3258 if (taskq_dispatch(SATA_TXLT_TASKQ(spx),
3259 (task_func_t *)spx->txlt_scsi_pkt->pkt_comp,
3260 (void *)spx->txlt_scsi_pkt, TQ_NOSLEEP) ==
3261 TASKQID_INVALID) {
3262 return (TRAN_BUSY);
3263 }
3264 } else if (taskq_dispatch(SATA_TXLT_TASKQ(spx),
3265 (task_func_t *)spx->txlt_scsi_pkt->pkt_comp,
3266 spx->txlt_scsi_pkt, TQ_SLEEP) == TASKQID_INVALID) {
3267 /* Scheduling the callback failed */
3268 return (TRAN_BUSY);
3269 }
3270
3271 return (TRAN_ACCEPT);
3272 }
3273 return (TRAN_FATAL_ERROR);
3274 default:
3275 /* all OK; pkt reason will be overwritten later */
3276 break;
3277 }
3278 /*
3279 * If pkt is to be executed in polling mode and a command will not be
3280 * emulated in SATA module (requires sending a non-read/write ATA
3281 * command to HBA driver in arbitrary SYNC mode) and we are in the
3282 * interrupt context and not in the panic dump, then reject the packet
3283 * to avoid a possible interrupt stack overrun or hang caused by
3284 * a potentially blocked interrupt.
3285 */
3286 if (((spx->txlt_scsi_pkt->pkt_flags & FLAG_NOINTR) != 0 || flag != 0) &&
3287 servicing_interrupt() && !ddi_in_panic()) {
3288 SATADBG1(SATA_DBG_INTR_CTX, spx->txlt_sata_hba_inst,
3289 "sata_scsi_start: rejecting synchronous command because "
3290 "of interrupt context\n", NULL);
3291 return (TRAN_BUSY);
3292 }
3293
3294 sdinfo = sata_get_device_info(spx->txlt_sata_hba_inst,
3295 &spx->txlt_sata_pkt->satapkt_device);
3296
3297 /*
3298 * If device is in reset condition, reject the packet with
3299 * TRAN_BUSY, unless:
3300 * 1. system is panicking (dumping)
3301 * In such case only one thread is running and there is no way to
3302 * process reset.
3303 * 2. cfgadm operation is is progress (internal APCTL lock is set)
3304 * Some cfgadm operations involve drive commands, so reset condition
3305 * needs to be ignored for IOCTL operations.
3306 */
3307 if ((sdinfo->satadrv_event_flags &
3308 (SATA_EVNT_DEVICE_RESET | SATA_EVNT_INPROC_DEVICE_RESET)) != 0) {
3309
3310 if (!ddi_in_panic() &&
3311 ((SATA_CPORT_EVENT_FLAGS(spx->txlt_sata_hba_inst,
3312 sata_device.satadev_addr.cport) &
3313 SATA_APCTL_LOCK_PORT_BUSY) == 0)) {
3314 spx->txlt_scsi_pkt->pkt_reason = CMD_INCOMPLETE;
3315 *reason = CMD_INCOMPLETE;
3316 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst,
3317 "sata_scsi_start: rejecting command because "
3318 "of device reset state\n", NULL);
3319 return (TRAN_BUSY);
3320 }
3321 }
3322
3323 /*
3324 * Fix the dev_type in the sata_pkt->satapkt_device. It was not set by
3325 * sata_scsi_pkt_init() because pkt init had to work also with
3326 * non-existing devices.
3327 * Now we know that the packet was set-up for a real device, so its
3328 * type is known.
3329 */
3330 spx->txlt_sata_pkt->satapkt_device.satadev_type = sdinfo->satadrv_type;
3331
3332 spx->txlt_sata_pkt->satapkt_cmd.satacmd_flags = sata_initial_cmd_flags;
3333 if ((SATA_CPORT_INFO(spx->txlt_sata_hba_inst,
3334 sata_device.satadev_addr.cport)->cport_event_flags &
3335 SATA_APCTL_LOCK_PORT_BUSY) != 0) {
3336 spx->txlt_sata_pkt->satapkt_cmd.satacmd_flags.
3337 sata_ignore_dev_reset = B_TRUE;
3338 }
3339 /*
3340 * At this point the generic translation routine determined that the
3341 * scsi packet should be accepted. Packet completion reason may be
3342 * changed later when a different completion reason is determined.
3343 */
3344 spx->txlt_scsi_pkt->pkt_reason = CMD_CMPLT;
3345 *reason = CMD_CMPLT;
3346
3347 if ((spx->txlt_scsi_pkt->pkt_flags & FLAG_NOINTR) != 0) {
3348 /* Synchronous execution */
3349 spx->txlt_sata_pkt->satapkt_op_mode = SATA_OPMODE_SYNCH |
3350 SATA_OPMODE_POLLING;
3351 spx->txlt_sata_pkt->satapkt_cmd.satacmd_flags.
3352 sata_ignore_dev_reset = ddi_in_panic();
3353 } else {
3354 /* Asynchronous execution */
3355 spx->txlt_sata_pkt->satapkt_op_mode = SATA_OPMODE_ASYNCH |
3356 SATA_OPMODE_INTERRUPTS;
3357 }
3358 /* Convert queuing information */
3359 if (spx->txlt_scsi_pkt->pkt_flags & FLAG_STAG)
3360 spx->txlt_sata_pkt->satapkt_cmd.satacmd_flags.sata_queue_stag =
3361 B_TRUE;
3362 else if (spx->txlt_scsi_pkt->pkt_flags &
3363 (FLAG_OTAG | FLAG_HTAG | FLAG_HEAD))
3364 spx->txlt_sata_pkt->satapkt_cmd.satacmd_flags.sata_queue_otag =
3365 B_TRUE;
3366
3367 /* Always limit pkt time */
3368 if (spx->txlt_scsi_pkt->pkt_time == 0)
3369 spx->txlt_sata_pkt->satapkt_time = sata_default_pkt_time;
3370 else
3371 /* Pass on scsi_pkt time */
3372 spx->txlt_sata_pkt->satapkt_time =
3373 spx->txlt_scsi_pkt->pkt_time;
3374
3375 return (TRAN_ACCEPT);
3376 }
3377
3378
3379 /*
3380 * Translate ATA Identify Device data to SCSI Inquiry data.
3381 * This function may be called only for ATA devices.
3382 * This function should not be called for ATAPI devices - they
3383 * respond directly to SCSI Inquiry command.
3384 *
3385 * SATA Identify Device data has to be valid in sata_drive_info.
3386 * Buffer has to accomodate the inquiry length (36 bytes).
3387 *
3388 * This function should be called with a port mutex held.
3389 */
3390 static void
sata_identdev_to_inquiry(sata_hba_inst_t * sata_hba_inst,sata_drive_info_t * sdinfo,uint8_t * buf)3391 sata_identdev_to_inquiry(sata_hba_inst_t *sata_hba_inst,
3392 sata_drive_info_t *sdinfo, uint8_t *buf)
3393 {
3394
3395 struct scsi_inquiry *inq = (struct scsi_inquiry *)buf;
3396 struct sata_id *sid = &sdinfo->satadrv_id;
3397
3398 /* Start with a nice clean slate */
3399 bzero((void *)inq, sizeof (struct scsi_inquiry));
3400
3401 /*
3402 * Rely on the dev_type for setting paripheral qualifier.
3403 * Assume that DTYPE_RODIRECT applies to CD/DVD R/W devices.
3404 * It could be that DTYPE_OPTICAL could also qualify in the future.
3405 * ATAPI Inquiry may provide more data to the target driver.
3406 */
3407 inq->inq_dtype = sdinfo->satadrv_type == SATA_DTYPE_ATADISK ?
3408 DTYPE_DIRECT : DTYPE_RODIRECT; /* DTYPE_UNKNOWN; */
3409
3410 /* CFA type device is not a removable media device */
3411 inq->inq_rmb = ((sid->ai_config != SATA_CFA_TYPE) &&
3412 (sid->ai_config & SATA_REM_MEDIA)) ? 1 : 0;
3413 inq->inq_qual = 0; /* Device type qualifier (obsolete in SCSI3? */
3414 inq->inq_iso = 0; /* ISO version */
3415 inq->inq_ecma = 0; /* ECMA version */
3416 inq->inq_ansi = 3; /* ANSI version - SCSI 3 */
3417 inq->inq_aenc = 0; /* Async event notification cap. */
3418 inq->inq_trmiop = 0; /* Supports TERMINATE I/O PROC msg - NO */
3419 inq->inq_normaca = 0; /* setting NACA bit supported - NO */
3420 inq->inq_rdf = RDF_SCSI2; /* Response data format- SPC-3 */
3421 inq->inq_len = 31; /* Additional length */
3422 inq->inq_dualp = 0; /* dual port device - NO */
3423 inq->inq_reladdr = 0; /* Supports relative addressing - NO */
3424 inq->inq_sync = 0; /* Supports synchronous data xfers - NO */
3425 inq->inq_linked = 0; /* Supports linked commands - NO */
3426 /*
3427 * Queuing support - controller has to
3428 * support some sort of command queuing.
3429 */
3430 if (SATA_QDEPTH(sata_hba_inst) > 1)
3431 inq->inq_cmdque = 1; /* Supports command queueing - YES */
3432 else
3433 inq->inq_cmdque = 0; /* Supports command queueing - NO */
3434 inq->inq_sftre = 0; /* Supports Soft Reset option - NO ??? */
3435 inq->inq_wbus32 = 0; /* Supports 32 bit wide data xfers - NO */
3436 inq->inq_wbus16 = 0; /* Supports 16 bit wide data xfers - NO */
3437
3438 #ifdef _LITTLE_ENDIAN
3439 /* Swap text fields to match SCSI format */
3440 bcopy("ATA ", inq->inq_vid, 8); /* Vendor ID */
3441 swab(sid->ai_model, inq->inq_pid, 16); /* Product ID */
3442 if (strncmp(&sid->ai_fw[4], " ", 4) == 0)
3443 swab(sid->ai_fw, inq->inq_revision, 4); /* Revision level */
3444 else
3445 swab(&sid->ai_fw[4], inq->inq_revision, 4); /* Rev. level */
3446 #else /* _LITTLE_ENDIAN */
3447 bcopy("ATA ", inq->inq_vid, 8); /* Vendor ID */
3448 bcopy(sid->ai_model, inq->inq_pid, 16); /* Product ID */
3449 if (strncmp(&sid->ai_fw[4], " ", 4) == 0)
3450 bcopy(sid->ai_fw, inq->inq_revision, 4); /* Revision level */
3451 else
3452 bcopy(&sid->ai_fw[4], inq->inq_revision, 4); /* Rev. level */
3453 #endif /* _LITTLE_ENDIAN */
3454 }
3455
3456
3457 /*
3458 * Scsi response set up for invalid command (command not supported)
3459 *
3460 * Returns TRAN_ACCEPT and appropriate values in scsi_pkt fields.
3461 */
3462 static int
sata_txlt_invalid_command(sata_pkt_txlate_t * spx)3463 sata_txlt_invalid_command(sata_pkt_txlate_t *spx)
3464 {
3465 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt;
3466 struct scsi_extended_sense *sense;
3467
3468 scsipkt->pkt_reason = CMD_CMPLT;
3469 scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET |
3470 STATE_SENT_CMD | STATE_GOT_STATUS;
3471
3472 *scsipkt->pkt_scbp = STATUS_CHECK;
3473
3474 sense = sata_arq_sense(spx);
3475 sense->es_key = KEY_ILLEGAL_REQUEST;
3476 sense->es_add_code = SD_SCSI_ASC_INVALID_COMMAND_CODE;
3477
3478 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst,
3479 "Scsi_pkt completion reason %x\n", scsipkt->pkt_reason);
3480
3481 if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0 &&
3482 scsipkt->pkt_comp != NULL) {
3483 /* scsi callback required */
3484 if (servicing_interrupt()) {
3485 if (taskq_dispatch(SATA_TXLT_TASKQ(spx),
3486 (task_func_t *)spx->txlt_scsi_pkt->pkt_comp,
3487 (void *)spx->txlt_scsi_pkt, TQ_NOSLEEP) ==
3488 TASKQID_INVALID) {
3489 return (TRAN_BUSY);
3490 }
3491 } else if (taskq_dispatch(SATA_TXLT_TASKQ(spx),
3492 (task_func_t *)spx->txlt_scsi_pkt->pkt_comp,
3493 (void *)spx->txlt_scsi_pkt, TQ_SLEEP) == TASKQID_INVALID) {
3494 /* Scheduling the callback failed */
3495 return (TRAN_BUSY);
3496 }
3497 }
3498 return (TRAN_ACCEPT);
3499 }
3500
3501 /*
3502 * Scsi response set up for check condition with special sense key
3503 * and additional sense code.
3504 *
3505 * Returns TRAN_ACCEPT and appropriate values in scsi_pkt fields.
3506 */
3507 static int
sata_txlt_check_condition(sata_pkt_txlate_t * spx,uchar_t key,uchar_t code)3508 sata_txlt_check_condition(sata_pkt_txlate_t *spx, uchar_t key, uchar_t code)
3509 {
3510 sata_hba_inst_t *shi = SATA_TXLT_HBA_INST(spx);
3511 int cport = SATA_TXLT_CPORT(spx);
3512 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt;
3513 struct scsi_extended_sense *sense;
3514
3515 mutex_enter(&SATA_CPORT_MUTEX(shi, cport));
3516 scsipkt->pkt_reason = CMD_CMPLT;
3517 scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET |
3518 STATE_SENT_CMD | STATE_GOT_STATUS;
3519
3520 *scsipkt->pkt_scbp = STATUS_CHECK;
3521
3522 sense = sata_arq_sense(spx);
3523 sense->es_key = key;
3524 sense->es_add_code = code;
3525
3526 mutex_exit(&SATA_CPORT_MUTEX(shi, cport));
3527
3528 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst,
3529 "Scsi_pkt completion reason %x\n", scsipkt->pkt_reason);
3530
3531 if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0 &&
3532 scsipkt->pkt_comp != NULL) {
3533 /* scsi callback required */
3534 if (servicing_interrupt()) {
3535 if (taskq_dispatch(SATA_TXLT_TASKQ(spx),
3536 (task_func_t *)spx->txlt_scsi_pkt->pkt_comp,
3537 (void *)spx->txlt_scsi_pkt, TQ_NOSLEEP) ==
3538 TASKQID_INVALID) {
3539 return (TRAN_BUSY);
3540 }
3541 } else if (taskq_dispatch(SATA_TXLT_TASKQ(spx),
3542 (task_func_t *)spx->txlt_scsi_pkt->pkt_comp,
3543 (void *)spx->txlt_scsi_pkt, TQ_SLEEP) == TASKQID_INVALID) {
3544 /* Scheduling the callback failed */
3545 return (TRAN_BUSY);
3546 }
3547 }
3548 return (TRAN_ACCEPT);
3549 }
3550
3551 /*
3552 * Scsi response setup for
3553 * emulated non-data command that requires no action/return data
3554 *
3555 * Returns TRAN_ACCEPT and appropriate values in scsi_pkt fields.
3556 */
3557 static int
sata_txlt_nodata_cmd_immediate(sata_pkt_txlate_t * spx)3558 sata_txlt_nodata_cmd_immediate(sata_pkt_txlate_t *spx)
3559 {
3560 int rval;
3561 int reason;
3562 kmutex_t *cport_mutex = &(SATA_TXLT_CPORT_MUTEX(spx));
3563
3564 mutex_enter(cport_mutex);
3565
3566 if (((rval = sata_txlt_generic_pkt_info(spx, &reason, 0)) !=
3567 TRAN_ACCEPT) || (reason == CMD_DEV_GONE)) {
3568 mutex_exit(cport_mutex);
3569 return (rval);
3570 }
3571 mutex_exit(cport_mutex);
3572
3573 spx->txlt_scsi_pkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET |
3574 STATE_SENT_CMD | STATE_GOT_STATUS;
3575 spx->txlt_scsi_pkt->pkt_reason = CMD_CMPLT;
3576 *(spx->txlt_scsi_pkt->pkt_scbp) = STATUS_GOOD;
3577
3578 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst,
3579 "Scsi_pkt completion reason %x\n",
3580 spx->txlt_scsi_pkt->pkt_reason);
3581
3582 if ((spx->txlt_scsi_pkt->pkt_flags & FLAG_NOINTR) == 0 &&
3583 spx->txlt_scsi_pkt->pkt_comp != NULL) {
3584 /* scsi callback required */
3585 if (servicing_interrupt()) {
3586 if (taskq_dispatch(SATA_TXLT_TASKQ(spx),
3587 (task_func_t *)spx->txlt_scsi_pkt->pkt_comp,
3588 (void *)spx->txlt_scsi_pkt, TQ_NOSLEEP) ==
3589 TASKQID_INVALID) {
3590 return (TRAN_BUSY);
3591 }
3592 } else if (taskq_dispatch(SATA_TXLT_TASKQ(spx),
3593 (task_func_t *)spx->txlt_scsi_pkt->pkt_comp,
3594 (void *)spx->txlt_scsi_pkt, TQ_SLEEP) == TASKQID_INVALID) {
3595 /* Scheduling the callback failed */
3596 return (TRAN_BUSY);
3597 }
3598 }
3599 return (TRAN_ACCEPT);
3600 }
3601
3602
3603 /*
3604 * SATA translate command: Inquiry / Identify Device
3605 * Use cached Identify Device data for now, rather than issuing actual
3606 * Device Identify cmd request. If device is detached and re-attached,
3607 * asynchronous event processing should fetch and refresh Identify Device
3608 * data.
3609 * VPD pages supported now:
3610 * Vital Product Data page
3611 * Unit Serial Number page
3612 * Block Device Characteristics Page
3613 * ATA Information Page
3614 *
3615 * Returns TRAN_ACCEPT and appropriate values in scsi_pkt fields.
3616 */
3617
3618 #define EVPD 1 /* Extended Vital Product Data flag */
3619 #define CMDDT 2 /* Command Support Data - Obsolete */
3620 #define INQUIRY_SUP_VPD_PAGE 0 /* Supported VPD Pages Page Code */
3621 #define INQUIRY_USN_PAGE 0x80 /* Unit Serial Number Page Code */
3622 #define INQUIRY_BDC_PAGE 0xB1 /* Block Device Characteristics Page */
3623 /* Code */
3624 #define INQUIRY_ATA_INFO_PAGE 0x89 /* ATA Information Page Code */
3625 #define INQUIRY_DEV_IDENTIFICATION_PAGE 0x83 /* Device identifiers */
3626
3627 static int
sata_txlt_inquiry(sata_pkt_txlate_t * spx)3628 sata_txlt_inquiry(sata_pkt_txlate_t *spx)
3629 {
3630 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt;
3631 struct buf *bp = spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp;
3632 sata_drive_info_t *sdinfo;
3633 struct scsi_extended_sense *sense;
3634 int count;
3635 uint8_t *p;
3636 int i, j;
3637 uint8_t page_buf[1024]; /* Max length */
3638 int rval, reason;
3639 ushort_t rate;
3640 kmutex_t *cport_mutex = &(SATA_TXLT_CPORT_MUTEX(spx));
3641
3642 /*
3643 * sata_txlt_generic_pkt_info() and sata_get_device_info() require
3644 * cport_mutex to be held while they are called. sdinfo is also
3645 * protected by cport_mutex, so we hold cport_mutex until after we've
3646 * finished using sdinfo.
3647 */
3648 mutex_enter(cport_mutex);
3649
3650 if (((rval = sata_txlt_generic_pkt_info(spx, &reason, 0)) !=
3651 TRAN_ACCEPT) || (reason == CMD_DEV_GONE)) {
3652 mutex_exit(cport_mutex);
3653 return (rval);
3654 }
3655
3656 sdinfo = sata_get_device_info(spx->txlt_sata_hba_inst,
3657 &spx->txlt_sata_pkt->satapkt_device);
3658
3659 ASSERT(sdinfo != NULL);
3660
3661 scsipkt->pkt_reason = CMD_CMPLT;
3662 scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET |
3663 STATE_SENT_CMD | STATE_GOT_STATUS;
3664
3665 /* Reject not supported request */
3666 if (scsipkt->pkt_cdbp[1] & CMDDT) { /* No support for this bit */
3667 *scsipkt->pkt_scbp = STATUS_CHECK;
3668 sense = sata_arq_sense(spx);
3669 sense->es_key = KEY_ILLEGAL_REQUEST;
3670 sense->es_add_code = SD_SCSI_ASC_INVALID_FIELD_IN_CDB;
3671 goto done;
3672 }
3673
3674 /* Valid Inquiry request */
3675 *scsipkt->pkt_scbp = STATUS_GOOD;
3676
3677 if (bp == NULL || bp->b_un.b_addr == NULL || bp->b_bcount == 0)
3678 goto done;
3679
3680 /*
3681 * Because it is fully emulated command storing data
3682 * programatically in the specified buffer, release
3683 * preallocated DMA resources before storing data in the buffer,
3684 * so no unwanted DMA sync would take place.
3685 */
3686 sata_scsi_dmafree(NULL, scsipkt);
3687
3688 if (!(scsipkt->pkt_cdbp[1] & EVPD)) {
3689 /* Standard Inquiry Data request */
3690 struct scsi_inquiry inq;
3691 unsigned int bufsize;
3692
3693 sata_identdev_to_inquiry(spx->txlt_sata_hba_inst,
3694 sdinfo, (uint8_t *)&inq);
3695 /* Copy no more than requested */
3696 count = MIN(bp->b_bcount, sizeof (struct scsi_inquiry));
3697 bufsize = scsipkt->pkt_cdbp[4];
3698 bufsize |= scsipkt->pkt_cdbp[3] << 8;
3699 count = MIN(count, bufsize);
3700 bcopy(&inq, bp->b_un.b_addr, count);
3701
3702 scsipkt->pkt_state |= STATE_XFERRED_DATA;
3703 scsipkt->pkt_resid = scsipkt->pkt_cdbp[4] > count ?
3704 bufsize - count : 0;
3705 goto done;
3706 }
3707
3708 /*
3709 * peripheral_qualifier = 0;
3710 *
3711 * We are dealing only with HD and will be
3712 * dealing with CD/DVD devices soon
3713 */
3714 uint8_t peripheral_device_type =
3715 sdinfo->satadrv_type == SATA_DTYPE_ATADISK ?
3716 DTYPE_DIRECT : DTYPE_RODIRECT;
3717
3718 bzero(page_buf, sizeof (page_buf));
3719
3720 switch ((uint_t)scsipkt->pkt_cdbp[2]) {
3721 case INQUIRY_SUP_VPD_PAGE:
3722 /*
3723 * Request for supported Vital Product Data pages.
3724 */
3725 page_buf[0] = peripheral_device_type;
3726 page_buf[1] = INQUIRY_SUP_VPD_PAGE;
3727 page_buf[2] = 0;
3728 page_buf[4] = INQUIRY_SUP_VPD_PAGE;
3729 page_buf[5] = INQUIRY_USN_PAGE;
3730 page_buf[6] = INQUIRY_BDC_PAGE;
3731 /*
3732 * If WWN info is present, provide a page for it.
3733 * Modern drives always have, but some legacy ones do not.
3734 */
3735 if (sdinfo->satadrv_id.ai_naa_ieee_oui != 0) {
3736 page_buf[3] = 5; /* page length */
3737 page_buf[7] = INQUIRY_DEV_IDENTIFICATION_PAGE;
3738 page_buf[8] = INQUIRY_ATA_INFO_PAGE;
3739 count = 9;
3740 } else {
3741 page_buf[3] = 4; /* page length */
3742 page_buf[7] = INQUIRY_ATA_INFO_PAGE;
3743 count = 8;
3744 }
3745 /* Copy no more than requested */
3746 count = MIN(bp->b_bcount, count);
3747 bcopy(page_buf, bp->b_un.b_addr, count);
3748 break;
3749
3750 case INQUIRY_USN_PAGE:
3751 /*
3752 * Request for Unit Serial Number page.
3753 * Set-up the page.
3754 */
3755 page_buf[0] = peripheral_device_type;
3756 page_buf[1] = INQUIRY_USN_PAGE;
3757 page_buf[2] = 0;
3758 /* remaining page length */
3759 page_buf[3] = SATA_ID_SERIAL_LEN;
3760
3761 /*
3762 * Copy serial number from Identify Device data
3763 * words into the inquiry page and swap bytes
3764 * when necessary.
3765 */
3766 p = (uint8_t *)(sdinfo->satadrv_id.ai_drvser);
3767 #ifdef _LITTLE_ENDIAN
3768 swab(p, &page_buf[4], SATA_ID_SERIAL_LEN);
3769 #else
3770 bcopy(p, &page_buf[4], SATA_ID_SERIAL_LEN);
3771 #endif
3772 /*
3773 * Least significant character of the serial
3774 * number shall appear as the last byte,
3775 * according to SBC-3 spec.
3776 * Count trailing spaces to determine the
3777 * necessary shift length.
3778 */
3779 p = &page_buf[SATA_ID_SERIAL_LEN + 4 - 1];
3780 for (j = 0; j < SATA_ID_SERIAL_LEN; j++) {
3781 if (*(p - j) != '\0' && *(p - j) != '\040')
3782 break;
3783 }
3784
3785 /*
3786 * Shift SN string right, so that the last
3787 * non-blank character would appear in last
3788 * byte of SN field in the page.
3789 * 'j' is the shift length.
3790 */
3791 for (i = 0; i < (SATA_ID_SERIAL_LEN - j) && j != 0; i++, p--)
3792 *p = *(p - j);
3793
3794 /*
3795 * Add leading spaces - same number as the
3796 * shift size
3797 */
3798 for (; j > 0; j--)
3799 page_buf[4 + j - 1] = '\040';
3800
3801 count = MIN(bp->b_bcount, SATA_ID_SERIAL_LEN + 4);
3802 bcopy(page_buf, bp->b_un.b_addr, count);
3803 break;
3804
3805 case INQUIRY_BDC_PAGE:
3806 /*
3807 * Request for Block Device Characteristics
3808 * page. Set-up the page.
3809 */
3810 page_buf[0] = peripheral_device_type;
3811 page_buf[1] = INQUIRY_BDC_PAGE;
3812 page_buf[2] = 0;
3813 /* remaining page length */
3814 page_buf[3] = SATA_ID_BDC_LEN;
3815
3816 rate = sdinfo->satadrv_id.ai_medrotrate;
3817 page_buf[4] = (rate >> 8) & 0xff;
3818 page_buf[5] = rate & 0xff;
3819 page_buf[6] = 0;
3820 page_buf[7] = sdinfo->satadrv_id.ai_nomformfactor & 0xf;
3821
3822 count = MIN(bp->b_bcount, SATA_ID_BDC_LEN + 4);
3823 bcopy(page_buf, bp->b_un.b_addr, count);
3824 break;
3825
3826 case INQUIRY_ATA_INFO_PAGE:
3827 /*
3828 * Request for ATA Information page.
3829 */
3830 page_buf[0] = peripheral_device_type;
3831 page_buf[1] = INQUIRY_ATA_INFO_PAGE;
3832 page_buf[2] = (SATA_ID_ATA_INFO_LEN >> 8) & 0xff;
3833 page_buf[3] = SATA_ID_ATA_INFO_LEN & 0xff;
3834 /* page_buf[4-7] reserved */
3835 #ifdef _LITTLE_ENDIAN
3836 bcopy("ATA ", &page_buf[8], 8);
3837 swab(sdinfo->satadrv_id.ai_model, &page_buf[16], 16);
3838 if (strncmp(&sdinfo->satadrv_id.ai_fw[4], " ", 4) == 0) {
3839 swab(sdinfo->satadrv_id.ai_fw, &page_buf[32], 4);
3840 } else {
3841 swab(&sdinfo->satadrv_id.ai_fw[4], &page_buf[32], 4);
3842 }
3843 #else /* _LITTLE_ENDIAN */
3844 bcopy("ATA ", &page_buf[8], 8);
3845 bcopy(sdinfo->satadrv_id.ai_model, &page_buf[16], 16);
3846 if (strncmp(&sdinfo->satadrv_id.ai_fw[4], " ", 4) == 0) {
3847 bcopy(sdinfo->satadrv_id.ai_fw, &page_buf[32], 4);
3848 } else {
3849 bcopy(&sdinfo->satadrv_id.ai_fw[4], &page_buf[32], 4);
3850 }
3851 #endif /* _LITTLE_ENDIAN */
3852 /*
3853 * page_buf[36-55] which defines the device
3854 * signature is not defined at this
3855 * time.
3856 */
3857
3858 /* Set the command code */
3859 if (sdinfo->satadrv_type == SATA_DTYPE_ATADISK) {
3860 page_buf[56] = SATAC_ID_DEVICE;
3861 } else if (sdinfo->satadrv_type == SATA_DTYPE_ATAPI) {
3862 page_buf[56] = SATAC_ID_PACKET_DEVICE;
3863 }
3864 /*
3865 * If the command code, page_buf[56], is not
3866 * zero and if one of the identify commands
3867 * succeeds, return the identify data.
3868 */
3869 if (page_buf[56] != 0) {
3870 sata_drive_info_t temp_info = {
3871 .satadrv_addr = sdinfo->satadrv_addr,
3872 .satadrv_type = sdinfo->satadrv_type,
3873 };
3874
3875 /*
3876 * It appears calls to an HBA's start (sata_hba_start)
3877 * method (which sata_fetch_device_identify_data_retry()
3878 * calls) must not be done while holding cport_mutex.
3879 *
3880 * A packet's completion routine may call back into
3881 * the sata framework and deadlock (and all extant
3882 * calls to the HBA's start method either drop and
3883 * re-acquire cport_mutex, or never held cport_mutex).
3884 *
3885 * sdinfo is protected by cport_mutex, so we need to
3886 * obtain the SATA address and type from sdinfo
3887 * before releasing cport_mutex and submitting the
3888 * request. We reacquire cport_mutex to simplfy
3889 * cleanup after the done label.
3890 */
3891 mutex_exit(cport_mutex);
3892 (void) sata_fetch_device_identify_data(
3893 spx->txlt_sata_hba_inst, &temp_info);
3894 mutex_enter(cport_mutex);
3895
3896 /*
3897 * If sata_fetch_device_identify_data()
3898 * fails, the bcopy() is harmless since we're copying
3899 * zeros back over zeros. If it succeeds, we're
3900 * copying over the portion of the response we need.
3901 */
3902 bcopy(&temp_info.satadrv_id, &page_buf[60],
3903 sizeof (sata_id_t));
3904 }
3905
3906 /* Need to copy out the page_buf to bp */
3907 count = MIN(bp->b_bcount, SATA_ID_ATA_INFO_LEN + 4);
3908 bcopy(page_buf, bp->b_un.b_addr, count);
3909 break;
3910
3911 case INQUIRY_DEV_IDENTIFICATION_PAGE:
3912 if (sdinfo->satadrv_id.ai_naa_ieee_oui != 0) {
3913 /*
3914 * Page 83; SAT-5 requires this, and modern
3915 * SATA devices all support a WWN.
3916 */
3917 page_buf[0] = peripheral_device_type;
3918 page_buf[1] = INQUIRY_DEV_IDENTIFICATION_PAGE;
3919 page_buf[2] = 0;
3920 page_buf[3] = 12; /* remaining length */
3921 page_buf[4] = 0x01; /* protocol 0, code set 1 */
3922 page_buf[5] = 0x03; /* LUN, NAA type */
3923 page_buf[6] = 0;
3924 page_buf[7] = 0x08; /* length (64-bit WWN) */
3925 #ifdef _LITTLE_ENDIAN
3926 swab(&sdinfo->satadrv_id.ai_naa_ieee_oui, &page_buf[8],
3927 8);
3928 #else
3929 bcopy(&sdinfo->satadrv_id.ai_naa_ieee_oui,
3930 &page_buf[8], 8);
3931 #endif
3932 /* header + designator */
3933 count = MIN(bp->b_bcount, 12 + 4);
3934 bcopy(page_buf, bp->b_un.b_addr, count);
3935 break;
3936 }
3937 /* FALLTHROUGH */
3938
3939 default:
3940 /* Request for unsupported VPD page */
3941 *scsipkt->pkt_scbp = STATUS_CHECK;
3942 sense = sata_arq_sense(spx);
3943 sense->es_key = KEY_ILLEGAL_REQUEST;
3944 sense->es_add_code = SD_SCSI_ASC_INVALID_FIELD_IN_CDB;
3945 goto done;
3946 }
3947
3948 scsipkt->pkt_state |= STATE_XFERRED_DATA;
3949 scsipkt->pkt_resid = scsipkt->pkt_cdbp[4] > count ?
3950 scsipkt->pkt_cdbp[4] - count : 0;
3951
3952 done:
3953 mutex_exit(cport_mutex);
3954
3955 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst,
3956 "Scsi_pkt completion reason %x\n",
3957 scsipkt->pkt_reason);
3958
3959 if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0 &&
3960 scsipkt->pkt_comp != NULL) {
3961 /* scsi callback required */
3962 if (servicing_interrupt()) {
3963 if (taskq_dispatch(SATA_TXLT_TASKQ(spx),
3964 (task_func_t *)spx->txlt_scsi_pkt->pkt_comp,
3965 (void *)spx->txlt_scsi_pkt, TQ_NOSLEEP) ==
3966 TASKQID_INVALID) {
3967 return (TRAN_BUSY);
3968 }
3969 } else if (taskq_dispatch(SATA_TXLT_TASKQ(spx),
3970 (task_func_t *)spx->txlt_scsi_pkt->pkt_comp,
3971 (void *)spx->txlt_scsi_pkt, TQ_SLEEP) == TASKQID_INVALID) {
3972 /* Scheduling the callback failed */
3973 return (TRAN_BUSY);
3974 }
3975 }
3976 return (TRAN_ACCEPT);
3977 }
3978
3979 /*
3980 * SATA translate command: Request Sense.
3981 *
3982 * Returns TRAN_ACCEPT and appropriate values in scsi_pkt fields.
3983 * At the moment this is an emulated command (ATA version for SATA hard disks).
3984 * May be translated into Check Power Mode command in the future.
3985 *
3986 * Note: There is a mismatch between already implemented Informational
3987 * Exception Mode Select page 0x1C and this function.
3988 * When MRIE bit is set in page 0x1C, Request Sense is supposed to return
3989 * NO SENSE and set additional sense code to the exception code - this is not
3990 * implemented here.
3991 */
3992 static int
sata_txlt_request_sense(sata_pkt_txlate_t * spx)3993 sata_txlt_request_sense(sata_pkt_txlate_t *spx)
3994 {
3995 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt;
3996 struct scsi_extended_sense sense;
3997 struct buf *bp = spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp;
3998 sata_drive_info_t *sdinfo;
3999 sata_cmd_t *scmd = &spx->txlt_sata_pkt->satapkt_cmd;
4000 int rval, reason, power_state = 0;
4001 kmutex_t *cport_mutex;
4002
4003 cport_mutex = &(SATA_TXLT_CPORT_MUTEX(spx));
4004 mutex_enter(cport_mutex);
4005
4006 if (((rval = sata_txlt_generic_pkt_info(spx, &reason, 1)) !=
4007 TRAN_ACCEPT) || (reason == CMD_DEV_GONE)) {
4008 mutex_exit(cport_mutex);
4009 return (rval);
4010 }
4011
4012 scsipkt->pkt_reason = CMD_CMPLT;
4013 scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET |
4014 STATE_SENT_CMD | STATE_GOT_STATUS;
4015 *scsipkt->pkt_scbp = STATUS_GOOD;
4016
4017 /*
4018 * when CONTROL field's NACA bit == 1
4019 * return ILLEGAL_REQUEST
4020 */
4021 if (scsipkt->pkt_cdbp[5] & CTL_BYTE_NACA_MASK) {
4022 mutex_exit(cport_mutex);
4023 return (sata_txlt_check_condition(spx, KEY_ILLEGAL_REQUEST,
4024 SD_SCSI_ASC_CMD_SEQUENCE_ERR));
4025 }
4026
4027 sdinfo = sata_get_device_info(spx->txlt_sata_hba_inst,
4028 &spx->txlt_sata_pkt->satapkt_device);
4029 ASSERT(sdinfo != NULL);
4030
4031 spx->txlt_sata_pkt->satapkt_op_mode |= SATA_OPMODE_SYNCH;
4032
4033 sata_build_generic_cmd(scmd, SATAC_CHECK_POWER_MODE);
4034 scmd->satacmd_flags.sata_copy_out_sec_count_lsb = B_TRUE;
4035 scmd->satacmd_flags.sata_copy_out_error_reg = B_TRUE;
4036 if (sata_hba_start(spx, &rval) != 0) {
4037 mutex_exit(cport_mutex);
4038 return (rval);
4039 }
4040 if (scmd->satacmd_error_reg != 0) {
4041 mutex_exit(cport_mutex);
4042 return (sata_txlt_check_condition(spx, KEY_NO_SENSE,
4043 SD_SCSI_ASC_NO_ADD_SENSE));
4044 }
4045
4046 switch (scmd->satacmd_sec_count_lsb) {
4047 case SATA_PWRMODE_STANDBY: /* device in standby mode */
4048 if (sdinfo->satadrv_power_level == SATA_POWER_STOPPED)
4049 power_state = SATA_POWER_STOPPED;
4050 else {
4051 power_state = SATA_POWER_STANDBY;
4052 sdinfo->satadrv_power_level = SATA_POWER_STANDBY;
4053 }
4054 break;
4055 case SATA_PWRMODE_IDLE: /* device in idle mode */
4056 power_state = SATA_POWER_IDLE;
4057 sdinfo->satadrv_power_level = SATA_POWER_IDLE;
4058 break;
4059 case SATA_PWRMODE_ACTIVE: /* device in active or idle mode */
4060 default: /* 0x40, 0x41 active mode */
4061 if (sdinfo->satadrv_power_level == SATA_POWER_IDLE)
4062 power_state = SATA_POWER_IDLE;
4063 else {
4064 power_state = SATA_POWER_ACTIVE;
4065 sdinfo->satadrv_power_level = SATA_POWER_ACTIVE;
4066 }
4067 break;
4068 }
4069
4070 mutex_exit(cport_mutex);
4071
4072 if (bp != NULL && bp->b_un.b_addr && bp->b_bcount) {
4073 /*
4074 * Because it is fully emulated command storing data
4075 * programatically in the specified buffer, release
4076 * preallocated DMA resources before storing data in the buffer,
4077 * so no unwanted DMA sync would take place.
4078 */
4079 int count = MIN(bp->b_bcount,
4080 sizeof (struct scsi_extended_sense));
4081 sata_scsi_dmafree(NULL, scsipkt);
4082 bzero(&sense, sizeof (struct scsi_extended_sense));
4083 sense.es_valid = 0; /* Valid LBA */
4084 sense.es_class = 7; /* Response code 0x70 - current err */
4085 sense.es_key = KEY_NO_SENSE;
4086 sense.es_add_len = 6; /* Additional length */
4087 /* Copy no more than requested */
4088 bcopy(&sense, bp->b_un.b_addr, count);
4089 scsipkt->pkt_state |= STATE_XFERRED_DATA;
4090 scsipkt->pkt_resid = 0;
4091 switch (power_state) {
4092 case SATA_POWER_IDLE:
4093 case SATA_POWER_STANDBY:
4094 sense.es_add_code =
4095 SD_SCSI_ASC_LOW_POWER_CONDITION_ON;
4096 break;
4097 case SATA_POWER_STOPPED:
4098 sense.es_add_code = SD_SCSI_ASC_NO_ADD_SENSE;
4099 break;
4100 case SATA_POWER_ACTIVE:
4101 default:
4102 break;
4103 }
4104 }
4105
4106 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst,
4107 "Scsi_pkt completion reason %x\n",
4108 scsipkt->pkt_reason);
4109
4110 if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0 &&
4111 scsipkt->pkt_comp != NULL) {
4112 /* scsi callback required */
4113 if (servicing_interrupt()) {
4114 if (taskq_dispatch(SATA_TXLT_TASKQ(spx),
4115 (task_func_t *)spx->txlt_scsi_pkt->pkt_comp,
4116 (void *)spx->txlt_scsi_pkt, TQ_NOSLEEP) ==
4117 TASKQID_INVALID) {
4118 return (TRAN_BUSY);
4119 }
4120 } else if (taskq_dispatch(SATA_TXLT_TASKQ(spx),
4121 (task_func_t *)spx->txlt_scsi_pkt->pkt_comp,
4122 (void *)spx->txlt_scsi_pkt, TQ_SLEEP) == TASKQID_INVALID) {
4123 /* Scheduling the callback failed */
4124 return (TRAN_BUSY);
4125 }
4126 }
4127 return (TRAN_ACCEPT);
4128 }
4129
4130 /*
4131 * SATA translate command: Test Unit Ready
4132 * (ATA version for SATA hard disks).
4133 * It is translated into the Check Power Mode command.
4134 *
4135 * Returns TRAN_ACCEPT and appropriate values in scsi_pkt fields.
4136 */
4137 static int
sata_txlt_test_unit_ready(sata_pkt_txlate_t * spx)4138 sata_txlt_test_unit_ready(sata_pkt_txlate_t *spx)
4139 {
4140 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt;
4141 struct scsi_extended_sense *sense;
4142 sata_cmd_t *scmd = &spx->txlt_sata_pkt->satapkt_cmd;
4143 sata_drive_info_t *sdinfo;
4144 int power_state;
4145 int rval, reason;
4146 kmutex_t *cport_mutex = &(SATA_TXLT_CPORT_MUTEX(spx));
4147
4148 mutex_enter(cport_mutex);
4149
4150 if (((rval = sata_txlt_generic_pkt_info(spx, &reason, 1)) !=
4151 TRAN_ACCEPT) || (reason == CMD_DEV_GONE)) {
4152 mutex_exit(cport_mutex);
4153 return (rval);
4154 }
4155
4156 sdinfo = sata_get_device_info(spx->txlt_sata_hba_inst,
4157 &spx->txlt_sata_pkt->satapkt_device);
4158 ASSERT(sdinfo != NULL);
4159
4160 spx->txlt_sata_pkt->satapkt_op_mode |= SATA_OPMODE_SYNCH;
4161
4162 /* send CHECK POWER MODE command */
4163 sata_build_generic_cmd(scmd, SATAC_CHECK_POWER_MODE);
4164 scmd->satacmd_flags.sata_copy_out_sec_count_lsb = B_TRUE;
4165 scmd->satacmd_flags.sata_copy_out_error_reg = B_TRUE;
4166 if (sata_hba_start(spx, &rval) != 0) {
4167 mutex_exit(cport_mutex);
4168 return (rval);
4169 }
4170
4171 if (scmd->satacmd_error_reg != 0) {
4172 mutex_exit(cport_mutex);
4173 return (sata_txlt_check_condition(spx, KEY_NOT_READY,
4174 SD_SCSI_ASC_LU_NOT_RESPONSE));
4175 }
4176
4177 power_state = scmd->satacmd_sec_count_lsb;
4178
4179 /*
4180 * return NOT READY when device in STOPPED mode
4181 */
4182 if (power_state == SATA_PWRMODE_STANDBY &&
4183 sdinfo->satadrv_power_level == SATA_POWER_STOPPED) {
4184 *scsipkt->pkt_scbp = STATUS_CHECK;
4185 sense = sata_arq_sense(spx);
4186 sense->es_key = KEY_NOT_READY;
4187 sense->es_add_code = SD_SCSI_ASC_LU_NOT_READY;
4188 } else {
4189 /*
4190 * For other power mode, return GOOD status
4191 */
4192 *scsipkt->pkt_scbp = STATUS_GOOD;
4193 }
4194
4195 scsipkt->pkt_reason = CMD_CMPLT;
4196 scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET |
4197 STATE_SENT_CMD | STATE_GOT_STATUS;
4198
4199 mutex_exit(cport_mutex);
4200
4201 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst,
4202 "Scsi_pkt completion reason %x\n", scsipkt->pkt_reason);
4203
4204 if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0 &&
4205 scsipkt->pkt_comp != NULL) {
4206 /* scsi callback required */
4207 if (servicing_interrupt()) {
4208 if (taskq_dispatch(SATA_TXLT_TASKQ(spx),
4209 (task_func_t *)spx->txlt_scsi_pkt->pkt_comp,
4210 (void *)spx->txlt_scsi_pkt, TQ_NOSLEEP) ==
4211 TASKQID_INVALID) {
4212 return (TRAN_BUSY);
4213 }
4214 } else if (taskq_dispatch(SATA_TXLT_TASKQ(spx),
4215 (task_func_t *)spx->txlt_scsi_pkt->pkt_comp,
4216 (void *)spx->txlt_scsi_pkt, TQ_SLEEP) == TASKQID_INVALID) {
4217 /* Scheduling the callback failed */
4218 return (TRAN_BUSY);
4219 }
4220 }
4221
4222 return (TRAN_ACCEPT);
4223 }
4224
4225 /*
4226 * SATA translate command: Start Stop Unit
4227 * Translation depends on a command:
4228 *
4229 * Power condition bits will be supported
4230 * and the power level should be maintained by SATL,
4231 * When SATL received a command, it will check the
4232 * power level firstly, and return the status according
4233 * to SAT2 v2.6 and SAT-2 Standby Modifications
4234 *
4235 * SPC-4/SBC-3 SATL ATA power condition SATL SPC/SBC
4236 * -----------------------------------------------------------------------
4237 * SSU_PC1 Active <==> ATA Active <==> SSU:start_bit =1
4238 * SSU_PC2 Idle <==> ATA Idle <==> N/A
4239 * SSU_PC3 Standby <==> ATA Standby <==> N/A
4240 * SSU_PC4 Stopped <==> ATA Standby <==> SSU:start_bit = 0
4241 *
4242 * Unload Media / NOT SUPPORTED YET
4243 * Load Media / NOT SUPPROTED YET
4244 * Immediate bit / NOT SUPPORTED YET (deferred error)
4245 *
4246 * Returns TRAN_ACCEPT or code returned by sata_hba_start() and
4247 * appropriate values in scsi_pkt fields.
4248 */
4249 static int
sata_txlt_start_stop_unit(sata_pkt_txlate_t * spx)4250 sata_txlt_start_stop_unit(sata_pkt_txlate_t *spx)
4251 {
4252 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt;
4253 sata_cmd_t *scmd = &spx->txlt_sata_pkt->satapkt_cmd;
4254 int rval, reason;
4255 sata_drive_info_t *sdinfo;
4256 sata_id_t *sata_id;
4257 kmutex_t *cport_mutex = &(SATA_TXLT_CPORT_MUTEX(spx));
4258
4259 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst,
4260 "sata_txlt_start_stop_unit: %d\n", scsipkt->pkt_scbp[4] & 1);
4261
4262 mutex_enter(cport_mutex);
4263
4264 if (((rval = sata_txlt_generic_pkt_info(spx, &reason, 1)) !=
4265 TRAN_ACCEPT) || (reason == CMD_DEV_GONE)) {
4266 mutex_exit(cport_mutex);
4267 return (rval);
4268 }
4269
4270 if (scsipkt->pkt_cdbp[1] & START_STOP_IMMED_MASK) {
4271 /* IMMED bit - not supported */
4272 mutex_exit(cport_mutex);
4273 return (sata_txlt_check_condition(spx, KEY_ILLEGAL_REQUEST,
4274 SD_SCSI_ASC_INVALID_FIELD_IN_CDB));
4275 }
4276
4277 spx->txlt_sata_pkt->satapkt_op_mode |= SATA_OPMODE_SYNCH;
4278 spx->txlt_sata_pkt->satapkt_comp = NULL;
4279
4280 sdinfo = sata_get_device_info(spx->txlt_sata_hba_inst,
4281 &spx->txlt_sata_pkt->satapkt_device);
4282 ASSERT(sdinfo != NULL);
4283 sata_id = &sdinfo->satadrv_id;
4284
4285 switch ((scsipkt->pkt_cdbp[4] & START_STOP_POWER_COND_MASK) >> 4) {
4286 case 0:
4287 if (scsipkt->pkt_cdbp[4] & START_STOP_LOEJ_MASK) {
4288 /* Load/Unload Media - invalid request */
4289 goto err_out;
4290 }
4291 if (scsipkt->pkt_cdbp[4] & START_STOP_START_MASK) {
4292 /* Start Unit */
4293 sata_build_read_verify_cmd(scmd, 1, 5);
4294 scmd->satacmd_flags.sata_copy_out_error_reg = B_TRUE;
4295 /* Transfer command to HBA */
4296 if (sata_hba_start(spx, &rval) != 0) {
4297 /* Pkt not accepted for execution */
4298 mutex_exit(cport_mutex);
4299 return (rval);
4300 }
4301 if (scmd->satacmd_error_reg != 0) {
4302 goto err_out;
4303 }
4304 sdinfo->satadrv_power_level = SATA_POWER_ACTIVE;
4305 } else {
4306 /* Stop Unit */
4307 sata_build_generic_cmd(scmd, SATAC_FLUSH_CACHE);
4308 scmd->satacmd_flags.sata_copy_out_error_reg = B_TRUE;
4309 if (sata_hba_start(spx, &rval) != 0) {
4310 mutex_exit(cport_mutex);
4311 return (rval);
4312 } else {
4313 if (scmd->satacmd_error_reg != 0) {
4314 goto err_out;
4315 }
4316 }
4317 /* ata standby immediate command */
4318 sata_build_generic_cmd(scmd, SATAC_STANDBY_IM);
4319 scmd->satacmd_flags.sata_copy_out_error_reg = B_TRUE;
4320 if (sata_hba_start(spx, &rval) != 0) {
4321 mutex_exit(cport_mutex);
4322 return (rval);
4323 }
4324 if (scmd->satacmd_error_reg != 0) {
4325 goto err_out;
4326 }
4327 sdinfo->satadrv_power_level = SATA_POWER_STOPPED;
4328 }
4329 break;
4330 case 0x1:
4331 sata_build_generic_cmd(scmd, SATAC_IDLE);
4332 scmd->satacmd_flags.sata_copy_out_error_reg = B_TRUE;
4333 if (sata_hba_start(spx, &rval) != 0) {
4334 mutex_exit(cport_mutex);
4335 return (rval);
4336 }
4337 if (scmd->satacmd_error_reg != 0) {
4338 goto err_out;
4339 }
4340 sata_build_read_verify_cmd(scmd, 1, 5);
4341 scmd->satacmd_flags.sata_copy_out_error_reg = B_TRUE;
4342 /* Transfer command to HBA */
4343 if (sata_hba_start(spx, &rval) != 0) {
4344 /* Pkt not accepted for execution */
4345 mutex_exit(cport_mutex);
4346 return (rval);
4347 } else {
4348 if (scmd->satacmd_error_reg != 0) {
4349 goto err_out;
4350 }
4351 }
4352 sdinfo->satadrv_power_level = SATA_POWER_ACTIVE;
4353 break;
4354 case 0x2:
4355 sata_build_generic_cmd(scmd, SATAC_FLUSH_CACHE);
4356 scmd->satacmd_flags.sata_copy_out_error_reg = B_TRUE;
4357 if (!(scsipkt->pkt_cdbp[4] & START_STOP_NOFLUSH_MASK)) {
4358 if (sata_hba_start(spx, &rval) != 0) {
4359 mutex_exit(cport_mutex);
4360 return (rval);
4361 }
4362 if (scmd->satacmd_error_reg != 0) {
4363 goto err_out;
4364 }
4365 }
4366 sata_build_generic_cmd(scmd, SATAC_IDLE);
4367 scmd->satacmd_flags.sata_copy_out_error_reg = B_TRUE;
4368 if (sata_hba_start(spx, &rval) != 0) {
4369 mutex_exit(cport_mutex);
4370 return (rval);
4371 }
4372 if (scmd->satacmd_error_reg != 0) {
4373 goto err_out;
4374 }
4375 if ((scsipkt->pkt_cdbp[3] & START_STOP_MODIFIER_MASK)) {
4376 /*
4377 * POWER CONDITION MODIFIER bit set
4378 * to 0x1 or larger it will be handled
4379 * on the same way as bit = 0x1
4380 */
4381 if (!(sata_id->ai_cmdset84 &
4382 SATA_IDLE_UNLOAD_SUPPORTED)) {
4383 sdinfo->satadrv_power_level = SATA_POWER_IDLE;
4384 break;
4385 }
4386 sata_build_generic_cmd(scmd, SATAC_IDLE_IM);
4387 scmd->satacmd_features_reg = 0x44;
4388 scmd->satacmd_lba_low_lsb = 0x4c;
4389 scmd->satacmd_lba_mid_lsb = 0x4e;
4390 scmd->satacmd_lba_high_lsb = 0x55;
4391 scmd->satacmd_flags.sata_copy_out_error_reg = B_TRUE;
4392 if (sata_hba_start(spx, &rval) != 0) {
4393 mutex_exit(cport_mutex);
4394 return (rval);
4395 }
4396 if (scmd->satacmd_error_reg != 0) {
4397 goto err_out;
4398 }
4399 }
4400 sdinfo->satadrv_power_level = SATA_POWER_IDLE;
4401 break;
4402 case 0x3:
4403 sata_build_generic_cmd(scmd, SATAC_FLUSH_CACHE);
4404 scmd->satacmd_flags.sata_copy_out_error_reg = B_TRUE;
4405 if (!(scsipkt->pkt_cdbp[4] & START_STOP_NOFLUSH_MASK)) {
4406 if (sata_hba_start(spx, &rval) != 0) {
4407 mutex_exit(cport_mutex);
4408 return (rval);
4409 }
4410 if (scmd->satacmd_error_reg != 0) {
4411 goto err_out;
4412 }
4413 }
4414 sata_build_generic_cmd(scmd, SATAC_STANDBY);
4415 scmd->satacmd_flags.sata_copy_out_error_reg = B_TRUE;
4416 if (sata_hba_start(spx, &rval) != 0) {
4417 mutex_exit(cport_mutex);
4418 return (rval);
4419 }
4420 if (scmd->satacmd_error_reg != 0) {
4421 goto err_out;
4422 }
4423 sdinfo->satadrv_power_level = SATA_POWER_STANDBY;
4424 break;
4425 case 0x7:
4426 sata_build_generic_cmd(scmd, SATAC_CHECK_POWER_MODE);
4427 scmd->satacmd_flags.sata_copy_out_sec_count_lsb = B_TRUE;
4428 scmd->satacmd_flags.sata_copy_out_error_reg = B_TRUE;
4429 if (sata_hba_start(spx, &rval) != 0) {
4430 mutex_exit(cport_mutex);
4431 return (rval);
4432 }
4433 if (scmd->satacmd_error_reg != 0) {
4434 goto err_out;
4435 }
4436 switch (scmd->satacmd_sec_count_lsb) {
4437 case SATA_PWRMODE_STANDBY:
4438 sata_build_generic_cmd(scmd, SATAC_STANDBY);
4439 scmd->satacmd_sec_count_msb = sata_get_standby_timer(
4440 sdinfo->satadrv_standby_timer);
4441 scmd->satacmd_flags.sata_copy_out_error_reg = B_TRUE;
4442 if (sata_hba_start(spx, &rval) != 0) {
4443 mutex_exit(cport_mutex);
4444 return (rval);
4445 } else {
4446 if (scmd->satacmd_error_reg != 0) {
4447 goto err_out;
4448 }
4449 }
4450 break;
4451 case SATA_PWRMODE_IDLE:
4452 sata_build_generic_cmd(scmd, SATAC_IDLE);
4453 scmd->satacmd_sec_count_msb = sata_get_standby_timer(
4454 sdinfo->satadrv_standby_timer);
4455 scmd->satacmd_flags.sata_copy_out_error_reg = B_TRUE;
4456 if (sata_hba_start(spx, &rval) != 0) {
4457 mutex_exit(cport_mutex);
4458 return (rval);
4459 } else {
4460 if (scmd->satacmd_error_reg != 0) {
4461 goto err_out;
4462 }
4463 }
4464 break;
4465 case SATA_PWRMODE_ACTIVE_SPINDOWN:
4466 case SATA_PWRMODE_ACTIVE_SPINUP:
4467 case SATA_PWRMODE_ACTIVE:
4468 sata_build_generic_cmd(scmd, SATAC_IDLE);
4469 scmd->satacmd_sec_count_msb = sata_get_standby_timer(
4470 sdinfo->satadrv_standby_timer);
4471 scmd->satacmd_flags.sata_copy_out_error_reg = B_TRUE;
4472 if (sata_hba_start(spx, &rval) != 0) {
4473 mutex_exit(cport_mutex);
4474 return (rval);
4475 }
4476 if (scmd->satacmd_error_reg != 0) {
4477 goto err_out;
4478 }
4479 sata_build_read_verify_cmd(scmd, 1, 5);
4480 scmd->satacmd_flags.sata_copy_out_error_reg = B_TRUE;
4481 if (sata_hba_start(spx, &rval) != 0) {
4482 mutex_exit(cport_mutex);
4483 return (rval);
4484 }
4485 if (scmd->satacmd_error_reg != 0) {
4486 goto err_out;
4487 }
4488 break;
4489 default:
4490 goto err_out;
4491 }
4492 break;
4493 case 0xb:
4494 if ((sata_get_standby_timer(sdinfo->satadrv_standby_timer) ==
4495 0) || (!(sata_id->ai_cap & SATA_STANDBYTIMER))) {
4496 mutex_exit(cport_mutex);
4497 return (sata_txlt_check_condition(spx,
4498 KEY_ILLEGAL_REQUEST,
4499 SD_SCSI_ASC_INVALID_FIELD_IN_CDB));
4500 }
4501 sata_build_generic_cmd(scmd, SATAC_FLUSH_CACHE);
4502 scmd->satacmd_flags.sata_copy_out_error_reg = B_TRUE;
4503 if (!(scsipkt->pkt_cdbp[4] & START_STOP_NOFLUSH_MASK)) {
4504 if (sata_hba_start(spx, &rval) != 0) {
4505 mutex_exit(cport_mutex);
4506 return (rval);
4507 }
4508 if (scmd->satacmd_error_reg != 0) {
4509 goto err_out;
4510 }
4511 sata_build_generic_cmd(scmd, SATAC_STANDBY_IM);
4512 scmd->satacmd_flags.sata_copy_out_error_reg = B_TRUE;
4513 if (sata_hba_start(spx, &rval) != 0) {
4514 mutex_exit(cport_mutex);
4515 return (rval);
4516 }
4517 if (scmd->satacmd_error_reg != 0) {
4518 goto err_out;
4519 }
4520 }
4521 bzero(sdinfo->satadrv_standby_timer, sizeof (uchar_t) * 4);
4522 break;
4523 default:
4524 err_out:
4525 mutex_exit(cport_mutex);
4526 return (sata_txlt_check_condition(spx, KEY_ILLEGAL_REQUEST,
4527 SD_SCSI_ASC_INVALID_FIELD_IN_CDB));
4528 }
4529
4530 /*
4531 * Since it was a synchronous command,
4532 * a callback function will be called directly.
4533 */
4534 mutex_exit(cport_mutex);
4535 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst,
4536 "synchronous execution status %x\n",
4537 spx->txlt_sata_pkt->satapkt_reason);
4538
4539 if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0 &&
4540 scsipkt->pkt_comp != NULL) {
4541 sata_set_arq_data(spx->txlt_sata_pkt);
4542 if (servicing_interrupt()) {
4543 if (taskq_dispatch(SATA_TXLT_TASKQ(spx),
4544 (task_func_t *)spx->txlt_scsi_pkt->pkt_comp,
4545 (void *)spx->txlt_scsi_pkt, TQ_NOSLEEP) ==
4546 TASKQID_INVALID) {
4547 return (TRAN_BUSY);
4548 }
4549 } else if (taskq_dispatch(SATA_TXLT_TASKQ(spx),
4550 (task_func_t *)spx->txlt_scsi_pkt->pkt_comp,
4551 (void *)spx->txlt_scsi_pkt, TQ_SLEEP) == TASKQID_INVALID) {
4552 /* Scheduling the callback failed */
4553 return (TRAN_BUSY);
4554 }
4555 }
4556 else
4557
4558 sata_txlt_nodata_cmd_completion(spx->txlt_sata_pkt);
4559
4560 return (TRAN_ACCEPT);
4561
4562 }
4563
4564 /*
4565 * SATA translate command: Read Capacity.
4566 * Emulated command for SATA disks.
4567 * Capacity is retrieved from cached Idenifty Device data.
4568 * Identify Device data shows effective disk capacity, not the native
4569 * capacity, which may be limitted by Set Max Address command.
4570 * This is ATA version for SATA hard disks.
4571 *
4572 * Returns TRAN_ACCEPT and appropriate values in scsi_pkt fields.
4573 */
4574 static int
sata_txlt_read_capacity(sata_pkt_txlate_t * spx)4575 sata_txlt_read_capacity(sata_pkt_txlate_t *spx)
4576 {
4577 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt;
4578 struct buf *bp = spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp;
4579 sata_drive_info_t *sdinfo;
4580 uint64_t val;
4581 uint32_t lbsize = DEV_BSIZE;
4582 uchar_t *rbuf;
4583 int rval, reason;
4584 kmutex_t *cport_mutex = &(SATA_TXLT_CPORT_MUTEX(spx));
4585
4586 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst,
4587 "sata_txlt_read_capacity: ", NULL);
4588
4589 mutex_enter(cport_mutex);
4590
4591 if (((rval = sata_txlt_generic_pkt_info(spx, &reason, 0)) !=
4592 TRAN_ACCEPT) || (reason == CMD_DEV_GONE)) {
4593 mutex_exit(cport_mutex);
4594 return (rval);
4595 }
4596
4597 scsipkt->pkt_reason = CMD_CMPLT;
4598 scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET |
4599 STATE_SENT_CMD | STATE_GOT_STATUS;
4600 *scsipkt->pkt_scbp = STATUS_GOOD;
4601 if (bp != NULL && bp->b_un.b_addr && bp->b_bcount) {
4602 /*
4603 * Because it is fully emulated command storing data
4604 * programatically in the specified buffer, release
4605 * preallocated DMA resources before storing data in the buffer,
4606 * so no unwanted DMA sync would take place.
4607 */
4608 sata_scsi_dmafree(NULL, scsipkt);
4609
4610 sdinfo = sata_get_device_info(
4611 spx->txlt_sata_hba_inst,
4612 &spx->txlt_sata_pkt->satapkt_device);
4613
4614 /*
4615 * As per SBC-3, the "returned LBA" is either the highest
4616 * addressable LBA or 0xffffffff, whichever is smaller.
4617 */
4618 val = MIN(sdinfo->satadrv_capacity - 1, UINT32_MAX);
4619
4620 if (sdinfo->satadrv_id.ai_phys_sect_sz & SATA_L2PS_CHECK_BIT) {
4621 /* physical/logical sector size word is valid */
4622
4623 if (sdinfo->satadrv_id.ai_phys_sect_sz &
4624 SATA_L2PS_BIG_SECTORS) {
4625 /* if this set 117-118 words are valid */
4626 lbsize = sdinfo->satadrv_id.ai_words_lsec[0] |
4627 (sdinfo->satadrv_id.ai_words_lsec[1] << 16);
4628 lbsize <<= 1; /* convert from words to bytes */
4629 }
4630 }
4631 rbuf = (uchar_t *)bp->b_un.b_addr;
4632 /* Need to swap endians to match scsi format */
4633 rbuf[0] = (val >> 24) & 0xff;
4634 rbuf[1] = (val >> 16) & 0xff;
4635 rbuf[2] = (val >> 8) & 0xff;
4636 rbuf[3] = val & 0xff;
4637 rbuf[4] = (lbsize >> 24) & 0xff;
4638 rbuf[5] = (lbsize >> 16) & 0xff;
4639 rbuf[6] = (lbsize >> 8) & 0xff;
4640 rbuf[7] = lbsize & 0xff;
4641
4642 scsipkt->pkt_state |= STATE_XFERRED_DATA;
4643 scsipkt->pkt_resid = 0;
4644
4645 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst, "%d\n",
4646 sdinfo->satadrv_capacity -1);
4647 }
4648 mutex_exit(cport_mutex);
4649 /*
4650 * If a callback was requested, do it now.
4651 */
4652 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst,
4653 "Scsi_pkt completion reason %x\n", scsipkt->pkt_reason);
4654
4655 if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0 &&
4656 scsipkt->pkt_comp != NULL) {
4657 /* scsi callback required */
4658 if (servicing_interrupt()) {
4659 if (taskq_dispatch(SATA_TXLT_TASKQ(spx),
4660 (task_func_t *)spx->txlt_scsi_pkt->pkt_comp,
4661 (void *)spx->txlt_scsi_pkt, TQ_NOSLEEP) ==
4662 TASKQID_INVALID) {
4663 return (TRAN_BUSY);
4664 }
4665 } else if (taskq_dispatch(SATA_TXLT_TASKQ(spx),
4666 (task_func_t *)spx->txlt_scsi_pkt->pkt_comp,
4667 (void *)spx->txlt_scsi_pkt, TQ_SLEEP) == TASKQID_INVALID) {
4668 /* Scheduling the callback failed */
4669 return (TRAN_BUSY);
4670 }
4671 }
4672
4673 return (TRAN_ACCEPT);
4674 }
4675
4676 /*
4677 * SATA translate command: Read Capacity (16).
4678 * Emulated command for SATA disks.
4679 * Info is retrieved from cached Identify Device data.
4680 * Implemented to SBC-3 (draft 21) and SAT-2 (final) specifications.
4681 *
4682 * Returns TRAN_ACCEPT and appropriate values in scsi_pkt fields.
4683 */
4684 static int
sata_txlt_read_capacity16(sata_pkt_txlate_t * spx)4685 sata_txlt_read_capacity16(sata_pkt_txlate_t *spx)
4686 {
4687 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt;
4688 struct buf *bp = spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp;
4689 sata_drive_info_t *sdinfo;
4690 uint64_t val;
4691 uint16_t l2p_exp;
4692 uint32_t lbsize = DEV_BSIZE;
4693 uchar_t *rbuf;
4694 int rval, reason;
4695 #define TPE 0x80
4696 #define TPRZ 0x40
4697 kmutex_t *cport_mutex = &(SATA_TXLT_CPORT_MUTEX(spx));
4698
4699 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst,
4700 "sata_txlt_read_capacity: ", NULL);
4701
4702 mutex_enter(cport_mutex);
4703
4704 if (((rval = sata_txlt_generic_pkt_info(spx, &reason, 0)) !=
4705 TRAN_ACCEPT) || (reason == CMD_DEV_GONE)) {
4706 mutex_exit(cport_mutex);
4707 return (rval);
4708 }
4709
4710 scsipkt->pkt_reason = CMD_CMPLT;
4711 scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET |
4712 STATE_SENT_CMD | STATE_GOT_STATUS;
4713 if (bp != NULL && bp->b_un.b_addr && bp->b_bcount) {
4714 /*
4715 * Because it is fully emulated command storing data
4716 * programatically in the specified buffer, release
4717 * preallocated DMA resources before storing data in the buffer,
4718 * so no unwanted DMA sync would take place.
4719 */
4720 sata_scsi_dmafree(NULL, scsipkt);
4721
4722 /* Check SERVICE ACTION field */
4723 if ((scsipkt->pkt_cdbp[1] & 0x1f) !=
4724 SSVC_ACTION_READ_CAPACITY_G4) {
4725 mutex_exit(cport_mutex);
4726 return (sata_txlt_check_condition(spx,
4727 KEY_ILLEGAL_REQUEST,
4728 SD_SCSI_ASC_INVALID_FIELD_IN_CDB));
4729 }
4730
4731 /* Check LBA field */
4732 if ((scsipkt->pkt_cdbp[2] != 0) ||
4733 (scsipkt->pkt_cdbp[3] != 0) ||
4734 (scsipkt->pkt_cdbp[4] != 0) ||
4735 (scsipkt->pkt_cdbp[5] != 0) ||
4736 (scsipkt->pkt_cdbp[6] != 0) ||
4737 (scsipkt->pkt_cdbp[7] != 0) ||
4738 (scsipkt->pkt_cdbp[8] != 0) ||
4739 (scsipkt->pkt_cdbp[9] != 0)) {
4740 mutex_exit(cport_mutex);
4741 return (sata_txlt_check_condition(spx,
4742 KEY_ILLEGAL_REQUEST,
4743 SD_SCSI_ASC_INVALID_FIELD_IN_CDB));
4744 }
4745
4746 /* Check PMI bit */
4747 if (scsipkt->pkt_cdbp[14] & 0x1) {
4748 mutex_exit(cport_mutex);
4749 return (sata_txlt_check_condition(spx,
4750 KEY_ILLEGAL_REQUEST,
4751 SD_SCSI_ASC_INVALID_FIELD_IN_CDB));
4752 }
4753
4754 *scsipkt->pkt_scbp = STATUS_GOOD;
4755
4756 sdinfo = sata_get_device_info(
4757 spx->txlt_sata_hba_inst,
4758 &spx->txlt_sata_pkt->satapkt_device);
4759
4760 /* last logical block address */
4761 val = MIN(sdinfo->satadrv_capacity - 1,
4762 SCSI_READ_CAPACITY16_MAX_LBA);
4763
4764 /* logical to physical block size exponent */
4765 l2p_exp = 0;
4766 if (sdinfo->satadrv_id.ai_phys_sect_sz & SATA_L2PS_CHECK_BIT) {
4767 /* physical/logical sector size word is valid */
4768
4769 if (sdinfo->satadrv_id.ai_phys_sect_sz &
4770 SATA_L2PS_HAS_MULT) {
4771 /* multiple logical sectors per phys sectors */
4772 l2p_exp =
4773 sdinfo->satadrv_id.ai_phys_sect_sz &
4774 SATA_L2PS_EXP_MASK;
4775 }
4776
4777 if (sdinfo->satadrv_id.ai_phys_sect_sz &
4778 SATA_L2PS_BIG_SECTORS) {
4779 /* if this set 117-118 words are valid */
4780 lbsize = sdinfo->satadrv_id.ai_words_lsec[0] |
4781 (sdinfo->satadrv_id.ai_words_lsec[1] << 16);
4782 lbsize <<= 1; /* convert from words to bytes */
4783 }
4784 }
4785
4786 rbuf = (uchar_t *)bp->b_un.b_addr;
4787 bzero(rbuf, bp->b_bcount);
4788
4789 /* returned logical block address */
4790 rbuf[0] = (val >> 56) & 0xff;
4791 rbuf[1] = (val >> 48) & 0xff;
4792 rbuf[2] = (val >> 40) & 0xff;
4793 rbuf[3] = (val >> 32) & 0xff;
4794 rbuf[4] = (val >> 24) & 0xff;
4795 rbuf[5] = (val >> 16) & 0xff;
4796 rbuf[6] = (val >> 8) & 0xff;
4797 rbuf[7] = val & 0xff;
4798 rbuf[8] = (lbsize >> 24) & 0xff;
4799 rbuf[9] = (lbsize >> 16) & 0xff;
4800 rbuf[10] = (lbsize >> 8) & 0xff;
4801 rbuf[11] = lbsize & 0xff;
4802
4803 /* p_type, prot_en, unspecified by SAT-2 */
4804 /* rbuf[12] = 0; */
4805
4806 /* p_i_exponent, undefined by SAT-2 */
4807 /* logical blocks per physical block exponent */
4808 rbuf[13] = l2p_exp;
4809
4810 /*
4811 * tpe and tprz as defined in T10/10-079 r0.
4812 * TRIM support is indicated by the relevant bit in the data
4813 * set management word. Read-after-trim behavior is indicated
4814 * by the additional bits in the identify device word. Of the
4815 * three defined possibilities, we only flag read-zero.
4816 */
4817 if (sdinfo->satadrv_id.ai_dsm & SATA_DSM_TRIM) {
4818 rbuf[14] |= TPE;
4819
4820 if ((sdinfo->satadrv_id.ai_addsupported &
4821 SATA_DETERMINISTIC_READ) &&
4822 (sdinfo->satadrv_id.ai_addsupported &
4823 SATA_READ_ZERO)) {
4824 rbuf[14] |= TPRZ;
4825 }
4826 }
4827
4828 /* lowest aligned logical block address = 0 (for now) */
4829 /* rbuf[15] = 0; */
4830
4831 scsipkt->pkt_state |= STATE_XFERRED_DATA;
4832 scsipkt->pkt_resid = 0;
4833
4834 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst, "%llu\n",
4835 sdinfo->satadrv_capacity -1);
4836 }
4837
4838 mutex_exit(cport_mutex);
4839
4840 /*
4841 * If a callback was requested, do it now.
4842 */
4843 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst,
4844 "Scsi_pkt completion reason %x\n", scsipkt->pkt_reason);
4845
4846 if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0 &&
4847 scsipkt->pkt_comp != NULL) {
4848 /* scsi callback required */
4849 if (servicing_interrupt()) {
4850 if (taskq_dispatch(SATA_TXLT_TASKQ(spx),
4851 (task_func_t *)spx->txlt_scsi_pkt->pkt_comp,
4852 (void *)spx->txlt_scsi_pkt, TQ_NOSLEEP) ==
4853 TASKQID_INVALID) {
4854 return (TRAN_BUSY);
4855 }
4856 } else if (taskq_dispatch(SATA_TXLT_TASKQ(spx),
4857 (task_func_t *)spx->txlt_scsi_pkt->pkt_comp,
4858 (void *)spx->txlt_scsi_pkt, TQ_SLEEP) == TASKQID_INVALID) {
4859 /* Scheduling the callback failed */
4860 return (TRAN_BUSY);
4861 }
4862 }
4863
4864 return (TRAN_ACCEPT);
4865 }
4866
4867 /*
4868 * Translate command: UNMAP
4869 *
4870 * The function cannot be called in interrupt context since it may sleep.
4871 */
4872 static int
sata_txlt_unmap(sata_pkt_txlate_t * spx)4873 sata_txlt_unmap(sata_pkt_txlate_t *spx)
4874 {
4875 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt;
4876 sata_cmd_t *scmd = &spx->txlt_sata_pkt->satapkt_cmd;
4877 struct buf *bp = spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp;
4878 uint16_t count = 0;
4879 int synch;
4880 int rval, reason;
4881 int i, x;
4882 int bdlen = 0;
4883 int ranges = 0;
4884 int paramlen = 8;
4885 uint8_t *data, *tmpbd;
4886 sata_drive_info_t *sdinfo;
4887 kmutex_t *cport_mutex = &(SATA_TXLT_CPORT_MUTEX(spx));
4888 #define TRIM 0x1
4889
4890 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst,
4891 "sata_txlt_unmap: ", NULL);
4892
4893 mutex_enter(cport_mutex);
4894
4895 sdinfo = sata_get_device_info(spx->txlt_sata_hba_inst,
4896 &spx->txlt_sata_pkt->satapkt_device);
4897 if (sdinfo != NULL) {
4898 SATADBG2(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst,
4899 "DSM support 0x%x, max number of 512 byte blocks of LBA "
4900 "range entries 0x%x\n", sdinfo->satadrv_id.ai_dsm,
4901 sdinfo->satadrv_id.ai_maxcount);
4902 }
4903
4904 rval = sata_txlt_generic_pkt_info(spx, &reason, 1);
4905 if ((rval != TRAN_ACCEPT) || (reason == CMD_DEV_GONE)) {
4906 mutex_exit(cport_mutex);
4907 return (rval);
4908 }
4909
4910 /*
4911 * Need to modify bp to have TRIM data instead of UNMAP data.
4912 * Start by getting the block descriptor data length by subtracting
4913 * the 8 byte parameter list header from the parameter list length.
4914 * The block descriptor size has to be a multiple of 16 bytes.
4915 */
4916 bdlen = scsipkt->pkt_cdbp[7];
4917 bdlen = (bdlen << 8) + scsipkt->pkt_cdbp[8] - paramlen;
4918 if ((bdlen < 0) || ((bdlen % 16) != 0) ||
4919 ((bp != NULL) && (bdlen > (bp->b_bcount - paramlen)))) {
4920 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst,
4921 "sata_txlt_unmap: invalid block descriptor length", NULL);
4922 mutex_exit(cport_mutex);
4923 return ((sata_txlt_check_condition(spx, KEY_ILLEGAL_REQUEST,
4924 SD_SCSI_ASC_INVALID_FIELD_IN_CDB)));
4925 }
4926 /*
4927 * If there are no parameter data or block descriptors, it is not
4928 * considered an error so just complete the command without sending
4929 * TRIM.
4930 */
4931 if ((bdlen == 0) || (bp == NULL) || (bp->b_un.b_addr == NULL) ||
4932 (bp->b_bcount == 0)) {
4933 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst,
4934 "sata_txlt_unmap: no parameter data or block descriptors",
4935 NULL);
4936 mutex_exit(cport_mutex);
4937 return (sata_txlt_unmap_nodata_cmd(spx));
4938 }
4939 tmpbd = (uint8_t *)bp->b_un.b_addr + paramlen;
4940 data = kmem_zalloc(bdlen, KM_SLEEP);
4941
4942 /*
4943 * Loop through all the UNMAP block descriptors and convert the data
4944 * into TRIM format.
4945 */
4946 for (i = 0, x = 0; i < bdlen; i += 16, x += 8) {
4947 /* get range length */
4948 data[x] = tmpbd[i+7];
4949 data[x+1] = tmpbd[i+6];
4950 /* get LBA */
4951 data[x+2] = tmpbd[i+5];
4952 data[x+3] = tmpbd[i+4];
4953 data[x+4] = tmpbd[i+3];
4954 data[x+5] = tmpbd[i+2];
4955 data[x+6] = tmpbd[i+11];
4956 data[x+7] = tmpbd[i+10];
4957
4958 ranges++;
4959 }
4960
4961 /*
4962 * The TRIM command expects the data buffer to be a multiple of
4963 * 512-byte blocks of range entries. This means that the UNMAP buffer
4964 * may be too small. Free the original DMA resources and create a
4965 * local buffer.
4966 */
4967 sata_common_free_dma_rsrcs(spx);
4968
4969 /*
4970 * Get count of 512-byte blocks of range entries. The length
4971 * of a range entry is 8 bytes which means one count has 64 range
4972 * entries.
4973 */
4974 count = (ranges + 63)/64;
4975
4976 /* Allocate a buffer that is a multiple of 512 bytes. */
4977 mutex_exit(cport_mutex);
4978 bp = sata_alloc_local_buffer(spx, count * 512);
4979 if (bp == NULL) {
4980 SATADBG1(SATA_DBG_ATAPI, spx->txlt_sata_hba_inst,
4981 "sata_txlt_unmap: "
4982 "cannot allocate buffer for TRIM command", NULL);
4983 kmem_free(data, bdlen);
4984 return (TRAN_BUSY);
4985 }
4986 bp_mapin(bp); /* make data buffer accessible */
4987 mutex_enter(cport_mutex);
4988
4989 bzero(bp->b_un.b_addr, bp->b_bcount);
4990 bcopy(data, bp->b_un.b_addr, x);
4991 kmem_free(data, bdlen);
4992 rval = ddi_dma_sync(spx->txlt_buf_dma_handle, 0, 0,
4993 DDI_DMA_SYNC_FORDEV);
4994 ASSERT(rval == DDI_SUCCESS);
4995
4996 scmd->satacmd_flags.sata_data_direction = SATA_DIR_WRITE;
4997 scmd->satacmd_addr_type = ATA_ADDR_LBA48;
4998 scmd->satacmd_cmd_reg = SATAC_DSM;
4999 scmd->satacmd_sec_count_msb = (count >> 8) & 0xff;
5000 scmd->satacmd_sec_count_lsb = count & 0xff;
5001 scmd->satacmd_features_reg = TRIM;
5002 scmd->satacmd_device_reg = SATA_ADH_LBA;
5003 scmd->satacmd_status_reg = 0;
5004 scmd->satacmd_error_reg = 0;
5005
5006 /* Start processing command */
5007 if (!(spx->txlt_sata_pkt->satapkt_op_mode & SATA_OPMODE_SYNCH)) {
5008 spx->txlt_sata_pkt->satapkt_comp =
5009 sata_txlt_unmap_completion;
5010 synch = FALSE;
5011 } else {
5012 synch = TRUE;
5013 }
5014
5015 if (sata_hba_start(spx, &rval) != 0) {
5016 mutex_exit(cport_mutex);
5017 return (rval);
5018 }
5019
5020 mutex_exit(cport_mutex);
5021
5022 if (synch) {
5023 sata_txlt_unmap_completion(spx->txlt_sata_pkt);
5024 }
5025
5026 return (TRAN_ACCEPT);
5027 }
5028
5029 /*
5030 * SATA translate command: Mode Sense.
5031 * Translated into appropriate SATA command or emulated.
5032 * Saved Values Page Control (03) are not supported.
5033 *
5034 * NOTE: only caching mode sense page is currently implemented.
5035 *
5036 * Returns TRAN_ACCEPT and appropriate values in scsi_pkt fields.
5037 */
5038
5039 #define LLBAA 0x10 /* Long LBA Accepted */
5040
5041 static int
sata_txlt_mode_sense(sata_pkt_txlate_t * spx)5042 sata_txlt_mode_sense(sata_pkt_txlate_t *spx)
5043 {
5044 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt;
5045 struct buf *bp = spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp;
5046 sata_drive_info_t *sdinfo;
5047 sata_id_t *sata_id;
5048 struct scsi_extended_sense *sense;
5049 int len, bdlen, count, alc_len;
5050 int pc; /* Page Control code */
5051 uint8_t *buf; /* mode sense buffer */
5052 int rval, reason;
5053 kmutex_t *cport_mutex = &(SATA_TXLT_CPORT_MUTEX(spx));
5054
5055 SATADBG2(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst,
5056 "sata_txlt_mode_sense, pc %x page code 0x%02x\n",
5057 spx->txlt_scsi_pkt->pkt_cdbp[2] >> 6,
5058 spx->txlt_scsi_pkt->pkt_cdbp[2] & 0x3f);
5059
5060 if (servicing_interrupt()) {
5061 buf = kmem_zalloc(1024, KM_NOSLEEP);
5062 if (buf == NULL) {
5063 return (TRAN_BUSY);
5064 }
5065 } else {
5066 buf = kmem_zalloc(1024, KM_SLEEP);
5067 }
5068
5069 mutex_enter(cport_mutex);
5070
5071 if (((rval = sata_txlt_generic_pkt_info(spx, &reason, 0)) !=
5072 TRAN_ACCEPT) || (reason == CMD_DEV_GONE)) {
5073 mutex_exit(cport_mutex);
5074 kmem_free(buf, 1024);
5075 return (rval);
5076 }
5077
5078 scsipkt->pkt_reason = CMD_CMPLT;
5079 scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET |
5080 STATE_SENT_CMD | STATE_GOT_STATUS;
5081
5082 pc = scsipkt->pkt_cdbp[2] >> 6;
5083
5084 if (bp != NULL && bp->b_un.b_addr && bp->b_bcount) {
5085 /*
5086 * Because it is fully emulated command storing data
5087 * programatically in the specified buffer, release
5088 * preallocated DMA resources before storing data in the buffer,
5089 * so no unwanted DMA sync would take place.
5090 */
5091 sata_scsi_dmafree(NULL, scsipkt);
5092
5093 len = 0;
5094 bdlen = 0;
5095 if (!(scsipkt->pkt_cdbp[1] & 8)) {
5096 if (scsipkt->pkt_cdbp[0] == SCMD_MODE_SENSE_G1 &&
5097 (scsipkt->pkt_cdbp[1] & LLBAA))
5098 bdlen = 16;
5099 else
5100 bdlen = 8;
5101 }
5102 /* Build mode parameter header */
5103 if (spx->txlt_scsi_pkt->pkt_cdbp[0] == SCMD_MODE_SENSE) {
5104 /* 4-byte mode parameter header */
5105 buf[len++] = 0; /* mode data length */
5106 buf[len++] = 0; /* medium type */
5107 buf[len++] = 0; /* dev-specific param */
5108 buf[len++] = bdlen; /* Block Descriptor length */
5109 } else {
5110 /* 8-byte mode parameter header */
5111 buf[len++] = 0; /* mode data length */
5112 buf[len++] = 0;
5113 buf[len++] = 0; /* medium type */
5114 buf[len++] = 0; /* dev-specific param */
5115 if (bdlen == 16)
5116 buf[len++] = 1; /* long lba descriptor */
5117 else
5118 buf[len++] = 0;
5119 buf[len++] = 0;
5120 buf[len++] = 0; /* Block Descriptor length */
5121 buf[len++] = bdlen;
5122 }
5123
5124 sdinfo = sata_get_device_info(
5125 spx->txlt_sata_hba_inst,
5126 &spx->txlt_sata_pkt->satapkt_device);
5127
5128 /* Build block descriptor only if not disabled (DBD) */
5129 if ((scsipkt->pkt_cdbp[1] & 0x08) == 0) {
5130 /* Block descriptor - direct-access device format */
5131 if (bdlen == 8) {
5132 /* build regular block descriptor */
5133 buf[len++] =
5134 (sdinfo->satadrv_capacity >> 24) & 0xff;
5135 buf[len++] =
5136 (sdinfo->satadrv_capacity >> 16) & 0xff;
5137 buf[len++] =
5138 (sdinfo->satadrv_capacity >> 8) & 0xff;
5139 buf[len++] = sdinfo->satadrv_capacity & 0xff;
5140 buf[len++] = 0; /* density code */
5141 buf[len++] = 0;
5142 if (sdinfo->satadrv_type ==
5143 SATA_DTYPE_ATADISK)
5144 buf[len++] = 2;
5145 else
5146 /* ATAPI */
5147 buf[len++] = 8;
5148 buf[len++] = 0;
5149 } else if (bdlen == 16) {
5150 /* Long LBA Accepted */
5151 /* build long lba block descriptor */
5152 #ifndef __lock_lint
5153 buf[len++] =
5154 (sdinfo->satadrv_capacity >> 56) & 0xff;
5155 buf[len++] =
5156 (sdinfo->satadrv_capacity >> 48) & 0xff;
5157 buf[len++] =
5158 (sdinfo->satadrv_capacity >> 40) & 0xff;
5159 buf[len++] =
5160 (sdinfo->satadrv_capacity >> 32) & 0xff;
5161 #endif
5162 buf[len++] =
5163 (sdinfo->satadrv_capacity >> 24) & 0xff;
5164 buf[len++] =
5165 (sdinfo->satadrv_capacity >> 16) & 0xff;
5166 buf[len++] =
5167 (sdinfo->satadrv_capacity >> 8) & 0xff;
5168 buf[len++] = sdinfo->satadrv_capacity & 0xff;
5169 buf[len++] = 0;
5170 buf[len++] = 0; /* density code */
5171 buf[len++] = 0;
5172 buf[len++] = 0;
5173 if (sdinfo->satadrv_type ==
5174 SATA_DTYPE_ATADISK)
5175 buf[len++] = 2;
5176 else
5177 /* ATAPI */
5178 buf[len++] = 8;
5179 buf[len++] = 0;
5180 }
5181 }
5182
5183 sata_id = &sdinfo->satadrv_id;
5184
5185 /*
5186 * Add requested pages.
5187 * Page 3 and 4 are obsolete and we are not supporting them.
5188 * We deal now with:
5189 * caching (read/write cache control).
5190 * We should eventually deal with following mode pages:
5191 * error recovery (0x01),
5192 * power condition (0x1a),
5193 * exception control page (enables SMART) (0x1c),
5194 * enclosure management (ses),
5195 * protocol-specific port mode (port control).
5196 */
5197 switch (scsipkt->pkt_cdbp[2] & 0x3f) {
5198 case MODEPAGE_RW_ERRRECOV:
5199 /* DAD_MODE_ERR_RECOV */
5200 /* R/W recovery */
5201 len += sata_build_msense_page_1(sdinfo, pc, buf+len);
5202 break;
5203 case MODEPAGE_CACHING:
5204 /* DAD_MODE_CACHE */
5205 /* Reject not supported request for saved parameters */
5206 if (pc == 3) {
5207 *scsipkt->pkt_scbp = STATUS_CHECK;
5208 sense = sata_arq_sense(spx);
5209 sense->es_key = KEY_ILLEGAL_REQUEST;
5210 sense->es_add_code =
5211 SD_SCSI_ASC_SAVING_PARAMS_NOT_SUPPORTED;
5212 goto done;
5213 }
5214
5215 /* caching */
5216 len += sata_build_msense_page_8(sdinfo, pc, buf+len);
5217 break;
5218 case MODEPAGE_INFO_EXCPT:
5219 /* exception cntrl */
5220 if (sata_id->ai_cmdset82 & SATA_SMART_SUPPORTED) {
5221 len += sata_build_msense_page_1c(sdinfo, pc,
5222 buf+len);
5223 }
5224 else
5225 goto err;
5226 break;
5227 case MODEPAGE_POWER_COND:
5228 /* DAD_MODE_POWER_COND */
5229 /* power condition */
5230 len += sata_build_msense_page_1a(sdinfo, pc, buf+len);
5231 break;
5232
5233 case MODEPAGE_ACOUSTIC_MANAG:
5234 /* acoustic management */
5235 len += sata_build_msense_page_30(sdinfo, pc, buf+len);
5236 break;
5237 case MODEPAGE_ALLPAGES:
5238 /* all pages */
5239 len += sata_build_msense_page_1(sdinfo, pc, buf+len);
5240 len += sata_build_msense_page_8(sdinfo, pc, buf+len);
5241 len += sata_build_msense_page_1a(sdinfo, pc, buf+len);
5242 if (sata_id->ai_cmdset82 & SATA_SMART_SUPPORTED) {
5243 len += sata_build_msense_page_1c(sdinfo, pc,
5244 buf+len);
5245 }
5246 len += sata_build_msense_page_30(sdinfo, pc, buf+len);
5247 break;
5248 default:
5249 err:
5250 /* Invalid request */
5251 *scsipkt->pkt_scbp = STATUS_CHECK;
5252 sense = sata_arq_sense(spx);
5253 sense->es_key = KEY_ILLEGAL_REQUEST;
5254 sense->es_add_code = SD_SCSI_ASC_INVALID_FIELD_IN_CDB;
5255 goto done;
5256 }
5257
5258 /* fix total mode data length */
5259 if (spx->txlt_scsi_pkt->pkt_cdbp[0] == SCMD_MODE_SENSE) {
5260 /* 4-byte mode parameter header */
5261 buf[0] = len - 1; /* mode data length */
5262 } else {
5263 buf[0] = (len -2) >> 8;
5264 buf[1] = (len -2) & 0xff;
5265 }
5266
5267
5268 /* Check allocation length */
5269 if (scsipkt->pkt_cdbp[0] == SCMD_MODE_SENSE) {
5270 alc_len = scsipkt->pkt_cdbp[4];
5271 } else {
5272 alc_len = scsipkt->pkt_cdbp[7];
5273 alc_len = (alc_len << 8) | scsipkt->pkt_cdbp[8];
5274 }
5275 /*
5276 * We do not check for possible parameters truncation
5277 * (alc_len < len) assuming that the target driver works
5278 * correctly. Just avoiding overrun.
5279 * Copy no more than requested and possible, buffer-wise.
5280 */
5281 count = MIN(alc_len, len);
5282 count = MIN(bp->b_bcount, count);
5283 bcopy(buf, bp->b_un.b_addr, count);
5284
5285 scsipkt->pkt_state |= STATE_XFERRED_DATA;
5286 scsipkt->pkt_resid = alc_len > count ? alc_len - count : 0;
5287 }
5288 *scsipkt->pkt_scbp = STATUS_GOOD;
5289 done:
5290 mutex_exit(cport_mutex);
5291 (void) kmem_free(buf, 1024);
5292
5293 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst,
5294 "Scsi_pkt completion reason %x\n", scsipkt->pkt_reason);
5295
5296 if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0 &&
5297 scsipkt->pkt_comp != NULL) {
5298 /* scsi callback required */
5299 if (servicing_interrupt()) {
5300 if (taskq_dispatch(SATA_TXLT_TASKQ(spx),
5301 (task_func_t *)spx->txlt_scsi_pkt->pkt_comp,
5302 (void *)spx->txlt_scsi_pkt, TQ_NOSLEEP) ==
5303 TASKQID_INVALID) {
5304 return (TRAN_BUSY);
5305 }
5306 } else if (taskq_dispatch(SATA_TXLT_TASKQ(spx),
5307 (task_func_t *)spx->txlt_scsi_pkt->pkt_comp,
5308 (void *)spx->txlt_scsi_pkt, TQ_SLEEP) == TASKQID_INVALID) {
5309 /* Scheduling the callback failed */
5310 return (TRAN_BUSY);
5311 }
5312 }
5313
5314 return (TRAN_ACCEPT);
5315 }
5316
5317
5318 /*
5319 * SATA translate command: Mode Select.
5320 * Translated into appropriate SATA command or emulated.
5321 * Saving parameters is not supported.
5322 * Changing device capacity is not supported (although theoretically
5323 * possible by executing SET FEATURES/SET MAX ADDRESS)
5324 *
5325 * Assumption is that the target driver is working correctly.
5326 *
5327 * More than one SATA command may be executed to perform operations specified
5328 * by mode select pages. The first error terminates further execution.
5329 * Operations performed successully are not backed-up in such case.
5330 *
5331 * NOTE: Implemented pages:
5332 * - caching page
5333 * - informational exception page
5334 * - acoustic management page
5335 * - power condition page
5336 * Caching setup is remembered so it could be re-stored in case of
5337 * an unexpected device reset.
5338 *
5339 * Returns TRAN_XXXX.
5340 * If TRAN_ACCEPT is returned, appropriate values are set in scsi_pkt fields.
5341 */
5342
5343 static int
sata_txlt_mode_select(sata_pkt_txlate_t * spx)5344 sata_txlt_mode_select(sata_pkt_txlate_t *spx)
5345 {
5346 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt;
5347 struct buf *bp = spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp;
5348 struct scsi_extended_sense *sense;
5349 int len, pagelen, count, pllen;
5350 uint8_t *buf; /* mode select buffer */
5351 int rval, stat, reason;
5352 uint_t nointr_flag;
5353 int dmod = 0;
5354 kmutex_t *cport_mutex = &(SATA_TXLT_CPORT_MUTEX(spx));
5355
5356 SATADBG2(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst,
5357 "sata_txlt_mode_select, pc %x page code 0x%02x\n",
5358 spx->txlt_scsi_pkt->pkt_cdbp[2] >> 6,
5359 spx->txlt_scsi_pkt->pkt_cdbp[2] & 0x3f);
5360
5361 mutex_enter(cport_mutex);
5362
5363 if (((rval = sata_txlt_generic_pkt_info(spx, &reason, 1)) !=
5364 TRAN_ACCEPT) || (reason == CMD_DEV_GONE)) {
5365 mutex_exit(cport_mutex);
5366 return (rval);
5367 }
5368
5369 rval = TRAN_ACCEPT;
5370
5371 scsipkt->pkt_reason = CMD_CMPLT;
5372 scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET |
5373 STATE_SENT_CMD | STATE_GOT_STATUS;
5374 nointr_flag = scsipkt->pkt_flags & FLAG_NOINTR;
5375
5376 /* Reject not supported request */
5377 if (! (scsipkt->pkt_cdbp[1] & 0x10)) { /* No support for PF bit = 0 */
5378 *scsipkt->pkt_scbp = STATUS_CHECK;
5379 sense = sata_arq_sense(spx);
5380 sense->es_key = KEY_ILLEGAL_REQUEST;
5381 sense->es_add_code = SD_SCSI_ASC_INVALID_FIELD_IN_CDB;
5382 goto done;
5383 }
5384
5385 if (scsipkt->pkt_cdbp[0] == SCMD_MODE_SELECT) {
5386 pllen = scsipkt->pkt_cdbp[4];
5387 } else {
5388 pllen = scsipkt->pkt_cdbp[7];
5389 pllen = (pllen << 8) | scsipkt->pkt_cdbp[7];
5390 }
5391
5392 *scsipkt->pkt_scbp = STATUS_GOOD; /* Presumed outcome */
5393
5394 if (bp != NULL && bp->b_un.b_addr && bp->b_bcount && pllen != 0) {
5395 buf = (uint8_t *)bp->b_un.b_addr;
5396 count = MIN(bp->b_bcount, pllen);
5397 scsipkt->pkt_state |= STATE_XFERRED_DATA;
5398 scsipkt->pkt_resid = 0;
5399 pllen = count;
5400
5401 /*
5402 * Check the header to skip the block descriptor(s) - we
5403 * do not support setting device capacity.
5404 * Existing macros do not recognize long LBA dscriptor,
5405 * hence manual calculation.
5406 */
5407 if (scsipkt->pkt_cdbp[0] == SCMD_MODE_SELECT) {
5408 /* 6-bytes CMD, 4 bytes header */
5409 if (count <= 4)
5410 goto done; /* header only */
5411 len = buf[3] + 4;
5412 } else {
5413 /* 10-bytes CMD, 8 bytes header */
5414 if (count <= 8)
5415 goto done; /* header only */
5416 len = buf[6];
5417 len = (len << 8) + buf[7] + 8;
5418 }
5419 if (len >= count)
5420 goto done; /* header + descriptor(s) only */
5421
5422 pllen -= len; /* remaining data length */
5423
5424 /*
5425 * We may be executing SATA command and want to execute it
5426 * in SYNCH mode, regardless of scsi_pkt setting.
5427 * Save scsi_pkt setting and indicate SYNCH mode
5428 */
5429 if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0 &&
5430 scsipkt->pkt_comp != NULL) {
5431 scsipkt->pkt_flags |= FLAG_NOINTR;
5432 }
5433 spx->txlt_sata_pkt->satapkt_op_mode = SATA_OPMODE_SYNCH;
5434
5435 /*
5436 * len is now the offset to a first mode select page
5437 * Process all pages
5438 */
5439 while (pllen > 0) {
5440 switch ((int)buf[len]) {
5441 case MODEPAGE_CACHING:
5442 /* No support for SP (saving) */
5443 if (scsipkt->pkt_cdbp[1] & 0x01) {
5444 *scsipkt->pkt_scbp = STATUS_CHECK;
5445 sense = sata_arq_sense(spx);
5446 sense->es_key = KEY_ILLEGAL_REQUEST;
5447 sense->es_add_code =
5448 SD_SCSI_ASC_INVALID_FIELD_IN_CDB;
5449 goto done;
5450 }
5451 stat = sata_mode_select_page_8(spx,
5452 (struct mode_cache_scsi3 *)&buf[len],
5453 pllen, &pagelen, &rval, &dmod);
5454 /*
5455 * The pagelen value indicates the number of
5456 * parameter bytes already processed.
5457 * The rval is the return value from
5458 * sata_tran_start().
5459 * The stat indicates the overall status of
5460 * the operation(s).
5461 */
5462 if (stat != SATA_SUCCESS)
5463 /*
5464 * Page processing did not succeed -
5465 * all error info is already set-up,
5466 * just return
5467 */
5468 pllen = 0; /* this breaks the loop */
5469 else {
5470 len += pagelen;
5471 pllen -= pagelen;
5472 }
5473 break;
5474
5475 case MODEPAGE_INFO_EXCPT:
5476 stat = sata_mode_select_page_1c(spx,
5477 (struct mode_info_excpt_page *)&buf[len],
5478 pllen, &pagelen, &rval, &dmod);
5479 /*
5480 * The pagelen value indicates the number of
5481 * parameter bytes already processed.
5482 * The rval is the return value from
5483 * sata_tran_start().
5484 * The stat indicates the overall status of
5485 * the operation(s).
5486 */
5487 if (stat != SATA_SUCCESS)
5488 /*
5489 * Page processing did not succeed -
5490 * all error info is already set-up,
5491 * just return
5492 */
5493 pllen = 0; /* this breaks the loop */
5494 else {
5495 len += pagelen;
5496 pllen -= pagelen;
5497 }
5498 break;
5499
5500 case MODEPAGE_ACOUSTIC_MANAG:
5501 stat = sata_mode_select_page_30(spx,
5502 (struct mode_acoustic_management *)
5503 &buf[len], pllen, &pagelen, &rval, &dmod);
5504 /*
5505 * The pagelen value indicates the number of
5506 * parameter bytes already processed.
5507 * The rval is the return value from
5508 * sata_tran_start().
5509 * The stat indicates the overall status of
5510 * the operation(s).
5511 */
5512 if (stat != SATA_SUCCESS)
5513 /*
5514 * Page processing did not succeed -
5515 * all error info is already set-up,
5516 * just return
5517 */
5518 pllen = 0; /* this breaks the loop */
5519 else {
5520 len += pagelen;
5521 pllen -= pagelen;
5522 }
5523
5524 break;
5525 case MODEPAGE_POWER_COND:
5526 stat = sata_mode_select_page_1a(spx,
5527 (struct mode_info_power_cond *)&buf[len],
5528 pllen, &pagelen, &rval, &dmod);
5529 /*
5530 * The pagelen value indicates the number of
5531 * parameter bytes already processed.
5532 * The rval is the return value from
5533 * sata_tran_start().
5534 * The stat indicates the overall status of
5535 * the operation(s).
5536 */
5537 if (stat != SATA_SUCCESS)
5538 /*
5539 * Page processing did not succeed -
5540 * all error info is already set-up,
5541 * just return
5542 */
5543 pllen = 0; /* this breaks the loop */
5544 else {
5545 len += pagelen;
5546 pllen -= pagelen;
5547 }
5548 break;
5549 default:
5550 *scsipkt->pkt_scbp = STATUS_CHECK;
5551 sense = sata_arq_sense(spx);
5552 sense->es_key = KEY_ILLEGAL_REQUEST;
5553 sense->es_add_code =
5554 SD_SCSI_ASC_INVALID_FIELD_IN_PARAMS_LIST;
5555 goto done;
5556 }
5557 }
5558 }
5559 done:
5560 mutex_exit(cport_mutex);
5561 /*
5562 * If device parameters were modified, fetch and store the new
5563 * Identify Device data. Since port mutex could have been released
5564 * for accessing HBA driver, we need to re-check device existence.
5565 */
5566 if (dmod != 0) {
5567 sata_drive_info_t new_sdinfo, *sdinfo;
5568 int rv = 0;
5569
5570 /*
5571 * Following statement has to be changed if this function is
5572 * used for devices other than SATA hard disks.
5573 */
5574 new_sdinfo.satadrv_type = SATA_DTYPE_ATADISK;
5575
5576 new_sdinfo.satadrv_addr =
5577 spx->txlt_sata_pkt->satapkt_device.satadev_addr;
5578 rv = sata_fetch_device_identify_data(spx->txlt_sata_hba_inst,
5579 &new_sdinfo);
5580
5581 mutex_enter(cport_mutex);
5582 /*
5583 * Since port mutex could have been released when
5584 * accessing HBA driver, we need to re-check that the
5585 * framework still holds the device info structure.
5586 */
5587 sdinfo = sata_get_device_info(spx->txlt_sata_hba_inst,
5588 &spx->txlt_sata_pkt->satapkt_device);
5589 if (sdinfo != NULL) {
5590 /*
5591 * Device still has info structure in the
5592 * sata framework. Copy newly fetched info
5593 */
5594 if (rv == 0) {
5595 sdinfo->satadrv_id = new_sdinfo.satadrv_id;
5596 sata_save_drive_settings(sdinfo);
5597 } else {
5598 /*
5599 * Could not fetch new data - invalidate
5600 * sata_drive_info. That makes device
5601 * unusable.
5602 */
5603 sdinfo->satadrv_type = SATA_DTYPE_UNKNOWN;
5604 sdinfo->satadrv_state = SATA_STATE_UNKNOWN;
5605 }
5606 }
5607 if (rv != 0 || sdinfo == NULL) {
5608 /*
5609 * This changes the overall mode select completion
5610 * reason to a failed one !!!!!
5611 */
5612 *scsipkt->pkt_scbp = STATUS_CHECK;
5613 sense = sata_arq_sense(spx);
5614 scsipkt->pkt_reason = CMD_INCOMPLETE;
5615 rval = TRAN_ACCEPT;
5616 }
5617 mutex_exit(cport_mutex);
5618 }
5619 /* Restore the scsi pkt flags */
5620 scsipkt->pkt_flags &= ~FLAG_NOINTR;
5621 scsipkt->pkt_flags |= nointr_flag;
5622
5623 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst,
5624 "Scsi_pkt completion reason %x\n", scsipkt->pkt_reason);
5625
5626 if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0 &&
5627 scsipkt->pkt_comp != NULL) {
5628 /* scsi callback required */
5629 if (servicing_interrupt()) {
5630 if (taskq_dispatch(SATA_TXLT_TASKQ(spx),
5631 (task_func_t *)spx->txlt_scsi_pkt->pkt_comp,
5632 (void *)spx->txlt_scsi_pkt, TQ_NOSLEEP) ==
5633 TASKQID_INVALID) {
5634 return (TRAN_BUSY);
5635 }
5636 } else if (taskq_dispatch(SATA_TXLT_TASKQ(spx),
5637 (task_func_t *)spx->txlt_scsi_pkt->pkt_comp,
5638 (void *)spx->txlt_scsi_pkt, TQ_SLEEP) == TASKQID_INVALID) {
5639 /* Scheduling the callback failed */
5640 return (TRAN_BUSY);
5641 }
5642 }
5643
5644 return (rval);
5645 }
5646
5647 /*
5648 * Translate command: ATA Pass Through
5649 * Incomplete implementation. Only supports No-Data, PIO Data-In, and
5650 * PIO Data-Out protocols. Also supports CK_COND bit.
5651 *
5652 * Mapping of the incoming CDB bytes to the outgoing satacmd bytes is
5653 * described in Table 111 of SAT-2 (Draft 9).
5654 */
5655 static int
sata_txlt_ata_pass_thru(sata_pkt_txlate_t * spx)5656 sata_txlt_ata_pass_thru(sata_pkt_txlate_t *spx)
5657 {
5658 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt;
5659 sata_cmd_t *scmd = &spx->txlt_sata_pkt->satapkt_cmd;
5660 struct buf *bp = spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp;
5661 kmutex_t *cport_mutex = &(SATA_TXLT_CPORT_MUTEX(spx));
5662 uint32_t xfer_len;
5663 int extend = 0;
5664 int synch, rval, reason;
5665
5666 mutex_enter(cport_mutex);
5667
5668 rval = sata_txlt_generic_pkt_info(spx, &reason, 1);
5669 if ((rval != TRAN_ACCEPT) || (reason == CMD_DEV_GONE)) {
5670 mutex_exit(cport_mutex);
5671 return (rval);
5672 }
5673
5674 /* T_DIR bit */
5675 if (scsipkt->pkt_cdbp[2] & SATL_APT_BM_T_DIR)
5676 scmd->satacmd_flags.sata_data_direction = SATA_DIR_READ;
5677 else
5678 scmd->satacmd_flags.sata_data_direction = SATA_DIR_WRITE;
5679
5680 /* MULTIPLE_COUNT field. If non-zero, invalid command (for now). */
5681 if (((scsipkt->pkt_cdbp[1] >> 5) & 0x7) != 0) {
5682 mutex_exit(cport_mutex);
5683 return (sata_txlt_ata_pass_thru_illegal_cmd(spx));
5684 }
5685
5686 /* OFFLINE field. If non-zero, invalid command (for now). */
5687 if (((scsipkt->pkt_cdbp[2] >> 6) & 0x3) != 0) {
5688 mutex_exit(cport_mutex);
5689 return (sata_txlt_ata_pass_thru_illegal_cmd(spx));
5690 }
5691
5692 /* PROTOCOL field */
5693 switch ((scsipkt->pkt_cdbp[1] >> 1) & 0xf) {
5694 case SATL_APT_P_HW_RESET:
5695 case SATL_APT_P_SRST:
5696 case SATL_APT_P_DMA:
5697 case SATL_APT_P_DMA_QUEUED:
5698 case SATL_APT_P_DEV_DIAG:
5699 case SATL_APT_P_DEV_RESET:
5700 case SATL_APT_P_UDMA_IN:
5701 case SATL_APT_P_UDMA_OUT:
5702 case SATL_APT_P_FPDMA:
5703 case SATL_APT_P_RET_RESP:
5704 /* Not yet implemented */
5705 default:
5706 mutex_exit(cport_mutex);
5707 return (sata_txlt_ata_pass_thru_illegal_cmd(spx));
5708
5709 case SATL_APT_P_NON_DATA:
5710 scmd->satacmd_flags.sata_data_direction = SATA_DIR_NODATA_XFER;
5711 break;
5712
5713 case SATL_APT_P_PIO_DATA_IN:
5714 /* If PROTOCOL disagrees with T_DIR, invalid command */
5715 if (scmd->satacmd_flags.sata_data_direction == SATA_DIR_WRITE) {
5716 mutex_exit(cport_mutex);
5717 return (sata_txlt_ata_pass_thru_illegal_cmd(spx));
5718 }
5719
5720 /* if there is a buffer, release its DMA resources */
5721 if ((bp != NULL) && bp->b_un.b_addr && bp->b_bcount) {
5722 sata_scsi_dmafree(NULL, scsipkt);
5723 } else {
5724 /* if there is no buffer, how do you PIO in? */
5725 mutex_exit(cport_mutex);
5726 return (sata_txlt_ata_pass_thru_illegal_cmd(spx));
5727 }
5728
5729 break;
5730
5731 case SATL_APT_P_PIO_DATA_OUT:
5732 /* If PROTOCOL disagrees with T_DIR, invalid command */
5733 if (scmd->satacmd_flags.sata_data_direction == SATA_DIR_READ) {
5734 mutex_exit(cport_mutex);
5735 return (sata_txlt_ata_pass_thru_illegal_cmd(spx));
5736 }
5737
5738 /* if there is a buffer, release its DMA resources */
5739 if ((bp != NULL) && bp->b_un.b_addr && bp->b_bcount) {
5740 sata_scsi_dmafree(NULL, scsipkt);
5741 } else {
5742 /* if there is no buffer, how do you PIO out? */
5743 mutex_exit(cport_mutex);
5744 return (sata_txlt_ata_pass_thru_illegal_cmd(spx));
5745 }
5746
5747 break;
5748 }
5749
5750 /* Assume LBA28 by default */
5751 scmd->satacmd_addr_type = ATA_ADDR_LBA28;
5752 scmd->satacmd_lba_low_msb = 0;
5753 scmd->satacmd_lba_mid_msb = 0;
5754 scmd->satacmd_lba_high_msb = 0;
5755
5756 scmd->satacmd_features_reg_ext = 0;
5757 scmd->satacmd_sec_count_msb = 0;
5758
5759 /* Parse the ATA cmd fields, transfer some straight to the satacmd */
5760 switch ((uint_t)scsipkt->pkt_cdbp[0]) {
5761 case SPC3_CMD_ATA_COMMAND_PASS_THROUGH12:
5762 scmd->satacmd_lba_low_lsb = scsipkt->pkt_cdbp[5];
5763 scmd->satacmd_lba_mid_lsb = scsipkt->pkt_cdbp[6];
5764 scmd->satacmd_lba_high_lsb = scsipkt->pkt_cdbp[7];
5765
5766 scmd->satacmd_features_reg = scsipkt->pkt_cdbp[3];
5767 scmd->satacmd_sec_count_lsb = scsipkt->pkt_cdbp[4];
5768
5769 scmd->satacmd_device_reg = scsipkt->pkt_cdbp[8];
5770 scmd->satacmd_cmd_reg = scsipkt->pkt_cdbp[9];
5771 break;
5772
5773 case SPC3_CMD_ATA_COMMAND_PASS_THROUGH16:
5774 scmd->satacmd_device_reg = scsipkt->pkt_cdbp[13];
5775 scmd->satacmd_cmd_reg = scsipkt->pkt_cdbp[14];
5776
5777 scmd->satacmd_lba_low_lsb = scsipkt->pkt_cdbp[8];
5778 scmd->satacmd_lba_mid_lsb = scsipkt->pkt_cdbp[10];
5779 scmd->satacmd_lba_high_lsb = scsipkt->pkt_cdbp[12];
5780
5781 scmd->satacmd_features_reg = scsipkt->pkt_cdbp[4];
5782 scmd->satacmd_sec_count_lsb = scsipkt->pkt_cdbp[6];
5783
5784 if (scsipkt->pkt_cdbp[1] & SATL_APT_BM_EXTEND) {
5785 extend = 1;
5786
5787 scmd->satacmd_addr_type = ATA_ADDR_LBA48;
5788 scmd->satacmd_lba_low_msb = scsipkt->pkt_cdbp[7];
5789 scmd->satacmd_lba_mid_msb = scsipkt->pkt_cdbp[9];
5790 scmd->satacmd_lba_high_msb = scsipkt->pkt_cdbp[11];
5791
5792 scmd->satacmd_features_reg_ext = scsipkt->pkt_cdbp[3];
5793 scmd->satacmd_sec_count_msb = scsipkt->pkt_cdbp[5];
5794 }
5795 break;
5796
5797 default:
5798 /* No other SCSI ops should ever reach this function */
5799 cmn_err(CE_PANIC, "unexpected ATA pass-thru cmd %x",
5800 scsipkt->pkt_cdbp[0]);
5801 }
5802
5803 /* CK_COND bit */
5804 if (scsipkt->pkt_cdbp[2] & SATL_APT_BM_CK_COND) {
5805 if (extend) {
5806 scmd->satacmd_flags.sata_copy_out_sec_count_msb = 1;
5807 scmd->satacmd_flags.sata_copy_out_lba_low_msb = 1;
5808 scmd->satacmd_flags.sata_copy_out_lba_mid_msb = 1;
5809 scmd->satacmd_flags.sata_copy_out_lba_high_msb = 1;
5810 }
5811
5812 scmd->satacmd_flags.sata_copy_out_sec_count_lsb = 1;
5813 scmd->satacmd_flags.sata_copy_out_lba_low_lsb = 1;
5814 scmd->satacmd_flags.sata_copy_out_lba_mid_lsb = 1;
5815 scmd->satacmd_flags.sata_copy_out_lba_high_lsb = 1;
5816 scmd->satacmd_flags.sata_copy_out_device_reg = 1;
5817 scmd->satacmd_flags.sata_copy_out_error_reg = 1;
5818 }
5819
5820 /* Determine transfer length */
5821 switch (scsipkt->pkt_cdbp[2] & 0x03) { /* T_LENGTH field */
5822 case 1:
5823 /* Length is in the FEATURE field */
5824 xfer_len = (uint32_t)scmd->satacmd_features_reg_ext << 8 |
5825 scmd->satacmd_features_reg;
5826
5827 /* If BYTE_BLOCK is set, above value is in units of blocks */
5828 if (((scsipkt->pkt_cdbp[2] >> 2) & 1) == 0)
5829 xfer_len *= SATA_DISK_SECTOR_SIZE;
5830 break;
5831 case 2:
5832 /* Length is in the COUNT field */
5833 xfer_len = (uint32_t)scmd->satacmd_sec_count_msb << 8 |
5834 scmd->satacmd_sec_count_lsb;
5835
5836 /* If BYTE_BLOCK is set, above value is in units of blocks */
5837 if (((scsipkt->pkt_cdbp[2] >> 2) & 1) == 0)
5838 xfer_len *= SATA_DISK_SECTOR_SIZE;
5839 break;
5840 case 3:
5841 /*
5842 * Length is transport specific. The spec is a bit vague on
5843 * this, but it seems like using buf->b_bcount is the most
5844 * reasonable analogue in our situation. b_bcount is in
5845 * units of bytes.
5846 */
5847 xfer_len = bp->b_bcount;
5848 break;
5849 default:
5850 xfer_len = 0;
5851 }
5852
5853 /* Don't allow a transfer larger than what the struct buf supports */
5854 if (xfer_len > bp->b_bcount) {
5855 mutex_exit(cport_mutex);
5856 return (sata_txlt_ata_pass_thru_illegal_cmd(spx));
5857 }
5858
5859 /* Start processing command */
5860 if (!(spx->txlt_sata_pkt->satapkt_op_mode & SATA_OPMODE_SYNCH)) {
5861 spx->txlt_sata_pkt->satapkt_comp = sata_txlt_apt_completion;
5862 synch = FALSE;
5863 } else {
5864 synch = TRUE;
5865 }
5866
5867 if (sata_hba_start(spx, &rval) != 0) {
5868 mutex_exit(cport_mutex);
5869 return (rval);
5870 }
5871
5872 mutex_exit(cport_mutex);
5873
5874 if (synch) {
5875 sata_txlt_apt_completion(spx->txlt_sata_pkt);
5876 }
5877
5878 return (TRAN_ACCEPT);
5879 }
5880
5881 /*
5882 * Translate command: Log Sense
5883 */
5884 static int
sata_txlt_log_sense(sata_pkt_txlate_t * spx)5885 sata_txlt_log_sense(sata_pkt_txlate_t *spx)
5886 {
5887 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt;
5888 struct buf *bp = spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp;
5889 sata_drive_info_t *sdinfo;
5890 struct scsi_extended_sense *sense;
5891 int len, count, alc_len;
5892 int pc; /* Page Control code */
5893 int page_code; /* Page code */
5894 uint8_t *buf; /* log sense buffer */
5895 int rval, reason;
5896 #define MAX_LOG_SENSE_PAGE_SIZE 512
5897 kmutex_t *cport_mutex = &(SATA_TXLT_CPORT_MUTEX(spx));
5898
5899 SATADBG2(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst,
5900 "sata_txlt_log_sense, pc 0x%x, page code 0x%x\n",
5901 spx->txlt_scsi_pkt->pkt_cdbp[2] >> 6,
5902 spx->txlt_scsi_pkt->pkt_cdbp[2] & 0x3f);
5903
5904 if (servicing_interrupt()) {
5905 buf = kmem_zalloc(MAX_LOG_SENSE_PAGE_SIZE, KM_NOSLEEP);
5906 if (buf == NULL) {
5907 return (TRAN_BUSY);
5908 }
5909 } else {
5910 buf = kmem_zalloc(MAX_LOG_SENSE_PAGE_SIZE, KM_SLEEP);
5911 }
5912
5913 mutex_enter(cport_mutex);
5914
5915 if (((rval = sata_txlt_generic_pkt_info(spx, &reason, 1)) !=
5916 TRAN_ACCEPT) || (reason == CMD_DEV_GONE)) {
5917 mutex_exit(cport_mutex);
5918 kmem_free(buf, MAX_LOG_SENSE_PAGE_SIZE);
5919 return (rval);
5920 }
5921
5922 scsipkt->pkt_reason = CMD_CMPLT;
5923 scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET |
5924 STATE_SENT_CMD | STATE_GOT_STATUS;
5925
5926 pc = scsipkt->pkt_cdbp[2] >> 6;
5927 page_code = scsipkt->pkt_cdbp[2] & 0x3f;
5928
5929 /* Reject not supported request for all but cumulative values */
5930 switch (pc) {
5931 case PC_CUMULATIVE_VALUES:
5932 break;
5933 default:
5934 *scsipkt->pkt_scbp = STATUS_CHECK;
5935 sense = sata_arq_sense(spx);
5936 sense->es_key = KEY_ILLEGAL_REQUEST;
5937 sense->es_add_code = SD_SCSI_ASC_INVALID_FIELD_IN_CDB;
5938 goto done;
5939 }
5940
5941 switch (page_code) {
5942 case PAGE_CODE_GET_SUPPORTED_LOG_PAGES:
5943 case PAGE_CODE_SELF_TEST_RESULTS:
5944 case PAGE_CODE_INFORMATION_EXCEPTIONS:
5945 case PAGE_CODE_SMART_READ_DATA:
5946 case PAGE_CODE_START_STOP_CYCLE_COUNTER:
5947 break;
5948 default:
5949 *scsipkt->pkt_scbp = STATUS_CHECK;
5950 sense = sata_arq_sense(spx);
5951 sense->es_key = KEY_ILLEGAL_REQUEST;
5952 sense->es_add_code = SD_SCSI_ASC_INVALID_FIELD_IN_CDB;
5953 goto done;
5954 }
5955
5956 if (bp != NULL && bp->b_un.b_addr && bp->b_bcount) {
5957 /*
5958 * Because log sense uses local buffers for data retrieval from
5959 * the devices and sets the data programatically in the
5960 * original specified buffer, release preallocated DMA
5961 * resources before storing data in the original buffer,
5962 * so no unwanted DMA sync would take place.
5963 */
5964 sata_id_t *sata_id;
5965
5966 sata_scsi_dmafree(NULL, scsipkt);
5967
5968 len = 0;
5969
5970 /* Build log parameter header */
5971 buf[len++] = page_code; /* page code as in the CDB */
5972 buf[len++] = 0; /* reserved */
5973 buf[len++] = 0; /* Zero out page length for now (MSB) */
5974 buf[len++] = 0; /* (LSB) */
5975
5976 sdinfo = sata_get_device_info(
5977 spx->txlt_sata_hba_inst,
5978 &spx->txlt_sata_pkt->satapkt_device);
5979
5980 /*
5981 * Add requested pages.
5982 */
5983 switch (page_code) {
5984 case PAGE_CODE_GET_SUPPORTED_LOG_PAGES:
5985 len = sata_build_lsense_page_0(sdinfo, buf + len);
5986 break;
5987 case PAGE_CODE_SELF_TEST_RESULTS:
5988 sata_id = &sdinfo->satadrv_id;
5989 if ((! (sata_id->ai_cmdset84 &
5990 SATA_SMART_SELF_TEST_SUPPORTED)) ||
5991 (! (sata_id->ai_features87 &
5992 SATA_SMART_SELF_TEST_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 len = sata_build_lsense_page_10(sdinfo, buf + len,
6002 spx->txlt_sata_hba_inst);
6003 break;
6004 case PAGE_CODE_INFORMATION_EXCEPTIONS:
6005 sata_id = &sdinfo->satadrv_id;
6006 if (! (sata_id->ai_cmdset82 & SATA_SMART_SUPPORTED)) {
6007 *scsipkt->pkt_scbp = STATUS_CHECK;
6008 sense = sata_arq_sense(spx);
6009 sense->es_key = KEY_ILLEGAL_REQUEST;
6010 sense->es_add_code =
6011 SD_SCSI_ASC_INVALID_FIELD_IN_CDB;
6012
6013 goto done;
6014 }
6015 if (! (sata_id->ai_features85 & SATA_SMART_ENABLED)) {
6016 *scsipkt->pkt_scbp = STATUS_CHECK;
6017 sense = sata_arq_sense(spx);
6018 sense->es_key = KEY_ABORTED_COMMAND;
6019 sense->es_add_code =
6020 SCSI_ASC_ATA_DEV_FEAT_NOT_ENABLED;
6021 sense->es_qual_code =
6022 SCSI_ASCQ_ATA_DEV_FEAT_NOT_ENABLED;
6023
6024 goto done;
6025 }
6026
6027 len = sata_build_lsense_page_2f(sdinfo, buf + len,
6028 spx->txlt_sata_hba_inst);
6029 break;
6030 case PAGE_CODE_SMART_READ_DATA:
6031 sata_id = &sdinfo->satadrv_id;
6032 if (! (sata_id->ai_cmdset82 & SATA_SMART_SUPPORTED)) {
6033 *scsipkt->pkt_scbp = STATUS_CHECK;
6034 sense = sata_arq_sense(spx);
6035 sense->es_key = KEY_ILLEGAL_REQUEST;
6036 sense->es_add_code =
6037 SD_SCSI_ASC_INVALID_FIELD_IN_CDB;
6038
6039 goto done;
6040 }
6041 if (! (sata_id->ai_features85 & SATA_SMART_ENABLED)) {
6042 *scsipkt->pkt_scbp = STATUS_CHECK;
6043 sense = sata_arq_sense(spx);
6044 sense->es_key = KEY_ABORTED_COMMAND;
6045 sense->es_add_code =
6046 SCSI_ASC_ATA_DEV_FEAT_NOT_ENABLED;
6047 sense->es_qual_code =
6048 SCSI_ASCQ_ATA_DEV_FEAT_NOT_ENABLED;
6049
6050 goto done;
6051 }
6052
6053 /* This page doesn't include a page header */
6054 len = sata_build_lsense_page_30(sdinfo, buf,
6055 spx->txlt_sata_hba_inst);
6056 goto no_header;
6057 case PAGE_CODE_START_STOP_CYCLE_COUNTER:
6058 sata_id = &sdinfo->satadrv_id;
6059 if (! (sata_id->ai_cmdset82 & SATA_SMART_SUPPORTED)) {
6060 *scsipkt->pkt_scbp = STATUS_CHECK;
6061 sense = sata_arq_sense(spx);
6062 sense->es_key = KEY_ILLEGAL_REQUEST;
6063 sense->es_add_code =
6064 SD_SCSI_ASC_INVALID_FIELD_IN_CDB;
6065
6066 goto done;
6067 }
6068 if (! (sata_id->ai_features85 & SATA_SMART_ENABLED)) {
6069 *scsipkt->pkt_scbp = STATUS_CHECK;
6070 sense = sata_arq_sense(spx);
6071 sense->es_key = KEY_ABORTED_COMMAND;
6072 sense->es_add_code =
6073 SCSI_ASC_ATA_DEV_FEAT_NOT_ENABLED;
6074 sense->es_qual_code =
6075 SCSI_ASCQ_ATA_DEV_FEAT_NOT_ENABLED;
6076
6077 goto done;
6078 }
6079 len = sata_build_lsense_page_0e(sdinfo, buf, spx);
6080 goto no_header;
6081 default:
6082 /* Invalid request */
6083 *scsipkt->pkt_scbp = STATUS_CHECK;
6084 sense = sata_arq_sense(spx);
6085 sense->es_key = KEY_ILLEGAL_REQUEST;
6086 sense->es_add_code = SD_SCSI_ASC_INVALID_FIELD_IN_CDB;
6087 goto done;
6088 }
6089
6090 /* set parameter log sense data length */
6091 buf[2] = len >> 8; /* log sense length (MSB) */
6092 buf[3] = len & 0xff; /* log sense length (LSB) */
6093
6094 len += SCSI_LOG_PAGE_HDR_LEN;
6095 ASSERT(len <= MAX_LOG_SENSE_PAGE_SIZE);
6096
6097 no_header:
6098 /* Check allocation length */
6099 alc_len = scsipkt->pkt_cdbp[7];
6100 alc_len = (alc_len << 8) | scsipkt->pkt_cdbp[8];
6101
6102 /*
6103 * We do not check for possible parameters truncation
6104 * (alc_len < len) assuming that the target driver works
6105 * correctly. Just avoiding overrun.
6106 * Copy no more than requested and possible, buffer-wise.
6107 */
6108 count = MIN(alc_len, len);
6109 count = MIN(bp->b_bcount, count);
6110 bcopy(buf, bp->b_un.b_addr, count);
6111
6112 scsipkt->pkt_state |= STATE_XFERRED_DATA;
6113 scsipkt->pkt_resid = alc_len > count ? alc_len - count : 0;
6114 }
6115 *scsipkt->pkt_scbp = STATUS_GOOD;
6116 done:
6117 mutex_exit(cport_mutex);
6118 (void) kmem_free(buf, MAX_LOG_SENSE_PAGE_SIZE);
6119
6120 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst,
6121 "Scsi_pkt completion reason %x\n", scsipkt->pkt_reason);
6122
6123 if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0 &&
6124 scsipkt->pkt_comp != NULL) {
6125 /* scsi callback required */
6126 if (servicing_interrupt()) {
6127 if (taskq_dispatch(SATA_TXLT_TASKQ(spx),
6128 (task_func_t *)spx->txlt_scsi_pkt->pkt_comp,
6129 (void *)spx->txlt_scsi_pkt, TQ_NOSLEEP) ==
6130 TASKQID_INVALID) {
6131 return (TRAN_BUSY);
6132 }
6133 } else if (taskq_dispatch(SATA_TXLT_TASKQ(spx),
6134 (task_func_t *)spx->txlt_scsi_pkt->pkt_comp,
6135 (void *)spx->txlt_scsi_pkt, TQ_SLEEP) == TASKQID_INVALID) {
6136 /* Scheduling the callback failed */
6137 return (TRAN_BUSY);
6138 }
6139 }
6140
6141 return (TRAN_ACCEPT);
6142 }
6143
6144 /*
6145 * Translate command: Log Select
6146 * Not implemented at this time - returns invalid command response.
6147 */
6148 static int
sata_txlt_log_select(sata_pkt_txlate_t * spx)6149 sata_txlt_log_select(sata_pkt_txlate_t *spx)
6150 {
6151 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst,
6152 "sata_txlt_log_select\n", NULL);
6153
6154 return (sata_txlt_invalid_command(spx));
6155 }
6156
6157
6158 /*
6159 * Translate command: Read (various types).
6160 * Translated into appropriate type of ATA READ command
6161 * for SATA hard disks.
6162 * Both the device capabilities and requested operation mode are
6163 * considered.
6164 *
6165 * Following scsi cdb fields are ignored:
6166 * rdprotect, dpo, fua, fua_nv, group_number.
6167 *
6168 * If SATA_ENABLE_QUEUING flag is set (in the global SATA HBA framework
6169 * enable variable sata_func_enable), the capability of the controller and
6170 * capability of a device are checked and if both support queueing, read
6171 * request will be translated to READ_DMA_QUEUEING or READ_DMA_QUEUEING_EXT
6172 * command rather than plain READ_XXX command.
6173 * If SATA_ENABLE_NCQ flag is set in addition to SATA_ENABLE_QUEUING flag and
6174 * both the controller and device suport such functionality, the read
6175 * request will be translated to READ_FPDMA_QUEUED command.
6176 * In both cases the maximum queue depth is derived as minimum of:
6177 * HBA capability,device capability and sata_max_queue_depth variable setting.
6178 * The value passed to HBA driver is decremented by 1, because only 5 bits are
6179 * used to pass max queue depth value, and the maximum possible queue depth
6180 * is 32.
6181 *
6182 * Returns TRAN_ACCEPT or code returned by sata_hba_start() and
6183 * appropriate values in scsi_pkt fields.
6184 */
6185 static int
sata_txlt_read(sata_pkt_txlate_t * spx)6186 sata_txlt_read(sata_pkt_txlate_t *spx)
6187 {
6188 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt;
6189 sata_cmd_t *scmd = &spx->txlt_sata_pkt->satapkt_cmd;
6190 sata_drive_info_t *sdinfo;
6191 sata_hba_inst_t *shi = SATA_TXLT_HBA_INST(spx);
6192 kmutex_t *cport_mutex = &(SATA_TXLT_CPORT_MUTEX(spx));
6193 uint16_t sec_count;
6194 uint64_t lba;
6195 int rval, reason;
6196 int synch;
6197
6198 mutex_enter(cport_mutex);
6199
6200 if (((rval = sata_txlt_generic_pkt_info(spx, &reason, 0)) !=
6201 TRAN_ACCEPT) || (reason == CMD_DEV_GONE)) {
6202 mutex_exit(cport_mutex);
6203 return (rval);
6204 }
6205
6206 sdinfo = sata_get_device_info(spx->txlt_sata_hba_inst,
6207 &spx->txlt_sata_pkt->satapkt_device);
6208
6209 scmd->satacmd_flags.sata_data_direction = SATA_DIR_READ;
6210 /*
6211 * Extract LBA and sector count from scsi CDB.
6212 */
6213 switch ((uint_t)scsipkt->pkt_cdbp[0]) {
6214 case SCMD_READ:
6215 /* 6-byte scsi read cmd : 0x08 */
6216 lba = (scsipkt->pkt_cdbp[1] & 0x1f);
6217 lba = (lba << 8) | scsipkt->pkt_cdbp[2];
6218 lba = (lba << 8) | scsipkt->pkt_cdbp[3];
6219 sec_count = scsipkt->pkt_cdbp[4];
6220 /* sec_count 0 will be interpreted as 256 by a device */
6221 break;
6222 case SCMD_READ_G1:
6223 /* 10-bytes scsi read command : 0x28 */
6224 lba = scsipkt->pkt_cdbp[2];
6225 lba = (lba << 8) | scsipkt->pkt_cdbp[3];
6226 lba = (lba << 8) | scsipkt->pkt_cdbp[4];
6227 lba = (lba << 8) | scsipkt->pkt_cdbp[5];
6228 sec_count = scsipkt->pkt_cdbp[7];
6229 sec_count = (sec_count << 8) | scsipkt->pkt_cdbp[8];
6230 break;
6231 case SCMD_READ_G5:
6232 /* 12-bytes scsi read command : 0xA8 */
6233 lba = scsipkt->pkt_cdbp[2];
6234 lba = (lba << 8) | scsipkt->pkt_cdbp[3];
6235 lba = (lba << 8) | scsipkt->pkt_cdbp[4];
6236 lba = (lba << 8) | scsipkt->pkt_cdbp[5];
6237 sec_count = scsipkt->pkt_cdbp[6];
6238 sec_count = (sec_count << 8) | scsipkt->pkt_cdbp[7];
6239 sec_count = (sec_count << 8) | scsipkt->pkt_cdbp[8];
6240 sec_count = (sec_count << 8) | scsipkt->pkt_cdbp[9];
6241 break;
6242 case SCMD_READ_G4:
6243 /* 16-bytes scsi read command : 0x88 */
6244 lba = scsipkt->pkt_cdbp[2];
6245 lba = (lba << 8) | scsipkt->pkt_cdbp[3];
6246 lba = (lba << 8) | scsipkt->pkt_cdbp[4];
6247 lba = (lba << 8) | scsipkt->pkt_cdbp[5];
6248 lba = (lba << 8) | scsipkt->pkt_cdbp[6];
6249 lba = (lba << 8) | scsipkt->pkt_cdbp[7];
6250 lba = (lba << 8) | scsipkt->pkt_cdbp[8];
6251 lba = (lba << 8) | scsipkt->pkt_cdbp[9];
6252 sec_count = scsipkt->pkt_cdbp[10];
6253 sec_count = (sec_count << 8) | scsipkt->pkt_cdbp[11];
6254 sec_count = (sec_count << 8) | scsipkt->pkt_cdbp[12];
6255 sec_count = (sec_count << 8) | scsipkt->pkt_cdbp[13];
6256 break;
6257 default:
6258 /* Unsupported command */
6259 mutex_exit(cport_mutex);
6260 return (sata_txlt_invalid_command(spx));
6261 }
6262
6263 /*
6264 * Check if specified address exceeds device capacity
6265 */
6266 if ((lba >= sdinfo->satadrv_capacity) ||
6267 ((lba + sec_count) > sdinfo->satadrv_capacity)) {
6268 /* LBA out of range */
6269 mutex_exit(cport_mutex);
6270 return (sata_txlt_lba_out_of_range(spx));
6271 }
6272
6273 /*
6274 * For zero-length transfer, emulate good completion of the command
6275 * (reasons for rejecting the command were already checked).
6276 * No DMA resources were allocated.
6277 */
6278 if (spx->txlt_dma_cookie_list == NULL) {
6279 mutex_exit(cport_mutex);
6280 return (sata_emul_rw_completion(spx));
6281 }
6282
6283 /*
6284 * Build cmd block depending on the device capability and
6285 * requested operation mode.
6286 * Do not bother with non-dma mode - we are working only with
6287 * devices supporting DMA.
6288 */
6289 scmd->satacmd_addr_type = ATA_ADDR_LBA;
6290 scmd->satacmd_device_reg = SATA_ADH_LBA;
6291 scmd->satacmd_cmd_reg = SATAC_READ_DMA;
6292 if (sdinfo->satadrv_features_support & SATA_DEV_F_LBA48) {
6293 scmd->satacmd_addr_type = ATA_ADDR_LBA48;
6294 scmd->satacmd_cmd_reg = SATAC_READ_DMA_EXT;
6295 scmd->satacmd_sec_count_msb = sec_count >> 8;
6296 #ifndef __lock_lint
6297 scmd->satacmd_lba_low_msb = (lba >> 24) & 0xff;
6298 scmd->satacmd_lba_mid_msb = (lba >> 32) & 0xff;
6299 scmd->satacmd_lba_high_msb = lba >> 40;
6300 #endif
6301 } else if (sdinfo->satadrv_features_support & SATA_DEV_F_LBA28) {
6302 scmd->satacmd_addr_type = ATA_ADDR_LBA28;
6303 scmd->satacmd_device_reg = SATA_ADH_LBA | ((lba >> 24) & 0xf);
6304 }
6305 scmd->satacmd_sec_count_lsb = sec_count & 0xff;
6306 scmd->satacmd_lba_low_lsb = lba & 0xff;
6307 scmd->satacmd_lba_mid_lsb = (lba >> 8) & 0xff;
6308 scmd->satacmd_lba_high_lsb = (lba >> 16) & 0xff;
6309 scmd->satacmd_features_reg = 0;
6310 scmd->satacmd_status_reg = 0;
6311 scmd->satacmd_error_reg = 0;
6312
6313 /*
6314 * Check if queueing commands should be used and switch
6315 * to appropriate command if possible
6316 */
6317 if (sata_func_enable & SATA_ENABLE_QUEUING) {
6318 boolean_t using_queuing;
6319
6320 /* Queuing supported by controller and device? */
6321 if ((sata_func_enable & SATA_ENABLE_NCQ) &&
6322 (sdinfo->satadrv_features_support &
6323 SATA_DEV_F_NCQ) &&
6324 (SATA_FEATURES(spx->txlt_sata_hba_inst) &
6325 SATA_CTLF_NCQ)) {
6326 using_queuing = B_TRUE;
6327
6328 /* NCQ supported - use FPDMA READ */
6329 scmd->satacmd_cmd_reg =
6330 SATAC_READ_FPDMA_QUEUED;
6331 scmd->satacmd_features_reg_ext =
6332 scmd->satacmd_sec_count_msb;
6333 scmd->satacmd_sec_count_msb = 0;
6334 } else if ((sdinfo->satadrv_features_support &
6335 SATA_DEV_F_TCQ) &&
6336 (SATA_FEATURES(spx->txlt_sata_hba_inst) &
6337 SATA_CTLF_QCMD)) {
6338 using_queuing = B_TRUE;
6339
6340 /* Legacy queueing */
6341 if (sdinfo->satadrv_features_support &
6342 SATA_DEV_F_LBA48) {
6343 scmd->satacmd_cmd_reg =
6344 SATAC_READ_DMA_QUEUED_EXT;
6345 scmd->satacmd_features_reg_ext =
6346 scmd->satacmd_sec_count_msb;
6347 scmd->satacmd_sec_count_msb = 0;
6348 } else {
6349 scmd->satacmd_cmd_reg =
6350 SATAC_READ_DMA_QUEUED;
6351 }
6352 } else /* NCQ nor legacy queuing not supported */
6353 using_queuing = B_FALSE;
6354
6355 /*
6356 * If queuing, the sector count goes in the features register
6357 * and the secount count will contain the tag.
6358 */
6359 if (using_queuing) {
6360 scmd->satacmd_features_reg =
6361 scmd->satacmd_sec_count_lsb;
6362 scmd->satacmd_sec_count_lsb = 0;
6363 scmd->satacmd_flags.sata_queued = B_TRUE;
6364
6365 /* Set-up maximum queue depth */
6366 scmd->satacmd_flags.sata_max_queue_depth =
6367 sdinfo->satadrv_max_queue_depth - 1;
6368 } else if (sdinfo->satadrv_features_enabled &
6369 SATA_DEV_F_E_UNTAGGED_QING) {
6370 /*
6371 * Although NCQ/TCQ is not enabled, untagged queuing
6372 * may be still used.
6373 * Set-up the maximum untagged queue depth.
6374 * Use controller's queue depth from sata_hba_tran.
6375 * SATA HBA drivers may ignore this value and rely on
6376 * the internal limits.For drivers that do not
6377 * ignore untaged queue depth, limit the value to
6378 * SATA_MAX_QUEUE_DEPTH (32), as this is the
6379 * largest value that can be passed via
6380 * satacmd_flags.sata_max_queue_depth.
6381 */
6382 scmd->satacmd_flags.sata_max_queue_depth =
6383 SATA_QDEPTH(shi) <= SATA_MAX_QUEUE_DEPTH ?
6384 SATA_QDEPTH(shi) - 1: SATA_MAX_QUEUE_DEPTH - 1;
6385
6386 } else {
6387 scmd->satacmd_flags.sata_max_queue_depth = 0;
6388 }
6389 } else
6390 scmd->satacmd_flags.sata_max_queue_depth = 0;
6391
6392 SATADBG3(SATA_DBG_HBA_IF, spx->txlt_sata_hba_inst,
6393 "sata_txlt_read cmd 0x%2x, lba %llx, sec count %x\n",
6394 scmd->satacmd_cmd_reg, lba, sec_count);
6395
6396 if (!(spx->txlt_sata_pkt->satapkt_op_mode & SATA_OPMODE_SYNCH)) {
6397 /* Need callback function */
6398 spx->txlt_sata_pkt->satapkt_comp = sata_txlt_rw_completion;
6399 synch = FALSE;
6400 } else
6401 synch = TRUE;
6402
6403 /* Transfer command to HBA */
6404 if (sata_hba_start(spx, &rval) != 0) {
6405 /* Pkt not accepted for execution */
6406 mutex_exit(cport_mutex);
6407 return (rval);
6408 }
6409 mutex_exit(cport_mutex);
6410 /*
6411 * If execution is non-synchronous,
6412 * a callback function will handle potential errors, translate
6413 * the response and will do a callback to a target driver.
6414 * If it was synchronous, check execution status using the same
6415 * framework callback.
6416 */
6417 if (synch) {
6418 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst,
6419 "synchronous execution status %x\n",
6420 spx->txlt_sata_pkt->satapkt_reason);
6421 sata_txlt_rw_completion(spx->txlt_sata_pkt);
6422 }
6423 return (TRAN_ACCEPT);
6424 }
6425
6426
6427 /*
6428 * SATA translate command: Write (various types)
6429 * Translated into appropriate type of ATA WRITE command
6430 * for SATA hard disks.
6431 * Both the device capabilities and requested operation mode are
6432 * considered.
6433 *
6434 * Following scsi cdb fields are ignored:
6435 * rwprotect, dpo, fua, fua_nv, group_number.
6436 *
6437 * If SATA_ENABLE_QUEUING flag is set (in the global SATA HBA framework
6438 * enable variable sata_func_enable), the capability of the controller and
6439 * capability of a device are checked and if both support queueing, write
6440 * request will be translated to WRITE_DMA_QUEUEING or WRITE_DMA_QUEUEING_EXT
6441 * command rather than plain WRITE_XXX command.
6442 * If SATA_ENABLE_NCQ flag is set in addition to SATA_ENABLE_QUEUING flag and
6443 * both the controller and device suport such functionality, the write
6444 * request will be translated to WRITE_FPDMA_QUEUED command.
6445 * In both cases the maximum queue depth is derived as minimum of:
6446 * HBA capability,device capability and sata_max_queue_depth variable setting.
6447 * The value passed to HBA driver is decremented by 1, because only 5 bits are
6448 * used to pass max queue depth value, and the maximum possible queue depth
6449 * is 32.
6450 *
6451 * Returns TRAN_ACCEPT or code returned by sata_hba_start() and
6452 * appropriate values in scsi_pkt fields.
6453 */
6454 static int
sata_txlt_write(sata_pkt_txlate_t * spx)6455 sata_txlt_write(sata_pkt_txlate_t *spx)
6456 {
6457 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt;
6458 sata_cmd_t *scmd = &spx->txlt_sata_pkt->satapkt_cmd;
6459 sata_drive_info_t *sdinfo;
6460 sata_hba_inst_t *shi = SATA_TXLT_HBA_INST(spx);
6461 uint16_t sec_count;
6462 uint64_t lba;
6463 int rval, reason;
6464 int synch;
6465 kmutex_t *cport_mutex = &(SATA_TXLT_CPORT_MUTEX(spx));
6466
6467 mutex_enter(cport_mutex);
6468
6469 if (((rval = sata_txlt_generic_pkt_info(spx, &reason, 0)) !=
6470 TRAN_ACCEPT) || (reason == CMD_DEV_GONE)) {
6471 mutex_exit(cport_mutex);
6472 return (rval);
6473 }
6474
6475 sdinfo = sata_get_device_info(spx->txlt_sata_hba_inst,
6476 &spx->txlt_sata_pkt->satapkt_device);
6477
6478 scmd->satacmd_flags.sata_data_direction = SATA_DIR_WRITE;
6479 /*
6480 * Extract LBA and sector count from scsi CDB
6481 */
6482 switch ((uint_t)scsipkt->pkt_cdbp[0]) {
6483 case SCMD_WRITE:
6484 /* 6-byte scsi read cmd : 0x0A */
6485 lba = (scsipkt->pkt_cdbp[1] & 0x1f);
6486 lba = (lba << 8) | scsipkt->pkt_cdbp[2];
6487 lba = (lba << 8) | scsipkt->pkt_cdbp[3];
6488 sec_count = scsipkt->pkt_cdbp[4];
6489 /* sec_count 0 will be interpreted as 256 by a device */
6490 break;
6491 case SCMD_WRITE_G1:
6492 /* 10-bytes scsi write command : 0x2A */
6493 lba = scsipkt->pkt_cdbp[2];
6494 lba = (lba << 8) | scsipkt->pkt_cdbp[3];
6495 lba = (lba << 8) | scsipkt->pkt_cdbp[4];
6496 lba = (lba << 8) | scsipkt->pkt_cdbp[5];
6497 sec_count = scsipkt->pkt_cdbp[7];
6498 sec_count = (sec_count << 8) | scsipkt->pkt_cdbp[8];
6499 break;
6500 case SCMD_WRITE_G5:
6501 /* 12-bytes scsi read command : 0xAA */
6502 lba = scsipkt->pkt_cdbp[2];
6503 lba = (lba << 8) | scsipkt->pkt_cdbp[3];
6504 lba = (lba << 8) | scsipkt->pkt_cdbp[4];
6505 lba = (lba << 8) | scsipkt->pkt_cdbp[5];
6506 sec_count = scsipkt->pkt_cdbp[6];
6507 sec_count = (sec_count << 8) | scsipkt->pkt_cdbp[7];
6508 sec_count = (sec_count << 8) | scsipkt->pkt_cdbp[8];
6509 sec_count = (sec_count << 8) | scsipkt->pkt_cdbp[9];
6510 break;
6511 case SCMD_WRITE_G4:
6512 /* 16-bytes scsi write command : 0x8A */
6513 lba = scsipkt->pkt_cdbp[2];
6514 lba = (lba << 8) | scsipkt->pkt_cdbp[3];
6515 lba = (lba << 8) | scsipkt->pkt_cdbp[4];
6516 lba = (lba << 8) | scsipkt->pkt_cdbp[5];
6517 lba = (lba << 8) | scsipkt->pkt_cdbp[6];
6518 lba = (lba << 8) | scsipkt->pkt_cdbp[7];
6519 lba = (lba << 8) | scsipkt->pkt_cdbp[8];
6520 lba = (lba << 8) | scsipkt->pkt_cdbp[9];
6521 sec_count = scsipkt->pkt_cdbp[10];
6522 sec_count = (sec_count << 8) | scsipkt->pkt_cdbp[11];
6523 sec_count = (sec_count << 8) | scsipkt->pkt_cdbp[12];
6524 sec_count = (sec_count << 8) | scsipkt->pkt_cdbp[13];
6525 break;
6526 default:
6527 /* Unsupported command */
6528 mutex_exit(cport_mutex);
6529 return (sata_txlt_invalid_command(spx));
6530 }
6531
6532 /*
6533 * Check if specified address and length exceeds device capacity
6534 */
6535 if ((lba >= sdinfo->satadrv_capacity) ||
6536 ((lba + sec_count) > sdinfo->satadrv_capacity)) {
6537 /* LBA out of range */
6538 mutex_exit(cport_mutex);
6539 return (sata_txlt_lba_out_of_range(spx));
6540 }
6541
6542 /*
6543 * For zero-length transfer, emulate good completion of the command
6544 * (reasons for rejecting the command were already checked).
6545 * No DMA resources were allocated.
6546 */
6547 if (spx->txlt_dma_cookie_list == NULL) {
6548 mutex_exit(cport_mutex);
6549 return (sata_emul_rw_completion(spx));
6550 }
6551
6552 /*
6553 * Build cmd block depending on the device capability and
6554 * requested operation mode.
6555 * Do not bother with non-dma mode- we are working only with
6556 * devices supporting DMA.
6557 */
6558 scmd->satacmd_addr_type = ATA_ADDR_LBA;
6559 scmd->satacmd_device_reg = SATA_ADH_LBA;
6560 scmd->satacmd_cmd_reg = SATAC_WRITE_DMA;
6561 if (sdinfo->satadrv_features_support & SATA_DEV_F_LBA48) {
6562 scmd->satacmd_addr_type = ATA_ADDR_LBA48;
6563 scmd->satacmd_cmd_reg = SATAC_WRITE_DMA_EXT;
6564 scmd->satacmd_sec_count_msb = sec_count >> 8;
6565 scmd->satacmd_lba_low_msb = (lba >> 24) & 0xff;
6566 #ifndef __lock_lint
6567 scmd->satacmd_lba_mid_msb = (lba >> 32) & 0xff;
6568 scmd->satacmd_lba_high_msb = lba >> 40;
6569 #endif
6570 } else if (sdinfo->satadrv_features_support & SATA_DEV_F_LBA28) {
6571 scmd->satacmd_addr_type = ATA_ADDR_LBA28;
6572 scmd->satacmd_device_reg = SATA_ADH_LBA | ((lba >> 24) & 0xf);
6573 }
6574 scmd->satacmd_sec_count_lsb = sec_count & 0xff;
6575 scmd->satacmd_lba_low_lsb = lba & 0xff;
6576 scmd->satacmd_lba_mid_lsb = (lba >> 8) & 0xff;
6577 scmd->satacmd_lba_high_lsb = (lba >> 16) & 0xff;
6578 scmd->satacmd_features_reg = 0;
6579 scmd->satacmd_status_reg = 0;
6580 scmd->satacmd_error_reg = 0;
6581
6582 /*
6583 * Check if queueing commands should be used and switch
6584 * to appropriate command if possible
6585 */
6586 if (sata_func_enable & SATA_ENABLE_QUEUING) {
6587 boolean_t using_queuing;
6588
6589 /* Queuing supported by controller and device? */
6590 if ((sata_func_enable & SATA_ENABLE_NCQ) &&
6591 (sdinfo->satadrv_features_support &
6592 SATA_DEV_F_NCQ) &&
6593 (SATA_FEATURES(spx->txlt_sata_hba_inst) &
6594 SATA_CTLF_NCQ)) {
6595 using_queuing = B_TRUE;
6596
6597 /* NCQ supported - use FPDMA WRITE */
6598 scmd->satacmd_cmd_reg =
6599 SATAC_WRITE_FPDMA_QUEUED;
6600 scmd->satacmd_features_reg_ext =
6601 scmd->satacmd_sec_count_msb;
6602 scmd->satacmd_sec_count_msb = 0;
6603 } else if ((sdinfo->satadrv_features_support &
6604 SATA_DEV_F_TCQ) &&
6605 (SATA_FEATURES(spx->txlt_sata_hba_inst) &
6606 SATA_CTLF_QCMD)) {
6607 using_queuing = B_TRUE;
6608
6609 /* Legacy queueing */
6610 if (sdinfo->satadrv_features_support &
6611 SATA_DEV_F_LBA48) {
6612 scmd->satacmd_cmd_reg =
6613 SATAC_WRITE_DMA_QUEUED_EXT;
6614 scmd->satacmd_features_reg_ext =
6615 scmd->satacmd_sec_count_msb;
6616 scmd->satacmd_sec_count_msb = 0;
6617 } else {
6618 scmd->satacmd_cmd_reg =
6619 SATAC_WRITE_DMA_QUEUED;
6620 }
6621 } else /* NCQ nor legacy queuing not supported */
6622 using_queuing = B_FALSE;
6623
6624 if (using_queuing) {
6625 scmd->satacmd_features_reg =
6626 scmd->satacmd_sec_count_lsb;
6627 scmd->satacmd_sec_count_lsb = 0;
6628 scmd->satacmd_flags.sata_queued = B_TRUE;
6629 /* Set-up maximum queue depth */
6630 scmd->satacmd_flags.sata_max_queue_depth =
6631 sdinfo->satadrv_max_queue_depth - 1;
6632 } else if (sdinfo->satadrv_features_enabled &
6633 SATA_DEV_F_E_UNTAGGED_QING) {
6634 /*
6635 * Although NCQ/TCQ is not enabled, untagged queuing
6636 * may be still used.
6637 * Set-up the maximum untagged queue depth.
6638 * Use controller's queue depth from sata_hba_tran.
6639 * SATA HBA drivers may ignore this value and rely on
6640 * the internal limits. For drivera that do not
6641 * ignore untaged queue depth, limit the value to
6642 * SATA_MAX_QUEUE_DEPTH (32), as this is the
6643 * largest value that can be passed via
6644 * satacmd_flags.sata_max_queue_depth.
6645 */
6646 scmd->satacmd_flags.sata_max_queue_depth =
6647 SATA_QDEPTH(shi) <= SATA_MAX_QUEUE_DEPTH ?
6648 SATA_QDEPTH(shi) - 1: SATA_MAX_QUEUE_DEPTH - 1;
6649
6650 } else {
6651 scmd->satacmd_flags.sata_max_queue_depth = 0;
6652 }
6653 } else
6654 scmd->satacmd_flags.sata_max_queue_depth = 0;
6655
6656 SATADBG3(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst,
6657 "sata_txlt_write cmd 0x%2x, lba %llx, sec count %x\n",
6658 scmd->satacmd_cmd_reg, lba, sec_count);
6659
6660 if (!(spx->txlt_sata_pkt->satapkt_op_mode & SATA_OPMODE_SYNCH)) {
6661 /* Need callback function */
6662 spx->txlt_sata_pkt->satapkt_comp = sata_txlt_rw_completion;
6663 synch = FALSE;
6664 } else
6665 synch = TRUE;
6666
6667 /* Transfer command to HBA */
6668 if (sata_hba_start(spx, &rval) != 0) {
6669 /* Pkt not accepted for execution */
6670 mutex_exit(cport_mutex);
6671 return (rval);
6672 }
6673 mutex_exit(cport_mutex);
6674
6675 /*
6676 * If execution is non-synchronous,
6677 * a callback function will handle potential errors, translate
6678 * the response and will do a callback to a target driver.
6679 * If it was synchronous, check execution status using the same
6680 * framework callback.
6681 */
6682 if (synch) {
6683 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst,
6684 "synchronous execution status %x\n",
6685 spx->txlt_sata_pkt->satapkt_reason);
6686 sata_txlt_rw_completion(spx->txlt_sata_pkt);
6687 }
6688 return (TRAN_ACCEPT);
6689 }
6690
6691
6692 /*
6693 * Implements SCSI SBC WRITE BUFFER command download microcode option
6694 */
6695 static int
sata_txlt_write_buffer(sata_pkt_txlate_t * spx)6696 sata_txlt_write_buffer(sata_pkt_txlate_t *spx)
6697 {
6698 #define WB_DOWNLOAD_MICROCODE_AND_REVERT_MODE 4
6699 #define WB_DOWNLOAD_MICROCODE_AND_SAVE_MODE 5
6700
6701 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt;
6702 struct sata_pkt *sata_pkt = spx->txlt_sata_pkt;
6703 sata_cmd_t *scmd = &spx->txlt_sata_pkt->satapkt_cmd;
6704
6705 struct buf *bp = spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp;
6706 struct scsi_extended_sense *sense;
6707 int rval, mode, sector_count, reason;
6708 kmutex_t *cport_mutex = &(SATA_TXLT_CPORT_MUTEX(spx));
6709
6710 mode = scsipkt->pkt_cdbp[1] & 0x1f;
6711
6712 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst,
6713 "sata_txlt_write_buffer, mode 0x%x\n", mode);
6714
6715 mutex_enter(cport_mutex);
6716
6717 if ((rval = sata_txlt_generic_pkt_info(spx, &reason, 1)) !=
6718 TRAN_ACCEPT) {
6719 mutex_exit(cport_mutex);
6720 return (rval);
6721 }
6722
6723 /* Use synchronous mode */
6724 spx->txlt_sata_pkt->satapkt_op_mode
6725 |= SATA_OPMODE_SYNCH | SATA_OPMODE_INTERRUPTS;
6726
6727 scmd->satacmd_flags.sata_data_direction = SATA_DIR_WRITE;
6728
6729 scsipkt->pkt_reason = CMD_CMPLT;
6730 scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET |
6731 STATE_SENT_CMD | STATE_GOT_STATUS;
6732
6733 /*
6734 * The SCSI to ATA translation specification only calls
6735 * for WB_DOWNLOAD_MICROCODE_AND_SAVE_MODE.
6736 * WB_DOWNLOAD_MICROC_AND_REVERT_MODE is implemented, but
6737 * ATA 8 (draft) got rid of download microcode for temp
6738 * and it is even optional for ATA 7, so it may be aborted.
6739 * WB_DOWNLOAD_MICROCODE_WITH_OFFSET is not implemented as
6740 * it is not specified and the buffer offset for SCSI is a 16-bit
6741 * value in bytes, but for ATA it is a 16-bit offset in 512 byte
6742 * sectors. Thus the offset really doesn't buy us anything.
6743 * If and when ATA 8 is stabilized and the SCSI to ATA specification
6744 * is revised, this can be revisisted.
6745 */
6746 /* Reject not supported request */
6747 switch (mode) {
6748 case WB_DOWNLOAD_MICROCODE_AND_REVERT_MODE:
6749 scmd->satacmd_features_reg = SATA_DOWNLOAD_MCODE_TEMP;
6750 break;
6751 case WB_DOWNLOAD_MICROCODE_AND_SAVE_MODE:
6752 scmd->satacmd_features_reg = SATA_DOWNLOAD_MCODE_SAVE;
6753 break;
6754 default:
6755 goto bad_param;
6756 }
6757
6758 *scsipkt->pkt_scbp = STATUS_GOOD; /* Presumed outcome */
6759
6760 scmd->satacmd_cmd_reg = SATAC_DOWNLOAD_MICROCODE;
6761 if ((bp->b_bcount % SATA_DISK_SECTOR_SIZE) != 0)
6762 goto bad_param;
6763 sector_count = bp->b_bcount / SATA_DISK_SECTOR_SIZE;
6764 scmd->satacmd_sec_count_lsb = (uint8_t)sector_count;
6765 scmd->satacmd_lba_low_lsb = ((uint16_t)sector_count) >> 8;
6766 scmd->satacmd_lba_mid_lsb = 0;
6767 scmd->satacmd_lba_high_lsb = 0;
6768 scmd->satacmd_device_reg = 0;
6769 spx->txlt_sata_pkt->satapkt_comp = NULL;
6770 scmd->satacmd_addr_type = 0;
6771
6772 /* Transfer command to HBA */
6773 if (sata_hba_start(spx, &rval) != 0) {
6774 /* Pkt not accepted for execution */
6775 mutex_exit(cport_mutex);
6776 return (rval);
6777 }
6778
6779 mutex_exit(cport_mutex);
6780
6781 /* Then we need synchronous check the status of the disk */
6782 scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET |
6783 STATE_SENT_CMD | STATE_XFERRED_DATA | STATE_GOT_STATUS;
6784 if (sata_pkt->satapkt_reason == SATA_PKT_COMPLETED) {
6785 scsipkt->pkt_reason = CMD_CMPLT;
6786
6787 /* Download commmand succeed, so probe and identify device */
6788 sata_reidentify_device(spx);
6789 } else {
6790 /* Something went wrong, microcode download command failed */
6791 scsipkt->pkt_reason = CMD_INCOMPLETE;
6792 *scsipkt->pkt_scbp = STATUS_CHECK;
6793 sense = sata_arq_sense(spx);
6794 switch (sata_pkt->satapkt_reason) {
6795 case SATA_PKT_PORT_ERROR:
6796 /*
6797 * We have no device data. Assume no data transfered.
6798 */
6799 sense->es_key = KEY_HARDWARE_ERROR;
6800 break;
6801
6802 case SATA_PKT_DEV_ERROR:
6803 if (sata_pkt->satapkt_cmd.satacmd_status_reg &
6804 SATA_STATUS_ERR) {
6805 /*
6806 * determine dev error reason from error
6807 * reg content
6808 */
6809 sata_decode_device_error(spx, sense);
6810 break;
6811 }
6812 /* No extended sense key - no info available */
6813 break;
6814
6815 case SATA_PKT_TIMEOUT:
6816 scsipkt->pkt_reason = CMD_TIMEOUT;
6817 scsipkt->pkt_statistics |=
6818 STAT_TIMEOUT | STAT_DEV_RESET;
6819 /* No extended sense key ? */
6820 break;
6821
6822 case SATA_PKT_ABORTED:
6823 scsipkt->pkt_reason = CMD_ABORTED;
6824 scsipkt->pkt_statistics |= STAT_ABORTED;
6825 /* No extended sense key ? */
6826 break;
6827
6828 case SATA_PKT_RESET:
6829 /* pkt aborted by an explicit reset from a host */
6830 scsipkt->pkt_reason = CMD_RESET;
6831 scsipkt->pkt_statistics |= STAT_DEV_RESET;
6832 break;
6833
6834 default:
6835 SATA_LOG_D((spx->txlt_sata_hba_inst, CE_WARN,
6836 "sata_txlt_nodata_cmd_completion: "
6837 "invalid packet completion reason %d",
6838 sata_pkt->satapkt_reason));
6839 scsipkt->pkt_reason = CMD_TRAN_ERR;
6840 break;
6841 }
6842
6843 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst,
6844 "scsi_pkt completion reason %x\n", scsipkt->pkt_reason);
6845
6846 if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0)
6847 /* scsi callback required */
6848 scsi_hba_pkt_comp(scsipkt);
6849 }
6850 return (TRAN_ACCEPT);
6851
6852 bad_param:
6853 mutex_exit(cport_mutex);
6854 *scsipkt->pkt_scbp = STATUS_CHECK;
6855 sense = sata_arq_sense(spx);
6856 sense->es_key = KEY_ILLEGAL_REQUEST;
6857 sense->es_add_code = SD_SCSI_ASC_INVALID_FIELD_IN_CDB;
6858 if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0 &&
6859 scsipkt->pkt_comp != NULL) {
6860 /* scsi callback required */
6861 if (servicing_interrupt()) {
6862 if (taskq_dispatch(SATA_TXLT_TASKQ(spx),
6863 (task_func_t *)spx->txlt_scsi_pkt->pkt_comp,
6864 (void *)spx->txlt_scsi_pkt, TQ_NOSLEEP) ==
6865 TASKQID_INVALID) {
6866 return (TRAN_BUSY);
6867 }
6868 } else if (taskq_dispatch(SATA_TXLT_TASKQ(spx),
6869 (task_func_t *)spx->txlt_scsi_pkt->pkt_comp,
6870 (void *)spx->txlt_scsi_pkt, TQ_SLEEP) == TASKQID_INVALID) {
6871 /* Scheduling the callback failed */
6872 return (TRAN_BUSY);
6873 }
6874 }
6875 return (rval);
6876 }
6877
6878 /*
6879 * Re-identify device after doing a firmware download.
6880 */
6881 static void
sata_reidentify_device(sata_pkt_txlate_t * spx)6882 sata_reidentify_device(sata_pkt_txlate_t *spx)
6883 {
6884 #define DOWNLOAD_WAIT_TIME_SECS 60
6885 #define DOWNLOAD_WAIT_INTERVAL_SECS 1
6886 int rval;
6887 int retry_cnt;
6888 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt;
6889 sata_hba_inst_t *sata_hba_inst = spx->txlt_sata_hba_inst;
6890 sata_device_t sata_device = spx->txlt_sata_pkt->satapkt_device;
6891 sata_drive_info_t *sdinfo;
6892
6893 /*
6894 * Before returning good status, probe device.
6895 * Device probing will get IDENTIFY DEVICE data, if possible.
6896 * The assumption is that the new microcode is applied by the
6897 * device. It is a caller responsibility to verify this.
6898 */
6899 for (retry_cnt = 0;
6900 retry_cnt < DOWNLOAD_WAIT_TIME_SECS / DOWNLOAD_WAIT_INTERVAL_SECS;
6901 retry_cnt++) {
6902 rval = sata_probe_device(sata_hba_inst, &sata_device);
6903
6904 if (rval == SATA_SUCCESS) { /* Set default features */
6905 sdinfo = sata_get_device_info(sata_hba_inst,
6906 &sata_device);
6907 if (sata_initialize_device(sata_hba_inst, sdinfo) !=
6908 SATA_SUCCESS) {
6909 /* retry */
6910 rval = sata_initialize_device(sata_hba_inst,
6911 sdinfo);
6912 if (rval == SATA_RETRY)
6913 sata_log(sata_hba_inst, CE_WARN,
6914 "SATA device at port %d pmport %d -"
6915 " default device features could not"
6916 " be set. Device may not operate "
6917 "as expected.",
6918 sata_device.satadev_addr.cport,
6919 sata_device.satadev_addr.pmport);
6920 }
6921 if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0)
6922 scsi_hba_pkt_comp(scsipkt);
6923 return;
6924 } else if (rval == SATA_RETRY) {
6925 delay(drv_usectohz(1000000 *
6926 DOWNLOAD_WAIT_INTERVAL_SECS));
6927 continue;
6928 } else /* failed - no reason to retry */
6929 break;
6930 }
6931
6932 /*
6933 * Something went wrong, device probing failed.
6934 */
6935 SATA_LOG_D((sata_hba_inst, CE_WARN,
6936 "Cannot probe device after downloading microcode\n"));
6937
6938 /* Reset device to force retrying the probe. */
6939 (void) (*SATA_RESET_DPORT_FUNC(sata_hba_inst))
6940 (SATA_DIP(sata_hba_inst), &sata_device);
6941
6942 if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0)
6943 scsi_hba_pkt_comp(scsipkt);
6944 }
6945
6946
6947 /*
6948 * Translate command: Synchronize Cache.
6949 * Translates into Flush Cache command for SATA hard disks.
6950 *
6951 * Returns TRAN_ACCEPT or code returned by sata_hba_start() and
6952 * appropriate values in scsi_pkt fields.
6953 */
6954 static int
sata_txlt_synchronize_cache(sata_pkt_txlate_t * spx)6955 sata_txlt_synchronize_cache(sata_pkt_txlate_t *spx)
6956 {
6957 sata_cmd_t *scmd = &spx->txlt_sata_pkt->satapkt_cmd;
6958 kmutex_t *cport_mutex = &(SATA_TXLT_CPORT_MUTEX(spx));
6959 int rval, reason;
6960 int synch;
6961
6962 mutex_enter(cport_mutex);
6963
6964 if (((rval = sata_txlt_generic_pkt_info(spx, &reason, 1)) !=
6965 TRAN_ACCEPT) || (reason == CMD_DEV_GONE)) {
6966 mutex_exit(cport_mutex);
6967 return (rval);
6968 }
6969
6970 scmd->satacmd_addr_type = 0;
6971 scmd->satacmd_cmd_reg = SATAC_FLUSH_CACHE;
6972 scmd->satacmd_device_reg = 0;
6973 scmd->satacmd_sec_count_lsb = 0;
6974 scmd->satacmd_lba_low_lsb = 0;
6975 scmd->satacmd_lba_mid_lsb = 0;
6976 scmd->satacmd_lba_high_lsb = 0;
6977 scmd->satacmd_features_reg = 0;
6978 scmd->satacmd_status_reg = 0;
6979 scmd->satacmd_error_reg = 0;
6980
6981 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst,
6982 "sata_txlt_synchronize_cache\n", NULL);
6983
6984 if (!(spx->txlt_sata_pkt->satapkt_op_mode & SATA_OPMODE_SYNCH)) {
6985 /* Need to set-up a callback function */
6986 spx->txlt_sata_pkt->satapkt_comp =
6987 sata_txlt_nodata_cmd_completion;
6988 synch = FALSE;
6989 } else
6990 synch = TRUE;
6991
6992 /* Transfer command to HBA */
6993 if (sata_hba_start(spx, &rval) != 0) {
6994 /* Pkt not accepted for execution */
6995 mutex_exit(cport_mutex);
6996 return (rval);
6997 }
6998 mutex_exit(cport_mutex);
6999
7000 /*
7001 * If execution non-synchronous, it had to be completed
7002 * a callback function will handle potential errors, translate
7003 * the response and will do a callback to a target driver.
7004 * If it was synchronous, check status, using the same
7005 * framework callback.
7006 */
7007 if (synch) {
7008 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst,
7009 "synchronous execution status %x\n",
7010 spx->txlt_sata_pkt->satapkt_reason);
7011 sata_txlt_nodata_cmd_completion(spx->txlt_sata_pkt);
7012 }
7013 return (TRAN_ACCEPT);
7014 }
7015
7016
7017 /*
7018 * Send pkt to SATA HBA driver
7019 *
7020 * This function may be called only if the operation is requested by scsi_pkt,
7021 * i.e. scsi_pkt is not NULL.
7022 *
7023 * This function has to be called with cport mutex held. It does release
7024 * the mutex when it calls HBA driver sata_tran_start function and
7025 * re-acquires it afterwards.
7026 *
7027 * If return value is 0, pkt was accepted, -1 otherwise
7028 * rval is set to appropriate sata_scsi_start return value.
7029 *
7030 * Note 1:If HBA driver returns value other than TRAN_ACCEPT, it should not
7031 * have called the sata_pkt callback function for this packet.
7032 *
7033 * The scsi callback has to be performed by the caller of this routine.
7034 */
7035 static int
sata_hba_start(sata_pkt_txlate_t * spx,int * rval)7036 sata_hba_start(sata_pkt_txlate_t *spx, int *rval)
7037 {
7038 int stat;
7039 uint8_t cport = SATA_TXLT_CPORT(spx);
7040 uint8_t pmport = SATA_TXLT_PMPORT(spx);
7041 sata_hba_inst_t *sata_hba_inst = spx->txlt_sata_hba_inst;
7042 sata_drive_info_t *sdinfo;
7043 sata_pmult_info_t *pminfo = NULL;
7044 sata_pmport_info_t *pmportinfo = NULL;
7045 sata_device_t *sata_device = NULL;
7046 uint8_t cmd;
7047 struct sata_cmd_flags cmd_flags;
7048
7049 ASSERT(spx->txlt_sata_pkt != NULL);
7050
7051 ASSERT(mutex_owned(&SATA_CPORT_MUTEX(sata_hba_inst, cport)));
7052
7053 sdinfo = sata_get_device_info(sata_hba_inst,
7054 &spx->txlt_sata_pkt->satapkt_device);
7055 ASSERT(sdinfo != NULL);
7056
7057 /* Clear device reset state? */
7058 /* qual should be XXX_DPMPORT, but add XXX_PMPORT in case */
7059 if (sdinfo->satadrv_addr.qual == SATA_ADDR_DPMPORT ||
7060 sdinfo->satadrv_addr.qual == SATA_ADDR_PMPORT) {
7061
7062 /*
7063 * Get the pmult_info of the its parent port multiplier, all
7064 * sub-devices share a common device reset flags on in
7065 * pmult_info.
7066 */
7067 pminfo = SATA_PMULT_INFO(sata_hba_inst, cport);
7068 pmportinfo = pminfo->pmult_dev_port[pmport];
7069 ASSERT(pminfo != NULL);
7070 if (pminfo->pmult_event_flags & SATA_EVNT_CLEAR_DEVICE_RESET) {
7071 spx->txlt_sata_pkt->satapkt_cmd.satacmd_flags.
7072 sata_clear_dev_reset = B_TRUE;
7073 pminfo->pmult_event_flags &=
7074 ~SATA_EVNT_CLEAR_DEVICE_RESET;
7075 SATADBG1(SATA_DBG_EVENTS, sata_hba_inst,
7076 "sata_hba_start: clearing device reset state"
7077 "on pmult.\n", NULL);
7078 }
7079 } else {
7080 if (sdinfo->satadrv_event_flags &
7081 SATA_EVNT_CLEAR_DEVICE_RESET) {
7082 spx->txlt_sata_pkt->satapkt_cmd.satacmd_flags.
7083 sata_clear_dev_reset = B_TRUE;
7084 sdinfo->satadrv_event_flags &=
7085 ~SATA_EVNT_CLEAR_DEVICE_RESET;
7086 SATADBG1(SATA_DBG_EVENTS, sata_hba_inst,
7087 "sata_hba_start: clearing device reset state\n",
7088 NULL);
7089 }
7090 }
7091
7092 cmd = spx->txlt_sata_pkt->satapkt_cmd.satacmd_cmd_reg;
7093 cmd_flags = spx->txlt_sata_pkt->satapkt_cmd.satacmd_flags;
7094 sata_device = &spx->txlt_sata_pkt->satapkt_device;
7095
7096 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, cport)));
7097
7098 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst,
7099 "Sata cmd 0x%2x\n", cmd);
7100
7101 stat = (*SATA_START_FUNC(sata_hba_inst))(SATA_DIP(sata_hba_inst),
7102 spx->txlt_sata_pkt);
7103 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, cport)));
7104 /*
7105 * If sata pkt was accepted and executed in asynchronous mode, i.e.
7106 * with the sata callback, the sata_pkt could be already destroyed
7107 * by the time we check ther return status from the hba_start()
7108 * function, because sata_scsi_destroy_pkt() could have been already
7109 * called (perhaps in the interrupt context). So, in such case, there
7110 * should be no references to it. In other cases, sata_pkt still
7111 * exists.
7112 */
7113 if (stat == SATA_TRAN_ACCEPTED) {
7114 /*
7115 * pkt accepted for execution.
7116 * If it was executed synchronously, it is already completed
7117 * and pkt completion_reason indicates completion status.
7118 */
7119 *rval = TRAN_ACCEPT;
7120 return (0);
7121 }
7122
7123 sdinfo = sata_get_device_info(sata_hba_inst, sata_device);
7124 switch (stat) {
7125 case SATA_TRAN_QUEUE_FULL:
7126 /*
7127 * Controller detected queue full condition.
7128 */
7129 SATADBG1(SATA_DBG_HBA_IF, sata_hba_inst,
7130 "sata_hba_start: queue full\n", NULL);
7131
7132 spx->txlt_scsi_pkt->pkt_reason = CMD_INCOMPLETE;
7133 *spx->txlt_scsi_pkt->pkt_scbp = STATUS_QFULL;
7134
7135 *rval = TRAN_BUSY;
7136 break;
7137
7138 case SATA_TRAN_PORT_ERROR:
7139 /*
7140 * Communication/link with device or general port error
7141 * detected before pkt execution begun.
7142 */
7143 if (spx->txlt_sata_pkt->satapkt_device.satadev_addr.qual ==
7144 SATA_ADDR_CPORT ||
7145 spx->txlt_sata_pkt->satapkt_device.satadev_addr.qual ==
7146 SATA_ADDR_DCPORT)
7147 sata_log(sata_hba_inst, CE_CONT,
7148 "SATA port %d error",
7149 sata_device->satadev_addr.cport);
7150 else
7151 sata_log(sata_hba_inst, CE_CONT,
7152 "SATA port %d:%d error\n",
7153 sata_device->satadev_addr.cport,
7154 sata_device->satadev_addr.pmport);
7155
7156 /*
7157 * Update the port/device structure.
7158 * sata_pkt should be still valid. Since port error is
7159 * returned, sata_device content should reflect port
7160 * state - it means, that sata address have been changed,
7161 * because original packet's sata address refered to a device
7162 * attached to some port.
7163 */
7164 if (sata_device->satadev_addr.qual == SATA_ADDR_DPMPORT ||
7165 sata_device->satadev_addr.qual == SATA_ADDR_PMPORT) {
7166 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, cport)));
7167 mutex_enter(&pmportinfo->pmport_mutex);
7168 sata_update_pmport_info(sata_hba_inst, sata_device);
7169 mutex_exit(&pmportinfo->pmport_mutex);
7170 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, cport)));
7171 } else {
7172 sata_update_port_info(sata_hba_inst, sata_device);
7173 }
7174
7175 spx->txlt_scsi_pkt->pkt_reason = CMD_TRAN_ERR;
7176 *rval = TRAN_FATAL_ERROR;
7177 break;
7178
7179 case SATA_TRAN_CMD_UNSUPPORTED:
7180 /*
7181 * Command rejected by HBA as unsupported. It was HBA driver
7182 * that rejected the command, command was not sent to
7183 * an attached device.
7184 */
7185 if ((sdinfo != NULL) &&
7186 (sdinfo->satadrv_state & SATA_DSTATE_RESET))
7187 SATADBG1(SATA_DBG_EVENTS, sata_hba_inst,
7188 "sat_hba_start: cmd 0x%2x rejected "
7189 "with SATA_TRAN_CMD_UNSUPPORTED status\n", cmd);
7190
7191 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, cport)));
7192 (void) sata_txlt_invalid_command(spx);
7193 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, cport)));
7194
7195 *rval = TRAN_ACCEPT;
7196 break;
7197
7198 case SATA_TRAN_BUSY:
7199 /*
7200 * Command rejected by HBA because other operation prevents
7201 * accepting the packet, or device is in RESET condition.
7202 */
7203 if (sdinfo != NULL) {
7204 sdinfo->satadrv_state =
7205 spx->txlt_sata_pkt->satapkt_device.satadev_state;
7206
7207 if (sdinfo->satadrv_state & SATA_DSTATE_RESET) {
7208 SATADBG1(SATA_DBG_EVENTS, sata_hba_inst,
7209 "sata_hba_start: cmd 0x%2x rejected "
7210 "because of device reset condition\n",
7211 cmd);
7212 } else {
7213 SATADBG1(SATA_DBG_EVENTS, sata_hba_inst,
7214 "sata_hba_start: cmd 0x%2x rejected "
7215 "with SATA_TRAN_BUSY status\n",
7216 cmd);
7217 }
7218 }
7219 spx->txlt_scsi_pkt->pkt_reason = CMD_INCOMPLETE;
7220 *rval = TRAN_BUSY;
7221 break;
7222
7223 default:
7224 /* Unrecognized HBA response */
7225 SATA_LOG_D((sata_hba_inst, CE_WARN,
7226 "sata_hba_start: unrecognized HBA response "
7227 "to cmd : 0x%2x resp 0x%x", cmd, rval));
7228 spx->txlt_scsi_pkt->pkt_reason = CMD_TRAN_ERR;
7229 *rval = TRAN_FATAL_ERROR;
7230 break;
7231 }
7232
7233 /*
7234 * If we got here, the packet was rejected.
7235 * Check if we need to remember reset state clearing request
7236 */
7237 if (cmd_flags.sata_clear_dev_reset) {
7238 /*
7239 * Check if device is still configured - it may have
7240 * disapeared from the configuration
7241 */
7242 sdinfo = sata_get_device_info(sata_hba_inst, sata_device);
7243 if (sdinfo != NULL) {
7244 /*
7245 * Restore the flag that requests clearing of
7246 * the device reset state,
7247 * so the next sata packet may carry it to HBA.
7248 */
7249 if (sdinfo->satadrv_addr.qual == SATA_ADDR_PMPORT ||
7250 sdinfo->satadrv_addr.qual == SATA_ADDR_DPMPORT) {
7251 pminfo->pmult_event_flags |=
7252 SATA_EVNT_CLEAR_DEVICE_RESET;
7253 } else {
7254 sdinfo->satadrv_event_flags |=
7255 SATA_EVNT_CLEAR_DEVICE_RESET;
7256 }
7257 }
7258 }
7259 return (-1);
7260 }
7261
7262 /*
7263 * Scsi response setup for invalid LBA
7264 *
7265 * Returns TRAN_ACCEPT and appropriate values in scsi_pkt fields.
7266 */
7267 static int
sata_txlt_lba_out_of_range(sata_pkt_txlate_t * spx)7268 sata_txlt_lba_out_of_range(sata_pkt_txlate_t *spx)
7269 {
7270 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt;
7271 struct scsi_extended_sense *sense;
7272
7273 scsipkt->pkt_reason = CMD_CMPLT;
7274 scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET |
7275 STATE_SENT_CMD | STATE_GOT_STATUS;
7276 *scsipkt->pkt_scbp = STATUS_CHECK;
7277
7278 *scsipkt->pkt_scbp = STATUS_CHECK;
7279 sense = sata_arq_sense(spx);
7280 sense->es_key = KEY_ILLEGAL_REQUEST;
7281 sense->es_add_code = SD_SCSI_ASC_LBA_OUT_OF_RANGE;
7282
7283 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst,
7284 "Scsi_pkt completion reason %x\n", scsipkt->pkt_reason);
7285
7286 if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0 &&
7287 scsipkt->pkt_comp != NULL) {
7288 /* scsi callback required */
7289 if (servicing_interrupt()) {
7290 if (taskq_dispatch(SATA_TXLT_TASKQ(spx),
7291 (task_func_t *)spx->txlt_scsi_pkt->pkt_comp,
7292 (void *)spx->txlt_scsi_pkt, TQ_NOSLEEP) ==
7293 TASKQID_INVALID) {
7294 return (TRAN_BUSY);
7295 }
7296 } else if (taskq_dispatch(SATA_TXLT_TASKQ(spx),
7297 (task_func_t *)spx->txlt_scsi_pkt->pkt_comp,
7298 (void *)spx->txlt_scsi_pkt, TQ_SLEEP) == TASKQID_INVALID) {
7299 /* Scheduling the callback failed */
7300 return (TRAN_BUSY);
7301 }
7302 }
7303 return (TRAN_ACCEPT);
7304 }
7305
7306
7307 /*
7308 * Analyze device status and error registers and translate them into
7309 * appropriate scsi sense codes.
7310 * NOTE: non-packet commands only for now
7311 */
7312 static void
sata_decode_device_error(sata_pkt_txlate_t * spx,struct scsi_extended_sense * sense)7313 sata_decode_device_error(sata_pkt_txlate_t *spx,
7314 struct scsi_extended_sense *sense)
7315 {
7316 uint8_t err_reg = spx->txlt_sata_pkt->satapkt_cmd.satacmd_error_reg;
7317
7318 ASSERT(sense != NULL);
7319 ASSERT(spx->txlt_sata_pkt->satapkt_cmd.satacmd_status_reg &
7320 SATA_STATUS_ERR);
7321
7322
7323 if (err_reg & SATA_ERROR_ICRC) {
7324 sense->es_key = KEY_ABORTED_COMMAND;
7325 sense->es_add_code = 0x08; /* Communication failure */
7326 return;
7327 }
7328
7329 if (err_reg & SATA_ERROR_UNC) {
7330 sense->es_key = KEY_MEDIUM_ERROR;
7331 /* Information bytes (LBA) need to be set by a caller */
7332 return;
7333 }
7334
7335 /* ADD HERE: MC error bit handling for ATAPI CD/DVD */
7336 if (err_reg & (SATA_ERROR_MCR | SATA_ERROR_NM)) {
7337 sense->es_key = KEY_UNIT_ATTENTION;
7338 sense->es_add_code = 0x3a; /* No media present */
7339 return;
7340 }
7341
7342 if (err_reg & SATA_ERROR_IDNF) {
7343 if (err_reg & SATA_ERROR_ABORT) {
7344 sense->es_key = KEY_ABORTED_COMMAND;
7345 } else {
7346 sense->es_key = KEY_ILLEGAL_REQUEST;
7347 sense->es_add_code = 0x21; /* LBA out of range */
7348 }
7349 return;
7350 }
7351
7352 if (err_reg & SATA_ERROR_ABORT) {
7353 ASSERT(spx->txlt_sata_pkt != NULL);
7354 sense->es_key = KEY_ABORTED_COMMAND;
7355 return;
7356 }
7357 }
7358
7359 /*
7360 * Extract error LBA from sata_pkt.satapkt_cmd register fields
7361 */
7362 static void
sata_extract_error_lba(sata_pkt_txlate_t * spx,uint64_t * lba)7363 sata_extract_error_lba(sata_pkt_txlate_t *spx, uint64_t *lba)
7364 {
7365 sata_cmd_t *sata_cmd = &spx->txlt_sata_pkt->satapkt_cmd;
7366
7367 *lba = 0;
7368 if (sata_cmd->satacmd_addr_type == ATA_ADDR_LBA48) {
7369 *lba = sata_cmd->satacmd_lba_high_msb;
7370 *lba = (*lba << 8) | sata_cmd->satacmd_lba_mid_msb;
7371 *lba = (*lba << 8) | sata_cmd->satacmd_lba_low_msb;
7372 } else if (sata_cmd->satacmd_addr_type == ATA_ADDR_LBA28) {
7373 *lba = sata_cmd->satacmd_device_reg & 0xf;
7374 }
7375 *lba = (*lba << 8) | sata_cmd->satacmd_lba_high_lsb;
7376 *lba = (*lba << 8) | sata_cmd->satacmd_lba_mid_lsb;
7377 *lba = (*lba << 8) | sata_cmd->satacmd_lba_low_lsb;
7378 }
7379
7380 /*
7381 * This is fixed sense format - if LBA exceeds the info field size,
7382 * no valid info will be returned (valid bit in extended sense will
7383 * be set to 0).
7384 */
7385 static struct scsi_extended_sense *
sata_arq_sense(sata_pkt_txlate_t * spx)7386 sata_arq_sense(sata_pkt_txlate_t *spx)
7387 {
7388 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt;
7389 struct scsi_arq_status *arqs;
7390 struct scsi_extended_sense *sense;
7391
7392 /* Fill ARQ sense data */
7393 scsipkt->pkt_state |= STATE_ARQ_DONE;
7394 arqs = (struct scsi_arq_status *)scsipkt->pkt_scbp;
7395 *(uchar_t *)&arqs->sts_status = STATUS_CHECK;
7396 *(uchar_t *)&arqs->sts_rqpkt_status = STATUS_GOOD;
7397 arqs->sts_rqpkt_reason = CMD_CMPLT;
7398 arqs->sts_rqpkt_state = STATE_GOT_BUS | STATE_GOT_TARGET |
7399 STATE_XFERRED_DATA | STATE_SENT_CMD | STATE_GOT_STATUS;
7400 arqs->sts_rqpkt_resid = 0;
7401 sense = &arqs->sts_sensedata;
7402 bzero(sense, sizeof (struct scsi_extended_sense));
7403 sata_fixed_sense_data_preset(sense);
7404 return (sense);
7405 }
7406
7407 /*
7408 * ATA Pass Through support
7409 * Sets flags indicating that an invalid value was found in some
7410 * field in the command. It could be something illegal according to
7411 * the SAT-2 spec or it could be a feature that is not (yet?)
7412 * supported.
7413 */
7414 static int
sata_txlt_ata_pass_thru_illegal_cmd(sata_pkt_txlate_t * spx)7415 sata_txlt_ata_pass_thru_illegal_cmd(sata_pkt_txlate_t *spx)
7416 {
7417 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt;
7418 struct scsi_extended_sense *sense = sata_arq_sense(spx);
7419
7420 scsipkt->pkt_reason = CMD_CMPLT;
7421 *scsipkt->pkt_scbp = STATUS_CHECK;
7422 scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET |
7423 STATE_SENT_CMD | STATE_GOT_STATUS;
7424
7425 sense = sata_arq_sense(spx);
7426 sense->es_key = KEY_ILLEGAL_REQUEST;
7427 sense->es_add_code = SD_SCSI_ASC_INVALID_FIELD_IN_CDB;
7428
7429 if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0 &&
7430 scsipkt->pkt_comp != NULL) {
7431 /* scsi callback required */
7432 if (servicing_interrupt()) {
7433 if (taskq_dispatch(SATA_TXLT_TASKQ(spx),
7434 (task_func_t *)spx->txlt_scsi_pkt->pkt_comp,
7435 (void *)spx->txlt_scsi_pkt, TQ_NOSLEEP) ==
7436 TASKQID_INVALID) {
7437 return (TRAN_BUSY);
7438 }
7439 } else if (taskq_dispatch(SATA_TXLT_TASKQ(spx),
7440 (task_func_t *)spx->txlt_scsi_pkt->pkt_comp,
7441 (void *)spx->txlt_scsi_pkt, TQ_SLEEP) == TASKQID_INVALID) {
7442 /* Scheduling the callback failed */
7443 return (TRAN_BUSY);
7444 }
7445 }
7446
7447 return (TRAN_ACCEPT);
7448 }
7449
7450 /*
7451 * The UNMAP command considers it not to be an error if the parameter length
7452 * or block descriptor length is 0. For this case, there is nothing for TRIM
7453 * to do so just complete the command.
7454 */
7455 static int
sata_txlt_unmap_nodata_cmd(sata_pkt_txlate_t * spx)7456 sata_txlt_unmap_nodata_cmd(sata_pkt_txlate_t *spx)
7457 {
7458 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt;
7459
7460 scsipkt->pkt_reason = CMD_CMPLT;
7461 *scsipkt->pkt_scbp = STATUS_GOOD;
7462 scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET |
7463 STATE_SENT_CMD | STATE_GOT_STATUS;
7464
7465 if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0 &&
7466 scsipkt->pkt_comp != NULL) {
7467 /* scsi callback required */
7468 if (taskq_dispatch(SATA_TXLT_TASKQ(spx),
7469 (task_func_t *)spx->txlt_scsi_pkt->pkt_comp,
7470 (void *)spx->txlt_scsi_pkt, TQ_SLEEP) == TASKQID_INVALID) {
7471 /* Scheduling the callback failed */
7472 return (TRAN_BUSY);
7473 }
7474 }
7475
7476 return (TRAN_ACCEPT);
7477 }
7478
7479 /*
7480 * Emulated SATA Read/Write command completion for zero-length requests.
7481 * This request always succedes, so in synchronous mode it always returns
7482 * TRAN_ACCEPT, and in non-synchronous mode it may return TRAN_BUSY if the
7483 * callback cannot be scheduled.
7484 */
7485 static int
sata_emul_rw_completion(sata_pkt_txlate_t * spx)7486 sata_emul_rw_completion(sata_pkt_txlate_t *spx)
7487 {
7488 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt;
7489
7490 scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET |
7491 STATE_SENT_CMD | STATE_GOT_STATUS;
7492 scsipkt->pkt_reason = CMD_CMPLT;
7493 *scsipkt->pkt_scbp = STATUS_GOOD;
7494 if (!(spx->txlt_sata_pkt->satapkt_op_mode & SATA_OPMODE_SYNCH)) {
7495 /* scsi callback required - have to schedule it */
7496 if (servicing_interrupt()) {
7497 if (taskq_dispatch(SATA_TXLT_TASKQ(spx),
7498 (task_func_t *)spx->txlt_scsi_pkt->pkt_comp,
7499 (void *)spx->txlt_scsi_pkt, TQ_NOSLEEP) ==
7500 TASKQID_INVALID) {
7501 return (TRAN_BUSY);
7502 }
7503 } else if (taskq_dispatch(SATA_TXLT_TASKQ(spx),
7504 (task_func_t *)spx->txlt_scsi_pkt->pkt_comp,
7505 (void *)spx->txlt_scsi_pkt, TQ_SLEEP) == TASKQID_INVALID) {
7506 /* Scheduling the callback failed */
7507 return (TRAN_BUSY);
7508 }
7509 }
7510 return (TRAN_ACCEPT);
7511 }
7512
7513
7514 /*
7515 * Translate completion status of SATA read/write commands into scsi response.
7516 * pkt completion_reason is checked to determine the completion status.
7517 * Do scsi callback if necessary.
7518 *
7519 * Note: this function may be called also for synchronously executed
7520 * commands.
7521 * This function may be used only if scsi_pkt is non-NULL.
7522 */
7523 static void
sata_txlt_rw_completion(sata_pkt_t * sata_pkt)7524 sata_txlt_rw_completion(sata_pkt_t *sata_pkt)
7525 {
7526 sata_pkt_txlate_t *spx =
7527 (sata_pkt_txlate_t *)sata_pkt->satapkt_framework_private;
7528 sata_cmd_t *scmd = &sata_pkt->satapkt_cmd;
7529 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt;
7530 struct scsi_extended_sense *sense;
7531 uint64_t lba;
7532 struct buf *bp;
7533 int rval;
7534 if (sata_pkt->satapkt_reason == SATA_PKT_COMPLETED) {
7535 /* Normal completion */
7536 scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET |
7537 STATE_SENT_CMD | STATE_XFERRED_DATA | STATE_GOT_STATUS;
7538 scsipkt->pkt_reason = CMD_CMPLT;
7539 *scsipkt->pkt_scbp = STATUS_GOOD;
7540 if (spx->txlt_tmp_buf != NULL) {
7541 /* Temporary buffer was used */
7542 bp = spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp;
7543 if (bp->b_flags & B_READ) {
7544 rval = ddi_dma_sync(
7545 spx->txlt_buf_dma_handle, 0, 0,
7546 DDI_DMA_SYNC_FORCPU);
7547 ASSERT(rval == DDI_SUCCESS);
7548 bcopy(spx->txlt_tmp_buf, bp->b_un.b_addr,
7549 bp->b_bcount);
7550 }
7551 }
7552 } else {
7553 /*
7554 * Something went wrong - analyze return
7555 */
7556 scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET |
7557 STATE_SENT_CMD | STATE_GOT_STATUS;
7558 scsipkt->pkt_reason = CMD_INCOMPLETE;
7559 *scsipkt->pkt_scbp = STATUS_CHECK;
7560 sense = sata_arq_sense(spx);
7561 ASSERT(sense != NULL);
7562
7563 /*
7564 * SATA_PKT_DEV_ERROR is the only case where we may be able to
7565 * extract from device registers the failing LBA.
7566 */
7567 if (sata_pkt->satapkt_reason == SATA_PKT_DEV_ERROR) {
7568 if ((scmd->satacmd_addr_type == ATA_ADDR_LBA48) &&
7569 (scmd->satacmd_lba_mid_msb != 0 ||
7570 scmd->satacmd_lba_high_msb != 0)) {
7571 /*
7572 * We have problem reporting this cmd LBA
7573 * in fixed sense data format, because of
7574 * the size of the scsi LBA fields.
7575 */
7576 sense->es_valid = 0;
7577 } else {
7578 sata_extract_error_lba(spx, &lba);
7579 sense->es_info_1 = (lba & 0xFF000000) >> 24;
7580 sense->es_info_2 = (lba & 0xFF0000) >> 16;
7581 sense->es_info_3 = (lba & 0xFF00) >> 8;
7582 sense->es_info_4 = lba & 0xFF;
7583 }
7584 } else {
7585 /* Invalid extended sense info */
7586 sense->es_valid = 0;
7587 }
7588
7589 switch (sata_pkt->satapkt_reason) {
7590 case SATA_PKT_PORT_ERROR:
7591 /* We may want to handle DEV GONE state as well */
7592 /*
7593 * We have no device data. Assume no data transfered.
7594 */
7595 sense->es_key = KEY_HARDWARE_ERROR;
7596 break;
7597
7598 case SATA_PKT_DEV_ERROR:
7599 if (sata_pkt->satapkt_cmd.satacmd_status_reg &
7600 SATA_STATUS_ERR) {
7601 /*
7602 * determine dev error reason from error
7603 * reg content
7604 */
7605 sata_decode_device_error(spx, sense);
7606 if (sense->es_key == KEY_MEDIUM_ERROR) {
7607 switch (scmd->satacmd_cmd_reg) {
7608 case SATAC_READ_DMA:
7609 case SATAC_READ_DMA_EXT:
7610 case SATAC_READ_DMA_QUEUED:
7611 case SATAC_READ_DMA_QUEUED_EXT:
7612 case SATAC_READ_FPDMA_QUEUED:
7613 /* Unrecovered read error */
7614 sense->es_add_code =
7615 SD_SCSI_ASC_UNREC_READ_ERR;
7616 break;
7617 case SATAC_WRITE_DMA:
7618 case SATAC_WRITE_DMA_EXT:
7619 case SATAC_WRITE_DMA_QUEUED:
7620 case SATAC_WRITE_DMA_QUEUED_EXT:
7621 case SATAC_WRITE_FPDMA_QUEUED:
7622 /* Write error */
7623 sense->es_add_code =
7624 SD_SCSI_ASC_WRITE_ERR;
7625 break;
7626 default:
7627 /* Internal error */
7628 SATA_LOG_D((
7629 spx->txlt_sata_hba_inst,
7630 CE_WARN,
7631 "sata_txlt_rw_completion :"
7632 "internal error - invalid "
7633 "command 0x%2x",
7634 scmd->satacmd_cmd_reg));
7635 break;
7636 }
7637 }
7638 break;
7639 }
7640 /* No extended sense key - no info available */
7641 scsipkt->pkt_reason = CMD_INCOMPLETE;
7642 break;
7643
7644 case SATA_PKT_TIMEOUT:
7645 scsipkt->pkt_reason = CMD_TIMEOUT;
7646 scsipkt->pkt_statistics |=
7647 STAT_TIMEOUT | STAT_DEV_RESET;
7648 sense->es_key = KEY_ABORTED_COMMAND;
7649 break;
7650
7651 case SATA_PKT_ABORTED:
7652 scsipkt->pkt_reason = CMD_ABORTED;
7653 scsipkt->pkt_statistics |= STAT_ABORTED;
7654 sense->es_key = KEY_ABORTED_COMMAND;
7655 break;
7656
7657 case SATA_PKT_RESET:
7658 scsipkt->pkt_reason = CMD_RESET;
7659 scsipkt->pkt_statistics |= STAT_DEV_RESET;
7660 sense->es_key = KEY_ABORTED_COMMAND;
7661 break;
7662
7663 default:
7664 SATA_LOG_D((spx->txlt_sata_hba_inst, CE_WARN,
7665 "sata_txlt_rw_completion: "
7666 "invalid packet completion reason"));
7667 scsipkt->pkt_reason = CMD_TRAN_ERR;
7668 break;
7669 }
7670 }
7671 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst,
7672 "Scsi_pkt completion reason %x\n", scsipkt->pkt_reason);
7673
7674 if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0)
7675 /* scsi callback required */
7676 scsi_hba_pkt_comp(scsipkt);
7677 }
7678
7679
7680 /*
7681 * Translate completion status of non-data commands (i.e. commands returning
7682 * no data).
7683 * pkt completion_reason is checked to determine the completion status.
7684 * Do scsi callback if necessary (FLAG_NOINTR == 0)
7685 *
7686 * Note: this function may be called also for synchronously executed
7687 * commands.
7688 * This function may be used only if scsi_pkt is non-NULL.
7689 */
7690
7691 static void
sata_txlt_nodata_cmd_completion(sata_pkt_t * sata_pkt)7692 sata_txlt_nodata_cmd_completion(sata_pkt_t *sata_pkt)
7693 {
7694 sata_pkt_txlate_t *spx =
7695 (sata_pkt_txlate_t *)sata_pkt->satapkt_framework_private;
7696 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt;
7697
7698 sata_set_arq_data(sata_pkt);
7699
7700 if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0)
7701 /* scsi callback required */
7702 scsi_hba_pkt_comp(scsipkt);
7703 }
7704
7705 /*
7706 * Completion handler for ATA Pass Through command
7707 */
7708 static void
sata_txlt_apt_completion(sata_pkt_t * sata_pkt)7709 sata_txlt_apt_completion(sata_pkt_t *sata_pkt)
7710 {
7711 sata_pkt_txlate_t *spx =
7712 (sata_pkt_txlate_t *)sata_pkt->satapkt_framework_private;
7713 sata_cmd_t *scmd = &sata_pkt->satapkt_cmd;
7714 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt;
7715 struct buf *bp;
7716 uint8_t sense_key = 0, addl_sense_code = 0, addl_sense_qual = 0;
7717
7718 if (sata_pkt->satapkt_reason == SATA_PKT_COMPLETED) {
7719 /* Normal completion */
7720 scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET |
7721 STATE_SENT_CMD | STATE_XFERRED_DATA | STATE_GOT_STATUS;
7722 scsipkt->pkt_reason = CMD_CMPLT;
7723 *scsipkt->pkt_scbp = STATUS_GOOD;
7724
7725 /*
7726 * If the command has CK_COND set
7727 */
7728 if (scsipkt->pkt_cdbp[2] & SATL_APT_BM_CK_COND) {
7729 *scsipkt->pkt_scbp = STATUS_CHECK;
7730 sata_fill_ata_return_desc(sata_pkt,
7731 KEY_RECOVERABLE_ERROR,
7732 SD_SCSI_ASC_APT_INFO_AVAIL, 0x1d);
7733 }
7734
7735 if (spx->txlt_tmp_buf != NULL) {
7736 /* Temporary buffer was used */
7737 bp = spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp;
7738 if (bp->b_flags & B_READ) {
7739 bcopy(spx->txlt_tmp_buf, bp->b_un.b_addr,
7740 bp->b_bcount);
7741 }
7742 }
7743 } else {
7744 scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET |
7745 STATE_SENT_CMD | STATE_GOT_STATUS;
7746 scsipkt->pkt_reason = CMD_INCOMPLETE;
7747 *scsipkt->pkt_scbp = STATUS_CHECK;
7748
7749 /*
7750 * If DF or ERR was set, the HBA should have copied out the
7751 * status and error registers to the satacmd structure.
7752 */
7753 if (scmd->satacmd_status_reg & SATA_STATUS_DF) {
7754 sense_key = KEY_HARDWARE_ERROR;
7755 addl_sense_code = SD_SCSI_ASC_INTERNAL_TARGET_FAILURE;
7756 addl_sense_qual = 0;
7757 } else if (scmd->satacmd_status_reg & SATA_STATUS_ERR) {
7758 if (scmd->satacmd_error_reg & SATA_ERROR_NM) {
7759 sense_key = KEY_NOT_READY;
7760 addl_sense_code =
7761 SD_SCSI_ASC_MEDIUM_NOT_PRESENT;
7762 addl_sense_qual = 0;
7763 } else if (scmd->satacmd_error_reg & SATA_ERROR_UNC) {
7764 sense_key = KEY_MEDIUM_ERROR;
7765 addl_sense_code = SD_SCSI_ASC_UNREC_READ_ERR;
7766 addl_sense_qual = 0;
7767 } else if (scmd->satacmd_error_reg & SATA_ERROR_ILI) {
7768 sense_key = KEY_DATA_PROTECT;
7769 addl_sense_code = SD_SCSI_ASC_WRITE_PROTECTED;
7770 addl_sense_qual = 0;
7771 } else if (scmd->satacmd_error_reg & SATA_ERROR_IDNF) {
7772 sense_key = KEY_ILLEGAL_REQUEST;
7773 addl_sense_code = SD_SCSI_ASC_LBA_OUT_OF_RANGE;
7774 addl_sense_qual = 0;
7775 } else if (scmd->satacmd_error_reg & SATA_ERROR_ABORT) {
7776 sense_key = KEY_ABORTED_COMMAND;
7777 addl_sense_code = SD_SCSI_ASC_NO_ADD_SENSE;
7778 addl_sense_qual = 0;
7779 } else if (scmd->satacmd_error_reg & SATA_ERROR_MC) {
7780 sense_key = KEY_UNIT_ATTENTION;
7781 addl_sense_code =
7782 SD_SCSI_ASC_MEDIUM_MAY_HAVE_CHANGED;
7783 addl_sense_qual = 0;
7784 } else if (scmd->satacmd_error_reg & SATA_ERROR_MCR) {
7785 sense_key = KEY_UNIT_ATTENTION;
7786 addl_sense_code = SD_SCSI_ASC_OP_MEDIUM_REM_REQ;
7787 addl_sense_qual = 0;
7788 } else if (scmd->satacmd_error_reg & SATA_ERROR_ICRC) {
7789 sense_key = KEY_ABORTED_COMMAND;
7790 addl_sense_code =
7791 SD_SCSI_ASC_INFO_UNIT_IUCRC_ERR;
7792 addl_sense_qual = 0;
7793 }
7794 }
7795
7796 sata_fill_ata_return_desc(sata_pkt, sense_key, addl_sense_code,
7797 addl_sense_qual);
7798 }
7799
7800 if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0)
7801 /* scsi callback required */
7802 scsi_hba_pkt_comp(scsipkt);
7803 }
7804
7805 /*
7806 * Completion handler for unmap translation command
7807 */
7808 static void
sata_txlt_unmap_completion(sata_pkt_t * sata_pkt)7809 sata_txlt_unmap_completion(sata_pkt_t *sata_pkt)
7810 {
7811 sata_pkt_txlate_t *spx =
7812 (sata_pkt_txlate_t *)sata_pkt->satapkt_framework_private;
7813 sata_cmd_t *scmd = &sata_pkt->satapkt_cmd;
7814 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt;
7815 struct buf *bp;
7816 uint8_t sense_key = 0, addl_sense_code = 0, addl_sense_qual = 0;
7817
7818 if (sata_pkt->satapkt_reason == SATA_PKT_COMPLETED) {
7819 /* Normal completion */
7820 scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET |
7821 STATE_SENT_CMD | STATE_XFERRED_DATA | STATE_GOT_STATUS;
7822 scsipkt->pkt_reason = CMD_CMPLT;
7823 *scsipkt->pkt_scbp = STATUS_GOOD;
7824
7825 if (spx->txlt_tmp_buf != NULL) {
7826 /* Temporary buffer was used */
7827 bp = spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp;
7828 if (bp->b_flags & B_READ) {
7829 bcopy(spx->txlt_tmp_buf, bp->b_un.b_addr,
7830 bp->b_bcount);
7831 }
7832 }
7833 } else {
7834 scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET |
7835 STATE_SENT_CMD | STATE_GOT_STATUS;
7836 scsipkt->pkt_reason = CMD_INCOMPLETE;
7837 *scsipkt->pkt_scbp = STATUS_CHECK;
7838
7839 /*
7840 * If DF or ERR was set, the HBA should have copied out the
7841 * status and error registers to the satacmd structure.
7842 */
7843 if (scmd->satacmd_status_reg & SATA_STATUS_DF) {
7844 sense_key = KEY_HARDWARE_ERROR;
7845 addl_sense_code = SD_SCSI_ASC_INTERNAL_TARGET_FAILURE;
7846 addl_sense_qual = 0;
7847 } else if (scmd->satacmd_status_reg & SATA_STATUS_ERR) {
7848 if (scmd->satacmd_error_reg & SATA_ERROR_NM) {
7849 sense_key = KEY_NOT_READY;
7850 addl_sense_code =
7851 SD_SCSI_ASC_MEDIUM_NOT_PRESENT;
7852 addl_sense_qual = 0;
7853 } else if (scmd->satacmd_error_reg & SATA_ERROR_UNC) {
7854 sense_key = KEY_MEDIUM_ERROR;
7855 addl_sense_code = SD_SCSI_ASC_WRITE_ERR;
7856 addl_sense_qual = 0;
7857 } else if (scmd->satacmd_error_reg & SATA_ERROR_ILI) {
7858 sense_key = KEY_DATA_PROTECT;
7859 addl_sense_code = SD_SCSI_ASC_WRITE_PROTECTED;
7860 addl_sense_qual = 0;
7861 } else if (scmd->satacmd_error_reg & SATA_ERROR_IDNF) {
7862 sense_key = KEY_ILLEGAL_REQUEST;
7863 addl_sense_code = SD_SCSI_ASC_LBA_OUT_OF_RANGE;
7864 addl_sense_qual = 0;
7865 } else if (scmd->satacmd_error_reg & SATA_ERROR_ABORT) {
7866 sense_key = KEY_ABORTED_COMMAND;
7867 addl_sense_code = SD_SCSI_ASC_NO_ADD_SENSE;
7868 addl_sense_qual = 0;
7869 } else if (scmd->satacmd_error_reg & SATA_ERROR_MC) {
7870 sense_key = KEY_UNIT_ATTENTION;
7871 addl_sense_code =
7872 SD_SCSI_ASC_MEDIUM_MAY_HAVE_CHANGED;
7873 addl_sense_qual = 0;
7874 } else if (scmd->satacmd_error_reg & SATA_ERROR_MCR) {
7875 sense_key = KEY_UNIT_ATTENTION;
7876 addl_sense_code = SD_SCSI_ASC_OP_MEDIUM_REM_REQ;
7877 addl_sense_qual = 0;
7878 } else if (scmd->satacmd_error_reg & SATA_ERROR_ICRC) {
7879 sense_key = KEY_ABORTED_COMMAND;
7880 addl_sense_code =
7881 SD_SCSI_ASC_INFO_UNIT_IUCRC_ERR;
7882 addl_sense_qual = 0;
7883 }
7884 }
7885
7886 sata_fill_ata_return_desc(sata_pkt, sense_key, addl_sense_code,
7887 addl_sense_qual);
7888 }
7889
7890 sata_free_local_buffer(spx);
7891
7892 if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0)
7893 /* scsi callback required */
7894 scsi_hba_pkt_comp(scsipkt);
7895 }
7896
7897 /*
7898 *
7899 */
7900 static void
sata_fill_ata_return_desc(sata_pkt_t * sata_pkt,uint8_t sense_key,uint8_t addl_sense_code,uint8_t addl_sense_qual)7901 sata_fill_ata_return_desc(sata_pkt_t *sata_pkt, uint8_t sense_key,
7902 uint8_t addl_sense_code, uint8_t addl_sense_qual)
7903 {
7904 sata_pkt_txlate_t *spx =
7905 (sata_pkt_txlate_t *)sata_pkt->satapkt_framework_private;
7906 sata_cmd_t *scmd = &sata_pkt->satapkt_cmd;
7907 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt;
7908 struct sata_apt_sense_data *apt_sd =
7909 (struct sata_apt_sense_data *)scsipkt->pkt_scbp;
7910 struct scsi_descr_sense_hdr *sds = &(apt_sd->apt_sd_hdr);
7911 struct scsi_ata_status_ret_sense_descr *ata_ret_desc =
7912 &(apt_sd->apt_sd_sense);
7913 int extend = 0;
7914
7915 if ((scsipkt->pkt_cdbp[0] == SPC3_CMD_ATA_COMMAND_PASS_THROUGH16) &&
7916 (scsipkt->pkt_cdbp[2] & SATL_APT_BM_EXTEND))
7917 extend = 1;
7918
7919 scsipkt->pkt_state |= STATE_ARQ_DONE;
7920
7921 /* update the residual count */
7922 *(uchar_t *)&apt_sd->apt_status = STATUS_CHECK;
7923 *(uchar_t *)&apt_sd->apt_rqpkt_status = STATUS_GOOD;
7924 apt_sd->apt_rqpkt_reason = CMD_CMPLT;
7925 apt_sd->apt_rqpkt_state = STATE_GOT_BUS | STATE_GOT_TARGET |
7926 STATE_XFERRED_DATA | STATE_SENT_CMD | STATE_GOT_STATUS;
7927 apt_sd->apt_rqpkt_resid = scsipkt->pkt_scblen -
7928 sizeof (struct sata_apt_sense_data);
7929
7930 /*
7931 * Fill in the Descriptor sense header
7932 */
7933 bzero(sds, sizeof (struct scsi_descr_sense_hdr));
7934 sds->ds_code = CODE_FMT_DESCR_CURRENT;
7935 sds->ds_class = CLASS_EXTENDED_SENSE;
7936 sds->ds_key = sense_key & 0xf;
7937 sds->ds_add_code = addl_sense_code;
7938 sds->ds_qual_code = addl_sense_qual;
7939 sds->ds_addl_sense_length =
7940 sizeof (struct scsi_ata_status_ret_sense_descr);
7941
7942 /*
7943 * Fill in the ATA Return descriptor sense data
7944 */
7945 bzero(ata_ret_desc, sizeof (struct scsi_ata_status_ret_sense_descr));
7946 ata_ret_desc->ars_descr_type = DESCR_ATA_STATUS_RETURN;
7947 ata_ret_desc->ars_addl_length = 0xc;
7948 ata_ret_desc->ars_error = scmd->satacmd_error_reg;
7949 ata_ret_desc->ars_sec_count_lsb = scmd->satacmd_sec_count_lsb;
7950 ata_ret_desc->ars_lba_low_lsb = scmd->satacmd_lba_low_lsb;
7951 ata_ret_desc->ars_lba_mid_lsb = scmd->satacmd_lba_mid_lsb;
7952 ata_ret_desc->ars_lba_high_lsb = scmd->satacmd_lba_high_lsb;
7953 ata_ret_desc->ars_device = scmd->satacmd_device_reg;
7954 ata_ret_desc->ars_status = scmd->satacmd_status_reg;
7955
7956 if (extend == 1) {
7957 ata_ret_desc->ars_extend = 1;
7958 ata_ret_desc->ars_sec_count_msb = scmd->satacmd_sec_count_msb;
7959 ata_ret_desc->ars_lba_low_msb = scmd->satacmd_lba_low_msb;
7960 ata_ret_desc->ars_lba_mid_msb = scmd->satacmd_lba_mid_msb;
7961 ata_ret_desc->ars_lba_high_msb = scmd->satacmd_lba_high_msb;
7962 } else {
7963 ata_ret_desc->ars_extend = 0;
7964 ata_ret_desc->ars_sec_count_msb = 0;
7965 ata_ret_desc->ars_lba_low_msb = 0;
7966 ata_ret_desc->ars_lba_mid_msb = 0;
7967 ata_ret_desc->ars_lba_high_msb = 0;
7968 }
7969 }
7970
7971 static void
sata_set_arq_data(sata_pkt_t * sata_pkt)7972 sata_set_arq_data(sata_pkt_t *sata_pkt)
7973 {
7974 sata_pkt_txlate_t *spx =
7975 (sata_pkt_txlate_t *)sata_pkt->satapkt_framework_private;
7976 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt;
7977 struct scsi_extended_sense *sense;
7978
7979 scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET |
7980 STATE_SENT_CMD | STATE_GOT_STATUS;
7981 if (sata_pkt->satapkt_reason == SATA_PKT_COMPLETED) {
7982 /* Normal completion */
7983 scsipkt->pkt_reason = CMD_CMPLT;
7984 *scsipkt->pkt_scbp = STATUS_GOOD;
7985 } else {
7986 /* Something went wrong */
7987 scsipkt->pkt_reason = CMD_INCOMPLETE;
7988 *scsipkt->pkt_scbp = STATUS_CHECK;
7989 sense = sata_arq_sense(spx);
7990 switch (sata_pkt->satapkt_reason) {
7991 case SATA_PKT_PORT_ERROR:
7992 /*
7993 * We have no device data. Assume no data transfered.
7994 */
7995 sense->es_key = KEY_HARDWARE_ERROR;
7996 break;
7997
7998 case SATA_PKT_DEV_ERROR:
7999 if (sata_pkt->satapkt_cmd.satacmd_status_reg &
8000 SATA_STATUS_ERR) {
8001 /*
8002 * determine dev error reason from error
8003 * reg content
8004 */
8005 sata_decode_device_error(spx, sense);
8006 break;
8007 }
8008 /* No extended sense key - no info available */
8009 break;
8010
8011 case SATA_PKT_TIMEOUT:
8012 scsipkt->pkt_reason = CMD_TIMEOUT;
8013 scsipkt->pkt_statistics |=
8014 STAT_TIMEOUT | STAT_DEV_RESET;
8015 /* No extended sense key ? */
8016 break;
8017
8018 case SATA_PKT_ABORTED:
8019 scsipkt->pkt_reason = CMD_ABORTED;
8020 scsipkt->pkt_statistics |= STAT_ABORTED;
8021 /* No extended sense key ? */
8022 break;
8023
8024 case SATA_PKT_RESET:
8025 /* pkt aborted by an explicit reset from a host */
8026 scsipkt->pkt_reason = CMD_RESET;
8027 scsipkt->pkt_statistics |= STAT_DEV_RESET;
8028 break;
8029
8030 default:
8031 SATA_LOG_D((spx->txlt_sata_hba_inst, CE_WARN,
8032 "sata_txlt_nodata_cmd_completion: "
8033 "invalid packet completion reason %d",
8034 sata_pkt->satapkt_reason));
8035 scsipkt->pkt_reason = CMD_TRAN_ERR;
8036 break;
8037 }
8038
8039 }
8040 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst,
8041 "Scsi_pkt completion reason %x\n", scsipkt->pkt_reason);
8042 }
8043
8044
8045 /*
8046 * Build Mode sense R/W recovery page
8047 * NOT IMPLEMENTED
8048 */
8049
8050 static int
sata_build_msense_page_1(sata_drive_info_t * sdinfo,int pcntrl,uint8_t * buf)8051 sata_build_msense_page_1(sata_drive_info_t *sdinfo, int pcntrl, uint8_t *buf)
8052 {
8053 #ifndef __lock_lint
8054 _NOTE(ARGUNUSED(sdinfo))
8055 _NOTE(ARGUNUSED(pcntrl))
8056 _NOTE(ARGUNUSED(buf))
8057 #endif
8058 return (0);
8059 }
8060
8061 /*
8062 * Build Mode sense caching page - scsi-3 implementation.
8063 * Page length distinguishes previous format from scsi-3 format.
8064 * buf must have space for 0x12 bytes.
8065 * Only DRA (disable read ahead ) and WCE (write cache enable) are changeable.
8066 *
8067 */
8068 static int
sata_build_msense_page_8(sata_drive_info_t * sdinfo,int pcntrl,uint8_t * buf)8069 sata_build_msense_page_8(sata_drive_info_t *sdinfo, int pcntrl, uint8_t *buf)
8070 {
8071 struct mode_cache_scsi3 *page = (struct mode_cache_scsi3 *)buf;
8072 sata_id_t *sata_id = &sdinfo->satadrv_id;
8073
8074 /*
8075 * Most of the fields are set to 0, being not supported and/or disabled
8076 */
8077 bzero(buf, PAGELENGTH_DAD_MODE_CACHE_SCSI3);
8078
8079 /* Saved paramters not supported */
8080 if (pcntrl == 3)
8081 return (0);
8082 if (pcntrl == 0 || pcntrl == 2) {
8083 /*
8084 * For now treat current and default parameters as same
8085 * That may have to change, if target driver will complain
8086 */
8087 page->mode_page.code = MODEPAGE_CACHING; /* PS = 0 */
8088 page->mode_page.length = PAGELENGTH_DAD_MODE_CACHE_SCSI3;
8089
8090 if (SATA_READ_AHEAD_SUPPORTED(*sata_id) &&
8091 !SATA_READ_AHEAD_ENABLED(*sata_id)) {
8092 page->dra = 1; /* Read Ahead disabled */
8093 page->rcd = 1; /* Read Cache disabled */
8094 }
8095 if (SATA_WRITE_CACHE_SUPPORTED(*sata_id) &&
8096 SATA_WRITE_CACHE_ENABLED(*sata_id))
8097 page->wce = 1; /* Write Cache enabled */
8098 } else {
8099 /* Changeable parameters */
8100 page->mode_page.code = MODEPAGE_CACHING;
8101 page->mode_page.length = PAGELENGTH_DAD_MODE_CACHE_SCSI3;
8102 if (SATA_READ_AHEAD_SUPPORTED(*sata_id)) {
8103 page->dra = 1;
8104 page->rcd = 1;
8105 }
8106 if (SATA_WRITE_CACHE_SUPPORTED(*sata_id))
8107 page->wce = 1;
8108 }
8109 return (PAGELENGTH_DAD_MODE_CACHE_SCSI3 +
8110 sizeof (struct mode_page));
8111 }
8112
8113 /*
8114 * Build Mode sense exception cntrl page
8115 */
8116 static int
sata_build_msense_page_1c(sata_drive_info_t * sdinfo,int pcntrl,uint8_t * buf)8117 sata_build_msense_page_1c(sata_drive_info_t *sdinfo, int pcntrl, uint8_t *buf)
8118 {
8119 struct mode_info_excpt_page *page = (struct mode_info_excpt_page *)buf;
8120 sata_id_t *sata_id = &sdinfo->satadrv_id;
8121
8122 /*
8123 * Most of the fields are set to 0, being not supported and/or disabled
8124 */
8125 bzero(buf, PAGELENGTH_INFO_EXCPT);
8126
8127 page->mode_page.code = MODEPAGE_INFO_EXCPT;
8128 page->mode_page.length = PAGELENGTH_INFO_EXCPT;
8129
8130 /* Indicate that this is page is saveable */
8131 page->mode_page.ps = 1;
8132
8133 /*
8134 * We will return the same data for default, current and saved page.
8135 * The only changeable bit is dexcpt and that bit is required
8136 * by the ATA specification to be preserved across power cycles.
8137 */
8138 if (pcntrl != 1) {
8139 page->dexcpt = !(sata_id->ai_features85 & SATA_SMART_SUPPORTED);
8140 page->mrie = MRIE_ONLY_ON_REQUEST;
8141 }
8142 else
8143 page->dexcpt = 1; /* Only changeable parameter */
8144
8145 return (PAGELENGTH_INFO_EXCPT + sizeof (struct mode_page));
8146 }
8147
8148
8149 static int
sata_build_msense_page_30(sata_drive_info_t * sdinfo,int pcntrl,uint8_t * buf)8150 sata_build_msense_page_30(sata_drive_info_t *sdinfo, int pcntrl, uint8_t *buf)
8151 {
8152 struct mode_acoustic_management *page =
8153 (struct mode_acoustic_management *)buf;
8154 sata_id_t *sata_id = &sdinfo->satadrv_id;
8155
8156 /*
8157 * Most of the fields are set to 0, being not supported and/or disabled
8158 */
8159 bzero(buf, PAGELENGTH_DAD_MODE_ACOUSTIC_MANAGEMENT);
8160
8161 switch (pcntrl) {
8162 case P_CNTRL_DEFAULT:
8163 /* default paramters not supported */
8164 return (0);
8165
8166 case P_CNTRL_CURRENT:
8167 case P_CNTRL_SAVED:
8168 /* Saved and current are supported and are identical */
8169 page->mode_page.code = MODEPAGE_ACOUSTIC_MANAG;
8170 page->mode_page.length =
8171 PAGELENGTH_DAD_MODE_ACOUSTIC_MANAGEMENT;
8172 page->mode_page.ps = 1;
8173
8174 /* Word 83 indicates if feature is supported */
8175 /* If feature is not supported */
8176 if (!(sata_id->ai_cmdset83 & SATA_ACOUSTIC_MGMT)) {
8177 page->acoustic_manag_enable =
8178 ACOUSTIC_DISABLED;
8179 } else {
8180 page->acoustic_manag_enable =
8181 ((sata_id->ai_features86 & SATA_ACOUSTIC_MGMT)
8182 != 0);
8183 /* Word 94 inidicates the value */
8184 #ifdef _LITTLE_ENDIAN
8185 page->acoustic_manag_level =
8186 (uchar_t)sata_id->ai_acoustic;
8187 page->vendor_recommended_value =
8188 sata_id->ai_acoustic >> 8;
8189 #else
8190 page->acoustic_manag_level =
8191 sata_id->ai_acoustic >> 8;
8192 page->vendor_recommended_value =
8193 (uchar_t)sata_id->ai_acoustic;
8194 #endif
8195 }
8196 break;
8197
8198 case P_CNTRL_CHANGEABLE:
8199 page->mode_page.code = MODEPAGE_ACOUSTIC_MANAG;
8200 page->mode_page.length =
8201 PAGELENGTH_DAD_MODE_ACOUSTIC_MANAGEMENT;
8202 page->mode_page.ps = 1;
8203
8204 /* Word 83 indicates if the feature is supported */
8205 if (sata_id->ai_cmdset83 & SATA_ACOUSTIC_MGMT) {
8206 page->acoustic_manag_enable =
8207 ACOUSTIC_ENABLED;
8208 page->acoustic_manag_level = 0xff;
8209 }
8210 break;
8211 }
8212 return (PAGELENGTH_DAD_MODE_ACOUSTIC_MANAGEMENT +
8213 sizeof (struct mode_page));
8214 }
8215
8216
8217 /*
8218 * Build Mode sense power condition page.
8219 */
8220 static int
sata_build_msense_page_1a(sata_drive_info_t * sdinfo,int pcntrl,uint8_t * buf)8221 sata_build_msense_page_1a(sata_drive_info_t *sdinfo, int pcntrl, uint8_t *buf)
8222 {
8223 struct mode_info_power_cond *page = (struct mode_info_power_cond *)buf;
8224 sata_id_t *sata_id = &sdinfo->satadrv_id;
8225
8226 /*
8227 * Most of the fields are set to 0, being not supported and/or disabled
8228 * power condition page length was 0x0a
8229 */
8230 bzero(buf, sizeof (struct mode_info_power_cond));
8231
8232 if (pcntrl == P_CNTRL_DEFAULT) {
8233 /* default paramters not supported */
8234 return (0);
8235 }
8236
8237 page->mode_page.code = MODEPAGE_POWER_COND;
8238 page->mode_page.length = sizeof (struct mode_info_power_cond);
8239
8240 if (sata_id->ai_cap & SATA_STANDBYTIMER) {
8241 page->standby = 1;
8242 bcopy(sdinfo->satadrv_standby_timer, page->standby_cond_timer,
8243 sizeof (uchar_t) * 4);
8244 }
8245
8246 return (sizeof (struct mode_info_power_cond));
8247 }
8248
8249 /*
8250 * Process mode select caching page 8 (scsi3 format only).
8251 * Read Ahead (same as read cache) and Write Cache may be turned on and off
8252 * if these features are supported by the device. If these features are not
8253 * supported, the command will be terminated with STATUS_CHECK.
8254 * This function fails only if the SET FEATURE command sent to
8255 * the device fails. The page format is not verified, assuming that the
8256 * target driver operates correctly - if parameters length is too short,
8257 * we just drop the page.
8258 * Two command may be sent if both Read Cache/Read Ahead and Write Cache
8259 * setting have to be changed.
8260 * SET FEATURE command is executed synchronously, i.e. we wait here until
8261 * it is completed, regardless of the scsi pkt directives.
8262 *
8263 * Note: Mode Select Caching page RCD and DRA bits are tied together, i.e.
8264 * changing DRA will change RCD.
8265 *
8266 * More than one SATA command may be executed to perform operations specified
8267 * by mode select pages. The first error terminates further execution.
8268 * Operations performed successully are not backed-up in such case.
8269 *
8270 * Return SATA_SUCCESS if operation succeeded, SATA_FAILURE otherwise.
8271 * If operation resulted in changing device setup, dmod flag should be set to
8272 * one (1). If parameters were not changed, dmod flag should be set to 0.
8273 * Upon return, if operation required sending command to the device, the rval
8274 * should be set to the value returned by sata_hba_start. If operation
8275 * did not require device access, rval should be set to TRAN_ACCEPT.
8276 * The pagelen should be set to the length of the page.
8277 *
8278 * This function has to be called with a port mutex held.
8279 *
8280 * Returns SATA_SUCCESS if operation was successful, SATA_FAILURE otherwise.
8281 */
8282 int
sata_mode_select_page_8(sata_pkt_txlate_t * spx,struct mode_cache_scsi3 * page,int parmlen,int * pagelen,int * rval,int * dmod)8283 sata_mode_select_page_8(sata_pkt_txlate_t *spx, struct mode_cache_scsi3 *page,
8284 int parmlen, int *pagelen, int *rval, int *dmod)
8285 {
8286 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt;
8287 sata_drive_info_t *sdinfo;
8288 sata_cmd_t *scmd = &spx->txlt_sata_pkt->satapkt_cmd;
8289 sata_id_t *sata_id;
8290 struct scsi_extended_sense *sense;
8291 int wce, dra; /* Current settings */
8292
8293 sdinfo = sata_get_device_info(spx->txlt_sata_hba_inst,
8294 &spx->txlt_sata_pkt->satapkt_device);
8295 sata_id = &sdinfo->satadrv_id;
8296 *dmod = 0;
8297
8298 /* Verify parameters length. If too short, drop it */
8299 if ((PAGELENGTH_DAD_MODE_CACHE_SCSI3 +
8300 sizeof (struct mode_page)) > parmlen) {
8301 *scsipkt->pkt_scbp = STATUS_CHECK;
8302 sense = sata_arq_sense(spx);
8303 sense->es_key = KEY_ILLEGAL_REQUEST;
8304 sense->es_add_code = SD_SCSI_ASC_INVALID_FIELD_IN_PARAMS_LIST;
8305 *pagelen = parmlen;
8306 *rval = TRAN_ACCEPT;
8307 return (SATA_FAILURE);
8308 }
8309
8310 *pagelen = PAGELENGTH_DAD_MODE_CACHE_SCSI3 + sizeof (struct mode_page);
8311
8312 /* Current setting of Read Ahead (and Read Cache) */
8313 if (SATA_READ_AHEAD_ENABLED(*sata_id))
8314 dra = 0; /* 0 == not disabled */
8315 else
8316 dra = 1;
8317 /* Current setting of Write Cache */
8318 if (SATA_WRITE_CACHE_ENABLED(*sata_id))
8319 wce = 1;
8320 else
8321 wce = 0;
8322
8323 if (page->dra == dra && page->wce == wce && page->rcd == dra) {
8324 /* nothing to do */
8325 *rval = TRAN_ACCEPT;
8326 return (SATA_SUCCESS);
8327 }
8328
8329 /*
8330 * Need to flip some setting
8331 * Set-up Internal SET FEATURES command(s)
8332 */
8333 scmd->satacmd_flags.sata_data_direction = SATA_DIR_NODATA_XFER;
8334 scmd->satacmd_addr_type = 0;
8335 scmd->satacmd_device_reg = 0;
8336 scmd->satacmd_status_reg = 0;
8337 scmd->satacmd_error_reg = 0;
8338 scmd->satacmd_cmd_reg = SATAC_SET_FEATURES;
8339 if (page->dra != dra || page->rcd != dra) {
8340 if (SATA_READ_AHEAD_SUPPORTED(*sata_id)) {
8341 /* Need to flip read ahead setting */
8342 if (dra == 0)
8343 /* Disable read ahead / read cache */
8344 scmd->satacmd_features_reg =
8345 SATAC_SF_DISABLE_READ_AHEAD;
8346 else
8347 /* Enable read ahead / read cache */
8348 scmd->satacmd_features_reg =
8349 SATAC_SF_ENABLE_READ_AHEAD;
8350
8351 /* Transfer command to HBA */
8352 if (sata_hba_start(spx, rval) != 0)
8353 /*
8354 * Pkt not accepted for execution.
8355 */
8356 return (SATA_FAILURE);
8357
8358 *dmod = 1;
8359
8360 /* Now process return */
8361 if (spx->txlt_sata_pkt->satapkt_reason !=
8362 SATA_PKT_COMPLETED) {
8363 goto failure; /* Terminate */
8364 }
8365 } else {
8366 *scsipkt->pkt_scbp = STATUS_CHECK;
8367 sense = sata_arq_sense(spx);
8368 sense->es_key = KEY_ILLEGAL_REQUEST;
8369 sense->es_add_code =
8370 SD_SCSI_ASC_INVALID_FIELD_IN_PARAMS_LIST;
8371 *pagelen = parmlen;
8372 *rval = TRAN_ACCEPT;
8373 return (SATA_FAILURE);
8374 }
8375 }
8376
8377 /* Note that the packet is not removed, so it could be re-used */
8378 if (page->wce != wce) {
8379 if (SATA_WRITE_CACHE_SUPPORTED(*sata_id)) {
8380 /* Need to flip Write Cache setting */
8381 if (page->wce == 1)
8382 /* Enable write cache */
8383 scmd->satacmd_features_reg =
8384 SATAC_SF_ENABLE_WRITE_CACHE;
8385 else
8386 /* Disable write cache */
8387 scmd->satacmd_features_reg =
8388 SATAC_SF_DISABLE_WRITE_CACHE;
8389
8390 /* Transfer command to HBA */
8391 if (sata_hba_start(spx, rval) != 0)
8392 /*
8393 * Pkt not accepted for execution.
8394 */
8395 return (SATA_FAILURE);
8396
8397 *dmod = 1;
8398
8399 /* Now process return */
8400 if (spx->txlt_sata_pkt->satapkt_reason !=
8401 SATA_PKT_COMPLETED) {
8402 goto failure;
8403 }
8404 } else {
8405 *scsipkt->pkt_scbp = STATUS_CHECK;
8406 sense = sata_arq_sense(spx);
8407 sense->es_key = KEY_ILLEGAL_REQUEST;
8408 sense->es_add_code =
8409 SD_SCSI_ASC_INVALID_FIELD_IN_PARAMS_LIST;
8410 *pagelen = parmlen;
8411 *rval = TRAN_ACCEPT;
8412 return (SATA_FAILURE);
8413 }
8414 }
8415 return (SATA_SUCCESS);
8416
8417 failure:
8418 sata_xlate_errors(spx);
8419
8420 return (SATA_FAILURE);
8421 }
8422
8423 /*
8424 * Process mode select informational exceptions control page 0x1c
8425 *
8426 * The only changeable bit is dexcpt (disable exceptions).
8427 * MRIE (method of reporting informational exceptions) must be
8428 * "only on request".
8429 * This page applies to informational exceptions that report
8430 * additional sense codes with the ADDITIONAL SENSE CODE field set to 5Dh
8431 * (e.g.,FAILURE PREDICTION THRESHOLD EXCEEDED) or 0Bh (e.g., WARNING_).
8432 * Informational exception conditions occur as the result of background scan
8433 * errors, background self-test errors, or vendor specific events within a
8434 * logical unit. An informational exception condition may occur asynchronous
8435 * to any commands.
8436 *
8437 * Returns: SATA_SUCCESS if operation succeeded, SATA_FAILURE otherwise.
8438 * If operation resulted in changing device setup, dmod flag should be set to
8439 * one (1). If parameters were not changed, dmod flag should be set to 0.
8440 * Upon return, if operation required sending command to the device, the rval
8441 * should be set to the value returned by sata_hba_start. If operation
8442 * did not require device access, rval should be set to TRAN_ACCEPT.
8443 * The pagelen should be set to the length of the page.
8444 *
8445 * This function has to be called with a port mutex held.
8446 *
8447 * Returns SATA_SUCCESS if operation was successful, SATA_FAILURE otherwise.
8448 *
8449 * Cannot be called in the interrupt context.
8450 */
8451 static int
sata_mode_select_page_1c(sata_pkt_txlate_t * spx,struct mode_info_excpt_page * page,int parmlen,int * pagelen,int * rval,int * dmod)8452 sata_mode_select_page_1c(
8453 sata_pkt_txlate_t *spx,
8454 struct mode_info_excpt_page *page,
8455 int parmlen,
8456 int *pagelen,
8457 int *rval,
8458 int *dmod)
8459 {
8460 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt;
8461 sata_cmd_t *scmd = &spx->txlt_sata_pkt->satapkt_cmd;
8462 sata_drive_info_t *sdinfo;
8463 sata_id_t *sata_id;
8464 struct scsi_extended_sense *sense;
8465
8466 sdinfo = sata_get_device_info(spx->txlt_sata_hba_inst,
8467 &spx->txlt_sata_pkt->satapkt_device);
8468 sata_id = &sdinfo->satadrv_id;
8469
8470 *dmod = 0;
8471
8472 /* Verify parameters length. If too short, drop it */
8473 if (((PAGELENGTH_INFO_EXCPT + sizeof (struct mode_page)) > parmlen) ||
8474 page->perf || page->test || (page->mrie != MRIE_ONLY_ON_REQUEST)) {
8475 *scsipkt->pkt_scbp = STATUS_CHECK;
8476 sense = sata_arq_sense(spx);
8477 sense->es_key = KEY_ILLEGAL_REQUEST;
8478 sense->es_add_code = SD_SCSI_ASC_INVALID_FIELD_IN_PARAMS_LIST;
8479 *pagelen = parmlen;
8480 *rval = TRAN_ACCEPT;
8481 return (SATA_FAILURE);
8482 }
8483
8484 *pagelen = PAGELENGTH_INFO_EXCPT + sizeof (struct mode_page);
8485
8486 if (! (sata_id->ai_cmdset82 & SATA_SMART_SUPPORTED)) {
8487 *scsipkt->pkt_scbp = STATUS_CHECK;
8488 sense = sata_arq_sense(spx);
8489 sense->es_key = KEY_ILLEGAL_REQUEST;
8490 sense->es_add_code = SD_SCSI_ASC_INVALID_FIELD_IN_CDB;
8491 *pagelen = parmlen;
8492 *rval = TRAN_ACCEPT;
8493 return (SATA_FAILURE);
8494 }
8495
8496 /* If already in the state requested, we are done */
8497 if (page->dexcpt == ! (sata_id->ai_features85 & SATA_SMART_ENABLED)) {
8498 /* nothing to do */
8499 *rval = TRAN_ACCEPT;
8500 return (SATA_SUCCESS);
8501 }
8502
8503 scmd->satacmd_flags.sata_data_direction = SATA_DIR_NODATA_XFER;
8504
8505 /* Build SMART_ENABLE or SMART_DISABLE command */
8506 scmd->satacmd_addr_type = 0; /* N/A */
8507 scmd->satacmd_lba_mid_lsb = SMART_MAGIC_VAL_1;
8508 scmd->satacmd_lba_high_lsb = SMART_MAGIC_VAL_2;
8509 scmd->satacmd_features_reg = page->dexcpt ?
8510 SATA_SMART_DISABLE_OPS : SATA_SMART_ENABLE_OPS;
8511 scmd->satacmd_device_reg = 0; /* Always device 0 */
8512 scmd->satacmd_cmd_reg = SATAC_SMART;
8513
8514 /* Transfer command to HBA */
8515 if (sata_hba_start(spx, rval) != 0)
8516 /*
8517 * Pkt not accepted for execution.
8518 */
8519 return (SATA_FAILURE);
8520
8521 *dmod = 1; /* At least may have been modified */
8522
8523 /* Now process return */
8524 if (spx->txlt_sata_pkt->satapkt_reason == SATA_PKT_COMPLETED)
8525 return (SATA_SUCCESS);
8526
8527 /* Packet did not complete successfully */
8528 sata_xlate_errors(spx);
8529
8530 return (SATA_FAILURE);
8531 }
8532
8533 /*
8534 * Process mode select acoustic management control page 0x30
8535 *
8536 *
8537 * This function has to be called with a port mutex held.
8538 *
8539 * Returns SATA_SUCCESS if operation was successful, SATA_FAILURE otherwise.
8540 *
8541 * Cannot be called in the interrupt context.
8542 */
8543 int
sata_mode_select_page_30(sata_pkt_txlate_t * spx,struct mode_acoustic_management * page,int parmlen,int * pagelen,int * rval,int * dmod)8544 sata_mode_select_page_30(sata_pkt_txlate_t *spx, struct
8545 mode_acoustic_management *page, int parmlen, int *pagelen,
8546 int *rval, int *dmod)
8547 {
8548 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt;
8549 sata_drive_info_t *sdinfo;
8550 sata_cmd_t *scmd = &spx->txlt_sata_pkt->satapkt_cmd;
8551 sata_id_t *sata_id;
8552 struct scsi_extended_sense *sense;
8553
8554 sdinfo = sata_get_device_info(spx->txlt_sata_hba_inst,
8555 &spx->txlt_sata_pkt->satapkt_device);
8556 sata_id = &sdinfo->satadrv_id;
8557 *dmod = 0;
8558
8559 /* If parmlen is too short or the feature is not supported, drop it */
8560 if (((PAGELENGTH_DAD_MODE_ACOUSTIC_MANAGEMENT +
8561 sizeof (struct mode_page)) > parmlen) ||
8562 (! (sata_id->ai_cmdset83 & SATA_ACOUSTIC_MGMT))) {
8563 *scsipkt->pkt_scbp = STATUS_CHECK;
8564 sense = sata_arq_sense(spx);
8565 sense->es_key = KEY_ILLEGAL_REQUEST;
8566 sense->es_add_code = SD_SCSI_ASC_INVALID_FIELD_IN_PARAMS_LIST;
8567 *pagelen = parmlen;
8568 *rval = TRAN_ACCEPT;
8569 return (SATA_FAILURE);
8570 }
8571
8572 *pagelen = PAGELENGTH_DAD_MODE_ACOUSTIC_MANAGEMENT +
8573 sizeof (struct mode_page);
8574
8575 /*
8576 * We can enable and disable acoustice management and
8577 * set the acoustic management level.
8578 */
8579
8580 /*
8581 * Set-up Internal SET FEATURES command(s)
8582 */
8583 scmd->satacmd_flags.sata_data_direction = SATA_DIR_NODATA_XFER;
8584 scmd->satacmd_addr_type = 0;
8585 scmd->satacmd_device_reg = 0;
8586 scmd->satacmd_status_reg = 0;
8587 scmd->satacmd_error_reg = 0;
8588 scmd->satacmd_cmd_reg = SATAC_SET_FEATURES;
8589 if (page->acoustic_manag_enable) {
8590 scmd->satacmd_features_reg = SATAC_SF_ENABLE_ACOUSTIC;
8591 scmd->satacmd_sec_count_lsb = page->acoustic_manag_level;
8592 } else { /* disabling acoustic management */
8593 scmd->satacmd_features_reg = SATAC_SF_DISABLE_ACOUSTIC;
8594 }
8595
8596 /* Transfer command to HBA */
8597 if (sata_hba_start(spx, rval) != 0)
8598 /*
8599 * Pkt not accepted for execution.
8600 */
8601 return (SATA_FAILURE);
8602
8603 /* Now process return */
8604 if (spx->txlt_sata_pkt->satapkt_reason != SATA_PKT_COMPLETED) {
8605 sata_xlate_errors(spx);
8606 return (SATA_FAILURE);
8607 }
8608
8609 *dmod = 1;
8610
8611 return (SATA_SUCCESS);
8612 }
8613
8614 /*
8615 * Process mode select power condition page 0x1a
8616 *
8617 * This function has to be called with a port mutex held.
8618 *
8619 * Returns SATA_SUCCESS if operation was successful, SATA_FAILURE otherwise.
8620 *
8621 * Cannot be called in the interrupt context.
8622 */
8623 int
sata_mode_select_page_1a(sata_pkt_txlate_t * spx,struct mode_info_power_cond * page,int parmlen,int * pagelen,int * rval,int * dmod)8624 sata_mode_select_page_1a(sata_pkt_txlate_t *spx, struct
8625 mode_info_power_cond *page, int parmlen, int *pagelen,
8626 int *rval, int *dmod)
8627 {
8628 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt;
8629 sata_drive_info_t *sdinfo;
8630 sata_cmd_t *scmd = &spx->txlt_sata_pkt->satapkt_cmd;
8631 sata_id_t *sata_id;
8632 struct scsi_extended_sense *sense;
8633 uint8_t ata_count;
8634 int i, len;
8635
8636 sdinfo = sata_get_device_info(spx->txlt_sata_hba_inst,
8637 &spx->txlt_sata_pkt->satapkt_device);
8638 sata_id = &sdinfo->satadrv_id;
8639 *dmod = 0;
8640
8641 len = sizeof (struct mode_info_power_cond);
8642 len += sizeof (struct mode_page);
8643
8644 /* If parmlen is too short or the feature is not supported, drop it */
8645 if ((len < parmlen) || (page->idle == 1) ||
8646 (!(sata_id->ai_cap & SATA_STANDBYTIMER) && page->standby == 1)) {
8647 *scsipkt->pkt_scbp = STATUS_CHECK;
8648 sense = sata_arq_sense(spx);
8649 sense->es_key = KEY_ILLEGAL_REQUEST;
8650 sense->es_add_code = SD_SCSI_ASC_INVALID_FIELD_IN_PARAMS_LIST;
8651 *pagelen = parmlen;
8652 *rval = TRAN_ACCEPT;
8653 return (SATA_FAILURE);
8654 }
8655
8656 *pagelen = len;
8657
8658 /*
8659 * Set-up Internal STANDBY command(s)
8660 */
8661 if (page->standby == 0)
8662 goto out;
8663
8664 ata_count = sata_get_standby_timer(page->standby_cond_timer);
8665
8666 scmd->satacmd_addr_type = 0;
8667 scmd->satacmd_sec_count_lsb = ata_count;
8668 scmd->satacmd_lba_low_lsb = 0;
8669 scmd->satacmd_lba_mid_lsb = 0;
8670 scmd->satacmd_lba_high_lsb = 0;
8671 scmd->satacmd_features_reg = 0;
8672 scmd->satacmd_device_reg = 0;
8673 scmd->satacmd_status_reg = 0;
8674 scmd->satacmd_cmd_reg = SATAC_STANDBY;
8675 scmd->satacmd_flags.sata_special_regs = B_TRUE;
8676 scmd->satacmd_flags.sata_copy_out_error_reg = B_TRUE;
8677
8678 /* Transfer command to HBA */
8679 if (sata_hba_start(spx, rval) != 0) {
8680 return (SATA_FAILURE);
8681 } else {
8682 if ((scmd->satacmd_error_reg != 0) ||
8683 (spx->txlt_sata_pkt->satapkt_reason !=
8684 SATA_PKT_COMPLETED)) {
8685 sata_xlate_errors(spx);
8686 return (SATA_FAILURE);
8687 }
8688 }
8689
8690 for (i = 0; i < 4; i++) {
8691 sdinfo->satadrv_standby_timer[i] = page->standby_cond_timer[i];
8692 }
8693 out:
8694 *dmod = 1;
8695 return (SATA_SUCCESS);
8696 }
8697
8698 /*
8699 * sata_build_lsense_page0() is used to create the
8700 * SCSI LOG SENSE page 0 (supported log pages)
8701 *
8702 * Currently supported pages are 0, 0x10, 0x2f, 0x30 and 0x0e
8703 * (supported log pages, self-test results, informational exceptions
8704 * Sun vendor specific ATA SMART data, and start stop cycle counter).
8705 *
8706 * Takes a sata_drive_info t * and the address of a buffer
8707 * in which to create the page information.
8708 *
8709 * Returns the number of bytes valid in the buffer.
8710 */
8711 static int
sata_build_lsense_page_0(sata_drive_info_t * sdinfo,uint8_t * buf)8712 sata_build_lsense_page_0(sata_drive_info_t *sdinfo, uint8_t *buf)
8713 {
8714 uint8_t *ptr = buf;
8715 sata_id_t *sata_id = &sdinfo->satadrv_id;
8716
8717 /* The supported log pages should be in ascending order */
8718 *ptr++ = PAGE_CODE_GET_SUPPORTED_LOG_PAGES;
8719
8720 if (sata_id->ai_cmdset82 & SATA_SMART_SUPPORTED) {
8721 *ptr++ = PAGE_CODE_START_STOP_CYCLE_COUNTER;
8722 if (sata_id->ai_cmdset84 & SATA_SMART_SELF_TEST_SUPPORTED) {
8723 *ptr++ = PAGE_CODE_SELF_TEST_RESULTS;
8724 }
8725 *ptr++ = PAGE_CODE_INFORMATION_EXCEPTIONS;
8726 *ptr++ = PAGE_CODE_SMART_READ_DATA;
8727 }
8728
8729 return ((int)((uintptr_t)ptr - (uintptr_t)buf));
8730 }
8731
8732 /*
8733 * sata_build_lsense_page_10() is used to create the
8734 * SCSI LOG SENSE page 0x10 (self-test results)
8735 *
8736 * Takes a sata_drive_info t * and the address of a buffer
8737 * in which to create the page information as well as a sata_hba_inst_t *.
8738 *
8739 * Returns the number of bytes valid in the buffer.
8740 *
8741 * Note: Self test and SMART data is accessible in device log pages.
8742 * The log pages can be accessed by SMART READ/WRITE LOG (up to 255 sectors
8743 * of data can be transferred by a single command), or by the General Purpose
8744 * Logging commands (GPL) READ LOG EXT and WRITE LOG EXT (up to 65,535 sectors
8745 * - approximately 33MB - can be transferred by a single command.
8746 * The SCT Command response (either error or command) is the same for both
8747 * the SMART and GPL methods of issuing commands.
8748 * This function uses READ LOG EXT command when drive supports LBA48, and
8749 * SMART READ command otherwise.
8750 *
8751 * Since above commands are executed in a synchronous mode, this function
8752 * should not be called in an interrupt context.
8753 */
8754 static int
sata_build_lsense_page_10(sata_drive_info_t * sdinfo,uint8_t * buf,sata_hba_inst_t * sata_hba_inst)8755 sata_build_lsense_page_10(
8756 sata_drive_info_t *sdinfo,
8757 uint8_t *buf,
8758 sata_hba_inst_t *sata_hba_inst)
8759 {
8760 struct log_parameter *lpp = (struct log_parameter *)buf;
8761 int rval;
8762
8763 if (sdinfo->satadrv_features_support & SATA_DEV_F_LBA48) {
8764 struct smart_ext_selftest_log *ext_selftest_log;
8765
8766 ext_selftest_log = kmem_zalloc(
8767 sizeof (struct smart_ext_selftest_log), KM_SLEEP);
8768
8769 rval = sata_ext_smart_selftest_read_log(sata_hba_inst, sdinfo,
8770 ext_selftest_log, 0);
8771 if (rval == 0) {
8772 int index, start_index;
8773 struct smart_ext_selftest_log_entry *entry;
8774 static const struct smart_ext_selftest_log_entry empty =
8775 {0};
8776 uint16_t block_num;
8777 int count;
8778 boolean_t only_one_block = B_FALSE;
8779
8780 index = ext_selftest_log->
8781 smart_ext_selftest_log_index[0];
8782 index |= ext_selftest_log->
8783 smart_ext_selftest_log_index[1] << 8;
8784 if (index == 0)
8785 goto out;
8786
8787 --index; /* Correct for 0 origin */
8788 start_index = index; /* remember where we started */
8789 block_num = index / ENTRIES_PER_EXT_SELFTEST_LOG_BLK;
8790 if (block_num != 0) {
8791 rval = sata_ext_smart_selftest_read_log(
8792 sata_hba_inst, sdinfo, ext_selftest_log,
8793 block_num);
8794 if (rval != 0)
8795 goto out;
8796 }
8797 index %= ENTRIES_PER_EXT_SELFTEST_LOG_BLK;
8798 entry =
8799 &ext_selftest_log->
8800 smart_ext_selftest_log_entries[index];
8801
8802 for (count = 1;
8803 count <= SCSI_ENTRIES_IN_LOG_SENSE_SELFTEST_RESULTS;
8804 ++count) {
8805 uint8_t status;
8806 uint8_t code;
8807 uint8_t sense_key;
8808 uint8_t add_sense_code;
8809 uint8_t add_sense_code_qual;
8810
8811 /* If this is an unused entry, we are done */
8812 if (bcmp(entry, &empty, sizeof (empty)) == 0) {
8813 /* Broken firmware on some disks */
8814 if (index + 1 ==
8815 ENTRIES_PER_EXT_SELFTEST_LOG_BLK) {
8816 --entry;
8817 --index;
8818 if (bcmp(entry, &empty,
8819 sizeof (empty)) == 0)
8820 goto out;
8821 } else
8822 goto out;
8823 }
8824
8825 if (only_one_block &&
8826 start_index == index)
8827 goto out;
8828
8829 lpp->param_code[0] = 0;
8830 lpp->param_code[1] = count;
8831 lpp->param_ctrl_flags =
8832 LOG_CTRL_LP | LOG_CTRL_LBIN;
8833 lpp->param_len =
8834 SCSI_LOG_SENSE_SELFTEST_PARAM_LEN;
8835
8836 status = entry->smart_ext_selftest_log_status;
8837 status >>= 4;
8838 switch (status) {
8839 case 0:
8840 default:
8841 sense_key = KEY_NO_SENSE;
8842 add_sense_code =
8843 SD_SCSI_ASC_NO_ADD_SENSE;
8844 add_sense_code_qual = 0;
8845 break;
8846 case 1:
8847 sense_key = KEY_ABORTED_COMMAND;
8848 add_sense_code =
8849 DIAGNOSTIC_FAILURE_ON_COMPONENT;
8850 add_sense_code_qual = SCSI_COMPONENT_81;
8851 break;
8852 case 2:
8853 sense_key = KEY_ABORTED_COMMAND;
8854 add_sense_code =
8855 DIAGNOSTIC_FAILURE_ON_COMPONENT;
8856 add_sense_code_qual = SCSI_COMPONENT_82;
8857 break;
8858 case 3:
8859 sense_key = KEY_ABORTED_COMMAND;
8860 add_sense_code =
8861 DIAGNOSTIC_FAILURE_ON_COMPONENT;
8862 add_sense_code_qual = SCSI_COMPONENT_83;
8863 break;
8864 case 4:
8865 sense_key = KEY_HARDWARE_ERROR;
8866 add_sense_code =
8867 DIAGNOSTIC_FAILURE_ON_COMPONENT;
8868 add_sense_code_qual = SCSI_COMPONENT_84;
8869 break;
8870 case 5:
8871 sense_key = KEY_HARDWARE_ERROR;
8872 add_sense_code =
8873 DIAGNOSTIC_FAILURE_ON_COMPONENT;
8874 add_sense_code_qual = SCSI_COMPONENT_85;
8875 break;
8876 case 6:
8877 sense_key = KEY_HARDWARE_ERROR;
8878 add_sense_code =
8879 DIAGNOSTIC_FAILURE_ON_COMPONENT;
8880 add_sense_code_qual = SCSI_COMPONENT_86;
8881 break;
8882 case 7:
8883 sense_key = KEY_MEDIUM_ERROR;
8884 add_sense_code =
8885 DIAGNOSTIC_FAILURE_ON_COMPONENT;
8886 add_sense_code_qual = SCSI_COMPONENT_87;
8887 break;
8888 case 8:
8889 sense_key = KEY_HARDWARE_ERROR;
8890 add_sense_code =
8891 DIAGNOSTIC_FAILURE_ON_COMPONENT;
8892 add_sense_code_qual = SCSI_COMPONENT_88;
8893 break;
8894 }
8895 code = 0; /* unspecified */
8896 status |= (code << 4);
8897 lpp->param_values[0] = status;
8898 lpp->param_values[1] = 0; /* unspecified */
8899 lpp->param_values[2] = entry->
8900 smart_ext_selftest_log_timestamp[1];
8901 lpp->param_values[3] = entry->
8902 smart_ext_selftest_log_timestamp[0];
8903 if (status != 0) {
8904 lpp->param_values[4] = 0;
8905 lpp->param_values[5] = 0;
8906 lpp->param_values[6] = entry->
8907 smart_ext_selftest_log_failing_lba
8908 [5];
8909 lpp->param_values[7] = entry->
8910 smart_ext_selftest_log_failing_lba
8911 [4];
8912 lpp->param_values[8] = entry->
8913 smart_ext_selftest_log_failing_lba
8914 [3];
8915 lpp->param_values[9] = entry->
8916 smart_ext_selftest_log_failing_lba
8917 [2];
8918 lpp->param_values[10] = entry->
8919 smart_ext_selftest_log_failing_lba
8920 [1];
8921 lpp->param_values[11] = entry->
8922 smart_ext_selftest_log_failing_lba
8923 [0];
8924 } else { /* No bad block address */
8925 lpp->param_values[4] = 0xff;
8926 lpp->param_values[5] = 0xff;
8927 lpp->param_values[6] = 0xff;
8928 lpp->param_values[7] = 0xff;
8929 lpp->param_values[8] = 0xff;
8930 lpp->param_values[9] = 0xff;
8931 lpp->param_values[10] = 0xff;
8932 lpp->param_values[11] = 0xff;
8933 }
8934
8935 lpp->param_values[12] = sense_key;
8936 lpp->param_values[13] = add_sense_code;
8937 lpp->param_values[14] = add_sense_code_qual;
8938 lpp->param_values[15] = 0; /* undefined */
8939
8940 lpp = (struct log_parameter *)
8941 (((uint8_t *)lpp) +
8942 SCSI_LOG_PARAM_HDR_LEN +
8943 SCSI_LOG_SENSE_SELFTEST_PARAM_LEN);
8944
8945 --index; /* Back up to previous entry */
8946 if (index < 0) {
8947 if (block_num > 0) {
8948 --block_num;
8949 } else {
8950 struct read_log_ext_directory
8951 logdir;
8952
8953 rval =
8954 sata_read_log_ext_directory(
8955 sata_hba_inst, sdinfo,
8956 &logdir);
8957 if (rval == -1)
8958 goto out;
8959 if ((logdir.read_log_ext_vers
8960 [0] == 0) &&
8961 (logdir.read_log_ext_vers
8962 [1] == 0))
8963 goto out;
8964 block_num =
8965 logdir.read_log_ext_nblks
8966 [EXT_SMART_SELFTEST_LOG_PAGE
8967 - 1][0];
8968 block_num |= logdir.
8969 read_log_ext_nblks
8970 [EXT_SMART_SELFTEST_LOG_PAGE
8971 - 1][1] << 8;
8972 --block_num;
8973 only_one_block =
8974 (block_num == 0);
8975 }
8976 rval = sata_ext_smart_selftest_read_log(
8977 sata_hba_inst, sdinfo,
8978 ext_selftest_log, block_num);
8979 if (rval != 0)
8980 goto out;
8981
8982 index =
8983 ENTRIES_PER_EXT_SELFTEST_LOG_BLK -
8984 1;
8985 }
8986 index %= ENTRIES_PER_EXT_SELFTEST_LOG_BLK;
8987 entry = &ext_selftest_log->
8988 smart_ext_selftest_log_entries[index];
8989 }
8990 }
8991 out:
8992 kmem_free(ext_selftest_log,
8993 sizeof (struct smart_ext_selftest_log));
8994 } else {
8995 struct smart_selftest_log *selftest_log;
8996
8997 selftest_log = kmem_zalloc(sizeof (struct smart_selftest_log),
8998 KM_SLEEP);
8999
9000 rval = sata_smart_selftest_log(sata_hba_inst, sdinfo,
9001 selftest_log);
9002
9003 if (rval == 0) {
9004 int index;
9005 int count;
9006 struct smart_selftest_log_entry *entry;
9007 static const struct smart_selftest_log_entry empty =
9008 { 0 };
9009
9010 index = selftest_log->smart_selftest_log_index;
9011 if (index == 0)
9012 goto done;
9013 --index; /* Correct for 0 origin */
9014 entry = &selftest_log->
9015 smart_selftest_log_entries[index];
9016 for (count = 1;
9017 count <= SCSI_ENTRIES_IN_LOG_SENSE_SELFTEST_RESULTS;
9018 ++count) {
9019 uint8_t status;
9020 uint8_t code;
9021 uint8_t sense_key;
9022 uint8_t add_sense_code;
9023 uint8_t add_sense_code_qual = 0;
9024
9025 if (bcmp(entry, &empty, sizeof (empty)) == 0)
9026 goto done;
9027
9028 lpp->param_code[0] = 0;
9029 lpp->param_code[1] = count;
9030 lpp->param_ctrl_flags =
9031 LOG_CTRL_LP | LOG_CTRL_LBIN;
9032 lpp->param_len =
9033 SCSI_LOG_SENSE_SELFTEST_PARAM_LEN;
9034
9035 status = entry->smart_selftest_log_status;
9036 status >>= 4;
9037 switch (status) {
9038 case 0:
9039 default:
9040 sense_key = KEY_NO_SENSE;
9041 add_sense_code =
9042 SD_SCSI_ASC_NO_ADD_SENSE;
9043 break;
9044 case 1:
9045 sense_key = KEY_ABORTED_COMMAND;
9046 add_sense_code =
9047 DIAGNOSTIC_FAILURE_ON_COMPONENT;
9048 add_sense_code_qual = SCSI_COMPONENT_81;
9049 break;
9050 case 2:
9051 sense_key = KEY_ABORTED_COMMAND;
9052 add_sense_code =
9053 DIAGNOSTIC_FAILURE_ON_COMPONENT;
9054 add_sense_code_qual = SCSI_COMPONENT_82;
9055 break;
9056 case 3:
9057 sense_key = KEY_ABORTED_COMMAND;
9058 add_sense_code =
9059 DIAGNOSTIC_FAILURE_ON_COMPONENT;
9060 add_sense_code_qual = SCSI_COMPONENT_83;
9061 break;
9062 case 4:
9063 sense_key = KEY_HARDWARE_ERROR;
9064 add_sense_code =
9065 DIAGNOSTIC_FAILURE_ON_COMPONENT;
9066 add_sense_code_qual = SCSI_COMPONENT_84;
9067 break;
9068 case 5:
9069 sense_key = KEY_HARDWARE_ERROR;
9070 add_sense_code =
9071 DIAGNOSTIC_FAILURE_ON_COMPONENT;
9072 add_sense_code_qual = SCSI_COMPONENT_85;
9073 break;
9074 case 6:
9075 sense_key = KEY_HARDWARE_ERROR;
9076 add_sense_code =
9077 DIAGNOSTIC_FAILURE_ON_COMPONENT;
9078 add_sense_code_qual = SCSI_COMPONENT_86;
9079 break;
9080 case 7:
9081 sense_key = KEY_MEDIUM_ERROR;
9082 add_sense_code =
9083 DIAGNOSTIC_FAILURE_ON_COMPONENT;
9084 add_sense_code_qual = SCSI_COMPONENT_87;
9085 break;
9086 case 8:
9087 sense_key = KEY_HARDWARE_ERROR;
9088 add_sense_code =
9089 DIAGNOSTIC_FAILURE_ON_COMPONENT;
9090 add_sense_code_qual = SCSI_COMPONENT_88;
9091 break;
9092 }
9093 code = 0; /* unspecified */
9094 status |= (code << 4);
9095 lpp->param_values[0] = status;
9096 lpp->param_values[1] = 0; /* unspecified */
9097 lpp->param_values[2] = entry->
9098 smart_selftest_log_timestamp[1];
9099 lpp->param_values[3] = entry->
9100 smart_selftest_log_timestamp[0];
9101 if (status != 0) {
9102 lpp->param_values[4] = 0;
9103 lpp->param_values[5] = 0;
9104 lpp->param_values[6] = 0;
9105 lpp->param_values[7] = 0;
9106 lpp->param_values[8] = entry->
9107 smart_selftest_log_failing_lba[3];
9108 lpp->param_values[9] = entry->
9109 smart_selftest_log_failing_lba[2];
9110 lpp->param_values[10] = entry->
9111 smart_selftest_log_failing_lba[1];
9112 lpp->param_values[11] = entry->
9113 smart_selftest_log_failing_lba[0];
9114 } else { /* No block address */
9115 lpp->param_values[4] = 0xff;
9116 lpp->param_values[5] = 0xff;
9117 lpp->param_values[6] = 0xff;
9118 lpp->param_values[7] = 0xff;
9119 lpp->param_values[8] = 0xff;
9120 lpp->param_values[9] = 0xff;
9121 lpp->param_values[10] = 0xff;
9122 lpp->param_values[11] = 0xff;
9123 }
9124 lpp->param_values[12] = sense_key;
9125 lpp->param_values[13] = add_sense_code;
9126 lpp->param_values[14] = add_sense_code_qual;
9127 lpp->param_values[15] = 0; /* undefined */
9128
9129 lpp = (struct log_parameter *)
9130 (((uint8_t *)lpp) +
9131 SCSI_LOG_PARAM_HDR_LEN +
9132 SCSI_LOG_SENSE_SELFTEST_PARAM_LEN);
9133 --index; /* back up to previous entry */
9134 if (index < 0) {
9135 index =
9136 NUM_SMART_SELFTEST_LOG_ENTRIES - 1;
9137 }
9138 entry = &selftest_log->
9139 smart_selftest_log_entries[index];
9140 }
9141 }
9142 done:
9143 kmem_free(selftest_log, sizeof (struct smart_selftest_log));
9144 }
9145
9146 return ((SCSI_LOG_PARAM_HDR_LEN + SCSI_LOG_SENSE_SELFTEST_PARAM_LEN) *
9147 SCSI_ENTRIES_IN_LOG_SENSE_SELFTEST_RESULTS);
9148 }
9149
9150 /*
9151 * sata_build_lsense_page_2f() is used to create the
9152 * SCSI LOG SENSE page 0x2f (informational exceptions)
9153 *
9154 * Takes a sata_drive_info t * and the address of a buffer
9155 * in which to create the page information as well as a sata_hba_inst_t *.
9156 *
9157 * Returns the number of bytes valid in the buffer.
9158 *
9159 * Because it invokes function(s) that send synchronously executed command
9160 * to the HBA, it cannot be called in the interrupt context.
9161 */
9162 static int
sata_build_lsense_page_2f(sata_drive_info_t * sdinfo,uint8_t * buf,sata_hba_inst_t * sata_hba_inst)9163 sata_build_lsense_page_2f(
9164 sata_drive_info_t *sdinfo,
9165 uint8_t *buf,
9166 sata_hba_inst_t *sata_hba_inst)
9167 {
9168 struct log_parameter *lpp = (struct log_parameter *)buf;
9169 int rval;
9170 uint8_t *smart_data;
9171 uint8_t temp;
9172 sata_id_t *sata_id;
9173 #define SMART_NO_TEMP 0xff
9174
9175 lpp->param_code[0] = 0;
9176 lpp->param_code[1] = 0;
9177 lpp->param_ctrl_flags = LOG_CTRL_LP | LOG_CTRL_LBIN;
9178
9179 /* Now get the SMART status w.r.t. threshold exceeded */
9180 rval = sata_fetch_smart_return_status(sata_hba_inst, sdinfo);
9181 switch (rval) {
9182 case 1:
9183 lpp->param_values[0] = SCSI_PREDICTED_FAILURE;
9184 lpp->param_values[1] = SCSI_GENERAL_HD_FAILURE;
9185 break;
9186 case 0:
9187 case -1: /* failed to get data */
9188 lpp->param_values[0] = 0; /* No failure predicted */
9189 lpp->param_values[1] = 0;
9190 break;
9191 #if defined(SATA_DEBUG)
9192 default:
9193 cmn_err(CE_PANIC, "sata_build_lsense_page_2f bad return value");
9194 /* NOTREACHED */
9195 #endif
9196 }
9197
9198 sata_id = &sdinfo->satadrv_id;
9199 if (! (sata_id->ai_sctsupport & SATA_SCT_CMD_TRANS_SUP))
9200 temp = SMART_NO_TEMP;
9201 else {
9202 /* Now get the temperature */
9203 smart_data = kmem_zalloc(512, KM_SLEEP);
9204 rval = sata_smart_read_log(sata_hba_inst, sdinfo, smart_data,
9205 SCT_STATUS_LOG_PAGE, 1);
9206 if (rval == -1)
9207 temp = SMART_NO_TEMP;
9208 else {
9209 temp = smart_data[200];
9210 if (temp & 0x80) {
9211 if (temp & 0x7f)
9212 temp = 0;
9213 else
9214 temp = SMART_NO_TEMP;
9215 }
9216 }
9217 kmem_free(smart_data, 512);
9218 }
9219
9220 lpp->param_values[2] = temp; /* most recent temperature */
9221 lpp->param_values[3] = 0; /* required vendor specific byte */
9222
9223 lpp->param_len = SCSI_INFO_EXCEPTIONS_PARAM_LEN;
9224
9225
9226 return (SCSI_INFO_EXCEPTIONS_PARAM_LEN + SCSI_LOG_PARAM_HDR_LEN);
9227 }
9228
9229 /*
9230 * sata_build_lsense_page_30() is used to create the
9231 * SCSI LOG SENSE page 0x30 (Sun's vendor specific page for ATA SMART data).
9232 *
9233 * Takes a sata_drive_info t * and the address of a buffer
9234 * in which to create the page information as well as a sata_hba_inst_t *.
9235 *
9236 * Returns the number of bytes valid in the buffer.
9237 */
9238 static int
sata_build_lsense_page_30(sata_drive_info_t * sdinfo,uint8_t * buf,sata_hba_inst_t * sata_hba_inst)9239 sata_build_lsense_page_30(
9240 sata_drive_info_t *sdinfo,
9241 uint8_t *buf,
9242 sata_hba_inst_t *sata_hba_inst)
9243 {
9244 struct smart_data *smart_data = (struct smart_data *)buf;
9245 int rval;
9246
9247 /* Now do the SMART READ DATA */
9248 rval = sata_fetch_smart_data(sata_hba_inst, sdinfo, smart_data);
9249 if (rval == -1)
9250 return (0);
9251
9252 return (sizeof (struct smart_data));
9253 }
9254
9255 /*
9256 * sata_build_lsense_page_0e() is used to create the
9257 * SCSI LOG SENSE page 0e (start-stop cycle counter page)
9258 *
9259 * Date of Manufacture (0x0001)
9260 * YEAR = "0000"
9261 * WEEK = "00"
9262 * Accounting Date (0x0002)
9263 * 6 ASCII space character(20h)
9264 * Specified cycle count over device lifetime
9265 * VALUE - THRESH - the delta between max and min;
9266 * Accumulated start-stop cycles
9267 * VALUE - WORST - the accumulated cycles;
9268 *
9269 * ID FLAG THRESH VALUE WORST RAW on start/stop counter attribute
9270 *
9271 * Takes a sata_drive_info t * and the address of a buffer
9272 * in which to create the page information as well as a sata_hba_inst_t *.
9273 *
9274 * Returns the number of bytes valid in the buffer.
9275 */
9276 static int
sata_build_lsense_page_0e(sata_drive_info_t * sdinfo,uint8_t * buf,sata_pkt_txlate_t * spx)9277 sata_build_lsense_page_0e(sata_drive_info_t *sdinfo, uint8_t *buf,
9278 sata_pkt_txlate_t *spx)
9279 {
9280 struct start_stop_cycle_counter_log *log_page;
9281 int i, rval, index;
9282 uint8_t smart_data[512], id, value, worst, thresh;
9283 uint32_t max_count, cycles;
9284
9285 /* Now do the SMART READ DATA */
9286 rval = sata_fetch_smart_data(spx->txlt_sata_hba_inst, sdinfo,
9287 (struct smart_data *)smart_data);
9288 if (rval == -1)
9289 return (0);
9290 for (i = 0, id = 0; i < SMART_START_STOP_COUNT_ID * 2; i++) {
9291 index = (i * 12) + 2;
9292 id = smart_data[index];
9293 if (id != SMART_START_STOP_COUNT_ID)
9294 continue;
9295 else {
9296 thresh = smart_data[index + 2];
9297 value = smart_data[index + 3];
9298 worst = smart_data[index + 4];
9299 break;
9300 }
9301 }
9302 if (id != SMART_START_STOP_COUNT_ID)
9303 return (0);
9304 max_count = value - thresh;
9305 cycles = value - worst;
9306
9307 log_page = (struct start_stop_cycle_counter_log *)buf;
9308 bzero(log_page, sizeof (struct start_stop_cycle_counter_log));
9309 log_page->code = 0x0e;
9310 log_page->page_len_low = 0x24;
9311
9312 log_page->manufactor_date_low = 0x1;
9313 log_page->param_1.fmt_link = 0x1; /* 01b */
9314 log_page->param_len_1 = 0x06;
9315 for (i = 0; i < 4; i++) {
9316 log_page->year_manu[i] = 0x30;
9317 if (i < 2)
9318 log_page->week_manu[i] = 0x30;
9319 }
9320
9321 log_page->account_date_low = 0x02;
9322 log_page->param_2.fmt_link = 0x01; /* 01b */
9323 log_page->param_len_2 = 0x06;
9324 for (i = 0; i < 4; i++) {
9325 log_page->year_account[i] = 0x20;
9326 if (i < 2)
9327 log_page->week_account[i] = 0x20;
9328 }
9329
9330 log_page->lifetime_code_low = 0x03;
9331 log_page->param_3.fmt_link = 0x03; /* 11b */
9332 log_page->param_len_3 = 0x04;
9333 /* VALUE - THRESH - the delta between max and min */
9334 log_page->cycle_code_low = 0x04;
9335 log_page->param_4.fmt_link = 0x03; /* 11b */
9336 log_page->param_len_4 = 0x04;
9337 /* WORST - THRESH - the distance from 'now' to min */
9338
9339 for (i = 0; i < 4; i++) {
9340 log_page->cycle_lifetime[i] =
9341 (max_count >> (8 * (3 - i))) & 0xff;
9342 log_page->cycle_accumulated[i] =
9343 (cycles >> (8 * (3 - i))) & 0xff;
9344 }
9345
9346 return (sizeof (struct start_stop_cycle_counter_log));
9347 }
9348
9349 /*
9350 * This function was used for build a ATA read verify sector command
9351 */
9352 static void
sata_build_read_verify_cmd(sata_cmd_t * scmd,uint16_t sec,uint64_t lba)9353 sata_build_read_verify_cmd(sata_cmd_t *scmd, uint16_t sec, uint64_t lba)
9354 {
9355 scmd->satacmd_cmd_reg = SATAC_RDVER;
9356 scmd->satacmd_addr_type = ATA_ADDR_LBA28;
9357 scmd->satacmd_flags.sata_special_regs = B_TRUE;
9358
9359 scmd->satacmd_sec_count_lsb = sec & 0xff;
9360 scmd->satacmd_lba_low_lsb = lba & 0xff;
9361 scmd->satacmd_lba_mid_lsb = (lba >> 8) & 0xff;
9362 scmd->satacmd_lba_high_lsb = (lba >> 16) & 0xff;
9363 scmd->satacmd_device_reg = (SATA_ADH_LBA | ((lba >> 24) & 0xf));
9364 scmd->satacmd_features_reg = 0;
9365 scmd->satacmd_status_reg = 0;
9366 scmd->satacmd_error_reg = 0;
9367 }
9368
9369 /*
9370 * This function was used for building an ATA
9371 * command, and only command register need to
9372 * be defined, other register will be zero or na.
9373 */
9374 static void
sata_build_generic_cmd(sata_cmd_t * scmd,uint8_t cmd)9375 sata_build_generic_cmd(sata_cmd_t *scmd, uint8_t cmd)
9376 {
9377 scmd->satacmd_addr_type = 0;
9378 scmd->satacmd_cmd_reg = cmd;
9379 scmd->satacmd_device_reg = 0;
9380 scmd->satacmd_sec_count_lsb = 0;
9381 scmd->satacmd_lba_low_lsb = 0;
9382 scmd->satacmd_lba_mid_lsb = 0;
9383 scmd->satacmd_lba_high_lsb = 0;
9384 scmd->satacmd_features_reg = 0;
9385 scmd->satacmd_status_reg = 0;
9386 scmd->satacmd_error_reg = 0;
9387 scmd->satacmd_flags.sata_special_regs = B_TRUE;
9388 }
9389
9390 /*
9391 * This function was used for changing the standby
9392 * timer format from SCSI to ATA.
9393 */
9394 static uint8_t
sata_get_standby_timer(uint8_t * timer)9395 sata_get_standby_timer(uint8_t *timer)
9396 {
9397 uint32_t i = 0, count = 0;
9398 uint8_t ata_count;
9399
9400 for (i = 0; i < 4; i++) {
9401 count = count << 8 | timer[i];
9402 }
9403
9404 if (count == 0)
9405 return (0);
9406
9407 if (count >= 1 && count <= 12000)
9408 ata_count = (count -1) / 50 + 1;
9409 else if (count > 12000 && count <= 12600)
9410 ata_count = 0xfc;
9411 else if (count > 12601 && count <= 12750)
9412 ata_count = 0xff;
9413 else if (count > 12750 && count <= 17999)
9414 ata_count = 0xf1;
9415 else if (count > 18000 && count <= 198000)
9416 ata_count = count / 18000 + 240;
9417 else
9418 ata_count = 0xfd;
9419 return (ata_count);
9420 }
9421
9422 /* ************************** ATAPI-SPECIFIC FUNCTIONS ********************** */
9423
9424 /*
9425 * Start command for ATAPI device.
9426 * This function processes scsi_pkt requests.
9427 * Now CD/DVD, tape and ATAPI disk devices are supported.
9428 * Most commands are packet without any translation into Packet Command.
9429 * Some may be trapped and executed as SATA commands (not clear which one).
9430 *
9431 * Returns TRAN_ACCEPT if command is accepted for execution (or completed
9432 * execution).
9433 * Returns other TRAN_XXXX codes if command is not accepted or completed
9434 * (see return values for sata_hba_start()).
9435 *
9436 * Note:
9437 * Inquiry cdb format differs between transport version 2 and 3.
9438 * However, the transport version 3 devices that were checked did not adhere
9439 * to the specification (ignored MSB of the allocation length). Therefore,
9440 * the transport version is not checked, but Inquiry allocation length is
9441 * truncated to 255 bytes if the original allocation length set-up by the
9442 * target driver is greater than 255 bytes.
9443 */
9444 static int
sata_txlt_atapi(sata_pkt_txlate_t * spx)9445 sata_txlt_atapi(sata_pkt_txlate_t *spx)
9446 {
9447 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt;
9448 sata_cmd_t *scmd = &spx->txlt_sata_pkt->satapkt_cmd;
9449 struct buf *bp = spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp;
9450 sata_hba_inst_t *sata_hba = SATA_TXLT_HBA_INST(spx);
9451 sata_drive_info_t *sdinfo = sata_get_device_info(sata_hba,
9452 &spx->txlt_sata_pkt->satapkt_device);
9453 kmutex_t *cport_mutex = &(SATA_TXLT_CPORT_MUTEX(spx));
9454 int cdblen;
9455 int rval, reason;
9456 int synch;
9457 union scsi_cdb *cdbp = (union scsi_cdb *)scsipkt->pkt_cdbp;
9458
9459 mutex_enter(cport_mutex);
9460
9461 if (((rval = sata_txlt_generic_pkt_info(spx, &reason, 0)) !=
9462 TRAN_ACCEPT) || (reason == CMD_DEV_GONE)) {
9463 mutex_exit(cport_mutex);
9464 return (rval);
9465 }
9466
9467 /*
9468 * ATAPI device executes some ATA commands in addition to those
9469 * commands sent via PACKET command. These ATA commands may be
9470 * executed by the regular SATA translation functions. None needs
9471 * to be captured now.
9472 *
9473 * Commands sent via PACKET command include:
9474 * MMC command set for ATAPI CD/DVD device
9475 * SSC command set for ATAPI TAPE device
9476 * SBC command set for ATAPI disk device
9477 *
9478 */
9479
9480 /* Check the size of cdb */
9481
9482 switch (GETGROUP(cdbp)) {
9483 case CDB_GROUPID_3: /* Reserved, per SPC-4 */
9484 /*
9485 * opcodes 0x7e and 0x7f identify variable-length CDBs and
9486 * therefore require special handling. Return failure, for now.
9487 */
9488 mutex_exit(cport_mutex);
9489 return (TRAN_BADPKT);
9490
9491 case CDB_GROUPID_6: /* Vendor-specific, per SPC-4 */
9492 case CDB_GROUPID_7: /* Vendor-specific, per SPC-4 */
9493 /* obtain length from the scsi_pkt */
9494 cdblen = scsipkt->pkt_cdblen;
9495 break;
9496
9497 default:
9498 /* CDB's length is statically known, per SPC-4 */
9499 cdblen = scsi_cdb_size[GETGROUP(cdbp)];
9500 break;
9501 }
9502
9503 if (cdblen <= 0 || cdblen > sdinfo->satadrv_atapi_cdb_len) {
9504 sata_log(NULL, CE_WARN,
9505 "sata: invalid ATAPI cdb length %d",
9506 cdblen);
9507 mutex_exit(cport_mutex);
9508 return (TRAN_BADPKT);
9509 }
9510
9511 SATAATAPITRACE(spx, cdblen);
9512
9513 /*
9514 * For non-read/write commands we need to
9515 * map buffer
9516 */
9517 switch ((uint_t)scsipkt->pkt_cdbp[0]) {
9518 case SCMD_READ:
9519 case SCMD_READ_G1:
9520 case SCMD_READ_G5:
9521 case SCMD_READ_G4:
9522 case SCMD_WRITE:
9523 case SCMD_WRITE_G1:
9524 case SCMD_WRITE_G5:
9525 case SCMD_WRITE_G4:
9526 break;
9527 default:
9528 if (bp != NULL) {
9529 if (bp->b_flags & (B_PHYS | B_PAGEIO))
9530 bp_mapin(bp);
9531 }
9532 break;
9533 }
9534 /*
9535 * scmd->satacmd_flags.sata_data_direction default -
9536 * SATA_DIR_NODATA_XFER - is set by
9537 * sata_txlt_generic_pkt_info().
9538 */
9539 if (scmd->satacmd_bp) {
9540 if (scmd->satacmd_bp->b_flags & B_READ) {
9541 scmd->satacmd_flags.sata_data_direction = SATA_DIR_READ;
9542 } else {
9543 scmd->satacmd_flags.sata_data_direction =
9544 SATA_DIR_WRITE;
9545 }
9546 }
9547
9548 /*
9549 * Set up ATAPI packet command.
9550 */
9551
9552 sata_atapi_packet_cmd_setup(scmd, sdinfo);
9553
9554 /* Copy cdb into sata_cmd */
9555 scmd->satacmd_acdb_len = sdinfo->satadrv_atapi_cdb_len;
9556 bzero(scmd->satacmd_acdb, SATA_ATAPI_MAX_CDB_LEN);
9557 bcopy(cdbp, scmd->satacmd_acdb, cdblen);
9558
9559 /* See note in the command header */
9560 if (scmd->satacmd_acdb[0] == SCMD_INQUIRY) {
9561 if (scmd->satacmd_acdb[3] != 0)
9562 scmd->satacmd_acdb[4] = 255;
9563 }
9564
9565 #ifdef SATA_DEBUG
9566 if (sata_debug_flags & SATA_DBG_ATAPI) {
9567 uint8_t *p = scmd->satacmd_acdb;
9568 char buf[3 * SATA_ATAPI_MAX_CDB_LEN];
9569
9570 (void) snprintf(buf, SATA_ATAPI_MAX_CDB_LEN,
9571 "%02x %02x %02x %02x %02x %02x %02x %02x "
9572 "%2x %02x %02x %02x %02x %02x %02x %02x",
9573 p[0], p[1], p[2], p[3], p[4], p[5], p[6], p[7],
9574 p[8], p[9], p[10], p[11], p[12], p[13], p[14], p[15]);
9575 buf[(3 * SATA_ATAPI_MAX_CDB_LEN) - 1] = '\0';
9576 cmn_err(CE_NOTE, "ATAPI cdb: %s\n", buf);
9577 }
9578 #endif
9579
9580 /*
9581 * Preset request sense data to NO SENSE.
9582 * If there is no way to get error information via Request Sense,
9583 * the packet request sense data would not have to be modified by HBA,
9584 * but it could be returned as is.
9585 */
9586 bzero(scmd->satacmd_rqsense, SATA_ATAPI_RQSENSE_LEN);
9587 sata_fixed_sense_data_preset(
9588 (struct scsi_extended_sense *)scmd->satacmd_rqsense);
9589
9590 if (!(spx->txlt_sata_pkt->satapkt_op_mode & SATA_OPMODE_SYNCH)) {
9591 /* Need callback function */
9592 spx->txlt_sata_pkt->satapkt_comp = sata_txlt_atapi_completion;
9593 synch = FALSE;
9594 } else
9595 synch = TRUE;
9596
9597 /* Transfer command to HBA */
9598 if (sata_hba_start(spx, &rval) != 0) {
9599 /* Pkt not accepted for execution */
9600 mutex_exit(cport_mutex);
9601 return (rval);
9602 }
9603 mutex_exit(cport_mutex);
9604 /*
9605 * If execution is non-synchronous,
9606 * a callback function will handle potential errors, translate
9607 * the response and will do a callback to a target driver.
9608 * If it was synchronous, use the same framework callback to check
9609 * an execution status.
9610 */
9611 if (synch) {
9612 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst,
9613 "synchronous execution status %x\n",
9614 spx->txlt_sata_pkt->satapkt_reason);
9615 sata_txlt_atapi_completion(spx->txlt_sata_pkt);
9616 }
9617 return (TRAN_ACCEPT);
9618 }
9619
9620
9621 /*
9622 * ATAPI Packet command completion.
9623 *
9624 * Failure of the command passed via Packet command are considered device
9625 * error. SATA HBA driver would have to retrieve error data (via Request
9626 * Sense command delivered via error retrieval sata packet) and copy it
9627 * to satacmd_rqsense array. From there, it is moved into scsi pkt sense data.
9628 */
9629 static void
sata_txlt_atapi_completion(sata_pkt_t * sata_pkt)9630 sata_txlt_atapi_completion(sata_pkt_t *sata_pkt)
9631 {
9632 sata_pkt_txlate_t *spx =
9633 (sata_pkt_txlate_t *)sata_pkt->satapkt_framework_private;
9634 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt;
9635 struct scsi_extended_sense *sense;
9636 struct buf *bp;
9637 int rval;
9638
9639 #ifdef SATA_DEBUG
9640 uint8_t *rqsp = sata_pkt->satapkt_cmd.satacmd_rqsense;
9641 #endif
9642
9643 scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET |
9644 STATE_SENT_CMD | STATE_GOT_STATUS;
9645
9646 if (sata_pkt->satapkt_reason == SATA_PKT_COMPLETED) {
9647 /* Normal completion */
9648 if (sata_pkt->satapkt_cmd.satacmd_bp != NULL)
9649 scsipkt->pkt_state |= STATE_XFERRED_DATA;
9650 scsipkt->pkt_reason = CMD_CMPLT;
9651 *scsipkt->pkt_scbp = STATUS_GOOD;
9652 if (spx->txlt_tmp_buf != NULL) {
9653 /* Temporary buffer was used */
9654 bp = spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp;
9655 if (bp->b_flags & B_READ) {
9656 rval = ddi_dma_sync(
9657 spx->txlt_buf_dma_handle, 0, 0,
9658 DDI_DMA_SYNC_FORCPU);
9659 ASSERT(rval == DDI_SUCCESS);
9660 bcopy(spx->txlt_tmp_buf, bp->b_un.b_addr,
9661 bp->b_bcount);
9662 }
9663 }
9664 } else {
9665 /*
9666 * Something went wrong - analyze return
9667 */
9668 *scsipkt->pkt_scbp = STATUS_CHECK;
9669 sense = sata_arq_sense(spx);
9670
9671 if (sata_pkt->satapkt_reason == SATA_PKT_DEV_ERROR) {
9672 /*
9673 * pkt_reason should be CMD_CMPLT for DEVICE ERROR.
9674 * Under this condition ERR bit is set for ATA command,
9675 * and CHK bit set for ATAPI command.
9676 *
9677 * Please check st_intr & sdintr about how pkt_reason
9678 * is used.
9679 */
9680 scsipkt->pkt_reason = CMD_CMPLT;
9681
9682 /*
9683 * We may not have ARQ data if there was a double
9684 * error. But sense data in sata packet was pre-set
9685 * with NO SENSE so it is valid even if HBA could
9686 * not retrieve a real sense data.
9687 * Just copy this sense data into scsi pkt sense area.
9688 */
9689 bcopy(sata_pkt->satapkt_cmd.satacmd_rqsense, sense,
9690 SATA_ATAPI_MIN_RQSENSE_LEN);
9691 #ifdef SATA_DEBUG
9692 if (sata_debug_flags & SATA_DBG_SCSI_IF) {
9693 sata_log(spx->txlt_sata_hba_inst, CE_WARN,
9694 "sata_txlt_atapi_completion: %02x\n"
9695 "RQSENSE: %02x %02x %02x %02x %02x %02x "
9696 " %02x %02x %02x %02x %02x %02x "
9697 " %02x %02x %02x %02x %02x %02x\n",
9698 scsipkt->pkt_reason,
9699 rqsp[0], rqsp[1], rqsp[2], rqsp[3],
9700 rqsp[4], rqsp[5], rqsp[6], rqsp[7],
9701 rqsp[8], rqsp[9], rqsp[10], rqsp[11],
9702 rqsp[12], rqsp[13], rqsp[14], rqsp[15],
9703 rqsp[16], rqsp[17]);
9704 }
9705 #endif
9706 } else {
9707 switch (sata_pkt->satapkt_reason) {
9708 case SATA_PKT_PORT_ERROR:
9709 /*
9710 * We have no device data.
9711 */
9712 scsipkt->pkt_reason = CMD_INCOMPLETE;
9713 scsipkt->pkt_state &= ~(STATE_GOT_BUS |
9714 STATE_GOT_TARGET | STATE_SENT_CMD |
9715 STATE_GOT_STATUS);
9716 sense->es_key = KEY_HARDWARE_ERROR;
9717 break;
9718
9719 case SATA_PKT_TIMEOUT:
9720 scsipkt->pkt_reason = CMD_TIMEOUT;
9721 scsipkt->pkt_statistics |=
9722 STAT_TIMEOUT | STAT_DEV_RESET;
9723 /*
9724 * Need to check if HARDWARE_ERROR/
9725 * TIMEOUT_ON_LOGICAL_UNIT 4/3E/2 would be more
9726 * appropriate.
9727 */
9728 break;
9729
9730 case SATA_PKT_ABORTED:
9731 scsipkt->pkt_reason = CMD_ABORTED;
9732 scsipkt->pkt_statistics |= STAT_ABORTED;
9733 /* Should we set key COMMAND_ABPRTED? */
9734 break;
9735
9736 case SATA_PKT_RESET:
9737 scsipkt->pkt_reason = CMD_RESET;
9738 scsipkt->pkt_statistics |= STAT_DEV_RESET;
9739 /*
9740 * May be we should set Unit Attention /
9741 * Reset. Perhaps the same should be
9742 * returned for disks....
9743 */
9744 sense->es_key = KEY_UNIT_ATTENTION;
9745 sense->es_add_code = SD_SCSI_ASC_RESET;
9746 break;
9747
9748 default:
9749 SATA_LOG_D((spx->txlt_sata_hba_inst, CE_WARN,
9750 "sata_txlt_atapi_completion: "
9751 "invalid packet completion reason"));
9752 scsipkt->pkt_reason = CMD_TRAN_ERR;
9753 scsipkt->pkt_state &= ~(STATE_GOT_BUS |
9754 STATE_GOT_TARGET | STATE_SENT_CMD |
9755 STATE_GOT_STATUS);
9756 break;
9757 }
9758 }
9759 }
9760
9761 SATAATAPITRACE(spx, 0);
9762
9763 if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0 &&
9764 scsipkt->pkt_comp != NULL) {
9765 /* scsi callback required */
9766 (*scsipkt->pkt_comp)(scsipkt);
9767 }
9768 }
9769
9770 /*
9771 * Set up error retrieval sata command for ATAPI Packet Command error data
9772 * recovery.
9773 *
9774 * Returns SATA_SUCCESS when data buffer is allocated and packet set-up,
9775 * returns SATA_FAILURE otherwise.
9776 */
9777
9778 static int
sata_atapi_err_ret_cmd_setup(sata_pkt_txlate_t * spx,sata_drive_info_t * sdinfo)9779 sata_atapi_err_ret_cmd_setup(sata_pkt_txlate_t *spx, sata_drive_info_t *sdinfo)
9780 {
9781 sata_pkt_t *spkt = spx->txlt_sata_pkt;
9782 sata_cmd_t *scmd;
9783 struct buf *bp;
9784
9785 /*
9786 * Allocate dma-able buffer error data.
9787 * Buffer allocation will take care of buffer alignment and other DMA
9788 * attributes.
9789 */
9790 bp = sata_alloc_local_buffer(spx, SATA_ATAPI_MIN_RQSENSE_LEN);
9791 if (bp == NULL) {
9792 SATADBG1(SATA_DBG_ATAPI, spx->txlt_sata_hba_inst,
9793 "sata_get_err_retrieval_pkt: "
9794 "cannot allocate buffer for error data", NULL);
9795 return (SATA_FAILURE);
9796 }
9797 bp_mapin(bp); /* make data buffer accessible */
9798
9799 /* Operation modes are up to the caller */
9800 spkt->satapkt_op_mode = SATA_OPMODE_SYNCH | SATA_OPMODE_INTERRUPTS;
9801
9802 /* Synchronous mode, no callback - may be changed by the caller */
9803 spkt->satapkt_comp = NULL;
9804 spkt->satapkt_time = sata_default_pkt_time;
9805
9806 scmd = &spkt->satapkt_cmd;
9807 scmd->satacmd_flags.sata_data_direction = SATA_DIR_READ;
9808 scmd->satacmd_flags.sata_ignore_dev_reset = B_TRUE;
9809
9810 sata_atapi_packet_cmd_setup(scmd, sdinfo);
9811
9812 /*
9813 * Set-up acdb. Request Sense CDB (packet command content) is
9814 * not in DMA-able buffer. Its handling is HBA-specific (how
9815 * it is transfered into packet FIS).
9816 */
9817 scmd->satacmd_acdb_len = sdinfo->satadrv_atapi_cdb_len;
9818 bcopy(sata_rqsense_cdb, scmd->satacmd_acdb, SATA_ATAPI_RQSENSE_CDB_LEN);
9819 /* Following zeroing of pad bytes may not be necessary */
9820 bzero(&scmd->satacmd_acdb[SATA_ATAPI_RQSENSE_CDB_LEN],
9821 sdinfo->satadrv_atapi_cdb_len - SATA_ATAPI_RQSENSE_CDB_LEN);
9822
9823 /*
9824 * Set-up pointer to the buffer handle, so HBA can sync buffer
9825 * before accessing it. Handle is in usual place in translate struct.
9826 */
9827 scmd->satacmd_err_ret_buf_handle = &spx->txlt_buf_dma_handle;
9828
9829 /*
9830 * Preset request sense data to NO SENSE.
9831 * Here it is redundant, only for a symetry with scsi-originated
9832 * packets. It should not be used for anything but debugging.
9833 */
9834 bzero(scmd->satacmd_rqsense, SATA_ATAPI_RQSENSE_LEN);
9835 sata_fixed_sense_data_preset(
9836 (struct scsi_extended_sense *)scmd->satacmd_rqsense);
9837
9838 ASSERT(scmd->satacmd_num_dma_cookies != 0);
9839 ASSERT(scmd->satacmd_dma_cookie_list != NULL);
9840
9841 return (SATA_SUCCESS);
9842 }
9843
9844 /*
9845 * Set-up ATAPI packet command.
9846 * Data transfer direction has to be set-up in sata_cmd structure prior to
9847 * calling this function.
9848 *
9849 * Returns void
9850 */
9851
9852 static void
sata_atapi_packet_cmd_setup(sata_cmd_t * scmd,sata_drive_info_t * sdinfo)9853 sata_atapi_packet_cmd_setup(sata_cmd_t *scmd, sata_drive_info_t *sdinfo)
9854 {
9855 scmd->satacmd_addr_type = 0; /* N/A */
9856 scmd->satacmd_sec_count_lsb = 0; /* no tag */
9857 scmd->satacmd_lba_low_lsb = 0; /* N/A */
9858 scmd->satacmd_lba_mid_lsb = (uint8_t)SATA_ATAPI_MAX_BYTES_PER_DRQ;
9859 scmd->satacmd_lba_high_lsb =
9860 (uint8_t)(SATA_ATAPI_MAX_BYTES_PER_DRQ >> 8);
9861 scmd->satacmd_cmd_reg = SATAC_PACKET; /* Command */
9862
9863 /*
9864 * We want all data to be transfered via DMA.
9865 * But specify it only if drive supports DMA and DMA mode is
9866 * selected - some drives are sensitive about it.
9867 * Hopefully it wil work for all drives....
9868 */
9869 if (sdinfo->satadrv_settings & SATA_DEV_DMA)
9870 scmd->satacmd_features_reg = SATA_ATAPI_F_DMA;
9871
9872 /*
9873 * Features register requires special care for devices that use
9874 * Serial ATA bridge - they need an explicit specification of
9875 * the data transfer direction for Packet DMA commands.
9876 * Setting this bit is harmless if DMA is not used.
9877 *
9878 * Many drives do not implement word 80, specifying what ATA/ATAPI
9879 * spec they follow.
9880 * We are arbitrarily following the latest SerialATA 2.6 spec,
9881 * which uses ATA/ATAPI 6 specification for Identify Data, unless
9882 * ATA/ATAPI-7 support is explicitly indicated.
9883 */
9884 if (sdinfo->satadrv_id.ai_majorversion != 0 &&
9885 sdinfo->satadrv_id.ai_majorversion != 0xffff &&
9886 (sdinfo->satadrv_id.ai_majorversion & SATA_MAJVER_7) != 0) {
9887 /*
9888 * Specification of major version is valid and version 7
9889 * is supported. It does automatically imply that all
9890 * spec features are supported. For now, we assume that
9891 * DMADIR setting is valid. ATA/ATAPI7 spec is incomplete.
9892 */
9893 if ((sdinfo->satadrv_id.ai_dirdma &
9894 SATA_ATAPI_ID_DMADIR_REQ) != 0) {
9895 if (scmd->satacmd_flags.sata_data_direction ==
9896 SATA_DIR_READ) {
9897 scmd->satacmd_features_reg |=
9898 SATA_ATAPI_F_DATA_DIR_READ;
9899 }
9900 }
9901 }
9902 }
9903
9904
9905 #ifdef SATA_DEBUG
9906
9907 /* Display 18 bytes of Inquiry data */
9908 static void
sata_show_inqry_data(uint8_t * buf)9909 sata_show_inqry_data(uint8_t *buf)
9910 {
9911 struct scsi_inquiry *inq = (struct scsi_inquiry *)buf;
9912 uint8_t *p;
9913
9914 cmn_err(CE_NOTE, "Inquiry data:");
9915 cmn_err(CE_NOTE, "device type %x", inq->inq_dtype);
9916 cmn_err(CE_NOTE, "removable media %x", inq->inq_rmb);
9917 cmn_err(CE_NOTE, "version %x", inq->inq_ansi);
9918 cmn_err(CE_NOTE, "ATAPI transport version %d",
9919 SATA_ATAPI_TRANS_VERSION(inq));
9920 cmn_err(CE_NOTE, "response data format %d, aenc %d",
9921 inq->inq_rdf, inq->inq_aenc);
9922 cmn_err(CE_NOTE, " additional length %d", inq->inq_len);
9923 cmn_err(CE_NOTE, "tpgs %d", inq->inq_tpgs);
9924 p = (uint8_t *)inq->inq_vid;
9925 cmn_err(CE_NOTE, "vendor id (binary): %02x %02x %02x %02x "
9926 "%02x %02x %02x %02x",
9927 p[0], p[1], p[2], p[3], p[4], p[5], p[6], p[7]);
9928 p = (uint8_t *)inq->inq_vid;
9929 cmn_err(CE_NOTE, "vendor id: %c %c %c %c %c %c %c %c",
9930 p[0], p[1], p[2], p[3], p[4], p[5], p[6], p[7]);
9931
9932 p = (uint8_t *)inq->inq_pid;
9933 cmn_err(CE_NOTE, "product id (binary): %02x %02x %02x %02x "
9934 "%02x %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x",
9935 p[0], p[1], p[2], p[3], p[4], p[5], p[6], p[7],
9936 p[8], p[9], p[10], p[11], p[12], p[13], p[14], p[15]);
9937 p = (uint8_t *)inq->inq_pid;
9938 cmn_err(CE_NOTE, "product id: %c %c %c %c %c %c %c %c "
9939 "%c %c %c %c %c %c %c %c",
9940 p[0], p[1], p[2], p[3], p[4], p[5], p[6], p[7],
9941 p[8], p[9], p[10], p[11], p[12], p[13], p[14], p[15]);
9942
9943 p = (uint8_t *)inq->inq_revision;
9944 cmn_err(CE_NOTE, "revision (binary): %02x %02x %02x %02x",
9945 p[0], p[1], p[2], p[3]);
9946 p = (uint8_t *)inq->inq_revision;
9947 cmn_err(CE_NOTE, "revision: %c %c %c %c",
9948 p[0], p[1], p[2], p[3]);
9949
9950 }
9951
9952
9953 static void
sata_save_atapi_trace(sata_pkt_txlate_t * spx,int count)9954 sata_save_atapi_trace(sata_pkt_txlate_t *spx, int count)
9955 {
9956 struct scsi_pkt *scsi_pkt = spx->txlt_scsi_pkt;
9957
9958 if (scsi_pkt == NULL)
9959 return;
9960 if (count != 0) {
9961 /* saving cdb */
9962 bzero(sata_atapi_trace[sata_atapi_trace_index].acdb,
9963 SATA_ATAPI_MAX_CDB_LEN);
9964 bcopy(scsi_pkt->pkt_cdbp,
9965 sata_atapi_trace[sata_atapi_trace_index].acdb, count);
9966 } else {
9967 bcopy(&((struct scsi_arq_status *)scsi_pkt->pkt_scbp)->
9968 sts_sensedata,
9969 sata_atapi_trace[sata_atapi_trace_index].arqs,
9970 SATA_ATAPI_MIN_RQSENSE_LEN);
9971 sata_atapi_trace[sata_atapi_trace_index].scsi_pkt_reason =
9972 scsi_pkt->pkt_reason;
9973 sata_atapi_trace[sata_atapi_trace_index].sata_pkt_reason =
9974 spx->txlt_sata_pkt->satapkt_reason;
9975
9976 if (++sata_atapi_trace_index >= 64)
9977 sata_atapi_trace_index = 0;
9978 }
9979 }
9980
9981 #endif
9982
9983 /*
9984 * Fetch inquiry data from ATAPI device
9985 * Returns SATA_SUCCESS if operation was successful, SATA_FAILURE otherwise.
9986 *
9987 * Note:
9988 * inqb pointer does not point to a DMA-able buffer. It is a local buffer
9989 * where the caller expects to see the inquiry data.
9990 *
9991 */
9992
9993 static int
sata_get_atapi_inquiry_data(sata_hba_inst_t * sata_hba,sata_address_t * saddr,struct scsi_inquiry * inq)9994 sata_get_atapi_inquiry_data(sata_hba_inst_t *sata_hba,
9995 sata_address_t *saddr, struct scsi_inquiry *inq)
9996 {
9997 sata_pkt_txlate_t *spx;
9998 sata_pkt_t *spkt;
9999 struct buf *bp;
10000 sata_drive_info_t *sdinfo;
10001 sata_cmd_t *scmd;
10002 int rval;
10003 uint8_t *rqsp;
10004 dev_info_t *dip = SATA_DIP(sata_hba);
10005 #ifdef SATA_DEBUG
10006 char msg_buf[MAXPATHLEN];
10007 #endif
10008 kmutex_t *cport_mutex;
10009
10010 ASSERT(sata_hba != NULL);
10011
10012 spx = kmem_zalloc(sizeof (sata_pkt_txlate_t), KM_SLEEP);
10013 spx->txlt_sata_hba_inst = sata_hba;
10014 spx->txlt_scsi_pkt = NULL; /* No scsi pkt involved */
10015 spkt = sata_pkt_alloc(spx, NULL);
10016 if (spkt == NULL) {
10017 kmem_free(spx, sizeof (sata_pkt_txlate_t));
10018 return (SATA_FAILURE);
10019 }
10020 /* address is needed now */
10021 spkt->satapkt_device.satadev_addr = *saddr;
10022
10023 /* scsi_inquiry size buffer */
10024 bp = sata_alloc_local_buffer(spx, sizeof (struct scsi_inquiry));
10025 if (bp == NULL) {
10026 sata_pkt_free(spx);
10027 kmem_free(spx, sizeof (sata_pkt_txlate_t));
10028 SATA_LOG_D((sata_hba, CE_WARN,
10029 "sata_get_atapi_inquiry_data: "
10030 "cannot allocate data buffer"));
10031 return (SATA_FAILURE);
10032 }
10033 bp_mapin(bp); /* make data buffer accessible */
10034
10035 scmd = &spkt->satapkt_cmd;
10036 ASSERT(scmd->satacmd_num_dma_cookies != 0);
10037 ASSERT(scmd->satacmd_dma_cookie_list != NULL);
10038
10039 /* Use synchronous mode */
10040 spkt->satapkt_op_mode = SATA_OPMODE_SYNCH | SATA_OPMODE_INTERRUPTS;
10041 spkt->satapkt_comp = NULL;
10042 spkt->satapkt_time = sata_default_pkt_time;
10043
10044 /* Issue inquiry command - 6 bytes cdb, data transfer, read */
10045
10046 scmd->satacmd_flags.sata_data_direction = SATA_DIR_READ;
10047 scmd->satacmd_flags.sata_ignore_dev_reset = B_TRUE;
10048
10049 cport_mutex = &(SATA_CPORT_MUTEX(sata_hba, saddr->cport));
10050 mutex_enter(cport_mutex);
10051 sdinfo = sata_get_device_info(sata_hba,
10052 &spx->txlt_sata_pkt->satapkt_device);
10053 if (sdinfo == NULL) {
10054 /* we have to be carefull about the disapearing device */
10055 mutex_exit(cport_mutex);
10056 rval = SATA_FAILURE;
10057 goto cleanup;
10058 }
10059 sata_atapi_packet_cmd_setup(scmd, sdinfo);
10060
10061 /*
10062 * Set-up acdb. This works for atapi transport version 2 and later.
10063 */
10064 scmd->satacmd_acdb_len = sdinfo->satadrv_atapi_cdb_len;
10065 bzero(scmd->satacmd_acdb, SATA_ATAPI_MAX_CDB_LEN);
10066 scmd->satacmd_acdb[0] = 0x12; /* Inquiry */
10067 scmd->satacmd_acdb[1] = 0x00;
10068 scmd->satacmd_acdb[2] = 0x00;
10069 scmd->satacmd_acdb[3] = 0x00;
10070 scmd->satacmd_acdb[4] = sizeof (struct scsi_inquiry);
10071 scmd->satacmd_acdb[5] = 0x00;
10072
10073 sata_fixed_sense_data_preset(
10074 (struct scsi_extended_sense *)scmd->satacmd_rqsense);
10075
10076 /* Transfer command to HBA */
10077 if (sata_hba_start(spx, &rval) != 0) {
10078 /* Pkt not accepted for execution */
10079 SATADBG1(SATA_DBG_ATAPI, sata_hba,
10080 "sata_get_atapi_inquiry_data: "
10081 "Packet not accepted for execution - ret: %02x", rval);
10082 mutex_exit(cport_mutex);
10083 rval = SATA_FAILURE;
10084 goto cleanup;
10085 }
10086 mutex_exit(cport_mutex);
10087
10088 if (spkt->satapkt_reason == SATA_PKT_COMPLETED) {
10089 SATADBG1(SATA_DBG_ATAPI, sata_hba,
10090 "sata_get_atapi_inquiry_data: "
10091 "Packet completed successfully - ret: %02x", rval);
10092 if (spx->txlt_buf_dma_handle != NULL) {
10093 /*
10094 * Sync buffer. Handle is in usual place in translate
10095 * struct.
10096 */
10097 rval = ddi_dma_sync(spx->txlt_buf_dma_handle, 0, 0,
10098 DDI_DMA_SYNC_FORCPU);
10099 ASSERT(rval == DDI_SUCCESS);
10100 }
10101
10102 if (sata_check_for_dma_error(dip, spx)) {
10103 ddi_fm_service_impact(dip, DDI_SERVICE_UNAFFECTED);
10104 rval = SATA_FAILURE;
10105 } else {
10106 /*
10107 * Normal completion - copy data into caller's buffer
10108 */
10109 bcopy(bp->b_un.b_addr, (uint8_t *)inq,
10110 sizeof (struct scsi_inquiry));
10111 #ifdef SATA_DEBUG
10112 if (sata_debug_flags & SATA_DBG_ATAPI) {
10113 sata_show_inqry_data((uint8_t *)inq);
10114 }
10115 #endif
10116 rval = SATA_SUCCESS;
10117 }
10118 } else {
10119 /*
10120 * Something went wrong - analyze return - check rqsense data
10121 */
10122 rval = SATA_FAILURE;
10123 if (spkt->satapkt_reason == SATA_PKT_DEV_ERROR) {
10124 /*
10125 * ARQ data hopefull show something other than NO SENSE
10126 */
10127 rqsp = scmd->satacmd_rqsense;
10128 #ifdef SATA_DEBUG
10129 if (sata_debug_flags & SATA_DBG_ATAPI) {
10130 msg_buf[0] = '\0';
10131 (void) snprintf(msg_buf, MAXPATHLEN,
10132 "ATAPI packet completion reason: %02x\n"
10133 "RQSENSE: %02x %02x %02x %02x %02x %02x\n"
10134 " %02x %02x %02x %02x %02x %02x\n"
10135 " %02x %02x %02x %02x %02x %02x",
10136 spkt->satapkt_reason,
10137 rqsp[0], rqsp[1], rqsp[2], rqsp[3],
10138 rqsp[4], rqsp[5], rqsp[6], rqsp[7],
10139 rqsp[8], rqsp[9], rqsp[10], rqsp[11],
10140 rqsp[12], rqsp[13], rqsp[14], rqsp[15],
10141 rqsp[16], rqsp[17]);
10142 sata_log(spx->txlt_sata_hba_inst, CE_WARN,
10143 "%s", msg_buf);
10144 }
10145 #endif
10146 } else {
10147 switch (spkt->satapkt_reason) {
10148 case SATA_PKT_PORT_ERROR:
10149 SATADBG1(SATA_DBG_ATAPI, sata_hba,
10150 "sata_get_atapi_inquiry_data: "
10151 "packet reason: port error", NULL);
10152 break;
10153
10154 case SATA_PKT_TIMEOUT:
10155 SATADBG1(SATA_DBG_ATAPI, sata_hba,
10156 "sata_get_atapi_inquiry_data: "
10157 "packet reason: timeout", NULL);
10158 break;
10159
10160 case SATA_PKT_ABORTED:
10161 SATADBG1(SATA_DBG_ATAPI, sata_hba,
10162 "sata_get_atapi_inquiry_data: "
10163 "packet reason: aborted", NULL);
10164 break;
10165
10166 case SATA_PKT_RESET:
10167 SATADBG1(SATA_DBG_ATAPI, sata_hba,
10168 "sata_get_atapi_inquiry_data: "
10169 "packet reason: reset\n", NULL);
10170 break;
10171 default:
10172 SATADBG1(SATA_DBG_ATAPI, sata_hba,
10173 "sata_get_atapi_inquiry_data: "
10174 "invalid packet reason: %02x\n",
10175 spkt->satapkt_reason);
10176 break;
10177 }
10178 }
10179 }
10180 cleanup:
10181 sata_free_local_buffer(spx);
10182 sata_pkt_free(spx);
10183 kmem_free(spx, sizeof (sata_pkt_txlate_t));
10184 return (rval);
10185 }
10186
10187
10188
10189
10190
10191 #if 0
10192 #ifdef SATA_DEBUG
10193
10194 /*
10195 * Test ATAPI packet command.
10196 * Single threaded test: send packet command in synch mode, process completion
10197 *
10198 */
10199 static void
10200 sata_test_atapi_packet_command(sata_hba_inst_t *sata_hba_inst, int cport)
10201 {
10202 sata_pkt_txlate_t *spx;
10203 sata_pkt_t *spkt;
10204 struct buf *bp;
10205 sata_device_t sata_device;
10206 sata_drive_info_t *sdinfo;
10207 sata_cmd_t *scmd;
10208 int rval;
10209 uint8_t *rqsp;
10210
10211 ASSERT(sata_hba_inst != NULL);
10212 sata_device.satadev_addr.cport = cport;
10213 sata_device.satadev_addr.pmport = 0;
10214 sata_device.satadev_addr.qual = SATA_ADDR_DCPORT;
10215 sata_device.satadev_rev = SATA_DEVICE_REV;
10216 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex);
10217 sdinfo = sata_get_device_info(sata_hba_inst, &sata_device);
10218 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex);
10219 if (sdinfo == NULL) {
10220 sata_log(sata_hba_inst, CE_WARN,
10221 "sata_test_atapi_packet_command: "
10222 "no device info for cport %d",
10223 sata_device.satadev_addr.cport);
10224 return;
10225 }
10226
10227 spx = kmem_zalloc(sizeof (sata_pkt_txlate_t), KM_SLEEP);
10228 spx->txlt_sata_hba_inst = sata_hba_inst;
10229 spx->txlt_scsi_pkt = NULL; /* No scsi pkt involved */
10230 spkt = sata_pkt_alloc(spx, NULL);
10231 if (spkt == NULL) {
10232 kmem_free(spx, sizeof (sata_pkt_txlate_t));
10233 return;
10234 }
10235 /* address is needed now */
10236 spkt->satapkt_device.satadev_addr = sata_device.satadev_addr;
10237
10238 /* 1024k buffer */
10239 bp = sata_alloc_local_buffer(spx, 1024);
10240 if (bp == NULL) {
10241 sata_pkt_free(spx);
10242 kmem_free(spx, sizeof (sata_pkt_txlate_t));
10243 sata_log(sata_hba_inst, CE_WARN,
10244 "sata_test_atapi_packet_command: "
10245 "cannot allocate data buffer");
10246 return;
10247 }
10248 bp_mapin(bp); /* make data buffer accessible */
10249
10250 scmd = &spkt->satapkt_cmd;
10251 ASSERT(scmd->satacmd_num_dma_cookies != 0);
10252 ASSERT(scmd->satacmd_dma_cookie_list != NULL);
10253
10254 /* Use synchronous mode */
10255 spkt->satapkt_op_mode = SATA_OPMODE_SYNCH | SATA_OPMODE_INTERRUPTS;
10256
10257 /* Synchronous mode, no callback - may be changed by the caller */
10258 spkt->satapkt_comp = NULL;
10259 spkt->satapkt_time = sata_default_pkt_time;
10260
10261 /* Issue inquiry command - 6 bytes cdb, data transfer, read */
10262
10263 scmd->satacmd_flags.sata_data_direction = SATA_DIR_READ;
10264 scmd->satacmd_flags.sata_ignore_dev_reset = B_TRUE;
10265
10266 sata_atapi_packet_cmd_setup(scmd, sdinfo);
10267
10268 /* Set-up acdb. */
10269 scmd->satacmd_acdb_len = sdinfo->satadrv_atapi_cdb_len;
10270 bzero(scmd->satacmd_acdb, SATA_ATAPI_MAX_CDB_LEN);
10271 scmd->satacmd_acdb[0] = 0x12; /* Inquiry */
10272 scmd->satacmd_acdb[1] = 0x00;
10273 scmd->satacmd_acdb[2] = 0x00;
10274 scmd->satacmd_acdb[3] = 0x00;
10275 scmd->satacmd_acdb[4] = sizeof (struct scsi_inquiry);
10276 scmd->satacmd_acdb[5] = 0x00;
10277
10278 sata_fixed_sense_data_preset(
10279 (struct scsi_extended_sense *)scmd->satacmd_rqsense);
10280
10281 /* Transfer command to HBA */
10282 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex);
10283 if (sata_hba_start(spx, &rval) != 0) {
10284 /* Pkt not accepted for execution */
10285 sata_log(sata_hba_inst, CE_WARN,
10286 "sata_test_atapi_packet_command: "
10287 "Packet not accepted for execution - ret: %02x", rval);
10288 mutex_exit(
10289 &SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex);
10290 goto cleanup;
10291 }
10292 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex);
10293
10294 if (spx->txlt_buf_dma_handle != NULL) {
10295 /*
10296 * Sync buffer. Handle is in usual place in translate struct.
10297 */
10298 rval = ddi_dma_sync(spx->txlt_buf_dma_handle, 0, 0,
10299 DDI_DMA_SYNC_FORCPU);
10300 ASSERT(rval == DDI_SUCCESS);
10301 }
10302 if (spkt->satapkt_reason == SATA_PKT_COMPLETED) {
10303 sata_log(sata_hba_inst, CE_WARN,
10304 "sata_test_atapi_packet_command: "
10305 "Packet completed successfully");
10306 /*
10307 * Normal completion - show inquiry data
10308 */
10309 sata_show_inqry_data((uint8_t *)bp->b_un.b_addr);
10310 } else {
10311 /*
10312 * Something went wrong - analyze return - check rqsense data
10313 */
10314 if (spkt->satapkt_reason == SATA_PKT_DEV_ERROR) {
10315 /*
10316 * ARQ data hopefull show something other than NO SENSE
10317 */
10318 rqsp = scmd->satacmd_rqsense;
10319 sata_log(spx->txlt_sata_hba_inst, CE_WARN,
10320 "ATAPI packet completion reason: %02x\n"
10321 "RQSENSE: %02x %02x %02x %02x %02x %02x "
10322 " %02x %02x %02x %02x %02x %02x "
10323 " %02x %02x %02x %02x %02x %02x\n",
10324 spkt->satapkt_reason,
10325 rqsp[0], rqsp[1], rqsp[2], rqsp[3],
10326 rqsp[4], rqsp[5], rqsp[6], rqsp[7],
10327 rqsp[8], rqsp[9], rqsp[10], rqsp[11],
10328 rqsp[12], rqsp[13], rqsp[14], rqsp[15],
10329 rqsp[16], rqsp[17]);
10330 } else {
10331 switch (spkt->satapkt_reason) {
10332 case SATA_PKT_PORT_ERROR:
10333 sata_log(sata_hba_inst, CE_WARN,
10334 "sata_test_atapi_packet_command: "
10335 "packet reason: port error\n");
10336 break;
10337
10338 case SATA_PKT_TIMEOUT:
10339 sata_log(sata_hba_inst, CE_WARN,
10340 "sata_test_atapi_packet_command: "
10341 "packet reason: timeout\n");
10342 break;
10343
10344 case SATA_PKT_ABORTED:
10345 sata_log(sata_hba_inst, CE_WARN,
10346 "sata_test_atapi_packet_command: "
10347 "packet reason: aborted\n");
10348 break;
10349
10350 case SATA_PKT_RESET:
10351 sata_log(sata_hba_inst, CE_WARN,
10352 "sata_test_atapi_packet_command: "
10353 "packet reason: reset\n");
10354 break;
10355 default:
10356 sata_log(sata_hba_inst, CE_WARN,
10357 "sata_test_atapi_packet_command: "
10358 "invalid packet reason: %02x\n",
10359 spkt->satapkt_reason);
10360 break;
10361 }
10362 }
10363 }
10364 cleanup:
10365 sata_free_local_buffer(spx);
10366 sata_pkt_free(spx);
10367 kmem_free(spx, sizeof (sata_pkt_txlate_t));
10368 }
10369
10370 #endif /* SATA_DEBUG */
10371 #endif /* 1 */
10372
10373
10374 /* ************************** LOCAL HELPER FUNCTIONS *********************** */
10375
10376 /*
10377 * Validate sata_tran info
10378 * SATA_FAILURE returns if structure is inconsistent or structure revision
10379 * does not match one used by the framework.
10380 *
10381 * Returns SATA_SUCCESS if sata_hba_tran has matching revision and contains
10382 * required function pointers.
10383 * Returns SATA_FAILURE otherwise.
10384 */
10385 static int
sata_validate_sata_hba_tran(dev_info_t * dip,sata_hba_tran_t * sata_tran)10386 sata_validate_sata_hba_tran(dev_info_t *dip, sata_hba_tran_t *sata_tran)
10387 {
10388 /*
10389 * SATA_TRAN_HBA_REV is the current (highest) revision number
10390 * of the SATA interface.
10391 */
10392 if (sata_tran->sata_tran_hba_rev > SATA_TRAN_HBA_REV) {
10393 sata_log(NULL, CE_WARN,
10394 "sata: invalid sata_hba_tran version %d for driver %s",
10395 sata_tran->sata_tran_hba_rev, ddi_driver_name(dip));
10396 return (SATA_FAILURE);
10397 }
10398
10399 if (dip != sata_tran->sata_tran_hba_dip) {
10400 SATA_LOG_D((NULL, CE_WARN,
10401 "sata: inconsistent sata_tran_hba_dip "
10402 "%p / %p", sata_tran->sata_tran_hba_dip, dip));
10403 return (SATA_FAILURE);
10404 }
10405
10406 if (sata_tran->sata_tran_probe_port == NULL ||
10407 sata_tran->sata_tran_start == NULL ||
10408 sata_tran->sata_tran_abort == NULL ||
10409 sata_tran->sata_tran_reset_dport == NULL ||
10410 sata_tran->sata_tran_hotplug_ops == NULL ||
10411 sata_tran->sata_tran_hotplug_ops->sata_tran_port_activate == NULL ||
10412 sata_tran->sata_tran_hotplug_ops->sata_tran_port_deactivate ==
10413 NULL) {
10414 SATA_LOG_D((NULL, CE_WARN, "sata: sata_hba_tran missing "
10415 "required functions"));
10416 }
10417 return (SATA_SUCCESS);
10418 }
10419
10420 /*
10421 * Remove HBA instance from sata_hba_list.
10422 */
10423 static void
sata_remove_hba_instance(dev_info_t * dip)10424 sata_remove_hba_instance(dev_info_t *dip)
10425 {
10426 sata_hba_inst_t *sata_hba_inst;
10427
10428 mutex_enter(&sata_mutex);
10429 for (sata_hba_inst = sata_hba_list;
10430 sata_hba_inst != (struct sata_hba_inst *)NULL;
10431 sata_hba_inst = sata_hba_inst->satahba_next) {
10432 if (sata_hba_inst->satahba_dip == dip)
10433 break;
10434 }
10435
10436 if (sata_hba_inst == (struct sata_hba_inst *)NULL) {
10437 #ifdef SATA_DEBUG
10438 cmn_err(CE_WARN, "sata_remove_hba_instance: "
10439 "unknown HBA instance\n");
10440 #endif
10441 ASSERT(FALSE);
10442 }
10443 if (sata_hba_inst == sata_hba_list) {
10444 sata_hba_list = sata_hba_inst->satahba_next;
10445 if (sata_hba_list) {
10446 sata_hba_list->satahba_prev =
10447 (struct sata_hba_inst *)NULL;
10448 }
10449 if (sata_hba_inst == sata_hba_list_tail) {
10450 sata_hba_list_tail = NULL;
10451 }
10452 } else if (sata_hba_inst == sata_hba_list_tail) {
10453 sata_hba_list_tail = sata_hba_inst->satahba_prev;
10454 if (sata_hba_list_tail) {
10455 sata_hba_list_tail->satahba_next =
10456 (struct sata_hba_inst *)NULL;
10457 }
10458 } else {
10459 sata_hba_inst->satahba_prev->satahba_next =
10460 sata_hba_inst->satahba_next;
10461 sata_hba_inst->satahba_next->satahba_prev =
10462 sata_hba_inst->satahba_prev;
10463 }
10464 mutex_exit(&sata_mutex);
10465 }
10466
10467 /*
10468 * Probe all SATA ports of the specified HBA instance.
10469 * The assumption is that there are no target and attachment point minor nodes
10470 * created by the boot subsystems, so we do not need to prune device tree.
10471 *
10472 * This function is called only from sata_hba_attach(). It does not have to
10473 * be protected by controller mutex, because the hba_attached flag is not set
10474 * yet and no one would be touching this HBA instance other than this thread.
10475 * Determines if port is active and what type of the device is attached
10476 * (if any). Allocates necessary structures for each port.
10477 *
10478 * An AP (Attachement Point) node is created for each SATA device port even
10479 * when there is no device attached.
10480 */
10481
10482 static void
sata_probe_ports(sata_hba_inst_t * sata_hba_inst)10483 sata_probe_ports(sata_hba_inst_t *sata_hba_inst)
10484 {
10485 dev_info_t *dip = SATA_DIP(sata_hba_inst);
10486 int ncport;
10487 sata_cport_info_t *cportinfo;
10488 sata_drive_info_t *drive;
10489 sata_device_t sata_device;
10490 int rval;
10491 dev_t minor_number;
10492 char name[16];
10493 clock_t start_time, cur_time;
10494
10495 /*
10496 * Probe controller ports first, to find port status and
10497 * any port multiplier attached.
10498 */
10499 for (ncport = 0; ncport < SATA_NUM_CPORTS(sata_hba_inst); ncport++) {
10500 /* allocate cport structure */
10501 cportinfo = kmem_zalloc(sizeof (sata_cport_info_t), KM_SLEEP);
10502 ASSERT(cportinfo != NULL);
10503 mutex_init(&cportinfo->cport_mutex, NULL, MUTEX_DRIVER, NULL);
10504
10505 mutex_enter(&cportinfo->cport_mutex);
10506
10507 cportinfo->cport_addr.cport = ncport;
10508 cportinfo->cport_addr.pmport = 0;
10509 cportinfo->cport_addr.qual = SATA_ADDR_CPORT;
10510 cportinfo->cport_state &= ~SATA_PORT_STATE_CLEAR_MASK;
10511 cportinfo->cport_state |= SATA_STATE_PROBING;
10512 SATA_CPORT_INFO(sata_hba_inst, ncport) = cportinfo;
10513
10514 /*
10515 * Regardless if a port is usable or not, create
10516 * an attachment point
10517 */
10518 mutex_exit(&cportinfo->cport_mutex);
10519 minor_number = SATA_MAKE_AP_MINOR(ddi_get_instance(dip),
10520 ncport, 0, SATA_ADDR_CPORT);
10521 (void) sprintf(name, "%d", ncport);
10522 if (ddi_create_minor_node(dip, name, S_IFCHR,
10523 minor_number, DDI_NT_SATA_ATTACHMENT_POINT, 0) !=
10524 DDI_SUCCESS) {
10525 sata_log(sata_hba_inst, CE_WARN, "sata_hba_attach: "
10526 "cannot create SATA attachment point for port %d",
10527 ncport);
10528 }
10529
10530 /* Probe port */
10531 start_time = ddi_get_lbolt();
10532 reprobe_cport:
10533 sata_device.satadev_addr.cport = ncport;
10534 sata_device.satadev_addr.pmport = 0;
10535 sata_device.satadev_addr.qual = SATA_ADDR_CPORT;
10536 sata_device.satadev_rev = SATA_DEVICE_REV;
10537
10538 rval = (*SATA_PROBE_PORT_FUNC(sata_hba_inst))
10539 (dip, &sata_device);
10540
10541 mutex_enter(&cportinfo->cport_mutex);
10542 cportinfo->cport_scr = sata_device.satadev_scr;
10543 if (rval != SATA_SUCCESS) {
10544 /* Something went wrong? Fail the port */
10545 cportinfo->cport_state = SATA_PSTATE_FAILED;
10546 mutex_exit(&cportinfo->cport_mutex);
10547 continue;
10548 }
10549 cportinfo->cport_state &= ~SATA_STATE_PROBING;
10550 cportinfo->cport_state |= SATA_STATE_PROBED;
10551 cportinfo->cport_dev_type = sata_device.satadev_type;
10552
10553 cportinfo->cport_state |= SATA_STATE_READY;
10554 if (cportinfo->cport_dev_type == SATA_DTYPE_NONE) {
10555 mutex_exit(&cportinfo->cport_mutex);
10556 continue;
10557 }
10558 if (cportinfo->cport_dev_type != SATA_DTYPE_PMULT) {
10559 /*
10560 * There is some device attached.
10561 * Allocate device info structure
10562 */
10563 if (SATA_CPORTINFO_DRV_INFO(cportinfo) == NULL) {
10564 mutex_exit(&cportinfo->cport_mutex);
10565 SATA_CPORTINFO_DRV_INFO(cportinfo) =
10566 kmem_zalloc(sizeof (sata_drive_info_t),
10567 KM_SLEEP);
10568 mutex_enter(&cportinfo->cport_mutex);
10569 }
10570 drive = SATA_CPORTINFO_DRV_INFO(cportinfo);
10571 drive->satadrv_addr = cportinfo->cport_addr;
10572 drive->satadrv_addr.qual = SATA_ADDR_DCPORT;
10573 drive->satadrv_type = cportinfo->cport_dev_type;
10574 drive->satadrv_state = SATA_STATE_UNKNOWN;
10575
10576 mutex_exit(&cportinfo->cport_mutex);
10577 if (sata_add_device(dip, sata_hba_inst, &sata_device) !=
10578 SATA_SUCCESS) {
10579 /*
10580 * Plugged device was not correctly identified.
10581 * Retry, within a SATA_DEV_IDENTIFY_TIMEOUT
10582 */
10583 cur_time = ddi_get_lbolt();
10584 if ((cur_time - start_time) <
10585 drv_usectohz(SATA_DEV_IDENTIFY_TIMEOUT)) {
10586 /* sleep for a while */
10587 delay(drv_usectohz(
10588 SATA_DEV_RETRY_DLY));
10589 goto reprobe_cport;
10590 }
10591 }
10592 } else { /* SATA_DTYPE_PMULT */
10593 mutex_exit(&cportinfo->cport_mutex);
10594
10595 /* Allocate sata_pmult_info and sata_pmport_info */
10596 if (sata_alloc_pmult(sata_hba_inst, &sata_device) !=
10597 SATA_SUCCESS)
10598 continue;
10599
10600 /* Log the information of the port multiplier */
10601 sata_show_pmult_info(sata_hba_inst, &sata_device);
10602
10603 /* Probe its pmports */
10604 sata_probe_pmports(sata_hba_inst, ncport);
10605 }
10606 }
10607 }
10608
10609 /*
10610 * Probe all device ports behind a port multiplier.
10611 *
10612 * PMult-related structure should be allocated before by sata_alloc_pmult().
10613 *
10614 * NOTE1: Only called from sata_probe_ports()
10615 * NOTE2: No mutex should be hold.
10616 */
10617 static void
sata_probe_pmports(sata_hba_inst_t * sata_hba_inst,uint8_t ncport)10618 sata_probe_pmports(sata_hba_inst_t *sata_hba_inst, uint8_t ncport)
10619 {
10620 dev_info_t *dip = SATA_DIP(sata_hba_inst);
10621 sata_pmult_info_t *pmultinfo = NULL;
10622 sata_pmport_info_t *pmportinfo = NULL;
10623 sata_drive_info_t *drive = NULL;
10624 sata_device_t sata_device;
10625
10626 clock_t start_time, cur_time;
10627 int npmport;
10628 int rval;
10629
10630 pmultinfo = SATA_PMULT_INFO(sata_hba_inst, ncport);
10631
10632 /* Probe Port Multiplier ports */
10633 for (npmport = 0; npmport < pmultinfo->pmult_num_dev_ports; npmport++) {
10634 pmportinfo = pmultinfo->pmult_dev_port[npmport];
10635 start_time = ddi_get_lbolt();
10636 reprobe_pmport:
10637 sata_device.satadev_addr.cport = ncport;
10638 sata_device.satadev_addr.pmport = npmport;
10639 sata_device.satadev_addr.qual = SATA_ADDR_PMPORT;
10640 sata_device.satadev_rev = SATA_DEVICE_REV;
10641
10642 /* Let HBA driver probe it. */
10643 rval = (*SATA_PROBE_PORT_FUNC(sata_hba_inst))
10644 (dip, &sata_device);
10645 mutex_enter(&pmportinfo->pmport_mutex);
10646
10647 pmportinfo->pmport_scr = sata_device.satadev_scr;
10648
10649 if (rval != SATA_SUCCESS) {
10650 pmportinfo->pmport_state =
10651 SATA_PSTATE_FAILED;
10652 mutex_exit(&pmportinfo->pmport_mutex);
10653 continue;
10654 }
10655 pmportinfo->pmport_state &= ~SATA_STATE_PROBING;
10656 pmportinfo->pmport_state |= SATA_STATE_PROBED;
10657 pmportinfo->pmport_dev_type = sata_device.satadev_type;
10658
10659 pmportinfo->pmport_state |= SATA_STATE_READY;
10660 if (pmportinfo->pmport_dev_type ==
10661 SATA_DTYPE_NONE) {
10662 SATADBG2(SATA_DBG_PMULT, sata_hba_inst,
10663 "no device found at port %d:%d", ncport, npmport);
10664 mutex_exit(&pmportinfo->pmport_mutex);
10665 continue;
10666 }
10667 /* Port multipliers cannot be chained */
10668 ASSERT(pmportinfo->pmport_dev_type != SATA_DTYPE_PMULT);
10669 /*
10670 * There is something attached to Port
10671 * Multiplier device port
10672 * Allocate device info structure
10673 */
10674 if (pmportinfo->pmport_sata_drive == NULL) {
10675 mutex_exit(&pmportinfo->pmport_mutex);
10676 pmportinfo->pmport_sata_drive =
10677 kmem_zalloc(sizeof (sata_drive_info_t), KM_SLEEP);
10678 mutex_enter(&pmportinfo->pmport_mutex);
10679 }
10680 drive = pmportinfo->pmport_sata_drive;
10681 drive->satadrv_addr.cport = pmportinfo->pmport_addr.cport;
10682 drive->satadrv_addr.pmport = npmport;
10683 drive->satadrv_addr.qual = SATA_ADDR_DPMPORT;
10684 drive->satadrv_type = pmportinfo-> pmport_dev_type;
10685 drive->satadrv_state = SATA_STATE_UNKNOWN;
10686
10687 mutex_exit(&pmportinfo->pmport_mutex);
10688 rval = sata_add_device(dip, sata_hba_inst, &sata_device);
10689
10690 if (rval != SATA_SUCCESS) {
10691 /*
10692 * Plugged device was not correctly identified.
10693 * Retry, within the SATA_DEV_IDENTIFY_TIMEOUT
10694 */
10695 cur_time = ddi_get_lbolt();
10696 if ((cur_time - start_time) < drv_usectohz(
10697 SATA_DEV_IDENTIFY_TIMEOUT)) {
10698 /* sleep for a while */
10699 delay(drv_usectohz(SATA_DEV_RETRY_DLY));
10700 goto reprobe_pmport;
10701 }
10702 }
10703 }
10704 }
10705
10706 /*
10707 * Add SATA device for specified HBA instance & port (SCSI target
10708 * device nodes).
10709 * This function is called (indirectly) only from sata_hba_attach().
10710 * A target node is created when there is a supported type device attached,
10711 * but may be removed if it cannot be put online.
10712 *
10713 * This function cannot be called from an interrupt context.
10714 *
10715 * Create target nodes for disk, CD/DVD, Tape and ATAPI disk devices
10716 *
10717 * Returns SATA_SUCCESS when port/device was fully processed, SATA_FAILURE when
10718 * device identification failed - adding a device could be retried.
10719 *
10720 */
10721 static int
sata_add_device(dev_info_t * pdip,sata_hba_inst_t * sata_hba_inst,sata_device_t * sata_device)10722 sata_add_device(dev_info_t *pdip, sata_hba_inst_t *sata_hba_inst,
10723 sata_device_t *sata_device)
10724 {
10725 sata_cport_info_t *cportinfo;
10726 sata_pmult_info_t *pminfo;
10727 sata_pmport_info_t *pmportinfo;
10728 dev_info_t *cdip; /* child dip */
10729 sata_address_t *saddr = &sata_device->satadev_addr;
10730 uint8_t cport, pmport;
10731 int rval;
10732
10733 cport = saddr->cport;
10734 pmport = saddr->pmport;
10735 cportinfo = SATA_CPORT_INFO(sata_hba_inst, cport);
10736 ASSERT(cportinfo->cport_dev_type != SATA_DTYPE_NONE);
10737
10738 /*
10739 * Some device is attached to a controller port.
10740 * We rely on controllers distinquishing between no-device,
10741 * attached port multiplier and other kind of attached device.
10742 * We need to get Identify Device data and determine
10743 * positively the dev type before trying to attach
10744 * the target driver.
10745 */
10746 sata_device->satadev_rev = SATA_DEVICE_REV;
10747 switch (saddr->qual) {
10748 case SATA_ADDR_CPORT:
10749 /*
10750 * Add a non-port-multiplier device at controller port.
10751 */
10752 saddr->qual = SATA_ADDR_DCPORT;
10753
10754 rval = sata_probe_device(sata_hba_inst, sata_device);
10755 if (rval != SATA_SUCCESS ||
10756 sata_device->satadev_type == SATA_DTYPE_UNKNOWN)
10757 return (SATA_FAILURE);
10758
10759 mutex_enter(&cportinfo->cport_mutex);
10760 sata_show_drive_info(sata_hba_inst,
10761 SATA_CPORTINFO_DRV_INFO(cportinfo));
10762
10763 if ((sata_device->satadev_type & SATA_VALID_DEV_TYPE) == 0) {
10764 /*
10765 * Could not determine device type or
10766 * a device is not supported.
10767 * Degrade this device to unknown.
10768 */
10769 cportinfo->cport_dev_type = SATA_DTYPE_UNKNOWN;
10770 mutex_exit(&cportinfo->cport_mutex);
10771 return (SATA_SUCCESS);
10772 }
10773 cportinfo->cport_dev_type = sata_device->satadev_type;
10774 cportinfo->cport_tgtnode_clean = B_TRUE;
10775 mutex_exit(&cportinfo->cport_mutex);
10776
10777 /*
10778 * Initialize device to the desired state. Even if it
10779 * fails, the device will still attach but syslog
10780 * will show the warning.
10781 */
10782 if (sata_initialize_device(sata_hba_inst,
10783 SATA_CPORTINFO_DRV_INFO(cportinfo)) != SATA_SUCCESS) {
10784 /* Retry */
10785 rval = sata_initialize_device(sata_hba_inst,
10786 SATA_CPORTINFO_DRV_INFO(cportinfo));
10787
10788 if (rval == SATA_RETRY)
10789 sata_log(sata_hba_inst, CE_WARN,
10790 "SATA device at port %d - "
10791 "default device features could not be set."
10792 " Device may not operate as expected.",
10793 cport);
10794 }
10795
10796 cdip = sata_create_target_node(pdip, sata_hba_inst, saddr);
10797 if (cdip == NULL) {
10798 /*
10799 * Attaching target node failed.
10800 * We retain sata_drive_info structure...
10801 */
10802 return (SATA_SUCCESS);
10803 }
10804
10805 mutex_enter(&cportinfo->cport_mutex);
10806 (SATA_CPORTINFO_DRV_INFO(cportinfo))->
10807 satadrv_state = SATA_STATE_READY;
10808 mutex_exit(&cportinfo->cport_mutex);
10809
10810 break;
10811
10812 case SATA_ADDR_PMPORT:
10813 saddr->qual = SATA_ADDR_DPMPORT;
10814
10815 mutex_enter(&cportinfo->cport_mutex);
10816 /* It must be a Port Multiplier at the controller port */
10817 ASSERT(cportinfo->cport_dev_type == SATA_DTYPE_PMULT);
10818
10819 pminfo = SATA_CPORTINFO_PMULT_INFO(cportinfo);
10820 pmportinfo = pminfo->pmult_dev_port[saddr->pmport];
10821 mutex_exit(&cportinfo->cport_mutex);
10822
10823 rval = sata_probe_device(sata_hba_inst, sata_device);
10824 if (rval != SATA_SUCCESS ||
10825 sata_device->satadev_type == SATA_DTYPE_UNKNOWN) {
10826 return (SATA_FAILURE);
10827 }
10828
10829 mutex_enter(&pmportinfo->pmport_mutex);
10830 sata_show_drive_info(sata_hba_inst,
10831 SATA_PMPORTINFO_DRV_INFO(pmportinfo));
10832
10833 if ((sata_device->satadev_type & SATA_VALID_DEV_TYPE) == 0) {
10834 /*
10835 * Could not determine device type.
10836 * Degrade this device to unknown.
10837 */
10838 pmportinfo->pmport_dev_type = SATA_DTYPE_UNKNOWN;
10839 mutex_exit(&pmportinfo->pmport_mutex);
10840 return (SATA_SUCCESS);
10841 }
10842 pmportinfo->pmport_dev_type = sata_device->satadev_type;
10843 pmportinfo->pmport_tgtnode_clean = B_TRUE;
10844 mutex_exit(&pmportinfo->pmport_mutex);
10845
10846 /*
10847 * Initialize device to the desired state.
10848 * Even if it fails, the device will still
10849 * attach but syslog will show the warning.
10850 */
10851 if (sata_initialize_device(sata_hba_inst,
10852 pmportinfo->pmport_sata_drive) != SATA_SUCCESS) {
10853 /* Retry */
10854 rval = sata_initialize_device(sata_hba_inst,
10855 pmportinfo->pmport_sata_drive);
10856
10857 if (rval == SATA_RETRY)
10858 sata_log(sata_hba_inst, CE_WARN,
10859 "SATA device at port %d:%d - "
10860 "default device features could not be set."
10861 " Device may not operate as expected.",
10862 cport, pmport);
10863 }
10864
10865 cdip = sata_create_target_node(pdip, sata_hba_inst, saddr);
10866 if (cdip == NULL) {
10867 /*
10868 * Attaching target node failed.
10869 * We retain sata_drive_info structure...
10870 */
10871 return (SATA_SUCCESS);
10872 }
10873 mutex_enter(&pmportinfo->pmport_mutex);
10874 pmportinfo->pmport_sata_drive->satadrv_state |=
10875 SATA_STATE_READY;
10876 mutex_exit(&pmportinfo->pmport_mutex);
10877
10878 break;
10879
10880 default:
10881 return (SATA_FAILURE);
10882 }
10883
10884 return (SATA_SUCCESS);
10885 }
10886
10887 /*
10888 * Clean up target node at specific address.
10889 *
10890 * NOTE: No Mutex should be hold.
10891 */
10892 static int
sata_offline_device(sata_hba_inst_t * sata_hba_inst,sata_device_t * sata_device,sata_drive_info_t * sdinfo)10893 sata_offline_device(sata_hba_inst_t *sata_hba_inst,
10894 sata_device_t *sata_device, sata_drive_info_t *sdinfo)
10895 {
10896 uint8_t cport, pmport, qual;
10897 dev_info_t *tdip;
10898
10899 cport = sata_device->satadev_addr.cport;
10900 pmport = sata_device->satadev_addr.pmport;
10901 qual = sata_device->satadev_addr.qual;
10902
10903 if (qual == SATA_ADDR_DCPORT) {
10904 SATA_LOG_D((sata_hba_inst, CE_WARN,
10905 "sata_hba_ioctl: disconnect device at port %d", cport));
10906 } else {
10907 SATA_LOG_D((sata_hba_inst, CE_WARN,
10908 "sata_hba_ioctl: disconnect device at port %d:%d",
10909 cport, pmport));
10910 }
10911
10912 /* We are addressing attached device, not a port */
10913 sata_device->satadev_addr.qual =
10914 sdinfo->satadrv_addr.qual;
10915 tdip = sata_get_scsi_target_dip(SATA_DIP(sata_hba_inst),
10916 &sata_device->satadev_addr);
10917 if (tdip != NULL && ndi_devi_offline(tdip,
10918 NDI_DEVI_REMOVE) != NDI_SUCCESS) {
10919 /*
10920 * Problem :
10921 * The target node remained attached.
10922 * This happens when the device file was open
10923 * or a node was waiting for resources.
10924 * Cannot do anything about it.
10925 */
10926 if (qual == SATA_ADDR_DCPORT) {
10927 SATA_LOG_D((sata_hba_inst, CE_WARN,
10928 "sata_hba_ioctl: disconnect: could "
10929 "not unconfigure device before "
10930 "disconnecting the SATA port %d",
10931 cport));
10932 } else {
10933 SATA_LOG_D((sata_hba_inst, CE_WARN,
10934 "sata_hba_ioctl: disconnect: could "
10935 "not unconfigure device before "
10936 "disconnecting the SATA port %d:%d",
10937 cport, pmport));
10938 }
10939 /*
10940 * Set DEVICE REMOVED state in the target
10941 * node. It will prevent access to the device
10942 * even when a new device is attached, until
10943 * the old target node is released, removed and
10944 * recreated for a new device.
10945 */
10946 sata_set_device_removed(tdip);
10947
10948 /*
10949 * Instruct event daemon to try the target
10950 * node cleanup later.
10951 */
10952 sata_set_target_node_cleanup(
10953 sata_hba_inst, &sata_device->satadev_addr);
10954 }
10955
10956
10957 return (SATA_SUCCESS);
10958 }
10959
10960
10961 /*
10962 * Create scsi target node for attached device, create node properties and
10963 * attach the node.
10964 * The node could be removed if the device onlining fails.
10965 *
10966 * A dev_info_t pointer is returned if operation is successful, NULL is
10967 * returned otherwise.
10968 */
10969
10970 static dev_info_t *
sata_create_target_node(dev_info_t * dip,sata_hba_inst_t * sata_hba_inst,sata_address_t * sata_addr)10971 sata_create_target_node(dev_info_t *dip, sata_hba_inst_t *sata_hba_inst,
10972 sata_address_t *sata_addr)
10973 {
10974 dev_info_t *cdip = NULL;
10975 int rval;
10976 char *nname = NULL;
10977 char **compatible = NULL;
10978 int ncompatible;
10979 struct scsi_inquiry inq;
10980 sata_device_t sata_device;
10981 sata_drive_info_t *sdinfo;
10982 int target;
10983 int i;
10984
10985 sata_device.satadev_rev = SATA_DEVICE_REV;
10986 sata_device.satadev_addr = *sata_addr;
10987
10988 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, sata_addr->cport)));
10989
10990 sdinfo = sata_get_device_info(sata_hba_inst, &sata_device);
10991
10992 target = SATA_TO_SCSI_TARGET(sata_addr->cport,
10993 sata_addr->pmport, sata_addr->qual);
10994
10995 if (sdinfo == NULL) {
10996 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst,
10997 sata_addr->cport)));
10998 SATA_LOG_D((sata_hba_inst, CE_WARN,
10999 "sata_create_target_node: no sdinfo for target %x",
11000 target));
11001 return (NULL);
11002 }
11003
11004 /*
11005 * create or get scsi inquiry data, expected by
11006 * scsi_hba_nodename_compatible_get()
11007 * SATA hard disks get Identify Data translated into Inguiry Data.
11008 * ATAPI devices respond directly to Inquiry request.
11009 */
11010 if (sdinfo->satadrv_type == SATA_DTYPE_ATADISK) {
11011 sata_identdev_to_inquiry(sata_hba_inst, sdinfo,
11012 (uint8_t *)&inq);
11013 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst,
11014 sata_addr->cport)));
11015 } else { /* Assume supported ATAPI device */
11016 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst,
11017 sata_addr->cport)));
11018 if (sata_get_atapi_inquiry_data(sata_hba_inst, sata_addr,
11019 &inq) == SATA_FAILURE)
11020 return (NULL);
11021 /*
11022 * Save supported ATAPI transport version
11023 */
11024 sdinfo->satadrv_atapi_trans_ver =
11025 SATA_ATAPI_TRANS_VERSION(&inq);
11026 }
11027
11028 /* determine the node name and compatible */
11029 scsi_hba_nodename_compatible_get(&inq, NULL,
11030 inq.inq_dtype, NULL, &nname, &compatible, &ncompatible);
11031
11032 #ifdef SATA_DEBUG
11033 if (sata_debug_flags & SATA_DBG_NODES) {
11034 if (nname == NULL) {
11035 cmn_err(CE_NOTE, "sata_create_target_node: "
11036 "cannot determine nodename for target %d\n",
11037 target);
11038 } else {
11039 cmn_err(CE_WARN, "sata_create_target_node: "
11040 "target %d nodename: %s\n", target, nname);
11041 }
11042 if (compatible == NULL) {
11043 cmn_err(CE_WARN,
11044 "sata_create_target_node: no compatible name\n");
11045 } else {
11046 for (i = 0; i < ncompatible; i++) {
11047 cmn_err(CE_WARN, "sata_create_target_node: "
11048 "compatible name: %s\n", compatible[i]);
11049 }
11050 }
11051 }
11052 #endif
11053
11054 /* if nodename can't be determined, log error and exit */
11055 if (nname == NULL) {
11056 SATA_LOG_D((sata_hba_inst, CE_WARN,
11057 "sata_create_target_node: cannot determine nodename "
11058 "for target %d\n", target));
11059 scsi_hba_nodename_compatible_free(nname, compatible);
11060 return (NULL);
11061 }
11062 /*
11063 * Create scsi target node
11064 */
11065 ndi_devi_alloc_sleep(dip, nname, (pnode_t)DEVI_SID_NODEID, &cdip);
11066 rval = ndi_prop_update_string(DDI_DEV_T_NONE, cdip,
11067 "device-type", "scsi");
11068
11069 if (rval != DDI_PROP_SUCCESS) {
11070 SATA_LOG_D((sata_hba_inst, CE_WARN, "sata_create_target_node: "
11071 "updating device_type prop failed %d", rval));
11072 goto fail;
11073 }
11074
11075 /*
11076 * Create target node properties: target & lun
11077 */
11078 rval = ndi_prop_update_int(DDI_DEV_T_NONE, cdip, "target", target);
11079 if (rval != DDI_PROP_SUCCESS) {
11080 SATA_LOG_D((sata_hba_inst, CE_WARN, "sata_create_target_node: "
11081 "updating target prop failed %d", rval));
11082 goto fail;
11083 }
11084 rval = ndi_prop_update_int(DDI_DEV_T_NONE, cdip, "lun", 0);
11085 if (rval != DDI_PROP_SUCCESS) {
11086 SATA_LOG_D((sata_hba_inst, CE_WARN, "sata_create_target_node: "
11087 "updating target prop failed %d", rval));
11088 goto fail;
11089 }
11090
11091 if (sdinfo->satadrv_type & SATA_DTYPE_ATAPI) {
11092 /*
11093 * Add "variant" property
11094 */
11095 rval = ndi_prop_update_string(DDI_DEV_T_NONE, cdip,
11096 "variant", "atapi");
11097 if (rval != DDI_PROP_SUCCESS) {
11098 SATA_LOG_D((sata_hba_inst, CE_WARN,
11099 "sata_create_target_node: variant atapi "
11100 "property could not be created: %d", rval));
11101 goto fail;
11102 }
11103 }
11104 /* decorate the node with compatible */
11105 if (ndi_prop_update_string_array(DDI_DEV_T_NONE, cdip, "compatible",
11106 compatible, ncompatible) != DDI_PROP_SUCCESS) {
11107 SATA_LOG_D((sata_hba_inst, CE_WARN,
11108 "sata_create_target_node: FAIL compatible props cdip 0x%p",
11109 (void *)cdip));
11110 goto fail;
11111 }
11112
11113 if (sdinfo->satadrv_type == SATA_DTYPE_ATADISK) {
11114 /*
11115 * Add "sata-phy" property
11116 */
11117 if (ndi_prop_update_int(DDI_DEV_T_NONE, cdip, "sata-phy",
11118 (int)sata_addr->cport) != DDI_PROP_SUCCESS) {
11119 SATA_LOG_D((sata_hba_inst, CE_WARN,
11120 "sata_create_target_node: failed to create "
11121 "\"sata-phy\" property: port %d",
11122 sata_addr->cport));
11123 }
11124 }
11125
11126
11127 /*
11128 * Now, try to attach the driver. If probing of the device fails,
11129 * the target node may be removed
11130 */
11131 rval = ndi_devi_online(cdip, NDI_ONLINE_ATTACH);
11132
11133 scsi_hba_nodename_compatible_free(nname, compatible);
11134
11135 if (rval == NDI_SUCCESS)
11136 return (cdip);
11137
11138 /* target node was removed - are we sure? */
11139 return (NULL);
11140
11141 fail:
11142 scsi_hba_nodename_compatible_free(nname, compatible);
11143 ddi_prop_remove_all(cdip);
11144 rval = ndi_devi_free(cdip);
11145 if (rval != NDI_SUCCESS) {
11146 SATA_LOG_D((sata_hba_inst, CE_WARN, "sata_create_target_node: "
11147 "node removal failed %d", rval));
11148 }
11149 sata_log(sata_hba_inst, CE_WARN, "sata_create_target_node: "
11150 "cannot create target node for SATA device at port %d",
11151 sata_addr->cport);
11152 return (NULL);
11153 }
11154
11155 /*
11156 * Remove a target node.
11157 */
11158 static void
sata_remove_target_node(sata_hba_inst_t * sata_hba_inst,sata_address_t * sata_addr)11159 sata_remove_target_node(sata_hba_inst_t *sata_hba_inst,
11160 sata_address_t *sata_addr)
11161 {
11162 dev_info_t *tdip;
11163 uint8_t cport = sata_addr->cport;
11164 uint8_t pmport = sata_addr->pmport;
11165 uint8_t qual = sata_addr->qual;
11166
11167 /* Note the sata daemon uses the address of the port/pmport */
11168 ASSERT(qual == SATA_ADDR_CPORT || qual == SATA_ADDR_PMPORT);
11169
11170 /* Remove target node */
11171 tdip = sata_get_target_dip(SATA_DIP(sata_hba_inst), cport, pmport);
11172 if (tdip != NULL) {
11173 /*
11174 * Target node exists. Unconfigure device
11175 * then remove the target node (one ndi
11176 * operation).
11177 */
11178 if (ndi_devi_offline(tdip, NDI_DEVI_REMOVE) != NDI_SUCCESS) {
11179 /*
11180 * PROBLEM - no device, but target node remained. This
11181 * happens when the file was open or node was waiting
11182 * for resources.
11183 */
11184 SATA_LOG_D((sata_hba_inst, CE_WARN,
11185 "sata_remove_target_node: "
11186 "Failed to remove target node for "
11187 "detached SATA device."));
11188 /*
11189 * Set target node state to DEVI_DEVICE_REMOVED. But
11190 * re-check first that the node still exists.
11191 */
11192 tdip = sata_get_target_dip(SATA_DIP(sata_hba_inst),
11193 cport, pmport);
11194 if (tdip != NULL) {
11195 sata_set_device_removed(tdip);
11196 /*
11197 * Instruct event daemon to retry the cleanup
11198 * later.
11199 */
11200 sata_set_target_node_cleanup(sata_hba_inst,
11201 sata_addr);
11202 }
11203 }
11204
11205 if (qual == SATA_ADDR_CPORT)
11206 sata_log(sata_hba_inst, CE_WARN,
11207 "SATA device detached at port %d", cport);
11208 else
11209 sata_log(sata_hba_inst, CE_WARN,
11210 "SATA device detached at port %d:%d",
11211 cport, pmport);
11212 }
11213 #ifdef SATA_DEBUG
11214 else {
11215 if (qual == SATA_ADDR_CPORT)
11216 sata_log(sata_hba_inst, CE_WARN,
11217 "target node not found at port %d", cport);
11218 else
11219 sata_log(sata_hba_inst, CE_WARN,
11220 "target node not found at port %d:%d",
11221 cport, pmport);
11222 }
11223 #endif
11224 }
11225
11226
11227 /*
11228 * Re-probe sata port, check for a device and attach info
11229 * structures when necessary. Identify Device data is fetched, if possible.
11230 * Assumption: sata address is already validated.
11231 * SATA_SUCCESS is returned if port is re-probed sucessfully, regardless of
11232 * the presence of a device and its type.
11233 *
11234 * flag arg specifies that the function should try multiple times to identify
11235 * device type and to initialize it, or it should return immediately on failure.
11236 * SATA_DEV_IDENTIFY_RETRY - retry
11237 * SATA_DEV_IDENTIFY_NORETRY - no retry
11238 *
11239 * SATA_FAILURE is returned if one of the operations failed.
11240 *
11241 * This function cannot be called in interrupt context - it may sleep.
11242 *
11243 * Note: Port multiplier is supported.
11244 */
11245 static int
sata_reprobe_port(sata_hba_inst_t * sata_hba_inst,sata_device_t * sata_device,int flag)11246 sata_reprobe_port(sata_hba_inst_t *sata_hba_inst, sata_device_t *sata_device,
11247 int flag)
11248 {
11249 sata_cport_info_t *cportinfo;
11250 sata_pmult_info_t *pmultinfo;
11251 sata_drive_info_t *sdinfo, *osdinfo;
11252 boolean_t init_device = B_FALSE;
11253 int prev_device_type = SATA_DTYPE_NONE;
11254 int prev_device_settings = 0;
11255 int prev_device_state = 0;
11256 clock_t start_time = 0;
11257 int retry = B_FALSE;
11258 uint8_t cport = sata_device->satadev_addr.cport;
11259 int rval_probe, rval_init;
11260
11261 /*
11262 * If target is pmport, sata_reprobe_pmport() will handle it.
11263 */
11264 if (sata_device->satadev_addr.qual == SATA_ADDR_PMPORT ||
11265 sata_device->satadev_addr.qual == SATA_ADDR_DPMPORT)
11266 return (sata_reprobe_pmport(sata_hba_inst, sata_device, flag));
11267
11268 /* We only care about host sata cport for now */
11269 cportinfo = SATA_CPORT_INFO(sata_hba_inst,
11270 sata_device->satadev_addr.cport);
11271
11272 /*
11273 * If a port multiplier was previously attached (we have no idea it
11274 * still there or not), sata_reprobe_pmult() will handle it.
11275 */
11276 if (cportinfo->cport_dev_type == SATA_DTYPE_PMULT)
11277 return (sata_reprobe_pmult(sata_hba_inst, sata_device, flag));
11278
11279 /* Store sata_drive_info when a non-pmult device was attached. */
11280 osdinfo = SATA_CPORTINFO_DRV_INFO(cportinfo);
11281 if (osdinfo != NULL) {
11282 /*
11283 * We are re-probing port with a previously attached device.
11284 * Save previous device type and settings.
11285 */
11286 prev_device_type = cportinfo->cport_dev_type;
11287 prev_device_settings = osdinfo->satadrv_settings;
11288 prev_device_state = osdinfo->satadrv_state;
11289 }
11290 if (flag == SATA_DEV_IDENTIFY_RETRY) {
11291 start_time = ddi_get_lbolt();
11292 retry = B_TRUE;
11293 }
11294 retry_probe:
11295
11296 /* probe port */
11297 mutex_enter(&cportinfo->cport_mutex);
11298 cportinfo->cport_state &= ~SATA_PORT_STATE_CLEAR_MASK;
11299 cportinfo->cport_state |= SATA_STATE_PROBING;
11300 mutex_exit(&cportinfo->cport_mutex);
11301
11302 rval_probe = (*SATA_PROBE_PORT_FUNC(sata_hba_inst))
11303 (SATA_DIP(sata_hba_inst), sata_device);
11304
11305 mutex_enter(&cportinfo->cport_mutex);
11306 if (rval_probe != SATA_SUCCESS) {
11307 cportinfo->cport_state = SATA_PSTATE_FAILED;
11308 mutex_exit(&cportinfo->cport_mutex);
11309 SATA_LOG_D((sata_hba_inst, CE_WARN, "sata_reprobe_port: "
11310 "SATA port %d probing failed",
11311 cportinfo->cport_addr.cport));
11312 return (SATA_FAILURE);
11313 }
11314
11315 /*
11316 * update sata port state and set device type
11317 */
11318 sata_update_port_info(sata_hba_inst, sata_device);
11319 cportinfo->cport_state &= ~SATA_STATE_PROBING;
11320
11321 /*
11322 * Sanity check - Port is active? Is the link active?
11323 * Is there any device attached?
11324 */
11325 if ((cportinfo->cport_state &
11326 (SATA_PSTATE_SHUTDOWN | SATA_PSTATE_FAILED)) ||
11327 (cportinfo->cport_scr.sstatus & SATA_PORT_DEVLINK_UP_MASK) !=
11328 SATA_PORT_DEVLINK_UP) {
11329 /*
11330 * Port in non-usable state or no link active/no device.
11331 * Free info structure if necessary (direct attached drive
11332 * only, for now!
11333 */
11334 sdinfo = SATA_CPORTINFO_DRV_INFO(cportinfo);
11335 SATA_CPORTINFO_DRV_INFO(cportinfo) = NULL;
11336 /* Add here differentiation for device attached or not */
11337 cportinfo->cport_dev_type = SATA_DTYPE_NONE;
11338 mutex_exit(&cportinfo->cport_mutex);
11339 if (sdinfo != NULL)
11340 kmem_free(sdinfo, sizeof (sata_drive_info_t));
11341 return (SATA_SUCCESS);
11342 }
11343
11344 cportinfo->cport_state |= SATA_STATE_READY;
11345 cportinfo->cport_state |= SATA_STATE_PROBED;
11346
11347 cportinfo->cport_dev_type = sata_device->satadev_type;
11348 sdinfo = SATA_CPORTINFO_DRV_INFO(cportinfo);
11349
11350 /*
11351 * If we are re-probing the port, there may be
11352 * sata_drive_info structure attached
11353 */
11354 if (sata_device->satadev_type == SATA_DTYPE_NONE) {
11355
11356 /*
11357 * There is no device, so remove device info structure,
11358 * if necessary.
11359 */
11360 /* Device change: Drive -> None */
11361 SATA_CPORTINFO_DRV_INFO(cportinfo) = NULL;
11362 cportinfo->cport_dev_type = SATA_DTYPE_NONE;
11363 if (sdinfo != NULL) {
11364 kmem_free(sdinfo, sizeof (sata_drive_info_t));
11365 sata_log(sata_hba_inst, CE_WARN,
11366 "SATA device detached "
11367 "from port %d", cportinfo->cport_addr.cport);
11368 }
11369 mutex_exit(&cportinfo->cport_mutex);
11370 return (SATA_SUCCESS);
11371
11372 }
11373
11374 if (sata_device->satadev_type != SATA_DTYPE_PMULT) {
11375
11376 /* Device (may) change: Drive -> Drive */
11377 if (sdinfo == NULL) {
11378 /*
11379 * There is some device attached, but there is
11380 * no sata_drive_info structure - allocate one
11381 */
11382 mutex_exit(&cportinfo->cport_mutex);
11383 sdinfo = kmem_zalloc(
11384 sizeof (sata_drive_info_t), KM_SLEEP);
11385 mutex_enter(&cportinfo->cport_mutex);
11386 /*
11387 * Recheck, that the port state did not change when we
11388 * released mutex.
11389 */
11390 if (cportinfo->cport_state & SATA_STATE_READY) {
11391 SATA_CPORTINFO_DRV_INFO(cportinfo) = sdinfo;
11392 sdinfo->satadrv_addr = cportinfo->cport_addr;
11393 sdinfo->satadrv_addr.qual = SATA_ADDR_DCPORT;
11394 sdinfo->satadrv_type = SATA_DTYPE_UNKNOWN;
11395 sdinfo->satadrv_state = SATA_STATE_UNKNOWN;
11396 } else {
11397 /*
11398 * Port is not in ready state, we
11399 * cannot attach a device.
11400 */
11401 mutex_exit(&cportinfo->cport_mutex);
11402 kmem_free(sdinfo, sizeof (sata_drive_info_t));
11403 return (SATA_SUCCESS);
11404 }
11405 /*
11406 * Since we are adding device, presumably new one,
11407 * indicate that it should be initalized,
11408 * as well as some internal framework states).
11409 */
11410 init_device = B_TRUE;
11411 }
11412 cportinfo->cport_dev_type = SATA_DTYPE_UNKNOWN;
11413 sata_device->satadev_addr.qual = sdinfo->satadrv_addr.qual;
11414 } else {
11415 /* Device change: Drive -> PMult */
11416 SATA_CPORTINFO_DRV_INFO(cportinfo) = NULL;
11417 if (sdinfo != NULL) {
11418 kmem_free(sdinfo, sizeof (sata_drive_info_t));
11419 sata_log(sata_hba_inst, CE_WARN,
11420 "SATA device detached "
11421 "from port %d", cportinfo->cport_addr.cport);
11422 }
11423
11424 sata_log(sata_hba_inst, CE_WARN,
11425 "SATA port multiplier detected at port %d",
11426 cportinfo->cport_addr.cport);
11427
11428 mutex_exit(&cportinfo->cport_mutex);
11429 if (sata_alloc_pmult(sata_hba_inst, sata_device) !=
11430 SATA_SUCCESS)
11431 return (SATA_FAILURE);
11432 sata_show_pmult_info(sata_hba_inst, sata_device);
11433 mutex_enter(&cportinfo->cport_mutex);
11434
11435 /*
11436 * Mark all the port multiplier port behind the port
11437 * multiplier behind with link events, so that the sata daemon
11438 * will update their status.
11439 */
11440 pmultinfo = SATA_PMULT_INFO(sata_hba_inst, cport);
11441 pmultinfo->pmult_event_flags |= SATA_EVNT_DEVICE_RESET;
11442 mutex_exit(&cportinfo->cport_mutex);
11443 return (SATA_SUCCESS);
11444 }
11445 mutex_exit(&cportinfo->cport_mutex);
11446
11447 /*
11448 * Figure out what kind of device we are really
11449 * dealing with. Failure of identifying device does not fail this
11450 * function.
11451 */
11452 rval_probe = sata_probe_device(sata_hba_inst, sata_device);
11453 rval_init = SATA_FAILURE;
11454 mutex_enter(&cportinfo->cport_mutex);
11455 if (rval_probe == SATA_SUCCESS) {
11456 /*
11457 * If we are dealing with the same type of a device as before,
11458 * restore its settings flags.
11459 */
11460 if (osdinfo != NULL &&
11461 sata_device->satadev_type == prev_device_type)
11462 sdinfo->satadrv_settings = prev_device_settings;
11463
11464 mutex_exit(&cportinfo->cport_mutex);
11465 rval_init = SATA_SUCCESS;
11466 /* Set initial device features, if necessary */
11467 if (init_device == B_TRUE) {
11468 rval_init = sata_initialize_device(sata_hba_inst,
11469 sdinfo);
11470 }
11471 if (rval_init == SATA_SUCCESS)
11472 return (rval_init);
11473 /* else we will retry if retry was asked for */
11474
11475 } else {
11476 /*
11477 * If there was some device info before we probe the device,
11478 * restore previous device setting, so we can retry from scratch
11479 * later. Providing, of course, that device has not disapear
11480 * during probing process.
11481 */
11482 if (sata_device->satadev_type != SATA_DTYPE_NONE) {
11483 if (osdinfo != NULL) {
11484 cportinfo->cport_dev_type = prev_device_type;
11485 sdinfo->satadrv_type = prev_device_type;
11486 sdinfo->satadrv_state = prev_device_state;
11487 }
11488 } else {
11489 /* device is gone */
11490 kmem_free(sdinfo, sizeof (sata_drive_info_t));
11491 cportinfo->cport_dev_type = SATA_DTYPE_NONE;
11492 SATA_CPORTINFO_DRV_INFO(cportinfo) = NULL;
11493 mutex_exit(&cportinfo->cport_mutex);
11494 return (SATA_SUCCESS);
11495 }
11496 mutex_exit(&cportinfo->cport_mutex);
11497 }
11498
11499 if (retry) {
11500 clock_t cur_time = ddi_get_lbolt();
11501 /*
11502 * A device was not successfully identified or initialized.
11503 * Track retry time for device identification.
11504 */
11505 if ((cur_time - start_time) <
11506 drv_usectohz(SATA_DEV_REPROBE_TIMEOUT)) {
11507 /* sleep for a while */
11508 delay(drv_usectohz(SATA_DEV_RETRY_DLY));
11509 goto retry_probe;
11510 }
11511 /* else no more retries */
11512 mutex_enter(&cportinfo->cport_mutex);
11513 if (SATA_CPORTINFO_DRV_INFO(cportinfo) != NULL) {
11514 if (rval_init == SATA_RETRY) {
11515 /*
11516 * Setting drive features have failed, but
11517 * because the drive is still accessible,
11518 * keep it and emit a warning message.
11519 */
11520 sata_log(sata_hba_inst, CE_WARN,
11521 "SATA device at port %d - desired "
11522 "drive features could not be set. "
11523 "Device may not operate as expected.",
11524 cportinfo->cport_addr.cport);
11525 } else {
11526 SATA_CPORTINFO_DRV_INFO(cportinfo)->
11527 satadrv_state = SATA_DSTATE_FAILED;
11528 }
11529 }
11530 mutex_exit(&cportinfo->cport_mutex);
11531 }
11532 return (SATA_SUCCESS);
11533 }
11534
11535 /*
11536 * Reprobe a controller port that connected to a port multiplier.
11537 *
11538 * NOTE: No Mutex should be hold.
11539 */
11540 static int
sata_reprobe_pmult(sata_hba_inst_t * sata_hba_inst,sata_device_t * sata_device,int flag)11541 sata_reprobe_pmult(sata_hba_inst_t *sata_hba_inst, sata_device_t *sata_device,
11542 int flag)
11543 {
11544 _NOTE(ARGUNUSED(flag))
11545 sata_cport_info_t *cportinfo;
11546 sata_pmult_info_t *pmultinfo;
11547 uint8_t cport = sata_device->satadev_addr.cport;
11548 int rval_probe;
11549
11550 cportinfo = SATA_CPORT_INFO(sata_hba_inst, cport);
11551 pmultinfo = SATA_PMULT_INFO(sata_hba_inst, cport);
11552
11553 /* probe port */
11554 mutex_enter(&cportinfo->cport_mutex);
11555 cportinfo->cport_state &= ~SATA_PORT_STATE_CLEAR_MASK;
11556 cportinfo->cport_state |= SATA_STATE_PROBING;
11557 mutex_exit(&cportinfo->cport_mutex);
11558
11559 rval_probe = (*SATA_PROBE_PORT_FUNC(sata_hba_inst))
11560 (SATA_DIP(sata_hba_inst), sata_device);
11561
11562 mutex_enter(&cportinfo->cport_mutex);
11563 if (rval_probe != SATA_SUCCESS) {
11564 cportinfo->cport_state = SATA_PSTATE_FAILED;
11565 SATA_LOG_D((sata_hba_inst, CE_WARN, "sata_reprobe_pmult: "
11566 "SATA port %d probing failed", cport));
11567 sata_log(sata_hba_inst, CE_WARN,
11568 "SATA port multiplier detached at port %d", cport);
11569 mutex_exit(&cportinfo->cport_mutex);
11570 sata_free_pmult(sata_hba_inst, sata_device);
11571 return (SATA_FAILURE);
11572 }
11573
11574 /*
11575 * update sata port state and set device type
11576 */
11577 sata_update_port_info(sata_hba_inst, sata_device);
11578 cportinfo->cport_state &= ~SATA_STATE_PROBING;
11579 cportinfo->cport_state |= SATA_STATE_PROBED;
11580
11581 /*
11582 * Sanity check - Port is active? Is the link active?
11583 * Is there any device attached?
11584 */
11585 if ((cportinfo->cport_state &
11586 (SATA_PSTATE_SHUTDOWN | SATA_PSTATE_FAILED)) ||
11587 (cportinfo->cport_scr.sstatus & SATA_PORT_DEVLINK_UP_MASK) !=
11588 SATA_PORT_DEVLINK_UP ||
11589 (sata_device->satadev_type == SATA_DTYPE_NONE)) {
11590 cportinfo->cport_dev_type = SATA_DTYPE_NONE;
11591 mutex_exit(&cportinfo->cport_mutex);
11592 sata_free_pmult(sata_hba_inst, sata_device);
11593 sata_log(sata_hba_inst, CE_WARN,
11594 "SATA port multiplier detached at port %d", cport);
11595 return (SATA_SUCCESS);
11596 }
11597
11598 /*
11599 * Device changed: PMult -> Non-PMult
11600 *
11601 * This situation is uncommon, most possibly being caused by errors
11602 * after which the port multiplier is not correct initialized and
11603 * recognized. In that case the new device will be marked as unknown
11604 * and will not be automatically probed in this routine. Instead
11605 * system administrator could manually restart it via cfgadm(8).
11606 */
11607 if (sata_device->satadev_type != SATA_DTYPE_PMULT) {
11608 cportinfo->cport_dev_type = SATA_DTYPE_UNKNOWN;
11609 mutex_exit(&cportinfo->cport_mutex);
11610 sata_free_pmult(sata_hba_inst, sata_device);
11611 sata_log(sata_hba_inst, CE_WARN,
11612 "SATA port multiplier detached at port %d", cport);
11613 return (SATA_FAILURE);
11614 }
11615
11616 /*
11617 * Now we know it is a port multiplier. However, if this is not the
11618 * previously attached port multiplier - they may have different
11619 * pmport numbers - we need to re-allocate data structures for every
11620 * pmport and drive.
11621 *
11622 * Port multipliers of the same model have identical values in these
11623 * registers, so it is still necessary to update the information of
11624 * all drives attached to the previous port multiplier afterwards.
11625 */
11626 /* Device changed: PMult -> another PMult */
11627 mutex_exit(&cportinfo->cport_mutex);
11628 sata_free_pmult(sata_hba_inst, sata_device);
11629 if (sata_alloc_pmult(sata_hba_inst, sata_device) != SATA_SUCCESS)
11630 return (SATA_FAILURE);
11631 mutex_enter(&cportinfo->cport_mutex);
11632
11633 SATADBG1(SATA_DBG_PMULT, sata_hba_inst,
11634 "SATA port multiplier [changed] at port %d", cport);
11635 sata_log(sata_hba_inst, CE_WARN,
11636 "SATA port multiplier detected at port %d", cport);
11637
11638 /*
11639 * Mark all the port multiplier port behind the port
11640 * multiplier behind with link events, so that the sata daemon
11641 * will update their status.
11642 */
11643 pmultinfo->pmult_event_flags |= SATA_EVNT_DEVICE_RESET;
11644 mutex_exit(&cportinfo->cport_mutex);
11645
11646 return (SATA_SUCCESS);
11647 }
11648
11649 /*
11650 * Re-probe a port multiplier port, check for a device and attach info
11651 * structures when necessary. Identify Device data is fetched, if possible.
11652 * Assumption: sata address is already validated as port multiplier port.
11653 * SATA_SUCCESS is returned if port is re-probed sucessfully, regardless of
11654 * the presence of a device and its type.
11655 *
11656 * flag arg specifies that the function should try multiple times to identify
11657 * device type and to initialize it, or it should return immediately on failure.
11658 * SATA_DEV_IDENTIFY_RETRY - retry
11659 * SATA_DEV_IDENTIFY_NORETRY - no retry
11660 *
11661 * SATA_FAILURE is returned if one of the operations failed.
11662 *
11663 * This function cannot be called in interrupt context - it may sleep.
11664 *
11665 * NOTE: Should be only called by sata_probe_port() in case target port is a
11666 * port multiplier port.
11667 * NOTE: No Mutex should be hold.
11668 */
11669 static int
sata_reprobe_pmport(sata_hba_inst_t * sata_hba_inst,sata_device_t * sata_device,int flag)11670 sata_reprobe_pmport(sata_hba_inst_t *sata_hba_inst, sata_device_t *sata_device,
11671 int flag)
11672 {
11673 sata_cport_info_t *cportinfo = NULL;
11674 sata_pmport_info_t *pmportinfo = NULL;
11675 sata_drive_info_t *sdinfo, *osdinfo;
11676 sata_device_t sdevice;
11677 boolean_t init_device = B_FALSE;
11678 int prev_device_type = SATA_DTYPE_NONE;
11679 int prev_device_settings = 0;
11680 int prev_device_state = 0;
11681 clock_t start_time;
11682 uint8_t cport = sata_device->satadev_addr.cport;
11683 uint8_t pmport = sata_device->satadev_addr.pmport;
11684 int rval;
11685
11686 cportinfo = SATA_CPORT_INFO(sata_hba_inst, cport);
11687 pmportinfo = SATA_PMPORT_INFO(sata_hba_inst, cport, pmport);
11688 osdinfo = SATA_PMPORTINFO_DRV_INFO(pmportinfo);
11689
11690 if (osdinfo != NULL) {
11691 /*
11692 * We are re-probing port with a previously attached device.
11693 * Save previous device type and settings.
11694 */
11695 prev_device_type = pmportinfo->pmport_dev_type;
11696 prev_device_settings = osdinfo->satadrv_settings;
11697 prev_device_state = osdinfo->satadrv_state;
11698 }
11699
11700 start_time = ddi_get_lbolt();
11701
11702 /* check parent status */
11703 mutex_enter(&cportinfo->cport_mutex);
11704 if ((cportinfo->cport_state &
11705 (SATA_PSTATE_SHUTDOWN | SATA_PSTATE_FAILED)) ||
11706 (cportinfo->cport_scr.sstatus & SATA_PORT_DEVLINK_UP_MASK) !=
11707 SATA_PORT_DEVLINK_UP) {
11708 mutex_exit(&cportinfo->cport_mutex);
11709 return (SATA_FAILURE);
11710 }
11711 mutex_exit(&cportinfo->cport_mutex);
11712
11713 retry_probe_pmport:
11714
11715 /* probe port */
11716 mutex_enter(&pmportinfo->pmport_mutex);
11717 pmportinfo->pmport_state &= ~SATA_PORT_STATE_CLEAR_MASK;
11718 pmportinfo->pmport_state |= SATA_STATE_PROBING;
11719 mutex_exit(&pmportinfo->pmport_mutex);
11720
11721 rval = (*SATA_PROBE_PORT_FUNC(sata_hba_inst))
11722 (SATA_DIP(sata_hba_inst), sata_device);
11723
11724 /* might need retry because we cannot touch registers. */
11725 if (rval == SATA_FAILURE) {
11726 mutex_enter(&pmportinfo->pmport_mutex);
11727 pmportinfo->pmport_state = SATA_PSTATE_FAILED;
11728 mutex_exit(&pmportinfo->pmport_mutex);
11729 SATA_LOG_D((sata_hba_inst, CE_WARN, "sata_reprobe_pmport: "
11730 "SATA port %d:%d probing failed",
11731 cport, pmport));
11732 return (SATA_FAILURE);
11733 } else if (rval == SATA_RETRY) {
11734 SATA_LOG_D((sata_hba_inst, CE_WARN, "sata_reprobe_pmport: "
11735 "SATA port %d:%d probing failed, retrying...",
11736 cport, pmport));
11737 clock_t cur_time = ddi_get_lbolt();
11738 /*
11739 * A device was not successfully identified or initialized.
11740 * Track retry time for device identification.
11741 */
11742 if ((cur_time - start_time) <
11743 drv_usectohz(SATA_DEV_REPROBE_TIMEOUT)) {
11744 /* sleep for a while */
11745 delay(drv_usectohz(SATA_DEV_RETRY_DLY));
11746 goto retry_probe_pmport;
11747 } else {
11748 mutex_enter(&pmportinfo->pmport_mutex);
11749 if (SATA_PMPORTINFO_DRV_INFO(pmportinfo) != NULL)
11750 SATA_PMPORTINFO_DRV_INFO(pmportinfo)->
11751 satadrv_state = SATA_DSTATE_FAILED;
11752 mutex_exit(&pmportinfo->pmport_mutex);
11753 return (SATA_SUCCESS);
11754 }
11755 }
11756
11757 /*
11758 * Sanity check - Controller port is active? Is the link active?
11759 * Is it still a port multiplier?
11760 */
11761 if ((cportinfo->cport_state &
11762 (SATA_PSTATE_SHUTDOWN | SATA_PSTATE_FAILED)) ||
11763 (cportinfo->cport_scr.sstatus & SATA_PORT_DEVLINK_UP_MASK) !=
11764 SATA_PORT_DEVLINK_UP ||
11765 (cportinfo->cport_dev_type != SATA_DTYPE_PMULT)) {
11766 /*
11767 * Port in non-usable state or no link active/no
11768 * device. Free info structure.
11769 */
11770 cportinfo->cport_dev_type = SATA_DTYPE_UNKNOWN;
11771
11772 sdevice.satadev_addr.cport = cport;
11773 sdevice.satadev_addr.pmport = pmport;
11774 sdevice.satadev_addr.qual = SATA_ADDR_PMULT;
11775 mutex_exit(&cportinfo->cport_mutex);
11776
11777 sata_free_pmult(sata_hba_inst, &sdevice);
11778 return (SATA_FAILURE);
11779 }
11780
11781 /* SATA_SUCCESS NOW */
11782 /*
11783 * update sata port state and set device type
11784 */
11785 mutex_enter(&pmportinfo->pmport_mutex);
11786 sata_update_pmport_info(sata_hba_inst, sata_device);
11787 pmportinfo->pmport_state &= ~SATA_STATE_PROBING;
11788
11789 /*
11790 * Sanity check - Port is active? Is the link active?
11791 * Is there any device attached?
11792 */
11793 if ((pmportinfo->pmport_state &
11794 (SATA_PSTATE_SHUTDOWN | SATA_PSTATE_FAILED)) ||
11795 (pmportinfo->pmport_scr.sstatus & SATA_PORT_DEVLINK_UP_MASK) !=
11796 SATA_PORT_DEVLINK_UP) {
11797 /*
11798 * Port in non-usable state or no link active/no device.
11799 * Free info structure if necessary (direct attached drive
11800 * only, for now!
11801 */
11802 sdinfo = SATA_PMPORTINFO_DRV_INFO(pmportinfo);
11803 SATA_PMPORTINFO_DRV_INFO(pmportinfo) = NULL;
11804 /* Add here differentiation for device attached or not */
11805 pmportinfo->pmport_dev_type = SATA_DTYPE_NONE;
11806 mutex_exit(&pmportinfo->pmport_mutex);
11807 if (sdinfo != NULL)
11808 kmem_free(sdinfo, sizeof (sata_drive_info_t));
11809 return (SATA_SUCCESS);
11810 }
11811
11812 pmportinfo->pmport_state |= SATA_STATE_READY;
11813 pmportinfo->pmport_dev_type = sata_device->satadev_type;
11814 sdinfo = SATA_PMPORTINFO_DRV_INFO(pmportinfo);
11815
11816 /*
11817 * If we are re-probing the port, there may be
11818 * sata_drive_info structure attached
11819 * (or sata_pm_info, if PMult is supported).
11820 */
11821 if (sata_device->satadev_type == SATA_DTYPE_NONE) {
11822 /*
11823 * There is no device, so remove device info structure,
11824 * if necessary.
11825 */
11826 SATA_PMPORTINFO_DRV_INFO(pmportinfo) = NULL;
11827 pmportinfo->pmport_dev_type = SATA_DTYPE_NONE;
11828 if (sdinfo != NULL) {
11829 kmem_free(sdinfo, sizeof (sata_drive_info_t));
11830 sata_log(sata_hba_inst, CE_WARN,
11831 "SATA device detached from port %d:%d",
11832 cport, pmport);
11833 }
11834 mutex_exit(&pmportinfo->pmport_mutex);
11835 return (SATA_SUCCESS);
11836 }
11837
11838 /* this should not be a pmult */
11839 ASSERT(sata_device->satadev_type != SATA_DTYPE_PMULT);
11840 if (sdinfo == NULL) {
11841 /*
11842 * There is some device attached, but there is
11843 * no sata_drive_info structure - allocate one
11844 */
11845 mutex_exit(&pmportinfo->pmport_mutex);
11846 sdinfo = kmem_zalloc(sizeof (sata_drive_info_t),
11847 KM_SLEEP);
11848 mutex_enter(&pmportinfo->pmport_mutex);
11849 /*
11850 * Recheck, that the port state did not change when we
11851 * released mutex.
11852 */
11853 if (pmportinfo->pmport_state & SATA_STATE_READY) {
11854 SATA_PMPORTINFO_DRV_INFO(pmportinfo) = sdinfo;
11855 sdinfo->satadrv_addr = pmportinfo->pmport_addr;
11856 sdinfo->satadrv_addr.qual = SATA_ADDR_DPMPORT;
11857 sdinfo->satadrv_type = SATA_DTYPE_UNKNOWN;
11858 sdinfo->satadrv_state = SATA_STATE_UNKNOWN;
11859 } else {
11860 /*
11861 * Port is not in ready state, we
11862 * cannot attach a device.
11863 */
11864 mutex_exit(&pmportinfo->pmport_mutex);
11865 kmem_free(sdinfo, sizeof (sata_drive_info_t));
11866 return (SATA_SUCCESS);
11867 }
11868 /*
11869 * Since we are adding device, presumably new one,
11870 * indicate that it should be initalized,
11871 * as well as some internal framework states).
11872 */
11873 init_device = B_TRUE;
11874 }
11875
11876 pmportinfo->pmport_dev_type = SATA_DTYPE_UNKNOWN;
11877 sata_device->satadev_addr.qual = sdinfo->satadrv_addr.qual;
11878
11879 mutex_exit(&pmportinfo->pmport_mutex);
11880 /*
11881 * Figure out what kind of device we are really
11882 * dealing with.
11883 */
11884 rval = sata_probe_device(sata_hba_inst, sata_device);
11885
11886 mutex_enter(&pmportinfo->pmport_mutex);
11887 if (rval == SATA_SUCCESS) {
11888 /*
11889 * If we are dealing with the same type of a device as before,
11890 * restore its settings flags.
11891 */
11892 if (osdinfo != NULL &&
11893 sata_device->satadev_type == prev_device_type)
11894 sdinfo->satadrv_settings = prev_device_settings;
11895
11896 mutex_exit(&pmportinfo->pmport_mutex);
11897 /* Set initial device features, if necessary */
11898 if (init_device == B_TRUE) {
11899 rval = sata_initialize_device(sata_hba_inst, sdinfo);
11900 }
11901 if (rval == SATA_SUCCESS)
11902 return (rval);
11903 } else {
11904 /*
11905 * If there was some device info before we probe the device,
11906 * restore previous device setting, so we can retry from scratch
11907 * later. Providing, of course, that device has not disappeared
11908 * during probing process.
11909 */
11910 if (sata_device->satadev_type != SATA_DTYPE_NONE) {
11911 if (osdinfo != NULL) {
11912 pmportinfo->pmport_dev_type = prev_device_type;
11913 sdinfo->satadrv_type = prev_device_type;
11914 sdinfo->satadrv_state = prev_device_state;
11915 }
11916 } else {
11917 /* device is gone */
11918 kmem_free(sdinfo, sizeof (sata_drive_info_t));
11919 pmportinfo->pmport_dev_type = SATA_DTYPE_NONE;
11920 SATA_PMPORTINFO_DRV_INFO(pmportinfo) = NULL;
11921 mutex_exit(&pmportinfo->pmport_mutex);
11922 return (SATA_SUCCESS);
11923 }
11924 mutex_exit(&pmportinfo->pmport_mutex);
11925 }
11926
11927 if (flag == SATA_DEV_IDENTIFY_RETRY) {
11928 clock_t cur_time = ddi_get_lbolt();
11929 /*
11930 * A device was not successfully identified or initialized.
11931 * Track retry time for device identification.
11932 */
11933 if ((cur_time - start_time) <
11934 drv_usectohz(SATA_DEV_REPROBE_TIMEOUT)) {
11935 /* sleep for a while */
11936 delay(drv_usectohz(SATA_DEV_RETRY_DLY));
11937 goto retry_probe_pmport;
11938 } else {
11939 mutex_enter(&pmportinfo->pmport_mutex);
11940 if (SATA_PMPORTINFO_DRV_INFO(pmportinfo) != NULL)
11941 SATA_PMPORTINFO_DRV_INFO(pmportinfo)->
11942 satadrv_state = SATA_DSTATE_FAILED;
11943 mutex_exit(&pmportinfo->pmport_mutex);
11944 }
11945 }
11946 return (SATA_SUCCESS);
11947 }
11948
11949 /*
11950 * Allocated related structure for a port multiplier and its device ports
11951 *
11952 * Port multiplier should be ready and probed, and related information like
11953 * the number of the device ports should be store in sata_device_t.
11954 *
11955 * NOTE: No Mutex should be hold.
11956 */
11957 static int
sata_alloc_pmult(sata_hba_inst_t * sata_hba_inst,sata_device_t * sata_device)11958 sata_alloc_pmult(sata_hba_inst_t *sata_hba_inst, sata_device_t *sata_device)
11959 {
11960 dev_info_t *dip = SATA_DIP(sata_hba_inst);
11961 sata_cport_info_t *cportinfo = NULL;
11962 sata_pmult_info_t *pmultinfo = NULL;
11963 sata_pmport_info_t *pmportinfo = NULL;
11964 sata_device_t sd;
11965 dev_t minor_number;
11966 char name[16];
11967 uint8_t cport = sata_device->satadev_addr.cport;
11968 int rval;
11969 int npmport;
11970
11971 cportinfo = SATA_CPORT_INFO(sata_hba_inst, cport);
11972
11973 /* This function might be called while a port-mult is hot-plugged. */
11974 mutex_enter(&cportinfo->cport_mutex);
11975
11976 /* dev_type's not updated when get called from sata_reprobe_port() */
11977 if (SATA_CPORTINFO_PMULT_INFO(cportinfo) == NULL) {
11978 /* Create a pmult_info structure */
11979 SATA_CPORTINFO_PMULT_INFO(cportinfo) =
11980 kmem_zalloc(sizeof (sata_pmult_info_t), KM_SLEEP);
11981 }
11982 pmultinfo = SATA_CPORTINFO_PMULT_INFO(cportinfo);
11983
11984 pmultinfo->pmult_addr = sata_device->satadev_addr;
11985 pmultinfo->pmult_addr.qual = SATA_ADDR_PMULT;
11986 pmultinfo->pmult_state = SATA_STATE_PROBING;
11987
11988 /*
11989 * Probe the port multiplier with qualifier SATA_ADDR_PMULT_SPEC,
11990 * The HBA driver should initialize and register the port multiplier,
11991 * sata_register_pmult() will fill following fields,
11992 * + sata_pmult_info.pmult_gscr
11993 * + sata_pmult_info.pmult_num_dev_ports
11994 */
11995 sd.satadev_addr = sata_device->satadev_addr;
11996 sd.satadev_addr.qual = SATA_ADDR_PMULT_SPEC;
11997 mutex_exit(&cportinfo->cport_mutex);
11998 rval = (*SATA_PROBE_PORT_FUNC(sata_hba_inst))
11999 (SATA_DIP(sata_hba_inst), &sd);
12000 mutex_enter(&cportinfo->cport_mutex);
12001
12002 if (rval != SATA_SUCCESS ||
12003 (sd.satadev_type != SATA_DTYPE_PMULT) ||
12004 !(sd.satadev_state & SATA_DSTATE_PMULT_INIT)) {
12005 SATA_CPORTINFO_PMULT_INFO(cportinfo) = NULL;
12006 kmem_free(pmultinfo, sizeof (sata_pmult_info_t));
12007 cportinfo->cport_state = SATA_PSTATE_FAILED;
12008 cportinfo->cport_dev_type = SATA_DTYPE_UNKNOWN;
12009 mutex_exit(&cportinfo->cport_mutex);
12010 SATADBG1(SATA_DBG_PMULT, sata_hba_inst,
12011 "sata_alloc_pmult: failed to initialize pmult "
12012 "at port %d.", cport)
12013 return (SATA_FAILURE);
12014 }
12015
12016 /* Initialize pmport_info structure */
12017 for (npmport = 0; npmport < pmultinfo->pmult_num_dev_ports;
12018 npmport++) {
12019
12020 /* if everything is allocated, skip */
12021 if (SATA_PMPORT_INFO(sata_hba_inst, cport, npmport) != NULL)
12022 continue;
12023
12024 pmportinfo = kmem_zalloc(sizeof (sata_pmport_info_t), KM_SLEEP);
12025 mutex_init(&pmportinfo->pmport_mutex, NULL, MUTEX_DRIVER, NULL);
12026 mutex_exit(&cportinfo->cport_mutex);
12027
12028 mutex_enter(&pmportinfo->pmport_mutex);
12029 pmportinfo->pmport_addr.cport = cport;
12030 pmportinfo->pmport_addr.pmport = (uint8_t)npmport;
12031 pmportinfo->pmport_addr.qual = SATA_ADDR_PMPORT;
12032 pmportinfo->pmport_state &= ~SATA_PORT_STATE_CLEAR_MASK;
12033 mutex_exit(&pmportinfo->pmport_mutex);
12034
12035 mutex_enter(&cportinfo->cport_mutex);
12036 SATA_PMPORT_INFO(sata_hba_inst, cport, npmport) = pmportinfo;
12037
12038 /* Create an attachment point */
12039 minor_number = SATA_MAKE_AP_MINOR(ddi_get_instance(dip),
12040 cport, (uint8_t)npmport, SATA_ADDR_PMPORT);
12041 (void) sprintf(name, "%d.%d", cport, npmport);
12042
12043 if (ddi_create_minor_node(dip, name, S_IFCHR, minor_number,
12044 DDI_NT_SATA_ATTACHMENT_POINT, 0) != DDI_SUCCESS) {
12045 sata_log(sata_hba_inst, CE_WARN, "sata_hba_attach: "
12046 "cannot create SATA attachment point for "
12047 "port %d:%d", cport, npmport);
12048 }
12049 }
12050
12051 pmultinfo->pmult_state &= ~SATA_STATE_PROBING;
12052 pmultinfo->pmult_state |= (SATA_STATE_PROBED|SATA_STATE_READY);
12053 cportinfo->cport_dev_type = SATA_DTYPE_PMULT;
12054
12055 mutex_exit(&cportinfo->cport_mutex);
12056 return (SATA_SUCCESS);
12057 }
12058
12059 /*
12060 * Free data structures when a port multiplier is removed.
12061 *
12062 * NOTE: No Mutex should be hold.
12063 */
12064 static void
sata_free_pmult(sata_hba_inst_t * sata_hba_inst,sata_device_t * sata_device)12065 sata_free_pmult(sata_hba_inst_t *sata_hba_inst, sata_device_t *sata_device)
12066 {
12067 sata_cport_info_t *cportinfo;
12068 sata_pmult_info_t *pmultinfo;
12069 sata_pmport_info_t *pmportinfo;
12070 sata_device_t pmport_device;
12071 sata_drive_info_t *sdinfo;
12072 dev_info_t *tdip;
12073 char name[16];
12074 uint8_t cport = sata_device->satadev_addr.cport;
12075 int npmport;
12076
12077 cportinfo = SATA_CPORT_INFO(sata_hba_inst, cport);
12078
12079 /* This function might be called while port-mult is hot plugged. */
12080 mutex_enter(&cportinfo->cport_mutex);
12081
12082 cportinfo->cport_dev_type = SATA_DTYPE_NONE;
12083 pmultinfo = SATA_CPORTINFO_PMULT_INFO(cportinfo);
12084 ASSERT(pmultinfo != NULL);
12085
12086 /* Free pmport_info structure */
12087 for (npmport = 0; npmport < pmultinfo->pmult_num_dev_ports;
12088 npmport++) {
12089 pmportinfo = SATA_PMPORT_INFO(sata_hba_inst, cport, npmport);
12090 if (pmportinfo == NULL)
12091 continue;
12092 mutex_exit(&cportinfo->cport_mutex);
12093
12094 mutex_enter(&pmportinfo->pmport_mutex);
12095 sdinfo = pmportinfo->pmport_sata_drive;
12096 SATA_PMPORTINFO_DRV_INFO(pmportinfo) = NULL;
12097 mutex_exit(&pmportinfo->pmport_mutex);
12098
12099 /* Remove attachment point. */
12100 name[0] = '\0';
12101 (void) sprintf(name, "%d.%d", cport, npmport);
12102 ddi_remove_minor_node(SATA_DIP(sata_hba_inst), name);
12103 sata_log(sata_hba_inst, CE_NOTE,
12104 "Remove attachment point of port %d:%d",
12105 cport, npmport);
12106
12107 /*
12108 * Rumove target node
12109 */
12110 bzero(&pmport_device, sizeof (sata_device_t));
12111 pmport_device.satadev_rev = SATA_DEVICE_REV;
12112 pmport_device.satadev_addr.cport = cport;
12113 pmport_device.satadev_addr.pmport = (uint8_t)npmport;
12114 pmport_device.satadev_addr.qual = SATA_ADDR_DPMPORT;
12115
12116 tdip = sata_get_scsi_target_dip(SATA_DIP(sata_hba_inst),
12117 &(pmport_device.satadev_addr));
12118 if (tdip != NULL && ndi_devi_offline(tdip,
12119 NDI_DEVI_REMOVE) != NDI_SUCCESS) {
12120 /*
12121 * Problem :
12122 * The target node remained attached.
12123 * This happens when the device file was open
12124 * or a node was waiting for resources.
12125 * Cannot do anything about it.
12126 */
12127 SATA_LOG_D((sata_hba_inst, CE_WARN,
12128 "sata_free_pmult: could not unconfigure device "
12129 "before disconnecting the SATA port %d:%d",
12130 cport, npmport));
12131
12132 /*
12133 * Set DEVICE REMOVED state in the target
12134 * node. It will prevent access to the device
12135 * even when a new device is attached, until
12136 * the old target node is released, removed and
12137 * recreated for a new device.
12138 */
12139 sata_set_device_removed(tdip);
12140
12141 /*
12142 * Instruct event daemon to try the target
12143 * node cleanup later.
12144 */
12145 sata_set_target_node_cleanup(
12146 sata_hba_inst, &(pmport_device.satadev_addr));
12147
12148 }
12149 mutex_enter(&cportinfo->cport_mutex);
12150
12151 /*
12152 * Add here differentiation for device attached or not
12153 */
12154 if (sdinfo != NULL) {
12155 sata_log(sata_hba_inst, CE_WARN,
12156 "SATA device detached from port %d:%d",
12157 cport, npmport);
12158 kmem_free(sdinfo, sizeof (sata_drive_info_t));
12159 }
12160
12161 mutex_destroy(&pmportinfo->pmport_mutex);
12162 kmem_free(pmportinfo, sizeof (sata_pmport_info_t));
12163 }
12164
12165 kmem_free(pmultinfo, sizeof (sata_pmult_info_t));
12166
12167 cportinfo->cport_devp.cport_sata_pmult = NULL;
12168
12169 sata_log(sata_hba_inst, CE_WARN,
12170 "SATA port multiplier detached at port %d", cport);
12171
12172 mutex_exit(&cportinfo->cport_mutex);
12173 }
12174
12175 /*
12176 * Initialize device
12177 * Specified device is initialized to a default state.
12178 *
12179 * Returns SATA_SUCCESS if all device features are set successfully,
12180 * SATA_RETRY if device is accessible but device features were not set
12181 * successfully, and SATA_FAILURE otherwise.
12182 */
12183 static int
sata_initialize_device(sata_hba_inst_t * sata_hba_inst,sata_drive_info_t * sdinfo)12184 sata_initialize_device(sata_hba_inst_t *sata_hba_inst,
12185 sata_drive_info_t *sdinfo)
12186 {
12187 int rval;
12188
12189 sata_save_drive_settings(sdinfo);
12190
12191 sdinfo->satadrv_settings |= SATA_DEV_READ_AHEAD;
12192
12193 sata_init_write_cache_mode(sdinfo);
12194
12195 rval = sata_set_drive_features(sata_hba_inst, sdinfo, 0);
12196
12197 /* Determine current data transfer mode */
12198 if ((sdinfo->satadrv_id.ai_cap & SATA_DMA_SUPPORT) == 0) {
12199 sdinfo->satadrv_settings &= ~SATA_DEV_DMA;
12200 } else if ((sdinfo->satadrv_id.ai_validinfo &
12201 SATA_VALIDINFO_88) != 0 &&
12202 (sdinfo->satadrv_id.ai_ultradma & SATA_UDMA_SEL_MASK) != 0) {
12203 sdinfo->satadrv_settings |= SATA_DEV_DMA;
12204 } else if ((sdinfo->satadrv_id.ai_dworddma &
12205 SATA_MDMA_SEL_MASK) != 0) {
12206 sdinfo->satadrv_settings |= SATA_DEV_DMA;
12207 } else
12208 /* DMA supported, not no DMA transfer mode is selected !? */
12209 sdinfo->satadrv_settings &= ~SATA_DEV_DMA;
12210
12211 if ((sdinfo->satadrv_id.ai_cmdset83 & 0x20) &&
12212 (sdinfo->satadrv_id.ai_features86 & 0x20))
12213 sdinfo->satadrv_power_level = SATA_POWER_STANDBY;
12214 else
12215 sdinfo->satadrv_power_level = SATA_POWER_ACTIVE;
12216
12217 return (rval);
12218 }
12219
12220
12221 /*
12222 * Initialize write cache mode.
12223 *
12224 * The default write cache setting for SATA HDD is provided by sata_write_cache
12225 * static variable. ATAPI CD/DVDs devices have write cache default is
12226 * determined by sata_atapicdvd_write_cache static variable.
12227 * ATAPI tape devices have write cache default is determined by
12228 * sata_atapitape_write_cache static variable.
12229 * ATAPI disk devices have write cache default is determined by
12230 * sata_atapidisk_write_cache static variable.
12231 * 1 - enable
12232 * 0 - disable
12233 * any other value - current drive setting
12234 *
12235 * Although there is not reason to disable write cache on CD/DVD devices,
12236 * tape devices and ATAPI disk devices, the default setting control is provided
12237 * for the maximun flexibility.
12238 *
12239 * In the future, it may be overridden by the
12240 * disk-write-cache-enable property setting, if it is defined.
12241 * Returns SATA_SUCCESS if all device features are set successfully,
12242 * SATA_FAILURE otherwise.
12243 */
12244 static void
sata_init_write_cache_mode(sata_drive_info_t * sdinfo)12245 sata_init_write_cache_mode(sata_drive_info_t *sdinfo)
12246 {
12247 switch (sdinfo->satadrv_type) {
12248 case SATA_DTYPE_ATADISK:
12249 if (sata_write_cache == 1)
12250 sdinfo->satadrv_settings |= SATA_DEV_WRITE_CACHE;
12251 else if (sata_write_cache == 0)
12252 sdinfo->satadrv_settings &= ~SATA_DEV_WRITE_CACHE;
12253 /*
12254 * When sata_write_cache value is not 0 or 1,
12255 * a current setting of the drive's write cache is used.
12256 */
12257 break;
12258 case SATA_DTYPE_ATAPICD:
12259 if (sata_atapicdvd_write_cache == 1)
12260 sdinfo->satadrv_settings |= SATA_DEV_WRITE_CACHE;
12261 else if (sata_atapicdvd_write_cache == 0)
12262 sdinfo->satadrv_settings &= ~SATA_DEV_WRITE_CACHE;
12263 /*
12264 * When sata_atapicdvd_write_cache value is not 0 or 1,
12265 * a current setting of the drive's write cache is used.
12266 */
12267 break;
12268 case SATA_DTYPE_ATAPITAPE:
12269 if (sata_atapitape_write_cache == 1)
12270 sdinfo->satadrv_settings |= SATA_DEV_WRITE_CACHE;
12271 else if (sata_atapitape_write_cache == 0)
12272 sdinfo->satadrv_settings &= ~SATA_DEV_WRITE_CACHE;
12273 /*
12274 * When sata_atapitape_write_cache value is not 0 or 1,
12275 * a current setting of the drive's write cache is used.
12276 */
12277 break;
12278 case SATA_DTYPE_ATAPIDISK:
12279 if (sata_atapidisk_write_cache == 1)
12280 sdinfo->satadrv_settings |= SATA_DEV_WRITE_CACHE;
12281 else if (sata_atapidisk_write_cache == 0)
12282 sdinfo->satadrv_settings &= ~SATA_DEV_WRITE_CACHE;
12283 /*
12284 * When sata_atapidisk_write_cache value is not 0 or 1,
12285 * a current setting of the drive's write cache is used.
12286 */
12287 break;
12288 }
12289 }
12290
12291
12292 /*
12293 * Validate sata address.
12294 * Specified cport, pmport and qualifier has to match
12295 * passed sata_scsi configuration info.
12296 * The presence of an attached device is not verified.
12297 *
12298 * Returns 0 when address is valid, -1 otherwise.
12299 */
12300 static int
sata_validate_sata_address(sata_hba_inst_t * sata_hba_inst,int cport,int pmport,int qual)12301 sata_validate_sata_address(sata_hba_inst_t *sata_hba_inst, int cport,
12302 int pmport, int qual)
12303 {
12304 if (qual == SATA_ADDR_DCPORT && pmport != 0)
12305 goto invalid_address;
12306 if (cport >= SATA_NUM_CPORTS(sata_hba_inst))
12307 goto invalid_address;
12308 if ((qual == SATA_ADDR_DPMPORT || qual == SATA_ADDR_PMPORT) &&
12309 ((SATA_CPORT_DEV_TYPE(sata_hba_inst, cport) != SATA_DTYPE_PMULT) ||
12310 (SATA_PMULT_INFO(sata_hba_inst, cport) == NULL) ||
12311 (pmport >= SATA_NUM_PMPORTS(sata_hba_inst, cport))))
12312 goto invalid_address;
12313
12314 return (0);
12315
12316 invalid_address:
12317 return (-1);
12318
12319 }
12320
12321 /*
12322 * Validate scsi address
12323 * SCSI target address is translated into SATA cport/pmport and compared
12324 * with a controller port/device configuration. LUN has to be 0.
12325 * Returns 0 if a scsi target refers to an attached device,
12326 * returns 1 if address is valid but no valid device is attached,
12327 * returns 2 if address is valid but device type is unknown (not valid device),
12328 * returns -1 if bad address or device is of an unsupported type.
12329 * Upon return sata_device argument is set.
12330 *
12331 * Port multiplier is supported now.
12332 */
12333 static int
sata_validate_scsi_address(sata_hba_inst_t * sata_hba_inst,struct scsi_address * ap,sata_device_t * sata_device)12334 sata_validate_scsi_address(sata_hba_inst_t *sata_hba_inst,
12335 struct scsi_address *ap, sata_device_t *sata_device)
12336 {
12337 int cport, pmport, qual, rval;
12338
12339 rval = -1; /* Invalid address */
12340 if (ap->a_lun != 0)
12341 goto out;
12342
12343 qual = SCSI_TO_SATA_ADDR_QUAL(ap->a_target);
12344 cport = SCSI_TO_SATA_CPORT(ap->a_target);
12345 pmport = SCSI_TO_SATA_PMPORT(ap->a_target);
12346
12347 if (qual != SATA_ADDR_DCPORT && qual != SATA_ADDR_DPMPORT)
12348 goto out;
12349
12350 if (sata_validate_sata_address(sata_hba_inst, cport, pmport, qual) ==
12351 0) {
12352
12353 sata_cport_info_t *cportinfo;
12354 sata_pmult_info_t *pmultinfo;
12355 sata_drive_info_t *sdinfo = NULL;
12356
12357 sata_device->satadev_addr.qual = qual;
12358 sata_device->satadev_addr.cport = cport;
12359 sata_device->satadev_addr.pmport = pmport;
12360 sata_device->satadev_rev = SATA_DEVICE_REV_1;
12361
12362 rval = 1; /* Valid sata address */
12363
12364 cportinfo = SATA_CPORT_INFO(sata_hba_inst, cport);
12365 if (qual == SATA_ADDR_DCPORT) {
12366 if (cportinfo == NULL ||
12367 cportinfo->cport_dev_type == SATA_DTYPE_NONE)
12368 goto out;
12369
12370 sdinfo = SATA_CPORTINFO_DRV_INFO(cportinfo);
12371 if (cportinfo->cport_dev_type == SATA_DTYPE_UNKNOWN &&
12372 sdinfo != NULL) {
12373 rval = 2;
12374 goto out;
12375 }
12376
12377 if ((cportinfo->cport_dev_type &
12378 SATA_VALID_DEV_TYPE) == 0) {
12379 rval = -1;
12380 goto out;
12381 }
12382
12383 } else if (qual == SATA_ADDR_DPMPORT) {
12384 pmultinfo = SATA_CPORTINFO_PMULT_INFO(cportinfo);
12385 if (pmultinfo == NULL) {
12386 rval = -1;
12387 goto out;
12388 }
12389 if (SATA_PMPORT_INFO(sata_hba_inst, cport, pmport) ==
12390 NULL ||
12391 SATA_PMPORT_DEV_TYPE(sata_hba_inst, cport,
12392 pmport) == SATA_DTYPE_NONE)
12393 goto out;
12394
12395 sdinfo = SATA_PMPORT_DRV_INFO(sata_hba_inst, cport,
12396 pmport);
12397 if (SATA_PMPORT_DEV_TYPE(sata_hba_inst, cport,
12398 pmport) == SATA_DTYPE_UNKNOWN && sdinfo != NULL) {
12399 rval = 2;
12400 goto out;
12401 }
12402
12403 if ((SATA_PMPORT_DEV_TYPE(sata_hba_inst, cport,
12404 pmport) & SATA_VALID_DEV_TYPE) == 0) {
12405 rval = -1;
12406 goto out;
12407 }
12408
12409 } else {
12410 rval = -1;
12411 goto out;
12412 }
12413 if ((sdinfo == NULL) ||
12414 (sdinfo->satadrv_type & SATA_VALID_DEV_TYPE) == 0)
12415 goto out;
12416
12417 sata_device->satadev_type = sdinfo->satadrv_type;
12418
12419 return (0);
12420 }
12421 out:
12422 if (rval > 0) {
12423 SATADBG2(SATA_DBG_SCSI_IF, sata_hba_inst,
12424 "sata_validate_scsi_address: no valid target %x lun %x",
12425 ap->a_target, ap->a_lun);
12426 }
12427 return (rval);
12428 }
12429
12430 /*
12431 * Find dip corresponding to passed device number
12432 *
12433 * Returns NULL if invalid device number is passed or device cannot be found,
12434 * Returns dip is device is found.
12435 */
12436 static dev_info_t *
sata_devt_to_devinfo(dev_t dev)12437 sata_devt_to_devinfo(dev_t dev)
12438 {
12439 dev_info_t *dip;
12440 #ifndef __lock_lint
12441 struct devnames *dnp;
12442 major_t major = getmajor(dev);
12443 int instance = SATA_MINOR2INSTANCE(getminor(dev));
12444
12445 if (major >= devcnt)
12446 return (NULL);
12447
12448 dnp = &devnamesp[major];
12449 LOCK_DEV_OPS(&(dnp->dn_lock));
12450 dip = dnp->dn_head;
12451 while (dip && (ddi_get_instance(dip) != instance)) {
12452 dip = ddi_get_next(dip);
12453 }
12454 UNLOCK_DEV_OPS(&(dnp->dn_lock));
12455 #endif
12456
12457 return (dip);
12458 }
12459
12460
12461 /*
12462 * Probe device.
12463 * This function issues Identify Device command and initializes local
12464 * sata_drive_info structure if the device can be identified.
12465 * The device type is determined by examining Identify Device
12466 * command response.
12467 * If the sata_hba_inst has linked drive info structure for this
12468 * device address, the Identify Device data is stored into sata_drive_info
12469 * structure linked to the port info structure.
12470 *
12471 * sata_device has to refer to the valid sata port(s) for HBA described
12472 * by sata_hba_inst structure.
12473 *
12474 * Returns:
12475 * SATA_SUCCESS if device type was successfully probed and port-linked
12476 * drive info structure was updated;
12477 * SATA_FAILURE if there is no device, or device was not probed
12478 * successully;
12479 * SATA_RETRY if device probe can be retried later.
12480 * If a device cannot be identified, sata_device's dev_state and dev_type
12481 * fields are set to unknown.
12482 * There are no retries in this function. Any retries should be managed by
12483 * the caller.
12484 */
12485
12486
12487 static int
sata_probe_device(sata_hba_inst_t * sata_hba_inst,sata_device_t * sata_device)12488 sata_probe_device(sata_hba_inst_t *sata_hba_inst, sata_device_t *sata_device)
12489 {
12490 sata_pmport_info_t *pmportinfo = NULL;
12491 sata_drive_info_t *sdinfo;
12492 sata_drive_info_t new_sdinfo; /* local drive info struct */
12493 int rval;
12494
12495 ASSERT((SATA_CPORT_STATE(sata_hba_inst,
12496 sata_device->satadev_addr.cport) &
12497 (SATA_STATE_PROBED | SATA_STATE_READY)) != 0);
12498
12499 sata_device->satadev_type = SATA_DTYPE_NONE;
12500
12501 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst,
12502 sata_device->satadev_addr.cport)));
12503
12504 if (sata_device->satadev_addr.qual == SATA_ADDR_DPMPORT) {
12505 pmportinfo = SATA_PMPORT_INFO(sata_hba_inst,
12506 sata_device->satadev_addr.cport,
12507 sata_device->satadev_addr.pmport);
12508 ASSERT(pmportinfo != NULL);
12509 }
12510
12511 /* Get pointer to port-linked sata device info structure */
12512 sdinfo = sata_get_device_info(sata_hba_inst, sata_device);
12513 if (sdinfo != NULL) {
12514 sdinfo->satadrv_state &=
12515 ~(SATA_STATE_PROBED | SATA_STATE_READY);
12516 sdinfo->satadrv_state |= SATA_STATE_PROBING;
12517 } else {
12518 /* No device to probe */
12519 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst,
12520 sata_device->satadev_addr.cport)));
12521 sata_device->satadev_type = SATA_DTYPE_NONE;
12522 sata_device->satadev_state = SATA_STATE_UNKNOWN;
12523 return (SATA_FAILURE);
12524 }
12525 /*
12526 * Need to issue both types of identify device command and
12527 * determine device type by examining retreived data/status.
12528 * First, ATA Identify Device.
12529 */
12530 bzero(&new_sdinfo, sizeof (sata_drive_info_t));
12531 new_sdinfo.satadrv_addr = sata_device->satadev_addr;
12532 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst,
12533 sata_device->satadev_addr.cport)));
12534 new_sdinfo.satadrv_type = SATA_DTYPE_ATADISK;
12535 rval = sata_identify_device(sata_hba_inst, &new_sdinfo);
12536 if (rval == SATA_RETRY) {
12537 /* We may try to check for ATAPI device */
12538 if (SATA_FEATURES(sata_hba_inst) & SATA_CTLF_ATAPI) {
12539 /*
12540 * HBA supports ATAPI - try to issue Identify Packet
12541 * Device command.
12542 */
12543 new_sdinfo.satadrv_type = SATA_DTYPE_ATAPI;
12544 rval = sata_identify_device(sata_hba_inst, &new_sdinfo);
12545 }
12546 }
12547 if (rval == SATA_SUCCESS) {
12548 /*
12549 * Got something responding positively to ATA Identify Device
12550 * or to Identify Packet Device cmd.
12551 * Save last used device type.
12552 */
12553 sata_device->satadev_type = new_sdinfo.satadrv_type;
12554
12555 /* save device info, if possible */
12556 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst,
12557 sata_device->satadev_addr.cport)));
12558 sdinfo = sata_get_device_info(sata_hba_inst, sata_device);
12559 if (sdinfo == NULL) {
12560 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst,
12561 sata_device->satadev_addr.cport)));
12562 return (SATA_FAILURE);
12563 }
12564 /*
12565 * Copy drive info into the port-linked drive info structure.
12566 */
12567 *sdinfo = new_sdinfo;
12568 sdinfo->satadrv_state &= ~SATA_STATE_PROBING;
12569 sdinfo->satadrv_state |= SATA_STATE_PROBED;
12570 if (sata_device->satadev_addr.qual == SATA_ADDR_DCPORT)
12571 SATA_CPORT_DEV_TYPE(sata_hba_inst,
12572 sata_device->satadev_addr.cport) =
12573 sdinfo->satadrv_type;
12574 else { /* SATA_ADDR_DPMPORT */
12575 mutex_enter(&pmportinfo->pmport_mutex);
12576 SATA_PMPORT_DEV_TYPE(sata_hba_inst,
12577 sata_device->satadev_addr.cport,
12578 sata_device->satadev_addr.pmport) =
12579 sdinfo->satadrv_type;
12580 mutex_exit(&pmportinfo->pmport_mutex);
12581 }
12582 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst,
12583 sata_device->satadev_addr.cport)));
12584 return (SATA_SUCCESS);
12585 }
12586
12587 /*
12588 * It may be SATA_RETRY or SATA_FAILURE return.
12589 * Looks like we cannot determine the device type at this time.
12590 */
12591 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst,
12592 sata_device->satadev_addr.cport)));
12593 sdinfo = sata_get_device_info(sata_hba_inst, sata_device);
12594 if (sdinfo != NULL) {
12595 sata_device->satadev_type = SATA_DTYPE_UNKNOWN;
12596 sdinfo->satadrv_type = SATA_DTYPE_UNKNOWN;
12597 sdinfo->satadrv_state &= ~SATA_STATE_PROBING;
12598 sdinfo->satadrv_state |= SATA_STATE_PROBED;
12599 if (sata_device->satadev_addr.qual == SATA_ADDR_DCPORT)
12600 SATA_CPORT_DEV_TYPE(sata_hba_inst,
12601 sata_device->satadev_addr.cport) =
12602 SATA_DTYPE_UNKNOWN;
12603 else {
12604 /* SATA_ADDR_DPMPORT */
12605 mutex_enter(&pmportinfo->pmport_mutex);
12606 if ((SATA_PMULT_INFO(sata_hba_inst,
12607 sata_device->satadev_addr.cport) != NULL) &&
12608 (SATA_PMPORT_INFO(sata_hba_inst,
12609 sata_device->satadev_addr.cport,
12610 sata_device->satadev_addr.pmport) != NULL))
12611 SATA_PMPORT_DEV_TYPE(sata_hba_inst,
12612 sata_device->satadev_addr.cport,
12613 sata_device->satadev_addr.pmport) =
12614 SATA_DTYPE_UNKNOWN;
12615 mutex_exit(&pmportinfo->pmport_mutex);
12616 }
12617 }
12618 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst,
12619 sata_device->satadev_addr.cport)));
12620 return (rval);
12621 }
12622
12623
12624 /*
12625 * Get pointer to sata_drive_info structure.
12626 *
12627 * The sata_device has to contain address (cport, pmport and qualifier) for
12628 * specified sata_scsi structure.
12629 *
12630 * Returns NULL if device address is not valid for this HBA configuration.
12631 * Otherwise, returns a pointer to sata_drive_info structure.
12632 *
12633 * This function should be called with a port mutex held.
12634 */
12635 static sata_drive_info_t *
sata_get_device_info(sata_hba_inst_t * sata_hba_inst,sata_device_t * sata_device)12636 sata_get_device_info(sata_hba_inst_t *sata_hba_inst,
12637 sata_device_t *sata_device)
12638 {
12639 uint8_t cport = sata_device->satadev_addr.cport;
12640 uint8_t pmport = sata_device->satadev_addr.pmport;
12641 uint8_t qual = sata_device->satadev_addr.qual;
12642
12643 if (cport >= SATA_NUM_CPORTS(sata_hba_inst))
12644 return (NULL);
12645
12646 if (!(SATA_CPORT_STATE(sata_hba_inst, cport) &
12647 (SATA_STATE_PROBED | SATA_STATE_READY)))
12648 /* Port not probed yet */
12649 return (NULL);
12650
12651 if (SATA_CPORT_DEV_TYPE(sata_hba_inst, cport) == SATA_DTYPE_NONE)
12652 return (NULL);
12653
12654 if (qual == SATA_ADDR_DCPORT) {
12655 /* Request for a device on a controller port */
12656 if (SATA_CPORT_DEV_TYPE(sata_hba_inst, cport) ==
12657 SATA_DTYPE_PMULT)
12658 /* Port multiplier attached */
12659 return (NULL);
12660 return (SATA_CPORT_DRV_INFO(sata_hba_inst, cport));
12661 }
12662 if (qual == SATA_ADDR_DPMPORT) {
12663 if (SATA_CPORT_DEV_TYPE(sata_hba_inst, cport) !=
12664 SATA_DTYPE_PMULT)
12665 return (NULL);
12666
12667 if (pmport > SATA_NUM_PMPORTS(sata_hba_inst, cport))
12668 return (NULL);
12669
12670 if (!(SATA_PMPORT_STATE(sata_hba_inst, cport, pmport) &
12671 (SATA_STATE_PROBED | SATA_STATE_READY)))
12672 /* Port multiplier port not probed yet */
12673 return (NULL);
12674
12675 return (SATA_PMPORT_DRV_INFO(sata_hba_inst, cport, pmport));
12676 }
12677
12678 /* we should not get here */
12679 return (NULL);
12680 }
12681
12682
12683 /*
12684 * sata_identify_device.
12685 * Send Identify Device command to SATA HBA driver.
12686 * If command executes successfully, update sata_drive_info structure pointed
12687 * to by sdinfo argument, including Identify Device data.
12688 * If command fails, invalidate data in sata_drive_info.
12689 *
12690 * Cannot be called from interrupt level.
12691 *
12692 * Returns:
12693 * SATA_SUCCESS if the device was identified as a supported device,
12694 * SATA_RETRY if the device was not identified but could be retried,
12695 * SATA_FAILURE if the device was not identified and identify attempt
12696 * should not be retried.
12697 */
12698 static int
sata_identify_device(sata_hba_inst_t * sata_hba_inst,sata_drive_info_t * sdinfo)12699 sata_identify_device(sata_hba_inst_t *sata_hba_inst,
12700 sata_drive_info_t *sdinfo)
12701 {
12702 uint16_t cfg_word;
12703 int rval;
12704
12705 /* fetch device identify data */
12706 if ((rval = sata_fetch_device_identify_data(sata_hba_inst,
12707 sdinfo)) != SATA_SUCCESS)
12708 goto fail_unknown;
12709
12710 cfg_word = sdinfo->satadrv_id.ai_config;
12711
12712 /* Set the correct device type */
12713 if ((cfg_word & SATA_ATA_TYPE_MASK) == SATA_ATA_TYPE) {
12714 sdinfo->satadrv_type = SATA_DTYPE_ATADISK;
12715 } else if (cfg_word == SATA_CFA_TYPE) {
12716 /* It's a Compact Flash media via CF-to-SATA HDD adapter */
12717 sdinfo->satadrv_type = SATA_DTYPE_ATADISK;
12718 } else if ((cfg_word & SATA_ATAPI_TYPE_MASK) == SATA_ATAPI_TYPE) {
12719 switch (cfg_word & SATA_ATAPI_ID_DEV_TYPE) {
12720 case SATA_ATAPI_CDROM_DEV:
12721 sdinfo->satadrv_type = SATA_DTYPE_ATAPICD;
12722 break;
12723 case SATA_ATAPI_SQACC_DEV:
12724 sdinfo->satadrv_type = SATA_DTYPE_ATAPITAPE;
12725 break;
12726 case SATA_ATAPI_DIRACC_DEV:
12727 sdinfo->satadrv_type = SATA_DTYPE_ATAPIDISK;
12728 break;
12729 case SATA_ATAPI_PROC_DEV:
12730 sdinfo->satadrv_type = SATA_DTYPE_ATAPIPROC;
12731 break;
12732 default:
12733 sdinfo->satadrv_type = SATA_DTYPE_UNKNOWN;
12734 }
12735 } else {
12736 sdinfo->satadrv_type = SATA_DTYPE_UNKNOWN;
12737 }
12738
12739 if (sdinfo->satadrv_type == SATA_DTYPE_ATADISK) {
12740 if (sdinfo->satadrv_capacity == 0) {
12741 /* Non-LBA disk. Too bad... */
12742 sata_log(sata_hba_inst, CE_WARN,
12743 "SATA disk device at port %d does not support LBA",
12744 sdinfo->satadrv_addr.cport);
12745 rval = SATA_FAILURE;
12746 goto fail_unknown;
12747 }
12748 }
12749 #if 0
12750 /* Left for historical reason */
12751 /*
12752 * Some initial version of SATA spec indicated that at least
12753 * UDMA mode 4 has to be supported. It is not metioned in
12754 * SerialATA 2.6, so this restriction is removed.
12755 */
12756 /* Check for Ultra DMA modes 6 through 0 being supported */
12757 for (i = 6; i >= 0; --i) {
12758 if (sdinfo->satadrv_id.ai_ultradma & (1 << i))
12759 break;
12760 }
12761
12762 /*
12763 * At least UDMA 4 mode has to be supported. If mode 4 or
12764 * higher are not supported by the device, fail this
12765 * device.
12766 */
12767 if (i < 4) {
12768 /* No required Ultra DMA mode supported */
12769 sata_log(sata_hba_inst, CE_WARN,
12770 "SATA disk device at port %d does not support UDMA "
12771 "mode 4 or higher", sdinfo->satadrv_addr.cport);
12772 SATA_LOG_D((sata_hba_inst, CE_WARN,
12773 "mode 4 or higher required, %d supported", i));
12774 rval = SATA_FAILURE;
12775 goto fail_unknown;
12776 }
12777 #endif
12778
12779 /*
12780 * For Disk devices, if it doesn't support UDMA mode, we would
12781 * like to return failure directly.
12782 */
12783 if ((sdinfo->satadrv_type == SATA_DTYPE_ATADISK) &&
12784 !((sdinfo->satadrv_id.ai_validinfo & SATA_VALIDINFO_88) != 0 &&
12785 (sdinfo->satadrv_id.ai_ultradma & SATA_UDMA_SUP_MASK) != 0)) {
12786 sata_log(sata_hba_inst, CE_WARN,
12787 "SATA disk device at port %d does not support UDMA",
12788 sdinfo->satadrv_addr.cport);
12789 rval = SATA_FAILURE;
12790 goto fail_unknown;
12791 }
12792
12793 return (SATA_SUCCESS);
12794
12795 fail_unknown:
12796 /* Invalidate sata_drive_info ? */
12797 sdinfo->satadrv_type = SATA_DTYPE_UNKNOWN;
12798 sdinfo->satadrv_state = SATA_STATE_UNKNOWN;
12799 return (rval);
12800 }
12801
12802 /*
12803 * Log/display device information
12804 */
12805 static void
sata_show_drive_info(sata_hba_inst_t * sata_hba_inst,sata_drive_info_t * sdinfo)12806 sata_show_drive_info(sata_hba_inst_t *sata_hba_inst,
12807 sata_drive_info_t *sdinfo)
12808 {
12809 int valid_version = 0;
12810 char msg_buf[MAXPATHLEN];
12811 int i;
12812
12813 /* Show HBA path */
12814 (void) ddi_pathname(SATA_DIP(sata_hba_inst), msg_buf);
12815
12816 cmn_err(CE_CONT, "?%s :\n", msg_buf);
12817
12818 switch (sdinfo->satadrv_type) {
12819 case SATA_DTYPE_ATADISK:
12820 (void) sprintf(msg_buf, "SATA disk device at");
12821 break;
12822
12823 case SATA_DTYPE_ATAPICD:
12824 (void) sprintf(msg_buf, "SATA CD/DVD (ATAPI) device at");
12825 break;
12826
12827 case SATA_DTYPE_ATAPITAPE:
12828 (void) sprintf(msg_buf, "SATA tape (ATAPI) device at");
12829 break;
12830
12831 case SATA_DTYPE_ATAPIDISK:
12832 (void) sprintf(msg_buf, "SATA disk (ATAPI) device at");
12833 break;
12834
12835 case SATA_DTYPE_ATAPIPROC:
12836 (void) sprintf(msg_buf, "SATA processor (ATAPI) device at");
12837 break;
12838
12839 case SATA_DTYPE_UNKNOWN:
12840 (void) sprintf(msg_buf,
12841 "Unsupported SATA device type (cfg 0x%x) at ",
12842 sdinfo->satadrv_id.ai_config);
12843 break;
12844 }
12845
12846 if (sdinfo->satadrv_addr.qual == SATA_ADDR_DCPORT)
12847 cmn_err(CE_CONT, "?\t%s port %d\n",
12848 msg_buf, sdinfo->satadrv_addr.cport);
12849 else
12850 cmn_err(CE_CONT, "?\t%s port %d:%d\n",
12851 msg_buf, sdinfo->satadrv_addr.cport,
12852 sdinfo->satadrv_addr.pmport);
12853
12854 bcopy(&sdinfo->satadrv_id.ai_model, msg_buf,
12855 sizeof (sdinfo->satadrv_id.ai_model));
12856 swab(msg_buf, msg_buf, sizeof (sdinfo->satadrv_id.ai_model));
12857 msg_buf[sizeof (sdinfo->satadrv_id.ai_model)] = '\0';
12858 cmn_err(CE_CONT, "?\tmodel %s\n", msg_buf);
12859
12860 bcopy(&sdinfo->satadrv_id.ai_fw, msg_buf,
12861 sizeof (sdinfo->satadrv_id.ai_fw));
12862 swab(msg_buf, msg_buf, sizeof (sdinfo->satadrv_id.ai_fw));
12863 msg_buf[sizeof (sdinfo->satadrv_id.ai_fw)] = '\0';
12864 cmn_err(CE_CONT, "?\tfirmware %s\n", msg_buf);
12865
12866 bcopy(&sdinfo->satadrv_id.ai_drvser, msg_buf,
12867 sizeof (sdinfo->satadrv_id.ai_drvser));
12868 swab(msg_buf, msg_buf, sizeof (sdinfo->satadrv_id.ai_drvser));
12869 msg_buf[sizeof (sdinfo->satadrv_id.ai_drvser)] = '\0';
12870 if (sdinfo->satadrv_type == SATA_DTYPE_ATADISK) {
12871 cmn_err(CE_CONT, "?\tserial number %s\n", msg_buf);
12872 } else {
12873 /*
12874 * Some drives do not implement serial number and may
12875 * violate the spec by providing spaces rather than zeros
12876 * in serial number field. Scan the buffer to detect it.
12877 */
12878 for (i = 0; i < sizeof (sdinfo->satadrv_id.ai_drvser); i++) {
12879 if (msg_buf[i] != '\0' && msg_buf[i] != ' ')
12880 break;
12881 }
12882 if (i == sizeof (sdinfo->satadrv_id.ai_drvser)) {
12883 cmn_err(CE_CONT, "?\tserial number - none\n");
12884 } else {
12885 cmn_err(CE_CONT, "?\tserial number %s\n", msg_buf);
12886 }
12887 }
12888
12889 #ifdef SATA_DEBUG
12890 if (sdinfo->satadrv_id.ai_majorversion != 0 &&
12891 sdinfo->satadrv_id.ai_majorversion != 0xffff) {
12892 int i;
12893 for (i = 14; i >= 2; i--) {
12894 if (sdinfo->satadrv_id.ai_majorversion & (1 << i)) {
12895 valid_version = i;
12896 break;
12897 }
12898 }
12899 cmn_err(CE_CONT,
12900 "?\tATA/ATAPI-%d supported, majver 0x%x minver 0x%x\n",
12901 valid_version,
12902 sdinfo->satadrv_id.ai_majorversion,
12903 sdinfo->satadrv_id.ai_minorversion);
12904 }
12905 #endif
12906 /* Log some info */
12907 cmn_err(CE_CONT, "?\tsupported features:\n");
12908 msg_buf[0] = '\0';
12909 if (sdinfo->satadrv_type == SATA_DTYPE_ATADISK) {
12910 if (sdinfo->satadrv_features_support & SATA_DEV_F_LBA48)
12911 (void) strlcat(msg_buf, "48-bit LBA, ", MAXPATHLEN);
12912 else if (sdinfo->satadrv_features_support & SATA_DEV_F_LBA28)
12913 (void) strlcat(msg_buf, "28-bit LBA, ", MAXPATHLEN);
12914 }
12915 if (sdinfo->satadrv_features_support & SATA_DEV_F_DMA)
12916 (void) strlcat(msg_buf, "DMA", MAXPATHLEN);
12917 if (sdinfo->satadrv_features_support & SATA_DEV_F_NCQ)
12918 (void) strlcat(msg_buf, ", Native Command Queueing",
12919 MAXPATHLEN);
12920 if (sdinfo->satadrv_features_support & SATA_DEV_F_TCQ)
12921 (void) strlcat(msg_buf, ", Legacy Tagged Queuing", MAXPATHLEN);
12922 if ((sdinfo->satadrv_id.ai_cmdset82 & SATA_SMART_SUPPORTED) &&
12923 (sdinfo->satadrv_id.ai_features85 & SATA_SMART_ENABLED))
12924 (void) strlcat(msg_buf, ", SMART", MAXPATHLEN);
12925 if ((sdinfo->satadrv_id.ai_cmdset84 & SATA_SMART_SELF_TEST_SUPPORTED) &&
12926 (sdinfo->satadrv_id.ai_features87 & SATA_SMART_SELF_TEST_SUPPORTED))
12927 (void) strlcat(msg_buf, ", SMART self-test", MAXPATHLEN);
12928 cmn_err(CE_CONT, "?\t %s\n", msg_buf);
12929 if (sdinfo->satadrv_features_support & SATA_DEV_F_SATA3)
12930 cmn_err(CE_CONT, "?\tSATA Gen3 signaling speed (6.0Gbps)\n");
12931 else if (sdinfo->satadrv_features_support & SATA_DEV_F_SATA2)
12932 cmn_err(CE_CONT, "?\tSATA Gen2 signaling speed (3.0Gbps)\n");
12933 else if (sdinfo->satadrv_features_support & SATA_DEV_F_SATA1)
12934 cmn_err(CE_CONT, "?\tSATA Gen1 signaling speed (1.5Gbps)\n");
12935 if (sdinfo->satadrv_features_support &
12936 (SATA_DEV_F_TCQ | SATA_DEV_F_NCQ)) {
12937 msg_buf[0] = '\0';
12938 (void) snprintf(msg_buf, MAXPATHLEN,
12939 "Supported queue depth %d",
12940 sdinfo->satadrv_queue_depth);
12941 if (!(sata_func_enable &
12942 (SATA_ENABLE_QUEUING | SATA_ENABLE_NCQ)))
12943 (void) strlcat(msg_buf,
12944 " - queueing disabled globally", MAXPATHLEN);
12945 else if (sdinfo->satadrv_queue_depth >
12946 sdinfo->satadrv_max_queue_depth) {
12947 (void) snprintf(&msg_buf[strlen(msg_buf)],
12948 MAXPATHLEN - strlen(msg_buf), ", limited to %d",
12949 (int)sdinfo->satadrv_max_queue_depth);
12950 }
12951 cmn_err(CE_CONT, "?\t%s\n", msg_buf);
12952 }
12953
12954 if (sdinfo->satadrv_type == SATA_DTYPE_ATADISK) {
12955 (void) sprintf(msg_buf, "\tcapacity = %lu sectors\n",
12956 sdinfo->satadrv_capacity);
12957 cmn_err(CE_CONT, "?%s", msg_buf);
12958 }
12959 }
12960
12961 /*
12962 * Log/display port multiplier information
12963 * No Mutex should be hold.
12964 */
12965 static void
sata_show_pmult_info(sata_hba_inst_t * sata_hba_inst,sata_device_t * sata_device)12966 sata_show_pmult_info(sata_hba_inst_t *sata_hba_inst,
12967 sata_device_t *sata_device)
12968 {
12969 _NOTE(ARGUNUSED(sata_hba_inst))
12970
12971 int cport = sata_device->satadev_addr.cport;
12972 sata_pmult_info_t *pmultinfo;
12973 char msg_buf[MAXPATHLEN];
12974 uint32_t gscr0, gscr1, gscr2, gscr64;
12975
12976 mutex_enter(&SATA_CPORT_MUTEX(sata_hba_inst, cport));
12977 pmultinfo = SATA_PMULT_INFO(sata_hba_inst, cport);
12978 if (pmultinfo == NULL) {
12979 mutex_exit(&SATA_CPORT_MUTEX(sata_hba_inst, cport));
12980 return;
12981 }
12982
12983 gscr0 = pmultinfo->pmult_gscr.gscr0;
12984 gscr1 = pmultinfo->pmult_gscr.gscr1;
12985 gscr2 = pmultinfo->pmult_gscr.gscr2;
12986 gscr64 = pmultinfo->pmult_gscr.gscr64;
12987 mutex_exit(&SATA_CPORT_MUTEX(sata_hba_inst, cport));
12988
12989 cmn_err(CE_CONT, "?Port Multiplier %d device-ports found at port %d",
12990 sata_device->satadev_add_info, sata_device->satadev_addr.cport);
12991
12992 (void) sprintf(msg_buf, "\tVendor_ID 0x%04x, Module_ID 0x%04x",
12993 gscr0 & 0xffff, (gscr0 >> 16) & 0xffff);
12994 cmn_err(CE_CONT, "?%s", msg_buf);
12995
12996 (void) strcpy(msg_buf, "\tSupport SATA PMP Spec ");
12997 if (gscr1 & (1 << 3))
12998 (void) strlcat(msg_buf, "1.2", MAXPATHLEN);
12999 else if (gscr1 & (1 << 2))
13000 (void) strlcat(msg_buf, "1.1", MAXPATHLEN);
13001 else if (gscr1 & (1 << 1))
13002 (void) strlcat(msg_buf, "1.0", MAXPATHLEN);
13003 else
13004 (void) strlcat(msg_buf, "unknown", MAXPATHLEN);
13005 cmn_err(CE_CONT, "?%s", msg_buf);
13006
13007 (void) strcpy(msg_buf, "\tSupport ");
13008 if (gscr64 & (1 << 3))
13009 (void) strlcat(msg_buf, "Asy-Notif, ",
13010 MAXPATHLEN);
13011 if (gscr64 & (1 << 2))
13012 (void) strlcat(msg_buf, "Dyn-SSC, ", MAXPATHLEN);
13013 if (gscr64 & (1 << 1))
13014 (void) strlcat(msg_buf, "Iss-PMREQ, ", MAXPATHLEN);
13015 if (gscr64 & (1 << 0))
13016 (void) strlcat(msg_buf, "BIST", MAXPATHLEN);
13017 if ((gscr64 & 0xf) == 0)
13018 (void) strlcat(msg_buf, "nothing", MAXPATHLEN);
13019 cmn_err(CE_CONT, "?%s", msg_buf);
13020
13021 (void) sprintf(msg_buf, "\tNumber of exposed device fan-out ports: %d",
13022 gscr2 & SATA_PMULT_PORTNUM_MASK);
13023 cmn_err(CE_CONT, "?%s", msg_buf);
13024 }
13025
13026 /*
13027 * sata_save_drive_settings extracts current setting of the device and stores
13028 * it for future reference, in case the device setup would need to be restored
13029 * after the device reset.
13030 *
13031 * For all devices read ahead and write cache settings are saved, if the
13032 * device supports these features at all.
13033 * For ATAPI devices the Removable Media Status Notification setting is saved.
13034 */
13035 static void
sata_save_drive_settings(sata_drive_info_t * sdinfo)13036 sata_save_drive_settings(sata_drive_info_t *sdinfo)
13037 {
13038 if (SATA_READ_AHEAD_SUPPORTED(sdinfo->satadrv_id) ||
13039 SATA_WRITE_CACHE_SUPPORTED(sdinfo->satadrv_id)) {
13040
13041 /* Current setting of Read Ahead (and Read Cache) */
13042 if (SATA_READ_AHEAD_ENABLED(sdinfo->satadrv_id))
13043 sdinfo->satadrv_settings |= SATA_DEV_READ_AHEAD;
13044 else
13045 sdinfo->satadrv_settings &= ~SATA_DEV_READ_AHEAD;
13046
13047 /* Current setting of Write Cache */
13048 if (SATA_WRITE_CACHE_ENABLED(sdinfo->satadrv_id))
13049 sdinfo->satadrv_settings |= SATA_DEV_WRITE_CACHE;
13050 else
13051 sdinfo->satadrv_settings &= ~SATA_DEV_WRITE_CACHE;
13052 }
13053
13054 if (sdinfo->satadrv_type == SATA_DTYPE_ATAPICD) {
13055 if (SATA_RM_NOTIFIC_SUPPORTED(sdinfo->satadrv_id))
13056 sdinfo->satadrv_settings |= SATA_DEV_RMSN;
13057 else
13058 sdinfo->satadrv_settings &= ~SATA_DEV_RMSN;
13059 }
13060 }
13061
13062
13063 /*
13064 * sata_check_capacity function determines a disk capacity
13065 * and addressing mode (LBA28/LBA48) by examining a disk identify device data.
13066 *
13067 * NOTE: CHS mode is not supported! If a device does not support LBA,
13068 * this function is not called.
13069 *
13070 * Returns device capacity in number of blocks, i.e. largest addressable LBA+1
13071 */
13072 static uint64_t
sata_check_capacity(sata_drive_info_t * sdinfo)13073 sata_check_capacity(sata_drive_info_t *sdinfo)
13074 {
13075 uint64_t capacity = 0;
13076 int i;
13077
13078 if (sdinfo->satadrv_type != SATA_DTYPE_ATADISK ||
13079 (sdinfo->satadrv_id.ai_cap & SATA_LBA_SUPPORT) == 0)
13080 /* Capacity valid only for LBA-addressable disk devices */
13081 return (0);
13082
13083 if ((sdinfo->satadrv_id.ai_validinfo & SATA_VALIDINFO_88) &&
13084 (sdinfo->satadrv_id.ai_cmdset83 & SATA_EXT48) &&
13085 (sdinfo->satadrv_id.ai_features86 & SATA_EXT48)) {
13086 /* LBA48 mode supported and enabled */
13087 sdinfo->satadrv_features_support |= SATA_DEV_F_LBA48 |
13088 SATA_DEV_F_LBA28;
13089 for (i = 3; i >= 0; --i) {
13090 capacity <<= 16;
13091 capacity += sdinfo->satadrv_id.ai_addrsecxt[i];
13092 }
13093 } else {
13094 capacity = sdinfo->satadrv_id.ai_addrsec[1];
13095 capacity <<= 16;
13096 capacity += sdinfo->satadrv_id.ai_addrsec[0];
13097 if (capacity >= 0x1000000)
13098 /* LBA28 mode */
13099 sdinfo->satadrv_features_support |= SATA_DEV_F_LBA28;
13100 }
13101 return (capacity);
13102 }
13103
13104
13105 /*
13106 * Allocate consistent buffer for DMA transfer
13107 *
13108 * Cannot be called from interrupt level or with mutex held - it may sleep.
13109 *
13110 * Returns pointer to allocated buffer structure, or NULL if allocation failed.
13111 */
13112 static struct buf *
sata_alloc_local_buffer(sata_pkt_txlate_t * spx,int len)13113 sata_alloc_local_buffer(sata_pkt_txlate_t *spx, int len)
13114 {
13115 struct scsi_address ap;
13116 struct buf *bp;
13117 ddi_dma_attr_t cur_dma_attr;
13118
13119 ASSERT(spx->txlt_sata_pkt != NULL);
13120 ap.a_hba_tran = spx->txlt_sata_hba_inst->satahba_scsi_tran;
13121 ap.a_target = SATA_TO_SCSI_TARGET(
13122 spx->txlt_sata_pkt->satapkt_device.satadev_addr.cport,
13123 spx->txlt_sata_pkt->satapkt_device.satadev_addr.pmport,
13124 spx->txlt_sata_pkt->satapkt_device.satadev_addr.qual);
13125 ap.a_lun = 0;
13126
13127 bp = scsi_alloc_consistent_buf(&ap, NULL, len,
13128 B_READ, SLEEP_FUNC, NULL);
13129
13130 if (bp != NULL) {
13131 /* Allocate DMA resources for this buffer */
13132 spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp = bp;
13133 /*
13134 * We use a local version of the dma_attr, to account
13135 * for a device addressing limitations.
13136 * sata_adjust_dma_attr() will handle sdinfo == NULL which
13137 * will cause dma attributes to be adjusted to a lowest
13138 * acceptable level.
13139 */
13140 sata_adjust_dma_attr(NULL,
13141 SATA_DMA_ATTR(spx->txlt_sata_hba_inst), &cur_dma_attr);
13142
13143 if (sata_dma_buf_setup(spx, PKT_CONSISTENT,
13144 SLEEP_FUNC, NULL, &cur_dma_attr) != DDI_SUCCESS) {
13145 scsi_free_consistent_buf(bp);
13146 spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp = NULL;
13147 bp = NULL;
13148 }
13149 }
13150 return (bp);
13151 }
13152
13153 /*
13154 * Release local buffer (consistent buffer for DMA transfer) allocated
13155 * via sata_alloc_local_buffer().
13156 */
13157 static void
sata_free_local_buffer(sata_pkt_txlate_t * spx)13158 sata_free_local_buffer(sata_pkt_txlate_t *spx)
13159 {
13160 ASSERT(spx->txlt_sata_pkt != NULL);
13161 ASSERT(spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp != NULL);
13162
13163 spx->txlt_sata_pkt->satapkt_cmd.satacmd_num_dma_cookies = 0;
13164 spx->txlt_sata_pkt->satapkt_cmd.satacmd_dma_cookie_list = NULL;
13165
13166 sata_common_free_dma_rsrcs(spx);
13167
13168 /* Free buffer */
13169 scsi_free_consistent_buf(spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp);
13170 spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp = NULL;
13171 }
13172
13173 /*
13174 * Allocate sata_pkt
13175 * Pkt structure version and embedded strcutures version are initialized.
13176 * sata_pkt and sata_pkt_txlate structures are cross-linked.
13177 *
13178 * Since this may be called in interrupt context by sata_scsi_init_pkt,
13179 * callback argument determines if it can sleep or not.
13180 * Hence, it should not be called from interrupt context.
13181 *
13182 * If successful, non-NULL pointer to a sata pkt is returned.
13183 * Upon failure, NULL pointer is returned.
13184 */
13185 static sata_pkt_t *
sata_pkt_alloc(sata_pkt_txlate_t * spx,int (* callback)(caddr_t))13186 sata_pkt_alloc(sata_pkt_txlate_t *spx, int (*callback)(caddr_t))
13187 {
13188 sata_pkt_t *spkt;
13189 int kmsflag;
13190
13191 kmsflag = (callback == SLEEP_FUNC) ? KM_SLEEP : KM_NOSLEEP;
13192 spkt = kmem_zalloc(sizeof (sata_pkt_t), kmsflag);
13193 if (spkt == NULL) {
13194 SATA_LOG_D((spx->txlt_sata_hba_inst, CE_WARN,
13195 "sata_pkt_alloc: failed"));
13196 return (NULL);
13197 }
13198 spkt->satapkt_rev = SATA_PKT_REV;
13199 spkt->satapkt_cmd.satacmd_rev = SATA_CMD_REV;
13200 spkt->satapkt_device.satadev_rev = SATA_DEVICE_REV;
13201 spkt->satapkt_framework_private = spx;
13202 spx->txlt_sata_pkt = spkt;
13203 return (spkt);
13204 }
13205
13206 /*
13207 * Free sata pkt allocated via sata_pkt_alloc()
13208 */
13209 static void
sata_pkt_free(sata_pkt_txlate_t * spx)13210 sata_pkt_free(sata_pkt_txlate_t *spx)
13211 {
13212 ASSERT(spx->txlt_sata_pkt != NULL);
13213 ASSERT(spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp == NULL);
13214 kmem_free(spx->txlt_sata_pkt, sizeof (sata_pkt_t));
13215 spx->txlt_sata_pkt = NULL;
13216 }
13217
13218
13219 /*
13220 * Adjust DMA attributes.
13221 * SCSI cmds block count is up to 24 bits, SATA cmd block count vary
13222 * from 8 bits to 16 bits, depending on a command being used.
13223 * Limiting max block count arbitrarily to 256 for all read/write
13224 * commands may affects performance, so check both the device and
13225 * controller capability before adjusting dma attributes.
13226 */
13227 void
sata_adjust_dma_attr(sata_drive_info_t * sdinfo,ddi_dma_attr_t * dma_attr,ddi_dma_attr_t * adj_dma_attr)13228 sata_adjust_dma_attr(sata_drive_info_t *sdinfo, ddi_dma_attr_t *dma_attr,
13229 ddi_dma_attr_t *adj_dma_attr)
13230 {
13231 uint32_t count_max;
13232
13233 /* Copy original attributes */
13234 *adj_dma_attr = *dma_attr;
13235 /*
13236 * Things to consider: device addressing capability,
13237 * "excessive" controller DMA capabilities.
13238 * If a device is being probed/initialized, there are
13239 * no device info - use default limits then.
13240 */
13241 if (sdinfo == NULL) {
13242 count_max = dma_attr->dma_attr_granular * 0x100;
13243 if (dma_attr->dma_attr_count_max > count_max)
13244 adj_dma_attr->dma_attr_count_max = count_max;
13245 if (dma_attr->dma_attr_maxxfer > count_max)
13246 adj_dma_attr->dma_attr_maxxfer = count_max;
13247 return;
13248 }
13249
13250 if (sdinfo->satadrv_type == SATA_DTYPE_ATADISK) {
13251 if (sdinfo->satadrv_features_support & (SATA_DEV_F_LBA48)) {
13252 /*
13253 * 16-bit sector count may be used - we rely on
13254 * the assumption that only read and write cmds
13255 * will request more than 256 sectors worth of data
13256 */
13257 count_max = adj_dma_attr->dma_attr_granular * 0x10000;
13258 } else {
13259 /*
13260 * 8-bit sector count will be used - default limits
13261 * for dma attributes
13262 */
13263 count_max = adj_dma_attr->dma_attr_granular * 0x100;
13264 }
13265 /*
13266 * Adjust controler dma attributes, if necessary
13267 */
13268 if (dma_attr->dma_attr_count_max > count_max)
13269 adj_dma_attr->dma_attr_count_max = count_max;
13270 if (dma_attr->dma_attr_maxxfer > count_max)
13271 adj_dma_attr->dma_attr_maxxfer = count_max;
13272 }
13273 }
13274
13275
13276 /*
13277 * Allocate DMA resources for the buffer
13278 * This function handles initial DMA resource allocation as well as
13279 * DMA window shift and may be called repeatedly for the same DMA window
13280 * until all DMA cookies in the DMA window are processed.
13281 * To guarantee that there is always a coherent set of cookies to process
13282 * by SATA HBA driver (observing alignment, device granularity, etc.),
13283 * the number of slots for DMA cookies is equal to lesser of a number of
13284 * cookies in a DMA window and a max number of scatter/gather entries.
13285 *
13286 * Returns DDI_SUCCESS upon successful operation.
13287 * Return failure code of a failing command or DDI_FAILURE when
13288 * internal cleanup failed.
13289 */
13290 static int
sata_dma_buf_setup(sata_pkt_txlate_t * spx,int flags,int (* callback)(caddr_t),caddr_t arg,ddi_dma_attr_t * cur_dma_attr)13291 sata_dma_buf_setup(sata_pkt_txlate_t *spx, int flags,
13292 int (*callback)(caddr_t), caddr_t arg,
13293 ddi_dma_attr_t *cur_dma_attr)
13294 {
13295 int rval;
13296 off_t offset;
13297 size_t size;
13298 int max_sg_len, req_len, i;
13299 uint_t dma_flags;
13300 struct buf *bp;
13301 uint64_t cur_txfer_len;
13302
13303
13304 ASSERT(spx->txlt_sata_pkt != NULL);
13305 bp = spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp;
13306 ASSERT(bp != NULL);
13307
13308
13309 if (spx->txlt_buf_dma_handle == NULL) {
13310 /*
13311 * No DMA resources allocated so far - this is a first call
13312 * for this sata pkt.
13313 */
13314 rval = ddi_dma_alloc_handle(SATA_DIP(spx->txlt_sata_hba_inst),
13315 cur_dma_attr, callback, arg, &spx->txlt_buf_dma_handle);
13316
13317 if (rval != DDI_SUCCESS) {
13318 SATA_LOG_D((spx->txlt_sata_hba_inst, CE_WARN,
13319 "sata_dma_buf_setup: no buf DMA resources %x",
13320 rval));
13321 return (rval);
13322 }
13323
13324 if (bp->b_flags & B_READ)
13325 dma_flags = DDI_DMA_READ;
13326 else
13327 dma_flags = DDI_DMA_WRITE;
13328
13329 if (flags & PKT_CONSISTENT)
13330 dma_flags |= DDI_DMA_CONSISTENT;
13331
13332 if (flags & PKT_DMA_PARTIAL)
13333 dma_flags |= DDI_DMA_PARTIAL;
13334
13335 /*
13336 * Check buffer alignment and size against dma attributes
13337 * Consider dma_attr_align only. There may be requests
13338 * with the size lower than device granularity, but they
13339 * will not read/write from/to the device, so no adjustment
13340 * is necessary. The dma_attr_minxfer theoretically should
13341 * be considered, but no HBA driver is checking it.
13342 */
13343 if (IS_P2ALIGNED(bp->b_un.b_addr,
13344 cur_dma_attr->dma_attr_align)) {
13345 rval = ddi_dma_buf_bind_handle(
13346 spx->txlt_buf_dma_handle,
13347 bp, dma_flags, callback, arg,
13348 &spx->txlt_dma_cookie,
13349 &spx->txlt_curwin_num_dma_cookies);
13350 } else { /* Buffer is not aligned */
13351
13352 int (*ddicallback)(caddr_t);
13353 size_t bufsz;
13354
13355 /* Check id sleeping is allowed */
13356 ddicallback = (callback == NULL_FUNC) ?
13357 DDI_DMA_DONTWAIT : DDI_DMA_SLEEP;
13358
13359 SATADBG2(SATA_DBG_DMA_SETUP, spx->txlt_sata_hba_inst,
13360 "mis-aligned buffer: addr=0x%p, cnt=%lu",
13361 (void *)bp->b_un.b_addr, bp->b_bcount);
13362
13363 if (bp->b_flags & (B_PAGEIO|B_PHYS))
13364 /*
13365 * CPU will need to access data in the buffer
13366 * (for copying) so map it.
13367 */
13368 bp_mapin(bp);
13369
13370 ASSERT(spx->txlt_tmp_buf == NULL);
13371
13372 /* Buffer may be padded by ddi_dma_mem_alloc()! */
13373 rval = ddi_dma_mem_alloc(
13374 spx->txlt_buf_dma_handle,
13375 bp->b_bcount,
13376 &sata_acc_attr,
13377 DDI_DMA_STREAMING,
13378 ddicallback, NULL,
13379 &spx->txlt_tmp_buf,
13380 &bufsz,
13381 &spx->txlt_tmp_buf_handle);
13382
13383 if (rval != DDI_SUCCESS) {
13384 /* DMA mapping failed */
13385 (void) ddi_dma_free_handle(
13386 &spx->txlt_buf_dma_handle);
13387 spx->txlt_buf_dma_handle = NULL;
13388 #ifdef SATA_DEBUG
13389 mbuffail_count++;
13390 #endif
13391 SATADBG1(SATA_DBG_DMA_SETUP,
13392 spx->txlt_sata_hba_inst,
13393 "sata_dma_buf_setup: "
13394 "buf dma mem alloc failed %x\n", rval);
13395 return (rval);
13396 }
13397 ASSERT(IS_P2ALIGNED(spx->txlt_tmp_buf,
13398 cur_dma_attr->dma_attr_align));
13399
13400 #ifdef SATA_DEBUG
13401 mbuf_count++;
13402
13403 if (bp->b_bcount != bufsz)
13404 /*
13405 * This will require special handling, because
13406 * DMA cookies will be based on the temporary
13407 * buffer size, not the original buffer
13408 * b_bcount, so the residue may have to
13409 * be counted differently.
13410 */
13411 SATADBG2(SATA_DBG_DMA_SETUP,
13412 spx->txlt_sata_hba_inst,
13413 "sata_dma_buf_setup: bp size %x != "
13414 "bufsz %x\n", bp->b_bcount, bufsz);
13415 #endif
13416 if (dma_flags & DDI_DMA_WRITE) {
13417 /*
13418 * Write operation - copy data into
13419 * an aligned temporary buffer. Buffer will be
13420 * synced for device by ddi_dma_addr_bind_handle
13421 */
13422 bcopy(bp->b_un.b_addr, spx->txlt_tmp_buf,
13423 bp->b_bcount);
13424 }
13425
13426 rval = ddi_dma_addr_bind_handle(
13427 spx->txlt_buf_dma_handle,
13428 NULL,
13429 spx->txlt_tmp_buf,
13430 bufsz, dma_flags, ddicallback, 0,
13431 &spx->txlt_dma_cookie,
13432 &spx->txlt_curwin_num_dma_cookies);
13433 }
13434
13435 switch (rval) {
13436 case DDI_DMA_PARTIAL_MAP:
13437 SATADBG1(SATA_DBG_DMA_SETUP, spx->txlt_sata_hba_inst,
13438 "sata_dma_buf_setup: DMA Partial Map\n", NULL);
13439 /*
13440 * Partial DMA mapping.
13441 * Retrieve number of DMA windows for this request.
13442 */
13443 if (ddi_dma_numwin(spx->txlt_buf_dma_handle,
13444 &spx->txlt_num_dma_win) != DDI_SUCCESS) {
13445 if (spx->txlt_tmp_buf != NULL) {
13446 ddi_dma_mem_free(
13447 &spx->txlt_tmp_buf_handle);
13448 spx->txlt_tmp_buf = NULL;
13449 }
13450 (void) ddi_dma_unbind_handle(
13451 spx->txlt_buf_dma_handle);
13452 (void) ddi_dma_free_handle(
13453 &spx->txlt_buf_dma_handle);
13454 spx->txlt_buf_dma_handle = NULL;
13455 SATA_LOG_D((spx->txlt_sata_hba_inst, CE_WARN,
13456 "sata_dma_buf_setup: numwin failed\n"));
13457 return (DDI_FAILURE);
13458 }
13459 SATADBG2(SATA_DBG_DMA_SETUP,
13460 spx->txlt_sata_hba_inst,
13461 "sata_dma_buf_setup: windows: %d, cookies: %d\n",
13462 spx->txlt_num_dma_win,
13463 spx->txlt_curwin_num_dma_cookies);
13464 spx->txlt_cur_dma_win = 0;
13465 break;
13466
13467 case DDI_DMA_MAPPED:
13468 /* DMA fully mapped */
13469 spx->txlt_num_dma_win = 1;
13470 spx->txlt_cur_dma_win = 0;
13471 SATADBG1(SATA_DBG_DMA_SETUP,
13472 spx->txlt_sata_hba_inst,
13473 "sata_dma_buf_setup: windows: 1 "
13474 "cookies: %d\n", spx->txlt_curwin_num_dma_cookies);
13475 break;
13476
13477 default:
13478 /* DMA mapping failed */
13479 if (spx->txlt_tmp_buf != NULL) {
13480 ddi_dma_mem_free(
13481 &spx->txlt_tmp_buf_handle);
13482 spx->txlt_tmp_buf = NULL;
13483 }
13484 (void) ddi_dma_free_handle(&spx->txlt_buf_dma_handle);
13485 spx->txlt_buf_dma_handle = NULL;
13486 SATA_LOG_D((spx->txlt_sata_hba_inst, CE_WARN,
13487 "sata_dma_buf_setup: buf dma handle binding "
13488 "failed %x\n", rval));
13489 return (rval);
13490 }
13491 spx->txlt_curwin_processed_dma_cookies = 0;
13492 spx->txlt_dma_cookie_list = NULL;
13493 } else {
13494 /*
13495 * DMA setup is reused. Check if we need to process more
13496 * cookies in current window, or to get next window, if any.
13497 */
13498
13499 ASSERT(spx->txlt_curwin_processed_dma_cookies <=
13500 spx->txlt_curwin_num_dma_cookies);
13501
13502 if (spx->txlt_curwin_processed_dma_cookies ==
13503 spx->txlt_curwin_num_dma_cookies) {
13504 /*
13505 * All cookies from current DMA window were processed.
13506 * Get next DMA window.
13507 */
13508 spx->txlt_cur_dma_win++;
13509 if (spx->txlt_cur_dma_win < spx->txlt_num_dma_win) {
13510 (void) ddi_dma_getwin(spx->txlt_buf_dma_handle,
13511 spx->txlt_cur_dma_win, &offset, &size,
13512 &spx->txlt_dma_cookie,
13513 &spx->txlt_curwin_num_dma_cookies);
13514 spx->txlt_curwin_processed_dma_cookies = 0;
13515 } else {
13516 /* No more windows! End of request! */
13517 /* What to do? - panic for now */
13518 ASSERT(spx->txlt_cur_dma_win >=
13519 spx->txlt_num_dma_win);
13520
13521 spx->txlt_curwin_num_dma_cookies = 0;
13522 spx->txlt_curwin_processed_dma_cookies = 0;
13523 spx->txlt_sata_pkt->
13524 satapkt_cmd.satacmd_num_dma_cookies = 0;
13525 return (DDI_SUCCESS);
13526 }
13527 }
13528 }
13529 /* There better be at least one DMA cookie outstanding */
13530 ASSERT((spx->txlt_curwin_num_dma_cookies -
13531 spx->txlt_curwin_processed_dma_cookies) > 0);
13532
13533 if (spx->txlt_dma_cookie_list == &spx->txlt_dma_cookie) {
13534 /* The default cookie slot was used in previous run */
13535 ASSERT(spx->txlt_curwin_processed_dma_cookies == 0);
13536 spx->txlt_dma_cookie_list = NULL;
13537 spx->txlt_dma_cookie_list_len = 0;
13538 }
13539 if (spx->txlt_curwin_processed_dma_cookies == 0) {
13540 /*
13541 * Processing a new DMA window - set-up dma cookies list.
13542 * We may reuse previously allocated cookie array if it is
13543 * possible.
13544 */
13545 if (spx->txlt_dma_cookie_list != NULL &&
13546 spx->txlt_dma_cookie_list_len <
13547 spx->txlt_curwin_num_dma_cookies) {
13548 /*
13549 * New DMA window contains more cookies than
13550 * the previous one. We need larger cookie list - free
13551 * the old one.
13552 */
13553 (void) kmem_free(spx->txlt_dma_cookie_list,
13554 spx->txlt_dma_cookie_list_len *
13555 sizeof (ddi_dma_cookie_t));
13556 spx->txlt_dma_cookie_list = NULL;
13557 spx->txlt_dma_cookie_list_len = 0;
13558 }
13559 if (spx->txlt_dma_cookie_list == NULL) {
13560 /*
13561 * Calculate lesser of number of cookies in this
13562 * DMA window and number of s/g entries.
13563 */
13564 max_sg_len = cur_dma_attr->dma_attr_sgllen;
13565 req_len = MIN(max_sg_len,
13566 spx->txlt_curwin_num_dma_cookies);
13567
13568 /* Allocate new dma cookie array if necessary */
13569 if (req_len == 1) {
13570 /* Only one cookie - no need for a list */
13571 spx->txlt_dma_cookie_list =
13572 &spx->txlt_dma_cookie;
13573 spx->txlt_dma_cookie_list_len = 1;
13574 } else {
13575 /*
13576 * More than one cookie - try to allocate space.
13577 */
13578 spx->txlt_dma_cookie_list = kmem_zalloc(
13579 sizeof (ddi_dma_cookie_t) * req_len,
13580 callback == NULL_FUNC ? KM_NOSLEEP :
13581 KM_SLEEP);
13582 if (spx->txlt_dma_cookie_list == NULL) {
13583 SATADBG1(SATA_DBG_DMA_SETUP,
13584 spx->txlt_sata_hba_inst,
13585 "sata_dma_buf_setup: cookie list "
13586 "allocation failed\n", NULL);
13587 /*
13588 * We could not allocate space for
13589 * neccessary number of dma cookies in
13590 * this window, so we fail this request.
13591 * Next invocation would try again to
13592 * allocate space for cookie list.
13593 * Note:Packet residue was not modified.
13594 */
13595 return (DDI_DMA_NORESOURCES);
13596 } else {
13597 spx->txlt_dma_cookie_list_len = req_len;
13598 }
13599 }
13600 }
13601 /*
13602 * Fetch DMA cookies into cookie list in sata_pkt_txlate.
13603 * First cookie was already fetched.
13604 */
13605 *(&spx->txlt_dma_cookie_list[0]) = spx->txlt_dma_cookie;
13606 cur_txfer_len =
13607 (uint64_t)spx->txlt_dma_cookie_list[0].dmac_size;
13608 spx->txlt_sata_pkt->satapkt_cmd.satacmd_num_dma_cookies = 1;
13609 spx->txlt_curwin_processed_dma_cookies++;
13610 for (i = 1; (i < spx->txlt_dma_cookie_list_len) &&
13611 (i < spx->txlt_curwin_num_dma_cookies); i++) {
13612 ddi_dma_nextcookie(spx->txlt_buf_dma_handle,
13613 &spx->txlt_dma_cookie_list[i]);
13614 cur_txfer_len +=
13615 (uint64_t)spx->txlt_dma_cookie_list[i].dmac_size;
13616 spx->txlt_curwin_processed_dma_cookies++;
13617 spx->txlt_sata_pkt->
13618 satapkt_cmd.satacmd_num_dma_cookies += 1;
13619 }
13620 } else {
13621 SATADBG2(SATA_DBG_DMA_SETUP, spx->txlt_sata_hba_inst,
13622 "sata_dma_buf_setup: sliding within DMA window, "
13623 "cur cookie %d, total cookies %d\n",
13624 spx->txlt_curwin_processed_dma_cookies,
13625 spx->txlt_curwin_num_dma_cookies);
13626
13627 /*
13628 * Not all cookies from the current dma window were used because
13629 * of s/g limitation.
13630 * There is no need to re-size the list - it was set at
13631 * optimal size, or only default entry is used (s/g = 1).
13632 */
13633 if (spx->txlt_dma_cookie_list == NULL) {
13634 spx->txlt_dma_cookie_list = &spx->txlt_dma_cookie;
13635 spx->txlt_dma_cookie_list_len = 1;
13636 }
13637 /*
13638 * Since we are processing remaining cookies in a DMA window,
13639 * there may be less of them than the number of entries in the
13640 * current dma cookie list.
13641 */
13642 req_len = MIN(spx->txlt_dma_cookie_list_len,
13643 (spx->txlt_curwin_num_dma_cookies -
13644 spx->txlt_curwin_processed_dma_cookies));
13645
13646 /* Fetch the next batch of cookies */
13647 for (i = 0, cur_txfer_len = 0; i < req_len; i++) {
13648 ddi_dma_nextcookie(spx->txlt_buf_dma_handle,
13649 &spx->txlt_dma_cookie_list[i]);
13650 cur_txfer_len +=
13651 (uint64_t)spx->txlt_dma_cookie_list[i].dmac_size;
13652 spx->txlt_sata_pkt->
13653 satapkt_cmd.satacmd_num_dma_cookies++;
13654 spx->txlt_curwin_processed_dma_cookies++;
13655 }
13656 }
13657
13658 ASSERT(spx->txlt_sata_pkt->satapkt_cmd.satacmd_num_dma_cookies > 0);
13659
13660 /* Point sata_cmd to the cookie list */
13661 spx->txlt_sata_pkt->satapkt_cmd.satacmd_dma_cookie_list =
13662 &spx->txlt_dma_cookie_list[0];
13663
13664 /* Remember number of DMA cookies passed in sata packet */
13665 spx->txlt_num_dma_cookies =
13666 spx->txlt_sata_pkt->satapkt_cmd.satacmd_num_dma_cookies;
13667
13668 ASSERT(cur_txfer_len != 0);
13669 if (cur_txfer_len <= bp->b_bcount)
13670 spx->txlt_total_residue -= cur_txfer_len;
13671 else {
13672 /*
13673 * Temporary DMA buffer has been padded by
13674 * ddi_dma_mem_alloc()!
13675 * This requires special handling, because DMA cookies are
13676 * based on the temporary buffer size, not the b_bcount,
13677 * and we have extra bytes to transfer - but the packet
13678 * residue has to stay correct because we will copy only
13679 * the requested number of bytes.
13680 */
13681 spx->txlt_total_residue -= bp->b_bcount;
13682 }
13683
13684 return (DDI_SUCCESS);
13685 }
13686
13687 /*
13688 * Common routine for releasing DMA resources
13689 */
13690 static void
sata_common_free_dma_rsrcs(sata_pkt_txlate_t * spx)13691 sata_common_free_dma_rsrcs(sata_pkt_txlate_t *spx)
13692 {
13693 if (spx->txlt_buf_dma_handle != NULL) {
13694 if (spx->txlt_tmp_buf != NULL) {
13695 /*
13696 * Intermediate DMA buffer was allocated.
13697 * Free allocated buffer and associated access handle.
13698 */
13699 ddi_dma_mem_free(&spx->txlt_tmp_buf_handle);
13700 spx->txlt_tmp_buf = NULL;
13701 }
13702 /*
13703 * Free DMA resources - cookies and handles
13704 */
13705 /* ASSERT(spx->txlt_dma_cookie_list != NULL); */
13706 if (spx->txlt_dma_cookie_list != NULL) {
13707 if (spx->txlt_dma_cookie_list !=
13708 &spx->txlt_dma_cookie) {
13709 (void) kmem_free(spx->txlt_dma_cookie_list,
13710 spx->txlt_dma_cookie_list_len *
13711 sizeof (ddi_dma_cookie_t));
13712 spx->txlt_dma_cookie_list = NULL;
13713 }
13714 }
13715 (void) ddi_dma_unbind_handle(spx->txlt_buf_dma_handle);
13716 (void) ddi_dma_free_handle(&spx->txlt_buf_dma_handle);
13717 spx->txlt_buf_dma_handle = NULL;
13718 }
13719 }
13720
13721 /*
13722 * Free DMA resources
13723 * Used by the HBA driver to release DMA resources that it does not use.
13724 *
13725 * Returns Void
13726 */
13727 void
sata_free_dma_resources(sata_pkt_t * sata_pkt)13728 sata_free_dma_resources(sata_pkt_t *sata_pkt)
13729 {
13730 sata_pkt_txlate_t *spx;
13731
13732 if (sata_pkt == NULL)
13733 return;
13734
13735 spx = (sata_pkt_txlate_t *)sata_pkt->satapkt_framework_private;
13736
13737 sata_common_free_dma_rsrcs(spx);
13738 }
13739
13740 /*
13741 * Fetch Device Identify data.
13742 * Send DEVICE IDENTIFY or IDENTIFY PACKET DEVICE (depending on a device type)
13743 * command to a device and get the device identify data.
13744 * The device_info structure has to be set to device type (for selecting proper
13745 * device identify command).
13746 *
13747 * Returns:
13748 * SATA_SUCCESS if cmd succeeded
13749 * SATA_RETRY if cmd was rejected and could be retried,
13750 * SATA_FAILURE if cmd failed and should not be retried (port error)
13751 *
13752 * Cannot be called in an interrupt context.
13753 */
13754
13755 static int
sata_fetch_device_identify_data(sata_hba_inst_t * sata_hba_inst,sata_drive_info_t * sdinfo)13756 sata_fetch_device_identify_data(sata_hba_inst_t *sata_hba_inst,
13757 sata_drive_info_t *sdinfo)
13758 {
13759 struct buf *bp;
13760 sata_pkt_t *spkt;
13761 sata_cmd_t *scmd;
13762 sata_pkt_txlate_t *spx;
13763 int rval;
13764 dev_info_t *dip = SATA_DIP(sata_hba_inst);
13765
13766 spx = kmem_zalloc(sizeof (sata_pkt_txlate_t), KM_SLEEP);
13767 spx->txlt_sata_hba_inst = sata_hba_inst;
13768 spx->txlt_scsi_pkt = NULL; /* No scsi pkt involved */
13769 spkt = sata_pkt_alloc(spx, SLEEP_FUNC);
13770 if (spkt == NULL) {
13771 kmem_free(spx, sizeof (sata_pkt_txlate_t));
13772 return (SATA_RETRY); /* may retry later */
13773 }
13774 /* address is needed now */
13775 spkt->satapkt_device.satadev_addr = sdinfo->satadrv_addr;
13776
13777 /*
13778 * Allocate buffer for Identify Data return data
13779 */
13780 bp = sata_alloc_local_buffer(spx, sizeof (sata_id_t));
13781 if (bp == NULL) {
13782 sata_pkt_free(spx);
13783 kmem_free(spx, sizeof (sata_pkt_txlate_t));
13784 SATA_LOG_D((sata_hba_inst, CE_WARN,
13785 "sata_fetch_device_identify_data: "
13786 "cannot allocate buffer for ID"));
13787 return (SATA_RETRY); /* may retry later */
13788 }
13789
13790 /* Fill sata_pkt */
13791 sdinfo->satadrv_state = SATA_STATE_PROBING;
13792 spkt->satapkt_device.satadev_addr = sdinfo->satadrv_addr;
13793 spkt->satapkt_op_mode = SATA_OPMODE_SYNCH | SATA_OPMODE_INTERRUPTS;
13794 /* Synchronous mode, no callback */
13795 spkt->satapkt_comp = NULL;
13796 /* Timeout 30s */
13797 spkt->satapkt_time = sata_default_pkt_time;
13798
13799 scmd = &spkt->satapkt_cmd;
13800 scmd->satacmd_bp = bp;
13801 scmd->satacmd_flags.sata_data_direction = SATA_DIR_READ;
13802 scmd->satacmd_flags.sata_ignore_dev_reset = B_TRUE;
13803
13804 /* Build Identify Device cmd in the sata_pkt */
13805 scmd->satacmd_addr_type = 0; /* N/A */
13806 scmd->satacmd_sec_count_lsb = 0; /* N/A */
13807 scmd->satacmd_lba_low_lsb = 0; /* N/A */
13808 scmd->satacmd_lba_mid_lsb = 0; /* N/A */
13809 scmd->satacmd_lba_high_lsb = 0; /* N/A */
13810 scmd->satacmd_features_reg = 0; /* N/A */
13811 scmd->satacmd_device_reg = 0; /* Always device 0 */
13812 if (sdinfo->satadrv_type & SATA_DTYPE_ATAPI) {
13813 /* Identify Packet Device cmd */
13814 scmd->satacmd_cmd_reg = SATAC_ID_PACKET_DEVICE;
13815 } else {
13816 /* Identify Device cmd - mandatory for all other devices */
13817 scmd->satacmd_cmd_reg = SATAC_ID_DEVICE;
13818 }
13819
13820 /* Send pkt to SATA HBA driver */
13821 rval = (*SATA_START_FUNC(sata_hba_inst))(SATA_DIP(sata_hba_inst), spkt);
13822
13823 #ifdef SATA_INJECT_FAULTS
13824 sata_inject_pkt_fault(spkt, &rval, sata_fault_type);
13825 #endif
13826
13827 if (rval == SATA_TRAN_ACCEPTED &&
13828 spkt->satapkt_reason == SATA_PKT_COMPLETED) {
13829 if (spx->txlt_buf_dma_handle != NULL) {
13830 rval = ddi_dma_sync(spx->txlt_buf_dma_handle, 0, 0,
13831 DDI_DMA_SYNC_FORKERNEL);
13832 ASSERT(rval == DDI_SUCCESS);
13833 if (sata_check_for_dma_error(dip, spx)) {
13834 ddi_fm_service_impact(dip,
13835 DDI_SERVICE_UNAFFECTED);
13836 rval = SATA_RETRY;
13837 goto fail;
13838 }
13839
13840 }
13841 if ((((sata_id_t *)(bp->b_un.b_addr))->ai_config &
13842 SATA_INCOMPLETE_DATA) == SATA_INCOMPLETE_DATA) {
13843 SATA_LOG_D((sata_hba_inst, CE_WARN,
13844 "SATA disk device at port %d - "
13845 "partial Identify Data",
13846 sdinfo->satadrv_addr.cport));
13847 rval = SATA_RETRY; /* may retry later */
13848 goto fail;
13849 }
13850 /* Update sata_drive_info */
13851 bcopy(bp->b_un.b_addr, &sdinfo->satadrv_id,
13852 sizeof (sata_id_t));
13853
13854 sdinfo->satadrv_features_support = 0;
13855 if (sdinfo->satadrv_type == SATA_DTYPE_ATADISK) {
13856 /*
13857 * Retrieve capacity (disks only) and addressing mode
13858 */
13859 sdinfo->satadrv_capacity = sata_check_capacity(sdinfo);
13860 } else {
13861 /*
13862 * For ATAPI devices one would have to issue
13863 * Get Capacity cmd for media capacity. Not here.
13864 */
13865 sdinfo->satadrv_capacity = 0;
13866 /*
13867 * Check what cdb length is supported
13868 */
13869 if ((sdinfo->satadrv_id.ai_config &
13870 SATA_ATAPI_ID_PKT_SZ) == SATA_ATAPI_ID_PKT_16B)
13871 sdinfo->satadrv_atapi_cdb_len = 16;
13872 else
13873 sdinfo->satadrv_atapi_cdb_len = 12;
13874 }
13875 /* Setup supported features flags */
13876 if (sdinfo->satadrv_id.ai_cap & SATA_DMA_SUPPORT)
13877 sdinfo->satadrv_features_support |= SATA_DEV_F_DMA;
13878
13879 /* Check for SATA GEN and NCQ support */
13880 if (sdinfo->satadrv_id.ai_satacap != 0 &&
13881 sdinfo->satadrv_id.ai_satacap != 0xffff) {
13882 /* SATA compliance */
13883 if (sdinfo->satadrv_id.ai_satacap & SATA_NCQ)
13884 sdinfo->satadrv_features_support |=
13885 SATA_DEV_F_NCQ;
13886 if (sdinfo->satadrv_id.ai_satacap &
13887 (SATA_1_SPEED | SATA_2_SPEED | SATA_3_SPEED)) {
13888 if (sdinfo->satadrv_id.ai_satacap &
13889 SATA_3_SPEED)
13890 sdinfo->satadrv_features_support |=
13891 SATA_DEV_F_SATA3;
13892 if (sdinfo->satadrv_id.ai_satacap &
13893 SATA_2_SPEED)
13894 sdinfo->satadrv_features_support |=
13895 SATA_DEV_F_SATA2;
13896 if (sdinfo->satadrv_id.ai_satacap &
13897 SATA_1_SPEED)
13898 sdinfo->satadrv_features_support |=
13899 SATA_DEV_F_SATA1;
13900 } else {
13901 sdinfo->satadrv_features_support |=
13902 SATA_DEV_F_SATA1;
13903 }
13904 }
13905 if ((sdinfo->satadrv_id.ai_cmdset83 & SATA_RW_DMA_QUEUED_CMD) &&
13906 (sdinfo->satadrv_id.ai_features86 & SATA_RW_DMA_QUEUED_CMD))
13907 sdinfo->satadrv_features_support |= SATA_DEV_F_TCQ;
13908
13909 sdinfo->satadrv_queue_depth = sdinfo->satadrv_id.ai_qdepth;
13910 if ((sdinfo->satadrv_features_support & SATA_DEV_F_NCQ) ||
13911 (sdinfo->satadrv_features_support & SATA_DEV_F_TCQ)) {
13912 ++sdinfo->satadrv_queue_depth;
13913 /* Adjust according to controller capabilities */
13914 sdinfo->satadrv_max_queue_depth = MIN(
13915 sdinfo->satadrv_queue_depth,
13916 SATA_QDEPTH(sata_hba_inst));
13917 /* Adjust according to global queue depth limit */
13918 sdinfo->satadrv_max_queue_depth = MIN(
13919 sdinfo->satadrv_max_queue_depth,
13920 sata_current_max_qdepth);
13921 if (sdinfo->satadrv_max_queue_depth == 0)
13922 sdinfo->satadrv_max_queue_depth = 1;
13923 } else
13924 sdinfo->satadrv_max_queue_depth = 1;
13925
13926 rval = SATA_SUCCESS;
13927 } else {
13928 /*
13929 * Woops, no Identify Data.
13930 */
13931 if (rval == SATA_TRAN_BUSY || rval == SATA_TRAN_QUEUE_FULL) {
13932 rval = SATA_RETRY; /* may retry later */
13933 } else if (rval == SATA_TRAN_ACCEPTED) {
13934 if (spkt->satapkt_reason == SATA_PKT_DEV_ERROR ||
13935 spkt->satapkt_reason == SATA_PKT_ABORTED ||
13936 spkt->satapkt_reason == SATA_PKT_TIMEOUT ||
13937 spkt->satapkt_reason == SATA_PKT_RESET)
13938 rval = SATA_RETRY; /* may retry later */
13939 else
13940 rval = SATA_FAILURE;
13941 } else {
13942 rval = SATA_FAILURE;
13943 }
13944 }
13945 fail:
13946 /* Free allocated resources */
13947 sata_free_local_buffer(spx);
13948 sata_pkt_free(spx);
13949 kmem_free(spx, sizeof (sata_pkt_txlate_t));
13950
13951 return (rval);
13952 }
13953
13954
13955 /*
13956 * Some devices may not come-up with default DMA mode (UDMA or MWDMA).
13957 * UDMA mode is checked first, followed by MWDMA mode.
13958 * set correctly, so this function is setting it to the highest supported level.
13959 * Older SATA spec required that the device supports at least DMA 4 mode and
13960 * UDMA mode is selected. It is not mentioned in SerialATA 2.6, so this
13961 * restriction has been removed.
13962 *
13963 * Returns SATA_SUCCESS if proper DMA mode is selected or no DMA is supported.
13964 * Returns SATA_FAILURE if proper DMA mode could not be selected.
13965 *
13966 * NOTE: This function should be called only if DMA mode is supported.
13967 */
13968 static int
sata_set_dma_mode(sata_hba_inst_t * sata_hba_inst,sata_drive_info_t * sdinfo)13969 sata_set_dma_mode(sata_hba_inst_t *sata_hba_inst, sata_drive_info_t *sdinfo)
13970 {
13971 sata_pkt_t *spkt;
13972 sata_cmd_t *scmd;
13973 sata_pkt_txlate_t *spx;
13974 int i, mode;
13975 uint8_t subcmd;
13976 int rval = SATA_SUCCESS;
13977
13978 ASSERT(sdinfo != NULL);
13979 ASSERT(sata_hba_inst != NULL);
13980
13981 if ((sdinfo->satadrv_id.ai_validinfo & SATA_VALIDINFO_88) != 0 &&
13982 (sdinfo->satadrv_id.ai_ultradma & SATA_UDMA_SUP_MASK) != 0) {
13983 /* Find highest Ultra DMA mode supported */
13984 for (mode = 6; mode >= 0; --mode) {
13985 if (sdinfo->satadrv_id.ai_ultradma & (1 << mode))
13986 break;
13987 }
13988 #if 0
13989 /* Left for historical reasons */
13990 /*
13991 * Some initial version of SATA spec indicated that at least
13992 * UDMA mode 4 has to be supported. It is not mentioned in
13993 * SerialATA 2.6, so this restriction is removed.
13994 */
13995 if (mode < 4)
13996 return (SATA_FAILURE);
13997 #endif
13998
13999 /*
14000 * For disk, we're still going to set DMA mode whatever is
14001 * selected by default
14002 *
14003 * We saw an old maxtor sata drive will select Ultra DMA and
14004 * Multi-Word DMA simultaneouly by default, which is going
14005 * to cause DMA command timed out, so we need to select DMA
14006 * mode even when it's already done by default
14007 */
14008 if (sdinfo->satadrv_type != SATA_DTYPE_ATADISK) {
14009
14010 /* Find UDMA mode currently selected */
14011 for (i = 6; i >= 0; --i) {
14012 if (sdinfo->satadrv_id.ai_ultradma &
14013 (1 << (i + 8)))
14014 break;
14015 }
14016 if (i >= mode)
14017 /* Nothing to do */
14018 return (SATA_SUCCESS);
14019 }
14020
14021 subcmd = SATAC_TRANSFER_MODE_ULTRA_DMA;
14022
14023 } else if ((sdinfo->satadrv_id.ai_dworddma & SATA_MDMA_SUP_MASK) != 0) {
14024 /* Find highest MultiWord DMA mode supported */
14025 for (mode = 2; mode >= 0; --mode) {
14026 if (sdinfo->satadrv_id.ai_dworddma & (1 << mode))
14027 break;
14028 }
14029
14030 /*
14031 * For disk, We're still going to set DMA mode whatever is
14032 * selected by default
14033 *
14034 * We saw an old maxtor sata drive will select Ultra DMA and
14035 * Multi-Word DMA simultaneouly by default, which is going
14036 * to cause DMA command timed out, so we need to select DMA
14037 * mode even when it's already done by default
14038 */
14039 if (sdinfo->satadrv_type != SATA_DTYPE_ATADISK) {
14040
14041 /* Find highest MultiWord DMA mode selected */
14042 for (i = 2; i >= 0; --i) {
14043 if (sdinfo->satadrv_id.ai_dworddma &
14044 (1 << (i + 8)))
14045 break;
14046 }
14047 if (i >= mode)
14048 /* Nothing to do */
14049 return (SATA_SUCCESS);
14050 }
14051
14052 subcmd = SATAC_TRANSFER_MODE_MULTI_WORD_DMA;
14053 } else
14054 return (SATA_SUCCESS);
14055
14056 /*
14057 * Set DMA mode via SET FEATURES COMMAND.
14058 * Prepare packet for SET FEATURES COMMAND.
14059 */
14060 spx = kmem_zalloc(sizeof (sata_pkt_txlate_t), KM_SLEEP);
14061 spx->txlt_sata_hba_inst = sata_hba_inst;
14062 spx->txlt_scsi_pkt = NULL; /* No scsi pkt involved */
14063 spkt = sata_pkt_alloc(spx, SLEEP_FUNC);
14064 if (spkt == NULL) {
14065 SATA_LOG_D((sata_hba_inst, CE_WARN,
14066 "sata_set_dma_mode: could not set DMA mode %d", mode));
14067 rval = SATA_FAILURE;
14068 goto done;
14069 }
14070 /* Fill sata_pkt */
14071 spkt->satapkt_device.satadev_addr = sdinfo->satadrv_addr;
14072 /* Timeout 30s */
14073 spkt->satapkt_time = sata_default_pkt_time;
14074 /* Synchronous mode, no callback, interrupts */
14075 spkt->satapkt_op_mode = SATA_OPMODE_SYNCH | SATA_OPMODE_INTERRUPTS;
14076 spkt->satapkt_comp = NULL;
14077 scmd = &spkt->satapkt_cmd;
14078 scmd->satacmd_flags.sata_data_direction = SATA_DIR_NODATA_XFER;
14079 scmd->satacmd_flags.sata_ignore_dev_reset = B_TRUE;
14080 scmd->satacmd_addr_type = 0;
14081 scmd->satacmd_device_reg = 0;
14082 scmd->satacmd_status_reg = 0;
14083 scmd->satacmd_error_reg = 0;
14084 scmd->satacmd_cmd_reg = SATAC_SET_FEATURES;
14085 scmd->satacmd_features_reg = SATAC_SF_TRANSFER_MODE;
14086 scmd->satacmd_sec_count_lsb = subcmd | mode;
14087
14088 /* Transfer command to HBA */
14089 if ((*SATA_START_FUNC(sata_hba_inst))(SATA_DIP(sata_hba_inst),
14090 spkt) != SATA_TRAN_ACCEPTED ||
14091 spkt->satapkt_reason != SATA_PKT_COMPLETED) {
14092 /* Pkt execution failed */
14093 rval = SATA_FAILURE;
14094 }
14095 done:
14096
14097 /* Free allocated resources */
14098 if (spkt != NULL)
14099 sata_pkt_free(spx);
14100 (void) kmem_free(spx, sizeof (sata_pkt_txlate_t));
14101
14102 return (rval);
14103 }
14104
14105
14106 /*
14107 * Set device caching mode.
14108 * One of the following operations should be specified:
14109 * SATAC_SF_ENABLE_READ_AHEAD
14110 * SATAC_SF_DISABLE_READ_AHEAD
14111 * SATAC_SF_ENABLE_WRITE_CACHE
14112 * SATAC_SF_DISABLE_WRITE_CACHE
14113 *
14114 * If operation fails, system log messgage is emitted.
14115 * Returns SATA_SUCCESS when the operation succeeds, SATA_RETRY if
14116 * command was sent but did not succeed, and SATA_FAILURE otherwise.
14117 */
14118
14119 static int
sata_set_cache_mode(sata_hba_inst_t * sata_hba_inst,sata_drive_info_t * sdinfo,int cache_op)14120 sata_set_cache_mode(sata_hba_inst_t *sata_hba_inst, sata_drive_info_t *sdinfo,
14121 int cache_op)
14122 {
14123 sata_pkt_t *spkt;
14124 sata_cmd_t *scmd;
14125 sata_pkt_txlate_t *spx;
14126 int rval = SATA_SUCCESS;
14127 int hba_rval;
14128 char *infop = NULL;
14129
14130 ASSERT(sdinfo != NULL);
14131 ASSERT(sata_hba_inst != NULL);
14132 ASSERT(cache_op == SATAC_SF_ENABLE_READ_AHEAD ||
14133 cache_op == SATAC_SF_DISABLE_READ_AHEAD ||
14134 cache_op == SATAC_SF_ENABLE_WRITE_CACHE ||
14135 cache_op == SATAC_SF_DISABLE_WRITE_CACHE);
14136
14137
14138 /* Prepare packet for SET FEATURES COMMAND */
14139 spx = kmem_zalloc(sizeof (sata_pkt_txlate_t), KM_SLEEP);
14140 spx->txlt_sata_hba_inst = sata_hba_inst;
14141 spx->txlt_scsi_pkt = NULL; /* No scsi pkt involved */
14142 spkt = sata_pkt_alloc(spx, SLEEP_FUNC);
14143 if (spkt == NULL) {
14144 rval = SATA_FAILURE;
14145 goto failure;
14146 }
14147 /* Fill sata_pkt */
14148 spkt->satapkt_device.satadev_addr = sdinfo->satadrv_addr;
14149 /* Timeout 30s */
14150 spkt->satapkt_time = sata_default_pkt_time;
14151 /* Synchronous mode, no callback, interrupts */
14152 spkt->satapkt_op_mode =
14153 SATA_OPMODE_SYNCH | SATA_OPMODE_INTERRUPTS;
14154 spkt->satapkt_comp = NULL;
14155 scmd = &spkt->satapkt_cmd;
14156 scmd->satacmd_flags.sata_data_direction = SATA_DIR_NODATA_XFER;
14157 scmd->satacmd_flags.sata_ignore_dev_reset = B_TRUE;
14158 scmd->satacmd_addr_type = 0;
14159 scmd->satacmd_device_reg = 0;
14160 scmd->satacmd_status_reg = 0;
14161 scmd->satacmd_error_reg = 0;
14162 scmd->satacmd_cmd_reg = SATAC_SET_FEATURES;
14163 scmd->satacmd_features_reg = cache_op;
14164
14165 /* Transfer command to HBA */
14166 hba_rval = (*SATA_START_FUNC(sata_hba_inst))(
14167 SATA_DIP(sata_hba_inst), spkt);
14168
14169 #ifdef SATA_INJECT_FAULTS
14170 sata_inject_pkt_fault(spkt, &rval, sata_fault_type);
14171 #endif
14172
14173 if ((hba_rval != SATA_TRAN_ACCEPTED) ||
14174 (spkt->satapkt_reason != SATA_PKT_COMPLETED)) {
14175 /* Pkt execution failed */
14176 switch (cache_op) {
14177 case SATAC_SF_ENABLE_READ_AHEAD:
14178 infop = "enabling read ahead failed";
14179 break;
14180 case SATAC_SF_DISABLE_READ_AHEAD:
14181 infop = "disabling read ahead failed";
14182 break;
14183 case SATAC_SF_ENABLE_WRITE_CACHE:
14184 infop = "enabling write cache failed";
14185 break;
14186 case SATAC_SF_DISABLE_WRITE_CACHE:
14187 infop = "disabling write cache failed";
14188 break;
14189 }
14190 SATA_LOG_D((sata_hba_inst, CE_WARN, "%s", infop));
14191 rval = SATA_RETRY;
14192 }
14193 failure:
14194 /* Free allocated resources */
14195 if (spkt != NULL)
14196 sata_pkt_free(spx);
14197 (void) kmem_free(spx, sizeof (sata_pkt_txlate_t));
14198 return (rval);
14199 }
14200
14201 /*
14202 * Set Removable Media Status Notification (enable/disable)
14203 * state == 0 , disable
14204 * state != 0 , enable
14205 *
14206 * If operation fails, system log messgage is emitted.
14207 * Returns SATA_SUCCESS when the operation succeeds, SATA_FAILURE otherwise.
14208 */
14209
14210 static int
sata_set_rmsn(sata_hba_inst_t * sata_hba_inst,sata_drive_info_t * sdinfo,int state)14211 sata_set_rmsn(sata_hba_inst_t *sata_hba_inst, sata_drive_info_t *sdinfo,
14212 int state)
14213 {
14214 sata_pkt_t *spkt;
14215 sata_cmd_t *scmd;
14216 sata_pkt_txlate_t *spx;
14217 int rval = SATA_SUCCESS;
14218 char *infop;
14219
14220 ASSERT(sdinfo != NULL);
14221 ASSERT(sata_hba_inst != NULL);
14222
14223 /* Prepare packet for SET FEATURES COMMAND */
14224 spx = kmem_zalloc(sizeof (sata_pkt_txlate_t), KM_SLEEP);
14225 spx->txlt_sata_hba_inst = sata_hba_inst;
14226 spx->txlt_scsi_pkt = NULL; /* No scsi pkt involved */
14227 spkt = sata_pkt_alloc(spx, SLEEP_FUNC);
14228 if (spkt == NULL) {
14229 rval = SATA_FAILURE;
14230 goto failure;
14231 }
14232 /* Fill sata_pkt */
14233 spkt->satapkt_device.satadev_addr = sdinfo->satadrv_addr;
14234 /* Timeout 30s */
14235 spkt->satapkt_time = sata_default_pkt_time;
14236 /* Synchronous mode, no callback, interrupts */
14237 spkt->satapkt_op_mode =
14238 SATA_OPMODE_SYNCH | SATA_OPMODE_INTERRUPTS;
14239 spkt->satapkt_comp = NULL;
14240 scmd = &spkt->satapkt_cmd;
14241 scmd->satacmd_flags.sata_data_direction = SATA_DIR_NODATA_XFER;
14242 scmd->satacmd_flags.sata_ignore_dev_reset = B_TRUE;
14243 scmd->satacmd_addr_type = 0;
14244 scmd->satacmd_device_reg = 0;
14245 scmd->satacmd_status_reg = 0;
14246 scmd->satacmd_error_reg = 0;
14247 scmd->satacmd_cmd_reg = SATAC_SET_FEATURES;
14248 if (state == 0)
14249 scmd->satacmd_features_reg = SATAC_SF_DISABLE_RMSN;
14250 else
14251 scmd->satacmd_features_reg = SATAC_SF_ENABLE_RMSN;
14252
14253 /* Transfer command to HBA */
14254 if (((*SATA_START_FUNC(sata_hba_inst))(
14255 SATA_DIP(sata_hba_inst), spkt) != SATA_TRAN_ACCEPTED) ||
14256 (spkt->satapkt_reason != SATA_PKT_COMPLETED)) {
14257 /* Pkt execution failed */
14258 if (state == 0)
14259 infop = "disabling Removable Media Status "
14260 "Notification failed";
14261 else
14262 infop = "enabling Removable Media Status "
14263 "Notification failed";
14264
14265 SATA_LOG_D((sata_hba_inst, CE_WARN, "%s", infop));
14266 rval = SATA_FAILURE;
14267 }
14268 failure:
14269 /* Free allocated resources */
14270 if (spkt != NULL)
14271 sata_pkt_free(spx);
14272 (void) kmem_free(spx, sizeof (sata_pkt_txlate_t));
14273 return (rval);
14274 }
14275
14276
14277 /*
14278 * Update state and copy port ss* values from passed sata_device structure.
14279 * sata_address is validated - if not valid, nothing is changed in sata_scsi
14280 * configuration struct.
14281 *
14282 * SATA_PSTATE_SHUTDOWN in port state is not reset to 0 by this function
14283 * regardless of the state in device argument.
14284 *
14285 * Port mutex should be held while calling this function.
14286 */
14287 static void
sata_update_port_info(sata_hba_inst_t * sata_hba_inst,sata_device_t * sata_device)14288 sata_update_port_info(sata_hba_inst_t *sata_hba_inst,
14289 sata_device_t *sata_device)
14290 {
14291 sata_cport_info_t *cportinfo;
14292
14293 if (sata_device->satadev_addr.qual == SATA_ADDR_CPORT ||
14294 sata_device->satadev_addr.qual == SATA_ADDR_DCPORT) {
14295 if (SATA_NUM_CPORTS(sata_hba_inst) <=
14296 sata_device->satadev_addr.cport)
14297 return;
14298
14299 cportinfo = SATA_CPORT_INFO(sata_hba_inst,
14300 sata_device->satadev_addr.cport);
14301
14302 ASSERT(mutex_owned(&cportinfo->cport_mutex));
14303 cportinfo->cport_scr = sata_device->satadev_scr;
14304
14305 /* Preserve SATA_PSTATE_SHUTDOWN flag */
14306 cportinfo->cport_state &= ~(SATA_PSTATE_PWRON |
14307 SATA_PSTATE_PWROFF | SATA_PSTATE_FAILED);
14308 cportinfo->cport_state |=
14309 sata_device->satadev_state & SATA_PSTATE_VALID;
14310 }
14311 }
14312
14313 void
sata_update_pmport_info(sata_hba_inst_t * sata_hba_inst,sata_device_t * sata_device)14314 sata_update_pmport_info(sata_hba_inst_t *sata_hba_inst,
14315 sata_device_t *sata_device)
14316 {
14317 sata_pmport_info_t *pmportinfo;
14318
14319 if ((sata_device->satadev_addr.qual != SATA_ADDR_PMPORT &&
14320 sata_device->satadev_addr.qual != SATA_ADDR_DPMPORT) ||
14321 SATA_NUM_PMPORTS(sata_hba_inst,
14322 sata_device->satadev_addr.cport) <
14323 sata_device->satadev_addr.pmport) {
14324 SATADBG1(SATA_DBG_PMULT, sata_hba_inst,
14325 "sata_update_port_info: error address %p.",
14326 &sata_device->satadev_addr);
14327 return;
14328 }
14329
14330 pmportinfo = SATA_PMPORT_INFO(sata_hba_inst,
14331 sata_device->satadev_addr.cport,
14332 sata_device->satadev_addr.pmport);
14333
14334 ASSERT(mutex_owned(&pmportinfo->pmport_mutex));
14335 pmportinfo->pmport_scr = sata_device->satadev_scr;
14336
14337 /* Preserve SATA_PSTATE_SHUTDOWN flag */
14338 pmportinfo->pmport_state &=
14339 ~(SATA_PSTATE_PWRON | SATA_PSTATE_PWROFF | SATA_PSTATE_FAILED);
14340 pmportinfo->pmport_state |=
14341 sata_device->satadev_state & SATA_PSTATE_VALID;
14342 }
14343
14344 /*
14345 * Extract SATA port specification from an IOCTL argument.
14346 *
14347 * This function return the port the user land send us as is, unless it
14348 * cannot retrieve port spec, then -1 is returned.
14349 *
14350 * Support port multiplier.
14351 */
14352 static int32_t
sata_get_port_num(sata_hba_inst_t * sata_hba_inst,struct devctl_iocdata * dcp)14353 sata_get_port_num(sata_hba_inst_t *sata_hba_inst, struct devctl_iocdata *dcp)
14354 {
14355 int32_t port;
14356
14357 /* Extract port number from nvpair in dca structure */
14358 if (nvlist_lookup_int32(ndi_dc_get_ap_data(dcp), "port", &port) != 0) {
14359 SATA_LOG_D((sata_hba_inst, CE_NOTE,
14360 "sata_get_port_num: invalid port spec 0x%x in ioctl",
14361 port));
14362 port = -1;
14363 }
14364
14365 return (port);
14366 }
14367
14368 /*
14369 * Get dev_info_t pointer to the device node pointed to by port argument.
14370 * NOTE: target argument is a value used in ioctls to identify
14371 * the AP - it is not a sata_address.
14372 * It is a combination of cport, pmport and address qualifier, encodded same
14373 * way as a scsi target number.
14374 * At this moment it carries only cport number.
14375 *
14376 * PMult hotplug is supported now.
14377 *
14378 * Returns dev_info_t pointer if target device was found, NULL otherwise.
14379 */
14380
14381 static dev_info_t *
sata_get_target_dip(dev_info_t * dip,uint8_t cport,uint8_t pmport)14382 sata_get_target_dip(dev_info_t *dip, uint8_t cport, uint8_t pmport)
14383 {
14384 dev_info_t *cdip = NULL;
14385 int target, tgt;
14386 uint8_t qual;
14387
14388 sata_hba_inst_t *sata_hba_inst;
14389 scsi_hba_tran_t *scsi_hba_tran;
14390
14391 /* Get target id */
14392 scsi_hba_tran = ddi_get_driver_private(dip);
14393 if (scsi_hba_tran == NULL)
14394 return (NULL);
14395
14396 sata_hba_inst = scsi_hba_tran->tran_hba_private;
14397
14398 if (sata_hba_inst == NULL)
14399 return (NULL);
14400
14401 /* Identify a port-mult by cport_info.cport_dev_type */
14402 if (SATA_CPORT_DEV_TYPE(sata_hba_inst, cport) == SATA_DTYPE_PMULT)
14403 qual = SATA_ADDR_DPMPORT;
14404 else
14405 qual = SATA_ADDR_DCPORT;
14406
14407 target = SATA_TO_SCSI_TARGET(cport, pmport, qual);
14408
14409 /* Retrieve target dip */
14410 ndi_devi_enter(dip);
14411 for (cdip = ddi_get_child(dip); cdip != NULL; ) {
14412 dev_info_t *next = ddi_get_next_sibling(cdip);
14413
14414 tgt = ddi_prop_get_int(DDI_DEV_T_ANY, cdip,
14415 DDI_PROP_DONTPASS, "target", -1);
14416 if (tgt == -1) {
14417 /*
14418 * This is actually an error condition, but not
14419 * a fatal one. Just continue the search.
14420 */
14421 cdip = next;
14422 continue;
14423 }
14424
14425 if (tgt == target)
14426 break;
14427
14428 cdip = next;
14429 }
14430 ndi_devi_exit(dip);
14431
14432 return (cdip);
14433 }
14434
14435 /*
14436 * Get dev_info_t pointer to the device node pointed to by port argument.
14437 * NOTE: target argument is a value used in ioctls to identify
14438 * the AP - it is not a sata_address.
14439 * It is a combination of cport, pmport and address qualifier, encoded same
14440 * way as a scsi target number.
14441 *
14442 * Returns dev_info_t pointer if target device was found, NULL otherwise.
14443 */
14444
14445 static dev_info_t *
sata_get_scsi_target_dip(dev_info_t * dip,sata_address_t * saddr)14446 sata_get_scsi_target_dip(dev_info_t *dip, sata_address_t *saddr)
14447 {
14448 dev_info_t *cdip = NULL;
14449 int target, tgt;
14450
14451 target = SATA_TO_SCSI_TARGET(saddr->cport, saddr->pmport, saddr->qual);
14452
14453 ndi_devi_enter(dip);
14454 for (cdip = ddi_get_child(dip); cdip != NULL; ) {
14455 dev_info_t *next = ddi_get_next_sibling(cdip);
14456
14457 tgt = ddi_prop_get_int(DDI_DEV_T_ANY, cdip,
14458 DDI_PROP_DONTPASS, "target", -1);
14459 if (tgt == -1) {
14460 /*
14461 * This is actually an error condition, but not
14462 * a fatal one. Just continue the search.
14463 */
14464 cdip = next;
14465 continue;
14466 }
14467
14468 if (tgt == target)
14469 break;
14470
14471 cdip = next;
14472 }
14473 ndi_devi_exit(dip);
14474
14475 return (cdip);
14476 }
14477
14478 /*
14479 * Process sata port disconnect request.
14480 * Normally, cfgadm sata plugin will try to offline (unconfigure) the device
14481 * before this request. Nevertheless, if a device is still configured,
14482 * we need to attempt to offline and unconfigure device.
14483 * Regardless of the unconfigure operation results the port is marked as
14484 * deactivated and no access to the attached device is possible.
14485 * If the target node remains because unconfigure operation failed, its state
14486 * will be set to DEVICE_REMOVED, preventing it to be used again when a device
14487 * is inserted/re-inserted. The event daemon will repeatedly try to unconfigure
14488 * the device and remove old target node.
14489 *
14490 * This function invokes sata_hba_inst->satahba_tran->
14491 * sata_tran_hotplug_ops->sata_tran_port_deactivate().
14492 * If successful, the device structure (if any) attached to the specified port
14493 * is removed and state of the port marked appropriately.
14494 * Failure of the port_deactivate may keep port in the physically active state,
14495 * or may fail the port.
14496 *
14497 * NOTE: Port multiplier is supported.
14498 */
14499
14500 static int
sata_ioctl_disconnect(sata_hba_inst_t * sata_hba_inst,sata_device_t * sata_device)14501 sata_ioctl_disconnect(sata_hba_inst_t *sata_hba_inst,
14502 sata_device_t *sata_device)
14503 {
14504 sata_drive_info_t *sdinfo = NULL, *subsdinfo = NULL;
14505 sata_cport_info_t *cportinfo = NULL;
14506 sata_pmport_info_t *pmportinfo = NULL;
14507 sata_pmult_info_t *pmultinfo = NULL;
14508 sata_device_t subsdevice;
14509 int cport, pmport, qual;
14510 int rval = SATA_SUCCESS;
14511 int npmport = 0;
14512 int rv = 0;
14513
14514 cport = sata_device->satadev_addr.cport;
14515 pmport = sata_device->satadev_addr.pmport;
14516 qual = sata_device->satadev_addr.qual;
14517
14518 ASSERT(qual == SATA_ADDR_DCPORT || qual == SATA_ADDR_DPMPORT);
14519 if (qual == SATA_ADDR_DCPORT)
14520 qual = SATA_ADDR_CPORT;
14521 else
14522 qual = SATA_ADDR_PMPORT;
14523
14524 /*
14525 * DEVCTL_AP_DISCONNECT invokes sata_hba_inst->satahba_tran->
14526 * sata_tran_hotplug_ops->sata_tran_port_deactivate().
14527 * Do the sanity check.
14528 */
14529 if (SATA_PORT_DEACTIVATE_FUNC(sata_hba_inst) == NULL) {
14530 /* No physical port deactivation supported. */
14531 return (EINVAL);
14532 }
14533
14534 /* Check the current state of the port */
14535 rval = (*SATA_PROBE_PORT_FUNC(sata_hba_inst))
14536 (SATA_DIP(sata_hba_inst), sata_device);
14537
14538 cportinfo = SATA_CPORT_INFO(sata_hba_inst, cport);
14539
14540 /*
14541 * Processing port mulitiplier
14542 */
14543 if (qual == SATA_ADDR_CPORT &&
14544 SATA_CPORT_DEV_TYPE(sata_hba_inst, cport) == SATA_DTYPE_PMULT) {
14545 mutex_enter(&cportinfo->cport_mutex);
14546
14547 /* Check controller port status */
14548 sata_update_port_info(sata_hba_inst, sata_device);
14549 if (rval != SATA_SUCCESS ||
14550 (sata_device->satadev_state & SATA_PSTATE_FAILED) != 0) {
14551 /*
14552 * Device port status is unknown or it is in failed
14553 * state
14554 */
14555 SATA_CPORT_STATE(sata_hba_inst, cport) =
14556 SATA_PSTATE_FAILED;
14557 SATADBG1(SATA_DBG_IOCTL_IF, sata_hba_inst,
14558 "sata_hba_ioctl: connect: failed to deactivate "
14559 "SATA port %d", cport);
14560 mutex_exit(&cportinfo->cport_mutex);
14561 return (EIO);
14562 }
14563
14564 /* Disconnect all sub-devices. */
14565 pmultinfo = SATA_CPORTINFO_PMULT_INFO(cportinfo);
14566 if (pmultinfo != NULL) {
14567
14568 for (npmport = 0; npmport < SATA_NUM_PMPORTS(
14569 sata_hba_inst, cport); npmport ++) {
14570 subsdinfo = SATA_PMPORT_DRV_INFO(
14571 sata_hba_inst, cport, npmport);
14572 if (subsdinfo == NULL)
14573 continue;
14574
14575 subsdevice.satadev_addr = subsdinfo->
14576 satadrv_addr;
14577
14578 mutex_exit(&cportinfo->cport_mutex);
14579 if (sata_ioctl_disconnect(sata_hba_inst,
14580 &subsdevice) == SATA_SUCCESS) {
14581 SATADBG2(SATA_DBG_PMULT, sata_hba_inst,
14582 "[Remove] device at port %d:%d "
14583 "successfully.", cport, npmport);
14584 }
14585 mutex_enter(&cportinfo->cport_mutex);
14586 }
14587 }
14588
14589 /* Disconnect the port multiplier */
14590 cportinfo->cport_state &= ~SATA_STATE_READY;
14591 mutex_exit(&cportinfo->cport_mutex);
14592
14593 sata_device->satadev_addr.qual = qual;
14594 rval = (*SATA_PORT_DEACTIVATE_FUNC(sata_hba_inst))
14595 (SATA_DIP(sata_hba_inst), sata_device);
14596
14597 sata_gen_sysevent(sata_hba_inst, &sata_device->satadev_addr,
14598 SE_NO_HINT);
14599
14600 mutex_enter(&cportinfo->cport_mutex);
14601 sata_update_port_info(sata_hba_inst, sata_device);
14602 if (rval != SATA_SUCCESS &&
14603 sata_device->satadev_state & SATA_PSTATE_FAILED) {
14604 cportinfo->cport_state = SATA_PSTATE_FAILED;
14605 rv = EIO;
14606 } else {
14607 cportinfo->cport_state |= SATA_PSTATE_SHUTDOWN;
14608 }
14609 mutex_exit(&cportinfo->cport_mutex);
14610
14611 return (rv);
14612 }
14613
14614 /*
14615 * Process non-port-multiplier device - it could be a drive connected
14616 * to a port multiplier port or a controller port.
14617 */
14618 if (qual == SATA_ADDR_PMPORT) {
14619 pmportinfo = SATA_PMPORT_INFO(sata_hba_inst, cport, pmport);
14620 mutex_enter(&pmportinfo->pmport_mutex);
14621 sata_update_pmport_info(sata_hba_inst, sata_device);
14622 if (rval != SATA_SUCCESS ||
14623 (sata_device->satadev_state & SATA_PSTATE_FAILED) != 0) {
14624 SATA_PMPORT_STATE(sata_hba_inst, cport, pmport) =
14625 SATA_PSTATE_FAILED;
14626 SATADBG2(SATA_DBG_IOCTL_IF, sata_hba_inst,
14627 "sata_hba_ioctl: connect: failed to deactivate "
14628 "SATA port %d:%d", cport, pmport);
14629 mutex_exit(&pmportinfo->pmport_mutex);
14630 return (EIO);
14631 }
14632
14633 if (pmportinfo->pmport_dev_type != SATA_DTYPE_NONE) {
14634 sdinfo = pmportinfo->pmport_sata_drive;
14635 ASSERT(sdinfo != NULL);
14636 }
14637
14638 /*
14639 * Set port's dev_state to not ready - this will disable
14640 * an access to a potentially attached device.
14641 */
14642 pmportinfo->pmport_state &= ~SATA_STATE_READY;
14643
14644 /* Remove and release sata_drive info structure. */
14645 if (sdinfo != NULL) {
14646 if ((sdinfo->satadrv_type &
14647 SATA_VALID_DEV_TYPE) != 0) {
14648 /*
14649 * If a target node exists, try to offline
14650 * a device and remove target node.
14651 */
14652 mutex_exit(&pmportinfo->pmport_mutex);
14653 (void) sata_offline_device(sata_hba_inst,
14654 sata_device, sdinfo);
14655 mutex_enter(&pmportinfo->pmport_mutex);
14656 }
14657
14658 SATA_PMPORTINFO_DRV_INFO(pmportinfo) = NULL;
14659 pmportinfo->pmport_dev_type = SATA_DTYPE_NONE;
14660 (void) kmem_free((void *)sdinfo,
14661 sizeof (sata_drive_info_t));
14662 }
14663 mutex_exit(&pmportinfo->pmport_mutex);
14664
14665 } else if (qual == SATA_ADDR_CPORT) {
14666 mutex_enter(&cportinfo->cport_mutex);
14667 sata_update_port_info(sata_hba_inst, sata_device);
14668 if (rval != SATA_SUCCESS ||
14669 (sata_device->satadev_state & SATA_PSTATE_FAILED) != 0) {
14670 /*
14671 * Device port status is unknown or it is in failed
14672 * state
14673 */
14674 SATA_CPORT_STATE(sata_hba_inst, cport) =
14675 SATA_PSTATE_FAILED;
14676 SATADBG1(SATA_DBG_IOCTL_IF, sata_hba_inst,
14677 "sata_hba_ioctl: connect: failed to deactivate "
14678 "SATA port %d", cport);
14679 mutex_exit(&cportinfo->cport_mutex);
14680 return (EIO);
14681 }
14682
14683 if (cportinfo->cport_dev_type == SATA_DTYPE_PMULT) {
14684 pmultinfo = SATA_CPORTINFO_PMULT_INFO(cportinfo);
14685 ASSERT(pmultinfo != NULL);
14686 } else if (cportinfo->cport_dev_type != SATA_DTYPE_NONE) {
14687 sdinfo = SATA_CPORTINFO_DRV_INFO(cportinfo);
14688 ASSERT(sdinfo != NULL);
14689 }
14690 cportinfo->cport_state &= ~SATA_STATE_READY;
14691
14692 if (sdinfo != NULL) {
14693 if ((sdinfo->satadrv_type &
14694 SATA_VALID_DEV_TYPE) != 0) {
14695 /*
14696 * If a target node exists, try to offline
14697 * a device and remove target node.
14698 */
14699 mutex_exit(&cportinfo->cport_mutex);
14700 (void) sata_offline_device(sata_hba_inst,
14701 sata_device, sdinfo);
14702 mutex_enter(&cportinfo->cport_mutex);
14703 }
14704
14705 SATA_CPORTINFO_DRV_INFO(cportinfo) = NULL;
14706 cportinfo->cport_dev_type = SATA_DTYPE_NONE;
14707 (void) kmem_free((void *)sdinfo,
14708 sizeof (sata_drive_info_t));
14709 }
14710 mutex_exit(&cportinfo->cport_mutex);
14711 }
14712
14713 /* Just ask HBA driver to deactivate port */
14714 sata_device->satadev_addr.qual = qual;
14715
14716 rval = (*SATA_PORT_DEACTIVATE_FUNC(sata_hba_inst))
14717 (SATA_DIP(sata_hba_inst), sata_device);
14718
14719 /*
14720 * Generate sysevent - EC_DR / ESC_DR_AP_STATE_CHANGE
14721 * without the hint (to force listener to investivate the state).
14722 */
14723 sata_gen_sysevent(sata_hba_inst, &sata_device->satadev_addr,
14724 SE_NO_HINT);
14725
14726 if (qual == SATA_ADDR_PMPORT) {
14727 mutex_enter(&pmportinfo->pmport_mutex);
14728 sata_update_pmport_info(sata_hba_inst, sata_device);
14729
14730 if (rval != SATA_SUCCESS &&
14731 sata_device->satadev_state & SATA_PSTATE_FAILED) {
14732 /*
14733 * Port deactivation failure - do not change port
14734 * state unless the state returned by HBA indicates a
14735 * port failure.
14736 *
14737 * NOTE: device structures were released, so devices
14738 * now are invisible! Port reset is needed to
14739 * re-enumerate devices.
14740 */
14741 pmportinfo->pmport_state = SATA_PSTATE_FAILED;
14742 rv = EIO;
14743 } else {
14744 /*
14745 * Deactivation succeded. From now on the sata framework
14746 * will not care what is happening to the device, until
14747 * the port is activated again.
14748 */
14749 pmportinfo->pmport_state |= SATA_PSTATE_SHUTDOWN;
14750 }
14751 mutex_exit(&pmportinfo->pmport_mutex);
14752 } else if (qual == SATA_ADDR_CPORT) {
14753 mutex_enter(&cportinfo->cport_mutex);
14754 sata_update_port_info(sata_hba_inst, sata_device);
14755
14756 if (rval != SATA_SUCCESS &&
14757 sata_device->satadev_state & SATA_PSTATE_FAILED) {
14758 cportinfo->cport_state = SATA_PSTATE_FAILED;
14759 rv = EIO;
14760 } else {
14761 cportinfo->cport_state |= SATA_PSTATE_SHUTDOWN;
14762 }
14763 mutex_exit(&cportinfo->cport_mutex);
14764 }
14765
14766 return (rv);
14767 }
14768
14769
14770
14771 /*
14772 * Process sata port connect request
14773 * The sata cfgadm pluging will invoke this operation only if port was found
14774 * in the disconnect state (failed state is also treated as the disconnected
14775 * state).
14776 * DEVCTL_AP_CONNECT would invoke sata_hba_inst->satahba_tran->
14777 * sata_tran_hotplug_ops->sata_tran_port_activate().
14778 * If successful and a device is found attached to the port,
14779 * the initialization sequence is executed to attach a device structure to
14780 * a port structure. The state of the port and a device would be set
14781 * appropriately.
14782 * The device is not set in configured state (system-wise) by this operation.
14783 *
14784 * Note, that activating the port may generate link events,
14785 * so it is important that following processing and the
14786 * event processing does not interfere with each other!
14787 *
14788 * This operation may remove port failed state and will
14789 * try to make port active and in good standing.
14790 *
14791 * NOTE: Port multiplier is supported.
14792 */
14793
14794 static int
sata_ioctl_connect(sata_hba_inst_t * sata_hba_inst,sata_device_t * sata_device)14795 sata_ioctl_connect(sata_hba_inst_t *sata_hba_inst,
14796 sata_device_t *sata_device)
14797 {
14798 sata_pmport_info_t *pmportinfo = NULL;
14799 uint8_t cport, pmport, qual;
14800 int rv = 0;
14801
14802 cport = sata_device->satadev_addr.cport;
14803 pmport = sata_device->satadev_addr.pmport;
14804 qual = sata_device->satadev_addr.qual;
14805
14806 ASSERT(qual == SATA_ADDR_DCPORT || qual == SATA_ADDR_DPMPORT);
14807 if (qual == SATA_ADDR_DCPORT)
14808 qual = SATA_ADDR_CPORT;
14809 else
14810 qual = SATA_ADDR_PMPORT;
14811
14812 if (qual == SATA_ADDR_PMPORT)
14813 pmportinfo = SATA_PMPORT_INFO(sata_hba_inst, cport, pmport);
14814
14815 /*
14816 * DEVCTL_AP_CONNECT would invoke sata_hba_inst->
14817 * satahba_tran->sata_tran_hotplug_ops->sata_tran_port_activate().
14818 * Perform sanity check now.
14819 */
14820 if (SATA_PORT_ACTIVATE_FUNC(sata_hba_inst) == NULL) {
14821 /* No physical port activation supported. */
14822 return (EINVAL);
14823 }
14824
14825 /* Just ask HBA driver to activate port */
14826 if ((*SATA_PORT_ACTIVATE_FUNC(sata_hba_inst))
14827 (SATA_DIP(sata_hba_inst), sata_device) != SATA_SUCCESS) {
14828 /*
14829 * Port activation failure.
14830 */
14831 if (qual == SATA_ADDR_CPORT) {
14832 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst,
14833 cport)->cport_mutex);
14834 sata_update_port_info(sata_hba_inst, sata_device);
14835 if (sata_device->satadev_state & SATA_PSTATE_FAILED) {
14836 SATA_CPORT_STATE(sata_hba_inst, cport) =
14837 SATA_PSTATE_FAILED;
14838 SATADBG1(SATA_DBG_IOCTL_IF, sata_hba_inst,
14839 "sata_hba_ioctl: connect: failed to "
14840 "activate SATA port %d", cport);
14841 }
14842 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst,
14843 cport)->cport_mutex);
14844 } else { /* port multiplier device port */
14845 mutex_enter(&pmportinfo->pmport_mutex);
14846 sata_update_pmport_info(sata_hba_inst, sata_device);
14847 if (sata_device->satadev_state & SATA_PSTATE_FAILED) {
14848 SATA_PMPORT_STATE(sata_hba_inst, cport,
14849 pmport) = SATA_PSTATE_FAILED;
14850 SATADBG2(SATA_DBG_IOCTL_IF, sata_hba_inst,
14851 "sata_hba_ioctl: connect: failed to "
14852 "activate SATA port %d:%d", cport, pmport);
14853 }
14854 mutex_exit(&pmportinfo->pmport_mutex);
14855 }
14856 return (EIO);
14857 }
14858
14859 /* Virgin port state - will be updated by the port re-probe. */
14860 if (qual == SATA_ADDR_CPORT) {
14861 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst,
14862 cport)->cport_mutex);
14863 SATA_CPORT_STATE(sata_hba_inst, cport) = 0;
14864 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst,
14865 cport)->cport_mutex);
14866 } else { /* port multiplier device port */
14867 mutex_enter(&pmportinfo->pmport_mutex);
14868 SATA_PMPORT_STATE(sata_hba_inst, cport, pmport) = 0;
14869 mutex_exit(&pmportinfo->pmport_mutex);
14870 }
14871
14872 /*
14873 * Probe the port to find its state and attached device.
14874 */
14875 if (sata_reprobe_port(sata_hba_inst, sata_device,
14876 SATA_DEV_IDENTIFY_RETRY) == SATA_FAILURE)
14877 rv = EIO;
14878
14879 /*
14880 * Generate sysevent - EC_DR / ESC_DR_AP_STATE_CHANGE
14881 * without the hint
14882 */
14883 sata_gen_sysevent(sata_hba_inst, &sata_device->satadev_addr,
14884 SE_NO_HINT);
14885
14886 /*
14887 * If there is a device attached to the port, emit
14888 * a message.
14889 */
14890 if (sata_device->satadev_type != SATA_DTYPE_NONE) {
14891
14892 if (qual == SATA_ADDR_CPORT) {
14893 if (sata_device->satadev_type == SATA_DTYPE_PMULT) {
14894 sata_log(sata_hba_inst, CE_WARN,
14895 "SATA port multiplier detected "
14896 "at port %d", cport);
14897 } else {
14898 sata_log(sata_hba_inst, CE_WARN,
14899 "SATA device detected at port %d", cport);
14900 if (sata_device->satadev_type ==
14901 SATA_DTYPE_UNKNOWN) {
14902 /*
14903 * A device was not successfully identified
14904 */
14905 sata_log(sata_hba_inst, CE_WARN,
14906 "Could not identify SATA "
14907 "device at port %d", cport);
14908 }
14909 }
14910 } else { /* port multiplier device port */
14911 sata_log(sata_hba_inst, CE_WARN,
14912 "SATA device detected at port %d:%d",
14913 cport, pmport);
14914 if (sata_device->satadev_type == SATA_DTYPE_UNKNOWN) {
14915 /*
14916 * A device was not successfully identified
14917 */
14918 sata_log(sata_hba_inst, CE_WARN,
14919 "Could not identify SATA "
14920 "device at port %d:%d", cport, pmport);
14921 }
14922 }
14923 }
14924
14925 return (rv);
14926 }
14927
14928
14929 /*
14930 * Process sata device unconfigure request.
14931 * The unconfigure operation uses generic nexus operation to
14932 * offline a device. It leaves a target device node attached.
14933 * and obviously sata_drive_info attached as well, because
14934 * from the hardware point of view nothing has changed.
14935 */
14936 static int
sata_ioctl_unconfigure(sata_hba_inst_t * sata_hba_inst,sata_device_t * sata_device)14937 sata_ioctl_unconfigure(sata_hba_inst_t *sata_hba_inst,
14938 sata_device_t *sata_device)
14939 {
14940 int rv = 0;
14941 dev_info_t *tdip;
14942
14943 /* We are addressing attached device, not a port */
14944 if (sata_device->satadev_addr.qual == SATA_ADDR_CPORT)
14945 sata_device->satadev_addr.qual = SATA_ADDR_DCPORT;
14946 else if (sata_device->satadev_addr.qual == SATA_ADDR_PMPORT)
14947 sata_device->satadev_addr.qual = SATA_ADDR_DPMPORT;
14948
14949 if ((tdip = sata_get_scsi_target_dip(SATA_DIP(sata_hba_inst),
14950 &sata_device->satadev_addr)) != NULL) {
14951
14952 if (ndi_devi_offline(tdip, NDI_UNCONFIG) != NDI_SUCCESS) {
14953 SATA_LOG_D((sata_hba_inst, CE_WARN,
14954 "sata_hba_ioctl: unconfigure: "
14955 "failed to unconfigure device at SATA port %d:%d",
14956 sata_device->satadev_addr.cport,
14957 sata_device->satadev_addr.pmport));
14958 rv = EIO;
14959 }
14960 /*
14961 * The target node devi_state should be marked with
14962 * DEVI_DEVICE_OFFLINE by ndi_devi_offline().
14963 * This would be the indication for cfgadm that
14964 * the AP node occupant state is 'unconfigured'.
14965 */
14966
14967 } else {
14968 /*
14969 * This would indicate a failure on the part of cfgadm
14970 * to detect correct state of the node prior to this
14971 * call - one cannot unconfigure non-existing device.
14972 */
14973 SATA_LOG_D((sata_hba_inst, CE_WARN,
14974 "sata_hba_ioctl: unconfigure: "
14975 "attempt to unconfigure non-existing device "
14976 "at SATA port %d:%d",
14977 sata_device->satadev_addr.cport,
14978 sata_device->satadev_addr.pmport));
14979 rv = ENXIO;
14980 }
14981 return (rv);
14982 }
14983
14984 /*
14985 * Process sata device configure request
14986 * If port is in a failed state, operation is aborted - one has to use
14987 * an explicit connect or port activate request to try to get a port into
14988 * non-failed mode. Port reset wil also work in such situation.
14989 * If the port is in disconnected (shutdown) state, the connect operation is
14990 * attempted prior to any other action.
14991 * When port is in the active state, there is a device attached and the target
14992 * node exists, a device was most likely offlined.
14993 * If target node does not exist, a new target node is created. In both cases
14994 * an attempt is made to online (configure) the device.
14995 *
14996 * NOTE: Port multiplier is supported.
14997 */
14998 static int
sata_ioctl_configure(sata_hba_inst_t * sata_hba_inst,sata_device_t * sata_device)14999 sata_ioctl_configure(sata_hba_inst_t *sata_hba_inst,
15000 sata_device_t *sata_device)
15001 {
15002 int cport, pmport, qual;
15003 int rval;
15004 boolean_t target = B_TRUE;
15005 sata_cport_info_t *cportinfo;
15006 sata_pmport_info_t *pmportinfo = NULL;
15007 dev_info_t *tdip;
15008 sata_drive_info_t *sdinfo;
15009
15010 cport = sata_device->satadev_addr.cport;
15011 pmport = sata_device->satadev_addr.pmport;
15012 qual = sata_device->satadev_addr.qual;
15013
15014 /* Get current port state */
15015 rval = (*SATA_PROBE_PORT_FUNC(sata_hba_inst))
15016 (SATA_DIP(sata_hba_inst), sata_device);
15017
15018 cportinfo = SATA_CPORT_INFO(sata_hba_inst, cport);
15019 if (qual == SATA_ADDR_DPMPORT) {
15020 pmportinfo = SATA_PMPORT_INFO(sata_hba_inst, cport, pmport);
15021 mutex_enter(&pmportinfo->pmport_mutex);
15022 sata_update_pmport_info(sata_hba_inst, sata_device);
15023 if (rval != SATA_SUCCESS ||
15024 (sata_device->satadev_state & SATA_PSTATE_FAILED) != 0) {
15025 /*
15026 * Obviously, device on a failed port is not visible
15027 */
15028 mutex_exit(&pmportinfo->pmport_mutex);
15029 return (ENXIO);
15030 }
15031 mutex_exit(&pmportinfo->pmport_mutex);
15032 } else {
15033 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst,
15034 cport)->cport_mutex);
15035 sata_update_port_info(sata_hba_inst, sata_device);
15036 if (rval != SATA_SUCCESS ||
15037 (sata_device->satadev_state & SATA_PSTATE_FAILED) != 0) {
15038 /*
15039 * Obviously, device on a failed port is not visible
15040 */
15041 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst,
15042 cport)->cport_mutex);
15043 return (ENXIO);
15044 }
15045 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst,
15046 cport)->cport_mutex);
15047 }
15048
15049 if ((sata_device->satadev_state & SATA_PSTATE_SHUTDOWN) != 0) {
15050 /* need to activate port */
15051 target = B_FALSE;
15052
15053 /* Sanity check */
15054 if (SATA_PORT_ACTIVATE_FUNC(sata_hba_inst) == NULL)
15055 return (ENXIO);
15056
15057 /* Just let HBA driver to activate port */
15058 if ((*SATA_PORT_ACTIVATE_FUNC(sata_hba_inst))
15059 (SATA_DIP(sata_hba_inst), sata_device) != SATA_SUCCESS) {
15060 /*
15061 * Port activation failure - do not change port state
15062 * unless the state returned by HBA indicates a port
15063 * failure.
15064 */
15065 if (qual == SATA_ADDR_DPMPORT) {
15066 mutex_enter(&pmportinfo->pmport_mutex);
15067 sata_update_pmport_info(sata_hba_inst,
15068 sata_device);
15069 if (sata_device->satadev_state &
15070 SATA_PSTATE_FAILED)
15071 pmportinfo->pmport_state =
15072 SATA_PSTATE_FAILED;
15073 mutex_exit(&pmportinfo->pmport_mutex);
15074 } else {
15075 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst,
15076 cport)->cport_mutex);
15077 sata_update_port_info(sata_hba_inst,
15078 sata_device);
15079 if (sata_device->satadev_state &
15080 SATA_PSTATE_FAILED)
15081 cportinfo->cport_state =
15082 SATA_PSTATE_FAILED;
15083 mutex_exit(&SATA_CPORT_INFO(
15084 sata_hba_inst, cport)->cport_mutex);
15085 }
15086 }
15087 SATA_LOG_D((sata_hba_inst, CE_WARN,
15088 "sata_hba_ioctl: configure: "
15089 "failed to activate SATA port %d:%d",
15090 cport, pmport));
15091 return (EIO);
15092 }
15093 /*
15094 * Generate sysevent - EC_DR / ESC_DR_AP_STATE_CHANGE
15095 * without the hint.
15096 */
15097 sata_gen_sysevent(sata_hba_inst,
15098 &sata_device->satadev_addr, SE_NO_HINT);
15099
15100 /* Virgin port state */
15101 if (qual == SATA_ADDR_DPMPORT) {
15102 mutex_enter(&pmportinfo->pmport_mutex);
15103 pmportinfo->pmport_state = 0;
15104 mutex_exit(&pmportinfo->pmport_mutex);
15105 } else {
15106 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst,
15107 cport)-> cport_mutex);
15108 cportinfo->cport_state = 0;
15109 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst,
15110 cport)->cport_mutex);
15111 }
15112 /*
15113 * Always reprobe port, to get current device info.
15114 */
15115 if (sata_reprobe_port(sata_hba_inst, sata_device,
15116 SATA_DEV_IDENTIFY_RETRY) != SATA_SUCCESS)
15117 return (EIO);
15118
15119 if (sata_device->satadev_type != SATA_DTYPE_NONE && target == B_FALSE) {
15120 if (qual == SATA_ADDR_DPMPORT) {
15121 /*
15122 * That's the transition from "inactive" port
15123 * to active one with device attached.
15124 */
15125 sata_log(sata_hba_inst, CE_WARN,
15126 "SATA device detected at port %d:%d",
15127 cport, pmport);
15128 } else {
15129 /*
15130 * When PM is attached to the cport and cport is
15131 * activated, every PM device port needs to be reprobed.
15132 * We need to emit message for all devices detected
15133 * at port multiplier's device ports.
15134 * Add such code here.
15135 * For now, just inform about device attached to
15136 * cport.
15137 */
15138 sata_log(sata_hba_inst, CE_WARN,
15139 "SATA device detected at port %d", cport);
15140 }
15141 }
15142
15143 /*
15144 * This is where real configuration operation starts.
15145 *
15146 * When PM is attached to the cport and cport is activated,
15147 * devices attached PM device ports may have to be configured
15148 * explicitly. This may change when port multiplier is supported.
15149 * For now, configure only disks and other valid target devices.
15150 */
15151 if (!(sata_device->satadev_type & SATA_VALID_DEV_TYPE)) {
15152 if (qual == SATA_ADDR_DCPORT) {
15153 if (sata_device->satadev_type == SATA_DTYPE_UNKNOWN) {
15154 /*
15155 * A device was not successfully identified
15156 */
15157 sata_log(sata_hba_inst, CE_WARN,
15158 "Could not identify SATA "
15159 "device at port %d", cport);
15160 }
15161 } else { /* port multiplier device port */
15162 if (sata_device->satadev_type == SATA_DTYPE_UNKNOWN) {
15163 /*
15164 * A device was not successfully identified
15165 */
15166 sata_log(sata_hba_inst, CE_WARN,
15167 "Could not identify SATA "
15168 "device at port %d:%d", cport, pmport);
15169 }
15170 }
15171 return (ENXIO); /* No device to configure */
15172 }
15173
15174 /*
15175 * Here we may have a device in reset condition,
15176 * but because we are just configuring it, there is
15177 * no need to process the reset other than just
15178 * to clear device reset condition in the HBA driver.
15179 * Setting the flag SATA_EVNT_CLEAR_DEVICE_RESET will
15180 * cause a first command sent the HBA driver with the request
15181 * to clear device reset condition.
15182 */
15183 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex);
15184 if (qual == SATA_ADDR_DPMPORT)
15185 sata_device->satadev_addr.qual = SATA_ADDR_DPMPORT;
15186 else
15187 sata_device->satadev_addr.qual = SATA_ADDR_DCPORT;
15188 sdinfo = sata_get_device_info(sata_hba_inst, sata_device);
15189 if (sdinfo == NULL) {
15190 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex);
15191 return (ENXIO);
15192 }
15193 if (sdinfo->satadrv_event_flags &
15194 (SATA_EVNT_DEVICE_RESET | SATA_EVNT_INPROC_DEVICE_RESET)) {
15195 sdinfo->satadrv_event_flags = 0;
15196 }
15197 sdinfo->satadrv_event_flags |= SATA_EVNT_CLEAR_DEVICE_RESET;
15198 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex);
15199
15200 if ((tdip = sata_get_scsi_target_dip(SATA_DIP(sata_hba_inst),
15201 &sata_device->satadev_addr)) != NULL) {
15202 /*
15203 * Target node exists. Verify, that it belongs
15204 * to existing, attached device and not to
15205 * a removed device.
15206 */
15207 if (sata_check_device_removed(tdip) == B_TRUE) {
15208 if (qual == SATA_ADDR_DPMPORT)
15209 sata_log(sata_hba_inst, CE_WARN,
15210 "SATA device at port %d cannot be "
15211 "configured. "
15212 "Application(s) accessing "
15213 "previously attached device "
15214 "have to release it before newly "
15215 "inserted device can be made accessible.",
15216 cport);
15217 else
15218 sata_log(sata_hba_inst, CE_WARN,
15219 "SATA device at port %d:%d cannot be"
15220 "configured. "
15221 "Application(s) accessing "
15222 "previously attached device "
15223 "have to release it before newly "
15224 "inserted device can be made accessible.",
15225 cport, pmport);
15226 return (EIO);
15227 }
15228 /*
15229 * Device was not removed and re-inserted.
15230 * Try to online it.
15231 */
15232 if (ndi_devi_online(tdip, 0) != NDI_SUCCESS) {
15233 SATA_LOG_D((sata_hba_inst, CE_WARN,
15234 "sata_hba_ioctl: configure: "
15235 "onlining device at SATA port "
15236 "%d:%d failed", cport, pmport));
15237 return (EIO);
15238 }
15239
15240 if (qual == SATA_ADDR_DPMPORT) {
15241 mutex_enter(&pmportinfo->pmport_mutex);
15242 pmportinfo->pmport_tgtnode_clean = B_TRUE;
15243 mutex_exit(&pmportinfo->pmport_mutex);
15244 } else {
15245 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst,
15246 cport)->cport_mutex);
15247 cportinfo-> cport_tgtnode_clean = B_TRUE;
15248 mutex_exit(&SATA_CPORT_INFO(
15249 sata_hba_inst, cport)->cport_mutex);
15250 }
15251 } else {
15252 /*
15253 * No target node - need to create a new target node.
15254 */
15255 if (qual == SATA_ADDR_DPMPORT) {
15256 mutex_enter(&pmportinfo->pmport_mutex);
15257 pmportinfo->pmport_tgtnode_clean = B_TRUE;
15258 mutex_exit(&pmportinfo->pmport_mutex);
15259 } else {
15260 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, cport)->
15261 cport_mutex);
15262 cportinfo-> cport_tgtnode_clean = B_TRUE;
15263 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)->
15264 cport_mutex);
15265 }
15266
15267 tdip = sata_create_target_node(SATA_DIP(sata_hba_inst),
15268 sata_hba_inst, &sata_device->satadev_addr);
15269 if (tdip == NULL) {
15270 /* Configure operation failed */
15271 SATA_LOG_D((sata_hba_inst, CE_WARN,
15272 "sata_hba_ioctl: configure: "
15273 "configuring SATA device at port %d:%d "
15274 "failed", cport, pmport));
15275 return (EIO);
15276 }
15277 }
15278 return (0);
15279 }
15280
15281
15282 /*
15283 * Process ioctl deactivate port request.
15284 * Arbitrarily unconfigure attached device, if any.
15285 * Even if the unconfigure fails, proceed with the
15286 * port deactivation.
15287 *
15288 * NOTE: Port Multiplier is supported now.
15289 */
15290
15291 static int
sata_ioctl_deactivate(sata_hba_inst_t * sata_hba_inst,sata_device_t * sata_device)15292 sata_ioctl_deactivate(sata_hba_inst_t *sata_hba_inst,
15293 sata_device_t *sata_device)
15294 {
15295 int cport, pmport, qual;
15296 int rval, rv = 0;
15297 int npmport;
15298 sata_cport_info_t *cportinfo;
15299 sata_pmport_info_t *pmportinfo;
15300 sata_pmult_info_t *pmultinfo;
15301 dev_info_t *tdip;
15302 sata_drive_info_t *sdinfo = NULL;
15303 sata_device_t subsdevice;
15304
15305 /* Sanity check */
15306 if (SATA_PORT_DEACTIVATE_FUNC(sata_hba_inst) == NULL)
15307 return (ENOTSUP);
15308
15309 cport = sata_device->satadev_addr.cport;
15310 pmport = sata_device->satadev_addr.pmport;
15311 qual = sata_device->satadev_addr.qual;
15312
15313 /* SCSI_TO_SATA_ADDR_QUAL() translate ap_id into a device qualifier */
15314 ASSERT(qual == SATA_ADDR_DCPORT || qual == SATA_ADDR_DPMPORT);
15315 if (qual == SATA_ADDR_DCPORT)
15316 qual = SATA_ADDR_CPORT;
15317 else
15318 qual = SATA_ADDR_PMPORT;
15319
15320 cportinfo = SATA_CPORT_INFO(sata_hba_inst, cport);
15321 if (qual == SATA_ADDR_PMPORT)
15322 pmportinfo = SATA_PMPORT_INFO(sata_hba_inst, cport, pmport);
15323
15324 /*
15325 * Processing port multiplier
15326 */
15327 if (qual == SATA_ADDR_CPORT &&
15328 SATA_CPORT_DEV_TYPE(sata_hba_inst, cport) == SATA_DTYPE_PMULT) {
15329 mutex_enter(&cportinfo->cport_mutex);
15330
15331 /* Deactivate all sub-deices */
15332 pmultinfo = SATA_CPORTINFO_PMULT_INFO(cportinfo);
15333 if (pmultinfo != NULL) {
15334 for (npmport = 0; npmport < SATA_NUM_PMPORTS(
15335 sata_hba_inst, cport); npmport++) {
15336
15337 subsdevice.satadev_addr.cport = cport;
15338 subsdevice.satadev_addr.pmport =
15339 (uint8_t)npmport;
15340 subsdevice.satadev_addr.qual =
15341 SATA_ADDR_DPMPORT;
15342
15343 SATADBG2(SATA_DBG_PMULT, sata_hba_inst,
15344 "sata_hba_ioctl: deactivate: trying to "
15345 "deactivate SATA port %d:%d",
15346 cport, npmport);
15347
15348 mutex_exit(&cportinfo->cport_mutex);
15349 if (sata_ioctl_deactivate(sata_hba_inst,
15350 &subsdevice) == SATA_SUCCESS) {
15351 SATADBG2(SATA_DBG_PMULT, sata_hba_inst,
15352 "[Deactivate] device at port %d:%d "
15353 "successfully.", cport, npmport);
15354 }
15355 mutex_enter(&cportinfo->cport_mutex);
15356 }
15357 }
15358
15359 /* Deactivate the port multiplier now. */
15360 cportinfo->cport_state &= ~SATA_STATE_READY;
15361 mutex_exit(&cportinfo->cport_mutex);
15362
15363 sata_device->satadev_addr.qual = qual;
15364 rval = (*SATA_PORT_DEACTIVATE_FUNC(sata_hba_inst))
15365 (SATA_DIP(sata_hba_inst), sata_device);
15366
15367 sata_gen_sysevent(sata_hba_inst, &sata_device->satadev_addr,
15368 SE_NO_HINT);
15369
15370 mutex_enter(&cportinfo->cport_mutex);
15371 sata_update_port_info(sata_hba_inst, sata_device);
15372 if (rval != SATA_SUCCESS) {
15373 if (sata_device->satadev_state & SATA_PSTATE_FAILED) {
15374 cportinfo->cport_state = SATA_PSTATE_FAILED;
15375 }
15376 rv = EIO;
15377 } else {
15378 cportinfo->cport_state |= SATA_PSTATE_SHUTDOWN;
15379 }
15380 mutex_exit(&cportinfo->cport_mutex);
15381
15382 return (rv);
15383 }
15384
15385 /*
15386 * Process non-port-multiplier device - it could be a drive connected
15387 * to a port multiplier port or a controller port.
15388 */
15389 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex);
15390 if (qual == SATA_ADDR_CPORT) {
15391 sata_device->satadev_addr.qual = SATA_ADDR_DCPORT;
15392 if (cportinfo->cport_dev_type != SATA_DTYPE_NONE) {
15393 /* deal only with valid devices */
15394 if ((cportinfo->cport_dev_type &
15395 SATA_VALID_DEV_TYPE) != 0)
15396 sdinfo = SATA_CPORTINFO_DRV_INFO(cportinfo);
15397 }
15398 cportinfo->cport_state &= ~SATA_STATE_READY;
15399 } else {
15400 /* Port multiplier device port */
15401 mutex_enter(&pmportinfo->pmport_mutex);
15402 sata_device->satadev_addr.qual = SATA_ADDR_DPMPORT;
15403 if (pmportinfo->pmport_dev_type != SATA_DTYPE_NONE &&
15404 (pmportinfo->pmport_dev_type & SATA_VALID_DEV_TYPE) != 0)
15405 sdinfo = SATA_PMPORTINFO_DRV_INFO(pmportinfo);
15406 pmportinfo->pmport_state &= ~SATA_STATE_READY;
15407 mutex_exit(&pmportinfo->pmport_mutex);
15408 }
15409
15410 if (sdinfo != NULL) {
15411 /*
15412 * If a target node exists, try to offline a device and
15413 * to remove a target node.
15414 */
15415 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)->
15416 cport_mutex);
15417 tdip = sata_get_scsi_target_dip(SATA_DIP(sata_hba_inst),
15418 &sata_device->satadev_addr);
15419 if (tdip != NULL) {
15420 /* target node exist */
15421 SATADBG1(SATA_DBG_IOCTL_IF, sata_hba_inst,
15422 "sata_hba_ioctl: port deactivate: "
15423 "target node exists.", NULL);
15424
15425 if (ndi_devi_offline(tdip, NDI_DEVI_REMOVE) !=
15426 NDI_SUCCESS) {
15427 SATA_LOG_D((sata_hba_inst, CE_WARN,
15428 "sata_hba_ioctl: port deactivate: "
15429 "failed to unconfigure device at port "
15430 "%d:%d before deactivating the port",
15431 cport, pmport));
15432 /*
15433 * Set DEVICE REMOVED state in the target
15434 * node. It will prevent an access to
15435 * the device even when a new device is
15436 * attached, until the old target node is
15437 * released, removed and recreated for a new
15438 * device.
15439 */
15440 sata_set_device_removed(tdip);
15441
15442 /*
15443 * Instruct the event daemon to try the
15444 * target node cleanup later.
15445 */
15446 sata_set_target_node_cleanup(sata_hba_inst,
15447 &sata_device->satadev_addr);
15448 }
15449 }
15450 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, cport)->
15451 cport_mutex);
15452 /*
15453 * In any case, remove and release sata_drive_info
15454 * structure.
15455 */
15456 if (qual == SATA_ADDR_CPORT) {
15457 SATA_CPORTINFO_DRV_INFO(cportinfo) = NULL;
15458 cportinfo->cport_dev_type = SATA_DTYPE_NONE;
15459 } else { /* port multiplier device port */
15460 mutex_enter(&pmportinfo->pmport_mutex);
15461 SATA_PMPORTINFO_DRV_INFO(pmportinfo) = NULL;
15462 pmportinfo->pmport_dev_type = SATA_DTYPE_NONE;
15463 mutex_exit(&pmportinfo->pmport_mutex);
15464 }
15465 (void) kmem_free((void *)sdinfo, sizeof (sata_drive_info_t));
15466 }
15467
15468 if (qual == SATA_ADDR_CPORT) {
15469 cportinfo->cport_state &= ~(SATA_STATE_PROBED |
15470 SATA_STATE_PROBING);
15471 } else if (qual == SATA_ADDR_PMPORT) {
15472 mutex_enter(&pmportinfo->pmport_mutex);
15473 pmportinfo->pmport_state &= ~(SATA_STATE_PROBED |
15474 SATA_STATE_PROBING);
15475 mutex_exit(&pmportinfo->pmport_mutex);
15476 }
15477 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex);
15478
15479 /* Just let HBA driver to deactivate port */
15480 sata_device->satadev_addr.qual = qual;
15481 rval = (*SATA_PORT_DEACTIVATE_FUNC(sata_hba_inst))
15482 (SATA_DIP(sata_hba_inst), sata_device);
15483
15484 /*
15485 * Generate sysevent - EC_DR / ESC_DR_AP_STATE_CHANGE
15486 * without the hint
15487 */
15488 sata_gen_sysevent(sata_hba_inst, &sata_device->satadev_addr,
15489 SE_NO_HINT);
15490
15491 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex);
15492 sata_update_port_info(sata_hba_inst, sata_device);
15493 if (qual == SATA_ADDR_CPORT) {
15494 if (rval != SATA_SUCCESS) {
15495 /*
15496 * Port deactivation failure - do not change port state
15497 * unless the state returned by HBA indicates a port
15498 * failure.
15499 */
15500 if (sata_device->satadev_state & SATA_PSTATE_FAILED) {
15501 SATA_CPORT_STATE(sata_hba_inst, cport) =
15502 SATA_PSTATE_FAILED;
15503 }
15504 SATA_LOG_D((sata_hba_inst, CE_WARN,
15505 "sata_hba_ioctl: port deactivate: "
15506 "cannot deactivate SATA port %d", cport));
15507 rv = EIO;
15508 } else {
15509 cportinfo->cport_state |= SATA_PSTATE_SHUTDOWN;
15510 }
15511 } else {
15512 mutex_enter(&pmportinfo->pmport_mutex);
15513 if (rval != SATA_SUCCESS) {
15514 if (sata_device->satadev_state & SATA_PSTATE_FAILED) {
15515 SATA_PMPORT_STATE(sata_hba_inst, cport,
15516 pmport) = SATA_PSTATE_FAILED;
15517 }
15518 SATA_LOG_D((sata_hba_inst, CE_WARN,
15519 "sata_hba_ioctl: port deactivate: "
15520 "cannot deactivate SATA port %d:%d",
15521 cport, pmport));
15522 rv = EIO;
15523 } else {
15524 pmportinfo->pmport_state |= SATA_PSTATE_SHUTDOWN;
15525 }
15526 mutex_exit(&pmportinfo->pmport_mutex);
15527 }
15528
15529 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex);
15530
15531 return (rv);
15532 }
15533
15534 /*
15535 * Process ioctl port activate request.
15536 *
15537 * NOTE: Port multiplier is supported now.
15538 */
15539 static int
sata_ioctl_activate(sata_hba_inst_t * sata_hba_inst,sata_device_t * sata_device)15540 sata_ioctl_activate(sata_hba_inst_t *sata_hba_inst,
15541 sata_device_t *sata_device)
15542 {
15543 int cport, pmport, qual;
15544 sata_cport_info_t *cportinfo;
15545 sata_pmport_info_t *pmportinfo = NULL;
15546 boolean_t dev_existed = B_TRUE;
15547
15548 /* Sanity check */
15549 if (SATA_PORT_ACTIVATE_FUNC(sata_hba_inst) == NULL)
15550 return (ENOTSUP);
15551
15552 cport = sata_device->satadev_addr.cport;
15553 pmport = sata_device->satadev_addr.pmport;
15554 qual = sata_device->satadev_addr.qual;
15555
15556 cportinfo = SATA_CPORT_INFO(sata_hba_inst, cport);
15557
15558 /*
15559 * The qual translate from ap_id (by SCSI_TO_SATA_ADDR_QUAL())
15560 * is a device. But what we are dealing with is port/pmport.
15561 */
15562 ASSERT(qual == SATA_ADDR_DCPORT || qual == SATA_ADDR_DPMPORT);
15563 if (qual == SATA_ADDR_DCPORT)
15564 sata_device->satadev_addr.qual = qual = SATA_ADDR_CPORT;
15565 else
15566 sata_device->satadev_addr.qual = qual = SATA_ADDR_PMPORT;
15567
15568 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex);
15569 if (qual == SATA_ADDR_PMPORT) {
15570 pmportinfo = SATA_PMPORT_INFO(sata_hba_inst, cport, pmport);
15571 if (pmportinfo->pmport_state & SATA_PSTATE_SHUTDOWN ||
15572 pmportinfo->pmport_dev_type == SATA_DTYPE_NONE)
15573 dev_existed = B_FALSE;
15574 } else { /* cport */
15575 if (cportinfo->cport_state & SATA_PSTATE_SHUTDOWN ||
15576 cportinfo->cport_dev_type == SATA_DTYPE_NONE)
15577 dev_existed = B_FALSE;
15578 }
15579 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex);
15580
15581 /* Just let HBA driver to activate port, if necessary */
15582 if ((*SATA_PORT_ACTIVATE_FUNC(sata_hba_inst))
15583 (SATA_DIP(sata_hba_inst), sata_device) != SATA_SUCCESS) {
15584 /*
15585 * Port activation failure - do not change port state unless
15586 * the state returned by HBA indicates a port failure.
15587 */
15588 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst,
15589 cport)->cport_mutex);
15590 sata_update_port_info(sata_hba_inst, sata_device);
15591 if (sata_device->satadev_state & SATA_PSTATE_FAILED) {
15592 if (qual == SATA_ADDR_PMPORT) {
15593 mutex_enter(&pmportinfo->pmport_mutex);
15594 pmportinfo->pmport_state = SATA_PSTATE_FAILED;
15595 mutex_exit(&pmportinfo->pmport_mutex);
15596 } else
15597 cportinfo->cport_state = SATA_PSTATE_FAILED;
15598
15599 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst,
15600 cport)->cport_mutex);
15601 SATA_LOG_D((sata_hba_inst, CE_WARN,
15602 "sata_hba_ioctl: port activate: cannot activate "
15603 "SATA port %d:%d", cport, pmport));
15604 return (EIO);
15605 }
15606 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex);
15607 }
15608 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex);
15609 if (qual == SATA_ADDR_PMPORT) {
15610 mutex_enter(&pmportinfo->pmport_mutex);
15611 pmportinfo->pmport_state &= ~SATA_PSTATE_SHUTDOWN;
15612 mutex_exit(&pmportinfo->pmport_mutex);
15613 } else
15614 cportinfo->cport_state &= ~SATA_PSTATE_SHUTDOWN;
15615 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex);
15616
15617 /*
15618 * Re-probe port to find its current state and possibly attached device.
15619 * Port re-probing may change the cportinfo device type if device is
15620 * found attached.
15621 * If port probing failed, the device type would be set to
15622 * SATA_DTYPE_NONE.
15623 */
15624 (void) sata_reprobe_port(sata_hba_inst, sata_device,
15625 SATA_DEV_IDENTIFY_RETRY);
15626
15627 /*
15628 * Generate sysevent - EC_DR / ESC_DR_AP_STATE_CHANGE
15629 * without the hint.
15630 */
15631 sata_gen_sysevent(sata_hba_inst, &sata_device->satadev_addr,
15632 SE_NO_HINT);
15633
15634 if (dev_existed == B_FALSE) {
15635 if (qual == SATA_ADDR_PMPORT &&
15636 pmportinfo->pmport_dev_type != SATA_DTYPE_NONE) {
15637 /*
15638 * That's the transition from the "inactive" port state
15639 * or the active port without a device attached to the
15640 * active port state with a device attached.
15641 */
15642 sata_log(sata_hba_inst, CE_WARN,
15643 "SATA device detected at port %d:%d",
15644 cport, pmport);
15645 } else if (qual == SATA_ADDR_CPORT &&
15646 cportinfo->cport_dev_type != SATA_DTYPE_NONE) {
15647 /*
15648 * That's the transition from the "inactive" port state
15649 * or the active port without a device attached to the
15650 * active port state with a device attached.
15651 */
15652 if (cportinfo->cport_dev_type != SATA_DTYPE_PMULT) {
15653 sata_log(sata_hba_inst, CE_WARN,
15654 "SATA device detected at port %d", cport);
15655 } else {
15656 sata_log(sata_hba_inst, CE_WARN,
15657 "SATA port multiplier detected at port %d",
15658 cport);
15659 }
15660 }
15661 }
15662 return (0);
15663 }
15664
15665
15666
15667 /*
15668 * Process ioctl reset port request.
15669 *
15670 * NOTE: Port-Multiplier is supported.
15671 */
15672 static int
sata_ioctl_reset_port(sata_hba_inst_t * sata_hba_inst,sata_device_t * sata_device)15673 sata_ioctl_reset_port(sata_hba_inst_t *sata_hba_inst,
15674 sata_device_t *sata_device)
15675 {
15676 int cport, pmport, qual;
15677 int rv = 0;
15678
15679 cport = sata_device->satadev_addr.cport;
15680 pmport = sata_device->satadev_addr.pmport;
15681 qual = sata_device->satadev_addr.qual;
15682
15683 /*
15684 * The qual translate from ap_id (by SCSI_TO_SATA_ADDR_QUAL())
15685 * is a device. But what we are dealing with is port/pmport.
15686 */
15687 if (qual == SATA_ADDR_DCPORT)
15688 sata_device->satadev_addr.qual = qual = SATA_ADDR_CPORT;
15689 else
15690 sata_device->satadev_addr.qual = qual = SATA_ADDR_PMPORT;
15691 ASSERT(qual == SATA_ADDR_CPORT || qual == SATA_ADDR_PMPORT);
15692
15693 /* Sanity check */
15694 if (SATA_RESET_DPORT_FUNC(sata_hba_inst) == NULL) {
15695 SATA_LOG_D((sata_hba_inst, CE_WARN,
15696 "sata_hba_ioctl: sata_hba_tran missing required "
15697 "function sata_tran_reset_dport"));
15698 return (ENOTSUP);
15699 }
15700
15701 /* Ask HBA to reset port */
15702 if ((*SATA_RESET_DPORT_FUNC(sata_hba_inst))(SATA_DIP(sata_hba_inst),
15703 sata_device) != SATA_SUCCESS) {
15704 SATA_LOG_D((sata_hba_inst, CE_WARN,
15705 "sata_hba_ioctl: reset port: failed %d:%d",
15706 cport, pmport));
15707 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, cport)->
15708 cport_mutex);
15709 sata_update_port_info(sata_hba_inst, sata_device);
15710 if (qual == SATA_ADDR_CPORT)
15711 SATA_CPORT_STATE(sata_hba_inst, cport) =
15712 SATA_PSTATE_FAILED;
15713 else {
15714 mutex_enter(&SATA_PMPORT_MUTEX(sata_hba_inst, cport,
15715 pmport));
15716 SATA_PMPORT_STATE(sata_hba_inst, cport, pmport) =
15717 SATA_PSTATE_FAILED;
15718 mutex_exit(&SATA_PMPORT_MUTEX(sata_hba_inst, cport,
15719 pmport));
15720 }
15721 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)->
15722 cport_mutex);
15723 rv = EIO;
15724 }
15725
15726 return (rv);
15727 }
15728
15729 /*
15730 * Process ioctl reset device request.
15731 *
15732 * NOTE: Port multiplier is supported.
15733 */
15734 static int
sata_ioctl_reset_device(sata_hba_inst_t * sata_hba_inst,sata_device_t * sata_device)15735 sata_ioctl_reset_device(sata_hba_inst_t *sata_hba_inst,
15736 sata_device_t *sata_device)
15737 {
15738 sata_drive_info_t *sdinfo = NULL;
15739 sata_pmult_info_t *pmultinfo = NULL;
15740 int cport, pmport;
15741 int rv = 0;
15742
15743 /* Sanity check */
15744 if (SATA_RESET_DPORT_FUNC(sata_hba_inst) == NULL) {
15745 SATA_LOG_D((sata_hba_inst, CE_WARN,
15746 "sata_hba_ioctl: sata_hba_tran missing required "
15747 "function sata_tran_reset_dport"));
15748 return (ENOTSUP);
15749 }
15750
15751 cport = sata_device->satadev_addr.cport;
15752 pmport = sata_device->satadev_addr.pmport;
15753
15754 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex);
15755 if (sata_device->satadev_addr.qual == SATA_ADDR_DCPORT) {
15756 if (SATA_CPORT_DEV_TYPE(sata_hba_inst, cport) ==
15757 SATA_DTYPE_PMULT)
15758 pmultinfo = SATA_CPORT_INFO(sata_hba_inst, cport)->
15759 cport_devp.cport_sata_pmult;
15760 else
15761 sdinfo = SATA_CPORT_DRV_INFO(sata_hba_inst,
15762 sata_device->satadev_addr.cport);
15763 } else { /* port multiplier */
15764 sata_device->satadev_addr.qual = SATA_ADDR_DPMPORT;
15765 sdinfo = SATA_PMPORT_DRV_INFO(sata_hba_inst,
15766 sata_device->satadev_addr.cport,
15767 sata_device->satadev_addr.pmport);
15768 }
15769 if (sdinfo == NULL && pmultinfo == NULL) {
15770 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex);
15771 return (EINVAL);
15772 }
15773 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex);
15774
15775 /* Ask HBA to reset device */
15776 if ((*SATA_RESET_DPORT_FUNC(sata_hba_inst))
15777 (SATA_DIP(sata_hba_inst), sata_device) != SATA_SUCCESS) {
15778 SATA_LOG_D((sata_hba_inst, CE_WARN,
15779 "sata_hba_ioctl: reset device: failed at port %d:%d",
15780 cport, pmport));
15781 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, cport)->
15782 cport_mutex);
15783 sata_update_port_info(sata_hba_inst, sata_device);
15784 /*
15785 * Device info structure remains attached. Another device reset
15786 * or port disconnect/connect and re-probing is
15787 * needed to change it's state
15788 */
15789 if (sdinfo != NULL) {
15790 sdinfo->satadrv_state &= ~SATA_STATE_READY;
15791 sdinfo->satadrv_state |= SATA_DSTATE_FAILED;
15792 } else if (pmultinfo != NULL) {
15793 pmultinfo->pmult_state &= ~SATA_STATE_READY;
15794 pmultinfo->pmult_state |= SATA_DSTATE_FAILED;
15795 }
15796
15797 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex);
15798 rv = EIO;
15799 }
15800 /*
15801 * If attached device was a port multiplier, some extra processing
15802 * may be needed to bring it back. SATA specification requies a
15803 * mandatory software reset on host port to reliably enumerate a port
15804 * multiplier, the HBA driver should handle that after reset
15805 * operation.
15806 */
15807 return (rv);
15808 }
15809
15810
15811 /*
15812 * Process ioctl reset all request.
15813 */
15814 static int
sata_ioctl_reset_all(sata_hba_inst_t * sata_hba_inst)15815 sata_ioctl_reset_all(sata_hba_inst_t *sata_hba_inst)
15816 {
15817 sata_device_t sata_device;
15818 int rv = 0;
15819 int tcport;
15820
15821 sata_device.satadev_rev = SATA_DEVICE_REV;
15822
15823 /*
15824 * There is no protection here for configured devices.
15825 */
15826 /* Sanity check */
15827 if (SATA_RESET_DPORT_FUNC(sata_hba_inst) == NULL) {
15828 SATA_LOG_D((sata_hba_inst, CE_WARN,
15829 "sata_hba_ioctl: sata_hba_tran missing required "
15830 "function sata_tran_reset_dport"));
15831 return (ENOTSUP);
15832 }
15833
15834 /*
15835 * Need to lock all ports, not just one.
15836 * If any port is locked by event processing, fail the whole operation.
15837 * One port is already locked, but for simplicity lock it again.
15838 */
15839 for (tcport = 0; tcport < SATA_NUM_CPORTS(sata_hba_inst); tcport++) {
15840 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, tcport)->
15841 cport_mutex);
15842 if (((SATA_CPORT_INFO(sata_hba_inst, tcport)->
15843 cport_event_flags) & SATA_EVNT_LOCK_PORT_BUSY) != 0) {
15844 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, tcport)->
15845 cport_mutex);
15846 rv = EBUSY;
15847 break;
15848 } else {
15849 /*
15850 * It is enough to lock cport in command-based
15851 * switching mode.
15852 */
15853 SATA_CPORT_INFO(sata_hba_inst, tcport)->
15854 cport_event_flags |= SATA_APCTL_LOCK_PORT_BUSY;
15855 }
15856 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, tcport)->
15857 cport_mutex);
15858 }
15859
15860 if (rv == 0) {
15861 /*
15862 * All cports were successfully locked.
15863 * Reset main SATA controller.
15864 * Set the device address to port 0, to have a valid device
15865 * address.
15866 */
15867 sata_device.satadev_addr.qual = SATA_ADDR_CNTRL;
15868 sata_device.satadev_addr.cport = 0;
15869 sata_device.satadev_addr.pmport = 0;
15870
15871 if ((*SATA_RESET_DPORT_FUNC(sata_hba_inst))
15872 (SATA_DIP(sata_hba_inst), &sata_device) != SATA_SUCCESS) {
15873 SATA_LOG_D((sata_hba_inst, CE_WARN,
15874 "sata_hba_ioctl: reset controller failed"));
15875 return (EIO);
15876 }
15877 }
15878 /*
15879 * Unlock all ports
15880 */
15881 for (tcport = 0; tcport < SATA_NUM_CPORTS(sata_hba_inst); tcport++) {
15882 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, tcport)->
15883 cport_mutex);
15884 SATA_CPORT_INFO(sata_hba_inst, tcport)->
15885 cport_event_flags &= ~SATA_APCTL_LOCK_PORT_BUSY;
15886 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, tcport)->
15887 cport_mutex);
15888 }
15889
15890 /*
15891 * This operation returns EFAULT if either reset
15892 * controller failed or a re-probing of any port failed.
15893 */
15894 return (rv);
15895 }
15896
15897
15898 /*
15899 * Process ioctl port self test request.
15900 *
15901 * NOTE: Port multiplier code is not completed nor tested.
15902 */
15903 static int
sata_ioctl_port_self_test(sata_hba_inst_t * sata_hba_inst,sata_device_t * sata_device)15904 sata_ioctl_port_self_test(sata_hba_inst_t *sata_hba_inst,
15905 sata_device_t *sata_device)
15906 {
15907 int cport, pmport, qual;
15908 int rv = 0;
15909
15910 /* Sanity check */
15911 if (SATA_SELFTEST_FUNC(sata_hba_inst) == NULL)
15912 return (ENOTSUP);
15913
15914 cport = sata_device->satadev_addr.cport;
15915 pmport = sata_device->satadev_addr.pmport;
15916 qual = sata_device->satadev_addr.qual;
15917
15918 /*
15919 * There is no protection here for a configured
15920 * device attached to this port.
15921 */
15922
15923 if ((*SATA_SELFTEST_FUNC(sata_hba_inst))
15924 (SATA_DIP(sata_hba_inst), sata_device) != SATA_SUCCESS) {
15925 SATA_LOG_D((sata_hba_inst, CE_WARN,
15926 "sata_hba_ioctl: port selftest: "
15927 "failed port %d:%d", cport, pmport));
15928 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, cport)->
15929 cport_mutex);
15930 sata_update_port_info(sata_hba_inst, sata_device);
15931 if (qual == SATA_ADDR_CPORT)
15932 SATA_CPORT_STATE(sata_hba_inst, cport) =
15933 SATA_PSTATE_FAILED;
15934 else { /* port multiplier device port */
15935 mutex_enter(&SATA_PMPORT_MUTEX(sata_hba_inst,
15936 cport, pmport));
15937 SATA_PMPORT_STATE(sata_hba_inst, cport, pmport) =
15938 SATA_PSTATE_FAILED;
15939 mutex_exit(&SATA_PMPORT_MUTEX(sata_hba_inst,
15940 cport, pmport));
15941 }
15942
15943 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)->
15944 cport_mutex);
15945 return (EIO);
15946 }
15947 /*
15948 * Beacuse the port was reset in the course of testing, it should be
15949 * re-probed and attached device state should be restored. At this
15950 * point the port state is unknown - it's state is HBA-specific.
15951 * Force port re-probing to get it into a known state.
15952 */
15953 if (sata_reprobe_port(sata_hba_inst, sata_device,
15954 SATA_DEV_IDENTIFY_RETRY) != SATA_SUCCESS)
15955 rv = EIO;
15956 return (rv);
15957 }
15958
15959
15960 /*
15961 * sata_cfgadm_state:
15962 * Use the sata port state and state of the target node to figure out
15963 * the cfgadm_state.
15964 *
15965 * The port argument is a value with encoded cport,
15966 * pmport and address qualifier, in the same manner as a scsi target number.
15967 * SCSI_TO_SATA_CPORT macro extracts cport number,
15968 * SCSI_TO_SATA_PMPORT extracts pmport number and
15969 * SCSI_TO_SATA_ADDR_QUAL extracts port mulitplier qualifier flag.
15970 *
15971 * Port multiplier is supported.
15972 */
15973
15974 static void
sata_cfgadm_state(sata_hba_inst_t * sata_hba_inst,int32_t port,devctl_ap_state_t * ap_state)15975 sata_cfgadm_state(sata_hba_inst_t *sata_hba_inst, int32_t port,
15976 devctl_ap_state_t *ap_state)
15977 {
15978 uint8_t cport, pmport, qual;
15979 uint32_t port_state, pmult_state;
15980 uint32_t dev_type;
15981 sata_drive_info_t *sdinfo;
15982
15983 cport = SCSI_TO_SATA_CPORT(port);
15984 pmport = SCSI_TO_SATA_PMPORT(port);
15985 qual = SCSI_TO_SATA_ADDR_QUAL(port);
15986
15987 /* Check cport state */
15988 port_state = SATA_CPORT_STATE(sata_hba_inst, cport);
15989 if (port_state & SATA_PSTATE_SHUTDOWN ||
15990 port_state & SATA_PSTATE_FAILED) {
15991 ap_state->ap_rstate = AP_RSTATE_DISCONNECTED;
15992 ap_state->ap_ostate = AP_OSTATE_UNCONFIGURED;
15993 if (port_state & SATA_PSTATE_FAILED)
15994 ap_state->ap_condition = AP_COND_FAILED;
15995 else
15996 ap_state->ap_condition = AP_COND_UNKNOWN;
15997
15998 return;
15999 }
16000
16001 /* cport state is okay. Now check pmport state */
16002 if (qual == SATA_ADDR_DPMPORT || qual == SATA_ADDR_PMPORT) {
16003 /* Sanity check */
16004 if (SATA_CPORT_DEV_TYPE(sata_hba_inst, cport) !=
16005 SATA_DTYPE_PMULT || SATA_PMPORT_INFO(sata_hba_inst,
16006 cport, pmport) == NULL)
16007 return;
16008 port_state = SATA_PMPORT_STATE(sata_hba_inst, cport, pmport);
16009 if (port_state & SATA_PSTATE_SHUTDOWN ||
16010 port_state & SATA_PSTATE_FAILED) {
16011 ap_state->ap_rstate = AP_RSTATE_DISCONNECTED;
16012 ap_state->ap_ostate = AP_OSTATE_UNCONFIGURED;
16013 if (port_state & SATA_PSTATE_FAILED)
16014 ap_state->ap_condition = AP_COND_FAILED;
16015 else
16016 ap_state->ap_condition = AP_COND_UNKNOWN;
16017
16018 return;
16019 }
16020 }
16021
16022 /* Port is enabled and ready */
16023 if (qual == SATA_ADDR_DCPORT || qual == SATA_ADDR_CPORT)
16024 dev_type = SATA_CPORT_DEV_TYPE(sata_hba_inst, cport);
16025 else
16026 dev_type = SATA_PMPORT_DEV_TYPE(sata_hba_inst, cport, pmport);
16027
16028 switch (dev_type) {
16029 case SATA_DTYPE_NONE:
16030 {
16031 ap_state->ap_ostate = AP_OSTATE_UNCONFIGURED;
16032 ap_state->ap_condition = AP_COND_OK;
16033 /* No device attached */
16034 ap_state->ap_rstate = AP_RSTATE_EMPTY;
16035 break;
16036 }
16037 case SATA_DTYPE_PMULT:
16038 {
16039 /* Need to check port multiplier state */
16040 ASSERT(qual == SATA_ADDR_DCPORT);
16041 pmult_state = SATA_PMULT_INFO(sata_hba_inst, cport)->
16042 pmult_state;
16043 if (pmult_state & (SATA_PSTATE_SHUTDOWN|SATA_PSTATE_FAILED)) {
16044 ap_state->ap_rstate = AP_RSTATE_DISCONNECTED;
16045 ap_state->ap_ostate = AP_OSTATE_UNCONFIGURED;
16046 if (pmult_state & SATA_PSTATE_FAILED)
16047 ap_state->ap_condition = AP_COND_FAILED;
16048 else
16049 ap_state->ap_condition = AP_COND_UNKNOWN;
16050
16051 return;
16052 }
16053
16054 /* Port multiplier is not configurable */
16055 ap_state->ap_ostate = AP_OSTATE_CONFIGURED;
16056 ap_state->ap_rstate = AP_RSTATE_CONNECTED;
16057 ap_state->ap_condition = AP_COND_OK;
16058 break;
16059 }
16060
16061 case SATA_DTYPE_ATADISK:
16062 case SATA_DTYPE_ATAPICD:
16063 case SATA_DTYPE_ATAPITAPE:
16064 case SATA_DTYPE_ATAPIDISK:
16065 {
16066 dev_info_t *tdip = NULL;
16067 dev_info_t *dip = NULL;
16068
16069 dip = SATA_DIP(sata_hba_inst);
16070 tdip = sata_get_target_dip(dip, cport, pmport);
16071 ap_state->ap_rstate = AP_RSTATE_CONNECTED;
16072 if (tdip != NULL) {
16073 ndi_devi_enter(dip);
16074 mutex_enter(&(DEVI(tdip)->devi_lock));
16075 if (DEVI_IS_DEVICE_REMOVED(tdip)) {
16076 /*
16077 * There could be the case where previously
16078 * configured and opened device was removed
16079 * and unknown device was plugged.
16080 * In such case we want to show a device, and
16081 * its configured or unconfigured state but
16082 * indicate unusable condition untill the
16083 * old target node is released and removed.
16084 */
16085 ap_state->ap_condition = AP_COND_UNUSABLE;
16086 } else {
16087 mutex_enter(&SATA_CPORT_MUTEX(sata_hba_inst,
16088 cport));
16089 sdinfo = SATA_CPORT_DRV_INFO(sata_hba_inst,
16090 cport);
16091 if (sdinfo != NULL) {
16092 if ((sdinfo->satadrv_state &
16093 SATA_DSTATE_FAILED) != 0)
16094 ap_state->ap_condition =
16095 AP_COND_FAILED;
16096 else
16097 ap_state->ap_condition =
16098 AP_COND_OK;
16099 } else {
16100 ap_state->ap_condition =
16101 AP_COND_UNKNOWN;
16102 }
16103 mutex_exit(&SATA_CPORT_MUTEX(sata_hba_inst,
16104 cport));
16105 }
16106 if ((DEVI_IS_DEVICE_OFFLINE(tdip)) ||
16107 (DEVI_IS_DEVICE_DOWN(tdip))) {
16108 ap_state->ap_ostate =
16109 AP_OSTATE_UNCONFIGURED;
16110 } else {
16111 ap_state->ap_ostate =
16112 AP_OSTATE_CONFIGURED;
16113 }
16114 mutex_exit(&(DEVI(tdip)->devi_lock));
16115 ndi_devi_exit(dip);
16116 } else {
16117 ap_state->ap_ostate = AP_OSTATE_UNCONFIGURED;
16118 ap_state->ap_condition = AP_COND_UNKNOWN;
16119 }
16120 break;
16121 }
16122 case SATA_DTYPE_ATAPIPROC:
16123 ap_state->ap_rstate = AP_RSTATE_CONNECTED;
16124 ap_state->ap_ostate = AP_OSTATE_UNCONFIGURED;
16125 ap_state->ap_condition = AP_COND_OK;
16126 break;
16127 default:
16128 ap_state->ap_rstate = AP_RSTATE_CONNECTED;
16129 ap_state->ap_ostate = AP_OSTATE_UNCONFIGURED;
16130 ap_state->ap_condition = AP_COND_UNKNOWN;
16131 /*
16132 * This is actually internal error condition (non fatal),
16133 * because we have already checked all defined device types.
16134 */
16135 SATA_LOG_D((sata_hba_inst, CE_WARN,
16136 "sata_cfgadm_state: Internal error: "
16137 "unknown device type"));
16138 break;
16139 }
16140 }
16141
16142
16143 /*
16144 * Process ioctl get device path request.
16145 *
16146 * NOTE: Port multiplier has no target dip. Devices connected to port
16147 * multiplier have target node attached to the HBA node. The only difference
16148 * between them and the directly-attached device node is a target address.
16149 */
16150 static int
sata_ioctl_get_device_path(sata_hba_inst_t * sata_hba_inst,sata_device_t * sata_device,sata_ioctl_data_t * ioc,int mode)16151 sata_ioctl_get_device_path(sata_hba_inst_t *sata_hba_inst,
16152 sata_device_t *sata_device, sata_ioctl_data_t *ioc, int mode)
16153 {
16154 char path[MAXPATHLEN];
16155 uint32_t size;
16156 dev_info_t *tdip;
16157
16158 (void) strcpy(path, "/devices");
16159 if ((tdip = sata_get_scsi_target_dip(SATA_DIP(sata_hba_inst),
16160 &sata_device->satadev_addr)) == NULL) {
16161 /*
16162 * No such device. If this is a request for a size, do not
16163 * return EINVAL for non-existing target, because cfgadm
16164 * will then indicate a meaningless ioctl failure.
16165 * If this is a request for a path, indicate invalid
16166 * argument.
16167 */
16168 if (ioc->get_size == 0)
16169 return (EINVAL);
16170 } else {
16171 (void) ddi_pathname(tdip, path + strlen(path));
16172 }
16173 size = strlen(path) + 1;
16174
16175 if (ioc->get_size != 0) {
16176 if (ddi_copyout((void *)&size, ioc->buf, ioc->bufsiz,
16177 mode) != 0)
16178 return (EFAULT);
16179 } else {
16180 if (ioc->bufsiz != size)
16181 return (EINVAL);
16182
16183 else if (ddi_copyout((void *)&path, ioc->buf, ioc->bufsiz,
16184 mode) != 0)
16185 return (EFAULT);
16186 }
16187 return (0);
16188 }
16189
16190 /*
16191 * Process ioctl get attachment point type request.
16192 *
16193 * NOTE: Port multiplier is supported.
16194 */
16195 static int
sata_ioctl_get_ap_type(sata_hba_inst_t * sata_hba_inst,sata_device_t * sata_device,sata_ioctl_data_t * ioc,int mode)16196 sata_ioctl_get_ap_type(sata_hba_inst_t *sata_hba_inst,
16197 sata_device_t *sata_device, sata_ioctl_data_t *ioc, int mode)
16198 {
16199 uint32_t type_len;
16200 const char *ap_type;
16201 int dev_type;
16202
16203 if (sata_device->satadev_addr.qual == SATA_ADDR_DCPORT)
16204 dev_type = SATA_CPORT_DEV_TYPE(sata_hba_inst,
16205 sata_device->satadev_addr.cport);
16206 else /* pmport */
16207 dev_type = SATA_PMPORT_DEV_TYPE(sata_hba_inst,
16208 sata_device->satadev_addr.cport,
16209 sata_device->satadev_addr.pmport);
16210
16211 switch (dev_type) {
16212 case SATA_DTYPE_NONE:
16213 ap_type = "port";
16214 break;
16215
16216 case SATA_DTYPE_ATADISK:
16217 case SATA_DTYPE_ATAPIDISK:
16218 ap_type = "disk";
16219 break;
16220
16221 case SATA_DTYPE_ATAPICD:
16222 ap_type = "cd/dvd";
16223 break;
16224
16225 case SATA_DTYPE_ATAPITAPE:
16226 ap_type = "tape";
16227 break;
16228
16229 case SATA_DTYPE_ATAPIPROC:
16230 ap_type = "processor";
16231 break;
16232
16233 case SATA_DTYPE_PMULT:
16234 ap_type = "sata-pmult";
16235 break;
16236
16237 case SATA_DTYPE_UNKNOWN:
16238 ap_type = "unknown";
16239 break;
16240
16241 default:
16242 ap_type = "unsupported";
16243 break;
16244
16245 } /* end of dev_type switch */
16246
16247 type_len = strlen(ap_type) + 1;
16248
16249 if (ioc->get_size) {
16250 if (ddi_copyout((void *)&type_len, ioc->buf, ioc->bufsiz,
16251 mode) != 0)
16252 return (EFAULT);
16253 } else {
16254 if (ioc->bufsiz != type_len)
16255 return (EINVAL);
16256
16257 if (ddi_copyout((void *)ap_type, ioc->buf,
16258 ioc->bufsiz, mode) != 0)
16259 return (EFAULT);
16260 }
16261 return (0);
16262
16263 }
16264
16265 /*
16266 * Process ioctl get device model info request.
16267 * This operation should return to cfgadm the device model
16268 * information string
16269 *
16270 * NOTE: Port multiplier is supported.
16271 */
16272 static int
sata_ioctl_get_model_info(sata_hba_inst_t * sata_hba_inst,sata_device_t * sata_device,sata_ioctl_data_t * ioc,int mode)16273 sata_ioctl_get_model_info(sata_hba_inst_t *sata_hba_inst,
16274 sata_device_t *sata_device, sata_ioctl_data_t *ioc, int mode)
16275 {
16276 sata_drive_info_t *sdinfo;
16277 uint32_t info_len;
16278 char ap_info[SATA_ID_MODEL_LEN + 1];
16279
16280 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst,
16281 sata_device->satadev_addr.cport)->cport_mutex);
16282 if (sata_device->satadev_addr.qual == SATA_ADDR_DCPORT)
16283 sdinfo = SATA_CPORT_DRV_INFO(sata_hba_inst,
16284 sata_device->satadev_addr.cport);
16285 else /* port multiplier */
16286 sdinfo = SATA_PMPORT_DRV_INFO(sata_hba_inst,
16287 sata_device->satadev_addr.cport,
16288 sata_device->satadev_addr.pmport);
16289 if (sdinfo == NULL) {
16290 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst,
16291 sata_device->satadev_addr.cport)->cport_mutex);
16292 return (EINVAL);
16293 }
16294
16295 #ifdef _LITTLE_ENDIAN
16296 swab(sdinfo->satadrv_id.ai_model, ap_info, SATA_ID_MODEL_LEN);
16297 #else /* _LITTLE_ENDIAN */
16298 bcopy(sdinfo->satadrv_id.ai_model, ap_info, SATA_ID_MODEL_LEN);
16299 #endif /* _LITTLE_ENDIAN */
16300
16301 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst,
16302 sata_device->satadev_addr.cport)->cport_mutex);
16303
16304 ap_info[SATA_ID_MODEL_LEN] = '\0';
16305
16306 info_len = strlen(ap_info) + 1;
16307
16308 if (ioc->get_size) {
16309 if (ddi_copyout((void *)&info_len, ioc->buf, ioc->bufsiz,
16310 mode) != 0)
16311 return (EFAULT);
16312 } else {
16313 if (ioc->bufsiz < info_len)
16314 return (EINVAL);
16315 if (ddi_copyout((void *)ap_info, ioc->buf, ioc->bufsiz,
16316 mode) != 0)
16317 return (EFAULT);
16318 }
16319 return (0);
16320 }
16321
16322
16323 /*
16324 * Process ioctl get device firmware revision info request.
16325 * This operation should return to cfgadm the device firmware revision
16326 * information string
16327 *
16328 * Port multiplier is supported.
16329 */
16330 static int
sata_ioctl_get_revfirmware_info(sata_hba_inst_t * sata_hba_inst,sata_device_t * sata_device,sata_ioctl_data_t * ioc,int mode)16331 sata_ioctl_get_revfirmware_info(sata_hba_inst_t *sata_hba_inst,
16332 sata_device_t *sata_device, sata_ioctl_data_t *ioc, int mode)
16333 {
16334 sata_drive_info_t *sdinfo;
16335 uint32_t info_len;
16336 char ap_info[SATA_ID_FW_LEN + 1];
16337
16338 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst,
16339 sata_device->satadev_addr.cport)->cport_mutex);
16340 if (sata_device->satadev_addr.qual == SATA_ADDR_DCPORT)
16341 sdinfo = SATA_CPORT_DRV_INFO(sata_hba_inst,
16342 sata_device->satadev_addr.cport);
16343 else /* port multiplier */
16344 sdinfo = SATA_PMPORT_DRV_INFO(sata_hba_inst,
16345 sata_device->satadev_addr.cport,
16346 sata_device->satadev_addr.pmport);
16347 if (sdinfo == NULL) {
16348 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst,
16349 sata_device->satadev_addr.cport)->cport_mutex);
16350 return (EINVAL);
16351 }
16352
16353 #ifdef _LITTLE_ENDIAN
16354 swab(sdinfo->satadrv_id.ai_fw, ap_info, SATA_ID_FW_LEN);
16355 #else /* _LITTLE_ENDIAN */
16356 bcopy(sdinfo->satadrv_id.ai_fw, ap_info, SATA_ID_FW_LEN);
16357 #endif /* _LITTLE_ENDIAN */
16358
16359 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst,
16360 sata_device->satadev_addr.cport)->cport_mutex);
16361
16362 ap_info[SATA_ID_FW_LEN] = '\0';
16363
16364 info_len = strlen(ap_info) + 1;
16365
16366 if (ioc->get_size) {
16367 if (ddi_copyout((void *)&info_len, ioc->buf, ioc->bufsiz,
16368 mode) != 0)
16369 return (EFAULT);
16370 } else {
16371 if (ioc->bufsiz < info_len)
16372 return (EINVAL);
16373 if (ddi_copyout((void *)ap_info, ioc->buf, ioc->bufsiz,
16374 mode) != 0)
16375 return (EFAULT);
16376 }
16377 return (0);
16378 }
16379
16380
16381 /*
16382 * Process ioctl get device serial number info request.
16383 * This operation should return to cfgadm the device serial number string.
16384 *
16385 * NOTE: Port multiplier is supported.
16386 */
16387 static int
sata_ioctl_get_serialnumber_info(sata_hba_inst_t * sata_hba_inst,sata_device_t * sata_device,sata_ioctl_data_t * ioc,int mode)16388 sata_ioctl_get_serialnumber_info(sata_hba_inst_t *sata_hba_inst,
16389 sata_device_t *sata_device, sata_ioctl_data_t *ioc, int mode)
16390 {
16391 sata_drive_info_t *sdinfo;
16392 uint32_t info_len;
16393 char ap_info[SATA_ID_SERIAL_LEN + 1];
16394
16395 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst,
16396 sata_device->satadev_addr.cport)->cport_mutex);
16397 if (sata_device->satadev_addr.qual == SATA_ADDR_DCPORT)
16398 sdinfo = SATA_CPORT_DRV_INFO(sata_hba_inst,
16399 sata_device->satadev_addr.cport);
16400 else /* port multiplier */
16401 sdinfo = SATA_PMPORT_DRV_INFO(sata_hba_inst,
16402 sata_device->satadev_addr.cport,
16403 sata_device->satadev_addr.pmport);
16404 if (sdinfo == NULL) {
16405 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst,
16406 sata_device->satadev_addr.cport)->cport_mutex);
16407 return (EINVAL);
16408 }
16409
16410 #ifdef _LITTLE_ENDIAN
16411 swab(sdinfo->satadrv_id.ai_drvser, ap_info, SATA_ID_SERIAL_LEN);
16412 #else /* _LITTLE_ENDIAN */
16413 bcopy(sdinfo->satadrv_id.ai_drvser, ap_info, SATA_ID_SERIAL_LEN);
16414 #endif /* _LITTLE_ENDIAN */
16415
16416 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst,
16417 sata_device->satadev_addr.cport)->cport_mutex);
16418
16419 ap_info[SATA_ID_SERIAL_LEN] = '\0';
16420
16421 info_len = strlen(ap_info) + 1;
16422
16423 if (ioc->get_size) {
16424 if (ddi_copyout((void *)&info_len, ioc->buf, ioc->bufsiz,
16425 mode) != 0)
16426 return (EFAULT);
16427 } else {
16428 if (ioc->bufsiz < info_len)
16429 return (EINVAL);
16430 if (ddi_copyout((void *)ap_info, ioc->buf, ioc->bufsiz,
16431 mode) != 0)
16432 return (EFAULT);
16433 }
16434 return (0);
16435 }
16436
16437
16438 /*
16439 * Preset scsi extended sense data (to NO SENSE)
16440 * First 18 bytes of the sense data are preset to current valid sense
16441 * with a key NO SENSE data.
16442 *
16443 * Returns void
16444 */
16445 static void
sata_fixed_sense_data_preset(struct scsi_extended_sense * sense)16446 sata_fixed_sense_data_preset(struct scsi_extended_sense *sense)
16447 {
16448 sense->es_valid = 1; /* Valid sense */
16449 sense->es_class = CLASS_EXTENDED_SENSE; /* 0x70 - current err */
16450 sense->es_key = KEY_NO_SENSE;
16451 sense->es_info_1 = 0;
16452 sense->es_info_2 = 0;
16453 sense->es_info_3 = 0;
16454 sense->es_info_4 = 0;
16455 sense->es_add_len = 10; /* Additional length - replace with a def */
16456 sense->es_cmd_info[0] = 0;
16457 sense->es_cmd_info[1] = 0;
16458 sense->es_cmd_info[2] = 0;
16459 sense->es_cmd_info[3] = 0;
16460 sense->es_add_code = 0;
16461 sense->es_qual_code = 0;
16462 }
16463
16464 /*
16465 * Register a legacy cmdk-style devid for the target (disk) device.
16466 *
16467 * Note: This function is called only when the HBA devinfo node has the
16468 * property "use-cmdk-devid-format" set. This property indicates that
16469 * devid compatible with old cmdk (target) driver is to be generated
16470 * for any target device attached to this controller. This will take
16471 * precedence over the devid generated by sd (target) driver.
16472 * This function is derived from cmdk_devid_setup() function in cmdk.c.
16473 */
16474 static void
sata_target_devid_register(dev_info_t * dip,sata_drive_info_t * sdinfo)16475 sata_target_devid_register(dev_info_t *dip, sata_drive_info_t *sdinfo)
16476 {
16477 char *hwid;
16478 int modlen;
16479 int serlen;
16480 int rval;
16481 ddi_devid_t devid;
16482
16483 /*
16484 * device ID is a concatanation of model number, "=", serial number.
16485 */
16486 hwid = kmem_zalloc(LEGACY_HWID_LEN, KM_SLEEP);
16487 bcopy(&sdinfo->satadrv_id.ai_model, hwid,
16488 sizeof (sdinfo->satadrv_id.ai_model));
16489 swab(hwid, hwid, sizeof (sdinfo->satadrv_id.ai_model));
16490 modlen = sata_check_modser(hwid, sizeof (sdinfo->satadrv_id.ai_model));
16491 if (modlen == 0)
16492 goto err;
16493 hwid[modlen++] = '=';
16494 bcopy(&sdinfo->satadrv_id.ai_drvser, &hwid[modlen],
16495 sizeof (sdinfo->satadrv_id.ai_drvser));
16496 swab(&hwid[modlen], &hwid[modlen],
16497 sizeof (sdinfo->satadrv_id.ai_drvser));
16498 serlen = sata_check_modser(&hwid[modlen],
16499 sizeof (sdinfo->satadrv_id.ai_drvser));
16500 if (serlen == 0)
16501 goto err;
16502 hwid[modlen + serlen] = 0; /* terminate the hwid string */
16503
16504 /* initialize/register devid */
16505 if ((rval = ddi_devid_init(dip, DEVID_ATA_SERIAL,
16506 (ushort_t)(modlen + serlen), hwid, &devid)) == DDI_SUCCESS) {
16507 rval = ddi_devid_register(dip, devid);
16508 /*
16509 * Free up the allocated devid buffer.
16510 * NOTE: This doesn't mean unregistering devid.
16511 */
16512 ddi_devid_free(devid);
16513 }
16514
16515 if (rval != DDI_SUCCESS)
16516 cmn_err(CE_WARN, "sata: failed to create devid for the disk"
16517 " on port %d", sdinfo->satadrv_addr.cport);
16518 err:
16519 kmem_free(hwid, LEGACY_HWID_LEN);
16520 }
16521
16522 /*
16523 * valid model/serial string must contain a non-zero non-space characters.
16524 * trim trailing spaces/NULLs.
16525 */
16526 static int
sata_check_modser(char * buf,int buf_len)16527 sata_check_modser(char *buf, int buf_len)
16528 {
16529 boolean_t ret;
16530 char *s;
16531 int i;
16532 int tb;
16533 char ch;
16534
16535 ret = B_FALSE;
16536 s = buf;
16537 for (i = 0; i < buf_len; i++) {
16538 ch = *s++;
16539 if (ch != ' ' && ch != '\0')
16540 tb = i + 1;
16541 if (ch != ' ' && ch != '\0' && ch != '0')
16542 ret = B_TRUE;
16543 }
16544
16545 if (ret == B_FALSE)
16546 return (0); /* invalid string */
16547
16548 return (tb); /* return length */
16549 }
16550
16551 /*
16552 * sata_set_drive_features function compares current device features setting
16553 * with the saved device features settings and, if there is a difference,
16554 * it restores device features setting to the previously saved state.
16555 * It also arbitrarily tries to select the highest supported DMA mode.
16556 * Device Identify or Identify Packet Device data has to be current.
16557 * At the moment read ahead and write cache are considered for all devices.
16558 * For atapi devices, Removable Media Status Notification is set in addition
16559 * to common features.
16560 *
16561 * This function cannot be called in the interrupt context (it may sleep).
16562 *
16563 * The input argument sdinfo should point to the drive info structure
16564 * to be updated after features are set. Note, that only
16565 * device (packet) identify data is updated, not the flags indicating the
16566 * supported features.
16567 *
16568 * Returns SATA_SUCCESS if successful or there was nothing to do.
16569 * Device Identify data in the drive info structure pointed to by the sdinfo
16570 * arguments is updated even when no features were set or changed.
16571 *
16572 * Returns SATA_FAILURE if device features could not be set or DMA mode
16573 * for a disk cannot be set and device identify data cannot be fetched.
16574 *
16575 * Returns SATA_RETRY if device features could not be set (other than disk
16576 * DMA mode) but the device identify data was fetched successfully.
16577 *
16578 * Note: This function may fail the port, making it inaccessible.
16579 * In such case the explicit port disconnect/connect or physical device
16580 * detach/attach is required to re-evaluate port state again.
16581 */
16582
16583 static int
sata_set_drive_features(sata_hba_inst_t * sata_hba_inst,sata_drive_info_t * sdinfo,int restore)16584 sata_set_drive_features(sata_hba_inst_t *sata_hba_inst,
16585 sata_drive_info_t *sdinfo, int restore)
16586 {
16587 int rval = SATA_SUCCESS;
16588 int rval_set;
16589 sata_drive_info_t new_sdinfo;
16590 char *finfo = "sata_set_drive_features: cannot";
16591 char *finfox;
16592 int cache_op;
16593
16594 bzero(&new_sdinfo, sizeof (sata_drive_info_t));
16595 new_sdinfo.satadrv_addr = sdinfo->satadrv_addr;
16596 new_sdinfo.satadrv_type = sdinfo->satadrv_type;
16597 if (sata_fetch_device_identify_data(sata_hba_inst, &new_sdinfo) != 0) {
16598 /*
16599 * Cannot get device identification - caller may retry later
16600 */
16601 SATADBG1(SATA_DBG_DEV_SETTINGS, sata_hba_inst,
16602 "%s fetch device identify data\n", finfo);
16603 return (SATA_FAILURE);
16604 }
16605 finfox = (restore != 0) ? " restore device features" :
16606 " initialize device features\n";
16607
16608 switch (sdinfo->satadrv_type) {
16609 case SATA_DTYPE_ATADISK:
16610 /* Arbitrarily set UDMA mode */
16611 if (sata_set_dma_mode(sata_hba_inst, &new_sdinfo) !=
16612 SATA_SUCCESS) {
16613 SATA_LOG_D((sata_hba_inst, CE_WARN,
16614 "%s set UDMA mode\n", finfo));
16615 return (SATA_FAILURE);
16616 }
16617 break;
16618 case SATA_DTYPE_ATAPICD:
16619 case SATA_DTYPE_ATAPITAPE:
16620 case SATA_DTYPE_ATAPIDISK:
16621 /* Set Removable Media Status Notification, if necessary */
16622 if (SATA_RM_NOTIFIC_SUPPORTED(new_sdinfo.satadrv_id) &&
16623 restore != 0) {
16624 if (((sdinfo->satadrv_settings & SATA_DEV_RMSN) &&
16625 (!SATA_RM_NOTIFIC_ENABLED(new_sdinfo.satadrv_id)))||
16626 ((!(sdinfo->satadrv_settings & SATA_DEV_RMSN)) &&
16627 SATA_RM_NOTIFIC_ENABLED(new_sdinfo.satadrv_id))) {
16628 /* Current setting does not match saved one */
16629 if (sata_set_rmsn(sata_hba_inst, sdinfo,
16630 sdinfo->satadrv_settings &
16631 SATA_DEV_RMSN) != SATA_SUCCESS)
16632 rval = SATA_FAILURE;
16633 }
16634 }
16635 /*
16636 * We have to set Multiword DMA or UDMA, if it is supported, as
16637 * we want to use DMA transfer mode whenever possible.
16638 * Some devices require explicit setting of the DMA mode.
16639 */
16640 if (new_sdinfo.satadrv_id.ai_cap & SATA_DMA_SUPPORT) {
16641 /* Set highest supported DMA mode */
16642 if (sata_set_dma_mode(sata_hba_inst, &new_sdinfo) !=
16643 SATA_SUCCESS) {
16644 SATA_LOG_D((sata_hba_inst, CE_WARN,
16645 "%s set UDMA mode\n", finfo));
16646 rval = SATA_FAILURE;
16647 }
16648 }
16649 break;
16650 }
16651
16652 if (!SATA_READ_AHEAD_SUPPORTED(new_sdinfo.satadrv_id) &&
16653 !SATA_WRITE_CACHE_SUPPORTED(new_sdinfo.satadrv_id)) {
16654 /*
16655 * neither READ AHEAD nor WRITE CACHE is supported
16656 * - do nothing
16657 */
16658 SATADBG1(SATA_DBG_DEV_SETTINGS, sata_hba_inst,
16659 "settable features not supported\n", NULL);
16660 goto update_sdinfo;
16661 }
16662
16663 if ((SATA_READ_AHEAD_ENABLED(new_sdinfo.satadrv_id) &&
16664 (sdinfo->satadrv_settings & SATA_DEV_READ_AHEAD)) &&
16665 (SATA_WRITE_CACHE_ENABLED(new_sdinfo.satadrv_id) &&
16666 (sdinfo->satadrv_settings & SATA_DEV_WRITE_CACHE))) {
16667 /*
16668 * both READ AHEAD and WRITE CACHE are enabled
16669 * - Nothing to do
16670 */
16671 SATADBG1(SATA_DBG_DEV_SETTINGS, sata_hba_inst,
16672 "no device features to set\n", NULL);
16673 goto update_sdinfo;
16674 }
16675
16676 cache_op = 0;
16677
16678 if (SATA_READ_AHEAD_SUPPORTED(new_sdinfo.satadrv_id)) {
16679 if ((sdinfo->satadrv_settings & SATA_DEV_READ_AHEAD) &&
16680 !SATA_READ_AHEAD_ENABLED(new_sdinfo.satadrv_id)) {
16681 /* Enable read ahead / read cache */
16682 cache_op = SATAC_SF_ENABLE_READ_AHEAD;
16683 SATADBG1(SATA_DBG_DEV_SETTINGS, sata_hba_inst,
16684 "enabling read cache\n", NULL);
16685 } else if (!(sdinfo->satadrv_settings & SATA_DEV_READ_AHEAD) &&
16686 SATA_READ_AHEAD_ENABLED(new_sdinfo.satadrv_id)) {
16687 /* Disable read ahead / read cache */
16688 cache_op = SATAC_SF_DISABLE_READ_AHEAD;
16689 SATADBG1(SATA_DBG_DEV_SETTINGS, sata_hba_inst,
16690 "disabling read cache\n", NULL);
16691 }
16692
16693 if (cache_op != 0) {
16694 /* Try to set read cache mode */
16695 rval_set = sata_set_cache_mode(sata_hba_inst,
16696 &new_sdinfo, cache_op);
16697 if (rval != SATA_FAILURE && rval_set != SATA_SUCCESS)
16698 rval = rval_set;
16699 }
16700 }
16701
16702 cache_op = 0;
16703
16704 if (SATA_WRITE_CACHE_SUPPORTED(new_sdinfo.satadrv_id)) {
16705 if ((sdinfo->satadrv_settings & SATA_DEV_WRITE_CACHE) &&
16706 !SATA_WRITE_CACHE_ENABLED(new_sdinfo.satadrv_id)) {
16707 /* Enable write cache */
16708 cache_op = SATAC_SF_ENABLE_WRITE_CACHE;
16709 SATADBG1(SATA_DBG_DEV_SETTINGS, sata_hba_inst,
16710 "enabling write cache\n", NULL);
16711 } else if (!(sdinfo->satadrv_settings & SATA_DEV_WRITE_CACHE) &&
16712 SATA_WRITE_CACHE_ENABLED(new_sdinfo.satadrv_id)) {
16713 /* Disable write cache */
16714 cache_op = SATAC_SF_DISABLE_WRITE_CACHE;
16715 SATADBG1(SATA_DBG_DEV_SETTINGS, sata_hba_inst,
16716 "disabling write cache\n", NULL);
16717 }
16718
16719 if (cache_op != 0) {
16720 /* Try to set write cache mode */
16721 rval_set = sata_set_cache_mode(sata_hba_inst,
16722 &new_sdinfo, cache_op);
16723 if (rval != SATA_FAILURE && rval_set != SATA_SUCCESS)
16724 rval = rval_set;
16725 }
16726 }
16727 if (rval != SATA_SUCCESS)
16728 SATA_LOG_D((sata_hba_inst, CE_WARN,
16729 "%s %s", finfo, finfox));
16730
16731 update_sdinfo:
16732 /*
16733 * We need to fetch Device Identify data again
16734 */
16735 if (sata_fetch_device_identify_data(sata_hba_inst, &new_sdinfo) != 0) {
16736 /*
16737 * Cannot get device identification - retry later
16738 */
16739 SATA_LOG_D((sata_hba_inst, CE_WARN,
16740 "%s re-fetch device identify data\n", finfo));
16741 rval = SATA_FAILURE;
16742 }
16743 /* Copy device sata info. */
16744 sdinfo->satadrv_id = new_sdinfo.satadrv_id;
16745
16746 return (rval);
16747 }
16748
16749
16750 /*
16751 *
16752 * Returns 1 if threshold exceeded, 0 if threshold not exceeded, -1 if
16753 * unable to determine.
16754 *
16755 * Cannot be called in an interrupt context.
16756 *
16757 * Called by sata_build_lsense_page_2f()
16758 */
16759
16760 static int
sata_fetch_smart_return_status(sata_hba_inst_t * sata_hba_inst,sata_drive_info_t * sdinfo)16761 sata_fetch_smart_return_status(sata_hba_inst_t *sata_hba_inst,
16762 sata_drive_info_t *sdinfo)
16763 {
16764 sata_pkt_t *spkt;
16765 sata_cmd_t *scmd;
16766 sata_pkt_txlate_t *spx;
16767 int rval;
16768
16769 spx = kmem_zalloc(sizeof (sata_pkt_txlate_t), KM_SLEEP);
16770 spx->txlt_sata_hba_inst = sata_hba_inst;
16771 spx->txlt_scsi_pkt = NULL; /* No scsi pkt involved */
16772 spkt = sata_pkt_alloc(spx, SLEEP_FUNC);
16773 if (spkt == NULL) {
16774 kmem_free(spx, sizeof (sata_pkt_txlate_t));
16775 return (-1);
16776 }
16777 /* address is needed now */
16778 spkt->satapkt_device.satadev_addr = sdinfo->satadrv_addr;
16779
16780
16781 /* Fill sata_pkt */
16782 spkt->satapkt_device.satadev_addr = sdinfo->satadrv_addr;
16783 spkt->satapkt_op_mode = SATA_OPMODE_SYNCH | SATA_OPMODE_INTERRUPTS;
16784 /* Synchronous mode, no callback */
16785 spkt->satapkt_comp = NULL;
16786 /* Timeout 30s */
16787 spkt->satapkt_time = sata_default_pkt_time;
16788
16789 scmd = &spkt->satapkt_cmd;
16790 scmd->satacmd_flags.sata_special_regs = B_TRUE;
16791 scmd->satacmd_flags.sata_data_direction = SATA_DIR_NODATA_XFER;
16792
16793 /* Set up which registers need to be returned */
16794 scmd->satacmd_flags.sata_copy_out_lba_mid_lsb = B_TRUE;
16795 scmd->satacmd_flags.sata_copy_out_lba_high_lsb = B_TRUE;
16796
16797 /* Build SMART_RETURN_STATUS cmd in the sata_pkt */
16798 scmd->satacmd_addr_type = 0; /* N/A */
16799 scmd->satacmd_sec_count_lsb = 0; /* N/A */
16800 scmd->satacmd_lba_low_lsb = 0; /* N/A */
16801 scmd->satacmd_lba_mid_lsb = SMART_MAGIC_VAL_1;
16802 scmd->satacmd_lba_high_lsb = SMART_MAGIC_VAL_2;
16803 scmd->satacmd_features_reg = SATA_SMART_RETURN_STATUS;
16804 scmd->satacmd_device_reg = 0; /* Always device 0 */
16805 scmd->satacmd_cmd_reg = SATAC_SMART;
16806 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst,
16807 sdinfo->satadrv_addr.cport)));
16808
16809
16810 /* Send pkt to SATA HBA driver */
16811 if ((*SATA_START_FUNC(sata_hba_inst))(SATA_DIP(sata_hba_inst), spkt) !=
16812 SATA_TRAN_ACCEPTED ||
16813 spkt->satapkt_reason != SATA_PKT_COMPLETED) {
16814 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst,
16815 sdinfo->satadrv_addr.cport)));
16816 /*
16817 * Whoops, no SMART RETURN STATUS
16818 */
16819 rval = -1;
16820 } else {
16821 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst,
16822 sdinfo->satadrv_addr.cport)));
16823 if (scmd->satacmd_error_reg & SATA_ERROR_ABORT) {
16824 rval = -1;
16825 goto fail;
16826 }
16827 if (scmd->satacmd_status_reg & SATA_STATUS_ERR) {
16828 rval = -1;
16829 goto fail;
16830 }
16831 if ((scmd->satacmd_lba_mid_lsb == SMART_MAGIC_VAL_1) &&
16832 (scmd->satacmd_lba_high_lsb == SMART_MAGIC_VAL_2))
16833 rval = 0;
16834 else if ((scmd->satacmd_lba_mid_lsb == SMART_MAGIC_VAL_3) &&
16835 (scmd->satacmd_lba_high_lsb == SMART_MAGIC_VAL_4))
16836 rval = 1;
16837 else {
16838 rval = -1;
16839 goto fail;
16840 }
16841 }
16842 fail:
16843 /* Free allocated resources */
16844 sata_pkt_free(spx);
16845 kmem_free(spx, sizeof (sata_pkt_txlate_t));
16846
16847 return (rval);
16848 }
16849
16850 /*
16851 *
16852 * Returns 0 if succeeded, -1 otherwise
16853 *
16854 * Cannot be called in an interrupt context.
16855 *
16856 */
16857 static int
sata_fetch_smart_data(sata_hba_inst_t * sata_hba_inst,sata_drive_info_t * sdinfo,struct smart_data * smart_data)16858 sata_fetch_smart_data(sata_hba_inst_t *sata_hba_inst, sata_drive_info_t *sdinfo,
16859 struct smart_data *smart_data)
16860 {
16861 sata_pkt_t *spkt;
16862 sata_cmd_t *scmd;
16863 sata_pkt_txlate_t *spx;
16864 int rval = 0;
16865 dev_info_t *dip = SATA_DIP(sata_hba_inst);
16866
16867 #if ! defined(lint)
16868 ASSERT(sizeof (struct smart_data) == 512);
16869 #endif
16870
16871 spx = kmem_zalloc(sizeof (sata_pkt_txlate_t), KM_SLEEP);
16872 spx->txlt_sata_hba_inst = sata_hba_inst;
16873 spx->txlt_scsi_pkt = NULL; /* No scsi pkt involved */
16874 spkt = sata_pkt_alloc(spx, SLEEP_FUNC);
16875 if (spkt == NULL) {
16876 kmem_free(spx, sizeof (sata_pkt_txlate_t));
16877 return (-1);
16878 }
16879 /* address is needed now */
16880 spkt->satapkt_device.satadev_addr = sdinfo->satadrv_addr;
16881
16882
16883 /* Fill sata_pkt */
16884 spkt->satapkt_device.satadev_addr = sdinfo->satadrv_addr;
16885 spkt->satapkt_op_mode = SATA_OPMODE_SYNCH | SATA_OPMODE_INTERRUPTS;
16886 /* Synchronous mode, no callback */
16887 spkt->satapkt_comp = NULL;
16888 /* Timeout 30s */
16889 spkt->satapkt_time = sata_default_pkt_time;
16890
16891 scmd = &spkt->satapkt_cmd;
16892 scmd->satacmd_flags.sata_data_direction = SATA_DIR_READ;
16893
16894 /*
16895 * Allocate buffer for SMART data
16896 */
16897 scmd->satacmd_bp = sata_alloc_local_buffer(spx,
16898 sizeof (struct smart_data));
16899 if (scmd->satacmd_bp == NULL) {
16900 sata_pkt_free(spx);
16901 kmem_free(spx, sizeof (sata_pkt_txlate_t));
16902 SATA_LOG_D((sata_hba_inst, CE_WARN,
16903 "sata_fetch_smart_data: "
16904 "cannot allocate buffer"));
16905 return (-1);
16906 }
16907
16908
16909 /* Build SMART_READ_DATA cmd in the sata_pkt */
16910 scmd->satacmd_addr_type = 0; /* N/A */
16911 scmd->satacmd_sec_count_lsb = 0; /* N/A */
16912 scmd->satacmd_lba_low_lsb = 0; /* N/A */
16913 scmd->satacmd_lba_mid_lsb = SMART_MAGIC_VAL_1;
16914 scmd->satacmd_lba_high_lsb = SMART_MAGIC_VAL_2;
16915 scmd->satacmd_features_reg = SATA_SMART_READ_DATA;
16916 scmd->satacmd_device_reg = 0; /* Always device 0 */
16917 scmd->satacmd_cmd_reg = SATAC_SMART;
16918 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst,
16919 sdinfo->satadrv_addr.cport)));
16920
16921 /* Send pkt to SATA HBA driver */
16922 if ((*SATA_START_FUNC(sata_hba_inst))(SATA_DIP(sata_hba_inst), spkt) !=
16923 SATA_TRAN_ACCEPTED ||
16924 spkt->satapkt_reason != SATA_PKT_COMPLETED) {
16925 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst,
16926 sdinfo->satadrv_addr.cport)));
16927 /*
16928 * Whoops, no SMART DATA available
16929 */
16930 rval = -1;
16931 goto fail;
16932 } else {
16933 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst,
16934 sdinfo->satadrv_addr.cport)));
16935 if (spx->txlt_buf_dma_handle != NULL) {
16936 rval = ddi_dma_sync(spx->txlt_buf_dma_handle, 0, 0,
16937 DDI_DMA_SYNC_FORKERNEL);
16938 ASSERT(rval == DDI_SUCCESS);
16939 if (sata_check_for_dma_error(dip, spx)) {
16940 ddi_fm_service_impact(dip,
16941 DDI_SERVICE_UNAFFECTED);
16942 rval = -1;
16943 goto fail;
16944 }
16945 }
16946 bcopy(scmd->satacmd_bp->b_un.b_addr, (uint8_t *)smart_data,
16947 sizeof (struct smart_data));
16948 }
16949
16950 fail:
16951 /* Free allocated resources */
16952 sata_free_local_buffer(spx);
16953 sata_pkt_free(spx);
16954 kmem_free(spx, sizeof (sata_pkt_txlate_t));
16955
16956 return (rval);
16957 }
16958
16959 /*
16960 * Used by LOG SENSE page 0x10
16961 * Reads (in synchronous mode) the self test log data using Read Log Ext cmd.
16962 * Note: cannot be called in the interrupt context.
16963 *
16964 * return 0 for success, -1 otherwise
16965 *
16966 */
16967 static int
sata_ext_smart_selftest_read_log(sata_hba_inst_t * sata_hba_inst,sata_drive_info_t * sdinfo,struct smart_ext_selftest_log * ext_selftest_log,uint16_t block_num)16968 sata_ext_smart_selftest_read_log(
16969 sata_hba_inst_t *sata_hba_inst,
16970 sata_drive_info_t *sdinfo,
16971 struct smart_ext_selftest_log *ext_selftest_log,
16972 uint16_t block_num)
16973 {
16974 sata_pkt_txlate_t *spx;
16975 sata_pkt_t *spkt;
16976 sata_cmd_t *scmd;
16977 int rval;
16978 dev_info_t *dip = SATA_DIP(sata_hba_inst);
16979
16980 #if ! defined(lint)
16981 ASSERT(sizeof (struct smart_ext_selftest_log) == 512);
16982 #endif
16983
16984 spx = kmem_zalloc(sizeof (sata_pkt_txlate_t), KM_SLEEP);
16985 spx->txlt_sata_hba_inst = sata_hba_inst;
16986 spx->txlt_scsi_pkt = NULL; /* No scsi pkt involved */
16987 spkt = sata_pkt_alloc(spx, SLEEP_FUNC);
16988 if (spkt == NULL) {
16989 kmem_free(spx, sizeof (sata_pkt_txlate_t));
16990 return (-1);
16991 }
16992 /* address is needed now */
16993 spkt->satapkt_device.satadev_addr = sdinfo->satadrv_addr;
16994
16995
16996 /* Fill sata_pkt */
16997 spkt->satapkt_device.satadev_addr = sdinfo->satadrv_addr;
16998 spkt->satapkt_op_mode = SATA_OPMODE_SYNCH | SATA_OPMODE_INTERRUPTS;
16999 /* Synchronous mode, no callback */
17000 spkt->satapkt_comp = NULL;
17001 /* Timeout 30s */
17002 spkt->satapkt_time = sata_default_pkt_time;
17003
17004 scmd = &spkt->satapkt_cmd;
17005 scmd->satacmd_flags.sata_data_direction = SATA_DIR_READ;
17006
17007 /*
17008 * Allocate buffer for SMART extended self-test log
17009 */
17010 scmd->satacmd_bp = sata_alloc_local_buffer(spx,
17011 sizeof (struct smart_ext_selftest_log));
17012 if (scmd->satacmd_bp == NULL) {
17013 sata_pkt_free(spx);
17014 kmem_free(spx, sizeof (sata_pkt_txlate_t));
17015 SATA_LOG_D((sata_hba_inst, CE_WARN,
17016 "sata_ext_smart_selftest_log: "
17017 "cannot allocate buffer"));
17018 return (-1);
17019 }
17020
17021 /* Build READ LOG EXT w/ extended self-test log cmd in the sata_pkt */
17022 scmd->satacmd_addr_type = ATA_ADDR_LBA48;
17023 scmd->satacmd_sec_count_lsb = 1; /* One sector of selftest log */
17024 scmd->satacmd_sec_count_msb = 0; /* One sector of selftest log */
17025 scmd->satacmd_lba_low_lsb = EXT_SMART_SELFTEST_LOG_PAGE;
17026 scmd->satacmd_lba_low_msb = 0;
17027 scmd->satacmd_lba_mid_lsb = block_num & 0xff;
17028 scmd->satacmd_lba_mid_msb = block_num >> 8;
17029 scmd->satacmd_device_reg = 0; /* Always device 0 */
17030 scmd->satacmd_cmd_reg = SATAC_READ_LOG_EXT;
17031
17032 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst,
17033 sdinfo->satadrv_addr.cport)));
17034
17035 /* Send pkt to SATA HBA driver */
17036 if ((*SATA_START_FUNC(sata_hba_inst))(SATA_DIP(sata_hba_inst), spkt) !=
17037 SATA_TRAN_ACCEPTED ||
17038 spkt->satapkt_reason != SATA_PKT_COMPLETED) {
17039 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst,
17040 sdinfo->satadrv_addr.cport)));
17041
17042 /*
17043 * Whoops, no SMART selftest log info available
17044 */
17045 rval = -1;
17046 goto fail;
17047 } else {
17048 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst,
17049 sdinfo->satadrv_addr.cport)));
17050
17051 if (spx->txlt_buf_dma_handle != NULL) {
17052 rval = ddi_dma_sync(spx->txlt_buf_dma_handle, 0, 0,
17053 DDI_DMA_SYNC_FORKERNEL);
17054 ASSERT(rval == DDI_SUCCESS);
17055 if (sata_check_for_dma_error(dip, spx)) {
17056 ddi_fm_service_impact(dip,
17057 DDI_SERVICE_UNAFFECTED);
17058 rval = -1;
17059 goto fail;
17060 }
17061 }
17062 bcopy(scmd->satacmd_bp->b_un.b_addr,
17063 (uint8_t *)ext_selftest_log,
17064 sizeof (struct smart_ext_selftest_log));
17065 rval = 0;
17066 }
17067
17068 fail:
17069 /* Free allocated resources */
17070 sata_free_local_buffer(spx);
17071 sata_pkt_free(spx);
17072 kmem_free(spx, sizeof (sata_pkt_txlate_t));
17073
17074 return (rval);
17075 }
17076
17077 /*
17078 * Returns 0 for success, -1 otherwise
17079 *
17080 * SMART self-test log data is returned in buffer pointed to by selftest_log
17081 */
17082 static int
sata_smart_selftest_log(sata_hba_inst_t * sata_hba_inst,sata_drive_info_t * sdinfo,struct smart_selftest_log * selftest_log)17083 sata_smart_selftest_log(
17084 sata_hba_inst_t *sata_hba_inst,
17085 sata_drive_info_t *sdinfo,
17086 struct smart_selftest_log *selftest_log)
17087 {
17088 sata_pkt_t *spkt;
17089 sata_cmd_t *scmd;
17090 sata_pkt_txlate_t *spx;
17091 int rval;
17092 dev_info_t *dip = SATA_DIP(sata_hba_inst);
17093
17094 #if ! defined(lint)
17095 ASSERT(sizeof (struct smart_selftest_log) == 512);
17096 #endif
17097
17098 spx = kmem_zalloc(sizeof (sata_pkt_txlate_t), KM_SLEEP);
17099 spx->txlt_sata_hba_inst = sata_hba_inst;
17100 spx->txlt_scsi_pkt = NULL; /* No scsi pkt involved */
17101 spkt = sata_pkt_alloc(spx, SLEEP_FUNC);
17102 if (spkt == NULL) {
17103 kmem_free(spx, sizeof (sata_pkt_txlate_t));
17104 return (-1);
17105 }
17106 /* address is needed now */
17107 spkt->satapkt_device.satadev_addr = sdinfo->satadrv_addr;
17108
17109
17110 /* Fill sata_pkt */
17111 spkt->satapkt_device.satadev_addr = sdinfo->satadrv_addr;
17112 spkt->satapkt_op_mode = SATA_OPMODE_SYNCH | SATA_OPMODE_INTERRUPTS;
17113 /* Synchronous mode, no callback */
17114 spkt->satapkt_comp = NULL;
17115 /* Timeout 30s */
17116 spkt->satapkt_time = sata_default_pkt_time;
17117
17118 scmd = &spkt->satapkt_cmd;
17119 scmd->satacmd_flags.sata_data_direction = SATA_DIR_READ;
17120
17121 /*
17122 * Allocate buffer for SMART SELFTEST LOG
17123 */
17124 scmd->satacmd_bp = sata_alloc_local_buffer(spx,
17125 sizeof (struct smart_selftest_log));
17126 if (scmd->satacmd_bp == NULL) {
17127 sata_pkt_free(spx);
17128 kmem_free(spx, sizeof (sata_pkt_txlate_t));
17129 SATA_LOG_D((sata_hba_inst, CE_WARN,
17130 "sata_smart_selftest_log: "
17131 "cannot allocate buffer"));
17132 return (-1);
17133 }
17134
17135 /* Build SMART_READ_LOG cmd in the sata_pkt */
17136 scmd->satacmd_addr_type = 0; /* N/A */
17137 scmd->satacmd_sec_count_lsb = 1; /* One sector of SMART log */
17138 scmd->satacmd_lba_low_lsb = SMART_SELFTEST_LOG_PAGE;
17139 scmd->satacmd_lba_mid_lsb = SMART_MAGIC_VAL_1;
17140 scmd->satacmd_lba_high_lsb = SMART_MAGIC_VAL_2;
17141 scmd->satacmd_features_reg = SATA_SMART_READ_LOG;
17142 scmd->satacmd_device_reg = 0; /* Always device 0 */
17143 scmd->satacmd_cmd_reg = SATAC_SMART;
17144 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst,
17145 sdinfo->satadrv_addr.cport)));
17146
17147 /* Send pkt to SATA HBA driver */
17148 if ((*SATA_START_FUNC(sata_hba_inst))(SATA_DIP(sata_hba_inst), spkt) !=
17149 SATA_TRAN_ACCEPTED ||
17150 spkt->satapkt_reason != SATA_PKT_COMPLETED) {
17151 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst,
17152 sdinfo->satadrv_addr.cport)));
17153 /*
17154 * Whoops, no SMART DATA available
17155 */
17156 rval = -1;
17157 goto fail;
17158 } else {
17159 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst,
17160 sdinfo->satadrv_addr.cport)));
17161 if (spx->txlt_buf_dma_handle != NULL) {
17162 rval = ddi_dma_sync(spx->txlt_buf_dma_handle, 0, 0,
17163 DDI_DMA_SYNC_FORKERNEL);
17164 ASSERT(rval == DDI_SUCCESS);
17165 if (sata_check_for_dma_error(dip, spx)) {
17166 ddi_fm_service_impact(dip,
17167 DDI_SERVICE_UNAFFECTED);
17168 rval = -1;
17169 goto fail;
17170 }
17171 }
17172 bcopy(scmd->satacmd_bp->b_un.b_addr, (uint8_t *)selftest_log,
17173 sizeof (struct smart_selftest_log));
17174 rval = 0;
17175 }
17176
17177 fail:
17178 /* Free allocated resources */
17179 sata_free_local_buffer(spx);
17180 sata_pkt_free(spx);
17181 kmem_free(spx, sizeof (sata_pkt_txlate_t));
17182
17183 return (rval);
17184 }
17185
17186
17187 /*
17188 * Returns 0 for success, -1 otherwise
17189 *
17190 * SMART READ LOG data is returned in buffer pointed to by smart_log
17191 */
17192 static int
sata_smart_read_log(sata_hba_inst_t * sata_hba_inst,sata_drive_info_t * sdinfo,uint8_t * smart_log,uint8_t which_log,uint8_t log_size)17193 sata_smart_read_log(
17194 sata_hba_inst_t *sata_hba_inst,
17195 sata_drive_info_t *sdinfo,
17196 uint8_t *smart_log, /* where the data should be returned */
17197 uint8_t which_log, /* which log should be returned */
17198 uint8_t log_size) /* # of 512 bytes in log */
17199 {
17200 sata_pkt_t *spkt;
17201 sata_cmd_t *scmd;
17202 sata_pkt_txlate_t *spx;
17203 int rval;
17204 dev_info_t *dip = SATA_DIP(sata_hba_inst);
17205
17206 spx = kmem_zalloc(sizeof (sata_pkt_txlate_t), KM_SLEEP);
17207 spx->txlt_sata_hba_inst = sata_hba_inst;
17208 spx->txlt_scsi_pkt = NULL; /* No scsi pkt involved */
17209 spkt = sata_pkt_alloc(spx, SLEEP_FUNC);
17210 if (spkt == NULL) {
17211 kmem_free(spx, sizeof (sata_pkt_txlate_t));
17212 return (-1);
17213 }
17214 /* address is needed now */
17215 spkt->satapkt_device.satadev_addr = sdinfo->satadrv_addr;
17216
17217
17218 /* Fill sata_pkt */
17219 spkt->satapkt_device.satadev_addr = sdinfo->satadrv_addr;
17220 spkt->satapkt_op_mode = SATA_OPMODE_SYNCH | SATA_OPMODE_INTERRUPTS;
17221 /* Synchronous mode, no callback */
17222 spkt->satapkt_comp = NULL;
17223 /* Timeout 30s */
17224 spkt->satapkt_time = sata_default_pkt_time;
17225
17226 scmd = &spkt->satapkt_cmd;
17227 scmd->satacmd_flags.sata_data_direction = SATA_DIR_READ;
17228
17229 /*
17230 * Allocate buffer for SMART READ LOG
17231 */
17232 scmd->satacmd_bp = sata_alloc_local_buffer(spx, log_size * 512);
17233 if (scmd->satacmd_bp == NULL) {
17234 sata_pkt_free(spx);
17235 kmem_free(spx, sizeof (sata_pkt_txlate_t));
17236 SATA_LOG_D((sata_hba_inst, CE_WARN,
17237 "sata_smart_read_log: " "cannot allocate buffer"));
17238 return (-1);
17239 }
17240
17241 /* Build SMART_READ_LOG cmd in the sata_pkt */
17242 scmd->satacmd_addr_type = 0; /* N/A */
17243 scmd->satacmd_sec_count_lsb = log_size; /* what the caller asked for */
17244 scmd->satacmd_lba_low_lsb = which_log; /* which log page */
17245 scmd->satacmd_lba_mid_lsb = SMART_MAGIC_VAL_1;
17246 scmd->satacmd_lba_high_lsb = SMART_MAGIC_VAL_2;
17247 scmd->satacmd_features_reg = SATA_SMART_READ_LOG;
17248 scmd->satacmd_device_reg = 0; /* Always device 0 */
17249 scmd->satacmd_cmd_reg = SATAC_SMART;
17250
17251 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst,
17252 sdinfo->satadrv_addr.cport)));
17253
17254 /* Send pkt to SATA HBA driver */
17255 if ((*SATA_START_FUNC(sata_hba_inst))(SATA_DIP(sata_hba_inst), spkt) !=
17256 SATA_TRAN_ACCEPTED ||
17257 spkt->satapkt_reason != SATA_PKT_COMPLETED) {
17258 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst,
17259 sdinfo->satadrv_addr.cport)));
17260
17261 /*
17262 * Whoops, no SMART DATA available
17263 */
17264 rval = -1;
17265 goto fail;
17266 } else {
17267 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst,
17268 sdinfo->satadrv_addr.cport)));
17269
17270 if (spx->txlt_buf_dma_handle != NULL) {
17271 rval = ddi_dma_sync(spx->txlt_buf_dma_handle, 0, 0,
17272 DDI_DMA_SYNC_FORKERNEL);
17273 ASSERT(rval == DDI_SUCCESS);
17274 if (sata_check_for_dma_error(dip, spx)) {
17275 ddi_fm_service_impact(dip,
17276 DDI_SERVICE_UNAFFECTED);
17277 rval = -1;
17278 goto fail;
17279 }
17280 }
17281 bcopy(scmd->satacmd_bp->b_un.b_addr, smart_log, log_size * 512);
17282 rval = 0;
17283 }
17284
17285 fail:
17286 /* Free allocated resources */
17287 sata_free_local_buffer(spx);
17288 sata_pkt_free(spx);
17289 kmem_free(spx, sizeof (sata_pkt_txlate_t));
17290
17291 return (rval);
17292 }
17293
17294 /*
17295 * Used by LOG SENSE page 0x10
17296 *
17297 * return 0 for success, -1 otherwise
17298 *
17299 */
17300 static int
sata_read_log_ext_directory(sata_hba_inst_t * sata_hba_inst,sata_drive_info_t * sdinfo,struct read_log_ext_directory * logdir)17301 sata_read_log_ext_directory(
17302 sata_hba_inst_t *sata_hba_inst,
17303 sata_drive_info_t *sdinfo,
17304 struct read_log_ext_directory *logdir)
17305 {
17306 sata_pkt_txlate_t *spx;
17307 sata_pkt_t *spkt;
17308 sata_cmd_t *scmd;
17309 int rval;
17310 dev_info_t *dip = SATA_DIP(sata_hba_inst);
17311
17312 #if ! defined(lint)
17313 ASSERT(sizeof (struct read_log_ext_directory) == 512);
17314 #endif
17315
17316 spx = kmem_zalloc(sizeof (sata_pkt_txlate_t), KM_SLEEP);
17317 spx->txlt_sata_hba_inst = sata_hba_inst;
17318 spx->txlt_scsi_pkt = NULL; /* No scsi pkt involved */
17319 spkt = sata_pkt_alloc(spx, SLEEP_FUNC);
17320 if (spkt == NULL) {
17321 kmem_free(spx, sizeof (sata_pkt_txlate_t));
17322 return (-1);
17323 }
17324
17325 /* Fill sata_pkt */
17326 spkt->satapkt_device.satadev_addr = sdinfo->satadrv_addr;
17327 spkt->satapkt_op_mode = SATA_OPMODE_SYNCH | SATA_OPMODE_INTERRUPTS;
17328 /* Synchronous mode, no callback */
17329 spkt->satapkt_comp = NULL;
17330 /* Timeout 30s */
17331 spkt->satapkt_time = sata_default_pkt_time;
17332
17333 scmd = &spkt->satapkt_cmd;
17334 scmd->satacmd_flags.sata_data_direction = SATA_DIR_READ;
17335
17336 /*
17337 * Allocate buffer for SMART READ LOG EXTENDED command
17338 */
17339 scmd->satacmd_bp = sata_alloc_local_buffer(spx,
17340 sizeof (struct read_log_ext_directory));
17341 if (scmd->satacmd_bp == NULL) {
17342 sata_pkt_free(spx);
17343 kmem_free(spx, sizeof (sata_pkt_txlate_t));
17344 SATA_LOG_D((sata_hba_inst, CE_WARN,
17345 "sata_read_log_ext_directory: "
17346 "cannot allocate buffer"));
17347 return (-1);
17348 }
17349
17350 /* Build READ LOG EXT w/ log directory cmd in the sata_pkt */
17351 scmd->satacmd_addr_type = ATA_ADDR_LBA48;
17352 scmd->satacmd_sec_count_lsb = 1; /* One sector of directory */
17353 scmd->satacmd_sec_count_msb = 0; /* One sector of directory */
17354 scmd->satacmd_lba_low_lsb = READ_LOG_EXT_LOG_DIRECTORY;
17355 scmd->satacmd_lba_low_msb = 0;
17356 scmd->satacmd_lba_mid_lsb = 0;
17357 scmd->satacmd_lba_mid_msb = 0;
17358 scmd->satacmd_device_reg = 0; /* Always device 0 */
17359 scmd->satacmd_cmd_reg = SATAC_READ_LOG_EXT;
17360
17361 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst,
17362 sdinfo->satadrv_addr.cport)));
17363
17364 /* Send pkt to SATA HBA driver */
17365 if ((*SATA_START_FUNC(sata_hba_inst))(SATA_DIP(sata_hba_inst), spkt) !=
17366 SATA_TRAN_ACCEPTED ||
17367 spkt->satapkt_reason != SATA_PKT_COMPLETED) {
17368 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst,
17369 sdinfo->satadrv_addr.cport)));
17370 /*
17371 * Whoops, no SMART selftest log info available
17372 */
17373 rval = -1;
17374 goto fail;
17375 } else {
17376 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst,
17377 sdinfo->satadrv_addr.cport)));
17378 if (spx->txlt_buf_dma_handle != NULL) {
17379 rval = ddi_dma_sync(spx->txlt_buf_dma_handle, 0, 0,
17380 DDI_DMA_SYNC_FORKERNEL);
17381 ASSERT(rval == DDI_SUCCESS);
17382 if (sata_check_for_dma_error(dip, spx)) {
17383 ddi_fm_service_impact(dip,
17384 DDI_SERVICE_UNAFFECTED);
17385 rval = -1;
17386 goto fail;
17387 }
17388 }
17389 bcopy(scmd->satacmd_bp->b_un.b_addr, (uint8_t *)logdir,
17390 sizeof (struct read_log_ext_directory));
17391 rval = 0;
17392 }
17393
17394 fail:
17395 /* Free allocated resources */
17396 sata_free_local_buffer(spx);
17397 sata_pkt_free(spx);
17398 kmem_free(spx, sizeof (sata_pkt_txlate_t));
17399
17400 return (rval);
17401 }
17402
17403 /*
17404 * Set up error retrieval sata command for NCQ command error data
17405 * recovery.
17406 *
17407 * Returns SATA_SUCCESS when data buffer is allocated and packet set-up,
17408 * returns SATA_FAILURE otherwise.
17409 */
17410 static int
sata_ncq_err_ret_cmd_setup(sata_pkt_txlate_t * spx,sata_drive_info_t * sdinfo)17411 sata_ncq_err_ret_cmd_setup(sata_pkt_txlate_t *spx, sata_drive_info_t *sdinfo)
17412 {
17413 #ifndef __lock_lint
17414 _NOTE(ARGUNUSED(sdinfo))
17415 #endif
17416
17417 sata_pkt_t *spkt = spx->txlt_sata_pkt;
17418 sata_cmd_t *scmd;
17419 struct buf *bp;
17420
17421 /* Operation modes are up to the caller */
17422 spkt->satapkt_op_mode = SATA_OPMODE_SYNCH | SATA_OPMODE_INTERRUPTS;
17423
17424 /* Synchronous mode, no callback - may be changed by the caller */
17425 spkt->satapkt_comp = NULL;
17426 spkt->satapkt_time = sata_default_pkt_time;
17427
17428 scmd = &spkt->satapkt_cmd;
17429 bcopy(&sata_rle_cmd, scmd, sizeof (sata_cmd_t));
17430 scmd->satacmd_flags.sata_ignore_dev_reset = B_TRUE;
17431
17432 /*
17433 * Allocate dma_able buffer error data.
17434 * Buffer allocation will take care of buffer alignment and other DMA
17435 * attributes.
17436 */
17437 bp = sata_alloc_local_buffer(spx,
17438 sizeof (struct sata_ncq_error_recovery_page));
17439 if (bp == NULL)
17440 return (SATA_FAILURE);
17441
17442 bp_mapin(bp); /* make data buffer accessible */
17443 scmd->satacmd_bp = bp;
17444
17445 /*
17446 * Set-up pointer to the buffer handle, so HBA can sync buffer
17447 * before accessing it. Handle is in usual place in translate struct.
17448 */
17449 scmd->satacmd_err_ret_buf_handle = &spx->txlt_buf_dma_handle;
17450
17451 ASSERT(scmd->satacmd_num_dma_cookies != 0);
17452 ASSERT(scmd->satacmd_dma_cookie_list != NULL);
17453
17454 return (SATA_SUCCESS);
17455 }
17456
17457 /*
17458 * sata_xlate_errors() is used to translate (S)ATA error
17459 * information to SCSI information returned in the SCSI
17460 * packet.
17461 */
17462 static void
sata_xlate_errors(sata_pkt_txlate_t * spx)17463 sata_xlate_errors(sata_pkt_txlate_t *spx)
17464 {
17465 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt;
17466 struct scsi_extended_sense *sense;
17467
17468 scsipkt->pkt_reason = CMD_INCOMPLETE;
17469 *scsipkt->pkt_scbp = STATUS_CHECK;
17470 sense = sata_arq_sense(spx);
17471
17472 switch (spx->txlt_sata_pkt->satapkt_reason) {
17473 case SATA_PKT_PORT_ERROR:
17474 /*
17475 * We have no device data. Assume no data transfered.
17476 */
17477 sense->es_key = KEY_HARDWARE_ERROR;
17478 break;
17479
17480 case SATA_PKT_DEV_ERROR:
17481 if (spx->txlt_sata_pkt->satapkt_cmd.satacmd_status_reg &
17482 SATA_STATUS_ERR) {
17483 /*
17484 * determine dev error reason from error
17485 * reg content
17486 */
17487 sata_decode_device_error(spx, sense);
17488 break;
17489 }
17490 /* No extended sense key - no info available */
17491 break;
17492
17493 case SATA_PKT_TIMEOUT:
17494 scsipkt->pkt_reason = CMD_TIMEOUT;
17495 scsipkt->pkt_statistics |= STAT_TIMEOUT | STAT_DEV_RESET;
17496 /* No extended sense key */
17497 break;
17498
17499 case SATA_PKT_ABORTED:
17500 scsipkt->pkt_reason = CMD_ABORTED;
17501 scsipkt->pkt_statistics |= STAT_ABORTED;
17502 /* No extended sense key */
17503 break;
17504
17505 case SATA_PKT_RESET:
17506 /*
17507 * pkt aborted either by an explicit reset request from
17508 * a host, or due to error recovery
17509 */
17510 scsipkt->pkt_reason = CMD_RESET;
17511 scsipkt->pkt_statistics |= STAT_DEV_RESET;
17512 break;
17513
17514 default:
17515 scsipkt->pkt_reason = CMD_TRAN_ERR;
17516 break;
17517 }
17518 }
17519
17520
17521
17522
17523 /*
17524 * Log sata message
17525 * dev pathname msg line preceeds the logged message.
17526 */
17527
17528 static void
sata_log(sata_hba_inst_t * sata_hba_inst,uint_t level,char * fmt,...)17529 sata_log(sata_hba_inst_t *sata_hba_inst, uint_t level, char *fmt, ...)
17530 {
17531 char pathname[128];
17532 dev_info_t *dip = NULL;
17533 va_list ap;
17534
17535 mutex_enter(&sata_log_mutex);
17536
17537 va_start(ap, fmt);
17538 (void) vsprintf(sata_log_buf, fmt, ap);
17539 va_end(ap);
17540
17541 if (sata_hba_inst != NULL) {
17542 dip = SATA_DIP(sata_hba_inst);
17543 (void) ddi_pathname(dip, pathname);
17544 } else {
17545 pathname[0] = 0;
17546 }
17547 if (level == CE_CONT) {
17548 if (sata_debug_flags == 0)
17549 cmn_err(level, "?%s:\n %s\n", pathname, sata_log_buf);
17550 else
17551 cmn_err(level, "%s:\n %s\n", pathname, sata_log_buf);
17552 } else {
17553 if (level != CE_NOTE) {
17554 cmn_err(level, "%s:\n %s", pathname, sata_log_buf);
17555 } else if (sata_msg) {
17556 cmn_err(level, "%s:\n %s", pathname,
17557 sata_log_buf);
17558 }
17559 }
17560
17561 /* sata trace debug */
17562 sata_trace_debug(dip, sata_log_buf);
17563
17564 mutex_exit(&sata_log_mutex);
17565 }
17566
17567
17568 /* ******** Asynchronous HBA events handling & hotplugging support ******** */
17569
17570 /*
17571 * Start or terminate the thread, depending on flag arg and current state
17572 */
17573 static void
sata_event_thread_control(int startstop)17574 sata_event_thread_control(int startstop)
17575 {
17576 static int sata_event_thread_terminating = 0;
17577 static int sata_event_thread_starting = 0;
17578 int i;
17579
17580 mutex_enter(&sata_event_mutex);
17581
17582 if (startstop == 0 && (sata_event_thread_starting == 1 ||
17583 sata_event_thread_terminating == 1)) {
17584 mutex_exit(&sata_event_mutex);
17585 return;
17586 }
17587 if (startstop == 1 && sata_event_thread_starting == 1) {
17588 mutex_exit(&sata_event_mutex);
17589 return;
17590 }
17591 if (startstop == 1 && sata_event_thread_terminating == 1) {
17592 sata_event_thread_starting = 1;
17593 /* wait til terminate operation completes */
17594 i = SATA_EVNT_DAEMON_TERM_WAIT/SATA_EVNT_DAEMON_TERM_TIMEOUT;
17595 while (sata_event_thread_terminating == 1) {
17596 if (i-- <= 0) {
17597 sata_event_thread_starting = 0;
17598 mutex_exit(&sata_event_mutex);
17599 #ifdef SATA_DEBUG
17600 cmn_err(CE_WARN, "sata_event_thread_control: "
17601 "timeout waiting for thread to terminate");
17602 #endif
17603 return;
17604 }
17605 mutex_exit(&sata_event_mutex);
17606 delay(drv_usectohz(SATA_EVNT_DAEMON_TERM_TIMEOUT));
17607 mutex_enter(&sata_event_mutex);
17608 }
17609 }
17610 if (startstop == 1) {
17611 if (sata_event_thread == NULL) {
17612 sata_event_thread = thread_create(NULL, 0,
17613 (void (*)())sata_event_daemon,
17614 &sata_hba_list, 0, &p0, TS_RUN, minclsyspri);
17615 }
17616 sata_event_thread_starting = 0;
17617 mutex_exit(&sata_event_mutex);
17618 return;
17619 }
17620
17621 /*
17622 * If we got here, thread may need to be terminated
17623 */
17624 if (sata_event_thread != NULL) {
17625 int i;
17626 /* Signal event thread to go away */
17627 sata_event_thread_terminating = 1;
17628 sata_event_thread_terminate = 1;
17629 cv_signal(&sata_event_cv);
17630 /*
17631 * Wait til daemon terminates.
17632 */
17633 i = SATA_EVNT_DAEMON_TERM_WAIT/SATA_EVNT_DAEMON_TERM_TIMEOUT;
17634 while (sata_event_thread_terminate == 1) {
17635 mutex_exit(&sata_event_mutex);
17636 if (i-- <= 0) {
17637 /* Daemon did not go away !!! */
17638 #ifdef SATA_DEBUG
17639 cmn_err(CE_WARN, "sata_event_thread_control: "
17640 "cannot terminate event daemon thread");
17641 #endif
17642 mutex_enter(&sata_event_mutex);
17643 break;
17644 }
17645 delay(drv_usectohz(SATA_EVNT_DAEMON_TERM_TIMEOUT));
17646 mutex_enter(&sata_event_mutex);
17647 }
17648 sata_event_thread_terminating = 0;
17649 }
17650 ASSERT(sata_event_thread_terminating == 0);
17651 ASSERT(sata_event_thread_starting == 0);
17652 mutex_exit(&sata_event_mutex);
17653 }
17654
17655
17656 /*
17657 * SATA HBA event notification function.
17658 * Events reported by SATA HBA drivers per HBA instance relate to a change in
17659 * a port and/or device state or a controller itself.
17660 * Events for different addresses/addr types cannot be combined.
17661 * A warning message is generated for each event type.
17662 * Events are not processed by this function, so only the
17663 * event flag(s)is set for an affected entity and the event thread is
17664 * waken up. Event daemon thread processes all events.
17665 *
17666 * NOTE: Since more than one event may be reported at the same time, one
17667 * cannot determine a sequence of events when opposite event are reported, eg.
17668 * LINK_LOST and LINK_ESTABLISHED. Actual port status during event processing
17669 * is taking precedence over reported events, i.e. may cause ignoring some
17670 * events.
17671 */
17672 #define SATA_EVENT_MAX_MSG_LENGTH 79
17673
17674 void
sata_hba_event_notify(dev_info_t * dip,sata_device_t * sata_device,int event)17675 sata_hba_event_notify(dev_info_t *dip, sata_device_t *sata_device, int event)
17676 {
17677 sata_hba_inst_t *sata_hba_inst = NULL;
17678 sata_address_t *saddr;
17679 sata_pmult_info_t *pmultinfo;
17680 sata_drive_info_t *sdinfo;
17681 sata_port_stats_t *pstats;
17682 sata_cport_info_t *cportinfo = NULL;
17683 sata_pmport_info_t *pmportinfo = NULL;
17684 int cport, pmport;
17685 char buf1[SATA_EVENT_MAX_MSG_LENGTH + 1];
17686 char buf2[SATA_EVENT_MAX_MSG_LENGTH + 1];
17687 char *lcp;
17688 static char *err_msg_evnt_1 =
17689 "sata_hba_event_notify: invalid port event 0x%x ";
17690 static char *err_msg_evnt_2 =
17691 "sata_hba_event_notify: invalid device event 0x%x ";
17692 int linkevent;
17693
17694 /*
17695 * There is a possibility that an event will be generated on HBA
17696 * that has not completed attachment or is detaching. We still want
17697 * to process events until HBA is detached.
17698 */
17699 mutex_enter(&sata_mutex);
17700 for (sata_hba_inst = sata_hba_list; sata_hba_inst != NULL;
17701 sata_hba_inst = sata_hba_inst->satahba_next) {
17702 if (SATA_DIP(sata_hba_inst) == dip)
17703 if (sata_hba_inst->satahba_attached == 1)
17704 break;
17705 }
17706 mutex_exit(&sata_mutex);
17707 if (sata_hba_inst == NULL)
17708 /* HBA not attached */
17709 return;
17710
17711 ASSERT(sata_device != NULL);
17712
17713 /*
17714 * Validate address before - do not proceed with invalid address.
17715 */
17716 saddr = &sata_device->satadev_addr;
17717 if (saddr->cport >= SATA_NUM_CPORTS(sata_hba_inst))
17718 return;
17719
17720 cport = saddr->cport;
17721 pmport = saddr->pmport;
17722
17723 buf1[0] = buf2[0] = '\0';
17724
17725 /*
17726 * If event relates to port or device, check port state.
17727 * Port has to be initialized, or we cannot accept an event.
17728 */
17729 if ((saddr->qual & (SATA_ADDR_CPORT | SATA_ADDR_PMPORT |
17730 SATA_ADDR_DCPORT | SATA_ADDR_DPMPORT | SATA_ADDR_PMULT)) != 0) {
17731 mutex_enter(&sata_hba_inst->satahba_mutex);
17732 cportinfo = SATA_CPORT_INFO(sata_hba_inst, cport);
17733 mutex_exit(&sata_hba_inst->satahba_mutex);
17734 if (cportinfo == NULL || cportinfo->cport_state == 0)
17735 return;
17736 }
17737
17738 if ((saddr->qual & (SATA_ADDR_PMULT | SATA_ADDR_PMPORT |
17739 SATA_ADDR_DPMPORT)) != 0) {
17740 if (cportinfo->cport_dev_type != SATA_DTYPE_PMULT) {
17741 SATA_LOG_D((sata_hba_inst, CE_WARN,
17742 "sata_hba_event_notify: Non-pmult device (0x%x)"
17743 "is attached to port %d, ignore pmult/pmport "
17744 "event 0x%x", cportinfo->cport_dev_type,
17745 cport, event));
17746 return;
17747 }
17748
17749 mutex_enter(&cportinfo->cport_mutex);
17750 pmultinfo = SATA_PMULT_INFO(sata_hba_inst, cport);
17751 mutex_exit(&cportinfo->cport_mutex);
17752
17753 /*
17754 * The daemon might be processing attachment of port
17755 * multiplier, in that case we should ignore events on its
17756 * sub-devices.
17757 *
17758 * NOTE: Only pmult_state is checked in sata_hba_event_notify.
17759 * The pmport_state is checked by sata daemon.
17760 */
17761 if (pmultinfo == NULL ||
17762 pmultinfo->pmult_state == SATA_STATE_UNKNOWN) {
17763 SATA_LOG_D((sata_hba_inst, CE_WARN,
17764 "sata_hba_event_notify: pmult is not"
17765 "available at port %d:%d, ignore event 0x%x",
17766 cport, pmport, event));
17767 return;
17768 }
17769 }
17770
17771 if ((saddr->qual &
17772 (SATA_ADDR_PMPORT | SATA_ADDR_DPMPORT)) != 0) {
17773
17774 mutex_enter(&cportinfo->cport_mutex);
17775 if (pmport > SATA_NUM_PMPORTS(sata_hba_inst, cport)) {
17776 SATA_LOG_D((sata_hba_inst, CE_WARN,
17777 "sata_hba_event_notify: invalid/"
17778 "un-implemented port %d:%d (%d ports), "
17779 "ignore event 0x%x", cport, pmport,
17780 SATA_NUM_PMPORTS(sata_hba_inst, cport), event));
17781 mutex_exit(&cportinfo->cport_mutex);
17782 return;
17783 }
17784 mutex_exit(&cportinfo->cport_mutex);
17785
17786 mutex_enter(&sata_hba_inst->satahba_mutex);
17787 pmportinfo = SATA_PMPORT_INFO(sata_hba_inst,
17788 cport, pmport);
17789 mutex_exit(&sata_hba_inst->satahba_mutex);
17790
17791 /* pmport is implemented/valid? */
17792 if (pmportinfo == NULL) {
17793 SATA_LOG_D((sata_hba_inst, CE_WARN,
17794 "sata_hba_event_notify: invalid/"
17795 "un-implemented port %d:%d, ignore "
17796 "event 0x%x", cport, pmport, event));
17797 return;
17798 }
17799 }
17800
17801 /*
17802 * Events refer to devices, ports and controllers - each has
17803 * unique address. Events for different addresses cannot be combined.
17804 */
17805 if (saddr->qual & (SATA_ADDR_CPORT | SATA_ADDR_PMPORT)) {
17806
17807 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, cport)));
17808
17809 /* qualify this event(s) */
17810 if ((event & SATA_EVNT_PORT_EVENTS) == 0) {
17811 /* Invalid event for the device port */
17812 (void) sprintf(buf2, err_msg_evnt_1,
17813 event & SATA_EVNT_PORT_EVENTS);
17814 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, cport)));
17815 goto event_info;
17816 }
17817 if (saddr->qual == SATA_ADDR_CPORT) {
17818 /* Controller's device port event */
17819
17820 (SATA_CPORT_INFO(sata_hba_inst, cport))->
17821 cport_event_flags |=
17822 event & SATA_EVNT_PORT_EVENTS;
17823 pstats =
17824 &(SATA_CPORT_INFO(sata_hba_inst, cport))->
17825 cport_stats;
17826 } else {
17827 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, cport)));
17828 mutex_enter(&pmportinfo->pmport_mutex);
17829 /* Port multiplier's device port event */
17830 (SATA_PMPORT_INFO(sata_hba_inst, cport, pmport))->
17831 pmport_event_flags |=
17832 event & SATA_EVNT_PORT_EVENTS;
17833 pstats =
17834 &(SATA_PMPORT_INFO(sata_hba_inst, cport, pmport))->
17835 pmport_stats;
17836 mutex_exit(&pmportinfo->pmport_mutex);
17837 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, cport)));
17838 }
17839
17840 /*
17841 * Add to statistics and log the message. We have to do it
17842 * here rather than in the event daemon, because there may be
17843 * multiple events occuring before they are processed.
17844 */
17845 linkevent = event &
17846 (SATA_EVNT_LINK_LOST | SATA_EVNT_LINK_ESTABLISHED);
17847 if (linkevent) {
17848 if (linkevent == (SATA_EVNT_LINK_LOST |
17849 SATA_EVNT_LINK_ESTABLISHED)) {
17850 /* This is likely event combination */
17851 (void) strlcat(buf1, "link lost/established, ",
17852 SATA_EVENT_MAX_MSG_LENGTH);
17853
17854 if (pstats->link_lost < 0xffffffffffffffffULL)
17855 pstats->link_lost++;
17856 if (pstats->link_established <
17857 0xffffffffffffffffULL)
17858 pstats->link_established++;
17859 linkevent = 0;
17860 } else if (linkevent & SATA_EVNT_LINK_LOST) {
17861 (void) strlcat(buf1, "link lost, ",
17862 SATA_EVENT_MAX_MSG_LENGTH);
17863
17864 if (pstats->link_lost < 0xffffffffffffffffULL)
17865 pstats->link_lost++;
17866 } else {
17867 (void) strlcat(buf1, "link established, ",
17868 SATA_EVENT_MAX_MSG_LENGTH);
17869 if (pstats->link_established <
17870 0xffffffffffffffffULL)
17871 pstats->link_established++;
17872 }
17873 }
17874 if (event & SATA_EVNT_DEVICE_ATTACHED) {
17875 (void) strlcat(buf1, "device attached, ",
17876 SATA_EVENT_MAX_MSG_LENGTH);
17877 if (pstats->device_attached < 0xffffffffffffffffULL)
17878 pstats->device_attached++;
17879 }
17880 if (event & SATA_EVNT_DEVICE_DETACHED) {
17881 (void) strlcat(buf1, "device detached, ",
17882 SATA_EVENT_MAX_MSG_LENGTH);
17883 if (pstats->device_detached < 0xffffffffffffffffULL)
17884 pstats->device_detached++;
17885 }
17886 if (event & SATA_EVNT_PWR_LEVEL_CHANGED) {
17887 SATADBG1(SATA_DBG_EVENTS, sata_hba_inst,
17888 "port %d power level changed", cport);
17889 if (pstats->port_pwr_changed < 0xffffffffffffffffULL)
17890 pstats->port_pwr_changed++;
17891 }
17892
17893 if ((event & ~SATA_EVNT_PORT_EVENTS) != 0) {
17894 /* There should be no other events for this address */
17895 (void) sprintf(buf2, err_msg_evnt_1,
17896 event & ~SATA_EVNT_PORT_EVENTS);
17897 }
17898 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, cport)));
17899
17900 } else if (saddr->qual & (SATA_ADDR_DCPORT | SATA_ADDR_DPMPORT)) {
17901 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, cport)));
17902
17903 /* qualify this event */
17904 if ((event & SATA_EVNT_DEVICE_RESET) == 0) {
17905 /* Invalid event for a device */
17906 (void) sprintf(buf2, err_msg_evnt_2,
17907 event & SATA_EVNT_DEVICE_RESET);
17908 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, cport)));
17909 goto event_info;
17910 }
17911 /* drive event */
17912 sdinfo = sata_get_device_info(sata_hba_inst, sata_device);
17913 if (sdinfo != NULL) {
17914 if (event & SATA_EVNT_DEVICE_RESET) {
17915 (void) strlcat(buf1, "device reset, ",
17916 SATA_EVENT_MAX_MSG_LENGTH);
17917 if (sdinfo->satadrv_stats.drive_reset <
17918 0xffffffffffffffffULL)
17919 sdinfo->satadrv_stats.drive_reset++;
17920 sdinfo->satadrv_event_flags |=
17921 SATA_EVNT_DEVICE_RESET;
17922 }
17923 }
17924 if ((event & ~SATA_EVNT_DEVICE_RESET) != 0) {
17925 /* Invalid event for a device */
17926 (void) sprintf(buf2, err_msg_evnt_2,
17927 event & ~SATA_EVNT_DRIVE_EVENTS);
17928 }
17929 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, cport)));
17930 } else if (saddr->qual == SATA_ADDR_PMULT) {
17931 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, cport)));
17932
17933 /* qualify this event */
17934 if ((event & (SATA_EVNT_DEVICE_RESET |
17935 SATA_EVNT_PMULT_LINK_CHANGED)) == 0) {
17936 /* Invalid event for a port multiplier */
17937 (void) sprintf(buf2, err_msg_evnt_2,
17938 event & SATA_EVNT_DEVICE_RESET);
17939 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, cport)));
17940 goto event_info;
17941 }
17942
17943 pmultinfo = SATA_PMULT_INFO(sata_hba_inst, cport);
17944
17945 if (event & SATA_EVNT_DEVICE_RESET) {
17946
17947 SATADBG1(SATA_DBG_PMULT, sata_hba_inst,
17948 "[Reset] port-mult on cport %d", cport);
17949 pmultinfo->pmult_event_flags |=
17950 SATA_EVNT_DEVICE_RESET;
17951 (void) strlcat(buf1, "pmult reset, ",
17952 SATA_EVENT_MAX_MSG_LENGTH);
17953 }
17954
17955 if (event & SATA_EVNT_PMULT_LINK_CHANGED) {
17956
17957 SATADBG1(SATA_DBG_PMULT, sata_hba_inst,
17958 "pmult link changed on cport %d", cport);
17959 pmultinfo->pmult_event_flags |=
17960 SATA_EVNT_PMULT_LINK_CHANGED;
17961 (void) strlcat(buf1, "pmult link changed, ",
17962 SATA_EVENT_MAX_MSG_LENGTH);
17963 }
17964 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, cport)));
17965
17966 } else {
17967 if (saddr->qual != SATA_ADDR_NULL) {
17968 /* Wrong address qualifier */
17969 SATA_LOG_D((sata_hba_inst, CE_WARN,
17970 "sata_hba_event_notify: invalid address 0x%x",
17971 *(uint32_t *)saddr));
17972 return;
17973 }
17974 if ((event & SATA_EVNT_CONTROLLER_EVENTS) == 0 ||
17975 (event & ~SATA_EVNT_CONTROLLER_EVENTS) != 0) {
17976 /* Invalid event for the controller */
17977 SATA_LOG_D((sata_hba_inst, CE_WARN,
17978 "sata_hba_event_notify: invalid event 0x%x for "
17979 "controller",
17980 event & SATA_EVNT_CONTROLLER_EVENTS));
17981 return;
17982 }
17983 buf1[0] = '\0';
17984 /* This may be a frequent and not interesting event */
17985 SATADBG1(SATA_DBG_EVENTS, sata_hba_inst,
17986 "controller power level changed\n", NULL);
17987
17988 mutex_enter(&sata_hba_inst->satahba_mutex);
17989 if (sata_hba_inst->satahba_stats.ctrl_pwr_change <
17990 0xffffffffffffffffULL)
17991 sata_hba_inst->satahba_stats.ctrl_pwr_change++;
17992
17993 sata_hba_inst->satahba_event_flags |=
17994 SATA_EVNT_PWR_LEVEL_CHANGED;
17995 mutex_exit(&sata_hba_inst->satahba_mutex);
17996 }
17997 /*
17998 * If we got here, there is something to do with this HBA
17999 * instance.
18000 */
18001 mutex_enter(&sata_hba_inst->satahba_mutex);
18002 sata_hba_inst->satahba_event_flags |= SATA_EVNT_MAIN;
18003 mutex_exit(&sata_hba_inst->satahba_mutex);
18004 mutex_enter(&sata_mutex);
18005 sata_event_pending |= SATA_EVNT_MAIN; /* global event indicator */
18006 mutex_exit(&sata_mutex);
18007
18008 /* Tickle event thread */
18009 mutex_enter(&sata_event_mutex);
18010 if (sata_event_thread_active == 0)
18011 cv_signal(&sata_event_cv);
18012 mutex_exit(&sata_event_mutex);
18013
18014 event_info:
18015 if (buf1[0] != '\0') {
18016 lcp = strrchr(buf1, ',');
18017 if (lcp != NULL)
18018 *lcp = '\0';
18019 }
18020 if (saddr->qual == SATA_ADDR_CPORT ||
18021 saddr->qual == SATA_ADDR_DCPORT) {
18022 if (buf1[0] != '\0') {
18023 sata_log(sata_hba_inst, CE_NOTE, "port %d: %s\n",
18024 cport, buf1);
18025 }
18026 if (buf2[0] != '\0') {
18027 sata_log(sata_hba_inst, CE_NOTE, "port %d: %s\n",
18028 cport, buf2);
18029 }
18030 } else if (saddr->qual == SATA_ADDR_PMPORT ||
18031 saddr->qual == SATA_ADDR_DPMPORT) {
18032 if (buf1[0] != '\0') {
18033 sata_log(sata_hba_inst, CE_NOTE,
18034 "port %d pmport %d: %s\n", cport, pmport, buf1);
18035 }
18036 if (buf2[0] != '\0') {
18037 sata_log(sata_hba_inst, CE_NOTE,
18038 "port %d pmport %d: %s\n", cport, pmport, buf2);
18039 }
18040 }
18041 }
18042
18043
18044 /*
18045 * Event processing thread.
18046 * Arg is a pointer to the sata_hba_list pointer.
18047 * It is not really needed, because sata_hba_list is global and static
18048 */
18049 static void
sata_event_daemon(void * arg)18050 sata_event_daemon(void *arg)
18051 {
18052 #ifndef __lock_lint
18053 _NOTE(ARGUNUSED(arg))
18054 #endif
18055 sata_hba_inst_t *sata_hba_inst;
18056 clock_t delta;
18057
18058 SATADBG1(SATA_DBG_EVENTS_DAEMON, NULL,
18059 "SATA event daemon started\n", NULL);
18060 loop:
18061 /*
18062 * Process events here. Walk through all registered HBAs
18063 */
18064 mutex_enter(&sata_mutex);
18065 for (sata_hba_inst = sata_hba_list; sata_hba_inst != NULL;
18066 sata_hba_inst = sata_hba_inst->satahba_next) {
18067 ASSERT(sata_hba_inst != NULL);
18068 mutex_enter(&sata_hba_inst->satahba_mutex);
18069 if (sata_hba_inst->satahba_attached == 0 ||
18070 (sata_hba_inst->satahba_event_flags &
18071 SATA_EVNT_SKIP) != 0) {
18072 mutex_exit(&sata_hba_inst->satahba_mutex);
18073 continue;
18074 }
18075 if (sata_hba_inst->satahba_event_flags & SATA_EVNT_MAIN) {
18076 sata_hba_inst->satahba_event_flags |= SATA_EVNT_SKIP;
18077 mutex_exit(&sata_hba_inst->satahba_mutex);
18078 mutex_exit(&sata_mutex);
18079 /* Got the controller with pending event */
18080 sata_process_controller_events(sata_hba_inst);
18081 /*
18082 * Since global mutex was released, there is a
18083 * possibility that HBA list has changed, so start
18084 * over from the top. Just processed controller
18085 * will be passed-over because of the SKIP flag.
18086 */
18087 goto loop;
18088 }
18089 mutex_exit(&sata_hba_inst->satahba_mutex);
18090 }
18091 /* Clear SKIP flag in all controllers */
18092 for (sata_hba_inst = sata_hba_list; sata_hba_inst != NULL;
18093 sata_hba_inst = sata_hba_inst->satahba_next) {
18094 mutex_enter(&sata_hba_inst->satahba_mutex);
18095 sata_hba_inst->satahba_event_flags &= ~SATA_EVNT_SKIP;
18096 mutex_exit(&sata_hba_inst->satahba_mutex);
18097 }
18098 mutex_exit(&sata_mutex);
18099
18100 SATADBG1(SATA_DBG_EVENTS_DAEMON, NULL,
18101 "SATA EVENT DAEMON suspending itself", NULL);
18102
18103 #ifdef SATA_DEBUG
18104 if ((sata_func_enable & SATA_ENABLE_PROCESS_EVENTS) == 0) {
18105 sata_log(sata_hba_inst, CE_WARN,
18106 "SATA EVENTS PROCESSING DISABLED\n");
18107 thread_exit(); /* Daemon will not run again */
18108 }
18109 #endif
18110 mutex_enter(&sata_event_mutex);
18111 sata_event_thread_active = 0;
18112 mutex_exit(&sata_event_mutex);
18113 /*
18114 * Go to sleep/suspend itself and wake up either because new event or
18115 * wait timeout. Exit if there is a termination request (driver
18116 * unload).
18117 */
18118 delta = drv_usectohz(SATA_EVNT_DAEMON_SLEEP_TIME);
18119 do {
18120 mutex_enter(&sata_event_mutex);
18121 (void) cv_reltimedwait(&sata_event_cv, &sata_event_mutex,
18122 delta, TR_CLOCK_TICK);
18123
18124 if (sata_event_thread_active != 0) {
18125 mutex_exit(&sata_event_mutex);
18126 continue;
18127 }
18128
18129 /* Check if it is time to go away */
18130 if (sata_event_thread_terminate == 1) {
18131 /*
18132 * It is up to the thread setting above flag to make
18133 * sure that this thread is not killed prematurely.
18134 */
18135 sata_event_thread_terminate = 0;
18136 sata_event_thread = NULL;
18137 mutex_exit(&sata_event_mutex);
18138 SATADBG1(SATA_DBG_EVENTS_DAEMON, NULL,
18139 "SATA_EVENT_DAEMON_TERMINATING", NULL);
18140 thread_exit(); { _NOTE(NOT_REACHED) }
18141 }
18142 mutex_exit(&sata_event_mutex);
18143 } while (!(sata_event_pending & SATA_EVNT_MAIN));
18144
18145 mutex_enter(&sata_event_mutex);
18146 sata_event_thread_active = 1;
18147 mutex_exit(&sata_event_mutex);
18148
18149 mutex_enter(&sata_mutex);
18150 sata_event_pending &= ~SATA_EVNT_MAIN;
18151 mutex_exit(&sata_mutex);
18152
18153 SATADBG1(SATA_DBG_EVENTS_DAEMON, NULL,
18154 "SATA EVENT DAEMON READY TO PROCESS EVENT", NULL);
18155
18156 goto loop;
18157 }
18158
18159 /*
18160 * Specific HBA instance event processing.
18161 *
18162 * NOTE: At the moment, device event processing is limited to hard disks
18163 * only.
18164 * Port multiplier is supported now.
18165 */
18166 static void
sata_process_controller_events(sata_hba_inst_t * sata_hba_inst)18167 sata_process_controller_events(sata_hba_inst_t *sata_hba_inst)
18168 {
18169 int ncport;
18170 uint32_t event_flags;
18171 sata_address_t *saddr;
18172 sata_cport_info_t *cportinfo;
18173 sata_pmult_info_t *pmultinfo;
18174
18175 SATADBG1(SATA_DBG_EVENTS_CNTRL, sata_hba_inst,
18176 "Processing controller %d event(s)",
18177 ddi_get_instance(SATA_DIP(sata_hba_inst)));
18178
18179 mutex_enter(&sata_hba_inst->satahba_mutex);
18180 sata_hba_inst->satahba_event_flags &= ~SATA_EVNT_MAIN;
18181 event_flags = sata_hba_inst->satahba_event_flags;
18182 mutex_exit(&sata_hba_inst->satahba_mutex);
18183 /*
18184 * Process controller power change first
18185 * HERE
18186 */
18187 if (event_flags & SATA_EVNT_PWR_LEVEL_CHANGED)
18188 sata_process_cntrl_pwr_level_change(sata_hba_inst);
18189
18190 /*
18191 * Search through ports/devices to identify affected port/device.
18192 * We may have to process events for more than one port/device.
18193 */
18194 for (ncport = 0; ncport < SATA_NUM_CPORTS(sata_hba_inst); ncport++) {
18195 /*
18196 * Not all ports may be processed in attach by the time we
18197 * get an event. Check if port info is initialized.
18198 */
18199 mutex_enter(&sata_hba_inst->satahba_mutex);
18200 cportinfo = SATA_CPORT_INFO(sata_hba_inst, ncport);
18201 mutex_exit(&sata_hba_inst->satahba_mutex);
18202 if (cportinfo == NULL || cportinfo->cport_state == 0)
18203 continue;
18204
18205 /* We have initialized controller port info */
18206 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, ncport)));
18207 event_flags = (SATA_CPORT_INFO(sata_hba_inst, ncport))->
18208 cport_event_flags;
18209 /* Check if port was locked by IOCTL processing */
18210 if (event_flags & SATA_APCTL_LOCK_PORT_BUSY) {
18211 /*
18212 * We ignore port events because port is busy
18213 * with AP control processing. Set again
18214 * controller and main event flag, so that
18215 * events may be processed by the next daemon
18216 * run.
18217 */
18218 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, ncport)));
18219 mutex_enter(&sata_hba_inst->satahba_mutex);
18220 sata_hba_inst->satahba_event_flags |= SATA_EVNT_MAIN;
18221 mutex_exit(&sata_hba_inst->satahba_mutex);
18222 mutex_enter(&sata_mutex);
18223 sata_event_pending |= SATA_EVNT_MAIN;
18224 mutex_exit(&sata_mutex);
18225 SATADBG1(SATA_DBG_EVENTS_PROCPST, sata_hba_inst,
18226 "Event processing postponed until "
18227 "AP control processing completes",
18228 NULL);
18229 /* Check other ports */
18230 continue;
18231 } else {
18232 /*
18233 * Set BSY flag so that AP control would not
18234 * interfere with events processing for
18235 * this port.
18236 */
18237 (SATA_CPORT_INFO(sata_hba_inst, ncport))->
18238 cport_event_flags |= SATA_EVNT_LOCK_PORT_BUSY;
18239 }
18240 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, ncport)));
18241
18242 saddr = &(SATA_CPORT_INFO(sata_hba_inst, ncport))->cport_addr;
18243
18244 if ((event_flags &
18245 (SATA_EVNT_PORT_EVENTS | SATA_EVNT_DRIVE_EVENTS)) != 0) {
18246 /*
18247 * Got port event.
18248 * We need some hierarchy of event processing as they
18249 * are affecting each other:
18250 * 1. port failed
18251 * 2. device detached/attached
18252 * 3. link events - link events may trigger device
18253 * detached or device attached events in some
18254 * circumstances.
18255 * 4. port power level changed
18256 */
18257 if (event_flags & SATA_EVNT_PORT_FAILED) {
18258 sata_process_port_failed_event(sata_hba_inst,
18259 saddr);
18260 }
18261 if (event_flags & SATA_EVNT_DEVICE_DETACHED) {
18262 sata_process_device_detached(sata_hba_inst,
18263 saddr);
18264 }
18265 if (event_flags & SATA_EVNT_DEVICE_ATTACHED) {
18266 sata_process_device_attached(sata_hba_inst,
18267 saddr);
18268 }
18269 if (event_flags &
18270 (SATA_EVNT_LINK_ESTABLISHED |
18271 SATA_EVNT_LINK_LOST)) {
18272 sata_process_port_link_events(sata_hba_inst,
18273 saddr);
18274 }
18275 if (event_flags & SATA_EVNT_PWR_LEVEL_CHANGED) {
18276 sata_process_port_pwr_change(sata_hba_inst,
18277 saddr);
18278 }
18279 if (event_flags & SATA_EVNT_TARGET_NODE_CLEANUP) {
18280 sata_process_target_node_cleanup(
18281 sata_hba_inst, saddr);
18282 }
18283 if (event_flags & SATA_EVNT_AUTOONLINE_DEVICE) {
18284 sata_process_device_autoonline(
18285 sata_hba_inst, saddr);
18286 }
18287 }
18288
18289
18290 /*
18291 * Scan port multiplier and all its sub-ports event flags.
18292 * The events are marked by
18293 * (1) sata_pmult_info.pmult_event_flags
18294 * (2) sata_pmport_info.pmport_event_flags
18295 */
18296 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, ncport)));
18297 if (cportinfo->cport_dev_type == SATA_DTYPE_PMULT) {
18298 /*
18299 * There should be another extra check: this
18300 * port multiplier still exists?
18301 */
18302 pmultinfo = SATA_PMULT_INFO(sata_hba_inst,
18303 ncport);
18304
18305 if (pmultinfo != NULL) {
18306 mutex_exit(&(SATA_CPORT_MUTEX(
18307 sata_hba_inst, ncport)));
18308 sata_process_pmult_events(
18309 sata_hba_inst, ncport);
18310 mutex_enter(&(SATA_CPORT_MUTEX(
18311 sata_hba_inst, ncport)));
18312 } else {
18313 SATADBG1(SATA_DBG_PMULT, sata_hba_inst,
18314 "Port-multiplier is gone. "
18315 "Ignore all sub-device events "
18316 "at port %d.", ncport);
18317 }
18318 }
18319
18320 if ((SATA_CPORT_DEV_TYPE(sata_hba_inst, ncport) !=
18321 SATA_DTYPE_NONE) &&
18322 (SATA_CPORT_DRV_INFO(sata_hba_inst, ncport) != NULL)) {
18323 if (SATA_CPORT_DRV_INFO(sata_hba_inst, ncport)->
18324 satadrv_event_flags &
18325 (SATA_EVNT_DEVICE_RESET |
18326 SATA_EVNT_INPROC_DEVICE_RESET)) {
18327 /* Have device event */
18328 sata_process_device_reset(sata_hba_inst,
18329 saddr);
18330 }
18331 }
18332 /* Release PORT_BUSY flag */
18333 (SATA_CPORT_INFO(sata_hba_inst, ncport))->
18334 cport_event_flags &= ~SATA_EVNT_LOCK_PORT_BUSY;
18335 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, ncport)));
18336
18337 } /* End of loop through the controller SATA ports */
18338 }
18339
18340 /*
18341 * Specific port multiplier instance event processing. At the moment, device
18342 * event processing is limited to link/attach event only.
18343 *
18344 * NOTE: power management event is not supported yet.
18345 */
18346 static void
sata_process_pmult_events(sata_hba_inst_t * sata_hba_inst,uint8_t cport)18347 sata_process_pmult_events(sata_hba_inst_t *sata_hba_inst, uint8_t cport)
18348 {
18349 sata_cport_info_t *cportinfo = SATA_CPORT_INFO(sata_hba_inst, cport);
18350 sata_pmult_info_t *pmultinfo;
18351 sata_pmport_info_t *pmportinfo;
18352 sata_address_t *saddr;
18353 sata_device_t sata_device;
18354 uint32_t event_flags;
18355 int npmport;
18356 int rval;
18357
18358 SATADBG2(SATA_DBG_EVENTS_CNTRL|SATA_DBG_PMULT, sata_hba_inst,
18359 "Processing pmult event(s) on cport %d of controller %d",
18360 cport, ddi_get_instance(SATA_DIP(sata_hba_inst)));
18361
18362 /* First process events on port multiplier */
18363 mutex_enter(&cportinfo->cport_mutex);
18364 pmultinfo = SATA_PMULT_INFO(sata_hba_inst, cport);
18365 event_flags = pmultinfo->pmult_event_flags;
18366
18367 /*
18368 * Reset event (of port multiplier) has higher priority because the
18369 * port multiplier itself might be failed or removed after reset.
18370 */
18371 if (event_flags & SATA_EVNT_DEVICE_RESET) {
18372 /*
18373 * The status of the sub-links are uncertain,
18374 * so mark all sub-ports as RESET
18375 */
18376 for (npmport = 0; npmport < SATA_NUM_PMPORTS(
18377 sata_hba_inst, cport); npmport ++) {
18378 pmportinfo = SATA_PMPORT_INFO(sata_hba_inst,
18379 cport, npmport);
18380 if (pmportinfo == NULL) {
18381 /* That's weird. */
18382 SATA_LOG_D((sata_hba_inst, CE_WARN,
18383 "sata_hba_event_notify: "
18384 "invalid/un-implemented "
18385 "port %d:%d (%d ports), ",
18386 cport, npmport, SATA_NUM_PMPORTS(
18387 sata_hba_inst, cport)));
18388 continue;
18389 }
18390
18391 mutex_enter(&pmportinfo->pmport_mutex);
18392
18393 /* Mark all pmport to unknow state. */
18394 pmportinfo->pmport_state = SATA_STATE_UNKNOWN;
18395 /* Mark all pmports with link events. */
18396 pmportinfo->pmport_event_flags =
18397 (SATA_EVNT_LINK_ESTABLISHED|SATA_EVNT_LINK_LOST);
18398 mutex_exit(&pmportinfo->pmport_mutex);
18399 }
18400
18401 } else if (event_flags & SATA_EVNT_PMULT_LINK_CHANGED) {
18402 /*
18403 * We need probe the port multiplier to know what has
18404 * happened.
18405 */
18406 bzero(&sata_device, sizeof (sata_device_t));
18407 sata_device.satadev_rev = SATA_DEVICE_REV;
18408 sata_device.satadev_addr.cport = cport;
18409 sata_device.satadev_addr.pmport = SATA_PMULT_HOSTPORT;
18410 sata_device.satadev_addr.qual = SATA_ADDR_PMULT;
18411
18412 mutex_exit(&cportinfo->cport_mutex);
18413 rval = (*SATA_PROBE_PORT_FUNC(sata_hba_inst))
18414 (SATA_DIP(sata_hba_inst), &sata_device);
18415 mutex_enter(&cportinfo->cport_mutex);
18416 if (rval != SATA_SUCCESS) {
18417 /* Something went wrong? Fail the port */
18418 cportinfo->cport_state = SATA_PSTATE_FAILED;
18419 mutex_exit(&cportinfo->cport_mutex);
18420 SATA_LOG_D((sata_hba_inst, CE_WARN,
18421 "SATA port %d probing failed", cport));
18422
18423 /* PMult structure must be released. */
18424 sata_free_pmult(sata_hba_inst, &sata_device);
18425 return;
18426 }
18427
18428 sata_update_port_info(sata_hba_inst, &sata_device);
18429
18430 /*
18431 * Sanity check - Port is active? Is the link active?
18432 * The device is still a port multiplier?
18433 */
18434 if ((cportinfo->cport_state &
18435 (SATA_PSTATE_SHUTDOWN | SATA_PSTATE_FAILED)) ||
18436 ((cportinfo->cport_scr.sstatus &
18437 SATA_PORT_DEVLINK_UP_MASK) != SATA_PORT_DEVLINK_UP) ||
18438 (cportinfo->cport_dev_type != SATA_DTYPE_PMULT)) {
18439 mutex_exit(&cportinfo->cport_mutex);
18440
18441 /* PMult structure must be released. */
18442 sata_free_pmult(sata_hba_inst, &sata_device);
18443 return;
18444 }
18445
18446 /* Probed succeed, set port ready. */
18447 cportinfo->cport_state |=
18448 SATA_STATE_PROBED | SATA_STATE_READY;
18449 }
18450
18451 /* Release port multiplier event flags. */
18452 pmultinfo->pmult_event_flags &=
18453 ~(SATA_EVNT_DEVICE_RESET|SATA_EVNT_PMULT_LINK_CHANGED);
18454 mutex_exit(&cportinfo->cport_mutex);
18455
18456 /*
18457 * Check all sub-links.
18458 */
18459 for (npmport = 0; npmport < SATA_NUM_PMPORTS(sata_hba_inst, cport);
18460 npmport ++) {
18461 pmportinfo = SATA_PMPORT_INFO(sata_hba_inst, cport, npmport);
18462 mutex_enter(&pmportinfo->pmport_mutex);
18463 event_flags = pmportinfo->pmport_event_flags;
18464 mutex_exit(&pmportinfo->pmport_mutex);
18465 saddr = &pmportinfo->pmport_addr;
18466
18467 if ((event_flags &
18468 (SATA_EVNT_PORT_EVENTS | SATA_EVNT_DRIVE_EVENTS)) != 0) {
18469 /*
18470 * Got port multiplier port event.
18471 * We need some hierarchy of event processing as they
18472 * are affecting each other:
18473 * 1. device detached/attached
18474 * 2. link events - link events may trigger device
18475 * detached or device attached events in some
18476 * circumstances.
18477 */
18478 if (event_flags & SATA_EVNT_DEVICE_DETACHED) {
18479 sata_process_pmdevice_detached(sata_hba_inst,
18480 saddr);
18481 }
18482 if (event_flags & SATA_EVNT_DEVICE_ATTACHED) {
18483 sata_process_pmdevice_attached(sata_hba_inst,
18484 saddr);
18485 }
18486 if (event_flags & SATA_EVNT_LINK_ESTABLISHED ||
18487 event_flags & SATA_EVNT_LINK_LOST) {
18488 sata_process_pmport_link_events(sata_hba_inst,
18489 saddr);
18490 }
18491 if (event_flags & SATA_EVNT_TARGET_NODE_CLEANUP) {
18492 sata_process_target_node_cleanup(
18493 sata_hba_inst, saddr);
18494 }
18495 }
18496
18497 /* Checking drive event(s). */
18498 mutex_enter(&pmportinfo->pmport_mutex);
18499 if (pmportinfo->pmport_dev_type != SATA_DTYPE_NONE &&
18500 pmportinfo->pmport_sata_drive != NULL) {
18501 event_flags = pmportinfo->pmport_sata_drive->
18502 satadrv_event_flags;
18503 if (event_flags & (SATA_EVNT_DEVICE_RESET |
18504 SATA_EVNT_INPROC_DEVICE_RESET)) {
18505
18506 /* Have device event */
18507 sata_process_pmdevice_reset(sata_hba_inst,
18508 saddr);
18509 }
18510 }
18511 mutex_exit(&pmportinfo->pmport_mutex);
18512
18513 /* Release PORT_BUSY flag */
18514 mutex_enter(&cportinfo->cport_mutex);
18515 cportinfo->cport_event_flags &= ~SATA_EVNT_LOCK_PORT_BUSY;
18516 mutex_exit(&cportinfo->cport_mutex);
18517 }
18518
18519 SATADBG2(SATA_DBG_EVENTS_CNTRL|SATA_DBG_PMULT, sata_hba_inst,
18520 "[DONE] pmult event(s) on cport %d of controller %d",
18521 cport, ddi_get_instance(SATA_DIP(sata_hba_inst)));
18522 }
18523
18524 /*
18525 * Process HBA power level change reported by HBA driver.
18526 * Not implemented at this time - event is ignored.
18527 */
18528 static void
sata_process_cntrl_pwr_level_change(sata_hba_inst_t * sata_hba_inst)18529 sata_process_cntrl_pwr_level_change(sata_hba_inst_t *sata_hba_inst)
18530 {
18531 SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst,
18532 "Processing controller power level change", NULL);
18533
18534 /* Ignoring it for now */
18535 mutex_enter(&sata_hba_inst->satahba_mutex);
18536 sata_hba_inst->satahba_event_flags &= ~SATA_EVNT_PWR_LEVEL_CHANGED;
18537 mutex_exit(&sata_hba_inst->satahba_mutex);
18538 }
18539
18540 /*
18541 * Process port power level change reported by HBA driver.
18542 * Not implemented at this time - event is ignored.
18543 */
18544 static void
sata_process_port_pwr_change(sata_hba_inst_t * sata_hba_inst,sata_address_t * saddr)18545 sata_process_port_pwr_change(sata_hba_inst_t *sata_hba_inst,
18546 sata_address_t *saddr)
18547 {
18548 sata_cport_info_t *cportinfo;
18549
18550 SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst,
18551 "Processing port power level change", NULL);
18552
18553 cportinfo = SATA_CPORT_INFO(sata_hba_inst, saddr->cport);
18554 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex);
18555 /* Reset event flag */
18556 cportinfo->cport_event_flags &= ~SATA_EVNT_PWR_LEVEL_CHANGED;
18557 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex);
18558 }
18559
18560 /*
18561 * Process port failure reported by HBA driver.
18562 * cports support only - no pmports.
18563 */
18564 static void
sata_process_port_failed_event(sata_hba_inst_t * sata_hba_inst,sata_address_t * saddr)18565 sata_process_port_failed_event(sata_hba_inst_t *sata_hba_inst,
18566 sata_address_t *saddr)
18567 {
18568 sata_cport_info_t *cportinfo;
18569
18570 cportinfo = SATA_CPORT_INFO(sata_hba_inst, saddr->cport);
18571 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex);
18572 /* Reset event flag first */
18573 cportinfo->cport_event_flags &= ~SATA_EVNT_PORT_FAILED;
18574 /* If the port is in SHUTDOWN or FAILED state, ignore this event. */
18575 if ((cportinfo->cport_state &
18576 (SATA_PSTATE_SHUTDOWN | SATA_PSTATE_FAILED)) == 0) {
18577 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->
18578 cport_mutex);
18579 return;
18580 }
18581 /* Fail the port */
18582 cportinfo->cport_state = SATA_PSTATE_FAILED;
18583 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex);
18584 sata_log(sata_hba_inst, CE_WARN, "SATA port %d failed", saddr->cport);
18585 }
18586
18587 /*
18588 * Device Reset Event processing.
18589 * The sequence is managed by 3 stage flags:
18590 * - reset event reported,
18591 * - reset event being processed,
18592 * - request to clear device reset state.
18593 *
18594 * NOTE: This function has to be entered with cport mutex held. It exits with
18595 * mutex held as well, but can release mutex during the processing.
18596 */
18597 static void
sata_process_device_reset(sata_hba_inst_t * sata_hba_inst,sata_address_t * saddr)18598 sata_process_device_reset(sata_hba_inst_t *sata_hba_inst,
18599 sata_address_t *saddr)
18600 {
18601 sata_drive_info_t old_sdinfo; /* local copy of the drive info */
18602 sata_drive_info_t *sdinfo;
18603 sata_cport_info_t *cportinfo;
18604 sata_device_t sata_device;
18605 int rval_probe, rval_set;
18606
18607 /* We only care about host sata cport for now */
18608 cportinfo = SATA_CPORT_INFO(sata_hba_inst, saddr->cport);
18609 sdinfo = SATA_CPORT_DRV_INFO(sata_hba_inst, saddr->cport);
18610 /*
18611 * If the port is in SHUTDOWN or FAILED state, or device is in FAILED
18612 * state, ignore reset event.
18613 */
18614 if (((cportinfo->cport_state &
18615 (SATA_PSTATE_SHUTDOWN | SATA_PSTATE_FAILED)) != 0) ||
18616 (sdinfo->satadrv_state & SATA_DSTATE_FAILED) != 0) {
18617 sdinfo->satadrv_event_flags &=
18618 ~(SATA_EVNT_DEVICE_RESET | SATA_EVNT_INPROC_DEVICE_RESET);
18619 return;
18620 }
18621
18622 if ((SATA_CPORT_DEV_TYPE(sata_hba_inst, saddr->cport) ==
18623 SATA_DTYPE_PMULT)) {
18624 /*
18625 * Should not happened: this is already handled in
18626 * sata_hba_event_notify()
18627 */
18628 mutex_exit(&cportinfo->cport_mutex);
18629 goto done;
18630 }
18631
18632 if ((SATA_CPORT_DEV_TYPE(sata_hba_inst, saddr->cport) &
18633 SATA_VALID_DEV_TYPE) == 0) {
18634 /*
18635 * This should not happen - coding error.
18636 * But we can recover, so do not panic, just clean up
18637 * and if in debug mode, log the message.
18638 */
18639 #ifdef SATA_DEBUG
18640 sata_log(sata_hba_inst, CE_WARN,
18641 "sata_process_device_reset: "
18642 "Invalid device type with sdinfo!", NULL);
18643 #endif
18644 sdinfo->satadrv_event_flags = 0;
18645 return;
18646 }
18647
18648 #ifdef SATA_DEBUG
18649 if ((sdinfo->satadrv_event_flags &
18650 (SATA_EVNT_DEVICE_RESET | SATA_EVNT_INPROC_DEVICE_RESET)) == 0) {
18651 /* Nothing to do */
18652 /* Something is weird - why we are processing dev reset? */
18653 SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst,
18654 "No device reset event!!!!", NULL);
18655
18656 return;
18657 }
18658 if ((sdinfo->satadrv_event_flags &
18659 (SATA_EVNT_DEVICE_RESET | SATA_EVNT_INPROC_DEVICE_RESET)) ==
18660 (SATA_EVNT_DEVICE_RESET | SATA_EVNT_INPROC_DEVICE_RESET)) {
18661 /* Something is weird - new device reset event */
18662 SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst,
18663 "Overlapping device reset events!", NULL);
18664 }
18665 #endif
18666 SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst,
18667 "Processing port %d device reset", saddr->cport);
18668
18669 /* Clear event flag */
18670 sdinfo->satadrv_event_flags &= ~SATA_EVNT_DEVICE_RESET;
18671
18672 /* It seems that we always need to check the port state first */
18673 sata_device.satadev_rev = SATA_DEVICE_REV;
18674 sata_device.satadev_addr = *saddr;
18675 /*
18676 * We have to exit mutex, because the HBA probe port function may
18677 * block on its own mutex.
18678 */
18679 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex);
18680 rval_probe = (*SATA_PROBE_PORT_FUNC(sata_hba_inst))
18681 (SATA_DIP(sata_hba_inst), &sata_device);
18682 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex);
18683 sata_update_port_info(sata_hba_inst, &sata_device);
18684 if (rval_probe != SATA_SUCCESS) {
18685 /* Something went wrong? Fail the port */
18686 cportinfo->cport_state = SATA_PSTATE_FAILED;
18687 sdinfo = SATA_CPORT_DRV_INFO(sata_hba_inst, saddr->cport);
18688 if (sdinfo != NULL)
18689 sdinfo->satadrv_event_flags = 0;
18690 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->
18691 cport_mutex);
18692 SATA_LOG_D((sata_hba_inst, CE_WARN,
18693 "SATA port %d probing failed",
18694 saddr->cport));
18695 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst,
18696 saddr->cport)->cport_mutex);
18697 return;
18698 }
18699 if ((sata_device.satadev_scr.sstatus &
18700 SATA_PORT_DEVLINK_UP_MASK) !=
18701 SATA_PORT_DEVLINK_UP ||
18702 sata_device.satadev_type == SATA_DTYPE_NONE) {
18703 /*
18704 * No device to process, anymore. Some other event processing
18705 * would or have already performed port info cleanup.
18706 * To be safe (HBA may need it), request clearing device
18707 * reset condition.
18708 */
18709 sdinfo = SATA_CPORT_DRV_INFO(sata_hba_inst, saddr->cport);
18710 if (sdinfo != NULL) {
18711 sdinfo->satadrv_event_flags &=
18712 ~SATA_EVNT_INPROC_DEVICE_RESET;
18713 sdinfo->satadrv_event_flags |=
18714 SATA_EVNT_CLEAR_DEVICE_RESET;
18715 }
18716 return;
18717 }
18718
18719 sdinfo = SATA_CPORT_DRV_INFO(sata_hba_inst, saddr->cport);
18720 if (sdinfo == NULL) {
18721 return;
18722 }
18723 if ((sdinfo->satadrv_event_flags &
18724 SATA_EVNT_INPROC_DEVICE_RESET) == 0) {
18725 /*
18726 * Start tracking time for device feature restoration and
18727 * identification. Save current time (lbolt value).
18728 */
18729 sdinfo->satadrv_reset_time = ddi_get_lbolt();
18730 }
18731 /* Mark device reset processing as active */
18732 sdinfo->satadrv_event_flags |= SATA_EVNT_INPROC_DEVICE_RESET;
18733
18734 old_sdinfo = *sdinfo; /* local copy of the drive info */
18735 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex);
18736
18737 rval_set = sata_set_drive_features(sata_hba_inst, &old_sdinfo, 1);
18738
18739 if (rval_set != SATA_SUCCESS) {
18740 /*
18741 * Restoring drive setting failed.
18742 * Probe the port first, to check if the port state has changed
18743 */
18744 sata_device.satadev_rev = SATA_DEVICE_REV;
18745 sata_device.satadev_addr = *saddr;
18746 sata_device.satadev_addr.qual = SATA_ADDR_CPORT;
18747 /* probe port */
18748 rval_probe = (*SATA_PROBE_PORT_FUNC(sata_hba_inst))
18749 (SATA_DIP(sata_hba_inst), &sata_device);
18750 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->
18751 cport_mutex);
18752 if (rval_probe == SATA_SUCCESS &&
18753 (sata_device.satadev_state &
18754 (SATA_PSTATE_SHUTDOWN | SATA_PSTATE_FAILED)) == 0 &&
18755 (sata_device.satadev_scr.sstatus &
18756 SATA_PORT_DEVLINK_UP_MASK) == SATA_PORT_DEVLINK_UP &&
18757 sata_device.satadev_type != SATA_DTYPE_NONE) {
18758 /*
18759 * We may retry this a bit later - in-process reset
18760 * condition should be already set.
18761 * Track retry time for device identification.
18762 */
18763 if ((cportinfo->cport_dev_type &
18764 SATA_VALID_DEV_TYPE) != 0 &&
18765 SATA_CPORTINFO_DRV_INFO(cportinfo) != NULL &&
18766 sdinfo->satadrv_reset_time != 0) {
18767 clock_t cur_time = ddi_get_lbolt();
18768 /*
18769 * If the retry time limit was not
18770 * exceeded, retry.
18771 */
18772 if ((cur_time - sdinfo->satadrv_reset_time) <
18773 drv_usectohz(SATA_DEV_REPROBE_TIMEOUT)) {
18774 mutex_enter(
18775 &sata_hba_inst->satahba_mutex);
18776 sata_hba_inst->satahba_event_flags |=
18777 SATA_EVNT_MAIN;
18778 mutex_exit(
18779 &sata_hba_inst->satahba_mutex);
18780 mutex_enter(&sata_mutex);
18781 sata_event_pending |= SATA_EVNT_MAIN;
18782 mutex_exit(&sata_mutex);
18783 return;
18784 }
18785 if (rval_set == SATA_RETRY) {
18786 /*
18787 * Setting drive features failed, but
18788 * the drive is still accessible,
18789 * so emit a warning message before
18790 * return.
18791 */
18792 mutex_exit(&SATA_CPORT_INFO(
18793 sata_hba_inst,
18794 saddr->cport)->cport_mutex);
18795 goto done;
18796 }
18797 }
18798 /* Fail the drive */
18799 sdinfo->satadrv_state = SATA_DSTATE_FAILED;
18800
18801 sata_log(sata_hba_inst, CE_WARN,
18802 "SATA device at port %d - device failed",
18803 saddr->cport);
18804
18805 DTRACE_PROBE(port_failed_f);
18806 }
18807 /*
18808 * No point of retrying - device failed or some other event
18809 * processing or already did or will do port info cleanup.
18810 * To be safe (HBA may need it),
18811 * request clearing device reset condition.
18812 */
18813 sdinfo->satadrv_event_flags |= SATA_EVNT_CLEAR_DEVICE_RESET;
18814 sdinfo->satadrv_event_flags &= ~SATA_EVNT_INPROC_DEVICE_RESET;
18815 sdinfo->satadrv_reset_time = 0;
18816 return;
18817 }
18818 done:
18819 /*
18820 * If setting of drive features failed, but the drive is still
18821 * accessible, emit a warning message.
18822 */
18823 if (rval_set == SATA_RETRY) {
18824 sata_log(sata_hba_inst, CE_WARN,
18825 "SATA device at port %d - desired setting could not be "
18826 "restored after reset. Device may not operate as expected.",
18827 saddr->cport);
18828 }
18829 /*
18830 * Raise the flag indicating that the next sata command could
18831 * be sent with SATA_CLEAR_DEV_RESET_STATE flag, if no new device
18832 * reset is reported.
18833 */
18834 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex);
18835 if (SATA_CPORTINFO_DRV_INFO(cportinfo) != NULL) {
18836 sdinfo->satadrv_reset_time = 0;
18837 if ((cportinfo->cport_dev_type & SATA_VALID_DEV_TYPE) != 0) {
18838 sdinfo = SATA_CPORTINFO_DRV_INFO(cportinfo);
18839 sdinfo->satadrv_event_flags &=
18840 ~SATA_EVNT_INPROC_DEVICE_RESET;
18841 sdinfo->satadrv_event_flags |=
18842 SATA_EVNT_CLEAR_DEVICE_RESET;
18843 }
18844 }
18845 }
18846
18847
18848 /*
18849 * Port Multiplier Port Device Reset Event processing.
18850 *
18851 * NOTE: This function has to be entered with pmport mutex held. It exits with
18852 * mutex held as well, but can release mutex during the processing.
18853 */
18854 static void
sata_process_pmdevice_reset(sata_hba_inst_t * sata_hba_inst,sata_address_t * saddr)18855 sata_process_pmdevice_reset(sata_hba_inst_t *sata_hba_inst,
18856 sata_address_t *saddr)
18857 {
18858 sata_drive_info_t old_sdinfo; /* local copy of the drive info */
18859 sata_drive_info_t *sdinfo = NULL;
18860 sata_cport_info_t *cportinfo = NULL;
18861 sata_pmport_info_t *pmportinfo = NULL;
18862 sata_pmult_info_t *pminfo = NULL;
18863 sata_device_t sata_device;
18864 uint8_t cport = saddr->cport;
18865 uint8_t pmport = saddr->pmport;
18866 int rval;
18867
18868 SATADBG2(SATA_DBG_EVENTS_PROC, sata_hba_inst,
18869 "Processing drive reset at port %d:%d", cport, pmport);
18870
18871 cportinfo = SATA_CPORT_INFO(sata_hba_inst, cport);
18872 pmportinfo = SATA_PMPORT_INFO(sata_hba_inst, cport, pmport);
18873 sdinfo = SATA_PMPORT_DRV_INFO(sata_hba_inst, cport, pmport);
18874
18875 /*
18876 * If the port is in SHUTDOWN or FAILED state, or device is in FAILED
18877 * state, ignore reset event.
18878 */
18879 if (((cportinfo->cport_state &
18880 (SATA_PSTATE_SHUTDOWN | SATA_PSTATE_FAILED)) != 0) ||
18881 (sdinfo->satadrv_state & SATA_DSTATE_FAILED) != 0) {
18882 sdinfo->satadrv_event_flags &=
18883 ~(SATA_EVNT_DEVICE_RESET | SATA_EVNT_INPROC_DEVICE_RESET);
18884 return;
18885 }
18886
18887 if ((pmportinfo->pmport_dev_type & SATA_VALID_DEV_TYPE) == 0) {
18888 /*
18889 * This should not happen - coding error.
18890 * But we can recover, so do not panic, just clean up
18891 * and if in debug mode, log the message.
18892 */
18893 #ifdef SATA_DEBUG
18894 sata_log(sata_hba_inst, CE_WARN,
18895 "sata_process_pmdevice_reset: "
18896 "Invalid device type with sdinfo!", NULL);
18897 #endif
18898 sdinfo->satadrv_event_flags = 0;
18899 return;
18900 }
18901
18902 #ifdef SATA_DEBUG
18903 if ((sdinfo->satadrv_event_flags &
18904 (SATA_EVNT_DEVICE_RESET | SATA_EVNT_INPROC_DEVICE_RESET)) == 0) {
18905 /* Nothing to do */
18906 /* Something is weird - why we are processing dev reset? */
18907 SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst,
18908 "No device reset event!!!!", NULL);
18909
18910 return;
18911 }
18912 if ((sdinfo->satadrv_event_flags &
18913 (SATA_EVNT_DEVICE_RESET | SATA_EVNT_INPROC_DEVICE_RESET)) ==
18914 (SATA_EVNT_DEVICE_RESET | SATA_EVNT_INPROC_DEVICE_RESET)) {
18915 /* Something is weird - new device reset event */
18916 SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst,
18917 "Overlapping device reset events!", NULL);
18918 }
18919 #endif
18920 SATADBG2(SATA_DBG_EVENTS_PROC, sata_hba_inst,
18921 "Processing port %d:%d device reset", cport, pmport);
18922
18923 /* Clear event flag */
18924 sdinfo->satadrv_event_flags &= ~SATA_EVNT_DEVICE_RESET;
18925
18926 /* It seems that we always need to check the port state first */
18927 sata_device.satadev_rev = SATA_DEVICE_REV;
18928 sata_device.satadev_addr = *saddr;
18929 /*
18930 * We have to exit mutex, because the HBA probe port function may
18931 * block on its own mutex.
18932 */
18933 mutex_exit(&pmportinfo->pmport_mutex);
18934 rval = (*SATA_PROBE_PORT_FUNC(sata_hba_inst))
18935 (SATA_DIP(sata_hba_inst), &sata_device);
18936 mutex_enter(&pmportinfo->pmport_mutex);
18937
18938 sata_update_pmport_info(sata_hba_inst, &sata_device);
18939 if (rval != SATA_SUCCESS) {
18940 /* Something went wrong? Fail the port */
18941 pmportinfo->pmport_state = SATA_PSTATE_FAILED;
18942 sdinfo = SATA_PMPORT_DRV_INFO(sata_hba_inst, saddr->cport,
18943 saddr->pmport);
18944 if (sdinfo != NULL)
18945 sdinfo->satadrv_event_flags = 0;
18946 mutex_exit(&pmportinfo->pmport_mutex);
18947 SATA_LOG_D((sata_hba_inst, CE_WARN,
18948 "SATA port %d:%d probing failed",
18949 saddr->cport, saddr->pmport));
18950 mutex_enter(&pmportinfo->pmport_mutex);
18951 return;
18952 }
18953 if ((sata_device.satadev_scr.sstatus &
18954 SATA_PORT_DEVLINK_UP_MASK) !=
18955 SATA_PORT_DEVLINK_UP ||
18956 sata_device.satadev_type == SATA_DTYPE_NONE) {
18957 /*
18958 * No device to process, anymore. Some other event processing
18959 * would or have already performed port info cleanup.
18960 * To be safe (HBA may need it), request clearing device
18961 * reset condition.
18962 */
18963 sdinfo = SATA_PMPORT_DRV_INFO(sata_hba_inst, saddr->cport,
18964 saddr->pmport);
18965 if (sdinfo != NULL) {
18966 sdinfo->satadrv_event_flags &=
18967 ~SATA_EVNT_INPROC_DEVICE_RESET;
18968 /* must clear flags on cport */
18969 pminfo = SATA_PMULT_INFO(sata_hba_inst,
18970 saddr->cport);
18971 pminfo->pmult_event_flags |=
18972 SATA_EVNT_CLEAR_DEVICE_RESET;
18973 }
18974 return;
18975 }
18976
18977 sdinfo = SATA_PMPORT_DRV_INFO(sata_hba_inst, saddr->cport,
18978 saddr->pmport);
18979 if (sdinfo == NULL) {
18980 return;
18981 }
18982 if ((sdinfo->satadrv_event_flags &
18983 SATA_EVNT_INPROC_DEVICE_RESET) == 0) {
18984 /*
18985 * Start tracking time for device feature restoration and
18986 * identification. Save current time (lbolt value).
18987 */
18988 sdinfo->satadrv_reset_time = ddi_get_lbolt();
18989 }
18990 /* Mark device reset processing as active */
18991 sdinfo->satadrv_event_flags |= SATA_EVNT_INPROC_DEVICE_RESET;
18992
18993 old_sdinfo = *sdinfo; /* local copy of the drive info */
18994 mutex_exit(&pmportinfo->pmport_mutex);
18995
18996 if (sata_set_drive_features(sata_hba_inst, &old_sdinfo, 1) ==
18997 SATA_FAILURE) {
18998 /*
18999 * Restoring drive setting failed.
19000 * Probe the port first, to check if the port state has changed
19001 */
19002 sata_device.satadev_rev = SATA_DEVICE_REV;
19003 sata_device.satadev_addr = *saddr;
19004 sata_device.satadev_addr.qual = SATA_ADDR_PMPORT;
19005
19006 /* probe port */
19007 rval = (*SATA_PROBE_PORT_FUNC(sata_hba_inst))
19008 (SATA_DIP(sata_hba_inst), &sata_device);
19009 mutex_enter(&pmportinfo->pmport_mutex);
19010 if (rval == SATA_SUCCESS &&
19011 (sata_device.satadev_state &
19012 (SATA_PSTATE_SHUTDOWN | SATA_PSTATE_FAILED)) == 0 &&
19013 (sata_device.satadev_scr.sstatus &
19014 SATA_PORT_DEVLINK_UP_MASK) == SATA_PORT_DEVLINK_UP &&
19015 sata_device.satadev_type != SATA_DTYPE_NONE) {
19016 /*
19017 * We may retry this a bit later - in-process reset
19018 * condition should be already set.
19019 * Track retry time for device identification.
19020 */
19021 if ((pmportinfo->pmport_dev_type &
19022 SATA_VALID_DEV_TYPE) != 0 &&
19023 SATA_PMPORTINFO_DRV_INFO(pmportinfo) != NULL &&
19024 sdinfo->satadrv_reset_time != 0) {
19025 clock_t cur_time = ddi_get_lbolt();
19026 /*
19027 * If the retry time limit was not
19028 * exceeded, retry.
19029 */
19030 if ((cur_time - sdinfo->satadrv_reset_time) <
19031 drv_usectohz(SATA_DEV_REPROBE_TIMEOUT)) {
19032 mutex_enter(
19033 &sata_hba_inst->satahba_mutex);
19034 sata_hba_inst->satahba_event_flags |=
19035 SATA_EVNT_MAIN;
19036 mutex_exit(
19037 &sata_hba_inst->satahba_mutex);
19038 mutex_enter(&sata_mutex);
19039 sata_event_pending |= SATA_EVNT_MAIN;
19040 mutex_exit(&sata_mutex);
19041 return;
19042 }
19043 }
19044 /* Fail the drive */
19045 sdinfo->satadrv_state = SATA_DSTATE_FAILED;
19046
19047 sata_log(sata_hba_inst, CE_WARN,
19048 "SATA device at port %d:%d - device failed",
19049 saddr->cport, saddr->pmport);
19050 } else {
19051 /*
19052 * No point of retrying - some other event processing
19053 * would or already did port info cleanup.
19054 * To be safe (HBA may need it),
19055 * request clearing device reset condition.
19056 */
19057 sdinfo->satadrv_event_flags |=
19058 SATA_EVNT_CLEAR_DEVICE_RESET;
19059 }
19060 sdinfo->satadrv_event_flags &= ~SATA_EVNT_INPROC_DEVICE_RESET;
19061 sdinfo->satadrv_reset_time = 0;
19062 return;
19063 }
19064 /*
19065 * Raise the flag indicating that the next sata command could
19066 * be sent with SATA_CLEAR_DEV_RESET_STATE flag, if no new device
19067 * reset is reported.
19068 */
19069 mutex_enter(&pmportinfo->pmport_mutex);
19070 if (SATA_PMPORTINFO_DRV_INFO(pmportinfo) != NULL) {
19071 sdinfo->satadrv_reset_time = 0;
19072 if (pmportinfo->pmport_dev_type & SATA_VALID_DEV_TYPE) {
19073 sdinfo = SATA_PMPORTINFO_DRV_INFO(pmportinfo);
19074 sdinfo->satadrv_event_flags &=
19075 ~SATA_EVNT_INPROC_DEVICE_RESET;
19076 /* must clear flags on cport */
19077 pminfo = SATA_PMULT_INFO(sata_hba_inst,
19078 saddr->cport);
19079 pminfo->pmult_event_flags |=
19080 SATA_EVNT_CLEAR_DEVICE_RESET;
19081 }
19082 }
19083 }
19084
19085 /*
19086 * Port Link Events processing.
19087 * Every link established event may involve device reset (due to
19088 * COMRESET signal, equivalent of the hard reset) so arbitrarily
19089 * set device reset event for an attached device (if any).
19090 * If the port is in SHUTDOWN or FAILED state, ignore link events.
19091 *
19092 * The link established event processing varies, depending on the state
19093 * of the target node, HBA hotplugging capabilities, state of the port.
19094 * If the link is not active, the link established event is ignored.
19095 * If HBA cannot detect device attachment and there is no target node,
19096 * the link established event triggers device attach event processing.
19097 * Else, link established event triggers device reset event processing.
19098 *
19099 * The link lost event processing varies, depending on a HBA hotplugging
19100 * capability and the state of the port (link active or not active).
19101 * If the link is active, the lost link event is ignored.
19102 * If HBA cannot detect device removal, the lost link event triggers
19103 * device detached event processing after link lost timeout.
19104 * Else, the event is ignored.
19105 *
19106 * NOTE: Port multiplier ports events are handled by
19107 * sata_process_pmport_link_events();
19108 */
19109 static void
sata_process_port_link_events(sata_hba_inst_t * sata_hba_inst,sata_address_t * saddr)19110 sata_process_port_link_events(sata_hba_inst_t *sata_hba_inst,
19111 sata_address_t *saddr)
19112 {
19113 sata_device_t sata_device;
19114 sata_cport_info_t *cportinfo;
19115 sata_drive_info_t *sdinfo;
19116 uint32_t event_flags;
19117 int rval;
19118
19119 SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst,
19120 "Processing port %d link event(s)", saddr->cport);
19121
19122 cportinfo = SATA_CPORT_INFO(sata_hba_inst, saddr->cport);
19123 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex);
19124 event_flags = cportinfo->cport_event_flags;
19125
19126 /* Reset event flags first */
19127 cportinfo->cport_event_flags &=
19128 ~(SATA_EVNT_LINK_ESTABLISHED | SATA_EVNT_LINK_LOST);
19129
19130 /* If the port is in SHUTDOWN or FAILED state, ignore link events. */
19131 if ((cportinfo->cport_state &
19132 (SATA_PSTATE_SHUTDOWN | SATA_PSTATE_FAILED)) != 0) {
19133 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->
19134 cport_mutex);
19135 return;
19136 }
19137
19138 /*
19139 * For the sanity sake get current port state.
19140 * Set device address only. Other sata_device fields should be
19141 * set by HBA driver.
19142 */
19143 sata_device.satadev_rev = SATA_DEVICE_REV;
19144 sata_device.satadev_addr = *saddr;
19145 /*
19146 * We have to exit mutex, because the HBA probe port function may
19147 * block on its own mutex.
19148 */
19149 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex);
19150 rval = (*SATA_PROBE_PORT_FUNC(sata_hba_inst))
19151 (SATA_DIP(sata_hba_inst), &sata_device);
19152 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex);
19153 sata_update_port_info(sata_hba_inst, &sata_device);
19154 if (rval != SATA_SUCCESS) {
19155 /* Something went wrong? Fail the port */
19156 cportinfo->cport_state = SATA_PSTATE_FAILED;
19157 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->
19158 cport_mutex);
19159 SATA_LOG_D((sata_hba_inst, CE_WARN,
19160 "SATA port %d probing failed",
19161 saddr->cport));
19162 /*
19163 * We may want to release device info structure, but
19164 * it is not necessary.
19165 */
19166 return;
19167 } else {
19168 /* port probed successfully */
19169 cportinfo->cport_state |= SATA_STATE_PROBED | SATA_STATE_READY;
19170 }
19171 if (event_flags & SATA_EVNT_LINK_ESTABLISHED) {
19172
19173 if ((sata_device.satadev_scr.sstatus &
19174 SATA_PORT_DEVLINK_UP_MASK) != SATA_PORT_DEVLINK_UP) {
19175 /* Ignore event */
19176 SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst,
19177 "Ignoring port %d link established event - "
19178 "link down",
19179 saddr->cport);
19180 goto linklost;
19181 }
19182
19183 SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst,
19184 "Processing port %d link established event",
19185 saddr->cport);
19186
19187 /*
19188 * For the sanity sake check if a device is attached - check
19189 * return state of a port probing.
19190 */
19191 if (sata_device.satadev_type != SATA_DTYPE_NONE) {
19192 /*
19193 * HBA port probe indicated that there is a device
19194 * attached. Check if the framework had device info
19195 * structure attached for this device.
19196 */
19197 if (cportinfo->cport_dev_type != SATA_DTYPE_NONE) {
19198 ASSERT(SATA_CPORTINFO_DRV_INFO(cportinfo) !=
19199 NULL);
19200
19201 sdinfo = SATA_CPORTINFO_DRV_INFO(cportinfo);
19202 if ((sdinfo->satadrv_type &
19203 SATA_VALID_DEV_TYPE) != 0) {
19204 /*
19205 * Dev info structure is present.
19206 * If dev_type is set to known type in
19207 * the framework's drive info struct
19208 * then the device existed before and
19209 * the link was probably lost
19210 * momentarily - in such case
19211 * we may want to check device
19212 * identity.
19213 * Identity check is not supported now.
19214 *
19215 * Link established event
19216 * triggers device reset event.
19217 */
19218 (SATA_CPORTINFO_DRV_INFO(cportinfo))->
19219 satadrv_event_flags |=
19220 SATA_EVNT_DEVICE_RESET;
19221 }
19222 } else if (cportinfo->cport_dev_type ==
19223 SATA_DTYPE_NONE) {
19224 /*
19225 * We got new device attached! If HBA does not
19226 * generate device attached events, trigger it
19227 * here.
19228 */
19229 if (!(SATA_FEATURES(sata_hba_inst) &
19230 SATA_CTLF_HOTPLUG)) {
19231 cportinfo->cport_event_flags |=
19232 SATA_EVNT_DEVICE_ATTACHED;
19233 }
19234 }
19235 /* Reset link lost timeout */
19236 cportinfo->cport_link_lost_time = 0;
19237 }
19238 }
19239 linklost:
19240 if (event_flags & SATA_EVNT_LINK_LOST) {
19241 if ((sata_device.satadev_scr.sstatus &
19242 SATA_PORT_DEVLINK_UP_MASK) == SATA_PORT_DEVLINK_UP) {
19243 /* Ignore event */
19244 SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst,
19245 "Ignoring port %d link lost event - link is up",
19246 saddr->cport);
19247 goto done;
19248 }
19249 #ifdef SATA_DEBUG
19250 if (cportinfo->cport_link_lost_time == 0) {
19251 SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst,
19252 "Processing port %d link lost event",
19253 saddr->cport);
19254 }
19255 #endif
19256 /*
19257 * When HBA cannot generate device attached/detached events,
19258 * we need to track link lost time and eventually generate
19259 * device detach event.
19260 */
19261 if (!(SATA_FEATURES(sata_hba_inst) & SATA_CTLF_HOTPLUG)) {
19262 /* We are tracking link lost time */
19263 if (cportinfo->cport_link_lost_time == 0) {
19264 /* save current time (lbolt value) */
19265 cportinfo->cport_link_lost_time =
19266 ddi_get_lbolt();
19267 /* just keep link lost event */
19268 cportinfo->cport_event_flags |=
19269 SATA_EVNT_LINK_LOST;
19270 } else {
19271 clock_t cur_time = ddi_get_lbolt();
19272 if ((cur_time -
19273 cportinfo->cport_link_lost_time) >=
19274 drv_usectohz(
19275 SATA_EVNT_LINK_LOST_TIMEOUT)) {
19276 /* trigger device detach event */
19277 cportinfo->cport_event_flags |=
19278 SATA_EVNT_DEVICE_DETACHED;
19279 cportinfo->cport_link_lost_time = 0;
19280 SATADBG1(SATA_DBG_EVENTS,
19281 sata_hba_inst,
19282 "Triggering port %d "
19283 "device detached event",
19284 saddr->cport);
19285 } else {
19286 /* keep link lost event */
19287 cportinfo->cport_event_flags |=
19288 SATA_EVNT_LINK_LOST;
19289 }
19290 }
19291 }
19292 /*
19293 * We could change port state to disable/delay access to
19294 * the attached device until the link is recovered.
19295 */
19296 }
19297 done:
19298 event_flags = cportinfo->cport_event_flags;
19299 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex);
19300 if (event_flags != 0) {
19301 mutex_enter(&sata_hba_inst->satahba_mutex);
19302 sata_hba_inst->satahba_event_flags |= SATA_EVNT_MAIN;
19303 mutex_exit(&sata_hba_inst->satahba_mutex);
19304 mutex_enter(&sata_mutex);
19305 sata_event_pending |= SATA_EVNT_MAIN;
19306 mutex_exit(&sata_mutex);
19307 }
19308 }
19309
19310 /*
19311 * Port Multiplier Port Link Events processing.
19312 */
19313 static void
sata_process_pmport_link_events(sata_hba_inst_t * sata_hba_inst,sata_address_t * saddr)19314 sata_process_pmport_link_events(sata_hba_inst_t *sata_hba_inst,
19315 sata_address_t *saddr)
19316 {
19317 sata_device_t sata_device;
19318 sata_pmport_info_t *pmportinfo = NULL;
19319 sata_drive_info_t *sdinfo = NULL;
19320 uint32_t event_flags;
19321 uint8_t cport = saddr->cport;
19322 uint8_t pmport = saddr->pmport;
19323 int rval;
19324
19325 SATADBG2(SATA_DBG_EVENTS_PROC, sata_hba_inst,
19326 "Processing port %d:%d link event(s)",
19327 cport, pmport);
19328
19329 pmportinfo = SATA_PMPORT_INFO(sata_hba_inst, cport, pmport);
19330 mutex_enter(&pmportinfo->pmport_mutex);
19331 event_flags = pmportinfo->pmport_event_flags;
19332
19333 /* Reset event flags first */
19334 pmportinfo->pmport_event_flags &=
19335 ~(SATA_EVNT_LINK_ESTABLISHED | SATA_EVNT_LINK_LOST);
19336
19337 /* If the port is in SHUTDOWN or FAILED state, ignore link events. */
19338 if ((pmportinfo->pmport_state &
19339 (SATA_PSTATE_SHUTDOWN | SATA_PSTATE_FAILED)) != 0) {
19340 mutex_exit(&pmportinfo->pmport_mutex);
19341 return;
19342 }
19343
19344 /*
19345 * For the sanity sake get current port state.
19346 * Set device address only. Other sata_device fields should be
19347 * set by HBA driver.
19348 */
19349 sata_device.satadev_rev = SATA_DEVICE_REV;
19350 sata_device.satadev_addr = *saddr;
19351 /*
19352 * We have to exit mutex, because the HBA probe port function may
19353 * block on its own mutex.
19354 */
19355 mutex_exit(&SATA_PMPORT_MUTEX(sata_hba_inst, saddr->cport,
19356 saddr->pmport));
19357 rval = (*SATA_PROBE_PORT_FUNC(sata_hba_inst))
19358 (SATA_DIP(sata_hba_inst), &sata_device);
19359 mutex_enter(&SATA_PMPORT_MUTEX(sata_hba_inst, saddr->cport,
19360 saddr->pmport));
19361 sata_update_pmport_info(sata_hba_inst, &sata_device);
19362 if (rval != SATA_SUCCESS) {
19363 /* Something went wrong? Fail the port */
19364 pmportinfo->pmport_state = SATA_PSTATE_FAILED;
19365 mutex_exit(&SATA_PMPORT_MUTEX(sata_hba_inst, saddr->cport,
19366 saddr->pmport));
19367 SATA_LOG_D((sata_hba_inst, CE_WARN,
19368 "SATA port %d:%d probing failed",
19369 saddr->cport, saddr->pmport));
19370 /*
19371 * We may want to release device info structure, but
19372 * it is not necessary.
19373 */
19374 return;
19375 } else {
19376 /* port probed successfully */
19377 pmportinfo->pmport_state |=
19378 SATA_STATE_PROBED | SATA_STATE_READY;
19379 }
19380 mutex_exit(&SATA_PMPORT_MUTEX(sata_hba_inst,
19381 saddr->cport, saddr->pmport));
19382 mutex_enter(&SATA_PMPORT_MUTEX(sata_hba_inst,
19383 saddr->cport, saddr->pmport));
19384 if (event_flags & SATA_EVNT_LINK_ESTABLISHED) {
19385
19386 if ((sata_device.satadev_scr.sstatus &
19387 SATA_PORT_DEVLINK_UP_MASK) != SATA_PORT_DEVLINK_UP) {
19388 /* Ignore event */
19389 SATADBG2(SATA_DBG_EVENTS_PROC, sata_hba_inst,
19390 "Ignoring port %d:%d link established event - "
19391 "link down",
19392 saddr->cport, saddr->pmport);
19393 goto linklost;
19394 }
19395
19396 SATADBG2(SATA_DBG_EVENTS_PROC, sata_hba_inst,
19397 "Processing port %d:%d link established event",
19398 cport, pmport);
19399
19400 /*
19401 * For the sanity sake check if a device is attached - check
19402 * return state of a port probing.
19403 */
19404 if (sata_device.satadev_type != SATA_DTYPE_NONE &&
19405 sata_device.satadev_type != SATA_DTYPE_PMULT) {
19406 /*
19407 * HBA port probe indicated that there is a device
19408 * attached. Check if the framework had device info
19409 * structure attached for this device.
19410 */
19411 if (pmportinfo->pmport_dev_type != SATA_DTYPE_NONE) {
19412 ASSERT(SATA_PMPORTINFO_DRV_INFO(pmportinfo) !=
19413 NULL);
19414
19415 sdinfo = SATA_PMPORTINFO_DRV_INFO(pmportinfo);
19416 if ((sdinfo->satadrv_type &
19417 SATA_VALID_DEV_TYPE) != 0) {
19418 /*
19419 * Dev info structure is present.
19420 * If dev_type is set to known type in
19421 * the framework's drive info struct
19422 * then the device existed before and
19423 * the link was probably lost
19424 * momentarily - in such case
19425 * we may want to check device
19426 * identity.
19427 * Identity check is not supported now.
19428 *
19429 * Link established event
19430 * triggers device reset event.
19431 */
19432 (SATA_PMPORTINFO_DRV_INFO(pmportinfo))->
19433 satadrv_event_flags |=
19434 SATA_EVNT_DEVICE_RESET;
19435 }
19436 } else if (pmportinfo->pmport_dev_type ==
19437 SATA_DTYPE_NONE) {
19438 /*
19439 * We got new device attached! If HBA does not
19440 * generate device attached events, trigger it
19441 * here.
19442 */
19443 if (!(SATA_FEATURES(sata_hba_inst) &
19444 SATA_CTLF_HOTPLUG)) {
19445 pmportinfo->pmport_event_flags |=
19446 SATA_EVNT_DEVICE_ATTACHED;
19447 }
19448 }
19449 /* Reset link lost timeout */
19450 pmportinfo->pmport_link_lost_time = 0;
19451 }
19452 }
19453 linklost:
19454 if (event_flags & SATA_EVNT_LINK_LOST) {
19455 #ifdef SATA_DEBUG
19456 if (pmportinfo->pmport_link_lost_time == 0) {
19457 SATADBG2(SATA_DBG_EVENTS_PROC, sata_hba_inst,
19458 "Processing port %d:%d link lost event",
19459 saddr->cport, saddr->pmport);
19460 }
19461 #endif
19462 if ((sata_device.satadev_scr.sstatus &
19463 SATA_PORT_DEVLINK_UP_MASK) == SATA_PORT_DEVLINK_UP) {
19464 /* Ignore event */
19465 SATADBG2(SATA_DBG_EVENTS_PROC, sata_hba_inst,
19466 "Ignoring port %d:%d link lost event - link is up",
19467 saddr->cport, saddr->pmport);
19468 goto done;
19469 }
19470 /*
19471 * When HBA cannot generate device attached/detached events,
19472 * we need to track link lost time and eventually generate
19473 * device detach event.
19474 */
19475 if (!(SATA_FEATURES(sata_hba_inst) & SATA_CTLF_HOTPLUG)) {
19476 /* We are tracking link lost time */
19477 if (pmportinfo->pmport_link_lost_time == 0) {
19478 /* save current time (lbolt value) */
19479 pmportinfo->pmport_link_lost_time =
19480 ddi_get_lbolt();
19481 /* just keep link lost event */
19482 pmportinfo->pmport_event_flags |=
19483 SATA_EVNT_LINK_LOST;
19484 } else {
19485 clock_t cur_time = ddi_get_lbolt();
19486 if ((cur_time -
19487 pmportinfo->pmport_link_lost_time) >=
19488 drv_usectohz(
19489 SATA_EVNT_LINK_LOST_TIMEOUT)) {
19490 /* trigger device detach event */
19491 pmportinfo->pmport_event_flags |=
19492 SATA_EVNT_DEVICE_DETACHED;
19493 pmportinfo->pmport_link_lost_time = 0;
19494 SATADBG2(SATA_DBG_EVENTS,
19495 sata_hba_inst,
19496 "Triggering port %d:%d "
19497 "device detached event",
19498 saddr->cport, saddr->pmport);
19499 } else {
19500 /* keep link lost event */
19501 pmportinfo->pmport_event_flags |=
19502 SATA_EVNT_LINK_LOST;
19503 }
19504 }
19505 }
19506 /*
19507 * We could change port state to disable/delay access to
19508 * the attached device until the link is recovered.
19509 */
19510 }
19511 done:
19512 event_flags = pmportinfo->pmport_event_flags;
19513 mutex_exit(&SATA_PMPORT_MUTEX(sata_hba_inst, saddr->cport,
19514 saddr->pmport));
19515 if (event_flags != 0) {
19516 mutex_enter(&sata_hba_inst->satahba_mutex);
19517 sata_hba_inst->satahba_event_flags |= SATA_EVNT_MAIN;
19518 mutex_exit(&sata_hba_inst->satahba_mutex);
19519 mutex_enter(&sata_mutex);
19520 sata_event_pending |= SATA_EVNT_MAIN;
19521 mutex_exit(&sata_mutex);
19522 }
19523 }
19524
19525 /*
19526 * Device Detached Event processing.
19527 * Port is probed to find if a device is really gone. If so,
19528 * the device info structure is detached from the SATA port info structure
19529 * and released.
19530 * Port status is updated.
19531 *
19532 * NOTE: Port multiplier ports events are handled by
19533 * sata_process_pmdevice_detached()
19534 */
19535 static void
sata_process_device_detached(sata_hba_inst_t * sata_hba_inst,sata_address_t * saddr)19536 sata_process_device_detached(sata_hba_inst_t *sata_hba_inst,
19537 sata_address_t *saddr)
19538 {
19539 sata_cport_info_t *cportinfo;
19540 sata_pmport_info_t *pmportinfo;
19541 sata_drive_info_t *sdevinfo;
19542 sata_device_t sata_device;
19543 sata_address_t pmport_addr;
19544 char name[16];
19545 uint8_t cport = saddr->cport;
19546 int npmport;
19547 int rval;
19548
19549 SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst,
19550 "Processing port %d device detached", saddr->cport);
19551
19552 cportinfo = SATA_CPORT_INFO(sata_hba_inst, saddr->cport);
19553 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex);
19554 /* Clear event flag */
19555 cportinfo->cport_event_flags &= ~SATA_EVNT_DEVICE_DETACHED;
19556
19557 /* If the port is in SHUTDOWN or FAILED state, ignore detach event. */
19558 if ((cportinfo->cport_state &
19559 (SATA_PSTATE_SHUTDOWN | SATA_PSTATE_FAILED)) != 0) {
19560 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->
19561 cport_mutex);
19562 return;
19563 }
19564 /* For sanity, re-probe the port */
19565 sata_device.satadev_rev = SATA_DEVICE_REV;
19566 sata_device.satadev_addr = *saddr;
19567
19568 /*
19569 * We have to exit mutex, because the HBA probe port function may
19570 * block on its own mutex.
19571 */
19572 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex);
19573 rval = (*SATA_PROBE_PORT_FUNC(sata_hba_inst))
19574 (SATA_DIP(sata_hba_inst), &sata_device);
19575 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex);
19576 sata_update_port_info(sata_hba_inst, &sata_device);
19577 if (rval != SATA_SUCCESS) {
19578 /* Something went wrong? Fail the port */
19579 cportinfo->cport_state = SATA_PSTATE_FAILED;
19580 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->
19581 cport_mutex);
19582 SATA_LOG_D((sata_hba_inst, CE_WARN,
19583 "SATA port %d probing failed",
19584 saddr->cport));
19585 /*
19586 * We may want to release device info structure, but
19587 * it is not necessary.
19588 */
19589 return;
19590 } else {
19591 /* port probed successfully */
19592 cportinfo->cport_state |= SATA_STATE_PROBED | SATA_STATE_READY;
19593 }
19594 /*
19595 * Check if a device is still attached. For sanity, check also
19596 * link status - if no link, there is no device.
19597 */
19598 if ((sata_device.satadev_scr.sstatus & SATA_PORT_DEVLINK_UP_MASK) ==
19599 SATA_PORT_DEVLINK_UP && sata_device.satadev_type !=
19600 SATA_DTYPE_NONE) {
19601 /*
19602 * Device is still attached - ignore detach event.
19603 */
19604 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->
19605 cport_mutex);
19606 SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst,
19607 "Ignoring detach - device still attached to port %d",
19608 sata_device.satadev_addr.cport);
19609 return;
19610 }
19611 /*
19612 * We need to detach and release device info structure here
19613 */
19614 if (cportinfo->cport_dev_type == SATA_DTYPE_PMULT) {
19615 /*
19616 * A port-multiplier is removed.
19617 *
19618 * Calling sata_process_pmdevice_detached() does not work
19619 * here. The port multiplier is gone, so we cannot probe
19620 * sub-port any more and all pmult-related data structure must
19621 * be de-allocated immediately. Following structure of every
19622 * implemented sub-port behind the pmult are required to
19623 * released.
19624 *
19625 * - attachment point
19626 * - target node
19627 * - sata_drive_info
19628 * - sata_pmport_info
19629 */
19630 for (npmport = 0; npmport < SATA_NUM_PMPORTS(sata_hba_inst,
19631 cport); npmport ++) {
19632 SATADBG2(SATA_DBG_PMULT|SATA_DBG_EVENTS_PROC,
19633 sata_hba_inst,
19634 "Detaching target node at port %d:%d",
19635 cport, npmport);
19636
19637 mutex_exit(&SATA_CPORT_MUTEX(sata_hba_inst, cport));
19638
19639 /* Remove attachment point. */
19640 name[0] = '\0';
19641 (void) sprintf(name, "%d.%d", cport, npmport);
19642 ddi_remove_minor_node(SATA_DIP(sata_hba_inst), name);
19643 sata_log(sata_hba_inst, CE_NOTE,
19644 "Remove attachment point of port %d:%d",
19645 cport, npmport);
19646
19647 /* Remove target node */
19648 pmport_addr.cport = cport;
19649 pmport_addr.pmport = (uint8_t)npmport;
19650 pmport_addr.qual = SATA_ADDR_PMPORT;
19651 sata_remove_target_node(sata_hba_inst, &pmport_addr);
19652
19653 mutex_enter(&SATA_CPORT_MUTEX(sata_hba_inst, cport));
19654
19655 /* Release sata_pmport_info & sata_drive_info. */
19656 pmportinfo = SATA_PMPORT_INFO(sata_hba_inst,
19657 cport, npmport);
19658 ASSERT(pmportinfo != NULL);
19659
19660 sdevinfo = SATA_PMPORTINFO_DRV_INFO(pmportinfo);
19661 if (sdevinfo != NULL) {
19662 (void) kmem_free((void *) sdevinfo,
19663 sizeof (sata_drive_info_t));
19664 }
19665
19666 /* Release sata_pmport_info at last */
19667 (void) kmem_free((void *) pmportinfo,
19668 sizeof (sata_pmport_info_t));
19669 }
19670
19671 /* Finally, release sata_pmult_info */
19672 (void) kmem_free((void *)
19673 SATA_CPORTINFO_PMULT_INFO(cportinfo),
19674 sizeof (sata_pmult_info_t));
19675 SATA_CPORTINFO_PMULT_INFO(cportinfo) = NULL;
19676
19677 sata_log(sata_hba_inst, CE_WARN,
19678 "SATA port-multiplier detached at port %d", cport);
19679
19680 cportinfo->cport_dev_type = SATA_DTYPE_NONE;
19681 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst,
19682 saddr->cport)->cport_mutex);
19683 } else {
19684 if (SATA_CPORTINFO_DRV_INFO(cportinfo) != NULL) {
19685 sdevinfo = SATA_CPORTINFO_DRV_INFO(cportinfo);
19686 SATA_CPORTINFO_DRV_INFO(cportinfo) = NULL;
19687 (void) kmem_free((void *)sdevinfo,
19688 sizeof (sata_drive_info_t));
19689 }
19690 sata_log(sata_hba_inst, CE_WARN,
19691 "SATA device detached at port %d", cport);
19692
19693 cportinfo->cport_dev_type = SATA_DTYPE_NONE;
19694 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst,
19695 saddr->cport)->cport_mutex);
19696
19697 /*
19698 * Try to offline a device and remove target node
19699 * if it still exists
19700 */
19701 sata_remove_target_node(sata_hba_inst, saddr);
19702 }
19703
19704
19705 /*
19706 * Generate sysevent - EC_DR / ESC_DR_AP_STATE_CHANGE
19707 * with the hint: SE_HINT_REMOVE
19708 */
19709 sata_gen_sysevent(sata_hba_inst, saddr, SE_HINT_REMOVE);
19710 }
19711
19712 /*
19713 * Port Multiplier Port Device Deattached Event processing.
19714 *
19715 * NOTE: No Mutex should be hold.
19716 */
19717 static void
sata_process_pmdevice_detached(sata_hba_inst_t * sata_hba_inst,sata_address_t * saddr)19718 sata_process_pmdevice_detached(sata_hba_inst_t *sata_hba_inst,
19719 sata_address_t *saddr)
19720 {
19721 sata_pmport_info_t *pmportinfo;
19722 sata_drive_info_t *sdevinfo;
19723 sata_device_t sata_device;
19724 int rval;
19725 uint8_t cport, pmport;
19726
19727 cport = saddr->cport;
19728 pmport = saddr->pmport;
19729
19730 SATADBG2(SATA_DBG_EVENTS_PROC, sata_hba_inst,
19731 "Processing port %d:%d device detached",
19732 cport, pmport);
19733
19734 pmportinfo = SATA_PMPORT_INFO(sata_hba_inst, cport, pmport);
19735 mutex_enter(&SATA_PMPORT_MUTEX(sata_hba_inst, cport, pmport));
19736
19737 /* Clear event flag */
19738 pmportinfo->pmport_event_flags &= ~SATA_EVNT_DEVICE_DETACHED;
19739
19740 /* If the port is in SHUTDOWN or FAILED state, ignore detach event. */
19741 if ((pmportinfo->pmport_state &
19742 (SATA_PSTATE_SHUTDOWN | SATA_PSTATE_FAILED)) != 0) {
19743 mutex_exit(&SATA_PMPORT_MUTEX(sata_hba_inst, cport, pmport));
19744 return;
19745 }
19746 /* For sanity, re-probe the port */
19747 sata_device.satadev_rev = SATA_DEVICE_REV;
19748 sata_device.satadev_addr = *saddr;
19749
19750 /*
19751 * We have to exit mutex, because the HBA probe port function may
19752 * block on its own mutex.
19753 */
19754 mutex_exit(&SATA_PMPORT_MUTEX(sata_hba_inst, cport, pmport));
19755 rval = (*SATA_PROBE_PORT_FUNC(sata_hba_inst))
19756 (SATA_DIP(sata_hba_inst), &sata_device);
19757 mutex_enter(&SATA_PMPORT_MUTEX(sata_hba_inst, cport, pmport));
19758 sata_update_pmport_info(sata_hba_inst, &sata_device);
19759 if (rval != SATA_SUCCESS) {
19760 /* Something went wrong? Fail the port */
19761 pmportinfo->pmport_state = SATA_PSTATE_FAILED;
19762 mutex_exit(&SATA_PMPORT_MUTEX(sata_hba_inst, cport, pmport));
19763 SATA_LOG_D((sata_hba_inst, CE_WARN,
19764 "SATA port %d:%d probing failed",
19765 saddr->pmport));
19766 /*
19767 * We may want to release device info structure, but
19768 * it is not necessary.
19769 */
19770 return;
19771 } else {
19772 /* port probed successfully */
19773 pmportinfo->pmport_state |=
19774 SATA_STATE_PROBED | SATA_STATE_READY;
19775 }
19776 /*
19777 * Check if a device is still attached. For sanity, check also
19778 * link status - if no link, there is no device.
19779 */
19780 if ((sata_device.satadev_scr.sstatus & SATA_PORT_DEVLINK_UP_MASK) ==
19781 SATA_PORT_DEVLINK_UP && sata_device.satadev_type !=
19782 SATA_DTYPE_NONE) {
19783 /*
19784 * Device is still attached - ignore detach event.
19785 */
19786 mutex_exit(&SATA_PMPORT_MUTEX(sata_hba_inst, cport, pmport));
19787 SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst,
19788 "Ignoring detach - device still attached to port %d",
19789 sata_device.satadev_addr.pmport);
19790 return;
19791 }
19792 /*
19793 * We need to detach and release device info structure here
19794 */
19795 if (SATA_PMPORTINFO_DRV_INFO(pmportinfo) != NULL) {
19796 sdevinfo = SATA_PMPORTINFO_DRV_INFO(pmportinfo);
19797 SATA_PMPORTINFO_DRV_INFO(pmportinfo) = NULL;
19798 (void) kmem_free((void *)sdevinfo,
19799 sizeof (sata_drive_info_t));
19800 }
19801 pmportinfo->pmport_dev_type = SATA_DTYPE_NONE;
19802 /*
19803 * Device cannot be reached anymore, even if the target node may be
19804 * still present.
19805 */
19806 mutex_exit(&SATA_PMPORT_MUTEX(sata_hba_inst, cport, pmport));
19807
19808 /*
19809 * Try to offline a device and remove target node if it still exists
19810 */
19811 sata_remove_target_node(sata_hba_inst, saddr);
19812
19813 /*
19814 * Generate sysevent - EC_DR / ESC_DR_AP_STATE_CHANGE
19815 * with the hint: SE_HINT_REMOVE
19816 */
19817 sata_gen_sysevent(sata_hba_inst, saddr, SE_HINT_REMOVE);
19818 }
19819
19820
19821 /*
19822 * Device Attached Event processing.
19823 * Port state is checked to verify that a device is really attached. If so,
19824 * the device info structure is created and attached to the SATA port info
19825 * structure.
19826 *
19827 * If attached device cannot be identified or set-up, the retry for the
19828 * attach processing is set-up. Subsequent daemon run would try again to
19829 * identify the device, until the time limit is reached
19830 * (SATA_DEV_IDENTIFY_TIMEOUT).
19831 *
19832 * This function cannot be called in interrupt context (it may sleep).
19833 *
19834 * NOTE: Port multiplier ports events are handled by
19835 * sata_process_pmdevice_attached()
19836 */
19837 static void
sata_process_device_attached(sata_hba_inst_t * sata_hba_inst,sata_address_t * saddr)19838 sata_process_device_attached(sata_hba_inst_t *sata_hba_inst,
19839 sata_address_t *saddr)
19840 {
19841 sata_cport_info_t *cportinfo = NULL;
19842 sata_drive_info_t *sdevinfo = NULL;
19843 sata_pmult_info_t *pmultinfo = NULL;
19844 sata_pmport_info_t *pmportinfo = NULL;
19845 sata_device_t sata_device;
19846 dev_info_t *tdip;
19847 uint32_t event_flags = 0, pmult_event_flags = 0;
19848 int rval;
19849 int npmport;
19850
19851 SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst,
19852 "Processing port %d device attached", saddr->cport);
19853
19854 cportinfo = SATA_CPORT_INFO(sata_hba_inst, saddr->cport);
19855 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex);
19856
19857 /* Clear attach event flag first */
19858 cportinfo->cport_event_flags &= ~SATA_EVNT_DEVICE_ATTACHED;
19859
19860 /* If the port is in SHUTDOWN or FAILED state, ignore event. */
19861 if ((cportinfo->cport_state &
19862 (SATA_PSTATE_SHUTDOWN | SATA_PSTATE_FAILED)) != 0) {
19863 cportinfo->cport_dev_attach_time = 0;
19864 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->
19865 cport_mutex);
19866 return;
19867 }
19868
19869 /*
19870 * If the sata_drive_info structure is found attached to the port info,
19871 * despite the fact the device was removed and now it is re-attached,
19872 * the old drive info structure was not removed.
19873 * Arbitrarily release device info structure.
19874 */
19875 if (SATA_CPORTINFO_DRV_INFO(cportinfo) != NULL) {
19876 sdevinfo = SATA_CPORTINFO_DRV_INFO(cportinfo);
19877 SATA_CPORTINFO_DRV_INFO(cportinfo) = NULL;
19878 (void) kmem_free((void *)sdevinfo,
19879 sizeof (sata_drive_info_t));
19880 SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst,
19881 "Arbitrarily detaching old device info.", NULL);
19882 }
19883 cportinfo->cport_dev_type = SATA_DTYPE_NONE;
19884
19885 /* For sanity, re-probe the port */
19886 sata_device.satadev_rev = SATA_DEVICE_REV;
19887 sata_device.satadev_addr = *saddr;
19888
19889 /*
19890 * We have to exit mutex, because the HBA probe port function may
19891 * block on its own mutex.
19892 */
19893 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex);
19894 rval = (*SATA_PROBE_PORT_FUNC(sata_hba_inst))
19895 (SATA_DIP(sata_hba_inst), &sata_device);
19896 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex);
19897 sata_update_port_info(sata_hba_inst, &sata_device);
19898 if (rval != SATA_SUCCESS) {
19899 /* Something went wrong? Fail the port */
19900 cportinfo->cport_state = SATA_PSTATE_FAILED;
19901 cportinfo->cport_dev_attach_time = 0;
19902 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->
19903 cport_mutex);
19904 SATA_LOG_D((sata_hba_inst, CE_WARN,
19905 "SATA port %d probing failed",
19906 saddr->cport));
19907 return;
19908 } else {
19909 /* port probed successfully */
19910 cportinfo->cport_state |= SATA_STATE_PROBED | SATA_STATE_READY;
19911 }
19912 /*
19913 * Check if a device is still attached. For sanity, check also
19914 * link status - if no link, there is no device.
19915 */
19916 if ((sata_device.satadev_scr.sstatus & SATA_PORT_DEVLINK_UP_MASK) !=
19917 SATA_PORT_DEVLINK_UP || sata_device.satadev_type ==
19918 SATA_DTYPE_NONE) {
19919 /*
19920 * No device - ignore attach event.
19921 */
19922 cportinfo->cport_dev_attach_time = 0;
19923 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->
19924 cport_mutex);
19925 SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst,
19926 "Ignoring attach - no device connected to port %d",
19927 sata_device.satadev_addr.cport);
19928 return;
19929 }
19930
19931 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex);
19932 /*
19933 * Generate sysevent - EC_DR / ESC_DR_AP_STATE_CHANGE
19934 * with the hint: SE_HINT_INSERT
19935 */
19936 sata_gen_sysevent(sata_hba_inst, saddr, SE_HINT_INSERT);
19937
19938 /*
19939 * Port reprobing will take care of the creation of the device
19940 * info structure and determination of the device type.
19941 */
19942 sata_device.satadev_addr = *saddr;
19943 (void) sata_reprobe_port(sata_hba_inst, &sata_device,
19944 SATA_DEV_IDENTIFY_NORETRY);
19945
19946 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->
19947 cport_mutex);
19948 if ((cportinfo->cport_state & SATA_STATE_READY) &&
19949 (cportinfo->cport_dev_type != SATA_DTYPE_NONE)) {
19950 /* Some device is attached to the port */
19951 if (cportinfo->cport_dev_type == SATA_DTYPE_UNKNOWN) {
19952 /*
19953 * A device was not successfully attached.
19954 * Track retry time for device identification.
19955 */
19956 if (cportinfo->cport_dev_attach_time != 0) {
19957 clock_t cur_time = ddi_get_lbolt();
19958 /*
19959 * If the retry time limit was not exceeded,
19960 * reinstate attach event.
19961 */
19962 if ((cur_time -
19963 cportinfo->cport_dev_attach_time) <
19964 drv_usectohz(
19965 SATA_DEV_IDENTIFY_TIMEOUT)) {
19966 /* OK, restore attach event */
19967 cportinfo->cport_event_flags |=
19968 SATA_EVNT_DEVICE_ATTACHED;
19969 } else {
19970 /* Timeout - cannot identify device */
19971 cportinfo->cport_dev_attach_time = 0;
19972 sata_log(sata_hba_inst,
19973 CE_WARN,
19974 "Could not identify SATA device "
19975 "at port %d",
19976 saddr->cport);
19977 }
19978 } else {
19979 /*
19980 * Start tracking time for device
19981 * identification.
19982 * Save current time (lbolt value).
19983 */
19984 cportinfo->cport_dev_attach_time =
19985 ddi_get_lbolt();
19986 /* Restore attach event */
19987 cportinfo->cport_event_flags |=
19988 SATA_EVNT_DEVICE_ATTACHED;
19989 }
19990 } else if (cportinfo->cport_dev_type == SATA_DTYPE_PMULT) {
19991 cportinfo->cport_dev_attach_time = 0;
19992 sata_log(sata_hba_inst, CE_NOTE,
19993 "SATA port-multiplier detected at port %d",
19994 saddr->cport);
19995
19996 if (SATA_CPORTINFO_PMULT_INFO(cportinfo) != NULL) {
19997 /* Log the info of new port multiplier */
19998 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst,
19999 saddr->cport)->cport_mutex);
20000 sata_show_pmult_info(sata_hba_inst,
20001 &sata_device);
20002 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst,
20003 saddr->cport)->cport_mutex);
20004 }
20005
20006 ASSERT(SATA_CPORTINFO_PMULT_INFO(cportinfo) != NULL);
20007 pmultinfo = SATA_CPORTINFO_PMULT_INFO(cportinfo);
20008 for (npmport = 0; npmport <
20009 pmultinfo->pmult_num_dev_ports; npmport++) {
20010 pmportinfo = SATA_PMPORT_INFO(sata_hba_inst,
20011 saddr->cport, npmport);
20012 ASSERT(pmportinfo != NULL);
20013
20014 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst,
20015 saddr->cport)->cport_mutex);
20016 mutex_enter(&pmportinfo->pmport_mutex);
20017 /* Marked all pmports with link events. */
20018 pmportinfo->pmport_event_flags =
20019 SATA_EVNT_LINK_ESTABLISHED;
20020 pmult_event_flags |=
20021 pmportinfo->pmport_event_flags;
20022 mutex_exit(&pmportinfo->pmport_mutex);
20023 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst,
20024 saddr->cport)->cport_mutex);
20025 }
20026 /* Auto-online is not available for PMult now. */
20027
20028 } else {
20029 /*
20030 * If device was successfully attached, the subsequent
20031 * action depends on a state of the
20032 * sata_auto_online variable. If it is set to zero.
20033 * an explicit 'configure' command will be needed to
20034 * configure it. If its value is non-zero, we will
20035 * attempt to online (configure) the device.
20036 * First, log the message indicating that a device
20037 * was attached.
20038 */
20039 cportinfo->cport_dev_attach_time = 0;
20040 sata_log(sata_hba_inst, CE_WARN,
20041 "SATA device detected at port %d", saddr->cport);
20042
20043 if (SATA_CPORTINFO_DRV_INFO(cportinfo) != NULL) {
20044 sata_drive_info_t new_sdinfo;
20045
20046 /* Log device info data */
20047 new_sdinfo = *(SATA_CPORTINFO_DRV_INFO(
20048 cportinfo));
20049 sata_show_drive_info(sata_hba_inst,
20050 &new_sdinfo);
20051 }
20052
20053 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst,
20054 saddr->cport)->cport_mutex);
20055
20056 /*
20057 * Make sure that there is no target node for that
20058 * device. If so, release it. It should not happen,
20059 * unless we had problem removing the node when
20060 * device was detached.
20061 */
20062 tdip = sata_get_target_dip(SATA_DIP(sata_hba_inst),
20063 saddr->cport, saddr->pmport);
20064 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst,
20065 saddr->cport)->cport_mutex);
20066 if (tdip != NULL) {
20067
20068 #ifdef SATA_DEBUG
20069 if ((cportinfo->cport_event_flags &
20070 SATA_EVNT_TARGET_NODE_CLEANUP) == 0)
20071 sata_log(sata_hba_inst, CE_WARN,
20072 "sata_process_device_attached: "
20073 "old device target node exists!");
20074 #endif
20075 /*
20076 * target node exists - try to unconfigure
20077 * device and remove the node.
20078 */
20079 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst,
20080 saddr->cport)->cport_mutex);
20081 rval = ndi_devi_offline(tdip,
20082 NDI_DEVI_REMOVE);
20083 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst,
20084 saddr->cport)->cport_mutex);
20085
20086 if (rval == NDI_SUCCESS) {
20087 cportinfo->cport_event_flags &=
20088 ~SATA_EVNT_TARGET_NODE_CLEANUP;
20089 cportinfo->cport_tgtnode_clean = B_TRUE;
20090 } else {
20091 /*
20092 * PROBLEM - the target node remained
20093 * and it belongs to a previously
20094 * attached device.
20095 * This happens when the file was open
20096 * or the node was waiting for
20097 * resources at the time the
20098 * associated device was removed.
20099 * Instruct event daemon to retry the
20100 * cleanup later.
20101 */
20102 sata_log(sata_hba_inst,
20103 CE_WARN,
20104 "Application(s) accessing "
20105 "previously attached SATA "
20106 "device have to release "
20107 "it before newly inserted "
20108 "device can be made accessible.",
20109 saddr->cport);
20110 cportinfo->cport_event_flags |=
20111 SATA_EVNT_TARGET_NODE_CLEANUP;
20112 cportinfo->cport_tgtnode_clean =
20113 B_FALSE;
20114 }
20115 }
20116 if (sata_auto_online != 0) {
20117 cportinfo->cport_event_flags |=
20118 SATA_EVNT_AUTOONLINE_DEVICE;
20119 }
20120
20121 }
20122 } else {
20123 cportinfo->cport_dev_attach_time = 0;
20124 }
20125
20126 event_flags = cportinfo->cport_event_flags;
20127 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex);
20128 if (event_flags != 0 || pmult_event_flags != 0) {
20129 mutex_enter(&sata_hba_inst->satahba_mutex);
20130 sata_hba_inst->satahba_event_flags |= SATA_EVNT_MAIN;
20131 mutex_exit(&sata_hba_inst->satahba_mutex);
20132 mutex_enter(&sata_mutex);
20133 sata_event_pending |= SATA_EVNT_MAIN;
20134 mutex_exit(&sata_mutex);
20135 }
20136 }
20137
20138 /*
20139 * Port Multiplier Port Device Attached Event processing.
20140 *
20141 * NOTE: No Mutex should be hold.
20142 */
20143 static void
sata_process_pmdevice_attached(sata_hba_inst_t * sata_hba_inst,sata_address_t * saddr)20144 sata_process_pmdevice_attached(sata_hba_inst_t *sata_hba_inst,
20145 sata_address_t *saddr)
20146 {
20147 sata_pmport_info_t *pmportinfo;
20148 sata_drive_info_t *sdinfo;
20149 sata_device_t sata_device;
20150 dev_info_t *tdip;
20151 uint32_t event_flags;
20152 uint8_t cport = saddr->cport;
20153 uint8_t pmport = saddr->pmport;
20154 int rval;
20155
20156 SATADBG2(SATA_DBG_EVENTS_PROC, sata_hba_inst,
20157 "Processing port %d:%d device attached", cport, pmport);
20158
20159 pmportinfo = SATA_PMPORT_INFO(sata_hba_inst, cport, pmport);
20160
20161 mutex_enter(&pmportinfo->pmport_mutex);
20162
20163 /* Clear attach event flag first */
20164 pmportinfo->pmport_event_flags &= ~SATA_EVNT_DEVICE_ATTACHED;
20165
20166 /* If the port is in SHUTDOWN or FAILED state, ignore event. */
20167 if ((pmportinfo->pmport_state &
20168 (SATA_PSTATE_SHUTDOWN | SATA_PSTATE_FAILED)) != 0) {
20169 pmportinfo->pmport_dev_attach_time = 0;
20170 mutex_exit(&pmportinfo->pmport_mutex);
20171 return;
20172 }
20173
20174 /*
20175 * If the sata_drive_info structure is found attached to the port info,
20176 * despite the fact the device was removed and now it is re-attached,
20177 * the old drive info structure was not removed.
20178 * Arbitrarily release device info structure.
20179 */
20180 if (SATA_PMPORTINFO_DRV_INFO(pmportinfo) != NULL) {
20181 sdinfo = SATA_PMPORTINFO_DRV_INFO(pmportinfo);
20182 SATA_PMPORTINFO_DRV_INFO(pmportinfo) = NULL;
20183 (void) kmem_free((void *)sdinfo,
20184 sizeof (sata_drive_info_t));
20185 SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst,
20186 "Arbitrarily detaching old device info.", NULL);
20187 }
20188 pmportinfo->pmport_dev_type = SATA_DTYPE_NONE;
20189
20190 /* For sanity, re-probe the port */
20191 sata_device.satadev_rev = SATA_DEVICE_REV;
20192 sata_device.satadev_addr = *saddr;
20193
20194 /*
20195 * We have to exit mutex, because the HBA probe port function may
20196 * block on its own mutex.
20197 */
20198 mutex_exit(&pmportinfo->pmport_mutex);
20199 rval = (*SATA_PROBE_PORT_FUNC(sata_hba_inst))
20200 (SATA_DIP(sata_hba_inst), &sata_device);
20201 mutex_enter(&pmportinfo->pmport_mutex);
20202
20203 sata_update_pmport_info(sata_hba_inst, &sata_device);
20204 if (rval != SATA_SUCCESS) {
20205 /* Something went wrong? Fail the port */
20206 pmportinfo->pmport_state = SATA_PSTATE_FAILED;
20207 pmportinfo->pmport_dev_attach_time = 0;
20208 mutex_exit(&pmportinfo->pmport_mutex);
20209 SATA_LOG_D((sata_hba_inst, CE_WARN,
20210 "SATA port %d:%d probing failed", cport, pmport));
20211 return;
20212 } else {
20213 /* pmport probed successfully */
20214 pmportinfo->pmport_state |=
20215 SATA_STATE_PROBED | SATA_STATE_READY;
20216 }
20217 /*
20218 * Check if a device is still attached. For sanity, check also
20219 * link status - if no link, there is no device.
20220 */
20221 if ((sata_device.satadev_scr.sstatus & SATA_PORT_DEVLINK_UP_MASK) !=
20222 SATA_PORT_DEVLINK_UP || sata_device.satadev_type ==
20223 SATA_DTYPE_NONE) {
20224 /*
20225 * No device - ignore attach event.
20226 */
20227 pmportinfo->pmport_dev_attach_time = 0;
20228 mutex_exit(&pmportinfo->pmport_mutex);
20229 SATADBG2(SATA_DBG_EVENTS_PROC, sata_hba_inst,
20230 "Ignoring attach - no device connected to port %d:%d",
20231 cport, pmport);
20232 return;
20233 }
20234
20235 mutex_exit(&pmportinfo->pmport_mutex);
20236 /*
20237 * Generate sysevent - EC_DR / ESC_DR_AP_STATE_CHANGE
20238 * with the hint: SE_HINT_INSERT
20239 */
20240 sata_gen_sysevent(sata_hba_inst, saddr, SE_HINT_INSERT);
20241
20242 /*
20243 * Port reprobing will take care of the creation of the device
20244 * info structure and determination of the device type.
20245 */
20246 sata_device.satadev_addr = *saddr;
20247 (void) sata_reprobe_port(sata_hba_inst, &sata_device,
20248 SATA_DEV_IDENTIFY_NORETRY);
20249
20250 mutex_enter(&pmportinfo->pmport_mutex);
20251 if ((pmportinfo->pmport_state & SATA_STATE_READY) &&
20252 (pmportinfo->pmport_dev_type != SATA_DTYPE_NONE)) {
20253 /* Some device is attached to the port */
20254 if (pmportinfo->pmport_dev_type == SATA_DTYPE_UNKNOWN) {
20255 /*
20256 * A device was not successfully attached.
20257 * Track retry time for device identification.
20258 */
20259 if (pmportinfo->pmport_dev_attach_time != 0) {
20260 clock_t cur_time = ddi_get_lbolt();
20261 /*
20262 * If the retry time limit was not exceeded,
20263 * reinstate attach event.
20264 */
20265 if ((cur_time -
20266 pmportinfo->pmport_dev_attach_time) <
20267 drv_usectohz(
20268 SATA_DEV_IDENTIFY_TIMEOUT)) {
20269 /* OK, restore attach event */
20270 pmportinfo->pmport_event_flags |=
20271 SATA_EVNT_DEVICE_ATTACHED;
20272 } else {
20273 /* Timeout - cannot identify device */
20274 pmportinfo->pmport_dev_attach_time = 0;
20275 sata_log(sata_hba_inst, CE_WARN,
20276 "Could not identify SATA device "
20277 "at port %d:%d",
20278 cport, pmport);
20279 }
20280 } else {
20281 /*
20282 * Start tracking time for device
20283 * identification.
20284 * Save current time (lbolt value).
20285 */
20286 pmportinfo->pmport_dev_attach_time =
20287 ddi_get_lbolt();
20288 /* Restore attach event */
20289 pmportinfo->pmport_event_flags |=
20290 SATA_EVNT_DEVICE_ATTACHED;
20291 }
20292 } else {
20293 /*
20294 * If device was successfully attached, the subsequent
20295 * action depends on a state of the
20296 * sata_auto_online variable. If it is set to zero.
20297 * an explicit 'configure' command will be needed to
20298 * configure it. If its value is non-zero, we will
20299 * attempt to online (configure) the device.
20300 * First, log the message indicating that a device
20301 * was attached.
20302 */
20303 pmportinfo->pmport_dev_attach_time = 0;
20304 sata_log(sata_hba_inst, CE_WARN,
20305 "SATA device detected at port %d:%d",
20306 cport, pmport);
20307
20308 if (SATA_PMPORTINFO_DRV_INFO(pmportinfo) != NULL) {
20309 sata_drive_info_t new_sdinfo;
20310
20311 /* Log device info data */
20312 new_sdinfo = *(SATA_PMPORTINFO_DRV_INFO(
20313 pmportinfo));
20314 sata_show_drive_info(sata_hba_inst,
20315 &new_sdinfo);
20316 }
20317
20318 mutex_exit(&pmportinfo->pmport_mutex);
20319
20320 /*
20321 * Make sure that there is no target node for that
20322 * device. If so, release it. It should not happen,
20323 * unless we had problem removing the node when
20324 * device was detached.
20325 */
20326 tdip = sata_get_target_dip(SATA_DIP(sata_hba_inst),
20327 saddr->cport, saddr->pmport);
20328 mutex_enter(&pmportinfo->pmport_mutex);
20329 if (tdip != NULL) {
20330
20331 #ifdef SATA_DEBUG
20332 if ((pmportinfo->pmport_event_flags &
20333 SATA_EVNT_TARGET_NODE_CLEANUP) == 0)
20334 sata_log(sata_hba_inst, CE_WARN,
20335 "sata_process_device_attached: "
20336 "old device target node exists!");
20337 #endif
20338 /*
20339 * target node exists - try to unconfigure
20340 * device and remove the node.
20341 */
20342 mutex_exit(&pmportinfo->pmport_mutex);
20343 rval = ndi_devi_offline(tdip,
20344 NDI_DEVI_REMOVE);
20345 mutex_enter(&pmportinfo->pmport_mutex);
20346
20347 if (rval == NDI_SUCCESS) {
20348 pmportinfo->pmport_event_flags &=
20349 ~SATA_EVNT_TARGET_NODE_CLEANUP;
20350 pmportinfo->pmport_tgtnode_clean =
20351 B_TRUE;
20352 } else {
20353 /*
20354 * PROBLEM - the target node remained
20355 * and it belongs to a previously
20356 * attached device.
20357 * This happens when the file was open
20358 * or the node was waiting for
20359 * resources at the time the
20360 * associated device was removed.
20361 * Instruct event daemon to retry the
20362 * cleanup later.
20363 */
20364 sata_log(sata_hba_inst,
20365 CE_WARN,
20366 "Application(s) accessing "
20367 "previously attached SATA "
20368 "device have to release "
20369 "it before newly inserted "
20370 "device can be made accessible."
20371 "at port %d:%d",
20372 cport, pmport);
20373 pmportinfo->pmport_event_flags |=
20374 SATA_EVNT_TARGET_NODE_CLEANUP;
20375 pmportinfo->pmport_tgtnode_clean =
20376 B_FALSE;
20377 }
20378 }
20379 if (sata_auto_online != 0) {
20380 pmportinfo->pmport_event_flags |=
20381 SATA_EVNT_AUTOONLINE_DEVICE;
20382 }
20383
20384 }
20385 } else {
20386 pmportinfo->pmport_dev_attach_time = 0;
20387 }
20388
20389 event_flags = pmportinfo->pmport_event_flags;
20390 mutex_exit(&pmportinfo->pmport_mutex);
20391 if (event_flags != 0) {
20392 mutex_enter(&sata_hba_inst->satahba_mutex);
20393 sata_hba_inst->satahba_event_flags |= SATA_EVNT_MAIN;
20394 mutex_exit(&sata_hba_inst->satahba_mutex);
20395 mutex_enter(&sata_mutex);
20396 sata_event_pending |= SATA_EVNT_MAIN;
20397 mutex_exit(&sata_mutex);
20398 }
20399
20400 /* clear the reset_in_progress events */
20401 if (SATA_PMPORTINFO_DRV_INFO(pmportinfo) != NULL) {
20402 if (pmportinfo->pmport_dev_type & SATA_VALID_DEV_TYPE) {
20403 /* must clear flags on cport */
20404 sata_pmult_info_t *pminfo =
20405 SATA_PMULT_INFO(sata_hba_inst,
20406 saddr->cport);
20407 pminfo->pmult_event_flags |=
20408 SATA_EVNT_CLEAR_DEVICE_RESET;
20409 }
20410 }
20411 }
20412
20413 /*
20414 * Device Target Node Cleanup Event processing.
20415 * If the target node associated with a sata port device is in
20416 * DEVI_DEVICE_REMOVED state, an attempt is made to remove it.
20417 * If the target node cannot be removed, the event flag is left intact,
20418 * so that event daemon may re-run this function later.
20419 *
20420 * This function cannot be called in interrupt context (it may sleep).
20421 *
20422 * NOTE: Processes cport events only, not port multiplier ports.
20423 */
20424 static void
sata_process_target_node_cleanup(sata_hba_inst_t * sata_hba_inst,sata_address_t * saddr)20425 sata_process_target_node_cleanup(sata_hba_inst_t *sata_hba_inst,
20426 sata_address_t *saddr)
20427 {
20428 sata_cport_info_t *cportinfo;
20429 dev_info_t *tdip;
20430
20431 SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst,
20432 "Processing port %d device target node cleanup", saddr->cport);
20433
20434 cportinfo = SATA_CPORT_INFO(sata_hba_inst, saddr->cport);
20435
20436 /*
20437 * Check if there is target node for that device and it is in the
20438 * DEVI_DEVICE_REMOVED state. If so, release it.
20439 */
20440 tdip = sata_get_target_dip(SATA_DIP(sata_hba_inst), saddr->cport,
20441 saddr->pmport);
20442 if (tdip != NULL) {
20443 /*
20444 * target node exists - check if it is target node of
20445 * a removed device.
20446 */
20447 if (sata_check_device_removed(tdip) == B_TRUE) {
20448 SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst,
20449 "sata_process_target_node_cleanup: "
20450 "old device target node exists!", NULL);
20451 /*
20452 * Unconfigure and remove the target node
20453 */
20454 if (ndi_devi_offline(tdip, NDI_DEVI_REMOVE) ==
20455 NDI_SUCCESS) {
20456 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst,
20457 saddr->cport)->cport_mutex);
20458 cportinfo->cport_event_flags &=
20459 ~SATA_EVNT_TARGET_NODE_CLEANUP;
20460 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst,
20461 saddr->cport)->cport_mutex);
20462 return;
20463 }
20464 /*
20465 * Event daemon will retry the cleanup later.
20466 */
20467 mutex_enter(&sata_hba_inst->satahba_mutex);
20468 sata_hba_inst->satahba_event_flags |= SATA_EVNT_MAIN;
20469 mutex_exit(&sata_hba_inst->satahba_mutex);
20470 mutex_enter(&sata_mutex);
20471 sata_event_pending |= SATA_EVNT_MAIN;
20472 mutex_exit(&sata_mutex);
20473 }
20474 } else {
20475 if (saddr->qual == SATA_ADDR_CPORT ||
20476 saddr->qual == SATA_ADDR_DCPORT) {
20477 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst,
20478 saddr->cport)->cport_mutex);
20479 cportinfo->cport_event_flags &=
20480 ~SATA_EVNT_TARGET_NODE_CLEANUP;
20481 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst,
20482 saddr->cport)->cport_mutex);
20483 } else {
20484 /* sanity check */
20485 if (SATA_CPORT_DEV_TYPE(sata_hba_inst, saddr->cport) !=
20486 SATA_DTYPE_PMULT || SATA_PMULT_INFO(sata_hba_inst,
20487 saddr->cport) == NULL)
20488 return;
20489 if (SATA_PMPORT_INFO(sata_hba_inst, saddr->cport,
20490 saddr->pmport) == NULL)
20491 return;
20492
20493 mutex_enter(&SATA_PMPORT_INFO(sata_hba_inst,
20494 saddr->cport, saddr->pmport)->pmport_mutex);
20495 SATA_PMPORT_INFO(sata_hba_inst, saddr->cport,
20496 saddr->pmport)->pmport_event_flags &=
20497 ~SATA_EVNT_TARGET_NODE_CLEANUP;
20498 mutex_exit(&SATA_PMPORT_INFO(sata_hba_inst,
20499 saddr->cport, saddr->pmport)->pmport_mutex);
20500 }
20501 }
20502 }
20503
20504 /*
20505 * Device AutoOnline Event processing.
20506 * If attached device is to be onlined, an attempt is made to online this
20507 * device, but only if there is no lingering (old) target node present.
20508 * If the device cannot be onlined, the event flag is left intact,
20509 * so that event daemon may re-run this function later.
20510 *
20511 * This function cannot be called in interrupt context (it may sleep).
20512 *
20513 * NOTE: Processes cport events only, not port multiplier ports.
20514 */
20515 static void
sata_process_device_autoonline(sata_hba_inst_t * sata_hba_inst,sata_address_t * saddr)20516 sata_process_device_autoonline(sata_hba_inst_t *sata_hba_inst,
20517 sata_address_t *saddr)
20518 {
20519 sata_cport_info_t *cportinfo;
20520 sata_drive_info_t *sdinfo;
20521 sata_device_t sata_device;
20522 dev_info_t *tdip;
20523
20524 SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst,
20525 "Processing port %d attached device auto-onlining", saddr->cport);
20526
20527 cportinfo = SATA_CPORT_INFO(sata_hba_inst, saddr->cport);
20528
20529 /*
20530 * Check if device is present and recognized. If not, reset event.
20531 */
20532 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex);
20533 if ((cportinfo->cport_dev_type & SATA_VALID_DEV_TYPE) == 0) {
20534 /* Nothing to online */
20535 cportinfo->cport_event_flags &= ~SATA_EVNT_AUTOONLINE_DEVICE;
20536 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst,
20537 saddr->cport)->cport_mutex);
20538 return;
20539 }
20540 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex);
20541
20542 /*
20543 * Check if there is target node for this device and if it is in the
20544 * DEVI_DEVICE_REMOVED state. If so, abort onlining but keep
20545 * the event for later processing.
20546 */
20547 tdip = sata_get_target_dip(SATA_DIP(sata_hba_inst), saddr->cport,
20548 saddr->pmport);
20549 if (tdip != NULL) {
20550 /*
20551 * target node exists - check if it is target node of
20552 * a removed device.
20553 */
20554 if (sata_check_device_removed(tdip) == B_TRUE) {
20555 SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst,
20556 "sata_process_device_autoonline: "
20557 "old device target node exists!", NULL);
20558 /*
20559 * Event daemon will retry device onlining later.
20560 */
20561 mutex_enter(&sata_hba_inst->satahba_mutex);
20562 sata_hba_inst->satahba_event_flags |= SATA_EVNT_MAIN;
20563 mutex_exit(&sata_hba_inst->satahba_mutex);
20564 mutex_enter(&sata_mutex);
20565 sata_event_pending |= SATA_EVNT_MAIN;
20566 mutex_exit(&sata_mutex);
20567 return;
20568 }
20569 /*
20570 * If the target node is not in the 'removed" state, assume
20571 * that it belongs to this device. There is nothing more to do,
20572 * but reset the event.
20573 */
20574 } else {
20575
20576 /*
20577 * Try to online the device
20578 * If there is any reset-related event, remove it. We are
20579 * configuring the device and no state restoring is needed.
20580 */
20581 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst,
20582 saddr->cport)->cport_mutex);
20583 sata_device.satadev_addr = *saddr;
20584 if (saddr->qual == SATA_ADDR_CPORT)
20585 sata_device.satadev_addr.qual = SATA_ADDR_DCPORT;
20586 else
20587 sata_device.satadev_addr.qual = SATA_ADDR_DPMPORT;
20588 sdinfo = sata_get_device_info(sata_hba_inst, &sata_device);
20589 if (sdinfo != NULL) {
20590 if (sdinfo->satadrv_event_flags &
20591 (SATA_EVNT_DEVICE_RESET |
20592 SATA_EVNT_INPROC_DEVICE_RESET))
20593 sdinfo->satadrv_event_flags = 0;
20594 sdinfo->satadrv_event_flags |=
20595 SATA_EVNT_CLEAR_DEVICE_RESET;
20596
20597 /* Need to create a new target node. */
20598 cportinfo->cport_tgtnode_clean = B_TRUE;
20599 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst,
20600 saddr->cport)->cport_mutex);
20601 tdip = sata_create_target_node(SATA_DIP(sata_hba_inst),
20602 sata_hba_inst, &sata_device.satadev_addr);
20603 if (tdip == NULL) {
20604 /*
20605 * Configure (onlining) failed.
20606 * We will NOT retry
20607 */
20608 SATA_LOG_D((sata_hba_inst, CE_WARN,
20609 "sata_process_device_autoonline: "
20610 "configuring SATA device at port %d failed",
20611 saddr->cport));
20612 }
20613 } else {
20614 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst,
20615 saddr->cport)->cport_mutex);
20616 }
20617
20618 }
20619 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex);
20620 cportinfo->cport_event_flags &= ~SATA_EVNT_AUTOONLINE_DEVICE;
20621 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst,
20622 saddr->cport)->cport_mutex);
20623 }
20624
20625
20626 static void
sata_gen_sysevent(sata_hba_inst_t * sata_hba_inst,sata_address_t * saddr,int hint)20627 sata_gen_sysevent(sata_hba_inst_t *sata_hba_inst, sata_address_t *saddr,
20628 int hint)
20629 {
20630 char ap[MAXPATHLEN];
20631 nvlist_t *ev_attr_list = NULL;
20632 int err;
20633
20634 /* Allocate and build sysevent attribute list */
20635 err = nvlist_alloc(&ev_attr_list, NV_UNIQUE_NAME_TYPE, DDI_NOSLEEP);
20636 if (err != 0) {
20637 SATA_LOG_D((sata_hba_inst, CE_WARN,
20638 "sata_gen_sysevent: "
20639 "cannot allocate memory for sysevent attributes\n"));
20640 return;
20641 }
20642 /* Add hint attribute */
20643 err = nvlist_add_string(ev_attr_list, DR_HINT, SE_HINT2STR(hint));
20644 if (err != 0) {
20645 SATA_LOG_D((sata_hba_inst, CE_WARN,
20646 "sata_gen_sysevent: "
20647 "failed to add DR_HINT attr for sysevent"));
20648 nvlist_free(ev_attr_list);
20649 return;
20650 }
20651 /*
20652 * Add AP attribute.
20653 * Get controller pathname and convert it into AP pathname by adding
20654 * a target number.
20655 */
20656 (void) snprintf(ap, MAXPATHLEN, "/devices");
20657 (void) ddi_pathname(SATA_DIP(sata_hba_inst), ap + strlen(ap));
20658 (void) snprintf(ap + strlen(ap), MAXPATHLEN - strlen(ap), ":%d",
20659 SATA_MAKE_AP_NUMBER(saddr->cport, saddr->pmport, saddr->qual));
20660
20661 err = nvlist_add_string(ev_attr_list, DR_AP_ID, ap);
20662 if (err != 0) {
20663 SATA_LOG_D((sata_hba_inst, CE_WARN,
20664 "sata_gen_sysevent: "
20665 "failed to add DR_AP_ID attr for sysevent"));
20666 nvlist_free(ev_attr_list);
20667 return;
20668 }
20669
20670 /* Generate/log sysevent */
20671 err = ddi_log_sysevent(SATA_DIP(sata_hba_inst), DDI_VENDOR_SUNW, EC_DR,
20672 ESC_DR_AP_STATE_CHANGE, ev_attr_list, NULL, DDI_NOSLEEP);
20673 if (err != DDI_SUCCESS) {
20674 SATA_LOG_D((sata_hba_inst, CE_WARN,
20675 "sata_gen_sysevent: "
20676 "cannot log sysevent, err code %x\n", err));
20677 }
20678
20679 nvlist_free(ev_attr_list);
20680 }
20681
20682
20683
20684
20685 /*
20686 * Set DEVI_DEVICE_REMOVED state in the SATA device target node.
20687 */
20688 static void
sata_set_device_removed(dev_info_t * tdip)20689 sata_set_device_removed(dev_info_t *tdip)
20690 {
20691 ASSERT(tdip != NULL);
20692
20693 ndi_devi_enter(tdip);
20694 mutex_enter(&DEVI(tdip)->devi_lock);
20695 DEVI_SET_DEVICE_REMOVED(tdip);
20696 mutex_exit(&DEVI(tdip)->devi_lock);
20697 ndi_devi_exit(tdip);
20698 }
20699
20700
20701 /*
20702 * Set internal event instructing event daemon to try
20703 * to perform the target node cleanup.
20704 */
20705 static void
sata_set_target_node_cleanup(sata_hba_inst_t * sata_hba_inst,sata_address_t * saddr)20706 sata_set_target_node_cleanup(sata_hba_inst_t *sata_hba_inst,
20707 sata_address_t *saddr)
20708 {
20709 if (saddr->qual == SATA_ADDR_CPORT ||
20710 saddr->qual == SATA_ADDR_DCPORT) {
20711 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst,
20712 saddr->cport)->cport_mutex);
20713 SATA_CPORT_EVENT_FLAGS(sata_hba_inst, saddr->cport) |=
20714 SATA_EVNT_TARGET_NODE_CLEANUP;
20715 SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->
20716 cport_tgtnode_clean = B_FALSE;
20717 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst,
20718 saddr->cport)->cport_mutex);
20719 } else {
20720 mutex_enter(&SATA_PMPORT_INFO(sata_hba_inst,
20721 saddr->cport, saddr->pmport)->pmport_mutex);
20722 SATA_PMPORT_EVENT_FLAGS(sata_hba_inst, saddr->cport,
20723 saddr->pmport) |= SATA_EVNT_TARGET_NODE_CLEANUP;
20724 SATA_PMPORT_INFO(sata_hba_inst, saddr->cport, saddr->pmport)->
20725 pmport_tgtnode_clean = B_FALSE;
20726 mutex_exit(&SATA_PMPORT_INFO(sata_hba_inst,
20727 saddr->cport, saddr->pmport)->pmport_mutex);
20728 }
20729 mutex_enter(&sata_hba_inst->satahba_mutex);
20730 sata_hba_inst->satahba_event_flags |= SATA_EVNT_MAIN;
20731 mutex_exit(&sata_hba_inst->satahba_mutex);
20732 mutex_enter(&sata_mutex);
20733 sata_event_pending |= SATA_EVNT_MAIN;
20734 mutex_exit(&sata_mutex);
20735 }
20736
20737
20738 /*
20739 * Check if the SATA device target node is in DEVI_DEVICE_REMOVED state,
20740 * i.e. check if the target node state indicates that it belongs to a removed
20741 * device.
20742 *
20743 * Returns B_TRUE if the target node is in DEVI_DEVICE_REMOVED state,
20744 * B_FALSE otherwise.
20745 */
20746 static boolean_t
sata_check_device_removed(dev_info_t * tdip)20747 sata_check_device_removed(dev_info_t *tdip)
20748 {
20749 ASSERT(tdip != NULL);
20750
20751 if (DEVI_IS_DEVICE_REMOVED(tdip))
20752 return (B_TRUE);
20753 else
20754 return (B_FALSE);
20755 }
20756
20757
20758 /*
20759 * Check for DMA error. Return B_TRUE if error, B_FALSE otherwise.
20760 */
20761 static boolean_t
sata_check_for_dma_error(dev_info_t * dip,sata_pkt_txlate_t * spx)20762 sata_check_for_dma_error(dev_info_t *dip, sata_pkt_txlate_t *spx)
20763 {
20764 int fm_capability = ddi_fm_capable(dip);
20765 ddi_fm_error_t de;
20766
20767 if (fm_capability & DDI_FM_DMACHK_CAPABLE) {
20768 if (spx->txlt_buf_dma_handle != NULL) {
20769 ddi_fm_dma_err_get(spx->txlt_buf_dma_handle, &de,
20770 DDI_FME_VERSION);
20771 if (de.fme_status != DDI_SUCCESS)
20772 return (B_TRUE);
20773 }
20774 }
20775 return (B_FALSE);
20776 }
20777
20778
20779 /* ************************ FAULT INJECTTION **************************** */
20780
20781 #ifdef SATA_INJECT_FAULTS
20782
20783 static uint32_t sata_fault_count = 0;
20784 static uint32_t sata_fault_suspend_count = 0;
20785
20786 /*
20787 * Inject sata pkt fault
20788 * It modifies returned values of the sata packet.
20789 * It returns immediately if:
20790 * pkt fault injection is not enabled (via sata_inject_fault,
20791 * sata_inject_fault_count), or invalid fault is specified (sata_fault_type),
20792 * or pkt does not contain command to be faulted (set in sata_fault_cmd), or
20793 * pkt is not directed to specified fault controller/device
20794 * (sata_fault_ctrl_dev and sata_fault_device).
20795 * If fault controller is not specified, fault injection applies to all
20796 * controllers and devices.
20797 *
20798 * First argument is the pointer to the executed sata packet.
20799 * Second argument is a pointer to a value returned by the HBA tran_start
20800 * function.
20801 * Third argument specifies injected error. Injected sata packet faults
20802 * are the satapkt_reason values.
20803 * SATA_PKT_BUSY -1 Not completed, busy
20804 * SATA_PKT_DEV_ERROR 1 Device reported error
20805 * SATA_PKT_QUEUE_FULL 2 Not accepted, queue full
20806 * SATA_PKT_PORT_ERROR 3 Not completed, port error
20807 * SATA_PKT_CMD_UNSUPPORTED 4 Cmd unsupported
20808 * SATA_PKT_ABORTED 5 Aborted by request
20809 * SATA_PKT_TIMEOUT 6 Operation timeut
20810 * SATA_PKT_RESET 7 Aborted by reset request
20811 *
20812 * Additional global variables affecting the execution:
20813 *
20814 * sata_inject_fault_count variable specifies number of times in row the
20815 * error is injected. Value of -1 specifies permanent fault, ie. every time
20816 * the fault injection point is reached, the fault is injected and a pause
20817 * between fault injection specified by sata_inject_fault_pause_count is
20818 * ignored). Fault injection routine decrements sata_inject_fault_count
20819 * (if greater than zero) until it reaches 0. No fault is injected when
20820 * sata_inject_fault_count is 0 (zero).
20821 *
20822 * sata_inject_fault_pause_count variable specifies number of times a fault
20823 * injection is bypassed (pause between fault injections).
20824 * If set to 0, a fault is injected only a number of times specified by
20825 * sata_inject_fault_count.
20826 *
20827 * The fault counts are static, so for periodic errors they have to be manually
20828 * reset to start repetition sequence from scratch.
20829 * If the original value returned by the HBA tran_start function is not
20830 * SATA_TRAN_ACCEPTED and pkt reason is not SATA_PKT_COMPLETED, no error
20831 * is injected (to avoid masking real problems);
20832 *
20833 * NOTE: In its current incarnation, this function should be invoked only for
20834 * commands executed in SYNCHRONOUS mode.
20835 */
20836
20837
20838 static void
sata_inject_pkt_fault(sata_pkt_t * spkt,int * rval,int fault)20839 sata_inject_pkt_fault(sata_pkt_t *spkt, int *rval, int fault)
20840 {
20841
20842 if (sata_inject_fault != SATA_INJECT_PKT_FAULT)
20843 return;
20844
20845 if (sata_inject_fault_count == 0)
20846 return;
20847
20848 if (fault == 0)
20849 return;
20850
20851 if (sata_fault_cmd != spkt->satapkt_cmd.satacmd_cmd_reg)
20852 return;
20853
20854 if (sata_fault_ctrl != NULL) {
20855 sata_pkt_txlate_t *spx =
20856 (sata_pkt_txlate_t *)spkt->satapkt_framework_private;
20857
20858 if (sata_fault_ctrl != NULL && sata_fault_ctrl !=
20859 spx->txlt_sata_hba_inst->satahba_dip)
20860 return;
20861
20862 if (sata_fault_device.satadev_addr.cport !=
20863 spkt->satapkt_device.satadev_addr.cport ||
20864 sata_fault_device.satadev_addr.pmport !=
20865 spkt->satapkt_device.satadev_addr.pmport ||
20866 sata_fault_device.satadev_addr.qual !=
20867 spkt->satapkt_device.satadev_addr.qual)
20868 return;
20869 }
20870
20871 /* Modify pkt return parameters */
20872 if (*rval != SATA_TRAN_ACCEPTED ||
20873 spkt->satapkt_reason != SATA_PKT_COMPLETED) {
20874 sata_fault_count = 0;
20875 sata_fault_suspend_count = 0;
20876 return;
20877 }
20878 if (sata_fault_count == 0 && sata_fault_suspend_count != 0) {
20879 /* Pause in the injection */
20880 sata_fault_suspend_count -= 1;
20881 return;
20882 }
20883
20884 if (sata_fault_count == 0 && sata_fault_suspend_count == 0) {
20885 /*
20886 * Init inject fault cycle. If fault count is set to -1,
20887 * it is a permanent fault.
20888 */
20889 if (sata_inject_fault_count != -1) {
20890 sata_fault_count = sata_inject_fault_count;
20891 sata_fault_suspend_count =
20892 sata_inject_fault_pause_count;
20893 if (sata_fault_suspend_count == 0)
20894 sata_inject_fault_count = 0;
20895 }
20896 }
20897
20898 if (sata_fault_count != 0)
20899 sata_fault_count -= 1;
20900
20901 switch (fault) {
20902 case SATA_PKT_BUSY:
20903 *rval = SATA_TRAN_BUSY;
20904 spkt->satapkt_reason = SATA_PKT_BUSY;
20905 break;
20906
20907 case SATA_PKT_QUEUE_FULL:
20908 *rval = SATA_TRAN_QUEUE_FULL;
20909 spkt->satapkt_reason = SATA_PKT_QUEUE_FULL;
20910 break;
20911
20912 case SATA_PKT_CMD_UNSUPPORTED:
20913 *rval = SATA_TRAN_CMD_UNSUPPORTED;
20914 spkt->satapkt_reason = SATA_PKT_CMD_UNSUPPORTED;
20915 break;
20916
20917 case SATA_PKT_PORT_ERROR:
20918 /* This is "rejected" command */
20919 *rval = SATA_TRAN_PORT_ERROR;
20920 spkt->satapkt_reason = SATA_PKT_PORT_ERROR;
20921 /* Additional error setup could be done here - port state */
20922 break;
20923
20924 case SATA_PKT_DEV_ERROR:
20925 spkt->satapkt_reason = SATA_PKT_DEV_ERROR;
20926 /*
20927 * Additional error setup could be done here
20928 */
20929 break;
20930
20931 case SATA_PKT_ABORTED:
20932 spkt->satapkt_reason = SATA_PKT_ABORTED;
20933 break;
20934
20935 case SATA_PKT_TIMEOUT:
20936 spkt->satapkt_reason = SATA_PKT_TIMEOUT;
20937 /* Additional error setup could be done here */
20938 break;
20939
20940 case SATA_PKT_RESET:
20941 spkt->satapkt_reason = SATA_PKT_RESET;
20942 /*
20943 * Additional error setup could be done here - device reset
20944 */
20945 break;
20946
20947 default:
20948 break;
20949 }
20950 }
20951
20952 #endif
20953
20954 /*
20955 * SATA Trace Ring Buffer
20956 * ----------------------
20957 *
20958 * Overview
20959 *
20960 * The SATA trace ring buffer is a ring buffer created and managed by
20961 * the SATA framework module that can be used by any module or driver
20962 * within the SATA framework to store debug messages.
20963 *
20964 * Ring Buffer Interfaces:
20965 *
20966 * sata_vtrace_debug() <-- Adds debug message to ring buffer
20967 * sata_trace_debug() <-- Wraps varargs into sata_vtrace_debug()
20968 *
20969 * Note that the sata_trace_debug() interface was created to give
20970 * consumers the flexibilty of sending debug messages to ring buffer
20971 * as variable arguments. Consumers can send type va_list debug
20972 * messages directly to sata_vtrace_debug(). The sata_trace_debug()
20973 * and sata_vtrace_debug() relationship is similar to that of
20974 * cmn_err(9F) and vcmn_err(9F).
20975 *
20976 * Below is a diagram of the SATA trace ring buffer interfaces and
20977 * sample consumers:
20978 *
20979 * +---------------------------------+
20980 * | o o SATA Framework Module |
20981 * | o SATA o +------------------+ +------------------+
20982 * |o Trace o <--|sata_vtrace_debug/|<-----|SATA HBA Driver #1|
20983 * |o R-Buf o |sata_trace_debug |<--+ +------------------+
20984 * | o o +------------------+ | +------------------+
20985 * | o o ^ | +--|SATA HBA Driver #2|
20986 * | | | +------------------+
20987 * | +------------------+ |
20988 * | |SATA Debug Message| |
20989 * | +------------------+ |
20990 * +---------------------------------+
20991 *
20992 * Supporting Routines:
20993 *
20994 * sata_trace_rbuf_alloc() <-- Initializes ring buffer
20995 * sata_trace_rbuf_free() <-- Destroys ring buffer
20996 * sata_trace_dmsg_alloc() <-- Creates or reuses buffer in ring buffer
20997 * sata_trace_dmsg_free() <-- Destroys content of ring buffer
20998 *
20999 * The default SATA trace ring buffer size is defined by DMSG_RING_SIZE.
21000 * The ring buffer size can be adjusted by setting dmsg_ring_size in
21001 * /etc/system to desired size in unit of bytes.
21002 *
21003 * The individual debug message size in the ring buffer is restricted
21004 * to DMSG_BUF_SIZE.
21005 */
21006 void
sata_vtrace_debug(dev_info_t * dip,const char * fmt,va_list ap)21007 sata_vtrace_debug(dev_info_t *dip, const char *fmt, va_list ap)
21008 {
21009 sata_trace_dmsg_t *dmsg;
21010
21011 if (sata_debug_rbuf == NULL) {
21012 return;
21013 }
21014
21015 /*
21016 * If max size of ring buffer is smaller than size
21017 * required for one debug message then just return
21018 * since we have no room for the debug message.
21019 */
21020 if (sata_debug_rbuf->maxsize < (sizeof (sata_trace_dmsg_t))) {
21021 return;
21022 }
21023
21024 mutex_enter(&sata_debug_rbuf->lock);
21025
21026 /* alloc or reuse on ring buffer */
21027 dmsg = sata_trace_dmsg_alloc();
21028
21029 if (dmsg == NULL) {
21030 /* resource allocation failed */
21031 mutex_exit(&sata_debug_rbuf->lock);
21032 return;
21033 }
21034
21035 dmsg->dip = dip;
21036 gethrestime(&dmsg->timestamp);
21037
21038 (void) vsnprintf(dmsg->buf, sizeof (dmsg->buf), fmt, ap);
21039
21040 mutex_exit(&sata_debug_rbuf->lock);
21041 }
21042
21043 void
sata_trace_debug(dev_info_t * dip,const char * fmt,...)21044 sata_trace_debug(dev_info_t *dip, const char *fmt, ...)
21045 {
21046 va_list ap;
21047
21048 va_start(ap, fmt);
21049 sata_vtrace_debug(dip, fmt, ap);
21050 va_end(ap);
21051 }
21052
21053 /*
21054 * This routine is used to manage debug messages
21055 * on ring buffer.
21056 */
21057 static sata_trace_dmsg_t *
sata_trace_dmsg_alloc(void)21058 sata_trace_dmsg_alloc(void)
21059 {
21060 sata_trace_dmsg_t *dmsg_alloc, *dmsg = sata_debug_rbuf->dmsgp;
21061
21062 if (sata_debug_rbuf->looped == TRUE) {
21063 sata_debug_rbuf->dmsgp = dmsg->next;
21064 return (sata_debug_rbuf->dmsgp);
21065 }
21066
21067 /*
21068 * If we're looping for the first time,
21069 * connect the ring.
21070 */
21071 if (((sata_debug_rbuf->size + (sizeof (sata_trace_dmsg_t))) >
21072 sata_debug_rbuf->maxsize) && (sata_debug_rbuf->dmsgh != NULL)) {
21073 dmsg->next = sata_debug_rbuf->dmsgh;
21074 sata_debug_rbuf->dmsgp = sata_debug_rbuf->dmsgh;
21075 sata_debug_rbuf->looped = TRUE;
21076 return (sata_debug_rbuf->dmsgp);
21077 }
21078
21079 /* If we've gotten this far then memory allocation is needed */
21080 dmsg_alloc = kmem_zalloc(sizeof (sata_trace_dmsg_t), KM_NOSLEEP);
21081 if (dmsg_alloc == NULL) {
21082 sata_debug_rbuf->allocfailed++;
21083 return (dmsg_alloc);
21084 } else {
21085 sata_debug_rbuf->size += sizeof (sata_trace_dmsg_t);
21086 }
21087
21088 if (sata_debug_rbuf->dmsgp != NULL) {
21089 dmsg->next = dmsg_alloc;
21090 sata_debug_rbuf->dmsgp = dmsg->next;
21091 return (sata_debug_rbuf->dmsgp);
21092 } else {
21093 /*
21094 * We should only be here if we're initializing
21095 * the ring buffer.
21096 */
21097 if (sata_debug_rbuf->dmsgh == NULL) {
21098 sata_debug_rbuf->dmsgh = dmsg_alloc;
21099 } else {
21100 /* Something is wrong */
21101 kmem_free(dmsg_alloc, sizeof (sata_trace_dmsg_t));
21102 return (NULL);
21103 }
21104
21105 sata_debug_rbuf->dmsgp = dmsg_alloc;
21106 return (sata_debug_rbuf->dmsgp);
21107 }
21108 }
21109
21110
21111 /*
21112 * Free all messages on debug ring buffer.
21113 */
21114 static void
sata_trace_dmsg_free(void)21115 sata_trace_dmsg_free(void)
21116 {
21117 sata_trace_dmsg_t *dmsg_next, *dmsg = sata_debug_rbuf->dmsgh;
21118
21119 while (dmsg != NULL) {
21120 dmsg_next = dmsg->next;
21121 kmem_free(dmsg, sizeof (sata_trace_dmsg_t));
21122
21123 /*
21124 * If we've looped around the ring than we're done.
21125 */
21126 if (dmsg_next == sata_debug_rbuf->dmsgh) {
21127 break;
21128 } else {
21129 dmsg = dmsg_next;
21130 }
21131 }
21132 }
21133
21134
21135 /*
21136 * This function can block
21137 */
21138 static void
sata_trace_rbuf_alloc(void)21139 sata_trace_rbuf_alloc(void)
21140 {
21141 sata_debug_rbuf = kmem_zalloc(sizeof (sata_trace_rbuf_t), KM_SLEEP);
21142
21143 mutex_init(&sata_debug_rbuf->lock, NULL, MUTEX_DRIVER, NULL);
21144
21145 if (dmsg_ring_size > 0) {
21146 sata_debug_rbuf->maxsize = (size_t)dmsg_ring_size;
21147 }
21148 }
21149
21150
21151 static void
sata_trace_rbuf_free(void)21152 sata_trace_rbuf_free(void)
21153 {
21154 sata_trace_dmsg_free();
21155 mutex_destroy(&sata_debug_rbuf->lock);
21156 kmem_free(sata_debug_rbuf, sizeof (sata_trace_rbuf_t));
21157 }
21158
21159 #ifndef SATA_DEBUG
21160 /*
21161 * If SATA_DEBUG is not defined then this routine is called instead
21162 * of sata_log() via the SATA_LOG_D macro.
21163 */
21164 static void
sata_trace_log(sata_hba_inst_t * sata_hba_inst,uint_t level __unused,const char * fmt,...)21165 sata_trace_log(sata_hba_inst_t *sata_hba_inst, uint_t level __unused,
21166 const char *fmt, ...)
21167 {
21168 dev_info_t *dip = NULL;
21169 va_list ap;
21170
21171 if (sata_hba_inst != NULL) {
21172 dip = SATA_DIP(sata_hba_inst);
21173 }
21174
21175 va_start(ap, fmt);
21176 sata_vtrace_debug(dip, fmt, ap);
21177 va_end(ap);
21178 }
21179 #endif /* SATA_DEBUG */
21180