1 /*
2 * CDDL HEADER START
3 *
4 * The contents of this file are subject to the terms of the
5 * Common Development and Distribution License (the "License").
6 * You may not use this file except in compliance with the License.
7 *
8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9 * or http://www.opensolaris.org/os/licensing.
10 * See the License for the specific language governing permissions
11 * and limitations under the License.
12 *
13 * When distributing Covered Code, include this CDDL HEADER in each
14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15 * If applicable, add the following below this CDDL HEADER, with the
16 * fields enclosed by brackets "[]" replaced with your own identifying
17 * information: Portions Copyright [yyyy] [name of copyright owner]
18 *
19 * CDDL HEADER END
20 */
21
22 /*
23 * Copyright (c) 2006, 2010, Oracle and/or its affiliates. All rights reserved.
24 */
25 /*
26 * Copyright 2015 Nexenta Systems, Inc. All rights reserved.
27 */
28
29 /*
30 * SATA Framework
31 * Generic SATA Host Adapter Implementation
32 */
33
34 #include <sys/conf.h>
35 #include <sys/file.h>
36 #include <sys/ddi.h>
37 #include <sys/sunddi.h>
38 #include <sys/modctl.h>
39 #include <sys/cmn_err.h>
40 #include <sys/errno.h>
41 #include <sys/thread.h>
42 #include <sys/kstat.h>
43 #include <sys/note.h>
44 #include <sys/sysevent.h>
45 #include <sys/sysevent/eventdefs.h>
46 #include <sys/sysevent/dr.h>
47 #include <sys/taskq.h>
48 #include <sys/disp.h>
49 #include <sys/sdt.h>
50
51 #include <sys/sata/impl/sata.h>
52 #include <sys/sata/sata_hba.h>
53 #include <sys/sata/sata_defs.h>
54 #include <sys/sata/sata_cfgadm.h>
55 #include <sys/sata/sata_blacklist.h>
56 #include <sys/sata/sata_satl.h>
57
58 #include <sys/scsi/impl/spc3_types.h>
59
60 /*
61 * FMA header files
62 */
63 #include <sys/ddifm.h>
64 #include <sys/fm/protocol.h>
65 #include <sys/fm/util.h>
66 #include <sys/fm/io/ddi.h>
67
68 /* Debug flags - defined in sata.h */
69 int sata_debug_flags = 0;
70 int sata_msg = 0;
71
72 /*
73 * Flags enabling selected SATA HBA framework functionality
74 */
75 #define SATA_ENABLE_QUEUING 1
76 #define SATA_ENABLE_NCQ 2
77 #define SATA_ENABLE_PROCESS_EVENTS 4
78 #define SATA_ENABLE_PMULT_FBS 8 /* FIS-Based Switching */
79 int sata_func_enable =
80 SATA_ENABLE_PROCESS_EVENTS | SATA_ENABLE_QUEUING | SATA_ENABLE_NCQ;
81
82 /*
83 * Global variable setting default maximum queue depth (NCQ or TCQ)
84 * Note:minimum queue depth is 1
85 */
86 int sata_max_queue_depth = SATA_MAX_QUEUE_DEPTH; /* max NCQ/TCQ queue depth */
87
88 /*
89 * Currently used default NCQ/TCQ queue depth. It is set-up during the driver
90 * initialization, using value from sata_max_queue_depth
91 * It is adjusted to minimum supported by the controller and by the device,
92 * if queueing is enabled.
93 */
94 static int sata_current_max_qdepth;
95
96 /*
97 * Global variable determining the default behavior after device hotpluggin.
98 * If non-zero, the hotplugged device is onlined (if possible) without explicit
99 * IOCTL request (AP_CONFIGURE).
100 * If zero, hotplugged device is identified, but not onlined.
101 * Enabling (AP_CONNECT) device port with an attached device does not result
102 * in device onlining regardless of the flag setting
103 */
104 int sata_auto_online = 0;
105
106 #ifdef SATA_DEBUG
107
108 #define SATA_LOG_D(args) sata_log args
109 uint64_t mbuf_count = 0;
110 uint64_t mbuffail_count = 0;
111
112 sata_atapi_cmd_t sata_atapi_trace[64];
113 uint32_t sata_atapi_trace_index = 0;
114 int sata_atapi_trace_save = 1;
115 static void sata_save_atapi_trace(sata_pkt_txlate_t *, int);
116 #define SATAATAPITRACE(spx, count) if (sata_atapi_trace_save) \
117 sata_save_atapi_trace(spx, count);
118
119 #else
120 #define SATA_LOG_D(args) sata_trace_log args
121 #define SATAATAPITRACE(spx, count)
122 #endif
123
124 #if 0
125 static void
126 sata_test_atapi_packet_command(sata_hba_inst_t *, int);
127 #endif
128
129 #ifdef SATA_INJECT_FAULTS
130
131 #define SATA_INJECT_PKT_FAULT 1
132 uint32_t sata_inject_fault = 0;
133
134 uint32_t sata_inject_fault_count = 0;
135 uint32_t sata_inject_fault_pause_count = 0;
136 uint32_t sata_fault_type = 0;
137 uint32_t sata_fault_cmd = 0;
138 dev_info_t *sata_fault_ctrl = NULL;
139 sata_device_t sata_fault_device;
140
141 static void sata_inject_pkt_fault(sata_pkt_t *, int *, int);
142
143 #endif
144
145 #define LEGACY_HWID_LEN 64 /* Model (40) + Serial (20) + pad */
146
147 static char sata_rev_tag[] = {"1.46"};
148
149 /*
150 * SATA cb_ops functions
151 */
152 static int sata_hba_open(dev_t *, int, int, cred_t *);
153 static int sata_hba_close(dev_t, int, int, cred_t *);
154 static int sata_hba_ioctl(dev_t, int, intptr_t, int, cred_t *, int *);
155
156 /*
157 * SCSA required entry points
158 */
159 static int sata_scsi_tgt_init(dev_info_t *, dev_info_t *,
160 scsi_hba_tran_t *, struct scsi_device *);
161 static int sata_scsi_tgt_probe(struct scsi_device *,
162 int (*callback)(void));
163 static void sata_scsi_tgt_free(dev_info_t *, dev_info_t *,
164 scsi_hba_tran_t *, struct scsi_device *);
165 static int sata_scsi_start(struct scsi_address *, struct scsi_pkt *);
166 static int sata_scsi_abort(struct scsi_address *, struct scsi_pkt *);
167 static int sata_scsi_reset(struct scsi_address *, int);
168 static int sata_scsi_getcap(struct scsi_address *, char *, int);
169 static int sata_scsi_setcap(struct scsi_address *, char *, int, int);
170 static struct scsi_pkt *sata_scsi_init_pkt(struct scsi_address *,
171 struct scsi_pkt *, struct buf *, int, int, int, int, int (*)(caddr_t),
172 caddr_t);
173 static void sata_scsi_destroy_pkt(struct scsi_address *, struct scsi_pkt *);
174 static void sata_scsi_dmafree(struct scsi_address *, struct scsi_pkt *);
175 static void sata_scsi_sync_pkt(struct scsi_address *, struct scsi_pkt *);
176
177 /*
178 * SATA HBA interface functions are defined in sata_hba.h header file
179 */
180
181 /* Event processing functions */
182 static void sata_event_daemon(void *);
183 static void sata_event_thread_control(int);
184 static void sata_process_controller_events(sata_hba_inst_t *sata_hba_inst);
185 static void sata_process_pmult_events(sata_hba_inst_t *, uint8_t);
186 static void sata_process_device_reset(sata_hba_inst_t *, sata_address_t *);
187 static void sata_process_pmdevice_reset(sata_hba_inst_t *, sata_address_t *);
188 static void sata_process_port_failed_event(sata_hba_inst_t *,
189 sata_address_t *);
190 static void sata_process_port_link_events(sata_hba_inst_t *,
191 sata_address_t *);
192 static void sata_process_pmport_link_events(sata_hba_inst_t *,
193 sata_address_t *);
194 static void sata_process_device_detached(sata_hba_inst_t *, sata_address_t *);
195 static void sata_process_pmdevice_detached(sata_hba_inst_t *,
196 sata_address_t *);
197 static void sata_process_device_attached(sata_hba_inst_t *, sata_address_t *);
198 static void sata_process_pmdevice_attached(sata_hba_inst_t *,
199 sata_address_t *);
200 static void sata_process_port_pwr_change(sata_hba_inst_t *, sata_address_t *);
201 static void sata_process_cntrl_pwr_level_change(sata_hba_inst_t *);
202 static void sata_process_target_node_cleanup(sata_hba_inst_t *,
203 sata_address_t *);
204 static void sata_process_device_autoonline(sata_hba_inst_t *,
205 sata_address_t *saddr);
206
207 /*
208 * Local translation functions
209 */
210 static int sata_txlt_inquiry(sata_pkt_txlate_t *);
211 static int sata_txlt_test_unit_ready(sata_pkt_txlate_t *);
212 static int sata_txlt_start_stop_unit(sata_pkt_txlate_t *);
213 static int sata_txlt_read_capacity(sata_pkt_txlate_t *);
214 static int sata_txlt_read_capacity16(sata_pkt_txlate_t *);
215 static int sata_txlt_unmap(sata_pkt_txlate_t *);
216 static int sata_txlt_request_sense(sata_pkt_txlate_t *);
217 static int sata_txlt_read(sata_pkt_txlate_t *);
218 static int sata_txlt_write(sata_pkt_txlate_t *);
219 static int sata_txlt_log_sense(sata_pkt_txlate_t *);
220 static int sata_txlt_log_select(sata_pkt_txlate_t *);
221 static int sata_txlt_mode_sense(sata_pkt_txlate_t *);
222 static int sata_txlt_mode_select(sata_pkt_txlate_t *);
223 static int sata_txlt_ata_pass_thru(sata_pkt_txlate_t *);
224 static int sata_txlt_synchronize_cache(sata_pkt_txlate_t *);
225 static int sata_txlt_write_buffer(sata_pkt_txlate_t *);
226 static int sata_txlt_nodata_cmd_immediate(sata_pkt_txlate_t *);
227
228 static int sata_hba_start(sata_pkt_txlate_t *, int *);
229 static int sata_txlt_invalid_command(sata_pkt_txlate_t *);
230 static int sata_txlt_check_condition(sata_pkt_txlate_t *, uchar_t, uchar_t);
231 static int sata_txlt_lba_out_of_range(sata_pkt_txlate_t *);
232 static int sata_txlt_ata_pass_thru_illegal_cmd(sata_pkt_txlate_t *);
233 static int sata_txlt_unmap_nodata_cmd(sata_pkt_txlate_t *);
234 static void sata_txlt_rw_completion(sata_pkt_t *);
235 static void sata_txlt_nodata_cmd_completion(sata_pkt_t *);
236 static void sata_txlt_apt_completion(sata_pkt_t *sata_pkt);
237 static void sata_txlt_unmap_completion(sata_pkt_t *sata_pkt);
238 static void sata_txlt_download_mcode_cmd_completion(sata_pkt_t *);
239 static int sata_emul_rw_completion(sata_pkt_txlate_t *);
240 static void sata_fill_ata_return_desc(sata_pkt_t *, uint8_t, uint8_t,
241 uint8_t);
242 static struct scsi_extended_sense *sata_immediate_error_response(
243 sata_pkt_txlate_t *, int);
244 static struct scsi_extended_sense *sata_arq_sense(sata_pkt_txlate_t *);
245
246 static int sata_txlt_atapi(sata_pkt_txlate_t *);
247 static void sata_txlt_atapi_completion(sata_pkt_t *);
248
249 /*
250 * Local functions for ioctl
251 */
252 static int32_t sata_get_port_num(sata_hba_inst_t *, struct devctl_iocdata *);
253 static void sata_cfgadm_state(sata_hba_inst_t *, int32_t,
254 devctl_ap_state_t *);
255 static dev_info_t *sata_get_target_dip(dev_info_t *, uint8_t, uint8_t);
256 static dev_info_t *sata_get_scsi_target_dip(dev_info_t *, sata_address_t *);
257 static dev_info_t *sata_devt_to_devinfo(dev_t);
258 static int sata_ioctl_connect(sata_hba_inst_t *, sata_device_t *);
259 static int sata_ioctl_disconnect(sata_hba_inst_t *, sata_device_t *);
260 static int sata_ioctl_configure(sata_hba_inst_t *, sata_device_t *);
261 static int sata_ioctl_unconfigure(sata_hba_inst_t *, sata_device_t *);
262 static int sata_ioctl_activate(sata_hba_inst_t *, sata_device_t *);
263 static int sata_ioctl_deactivate(sata_hba_inst_t *, sata_device_t *);
264 static int sata_ioctl_reset_port(sata_hba_inst_t *, sata_device_t *);
265 static int sata_ioctl_reset_device(sata_hba_inst_t *, sata_device_t *);
266 static int sata_ioctl_reset_all(sata_hba_inst_t *);
267 static int sata_ioctl_port_self_test(sata_hba_inst_t *, sata_device_t *);
268 static int sata_ioctl_get_device_path(sata_hba_inst_t *, sata_device_t *,
269 sata_ioctl_data_t *, int mode);
270 static int sata_ioctl_get_ap_type(sata_hba_inst_t *, sata_device_t *,
271 sata_ioctl_data_t *, int mode);
272 static int sata_ioctl_get_model_info(sata_hba_inst_t *, sata_device_t *,
273 sata_ioctl_data_t *, int mode);
274 static int sata_ioctl_get_revfirmware_info(sata_hba_inst_t *, sata_device_t *,
275 sata_ioctl_data_t *, int mode);
276 static int sata_ioctl_get_serialnumber_info(sata_hba_inst_t *,
277 sata_device_t *, sata_ioctl_data_t *, int mode);
278
279 /*
280 * Local functions
281 */
282 static void sata_remove_hba_instance(dev_info_t *);
283 static int sata_validate_sata_hba_tran(dev_info_t *, sata_hba_tran_t *);
284 static void sata_probe_ports(sata_hba_inst_t *);
285 static void sata_probe_pmports(sata_hba_inst_t *, uint8_t);
286 static int sata_reprobe_port(sata_hba_inst_t *, sata_device_t *, int);
287 static int sata_reprobe_pmult(sata_hba_inst_t *, sata_device_t *, int);
288 static int sata_reprobe_pmport(sata_hba_inst_t *, sata_device_t *, int);
289 static int sata_alloc_pmult(sata_hba_inst_t *, sata_device_t *);
290 static void sata_free_pmult(sata_hba_inst_t *, sata_device_t *);
291 static int sata_add_device(dev_info_t *, sata_hba_inst_t *, sata_device_t *);
292 static int sata_offline_device(sata_hba_inst_t *, sata_device_t *,
293 sata_drive_info_t *);
294 static dev_info_t *sata_create_target_node(dev_info_t *, sata_hba_inst_t *,
295 sata_address_t *);
296 static void sata_remove_target_node(sata_hba_inst_t *,
297 sata_address_t *);
298 static int sata_validate_scsi_address(sata_hba_inst_t *,
299 struct scsi_address *, sata_device_t *);
300 static int sata_validate_sata_address(sata_hba_inst_t *, int, int, int);
301 static sata_pkt_t *sata_pkt_alloc(sata_pkt_txlate_t *, int (*)(caddr_t));
302 static void sata_pkt_free(sata_pkt_txlate_t *);
303 static int sata_dma_buf_setup(sata_pkt_txlate_t *, int, int (*)(caddr_t),
304 caddr_t, ddi_dma_attr_t *);
305 static void sata_common_free_dma_rsrcs(sata_pkt_txlate_t *);
306 static int sata_probe_device(sata_hba_inst_t *, sata_device_t *);
307 static sata_drive_info_t *sata_get_device_info(sata_hba_inst_t *,
308 sata_device_t *);
309 static int sata_identify_device(sata_hba_inst_t *, sata_drive_info_t *);
310 static void sata_reidentify_device(sata_pkt_txlate_t *);
311 static struct buf *sata_alloc_local_buffer(sata_pkt_txlate_t *, int);
312 static void sata_free_local_buffer(sata_pkt_txlate_t *);
313 static uint64_t sata_check_capacity(sata_drive_info_t *);
314 void sata_adjust_dma_attr(sata_drive_info_t *, ddi_dma_attr_t *,
315 ddi_dma_attr_t *);
316 static int sata_fetch_device_identify_data(sata_hba_inst_t *,
317 sata_drive_info_t *);
318 static void sata_update_port_info(sata_hba_inst_t *, sata_device_t *);
319 static void sata_update_pmport_info(sata_hba_inst_t *, sata_device_t *);
320 static void sata_update_port_scr(sata_port_scr_t *, sata_device_t *);
321 static int sata_set_dma_mode(sata_hba_inst_t *, sata_drive_info_t *);
322 static int sata_set_cache_mode(sata_hba_inst_t *, sata_drive_info_t *, int);
323 static int sata_set_rmsn(sata_hba_inst_t *, sata_drive_info_t *, int);
324 static int sata_set_drive_features(sata_hba_inst_t *,
325 sata_drive_info_t *, int flag);
326 static void sata_init_write_cache_mode(sata_drive_info_t *sdinfo);
327 static int sata_initialize_device(sata_hba_inst_t *, sata_drive_info_t *);
328 static void sata_identdev_to_inquiry(sata_hba_inst_t *, sata_drive_info_t *,
329 uint8_t *);
330 static int sata_get_atapi_inquiry_data(sata_hba_inst_t *, sata_address_t *,
331 struct scsi_inquiry *);
332 static int sata_build_msense_page_1(sata_drive_info_t *, int, uint8_t *);
333 static int sata_build_msense_page_8(sata_drive_info_t *, int, uint8_t *);
334 static int sata_build_msense_page_1a(sata_drive_info_t *, int, uint8_t *);
335 static int sata_build_msense_page_1c(sata_drive_info_t *, int, uint8_t *);
336 static int sata_build_msense_page_30(sata_drive_info_t *, int, uint8_t *);
337 static int sata_mode_select_page_8(sata_pkt_txlate_t *,
338 struct mode_cache_scsi3 *, int, int *, int *, int *);
339 static int sata_mode_select_page_1a(sata_pkt_txlate_t *,
340 struct mode_info_power_cond *, int, int *, int *, int *);
341 static int sata_mode_select_page_1c(sata_pkt_txlate_t *,
342 struct mode_info_excpt_page *, int, int *, int *, int *);
343 static int sata_mode_select_page_30(sata_pkt_txlate_t *,
344 struct mode_acoustic_management *, int, int *, int *, int *);
345
346 static int sata_build_lsense_page_0(sata_drive_info_t *, uint8_t *);
347 static int sata_build_lsense_page_10(sata_drive_info_t *, uint8_t *,
348 sata_hba_inst_t *);
349 static int sata_build_lsense_page_2f(sata_drive_info_t *, uint8_t *,
350 sata_hba_inst_t *);
351 static int sata_build_lsense_page_30(sata_drive_info_t *, uint8_t *,
352 sata_hba_inst_t *);
353 static int sata_build_lsense_page_0e(sata_drive_info_t *, uint8_t *,
354 sata_pkt_txlate_t *);
355
356 static void sata_set_arq_data(sata_pkt_t *);
357 static void sata_build_read_verify_cmd(sata_cmd_t *, uint16_t, uint64_t);
358 static void sata_build_generic_cmd(sata_cmd_t *, uint8_t);
359 static uint8_t sata_get_standby_timer(uint8_t *timer);
360
361 static void sata_save_drive_settings(sata_drive_info_t *);
362 static void sata_show_drive_info(sata_hba_inst_t *, sata_drive_info_t *);
363 static void sata_show_pmult_info(sata_hba_inst_t *, sata_device_t *);
364 static void sata_log(sata_hba_inst_t *, uint_t, char *fmt, ...);
365 static void sata_trace_log(sata_hba_inst_t *, uint_t, const char *fmt, ...);
366 static int sata_fetch_smart_return_status(sata_hba_inst_t *,
367 sata_drive_info_t *);
368 static int sata_fetch_smart_data(sata_hba_inst_t *, sata_drive_info_t *,
369 struct smart_data *);
370 static int sata_smart_selftest_log(sata_hba_inst_t *,
371 sata_drive_info_t *,
372 struct smart_selftest_log *);
373 static int sata_ext_smart_selftest_read_log(sata_hba_inst_t *,
374 sata_drive_info_t *, struct smart_ext_selftest_log *, uint16_t);
375 static int sata_smart_read_log(sata_hba_inst_t *, sata_drive_info_t *,
376 uint8_t *, uint8_t, uint8_t);
377 static int sata_read_log_ext_directory(sata_hba_inst_t *, sata_drive_info_t *,
378 struct read_log_ext_directory *);
379 static void sata_gen_sysevent(sata_hba_inst_t *, sata_address_t *, int);
380 static void sata_xlate_errors(sata_pkt_txlate_t *);
381 static void sata_decode_device_error(sata_pkt_txlate_t *,
382 struct scsi_extended_sense *);
383 static void sata_set_device_removed(dev_info_t *);
384 static boolean_t sata_check_device_removed(dev_info_t *);
385 static void sata_set_target_node_cleanup(sata_hba_inst_t *, sata_address_t *);
386 static int sata_ncq_err_ret_cmd_setup(sata_pkt_txlate_t *,
387 sata_drive_info_t *);
388 static int sata_atapi_err_ret_cmd_setup(sata_pkt_txlate_t *,
389 sata_drive_info_t *);
390 static void sata_atapi_packet_cmd_setup(sata_cmd_t *, sata_drive_info_t *);
391 static void sata_fixed_sense_data_preset(struct scsi_extended_sense *);
392 static void sata_target_devid_register(dev_info_t *, sata_drive_info_t *);
393 static int sata_check_modser(char *, int);
394
395 /*
396 * FMA
397 */
398 static boolean_t sata_check_for_dma_error(dev_info_t *, sata_pkt_txlate_t *);
399
400
401 /*
402 * SATA Framework will ignore SATA HBA driver cb_ops structure and
403 * register following one with SCSA framework.
404 * Open & close are provided, so scsi framework will not use its own
405 */
406 static struct cb_ops sata_cb_ops = {
407 sata_hba_open, /* open */
408 sata_hba_close, /* close */
409 nodev, /* strategy */
410 nodev, /* print */
411 nodev, /* dump */
412 nodev, /* read */
413 nodev, /* write */
414 sata_hba_ioctl, /* ioctl */
415 nodev, /* devmap */
416 nodev, /* mmap */
417 nodev, /* segmap */
418 nochpoll, /* chpoll */
419 ddi_prop_op, /* cb_prop_op */
420 0, /* streamtab */
421 D_NEW | D_MP, /* cb_flag */
422 CB_REV, /* rev */
423 nodev, /* aread */
424 nodev /* awrite */
425 };
426
427
428 extern struct mod_ops mod_miscops;
429 extern uchar_t scsi_cdb_size[];
430
431 static struct modlmisc modlmisc = {
432 &mod_miscops, /* Type of module */
433 "SATA Module" /* module name */
434 };
435
436
437 static struct modlinkage modlinkage = {
438 MODREV_1,
439 (void *)&modlmisc,
440 NULL
441 };
442
443 /*
444 * Default sata pkt timeout. Used when a target driver scsi_pkt time is zero,
445 * i.e. when scsi_pkt has not timeout specified.
446 */
447 static int sata_default_pkt_time = 60; /* 60 seconds */
448
449 /*
450 * Intermediate buffer device access attributes - they are required,
451 * but not necessarily used.
452 */
453 static ddi_device_acc_attr_t sata_acc_attr = {
454 DDI_DEVICE_ATTR_V0,
455 DDI_STRUCTURE_LE_ACC,
456 DDI_STRICTORDER_ACC
457 };
458
459
460 /*
461 * Mutexes protecting structures in multithreaded operations.
462 * Because events are relatively rare, a single global mutex protecting
463 * data structures should be sufficient. To increase performance, add
464 * separate mutex per each sata port and use global mutex only to protect
465 * common data structures.
466 */
467 static kmutex_t sata_mutex; /* protects sata_hba_list */
468 static kmutex_t sata_log_mutex; /* protects log */
469
470 static char sata_log_buf[256];
471
472 /*
473 * sata trace debug
474 */
475 static sata_trace_rbuf_t *sata_debug_rbuf;
476 static sata_trace_dmsg_t *sata_trace_dmsg_alloc(void);
477 static void sata_trace_dmsg_free(void);
478 static void sata_trace_rbuf_alloc(void);
479 static void sata_trace_rbuf_free(void);
480
481 int dmsg_ring_size = DMSG_RING_SIZE;
482
483 /* Default write cache setting for SATA hard disks */
484 int sata_write_cache = 1; /* enabled */
485
486 /* Default write cache setting for SATA ATAPI CD/DVD */
487 int sata_atapicdvd_write_cache = 1; /* enabled */
488
489 /* Default write cache setting for SATA ATAPI tape */
490 int sata_atapitape_write_cache = 1; /* enabled */
491
492 /* Default write cache setting for SATA ATAPI disk */
493 int sata_atapidisk_write_cache = 1; /* enabled */
494
495 /*
496 * Linked list of HBA instances
497 */
498 static sata_hba_inst_t *sata_hba_list = NULL;
499 static sata_hba_inst_t *sata_hba_list_tail = NULL;
500 /*
501 * Pointer to per-instance SATA HBA soft structure is stored in sata_hba_tran
502 * structure and in sata soft state.
503 */
504
505 /*
506 * Event daemon related variables
507 */
508 static kmutex_t sata_event_mutex;
509 static kcondvar_t sata_event_cv;
510 static kthread_t *sata_event_thread = NULL;
511 static int sata_event_thread_terminate = 0;
512 static int sata_event_pending = 0;
513 static int sata_event_thread_active = 0;
514 extern pri_t minclsyspri;
515
516 /*
517 * NCQ error recovery command
518 */
519 static const sata_cmd_t sata_rle_cmd = {
520 SATA_CMD_REV,
521 NULL,
522 {
523 SATA_DIR_READ
524 },
525 ATA_ADDR_LBA48,
526 0,
527 0,
528 0,
529 0,
530 0,
531 1,
532 READ_LOG_EXT_NCQ_ERROR_RECOVERY,
533 0,
534 0,
535 0,
536 SATAC_READ_LOG_EXT,
537 0,
538 0,
539 0,
540 };
541
542 /*
543 * ATAPI error recovery CDB
544 */
545 static const uint8_t sata_rqsense_cdb[SATA_ATAPI_RQSENSE_CDB_LEN] = {
546 SCMD_REQUEST_SENSE,
547 0, /* Only fixed RQ format is supported */
548 0,
549 0,
550 SATA_ATAPI_MIN_RQSENSE_LEN, /* Less data may be returned */
551 0
552 };
553
554
555 /* Warlock directives */
556
557 _NOTE(SCHEME_PROTECTS_DATA("No Mutex Needed", scsi_hba_tran))
558 _NOTE(SCHEME_PROTECTS_DATA("No Mutex Needed", scsi_device))
559 _NOTE(SCHEME_PROTECTS_DATA("No Mutex Needed", dev_ops))
560 _NOTE(SCHEME_PROTECTS_DATA("No Mutex Needed", scsi_extended_sense))
561 _NOTE(SCHEME_PROTECTS_DATA("No Mutex Needed", scsi_arq_status))
562 _NOTE(SCHEME_PROTECTS_DATA("No Mutex Needed", ddi_dma_attr))
563 _NOTE(SCHEME_PROTECTS_DATA("No Mutex Needed", ddi_dma_cookie_t))
564 _NOTE(SCHEME_PROTECTS_DATA("No Mutex Needed", devctl_ap_state))
565 _NOTE(SCHEME_PROTECTS_DATA("No Mutex Needed", dev_info::devi_state))
566 _NOTE(MUTEX_PROTECTS_DATA(sata_mutex, sata_hba_list))
567 _NOTE(DATA_READABLE_WITHOUT_LOCK(sata_hba_list))
568 _NOTE(MUTEX_PROTECTS_DATA(sata_mutex, sata_hba_inst::satahba_next))
569 _NOTE(MUTEX_PROTECTS_DATA(sata_mutex, sata_hba_inst::satahba_prev))
570 _NOTE(SCHEME_PROTECTS_DATA("No Mutex Needed", \
571 sata_hba_inst::satahba_scsi_tran))
572 _NOTE(SCHEME_PROTECTS_DATA("No Mutex Needed", sata_hba_inst::satahba_tran))
573 _NOTE(SCHEME_PROTECTS_DATA("No Mutex Needed", sata_hba_inst::satahba_dip))
574 _NOTE(SCHEME_PROTECTS_DATA("Scheme", sata_hba_inst::satahba_attached))
575 _NOTE(DATA_READABLE_WITHOUT_LOCK(sata_hba_inst::satahba_dev_port))
576 _NOTE(MUTEX_PROTECTS_DATA(sata_hba_inst::satahba_mutex,
577 sata_hba_inst::satahba_event_flags))
578 _NOTE(MUTEX_PROTECTS_DATA(sata_cport_info::cport_mutex, \
579 sata_cport_info::cport_devp))
580 _NOTE(DATA_READABLE_WITHOUT_LOCK(sata_cport_info::cport_devp))
581 _NOTE(SCHEME_PROTECTS_DATA("Scheme", sata_cport_info::cport_addr))
582 _NOTE(MUTEX_PROTECTS_DATA(sata_cport_info::cport_mutex, \
583 sata_cport_info::cport_dev_type))
584 _NOTE(DATA_READABLE_WITHOUT_LOCK(sata_cport_info::cport_dev_type))
585 _NOTE(MUTEX_PROTECTS_DATA(sata_cport_info::cport_mutex, \
586 sata_cport_info::cport_state))
587 _NOTE(DATA_READABLE_WITHOUT_LOCK(sata_cport_info::cport_state))
588 _NOTE(MUTEX_PROTECTS_DATA(sata_pmport_info::pmport_mutex, \
589 sata_pmport_info::pmport_state))
590 _NOTE(DATA_READABLE_WITHOUT_LOCK(sata_pmport_info::pmport_state))
591 _NOTE(MUTEX_PROTECTS_DATA(sata_pmport_info::pmport_mutex, \
592 sata_pmport_info::pmport_dev_type))
593 _NOTE(DATA_READABLE_WITHOUT_LOCK(sata_pmport_info::pmport_dev_type))
594 _NOTE(MUTEX_PROTECTS_DATA(sata_pmport_info::pmport_mutex, \
595 sata_pmport_info::pmport_sata_drive))
596 _NOTE(MUTEX_PROTECTS_DATA(sata_pmport_info::pmport_mutex, \
597 sata_pmport_info::pmport_tgtnode_clean))
598 _NOTE(MUTEX_PROTECTS_DATA(sata_pmport_info::pmport_mutex, \
599 sata_pmport_info::pmport_event_flags))
600 _NOTE(DATA_READABLE_WITHOUT_LOCK(sata_pmport_info::pmport_sata_drive))
601 _NOTE(DATA_READABLE_WITHOUT_LOCK(sata_pmult_info::pmult_dev_port))
602 _NOTE(DATA_READABLE_WITHOUT_LOCK(sata_pmult_info::pmult_num_dev_ports))
603 #ifdef SATA_DEBUG
604 _NOTE(SCHEME_PROTECTS_DATA("No Mutex Needed", mbuf_count))
605 _NOTE(SCHEME_PROTECTS_DATA("No Mutex Needed", mbuffail_count))
606 _NOTE(SCHEME_PROTECTS_DATA("No Mutex Needed", sata_atapi_trace))
607 _NOTE(SCHEME_PROTECTS_DATA("No Mutex Needed", sata_atapi_trace_index))
608 #endif
609
610 /* End of warlock directives */
611
612 /* ************** loadable module configuration functions ************** */
613
614 int
615 _init()
616 {
617 int rval;
618
619 mutex_init(&sata_mutex, NULL, MUTEX_DRIVER, NULL);
620 mutex_init(&sata_event_mutex, NULL, MUTEX_DRIVER, NULL);
621 mutex_init(&sata_log_mutex, NULL, MUTEX_DRIVER, NULL);
622 cv_init(&sata_event_cv, NULL, CV_DRIVER, NULL);
623 sata_trace_rbuf_alloc();
624 if ((rval = mod_install(&modlinkage)) != 0) {
625 #ifdef SATA_DEBUG
626 cmn_err(CE_WARN, "sata: _init: mod_install failed\n");
627 #endif
628 sata_trace_rbuf_free();
629 mutex_destroy(&sata_log_mutex);
630 cv_destroy(&sata_event_cv);
631 mutex_destroy(&sata_event_mutex);
632 mutex_destroy(&sata_mutex);
633 }
634 return (rval);
635 }
636
637 int
638 _fini()
639 {
640 int rval;
641
642 if ((rval = mod_remove(&modlinkage)) != 0)
643 return (rval);
644
645 sata_trace_rbuf_free();
646 mutex_destroy(&sata_log_mutex);
647 cv_destroy(&sata_event_cv);
648 mutex_destroy(&sata_event_mutex);
649 mutex_destroy(&sata_mutex);
650 return (rval);
651 }
652
653 int
654 _info(struct modinfo *modinfop)
655 {
656 return (mod_info(&modlinkage, modinfop));
657 }
658
659
660
661 /* ********************* SATA HBA entry points ********************* */
662
663
664 /*
665 * Called by SATA HBA from _init().
666 * Registers HBA driver instance/sata framework pair with scsi framework, by
667 * calling scsi_hba_init().
668 *
669 * SATA HBA driver cb_ops are ignored - SATA HBA framework cb_ops are used
670 * instead. SATA HBA framework cb_ops pointer overwrites SATA HBA driver
671 * cb_ops pointer in SATA HBA driver dev_ops structure.
672 * SATA HBA framework cb_ops supplies cb_open cb_close and cb_ioctl vectors.
673 *
674 * Return status of the scsi_hba_init() is returned to a calling SATA HBA
675 * driver.
676 */
677 int
678 sata_hba_init(struct modlinkage *modlp)
679 {
680 int rval;
681 struct dev_ops *hba_ops;
682
683 SATADBG1(SATA_DBG_HBA_IF, NULL,
684 "sata_hba_init: name %s \n",
685 ((struct modldrv *)(modlp->ml_linkage[0]))->drv_linkinfo);
686 /*
687 * Fill-up cb_ops and dev_ops when necessary
688 */
689 hba_ops = ((struct modldrv *)(modlp->ml_linkage[0]))->drv_dev_ops;
690 /*
691 * Provide pointer to SATA dev_ops
692 */
693 hba_ops->devo_cb_ops = &sata_cb_ops;
694
695 /*
696 * Register SATA HBA with SCSI framework
697 */
698 if ((rval = scsi_hba_init(modlp)) != 0) {
699 SATADBG1(SATA_DBG_HBA_IF, NULL,
700 "sata_hba_init: scsi hba init failed\n", NULL);
701 return (rval);
702 }
703
704 return (0);
705 }
706
707
708 /* HBA attach stages */
709 #define HBA_ATTACH_STAGE_SATA_HBA_INST 1
710 #define HBA_ATTACH_STAGE_SCSI_ATTACHED 2
711 #define HBA_ATTACH_STAGE_SETUP 4
712 #define HBA_ATTACH_STAGE_LINKED 8
713
714
715 /*
716 *
717 * Called from SATA HBA driver's attach routine to attach an instance of
718 * the HBA.
719 *
720 * For DDI_ATTACH command:
721 * sata_hba_inst structure is allocated here and initialized with pointers to
722 * SATA framework implementation of required scsi tran functions.
723 * The scsi_tran's tran_hba_private field is used by SATA Framework to point
724 * to the soft structure (sata_hba_inst) allocated by SATA framework for
725 * SATA HBA instance related data.
726 * The scsi_tran's tran_hba_private field is used by SATA framework to
727 * store a pointer to per-HBA-instance of sata_hba_inst structure.
728 * The sata_hba_inst structure is cross-linked to scsi tran structure.
729 * Among other info, a pointer to sata_hba_tran structure is stored in
730 * sata_hba_inst. The sata_hba_inst structures for different HBA instances are
731 * linked together into the list, pointed to by sata_hba_list.
732 * On the first HBA instance attach the sata event thread is initialized.
733 * Attachment points are created for all SATA ports of the HBA being attached.
734 * All HBA instance's SATA ports are probed and type of plugged devices is
735 * determined. For each device of a supported type, a target node is created.
736 *
737 * DDI_SUCCESS is returned when attachment process is successful,
738 * DDI_FAILURE is returned otherwise.
739 *
740 * For DDI_RESUME command:
741 * Not implemented at this time (postponed until phase 2 of the development).
742 */
743 int
744 sata_hba_attach(dev_info_t *dip, sata_hba_tran_t *sata_tran,
745 ddi_attach_cmd_t cmd)
746 {
747 sata_hba_inst_t *sata_hba_inst;
748 scsi_hba_tran_t *scsi_tran = NULL;
749 int hba_attach_state = 0;
750 char taskq_name[MAXPATHLEN];
751
752 SATADBG3(SATA_DBG_HBA_IF, NULL,
753 "sata_hba_attach: node %s (%s%d)\n",
754 ddi_node_name(dip), ddi_driver_name(dip),
755 ddi_get_instance(dip));
756
757 if (cmd == DDI_RESUME) {
758 /*
759 * Postponed until phase 2 of the development
760 */
761 return (DDI_FAILURE);
762 }
763
764 if (cmd != DDI_ATTACH) {
765 return (DDI_FAILURE);
766 }
767
768 /* cmd == DDI_ATTACH */
769
770 if (sata_validate_sata_hba_tran(dip, sata_tran) != SATA_SUCCESS) {
771 SATA_LOG_D((NULL, CE_WARN,
772 "sata_hba_attach: invalid sata_hba_tran"));
773 return (DDI_FAILURE);
774 }
775 /*
776 * Allocate and initialize SCSI tran structure.
777 * SATA copy of tran_bus_config is provided to create port nodes.
778 */
779 scsi_tran = scsi_hba_tran_alloc(dip, SCSI_HBA_CANSLEEP);
780 if (scsi_tran == NULL)
781 return (DDI_FAILURE);
782 /*
783 * Allocate soft structure for SATA HBA instance.
784 * There is a separate softstate for each HBA instance.
785 */
786 sata_hba_inst = kmem_zalloc(sizeof (struct sata_hba_inst), KM_SLEEP);
787 ASSERT(sata_hba_inst != NULL); /* this should not fail */
788 mutex_init(&sata_hba_inst->satahba_mutex, NULL, MUTEX_DRIVER, NULL);
789 hba_attach_state |= HBA_ATTACH_STAGE_SATA_HBA_INST;
790
791 /*
792 * scsi_trans's tran_hba_private is used by SATA Framework to point to
793 * soft structure allocated by SATA framework for
794 * SATA HBA instance related data.
795 */
796 scsi_tran->tran_hba_private = sata_hba_inst;
797 scsi_tran->tran_tgt_private = NULL;
798
799 scsi_tran->tran_tgt_init = sata_scsi_tgt_init;
800 scsi_tran->tran_tgt_probe = sata_scsi_tgt_probe;
801 scsi_tran->tran_tgt_free = sata_scsi_tgt_free;
802
803 scsi_tran->tran_start = sata_scsi_start;
804 scsi_tran->tran_reset = sata_scsi_reset;
805 scsi_tran->tran_abort = sata_scsi_abort;
806 scsi_tran->tran_getcap = sata_scsi_getcap;
807 scsi_tran->tran_setcap = sata_scsi_setcap;
808 scsi_tran->tran_init_pkt = sata_scsi_init_pkt;
809 scsi_tran->tran_destroy_pkt = sata_scsi_destroy_pkt;
810
811 scsi_tran->tran_dmafree = sata_scsi_dmafree;
812 scsi_tran->tran_sync_pkt = sata_scsi_sync_pkt;
813
814 scsi_tran->tran_reset_notify = NULL;
815 scsi_tran->tran_get_bus_addr = NULL;
816 scsi_tran->tran_quiesce = NULL;
817 scsi_tran->tran_unquiesce = NULL;
818 scsi_tran->tran_bus_reset = NULL;
819
820 if (scsi_hba_attach_setup(dip, sata_tran->sata_tran_hba_dma_attr,
821 scsi_tran, 0) != DDI_SUCCESS) {
822 #ifdef SATA_DEBUG
823 cmn_err(CE_WARN, "?SATA: %s%d hba scsi attach failed",
824 ddi_driver_name(dip), ddi_get_instance(dip));
825 #endif
826 goto fail;
827 }
828 hba_attach_state |= HBA_ATTACH_STAGE_SCSI_ATTACHED;
829
830 if (!ddi_prop_exists(DDI_DEV_T_ANY, dip, DDI_PROP_DONTPASS, "sata")) {
831 if (ddi_prop_update_int(DDI_DEV_T_NONE, dip,
832 "sata", 1) != DDI_PROP_SUCCESS) {
833 SATA_LOG_D((NULL, CE_WARN, "sata_hba_attach: "
834 "failed to create hba sata prop"));
835 goto fail;
836 }
837 }
838
839 /*
840 * Save pointers in hba instance soft state.
841 */
842 sata_hba_inst->satahba_scsi_tran = scsi_tran;
843 sata_hba_inst->satahba_tran = sata_tran;
844 sata_hba_inst->satahba_dip = dip;
845
846 /*
847 * Create a task queue to handle emulated commands completion
848 * Use node name, dash, instance number as the queue name.
849 */
850 taskq_name[0] = '\0';
851 (void) strlcat(taskq_name, DEVI(dip)->devi_node_name,
852 sizeof (taskq_name));
853 (void) snprintf(taskq_name + strlen(taskq_name),
854 sizeof (taskq_name) - strlen(taskq_name),
855 "-%d", DEVI(dip)->devi_instance);
856 sata_hba_inst->satahba_taskq = taskq_create(taskq_name, 1,
857 minclsyspri, 1, sata_tran->sata_tran_hba_num_cports * 4,
858 TASKQ_DYNAMIC);
859
860 hba_attach_state |= HBA_ATTACH_STAGE_SETUP;
861
862 /*
863 * Create events thread if not created yet.
864 */
865 sata_event_thread_control(1);
866
867 /*
868 * Link this hba instance into the list.
869 */
870 mutex_enter(&sata_mutex);
871
872 if (sata_hba_list == NULL) {
873 /*
874 * The first instance of HBA is attached.
875 * Set current/active default maximum NCQ/TCQ queue depth for
876 * all SATA devices. It is done here and now, to eliminate the
877 * possibility of the dynamic, programatic modification of the
878 * queue depth via global (and public) sata_max_queue_depth
879 * variable (this would require special handling in HBA drivers)
880 */
881 sata_current_max_qdepth = sata_max_queue_depth;
882 if (sata_current_max_qdepth > 32)
883 sata_current_max_qdepth = 32;
884 else if (sata_current_max_qdepth < 1)
885 sata_current_max_qdepth = 1;
886 }
887
888 sata_hba_inst->satahba_next = NULL;
889 sata_hba_inst->satahba_prev = sata_hba_list_tail;
890 if (sata_hba_list == NULL) {
891 sata_hba_list = sata_hba_inst;
892 }
893 if (sata_hba_list_tail != NULL) {
894 sata_hba_list_tail->satahba_next = sata_hba_inst;
895 }
896 sata_hba_list_tail = sata_hba_inst;
897 mutex_exit(&sata_mutex);
898 hba_attach_state |= HBA_ATTACH_STAGE_LINKED;
899
900 /*
901 * Create SATA HBA devctl minor node for sata_hba_open, close, ioctl
902 * SATA HBA driver should not use its own open/close entry points.
903 *
904 * Make sure that instance number doesn't overflow
905 * when forming minor numbers.
906 */
907 ASSERT(ddi_get_instance(dip) <= (L_MAXMIN >> INST_MINOR_SHIFT));
908 if (ddi_create_minor_node(dip, "devctl", S_IFCHR,
909 INST2DEVCTL(ddi_get_instance(dip)),
910 DDI_NT_SATA_NEXUS, 0) != DDI_SUCCESS) {
911 #ifdef SATA_DEBUG
912 cmn_err(CE_WARN, "sata_hba_attach: "
913 "cannot create devctl minor node");
914 #endif
915 goto fail;
916 }
917
918
919 /*
920 * Set-up kstats here, if necessary.
921 * (postponed until future phase of the development).
922 */
923
924 /*
925 * Indicate that HBA is attached. This will enable events processing
926 * for this HBA.
927 */
928 sata_hba_inst->satahba_attached = 1;
929 /*
930 * Probe controller ports. This operation will describe a current
931 * controller/port/multipliers/device configuration and will create
932 * attachment points.
933 * We may end-up with just a controller with no devices attached.
934 * For the ports with a supported device attached, device target nodes
935 * are created and devices are initialized.
936 */
937 sata_probe_ports(sata_hba_inst);
938
939 return (DDI_SUCCESS);
940
941 fail:
942 if (hba_attach_state & HBA_ATTACH_STAGE_LINKED) {
943 (void) sata_remove_hba_instance(dip);
944 if (sata_hba_list == NULL)
945 sata_event_thread_control(0);
946 }
947
948 if (hba_attach_state & HBA_ATTACH_STAGE_SETUP) {
949 (void) ddi_prop_remove(DDI_DEV_T_ANY, dip, "sata");
950 taskq_destroy(sata_hba_inst->satahba_taskq);
951 }
952
953 if (hba_attach_state & HBA_ATTACH_STAGE_SCSI_ATTACHED)
954 (void) scsi_hba_detach(dip);
955
956 if (hba_attach_state & HBA_ATTACH_STAGE_SATA_HBA_INST) {
957 mutex_destroy(&sata_hba_inst->satahba_mutex);
958 kmem_free((void *)sata_hba_inst,
959 sizeof (struct sata_hba_inst));
960 scsi_hba_tran_free(scsi_tran);
961 }
962
963 sata_log(NULL, CE_WARN, "?SATA: %s%d hba attach failed",
964 ddi_driver_name(dip), ddi_get_instance(dip));
965
966 return (DDI_FAILURE);
967 }
968
969
970 /*
971 * Called by SATA HBA from to detach an instance of the driver.
972 *
973 * For DDI_DETACH command:
974 * Free local structures allocated for SATA HBA instance during
975 * sata_hba_attach processing.
976 *
977 * Returns DDI_SUCCESS when HBA was detached, DDI_FAILURE otherwise.
978 *
979 * For DDI_SUSPEND command:
980 * Not implemented at this time (postponed until phase 2 of the development)
981 * Returnd DDI_SUCCESS.
982 *
983 * When the last HBA instance is detached, the event daemon is terminated.
984 *
985 * NOTE: Port multiplier is supported.
986 */
987 int
988 sata_hba_detach(dev_info_t *dip, ddi_detach_cmd_t cmd)
989 {
990 dev_info_t *tdip;
991 sata_hba_inst_t *sata_hba_inst;
992 scsi_hba_tran_t *scsi_hba_tran;
993 sata_cport_info_t *cportinfo;
994 sata_pmult_info_t *pminfo;
995 sata_drive_info_t *sdinfo;
996 sata_device_t sdevice;
997 int ncport, npmport;
998
999 SATADBG3(SATA_DBG_HBA_IF, NULL, "sata_hba_detach: node %s (%s%d)\n",
1000 ddi_node_name(dip), ddi_driver_name(dip), ddi_get_instance(dip));
1001
1002 switch (cmd) {
1003 case DDI_DETACH:
1004
1005 if ((scsi_hba_tran = ddi_get_driver_private(dip)) == NULL)
1006 return (DDI_FAILURE);
1007
1008 sata_hba_inst = scsi_hba_tran->tran_hba_private;
1009 if (sata_hba_inst == NULL)
1010 return (DDI_FAILURE);
1011
1012 if (scsi_hba_detach(dip) == DDI_FAILURE) {
1013 sata_hba_inst->satahba_attached = 1;
1014 return (DDI_FAILURE);
1015 }
1016
1017 /*
1018 * Free all target nodes - at this point
1019 * devices should be at least offlined
1020 * otherwise scsi_hba_detach() should not be called.
1021 */
1022 for (ncport = 0; ncport < SATA_NUM_CPORTS(sata_hba_inst);
1023 ncport++) {
1024 cportinfo = SATA_CPORT_INFO(sata_hba_inst, ncport);
1025 if (cportinfo->cport_dev_type != SATA_DTYPE_PMULT) {
1026 sdinfo = SATA_CPORTINFO_DRV_INFO(cportinfo);
1027 if (sdinfo != NULL) {
1028 tdip = sata_get_target_dip(dip,
1029 ncport, 0);
1030 if (tdip != NULL) {
1031 if (ndi_devi_offline(tdip,
1032 NDI_DEVI_REMOVE) !=
1033 NDI_SUCCESS) {
1034 SATA_LOG_D((
1035 sata_hba_inst,
1036 CE_WARN,
1037 "sata_hba_detach: "
1038 "Target node not "
1039 "removed !"));
1040 return (DDI_FAILURE);
1041 }
1042 }
1043 }
1044 } else { /* SATA_DTYPE_PMULT */
1045 mutex_enter(&cportinfo->cport_mutex);
1046 pminfo = SATA_CPORTINFO_PMULT_INFO(cportinfo);
1047
1048 if (pminfo == NULL) {
1049 SATA_LOG_D((sata_hba_inst, CE_WARN,
1050 "sata_hba_detach: Port multiplier "
1051 "not ready yet!"));
1052 mutex_exit(&cportinfo->cport_mutex);
1053 return (DDI_FAILURE);
1054 }
1055
1056 /*
1057 * Detach would fail if removal of any of the
1058 * target nodes is failed - albeit in that
1059 * case some of them may have been removed.
1060 */
1061 for (npmport = 0; npmport < SATA_NUM_PMPORTS(
1062 sata_hba_inst, ncport); npmport++) {
1063 tdip = sata_get_target_dip(dip, ncport,
1064 npmport);
1065 if (tdip != NULL) {
1066 if (ndi_devi_offline(tdip,
1067 NDI_DEVI_REMOVE) !=
1068 NDI_SUCCESS) {
1069 SATA_LOG_D((
1070 sata_hba_inst,
1071 CE_WARN,
1072 "sata_hba_detach: "
1073 "Target node not "
1074 "removed !"));
1075 mutex_exit(&cportinfo->
1076 cport_mutex);
1077 return (DDI_FAILURE);
1078 }
1079 }
1080 }
1081 mutex_exit(&cportinfo->cport_mutex);
1082 }
1083 }
1084 /*
1085 * Disable sata event daemon processing for this HBA
1086 */
1087 sata_hba_inst->satahba_attached = 0;
1088
1089 /*
1090 * Remove event daemon thread, if it is last HBA instance.
1091 */
1092
1093 mutex_enter(&sata_mutex);
1094 if (sata_hba_list->satahba_next == NULL) {
1095 mutex_exit(&sata_mutex);
1096 sata_event_thread_control(0);
1097 mutex_enter(&sata_mutex);
1098 }
1099 mutex_exit(&sata_mutex);
1100
1101 /* Remove this HBA instance from the HBA list */
1102 sata_remove_hba_instance(dip);
1103
1104 /*
1105 * At this point there should be no target nodes attached.
1106 * Detach and destroy device and port info structures.
1107 */
1108 for (ncport = 0; ncport < SATA_NUM_CPORTS(sata_hba_inst);
1109 ncport++) {
1110 cportinfo = SATA_CPORT_INFO(sata_hba_inst, ncport);
1111 if (cportinfo->cport_dev_type != SATA_DTYPE_PMULT) {
1112 sdinfo =
1113 cportinfo->cport_devp.cport_sata_drive;
1114 if (sdinfo != NULL) {
1115 /* Release device structure */
1116 kmem_free(sdinfo,
1117 sizeof (sata_drive_info_t));
1118 }
1119 /* Release cport info */
1120 mutex_destroy(&cportinfo->cport_mutex);
1121 kmem_free(cportinfo,
1122 sizeof (sata_cport_info_t));
1123 } else { /* SATA_DTYPE_PMULT */
1124 sdevice.satadev_addr.cport = (uint8_t)ncport;
1125 sdevice.satadev_addr.qual = SATA_ADDR_PMULT;
1126 sata_free_pmult(sata_hba_inst, &sdevice);
1127 }
1128 }
1129
1130 scsi_hba_tran_free(sata_hba_inst->satahba_scsi_tran);
1131
1132 (void) ddi_prop_remove(DDI_DEV_T_ANY, dip, "sata");
1133
1134 taskq_destroy(sata_hba_inst->satahba_taskq);
1135
1136 mutex_destroy(&sata_hba_inst->satahba_mutex);
1137 kmem_free((void *)sata_hba_inst,
1138 sizeof (struct sata_hba_inst));
1139
1140 return (DDI_SUCCESS);
1141
1142 case DDI_SUSPEND:
1143 /*
1144 * Postponed until phase 2
1145 */
1146 return (DDI_FAILURE);
1147
1148 default:
1149 return (DDI_FAILURE);
1150 }
1151 }
1152
1153
1154 /*
1155 * Called by an HBA drive from _fini() routine.
1156 * Unregisters SATA HBA instance/SATA framework pair from the scsi framework.
1157 */
1158 void
1159 sata_hba_fini(struct modlinkage *modlp)
1160 {
1161 SATADBG1(SATA_DBG_HBA_IF, NULL,
1162 "sata_hba_fini: name %s\n",
1163 ((struct modldrv *)(modlp->ml_linkage[0]))->drv_linkinfo);
1164
1165 scsi_hba_fini(modlp);
1166 }
1167
1168
1169 /*
1170 * Default open and close routine for sata_hba framework.
1171 *
1172 */
1173 /*
1174 * Open devctl node.
1175 *
1176 * Returns:
1177 * 0 if node was open successfully, error code otherwise.
1178 *
1179 *
1180 */
1181
1182 static int
1183 sata_hba_open(dev_t *devp, int flags, int otyp, cred_t *credp)
1184 {
1185 #ifndef __lock_lint
1186 _NOTE(ARGUNUSED(credp))
1187 #endif
1188 int rv = 0;
1189 dev_info_t *dip;
1190 scsi_hba_tran_t *scsi_hba_tran;
1191 sata_hba_inst_t *sata_hba_inst;
1192
1193 SATADBG1(SATA_DBG_IOCTL_IF, NULL, "sata_hba_open: entered", NULL);
1194
1195 if (otyp != OTYP_CHR)
1196 return (EINVAL);
1197
1198 dip = sata_devt_to_devinfo(*devp);
1199 if (dip == NULL)
1200 return (ENXIO);
1201
1202 if ((scsi_hba_tran = ddi_get_driver_private(dip)) == NULL)
1203 return (ENXIO);
1204
1205 sata_hba_inst = scsi_hba_tran->tran_hba_private;
1206 if (sata_hba_inst == NULL || sata_hba_inst->satahba_attached == 0)
1207 return (ENXIO);
1208
1209 mutex_enter(&sata_mutex);
1210 if (flags & FEXCL) {
1211 if (sata_hba_inst->satahba_open_flag != 0) {
1212 rv = EBUSY;
1213 } else {
1214 sata_hba_inst->satahba_open_flag =
1215 SATA_DEVCTL_EXOPENED;
1216 }
1217 } else {
1218 if (sata_hba_inst->satahba_open_flag == SATA_DEVCTL_EXOPENED) {
1219 rv = EBUSY;
1220 } else {
1221 sata_hba_inst->satahba_open_flag =
1222 SATA_DEVCTL_SOPENED;
1223 }
1224 }
1225 mutex_exit(&sata_mutex);
1226
1227 return (rv);
1228 }
1229
1230
1231 /*
1232 * Close devctl node.
1233 * Returns:
1234 * 0 if node was closed successfully, error code otherwise.
1235 *
1236 */
1237
1238 static int
1239 sata_hba_close(dev_t dev, int flag, int otyp, cred_t *credp)
1240 {
1241 #ifndef __lock_lint
1242 _NOTE(ARGUNUSED(credp))
1243 _NOTE(ARGUNUSED(flag))
1244 #endif
1245 dev_info_t *dip;
1246 scsi_hba_tran_t *scsi_hba_tran;
1247 sata_hba_inst_t *sata_hba_inst;
1248
1249 SATADBG1(SATA_DBG_IOCTL_IF, NULL, "sata_hba_close: entered", NULL);
1250
1251 if (otyp != OTYP_CHR)
1252 return (EINVAL);
1253
1254 dip = sata_devt_to_devinfo(dev);
1255 if (dip == NULL)
1256 return (ENXIO);
1257
1258 if ((scsi_hba_tran = ddi_get_driver_private(dip)) == NULL)
1259 return (ENXIO);
1260
1261 sata_hba_inst = scsi_hba_tran->tran_hba_private;
1262 if (sata_hba_inst == NULL || sata_hba_inst->satahba_attached == 0)
1263 return (ENXIO);
1264
1265 mutex_enter(&sata_mutex);
1266 sata_hba_inst->satahba_open_flag = 0;
1267 mutex_exit(&sata_mutex);
1268 return (0);
1269 }
1270
1271
1272
1273 /*
1274 * Standard IOCTL commands for SATA hotplugging.
1275 * Implemented DEVCTL_AP commands:
1276 * DEVCTL_AP_CONNECT
1277 * DEVCTL_AP_DISCONNECT
1278 * DEVCTL_AP_CONFIGURE
1279 * DEVCTL_UNCONFIGURE
1280 * DEVCTL_AP_CONTROL
1281 *
1282 * Commands passed to default ndi ioctl handler:
1283 * DEVCTL_DEVICE_GETSTATE
1284 * DEVCTL_DEVICE_ONLINE
1285 * DEVCTL_DEVICE_OFFLINE
1286 * DEVCTL_DEVICE_REMOVE
1287 * DEVCTL_DEVICE_INSERT
1288 * DEVCTL_BUS_GETSTATE
1289 *
1290 * All other cmds are passed to HBA if it provide ioctl handler, or failed
1291 * if not.
1292 *
1293 * Returns:
1294 * 0 if successful,
1295 * error code if operation failed.
1296 *
1297 * Port Multiplier support is supported now.
1298 *
1299 * NOTE: qual should be SATA_ADDR_DCPORT or SATA_ADDR_DPMPORT
1300 */
1301
1302 static int
1303 sata_hba_ioctl(dev_t dev, int cmd, intptr_t arg, int mode, cred_t *credp,
1304 int *rvalp)
1305 {
1306 #ifndef __lock_lint
1307 _NOTE(ARGUNUSED(credp))
1308 _NOTE(ARGUNUSED(rvalp))
1309 #endif
1310 int rv = 0;
1311 int32_t comp_port = -1;
1312 dev_info_t *dip;
1313 devctl_ap_state_t ap_state;
1314 struct devctl_iocdata *dcp = NULL;
1315 scsi_hba_tran_t *scsi_hba_tran;
1316 sata_hba_inst_t *sata_hba_inst;
1317 sata_device_t sata_device;
1318 sata_cport_info_t *cportinfo;
1319 int cport, pmport, qual;
1320 int rval = SATA_SUCCESS;
1321
1322 dip = sata_devt_to_devinfo(dev);
1323 if (dip == NULL)
1324 return (ENXIO);
1325
1326 if ((scsi_hba_tran = ddi_get_driver_private(dip)) == NULL)
1327 return (ENXIO);
1328
1329 sata_hba_inst = scsi_hba_tran->tran_hba_private;
1330 if (sata_hba_inst == NULL)
1331 return (ENXIO);
1332
1333 if (sata_hba_inst->satahba_tran == NULL)
1334 return (ENXIO);
1335
1336 switch (cmd) {
1337
1338 case DEVCTL_DEVICE_GETSTATE:
1339 case DEVCTL_DEVICE_ONLINE:
1340 case DEVCTL_DEVICE_OFFLINE:
1341 case DEVCTL_DEVICE_REMOVE:
1342 case DEVCTL_BUS_GETSTATE:
1343 /*
1344 * There may be more cases that we want to pass to default
1345 * handler rather than fail them.
1346 */
1347 return (ndi_devctl_ioctl(dip, cmd, arg, mode, 0));
1348 }
1349
1350 /* read devctl ioctl data */
1351 if (cmd != DEVCTL_AP_CONTROL) {
1352 if (ndi_dc_allochdl((void *)arg, &dcp) != NDI_SUCCESS)
1353 return (EFAULT);
1354
1355 if ((comp_port = sata_get_port_num(sata_hba_inst, dcp)) ==
1356 -1) {
1357 if (dcp)
1358 ndi_dc_freehdl(dcp);
1359 return (EINVAL);
1360 }
1361
1362 /*
1363 * According to SCSI_TO_SATA_ADDR_QUAL, qual should be either
1364 * SATA_ADDR_DCPORT or SATA_ADDR_DPMPORT.
1365 */
1366 cport = SCSI_TO_SATA_CPORT(comp_port);
1367 pmport = SCSI_TO_SATA_PMPORT(comp_port);
1368 qual = SCSI_TO_SATA_ADDR_QUAL(comp_port);
1369
1370 if (sata_validate_sata_address(sata_hba_inst, cport, pmport,
1371 qual) != 0) {
1372 ndi_dc_freehdl(dcp);
1373 return (EINVAL);
1374 }
1375
1376 cportinfo = SATA_CPORT_INFO(sata_hba_inst, cport);
1377 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, cport)->
1378 cport_mutex);
1379 if (cportinfo->cport_event_flags & SATA_EVNT_LOCK_PORT_BUSY) {
1380 /*
1381 * Cannot process ioctl request now. Come back later.
1382 */
1383 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)->
1384 cport_mutex);
1385 ndi_dc_freehdl(dcp);
1386 return (EBUSY);
1387 }
1388 /* Block event processing for this port */
1389 cportinfo->cport_event_flags |= SATA_APCTL_LOCK_PORT_BUSY;
1390 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex);
1391
1392 sata_device.satadev_addr.cport = cport;
1393 sata_device.satadev_addr.pmport = pmport;
1394 sata_device.satadev_addr.qual = qual;
1395 sata_device.satadev_rev = SATA_DEVICE_REV;
1396 }
1397
1398 switch (cmd) {
1399
1400 case DEVCTL_AP_DISCONNECT:
1401
1402 /*
1403 * Normally, cfgadm sata plugin will try to offline
1404 * (unconfigure) device before this request. Nevertheless,
1405 * if a device is still configured, we need to
1406 * attempt to offline and unconfigure device first, and we will
1407 * deactivate the port regardless of the unconfigure
1408 * operation results.
1409 *
1410 */
1411 rv = sata_ioctl_disconnect(sata_hba_inst, &sata_device);
1412
1413 break;
1414
1415 case DEVCTL_AP_UNCONFIGURE:
1416
1417 /*
1418 * The unconfigure operation uses generic nexus operation to
1419 * offline a device. It leaves a target device node attached.
1420 * and obviously sata_drive_info attached as well, because
1421 * from the hardware point of view nothing has changed.
1422 */
1423 rv = sata_ioctl_unconfigure(sata_hba_inst, &sata_device);
1424 break;
1425
1426 case DEVCTL_AP_CONNECT:
1427 {
1428 /*
1429 * The sata cfgadm pluging will invoke this operation only if
1430 * port was found in the disconnect state (failed state
1431 * is also treated as the disconnected state).
1432 * If port activation is successful and a device is found
1433 * attached to the port, the initialization sequence is
1434 * executed to probe the port and attach
1435 * a device structure to a port structure. The device is not
1436 * set in configured state (system-wise) by this operation.
1437 */
1438
1439 rv = sata_ioctl_connect(sata_hba_inst, &sata_device);
1440
1441 break;
1442 }
1443
1444 case DEVCTL_AP_CONFIGURE:
1445 {
1446 /*
1447 * A port may be in an active or shutdown state.
1448 * If port is in a failed state, operation is aborted.
1449 * If a port is in a shutdown state, sata_tran_port_activate()
1450 * is invoked prior to any other operation.
1451 *
1452 * Onlining the device involves creating a new target node.
1453 * If there is an old target node present (belonging to
1454 * previously removed device), the operation is aborted - the
1455 * old node has to be released and removed before configure
1456 * operation is attempted.
1457 */
1458
1459 rv = sata_ioctl_configure(sata_hba_inst, &sata_device);
1460
1461 break;
1462 }
1463
1464 case DEVCTL_AP_GETSTATE:
1465
1466 sata_cfgadm_state(sata_hba_inst, comp_port, &ap_state);
1467
1468 ap_state.ap_last_change = (time_t)-1;
1469 ap_state.ap_error_code = 0;
1470 ap_state.ap_in_transition = 0;
1471
1472 /* Copy the return AP-state information to the user space */
1473 if (ndi_dc_return_ap_state(&ap_state, dcp) != NDI_SUCCESS) {
1474 rv = EFAULT;
1475 }
1476 break;
1477
1478 case DEVCTL_AP_CONTROL:
1479 {
1480 /*
1481 * Generic devctl for hardware specific functionality
1482 */
1483 sata_ioctl_data_t ioc;
1484
1485 ASSERT(dcp == NULL);
1486
1487 /* Copy in user ioctl data first */
1488 #ifdef _MULTI_DATAMODEL
1489 if (ddi_model_convert_from(mode & FMODELS) ==
1490 DDI_MODEL_ILP32) {
1491
1492 sata_ioctl_data_32_t ioc32;
1493
1494 if (ddi_copyin((void *)arg, (void *)&ioc32,
1495 sizeof (ioc32), mode) != 0) {
1496 rv = EFAULT;
1497 break;
1498 }
1499 ioc.cmd = (uint_t)ioc32.cmd;
1500 ioc.port = (uint_t)ioc32.port;
1501 ioc.get_size = (uint_t)ioc32.get_size;
1502 ioc.buf = (caddr_t)(uintptr_t)ioc32.buf;
1503 ioc.bufsiz = (uint_t)ioc32.bufsiz;
1504 ioc.misc_arg = (uint_t)ioc32.misc_arg;
1505 } else
1506 #endif /* _MULTI_DATAMODEL */
1507 if (ddi_copyin((void *)arg, (void *)&ioc, sizeof (ioc),
1508 mode) != 0) {
1509 return (EFAULT);
1510 }
1511
1512 SATADBG2(SATA_DBG_IOCTL_IF, sata_hba_inst,
1513 "sata_hba_ioctl: DEVCTL_AP_CONTROL "
1514 "cmd 0x%x, port 0x%x", ioc.cmd, ioc.port);
1515
1516 /*
1517 * To avoid BE/LE and 32/64 issues, a get_size always returns
1518 * a 32-bit number.
1519 */
1520 if (ioc.get_size != 0 && ioc.bufsiz != (sizeof (uint32_t))) {
1521 return (EINVAL);
1522 }
1523 /* validate address */
1524 cport = SCSI_TO_SATA_CPORT(ioc.port);
1525 pmport = SCSI_TO_SATA_PMPORT(ioc.port);
1526 qual = SCSI_TO_SATA_ADDR_QUAL(ioc.port);
1527
1528 SATADBG3(SATA_DBG_IOCTL_IF, sata_hba_inst,
1529 "sata_hba_ioctl: target port is %d:%d (%d)",
1530 cport, pmport, qual);
1531
1532 if (sata_validate_sata_address(sata_hba_inst, cport,
1533 pmport, qual) != 0)
1534 return (EINVAL);
1535
1536 cportinfo = SATA_CPORT_INFO(sata_hba_inst, cport);
1537 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, cport)->
1538 cport_mutex);
1539 /* Is the port locked by event processing daemon ? */
1540 if (cportinfo->cport_event_flags & SATA_EVNT_LOCK_PORT_BUSY) {
1541 /*
1542 * Cannot process ioctl request now. Come back later
1543 */
1544 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)->
1545 cport_mutex);
1546 return (EBUSY);
1547 }
1548 /* Block event processing for this port */
1549 cportinfo->cport_event_flags |= SATA_APCTL_LOCK_PORT_BUSY;
1550 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex);
1551
1552
1553 sata_device.satadev_addr.cport = cport;
1554 sata_device.satadev_addr.pmport = pmport;
1555 sata_device.satadev_addr.qual = qual;
1556 sata_device.satadev_rev = SATA_DEVICE_REV;
1557
1558 switch (ioc.cmd) {
1559
1560 case SATA_CFGA_RESET_PORT:
1561 /*
1562 * There is no protection for configured device.
1563 */
1564 rv = sata_ioctl_reset_port(sata_hba_inst, &sata_device);
1565 break;
1566
1567 case SATA_CFGA_RESET_DEVICE:
1568 /*
1569 * There is no protection for configured device.
1570 */
1571 rv = sata_ioctl_reset_device(sata_hba_inst,
1572 &sata_device);
1573 break;
1574
1575 case SATA_CFGA_RESET_ALL:
1576 /*
1577 * There is no protection for configured devices.
1578 */
1579 rv = sata_ioctl_reset_all(sata_hba_inst);
1580 /*
1581 * We return here, because common return is for
1582 * a single port operation - we have already unlocked
1583 * all ports and no dc handle was allocated.
1584 */
1585 return (rv);
1586
1587 case SATA_CFGA_PORT_DEACTIVATE:
1588 /*
1589 * Arbitrarily unconfigure attached device, if any.
1590 * Even if the unconfigure fails, proceed with the
1591 * port deactivation.
1592 */
1593 rv = sata_ioctl_deactivate(sata_hba_inst, &sata_device);
1594
1595 break;
1596
1597 case SATA_CFGA_PORT_ACTIVATE:
1598
1599 rv = sata_ioctl_activate(sata_hba_inst, &sata_device);
1600 break;
1601
1602 case SATA_CFGA_PORT_SELF_TEST:
1603
1604 rv = sata_ioctl_port_self_test(sata_hba_inst,
1605 &sata_device);
1606 break;
1607
1608 case SATA_CFGA_GET_DEVICE_PATH:
1609
1610 rv = sata_ioctl_get_device_path(sata_hba_inst,
1611 &sata_device, &ioc, mode);
1612 break;
1613
1614 case SATA_CFGA_GET_AP_TYPE:
1615
1616 rv = sata_ioctl_get_ap_type(sata_hba_inst,
1617 &sata_device, &ioc, mode);
1618 break;
1619
1620 case SATA_CFGA_GET_MODEL_INFO:
1621
1622 rv = sata_ioctl_get_model_info(sata_hba_inst,
1623 &sata_device, &ioc, mode);
1624 break;
1625
1626 case SATA_CFGA_GET_REVFIRMWARE_INFO:
1627
1628 rv = sata_ioctl_get_revfirmware_info(sata_hba_inst,
1629 &sata_device, &ioc, mode);
1630 break;
1631
1632 case SATA_CFGA_GET_SERIALNUMBER_INFO:
1633
1634 rv = sata_ioctl_get_serialnumber_info(sata_hba_inst,
1635 &sata_device, &ioc, mode);
1636 break;
1637
1638 default:
1639 rv = EINVAL;
1640 break;
1641
1642 } /* End of DEVCTL_AP_CONTROL cmd switch */
1643
1644 break;
1645 }
1646
1647 default:
1648 {
1649 /*
1650 * If we got here, we got an IOCTL that SATA HBA Framework
1651 * does not recognize. Pass ioctl to HBA driver, in case
1652 * it could process it.
1653 */
1654 sata_hba_tran_t *sata_tran = sata_hba_inst->satahba_tran;
1655 dev_info_t *mydip = SATA_DIP(sata_hba_inst);
1656
1657 SATADBG1(SATA_DBG_IOCTL_IF, sata_hba_inst,
1658 "IOCTL 0x%2x not supported in SATA framework, "
1659 "passthrough to HBA", cmd);
1660
1661 if (sata_tran->sata_tran_ioctl == NULL) {
1662 rv = EINVAL;
1663 break;
1664 }
1665 rval = (*sata_tran->sata_tran_ioctl)(mydip, cmd, arg);
1666 if (rval != 0) {
1667 SATADBG1(SATA_DBG_IOCTL_IF, sata_hba_inst,
1668 "IOCTL 0x%2x failed in HBA", cmd);
1669 rv = rval;
1670 }
1671 break;
1672 }
1673
1674 } /* End of main IOCTL switch */
1675
1676 if (dcp) {
1677 ndi_dc_freehdl(dcp);
1678 }
1679 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex);
1680 cportinfo->cport_event_flags &= ~SATA_APCTL_LOCK_PORT_BUSY;
1681 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex);
1682
1683 return (rv);
1684 }
1685
1686
1687 /*
1688 * Create error retrieval sata packet
1689 *
1690 * A sata packet is allocated and set-up to contain specified error retrieval
1691 * command and appropriate dma-able data buffer.
1692 * No association with any scsi packet is made and no callback routine is
1693 * specified.
1694 *
1695 * Returns a pointer to sata packet upon successful packet creation.
1696 * Returns NULL, if packet cannot be created.
1697 */
1698 sata_pkt_t *
1699 sata_get_error_retrieval_pkt(dev_info_t *dip, sata_device_t *sata_device,
1700 int pkt_type)
1701 {
1702 sata_hba_inst_t *sata_hba_inst;
1703 sata_pkt_txlate_t *spx;
1704 sata_pkt_t *spkt;
1705 sata_drive_info_t *sdinfo;
1706
1707 mutex_enter(&sata_mutex);
1708 for (sata_hba_inst = sata_hba_list; sata_hba_inst != NULL;
1709 sata_hba_inst = sata_hba_inst->satahba_next) {
1710 if (SATA_DIP(sata_hba_inst) == dip)
1711 break;
1712 }
1713 mutex_exit(&sata_mutex);
1714 ASSERT(sata_hba_inst != NULL);
1715
1716 sdinfo = sata_get_device_info(sata_hba_inst, sata_device);
1717 if (sdinfo == NULL) {
1718 sata_log(sata_hba_inst, CE_WARN,
1719 "sata: error recovery request for non-attached device at "
1720 "cport %d", sata_device->satadev_addr.cport);
1721 return (NULL);
1722 }
1723
1724 spx = kmem_zalloc(sizeof (sata_pkt_txlate_t), KM_SLEEP);
1725 spx->txlt_sata_hba_inst = sata_hba_inst;
1726 spx->txlt_scsi_pkt = NULL; /* No scsi pkt involved */
1727 spkt = sata_pkt_alloc(spx, NULL);
1728 if (spkt == NULL) {
1729 kmem_free(spx, sizeof (sata_pkt_txlate_t));
1730 return (NULL);
1731 }
1732 /* address is needed now */
1733 spkt->satapkt_device.satadev_addr = sata_device->satadev_addr;
1734
1735 switch (pkt_type) {
1736 case SATA_ERR_RETR_PKT_TYPE_NCQ:
1737 if (sata_ncq_err_ret_cmd_setup(spx, sdinfo) == SATA_SUCCESS) {
1738 if (sata_check_for_dma_error(dip, spx)) {
1739 ddi_fm_service_impact(dip,
1740 DDI_SERVICE_UNAFFECTED);
1741 break;
1742 }
1743 return (spkt);
1744 }
1745 break;
1746
1747 case SATA_ERR_RETR_PKT_TYPE_ATAPI:
1748 if (sata_atapi_err_ret_cmd_setup(spx, sdinfo) == SATA_SUCCESS) {
1749 if (sata_check_for_dma_error(dip, spx)) {
1750 ddi_fm_service_impact(dip,
1751 DDI_SERVICE_UNAFFECTED);
1752 break;
1753 }
1754 return (spkt);
1755 }
1756 break;
1757
1758 default:
1759 break;
1760 }
1761
1762 sata_pkt_free(spx);
1763 kmem_free(spx, sizeof (sata_pkt_txlate_t));
1764 return (NULL);
1765
1766 }
1767
1768
1769 /*
1770 * Free error retrieval sata packet
1771 *
1772 * Free sata packet and any associated resources allocated previously by
1773 * sata_get_error_retrieval_pkt().
1774 *
1775 * Void return.
1776 */
1777 void
1778 sata_free_error_retrieval_pkt(sata_pkt_t *sata_pkt)
1779 {
1780 sata_pkt_txlate_t *spx =
1781 (sata_pkt_txlate_t *)sata_pkt->satapkt_framework_private;
1782
1783 ASSERT(sata_pkt != NULL);
1784
1785 sata_free_local_buffer(spx);
1786 sata_pkt_free(spx);
1787 kmem_free(spx, sizeof (sata_pkt_txlate_t));
1788
1789 }
1790
1791 /*
1792 * Create READ PORT MULTIPLIER and WRITE PORT MULTIPLIER sata packet
1793 *
1794 * No association with any scsi packet is made and no callback routine is
1795 * specified.
1796 *
1797 * Returns a pointer to sata packet upon successful packet creation.
1798 * Returns NULL, if packet cannot be created.
1799 *
1800 * NOTE: Input/Output value includes 64 bits accoring to SATA Spec 2.6,
1801 * only lower 32 bits are available currently.
1802 */
1803 sata_pkt_t *
1804 sata_get_rdwr_pmult_pkt(dev_info_t *dip, sata_device_t *sd,
1805 uint8_t regn, uint32_t regv, uint32_t type)
1806 {
1807 sata_hba_inst_t *sata_hba_inst;
1808 sata_pkt_txlate_t *spx;
1809 sata_pkt_t *spkt;
1810 sata_cmd_t *scmd;
1811
1812 /* Only READ/WRITE commands are accepted. */
1813 ASSERT(type == SATA_RDWR_PMULT_PKT_TYPE_READ ||
1814 type == SATA_RDWR_PMULT_PKT_TYPE_WRITE);
1815
1816 mutex_enter(&sata_mutex);
1817 for (sata_hba_inst = sata_hba_list; sata_hba_inst != NULL;
1818 sata_hba_inst = sata_hba_inst->satahba_next) {
1819 if (SATA_DIP(sata_hba_inst) == dip)
1820 break;
1821 }
1822 mutex_exit(&sata_mutex);
1823 ASSERT(sata_hba_inst != NULL);
1824
1825 spx = kmem_zalloc(sizeof (sata_pkt_txlate_t), KM_SLEEP);
1826 spx->txlt_sata_hba_inst = sata_hba_inst;
1827 spx->txlt_scsi_pkt = NULL; /* No scsi pkt involved */
1828 spkt = sata_pkt_alloc(spx, SLEEP_FUNC);
1829 if (spkt == NULL) {
1830 kmem_free(spx, sizeof (sata_pkt_txlate_t));
1831 return (NULL);
1832 }
1833
1834 /*
1835 * NOTE: We need to send this command to the port multiplier,
1836 * that means send to SATA_PMULT_HOSTPORT(0xf) pmport
1837 *
1838 * sata_device contains the address of actual target device, and the
1839 * pmport number in the command comes from the sata_device structure.
1840 */
1841 spkt->satapkt_device.satadev_addr = sd->satadev_addr;
1842 spkt->satapkt_device.satadev_addr.pmport = SATA_PMULT_HOSTPORT;
1843 spkt->satapkt_device.satadev_addr.qual = SATA_ADDR_PMULT;
1844
1845 /* Fill sata_pkt */
1846 spkt->satapkt_op_mode = SATA_OPMODE_SYNCH | SATA_OPMODE_POLLING;
1847 spkt->satapkt_comp = NULL; /* Synchronous mode, no callback */
1848 spkt->satapkt_time = 10; /* Timeout 10s */
1849
1850 /* Build READ PORT MULTIPLIER cmd in the sata_pkt */
1851 scmd = &spkt->satapkt_cmd;
1852 scmd->satacmd_features_reg = regn & 0xff;
1853 scmd->satacmd_features_reg_ext = (regn >> 8) & 0xff;
1854 scmd->satacmd_device_reg = sd->satadev_addr.pmport;
1855 scmd->satacmd_addr_type = 0; /* N/A */
1856
1857 scmd->satacmd_flags.sata_ignore_dev_reset = B_TRUE;
1858
1859 if (type == SATA_RDWR_PMULT_PKT_TYPE_READ) {
1860 scmd->satacmd_cmd_reg = SATAC_READ_PORTMULT;
1861 scmd->satacmd_flags.sata_data_direction = SATA_DIR_READ;
1862 scmd->satacmd_flags.sata_special_regs = 1;
1863 scmd->satacmd_flags.sata_copy_out_lba_high_lsb = 1;
1864 scmd->satacmd_flags.sata_copy_out_lba_mid_lsb = 1;
1865 scmd->satacmd_flags.sata_copy_out_lba_low_lsb = 1;
1866 scmd->satacmd_flags.sata_copy_out_sec_count_lsb = 1;
1867 } else if (type == SATA_RDWR_PMULT_PKT_TYPE_WRITE) {
1868 scmd->satacmd_cmd_reg = SATAC_WRITE_PORTMULT;
1869 scmd->satacmd_flags.sata_data_direction = SATA_DIR_WRITE;
1870 scmd->satacmd_sec_count_lsb = regv & 0xff;
1871 scmd->satacmd_lba_low_lsb = regv >> 8 & 0xff;
1872 scmd->satacmd_lba_mid_lsb = regv >> 16 & 0xff;
1873 scmd->satacmd_lba_high_lsb = regv >> 24 & 0xff;
1874 }
1875
1876 return (spkt);
1877 }
1878
1879 /*
1880 * Free sata packet and any associated resources allocated previously by
1881 * sata_get_rdwr_pmult_pkt().
1882 *
1883 * Void return.
1884 */
1885 void
1886 sata_free_rdwr_pmult_pkt(sata_pkt_t *sata_pkt)
1887 {
1888 sata_pkt_txlate_t *spx =
1889 (sata_pkt_txlate_t *)sata_pkt->satapkt_framework_private;
1890
1891 /* Free allocated resources */
1892 sata_pkt_free(spx);
1893 kmem_free(spx, sizeof (sata_pkt_txlate_t));
1894 }
1895
1896 /*
1897 * Register a port multiplier to framework.
1898 * 1) Store the GSCR values in the previous allocated pmult_info strctures.
1899 * 2) Search in the blacklist and update the number of the device ports of the
1900 * port multiplier.
1901 *
1902 * Void return.
1903 */
1904 void
1905 sata_register_pmult(dev_info_t *dip, sata_device_t *sd, sata_pmult_gscr_t *sg)
1906 {
1907 sata_hba_inst_t *sata_hba_inst = NULL;
1908 sata_pmult_info_t *pmultinfo;
1909 sata_pmult_bl_t *blp;
1910 int cport = sd->satadev_addr.cport;
1911
1912 mutex_enter(&sata_mutex);
1913 for (sata_hba_inst = sata_hba_list; sata_hba_inst != NULL;
1914 sata_hba_inst = sata_hba_inst->satahba_next) {
1915 if (SATA_DIP(sata_hba_inst) == dip)
1916 if (sata_hba_inst->satahba_attached == 1)
1917 break;
1918 }
1919 mutex_exit(&sata_mutex);
1920 /* HBA not attached? */
1921 if (sata_hba_inst == NULL)
1922 return;
1923
1924 /* Number of pmports */
1925 sd->satadev_add_info = sg->gscr2 & SATA_PMULT_PORTNUM_MASK;
1926
1927 /* Check the blacklist */
1928 for (blp = sata_pmult_blacklist; blp->bl_gscr0; blp++) {
1929 if (sg->gscr0 != blp->bl_gscr0 && blp->bl_gscr0)
1930 continue;
1931 if (sg->gscr1 != blp->bl_gscr1 && blp->bl_gscr1)
1932 continue;
1933 if (sg->gscr2 != blp->bl_gscr2 && blp->bl_gscr2)
1934 continue;
1935
1936 cmn_err(CE_WARN, "!Port multiplier is on the blacklist.");
1937 sd->satadev_add_info = blp->bl_flags;
1938 break;
1939 }
1940
1941 /* Register the port multiplier GSCR */
1942 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, cport)));
1943 pmultinfo = SATA_PMULT_INFO(sata_hba_inst, cport);
1944 if (pmultinfo != NULL) {
1945 pmultinfo->pmult_gscr = *sg;
1946 pmultinfo->pmult_num_dev_ports =
1947 sd->satadev_add_info & SATA_PMULT_PORTNUM_MASK;
1948 SATADBG1(SATA_DBG_PMULT, sata_hba_inst,
1949 "Port multiplier registered at port %d", cport);
1950 }
1951 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, cport)));
1952 }
1953
1954 /*
1955 * sata_split_model splits the model ID into vendor and product IDs.
1956 * It assumes that a vendor ID cannot be longer than 8 characters, and
1957 * that vendor and product ID are separated by a whitespace.
1958 */
1959 void
1960 sata_split_model(char *model, char **vendor, char **product)
1961 {
1962 int i, modlen;
1963 char *vid, *pid;
1964
1965 /*
1966 * remove whitespace at the end of model
1967 */
1968 for (i = SATA_ID_MODEL_LEN; i > 0; i--)
1969 if (model[i] == ' ' || model[i] == '\t' || model[i] == '\0')
1970 model[i] = '\0';
1971 else
1972 break;
1973
1974 /*
1975 * try to split model into into vid/pid
1976 */
1977 modlen = strlen(model);
1978 for (i = 0, pid = model; i < modlen; i++, pid++)
1979 if ((*pid == ' ') || (*pid == '\t'))
1980 break;
1981
1982 /*
1983 * only use vid if it is less than 8 chars (as in SCSI)
1984 */
1985 if (i < modlen && i <= 8) {
1986 vid = model;
1987 /*
1988 * terminate vid, establish pid
1989 */
1990 *pid++ = '\0';
1991 } else {
1992 /*
1993 * vid will stay "ATA "
1994 */
1995 vid = NULL;
1996 /*
1997 * model is all pid
1998 */
1999 pid = model;
2000 }
2001
2002 *vendor = vid;
2003 *product = pid;
2004 }
2005
2006 /*
2007 * sata_name_child is for composing the name of the node
2008 * the format of the name is "target,0".
2009 */
2010 static int
2011 sata_name_child(dev_info_t *dip, char *name, int namelen)
2012 {
2013 int target;
2014
2015 target = ddi_prop_get_int(DDI_DEV_T_ANY, dip,
2016 DDI_PROP_DONTPASS, "target", -1);
2017 if (target == -1)
2018 return (DDI_FAILURE);
2019 (void) snprintf(name, namelen, "%x,0", target);
2020 return (DDI_SUCCESS);
2021 }
2022
2023
2024
2025 /* ****************** SCSA required entry points *********************** */
2026
2027 /*
2028 * Implementation of scsi tran_tgt_init.
2029 * sata_scsi_tgt_init() initializes scsi_device structure
2030 *
2031 * If successful, DDI_SUCCESS is returned.
2032 * DDI_FAILURE is returned if addressed device does not exist
2033 */
2034
2035 static int
2036 sata_scsi_tgt_init(dev_info_t *hba_dip, dev_info_t *tgt_dip,
2037 scsi_hba_tran_t *hba_tran, struct scsi_device *sd)
2038 {
2039 #ifndef __lock_lint
2040 _NOTE(ARGUNUSED(hba_dip))
2041 _NOTE(ARGUNUSED(tgt_dip))
2042 #endif
2043 sata_device_t sata_device;
2044 sata_drive_info_t *sdinfo;
2045 struct sata_id *sid;
2046 sata_hba_inst_t *sata_hba_inst;
2047 char model[SATA_ID_MODEL_LEN + 1];
2048 char fw[SATA_ID_FW_LEN + 1];
2049 char *vid, *pid;
2050
2051 /*
2052 * Fail tran_tgt_init for .conf stub node
2053 */
2054 if (ndi_dev_is_persistent_node(tgt_dip) == 0) {
2055 (void) ndi_merge_node(tgt_dip, sata_name_child);
2056 ddi_set_name_addr(tgt_dip, NULL);
2057 return (DDI_FAILURE);
2058 }
2059
2060 sata_hba_inst = (sata_hba_inst_t *)(hba_tran->tran_hba_private);
2061
2062 /* Validate scsi device address */
2063 if (sata_validate_scsi_address(sata_hba_inst, &sd->sd_address,
2064 &sata_device) != 0)
2065 return (DDI_FAILURE);
2066
2067 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst,
2068 sata_device.satadev_addr.cport)));
2069
2070 /* sata_device now contains a valid sata address */
2071 sdinfo = sata_get_device_info(sata_hba_inst, &sata_device);
2072 if (sdinfo == NULL) {
2073 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst,
2074 sata_device.satadev_addr.cport)));
2075 return (DDI_FAILURE);
2076 }
2077 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst,
2078 sata_device.satadev_addr.cport)));
2079
2080 /*
2081 * Check if we need to create a legacy devid (i.e cmdk style) for
2082 * the target disks.
2083 *
2084 * HBA devinfo node will have the property "use-cmdk-devid-format"
2085 * if we need to create cmdk-style devid for all the disk devices
2086 * attached to this controller. This property may have been set
2087 * from HBA driver's .conf file or by the HBA driver in its
2088 * attach(9F) function.
2089 */
2090 if ((sdinfo->satadrv_type == SATA_DTYPE_ATADISK) &&
2091 (ddi_getprop(DDI_DEV_T_ANY, hba_dip, DDI_PROP_DONTPASS,
2092 "use-cmdk-devid-format", 0) == 1)) {
2093 /* register a legacy devid for this target node */
2094 sata_target_devid_register(tgt_dip, sdinfo);
2095 }
2096
2097
2098 /*
2099 * 'Identify Device Data' does not always fit in standard SCSI
2100 * INQUIRY data, so establish INQUIRY_* properties with full-form
2101 * of information.
2102 */
2103 sid = &sdinfo->satadrv_id;
2104 #ifdef _LITTLE_ENDIAN
2105 swab(sid->ai_model, model, SATA_ID_MODEL_LEN);
2106 swab(sid->ai_fw, fw, SATA_ID_FW_LEN);
2107 #else /* _LITTLE_ENDIAN */
2108 bcopy(sid->ai_model, model, SATA_ID_MODEL_LEN);
2109 bcopy(sid->ai_fw, fw, SATA_ID_FW_LEN);
2110 #endif /* _LITTLE_ENDIAN */
2111 model[SATA_ID_MODEL_LEN] = 0;
2112 fw[SATA_ID_FW_LEN] = 0;
2113
2114 sata_split_model(model, &vid, &pid);
2115
2116 if (vid)
2117 (void) scsi_device_prop_update_inqstring(sd, INQUIRY_VENDOR_ID,
2118 vid, strlen(vid));
2119 if (pid)
2120 (void) scsi_device_prop_update_inqstring(sd, INQUIRY_PRODUCT_ID,
2121 pid, strlen(pid));
2122 (void) scsi_device_prop_update_inqstring(sd, INQUIRY_REVISION_ID,
2123 fw, strlen(fw));
2124
2125 return (DDI_SUCCESS);
2126 }
2127
2128 /*
2129 * Implementation of scsi tran_tgt_probe.
2130 * Probe target, by calling default scsi routine scsi_hba_probe()
2131 */
2132 static int
2133 sata_scsi_tgt_probe(struct scsi_device *sd, int (*callback)(void))
2134 {
2135 sata_hba_inst_t *sata_hba_inst =
2136 (sata_hba_inst_t *)(sd->sd_address.a_hba_tran->tran_hba_private);
2137 int rval;
2138 uint32_t pm_cap;
2139
2140 rval = scsi_hba_probe(sd, callback);
2141 pm_cap = SATA_CAP_POWER_CONDITON | SATA_CAP_SMART_PAGE |
2142 SATA_CAP_LOG_SENSE;
2143
2144 if (rval == SCSIPROBE_EXISTS) {
2145 /*
2146 * Set property "pm-capable" on the target device node, so that
2147 * the target driver will not try to fetch scsi cycle counters
2148 * before enabling device power-management.
2149 */
2150 if ((ddi_prop_update_int(DDI_DEV_T_NONE, sd->sd_dev,
2151 "pm-capable", pm_cap)) != DDI_PROP_SUCCESS) {
2152 sata_log(sata_hba_inst, CE_WARN,
2153 "SATA device at port %d: "
2154 "will not be power-managed ",
2155 SCSI_TO_SATA_CPORT(sd->sd_address.a_target));
2156 SATA_LOG_D((sata_hba_inst, CE_WARN,
2157 "failure updating pm-capable property"));
2158 }
2159 }
2160 return (rval);
2161 }
2162
2163 /*
2164 * Implementation of scsi tran_tgt_free.
2165 * Release all resources allocated for scsi_device
2166 */
2167 static void
2168 sata_scsi_tgt_free(dev_info_t *hba_dip, dev_info_t *tgt_dip,
2169 scsi_hba_tran_t *hba_tran, struct scsi_device *sd)
2170 {
2171 #ifndef __lock_lint
2172 _NOTE(ARGUNUSED(hba_dip))
2173 #endif
2174 sata_device_t sata_device;
2175 sata_drive_info_t *sdinfo;
2176 sata_hba_inst_t *sata_hba_inst;
2177 ddi_devid_t devid;
2178
2179 sata_hba_inst = (sata_hba_inst_t *)(hba_tran->tran_hba_private);
2180
2181 /* Validate scsi device address */
2182 /*
2183 * Note: tgt_free relates to the SCSA view of a device. If called, there
2184 * was a device at this address, so even if the sata framework internal
2185 * resources were alredy released because a device was detached,
2186 * this function should be executed as long as its actions do
2187 * not require the internal sata view of a device and the address
2188 * refers to a valid sata address.
2189 * Validating the address here means that we do not trust SCSA...
2190 */
2191 if (sata_validate_scsi_address(sata_hba_inst, &sd->sd_address,
2192 &sata_device) == -1)
2193 return;
2194
2195 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst,
2196 sata_device.satadev_addr.cport)));
2197
2198 /* sata_device now should contain a valid sata address */
2199 sdinfo = sata_get_device_info(sata_hba_inst, &sata_device);
2200 if (sdinfo == NULL) {
2201 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst,
2202 sata_device.satadev_addr.cport)));
2203 return;
2204 }
2205 /*
2206 * We did not allocate any resources in sata_scsi_tgt_init()
2207 * other than few properties.
2208 * Free them.
2209 */
2210 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst,
2211 sata_device.satadev_addr.cport)));
2212 (void) ndi_prop_remove(DDI_DEV_T_NONE, tgt_dip, "pm-capable");
2213
2214 /*
2215 * If devid was previously created but not freed up from
2216 * sd(7D) driver (i.e during detach(9F)) then do it here.
2217 */
2218 if ((sdinfo->satadrv_type == SATA_DTYPE_ATADISK) &&
2219 (ddi_getprop(DDI_DEV_T_ANY, hba_dip, DDI_PROP_DONTPASS,
2220 "use-cmdk-devid-format", 0) == 1) &&
2221 (ddi_devid_get(tgt_dip, &devid) == DDI_SUCCESS)) {
2222 ddi_devid_unregister(tgt_dip);
2223 ddi_devid_free(devid);
2224 }
2225 }
2226
2227 /*
2228 * Implementation of scsi tran_init_pkt
2229 * Upon successful return, scsi pkt buffer has DMA resources allocated.
2230 *
2231 * It seems that we should always allocate pkt, even if the address is
2232 * for non-existing device - just use some default for dma_attr.
2233 * The reason is that there is no way to communicate this to a caller here.
2234 * Subsequent call to sata_scsi_start may fail appropriately.
2235 * Simply returning NULL does not seem to discourage a target driver...
2236 *
2237 * Returns a pointer to initialized scsi_pkt, or NULL otherwise.
2238 */
2239 static struct scsi_pkt *
2240 sata_scsi_init_pkt(struct scsi_address *ap, struct scsi_pkt *pkt,
2241 struct buf *bp, int cmdlen, int statuslen, int tgtlen, int flags,
2242 int (*callback)(caddr_t), caddr_t arg)
2243 {
2244 sata_hba_inst_t *sata_hba_inst =
2245 (sata_hba_inst_t *)(ap->a_hba_tran->tran_hba_private);
2246 dev_info_t *dip = SATA_DIP(sata_hba_inst);
2247 sata_device_t sata_device;
2248 sata_drive_info_t *sdinfo;
2249 sata_pkt_txlate_t *spx;
2250 ddi_dma_attr_t cur_dma_attr;
2251 int rval;
2252 boolean_t new_pkt = B_TRUE;
2253
2254 ASSERT(ap->a_hba_tran->tran_hba_dip == dip);
2255
2256 /*
2257 * We need to translate the address, even if it could be
2258 * a bogus one, for a non-existing device
2259 */
2260 sata_device.satadev_addr.qual = SCSI_TO_SATA_ADDR_QUAL(ap->a_target);
2261 sata_device.satadev_addr.cport = SCSI_TO_SATA_CPORT(ap->a_target);
2262 sata_device.satadev_addr.pmport = SCSI_TO_SATA_PMPORT(ap->a_target);
2263 sata_device.satadev_rev = SATA_DEVICE_REV;
2264
2265 if (pkt == NULL) {
2266 /*
2267 * Have to allocate a brand new scsi packet.
2268 * We need to operate with auto request sense enabled.
2269 */
2270 pkt = scsi_hba_pkt_alloc(dip, ap, cmdlen,
2271 MAX(statuslen, SATA_MAX_SENSE_LEN),
2272 tgtlen, sizeof (sata_pkt_txlate_t), callback, arg);
2273
2274 if (pkt == NULL)
2275 return (NULL);
2276
2277 /* Fill scsi packet structure */
2278 pkt->pkt_comp = (void (*)())NULL;
2279 pkt->pkt_time = 0;
2280 pkt->pkt_resid = 0;
2281 pkt->pkt_statistics = 0;
2282 pkt->pkt_reason = 0;
2283
2284 /*
2285 * pkt_hba_private will point to sata pkt txlate structure
2286 */
2287 spx = (sata_pkt_txlate_t *)pkt->pkt_ha_private;
2288 bzero(spx, sizeof (sata_pkt_txlate_t));
2289
2290 spx->txlt_scsi_pkt = pkt;
2291 spx->txlt_sata_hba_inst = sata_hba_inst;
2292
2293 /* Allocate sata_pkt */
2294 spx->txlt_sata_pkt = sata_pkt_alloc(spx, callback);
2295 if (spx->txlt_sata_pkt == NULL) {
2296 /* Could not allocate sata pkt */
2297 scsi_hba_pkt_free(ap, pkt);
2298 return (NULL);
2299 }
2300 /* Set sata address */
2301 spx->txlt_sata_pkt->satapkt_device.satadev_addr =
2302 sata_device.satadev_addr;
2303 spx->txlt_sata_pkt->satapkt_device.satadev_rev =
2304 sata_device.satadev_rev;
2305
2306 if ((bp == NULL) || (bp->b_bcount == 0))
2307 return (pkt);
2308
2309 spx->txlt_total_residue = bp->b_bcount;
2310 } else {
2311 new_pkt = B_FALSE;
2312 /*
2313 * Packet was preallocated/initialized by previous call
2314 */
2315 spx = (sata_pkt_txlate_t *)pkt->pkt_ha_private;
2316
2317 if ((bp == NULL) || (bp->b_bcount == 0)) {
2318 return (pkt);
2319 }
2320
2321 /* Pkt is available already: spx->txlt_scsi_pkt == pkt; */
2322 }
2323
2324 spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp = bp;
2325
2326 /*
2327 * We use an adjusted version of the dma_attr, to account
2328 * for device addressing limitations.
2329 * sata_adjust_dma_attr() will handle sdinfo == NULL which may
2330 * happen when a device is not yet configured.
2331 */
2332 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst,
2333 sata_device.satadev_addr.cport)));
2334 sdinfo = sata_get_device_info(spx->txlt_sata_hba_inst,
2335 &spx->txlt_sata_pkt->satapkt_device);
2336 /* NULL sdinfo may be passsed to sata_adjust_dma_attr() */
2337 sata_adjust_dma_attr(sdinfo,
2338 SATA_DMA_ATTR(spx->txlt_sata_hba_inst), &cur_dma_attr);
2339 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst,
2340 sata_device.satadev_addr.cport)));
2341 /*
2342 * Allocate necessary DMA resources for the packet's data buffer
2343 * NOTE:
2344 * In case of read/write commands, DMA resource allocation here is
2345 * based on the premise that the transfer length specified in
2346 * the read/write scsi cdb will match exactly DMA resources -
2347 * returning correct packet residue is crucial.
2348 */
2349 if ((rval = sata_dma_buf_setup(spx, flags, callback, arg,
2350 &cur_dma_attr)) != DDI_SUCCESS) {
2351 /*
2352 * If a DMA allocation request fails with
2353 * DDI_DMA_NOMAPPING, indicate the error by calling
2354 * bioerror(9F) with bp and an error code of EFAULT.
2355 * If a DMA allocation request fails with
2356 * DDI_DMA_TOOBIG, indicate the error by calling
2357 * bioerror(9F) with bp and an error code of EINVAL.
2358 * For DDI_DMA_NORESOURCES, we may have some of them allocated.
2359 * Request may be repeated later - there is no real error.
2360 */
2361 switch (rval) {
2362 case DDI_DMA_NORESOURCES:
2363 bioerror(bp, 0);
2364 break;
2365 case DDI_DMA_NOMAPPING:
2366 case DDI_DMA_BADATTR:
2367 bioerror(bp, EFAULT);
2368 break;
2369 case DDI_DMA_TOOBIG:
2370 default:
2371 bioerror(bp, EINVAL);
2372 break;
2373 }
2374 goto fail;
2375 }
2376
2377 if (sata_check_for_dma_error(dip, spx)) {
2378 ddi_fm_service_impact(dip, DDI_SERVICE_UNAFFECTED);
2379 bioerror(bp, EFAULT);
2380 goto fail;
2381 }
2382
2383 success:
2384 /* Set number of bytes that are not yet accounted for */
2385 pkt->pkt_resid = spx->txlt_total_residue;
2386 ASSERT(pkt->pkt_resid >= 0);
2387
2388 return (pkt);
2389
2390 fail:
2391 if (new_pkt == B_TRUE) {
2392 /*
2393 * Since this is a new packet, we can clean-up
2394 * everything
2395 */
2396 sata_scsi_destroy_pkt(ap, pkt);
2397 } else {
2398 /*
2399 * This is a re-used packet. It will be target driver's
2400 * responsibility to eventually destroy it (which
2401 * will free allocated resources).
2402 * Here, we just "complete" the request, leaving
2403 * allocated resources intact, so the request may
2404 * be retried.
2405 */
2406 spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp = NULL;
2407 sata_pkt_free(spx);
2408 }
2409 return (NULL);
2410 }
2411
2412 /*
2413 * Implementation of scsi tran_start.
2414 * Translate scsi cmd into sata operation and return status.
2415 * ATAPI CDBs are passed to ATAPI devices - the device determines what commands
2416 * are supported.
2417 * For SATA hard disks, supported scsi commands:
2418 * SCMD_INQUIRY
2419 * SCMD_TEST_UNIT_READY
2420 * SCMD_START_STOP
2421 * SCMD_READ_CAPACITY
2422 * SCMD_SVC_ACTION_IN_G4 (READ CAPACITY (16))
2423 * SCMD_REQUEST_SENSE
2424 * SCMD_LOG_SENSE_G1
2425 * SCMD_LOG_SELECT_G1
2426 * SCMD_MODE_SENSE (specific pages)
2427 * SCMD_MODE_SENSE_G1 (specific pages)
2428 * SCMD_MODE_SELECT (specific pages)
2429 * SCMD_MODE_SELECT_G1 (specific pages)
2430 * SCMD_SYNCHRONIZE_CACHE
2431 * SCMD_SYNCHRONIZE_CACHE_G1
2432 * SCMD_READ
2433 * SCMD_READ_G1
2434 * SCMD_READ_G4
2435 * SCMD_READ_G5
2436 * SCMD_WRITE
2437 * SCMD_WRITE_BUFFER
2438 * SCMD_WRITE_G1
2439 * SCMD_WRITE_G4
2440 * SCMD_WRITE_G5
2441 * SCMD_SEEK (noop)
2442 * SCMD_SDIAG
2443 *
2444 * All other commands are rejected as unsupported.
2445 *
2446 * Returns:
2447 * TRAN_ACCEPT if command was executed successfully or accepted by HBA driver
2448 * for execution. TRAN_ACCEPT may be returned also if device was removed but
2449 * a callback could be scheduled.
2450 * TRAN_BADPKT if cmd was directed to invalid address.
2451 * TRAN_FATAL_ERROR is command was rejected due to hardware error, including
2452 * some unspecified error. TRAN_FATAL_ERROR may be also returned if a device
2453 * was removed and there was no callback specified in scsi pkt.
2454 * TRAN_BUSY if command could not be executed becasue HBA driver or SATA
2455 * framework was busy performing some other operation(s).
2456 *
2457 */
2458 static int
2459 sata_scsi_start(struct scsi_address *ap, struct scsi_pkt *pkt)
2460 {
2461 sata_hba_inst_t *sata_hba_inst =
2462 (sata_hba_inst_t *)(ap->a_hba_tran->tran_hba_private);
2463 sata_pkt_txlate_t *spx = (sata_pkt_txlate_t *)pkt->pkt_ha_private;
2464 sata_device_t *sdevice = &spx->txlt_sata_pkt->satapkt_device;
2465 sata_drive_info_t *sdinfo;
2466 struct buf *bp;
2467 uint8_t cport, pmport;
2468 boolean_t dev_gone = B_FALSE;
2469 int rval;
2470
2471 SATADBG1(SATA_DBG_SCSI_IF, sata_hba_inst,
2472 "sata_scsi_start: cmd 0x%02x\n", pkt->pkt_cdbp[0]);
2473
2474 ASSERT(spx != NULL &&
2475 spx->txlt_scsi_pkt == pkt && spx->txlt_sata_pkt != NULL);
2476
2477 cport = SCSI_TO_SATA_CPORT(ap->a_target);
2478 pmport = SCSI_TO_SATA_PMPORT(ap->a_target);
2479
2480 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, cport)));
2481
2482 if (sdevice->satadev_addr.qual == SATA_ADDR_DCPORT) {
2483 sdinfo = sata_get_device_info(sata_hba_inst, sdevice);
2484 if (sdinfo == NULL ||
2485 SATA_CPORT_INFO(sata_hba_inst, cport)->
2486 cport_tgtnode_clean == B_FALSE ||
2487 (sdinfo->satadrv_state & SATA_DSTATE_FAILED) != 0) {
2488 dev_gone = B_TRUE;
2489 }
2490 } else if (sdevice->satadev_addr.qual == SATA_ADDR_DPMPORT) {
2491 if (SATA_CPORT_DEV_TYPE(sata_hba_inst, cport) !=
2492 SATA_DTYPE_PMULT || SATA_PMULT_INFO(sata_hba_inst,
2493 cport) == NULL) {
2494 dev_gone = B_TRUE;
2495 } else if (SATA_PMPORT_INFO(sata_hba_inst, cport,
2496 pmport) == NULL) {
2497 dev_gone = B_TRUE;
2498 } else {
2499 mutex_enter(&(SATA_PMPORT_MUTEX(sata_hba_inst,
2500 cport, pmport)));
2501 sdinfo = sata_get_device_info(sata_hba_inst, sdevice);
2502 if (sdinfo == NULL ||
2503 SATA_PMPORT_INFO(sata_hba_inst, cport, pmport)->
2504 pmport_tgtnode_clean == B_FALSE ||
2505 (sdinfo->satadrv_state & SATA_DSTATE_FAILED) != 0) {
2506 dev_gone = B_TRUE;
2507 }
2508 mutex_exit(&(SATA_PMPORT_MUTEX(sata_hba_inst,
2509 cport, pmport)));
2510 }
2511 }
2512
2513 if (dev_gone == B_TRUE) {
2514 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, cport)));
2515 pkt->pkt_reason = CMD_DEV_GONE;
2516 /*
2517 * The sd target driver is checking CMD_DEV_GONE pkt_reason
2518 * only in callback function (for normal requests) and
2519 * in the dump code path.
2520 * So, if the callback is available, we need to do
2521 * the callback rather than returning TRAN_FATAL_ERROR here.
2522 */
2523 if (pkt->pkt_comp != NULL) {
2524 /* scsi callback required */
2525 if (servicing_interrupt()) {
2526 if (taskq_dispatch(SATA_TXLT_TASKQ(spx),
2527 (task_func_t *)spx->txlt_scsi_pkt->pkt_comp,
2528 (void *)spx->txlt_scsi_pkt, TQ_NOSLEEP) ==
2529 NULL) {
2530 return (TRAN_BUSY);
2531 }
2532 } else if (taskq_dispatch(SATA_TXLT_TASKQ(spx),
2533 (task_func_t *)spx->txlt_scsi_pkt->pkt_comp,
2534 (void *)spx->txlt_scsi_pkt, TQ_SLEEP) == NULL) {
2535 /* Scheduling the callback failed */
2536 return (TRAN_BUSY);
2537 }
2538 return (TRAN_ACCEPT);
2539 }
2540 /* No callback available */
2541 return (TRAN_FATAL_ERROR);
2542 }
2543
2544 if (sdinfo->satadrv_type & SATA_DTYPE_ATAPI) {
2545 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, cport)));
2546 rval = sata_txlt_atapi(spx);
2547 SATADBG1(SATA_DBG_SCSI_IF, sata_hba_inst,
2548 "sata_scsi_start atapi: rval %d\n", rval);
2549 return (rval);
2550 }
2551 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, cport)));
2552
2553 /*
2554 * Checking for power state, if it was on
2555 * STOPPED state, then the drive is not capable
2556 * of processing media access command. And
2557 * TEST_UNIT_READY, REQUEST_SENSE has special handling
2558 * in the function for different power state.
2559 */
2560 if (((sdinfo->satadrv_power_level == SATA_POWER_STANDBY) ||
2561 (sdinfo->satadrv_power_level == SATA_POWER_STOPPED)) &&
2562 (SATA_IS_MEDIUM_ACCESS_CMD(pkt->pkt_cdbp[0]))) {
2563 return (sata_txlt_check_condition(spx, KEY_NOT_READY,
2564 SD_SCSI_ASC_LU_NOT_READY));
2565 }
2566
2567 /* ATA Disk commands processing starts here */
2568
2569 bp = spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp;
2570
2571 switch (pkt->pkt_cdbp[0]) {
2572
2573 case SCMD_INQUIRY:
2574 /* Mapped to identify device */
2575 if (bp != NULL && (bp->b_flags & (B_PHYS | B_PAGEIO)))
2576 bp_mapin(bp);
2577 rval = sata_txlt_inquiry(spx);
2578 break;
2579
2580 case SCMD_TEST_UNIT_READY:
2581 /*
2582 * SAT "SATA to ATA Translation" doc specifies translation
2583 * to ATA CHECK POWER MODE.
2584 */
2585 rval = sata_txlt_test_unit_ready(spx);
2586 break;
2587
2588 case SCMD_START_STOP:
2589 /* Mapping depends on the command */
2590 rval = sata_txlt_start_stop_unit(spx);
2591 break;
2592
2593 case SCMD_READ_CAPACITY:
2594 if (bp != NULL && (bp->b_flags & (B_PHYS | B_PAGEIO)))
2595 bp_mapin(bp);
2596 rval = sata_txlt_read_capacity(spx);
2597 break;
2598
2599 case SCMD_SVC_ACTION_IN_G4: /* READ CAPACITY (16) */
2600 if (bp != NULL && (bp->b_flags & (B_PHYS | B_PAGEIO)))
2601 bp_mapin(bp);
2602 rval = sata_txlt_read_capacity16(spx);
2603 break;
2604
2605 case SCMD_REQUEST_SENSE:
2606 /*
2607 * Always No Sense, since we force ARQ
2608 */
2609 if (bp != NULL && (bp->b_flags & (B_PHYS | B_PAGEIO)))
2610 bp_mapin(bp);
2611 rval = sata_txlt_request_sense(spx);
2612 break;
2613
2614 case SCMD_LOG_SENSE_G1:
2615 if (bp != NULL && (bp->b_flags & (B_PHYS | B_PAGEIO)))
2616 bp_mapin(bp);
2617 rval = sata_txlt_log_sense(spx);
2618 break;
2619
2620 case SCMD_LOG_SELECT_G1:
2621 if (bp != NULL && (bp->b_flags & (B_PHYS | B_PAGEIO)))
2622 bp_mapin(bp);
2623 rval = sata_txlt_log_select(spx);
2624 break;
2625
2626 case SCMD_MODE_SENSE:
2627 case SCMD_MODE_SENSE_G1:
2628 if (bp != NULL && (bp->b_flags & (B_PHYS | B_PAGEIO)))
2629 bp_mapin(bp);
2630 rval = sata_txlt_mode_sense(spx);
2631 break;
2632
2633
2634 case SCMD_MODE_SELECT:
2635 case SCMD_MODE_SELECT_G1:
2636 if (bp != NULL && (bp->b_flags & (B_PHYS | B_PAGEIO)))
2637 bp_mapin(bp);
2638 rval = sata_txlt_mode_select(spx);
2639 break;
2640
2641 case SCMD_SYNCHRONIZE_CACHE:
2642 case SCMD_SYNCHRONIZE_CACHE_G1:
2643 rval = sata_txlt_synchronize_cache(spx);
2644 break;
2645
2646 case SCMD_READ:
2647 case SCMD_READ_G1:
2648 case SCMD_READ_G4:
2649 case SCMD_READ_G5:
2650 rval = sata_txlt_read(spx);
2651 break;
2652 case SCMD_WRITE_BUFFER:
2653 if (bp != NULL && (bp->b_flags & (B_PHYS | B_PAGEIO)))
2654 bp_mapin(bp);
2655 rval = sata_txlt_write_buffer(spx);
2656 break;
2657
2658 case SCMD_WRITE:
2659 case SCMD_WRITE_G1:
2660 case SCMD_WRITE_G4:
2661 case SCMD_WRITE_G5:
2662 rval = sata_txlt_write(spx);
2663 break;
2664
2665 case SCMD_SEEK:
2666 rval = sata_txlt_nodata_cmd_immediate(spx);
2667 break;
2668
2669 case SPC3_CMD_ATA_COMMAND_PASS_THROUGH12:
2670 case SPC3_CMD_ATA_COMMAND_PASS_THROUGH16:
2671 if (bp != NULL && (bp->b_flags & (B_PHYS | B_PAGEIO)))
2672 bp_mapin(bp);
2673 rval = sata_txlt_ata_pass_thru(spx);
2674 break;
2675
2676 /* Other cases will be filed later */
2677 /* postponed until phase 2 of the development */
2678 case SPC3_CMD_UNMAP:
2679 if (bp != NULL && (bp->b_flags & (B_PHYS | B_PAGEIO)))
2680 bp_mapin(bp);
2681 rval = sata_txlt_unmap(spx);
2682 break;
2683 default:
2684 rval = sata_txlt_invalid_command(spx);
2685 break;
2686 }
2687
2688 SATADBG1(SATA_DBG_SCSI_IF, sata_hba_inst,
2689 "sata_scsi_start: rval %d\n", rval);
2690
2691 return (rval);
2692 }
2693
2694 /*
2695 * Implementation of scsi tran_abort.
2696 * Abort specific pkt or all packets.
2697 *
2698 * Returns 1 if one or more packets were aborted, returns 0 otherwise
2699 *
2700 * May be called from an interrupt level.
2701 */
2702 static int
2703 sata_scsi_abort(struct scsi_address *ap, struct scsi_pkt *scsi_pkt)
2704 {
2705 sata_hba_inst_t *sata_hba_inst =
2706 (sata_hba_inst_t *)(ap->a_hba_tran->tran_hba_private);
2707 sata_device_t sata_device;
2708 sata_pkt_t *sata_pkt;
2709
2710 SATADBG2(SATA_DBG_SCSI_IF, sata_hba_inst,
2711 "sata_scsi_abort: %s at target: 0x%x\n",
2712 scsi_pkt == NULL ? "all packets" : "one pkt", ap->a_target);
2713
2714 /* Validate address */
2715 if (sata_validate_scsi_address(sata_hba_inst, ap, &sata_device) != 0)
2716 /* Invalid address */
2717 return (0);
2718
2719 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst,
2720 sata_device.satadev_addr.cport)));
2721 if (sata_get_device_info(sata_hba_inst, &sata_device) == NULL) {
2722 /* invalid address */
2723 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst,
2724 sata_device.satadev_addr.cport)));
2725 return (0);
2726 }
2727 if (scsi_pkt == NULL) {
2728 /*
2729 * Abort all packets.
2730 * Although we do not have specific packet, we still need
2731 * dummy packet structure to pass device address to HBA.
2732 * Allocate one, without sleeping. Fail if pkt cannot be
2733 * allocated.
2734 */
2735 sata_pkt = kmem_zalloc(sizeof (sata_pkt_t), KM_NOSLEEP);
2736 if (sata_pkt == NULL) {
2737 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst,
2738 sata_device.satadev_addr.cport)));
2739 SATA_LOG_D((sata_hba_inst, CE_WARN, "sata_pkt_abort: "
2740 "could not allocate sata_pkt"));
2741 return (0);
2742 }
2743 sata_pkt->satapkt_rev = SATA_PKT_REV;
2744 sata_pkt->satapkt_device = sata_device;
2745 sata_pkt->satapkt_device.satadev_rev = SATA_DEVICE_REV;
2746 } else {
2747 if (scsi_pkt->pkt_ha_private == NULL) {
2748 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst,
2749 sata_device.satadev_addr.cport)));
2750 return (0); /* Bad scsi pkt */
2751 }
2752 /* extract pointer to sata pkt */
2753 sata_pkt = ((sata_pkt_txlate_t *)scsi_pkt->pkt_ha_private)->
2754 txlt_sata_pkt;
2755 }
2756
2757 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst,
2758 sata_device.satadev_addr.cport)));
2759 /* Send abort request to HBA */
2760 if ((*SATA_ABORT_FUNC(sata_hba_inst))
2761 (SATA_DIP(sata_hba_inst), sata_pkt,
2762 scsi_pkt == NULL ? SATA_ABORT_ALL_PACKETS : SATA_ABORT_PACKET) ==
2763 SATA_SUCCESS) {
2764 if (scsi_pkt == NULL)
2765 kmem_free(sata_pkt, sizeof (sata_pkt_t));
2766 /* Success */
2767 return (1);
2768 }
2769 /* Else, something did not go right */
2770 if (scsi_pkt == NULL)
2771 kmem_free(sata_pkt, sizeof (sata_pkt_t));
2772 /* Failure */
2773 return (0);
2774 }
2775
2776
2777 /*
2778 * Implementation of scsi tran_reset.
2779 * RESET_ALL request is translated into port reset.
2780 * RESET_TARGET requests is translated into a device reset,
2781 * RESET_LUN request is accepted only for LUN 0 and translated into
2782 * device reset.
2783 * The target reset should cause all HBA active and queued packets to
2784 * be terminated and returned with pkt reason SATA_PKT_RESET prior to
2785 * the return. HBA should report reset event for the device.
2786 *
2787 * Returns 1 upon success, 0 upon failure.
2788 */
2789 static int
2790 sata_scsi_reset(struct scsi_address *ap, int level)
2791 {
2792 sata_hba_inst_t *sata_hba_inst =
2793 (sata_hba_inst_t *)(ap->a_hba_tran->tran_hba_private);
2794 sata_device_t sata_device;
2795 int val;
2796
2797 SATADBG2(SATA_DBG_SCSI_IF, sata_hba_inst,
2798 "sata_scsi_reset: level %d target: 0x%x\n",
2799 level, ap->a_target);
2800
2801 /* Validate address */
2802 val = sata_validate_scsi_address(sata_hba_inst, ap, &sata_device);
2803 if (val == -1)
2804 /* Invalid address */
2805 return (0);
2806
2807 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst,
2808 sata_device.satadev_addr.cport)));
2809 if (sata_get_device_info(sata_hba_inst, &sata_device) == NULL) {
2810 /* invalid address */
2811 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst,
2812 sata_device.satadev_addr.cport)));
2813 return (0);
2814 }
2815 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst,
2816 sata_device.satadev_addr.cport)));
2817 if (level == RESET_ALL) {
2818 /* port reset */
2819 if (sata_device.satadev_addr.qual == SATA_ADDR_DCPORT)
2820 sata_device.satadev_addr.qual = SATA_ADDR_CPORT;
2821 else
2822 sata_device.satadev_addr.qual = SATA_ADDR_PMPORT;
2823
2824 if ((*SATA_RESET_DPORT_FUNC(sata_hba_inst))
2825 (SATA_DIP(sata_hba_inst), &sata_device) == SATA_SUCCESS)
2826 return (1);
2827 else
2828 return (0);
2829
2830 } else if (val == 0 &&
2831 (level == RESET_TARGET || level == RESET_LUN)) {
2832 /* reset device (device attached) */
2833 if ((*SATA_RESET_DPORT_FUNC(sata_hba_inst))
2834 (SATA_DIP(sata_hba_inst), &sata_device) == SATA_SUCCESS)
2835 return (1);
2836 else
2837 return (0);
2838 }
2839 return (0);
2840 }
2841
2842
2843 /*
2844 * Implementation of scsi tran_getcap (get transport/device capabilities).
2845 * Supported capabilities for SATA hard disks:
2846 * auto-rqsense (always supported)
2847 * tagged-qing (supported if HBA supports it)
2848 * untagged-qing (could be supported if disk supports it, but because
2849 * caching behavior allowing untagged queuing actually
2850 * results in reduced performance. sd tries to throttle
2851 * back to only 3 outstanding commands, which may
2852 * work for real SCSI disks, but with read ahead
2853 * caching, having more than 1 outstanding command
2854 * results in cache thrashing.)
2855 * sector_size
2856 * dma_max
2857 * interconnect-type (INTERCONNECT_SATA)
2858 *
2859 * Supported capabilities for ATAPI CD/DVD devices:
2860 * auto-rqsense (always supported)
2861 * sector_size
2862 * dma_max
2863 * max-cdb-length
2864 * interconnect-type (INTERCONNECT_SATA)
2865 *
2866 * Supported capabilities for ATAPI TAPE devices:
2867 * auto-rqsense (always supported)
2868 * dma_max
2869 * max-cdb-length
2870 *
2871 * Supported capabilities for SATA ATAPI hard disks:
2872 * auto-rqsense (always supported)
2873 * interconnect-type (INTERCONNECT_SATA)
2874 * max-cdb-length
2875 *
2876 * Request for other capabilities is rejected as unsupported.
2877 *
2878 * Returns supported capability value, or -1 if capability is unsuppported or
2879 * the address is invalid - no device.
2880 */
2881
2882 static int
2883 sata_scsi_getcap(struct scsi_address *ap, char *cap, int whom)
2884 {
2885
2886 sata_hba_inst_t *sata_hba_inst =
2887 (sata_hba_inst_t *)(ap->a_hba_tran->tran_hba_private);
2888 sata_device_t sata_device;
2889 sata_drive_info_t *sdinfo;
2890 ddi_dma_attr_t adj_dma_attr;
2891 int rval;
2892
2893 SATADBG2(SATA_DBG_SCSI_IF, sata_hba_inst,
2894 "sata_scsi_getcap: target: 0x%x, cap: %s\n",
2895 ap->a_target, cap);
2896
2897 /*
2898 * We want to process the capabilities on per port granularity.
2899 * So, we are specifically restricting ourselves to whom != 0
2900 * to exclude the controller wide handling.
2901 */
2902 if (cap == NULL || whom == 0)
2903 return (-1);
2904
2905 if (sata_validate_scsi_address(sata_hba_inst, ap, &sata_device) != 0) {
2906 /* Invalid address */
2907 return (-1);
2908 }
2909 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst,
2910 sata_device.satadev_addr.cport)));
2911 if ((sdinfo = sata_get_device_info(sata_hba_inst, &sata_device)) ==
2912 NULL) {
2913 /* invalid address */
2914 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst,
2915 sata_device.satadev_addr.cport)));
2916 return (-1);
2917 }
2918
2919 switch (scsi_hba_lookup_capstr(cap)) {
2920 case SCSI_CAP_ARQ:
2921 rval = 1; /* ARQ supported, turned on */
2922 break;
2923
2924 case SCSI_CAP_SECTOR_SIZE:
2925 if (sdinfo->satadrv_type == SATA_DTYPE_ATADISK)
2926 rval = SATA_DISK_SECTOR_SIZE; /* fixed size */
2927 else if (sdinfo->satadrv_type == SATA_DTYPE_ATAPICD)
2928 rval = SATA_ATAPI_SECTOR_SIZE;
2929 else rval = -1;
2930 break;
2931
2932 /*
2933 * untagged queuing cause a performance inversion because of
2934 * the way sd operates. Because of this reason we do not
2935 * use it when available.
2936 */
2937 case SCSI_CAP_UNTAGGED_QING:
2938 if (sdinfo->satadrv_features_enabled &
2939 SATA_DEV_F_E_UNTAGGED_QING)
2940 rval = 1; /* Untagged queuing available */
2941 else
2942 rval = -1; /* Untagged queuing not available */
2943 break;
2944
2945 case SCSI_CAP_TAGGED_QING:
2946 if ((sdinfo->satadrv_features_enabled &
2947 SATA_DEV_F_E_TAGGED_QING) &&
2948 (sdinfo->satadrv_max_queue_depth > 1))
2949 rval = 1; /* Tagged queuing available */
2950 else
2951 rval = -1; /* Tagged queuing not available */
2952 break;
2953
2954 case SCSI_CAP_DMA_MAX:
2955 sata_adjust_dma_attr(sdinfo, SATA_DMA_ATTR(sata_hba_inst),
2956 &adj_dma_attr);
2957 rval = (int)adj_dma_attr.dma_attr_maxxfer;
2958 /* We rely on the fact that dma_attr_maxxfer < 0x80000000 */
2959 break;
2960
2961 case SCSI_CAP_INTERCONNECT_TYPE:
2962 rval = INTERCONNECT_SATA; /* SATA interconnect type */
2963 break;
2964
2965 case SCSI_CAP_CDB_LEN:
2966 if (sdinfo->satadrv_type & SATA_DTYPE_ATAPI)
2967 rval = sdinfo->satadrv_atapi_cdb_len;
2968 else
2969 rval = -1;
2970 break;
2971
2972 default:
2973 rval = -1;
2974 break;
2975 }
2976 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst,
2977 sata_device.satadev_addr.cport)));
2978 return (rval);
2979 }
2980
2981 /*
2982 * Implementation of scsi tran_setcap
2983 *
2984 * Only SCSI_CAP_UNTAGGED_QING and SCSI_CAP_TAGGED_QING are changeable.
2985 *
2986 */
2987 static int
2988 sata_scsi_setcap(struct scsi_address *ap, char *cap, int value, int whom)
2989 {
2990 sata_hba_inst_t *sata_hba_inst =
2991 (sata_hba_inst_t *)(ap->a_hba_tran->tran_hba_private);
2992 sata_device_t sata_device;
2993 sata_drive_info_t *sdinfo;
2994 int rval;
2995
2996 SATADBG2(SATA_DBG_SCSI_IF, sata_hba_inst,
2997 "sata_scsi_setcap: target: 0x%x, cap: %s\n", ap->a_target, cap);
2998
2999 /*
3000 * We want to process the capabilities on per port granularity.
3001 * So, we are specifically restricting ourselves to whom != 0
3002 * to exclude the controller wide handling.
3003 */
3004 if (cap == NULL || whom == 0) {
3005 return (-1);
3006 }
3007
3008 if (sata_validate_scsi_address(sata_hba_inst, ap, &sata_device) != 0) {
3009 /* Invalid address */
3010 return (-1);
3011 }
3012 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst,
3013 sata_device.satadev_addr.cport)));
3014 if ((sdinfo = sata_get_device_info(sata_hba_inst,
3015 &sata_device)) == NULL) {
3016 /* invalid address */
3017 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst,
3018 sata_device.satadev_addr.cport)));
3019 return (-1);
3020 }
3021 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst,
3022 sata_device.satadev_addr.cport)));
3023
3024 switch (scsi_hba_lookup_capstr(cap)) {
3025 case SCSI_CAP_ARQ:
3026 case SCSI_CAP_SECTOR_SIZE:
3027 case SCSI_CAP_DMA_MAX:
3028 case SCSI_CAP_INTERCONNECT_TYPE:
3029 rval = 0;
3030 break;
3031 case SCSI_CAP_UNTAGGED_QING:
3032 if (SATA_QDEPTH(sata_hba_inst) > 1) {
3033 rval = 1;
3034 if (value == 1) {
3035 sdinfo->satadrv_features_enabled |=
3036 SATA_DEV_F_E_UNTAGGED_QING;
3037 } else if (value == 0) {
3038 sdinfo->satadrv_features_enabled &=
3039 ~SATA_DEV_F_E_UNTAGGED_QING;
3040 } else {
3041 rval = -1;
3042 }
3043 } else {
3044 rval = 0;
3045 }
3046 break;
3047 case SCSI_CAP_TAGGED_QING:
3048 /* This can TCQ or NCQ */
3049 if (sata_func_enable & SATA_ENABLE_QUEUING &&
3050 ((sdinfo->satadrv_features_support & SATA_DEV_F_TCQ &&
3051 SATA_FEATURES(sata_hba_inst) & SATA_CTLF_QCMD) ||
3052 (sata_func_enable & SATA_ENABLE_NCQ &&
3053 sdinfo->satadrv_features_support & SATA_DEV_F_NCQ &&
3054 SATA_FEATURES(sata_hba_inst) & SATA_CTLF_NCQ)) &&
3055 (sdinfo->satadrv_max_queue_depth > 1)) {
3056 rval = 1;
3057 if (value == 1) {
3058 sdinfo->satadrv_features_enabled |=
3059 SATA_DEV_F_E_TAGGED_QING;
3060 } else if (value == 0) {
3061 sdinfo->satadrv_features_enabled &=
3062 ~SATA_DEV_F_E_TAGGED_QING;
3063 } else {
3064 rval = -1;
3065 }
3066 } else {
3067 rval = 0;
3068 }
3069 break;
3070 default:
3071 rval = -1;
3072 break;
3073 }
3074 return (rval);
3075 }
3076
3077 /*
3078 * Implementations of scsi tran_destroy_pkt.
3079 * Free resources allocated by sata_scsi_init_pkt()
3080 */
3081 static void
3082 sata_scsi_destroy_pkt(struct scsi_address *ap, struct scsi_pkt *pkt)
3083 {
3084 sata_pkt_txlate_t *spx;
3085
3086 spx = (sata_pkt_txlate_t *)pkt->pkt_ha_private;
3087
3088 sata_common_free_dma_rsrcs(spx);
3089
3090 spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp = NULL;
3091 sata_pkt_free(spx);
3092
3093 scsi_hba_pkt_free(ap, pkt);
3094 }
3095
3096 /*
3097 * Implementation of scsi tran_dmafree.
3098 * Free DMA resources allocated by sata_scsi_init_pkt()
3099 */
3100
3101 static void
3102 sata_scsi_dmafree(struct scsi_address *ap, struct scsi_pkt *pkt)
3103 {
3104 #ifndef __lock_lint
3105 _NOTE(ARGUNUSED(ap))
3106 #endif
3107 sata_pkt_txlate_t *spx;
3108
3109 ASSERT(pkt != NULL);
3110 spx = (sata_pkt_txlate_t *)pkt->pkt_ha_private;
3111
3112 sata_common_free_dma_rsrcs(spx);
3113 }
3114
3115 /*
3116 * Implementation of scsi tran_sync_pkt.
3117 *
3118 * The assumption below is that pkt is unique - there is no need to check ap
3119 *
3120 * Synchronize DMA buffer and, if the intermediate buffer is used, copy data
3121 * into/from the real buffer.
3122 */
3123 static void
3124 sata_scsi_sync_pkt(struct scsi_address *ap, struct scsi_pkt *pkt)
3125 {
3126 #ifndef __lock_lint
3127 _NOTE(ARGUNUSED(ap))
3128 #endif
3129 int rval;
3130 sata_pkt_txlate_t *spx = (sata_pkt_txlate_t *)pkt->pkt_ha_private;
3131 struct buf *bp;
3132 int direction;
3133
3134 ASSERT(spx != NULL);
3135 if (spx->txlt_buf_dma_handle != NULL) {
3136 direction = spx->txlt_sata_pkt->
3137 satapkt_cmd.satacmd_flags.sata_data_direction;
3138 if (spx->txlt_sata_pkt != NULL &&
3139 direction != SATA_DIR_NODATA_XFER) {
3140 if (spx->txlt_tmp_buf != NULL) {
3141 /* Intermediate DMA buffer used */
3142 bp = spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp;
3143
3144 if (direction & SATA_DIR_WRITE) {
3145 bcopy(bp->b_un.b_addr,
3146 spx->txlt_tmp_buf, bp->b_bcount);
3147 }
3148 }
3149 /* Sync the buffer for device or for CPU */
3150 rval = ddi_dma_sync(spx->txlt_buf_dma_handle, 0, 0,
3151 (direction & SATA_DIR_WRITE) ?
3152 DDI_DMA_SYNC_FORDEV : DDI_DMA_SYNC_FORCPU);
3153 ASSERT(rval == DDI_SUCCESS);
3154 if (spx->txlt_tmp_buf != NULL &&
3155 !(direction & SATA_DIR_WRITE)) {
3156 /* Intermediate DMA buffer used for read */
3157 bcopy(spx->txlt_tmp_buf,
3158 bp->b_un.b_addr, bp->b_bcount);
3159 }
3160
3161 }
3162 }
3163 }
3164
3165
3166
3167 /* ******************* SATA - SCSI Translation functions **************** */
3168 /*
3169 * SCSI to SATA pkt and command translation and SATA to SCSI status/error
3170 * translation.
3171 */
3172
3173 /*
3174 * Checks if a device exists and can be access and translates common
3175 * scsi_pkt data to sata_pkt data.
3176 *
3177 * Flag argument indicates that a non-read/write ATA command may be sent
3178 * to HBA in arbitrary SYNC mode to execute this packet.
3179 *
3180 * Returns TRAN_ACCEPT and scsi pkt_reason CMD_CMPLT if device exists and
3181 * sata_pkt was set-up.
3182 * Returns TRAN_ACCEPT and scsi pkt_reason CMD_DEV_GONE if device does not
3183 * exist and pkt_comp callback was scheduled.
3184 * Returns other TRAN_XXXXX values when error occured and command should be
3185 * rejected with the returned TRAN_XXXXX value.
3186 *
3187 * This function should be called with port mutex held.
3188 */
3189 static int
3190 sata_txlt_generic_pkt_info(sata_pkt_txlate_t *spx, int *reason, int flag)
3191 {
3192 sata_drive_info_t *sdinfo;
3193 sata_device_t sata_device;
3194 const struct sata_cmd_flags sata_initial_cmd_flags = {
3195 SATA_DIR_NODATA_XFER,
3196 /* all other values to 0/FALSE */
3197 };
3198 /*
3199 * Pkt_reason has to be set if the pkt_comp callback is invoked,
3200 * and that implies TRAN_ACCEPT return value. Any other returned value
3201 * indicates that the scsi packet was not accepted (the reason will not
3202 * be checked by the scsi target driver).
3203 * To make debugging easier, we set pkt_reason to know value here.
3204 * It may be changed later when different completion reason is
3205 * determined.
3206 */
3207 spx->txlt_scsi_pkt->pkt_reason = CMD_TRAN_ERR;
3208 *reason = CMD_TRAN_ERR;
3209
3210 /* Validate address */
3211 switch (sata_validate_scsi_address(spx->txlt_sata_hba_inst,
3212 &spx->txlt_scsi_pkt->pkt_address, &sata_device)) {
3213
3214 case -1:
3215 /* Invalid address or invalid device type */
3216 return (TRAN_BADPKT);
3217 case 2:
3218 /*
3219 * Valid address but device type is unknown - Chack if it is
3220 * in the reset state and therefore in an indeterminate state.
3221 */
3222 sdinfo = sata_get_device_info(spx->txlt_sata_hba_inst,
3223 &spx->txlt_sata_pkt->satapkt_device);
3224 if (sdinfo != NULL && (sdinfo->satadrv_event_flags &
3225 (SATA_EVNT_DEVICE_RESET |
3226 SATA_EVNT_INPROC_DEVICE_RESET)) != 0) {
3227 if (!ddi_in_panic()) {
3228 spx->txlt_scsi_pkt->pkt_reason = CMD_INCOMPLETE;
3229 *reason = CMD_INCOMPLETE;
3230 SATADBG1(SATA_DBG_SCSI_IF,
3231 spx->txlt_sata_hba_inst,
3232 "sata_scsi_start: rejecting command "
3233 "because of device reset state\n", NULL);
3234 return (TRAN_BUSY);
3235 }
3236 }
3237 /* FALLTHROUGH */
3238 case 1:
3239 /* valid address but no valid device - it has disappeared */
3240 spx->txlt_scsi_pkt->pkt_reason = CMD_DEV_GONE;
3241 *reason = CMD_DEV_GONE;
3242 /*
3243 * The sd target driver is checking CMD_DEV_GONE pkt_reason
3244 * only in callback function (for normal requests) and
3245 * in the dump code path.
3246 * So, if the callback is available, we need to do
3247 * the callback rather than returning TRAN_FATAL_ERROR here.
3248 */
3249 if (spx->txlt_scsi_pkt->pkt_comp != NULL) {
3250 /* scsi callback required */
3251 if (servicing_interrupt()) {
3252 if (taskq_dispatch(SATA_TXLT_TASKQ(spx),
3253 (task_func_t *)spx->txlt_scsi_pkt->pkt_comp,
3254 (void *)spx->txlt_scsi_pkt, TQ_NOSLEEP) ==
3255 NULL) {
3256 return (TRAN_BUSY);
3257 }
3258 } else if (taskq_dispatch(SATA_TXLT_TASKQ(spx),
3259 (task_func_t *)spx->txlt_scsi_pkt->pkt_comp,
3260 (void *)spx->txlt_scsi_pkt, TQ_SLEEP) == NULL) {
3261 /* Scheduling the callback failed */
3262 return (TRAN_BUSY);
3263 }
3264
3265 return (TRAN_ACCEPT);
3266 }
3267 return (TRAN_FATAL_ERROR);
3268 default:
3269 /* all OK; pkt reason will be overwritten later */
3270 break;
3271 }
3272 /*
3273 * If pkt is to be executed in polling mode and a command will not be
3274 * emulated in SATA module (requires sending a non-read/write ATA
3275 * command to HBA driver in arbitrary SYNC mode) and we are in the
3276 * interrupt context and not in the panic dump, then reject the packet
3277 * to avoid a possible interrupt stack overrun or hang caused by
3278 * a potentially blocked interrupt.
3279 */
3280 if (((spx->txlt_scsi_pkt->pkt_flags & FLAG_NOINTR) != 0 || flag != 0) &&
3281 servicing_interrupt() && !ddi_in_panic()) {
3282 SATADBG1(SATA_DBG_INTR_CTX, spx->txlt_sata_hba_inst,
3283 "sata_scsi_start: rejecting synchronous command because "
3284 "of interrupt context\n", NULL);
3285 return (TRAN_BUSY);
3286 }
3287
3288 sdinfo = sata_get_device_info(spx->txlt_sata_hba_inst,
3289 &spx->txlt_sata_pkt->satapkt_device);
3290
3291 /*
3292 * If device is in reset condition, reject the packet with
3293 * TRAN_BUSY, unless:
3294 * 1. system is panicking (dumping)
3295 * In such case only one thread is running and there is no way to
3296 * process reset.
3297 * 2. cfgadm operation is is progress (internal APCTL lock is set)
3298 * Some cfgadm operations involve drive commands, so reset condition
3299 * needs to be ignored for IOCTL operations.
3300 */
3301 if ((sdinfo->satadrv_event_flags &
3302 (SATA_EVNT_DEVICE_RESET | SATA_EVNT_INPROC_DEVICE_RESET)) != 0) {
3303
3304 if (!ddi_in_panic() &&
3305 ((SATA_CPORT_EVENT_FLAGS(spx->txlt_sata_hba_inst,
3306 sata_device.satadev_addr.cport) &
3307 SATA_APCTL_LOCK_PORT_BUSY) == 0)) {
3308 spx->txlt_scsi_pkt->pkt_reason = CMD_INCOMPLETE;
3309 *reason = CMD_INCOMPLETE;
3310 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst,
3311 "sata_scsi_start: rejecting command because "
3312 "of device reset state\n", NULL);
3313 return (TRAN_BUSY);
3314 }
3315 }
3316
3317 /*
3318 * Fix the dev_type in the sata_pkt->satapkt_device. It was not set by
3319 * sata_scsi_pkt_init() because pkt init had to work also with
3320 * non-existing devices.
3321 * Now we know that the packet was set-up for a real device, so its
3322 * type is known.
3323 */
3324 spx->txlt_sata_pkt->satapkt_device.satadev_type = sdinfo->satadrv_type;
3325
3326 spx->txlt_sata_pkt->satapkt_cmd.satacmd_flags = sata_initial_cmd_flags;
3327 if ((SATA_CPORT_INFO(spx->txlt_sata_hba_inst,
3328 sata_device.satadev_addr.cport)->cport_event_flags &
3329 SATA_APCTL_LOCK_PORT_BUSY) != 0) {
3330 spx->txlt_sata_pkt->satapkt_cmd.satacmd_flags.
3331 sata_ignore_dev_reset = B_TRUE;
3332 }
3333 /*
3334 * At this point the generic translation routine determined that the
3335 * scsi packet should be accepted. Packet completion reason may be
3336 * changed later when a different completion reason is determined.
3337 */
3338 spx->txlt_scsi_pkt->pkt_reason = CMD_CMPLT;
3339 *reason = CMD_CMPLT;
3340
3341 if ((spx->txlt_scsi_pkt->pkt_flags & FLAG_NOINTR) != 0) {
3342 /* Synchronous execution */
3343 spx->txlt_sata_pkt->satapkt_op_mode = SATA_OPMODE_SYNCH |
3344 SATA_OPMODE_POLLING;
3345 spx->txlt_sata_pkt->satapkt_cmd.satacmd_flags.
3346 sata_ignore_dev_reset = ddi_in_panic();
3347 } else {
3348 /* Asynchronous execution */
3349 spx->txlt_sata_pkt->satapkt_op_mode = SATA_OPMODE_ASYNCH |
3350 SATA_OPMODE_INTERRUPTS;
3351 }
3352 /* Convert queuing information */
3353 if (spx->txlt_scsi_pkt->pkt_flags & FLAG_STAG)
3354 spx->txlt_sata_pkt->satapkt_cmd.satacmd_flags.sata_queue_stag =
3355 B_TRUE;
3356 else if (spx->txlt_scsi_pkt->pkt_flags &
3357 (FLAG_OTAG | FLAG_HTAG | FLAG_HEAD))
3358 spx->txlt_sata_pkt->satapkt_cmd.satacmd_flags.sata_queue_otag =
3359 B_TRUE;
3360
3361 /* Always limit pkt time */
3362 if (spx->txlt_scsi_pkt->pkt_time == 0)
3363 spx->txlt_sata_pkt->satapkt_time = sata_default_pkt_time;
3364 else
3365 /* Pass on scsi_pkt time */
3366 spx->txlt_sata_pkt->satapkt_time =
3367 spx->txlt_scsi_pkt->pkt_time;
3368
3369 return (TRAN_ACCEPT);
3370 }
3371
3372
3373 /*
3374 * Translate ATA Identify Device data to SCSI Inquiry data.
3375 * This function may be called only for ATA devices.
3376 * This function should not be called for ATAPI devices - they
3377 * respond directly to SCSI Inquiry command.
3378 *
3379 * SATA Identify Device data has to be valid in sata_drive_info.
3380 * Buffer has to accomodate the inquiry length (36 bytes).
3381 *
3382 * This function should be called with a port mutex held.
3383 */
3384 static void
3385 sata_identdev_to_inquiry(sata_hba_inst_t *sata_hba_inst,
3386 sata_drive_info_t *sdinfo, uint8_t *buf)
3387 {
3388
3389 struct scsi_inquiry *inq = (struct scsi_inquiry *)buf;
3390 struct sata_id *sid = &sdinfo->satadrv_id;
3391
3392 /* Start with a nice clean slate */
3393 bzero((void *)inq, sizeof (struct scsi_inquiry));
3394
3395 /*
3396 * Rely on the dev_type for setting paripheral qualifier.
3397 * Assume that DTYPE_RODIRECT applies to CD/DVD R/W devices.
3398 * It could be that DTYPE_OPTICAL could also qualify in the future.
3399 * ATAPI Inquiry may provide more data to the target driver.
3400 */
3401 inq->inq_dtype = sdinfo->satadrv_type == SATA_DTYPE_ATADISK ?
3402 DTYPE_DIRECT : DTYPE_RODIRECT; /* DTYPE_UNKNOWN; */
3403
3404 /* CFA type device is not a removable media device */
3405 inq->inq_rmb = ((sid->ai_config != SATA_CFA_TYPE) &&
3406 (sid->ai_config & SATA_REM_MEDIA)) ? 1 : 0;
3407 inq->inq_qual = 0; /* Device type qualifier (obsolete in SCSI3? */
3408 inq->inq_iso = 0; /* ISO version */
3409 inq->inq_ecma = 0; /* ECMA version */
3410 inq->inq_ansi = 3; /* ANSI version - SCSI 3 */
3411 inq->inq_aenc = 0; /* Async event notification cap. */
3412 inq->inq_trmiop = 0; /* Supports TERMINATE I/O PROC msg - NO */
3413 inq->inq_normaca = 0; /* setting NACA bit supported - NO */
3414 inq->inq_rdf = RDF_SCSI2; /* Response data format- SPC-3 */
3415 inq->inq_len = 31; /* Additional length */
3416 inq->inq_dualp = 0; /* dual port device - NO */
3417 inq->inq_reladdr = 0; /* Supports relative addressing - NO */
3418 inq->inq_sync = 0; /* Supports synchronous data xfers - NO */
3419 inq->inq_linked = 0; /* Supports linked commands - NO */
3420 /*
3421 * Queuing support - controller has to
3422 * support some sort of command queuing.
3423 */
3424 if (SATA_QDEPTH(sata_hba_inst) > 1)
3425 inq->inq_cmdque = 1; /* Supports command queueing - YES */
3426 else
3427 inq->inq_cmdque = 0; /* Supports command queueing - NO */
3428 inq->inq_sftre = 0; /* Supports Soft Reset option - NO ??? */
3429 inq->inq_wbus32 = 0; /* Supports 32 bit wide data xfers - NO */
3430 inq->inq_wbus16 = 0; /* Supports 16 bit wide data xfers - NO */
3431
3432 #ifdef _LITTLE_ENDIAN
3433 /* Swap text fields to match SCSI format */
3434 bcopy("ATA ", inq->inq_vid, 8); /* Vendor ID */
3435 swab(sid->ai_model, inq->inq_pid, 16); /* Product ID */
3436 if (strncmp(&sid->ai_fw[4], " ", 4) == 0)
3437 swab(sid->ai_fw, inq->inq_revision, 4); /* Revision level */
3438 else
3439 swab(&sid->ai_fw[4], inq->inq_revision, 4); /* Rev. level */
3440 #else /* _LITTLE_ENDIAN */
3441 bcopy("ATA ", inq->inq_vid, 8); /* Vendor ID */
3442 bcopy(sid->ai_model, inq->inq_pid, 16); /* Product ID */
3443 if (strncmp(&sid->ai_fw[4], " ", 4) == 0)
3444 bcopy(sid->ai_fw, inq->inq_revision, 4); /* Revision level */
3445 else
3446 bcopy(&sid->ai_fw[4], inq->inq_revision, 4); /* Rev. level */
3447 #endif /* _LITTLE_ENDIAN */
3448 }
3449
3450
3451 /*
3452 * Scsi response set up for invalid command (command not supported)
3453 *
3454 * Returns TRAN_ACCEPT and appropriate values in scsi_pkt fields.
3455 */
3456 static int
3457 sata_txlt_invalid_command(sata_pkt_txlate_t *spx)
3458 {
3459 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt;
3460 struct scsi_extended_sense *sense;
3461
3462 scsipkt->pkt_reason = CMD_CMPLT;
3463 scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET |
3464 STATE_SENT_CMD | STATE_GOT_STATUS;
3465
3466 *scsipkt->pkt_scbp = STATUS_CHECK;
3467
3468 sense = sata_arq_sense(spx);
3469 sense->es_key = KEY_ILLEGAL_REQUEST;
3470 sense->es_add_code = SD_SCSI_ASC_INVALID_COMMAND_CODE;
3471
3472 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst,
3473 "Scsi_pkt completion reason %x\n", scsipkt->pkt_reason);
3474
3475 if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0 &&
3476 scsipkt->pkt_comp != NULL) {
3477 /* scsi callback required */
3478 if (servicing_interrupt()) {
3479 if (taskq_dispatch(SATA_TXLT_TASKQ(spx),
3480 (task_func_t *)spx->txlt_scsi_pkt->pkt_comp,
3481 (void *)spx->txlt_scsi_pkt, TQ_NOSLEEP) == NULL) {
3482 return (TRAN_BUSY);
3483 }
3484 } else if (taskq_dispatch(SATA_TXLT_TASKQ(spx),
3485 (task_func_t *)spx->txlt_scsi_pkt->pkt_comp,
3486 (void *)spx->txlt_scsi_pkt, TQ_SLEEP) == NULL) {
3487 /* Scheduling the callback failed */
3488 return (TRAN_BUSY);
3489 }
3490 }
3491 return (TRAN_ACCEPT);
3492 }
3493
3494 /*
3495 * Scsi response set up for check condition with special sense key
3496 * and additional sense code.
3497 *
3498 * Returns TRAN_ACCEPT and appropriate values in scsi_pkt fields.
3499 */
3500 static int
3501 sata_txlt_check_condition(sata_pkt_txlate_t *spx, uchar_t key, uchar_t code)
3502 {
3503 sata_hba_inst_t *shi = SATA_TXLT_HBA_INST(spx);
3504 int cport = SATA_TXLT_CPORT(spx);
3505 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt;
3506 struct scsi_extended_sense *sense;
3507
3508 mutex_enter(&SATA_CPORT_MUTEX(shi, cport));
3509 scsipkt->pkt_reason = CMD_CMPLT;
3510 scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET |
3511 STATE_SENT_CMD | STATE_GOT_STATUS;
3512
3513 *scsipkt->pkt_scbp = STATUS_CHECK;
3514
3515 sense = sata_arq_sense(spx);
3516 sense->es_key = key;
3517 sense->es_add_code = code;
3518
3519 mutex_exit(&SATA_CPORT_MUTEX(shi, cport));
3520
3521 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst,
3522 "Scsi_pkt completion reason %x\n", scsipkt->pkt_reason);
3523
3524 if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0 &&
3525 scsipkt->pkt_comp != NULL) {
3526 /* scsi callback required */
3527 if (servicing_interrupt()) {
3528 if (taskq_dispatch(SATA_TXLT_TASKQ(spx),
3529 (task_func_t *)spx->txlt_scsi_pkt->pkt_comp,
3530 (void *)spx->txlt_scsi_pkt, TQ_NOSLEEP) == NULL) {
3531 return (TRAN_BUSY);
3532 }
3533 } else if (taskq_dispatch(SATA_TXLT_TASKQ(spx),
3534 (task_func_t *)spx->txlt_scsi_pkt->pkt_comp,
3535 (void *)spx->txlt_scsi_pkt, TQ_SLEEP) == NULL) {
3536 /* Scheduling the callback failed */
3537 return (TRAN_BUSY);
3538 }
3539 }
3540 return (TRAN_ACCEPT);
3541 }
3542
3543 /*
3544 * Scsi response setup for
3545 * emulated non-data command that requires no action/return data
3546 *
3547 * Returns TRAN_ACCEPT and appropriate values in scsi_pkt fields.
3548 */
3549 static int
3550 sata_txlt_nodata_cmd_immediate(sata_pkt_txlate_t *spx)
3551 {
3552 int rval;
3553 int reason;
3554 kmutex_t *cport_mutex = &(SATA_TXLT_CPORT_MUTEX(spx));
3555
3556 mutex_enter(cport_mutex);
3557
3558 if (((rval = sata_txlt_generic_pkt_info(spx, &reason, 0)) !=
3559 TRAN_ACCEPT) || (reason == CMD_DEV_GONE)) {
3560 mutex_exit(cport_mutex);
3561 return (rval);
3562 }
3563 mutex_exit(cport_mutex);
3564
3565 spx->txlt_scsi_pkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET |
3566 STATE_SENT_CMD | STATE_GOT_STATUS;
3567 spx->txlt_scsi_pkt->pkt_reason = CMD_CMPLT;
3568 *(spx->txlt_scsi_pkt->pkt_scbp) = STATUS_GOOD;
3569
3570 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst,
3571 "Scsi_pkt completion reason %x\n",
3572 spx->txlt_scsi_pkt->pkt_reason);
3573
3574 if ((spx->txlt_scsi_pkt->pkt_flags & FLAG_NOINTR) == 0 &&
3575 spx->txlt_scsi_pkt->pkt_comp != NULL) {
3576 /* scsi callback required */
3577 if (servicing_interrupt()) {
3578 if (taskq_dispatch(SATA_TXLT_TASKQ(spx),
3579 (task_func_t *)spx->txlt_scsi_pkt->pkt_comp,
3580 (void *)spx->txlt_scsi_pkt, TQ_NOSLEEP) == NULL) {
3581 return (TRAN_BUSY);
3582 }
3583 } else if (taskq_dispatch(SATA_TXLT_TASKQ(spx),
3584 (task_func_t *)spx->txlt_scsi_pkt->pkt_comp,
3585 (void *)spx->txlt_scsi_pkt, TQ_SLEEP) == NULL) {
3586 /* Scheduling the callback failed */
3587 return (TRAN_BUSY);
3588 }
3589 }
3590 return (TRAN_ACCEPT);
3591 }
3592
3593
3594 /*
3595 * SATA translate command: Inquiry / Identify Device
3596 * Use cached Identify Device data for now, rather than issuing actual
3597 * Device Identify cmd request. If device is detached and re-attached,
3598 * asynchronous event processing should fetch and refresh Identify Device
3599 * data.
3600 * VPD pages supported now:
3601 * Vital Product Data page
3602 * Unit Serial Number page
3603 * Block Device Characteristics Page
3604 * ATA Information Page
3605 *
3606 * Returns TRAN_ACCEPT and appropriate values in scsi_pkt fields.
3607 */
3608
3609 #define EVPD 1 /* Extended Vital Product Data flag */
3610 #define CMDDT 2 /* Command Support Data - Obsolete */
3611 #define INQUIRY_SUP_VPD_PAGE 0 /* Supported VPD Pages Page Code */
3612 #define INQUIRY_USN_PAGE 0x80 /* Unit Serial Number Page Code */
3613 #define INQUIRY_BDC_PAGE 0xB1 /* Block Device Characteristics Page */
3614 /* Code */
3615 #define INQUIRY_ATA_INFO_PAGE 0x89 /* ATA Information Page Code */
3616 #define INQUIRY_DEV_IDENTIFICATION_PAGE 0x83 /* Not needed yet */
3617
3618 static int
3619 sata_txlt_inquiry(sata_pkt_txlate_t *spx)
3620 {
3621 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt;
3622 struct buf *bp = spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp;
3623 sata_drive_info_t *sdinfo;
3624 struct scsi_extended_sense *sense;
3625 int count;
3626 uint8_t *p;
3627 int i, j;
3628 uint8_t page_buf[1024]; /* Max length */
3629 int rval, reason;
3630 ushort_t rate;
3631 kmutex_t *cport_mutex = &(SATA_TXLT_CPORT_MUTEX(spx));
3632
3633 mutex_enter(cport_mutex);
3634
3635 if (((rval = sata_txlt_generic_pkt_info(spx, &reason, 0)) !=
3636 TRAN_ACCEPT) || (reason == CMD_DEV_GONE)) {
3637 mutex_exit(cport_mutex);
3638 return (rval);
3639 }
3640
3641 sdinfo = sata_get_device_info(spx->txlt_sata_hba_inst,
3642 &spx->txlt_sata_pkt->satapkt_device);
3643
3644 ASSERT(sdinfo != NULL);
3645
3646 scsipkt->pkt_reason = CMD_CMPLT;
3647 scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET |
3648 STATE_SENT_CMD | STATE_GOT_STATUS;
3649
3650 /* Reject not supported request */
3651 if (scsipkt->pkt_cdbp[1] & CMDDT) { /* No support for this bit */
3652 *scsipkt->pkt_scbp = STATUS_CHECK;
3653 sense = sata_arq_sense(spx);
3654 sense->es_key = KEY_ILLEGAL_REQUEST;
3655 sense->es_add_code = SD_SCSI_ASC_INVALID_FIELD_IN_CDB;
3656 goto done;
3657 }
3658
3659 /* Valid Inquiry request */
3660 *scsipkt->pkt_scbp = STATUS_GOOD;
3661
3662 if (bp != NULL && bp->b_un.b_addr && bp->b_bcount) {
3663
3664 /*
3665 * Because it is fully emulated command storing data
3666 * programatically in the specified buffer, release
3667 * preallocated DMA resources before storing data in the buffer,
3668 * so no unwanted DMA sync would take place.
3669 */
3670 sata_scsi_dmafree(NULL, scsipkt);
3671
3672 if (!(scsipkt->pkt_cdbp[1] & EVPD)) {
3673 /* Standard Inquiry Data request */
3674 struct scsi_inquiry inq;
3675 unsigned int bufsize;
3676
3677 sata_identdev_to_inquiry(spx->txlt_sata_hba_inst,
3678 sdinfo, (uint8_t *)&inq);
3679 /* Copy no more than requested */
3680 count = MIN(bp->b_bcount,
3681 sizeof (struct scsi_inquiry));
3682 bufsize = scsipkt->pkt_cdbp[4];
3683 bufsize |= scsipkt->pkt_cdbp[3] << 8;
3684 count = MIN(count, bufsize);
3685 bcopy(&inq, bp->b_un.b_addr, count);
3686
3687 scsipkt->pkt_state |= STATE_XFERRED_DATA;
3688 scsipkt->pkt_resid = scsipkt->pkt_cdbp[4] > count ?
3689 bufsize - count : 0;
3690 } else {
3691 /*
3692 * peripheral_qualifier = 0;
3693 *
3694 * We are dealing only with HD and will be
3695 * dealing with CD/DVD devices soon
3696 */
3697 uint8_t peripheral_device_type =
3698 sdinfo->satadrv_type == SATA_DTYPE_ATADISK ?
3699 DTYPE_DIRECT : DTYPE_RODIRECT;
3700
3701 bzero(page_buf, sizeof (page_buf));
3702
3703 switch ((uint_t)scsipkt->pkt_cdbp[2]) {
3704 case INQUIRY_SUP_VPD_PAGE:
3705 /*
3706 * Request for supported Vital Product Data
3707 * pages.
3708 */
3709 page_buf[0] = peripheral_device_type;
3710 page_buf[1] = INQUIRY_SUP_VPD_PAGE;
3711 page_buf[2] = 0;
3712 page_buf[3] = 4; /* page length */
3713 page_buf[4] = INQUIRY_SUP_VPD_PAGE;
3714 page_buf[5] = INQUIRY_USN_PAGE;
3715 page_buf[6] = INQUIRY_BDC_PAGE;
3716 page_buf[7] = INQUIRY_ATA_INFO_PAGE;
3717 /* Copy no more than requested */
3718 count = MIN(bp->b_bcount, 8);
3719 bcopy(page_buf, bp->b_un.b_addr, count);
3720 break;
3721
3722 case INQUIRY_USN_PAGE:
3723 /*
3724 * Request for Unit Serial Number page.
3725 * Set-up the page.
3726 */
3727 page_buf[0] = peripheral_device_type;
3728 page_buf[1] = INQUIRY_USN_PAGE;
3729 page_buf[2] = 0;
3730 /* remaining page length */
3731 page_buf[3] = SATA_ID_SERIAL_LEN;
3732
3733 /*
3734 * Copy serial number from Identify Device data
3735 * words into the inquiry page and swap bytes
3736 * when necessary.
3737 */
3738 p = (uint8_t *)(sdinfo->satadrv_id.ai_drvser);
3739 #ifdef _LITTLE_ENDIAN
3740 swab(p, &page_buf[4], SATA_ID_SERIAL_LEN);
3741 #else
3742 bcopy(p, &page_buf[4], SATA_ID_SERIAL_LEN);
3743 #endif
3744 /*
3745 * Least significant character of the serial
3746 * number shall appear as the last byte,
3747 * according to SBC-3 spec.
3748 * Count trailing spaces to determine the
3749 * necessary shift length.
3750 */
3751 p = &page_buf[SATA_ID_SERIAL_LEN + 4 - 1];
3752 for (j = 0; j < SATA_ID_SERIAL_LEN; j++) {
3753 if (*(p - j) != '\0' &&
3754 *(p - j) != '\040')
3755 break;
3756 }
3757
3758 /*
3759 * Shift SN string right, so that the last
3760 * non-blank character would appear in last
3761 * byte of SN field in the page.
3762 * 'j' is the shift length.
3763 */
3764 for (i = 0;
3765 i < (SATA_ID_SERIAL_LEN - j) && j != 0;
3766 i++, p--)
3767 *p = *(p - j);
3768
3769 /*
3770 * Add leading spaces - same number as the
3771 * shift size
3772 */
3773 for (; j > 0; j--)
3774 page_buf[4 + j - 1] = '\040';
3775
3776 count = MIN(bp->b_bcount,
3777 SATA_ID_SERIAL_LEN + 4);
3778 bcopy(page_buf, bp->b_un.b_addr, count);
3779 break;
3780
3781 case INQUIRY_BDC_PAGE:
3782 /*
3783 * Request for Block Device Characteristics
3784 * page. Set-up the page.
3785 */
3786 page_buf[0] = peripheral_device_type;
3787 page_buf[1] = INQUIRY_BDC_PAGE;
3788 page_buf[2] = 0;
3789 /* remaining page length */
3790 page_buf[3] = SATA_ID_BDC_LEN;
3791
3792 rate = sdinfo->satadrv_id.ai_medrotrate;
3793 page_buf[4] = (rate >> 8) & 0xff;
3794 page_buf[5] = rate & 0xff;
3795 page_buf[6] = 0;
3796 page_buf[7] = sdinfo->satadrv_id.
3797 ai_nomformfactor & 0xf;
3798
3799 count = MIN(bp->b_bcount,
3800 SATA_ID_BDC_LEN + 4);
3801 bcopy(page_buf, bp->b_un.b_addr, count);
3802 break;
3803
3804 case INQUIRY_ATA_INFO_PAGE:
3805 /*
3806 * Request for ATA Information page.
3807 */
3808 page_buf[0] = peripheral_device_type;
3809 page_buf[1] = INQUIRY_ATA_INFO_PAGE;
3810 page_buf[2] = (SATA_ID_ATA_INFO_LEN >> 8) &
3811 0xff;
3812 page_buf[3] = SATA_ID_ATA_INFO_LEN & 0xff;
3813 /* page_buf[4-7] reserved */
3814 #ifdef _LITTLE_ENDIAN
3815 bcopy("ATA ", &page_buf[8], 8);
3816 swab(sdinfo->satadrv_id.ai_model,
3817 &page_buf[16], 16);
3818 if (strncmp(&sdinfo->satadrv_id.ai_fw[4],
3819 " ", 4) == 0) {
3820 swab(sdinfo->satadrv_id.ai_fw,
3821 &page_buf[32], 4);
3822 } else {
3823 swab(&sdinfo->satadrv_id.ai_fw[4],
3824 &page_buf[32], 4);
3825 }
3826 #else /* _LITTLE_ENDIAN */
3827 bcopy("ATA ", &page_buf[8], 8);
3828 bcopy(sdinfo->satadrv_id.ai_model,
3829 &page_buf[16], 16);
3830 if (strncmp(&sdinfo->satadrv_id.ai_fw[4],
3831 " ", 4) == 0) {
3832 bcopy(sdinfo->satadrv_id.ai_fw,
3833 &page_buf[32], 4);
3834 } else {
3835 bcopy(&sdinfo->satadrv_id.ai_fw[4],
3836 &page_buf[32], 4);
3837 }
3838 #endif /* _LITTLE_ENDIAN */
3839 /*
3840 * page_buf[36-55] which defines the device
3841 * signature is not defined at this
3842 * time.
3843 */
3844
3845 /* Set the command code */
3846 if (sdinfo->satadrv_type ==
3847 SATA_DTYPE_ATADISK) {
3848 page_buf[56] = SATAC_ID_DEVICE;
3849 } else if (sdinfo->satadrv_type ==
3850 SATA_DTYPE_ATAPI) {
3851 page_buf[56] = SATAC_ID_PACKET_DEVICE;
3852 }
3853 /*
3854 * If the command code, page_buf[56], is not
3855 * zero and if one of the identify commands
3856 * succeeds, return the identify data.
3857 */
3858 if ((page_buf[56] != 0) &&
3859 (sata_fetch_device_identify_data(
3860 spx->txlt_sata_hba_inst, sdinfo) ==
3861 SATA_SUCCESS)) {
3862 bcopy(&sdinfo->satadrv_id,
3863 &page_buf[60], sizeof (sata_id_t));
3864 }
3865
3866 /* Need to copy out the page_buf to bp */
3867 count = MIN(bp->b_bcount,
3868 SATA_ID_ATA_INFO_LEN + 4);
3869 bcopy(page_buf, bp->b_un.b_addr, count);
3870 break;
3871
3872 case INQUIRY_DEV_IDENTIFICATION_PAGE:
3873 /*
3874 * We may want to implement this page, when
3875 * identifiers are common for SATA devices
3876 * But not now.
3877 */
3878 /*FALLTHROUGH*/
3879
3880 default:
3881 /* Request for unsupported VPD page */
3882 *scsipkt->pkt_scbp = STATUS_CHECK;
3883 sense = sata_arq_sense(spx);
3884 sense->es_key = KEY_ILLEGAL_REQUEST;
3885 sense->es_add_code =
3886 SD_SCSI_ASC_INVALID_FIELD_IN_CDB;
3887 goto done;
3888 }
3889 }
3890 scsipkt->pkt_state |= STATE_XFERRED_DATA;
3891 scsipkt->pkt_resid = scsipkt->pkt_cdbp[4] > count ?
3892 scsipkt->pkt_cdbp[4] - count : 0;
3893 }
3894 done:
3895 mutex_exit(cport_mutex);
3896
3897 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst,
3898 "Scsi_pkt completion reason %x\n",
3899 scsipkt->pkt_reason);
3900
3901 if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0 &&
3902 scsipkt->pkt_comp != NULL) {
3903 /* scsi callback required */
3904 if (servicing_interrupt()) {
3905 if (taskq_dispatch(SATA_TXLT_TASKQ(spx),
3906 (task_func_t *)spx->txlt_scsi_pkt->pkt_comp,
3907 (void *)spx->txlt_scsi_pkt, TQ_NOSLEEP) == NULL) {
3908 return (TRAN_BUSY);
3909 }
3910 } else if (taskq_dispatch(SATA_TXLT_TASKQ(spx),
3911 (task_func_t *)spx->txlt_scsi_pkt->pkt_comp,
3912 (void *)spx->txlt_scsi_pkt, TQ_SLEEP) == NULL) {
3913 /* Scheduling the callback failed */
3914 return (TRAN_BUSY);
3915 }
3916 }
3917 return (TRAN_ACCEPT);
3918 }
3919
3920 /*
3921 * SATA translate command: Request Sense.
3922 *
3923 * Returns TRAN_ACCEPT and appropriate values in scsi_pkt fields.
3924 * At the moment this is an emulated command (ATA version for SATA hard disks).
3925 * May be translated into Check Power Mode command in the future.
3926 *
3927 * Note: There is a mismatch between already implemented Informational
3928 * Exception Mode Select page 0x1C and this function.
3929 * When MRIE bit is set in page 0x1C, Request Sense is supposed to return
3930 * NO SENSE and set additional sense code to the exception code - this is not
3931 * implemented here.
3932 */
3933 static int
3934 sata_txlt_request_sense(sata_pkt_txlate_t *spx)
3935 {
3936 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt;
3937 struct scsi_extended_sense sense;
3938 struct buf *bp = spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp;
3939 sata_drive_info_t *sdinfo;
3940 sata_cmd_t *scmd = &spx->txlt_sata_pkt->satapkt_cmd;
3941 int rval, reason, power_state = 0;
3942 kmutex_t *cport_mutex;
3943
3944 cport_mutex = &(SATA_TXLT_CPORT_MUTEX(spx));
3945 mutex_enter(cport_mutex);
3946
3947 if (((rval = sata_txlt_generic_pkt_info(spx, &reason, 1)) !=
3948 TRAN_ACCEPT) || (reason == CMD_DEV_GONE)) {
3949 mutex_exit(cport_mutex);
3950 return (rval);
3951 }
3952
3953 scsipkt->pkt_reason = CMD_CMPLT;
3954 scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET |
3955 STATE_SENT_CMD | STATE_GOT_STATUS;
3956 *scsipkt->pkt_scbp = STATUS_GOOD;
3957
3958 /*
3959 * when CONTROL field's NACA bit == 1
3960 * return ILLEGAL_REQUEST
3961 */
3962 if (scsipkt->pkt_cdbp[5] & CTL_BYTE_NACA_MASK) {
3963 mutex_exit(cport_mutex);
3964 return (sata_txlt_check_condition(spx, KEY_ILLEGAL_REQUEST,
3965 SD_SCSI_ASC_CMD_SEQUENCE_ERR));
3966 }
3967
3968 sdinfo = sata_get_device_info(spx->txlt_sata_hba_inst,
3969 &spx->txlt_sata_pkt->satapkt_device);
3970 ASSERT(sdinfo != NULL);
3971
3972 spx->txlt_sata_pkt->satapkt_op_mode |= SATA_OPMODE_SYNCH;
3973
3974 sata_build_generic_cmd(scmd, SATAC_CHECK_POWER_MODE);
3975 scmd->satacmd_flags.sata_copy_out_sec_count_lsb = B_TRUE;
3976 scmd->satacmd_flags.sata_copy_out_error_reg = B_TRUE;
3977 if (sata_hba_start(spx, &rval) != 0) {
3978 mutex_exit(cport_mutex);
3979 return (rval);
3980 }
3981 if (scmd->satacmd_error_reg != 0) {
3982 mutex_exit(cport_mutex);
3983 return (sata_txlt_check_condition(spx, KEY_NO_SENSE,
3984 SD_SCSI_ASC_NO_ADD_SENSE));
3985 }
3986
3987 switch (scmd->satacmd_sec_count_lsb) {
3988 case SATA_PWRMODE_STANDBY: /* device in standby mode */
3989 if (sdinfo->satadrv_power_level == SATA_POWER_STOPPED)
3990 power_state = SATA_POWER_STOPPED;
3991 else {
3992 power_state = SATA_POWER_STANDBY;
3993 sdinfo->satadrv_power_level = SATA_POWER_STANDBY;
3994 }
3995 break;
3996 case SATA_PWRMODE_IDLE: /* device in idle mode */
3997 power_state = SATA_POWER_IDLE;
3998 sdinfo->satadrv_power_level = SATA_POWER_IDLE;
3999 break;
4000 case SATA_PWRMODE_ACTIVE: /* device in active or idle mode */
4001 default: /* 0x40, 0x41 active mode */
4002 if (sdinfo->satadrv_power_level == SATA_POWER_IDLE)
4003 power_state = SATA_POWER_IDLE;
4004 else {
4005 power_state = SATA_POWER_ACTIVE;
4006 sdinfo->satadrv_power_level = SATA_POWER_ACTIVE;
4007 }
4008 break;
4009 }
4010
4011 mutex_exit(cport_mutex);
4012
4013 if (bp != NULL && bp->b_un.b_addr && bp->b_bcount) {
4014 /*
4015 * Because it is fully emulated command storing data
4016 * programatically in the specified buffer, release
4017 * preallocated DMA resources before storing data in the buffer,
4018 * so no unwanted DMA sync would take place.
4019 */
4020 int count = MIN(bp->b_bcount,
4021 sizeof (struct scsi_extended_sense));
4022 sata_scsi_dmafree(NULL, scsipkt);
4023 bzero(&sense, sizeof (struct scsi_extended_sense));
4024 sense.es_valid = 0; /* Valid LBA */
4025 sense.es_class = 7; /* Response code 0x70 - current err */
4026 sense.es_key = KEY_NO_SENSE;
4027 sense.es_add_len = 6; /* Additional length */
4028 /* Copy no more than requested */
4029 bcopy(&sense, bp->b_un.b_addr, count);
4030 scsipkt->pkt_state |= STATE_XFERRED_DATA;
4031 scsipkt->pkt_resid = 0;
4032 switch (power_state) {
4033 case SATA_POWER_IDLE:
4034 case SATA_POWER_STANDBY:
4035 sense.es_add_code =
4036 SD_SCSI_ASC_LOW_POWER_CONDITION_ON;
4037 break;
4038 case SATA_POWER_STOPPED:
4039 sense.es_add_code = SD_SCSI_ASC_NO_ADD_SENSE;
4040 break;
4041 case SATA_POWER_ACTIVE:
4042 default:
4043 break;
4044 }
4045 }
4046
4047 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst,
4048 "Scsi_pkt completion reason %x\n",
4049 scsipkt->pkt_reason);
4050
4051 if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0 &&
4052 scsipkt->pkt_comp != NULL) {
4053 /* scsi callback required */
4054 if (servicing_interrupt()) {
4055 if (taskq_dispatch(SATA_TXLT_TASKQ(spx),
4056 (task_func_t *)spx->txlt_scsi_pkt->pkt_comp,
4057 (void *)spx->txlt_scsi_pkt, TQ_NOSLEEP) == NULL) {
4058 return (TRAN_BUSY);
4059 }
4060 } else if (taskq_dispatch(SATA_TXLT_TASKQ(spx),
4061 (task_func_t *)spx->txlt_scsi_pkt->pkt_comp,
4062 (void *)spx->txlt_scsi_pkt, TQ_SLEEP) == NULL) {
4063 /* Scheduling the callback failed */
4064 return (TRAN_BUSY);
4065 }
4066 }
4067 return (TRAN_ACCEPT);
4068 }
4069
4070 /*
4071 * SATA translate command: Test Unit Ready
4072 * (ATA version for SATA hard disks).
4073 * It is translated into the Check Power Mode command.
4074 *
4075 * Returns TRAN_ACCEPT and appropriate values in scsi_pkt fields.
4076 */
4077 static int
4078 sata_txlt_test_unit_ready(sata_pkt_txlate_t *spx)
4079 {
4080 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt;
4081 struct scsi_extended_sense *sense;
4082 sata_cmd_t *scmd = &spx->txlt_sata_pkt->satapkt_cmd;
4083 sata_drive_info_t *sdinfo;
4084 int power_state;
4085 int rval, reason;
4086 kmutex_t *cport_mutex = &(SATA_TXLT_CPORT_MUTEX(spx));
4087
4088 mutex_enter(cport_mutex);
4089
4090 if (((rval = sata_txlt_generic_pkt_info(spx, &reason, 1)) !=
4091 TRAN_ACCEPT) || (reason == CMD_DEV_GONE)) {
4092 mutex_exit(cport_mutex);
4093 return (rval);
4094 }
4095
4096 sdinfo = sata_get_device_info(spx->txlt_sata_hba_inst,
4097 &spx->txlt_sata_pkt->satapkt_device);
4098 ASSERT(sdinfo != NULL);
4099
4100 spx->txlt_sata_pkt->satapkt_op_mode |= SATA_OPMODE_SYNCH;
4101
4102 /* send CHECK POWER MODE command */
4103 sata_build_generic_cmd(scmd, SATAC_CHECK_POWER_MODE);
4104 scmd->satacmd_flags.sata_copy_out_sec_count_lsb = B_TRUE;
4105 scmd->satacmd_flags.sata_copy_out_error_reg = B_TRUE;
4106 if (sata_hba_start(spx, &rval) != 0) {
4107 mutex_exit(cport_mutex);
4108 return (rval);
4109 }
4110
4111 if (scmd->satacmd_error_reg != 0) {
4112 mutex_exit(cport_mutex);
4113 return (sata_txlt_check_condition(spx, KEY_NOT_READY,
4114 SD_SCSI_ASC_LU_NOT_RESPONSE));
4115 }
4116
4117 power_state = scmd->satacmd_sec_count_lsb;
4118
4119 /*
4120 * return NOT READY when device in STOPPED mode
4121 */
4122 if (power_state == SATA_PWRMODE_STANDBY &&
4123 sdinfo->satadrv_power_level == SATA_POWER_STOPPED) {
4124 *scsipkt->pkt_scbp = STATUS_CHECK;
4125 sense = sata_arq_sense(spx);
4126 sense->es_key = KEY_NOT_READY;
4127 sense->es_add_code = SD_SCSI_ASC_LU_NOT_READY;
4128 } else {
4129 /*
4130 * For other power mode, return GOOD status
4131 */
4132 *scsipkt->pkt_scbp = STATUS_GOOD;
4133 }
4134
4135 scsipkt->pkt_reason = CMD_CMPLT;
4136 scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET |
4137 STATE_SENT_CMD | STATE_GOT_STATUS;
4138
4139 mutex_exit(cport_mutex);
4140
4141 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst,
4142 "Scsi_pkt completion reason %x\n", scsipkt->pkt_reason);
4143
4144 if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0 &&
4145 scsipkt->pkt_comp != NULL) {
4146 /* scsi callback required */
4147 if (servicing_interrupt()) {
4148 if (taskq_dispatch(SATA_TXLT_TASKQ(spx),
4149 (task_func_t *)spx->txlt_scsi_pkt->pkt_comp,
4150 (void *)spx->txlt_scsi_pkt, TQ_NOSLEEP) == NULL) {
4151 return (TRAN_BUSY);
4152 }
4153 } else if (taskq_dispatch(SATA_TXLT_TASKQ(spx),
4154 (task_func_t *)spx->txlt_scsi_pkt->pkt_comp,
4155 (void *)spx->txlt_scsi_pkt, TQ_SLEEP) == NULL) {
4156 /* Scheduling the callback failed */
4157 return (TRAN_BUSY);
4158 }
4159 }
4160
4161 return (TRAN_ACCEPT);
4162 }
4163
4164 /*
4165 * SATA translate command: Start Stop Unit
4166 * Translation depends on a command:
4167 *
4168 * Power condition bits will be supported
4169 * and the power level should be maintained by SATL,
4170 * When SATL received a command, it will check the
4171 * power level firstly, and return the status according
4172 * to SAT2 v2.6 and SAT-2 Standby Modifications
4173 *
4174 * SPC-4/SBC-3 SATL ATA power condition SATL SPC/SBC
4175 * -----------------------------------------------------------------------
4176 * SSU_PC1 Active <==> ATA Active <==> SSU:start_bit =1
4177 * SSU_PC2 Idle <==> ATA Idle <==> N/A
4178 * SSU_PC3 Standby <==> ATA Standby <==> N/A
4179 * SSU_PC4 Stopped <==> ATA Standby <==> SSU:start_bit = 0
4180 *
4181 * Unload Media / NOT SUPPORTED YET
4182 * Load Media / NOT SUPPROTED YET
4183 * Immediate bit / NOT SUPPORTED YET (deferred error)
4184 *
4185 * Returns TRAN_ACCEPT or code returned by sata_hba_start() and
4186 * appropriate values in scsi_pkt fields.
4187 */
4188 static int
4189 sata_txlt_start_stop_unit(sata_pkt_txlate_t *spx)
4190 {
4191 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt;
4192 sata_cmd_t *scmd = &spx->txlt_sata_pkt->satapkt_cmd;
4193 int rval, reason;
4194 sata_drive_info_t *sdinfo;
4195 sata_id_t *sata_id;
4196 kmutex_t *cport_mutex = &(SATA_TXLT_CPORT_MUTEX(spx));
4197
4198 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst,
4199 "sata_txlt_start_stop_unit: %d\n", scsipkt->pkt_scbp[4] & 1);
4200
4201 mutex_enter(cport_mutex);
4202
4203 if (((rval = sata_txlt_generic_pkt_info(spx, &reason, 1)) !=
4204 TRAN_ACCEPT) || (reason == CMD_DEV_GONE)) {
4205 mutex_exit(cport_mutex);
4206 return (rval);
4207 }
4208
4209 if (scsipkt->pkt_cdbp[1] & START_STOP_IMMED_MASK) {
4210 /* IMMED bit - not supported */
4211 mutex_exit(cport_mutex);
4212 return (sata_txlt_check_condition(spx, KEY_ILLEGAL_REQUEST,
4213 SD_SCSI_ASC_INVALID_FIELD_IN_CDB));
4214 }
4215
4216 spx->txlt_sata_pkt->satapkt_op_mode |= SATA_OPMODE_SYNCH;
4217 spx->txlt_sata_pkt->satapkt_comp = NULL;
4218
4219 sdinfo = sata_get_device_info(spx->txlt_sata_hba_inst,
4220 &spx->txlt_sata_pkt->satapkt_device);
4221 ASSERT(sdinfo != NULL);
4222 sata_id = &sdinfo->satadrv_id;
4223
4224 switch ((scsipkt->pkt_cdbp[4] & START_STOP_POWER_COND_MASK) >> 4) {
4225 case 0:
4226 if (scsipkt->pkt_cdbp[4] & START_STOP_LOEJ_MASK) {
4227 /* Load/Unload Media - invalid request */
4228 goto err_out;
4229 }
4230 if (scsipkt->pkt_cdbp[4] & START_STOP_START_MASK) {
4231 /* Start Unit */
4232 sata_build_read_verify_cmd(scmd, 1, 5);
4233 scmd->satacmd_flags.sata_copy_out_error_reg = B_TRUE;
4234 /* Transfer command to HBA */
4235 if (sata_hba_start(spx, &rval) != 0) {
4236 /* Pkt not accepted for execution */
4237 mutex_exit(cport_mutex);
4238 return (rval);
4239 }
4240 if (scmd->satacmd_error_reg != 0) {
4241 goto err_out;
4242 }
4243 sdinfo->satadrv_power_level = SATA_POWER_ACTIVE;
4244 } else {
4245 /* Stop Unit */
4246 sata_build_generic_cmd(scmd, SATAC_FLUSH_CACHE);
4247 scmd->satacmd_flags.sata_copy_out_error_reg = B_TRUE;
4248 if (sata_hba_start(spx, &rval) != 0) {
4249 mutex_exit(cport_mutex);
4250 return (rval);
4251 } else {
4252 if (scmd->satacmd_error_reg != 0) {
4253 goto err_out;
4254 }
4255 }
4256 /* ata standby immediate command */
4257 sata_build_generic_cmd(scmd, SATAC_STANDBY_IM);
4258 scmd->satacmd_flags.sata_copy_out_error_reg = B_TRUE;
4259 if (sata_hba_start(spx, &rval) != 0) {
4260 mutex_exit(cport_mutex);
4261 return (rval);
4262 }
4263 if (scmd->satacmd_error_reg != 0) {
4264 goto err_out;
4265 }
4266 sdinfo->satadrv_power_level = SATA_POWER_STOPPED;
4267 }
4268 break;
4269 case 0x1:
4270 sata_build_generic_cmd(scmd, SATAC_IDLE);
4271 scmd->satacmd_flags.sata_copy_out_error_reg = B_TRUE;
4272 if (sata_hba_start(spx, &rval) != 0) {
4273 mutex_exit(cport_mutex);
4274 return (rval);
4275 }
4276 if (scmd->satacmd_error_reg != 0) {
4277 goto err_out;
4278 }
4279 sata_build_read_verify_cmd(scmd, 1, 5);
4280 scmd->satacmd_flags.sata_copy_out_error_reg = B_TRUE;
4281 /* Transfer command to HBA */
4282 if (sata_hba_start(spx, &rval) != 0) {
4283 /* Pkt not accepted for execution */
4284 mutex_exit(cport_mutex);
4285 return (rval);
4286 } else {
4287 if (scmd->satacmd_error_reg != 0) {
4288 goto err_out;
4289 }
4290 }
4291 sdinfo->satadrv_power_level = SATA_POWER_ACTIVE;
4292 break;
4293 case 0x2:
4294 sata_build_generic_cmd(scmd, SATAC_FLUSH_CACHE);
4295 scmd->satacmd_flags.sata_copy_out_error_reg = B_TRUE;
4296 if (!(scsipkt->pkt_cdbp[4] & START_STOP_NOFLUSH_MASK)) {
4297 if (sata_hba_start(spx, &rval) != 0) {
4298 mutex_exit(cport_mutex);
4299 return (rval);
4300 }
4301 if (scmd->satacmd_error_reg != 0) {
4302 goto err_out;
4303 }
4304 }
4305 sata_build_generic_cmd(scmd, SATAC_IDLE);
4306 scmd->satacmd_flags.sata_copy_out_error_reg = B_TRUE;
4307 if (sata_hba_start(spx, &rval) != 0) {
4308 mutex_exit(cport_mutex);
4309 return (rval);
4310 }
4311 if (scmd->satacmd_error_reg != 0) {
4312 goto err_out;
4313 }
4314 if ((scsipkt->pkt_cdbp[3] & START_STOP_MODIFIER_MASK)) {
4315 /*
4316 * POWER CONDITION MODIFIER bit set
4317 * to 0x1 or larger it will be handled
4318 * on the same way as bit = 0x1
4319 */
4320 if (!(sata_id->ai_cmdset84 &
4321 SATA_IDLE_UNLOAD_SUPPORTED)) {
4322 sdinfo->satadrv_power_level = SATA_POWER_IDLE;
4323 break;
4324 }
4325 sata_build_generic_cmd(scmd, SATAC_IDLE_IM);
4326 scmd->satacmd_features_reg = 0x44;
4327 scmd->satacmd_lba_low_lsb = 0x4c;
4328 scmd->satacmd_lba_mid_lsb = 0x4e;
4329 scmd->satacmd_lba_high_lsb = 0x55;
4330 scmd->satacmd_flags.sata_copy_out_error_reg = B_TRUE;
4331 if (sata_hba_start(spx, &rval) != 0) {
4332 mutex_exit(cport_mutex);
4333 return (rval);
4334 }
4335 if (scmd->satacmd_error_reg != 0) {
4336 goto err_out;
4337 }
4338 }
4339 sdinfo->satadrv_power_level = SATA_POWER_IDLE;
4340 break;
4341 case 0x3:
4342 sata_build_generic_cmd(scmd, SATAC_FLUSH_CACHE);
4343 scmd->satacmd_flags.sata_copy_out_error_reg = B_TRUE;
4344 if (!(scsipkt->pkt_cdbp[4] & START_STOP_NOFLUSH_MASK)) {
4345 if (sata_hba_start(spx, &rval) != 0) {
4346 mutex_exit(cport_mutex);
4347 return (rval);
4348 }
4349 if (scmd->satacmd_error_reg != 0) {
4350 goto err_out;
4351 }
4352 }
4353 sata_build_generic_cmd(scmd, SATAC_STANDBY);
4354 scmd->satacmd_flags.sata_copy_out_error_reg = B_TRUE;
4355 if (sata_hba_start(spx, &rval) != 0) {
4356 mutex_exit(cport_mutex);
4357 return (rval);
4358 }
4359 if (scmd->satacmd_error_reg != 0) {
4360 goto err_out;
4361 }
4362 sdinfo->satadrv_power_level = SATA_POWER_STANDBY;
4363 break;
4364 case 0x7:
4365 sata_build_generic_cmd(scmd, SATAC_CHECK_POWER_MODE);
4366 scmd->satacmd_flags.sata_copy_out_sec_count_lsb = B_TRUE;
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 switch (scmd->satacmd_sec_count_lsb) {
4376 case SATA_PWRMODE_STANDBY:
4377 sata_build_generic_cmd(scmd, SATAC_STANDBY);
4378 scmd->satacmd_sec_count_msb = sata_get_standby_timer(
4379 sdinfo->satadrv_standby_timer);
4380 scmd->satacmd_flags.sata_copy_out_error_reg = B_TRUE;
4381 if (sata_hba_start(spx, &rval) != 0) {
4382 mutex_exit(cport_mutex);
4383 return (rval);
4384 } else {
4385 if (scmd->satacmd_error_reg != 0) {
4386 goto err_out;
4387 }
4388 }
4389 break;
4390 case SATA_PWRMODE_IDLE:
4391 sata_build_generic_cmd(scmd, SATAC_IDLE);
4392 scmd->satacmd_sec_count_msb = sata_get_standby_timer(
4393 sdinfo->satadrv_standby_timer);
4394 scmd->satacmd_flags.sata_copy_out_error_reg = B_TRUE;
4395 if (sata_hba_start(spx, &rval) != 0) {
4396 mutex_exit(cport_mutex);
4397 return (rval);
4398 } else {
4399 if (scmd->satacmd_error_reg != 0) {
4400 goto err_out;
4401 }
4402 }
4403 break;
4404 case SATA_PWRMODE_ACTIVE_SPINDOWN:
4405 case SATA_PWRMODE_ACTIVE_SPINUP:
4406 case SATA_PWRMODE_ACTIVE:
4407 sata_build_generic_cmd(scmd, SATAC_IDLE);
4408 scmd->satacmd_sec_count_msb = sata_get_standby_timer(
4409 sdinfo->satadrv_standby_timer);
4410 scmd->satacmd_flags.sata_copy_out_error_reg = B_TRUE;
4411 if (sata_hba_start(spx, &rval) != 0) {
4412 mutex_exit(cport_mutex);
4413 return (rval);
4414 }
4415 if (scmd->satacmd_error_reg != 0) {
4416 goto err_out;
4417 }
4418 sata_build_read_verify_cmd(scmd, 1, 5);
4419 scmd->satacmd_flags.sata_copy_out_error_reg = B_TRUE;
4420 if (sata_hba_start(spx, &rval) != 0) {
4421 mutex_exit(cport_mutex);
4422 return (rval);
4423 }
4424 if (scmd->satacmd_error_reg != 0) {
4425 goto err_out;
4426 }
4427 break;
4428 default:
4429 goto err_out;
4430 }
4431 break;
4432 case 0xb:
4433 if ((sata_get_standby_timer(sdinfo->satadrv_standby_timer) ==
4434 0) || (!(sata_id->ai_cap & SATA_STANDBYTIMER))) {
4435 mutex_exit(cport_mutex);
4436 return (sata_txlt_check_condition(spx,
4437 KEY_ILLEGAL_REQUEST,
4438 SD_SCSI_ASC_INVALID_FIELD_IN_CDB));
4439 }
4440 sata_build_generic_cmd(scmd, SATAC_FLUSH_CACHE);
4441 scmd->satacmd_flags.sata_copy_out_error_reg = B_TRUE;
4442 if (!(scsipkt->pkt_cdbp[4] & START_STOP_NOFLUSH_MASK)) {
4443 if (sata_hba_start(spx, &rval) != 0) {
4444 mutex_exit(cport_mutex);
4445 return (rval);
4446 }
4447 if (scmd->satacmd_error_reg != 0) {
4448 goto err_out;
4449 }
4450 sata_build_generic_cmd(scmd, SATAC_STANDBY_IM);
4451 scmd->satacmd_flags.sata_copy_out_error_reg = B_TRUE;
4452 if (sata_hba_start(spx, &rval) != 0) {
4453 mutex_exit(cport_mutex);
4454 return (rval);
4455 }
4456 if (scmd->satacmd_error_reg != 0) {
4457 goto err_out;
4458 }
4459 }
4460 bzero(sdinfo->satadrv_standby_timer, sizeof (uchar_t) * 4);
4461 break;
4462 default:
4463 err_out:
4464 mutex_exit(cport_mutex);
4465 return (sata_txlt_check_condition(spx, KEY_ILLEGAL_REQUEST,
4466 SD_SCSI_ASC_INVALID_FIELD_IN_CDB));
4467 }
4468
4469 /*
4470 * Since it was a synchronous command,
4471 * a callback function will be called directly.
4472 */
4473 mutex_exit(cport_mutex);
4474 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst,
4475 "synchronous execution status %x\n",
4476 spx->txlt_sata_pkt->satapkt_reason);
4477
4478 if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0 &&
4479 scsipkt->pkt_comp != NULL) {
4480 sata_set_arq_data(spx->txlt_sata_pkt);
4481 if (servicing_interrupt()) {
4482 if (taskq_dispatch(SATA_TXLT_TASKQ(spx),
4483 (task_func_t *)spx->txlt_scsi_pkt->pkt_comp,
4484 (void *)spx->txlt_scsi_pkt, TQ_NOSLEEP) == NULL) {
4485 return (TRAN_BUSY);
4486 }
4487 } else if (taskq_dispatch(SATA_TXLT_TASKQ(spx),
4488 (task_func_t *)spx->txlt_scsi_pkt->pkt_comp,
4489 (void *)spx->txlt_scsi_pkt, TQ_SLEEP) == NULL) {
4490 /* Scheduling the callback failed */
4491 return (TRAN_BUSY);
4492 }
4493 }
4494 else
4495
4496 sata_txlt_nodata_cmd_completion(spx->txlt_sata_pkt);
4497
4498 return (TRAN_ACCEPT);
4499
4500 }
4501
4502 /*
4503 * SATA translate command: Read Capacity.
4504 * Emulated command for SATA disks.
4505 * Capacity is retrieved from cached Idenifty Device data.
4506 * Identify Device data shows effective disk capacity, not the native
4507 * capacity, which may be limitted by Set Max Address command.
4508 * This is ATA version for SATA hard disks.
4509 *
4510 * Returns TRAN_ACCEPT and appropriate values in scsi_pkt fields.
4511 */
4512 static int
4513 sata_txlt_read_capacity(sata_pkt_txlate_t *spx)
4514 {
4515 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt;
4516 struct buf *bp = spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp;
4517 sata_drive_info_t *sdinfo;
4518 uint64_t val;
4519 uchar_t *rbuf;
4520 int rval, reason;
4521 kmutex_t *cport_mutex = &(SATA_TXLT_CPORT_MUTEX(spx));
4522
4523 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst,
4524 "sata_txlt_read_capacity: ", NULL);
4525
4526 mutex_enter(cport_mutex);
4527
4528 if (((rval = sata_txlt_generic_pkt_info(spx, &reason, 0)) !=
4529 TRAN_ACCEPT) || (reason == CMD_DEV_GONE)) {
4530 mutex_exit(cport_mutex);
4531 return (rval);
4532 }
4533
4534 scsipkt->pkt_reason = CMD_CMPLT;
4535 scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET |
4536 STATE_SENT_CMD | STATE_GOT_STATUS;
4537 *scsipkt->pkt_scbp = STATUS_GOOD;
4538 if (bp != NULL && bp->b_un.b_addr && bp->b_bcount) {
4539 /*
4540 * Because it is fully emulated command storing data
4541 * programatically in the specified buffer, release
4542 * preallocated DMA resources before storing data in the buffer,
4543 * so no unwanted DMA sync would take place.
4544 */
4545 sata_scsi_dmafree(NULL, scsipkt);
4546
4547 sdinfo = sata_get_device_info(
4548 spx->txlt_sata_hba_inst,
4549 &spx->txlt_sata_pkt->satapkt_device);
4550
4551 /*
4552 * As per SBC-3, the "returned LBA" is either the highest
4553 * addressable LBA or 0xffffffff, whichever is smaller.
4554 */
4555 val = MIN(sdinfo->satadrv_capacity - 1, UINT32_MAX);
4556
4557 rbuf = (uchar_t *)bp->b_un.b_addr;
4558 /* Need to swap endians to match scsi format */
4559 rbuf[0] = (val >> 24) & 0xff;
4560 rbuf[1] = (val >> 16) & 0xff;
4561 rbuf[2] = (val >> 8) & 0xff;
4562 rbuf[3] = val & 0xff;
4563 /* block size - always 512 bytes, for now */
4564 rbuf[4] = 0;
4565 rbuf[5] = 0;
4566 rbuf[6] = 0x02;
4567 rbuf[7] = 0;
4568 scsipkt->pkt_state |= STATE_XFERRED_DATA;
4569 scsipkt->pkt_resid = 0;
4570
4571 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst, "%d\n",
4572 sdinfo->satadrv_capacity -1);
4573 }
4574 mutex_exit(cport_mutex);
4575 /*
4576 * If a callback was requested, do it now.
4577 */
4578 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst,
4579 "Scsi_pkt completion reason %x\n", scsipkt->pkt_reason);
4580
4581 if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0 &&
4582 scsipkt->pkt_comp != NULL) {
4583 /* scsi callback required */
4584 if (servicing_interrupt()) {
4585 if (taskq_dispatch(SATA_TXLT_TASKQ(spx),
4586 (task_func_t *)spx->txlt_scsi_pkt->pkt_comp,
4587 (void *)spx->txlt_scsi_pkt, TQ_NOSLEEP) == NULL) {
4588 return (TRAN_BUSY);
4589 }
4590 } else if (taskq_dispatch(SATA_TXLT_TASKQ(spx),
4591 (task_func_t *)spx->txlt_scsi_pkt->pkt_comp,
4592 (void *)spx->txlt_scsi_pkt, TQ_SLEEP) == NULL) {
4593 /* Scheduling the callback failed */
4594 return (TRAN_BUSY);
4595 }
4596 }
4597
4598 return (TRAN_ACCEPT);
4599 }
4600
4601 /*
4602 * SATA translate command: Read Capacity (16).
4603 * Emulated command for SATA disks.
4604 * Info is retrieved from cached Identify Device data.
4605 * Implemented to SBC-3 (draft 21) and SAT-2 (final) specifications.
4606 *
4607 * Returns TRAN_ACCEPT and appropriate values in scsi_pkt fields.
4608 */
4609 static int
4610 sata_txlt_read_capacity16(sata_pkt_txlate_t *spx)
4611 {
4612 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt;
4613 struct buf *bp = spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp;
4614 sata_drive_info_t *sdinfo;
4615 uint64_t val;
4616 uint16_t l2p_exp;
4617 uchar_t *rbuf;
4618 int rval, reason;
4619 #define TPE 0x80
4620 #define TPRZ 0x40
4621 kmutex_t *cport_mutex = &(SATA_TXLT_CPORT_MUTEX(spx));
4622
4623 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst,
4624 "sata_txlt_read_capacity: ", NULL);
4625
4626 mutex_enter(cport_mutex);
4627
4628 if (((rval = sata_txlt_generic_pkt_info(spx, &reason, 0)) !=
4629 TRAN_ACCEPT) || (reason == CMD_DEV_GONE)) {
4630 mutex_exit(cport_mutex);
4631 return (rval);
4632 }
4633
4634 scsipkt->pkt_reason = CMD_CMPLT;
4635 scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET |
4636 STATE_SENT_CMD | STATE_GOT_STATUS;
4637 if (bp != NULL && bp->b_un.b_addr && bp->b_bcount) {
4638 /*
4639 * Because it is fully emulated command storing data
4640 * programatically in the specified buffer, release
4641 * preallocated DMA resources before storing data in the buffer,
4642 * so no unwanted DMA sync would take place.
4643 */
4644 sata_scsi_dmafree(NULL, scsipkt);
4645
4646 /* Check SERVICE ACTION field */
4647 if ((scsipkt->pkt_cdbp[1] & 0x1f) !=
4648 SSVC_ACTION_READ_CAPACITY_G4) {
4649 mutex_exit(cport_mutex);
4650 return (sata_txlt_check_condition(spx,
4651 KEY_ILLEGAL_REQUEST,
4652 SD_SCSI_ASC_INVALID_FIELD_IN_CDB));
4653 }
4654
4655 /* Check LBA field */
4656 if ((scsipkt->pkt_cdbp[2] != 0) ||
4657 (scsipkt->pkt_cdbp[3] != 0) ||
4658 (scsipkt->pkt_cdbp[4] != 0) ||
4659 (scsipkt->pkt_cdbp[5] != 0) ||
4660 (scsipkt->pkt_cdbp[6] != 0) ||
4661 (scsipkt->pkt_cdbp[7] != 0) ||
4662 (scsipkt->pkt_cdbp[8] != 0) ||
4663 (scsipkt->pkt_cdbp[9] != 0)) {
4664 mutex_exit(cport_mutex);
4665 return (sata_txlt_check_condition(spx,
4666 KEY_ILLEGAL_REQUEST,
4667 SD_SCSI_ASC_INVALID_FIELD_IN_CDB));
4668 }
4669
4670 /* Check PMI bit */
4671 if (scsipkt->pkt_cdbp[14] & 0x1) {
4672 mutex_exit(cport_mutex);
4673 return (sata_txlt_check_condition(spx,
4674 KEY_ILLEGAL_REQUEST,
4675 SD_SCSI_ASC_INVALID_FIELD_IN_CDB));
4676 }
4677
4678 *scsipkt->pkt_scbp = STATUS_GOOD;
4679
4680 sdinfo = sata_get_device_info(
4681 spx->txlt_sata_hba_inst,
4682 &spx->txlt_sata_pkt->satapkt_device);
4683
4684 /* last logical block address */
4685 val = MIN(sdinfo->satadrv_capacity - 1,
4686 SCSI_READ_CAPACITY16_MAX_LBA);
4687
4688 /* logical to physical block size exponent */
4689 l2p_exp = 0;
4690 if (sdinfo->satadrv_id.ai_phys_sect_sz & SATA_L2PS_CHECK_BIT) {
4691 /* physical/logical sector size word is valid */
4692
4693 if (sdinfo->satadrv_id.ai_phys_sect_sz &
4694 SATA_L2PS_HAS_MULT) {
4695 /* multiple logical sectors per phys sectors */
4696 l2p_exp =
4697 sdinfo->satadrv_id.ai_phys_sect_sz &
4698 SATA_L2PS_EXP_MASK;
4699 }
4700 }
4701
4702 rbuf = (uchar_t *)bp->b_un.b_addr;
4703 bzero(rbuf, bp->b_bcount);
4704
4705 /* returned logical block address */
4706 rbuf[0] = (val >> 56) & 0xff;
4707 rbuf[1] = (val >> 48) & 0xff;
4708 rbuf[2] = (val >> 40) & 0xff;
4709 rbuf[3] = (val >> 32) & 0xff;
4710 rbuf[4] = (val >> 24) & 0xff;
4711 rbuf[5] = (val >> 16) & 0xff;
4712 rbuf[6] = (val >> 8) & 0xff;
4713 rbuf[7] = val & 0xff;
4714
4715 /* logical block length in bytes = 512 (for now) */
4716 /* rbuf[8] = 0; */
4717 /* rbuf[9] = 0; */
4718 rbuf[10] = 0x02;
4719 /* rbuf[11] = 0; */
4720
4721 /* p_type, prot_en, unspecified by SAT-2 */
4722 /* rbuf[12] = 0; */
4723
4724 /* p_i_exponent, undefined by SAT-2 */
4725 /* logical blocks per physical block exponent */
4726 rbuf[13] = l2p_exp;
4727
4728 /* lowest aligned logical block address = 0 (for now) */
4729 /* tpe and tprz as defined in T10/10-079 r0 */
4730 if (sdinfo->satadrv_id.ai_addsupported &
4731 SATA_DETERMINISTIC_READ) {
4732 if (sdinfo->satadrv_id.ai_addsupported &
4733 SATA_READ_ZERO) {
4734 rbuf[14] |= TPRZ;
4735 } else {
4736 rbuf[14] |= TPE;
4737 }
4738 }
4739 /* rbuf[15] = 0; */
4740
4741 scsipkt->pkt_state |= STATE_XFERRED_DATA;
4742 scsipkt->pkt_resid = 0;
4743
4744 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst, "%llu\n",
4745 sdinfo->satadrv_capacity -1);
4746 }
4747
4748 mutex_exit(cport_mutex);
4749
4750 /*
4751 * If a callback was requested, do it now.
4752 */
4753 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst,
4754 "Scsi_pkt completion reason %x\n", scsipkt->pkt_reason);
4755
4756 if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0 &&
4757 scsipkt->pkt_comp != NULL) {
4758 /* scsi callback required */
4759 if (servicing_interrupt()) {
4760 if (taskq_dispatch(SATA_TXLT_TASKQ(spx),
4761 (task_func_t *)spx->txlt_scsi_pkt->pkt_comp,
4762 (void *)spx->txlt_scsi_pkt, TQ_NOSLEEP) == NULL) {
4763 return (TRAN_BUSY);
4764 }
4765 } else if (taskq_dispatch(SATA_TXLT_TASKQ(spx),
4766 (task_func_t *)spx->txlt_scsi_pkt->pkt_comp,
4767 (void *)spx->txlt_scsi_pkt, TQ_SLEEP) == NULL) {
4768 /* Scheduling the callback failed */
4769 return (TRAN_BUSY);
4770 }
4771 }
4772
4773 return (TRAN_ACCEPT);
4774 }
4775
4776 /*
4777 * Translate command: UNMAP
4778 *
4779 * The function cannot be called in interrupt context since it may sleep.
4780 */
4781 static int
4782 sata_txlt_unmap(sata_pkt_txlate_t *spx)
4783 {
4784 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt;
4785 sata_cmd_t *scmd = &spx->txlt_sata_pkt->satapkt_cmd;
4786 struct buf *bp = spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp;
4787 uint16_t count = 0;
4788 int synch;
4789 int rval, reason;
4790 int i, x;
4791 int bdlen = 0;
4792 int ranges = 0;
4793 int paramlen = 8;
4794 uint8_t *data, *tmpbd;
4795 sata_drive_info_t *sdinfo;
4796 kmutex_t *cport_mutex = &(SATA_TXLT_CPORT_MUTEX(spx));
4797 #define TRIM 0x1
4798
4799 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst,
4800 "sata_txlt_unmap: ", NULL);
4801
4802 mutex_enter(cport_mutex);
4803
4804 sdinfo = sata_get_device_info(spx->txlt_sata_hba_inst,
4805 &spx->txlt_sata_pkt->satapkt_device);
4806 if (sdinfo != NULL) {
4807 SATADBG2(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst,
4808 "DSM support 0x%x, max number of 512 byte blocks of LBA "
4809 "range entries 0x%x\n", sdinfo->satadrv_id.ai_dsm,
4810 sdinfo->satadrv_id.ai_maxcount);
4811 }
4812
4813 rval = sata_txlt_generic_pkt_info(spx, &reason, 1);
4814 if ((rval != TRAN_ACCEPT) || (reason == CMD_DEV_GONE)) {
4815 mutex_exit(cport_mutex);
4816 return (rval);
4817 }
4818
4819 /*
4820 * Need to modify bp to have TRIM data instead of UNMAP data.
4821 * Start by getting the block descriptor data length by subtracting
4822 * the 8 byte parameter list header from the parameter list length.
4823 * The block descriptor size has to be a multiple of 16 bytes.
4824 */
4825 bdlen = scsipkt->pkt_cdbp[7];
4826 bdlen = (bdlen << 8) + scsipkt->pkt_cdbp[8] - paramlen;
4827 if ((bdlen < 0) || ((bdlen % 16) != 0) ||
4828 (bdlen > (bp->b_bcount - paramlen))) {
4829 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst,
4830 "sata_txlt_unmap: invalid block descriptor length", NULL);
4831 mutex_exit(cport_mutex);
4832 return ((sata_txlt_check_condition(spx, KEY_ILLEGAL_REQUEST,
4833 SD_SCSI_ASC_INVALID_FIELD_IN_CDB)));
4834 }
4835 /*
4836 * If there are no parameter data or block descriptors, it is not
4837 * considered an error so just complete the command without sending
4838 * TRIM.
4839 */
4840 if ((bdlen == 0) || (bp == NULL) || (bp->b_un.b_addr == NULL) ||
4841 (bp->b_bcount == 0)) {
4842 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst,
4843 "sata_txlt_unmap: no parameter data or block descriptors",
4844 NULL);
4845 mutex_exit(cport_mutex);
4846 return (sata_txlt_unmap_nodata_cmd(spx));
4847 }
4848 tmpbd = (uint8_t *)bp->b_un.b_addr + paramlen;
4849 data = kmem_zalloc(bdlen, KM_SLEEP);
4850
4851 /*
4852 * Loop through all the UNMAP block descriptors and convert the data
4853 * into TRIM format.
4854 */
4855 for (i = 0, x = 0; i < bdlen; i += 16, x += 8) {
4856 /* get range length */
4857 data[x] = tmpbd[i+7];
4858 data[x+1] = tmpbd[i+6];
4859 /* get LBA */
4860 data[x+2] = tmpbd[i+5];
4861 data[x+3] = tmpbd[i+4];
4862 data[x+4] = tmpbd[i+3];
4863 data[x+5] = tmpbd[i+2];
4864 data[x+6] = tmpbd[i+11];
4865 data[x+7] = tmpbd[i+10];
4866
4867 ranges++;
4868 }
4869
4870 /*
4871 * The TRIM command expects the data buffer to be a multiple of
4872 * 512-byte blocks of range entries. This means that the UNMAP buffer
4873 * may be too small. Free the original DMA resources and create a
4874 * local buffer.
4875 */
4876 sata_common_free_dma_rsrcs(spx);
4877
4878 /*
4879 * Get count of 512-byte blocks of range entries. The length
4880 * of a range entry is 8 bytes which means one count has 64 range
4881 * entries.
4882 */
4883 count = (ranges + 63)/64;
4884
4885 /* Allocate a buffer that is a multiple of 512 bytes. */
4886 mutex_exit(cport_mutex);
4887 bp = sata_alloc_local_buffer(spx, count * 512);
4888 if (bp == NULL) {
4889 SATADBG1(SATA_DBG_ATAPI, spx->txlt_sata_hba_inst,
4890 "sata_txlt_unmap: "
4891 "cannot allocate buffer for TRIM command", NULL);
4892 kmem_free(data, bdlen);
4893 return (TRAN_BUSY);
4894 }
4895 bp_mapin(bp); /* make data buffer accessible */
4896 mutex_enter(cport_mutex);
4897
4898 bzero(bp->b_un.b_addr, bp->b_bcount);
4899 bcopy(data, bp->b_un.b_addr, x);
4900 kmem_free(data, bdlen);
4901 rval = ddi_dma_sync(spx->txlt_buf_dma_handle, 0, 0,
4902 DDI_DMA_SYNC_FORDEV);
4903 ASSERT(rval == DDI_SUCCESS);
4904
4905 scmd->satacmd_flags.sata_data_direction = SATA_DIR_WRITE;
4906 scmd->satacmd_addr_type = ATA_ADDR_LBA48;
4907 scmd->satacmd_cmd_reg = SATAC_DSM;
4908 scmd->satacmd_sec_count_msb = (count >> 8) & 0xff;
4909 scmd->satacmd_sec_count_lsb = count & 0xff;
4910 scmd->satacmd_features_reg = TRIM;
4911 scmd->satacmd_device_reg = SATA_ADH_LBA;
4912 scmd->satacmd_status_reg = 0;
4913 scmd->satacmd_error_reg = 0;
4914
4915 /* Start processing command */
4916 if (!(spx->txlt_sata_pkt->satapkt_op_mode & SATA_OPMODE_SYNCH)) {
4917 spx->txlt_sata_pkt->satapkt_comp =
4918 sata_txlt_unmap_completion;
4919 synch = FALSE;
4920 } else {
4921 synch = TRUE;
4922 }
4923
4924 if (sata_hba_start(spx, &rval) != 0) {
4925 mutex_exit(cport_mutex);
4926 return (rval);
4927 }
4928
4929 mutex_exit(cport_mutex);
4930
4931 if (synch) {
4932 sata_txlt_unmap_completion(spx->txlt_sata_pkt);
4933 }
4934
4935 return (TRAN_ACCEPT);
4936 }
4937
4938 /*
4939 * SATA translate command: Mode Sense.
4940 * Translated into appropriate SATA command or emulated.
4941 * Saved Values Page Control (03) are not supported.
4942 *
4943 * NOTE: only caching mode sense page is currently implemented.
4944 *
4945 * Returns TRAN_ACCEPT and appropriate values in scsi_pkt fields.
4946 */
4947
4948 #define LLBAA 0x10 /* Long LBA Accepted */
4949
4950 static int
4951 sata_txlt_mode_sense(sata_pkt_txlate_t *spx)
4952 {
4953 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt;
4954 struct buf *bp = spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp;
4955 sata_drive_info_t *sdinfo;
4956 sata_id_t *sata_id;
4957 struct scsi_extended_sense *sense;
4958 int len, bdlen, count, alc_len;
4959 int pc; /* Page Control code */
4960 uint8_t *buf; /* mode sense buffer */
4961 int rval, reason;
4962 kmutex_t *cport_mutex = &(SATA_TXLT_CPORT_MUTEX(spx));
4963
4964 SATADBG2(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst,
4965 "sata_txlt_mode_sense, pc %x page code 0x%02x\n",
4966 spx->txlt_scsi_pkt->pkt_cdbp[2] >> 6,
4967 spx->txlt_scsi_pkt->pkt_cdbp[2] & 0x3f);
4968
4969 if (servicing_interrupt()) {
4970 buf = kmem_zalloc(1024, KM_NOSLEEP);
4971 if (buf == NULL) {
4972 return (TRAN_BUSY);
4973 }
4974 } else {
4975 buf = kmem_zalloc(1024, KM_SLEEP);
4976 }
4977
4978 mutex_enter(cport_mutex);
4979
4980 if (((rval = sata_txlt_generic_pkt_info(spx, &reason, 0)) !=
4981 TRAN_ACCEPT) || (reason == CMD_DEV_GONE)) {
4982 mutex_exit(cport_mutex);
4983 kmem_free(buf, 1024);
4984 return (rval);
4985 }
4986
4987 scsipkt->pkt_reason = CMD_CMPLT;
4988 scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET |
4989 STATE_SENT_CMD | STATE_GOT_STATUS;
4990
4991 pc = scsipkt->pkt_cdbp[2] >> 6;
4992
4993 if (bp != NULL && bp->b_un.b_addr && bp->b_bcount) {
4994 /*
4995 * Because it is fully emulated command storing data
4996 * programatically in the specified buffer, release
4997 * preallocated DMA resources before storing data in the buffer,
4998 * so no unwanted DMA sync would take place.
4999 */
5000 sata_scsi_dmafree(NULL, scsipkt);
5001
5002 len = 0;
5003 bdlen = 0;
5004 if (!(scsipkt->pkt_cdbp[1] & 8)) {
5005 if (scsipkt->pkt_cdbp[0] == SCMD_MODE_SENSE_G1 &&
5006 (scsipkt->pkt_cdbp[1] & LLBAA))
5007 bdlen = 16;
5008 else
5009 bdlen = 8;
5010 }
5011 /* Build mode parameter header */
5012 if (spx->txlt_scsi_pkt->pkt_cdbp[0] == SCMD_MODE_SENSE) {
5013 /* 4-byte mode parameter header */
5014 buf[len++] = 0; /* mode data length */
5015 buf[len++] = 0; /* medium type */
5016 buf[len++] = 0; /* dev-specific param */
5017 buf[len++] = bdlen; /* Block Descriptor length */
5018 } else {
5019 /* 8-byte mode parameter header */
5020 buf[len++] = 0; /* mode data length */
5021 buf[len++] = 0;
5022 buf[len++] = 0; /* medium type */
5023 buf[len++] = 0; /* dev-specific param */
5024 if (bdlen == 16)
5025 buf[len++] = 1; /* long lba descriptor */
5026 else
5027 buf[len++] = 0;
5028 buf[len++] = 0;
5029 buf[len++] = 0; /* Block Descriptor length */
5030 buf[len++] = bdlen;
5031 }
5032
5033 sdinfo = sata_get_device_info(
5034 spx->txlt_sata_hba_inst,
5035 &spx->txlt_sata_pkt->satapkt_device);
5036
5037 /* Build block descriptor only if not disabled (DBD) */
5038 if ((scsipkt->pkt_cdbp[1] & 0x08) == 0) {
5039 /* Block descriptor - direct-access device format */
5040 if (bdlen == 8) {
5041 /* build regular block descriptor */
5042 buf[len++] =
5043 (sdinfo->satadrv_capacity >> 24) & 0xff;
5044 buf[len++] =
5045 (sdinfo->satadrv_capacity >> 16) & 0xff;
5046 buf[len++] =
5047 (sdinfo->satadrv_capacity >> 8) & 0xff;
5048 buf[len++] = sdinfo->satadrv_capacity & 0xff;
5049 buf[len++] = 0; /* density code */
5050 buf[len++] = 0;
5051 if (sdinfo->satadrv_type ==
5052 SATA_DTYPE_ATADISK)
5053 buf[len++] = 2;
5054 else
5055 /* ATAPI */
5056 buf[len++] = 8;
5057 buf[len++] = 0;
5058 } else if (bdlen == 16) {
5059 /* Long LBA Accepted */
5060 /* build long lba block descriptor */
5061 #ifndef __lock_lint
5062 buf[len++] =
5063 (sdinfo->satadrv_capacity >> 56) & 0xff;
5064 buf[len++] =
5065 (sdinfo->satadrv_capacity >> 48) & 0xff;
5066 buf[len++] =
5067 (sdinfo->satadrv_capacity >> 40) & 0xff;
5068 buf[len++] =
5069 (sdinfo->satadrv_capacity >> 32) & 0xff;
5070 #endif
5071 buf[len++] =
5072 (sdinfo->satadrv_capacity >> 24) & 0xff;
5073 buf[len++] =
5074 (sdinfo->satadrv_capacity >> 16) & 0xff;
5075 buf[len++] =
5076 (sdinfo->satadrv_capacity >> 8) & 0xff;
5077 buf[len++] = sdinfo->satadrv_capacity & 0xff;
5078 buf[len++] = 0;
5079 buf[len++] = 0; /* density code */
5080 buf[len++] = 0;
5081 buf[len++] = 0;
5082 if (sdinfo->satadrv_type ==
5083 SATA_DTYPE_ATADISK)
5084 buf[len++] = 2;
5085 else
5086 /* ATAPI */
5087 buf[len++] = 8;
5088 buf[len++] = 0;
5089 }
5090 }
5091
5092 sata_id = &sdinfo->satadrv_id;
5093
5094 /*
5095 * Add requested pages.
5096 * Page 3 and 4 are obsolete and we are not supporting them.
5097 * We deal now with:
5098 * caching (read/write cache control).
5099 * We should eventually deal with following mode pages:
5100 * error recovery (0x01),
5101 * power condition (0x1a),
5102 * exception control page (enables SMART) (0x1c),
5103 * enclosure management (ses),
5104 * protocol-specific port mode (port control).
5105 */
5106 switch (scsipkt->pkt_cdbp[2] & 0x3f) {
5107 case MODEPAGE_RW_ERRRECOV:
5108 /* DAD_MODE_ERR_RECOV */
5109 /* R/W recovery */
5110 len += sata_build_msense_page_1(sdinfo, pc, buf+len);
5111 break;
5112 case MODEPAGE_CACHING:
5113 /* DAD_MODE_CACHE */
5114 /* Reject not supported request for saved parameters */
5115 if (pc == 3) {
5116 *scsipkt->pkt_scbp = STATUS_CHECK;
5117 sense = sata_arq_sense(spx);
5118 sense->es_key = KEY_ILLEGAL_REQUEST;
5119 sense->es_add_code =
5120 SD_SCSI_ASC_SAVING_PARAMS_NOT_SUPPORTED;
5121 goto done;
5122 }
5123
5124 /* caching */
5125 len += sata_build_msense_page_8(sdinfo, pc, buf+len);
5126 break;
5127 case MODEPAGE_INFO_EXCPT:
5128 /* exception cntrl */
5129 if (sata_id->ai_cmdset82 & SATA_SMART_SUPPORTED) {
5130 len += sata_build_msense_page_1c(sdinfo, pc,
5131 buf+len);
5132 }
5133 else
5134 goto err;
5135 break;
5136 case MODEPAGE_POWER_COND:
5137 /* DAD_MODE_POWER_COND */
5138 /* power condition */
5139 len += sata_build_msense_page_1a(sdinfo, pc, buf+len);
5140 break;
5141
5142 case MODEPAGE_ACOUSTIC_MANAG:
5143 /* acoustic management */
5144 len += sata_build_msense_page_30(sdinfo, pc, buf+len);
5145 break;
5146 case MODEPAGE_ALLPAGES:
5147 /* all pages */
5148 len += sata_build_msense_page_1(sdinfo, pc, buf+len);
5149 len += sata_build_msense_page_8(sdinfo, pc, buf+len);
5150 len += sata_build_msense_page_1a(sdinfo, pc, buf+len);
5151 if (sata_id->ai_cmdset82 & SATA_SMART_SUPPORTED) {
5152 len += sata_build_msense_page_1c(sdinfo, pc,
5153 buf+len);
5154 }
5155 len += sata_build_msense_page_30(sdinfo, pc, buf+len);
5156 break;
5157 default:
5158 err:
5159 /* Invalid request */
5160 *scsipkt->pkt_scbp = STATUS_CHECK;
5161 sense = sata_arq_sense(spx);
5162 sense->es_key = KEY_ILLEGAL_REQUEST;
5163 sense->es_add_code = SD_SCSI_ASC_INVALID_FIELD_IN_CDB;
5164 goto done;
5165 }
5166
5167 /* fix total mode data length */
5168 if (spx->txlt_scsi_pkt->pkt_cdbp[0] == SCMD_MODE_SENSE) {
5169 /* 4-byte mode parameter header */
5170 buf[0] = len - 1; /* mode data length */
5171 } else {
5172 buf[0] = (len -2) >> 8;
5173 buf[1] = (len -2) & 0xff;
5174 }
5175
5176
5177 /* Check allocation length */
5178 if (scsipkt->pkt_cdbp[0] == SCMD_MODE_SENSE) {
5179 alc_len = scsipkt->pkt_cdbp[4];
5180 } else {
5181 alc_len = scsipkt->pkt_cdbp[7];
5182 alc_len = (len << 8) | scsipkt->pkt_cdbp[8];
5183 }
5184 /*
5185 * We do not check for possible parameters truncation
5186 * (alc_len < len) assuming that the target driver works
5187 * correctly. Just avoiding overrun.
5188 * Copy no more than requested and possible, buffer-wise.
5189 */
5190 count = MIN(alc_len, len);
5191 count = MIN(bp->b_bcount, count);
5192 bcopy(buf, bp->b_un.b_addr, count);
5193
5194 scsipkt->pkt_state |= STATE_XFERRED_DATA;
5195 scsipkt->pkt_resid = alc_len > count ? alc_len - count : 0;
5196 }
5197 *scsipkt->pkt_scbp = STATUS_GOOD;
5198 done:
5199 mutex_exit(cport_mutex);
5200 (void) kmem_free(buf, 1024);
5201
5202 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst,
5203 "Scsi_pkt completion reason %x\n", scsipkt->pkt_reason);
5204
5205 if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0 &&
5206 scsipkt->pkt_comp != NULL) {
5207 /* scsi callback required */
5208 if (servicing_interrupt()) {
5209 if (taskq_dispatch(SATA_TXLT_TASKQ(spx),
5210 (task_func_t *)spx->txlt_scsi_pkt->pkt_comp,
5211 (void *)spx->txlt_scsi_pkt, TQ_NOSLEEP) == NULL) {
5212 return (TRAN_BUSY);
5213 }
5214 } else if (taskq_dispatch(SATA_TXLT_TASKQ(spx),
5215 (task_func_t *)spx->txlt_scsi_pkt->pkt_comp,
5216 (void *)spx->txlt_scsi_pkt, TQ_SLEEP) == NULL) {
5217 /* Scheduling the callback failed */
5218 return (TRAN_BUSY);
5219 }
5220 }
5221
5222 return (TRAN_ACCEPT);
5223 }
5224
5225
5226 /*
5227 * SATA translate command: Mode Select.
5228 * Translated into appropriate SATA command or emulated.
5229 * Saving parameters is not supported.
5230 * Changing device capacity is not supported (although theoretically
5231 * possible by executing SET FEATURES/SET MAX ADDRESS)
5232 *
5233 * Assumption is that the target driver is working correctly.
5234 *
5235 * More than one SATA command may be executed to perform operations specified
5236 * by mode select pages. The first error terminates further execution.
5237 * Operations performed successully are not backed-up in such case.
5238 *
5239 * NOTE: Implemented pages:
5240 * - caching page
5241 * - informational exception page
5242 * - acoustic management page
5243 * - power condition page
5244 * Caching setup is remembered so it could be re-stored in case of
5245 * an unexpected device reset.
5246 *
5247 * Returns TRAN_XXXX.
5248 * If TRAN_ACCEPT is returned, appropriate values are set in scsi_pkt fields.
5249 */
5250
5251 static int
5252 sata_txlt_mode_select(sata_pkt_txlate_t *spx)
5253 {
5254 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt;
5255 struct buf *bp = spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp;
5256 struct scsi_extended_sense *sense;
5257 int len, pagelen, count, pllen;
5258 uint8_t *buf; /* mode select buffer */
5259 int rval, stat, reason;
5260 uint_t nointr_flag;
5261 int dmod = 0;
5262 kmutex_t *cport_mutex = &(SATA_TXLT_CPORT_MUTEX(spx));
5263
5264 SATADBG2(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst,
5265 "sata_txlt_mode_select, pc %x page code 0x%02x\n",
5266 spx->txlt_scsi_pkt->pkt_cdbp[2] >> 6,
5267 spx->txlt_scsi_pkt->pkt_cdbp[2] & 0x3f);
5268
5269 mutex_enter(cport_mutex);
5270
5271 if (((rval = sata_txlt_generic_pkt_info(spx, &reason, 1)) !=
5272 TRAN_ACCEPT) || (reason == CMD_DEV_GONE)) {
5273 mutex_exit(cport_mutex);
5274 return (rval);
5275 }
5276
5277 rval = TRAN_ACCEPT;
5278
5279 scsipkt->pkt_reason = CMD_CMPLT;
5280 scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET |
5281 STATE_SENT_CMD | STATE_GOT_STATUS;
5282 nointr_flag = scsipkt->pkt_flags & FLAG_NOINTR;
5283
5284 /* Reject not supported request */
5285 if (! (scsipkt->pkt_cdbp[1] & 0x10)) { /* No support for PF bit = 0 */
5286 *scsipkt->pkt_scbp = STATUS_CHECK;
5287 sense = sata_arq_sense(spx);
5288 sense->es_key = KEY_ILLEGAL_REQUEST;
5289 sense->es_add_code = SD_SCSI_ASC_INVALID_FIELD_IN_CDB;
5290 goto done;
5291 }
5292
5293 if (scsipkt->pkt_cdbp[0] == SCMD_MODE_SELECT) {
5294 pllen = scsipkt->pkt_cdbp[4];
5295 } else {
5296 pllen = scsipkt->pkt_cdbp[7];
5297 pllen = (pllen << 8) | scsipkt->pkt_cdbp[7];
5298 }
5299
5300 *scsipkt->pkt_scbp = STATUS_GOOD; /* Presumed outcome */
5301
5302 if (bp != NULL && bp->b_un.b_addr && bp->b_bcount && pllen != 0) {
5303 buf = (uint8_t *)bp->b_un.b_addr;
5304 count = MIN(bp->b_bcount, pllen);
5305 scsipkt->pkt_state |= STATE_XFERRED_DATA;
5306 scsipkt->pkt_resid = 0;
5307 pllen = count;
5308
5309 /*
5310 * Check the header to skip the block descriptor(s) - we
5311 * do not support setting device capacity.
5312 * Existing macros do not recognize long LBA dscriptor,
5313 * hence manual calculation.
5314 */
5315 if (scsipkt->pkt_cdbp[0] == SCMD_MODE_SELECT) {
5316 /* 6-bytes CMD, 4 bytes header */
5317 if (count <= 4)
5318 goto done; /* header only */
5319 len = buf[3] + 4;
5320 } else {
5321 /* 10-bytes CMD, 8 bytes header */
5322 if (count <= 8)
5323 goto done; /* header only */
5324 len = buf[6];
5325 len = (len << 8) + buf[7] + 8;
5326 }
5327 if (len >= count)
5328 goto done; /* header + descriptor(s) only */
5329
5330 pllen -= len; /* remaining data length */
5331
5332 /*
5333 * We may be executing SATA command and want to execute it
5334 * in SYNCH mode, regardless of scsi_pkt setting.
5335 * Save scsi_pkt setting and indicate SYNCH mode
5336 */
5337 if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0 &&
5338 scsipkt->pkt_comp != NULL) {
5339 scsipkt->pkt_flags |= FLAG_NOINTR;
5340 }
5341 spx->txlt_sata_pkt->satapkt_op_mode = SATA_OPMODE_SYNCH;
5342
5343 /*
5344 * len is now the offset to a first mode select page
5345 * Process all pages
5346 */
5347 while (pllen > 0) {
5348 switch ((int)buf[len]) {
5349 case MODEPAGE_CACHING:
5350 /* No support for SP (saving) */
5351 if (scsipkt->pkt_cdbp[1] & 0x01) {
5352 *scsipkt->pkt_scbp = STATUS_CHECK;
5353 sense = sata_arq_sense(spx);
5354 sense->es_key = KEY_ILLEGAL_REQUEST;
5355 sense->es_add_code =
5356 SD_SCSI_ASC_INVALID_FIELD_IN_CDB;
5357 goto done;
5358 }
5359 stat = sata_mode_select_page_8(spx,
5360 (struct mode_cache_scsi3 *)&buf[len],
5361 pllen, &pagelen, &rval, &dmod);
5362 /*
5363 * The pagelen value indicates the number of
5364 * parameter bytes already processed.
5365 * The rval is the return value from
5366 * sata_tran_start().
5367 * The stat indicates the overall status of
5368 * the operation(s).
5369 */
5370 if (stat != SATA_SUCCESS)
5371 /*
5372 * Page processing did not succeed -
5373 * all error info is already set-up,
5374 * just return
5375 */
5376 pllen = 0; /* this breaks the loop */
5377 else {
5378 len += pagelen;
5379 pllen -= pagelen;
5380 }
5381 break;
5382
5383 case MODEPAGE_INFO_EXCPT:
5384 stat = sata_mode_select_page_1c(spx,
5385 (struct mode_info_excpt_page *)&buf[len],
5386 pllen, &pagelen, &rval, &dmod);
5387 /*
5388 * The pagelen value indicates the number of
5389 * parameter bytes already processed.
5390 * The rval is the return value from
5391 * sata_tran_start().
5392 * The stat indicates the overall status of
5393 * the operation(s).
5394 */
5395 if (stat != SATA_SUCCESS)
5396 /*
5397 * Page processing did not succeed -
5398 * all error info is already set-up,
5399 * just return
5400 */
5401 pllen = 0; /* this breaks the loop */
5402 else {
5403 len += pagelen;
5404 pllen -= pagelen;
5405 }
5406 break;
5407
5408 case MODEPAGE_ACOUSTIC_MANAG:
5409 stat = sata_mode_select_page_30(spx,
5410 (struct mode_acoustic_management *)
5411 &buf[len], pllen, &pagelen, &rval, &dmod);
5412 /*
5413 * The pagelen value indicates the number of
5414 * parameter bytes already processed.
5415 * The rval is the return value from
5416 * sata_tran_start().
5417 * The stat indicates the overall status of
5418 * the operation(s).
5419 */
5420 if (stat != SATA_SUCCESS)
5421 /*
5422 * Page processing did not succeed -
5423 * all error info is already set-up,
5424 * just return
5425 */
5426 pllen = 0; /* this breaks the loop */
5427 else {
5428 len += pagelen;
5429 pllen -= pagelen;
5430 }
5431
5432 break;
5433 case MODEPAGE_POWER_COND:
5434 stat = sata_mode_select_page_1a(spx,
5435 (struct mode_info_power_cond *)&buf[len],
5436 pllen, &pagelen, &rval, &dmod);
5437 /*
5438 * The pagelen value indicates the number of
5439 * parameter bytes already processed.
5440 * The rval is the return value from
5441 * sata_tran_start().
5442 * The stat indicates the overall status of
5443 * the operation(s).
5444 */
5445 if (stat != SATA_SUCCESS)
5446 /*
5447 * Page processing did not succeed -
5448 * all error info is already set-up,
5449 * just return
5450 */
5451 pllen = 0; /* this breaks the loop */
5452 else {
5453 len += pagelen;
5454 pllen -= pagelen;
5455 }
5456 break;
5457 default:
5458 *scsipkt->pkt_scbp = STATUS_CHECK;
5459 sense = sata_arq_sense(spx);
5460 sense->es_key = KEY_ILLEGAL_REQUEST;
5461 sense->es_add_code =
5462 SD_SCSI_ASC_INVALID_FIELD_IN_PARAMS_LIST;
5463 goto done;
5464 }
5465 }
5466 }
5467 done:
5468 mutex_exit(cport_mutex);
5469 /*
5470 * If device parameters were modified, fetch and store the new
5471 * Identify Device data. Since port mutex could have been released
5472 * for accessing HBA driver, we need to re-check device existence.
5473 */
5474 if (dmod != 0) {
5475 sata_drive_info_t new_sdinfo, *sdinfo;
5476 int rv = 0;
5477
5478 /*
5479 * Following statement has to be changed if this function is
5480 * used for devices other than SATA hard disks.
5481 */
5482 new_sdinfo.satadrv_type = SATA_DTYPE_ATADISK;
5483
5484 new_sdinfo.satadrv_addr =
5485 spx->txlt_sata_pkt->satapkt_device.satadev_addr;
5486 rv = sata_fetch_device_identify_data(spx->txlt_sata_hba_inst,
5487 &new_sdinfo);
5488
5489 mutex_enter(cport_mutex);
5490 /*
5491 * Since port mutex could have been released when
5492 * accessing HBA driver, we need to re-check that the
5493 * framework still holds the device info structure.
5494 */
5495 sdinfo = sata_get_device_info(spx->txlt_sata_hba_inst,
5496 &spx->txlt_sata_pkt->satapkt_device);
5497 if (sdinfo != NULL) {
5498 /*
5499 * Device still has info structure in the
5500 * sata framework. Copy newly fetched info
5501 */
5502 if (rv == 0) {
5503 sdinfo->satadrv_id = new_sdinfo.satadrv_id;
5504 sata_save_drive_settings(sdinfo);
5505 } else {
5506 /*
5507 * Could not fetch new data - invalidate
5508 * sata_drive_info. That makes device
5509 * unusable.
5510 */
5511 sdinfo->satadrv_type = SATA_DTYPE_UNKNOWN;
5512 sdinfo->satadrv_state = SATA_STATE_UNKNOWN;
5513 }
5514 }
5515 if (rv != 0 || sdinfo == NULL) {
5516 /*
5517 * This changes the overall mode select completion
5518 * reason to a failed one !!!!!
5519 */
5520 *scsipkt->pkt_scbp = STATUS_CHECK;
5521 sense = sata_arq_sense(spx);
5522 scsipkt->pkt_reason = CMD_INCOMPLETE;
5523 rval = TRAN_ACCEPT;
5524 }
5525 mutex_exit(cport_mutex);
5526 }
5527 /* Restore the scsi pkt flags */
5528 scsipkt->pkt_flags &= ~FLAG_NOINTR;
5529 scsipkt->pkt_flags |= nointr_flag;
5530
5531 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst,
5532 "Scsi_pkt completion reason %x\n", scsipkt->pkt_reason);
5533
5534 if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0 &&
5535 scsipkt->pkt_comp != NULL) {
5536 /* scsi callback required */
5537 if (servicing_interrupt()) {
5538 if (taskq_dispatch(SATA_TXLT_TASKQ(spx),
5539 (task_func_t *)spx->txlt_scsi_pkt->pkt_comp,
5540 (void *)spx->txlt_scsi_pkt, TQ_NOSLEEP) == NULL) {
5541 return (TRAN_BUSY);
5542 }
5543 } else if (taskq_dispatch(SATA_TXLT_TASKQ(spx),
5544 (task_func_t *)spx->txlt_scsi_pkt->pkt_comp,
5545 (void *)spx->txlt_scsi_pkt, TQ_SLEEP) == NULL) {
5546 /* Scheduling the callback failed */
5547 return (TRAN_BUSY);
5548 }
5549 }
5550
5551 return (rval);
5552 }
5553
5554 /*
5555 * Translate command: ATA Pass Through
5556 * Incomplete implementation. Only supports No-Data, PIO Data-In, and
5557 * PIO Data-Out protocols. Also supports CK_COND bit.
5558 *
5559 * Mapping of the incoming CDB bytes to the outgoing satacmd bytes is
5560 * described in Table 111 of SAT-2 (Draft 9).
5561 */
5562 static int
5563 sata_txlt_ata_pass_thru(sata_pkt_txlate_t *spx)
5564 {
5565 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt;
5566 sata_cmd_t *scmd = &spx->txlt_sata_pkt->satapkt_cmd;
5567 struct buf *bp = spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp;
5568 int extend;
5569 uint64_t lba;
5570 uint16_t feature, sec_count;
5571 int t_len, synch;
5572 int rval, reason;
5573 kmutex_t *cport_mutex = &(SATA_TXLT_CPORT_MUTEX(spx));
5574
5575 mutex_enter(cport_mutex);
5576
5577 rval = sata_txlt_generic_pkt_info(spx, &reason, 1);
5578 if ((rval != TRAN_ACCEPT) || (reason == CMD_DEV_GONE)) {
5579 mutex_exit(cport_mutex);
5580 return (rval);
5581 }
5582
5583 /* T_DIR bit */
5584 if (scsipkt->pkt_cdbp[2] & SATL_APT_BM_T_DIR)
5585 scmd->satacmd_flags.sata_data_direction = SATA_DIR_READ;
5586 else
5587 scmd->satacmd_flags.sata_data_direction = SATA_DIR_WRITE;
5588
5589 /* MULTIPLE_COUNT field. If non-zero, invalid command (for now). */
5590 if (((scsipkt->pkt_cdbp[1] >> 5) & 0x7) != 0) {
5591 mutex_exit(cport_mutex);
5592 return (sata_txlt_ata_pass_thru_illegal_cmd(spx));
5593 }
5594
5595 /* OFFLINE field. If non-zero, invalid command (for now). */
5596 if (((scsipkt->pkt_cdbp[2] >> 6) & 0x3) != 0) {
5597 mutex_exit(cport_mutex);
5598 return (sata_txlt_ata_pass_thru_illegal_cmd(spx));
5599 }
5600
5601 /* PROTOCOL field */
5602 switch ((scsipkt->pkt_cdbp[1] >> 1) & 0xf) {
5603 case SATL_APT_P_HW_RESET:
5604 case SATL_APT_P_SRST:
5605 case SATL_APT_P_DMA:
5606 case SATL_APT_P_DMA_QUEUED:
5607 case SATL_APT_P_DEV_DIAG:
5608 case SATL_APT_P_DEV_RESET:
5609 case SATL_APT_P_UDMA_IN:
5610 case SATL_APT_P_UDMA_OUT:
5611 case SATL_APT_P_FPDMA:
5612 case SATL_APT_P_RET_RESP:
5613 /* Not yet implemented */
5614 default:
5615 mutex_exit(cport_mutex);
5616 return (sata_txlt_ata_pass_thru_illegal_cmd(spx));
5617
5618 case SATL_APT_P_NON_DATA:
5619 scmd->satacmd_flags.sata_data_direction = SATA_DIR_NODATA_XFER;
5620 break;
5621
5622 case SATL_APT_P_PIO_DATA_IN:
5623 /* If PROTOCOL disagrees with T_DIR, invalid command */
5624 if (scmd->satacmd_flags.sata_data_direction == SATA_DIR_WRITE) {
5625 mutex_exit(cport_mutex);
5626 return (sata_txlt_ata_pass_thru_illegal_cmd(spx));
5627 }
5628
5629 /* if there is a buffer, release its DMA resources */
5630 if ((bp != NULL) && bp->b_un.b_addr && bp->b_bcount) {
5631 sata_scsi_dmafree(NULL, scsipkt);
5632 } else {
5633 /* if there is no buffer, how do you PIO in? */
5634 mutex_exit(cport_mutex);
5635 return (sata_txlt_ata_pass_thru_illegal_cmd(spx));
5636 }
5637
5638 break;
5639
5640 case SATL_APT_P_PIO_DATA_OUT:
5641 /* If PROTOCOL disagrees with T_DIR, invalid command */
5642 if (scmd->satacmd_flags.sata_data_direction == SATA_DIR_READ) {
5643 mutex_exit(cport_mutex);
5644 return (sata_txlt_ata_pass_thru_illegal_cmd(spx));
5645 }
5646
5647 /* if there is a buffer, release its DMA resources */
5648 if ((bp != NULL) && bp->b_un.b_addr && bp->b_bcount) {
5649 sata_scsi_dmafree(NULL, scsipkt);
5650 } else {
5651 /* if there is no buffer, how do you PIO out? */
5652 mutex_exit(cport_mutex);
5653 return (sata_txlt_ata_pass_thru_illegal_cmd(spx));
5654 }
5655
5656 break;
5657 }
5658
5659 /* Parse the ATA cmd fields, transfer some straight to the satacmd */
5660 switch ((uint_t)scsipkt->pkt_cdbp[0]) {
5661 case SPC3_CMD_ATA_COMMAND_PASS_THROUGH12:
5662 feature = scsipkt->pkt_cdbp[3];
5663
5664 sec_count = scsipkt->pkt_cdbp[4];
5665
5666 lba = scsipkt->pkt_cdbp[8] & 0xf;
5667 lba = (lba << 8) | scsipkt->pkt_cdbp[7];
5668 lba = (lba << 8) | scsipkt->pkt_cdbp[6];
5669 lba = (lba << 8) | scsipkt->pkt_cdbp[5];
5670
5671 scmd->satacmd_device_reg = scsipkt->pkt_cdbp[13] & 0xf0;
5672 scmd->satacmd_cmd_reg = scsipkt->pkt_cdbp[9];
5673
5674 break;
5675
5676 case SPC3_CMD_ATA_COMMAND_PASS_THROUGH16:
5677 if (scsipkt->pkt_cdbp[1] & SATL_APT_BM_EXTEND) {
5678 extend = 1;
5679
5680 feature = scsipkt->pkt_cdbp[3];
5681 feature = (feature << 8) | scsipkt->pkt_cdbp[4];
5682
5683 sec_count = scsipkt->pkt_cdbp[5];
5684 sec_count = (sec_count << 8) | scsipkt->pkt_cdbp[6];
5685
5686 lba = scsipkt->pkt_cdbp[11];
5687 lba = (lba << 8) | scsipkt->pkt_cdbp[12];
5688 lba = (lba << 8) | scsipkt->pkt_cdbp[9];
5689 lba = (lba << 8) | scsipkt->pkt_cdbp[10];
5690 lba = (lba << 8) | scsipkt->pkt_cdbp[7];
5691 lba = (lba << 8) | scsipkt->pkt_cdbp[8];
5692
5693 scmd->satacmd_device_reg = scsipkt->pkt_cdbp[13];
5694 scmd->satacmd_cmd_reg = scsipkt->pkt_cdbp[14];
5695 } else {
5696 feature = scsipkt->pkt_cdbp[3];
5697
5698 sec_count = scsipkt->pkt_cdbp[5];
5699
5700 lba = scsipkt->pkt_cdbp[13] & 0xf;
5701 lba = (lba << 8) | scsipkt->pkt_cdbp[12];
5702 lba = (lba << 8) | scsipkt->pkt_cdbp[10];
5703 lba = (lba << 8) | scsipkt->pkt_cdbp[8];
5704
5705 scmd->satacmd_device_reg = scsipkt->pkt_cdbp[13] &
5706 0xf0;
5707 scmd->satacmd_cmd_reg = scsipkt->pkt_cdbp[14];
5708 }
5709
5710 break;
5711 }
5712
5713 /* CK_COND bit */
5714 if (scsipkt->pkt_cdbp[2] & SATL_APT_BM_CK_COND) {
5715 if (extend) {
5716 scmd->satacmd_flags.sata_copy_out_sec_count_msb = 1;
5717 scmd->satacmd_flags.sata_copy_out_lba_low_msb = 1;
5718 scmd->satacmd_flags.sata_copy_out_lba_mid_msb = 1;
5719 scmd->satacmd_flags.sata_copy_out_lba_high_msb = 1;
5720 }
5721
5722 scmd->satacmd_flags.sata_copy_out_sec_count_lsb = 1;
5723 scmd->satacmd_flags.sata_copy_out_lba_low_lsb = 1;
5724 scmd->satacmd_flags.sata_copy_out_lba_mid_lsb = 1;
5725 scmd->satacmd_flags.sata_copy_out_lba_high_lsb = 1;
5726 scmd->satacmd_flags.sata_copy_out_device_reg = 1;
5727 scmd->satacmd_flags.sata_copy_out_error_reg = 1;
5728 }
5729
5730 /* Transfer remaining parsed ATA cmd values to the satacmd */
5731 if (extend) {
5732 scmd->satacmd_addr_type = ATA_ADDR_LBA48;
5733
5734 scmd->satacmd_features_reg_ext = (feature >> 8) & 0xff;
5735 scmd->satacmd_sec_count_msb = (sec_count >> 8) & 0xff;
5736 scmd->satacmd_lba_low_msb = (lba >> 8) & 0xff;
5737 scmd->satacmd_lba_mid_msb = (lba >> 8) & 0xff;
5738 scmd->satacmd_lba_high_msb = lba >> 40;
5739 } else {
5740 scmd->satacmd_addr_type = ATA_ADDR_LBA28;
5741
5742 scmd->satacmd_features_reg_ext = 0;
5743 scmd->satacmd_sec_count_msb = 0;
5744 scmd->satacmd_lba_low_msb = 0;
5745 scmd->satacmd_lba_mid_msb = 0;
5746 scmd->satacmd_lba_high_msb = 0;
5747 }
5748
5749 scmd->satacmd_features_reg = feature & 0xff;
5750 scmd->satacmd_sec_count_lsb = sec_count & 0xff;
5751 scmd->satacmd_lba_low_lsb = lba & 0xff;
5752 scmd->satacmd_lba_mid_lsb = (lba >> 8) & 0xff;
5753 scmd->satacmd_lba_high_lsb = (lba >> 16) & 0xff;
5754
5755 /* Determine transfer length */
5756 switch (scsipkt->pkt_cdbp[2] & 0x3) { /* T_LENGTH field */
5757 case 1:
5758 t_len = feature;
5759 break;
5760 case 2:
5761 t_len = sec_count;
5762 break;
5763 default:
5764 t_len = 0;
5765 break;
5766 }
5767
5768 /* Adjust transfer length for the Byte Block bit */
5769 if ((scsipkt->pkt_cdbp[2] >> 2) & 1)
5770 t_len *= SATA_DISK_SECTOR_SIZE;
5771
5772 /* Start processing command */
5773 if (!(spx->txlt_sata_pkt->satapkt_op_mode & SATA_OPMODE_SYNCH)) {
5774 spx->txlt_sata_pkt->satapkt_comp = sata_txlt_apt_completion;
5775 synch = FALSE;
5776 } else {
5777 synch = TRUE;
5778 }
5779
5780 if (sata_hba_start(spx, &rval) != 0) {
5781 mutex_exit(cport_mutex);
5782 return (rval);
5783 }
5784
5785 mutex_exit(cport_mutex);
5786
5787 if (synch) {
5788 sata_txlt_apt_completion(spx->txlt_sata_pkt);
5789 }
5790
5791 return (TRAN_ACCEPT);
5792 }
5793
5794 /*
5795 * Translate command: Log Sense
5796 */
5797 static int
5798 sata_txlt_log_sense(sata_pkt_txlate_t *spx)
5799 {
5800 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt;
5801 struct buf *bp = spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp;
5802 sata_drive_info_t *sdinfo;
5803 struct scsi_extended_sense *sense;
5804 int len, count, alc_len;
5805 int pc; /* Page Control code */
5806 int page_code; /* Page code */
5807 uint8_t *buf; /* log sense buffer */
5808 int rval, reason;
5809 #define MAX_LOG_SENSE_PAGE_SIZE 512
5810 kmutex_t *cport_mutex = &(SATA_TXLT_CPORT_MUTEX(spx));
5811
5812 SATADBG2(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst,
5813 "sata_txlt_log_sense, pc 0x%x, page code 0x%x\n",
5814 spx->txlt_scsi_pkt->pkt_cdbp[2] >> 6,
5815 spx->txlt_scsi_pkt->pkt_cdbp[2] & 0x3f);
5816
5817 if (servicing_interrupt()) {
5818 buf = kmem_zalloc(MAX_LOG_SENSE_PAGE_SIZE, KM_NOSLEEP);
5819 if (buf == NULL) {
5820 return (TRAN_BUSY);
5821 }
5822 } else {
5823 buf = kmem_zalloc(MAX_LOG_SENSE_PAGE_SIZE, KM_SLEEP);
5824 }
5825
5826 mutex_enter(cport_mutex);
5827
5828 if (((rval = sata_txlt_generic_pkt_info(spx, &reason, 1)) !=
5829 TRAN_ACCEPT) || (reason == CMD_DEV_GONE)) {
5830 mutex_exit(cport_mutex);
5831 kmem_free(buf, MAX_LOG_SENSE_PAGE_SIZE);
5832 return (rval);
5833 }
5834
5835 scsipkt->pkt_reason = CMD_CMPLT;
5836 scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET |
5837 STATE_SENT_CMD | STATE_GOT_STATUS;
5838
5839 pc = scsipkt->pkt_cdbp[2] >> 6;
5840 page_code = scsipkt->pkt_cdbp[2] & 0x3f;
5841
5842 /* Reject not supported request for all but cumulative values */
5843 switch (pc) {
5844 case PC_CUMULATIVE_VALUES:
5845 break;
5846 default:
5847 *scsipkt->pkt_scbp = STATUS_CHECK;
5848 sense = sata_arq_sense(spx);
5849 sense->es_key = KEY_ILLEGAL_REQUEST;
5850 sense->es_add_code = SD_SCSI_ASC_INVALID_FIELD_IN_CDB;
5851 goto done;
5852 }
5853
5854 switch (page_code) {
5855 case PAGE_CODE_GET_SUPPORTED_LOG_PAGES:
5856 case PAGE_CODE_SELF_TEST_RESULTS:
5857 case PAGE_CODE_INFORMATION_EXCEPTIONS:
5858 case PAGE_CODE_SMART_READ_DATA:
5859 case PAGE_CODE_START_STOP_CYCLE_COUNTER:
5860 break;
5861 default:
5862 *scsipkt->pkt_scbp = STATUS_CHECK;
5863 sense = sata_arq_sense(spx);
5864 sense->es_key = KEY_ILLEGAL_REQUEST;
5865 sense->es_add_code = SD_SCSI_ASC_INVALID_FIELD_IN_CDB;
5866 goto done;
5867 }
5868
5869 if (bp != NULL && bp->b_un.b_addr && bp->b_bcount) {
5870 /*
5871 * Because log sense uses local buffers for data retrieval from
5872 * the devices and sets the data programatically in the
5873 * original specified buffer, release preallocated DMA
5874 * resources before storing data in the original buffer,
5875 * so no unwanted DMA sync would take place.
5876 */
5877 sata_id_t *sata_id;
5878
5879 sata_scsi_dmafree(NULL, scsipkt);
5880
5881 len = 0;
5882
5883 /* Build log parameter header */
5884 buf[len++] = page_code; /* page code as in the CDB */
5885 buf[len++] = 0; /* reserved */
5886 buf[len++] = 0; /* Zero out page length for now (MSB) */
5887 buf[len++] = 0; /* (LSB) */
5888
5889 sdinfo = sata_get_device_info(
5890 spx->txlt_sata_hba_inst,
5891 &spx->txlt_sata_pkt->satapkt_device);
5892
5893 /*
5894 * Add requested pages.
5895 */
5896 switch (page_code) {
5897 case PAGE_CODE_GET_SUPPORTED_LOG_PAGES:
5898 len = sata_build_lsense_page_0(sdinfo, buf + len);
5899 break;
5900 case PAGE_CODE_SELF_TEST_RESULTS:
5901 sata_id = &sdinfo->satadrv_id;
5902 if ((! (sata_id->ai_cmdset84 &
5903 SATA_SMART_SELF_TEST_SUPPORTED)) ||
5904 (! (sata_id->ai_features87 &
5905 SATA_SMART_SELF_TEST_SUPPORTED))) {
5906 *scsipkt->pkt_scbp = STATUS_CHECK;
5907 sense = sata_arq_sense(spx);
5908 sense->es_key = KEY_ILLEGAL_REQUEST;
5909 sense->es_add_code =
5910 SD_SCSI_ASC_INVALID_FIELD_IN_CDB;
5911
5912 goto done;
5913 }
5914 len = sata_build_lsense_page_10(sdinfo, buf + len,
5915 spx->txlt_sata_hba_inst);
5916 break;
5917 case PAGE_CODE_INFORMATION_EXCEPTIONS:
5918 sata_id = &sdinfo->satadrv_id;
5919 if (! (sata_id->ai_cmdset82 & SATA_SMART_SUPPORTED)) {
5920 *scsipkt->pkt_scbp = STATUS_CHECK;
5921 sense = sata_arq_sense(spx);
5922 sense->es_key = KEY_ILLEGAL_REQUEST;
5923 sense->es_add_code =
5924 SD_SCSI_ASC_INVALID_FIELD_IN_CDB;
5925
5926 goto done;
5927 }
5928 if (! (sata_id->ai_features85 & SATA_SMART_ENABLED)) {
5929 *scsipkt->pkt_scbp = STATUS_CHECK;
5930 sense = sata_arq_sense(spx);
5931 sense->es_key = KEY_ABORTED_COMMAND;
5932 sense->es_add_code =
5933 SCSI_ASC_ATA_DEV_FEAT_NOT_ENABLED;
5934 sense->es_qual_code =
5935 SCSI_ASCQ_ATA_DEV_FEAT_NOT_ENABLED;
5936
5937 goto done;
5938 }
5939
5940 len = sata_build_lsense_page_2f(sdinfo, buf + len,
5941 spx->txlt_sata_hba_inst);
5942 break;
5943 case PAGE_CODE_SMART_READ_DATA:
5944 sata_id = &sdinfo->satadrv_id;
5945 if (! (sata_id->ai_cmdset82 & SATA_SMART_SUPPORTED)) {
5946 *scsipkt->pkt_scbp = STATUS_CHECK;
5947 sense = sata_arq_sense(spx);
5948 sense->es_key = KEY_ILLEGAL_REQUEST;
5949 sense->es_add_code =
5950 SD_SCSI_ASC_INVALID_FIELD_IN_CDB;
5951
5952 goto done;
5953 }
5954 if (! (sata_id->ai_features85 & SATA_SMART_ENABLED)) {
5955 *scsipkt->pkt_scbp = STATUS_CHECK;
5956 sense = sata_arq_sense(spx);
5957 sense->es_key = KEY_ABORTED_COMMAND;
5958 sense->es_add_code =
5959 SCSI_ASC_ATA_DEV_FEAT_NOT_ENABLED;
5960 sense->es_qual_code =
5961 SCSI_ASCQ_ATA_DEV_FEAT_NOT_ENABLED;
5962
5963 goto done;
5964 }
5965
5966 /* This page doesn't include a page header */
5967 len = sata_build_lsense_page_30(sdinfo, buf,
5968 spx->txlt_sata_hba_inst);
5969 goto no_header;
5970 case PAGE_CODE_START_STOP_CYCLE_COUNTER:
5971 sata_id = &sdinfo->satadrv_id;
5972 if (! (sata_id->ai_cmdset82 & SATA_SMART_SUPPORTED)) {
5973 *scsipkt->pkt_scbp = STATUS_CHECK;
5974 sense = sata_arq_sense(spx);
5975 sense->es_key = KEY_ILLEGAL_REQUEST;
5976 sense->es_add_code =
5977 SD_SCSI_ASC_INVALID_FIELD_IN_CDB;
5978
5979 goto done;
5980 }
5981 if (! (sata_id->ai_features85 & SATA_SMART_ENABLED)) {
5982 *scsipkt->pkt_scbp = STATUS_CHECK;
5983 sense = sata_arq_sense(spx);
5984 sense->es_key = KEY_ABORTED_COMMAND;
5985 sense->es_add_code =
5986 SCSI_ASC_ATA_DEV_FEAT_NOT_ENABLED;
5987 sense->es_qual_code =
5988 SCSI_ASCQ_ATA_DEV_FEAT_NOT_ENABLED;
5989
5990 goto done;
5991 }
5992 len = sata_build_lsense_page_0e(sdinfo, buf, spx);
5993 goto no_header;
5994 default:
5995 /* Invalid request */
5996 *scsipkt->pkt_scbp = STATUS_CHECK;
5997 sense = sata_arq_sense(spx);
5998 sense->es_key = KEY_ILLEGAL_REQUEST;
5999 sense->es_add_code = SD_SCSI_ASC_INVALID_FIELD_IN_CDB;
6000 goto done;
6001 }
6002
6003 /* set parameter log sense data length */
6004 buf[2] = len >> 8; /* log sense length (MSB) */
6005 buf[3] = len & 0xff; /* log sense length (LSB) */
6006
6007 len += SCSI_LOG_PAGE_HDR_LEN;
6008 ASSERT(len <= MAX_LOG_SENSE_PAGE_SIZE);
6009
6010 no_header:
6011 /* Check allocation length */
6012 alc_len = scsipkt->pkt_cdbp[7];
6013 alc_len = (len << 8) | scsipkt->pkt_cdbp[8];
6014
6015 /*
6016 * We do not check for possible parameters truncation
6017 * (alc_len < len) assuming that the target driver works
6018 * correctly. Just avoiding overrun.
6019 * Copy no more than requested and possible, buffer-wise.
6020 */
6021 count = MIN(alc_len, len);
6022 count = MIN(bp->b_bcount, count);
6023 bcopy(buf, bp->b_un.b_addr, count);
6024
6025 scsipkt->pkt_state |= STATE_XFERRED_DATA;
6026 scsipkt->pkt_resid = alc_len > count ? alc_len - count : 0;
6027 }
6028 *scsipkt->pkt_scbp = STATUS_GOOD;
6029 done:
6030 mutex_exit(cport_mutex);
6031 (void) kmem_free(buf, MAX_LOG_SENSE_PAGE_SIZE);
6032
6033 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst,
6034 "Scsi_pkt completion reason %x\n", scsipkt->pkt_reason);
6035
6036 if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0 &&
6037 scsipkt->pkt_comp != NULL) {
6038 /* scsi callback required */
6039 if (servicing_interrupt()) {
6040 if (taskq_dispatch(SATA_TXLT_TASKQ(spx),
6041 (task_func_t *)spx->txlt_scsi_pkt->pkt_comp,
6042 (void *)spx->txlt_scsi_pkt, TQ_NOSLEEP) == NULL) {
6043 return (TRAN_BUSY);
6044 }
6045 } else if (taskq_dispatch(SATA_TXLT_TASKQ(spx),
6046 (task_func_t *)spx->txlt_scsi_pkt->pkt_comp,
6047 (void *)spx->txlt_scsi_pkt, TQ_SLEEP) == NULL) {
6048 /* Scheduling the callback failed */
6049 return (TRAN_BUSY);
6050 }
6051 }
6052
6053 return (TRAN_ACCEPT);
6054 }
6055
6056 /*
6057 * Translate command: Log Select
6058 * Not implemented at this time - returns invalid command response.
6059 */
6060 static int
6061 sata_txlt_log_select(sata_pkt_txlate_t *spx)
6062 {
6063 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst,
6064 "sata_txlt_log_select\n", NULL);
6065
6066 return (sata_txlt_invalid_command(spx));
6067 }
6068
6069
6070 /*
6071 * Translate command: Read (various types).
6072 * Translated into appropriate type of ATA READ command
6073 * for SATA hard disks.
6074 * Both the device capabilities and requested operation mode are
6075 * considered.
6076 *
6077 * Following scsi cdb fields are ignored:
6078 * rdprotect, dpo, fua, fua_nv, group_number.
6079 *
6080 * If SATA_ENABLE_QUEUING flag is set (in the global SATA HBA framework
6081 * enable variable sata_func_enable), the capability of the controller and
6082 * capability of a device are checked and if both support queueing, read
6083 * request will be translated to READ_DMA_QUEUEING or READ_DMA_QUEUEING_EXT
6084 * command rather than plain READ_XXX command.
6085 * If SATA_ENABLE_NCQ flag is set in addition to SATA_ENABLE_QUEUING flag and
6086 * both the controller and device suport such functionality, the read
6087 * request will be translated to READ_FPDMA_QUEUED command.
6088 * In both cases the maximum queue depth is derived as minimum of:
6089 * HBA capability,device capability and sata_max_queue_depth variable setting.
6090 * The value passed to HBA driver is decremented by 1, because only 5 bits are
6091 * used to pass max queue depth value, and the maximum possible queue depth
6092 * is 32.
6093 *
6094 * Returns TRAN_ACCEPT or code returned by sata_hba_start() and
6095 * appropriate values in scsi_pkt fields.
6096 */
6097 static int
6098 sata_txlt_read(sata_pkt_txlate_t *spx)
6099 {
6100 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt;
6101 sata_cmd_t *scmd = &spx->txlt_sata_pkt->satapkt_cmd;
6102 sata_drive_info_t *sdinfo;
6103 sata_hba_inst_t *shi = SATA_TXLT_HBA_INST(spx);
6104 kmutex_t *cport_mutex = &(SATA_TXLT_CPORT_MUTEX(spx));
6105 uint16_t sec_count;
6106 uint64_t lba;
6107 int rval, reason;
6108 int synch;
6109
6110 mutex_enter(cport_mutex);
6111
6112 if (((rval = sata_txlt_generic_pkt_info(spx, &reason, 0)) !=
6113 TRAN_ACCEPT) || (reason == CMD_DEV_GONE)) {
6114 mutex_exit(cport_mutex);
6115 return (rval);
6116 }
6117
6118 sdinfo = sata_get_device_info(spx->txlt_sata_hba_inst,
6119 &spx->txlt_sata_pkt->satapkt_device);
6120
6121 scmd->satacmd_flags.sata_data_direction = SATA_DIR_READ;
6122 /*
6123 * Extract LBA and sector count from scsi CDB.
6124 */
6125 switch ((uint_t)scsipkt->pkt_cdbp[0]) {
6126 case SCMD_READ:
6127 /* 6-byte scsi read cmd : 0x08 */
6128 lba = (scsipkt->pkt_cdbp[1] & 0x1f);
6129 lba = (lba << 8) | scsipkt->pkt_cdbp[2];
6130 lba = (lba << 8) | scsipkt->pkt_cdbp[3];
6131 sec_count = scsipkt->pkt_cdbp[4];
6132 /* sec_count 0 will be interpreted as 256 by a device */
6133 break;
6134 case SCMD_READ_G1:
6135 /* 10-bytes scsi read command : 0x28 */
6136 lba = scsipkt->pkt_cdbp[2];
6137 lba = (lba << 8) | scsipkt->pkt_cdbp[3];
6138 lba = (lba << 8) | scsipkt->pkt_cdbp[4];
6139 lba = (lba << 8) | scsipkt->pkt_cdbp[5];
6140 sec_count = scsipkt->pkt_cdbp[7];
6141 sec_count = (sec_count << 8) | scsipkt->pkt_cdbp[8];
6142 break;
6143 case SCMD_READ_G5:
6144 /* 12-bytes scsi read command : 0xA8 */
6145 lba = scsipkt->pkt_cdbp[2];
6146 lba = (lba << 8) | scsipkt->pkt_cdbp[3];
6147 lba = (lba << 8) | scsipkt->pkt_cdbp[4];
6148 lba = (lba << 8) | scsipkt->pkt_cdbp[5];
6149 sec_count = scsipkt->pkt_cdbp[6];
6150 sec_count = (sec_count << 8) | scsipkt->pkt_cdbp[7];
6151 sec_count = (sec_count << 8) | scsipkt->pkt_cdbp[8];
6152 sec_count = (sec_count << 8) | scsipkt->pkt_cdbp[9];
6153 break;
6154 case SCMD_READ_G4:
6155 /* 16-bytes scsi read command : 0x88 */
6156 lba = scsipkt->pkt_cdbp[2];
6157 lba = (lba << 8) | scsipkt->pkt_cdbp[3];
6158 lba = (lba << 8) | scsipkt->pkt_cdbp[4];
6159 lba = (lba << 8) | scsipkt->pkt_cdbp[5];
6160 lba = (lba << 8) | scsipkt->pkt_cdbp[6];
6161 lba = (lba << 8) | scsipkt->pkt_cdbp[7];
6162 lba = (lba << 8) | scsipkt->pkt_cdbp[8];
6163 lba = (lba << 8) | scsipkt->pkt_cdbp[9];
6164 sec_count = scsipkt->pkt_cdbp[10];
6165 sec_count = (sec_count << 8) | scsipkt->pkt_cdbp[11];
6166 sec_count = (sec_count << 8) | scsipkt->pkt_cdbp[12];
6167 sec_count = (sec_count << 8) | scsipkt->pkt_cdbp[13];
6168 break;
6169 default:
6170 /* Unsupported command */
6171 mutex_exit(cport_mutex);
6172 return (sata_txlt_invalid_command(spx));
6173 }
6174
6175 /*
6176 * Check if specified address exceeds device capacity
6177 */
6178 if ((lba >= sdinfo->satadrv_capacity) ||
6179 ((lba + sec_count) > sdinfo->satadrv_capacity)) {
6180 /* LBA out of range */
6181 mutex_exit(cport_mutex);
6182 return (sata_txlt_lba_out_of_range(spx));
6183 }
6184
6185 /*
6186 * For zero-length transfer, emulate good completion of the command
6187 * (reasons for rejecting the command were already checked).
6188 * No DMA resources were allocated.
6189 */
6190 if (spx->txlt_dma_cookie_list == NULL) {
6191 mutex_exit(cport_mutex);
6192 return (sata_emul_rw_completion(spx));
6193 }
6194
6195 /*
6196 * Build cmd block depending on the device capability and
6197 * requested operation mode.
6198 * Do not bother with non-dma mode - we are working only with
6199 * devices supporting DMA.
6200 */
6201 scmd->satacmd_addr_type = ATA_ADDR_LBA;
6202 scmd->satacmd_device_reg = SATA_ADH_LBA;
6203 scmd->satacmd_cmd_reg = SATAC_READ_DMA;
6204 if (sdinfo->satadrv_features_support & SATA_DEV_F_LBA48) {
6205 scmd->satacmd_addr_type = ATA_ADDR_LBA48;
6206 scmd->satacmd_cmd_reg = SATAC_READ_DMA_EXT;
6207 scmd->satacmd_sec_count_msb = sec_count >> 8;
6208 #ifndef __lock_lint
6209 scmd->satacmd_lba_low_msb = (lba >> 24) & 0xff;
6210 scmd->satacmd_lba_mid_msb = (lba >> 32) & 0xff;
6211 scmd->satacmd_lba_high_msb = lba >> 40;
6212 #endif
6213 } else if (sdinfo->satadrv_features_support & SATA_DEV_F_LBA28) {
6214 scmd->satacmd_addr_type = ATA_ADDR_LBA28;
6215 scmd->satacmd_device_reg = SATA_ADH_LBA | ((lba >> 24) & 0xf);
6216 }
6217 scmd->satacmd_sec_count_lsb = sec_count & 0xff;
6218 scmd->satacmd_lba_low_lsb = lba & 0xff;
6219 scmd->satacmd_lba_mid_lsb = (lba >> 8) & 0xff;
6220 scmd->satacmd_lba_high_lsb = (lba >> 16) & 0xff;
6221 scmd->satacmd_features_reg = 0;
6222 scmd->satacmd_status_reg = 0;
6223 scmd->satacmd_error_reg = 0;
6224
6225 /*
6226 * Check if queueing commands should be used and switch
6227 * to appropriate command if possible
6228 */
6229 if (sata_func_enable & SATA_ENABLE_QUEUING) {
6230 boolean_t using_queuing;
6231
6232 /* Queuing supported by controller and device? */
6233 if ((sata_func_enable & SATA_ENABLE_NCQ) &&
6234 (sdinfo->satadrv_features_support &
6235 SATA_DEV_F_NCQ) &&
6236 (SATA_FEATURES(spx->txlt_sata_hba_inst) &
6237 SATA_CTLF_NCQ)) {
6238 using_queuing = B_TRUE;
6239
6240 /* NCQ supported - use FPDMA READ */
6241 scmd->satacmd_cmd_reg =
6242 SATAC_READ_FPDMA_QUEUED;
6243 scmd->satacmd_features_reg_ext =
6244 scmd->satacmd_sec_count_msb;
6245 scmd->satacmd_sec_count_msb = 0;
6246 } else if ((sdinfo->satadrv_features_support &
6247 SATA_DEV_F_TCQ) &&
6248 (SATA_FEATURES(spx->txlt_sata_hba_inst) &
6249 SATA_CTLF_QCMD)) {
6250 using_queuing = B_TRUE;
6251
6252 /* Legacy queueing */
6253 if (sdinfo->satadrv_features_support &
6254 SATA_DEV_F_LBA48) {
6255 scmd->satacmd_cmd_reg =
6256 SATAC_READ_DMA_QUEUED_EXT;
6257 scmd->satacmd_features_reg_ext =
6258 scmd->satacmd_sec_count_msb;
6259 scmd->satacmd_sec_count_msb = 0;
6260 } else {
6261 scmd->satacmd_cmd_reg =
6262 SATAC_READ_DMA_QUEUED;
6263 }
6264 } else /* NCQ nor legacy queuing not supported */
6265 using_queuing = B_FALSE;
6266
6267 /*
6268 * If queuing, the sector count goes in the features register
6269 * and the secount count will contain the tag.
6270 */
6271 if (using_queuing) {
6272 scmd->satacmd_features_reg =
6273 scmd->satacmd_sec_count_lsb;
6274 scmd->satacmd_sec_count_lsb = 0;
6275 scmd->satacmd_flags.sata_queued = B_TRUE;
6276
6277 /* Set-up maximum queue depth */
6278 scmd->satacmd_flags.sata_max_queue_depth =
6279 sdinfo->satadrv_max_queue_depth - 1;
6280 } else if (sdinfo->satadrv_features_enabled &
6281 SATA_DEV_F_E_UNTAGGED_QING) {
6282 /*
6283 * Although NCQ/TCQ is not enabled, untagged queuing
6284 * may be still used.
6285 * Set-up the maximum untagged queue depth.
6286 * Use controller's queue depth from sata_hba_tran.
6287 * SATA HBA drivers may ignore this value and rely on
6288 * the internal limits.For drivers that do not
6289 * ignore untaged queue depth, limit the value to
6290 * SATA_MAX_QUEUE_DEPTH (32), as this is the
6291 * largest value that can be passed via
6292 * satacmd_flags.sata_max_queue_depth.
6293 */
6294 scmd->satacmd_flags.sata_max_queue_depth =
6295 SATA_QDEPTH(shi) <= SATA_MAX_QUEUE_DEPTH ?
6296 SATA_QDEPTH(shi) - 1: SATA_MAX_QUEUE_DEPTH - 1;
6297
6298 } else {
6299 scmd->satacmd_flags.sata_max_queue_depth = 0;
6300 }
6301 } else
6302 scmd->satacmd_flags.sata_max_queue_depth = 0;
6303
6304 SATADBG3(SATA_DBG_HBA_IF, spx->txlt_sata_hba_inst,
6305 "sata_txlt_read cmd 0x%2x, lba %llx, sec count %x\n",
6306 scmd->satacmd_cmd_reg, lba, sec_count);
6307
6308 if (!(spx->txlt_sata_pkt->satapkt_op_mode & SATA_OPMODE_SYNCH)) {
6309 /* Need callback function */
6310 spx->txlt_sata_pkt->satapkt_comp = sata_txlt_rw_completion;
6311 synch = FALSE;
6312 } else
6313 synch = TRUE;
6314
6315 /* Transfer command to HBA */
6316 if (sata_hba_start(spx, &rval) != 0) {
6317 /* Pkt not accepted for execution */
6318 mutex_exit(cport_mutex);
6319 return (rval);
6320 }
6321 mutex_exit(cport_mutex);
6322 /*
6323 * If execution is non-synchronous,
6324 * a callback function will handle potential errors, translate
6325 * the response and will do a callback to a target driver.
6326 * If it was synchronous, check execution status using the same
6327 * framework callback.
6328 */
6329 if (synch) {
6330 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst,
6331 "synchronous execution status %x\n",
6332 spx->txlt_sata_pkt->satapkt_reason);
6333 sata_txlt_rw_completion(spx->txlt_sata_pkt);
6334 }
6335 return (TRAN_ACCEPT);
6336 }
6337
6338
6339 /*
6340 * SATA translate command: Write (various types)
6341 * Translated into appropriate type of ATA WRITE command
6342 * for SATA hard disks.
6343 * Both the device capabilities and requested operation mode are
6344 * considered.
6345 *
6346 * Following scsi cdb fields are ignored:
6347 * rwprotect, dpo, fua, fua_nv, group_number.
6348 *
6349 * If SATA_ENABLE_QUEUING flag is set (in the global SATA HBA framework
6350 * enable variable sata_func_enable), the capability of the controller and
6351 * capability of a device are checked and if both support queueing, write
6352 * request will be translated to WRITE_DMA_QUEUEING or WRITE_DMA_QUEUEING_EXT
6353 * command rather than plain WRITE_XXX command.
6354 * If SATA_ENABLE_NCQ flag is set in addition to SATA_ENABLE_QUEUING flag and
6355 * both the controller and device suport such functionality, the write
6356 * request will be translated to WRITE_FPDMA_QUEUED command.
6357 * In both cases the maximum queue depth is derived as minimum of:
6358 * HBA capability,device capability and sata_max_queue_depth variable setting.
6359 * The value passed to HBA driver is decremented by 1, because only 5 bits are
6360 * used to pass max queue depth value, and the maximum possible queue depth
6361 * is 32.
6362 *
6363 * Returns TRAN_ACCEPT or code returned by sata_hba_start() and
6364 * appropriate values in scsi_pkt fields.
6365 */
6366 static int
6367 sata_txlt_write(sata_pkt_txlate_t *spx)
6368 {
6369 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt;
6370 sata_cmd_t *scmd = &spx->txlt_sata_pkt->satapkt_cmd;
6371 sata_drive_info_t *sdinfo;
6372 sata_hba_inst_t *shi = SATA_TXLT_HBA_INST(spx);
6373 uint16_t sec_count;
6374 uint64_t lba;
6375 int rval, reason;
6376 int synch;
6377 kmutex_t *cport_mutex = &(SATA_TXLT_CPORT_MUTEX(spx));
6378
6379 mutex_enter(cport_mutex);
6380
6381 if (((rval = sata_txlt_generic_pkt_info(spx, &reason, 0)) !=
6382 TRAN_ACCEPT) || (reason == CMD_DEV_GONE)) {
6383 mutex_exit(cport_mutex);
6384 return (rval);
6385 }
6386
6387 sdinfo = sata_get_device_info(spx->txlt_sata_hba_inst,
6388 &spx->txlt_sata_pkt->satapkt_device);
6389
6390 scmd->satacmd_flags.sata_data_direction = SATA_DIR_WRITE;
6391 /*
6392 * Extract LBA and sector count from scsi CDB
6393 */
6394 switch ((uint_t)scsipkt->pkt_cdbp[0]) {
6395 case SCMD_WRITE:
6396 /* 6-byte scsi read cmd : 0x0A */
6397 lba = (scsipkt->pkt_cdbp[1] & 0x1f);
6398 lba = (lba << 8) | scsipkt->pkt_cdbp[2];
6399 lba = (lba << 8) | scsipkt->pkt_cdbp[3];
6400 sec_count = scsipkt->pkt_cdbp[4];
6401 /* sec_count 0 will be interpreted as 256 by a device */
6402 break;
6403 case SCMD_WRITE_G1:
6404 /* 10-bytes scsi write command : 0x2A */
6405 lba = scsipkt->pkt_cdbp[2];
6406 lba = (lba << 8) | scsipkt->pkt_cdbp[3];
6407 lba = (lba << 8) | scsipkt->pkt_cdbp[4];
6408 lba = (lba << 8) | scsipkt->pkt_cdbp[5];
6409 sec_count = scsipkt->pkt_cdbp[7];
6410 sec_count = (sec_count << 8) | scsipkt->pkt_cdbp[8];
6411 break;
6412 case SCMD_WRITE_G5:
6413 /* 12-bytes scsi read command : 0xAA */
6414 lba = scsipkt->pkt_cdbp[2];
6415 lba = (lba << 8) | scsipkt->pkt_cdbp[3];
6416 lba = (lba << 8) | scsipkt->pkt_cdbp[4];
6417 lba = (lba << 8) | scsipkt->pkt_cdbp[5];
6418 sec_count = scsipkt->pkt_cdbp[6];
6419 sec_count = (sec_count << 8) | scsipkt->pkt_cdbp[7];
6420 sec_count = (sec_count << 8) | scsipkt->pkt_cdbp[8];
6421 sec_count = (sec_count << 8) | scsipkt->pkt_cdbp[9];
6422 break;
6423 case SCMD_WRITE_G4:
6424 /* 16-bytes scsi write command : 0x8A */
6425 lba = scsipkt->pkt_cdbp[2];
6426 lba = (lba << 8) | scsipkt->pkt_cdbp[3];
6427 lba = (lba << 8) | scsipkt->pkt_cdbp[4];
6428 lba = (lba << 8) | scsipkt->pkt_cdbp[5];
6429 lba = (lba << 8) | scsipkt->pkt_cdbp[6];
6430 lba = (lba << 8) | scsipkt->pkt_cdbp[7];
6431 lba = (lba << 8) | scsipkt->pkt_cdbp[8];
6432 lba = (lba << 8) | scsipkt->pkt_cdbp[9];
6433 sec_count = scsipkt->pkt_cdbp[10];
6434 sec_count = (sec_count << 8) | scsipkt->pkt_cdbp[11];
6435 sec_count = (sec_count << 8) | scsipkt->pkt_cdbp[12];
6436 sec_count = (sec_count << 8) | scsipkt->pkt_cdbp[13];
6437 break;
6438 default:
6439 /* Unsupported command */
6440 mutex_exit(cport_mutex);
6441 return (sata_txlt_invalid_command(spx));
6442 }
6443
6444 /*
6445 * Check if specified address and length exceeds device capacity
6446 */
6447 if ((lba >= sdinfo->satadrv_capacity) ||
6448 ((lba + sec_count) > sdinfo->satadrv_capacity)) {
6449 /* LBA out of range */
6450 mutex_exit(cport_mutex);
6451 return (sata_txlt_lba_out_of_range(spx));
6452 }
6453
6454 /*
6455 * For zero-length transfer, emulate good completion of the command
6456 * (reasons for rejecting the command were already checked).
6457 * No DMA resources were allocated.
6458 */
6459 if (spx->txlt_dma_cookie_list == NULL) {
6460 mutex_exit(cport_mutex);
6461 return (sata_emul_rw_completion(spx));
6462 }
6463
6464 /*
6465 * Build cmd block depending on the device capability and
6466 * requested operation mode.
6467 * Do not bother with non-dma mode- we are working only with
6468 * devices supporting DMA.
6469 */
6470 scmd->satacmd_addr_type = ATA_ADDR_LBA;
6471 scmd->satacmd_device_reg = SATA_ADH_LBA;
6472 scmd->satacmd_cmd_reg = SATAC_WRITE_DMA;
6473 if (sdinfo->satadrv_features_support & SATA_DEV_F_LBA48) {
6474 scmd->satacmd_addr_type = ATA_ADDR_LBA48;
6475 scmd->satacmd_cmd_reg = SATAC_WRITE_DMA_EXT;
6476 scmd->satacmd_sec_count_msb = sec_count >> 8;
6477 scmd->satacmd_lba_low_msb = (lba >> 24) & 0xff;
6478 #ifndef __lock_lint
6479 scmd->satacmd_lba_mid_msb = (lba >> 32) & 0xff;
6480 scmd->satacmd_lba_high_msb = lba >> 40;
6481 #endif
6482 } else if (sdinfo->satadrv_features_support & SATA_DEV_F_LBA28) {
6483 scmd->satacmd_addr_type = ATA_ADDR_LBA28;
6484 scmd->satacmd_device_reg = SATA_ADH_LBA | ((lba >> 24) & 0xf);
6485 }
6486 scmd->satacmd_sec_count_lsb = sec_count & 0xff;
6487 scmd->satacmd_lba_low_lsb = lba & 0xff;
6488 scmd->satacmd_lba_mid_lsb = (lba >> 8) & 0xff;
6489 scmd->satacmd_lba_high_lsb = (lba >> 16) & 0xff;
6490 scmd->satacmd_features_reg = 0;
6491 scmd->satacmd_status_reg = 0;
6492 scmd->satacmd_error_reg = 0;
6493
6494 /*
6495 * Check if queueing commands should be used and switch
6496 * to appropriate command if possible
6497 */
6498 if (sata_func_enable & SATA_ENABLE_QUEUING) {
6499 boolean_t using_queuing;
6500
6501 /* Queuing supported by controller and device? */
6502 if ((sata_func_enable & SATA_ENABLE_NCQ) &&
6503 (sdinfo->satadrv_features_support &
6504 SATA_DEV_F_NCQ) &&
6505 (SATA_FEATURES(spx->txlt_sata_hba_inst) &
6506 SATA_CTLF_NCQ)) {
6507 using_queuing = B_TRUE;
6508
6509 /* NCQ supported - use FPDMA WRITE */
6510 scmd->satacmd_cmd_reg =
6511 SATAC_WRITE_FPDMA_QUEUED;
6512 scmd->satacmd_features_reg_ext =
6513 scmd->satacmd_sec_count_msb;
6514 scmd->satacmd_sec_count_msb = 0;
6515 } else if ((sdinfo->satadrv_features_support &
6516 SATA_DEV_F_TCQ) &&
6517 (SATA_FEATURES(spx->txlt_sata_hba_inst) &
6518 SATA_CTLF_QCMD)) {
6519 using_queuing = B_TRUE;
6520
6521 /* Legacy queueing */
6522 if (sdinfo->satadrv_features_support &
6523 SATA_DEV_F_LBA48) {
6524 scmd->satacmd_cmd_reg =
6525 SATAC_WRITE_DMA_QUEUED_EXT;
6526 scmd->satacmd_features_reg_ext =
6527 scmd->satacmd_sec_count_msb;
6528 scmd->satacmd_sec_count_msb = 0;
6529 } else {
6530 scmd->satacmd_cmd_reg =
6531 SATAC_WRITE_DMA_QUEUED;
6532 }
6533 } else /* NCQ nor legacy queuing not supported */
6534 using_queuing = B_FALSE;
6535
6536 if (using_queuing) {
6537 scmd->satacmd_features_reg =
6538 scmd->satacmd_sec_count_lsb;
6539 scmd->satacmd_sec_count_lsb = 0;
6540 scmd->satacmd_flags.sata_queued = B_TRUE;
6541 /* Set-up maximum queue depth */
6542 scmd->satacmd_flags.sata_max_queue_depth =
6543 sdinfo->satadrv_max_queue_depth - 1;
6544 } else if (sdinfo->satadrv_features_enabled &
6545 SATA_DEV_F_E_UNTAGGED_QING) {
6546 /*
6547 * Although NCQ/TCQ is not enabled, untagged queuing
6548 * may be still used.
6549 * Set-up the maximum untagged queue depth.
6550 * Use controller's queue depth from sata_hba_tran.
6551 * SATA HBA drivers may ignore this value and rely on
6552 * the internal limits. For drivera that do not
6553 * ignore untaged queue depth, limit the value to
6554 * SATA_MAX_QUEUE_DEPTH (32), as this is the
6555 * largest value that can be passed via
6556 * satacmd_flags.sata_max_queue_depth.
6557 */
6558 scmd->satacmd_flags.sata_max_queue_depth =
6559 SATA_QDEPTH(shi) <= SATA_MAX_QUEUE_DEPTH ?
6560 SATA_QDEPTH(shi) - 1: SATA_MAX_QUEUE_DEPTH - 1;
6561
6562 } else {
6563 scmd->satacmd_flags.sata_max_queue_depth = 0;
6564 }
6565 } else
6566 scmd->satacmd_flags.sata_max_queue_depth = 0;
6567
6568 SATADBG3(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst,
6569 "sata_txlt_write cmd 0x%2x, lba %llx, sec count %x\n",
6570 scmd->satacmd_cmd_reg, lba, sec_count);
6571
6572 if (!(spx->txlt_sata_pkt->satapkt_op_mode & SATA_OPMODE_SYNCH)) {
6573 /* Need callback function */
6574 spx->txlt_sata_pkt->satapkt_comp = sata_txlt_rw_completion;
6575 synch = FALSE;
6576 } else
6577 synch = TRUE;
6578
6579 /* Transfer command to HBA */
6580 if (sata_hba_start(spx, &rval) != 0) {
6581 /* Pkt not accepted for execution */
6582 mutex_exit(cport_mutex);
6583 return (rval);
6584 }
6585 mutex_exit(cport_mutex);
6586
6587 /*
6588 * If execution is non-synchronous,
6589 * a callback function will handle potential errors, translate
6590 * the response and will do a callback to a target driver.
6591 * If it was synchronous, check execution status using the same
6592 * framework callback.
6593 */
6594 if (synch) {
6595 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst,
6596 "synchronous execution status %x\n",
6597 spx->txlt_sata_pkt->satapkt_reason);
6598 sata_txlt_rw_completion(spx->txlt_sata_pkt);
6599 }
6600 return (TRAN_ACCEPT);
6601 }
6602
6603
6604 /*
6605 * Implements SCSI SBC WRITE BUFFER command download microcode option
6606 */
6607 static int
6608 sata_txlt_write_buffer(sata_pkt_txlate_t *spx)
6609 {
6610 #define WB_DOWNLOAD_MICROCODE_AND_REVERT_MODE 4
6611 #define WB_DOWNLOAD_MICROCODE_AND_SAVE_MODE 5
6612
6613 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt;
6614 struct sata_pkt *sata_pkt = spx->txlt_sata_pkt;
6615 sata_cmd_t *scmd = &spx->txlt_sata_pkt->satapkt_cmd;
6616
6617 struct buf *bp = spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp;
6618 struct scsi_extended_sense *sense;
6619 int rval, mode, sector_count, reason;
6620 kmutex_t *cport_mutex = &(SATA_TXLT_CPORT_MUTEX(spx));
6621
6622 mode = scsipkt->pkt_cdbp[1] & 0x1f;
6623
6624 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst,
6625 "sata_txlt_write_buffer, mode 0x%x\n", mode);
6626
6627 mutex_enter(cport_mutex);
6628
6629 if ((rval = sata_txlt_generic_pkt_info(spx, &reason, 1)) !=
6630 TRAN_ACCEPT) {
6631 mutex_exit(cport_mutex);
6632 return (rval);
6633 }
6634
6635 /* Use synchronous mode */
6636 spx->txlt_sata_pkt->satapkt_op_mode
6637 |= SATA_OPMODE_SYNCH | SATA_OPMODE_INTERRUPTS;
6638
6639 scmd->satacmd_flags.sata_data_direction = SATA_DIR_WRITE;
6640
6641 scsipkt->pkt_reason = CMD_CMPLT;
6642 scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET |
6643 STATE_SENT_CMD | STATE_GOT_STATUS;
6644
6645 /*
6646 * The SCSI to ATA translation specification only calls
6647 * for WB_DOWNLOAD_MICROCODE_AND_SAVE_MODE.
6648 * WB_DOWNLOAD_MICROC_AND_REVERT_MODE is implemented, but
6649 * ATA 8 (draft) got rid of download microcode for temp
6650 * and it is even optional for ATA 7, so it may be aborted.
6651 * WB_DOWNLOAD_MICROCODE_WITH_OFFSET is not implemented as
6652 * it is not specified and the buffer offset for SCSI is a 16-bit
6653 * value in bytes, but for ATA it is a 16-bit offset in 512 byte
6654 * sectors. Thus the offset really doesn't buy us anything.
6655 * If and when ATA 8 is stabilized and the SCSI to ATA specification
6656 * is revised, this can be revisisted.
6657 */
6658 /* Reject not supported request */
6659 switch (mode) {
6660 case WB_DOWNLOAD_MICROCODE_AND_REVERT_MODE:
6661 scmd->satacmd_features_reg = SATA_DOWNLOAD_MCODE_TEMP;
6662 break;
6663 case WB_DOWNLOAD_MICROCODE_AND_SAVE_MODE:
6664 scmd->satacmd_features_reg = SATA_DOWNLOAD_MCODE_SAVE;
6665 break;
6666 default:
6667 goto bad_param;
6668 }
6669
6670 *scsipkt->pkt_scbp = STATUS_GOOD; /* Presumed outcome */
6671
6672 scmd->satacmd_cmd_reg = SATAC_DOWNLOAD_MICROCODE;
6673 if ((bp->b_bcount % SATA_DISK_SECTOR_SIZE) != 0)
6674 goto bad_param;
6675 sector_count = bp->b_bcount / SATA_DISK_SECTOR_SIZE;
6676 scmd->satacmd_sec_count_lsb = (uint8_t)sector_count;
6677 scmd->satacmd_lba_low_lsb = ((uint16_t)sector_count) >> 8;
6678 scmd->satacmd_lba_mid_lsb = 0;
6679 scmd->satacmd_lba_high_lsb = 0;
6680 scmd->satacmd_device_reg = 0;
6681 spx->txlt_sata_pkt->satapkt_comp = NULL;
6682 scmd->satacmd_addr_type = 0;
6683
6684 /* Transfer command to HBA */
6685 if (sata_hba_start(spx, &rval) != 0) {
6686 /* Pkt not accepted for execution */
6687 mutex_exit(cport_mutex);
6688 return (rval);
6689 }
6690
6691 mutex_exit(cport_mutex);
6692
6693 /* Then we need synchronous check the status of the disk */
6694 scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET |
6695 STATE_SENT_CMD | STATE_XFERRED_DATA | STATE_GOT_STATUS;
6696 if (sata_pkt->satapkt_reason == SATA_PKT_COMPLETED) {
6697 scsipkt->pkt_reason = CMD_CMPLT;
6698
6699 /* Download commmand succeed, so probe and identify device */
6700 sata_reidentify_device(spx);
6701 } else {
6702 /* Something went wrong, microcode download command failed */
6703 scsipkt->pkt_reason = CMD_INCOMPLETE;
6704 *scsipkt->pkt_scbp = STATUS_CHECK;
6705 sense = sata_arq_sense(spx);
6706 switch (sata_pkt->satapkt_reason) {
6707 case SATA_PKT_PORT_ERROR:
6708 /*
6709 * We have no device data. Assume no data transfered.
6710 */
6711 sense->es_key = KEY_HARDWARE_ERROR;
6712 break;
6713
6714 case SATA_PKT_DEV_ERROR:
6715 if (sata_pkt->satapkt_cmd.satacmd_status_reg &
6716 SATA_STATUS_ERR) {
6717 /*
6718 * determine dev error reason from error
6719 * reg content
6720 */
6721 sata_decode_device_error(spx, sense);
6722 break;
6723 }
6724 /* No extended sense key - no info available */
6725 break;
6726
6727 case SATA_PKT_TIMEOUT:
6728 scsipkt->pkt_reason = CMD_TIMEOUT;
6729 scsipkt->pkt_statistics |=
6730 STAT_TIMEOUT | STAT_DEV_RESET;
6731 /* No extended sense key ? */
6732 break;
6733
6734 case SATA_PKT_ABORTED:
6735 scsipkt->pkt_reason = CMD_ABORTED;
6736 scsipkt->pkt_statistics |= STAT_ABORTED;
6737 /* No extended sense key ? */
6738 break;
6739
6740 case SATA_PKT_RESET:
6741 /* pkt aborted by an explicit reset from a host */
6742 scsipkt->pkt_reason = CMD_RESET;
6743 scsipkt->pkt_statistics |= STAT_DEV_RESET;
6744 break;
6745
6746 default:
6747 SATA_LOG_D((spx->txlt_sata_hba_inst, CE_WARN,
6748 "sata_txlt_nodata_cmd_completion: "
6749 "invalid packet completion reason %d",
6750 sata_pkt->satapkt_reason));
6751 scsipkt->pkt_reason = CMD_TRAN_ERR;
6752 break;
6753 }
6754
6755 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst,
6756 "scsi_pkt completion reason %x\n", scsipkt->pkt_reason);
6757
6758 if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0)
6759 /* scsi callback required */
6760 scsi_hba_pkt_comp(scsipkt);
6761 }
6762 return (TRAN_ACCEPT);
6763
6764 bad_param:
6765 mutex_exit(cport_mutex);
6766 *scsipkt->pkt_scbp = STATUS_CHECK;
6767 sense = sata_arq_sense(spx);
6768 sense->es_key = KEY_ILLEGAL_REQUEST;
6769 sense->es_add_code = SD_SCSI_ASC_INVALID_FIELD_IN_CDB;
6770 if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0 &&
6771 scsipkt->pkt_comp != NULL) {
6772 /* scsi callback required */
6773 if (servicing_interrupt()) {
6774 if (taskq_dispatch(SATA_TXLT_TASKQ(spx),
6775 (task_func_t *)spx->txlt_scsi_pkt->pkt_comp,
6776 (void *)spx->txlt_scsi_pkt, TQ_NOSLEEP) == NULL) {
6777 return (TRAN_BUSY);
6778 }
6779 } else if (taskq_dispatch(SATA_TXLT_TASKQ(spx),
6780 (task_func_t *)spx->txlt_scsi_pkt->pkt_comp,
6781 (void *)spx->txlt_scsi_pkt, TQ_SLEEP) == NULL) {
6782 /* Scheduling the callback failed */
6783 return (TRAN_BUSY);
6784 }
6785 }
6786 return (rval);
6787 }
6788
6789 /*
6790 * Re-identify device after doing a firmware download.
6791 */
6792 static void
6793 sata_reidentify_device(sata_pkt_txlate_t *spx)
6794 {
6795 #define DOWNLOAD_WAIT_TIME_SECS 60
6796 #define DOWNLOAD_WAIT_INTERVAL_SECS 1
6797 int rval;
6798 int retry_cnt;
6799 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt;
6800 sata_hba_inst_t *sata_hba_inst = spx->txlt_sata_hba_inst;
6801 sata_device_t sata_device = spx->txlt_sata_pkt->satapkt_device;
6802 sata_drive_info_t *sdinfo;
6803
6804 /*
6805 * Before returning good status, probe device.
6806 * Device probing will get IDENTIFY DEVICE data, if possible.
6807 * The assumption is that the new microcode is applied by the
6808 * device. It is a caller responsibility to verify this.
6809 */
6810 for (retry_cnt = 0;
6811 retry_cnt < DOWNLOAD_WAIT_TIME_SECS / DOWNLOAD_WAIT_INTERVAL_SECS;
6812 retry_cnt++) {
6813 rval = sata_probe_device(sata_hba_inst, &sata_device);
6814
6815 if (rval == SATA_SUCCESS) { /* Set default features */
6816 sdinfo = sata_get_device_info(sata_hba_inst,
6817 &sata_device);
6818 if (sata_initialize_device(sata_hba_inst, sdinfo) !=
6819 SATA_SUCCESS) {
6820 /* retry */
6821 rval = sata_initialize_device(sata_hba_inst,
6822 sdinfo);
6823 if (rval == SATA_RETRY)
6824 sata_log(sata_hba_inst, CE_WARN,
6825 "SATA device at port %d pmport %d -"
6826 " default device features could not"
6827 " be set. Device may not operate "
6828 "as expected.",
6829 sata_device.satadev_addr.cport,
6830 sata_device.satadev_addr.pmport);
6831 }
6832 if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0)
6833 scsi_hba_pkt_comp(scsipkt);
6834 return;
6835 } else if (rval == SATA_RETRY) {
6836 delay(drv_usectohz(1000000 *
6837 DOWNLOAD_WAIT_INTERVAL_SECS));
6838 continue;
6839 } else /* failed - no reason to retry */
6840 break;
6841 }
6842
6843 /*
6844 * Something went wrong, device probing failed.
6845 */
6846 SATA_LOG_D((sata_hba_inst, CE_WARN,
6847 "Cannot probe device after downloading microcode\n"));
6848
6849 /* Reset device to force retrying the probe. */
6850 (void) (*SATA_RESET_DPORT_FUNC(sata_hba_inst))
6851 (SATA_DIP(sata_hba_inst), &sata_device);
6852
6853 if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0)
6854 scsi_hba_pkt_comp(scsipkt);
6855 }
6856
6857
6858 /*
6859 * Translate command: Synchronize Cache.
6860 * Translates into Flush Cache command for SATA hard disks.
6861 *
6862 * Returns TRAN_ACCEPT or code returned by sata_hba_start() and
6863 * appropriate values in scsi_pkt fields.
6864 */
6865 static int
6866 sata_txlt_synchronize_cache(sata_pkt_txlate_t *spx)
6867 {
6868 sata_cmd_t *scmd = &spx->txlt_sata_pkt->satapkt_cmd;
6869 kmutex_t *cport_mutex = &(SATA_TXLT_CPORT_MUTEX(spx));
6870 int rval, reason;
6871 int synch;
6872
6873 mutex_enter(cport_mutex);
6874
6875 if (((rval = sata_txlt_generic_pkt_info(spx, &reason, 1)) !=
6876 TRAN_ACCEPT) || (reason == CMD_DEV_GONE)) {
6877 mutex_exit(cport_mutex);
6878 return (rval);
6879 }
6880
6881 scmd->satacmd_addr_type = 0;
6882 scmd->satacmd_cmd_reg = SATAC_FLUSH_CACHE;
6883 scmd->satacmd_device_reg = 0;
6884 scmd->satacmd_sec_count_lsb = 0;
6885 scmd->satacmd_lba_low_lsb = 0;
6886 scmd->satacmd_lba_mid_lsb = 0;
6887 scmd->satacmd_lba_high_lsb = 0;
6888 scmd->satacmd_features_reg = 0;
6889 scmd->satacmd_status_reg = 0;
6890 scmd->satacmd_error_reg = 0;
6891
6892 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst,
6893 "sata_txlt_synchronize_cache\n", NULL);
6894
6895 if (!(spx->txlt_sata_pkt->satapkt_op_mode & SATA_OPMODE_SYNCH)) {
6896 /* Need to set-up a callback function */
6897 spx->txlt_sata_pkt->satapkt_comp =
6898 sata_txlt_nodata_cmd_completion;
6899 synch = FALSE;
6900 } else
6901 synch = TRUE;
6902
6903 /* Transfer command to HBA */
6904 if (sata_hba_start(spx, &rval) != 0) {
6905 /* Pkt not accepted for execution */
6906 mutex_exit(cport_mutex);
6907 return (rval);
6908 }
6909 mutex_exit(cport_mutex);
6910
6911 /*
6912 * If execution non-synchronous, it had to be completed
6913 * a callback function will handle potential errors, translate
6914 * the response and will do a callback to a target driver.
6915 * If it was synchronous, check status, using the same
6916 * framework callback.
6917 */
6918 if (synch) {
6919 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst,
6920 "synchronous execution status %x\n",
6921 spx->txlt_sata_pkt->satapkt_reason);
6922 sata_txlt_nodata_cmd_completion(spx->txlt_sata_pkt);
6923 }
6924 return (TRAN_ACCEPT);
6925 }
6926
6927
6928 /*
6929 * Send pkt to SATA HBA driver
6930 *
6931 * This function may be called only if the operation is requested by scsi_pkt,
6932 * i.e. scsi_pkt is not NULL.
6933 *
6934 * This function has to be called with cport mutex held. It does release
6935 * the mutex when it calls HBA driver sata_tran_start function and
6936 * re-acquires it afterwards.
6937 *
6938 * If return value is 0, pkt was accepted, -1 otherwise
6939 * rval is set to appropriate sata_scsi_start return value.
6940 *
6941 * Note 1:If HBA driver returns value other than TRAN_ACCEPT, it should not
6942 * have called the sata_pkt callback function for this packet.
6943 *
6944 * The scsi callback has to be performed by the caller of this routine.
6945 */
6946 static int
6947 sata_hba_start(sata_pkt_txlate_t *spx, int *rval)
6948 {
6949 int stat;
6950 uint8_t cport = SATA_TXLT_CPORT(spx);
6951 uint8_t pmport = SATA_TXLT_PMPORT(spx);
6952 sata_hba_inst_t *sata_hba_inst = spx->txlt_sata_hba_inst;
6953 sata_drive_info_t *sdinfo;
6954 sata_pmult_info_t *pminfo;
6955 sata_pmport_info_t *pmportinfo = NULL;
6956 sata_device_t *sata_device = NULL;
6957 uint8_t cmd;
6958 struct sata_cmd_flags cmd_flags;
6959
6960 ASSERT(spx->txlt_sata_pkt != NULL);
6961
6962 ASSERT(mutex_owned(&SATA_CPORT_MUTEX(sata_hba_inst, cport)));
6963
6964 sdinfo = sata_get_device_info(sata_hba_inst,
6965 &spx->txlt_sata_pkt->satapkt_device);
6966 ASSERT(sdinfo != NULL);
6967
6968 /* Clear device reset state? */
6969 /* qual should be XXX_DPMPORT, but add XXX_PMPORT in case */
6970 if (sdinfo->satadrv_addr.qual == SATA_ADDR_DPMPORT ||
6971 sdinfo->satadrv_addr.qual == SATA_ADDR_PMPORT) {
6972
6973 /*
6974 * Get the pmult_info of the its parent port multiplier, all
6975 * sub-devices share a common device reset flags on in
6976 * pmult_info.
6977 */
6978 pminfo = SATA_PMULT_INFO(sata_hba_inst, cport);
6979 pmportinfo = pminfo->pmult_dev_port[pmport];
6980 ASSERT(pminfo != NULL);
6981 if (pminfo->pmult_event_flags & SATA_EVNT_CLEAR_DEVICE_RESET) {
6982 spx->txlt_sata_pkt->satapkt_cmd.satacmd_flags.
6983 sata_clear_dev_reset = B_TRUE;
6984 pminfo->pmult_event_flags &=
6985 ~SATA_EVNT_CLEAR_DEVICE_RESET;
6986 SATADBG1(SATA_DBG_EVENTS, sata_hba_inst,
6987 "sata_hba_start: clearing device reset state"
6988 "on pmult.\n", NULL);
6989 }
6990 } else {
6991 if (sdinfo->satadrv_event_flags &
6992 SATA_EVNT_CLEAR_DEVICE_RESET) {
6993 spx->txlt_sata_pkt->satapkt_cmd.satacmd_flags.
6994 sata_clear_dev_reset = B_TRUE;
6995 sdinfo->satadrv_event_flags &=
6996 ~SATA_EVNT_CLEAR_DEVICE_RESET;
6997 SATADBG1(SATA_DBG_EVENTS, sata_hba_inst,
6998 "sata_hba_start: clearing device reset state\n",
6999 NULL);
7000 }
7001 }
7002
7003 cmd = spx->txlt_sata_pkt->satapkt_cmd.satacmd_cmd_reg;
7004 cmd_flags = spx->txlt_sata_pkt->satapkt_cmd.satacmd_flags;
7005 sata_device = &spx->txlt_sata_pkt->satapkt_device;
7006
7007 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, cport)));
7008
7009 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst,
7010 "Sata cmd 0x%2x\n", cmd);
7011
7012 stat = (*SATA_START_FUNC(sata_hba_inst))(SATA_DIP(sata_hba_inst),
7013 spx->txlt_sata_pkt);
7014 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, cport)));
7015 /*
7016 * If sata pkt was accepted and executed in asynchronous mode, i.e.
7017 * with the sata callback, the sata_pkt could be already destroyed
7018 * by the time we check ther return status from the hba_start()
7019 * function, because sata_scsi_destroy_pkt() could have been already
7020 * called (perhaps in the interrupt context). So, in such case, there
7021 * should be no references to it. In other cases, sata_pkt still
7022 * exists.
7023 */
7024 if (stat == SATA_TRAN_ACCEPTED) {
7025 /*
7026 * pkt accepted for execution.
7027 * If it was executed synchronously, it is already completed
7028 * and pkt completion_reason indicates completion status.
7029 */
7030 *rval = TRAN_ACCEPT;
7031 return (0);
7032 }
7033
7034 sdinfo = sata_get_device_info(sata_hba_inst, sata_device);
7035 switch (stat) {
7036 case SATA_TRAN_QUEUE_FULL:
7037 /*
7038 * Controller detected queue full condition.
7039 */
7040 SATADBG1(SATA_DBG_HBA_IF, sata_hba_inst,
7041 "sata_hba_start: queue full\n", NULL);
7042
7043 spx->txlt_scsi_pkt->pkt_reason = CMD_INCOMPLETE;
7044 *spx->txlt_scsi_pkt->pkt_scbp = STATUS_QFULL;
7045
7046 *rval = TRAN_BUSY;
7047 break;
7048
7049 case SATA_TRAN_PORT_ERROR:
7050 /*
7051 * Communication/link with device or general port error
7052 * detected before pkt execution begun.
7053 */
7054 if (spx->txlt_sata_pkt->satapkt_device.satadev_addr.qual ==
7055 SATA_ADDR_CPORT ||
7056 spx->txlt_sata_pkt->satapkt_device.satadev_addr.qual ==
7057 SATA_ADDR_DCPORT)
7058 sata_log(sata_hba_inst, CE_CONT,
7059 "SATA port %d error",
7060 sata_device->satadev_addr.cport);
7061 else
7062 sata_log(sata_hba_inst, CE_CONT,
7063 "SATA port %d:%d error\n",
7064 sata_device->satadev_addr.cport,
7065 sata_device->satadev_addr.pmport);
7066
7067 /*
7068 * Update the port/device structure.
7069 * sata_pkt should be still valid. Since port error is
7070 * returned, sata_device content should reflect port
7071 * state - it means, that sata address have been changed,
7072 * because original packet's sata address refered to a device
7073 * attached to some port.
7074 */
7075 if (sata_device->satadev_addr.qual == SATA_ADDR_DPMPORT ||
7076 sata_device->satadev_addr.qual == SATA_ADDR_PMPORT) {
7077 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, cport)));
7078 mutex_enter(&pmportinfo->pmport_mutex);
7079 sata_update_pmport_info(sata_hba_inst, sata_device);
7080 mutex_exit(&pmportinfo->pmport_mutex);
7081 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, cport)));
7082 } else {
7083 sata_update_port_info(sata_hba_inst, sata_device);
7084 }
7085
7086 spx->txlt_scsi_pkt->pkt_reason = CMD_TRAN_ERR;
7087 *rval = TRAN_FATAL_ERROR;
7088 break;
7089
7090 case SATA_TRAN_CMD_UNSUPPORTED:
7091 /*
7092 * Command rejected by HBA as unsupported. It was HBA driver
7093 * that rejected the command, command was not sent to
7094 * an attached device.
7095 */
7096 if ((sdinfo != NULL) &&
7097 (sdinfo->satadrv_state & SATA_DSTATE_RESET))
7098 SATADBG1(SATA_DBG_EVENTS, sata_hba_inst,
7099 "sat_hba_start: cmd 0x%2x rejected "
7100 "with SATA_TRAN_CMD_UNSUPPORTED status\n", cmd);
7101
7102 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, cport)));
7103 (void) sata_txlt_invalid_command(spx);
7104 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, cport)));
7105
7106 *rval = TRAN_ACCEPT;
7107 break;
7108
7109 case SATA_TRAN_BUSY:
7110 /*
7111 * Command rejected by HBA because other operation prevents
7112 * accepting the packet, or device is in RESET condition.
7113 */
7114 if (sdinfo != NULL) {
7115 sdinfo->satadrv_state =
7116 spx->txlt_sata_pkt->satapkt_device.satadev_state;
7117
7118 if (sdinfo->satadrv_state & SATA_DSTATE_RESET) {
7119 SATADBG1(SATA_DBG_EVENTS, sata_hba_inst,
7120 "sata_hba_start: cmd 0x%2x rejected "
7121 "because of device reset condition\n",
7122 cmd);
7123 } else {
7124 SATADBG1(SATA_DBG_EVENTS, sata_hba_inst,
7125 "sata_hba_start: cmd 0x%2x rejected "
7126 "with SATA_TRAN_BUSY status\n",
7127 cmd);
7128 }
7129 }
7130 spx->txlt_scsi_pkt->pkt_reason = CMD_INCOMPLETE;
7131 *rval = TRAN_BUSY;
7132 break;
7133
7134 default:
7135 /* Unrecognized HBA response */
7136 SATA_LOG_D((sata_hba_inst, CE_WARN,
7137 "sata_hba_start: unrecognized HBA response "
7138 "to cmd : 0x%2x resp 0x%x", cmd, rval));
7139 spx->txlt_scsi_pkt->pkt_reason = CMD_TRAN_ERR;
7140 *rval = TRAN_FATAL_ERROR;
7141 break;
7142 }
7143
7144 /*
7145 * If we got here, the packet was rejected.
7146 * Check if we need to remember reset state clearing request
7147 */
7148 if (cmd_flags.sata_clear_dev_reset) {
7149 /*
7150 * Check if device is still configured - it may have
7151 * disapeared from the configuration
7152 */
7153 sdinfo = sata_get_device_info(sata_hba_inst, sata_device);
7154 if (sdinfo != NULL) {
7155 /*
7156 * Restore the flag that requests clearing of
7157 * the device reset state,
7158 * so the next sata packet may carry it to HBA.
7159 */
7160 if (sdinfo->satadrv_addr.qual == SATA_ADDR_PMPORT ||
7161 sdinfo->satadrv_addr.qual == SATA_ADDR_DPMPORT) {
7162 pminfo->pmult_event_flags |=
7163 SATA_EVNT_CLEAR_DEVICE_RESET;
7164 } else {
7165 sdinfo->satadrv_event_flags |=
7166 SATA_EVNT_CLEAR_DEVICE_RESET;
7167 }
7168 }
7169 }
7170 return (-1);
7171 }
7172
7173 /*
7174 * Scsi response setup for invalid LBA
7175 *
7176 * Returns TRAN_ACCEPT and appropriate values in scsi_pkt fields.
7177 */
7178 static int
7179 sata_txlt_lba_out_of_range(sata_pkt_txlate_t *spx)
7180 {
7181 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt;
7182 struct scsi_extended_sense *sense;
7183
7184 scsipkt->pkt_reason = CMD_CMPLT;
7185 scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET |
7186 STATE_SENT_CMD | STATE_GOT_STATUS;
7187 *scsipkt->pkt_scbp = STATUS_CHECK;
7188
7189 *scsipkt->pkt_scbp = STATUS_CHECK;
7190 sense = sata_arq_sense(spx);
7191 sense->es_key = KEY_ILLEGAL_REQUEST;
7192 sense->es_add_code = SD_SCSI_ASC_LBA_OUT_OF_RANGE;
7193
7194 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst,
7195 "Scsi_pkt completion reason %x\n", scsipkt->pkt_reason);
7196
7197 if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0 &&
7198 scsipkt->pkt_comp != NULL) {
7199 /* scsi callback required */
7200 if (servicing_interrupt()) {
7201 if (taskq_dispatch(SATA_TXLT_TASKQ(spx),
7202 (task_func_t *)spx->txlt_scsi_pkt->pkt_comp,
7203 (void *)spx->txlt_scsi_pkt, TQ_NOSLEEP) == NULL) {
7204 return (TRAN_BUSY);
7205 }
7206 } else if (taskq_dispatch(SATA_TXLT_TASKQ(spx),
7207 (task_func_t *)spx->txlt_scsi_pkt->pkt_comp,
7208 (void *)spx->txlt_scsi_pkt, TQ_SLEEP) == NULL) {
7209 /* Scheduling the callback failed */
7210 return (TRAN_BUSY);
7211 }
7212 }
7213 return (TRAN_ACCEPT);
7214 }
7215
7216
7217 /*
7218 * Analyze device status and error registers and translate them into
7219 * appropriate scsi sense codes.
7220 * NOTE: non-packet commands only for now
7221 */
7222 static void
7223 sata_decode_device_error(sata_pkt_txlate_t *spx,
7224 struct scsi_extended_sense *sense)
7225 {
7226 uint8_t err_reg = spx->txlt_sata_pkt->satapkt_cmd.satacmd_error_reg;
7227
7228 ASSERT(sense != NULL);
7229 ASSERT(spx->txlt_sata_pkt->satapkt_cmd.satacmd_status_reg &
7230 SATA_STATUS_ERR);
7231
7232
7233 if (err_reg & SATA_ERROR_ICRC) {
7234 sense->es_key = KEY_ABORTED_COMMAND;
7235 sense->es_add_code = 0x08; /* Communication failure */
7236 return;
7237 }
7238
7239 if (err_reg & SATA_ERROR_UNC) {
7240 sense->es_key = KEY_MEDIUM_ERROR;
7241 /* Information bytes (LBA) need to be set by a caller */
7242 return;
7243 }
7244
7245 /* ADD HERE: MC error bit handling for ATAPI CD/DVD */
7246 if (err_reg & (SATA_ERROR_MCR | SATA_ERROR_NM)) {
7247 sense->es_key = KEY_UNIT_ATTENTION;
7248 sense->es_add_code = 0x3a; /* No media present */
7249 return;
7250 }
7251
7252 if (err_reg & SATA_ERROR_IDNF) {
7253 if (err_reg & SATA_ERROR_ABORT) {
7254 sense->es_key = KEY_ABORTED_COMMAND;
7255 } else {
7256 sense->es_key = KEY_ILLEGAL_REQUEST;
7257 sense->es_add_code = 0x21; /* LBA out of range */
7258 }
7259 return;
7260 }
7261
7262 if (err_reg & SATA_ERROR_ABORT) {
7263 ASSERT(spx->txlt_sata_pkt != NULL);
7264 sense->es_key = KEY_ABORTED_COMMAND;
7265 return;
7266 }
7267 }
7268
7269 /*
7270 * Extract error LBA from sata_pkt.satapkt_cmd register fields
7271 */
7272 static void
7273 sata_extract_error_lba(sata_pkt_txlate_t *spx, uint64_t *lba)
7274 {
7275 sata_cmd_t *sata_cmd = &spx->txlt_sata_pkt->satapkt_cmd;
7276
7277 *lba = 0;
7278 if (sata_cmd->satacmd_addr_type == ATA_ADDR_LBA48) {
7279 *lba = sata_cmd->satacmd_lba_high_msb;
7280 *lba = (*lba << 8) | sata_cmd->satacmd_lba_mid_msb;
7281 *lba = (*lba << 8) | sata_cmd->satacmd_lba_low_msb;
7282 } else if (sata_cmd->satacmd_addr_type == ATA_ADDR_LBA28) {
7283 *lba = sata_cmd->satacmd_device_reg & 0xf;
7284 }
7285 *lba = (*lba << 8) | sata_cmd->satacmd_lba_high_lsb;
7286 *lba = (*lba << 8) | sata_cmd->satacmd_lba_mid_lsb;
7287 *lba = (*lba << 8) | sata_cmd->satacmd_lba_low_lsb;
7288 }
7289
7290 /*
7291 * This is fixed sense format - if LBA exceeds the info field size,
7292 * no valid info will be returned (valid bit in extended sense will
7293 * be set to 0).
7294 */
7295 static struct scsi_extended_sense *
7296 sata_arq_sense(sata_pkt_txlate_t *spx)
7297 {
7298 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt;
7299 struct scsi_arq_status *arqs;
7300 struct scsi_extended_sense *sense;
7301
7302 /* Fill ARQ sense data */
7303 scsipkt->pkt_state |= STATE_ARQ_DONE;
7304 arqs = (struct scsi_arq_status *)scsipkt->pkt_scbp;
7305 *(uchar_t *)&arqs->sts_status = STATUS_CHECK;
7306 *(uchar_t *)&arqs->sts_rqpkt_status = STATUS_GOOD;
7307 arqs->sts_rqpkt_reason = CMD_CMPLT;
7308 arqs->sts_rqpkt_state = STATE_GOT_BUS | STATE_GOT_TARGET |
7309 STATE_XFERRED_DATA | STATE_SENT_CMD | STATE_GOT_STATUS;
7310 arqs->sts_rqpkt_resid = 0;
7311 sense = &arqs->sts_sensedata;
7312 bzero(sense, sizeof (struct scsi_extended_sense));
7313 sata_fixed_sense_data_preset(sense);
7314 return (sense);
7315 }
7316
7317 /*
7318 * ATA Pass Through support
7319 * Sets flags indicating that an invalid value was found in some
7320 * field in the command. It could be something illegal according to
7321 * the SAT-2 spec or it could be a feature that is not (yet?)
7322 * supported.
7323 */
7324 static int
7325 sata_txlt_ata_pass_thru_illegal_cmd(sata_pkt_txlate_t *spx)
7326 {
7327 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt;
7328 struct scsi_extended_sense *sense = sata_arq_sense(spx);
7329
7330 scsipkt->pkt_reason = CMD_CMPLT;
7331 *scsipkt->pkt_scbp = STATUS_CHECK;
7332 scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET |
7333 STATE_SENT_CMD | STATE_GOT_STATUS;
7334
7335 sense = sata_arq_sense(spx);
7336 sense->es_key = KEY_ILLEGAL_REQUEST;
7337 sense->es_add_code = SD_SCSI_ASC_INVALID_FIELD_IN_CDB;
7338
7339 if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0 &&
7340 scsipkt->pkt_comp != NULL) {
7341 /* scsi callback required */
7342 if (servicing_interrupt()) {
7343 if (taskq_dispatch(SATA_TXLT_TASKQ(spx),
7344 (task_func_t *)spx->txlt_scsi_pkt->pkt_comp,
7345 (void *)spx->txlt_scsi_pkt, TQ_NOSLEEP) == NULL) {
7346 return (TRAN_BUSY);
7347 }
7348 } else if (taskq_dispatch(SATA_TXLT_TASKQ(spx),
7349 (task_func_t *)spx->txlt_scsi_pkt->pkt_comp,
7350 (void *)spx->txlt_scsi_pkt, TQ_SLEEP) == NULL) {
7351 /* Scheduling the callback failed */
7352 return (TRAN_BUSY);
7353 }
7354 }
7355
7356 return (TRAN_ACCEPT);
7357 }
7358
7359 /*
7360 * The UNMAP command considers it not to be an error if the parameter length
7361 * or block descriptor length is 0. For this case, there is nothing for TRIM
7362 * to do so just complete the command.
7363 */
7364 static int
7365 sata_txlt_unmap_nodata_cmd(sata_pkt_txlate_t *spx)
7366 {
7367 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt;
7368
7369 scsipkt->pkt_reason = CMD_CMPLT;
7370 *scsipkt->pkt_scbp = STATUS_GOOD;
7371 scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET |
7372 STATE_SENT_CMD | STATE_GOT_STATUS;
7373
7374 if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0 &&
7375 scsipkt->pkt_comp != NULL) {
7376 /* scsi callback required */
7377 if (taskq_dispatch(SATA_TXLT_TASKQ(spx),
7378 (task_func_t *)spx->txlt_scsi_pkt->pkt_comp,
7379 (void *)spx->txlt_scsi_pkt, TQ_SLEEP) == NULL) {
7380 /* Scheduling the callback failed */
7381 return (TRAN_BUSY);
7382 }
7383 }
7384
7385 return (TRAN_ACCEPT);
7386 }
7387
7388 /*
7389 * Emulated SATA Read/Write command completion for zero-length requests.
7390 * This request always succedes, so in synchronous mode it always returns
7391 * TRAN_ACCEPT, and in non-synchronous mode it may return TRAN_BUSY if the
7392 * callback cannot be scheduled.
7393 */
7394 static int
7395 sata_emul_rw_completion(sata_pkt_txlate_t *spx)
7396 {
7397 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt;
7398
7399 scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET |
7400 STATE_SENT_CMD | STATE_GOT_STATUS;
7401 scsipkt->pkt_reason = CMD_CMPLT;
7402 *scsipkt->pkt_scbp = STATUS_GOOD;
7403 if (!(spx->txlt_sata_pkt->satapkt_op_mode & SATA_OPMODE_SYNCH)) {
7404 /* scsi callback required - have to schedule it */
7405 if (servicing_interrupt()) {
7406 if (taskq_dispatch(SATA_TXLT_TASKQ(spx),
7407 (task_func_t *)spx->txlt_scsi_pkt->pkt_comp,
7408 (void *)spx->txlt_scsi_pkt, TQ_NOSLEEP) == NULL) {
7409 return (TRAN_BUSY);
7410 }
7411 } else if (taskq_dispatch(SATA_TXLT_TASKQ(spx),
7412 (task_func_t *)spx->txlt_scsi_pkt->pkt_comp,
7413 (void *)spx->txlt_scsi_pkt, TQ_SLEEP) == NULL) {
7414 /* Scheduling the callback failed */
7415 return (TRAN_BUSY);
7416 }
7417 }
7418 return (TRAN_ACCEPT);
7419 }
7420
7421
7422 /*
7423 * Translate completion status of SATA read/write commands into scsi response.
7424 * pkt completion_reason is checked to determine the completion status.
7425 * Do scsi callback if necessary.
7426 *
7427 * Note: this function may be called also for synchronously executed
7428 * commands.
7429 * This function may be used only if scsi_pkt is non-NULL.
7430 */
7431 static void
7432 sata_txlt_rw_completion(sata_pkt_t *sata_pkt)
7433 {
7434 sata_pkt_txlate_t *spx =
7435 (sata_pkt_txlate_t *)sata_pkt->satapkt_framework_private;
7436 sata_cmd_t *scmd = &sata_pkt->satapkt_cmd;
7437 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt;
7438 struct scsi_extended_sense *sense;
7439 uint64_t lba;
7440 struct buf *bp;
7441 int rval;
7442 if (sata_pkt->satapkt_reason == SATA_PKT_COMPLETED) {
7443 /* Normal completion */
7444 scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET |
7445 STATE_SENT_CMD | STATE_XFERRED_DATA | STATE_GOT_STATUS;
7446 scsipkt->pkt_reason = CMD_CMPLT;
7447 *scsipkt->pkt_scbp = STATUS_GOOD;
7448 if (spx->txlt_tmp_buf != NULL) {
7449 /* Temporary buffer was used */
7450 bp = spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp;
7451 if (bp->b_flags & B_READ) {
7452 rval = ddi_dma_sync(
7453 spx->txlt_buf_dma_handle, 0, 0,
7454 DDI_DMA_SYNC_FORCPU);
7455 ASSERT(rval == DDI_SUCCESS);
7456 bcopy(spx->txlt_tmp_buf, bp->b_un.b_addr,
7457 bp->b_bcount);
7458 }
7459 }
7460 } else {
7461 /*
7462 * Something went wrong - analyze return
7463 */
7464 scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET |
7465 STATE_SENT_CMD | STATE_GOT_STATUS;
7466 scsipkt->pkt_reason = CMD_INCOMPLETE;
7467 *scsipkt->pkt_scbp = STATUS_CHECK;
7468 sense = sata_arq_sense(spx);
7469 ASSERT(sense != NULL);
7470
7471 /*
7472 * SATA_PKT_DEV_ERROR is the only case where we may be able to
7473 * extract from device registers the failing LBA.
7474 */
7475 if (sata_pkt->satapkt_reason == SATA_PKT_DEV_ERROR) {
7476 if ((scmd->satacmd_addr_type == ATA_ADDR_LBA48) &&
7477 (scmd->satacmd_lba_mid_msb != 0 ||
7478 scmd->satacmd_lba_high_msb != 0)) {
7479 /*
7480 * We have problem reporting this cmd LBA
7481 * in fixed sense data format, because of
7482 * the size of the scsi LBA fields.
7483 */
7484 sense->es_valid = 0;
7485 } else {
7486 sata_extract_error_lba(spx, &lba);
7487 sense->es_info_1 = (lba & 0xFF000000) >> 24;
7488 sense->es_info_2 = (lba & 0xFF0000) >> 16;
7489 sense->es_info_3 = (lba & 0xFF00) >> 8;
7490 sense->es_info_4 = lba & 0xFF;
7491 }
7492 } else {
7493 /* Invalid extended sense info */
7494 sense->es_valid = 0;
7495 }
7496
7497 switch (sata_pkt->satapkt_reason) {
7498 case SATA_PKT_PORT_ERROR:
7499 /* We may want to handle DEV GONE state as well */
7500 /*
7501 * We have no device data. Assume no data transfered.
7502 */
7503 sense->es_key = KEY_HARDWARE_ERROR;
7504 break;
7505
7506 case SATA_PKT_DEV_ERROR:
7507 if (sata_pkt->satapkt_cmd.satacmd_status_reg &
7508 SATA_STATUS_ERR) {
7509 /*
7510 * determine dev error reason from error
7511 * reg content
7512 */
7513 sata_decode_device_error(spx, sense);
7514 if (sense->es_key == KEY_MEDIUM_ERROR) {
7515 switch (scmd->satacmd_cmd_reg) {
7516 case SATAC_READ_DMA:
7517 case SATAC_READ_DMA_EXT:
7518 case SATAC_READ_DMA_QUEUED:
7519 case SATAC_READ_DMA_QUEUED_EXT:
7520 case SATAC_READ_FPDMA_QUEUED:
7521 /* Unrecovered read error */
7522 sense->es_add_code =
7523 SD_SCSI_ASC_UNREC_READ_ERR;
7524 break;
7525 case SATAC_WRITE_DMA:
7526 case SATAC_WRITE_DMA_EXT:
7527 case SATAC_WRITE_DMA_QUEUED:
7528 case SATAC_WRITE_DMA_QUEUED_EXT:
7529 case SATAC_WRITE_FPDMA_QUEUED:
7530 /* Write error */
7531 sense->es_add_code =
7532 SD_SCSI_ASC_WRITE_ERR;
7533 break;
7534 default:
7535 /* Internal error */
7536 SATA_LOG_D((
7537 spx->txlt_sata_hba_inst,
7538 CE_WARN,
7539 "sata_txlt_rw_completion :"
7540 "internal error - invalid "
7541 "command 0x%2x",
7542 scmd->satacmd_cmd_reg));
7543 break;
7544 }
7545 }
7546 break;
7547 }
7548 /* No extended sense key - no info available */
7549 scsipkt->pkt_reason = CMD_INCOMPLETE;
7550 break;
7551
7552 case SATA_PKT_TIMEOUT:
7553 scsipkt->pkt_reason = CMD_TIMEOUT;
7554 scsipkt->pkt_statistics |=
7555 STAT_TIMEOUT | STAT_DEV_RESET;
7556 sense->es_key = KEY_ABORTED_COMMAND;
7557 break;
7558
7559 case SATA_PKT_ABORTED:
7560 scsipkt->pkt_reason = CMD_ABORTED;
7561 scsipkt->pkt_statistics |= STAT_ABORTED;
7562 sense->es_key = KEY_ABORTED_COMMAND;
7563 break;
7564
7565 case SATA_PKT_RESET:
7566 scsipkt->pkt_reason = CMD_RESET;
7567 scsipkt->pkt_statistics |= STAT_DEV_RESET;
7568 sense->es_key = KEY_ABORTED_COMMAND;
7569 break;
7570
7571 default:
7572 SATA_LOG_D((spx->txlt_sata_hba_inst, CE_WARN,
7573 "sata_txlt_rw_completion: "
7574 "invalid packet completion reason"));
7575 scsipkt->pkt_reason = CMD_TRAN_ERR;
7576 break;
7577 }
7578 }
7579 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst,
7580 "Scsi_pkt completion reason %x\n", scsipkt->pkt_reason);
7581
7582 if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0)
7583 /* scsi callback required */
7584 scsi_hba_pkt_comp(scsipkt);
7585 }
7586
7587
7588 /*
7589 * Translate completion status of non-data commands (i.e. commands returning
7590 * no data).
7591 * pkt completion_reason is checked to determine the completion status.
7592 * Do scsi callback if necessary (FLAG_NOINTR == 0)
7593 *
7594 * Note: this function may be called also for synchronously executed
7595 * commands.
7596 * This function may be used only if scsi_pkt is non-NULL.
7597 */
7598
7599 static void
7600 sata_txlt_nodata_cmd_completion(sata_pkt_t *sata_pkt)
7601 {
7602 sata_pkt_txlate_t *spx =
7603 (sata_pkt_txlate_t *)sata_pkt->satapkt_framework_private;
7604 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt;
7605
7606 sata_set_arq_data(sata_pkt);
7607
7608 if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0)
7609 /* scsi callback required */
7610 scsi_hba_pkt_comp(scsipkt);
7611 }
7612
7613 /*
7614 * Completion handler for ATA Pass Through command
7615 */
7616 static void
7617 sata_txlt_apt_completion(sata_pkt_t *sata_pkt)
7618 {
7619 sata_pkt_txlate_t *spx =
7620 (sata_pkt_txlate_t *)sata_pkt->satapkt_framework_private;
7621 sata_cmd_t *scmd = &sata_pkt->satapkt_cmd;
7622 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt;
7623 struct buf *bp;
7624 uint8_t sense_key = 0, addl_sense_code = 0, addl_sense_qual = 0;
7625
7626 if (sata_pkt->satapkt_reason == SATA_PKT_COMPLETED) {
7627 /* Normal completion */
7628 scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET |
7629 STATE_SENT_CMD | STATE_XFERRED_DATA | STATE_GOT_STATUS;
7630 scsipkt->pkt_reason = CMD_CMPLT;
7631 *scsipkt->pkt_scbp = STATUS_GOOD;
7632
7633 /*
7634 * If the command has CK_COND set
7635 */
7636 if (scsipkt->pkt_cdbp[2] & SATL_APT_BM_CK_COND) {
7637 *scsipkt->pkt_scbp = STATUS_CHECK;
7638 sata_fill_ata_return_desc(sata_pkt,
7639 KEY_RECOVERABLE_ERROR,
7640 SD_SCSI_ASC_APT_INFO_AVAIL, 0x1d);
7641 }
7642
7643 if (spx->txlt_tmp_buf != NULL) {
7644 /* Temporary buffer was used */
7645 bp = spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp;
7646 if (bp->b_flags & B_READ) {
7647 bcopy(spx->txlt_tmp_buf, bp->b_un.b_addr,
7648 bp->b_bcount);
7649 }
7650 }
7651 } else {
7652 scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET |
7653 STATE_SENT_CMD | STATE_GOT_STATUS;
7654 scsipkt->pkt_reason = CMD_INCOMPLETE;
7655 *scsipkt->pkt_scbp = STATUS_CHECK;
7656
7657 /*
7658 * If DF or ERR was set, the HBA should have copied out the
7659 * status and error registers to the satacmd structure.
7660 */
7661 if (scmd->satacmd_status_reg & SATA_STATUS_DF) {
7662 sense_key = KEY_HARDWARE_ERROR;
7663 addl_sense_code = SD_SCSI_ASC_INTERNAL_TARGET_FAILURE;
7664 addl_sense_qual = 0;
7665 } else if (scmd->satacmd_status_reg & SATA_STATUS_ERR) {
7666 if (scmd->satacmd_error_reg & SATA_ERROR_NM) {
7667 sense_key = KEY_NOT_READY;
7668 addl_sense_code =
7669 SD_SCSI_ASC_MEDIUM_NOT_PRESENT;
7670 addl_sense_qual = 0;
7671 } else if (scmd->satacmd_error_reg & SATA_ERROR_UNC) {
7672 sense_key = KEY_MEDIUM_ERROR;
7673 addl_sense_code = SD_SCSI_ASC_UNREC_READ_ERR;
7674 addl_sense_qual = 0;
7675 } else if (scmd->satacmd_error_reg & SATA_ERROR_ILI) {
7676 sense_key = KEY_DATA_PROTECT;
7677 addl_sense_code = SD_SCSI_ASC_WRITE_PROTECTED;
7678 addl_sense_qual = 0;
7679 } else if (scmd->satacmd_error_reg & SATA_ERROR_IDNF) {
7680 sense_key = KEY_ILLEGAL_REQUEST;
7681 addl_sense_code = SD_SCSI_ASC_LBA_OUT_OF_RANGE;
7682 addl_sense_qual = 0;
7683 } else if (scmd->satacmd_error_reg & SATA_ERROR_ABORT) {
7684 sense_key = KEY_ABORTED_COMMAND;
7685 addl_sense_code = SD_SCSI_ASC_NO_ADD_SENSE;
7686 addl_sense_qual = 0;
7687 } else if (scmd->satacmd_error_reg & SATA_ERROR_MC) {
7688 sense_key = KEY_UNIT_ATTENTION;
7689 addl_sense_code =
7690 SD_SCSI_ASC_MEDIUM_MAY_HAVE_CHANGED;
7691 addl_sense_qual = 0;
7692 } else if (scmd->satacmd_error_reg & SATA_ERROR_MCR) {
7693 sense_key = KEY_UNIT_ATTENTION;
7694 addl_sense_code = SD_SCSI_ASC_OP_MEDIUM_REM_REQ;
7695 addl_sense_qual = 0;
7696 } else if (scmd->satacmd_error_reg & SATA_ERROR_ICRC) {
7697 sense_key = KEY_ABORTED_COMMAND;
7698 addl_sense_code =
7699 SD_SCSI_ASC_INFO_UNIT_IUCRC_ERR;
7700 addl_sense_qual = 0;
7701 }
7702 }
7703
7704 sata_fill_ata_return_desc(sata_pkt, sense_key, addl_sense_code,
7705 addl_sense_qual);
7706 }
7707
7708 if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0)
7709 /* scsi callback required */
7710 scsi_hba_pkt_comp(scsipkt);
7711 }
7712
7713 /*
7714 * Completion handler for unmap translation command
7715 */
7716 static void
7717 sata_txlt_unmap_completion(sata_pkt_t *sata_pkt)
7718 {
7719 sata_pkt_txlate_t *spx =
7720 (sata_pkt_txlate_t *)sata_pkt->satapkt_framework_private;
7721 sata_cmd_t *scmd = &sata_pkt->satapkt_cmd;
7722 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt;
7723 struct buf *bp;
7724 uint8_t sense_key = 0, addl_sense_code = 0, addl_sense_qual = 0;
7725
7726 if (sata_pkt->satapkt_reason == SATA_PKT_COMPLETED) {
7727 /* Normal completion */
7728 scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET |
7729 STATE_SENT_CMD | STATE_XFERRED_DATA | STATE_GOT_STATUS;
7730 scsipkt->pkt_reason = CMD_CMPLT;
7731 *scsipkt->pkt_scbp = STATUS_GOOD;
7732
7733 if (spx->txlt_tmp_buf != NULL) {
7734 /* Temporary buffer was used */
7735 bp = spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp;
7736 if (bp->b_flags & B_READ) {
7737 bcopy(spx->txlt_tmp_buf, bp->b_un.b_addr,
7738 bp->b_bcount);
7739 }
7740 }
7741 } else {
7742 scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET |
7743 STATE_SENT_CMD | STATE_GOT_STATUS;
7744 scsipkt->pkt_reason = CMD_INCOMPLETE;
7745 *scsipkt->pkt_scbp = STATUS_CHECK;
7746
7747 /*
7748 * If DF or ERR was set, the HBA should have copied out the
7749 * status and error registers to the satacmd structure.
7750 */
7751 if (scmd->satacmd_status_reg & SATA_STATUS_DF) {
7752 sense_key = KEY_HARDWARE_ERROR;
7753 addl_sense_code = SD_SCSI_ASC_INTERNAL_TARGET_FAILURE;
7754 addl_sense_qual = 0;
7755 } else if (scmd->satacmd_status_reg & SATA_STATUS_ERR) {
7756 if (scmd->satacmd_error_reg & SATA_ERROR_NM) {
7757 sense_key = KEY_NOT_READY;
7758 addl_sense_code =
7759 SD_SCSI_ASC_MEDIUM_NOT_PRESENT;
7760 addl_sense_qual = 0;
7761 } else if (scmd->satacmd_error_reg & SATA_ERROR_UNC) {
7762 sense_key = KEY_MEDIUM_ERROR;
7763 addl_sense_code = SD_SCSI_ASC_WRITE_ERR;
7764 addl_sense_qual = 0;
7765 } else if (scmd->satacmd_error_reg & SATA_ERROR_ILI) {
7766 sense_key = KEY_DATA_PROTECT;
7767 addl_sense_code = SD_SCSI_ASC_WRITE_PROTECTED;
7768 addl_sense_qual = 0;
7769 } else if (scmd->satacmd_error_reg & SATA_ERROR_IDNF) {
7770 sense_key = KEY_ILLEGAL_REQUEST;
7771 addl_sense_code = SD_SCSI_ASC_LBA_OUT_OF_RANGE;
7772 addl_sense_qual = 0;
7773 } else if (scmd->satacmd_error_reg & SATA_ERROR_ABORT) {
7774 sense_key = KEY_ABORTED_COMMAND;
7775 addl_sense_code = SD_SCSI_ASC_NO_ADD_SENSE;
7776 addl_sense_qual = 0;
7777 } else if (scmd->satacmd_error_reg & SATA_ERROR_MC) {
7778 sense_key = KEY_UNIT_ATTENTION;
7779 addl_sense_code =
7780 SD_SCSI_ASC_MEDIUM_MAY_HAVE_CHANGED;
7781 addl_sense_qual = 0;
7782 } else if (scmd->satacmd_error_reg & SATA_ERROR_MCR) {
7783 sense_key = KEY_UNIT_ATTENTION;
7784 addl_sense_code = SD_SCSI_ASC_OP_MEDIUM_REM_REQ;
7785 addl_sense_qual = 0;
7786 } else if (scmd->satacmd_error_reg & SATA_ERROR_ICRC) {
7787 sense_key = KEY_ABORTED_COMMAND;
7788 addl_sense_code =
7789 SD_SCSI_ASC_INFO_UNIT_IUCRC_ERR;
7790 addl_sense_qual = 0;
7791 }
7792 }
7793
7794 sata_fill_ata_return_desc(sata_pkt, sense_key, addl_sense_code,
7795 addl_sense_qual);
7796 }
7797
7798 sata_free_local_buffer(spx);
7799
7800 if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0)
7801 /* scsi callback required */
7802 scsi_hba_pkt_comp(scsipkt);
7803 }
7804
7805 /*
7806 *
7807 */
7808 static void
7809 sata_fill_ata_return_desc(sata_pkt_t *sata_pkt, uint8_t sense_key,
7810 uint8_t addl_sense_code, uint8_t addl_sense_qual)
7811 {
7812 sata_pkt_txlate_t *spx =
7813 (sata_pkt_txlate_t *)sata_pkt->satapkt_framework_private;
7814 sata_cmd_t *scmd = &sata_pkt->satapkt_cmd;
7815 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt;
7816 struct sata_apt_sense_data *apt_sd =
7817 (struct sata_apt_sense_data *)scsipkt->pkt_scbp;
7818 struct scsi_descr_sense_hdr *sds = &(apt_sd->apt_sd_hdr);
7819 struct scsi_ata_status_ret_sense_descr *ata_ret_desc =
7820 &(apt_sd->apt_sd_sense);
7821 int extend = 0;
7822
7823 if ((scsipkt->pkt_cdbp[0] == SPC3_CMD_ATA_COMMAND_PASS_THROUGH16) &&
7824 (scsipkt->pkt_cdbp[2] & SATL_APT_BM_EXTEND))
7825 extend = 1;
7826
7827 scsipkt->pkt_state |= STATE_ARQ_DONE;
7828
7829 /* update the residual count */
7830 *(uchar_t *)&apt_sd->apt_status = STATUS_CHECK;
7831 *(uchar_t *)&apt_sd->apt_rqpkt_status = STATUS_GOOD;
7832 apt_sd->apt_rqpkt_reason = CMD_CMPLT;
7833 apt_sd->apt_rqpkt_state = STATE_GOT_BUS | STATE_GOT_TARGET |
7834 STATE_XFERRED_DATA | STATE_SENT_CMD | STATE_GOT_STATUS;
7835 apt_sd->apt_rqpkt_resid = scsipkt->pkt_scblen -
7836 sizeof (struct sata_apt_sense_data);
7837
7838 /*
7839 * Fill in the Descriptor sense header
7840 */
7841 bzero(sds, sizeof (struct scsi_descr_sense_hdr));
7842 sds->ds_code = CODE_FMT_DESCR_CURRENT;
7843 sds->ds_class = CLASS_EXTENDED_SENSE;
7844 sds->ds_key = sense_key & 0xf;
7845 sds->ds_add_code = addl_sense_code;
7846 sds->ds_qual_code = addl_sense_qual;
7847 sds->ds_addl_sense_length =
7848 sizeof (struct scsi_ata_status_ret_sense_descr);
7849
7850 /*
7851 * Fill in the ATA Return descriptor sense data
7852 */
7853 bzero(ata_ret_desc, sizeof (struct scsi_ata_status_ret_sense_descr));
7854 ata_ret_desc->ars_descr_type = DESCR_ATA_STATUS_RETURN;
7855 ata_ret_desc->ars_addl_length = 0xc;
7856 ata_ret_desc->ars_error = scmd->satacmd_error_reg;
7857 ata_ret_desc->ars_sec_count_lsb = scmd->satacmd_sec_count_lsb;
7858 ata_ret_desc->ars_lba_low_lsb = scmd->satacmd_lba_low_lsb;
7859 ata_ret_desc->ars_lba_mid_lsb = scmd->satacmd_lba_mid_lsb;
7860 ata_ret_desc->ars_lba_high_lsb = scmd->satacmd_lba_high_lsb;
7861 ata_ret_desc->ars_device = scmd->satacmd_device_reg;
7862 ata_ret_desc->ars_status = scmd->satacmd_status_reg;
7863
7864 if (extend == 1) {
7865 ata_ret_desc->ars_extend = 1;
7866 ata_ret_desc->ars_sec_count_msb = scmd->satacmd_sec_count_msb;
7867 ata_ret_desc->ars_lba_low_msb = scmd->satacmd_lba_low_msb;
7868 ata_ret_desc->ars_lba_mid_msb = scmd->satacmd_lba_mid_msb;
7869 ata_ret_desc->ars_lba_high_msb = scmd->satacmd_lba_high_msb;
7870 } else {
7871 ata_ret_desc->ars_extend = 0;
7872 ata_ret_desc->ars_sec_count_msb = 0;
7873 ata_ret_desc->ars_lba_low_msb = 0;
7874 ata_ret_desc->ars_lba_mid_msb = 0;
7875 ata_ret_desc->ars_lba_high_msb = 0;
7876 }
7877 }
7878
7879 static void
7880 sata_set_arq_data(sata_pkt_t *sata_pkt)
7881 {
7882 sata_pkt_txlate_t *spx =
7883 (sata_pkt_txlate_t *)sata_pkt->satapkt_framework_private;
7884 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt;
7885 struct scsi_extended_sense *sense;
7886
7887 scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET |
7888 STATE_SENT_CMD | STATE_GOT_STATUS;
7889 if (sata_pkt->satapkt_reason == SATA_PKT_COMPLETED) {
7890 /* Normal completion */
7891 scsipkt->pkt_reason = CMD_CMPLT;
7892 *scsipkt->pkt_scbp = STATUS_GOOD;
7893 } else {
7894 /* Something went wrong */
7895 scsipkt->pkt_reason = CMD_INCOMPLETE;
7896 *scsipkt->pkt_scbp = STATUS_CHECK;
7897 sense = sata_arq_sense(spx);
7898 switch (sata_pkt->satapkt_reason) {
7899 case SATA_PKT_PORT_ERROR:
7900 /*
7901 * We have no device data. Assume no data transfered.
7902 */
7903 sense->es_key = KEY_HARDWARE_ERROR;
7904 break;
7905
7906 case SATA_PKT_DEV_ERROR:
7907 if (sata_pkt->satapkt_cmd.satacmd_status_reg &
7908 SATA_STATUS_ERR) {
7909 /*
7910 * determine dev error reason from error
7911 * reg content
7912 */
7913 sata_decode_device_error(spx, sense);
7914 break;
7915 }
7916 /* No extended sense key - no info available */
7917 break;
7918
7919 case SATA_PKT_TIMEOUT:
7920 scsipkt->pkt_reason = CMD_TIMEOUT;
7921 scsipkt->pkt_statistics |=
7922 STAT_TIMEOUT | STAT_DEV_RESET;
7923 /* No extended sense key ? */
7924 break;
7925
7926 case SATA_PKT_ABORTED:
7927 scsipkt->pkt_reason = CMD_ABORTED;
7928 scsipkt->pkt_statistics |= STAT_ABORTED;
7929 /* No extended sense key ? */
7930 break;
7931
7932 case SATA_PKT_RESET:
7933 /* pkt aborted by an explicit reset from a host */
7934 scsipkt->pkt_reason = CMD_RESET;
7935 scsipkt->pkt_statistics |= STAT_DEV_RESET;
7936 break;
7937
7938 default:
7939 SATA_LOG_D((spx->txlt_sata_hba_inst, CE_WARN,
7940 "sata_txlt_nodata_cmd_completion: "
7941 "invalid packet completion reason %d",
7942 sata_pkt->satapkt_reason));
7943 scsipkt->pkt_reason = CMD_TRAN_ERR;
7944 break;
7945 }
7946
7947 }
7948 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst,
7949 "Scsi_pkt completion reason %x\n", scsipkt->pkt_reason);
7950 }
7951
7952
7953 /*
7954 * Build Mode sense R/W recovery page
7955 * NOT IMPLEMENTED
7956 */
7957
7958 static int
7959 sata_build_msense_page_1(sata_drive_info_t *sdinfo, int pcntrl, uint8_t *buf)
7960 {
7961 #ifndef __lock_lint
7962 _NOTE(ARGUNUSED(sdinfo))
7963 _NOTE(ARGUNUSED(pcntrl))
7964 _NOTE(ARGUNUSED(buf))
7965 #endif
7966 return (0);
7967 }
7968
7969 /*
7970 * Build Mode sense caching page - scsi-3 implementation.
7971 * Page length distinguishes previous format from scsi-3 format.
7972 * buf must have space for 0x12 bytes.
7973 * Only DRA (disable read ahead ) and WCE (write cache enable) are changeable.
7974 *
7975 */
7976 static int
7977 sata_build_msense_page_8(sata_drive_info_t *sdinfo, int pcntrl, uint8_t *buf)
7978 {
7979 struct mode_cache_scsi3 *page = (struct mode_cache_scsi3 *)buf;
7980 sata_id_t *sata_id = &sdinfo->satadrv_id;
7981
7982 /*
7983 * Most of the fields are set to 0, being not supported and/or disabled
7984 */
7985 bzero(buf, PAGELENGTH_DAD_MODE_CACHE_SCSI3);
7986
7987 /* Saved paramters not supported */
7988 if (pcntrl == 3)
7989 return (0);
7990 if (pcntrl == 0 || pcntrl == 2) {
7991 /*
7992 * For now treat current and default parameters as same
7993 * That may have to change, if target driver will complain
7994 */
7995 page->mode_page.code = MODEPAGE_CACHING; /* PS = 0 */
7996 page->mode_page.length = PAGELENGTH_DAD_MODE_CACHE_SCSI3;
7997
7998 if (SATA_READ_AHEAD_SUPPORTED(*sata_id) &&
7999 !SATA_READ_AHEAD_ENABLED(*sata_id)) {
8000 page->dra = 1; /* Read Ahead disabled */
8001 page->rcd = 1; /* Read Cache disabled */
8002 }
8003 if (SATA_WRITE_CACHE_SUPPORTED(*sata_id) &&
8004 SATA_WRITE_CACHE_ENABLED(*sata_id))
8005 page->wce = 1; /* Write Cache enabled */
8006 } else {
8007 /* Changeable parameters */
8008 page->mode_page.code = MODEPAGE_CACHING;
8009 page->mode_page.length = PAGELENGTH_DAD_MODE_CACHE_SCSI3;
8010 if (SATA_READ_AHEAD_SUPPORTED(*sata_id)) {
8011 page->dra = 1;
8012 page->rcd = 1;
8013 }
8014 if (SATA_WRITE_CACHE_SUPPORTED(*sata_id))
8015 page->wce = 1;
8016 }
8017 return (PAGELENGTH_DAD_MODE_CACHE_SCSI3 +
8018 sizeof (struct mode_page));
8019 }
8020
8021 /*
8022 * Build Mode sense exception cntrl page
8023 */
8024 static int
8025 sata_build_msense_page_1c(sata_drive_info_t *sdinfo, int pcntrl, uint8_t *buf)
8026 {
8027 struct mode_info_excpt_page *page = (struct mode_info_excpt_page *)buf;
8028 sata_id_t *sata_id = &sdinfo->satadrv_id;
8029
8030 /*
8031 * Most of the fields are set to 0, being not supported and/or disabled
8032 */
8033 bzero(buf, PAGELENGTH_INFO_EXCPT);
8034
8035 page->mode_page.code = MODEPAGE_INFO_EXCPT;
8036 page->mode_page.length = PAGELENGTH_INFO_EXCPT;
8037
8038 /* Indicate that this is page is saveable */
8039 page->mode_page.ps = 1;
8040
8041 /*
8042 * We will return the same data for default, current and saved page.
8043 * The only changeable bit is dexcpt and that bit is required
8044 * by the ATA specification to be preserved across power cycles.
8045 */
8046 if (pcntrl != 1) {
8047 page->dexcpt = !(sata_id->ai_features85 & SATA_SMART_SUPPORTED);
8048 page->mrie = MRIE_ONLY_ON_REQUEST;
8049 }
8050 else
8051 page->dexcpt = 1; /* Only changeable parameter */
8052
8053 return (PAGELENGTH_INFO_EXCPT + sizeof (struct mode_page));
8054 }
8055
8056
8057 static int
8058 sata_build_msense_page_30(sata_drive_info_t *sdinfo, int pcntrl, uint8_t *buf)
8059 {
8060 struct mode_acoustic_management *page =
8061 (struct mode_acoustic_management *)buf;
8062 sata_id_t *sata_id = &sdinfo->satadrv_id;
8063
8064 /*
8065 * Most of the fields are set to 0, being not supported and/or disabled
8066 */
8067 bzero(buf, PAGELENGTH_DAD_MODE_ACOUSTIC_MANAGEMENT);
8068
8069 switch (pcntrl) {
8070 case P_CNTRL_DEFAULT:
8071 /* default paramters not supported */
8072 return (0);
8073
8074 case P_CNTRL_CURRENT:
8075 case P_CNTRL_SAVED:
8076 /* Saved and current are supported and are identical */
8077 page->mode_page.code = MODEPAGE_ACOUSTIC_MANAG;
8078 page->mode_page.length =
8079 PAGELENGTH_DAD_MODE_ACOUSTIC_MANAGEMENT;
8080 page->mode_page.ps = 1;
8081
8082 /* Word 83 indicates if feature is supported */
8083 /* If feature is not supported */
8084 if (!(sata_id->ai_cmdset83 & SATA_ACOUSTIC_MGMT)) {
8085 page->acoustic_manag_enable =
8086 ACOUSTIC_DISABLED;
8087 } else {
8088 page->acoustic_manag_enable =
8089 ((sata_id->ai_features86 & SATA_ACOUSTIC_MGMT)
8090 != 0);
8091 /* Word 94 inidicates the value */
8092 #ifdef _LITTLE_ENDIAN
8093 page->acoustic_manag_level =
8094 (uchar_t)sata_id->ai_acoustic;
8095 page->vendor_recommended_value =
8096 sata_id->ai_acoustic >> 8;
8097 #else
8098 page->acoustic_manag_level =
8099 sata_id->ai_acoustic >> 8;
8100 page->vendor_recommended_value =
8101 (uchar_t)sata_id->ai_acoustic;
8102 #endif
8103 }
8104 break;
8105
8106 case P_CNTRL_CHANGEABLE:
8107 page->mode_page.code = MODEPAGE_ACOUSTIC_MANAG;
8108 page->mode_page.length =
8109 PAGELENGTH_DAD_MODE_ACOUSTIC_MANAGEMENT;
8110 page->mode_page.ps = 1;
8111
8112 /* Word 83 indicates if the feature is supported */
8113 if (sata_id->ai_cmdset83 & SATA_ACOUSTIC_MGMT) {
8114 page->acoustic_manag_enable =
8115 ACOUSTIC_ENABLED;
8116 page->acoustic_manag_level = 0xff;
8117 }
8118 break;
8119 }
8120 return (PAGELENGTH_DAD_MODE_ACOUSTIC_MANAGEMENT +
8121 sizeof (struct mode_page));
8122 }
8123
8124
8125 /*
8126 * Build Mode sense power condition page.
8127 */
8128 static int
8129 sata_build_msense_page_1a(sata_drive_info_t *sdinfo, int pcntrl, uint8_t *buf)
8130 {
8131 struct mode_info_power_cond *page = (struct mode_info_power_cond *)buf;
8132 sata_id_t *sata_id = &sdinfo->satadrv_id;
8133
8134 /*
8135 * Most of the fields are set to 0, being not supported and/or disabled
8136 * power condition page length was 0x0a
8137 */
8138 bzero(buf, sizeof (struct mode_info_power_cond));
8139
8140 if (pcntrl == P_CNTRL_DEFAULT) {
8141 /* default paramters not supported */
8142 return (0);
8143 }
8144
8145 page->mode_page.code = MODEPAGE_POWER_COND;
8146 page->mode_page.length = sizeof (struct mode_info_power_cond);
8147
8148 if (sata_id->ai_cap & SATA_STANDBYTIMER) {
8149 page->standby = 1;
8150 bcopy(sdinfo->satadrv_standby_timer, page->standby_cond_timer,
8151 sizeof (uchar_t) * 4);
8152 }
8153
8154 return (sizeof (struct mode_info_power_cond));
8155 }
8156
8157 /*
8158 * Process mode select caching page 8 (scsi3 format only).
8159 * Read Ahead (same as read cache) and Write Cache may be turned on and off
8160 * if these features are supported by the device. If these features are not
8161 * supported, the command will be terminated with STATUS_CHECK.
8162 * This function fails only if the SET FEATURE command sent to
8163 * the device fails. The page format is not verified, assuming that the
8164 * target driver operates correctly - if parameters length is too short,
8165 * we just drop the page.
8166 * Two command may be sent if both Read Cache/Read Ahead and Write Cache
8167 * setting have to be changed.
8168 * SET FEATURE command is executed synchronously, i.e. we wait here until
8169 * it is completed, regardless of the scsi pkt directives.
8170 *
8171 * Note: Mode Select Caching page RCD and DRA bits are tied together, i.e.
8172 * changing DRA will change RCD.
8173 *
8174 * More than one SATA command may be executed to perform operations specified
8175 * by mode select pages. The first error terminates further execution.
8176 * Operations performed successully are not backed-up in such case.
8177 *
8178 * Return SATA_SUCCESS if operation succeeded, SATA_FAILURE otherwise.
8179 * If operation resulted in changing device setup, dmod flag should be set to
8180 * one (1). If parameters were not changed, dmod flag should be set to 0.
8181 * Upon return, if operation required sending command to the device, the rval
8182 * should be set to the value returned by sata_hba_start. If operation
8183 * did not require device access, rval should be set to TRAN_ACCEPT.
8184 * The pagelen should be set to the length of the page.
8185 *
8186 * This function has to be called with a port mutex held.
8187 *
8188 * Returns SATA_SUCCESS if operation was successful, SATA_FAILURE otherwise.
8189 */
8190 int
8191 sata_mode_select_page_8(sata_pkt_txlate_t *spx, struct mode_cache_scsi3 *page,
8192 int parmlen, int *pagelen, int *rval, int *dmod)
8193 {
8194 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt;
8195 sata_drive_info_t *sdinfo;
8196 sata_cmd_t *scmd = &spx->txlt_sata_pkt->satapkt_cmd;
8197 sata_id_t *sata_id;
8198 struct scsi_extended_sense *sense;
8199 int wce, dra; /* Current settings */
8200
8201 sdinfo = sata_get_device_info(spx->txlt_sata_hba_inst,
8202 &spx->txlt_sata_pkt->satapkt_device);
8203 sata_id = &sdinfo->satadrv_id;
8204 *dmod = 0;
8205
8206 /* Verify parameters length. If too short, drop it */
8207 if ((PAGELENGTH_DAD_MODE_CACHE_SCSI3 +
8208 sizeof (struct mode_page)) > parmlen) {
8209 *scsipkt->pkt_scbp = STATUS_CHECK;
8210 sense = sata_arq_sense(spx);
8211 sense->es_key = KEY_ILLEGAL_REQUEST;
8212 sense->es_add_code = SD_SCSI_ASC_INVALID_FIELD_IN_PARAMS_LIST;
8213 *pagelen = parmlen;
8214 *rval = TRAN_ACCEPT;
8215 return (SATA_FAILURE);
8216 }
8217
8218 *pagelen = PAGELENGTH_DAD_MODE_CACHE_SCSI3 + sizeof (struct mode_page);
8219
8220 /* Current setting of Read Ahead (and Read Cache) */
8221 if (SATA_READ_AHEAD_ENABLED(*sata_id))
8222 dra = 0; /* 0 == not disabled */
8223 else
8224 dra = 1;
8225 /* Current setting of Write Cache */
8226 if (SATA_WRITE_CACHE_ENABLED(*sata_id))
8227 wce = 1;
8228 else
8229 wce = 0;
8230
8231 if (page->dra == dra && page->wce == wce && page->rcd == dra) {
8232 /* nothing to do */
8233 *rval = TRAN_ACCEPT;
8234 return (SATA_SUCCESS);
8235 }
8236
8237 /*
8238 * Need to flip some setting
8239 * Set-up Internal SET FEATURES command(s)
8240 */
8241 scmd->satacmd_flags.sata_data_direction = SATA_DIR_NODATA_XFER;
8242 scmd->satacmd_addr_type = 0;
8243 scmd->satacmd_device_reg = 0;
8244 scmd->satacmd_status_reg = 0;
8245 scmd->satacmd_error_reg = 0;
8246 scmd->satacmd_cmd_reg = SATAC_SET_FEATURES;
8247 if (page->dra != dra || page->rcd != dra) {
8248 if (SATA_READ_AHEAD_SUPPORTED(*sata_id)) {
8249 /* Need to flip read ahead setting */
8250 if (dra == 0)
8251 /* Disable read ahead / read cache */
8252 scmd->satacmd_features_reg =
8253 SATAC_SF_DISABLE_READ_AHEAD;
8254 else
8255 /* Enable read ahead / read cache */
8256 scmd->satacmd_features_reg =
8257 SATAC_SF_ENABLE_READ_AHEAD;
8258
8259 /* Transfer command to HBA */
8260 if (sata_hba_start(spx, rval) != 0)
8261 /*
8262 * Pkt not accepted for execution.
8263 */
8264 return (SATA_FAILURE);
8265
8266 *dmod = 1;
8267
8268 /* Now process return */
8269 if (spx->txlt_sata_pkt->satapkt_reason !=
8270 SATA_PKT_COMPLETED) {
8271 goto failure; /* Terminate */
8272 }
8273 } else {
8274 *scsipkt->pkt_scbp = STATUS_CHECK;
8275 sense = sata_arq_sense(spx);
8276 sense->es_key = KEY_ILLEGAL_REQUEST;
8277 sense->es_add_code =
8278 SD_SCSI_ASC_INVALID_FIELD_IN_PARAMS_LIST;
8279 *pagelen = parmlen;
8280 *rval = TRAN_ACCEPT;
8281 return (SATA_FAILURE);
8282 }
8283 }
8284
8285 /* Note that the packet is not removed, so it could be re-used */
8286 if (page->wce != wce) {
8287 if (SATA_WRITE_CACHE_SUPPORTED(*sata_id)) {
8288 /* Need to flip Write Cache setting */
8289 if (page->wce == 1)
8290 /* Enable write cache */
8291 scmd->satacmd_features_reg =
8292 SATAC_SF_ENABLE_WRITE_CACHE;
8293 else
8294 /* Disable write cache */
8295 scmd->satacmd_features_reg =
8296 SATAC_SF_DISABLE_WRITE_CACHE;
8297
8298 /* Transfer command to HBA */
8299 if (sata_hba_start(spx, rval) != 0)
8300 /*
8301 * Pkt not accepted for execution.
8302 */
8303 return (SATA_FAILURE);
8304
8305 *dmod = 1;
8306
8307 /* Now process return */
8308 if (spx->txlt_sata_pkt->satapkt_reason !=
8309 SATA_PKT_COMPLETED) {
8310 goto failure;
8311 }
8312 } else {
8313 *scsipkt->pkt_scbp = STATUS_CHECK;
8314 sense = sata_arq_sense(spx);
8315 sense->es_key = KEY_ILLEGAL_REQUEST;
8316 sense->es_add_code =
8317 SD_SCSI_ASC_INVALID_FIELD_IN_PARAMS_LIST;
8318 *pagelen = parmlen;
8319 *rval = TRAN_ACCEPT;
8320 return (SATA_FAILURE);
8321 }
8322 }
8323 return (SATA_SUCCESS);
8324
8325 failure:
8326 sata_xlate_errors(spx);
8327
8328 return (SATA_FAILURE);
8329 }
8330
8331 /*
8332 * Process mode select informational exceptions control page 0x1c
8333 *
8334 * The only changeable bit is dexcpt (disable exceptions).
8335 * MRIE (method of reporting informational exceptions) must be
8336 * "only on request".
8337 * This page applies to informational exceptions that report
8338 * additional sense codes with the ADDITIONAL SENSE CODE field set to 5Dh
8339 * (e.g.,FAILURE PREDICTION THRESHOLD EXCEEDED) or 0Bh (e.g., WARNING_).
8340 * Informational exception conditions occur as the result of background scan
8341 * errors, background self-test errors, or vendor specific events within a
8342 * logical unit. An informational exception condition may occur asynchronous
8343 * to any commands.
8344 *
8345 * Returns: SATA_SUCCESS if operation succeeded, SATA_FAILURE otherwise.
8346 * If operation resulted in changing device setup, dmod flag should be set to
8347 * one (1). If parameters were not changed, dmod flag should be set to 0.
8348 * Upon return, if operation required sending command to the device, the rval
8349 * should be set to the value returned by sata_hba_start. If operation
8350 * did not require device access, rval should be set to TRAN_ACCEPT.
8351 * The pagelen should be set to the length of the page.
8352 *
8353 * This function has to be called with a port mutex held.
8354 *
8355 * Returns SATA_SUCCESS if operation was successful, SATA_FAILURE otherwise.
8356 *
8357 * Cannot be called in the interrupt context.
8358 */
8359 static int
8360 sata_mode_select_page_1c(
8361 sata_pkt_txlate_t *spx,
8362 struct mode_info_excpt_page *page,
8363 int parmlen,
8364 int *pagelen,
8365 int *rval,
8366 int *dmod)
8367 {
8368 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt;
8369 sata_cmd_t *scmd = &spx->txlt_sata_pkt->satapkt_cmd;
8370 sata_drive_info_t *sdinfo;
8371 sata_id_t *sata_id;
8372 struct scsi_extended_sense *sense;
8373
8374 sdinfo = sata_get_device_info(spx->txlt_sata_hba_inst,
8375 &spx->txlt_sata_pkt->satapkt_device);
8376 sata_id = &sdinfo->satadrv_id;
8377
8378 *dmod = 0;
8379
8380 /* Verify parameters length. If too short, drop it */
8381 if (((PAGELENGTH_INFO_EXCPT + sizeof (struct mode_page)) > parmlen) ||
8382 page->perf || page->test || (page->mrie != MRIE_ONLY_ON_REQUEST)) {
8383 *scsipkt->pkt_scbp = STATUS_CHECK;
8384 sense = sata_arq_sense(spx);
8385 sense->es_key = KEY_ILLEGAL_REQUEST;
8386 sense->es_add_code = SD_SCSI_ASC_INVALID_FIELD_IN_PARAMS_LIST;
8387 *pagelen = parmlen;
8388 *rval = TRAN_ACCEPT;
8389 return (SATA_FAILURE);
8390 }
8391
8392 *pagelen = PAGELENGTH_INFO_EXCPT + sizeof (struct mode_page);
8393
8394 if (! (sata_id->ai_cmdset82 & SATA_SMART_SUPPORTED)) {
8395 *scsipkt->pkt_scbp = STATUS_CHECK;
8396 sense = sata_arq_sense(spx);
8397 sense->es_key = KEY_ILLEGAL_REQUEST;
8398 sense->es_add_code = SD_SCSI_ASC_INVALID_FIELD_IN_CDB;
8399 *pagelen = parmlen;
8400 *rval = TRAN_ACCEPT;
8401 return (SATA_FAILURE);
8402 }
8403
8404 /* If already in the state requested, we are done */
8405 if (page->dexcpt == ! (sata_id->ai_features85 & SATA_SMART_ENABLED)) {
8406 /* nothing to do */
8407 *rval = TRAN_ACCEPT;
8408 return (SATA_SUCCESS);
8409 }
8410
8411 scmd->satacmd_flags.sata_data_direction = SATA_DIR_NODATA_XFER;
8412
8413 /* Build SMART_ENABLE or SMART_DISABLE command */
8414 scmd->satacmd_addr_type = 0; /* N/A */
8415 scmd->satacmd_lba_mid_lsb = SMART_MAGIC_VAL_1;
8416 scmd->satacmd_lba_high_lsb = SMART_MAGIC_VAL_2;
8417 scmd->satacmd_features_reg = page->dexcpt ?
8418 SATA_SMART_DISABLE_OPS : SATA_SMART_ENABLE_OPS;
8419 scmd->satacmd_device_reg = 0; /* Always device 0 */
8420 scmd->satacmd_cmd_reg = SATAC_SMART;
8421
8422 /* Transfer command to HBA */
8423 if (sata_hba_start(spx, rval) != 0)
8424 /*
8425 * Pkt not accepted for execution.
8426 */
8427 return (SATA_FAILURE);
8428
8429 *dmod = 1; /* At least may have been modified */
8430
8431 /* Now process return */
8432 if (spx->txlt_sata_pkt->satapkt_reason == SATA_PKT_COMPLETED)
8433 return (SATA_SUCCESS);
8434
8435 /* Packet did not complete successfully */
8436 sata_xlate_errors(spx);
8437
8438 return (SATA_FAILURE);
8439 }
8440
8441 /*
8442 * Process mode select acoustic management control page 0x30
8443 *
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 int
8452 sata_mode_select_page_30(sata_pkt_txlate_t *spx, struct
8453 mode_acoustic_management *page, int parmlen, int *pagelen,
8454 int *rval, int *dmod)
8455 {
8456 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt;
8457 sata_drive_info_t *sdinfo;
8458 sata_cmd_t *scmd = &spx->txlt_sata_pkt->satapkt_cmd;
8459 sata_id_t *sata_id;
8460 struct scsi_extended_sense *sense;
8461
8462 sdinfo = sata_get_device_info(spx->txlt_sata_hba_inst,
8463 &spx->txlt_sata_pkt->satapkt_device);
8464 sata_id = &sdinfo->satadrv_id;
8465 *dmod = 0;
8466
8467 /* If parmlen is too short or the feature is not supported, drop it */
8468 if (((PAGELENGTH_DAD_MODE_ACOUSTIC_MANAGEMENT +
8469 sizeof (struct mode_page)) > parmlen) ||
8470 (! (sata_id->ai_cmdset83 & SATA_ACOUSTIC_MGMT))) {
8471 *scsipkt->pkt_scbp = STATUS_CHECK;
8472 sense = sata_arq_sense(spx);
8473 sense->es_key = KEY_ILLEGAL_REQUEST;
8474 sense->es_add_code = SD_SCSI_ASC_INVALID_FIELD_IN_PARAMS_LIST;
8475 *pagelen = parmlen;
8476 *rval = TRAN_ACCEPT;
8477 return (SATA_FAILURE);
8478 }
8479
8480 *pagelen = PAGELENGTH_DAD_MODE_ACOUSTIC_MANAGEMENT +
8481 sizeof (struct mode_page);
8482
8483 /*
8484 * We can enable and disable acoustice management and
8485 * set the acoustic management level.
8486 */
8487
8488 /*
8489 * Set-up Internal SET FEATURES command(s)
8490 */
8491 scmd->satacmd_flags.sata_data_direction = SATA_DIR_NODATA_XFER;
8492 scmd->satacmd_addr_type = 0;
8493 scmd->satacmd_device_reg = 0;
8494 scmd->satacmd_status_reg = 0;
8495 scmd->satacmd_error_reg = 0;
8496 scmd->satacmd_cmd_reg = SATAC_SET_FEATURES;
8497 if (page->acoustic_manag_enable) {
8498 scmd->satacmd_features_reg = SATAC_SF_ENABLE_ACOUSTIC;
8499 scmd->satacmd_sec_count_lsb = page->acoustic_manag_level;
8500 } else { /* disabling acoustic management */
8501 scmd->satacmd_features_reg = SATAC_SF_DISABLE_ACOUSTIC;
8502 }
8503
8504 /* Transfer command to HBA */
8505 if (sata_hba_start(spx, rval) != 0)
8506 /*
8507 * Pkt not accepted for execution.
8508 */
8509 return (SATA_FAILURE);
8510
8511 /* Now process return */
8512 if (spx->txlt_sata_pkt->satapkt_reason != SATA_PKT_COMPLETED) {
8513 sata_xlate_errors(spx);
8514 return (SATA_FAILURE);
8515 }
8516
8517 *dmod = 1;
8518
8519 return (SATA_SUCCESS);
8520 }
8521
8522 /*
8523 * Process mode select power condition page 0x1a
8524 *
8525 * This function has to be called with a port mutex held.
8526 *
8527 * Returns SATA_SUCCESS if operation was successful, SATA_FAILURE otherwise.
8528 *
8529 * Cannot be called in the interrupt context.
8530 */
8531 int
8532 sata_mode_select_page_1a(sata_pkt_txlate_t *spx, struct
8533 mode_info_power_cond *page, int parmlen, int *pagelen,
8534 int *rval, int *dmod)
8535 {
8536 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt;
8537 sata_drive_info_t *sdinfo;
8538 sata_cmd_t *scmd = &spx->txlt_sata_pkt->satapkt_cmd;
8539 sata_id_t *sata_id;
8540 struct scsi_extended_sense *sense;
8541 uint8_t ata_count;
8542 int i, len;
8543
8544 sdinfo = sata_get_device_info(spx->txlt_sata_hba_inst,
8545 &spx->txlt_sata_pkt->satapkt_device);
8546 sata_id = &sdinfo->satadrv_id;
8547 *dmod = 0;
8548
8549 len = sizeof (struct mode_info_power_cond);
8550 len += sizeof (struct mode_page);
8551
8552 /* If parmlen is too short or the feature is not supported, drop it */
8553 if ((len < parmlen) || (page->idle == 1) ||
8554 (!(sata_id->ai_cap & SATA_STANDBYTIMER) && page->standby == 1)) {
8555 *scsipkt->pkt_scbp = STATUS_CHECK;
8556 sense = sata_arq_sense(spx);
8557 sense->es_key = KEY_ILLEGAL_REQUEST;
8558 sense->es_add_code = SD_SCSI_ASC_INVALID_FIELD_IN_PARAMS_LIST;
8559 *pagelen = parmlen;
8560 *rval = TRAN_ACCEPT;
8561 return (SATA_FAILURE);
8562 }
8563
8564 *pagelen = len;
8565
8566 /*
8567 * Set-up Internal STANDBY command(s)
8568 */
8569 if (page->standby == 0)
8570 goto out;
8571
8572 ata_count = sata_get_standby_timer(page->standby_cond_timer);
8573
8574 scmd->satacmd_addr_type = 0;
8575 scmd->satacmd_sec_count_lsb = ata_count;
8576 scmd->satacmd_lba_low_lsb = 0;
8577 scmd->satacmd_lba_mid_lsb = 0;
8578 scmd->satacmd_lba_high_lsb = 0;
8579 scmd->satacmd_features_reg = 0;
8580 scmd->satacmd_device_reg = 0;
8581 scmd->satacmd_status_reg = 0;
8582 scmd->satacmd_cmd_reg = SATAC_STANDBY;
8583 scmd->satacmd_flags.sata_special_regs = B_TRUE;
8584 scmd->satacmd_flags.sata_copy_out_error_reg = B_TRUE;
8585
8586 /* Transfer command to HBA */
8587 if (sata_hba_start(spx, rval) != 0) {
8588 return (SATA_FAILURE);
8589 } else {
8590 if ((scmd->satacmd_error_reg != 0) ||
8591 (spx->txlt_sata_pkt->satapkt_reason !=
8592 SATA_PKT_COMPLETED)) {
8593 sata_xlate_errors(spx);
8594 return (SATA_FAILURE);
8595 }
8596 }
8597
8598 for (i = 0; i < 4; i++) {
8599 sdinfo->satadrv_standby_timer[i] = page->standby_cond_timer[i];
8600 }
8601 out:
8602 *dmod = 1;
8603 return (SATA_SUCCESS);
8604 }
8605
8606 /*
8607 * sata_build_lsense_page0() is used to create the
8608 * SCSI LOG SENSE page 0 (supported log pages)
8609 *
8610 * Currently supported pages are 0, 0x10, 0x2f, 0x30 and 0x0e
8611 * (supported log pages, self-test results, informational exceptions
8612 * Sun vendor specific ATA SMART data, and start stop cycle counter).
8613 *
8614 * Takes a sata_drive_info t * and the address of a buffer
8615 * in which to create the page information.
8616 *
8617 * Returns the number of bytes valid in the buffer.
8618 */
8619 static int
8620 sata_build_lsense_page_0(sata_drive_info_t *sdinfo, uint8_t *buf)
8621 {
8622 struct log_parameter *lpp = (struct log_parameter *)buf;
8623 uint8_t *page_ptr = (uint8_t *)lpp->param_values;
8624 int num_pages_supported = 1; /* Always have GET_SUPPORTED_LOG_PAGES */
8625 sata_id_t *sata_id = &sdinfo->satadrv_id;
8626
8627 lpp->param_code[0] = 0;
8628 lpp->param_code[1] = 0;
8629 lpp->param_ctrl_flags = LOG_CTRL_LP | LOG_CTRL_LBIN;
8630 *page_ptr++ = PAGE_CODE_GET_SUPPORTED_LOG_PAGES;
8631
8632 if (sata_id->ai_cmdset82 & SATA_SMART_SUPPORTED) {
8633 if (sata_id->ai_cmdset84 & SATA_SMART_SELF_TEST_SUPPORTED) {
8634 *page_ptr++ = PAGE_CODE_SELF_TEST_RESULTS;
8635 ++num_pages_supported;
8636 }
8637 *page_ptr++ = PAGE_CODE_INFORMATION_EXCEPTIONS;
8638 ++num_pages_supported;
8639 *page_ptr++ = PAGE_CODE_SMART_READ_DATA;
8640 ++num_pages_supported;
8641 *page_ptr++ = PAGE_CODE_START_STOP_CYCLE_COUNTER;
8642 ++num_pages_supported;
8643 }
8644
8645 lpp->param_len = num_pages_supported;
8646
8647 return ((&lpp->param_values[0] - (uint8_t *)lpp) +
8648 num_pages_supported);
8649 }
8650
8651 /*
8652 * sata_build_lsense_page_10() is used to create the
8653 * SCSI LOG SENSE page 0x10 (self-test results)
8654 *
8655 * Takes a sata_drive_info t * and the address of a buffer
8656 * in which to create the page information as well as a sata_hba_inst_t *.
8657 *
8658 * Returns the number of bytes valid in the buffer.
8659 *
8660 * Note: Self test and SMART data is accessible in device log pages.
8661 * The log pages can be accessed by SMART READ/WRITE LOG (up to 255 sectors
8662 * of data can be transferred by a single command), or by the General Purpose
8663 * Logging commands (GPL) READ LOG EXT and WRITE LOG EXT (up to 65,535 sectors
8664 * - approximately 33MB - can be transferred by a single command.
8665 * The SCT Command response (either error or command) is the same for both
8666 * the SMART and GPL methods of issuing commands.
8667 * This function uses READ LOG EXT command when drive supports LBA48, and
8668 * SMART READ command otherwise.
8669 *
8670 * Since above commands are executed in a synchronous mode, this function
8671 * should not be called in an interrupt context.
8672 */
8673 static int
8674 sata_build_lsense_page_10(
8675 sata_drive_info_t *sdinfo,
8676 uint8_t *buf,
8677 sata_hba_inst_t *sata_hba_inst)
8678 {
8679 struct log_parameter *lpp = (struct log_parameter *)buf;
8680 int rval;
8681
8682 if (sdinfo->satadrv_features_support & SATA_DEV_F_LBA48) {
8683 struct smart_ext_selftest_log *ext_selftest_log;
8684
8685 ext_selftest_log = kmem_zalloc(
8686 sizeof (struct smart_ext_selftest_log), KM_SLEEP);
8687
8688 rval = sata_ext_smart_selftest_read_log(sata_hba_inst, sdinfo,
8689 ext_selftest_log, 0);
8690 if (rval == 0) {
8691 int index, start_index;
8692 struct smart_ext_selftest_log_entry *entry;
8693 static const struct smart_ext_selftest_log_entry empty =
8694 {0};
8695 uint16_t block_num;
8696 int count;
8697 boolean_t only_one_block = B_FALSE;
8698
8699 index = ext_selftest_log->
8700 smart_ext_selftest_log_index[0];
8701 index |= ext_selftest_log->
8702 smart_ext_selftest_log_index[1] << 8;
8703 if (index == 0)
8704 goto out;
8705
8706 --index; /* Correct for 0 origin */
8707 start_index = index; /* remember where we started */
8708 block_num = index / ENTRIES_PER_EXT_SELFTEST_LOG_BLK;
8709 if (block_num != 0) {
8710 rval = sata_ext_smart_selftest_read_log(
8711 sata_hba_inst, sdinfo, ext_selftest_log,
8712 block_num);
8713 if (rval != 0)
8714 goto out;
8715 }
8716 index %= ENTRIES_PER_EXT_SELFTEST_LOG_BLK;
8717 entry =
8718 &ext_selftest_log->
8719 smart_ext_selftest_log_entries[index];
8720
8721 for (count = 1;
8722 count <= SCSI_ENTRIES_IN_LOG_SENSE_SELFTEST_RESULTS;
8723 ++count) {
8724 uint8_t status;
8725 uint8_t code;
8726 uint8_t sense_key;
8727 uint8_t add_sense_code;
8728 uint8_t add_sense_code_qual;
8729
8730 /* If this is an unused entry, we are done */
8731 if (bcmp(entry, &empty, sizeof (empty)) == 0) {
8732 /* Broken firmware on some disks */
8733 if (index + 1 ==
8734 ENTRIES_PER_EXT_SELFTEST_LOG_BLK) {
8735 --entry;
8736 --index;
8737 if (bcmp(entry, &empty,
8738 sizeof (empty)) == 0)
8739 goto out;
8740 } else
8741 goto out;
8742 }
8743
8744 if (only_one_block &&
8745 start_index == index)
8746 goto out;
8747
8748 lpp->param_code[0] = 0;
8749 lpp->param_code[1] = count;
8750 lpp->param_ctrl_flags =
8751 LOG_CTRL_LP | LOG_CTRL_LBIN;
8752 lpp->param_len =
8753 SCSI_LOG_SENSE_SELFTEST_PARAM_LEN;
8754
8755 status = entry->smart_ext_selftest_log_status;
8756 status >>= 4;
8757 switch (status) {
8758 case 0:
8759 default:
8760 sense_key = KEY_NO_SENSE;
8761 add_sense_code =
8762 SD_SCSI_ASC_NO_ADD_SENSE;
8763 add_sense_code_qual = 0;
8764 break;
8765 case 1:
8766 sense_key = KEY_ABORTED_COMMAND;
8767 add_sense_code =
8768 DIAGNOSTIC_FAILURE_ON_COMPONENT;
8769 add_sense_code_qual = SCSI_COMPONENT_81;
8770 break;
8771 case 2:
8772 sense_key = KEY_ABORTED_COMMAND;
8773 add_sense_code =
8774 DIAGNOSTIC_FAILURE_ON_COMPONENT;
8775 add_sense_code_qual = SCSI_COMPONENT_82;
8776 break;
8777 case 3:
8778 sense_key = KEY_ABORTED_COMMAND;
8779 add_sense_code =
8780 DIAGNOSTIC_FAILURE_ON_COMPONENT;
8781 add_sense_code_qual = SCSI_COMPONENT_83;
8782 break;
8783 case 4:
8784 sense_key = KEY_HARDWARE_ERROR;
8785 add_sense_code =
8786 DIAGNOSTIC_FAILURE_ON_COMPONENT;
8787 add_sense_code_qual = SCSI_COMPONENT_84;
8788 break;
8789 case 5:
8790 sense_key = KEY_HARDWARE_ERROR;
8791 add_sense_code =
8792 DIAGNOSTIC_FAILURE_ON_COMPONENT;
8793 add_sense_code_qual = SCSI_COMPONENT_85;
8794 break;
8795 case 6:
8796 sense_key = KEY_HARDWARE_ERROR;
8797 add_sense_code =
8798 DIAGNOSTIC_FAILURE_ON_COMPONENT;
8799 add_sense_code_qual = SCSI_COMPONENT_86;
8800 break;
8801 case 7:
8802 sense_key = KEY_MEDIUM_ERROR;
8803 add_sense_code =
8804 DIAGNOSTIC_FAILURE_ON_COMPONENT;
8805 add_sense_code_qual = SCSI_COMPONENT_87;
8806 break;
8807 case 8:
8808 sense_key = KEY_HARDWARE_ERROR;
8809 add_sense_code =
8810 DIAGNOSTIC_FAILURE_ON_COMPONENT;
8811 add_sense_code_qual = SCSI_COMPONENT_88;
8812 break;
8813 }
8814 code = 0; /* unspecified */
8815 status |= (code << 4);
8816 lpp->param_values[0] = status;
8817 lpp->param_values[1] = 0; /* unspecified */
8818 lpp->param_values[2] = entry->
8819 smart_ext_selftest_log_timestamp[1];
8820 lpp->param_values[3] = entry->
8821 smart_ext_selftest_log_timestamp[0];
8822 if (status != 0) {
8823 lpp->param_values[4] = 0;
8824 lpp->param_values[5] = 0;
8825 lpp->param_values[6] = entry->
8826 smart_ext_selftest_log_failing_lba
8827 [5];
8828 lpp->param_values[7] = entry->
8829 smart_ext_selftest_log_failing_lba
8830 [4];
8831 lpp->param_values[8] = entry->
8832 smart_ext_selftest_log_failing_lba
8833 [3];
8834 lpp->param_values[9] = entry->
8835 smart_ext_selftest_log_failing_lba
8836 [2];
8837 lpp->param_values[10] = entry->
8838 smart_ext_selftest_log_failing_lba
8839 [1];
8840 lpp->param_values[11] = entry->
8841 smart_ext_selftest_log_failing_lba
8842 [0];
8843 } else { /* No bad block address */
8844 lpp->param_values[4] = 0xff;
8845 lpp->param_values[5] = 0xff;
8846 lpp->param_values[6] = 0xff;
8847 lpp->param_values[7] = 0xff;
8848 lpp->param_values[8] = 0xff;
8849 lpp->param_values[9] = 0xff;
8850 lpp->param_values[10] = 0xff;
8851 lpp->param_values[11] = 0xff;
8852 }
8853
8854 lpp->param_values[12] = sense_key;
8855 lpp->param_values[13] = add_sense_code;
8856 lpp->param_values[14] = add_sense_code_qual;
8857 lpp->param_values[15] = 0; /* undefined */
8858
8859 lpp = (struct log_parameter *)
8860 (((uint8_t *)lpp) +
8861 SCSI_LOG_PARAM_HDR_LEN +
8862 SCSI_LOG_SENSE_SELFTEST_PARAM_LEN);
8863
8864 --index; /* Back up to previous entry */
8865 if (index < 0) {
8866 if (block_num > 0) {
8867 --block_num;
8868 } else {
8869 struct read_log_ext_directory
8870 logdir;
8871
8872 rval =
8873 sata_read_log_ext_directory(
8874 sata_hba_inst, sdinfo,
8875 &logdir);
8876 if (rval == -1)
8877 goto out;
8878 if ((logdir.read_log_ext_vers
8879 [0] == 0) &&
8880 (logdir.read_log_ext_vers
8881 [1] == 0))
8882 goto out;
8883 block_num =
8884 logdir.read_log_ext_nblks
8885 [EXT_SMART_SELFTEST_LOG_PAGE
8886 - 1][0];
8887 block_num |= logdir.
8888 read_log_ext_nblks
8889 [EXT_SMART_SELFTEST_LOG_PAGE
8890 - 1][1] << 8;
8891 --block_num;
8892 only_one_block =
8893 (block_num == 0);
8894 }
8895 rval = sata_ext_smart_selftest_read_log(
8896 sata_hba_inst, sdinfo,
8897 ext_selftest_log, block_num);
8898 if (rval != 0)
8899 goto out;
8900
8901 index =
8902 ENTRIES_PER_EXT_SELFTEST_LOG_BLK -
8903 1;
8904 }
8905 index %= ENTRIES_PER_EXT_SELFTEST_LOG_BLK;
8906 entry = &ext_selftest_log->
8907 smart_ext_selftest_log_entries[index];
8908 }
8909 }
8910 out:
8911 kmem_free(ext_selftest_log,
8912 sizeof (struct smart_ext_selftest_log));
8913 } else {
8914 struct smart_selftest_log *selftest_log;
8915
8916 selftest_log = kmem_zalloc(sizeof (struct smart_selftest_log),
8917 KM_SLEEP);
8918
8919 rval = sata_smart_selftest_log(sata_hba_inst, sdinfo,
8920 selftest_log);
8921
8922 if (rval == 0) {
8923 int index;
8924 int count;
8925 struct smart_selftest_log_entry *entry;
8926 static const struct smart_selftest_log_entry empty =
8927 { 0 };
8928
8929 index = selftest_log->smart_selftest_log_index;
8930 if (index == 0)
8931 goto done;
8932 --index; /* Correct for 0 origin */
8933 entry = &selftest_log->
8934 smart_selftest_log_entries[index];
8935 for (count = 1;
8936 count <= SCSI_ENTRIES_IN_LOG_SENSE_SELFTEST_RESULTS;
8937 ++count) {
8938 uint8_t status;
8939 uint8_t code;
8940 uint8_t sense_key;
8941 uint8_t add_sense_code;
8942 uint8_t add_sense_code_qual;
8943
8944 if (bcmp(entry, &empty, sizeof (empty)) == 0)
8945 goto done;
8946
8947 lpp->param_code[0] = 0;
8948 lpp->param_code[1] = count;
8949 lpp->param_ctrl_flags =
8950 LOG_CTRL_LP | LOG_CTRL_LBIN;
8951 lpp->param_len =
8952 SCSI_LOG_SENSE_SELFTEST_PARAM_LEN;
8953
8954 status = entry->smart_selftest_log_status;
8955 status >>= 4;
8956 switch (status) {
8957 case 0:
8958 default:
8959 sense_key = KEY_NO_SENSE;
8960 add_sense_code =
8961 SD_SCSI_ASC_NO_ADD_SENSE;
8962 break;
8963 case 1:
8964 sense_key = KEY_ABORTED_COMMAND;
8965 add_sense_code =
8966 DIAGNOSTIC_FAILURE_ON_COMPONENT;
8967 add_sense_code_qual = SCSI_COMPONENT_81;
8968 break;
8969 case 2:
8970 sense_key = KEY_ABORTED_COMMAND;
8971 add_sense_code =
8972 DIAGNOSTIC_FAILURE_ON_COMPONENT;
8973 add_sense_code_qual = SCSI_COMPONENT_82;
8974 break;
8975 case 3:
8976 sense_key = KEY_ABORTED_COMMAND;
8977 add_sense_code =
8978 DIAGNOSTIC_FAILURE_ON_COMPONENT;
8979 add_sense_code_qual = SCSI_COMPONENT_83;
8980 break;
8981 case 4:
8982 sense_key = KEY_HARDWARE_ERROR;
8983 add_sense_code =
8984 DIAGNOSTIC_FAILURE_ON_COMPONENT;
8985 add_sense_code_qual = SCSI_COMPONENT_84;
8986 break;
8987 case 5:
8988 sense_key = KEY_HARDWARE_ERROR;
8989 add_sense_code =
8990 DIAGNOSTIC_FAILURE_ON_COMPONENT;
8991 add_sense_code_qual = SCSI_COMPONENT_85;
8992 break;
8993 case 6:
8994 sense_key = KEY_HARDWARE_ERROR;
8995 add_sense_code =
8996 DIAGNOSTIC_FAILURE_ON_COMPONENT;
8997 add_sense_code_qual = SCSI_COMPONENT_86;
8998 break;
8999 case 7:
9000 sense_key = KEY_MEDIUM_ERROR;
9001 add_sense_code =
9002 DIAGNOSTIC_FAILURE_ON_COMPONENT;
9003 add_sense_code_qual = SCSI_COMPONENT_87;
9004 break;
9005 case 8:
9006 sense_key = KEY_HARDWARE_ERROR;
9007 add_sense_code =
9008 DIAGNOSTIC_FAILURE_ON_COMPONENT;
9009 add_sense_code_qual = SCSI_COMPONENT_88;
9010 break;
9011 }
9012 code = 0; /* unspecified */
9013 status |= (code << 4);
9014 lpp->param_values[0] = status;
9015 lpp->param_values[1] = 0; /* unspecified */
9016 lpp->param_values[2] = entry->
9017 smart_selftest_log_timestamp[1];
9018 lpp->param_values[3] = entry->
9019 smart_selftest_log_timestamp[0];
9020 if (status != 0) {
9021 lpp->param_values[4] = 0;
9022 lpp->param_values[5] = 0;
9023 lpp->param_values[6] = 0;
9024 lpp->param_values[7] = 0;
9025 lpp->param_values[8] = entry->
9026 smart_selftest_log_failing_lba[3];
9027 lpp->param_values[9] = entry->
9028 smart_selftest_log_failing_lba[2];
9029 lpp->param_values[10] = entry->
9030 smart_selftest_log_failing_lba[1];
9031 lpp->param_values[11] = entry->
9032 smart_selftest_log_failing_lba[0];
9033 } else { /* No block address */
9034 lpp->param_values[4] = 0xff;
9035 lpp->param_values[5] = 0xff;
9036 lpp->param_values[6] = 0xff;
9037 lpp->param_values[7] = 0xff;
9038 lpp->param_values[8] = 0xff;
9039 lpp->param_values[9] = 0xff;
9040 lpp->param_values[10] = 0xff;
9041 lpp->param_values[11] = 0xff;
9042 }
9043 lpp->param_values[12] = sense_key;
9044 lpp->param_values[13] = add_sense_code;
9045 lpp->param_values[14] = add_sense_code_qual;
9046 lpp->param_values[15] = 0; /* undefined */
9047
9048 lpp = (struct log_parameter *)
9049 (((uint8_t *)lpp) +
9050 SCSI_LOG_PARAM_HDR_LEN +
9051 SCSI_LOG_SENSE_SELFTEST_PARAM_LEN);
9052 --index; /* back up to previous entry */
9053 if (index < 0) {
9054 index =
9055 NUM_SMART_SELFTEST_LOG_ENTRIES - 1;
9056 }
9057 entry = &selftest_log->
9058 smart_selftest_log_entries[index];
9059 }
9060 }
9061 done:
9062 kmem_free(selftest_log, sizeof (struct smart_selftest_log));
9063 }
9064
9065 return ((SCSI_LOG_PARAM_HDR_LEN + SCSI_LOG_SENSE_SELFTEST_PARAM_LEN) *
9066 SCSI_ENTRIES_IN_LOG_SENSE_SELFTEST_RESULTS);
9067 }
9068
9069 /*
9070 * sata_build_lsense_page_2f() is used to create the
9071 * SCSI LOG SENSE page 0x2f (informational exceptions)
9072 *
9073 * Takes a sata_drive_info t * and the address of a buffer
9074 * in which to create the page information as well as a sata_hba_inst_t *.
9075 *
9076 * Returns the number of bytes valid in the buffer.
9077 *
9078 * Because it invokes function(s) that send synchronously executed command
9079 * to the HBA, it cannot be called in the interrupt context.
9080 */
9081 static int
9082 sata_build_lsense_page_2f(
9083 sata_drive_info_t *sdinfo,
9084 uint8_t *buf,
9085 sata_hba_inst_t *sata_hba_inst)
9086 {
9087 struct log_parameter *lpp = (struct log_parameter *)buf;
9088 int rval;
9089 uint8_t *smart_data;
9090 uint8_t temp;
9091 sata_id_t *sata_id;
9092 #define SMART_NO_TEMP 0xff
9093
9094 lpp->param_code[0] = 0;
9095 lpp->param_code[1] = 0;
9096 lpp->param_ctrl_flags = LOG_CTRL_LP | LOG_CTRL_LBIN;
9097
9098 /* Now get the SMART status w.r.t. threshold exceeded */
9099 rval = sata_fetch_smart_return_status(sata_hba_inst, sdinfo);
9100 switch (rval) {
9101 case 1:
9102 lpp->param_values[0] = SCSI_PREDICTED_FAILURE;
9103 lpp->param_values[1] = SCSI_GENERAL_HD_FAILURE;
9104 break;
9105 case 0:
9106 case -1: /* failed to get data */
9107 lpp->param_values[0] = 0; /* No failure predicted */
9108 lpp->param_values[1] = 0;
9109 break;
9110 #if defined(SATA_DEBUG)
9111 default:
9112 cmn_err(CE_PANIC, "sata_build_lsense_page_2f bad return value");
9113 /* NOTREACHED */
9114 #endif
9115 }
9116
9117 sata_id = &sdinfo->satadrv_id;
9118 if (! (sata_id->ai_sctsupport & SATA_SCT_CMD_TRANS_SUP))
9119 temp = SMART_NO_TEMP;
9120 else {
9121 /* Now get the temperature */
9122 smart_data = kmem_zalloc(512, KM_SLEEP);
9123 rval = sata_smart_read_log(sata_hba_inst, sdinfo, smart_data,
9124 SCT_STATUS_LOG_PAGE, 1);
9125 if (rval == -1)
9126 temp = SMART_NO_TEMP;
9127 else {
9128 temp = smart_data[200];
9129 if (temp & 0x80) {
9130 if (temp & 0x7f)
9131 temp = 0;
9132 else
9133 temp = SMART_NO_TEMP;
9134 }
9135 }
9136 kmem_free(smart_data, 512);
9137 }
9138
9139 lpp->param_values[2] = temp; /* most recent temperature */
9140 lpp->param_values[3] = 0; /* required vendor specific byte */
9141
9142 lpp->param_len = SCSI_INFO_EXCEPTIONS_PARAM_LEN;
9143
9144
9145 return (SCSI_INFO_EXCEPTIONS_PARAM_LEN + SCSI_LOG_PARAM_HDR_LEN);
9146 }
9147
9148 /*
9149 * sata_build_lsense_page_30() is used to create the
9150 * SCSI LOG SENSE page 0x30 (Sun's vendor specific page for ATA SMART data).
9151 *
9152 * Takes a sata_drive_info t * and the address of a buffer
9153 * in which to create the page information as well as a sata_hba_inst_t *.
9154 *
9155 * Returns the number of bytes valid in the buffer.
9156 */
9157 static int
9158 sata_build_lsense_page_30(
9159 sata_drive_info_t *sdinfo,
9160 uint8_t *buf,
9161 sata_hba_inst_t *sata_hba_inst)
9162 {
9163 struct smart_data *smart_data = (struct smart_data *)buf;
9164 int rval;
9165
9166 /* Now do the SMART READ DATA */
9167 rval = sata_fetch_smart_data(sata_hba_inst, sdinfo, smart_data);
9168 if (rval == -1)
9169 return (0);
9170
9171 return (sizeof (struct smart_data));
9172 }
9173
9174 /*
9175 * sata_build_lsense_page_0e() is used to create the
9176 * SCSI LOG SENSE page 0e (start-stop cycle counter page)
9177 *
9178 * Date of Manufacture (0x0001)
9179 * YEAR = "0000"
9180 * WEEK = "00"
9181 * Accounting Date (0x0002)
9182 * 6 ASCII space character(20h)
9183 * Specified cycle count over device lifetime
9184 * VALUE - THRESH - the delta between max and min;
9185 * Accumulated start-stop cycles
9186 * VALUE - WORST - the accumulated cycles;
9187 *
9188 * ID FLAG THRESH VALUE WORST RAW on start/stop counter attribute
9189 *
9190 * Takes a sata_drive_info t * and the address of a buffer
9191 * in which to create the page information as well as a sata_hba_inst_t *.
9192 *
9193 * Returns the number of bytes valid in the buffer.
9194 */
9195 static int
9196 sata_build_lsense_page_0e(sata_drive_info_t *sdinfo, uint8_t *buf,
9197 sata_pkt_txlate_t *spx)
9198 {
9199 struct start_stop_cycle_counter_log *log_page;
9200 int i, rval, index;
9201 uint8_t smart_data[512], id, value, worst, thresh;
9202 uint32_t max_count, cycles;
9203
9204 /* Now do the SMART READ DATA */
9205 rval = sata_fetch_smart_data(spx->txlt_sata_hba_inst, sdinfo,
9206 (struct smart_data *)smart_data);
9207 if (rval == -1)
9208 return (0);
9209 for (i = 0, id = 0; i < SMART_START_STOP_COUNT_ID * 2; i++) {
9210 index = (i * 12) + 2;
9211 id = smart_data[index];
9212 if (id != SMART_START_STOP_COUNT_ID)
9213 continue;
9214 else {
9215 thresh = smart_data[index + 2];
9216 value = smart_data[index + 3];
9217 worst = smart_data[index + 4];
9218 break;
9219 }
9220 }
9221 if (id != SMART_START_STOP_COUNT_ID)
9222 return (0);
9223 max_count = value - thresh;
9224 cycles = value - worst;
9225
9226 log_page = (struct start_stop_cycle_counter_log *)buf;
9227 bzero(log_page, sizeof (struct start_stop_cycle_counter_log));
9228 log_page->code = 0x0e;
9229 log_page->page_len_low = 0x24;
9230
9231 log_page->manufactor_date_low = 0x1;
9232 log_page->param_1.fmt_link = 0x1; /* 01b */
9233 log_page->param_len_1 = 0x06;
9234 for (i = 0; i < 4; i++) {
9235 log_page->year_manu[i] = 0x30;
9236 if (i < 2)
9237 log_page->week_manu[i] = 0x30;
9238 }
9239
9240 log_page->account_date_low = 0x02;
9241 log_page->param_2.fmt_link = 0x01; /* 01b */
9242 log_page->param_len_2 = 0x06;
9243 for (i = 0; i < 4; i++) {
9244 log_page->year_account[i] = 0x20;
9245 if (i < 2)
9246 log_page->week_account[i] = 0x20;
9247 }
9248
9249 log_page->lifetime_code_low = 0x03;
9250 log_page->param_3.fmt_link = 0x03; /* 11b */
9251 log_page->param_len_3 = 0x04;
9252 /* VALUE - THRESH - the delta between max and min */
9253 log_page->cycle_code_low = 0x04;
9254 log_page->param_4.fmt_link = 0x03; /* 11b */
9255 log_page->param_len_4 = 0x04;
9256 /* WORST - THRESH - the distance from 'now' to min */
9257
9258 for (i = 0; i < 4; i++) {
9259 log_page->cycle_lifetime[i] =
9260 (max_count >> (8 * (3 - i))) & 0xff;
9261 log_page->cycle_accumulated[i] =
9262 (cycles >> (8 * (3 - i))) & 0xff;
9263 }
9264
9265 return (sizeof (struct start_stop_cycle_counter_log));
9266 }
9267
9268 /*
9269 * This function was used for build a ATA read verify sector command
9270 */
9271 static void
9272 sata_build_read_verify_cmd(sata_cmd_t *scmd, uint16_t sec, uint64_t lba)
9273 {
9274 scmd->satacmd_cmd_reg = SATAC_RDVER;
9275 scmd->satacmd_addr_type = ATA_ADDR_LBA28;
9276 scmd->satacmd_flags.sata_special_regs = B_TRUE;
9277
9278 scmd->satacmd_sec_count_lsb = sec & 0xff;
9279 scmd->satacmd_lba_low_lsb = lba & 0xff;
9280 scmd->satacmd_lba_mid_lsb = (lba >> 8) & 0xff;
9281 scmd->satacmd_lba_high_lsb = (lba >> 16) & 0xff;
9282 scmd->satacmd_device_reg = (SATA_ADH_LBA | (lba >> 24) & 0xf);
9283 scmd->satacmd_features_reg = 0;
9284 scmd->satacmd_status_reg = 0;
9285 scmd->satacmd_error_reg = 0;
9286 }
9287
9288 /*
9289 * This function was used for building an ATA
9290 * command, and only command register need to
9291 * be defined, other register will be zero or na.
9292 */
9293 static void
9294 sata_build_generic_cmd(sata_cmd_t *scmd, uint8_t cmd)
9295 {
9296 scmd->satacmd_addr_type = 0;
9297 scmd->satacmd_cmd_reg = cmd;
9298 scmd->satacmd_device_reg = 0;
9299 scmd->satacmd_sec_count_lsb = 0;
9300 scmd->satacmd_lba_low_lsb = 0;
9301 scmd->satacmd_lba_mid_lsb = 0;
9302 scmd->satacmd_lba_high_lsb = 0;
9303 scmd->satacmd_features_reg = 0;
9304 scmd->satacmd_status_reg = 0;
9305 scmd->satacmd_error_reg = 0;
9306 scmd->satacmd_flags.sata_special_regs = B_TRUE;
9307 }
9308
9309 /*
9310 * This function was used for changing the standby
9311 * timer format from SCSI to ATA.
9312 */
9313 static uint8_t
9314 sata_get_standby_timer(uint8_t *timer)
9315 {
9316 uint32_t i = 0, count = 0;
9317 uint8_t ata_count;
9318
9319 for (i = 0; i < 4; i++) {
9320 count = count << 8 | timer[i];
9321 }
9322
9323 if (count == 0)
9324 return (0);
9325
9326 if (count >= 1 && count <= 12000)
9327 ata_count = (count -1) / 50 + 1;
9328 else if (count > 12000 && count <= 12600)
9329 ata_count = 0xfc;
9330 else if (count > 12601 && count <= 12750)
9331 ata_count = 0xff;
9332 else if (count > 12750 && count <= 17999)
9333 ata_count = 0xf1;
9334 else if (count > 18000 && count <= 198000)
9335 ata_count = count / 18000 + 240;
9336 else
9337 ata_count = 0xfd;
9338 return (ata_count);
9339 }
9340
9341 /* ************************** ATAPI-SPECIFIC FUNCTIONS ********************** */
9342
9343 /*
9344 * Start command for ATAPI device.
9345 * This function processes scsi_pkt requests.
9346 * Now CD/DVD, tape and ATAPI disk devices are supported.
9347 * Most commands are packet without any translation into Packet Command.
9348 * Some may be trapped and executed as SATA commands (not clear which one).
9349 *
9350 * Returns TRAN_ACCEPT if command is accepted for execution (or completed
9351 * execution).
9352 * Returns other TRAN_XXXX codes if command is not accepted or completed
9353 * (see return values for sata_hba_start()).
9354 *
9355 * Note:
9356 * Inquiry cdb format differs between transport version 2 and 3.
9357 * However, the transport version 3 devices that were checked did not adhere
9358 * to the specification (ignored MSB of the allocation length). Therefore,
9359 * the transport version is not checked, but Inquiry allocation length is
9360 * truncated to 255 bytes if the original allocation length set-up by the
9361 * target driver is greater than 255 bytes.
9362 */
9363 static int
9364 sata_txlt_atapi(sata_pkt_txlate_t *spx)
9365 {
9366 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt;
9367 sata_cmd_t *scmd = &spx->txlt_sata_pkt->satapkt_cmd;
9368 struct buf *bp = spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp;
9369 sata_hba_inst_t *sata_hba = SATA_TXLT_HBA_INST(spx);
9370 sata_drive_info_t *sdinfo = sata_get_device_info(sata_hba,
9371 &spx->txlt_sata_pkt->satapkt_device);
9372 kmutex_t *cport_mutex = &(SATA_TXLT_CPORT_MUTEX(spx));
9373 int cdblen;
9374 int rval, reason;
9375 int synch;
9376 union scsi_cdb *cdbp = (union scsi_cdb *)scsipkt->pkt_cdbp;
9377
9378 mutex_enter(cport_mutex);
9379
9380 if (((rval = sata_txlt_generic_pkt_info(spx, &reason, 0)) !=
9381 TRAN_ACCEPT) || (reason == CMD_DEV_GONE)) {
9382 mutex_exit(cport_mutex);
9383 return (rval);
9384 }
9385
9386 /*
9387 * ATAPI device executes some ATA commands in addition to those
9388 * commands sent via PACKET command. These ATA commands may be
9389 * executed by the regular SATA translation functions. None needs
9390 * to be captured now.
9391 *
9392 * Commands sent via PACKET command include:
9393 * MMC command set for ATAPI CD/DVD device
9394 * SSC command set for ATAPI TAPE device
9395 * SBC command set for ATAPI disk device
9396 *
9397 */
9398
9399 /* Check the size of cdb */
9400
9401 switch (GETGROUP(cdbp)) {
9402 case CDB_GROUPID_3: /* Reserved, per SPC-4 */
9403 /*
9404 * opcodes 0x7e and 0x7f identify variable-length CDBs and
9405 * therefore require special handling. Return failure, for now.
9406 */
9407 mutex_exit(cport_mutex);
9408 return (TRAN_BADPKT);
9409
9410 case CDB_GROUPID_6: /* Vendor-specific, per SPC-4 */
9411 case CDB_GROUPID_7: /* Vendor-specific, per SPC-4 */
9412 /* obtain length from the scsi_pkt */
9413 cdblen = scsipkt->pkt_cdblen;
9414 break;
9415
9416 default:
9417 /* CDB's length is statically known, per SPC-4 */
9418 cdblen = scsi_cdb_size[GETGROUP(cdbp)];
9419 break;
9420 }
9421
9422 if (cdblen <= 0 || cdblen > sdinfo->satadrv_atapi_cdb_len) {
9423 sata_log(NULL, CE_WARN,
9424 "sata: invalid ATAPI cdb length %d",
9425 cdblen);
9426 mutex_exit(cport_mutex);
9427 return (TRAN_BADPKT);
9428 }
9429
9430 SATAATAPITRACE(spx, cdblen);
9431
9432 /*
9433 * For non-read/write commands we need to
9434 * map buffer
9435 */
9436 switch ((uint_t)scsipkt->pkt_cdbp[0]) {
9437 case SCMD_READ:
9438 case SCMD_READ_G1:
9439 case SCMD_READ_G5:
9440 case SCMD_READ_G4:
9441 case SCMD_WRITE:
9442 case SCMD_WRITE_G1:
9443 case SCMD_WRITE_G5:
9444 case SCMD_WRITE_G4:
9445 break;
9446 default:
9447 if (bp != NULL) {
9448 if (bp->b_flags & (B_PHYS | B_PAGEIO))
9449 bp_mapin(bp);
9450 }
9451 break;
9452 }
9453 /*
9454 * scmd->satacmd_flags.sata_data_direction default -
9455 * SATA_DIR_NODATA_XFER - is set by
9456 * sata_txlt_generic_pkt_info().
9457 */
9458 if (scmd->satacmd_bp) {
9459 if (scmd->satacmd_bp->b_flags & B_READ) {
9460 scmd->satacmd_flags.sata_data_direction = SATA_DIR_READ;
9461 } else {
9462 scmd->satacmd_flags.sata_data_direction =
9463 SATA_DIR_WRITE;
9464 }
9465 }
9466
9467 /*
9468 * Set up ATAPI packet command.
9469 */
9470
9471 sata_atapi_packet_cmd_setup(scmd, sdinfo);
9472
9473 /* Copy cdb into sata_cmd */
9474 scmd->satacmd_acdb_len = sdinfo->satadrv_atapi_cdb_len;
9475 bzero(scmd->satacmd_acdb, SATA_ATAPI_MAX_CDB_LEN);
9476 bcopy(cdbp, scmd->satacmd_acdb, cdblen);
9477
9478 /* See note in the command header */
9479 if (scmd->satacmd_acdb[0] == SCMD_INQUIRY) {
9480 if (scmd->satacmd_acdb[3] != 0)
9481 scmd->satacmd_acdb[4] = 255;
9482 }
9483
9484 #ifdef SATA_DEBUG
9485 if (sata_debug_flags & SATA_DBG_ATAPI) {
9486 uint8_t *p = scmd->satacmd_acdb;
9487 char buf[3 * SATA_ATAPI_MAX_CDB_LEN];
9488
9489 (void) snprintf(buf, SATA_ATAPI_MAX_CDB_LEN,
9490 "%02x %02x %02x %02x %02x %02x %02x %02x "
9491 "%2x %02x %02x %02x %02x %02x %02x %02x",
9492 p[0], p[1], p[2], p[3], p[4], p[5], p[6], p[7],
9493 p[8], p[9], p[10], p[11], p[12], p[13], p[14], p[15]);
9494 buf[(3 * SATA_ATAPI_MAX_CDB_LEN) - 1] = '\0';
9495 cmn_err(CE_NOTE, "ATAPI cdb: %s\n", buf);
9496 }
9497 #endif
9498
9499 /*
9500 * Preset request sense data to NO SENSE.
9501 * If there is no way to get error information via Request Sense,
9502 * the packet request sense data would not have to be modified by HBA,
9503 * but it could be returned as is.
9504 */
9505 bzero(scmd->satacmd_rqsense, SATA_ATAPI_RQSENSE_LEN);
9506 sata_fixed_sense_data_preset(
9507 (struct scsi_extended_sense *)scmd->satacmd_rqsense);
9508
9509 if (!(spx->txlt_sata_pkt->satapkt_op_mode & SATA_OPMODE_SYNCH)) {
9510 /* Need callback function */
9511 spx->txlt_sata_pkt->satapkt_comp = sata_txlt_atapi_completion;
9512 synch = FALSE;
9513 } else
9514 synch = TRUE;
9515
9516 /* Transfer command to HBA */
9517 if (sata_hba_start(spx, &rval) != 0) {
9518 /* Pkt not accepted for execution */
9519 mutex_exit(cport_mutex);
9520 return (rval);
9521 }
9522 mutex_exit(cport_mutex);
9523 /*
9524 * If execution is non-synchronous,
9525 * a callback function will handle potential errors, translate
9526 * the response and will do a callback to a target driver.
9527 * If it was synchronous, use the same framework callback to check
9528 * an execution status.
9529 */
9530 if (synch) {
9531 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst,
9532 "synchronous execution status %x\n",
9533 spx->txlt_sata_pkt->satapkt_reason);
9534 sata_txlt_atapi_completion(spx->txlt_sata_pkt);
9535 }
9536 return (TRAN_ACCEPT);
9537 }
9538
9539
9540 /*
9541 * ATAPI Packet command completion.
9542 *
9543 * Failure of the command passed via Packet command are considered device
9544 * error. SATA HBA driver would have to retrieve error data (via Request
9545 * Sense command delivered via error retrieval sata packet) and copy it
9546 * to satacmd_rqsense array. From there, it is moved into scsi pkt sense data.
9547 */
9548 static void
9549 sata_txlt_atapi_completion(sata_pkt_t *sata_pkt)
9550 {
9551 sata_pkt_txlate_t *spx =
9552 (sata_pkt_txlate_t *)sata_pkt->satapkt_framework_private;
9553 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt;
9554 struct scsi_extended_sense *sense;
9555 struct buf *bp;
9556 int rval;
9557
9558 #ifdef SATA_DEBUG
9559 uint8_t *rqsp = sata_pkt->satapkt_cmd.satacmd_rqsense;
9560 #endif
9561
9562 scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET |
9563 STATE_SENT_CMD | STATE_GOT_STATUS;
9564
9565 if (sata_pkt->satapkt_reason == SATA_PKT_COMPLETED) {
9566 /* Normal completion */
9567 if (sata_pkt->satapkt_cmd.satacmd_bp != NULL)
9568 scsipkt->pkt_state |= STATE_XFERRED_DATA;
9569 scsipkt->pkt_reason = CMD_CMPLT;
9570 *scsipkt->pkt_scbp = STATUS_GOOD;
9571 if (spx->txlt_tmp_buf != NULL) {
9572 /* Temporary buffer was used */
9573 bp = spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp;
9574 if (bp->b_flags & B_READ) {
9575 rval = ddi_dma_sync(
9576 spx->txlt_buf_dma_handle, 0, 0,
9577 DDI_DMA_SYNC_FORCPU);
9578 ASSERT(rval == DDI_SUCCESS);
9579 bcopy(spx->txlt_tmp_buf, bp->b_un.b_addr,
9580 bp->b_bcount);
9581 }
9582 }
9583 } else {
9584 /*
9585 * Something went wrong - analyze return
9586 */
9587 *scsipkt->pkt_scbp = STATUS_CHECK;
9588 sense = sata_arq_sense(spx);
9589
9590 if (sata_pkt->satapkt_reason == SATA_PKT_DEV_ERROR) {
9591 /*
9592 * pkt_reason should be CMD_CMPLT for DEVICE ERROR.
9593 * Under this condition ERR bit is set for ATA command,
9594 * and CHK bit set for ATAPI command.
9595 *
9596 * Please check st_intr & sdintr about how pkt_reason
9597 * is used.
9598 */
9599 scsipkt->pkt_reason = CMD_CMPLT;
9600
9601 /*
9602 * We may not have ARQ data if there was a double
9603 * error. But sense data in sata packet was pre-set
9604 * with NO SENSE so it is valid even if HBA could
9605 * not retrieve a real sense data.
9606 * Just copy this sense data into scsi pkt sense area.
9607 */
9608 bcopy(sata_pkt->satapkt_cmd.satacmd_rqsense, sense,
9609 SATA_ATAPI_MIN_RQSENSE_LEN);
9610 #ifdef SATA_DEBUG
9611 if (sata_debug_flags & SATA_DBG_SCSI_IF) {
9612 sata_log(spx->txlt_sata_hba_inst, CE_WARN,
9613 "sata_txlt_atapi_completion: %02x\n"
9614 "RQSENSE: %02x %02x %02x %02x %02x %02x "
9615 " %02x %02x %02x %02x %02x %02x "
9616 " %02x %02x %02x %02x %02x %02x\n",
9617 scsipkt->pkt_reason,
9618 rqsp[0], rqsp[1], rqsp[2], rqsp[3],
9619 rqsp[4], rqsp[5], rqsp[6], rqsp[7],
9620 rqsp[8], rqsp[9], rqsp[10], rqsp[11],
9621 rqsp[12], rqsp[13], rqsp[14], rqsp[15],
9622 rqsp[16], rqsp[17]);
9623 }
9624 #endif
9625 } else {
9626 switch (sata_pkt->satapkt_reason) {
9627 case SATA_PKT_PORT_ERROR:
9628 /*
9629 * We have no device data.
9630 */
9631 scsipkt->pkt_reason = CMD_INCOMPLETE;
9632 scsipkt->pkt_state &= ~(STATE_GOT_BUS |
9633 STATE_GOT_TARGET | STATE_SENT_CMD |
9634 STATE_GOT_STATUS);
9635 sense->es_key = KEY_HARDWARE_ERROR;
9636 break;
9637
9638 case SATA_PKT_TIMEOUT:
9639 scsipkt->pkt_reason = CMD_TIMEOUT;
9640 scsipkt->pkt_statistics |=
9641 STAT_TIMEOUT | STAT_DEV_RESET;
9642 /*
9643 * Need to check if HARDWARE_ERROR/
9644 * TIMEOUT_ON_LOGICAL_UNIT 4/3E/2 would be more
9645 * appropriate.
9646 */
9647 break;
9648
9649 case SATA_PKT_ABORTED:
9650 scsipkt->pkt_reason = CMD_ABORTED;
9651 scsipkt->pkt_statistics |= STAT_ABORTED;
9652 /* Should we set key COMMAND_ABPRTED? */
9653 break;
9654
9655 case SATA_PKT_RESET:
9656 scsipkt->pkt_reason = CMD_RESET;
9657 scsipkt->pkt_statistics |= STAT_DEV_RESET;
9658 /*
9659 * May be we should set Unit Attention /
9660 * Reset. Perhaps the same should be
9661 * returned for disks....
9662 */
9663 sense->es_key = KEY_UNIT_ATTENTION;
9664 sense->es_add_code = SD_SCSI_ASC_RESET;
9665 break;
9666
9667 default:
9668 SATA_LOG_D((spx->txlt_sata_hba_inst, CE_WARN,
9669 "sata_txlt_atapi_completion: "
9670 "invalid packet completion reason"));
9671 scsipkt->pkt_reason = CMD_TRAN_ERR;
9672 scsipkt->pkt_state &= ~(STATE_GOT_BUS |
9673 STATE_GOT_TARGET | STATE_SENT_CMD |
9674 STATE_GOT_STATUS);
9675 break;
9676 }
9677 }
9678 }
9679
9680 SATAATAPITRACE(spx, 0);
9681
9682 if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0 &&
9683 scsipkt->pkt_comp != NULL) {
9684 /* scsi callback required */
9685 (*scsipkt->pkt_comp)(scsipkt);
9686 }
9687 }
9688
9689 /*
9690 * Set up error retrieval sata command for ATAPI Packet Command error data
9691 * recovery.
9692 *
9693 * Returns SATA_SUCCESS when data buffer is allocated and packet set-up,
9694 * returns SATA_FAILURE otherwise.
9695 */
9696
9697 static int
9698 sata_atapi_err_ret_cmd_setup(sata_pkt_txlate_t *spx, sata_drive_info_t *sdinfo)
9699 {
9700 sata_pkt_t *spkt = spx->txlt_sata_pkt;
9701 sata_cmd_t *scmd;
9702 struct buf *bp;
9703
9704 /*
9705 * Allocate dma-able buffer error data.
9706 * Buffer allocation will take care of buffer alignment and other DMA
9707 * attributes.
9708 */
9709 bp = sata_alloc_local_buffer(spx, SATA_ATAPI_MIN_RQSENSE_LEN);
9710 if (bp == NULL) {
9711 SATADBG1(SATA_DBG_ATAPI, spx->txlt_sata_hba_inst,
9712 "sata_get_err_retrieval_pkt: "
9713 "cannot allocate buffer for error data", NULL);
9714 return (SATA_FAILURE);
9715 }
9716 bp_mapin(bp); /* make data buffer accessible */
9717
9718 /* Operation modes are up to the caller */
9719 spkt->satapkt_op_mode = SATA_OPMODE_SYNCH | SATA_OPMODE_INTERRUPTS;
9720
9721 /* Synchronous mode, no callback - may be changed by the caller */
9722 spkt->satapkt_comp = NULL;
9723 spkt->satapkt_time = sata_default_pkt_time;
9724
9725 scmd = &spkt->satapkt_cmd;
9726 scmd->satacmd_flags.sata_data_direction = SATA_DIR_READ;
9727 scmd->satacmd_flags.sata_ignore_dev_reset = B_TRUE;
9728
9729 sata_atapi_packet_cmd_setup(scmd, sdinfo);
9730
9731 /*
9732 * Set-up acdb. Request Sense CDB (packet command content) is
9733 * not in DMA-able buffer. Its handling is HBA-specific (how
9734 * it is transfered into packet FIS).
9735 */
9736 scmd->satacmd_acdb_len = sdinfo->satadrv_atapi_cdb_len;
9737 bcopy(sata_rqsense_cdb, scmd->satacmd_acdb, SATA_ATAPI_RQSENSE_CDB_LEN);
9738 /* Following zeroing of pad bytes may not be necessary */
9739 bzero(&scmd->satacmd_acdb[SATA_ATAPI_RQSENSE_CDB_LEN],
9740 sdinfo->satadrv_atapi_cdb_len - SATA_ATAPI_RQSENSE_CDB_LEN);
9741
9742 /*
9743 * Set-up pointer to the buffer handle, so HBA can sync buffer
9744 * before accessing it. Handle is in usual place in translate struct.
9745 */
9746 scmd->satacmd_err_ret_buf_handle = &spx->txlt_buf_dma_handle;
9747
9748 /*
9749 * Preset request sense data to NO SENSE.
9750 * Here it is redundant, only for a symetry with scsi-originated
9751 * packets. It should not be used for anything but debugging.
9752 */
9753 bzero(scmd->satacmd_rqsense, SATA_ATAPI_RQSENSE_LEN);
9754 sata_fixed_sense_data_preset(
9755 (struct scsi_extended_sense *)scmd->satacmd_rqsense);
9756
9757 ASSERT(scmd->satacmd_num_dma_cookies != 0);
9758 ASSERT(scmd->satacmd_dma_cookie_list != NULL);
9759
9760 return (SATA_SUCCESS);
9761 }
9762
9763 /*
9764 * Set-up ATAPI packet command.
9765 * Data transfer direction has to be set-up in sata_cmd structure prior to
9766 * calling this function.
9767 *
9768 * Returns void
9769 */
9770
9771 static void
9772 sata_atapi_packet_cmd_setup(sata_cmd_t *scmd, sata_drive_info_t *sdinfo)
9773 {
9774 scmd->satacmd_addr_type = 0; /* N/A */
9775 scmd->satacmd_sec_count_lsb = 0; /* no tag */
9776 scmd->satacmd_lba_low_lsb = 0; /* N/A */
9777 scmd->satacmd_lba_mid_lsb = (uint8_t)SATA_ATAPI_MAX_BYTES_PER_DRQ;
9778 scmd->satacmd_lba_high_lsb =
9779 (uint8_t)(SATA_ATAPI_MAX_BYTES_PER_DRQ >> 8);
9780 scmd->satacmd_cmd_reg = SATAC_PACKET; /* Command */
9781
9782 /*
9783 * We want all data to be transfered via DMA.
9784 * But specify it only if drive supports DMA and DMA mode is
9785 * selected - some drives are sensitive about it.
9786 * Hopefully it wil work for all drives....
9787 */
9788 if (sdinfo->satadrv_settings & SATA_DEV_DMA)
9789 scmd->satacmd_features_reg = SATA_ATAPI_F_DMA;
9790
9791 /*
9792 * Features register requires special care for devices that use
9793 * Serial ATA bridge - they need an explicit specification of
9794 * the data transfer direction for Packet DMA commands.
9795 * Setting this bit is harmless if DMA is not used.
9796 *
9797 * Many drives do not implement word 80, specifying what ATA/ATAPI
9798 * spec they follow.
9799 * We are arbitrarily following the latest SerialATA 2.6 spec,
9800 * which uses ATA/ATAPI 6 specification for Identify Data, unless
9801 * ATA/ATAPI-7 support is explicitly indicated.
9802 */
9803 if (sdinfo->satadrv_id.ai_majorversion != 0 &&
9804 sdinfo->satadrv_id.ai_majorversion != 0xffff &&
9805 (sdinfo->satadrv_id.ai_majorversion & SATA_MAJVER_7) != 0) {
9806 /*
9807 * Specification of major version is valid and version 7
9808 * is supported. It does automatically imply that all
9809 * spec features are supported. For now, we assume that
9810 * DMADIR setting is valid. ATA/ATAPI7 spec is incomplete.
9811 */
9812 if ((sdinfo->satadrv_id.ai_dirdma &
9813 SATA_ATAPI_ID_DMADIR_REQ) != 0) {
9814 if (scmd->satacmd_flags.sata_data_direction ==
9815 SATA_DIR_READ)
9816 scmd->satacmd_features_reg |=
9817 SATA_ATAPI_F_DATA_DIR_READ;
9818 }
9819 }
9820 }
9821
9822
9823 #ifdef SATA_DEBUG
9824
9825 /* Display 18 bytes of Inquiry data */
9826 static void
9827 sata_show_inqry_data(uint8_t *buf)
9828 {
9829 struct scsi_inquiry *inq = (struct scsi_inquiry *)buf;
9830 uint8_t *p;
9831
9832 cmn_err(CE_NOTE, "Inquiry data:");
9833 cmn_err(CE_NOTE, "device type %x", inq->inq_dtype);
9834 cmn_err(CE_NOTE, "removable media %x", inq->inq_rmb);
9835 cmn_err(CE_NOTE, "version %x", inq->inq_ansi);
9836 cmn_err(CE_NOTE, "ATAPI transport version %d",
9837 SATA_ATAPI_TRANS_VERSION(inq));
9838 cmn_err(CE_NOTE, "response data format %d, aenc %d",
9839 inq->inq_rdf, inq->inq_aenc);
9840 cmn_err(CE_NOTE, " additional length %d", inq->inq_len);
9841 cmn_err(CE_NOTE, "tpgs %d", inq->inq_tpgs);
9842 p = (uint8_t *)inq->inq_vid;
9843 cmn_err(CE_NOTE, "vendor id (binary): %02x %02x %02x %02x "
9844 "%02x %02x %02x %02x",
9845 p[0], p[1], p[2], p[3], p[4], p[5], p[6], p[7]);
9846 p = (uint8_t *)inq->inq_vid;
9847 cmn_err(CE_NOTE, "vendor id: %c %c %c %c %c %c %c %c",
9848 p[0], p[1], p[2], p[3], p[4], p[5], p[6], p[7]);
9849
9850 p = (uint8_t *)inq->inq_pid;
9851 cmn_err(CE_NOTE, "product id (binary): %02x %02x %02x %02x "
9852 "%02x %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x",
9853 p[0], p[1], p[2], p[3], p[4], p[5], p[6], p[7],
9854 p[8], p[9], p[10], p[11], p[12], p[13], p[14], p[15]);
9855 p = (uint8_t *)inq->inq_pid;
9856 cmn_err(CE_NOTE, "product id: %c %c %c %c %c %c %c %c "
9857 "%c %c %c %c %c %c %c %c",
9858 p[0], p[1], p[2], p[3], p[4], p[5], p[6], p[7],
9859 p[8], p[9], p[10], p[11], p[12], p[13], p[14], p[15]);
9860
9861 p = (uint8_t *)inq->inq_revision;
9862 cmn_err(CE_NOTE, "revision (binary): %02x %02x %02x %02x",
9863 p[0], p[1], p[2], p[3]);
9864 p = (uint8_t *)inq->inq_revision;
9865 cmn_err(CE_NOTE, "revision: %c %c %c %c",
9866 p[0], p[1], p[2], p[3]);
9867
9868 }
9869
9870
9871 static void
9872 sata_save_atapi_trace(sata_pkt_txlate_t *spx, int count)
9873 {
9874 struct scsi_pkt *scsi_pkt = spx->txlt_scsi_pkt;
9875
9876 if (scsi_pkt == NULL)
9877 return;
9878 if (count != 0) {
9879 /* saving cdb */
9880 bzero(sata_atapi_trace[sata_atapi_trace_index].acdb,
9881 SATA_ATAPI_MAX_CDB_LEN);
9882 bcopy(scsi_pkt->pkt_cdbp,
9883 sata_atapi_trace[sata_atapi_trace_index].acdb, count);
9884 } else {
9885 bcopy(&((struct scsi_arq_status *)scsi_pkt->pkt_scbp)->
9886 sts_sensedata,
9887 sata_atapi_trace[sata_atapi_trace_index].arqs,
9888 SATA_ATAPI_MIN_RQSENSE_LEN);
9889 sata_atapi_trace[sata_atapi_trace_index].scsi_pkt_reason =
9890 scsi_pkt->pkt_reason;
9891 sata_atapi_trace[sata_atapi_trace_index].sata_pkt_reason =
9892 spx->txlt_sata_pkt->satapkt_reason;
9893
9894 if (++sata_atapi_trace_index >= 64)
9895 sata_atapi_trace_index = 0;
9896 }
9897 }
9898
9899 #endif
9900
9901 /*
9902 * Fetch inquiry data from ATAPI device
9903 * Returns SATA_SUCCESS if operation was successful, SATA_FAILURE otherwise.
9904 *
9905 * Note:
9906 * inqb pointer does not point to a DMA-able buffer. It is a local buffer
9907 * where the caller expects to see the inquiry data.
9908 *
9909 */
9910
9911 static int
9912 sata_get_atapi_inquiry_data(sata_hba_inst_t *sata_hba,
9913 sata_address_t *saddr, struct scsi_inquiry *inq)
9914 {
9915 sata_pkt_txlate_t *spx;
9916 sata_pkt_t *spkt;
9917 struct buf *bp;
9918 sata_drive_info_t *sdinfo;
9919 sata_cmd_t *scmd;
9920 int rval;
9921 uint8_t *rqsp;
9922 dev_info_t *dip = SATA_DIP(sata_hba);
9923 #ifdef SATA_DEBUG
9924 char msg_buf[MAXPATHLEN];
9925 #endif
9926 kmutex_t *cport_mutex;
9927
9928 ASSERT(sata_hba != NULL);
9929
9930 spx = kmem_zalloc(sizeof (sata_pkt_txlate_t), KM_SLEEP);
9931 spx->txlt_sata_hba_inst = sata_hba;
9932 spx->txlt_scsi_pkt = NULL; /* No scsi pkt involved */
9933 spkt = sata_pkt_alloc(spx, NULL);
9934 if (spkt == NULL) {
9935 kmem_free(spx, sizeof (sata_pkt_txlate_t));
9936 return (SATA_FAILURE);
9937 }
9938 /* address is needed now */
9939 spkt->satapkt_device.satadev_addr = *saddr;
9940
9941 /* scsi_inquiry size buffer */
9942 bp = sata_alloc_local_buffer(spx, sizeof (struct scsi_inquiry));
9943 if (bp == NULL) {
9944 sata_pkt_free(spx);
9945 kmem_free(spx, sizeof (sata_pkt_txlate_t));
9946 SATA_LOG_D((sata_hba, CE_WARN,
9947 "sata_get_atapi_inquiry_data: "
9948 "cannot allocate data buffer"));
9949 return (SATA_FAILURE);
9950 }
9951 bp_mapin(bp); /* make data buffer accessible */
9952
9953 scmd = &spkt->satapkt_cmd;
9954 ASSERT(scmd->satacmd_num_dma_cookies != 0);
9955 ASSERT(scmd->satacmd_dma_cookie_list != NULL);
9956
9957 /* Use synchronous mode */
9958 spkt->satapkt_op_mode = SATA_OPMODE_SYNCH | SATA_OPMODE_INTERRUPTS;
9959 spkt->satapkt_comp = NULL;
9960 spkt->satapkt_time = sata_default_pkt_time;
9961
9962 /* Issue inquiry command - 6 bytes cdb, data transfer, read */
9963
9964 scmd->satacmd_flags.sata_data_direction = SATA_DIR_READ;
9965 scmd->satacmd_flags.sata_ignore_dev_reset = B_TRUE;
9966
9967 cport_mutex = &(SATA_CPORT_MUTEX(sata_hba, saddr->cport));
9968 mutex_enter(cport_mutex);
9969 sdinfo = sata_get_device_info(sata_hba,
9970 &spx->txlt_sata_pkt->satapkt_device);
9971 if (sdinfo == NULL) {
9972 /* we have to be carefull about the disapearing device */
9973 mutex_exit(cport_mutex);
9974 rval = SATA_FAILURE;
9975 goto cleanup;
9976 }
9977 sata_atapi_packet_cmd_setup(scmd, sdinfo);
9978
9979 /*
9980 * Set-up acdb. This works for atapi transport version 2 and later.
9981 */
9982 scmd->satacmd_acdb_len = sdinfo->satadrv_atapi_cdb_len;
9983 bzero(scmd->satacmd_acdb, SATA_ATAPI_MAX_CDB_LEN);
9984 scmd->satacmd_acdb[0] = 0x12; /* Inquiry */
9985 scmd->satacmd_acdb[1] = 0x00;
9986 scmd->satacmd_acdb[2] = 0x00;
9987 scmd->satacmd_acdb[3] = 0x00;
9988 scmd->satacmd_acdb[4] = sizeof (struct scsi_inquiry);
9989 scmd->satacmd_acdb[5] = 0x00;
9990
9991 sata_fixed_sense_data_preset(
9992 (struct scsi_extended_sense *)scmd->satacmd_rqsense);
9993
9994 /* Transfer command to HBA */
9995 if (sata_hba_start(spx, &rval) != 0) {
9996 /* Pkt not accepted for execution */
9997 SATADBG1(SATA_DBG_ATAPI, sata_hba,
9998 "sata_get_atapi_inquiry_data: "
9999 "Packet not accepted for execution - ret: %02x", rval);
10000 mutex_exit(cport_mutex);
10001 rval = SATA_FAILURE;
10002 goto cleanup;
10003 }
10004 mutex_exit(cport_mutex);
10005
10006 if (spkt->satapkt_reason == SATA_PKT_COMPLETED) {
10007 SATADBG1(SATA_DBG_ATAPI, sata_hba,
10008 "sata_get_atapi_inquiry_data: "
10009 "Packet completed successfully - ret: %02x", rval);
10010 if (spx->txlt_buf_dma_handle != NULL) {
10011 /*
10012 * Sync buffer. Handle is in usual place in translate
10013 * struct.
10014 */
10015 rval = ddi_dma_sync(spx->txlt_buf_dma_handle, 0, 0,
10016 DDI_DMA_SYNC_FORCPU);
10017 ASSERT(rval == DDI_SUCCESS);
10018 }
10019
10020 if (sata_check_for_dma_error(dip, spx)) {
10021 ddi_fm_service_impact(dip, DDI_SERVICE_UNAFFECTED);
10022 rval = SATA_FAILURE;
10023 } else {
10024 /*
10025 * Normal completion - copy data into caller's buffer
10026 */
10027 bcopy(bp->b_un.b_addr, (uint8_t *)inq,
10028 sizeof (struct scsi_inquiry));
10029 #ifdef SATA_DEBUG
10030 if (sata_debug_flags & SATA_DBG_ATAPI) {
10031 sata_show_inqry_data((uint8_t *)inq);
10032 }
10033 #endif
10034 rval = SATA_SUCCESS;
10035 }
10036 } else {
10037 /*
10038 * Something went wrong - analyze return - check rqsense data
10039 */
10040 rval = SATA_FAILURE;
10041 if (spkt->satapkt_reason == SATA_PKT_DEV_ERROR) {
10042 /*
10043 * ARQ data hopefull show something other than NO SENSE
10044 */
10045 rqsp = scmd->satacmd_rqsense;
10046 #ifdef SATA_DEBUG
10047 if (sata_debug_flags & SATA_DBG_ATAPI) {
10048 msg_buf[0] = '\0';
10049 (void) snprintf(msg_buf, MAXPATHLEN,
10050 "ATAPI packet completion reason: %02x\n"
10051 "RQSENSE: %02x %02x %02x %02x %02x %02x\n"
10052 " %02x %02x %02x %02x %02x %02x\n"
10053 " %02x %02x %02x %02x %02x %02x",
10054 spkt->satapkt_reason,
10055 rqsp[0], rqsp[1], rqsp[2], rqsp[3],
10056 rqsp[4], rqsp[5], rqsp[6], rqsp[7],
10057 rqsp[8], rqsp[9], rqsp[10], rqsp[11],
10058 rqsp[12], rqsp[13], rqsp[14], rqsp[15],
10059 rqsp[16], rqsp[17]);
10060 sata_log(spx->txlt_sata_hba_inst, CE_WARN,
10061 "%s", msg_buf);
10062 }
10063 #endif
10064 } else {
10065 switch (spkt->satapkt_reason) {
10066 case SATA_PKT_PORT_ERROR:
10067 SATADBG1(SATA_DBG_ATAPI, sata_hba,
10068 "sata_get_atapi_inquiry_data: "
10069 "packet reason: port error", NULL);
10070 break;
10071
10072 case SATA_PKT_TIMEOUT:
10073 SATADBG1(SATA_DBG_ATAPI, sata_hba,
10074 "sata_get_atapi_inquiry_data: "
10075 "packet reason: timeout", NULL);
10076 break;
10077
10078 case SATA_PKT_ABORTED:
10079 SATADBG1(SATA_DBG_ATAPI, sata_hba,
10080 "sata_get_atapi_inquiry_data: "
10081 "packet reason: aborted", NULL);
10082 break;
10083
10084 case SATA_PKT_RESET:
10085 SATADBG1(SATA_DBG_ATAPI, sata_hba,
10086 "sata_get_atapi_inquiry_data: "
10087 "packet reason: reset\n", NULL);
10088 break;
10089 default:
10090 SATADBG1(SATA_DBG_ATAPI, sata_hba,
10091 "sata_get_atapi_inquiry_data: "
10092 "invalid packet reason: %02x\n",
10093 spkt->satapkt_reason);
10094 break;
10095 }
10096 }
10097 }
10098 cleanup:
10099 sata_free_local_buffer(spx);
10100 sata_pkt_free(spx);
10101 kmem_free(spx, sizeof (sata_pkt_txlate_t));
10102 return (rval);
10103 }
10104
10105
10106
10107
10108
10109 #if 0
10110 #ifdef SATA_DEBUG
10111
10112 /*
10113 * Test ATAPI packet command.
10114 * Single threaded test: send packet command in synch mode, process completion
10115 *
10116 */
10117 static void
10118 sata_test_atapi_packet_command(sata_hba_inst_t *sata_hba_inst, int cport)
10119 {
10120 sata_pkt_txlate_t *spx;
10121 sata_pkt_t *spkt;
10122 struct buf *bp;
10123 sata_device_t sata_device;
10124 sata_drive_info_t *sdinfo;
10125 sata_cmd_t *scmd;
10126 int rval;
10127 uint8_t *rqsp;
10128
10129 ASSERT(sata_hba_inst != NULL);
10130 sata_device.satadev_addr.cport = cport;
10131 sata_device.satadev_addr.pmport = 0;
10132 sata_device.satadev_addr.qual = SATA_ADDR_DCPORT;
10133 sata_device.satadev_rev = SATA_DEVICE_REV;
10134 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex);
10135 sdinfo = sata_get_device_info(sata_hba_inst, &sata_device);
10136 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex);
10137 if (sdinfo == NULL) {
10138 sata_log(sata_hba_inst, CE_WARN,
10139 "sata_test_atapi_packet_command: "
10140 "no device info for cport %d",
10141 sata_device.satadev_addr.cport);
10142 return;
10143 }
10144
10145 spx = kmem_zalloc(sizeof (sata_pkt_txlate_t), KM_SLEEP);
10146 spx->txlt_sata_hba_inst = sata_hba_inst;
10147 spx->txlt_scsi_pkt = NULL; /* No scsi pkt involved */
10148 spkt = sata_pkt_alloc(spx, NULL);
10149 if (spkt == NULL) {
10150 kmem_free(spx, sizeof (sata_pkt_txlate_t));
10151 return;
10152 }
10153 /* address is needed now */
10154 spkt->satapkt_device.satadev_addr = sata_device.satadev_addr;
10155
10156 /* 1024k buffer */
10157 bp = sata_alloc_local_buffer(spx, 1024);
10158 if (bp == NULL) {
10159 sata_pkt_free(spx);
10160 kmem_free(spx, sizeof (sata_pkt_txlate_t));
10161 sata_log(sata_hba_inst, CE_WARN,
10162 "sata_test_atapi_packet_command: "
10163 "cannot allocate data buffer");
10164 return;
10165 }
10166 bp_mapin(bp); /* make data buffer accessible */
10167
10168 scmd = &spkt->satapkt_cmd;
10169 ASSERT(scmd->satacmd_num_dma_cookies != 0);
10170 ASSERT(scmd->satacmd_dma_cookie_list != NULL);
10171
10172 /* Use synchronous mode */
10173 spkt->satapkt_op_mode = SATA_OPMODE_SYNCH | SATA_OPMODE_INTERRUPTS;
10174
10175 /* Synchronous mode, no callback - may be changed by the caller */
10176 spkt->satapkt_comp = NULL;
10177 spkt->satapkt_time = sata_default_pkt_time;
10178
10179 /* Issue inquiry command - 6 bytes cdb, data transfer, read */
10180
10181 scmd->satacmd_flags.sata_data_direction = SATA_DIR_READ;
10182 scmd->satacmd_flags.sata_ignore_dev_reset = B_TRUE;
10183
10184 sata_atapi_packet_cmd_setup(scmd, sdinfo);
10185
10186 /* Set-up acdb. */
10187 scmd->satacmd_acdb_len = sdinfo->satadrv_atapi_cdb_len;
10188 bzero(scmd->satacmd_acdb, SATA_ATAPI_MAX_CDB_LEN);
10189 scmd->satacmd_acdb[0] = 0x12; /* Inquiry */
10190 scmd->satacmd_acdb[1] = 0x00;
10191 scmd->satacmd_acdb[2] = 0x00;
10192 scmd->satacmd_acdb[3] = 0x00;
10193 scmd->satacmd_acdb[4] = sizeof (struct scsi_inquiry);
10194 scmd->satacmd_acdb[5] = 0x00;
10195
10196 sata_fixed_sense_data_preset(
10197 (struct scsi_extended_sense *)scmd->satacmd_rqsense);
10198
10199 /* Transfer command to HBA */
10200 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex);
10201 if (sata_hba_start(spx, &rval) != 0) {
10202 /* Pkt not accepted for execution */
10203 sata_log(sata_hba_inst, CE_WARN,
10204 "sata_test_atapi_packet_command: "
10205 "Packet not accepted for execution - ret: %02x", rval);
10206 mutex_exit(
10207 &SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex);
10208 goto cleanup;
10209 }
10210 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex);
10211
10212 if (spx->txlt_buf_dma_handle != NULL) {
10213 /*
10214 * Sync buffer. Handle is in usual place in translate struct.
10215 */
10216 rval = ddi_dma_sync(spx->txlt_buf_dma_handle, 0, 0,
10217 DDI_DMA_SYNC_FORCPU);
10218 ASSERT(rval == DDI_SUCCESS);
10219 }
10220 if (spkt->satapkt_reason == SATA_PKT_COMPLETED) {
10221 sata_log(sata_hba_inst, CE_WARN,
10222 "sata_test_atapi_packet_command: "
10223 "Packet completed successfully");
10224 /*
10225 * Normal completion - show inquiry data
10226 */
10227 sata_show_inqry_data((uint8_t *)bp->b_un.b_addr);
10228 } else {
10229 /*
10230 * Something went wrong - analyze return - check rqsense data
10231 */
10232 if (spkt->satapkt_reason == SATA_PKT_DEV_ERROR) {
10233 /*
10234 * ARQ data hopefull show something other than NO SENSE
10235 */
10236 rqsp = scmd->satacmd_rqsense;
10237 sata_log(spx->txlt_sata_hba_inst, CE_WARN,
10238 "ATAPI packet completion reason: %02x\n"
10239 "RQSENSE: %02x %02x %02x %02x %02x %02x "
10240 " %02x %02x %02x %02x %02x %02x "
10241 " %02x %02x %02x %02x %02x %02x\n",
10242 spkt->satapkt_reason,
10243 rqsp[0], rqsp[1], rqsp[2], rqsp[3],
10244 rqsp[4], rqsp[5], rqsp[6], rqsp[7],
10245 rqsp[8], rqsp[9], rqsp[10], rqsp[11],
10246 rqsp[12], rqsp[13], rqsp[14], rqsp[15],
10247 rqsp[16], rqsp[17]);
10248 } else {
10249 switch (spkt->satapkt_reason) {
10250 case SATA_PKT_PORT_ERROR:
10251 sata_log(sata_hba_inst, CE_WARN,
10252 "sata_test_atapi_packet_command: "
10253 "packet reason: port error\n");
10254 break;
10255
10256 case SATA_PKT_TIMEOUT:
10257 sata_log(sata_hba_inst, CE_WARN,
10258 "sata_test_atapi_packet_command: "
10259 "packet reason: timeout\n");
10260 break;
10261
10262 case SATA_PKT_ABORTED:
10263 sata_log(sata_hba_inst, CE_WARN,
10264 "sata_test_atapi_packet_command: "
10265 "packet reason: aborted\n");
10266 break;
10267
10268 case SATA_PKT_RESET:
10269 sata_log(sata_hba_inst, CE_WARN,
10270 "sata_test_atapi_packet_command: "
10271 "packet reason: reset\n");
10272 break;
10273 default:
10274 sata_log(sata_hba_inst, CE_WARN,
10275 "sata_test_atapi_packet_command: "
10276 "invalid packet reason: %02x\n",
10277 spkt->satapkt_reason);
10278 break;
10279 }
10280 }
10281 }
10282 cleanup:
10283 sata_free_local_buffer(spx);
10284 sata_pkt_free(spx);
10285 kmem_free(spx, sizeof (sata_pkt_txlate_t));
10286 }
10287
10288 #endif /* SATA_DEBUG */
10289 #endif /* 1 */
10290
10291
10292 /* ************************** LOCAL HELPER FUNCTIONS *********************** */
10293
10294 /*
10295 * Validate sata_tran info
10296 * SATA_FAILURE returns if structure is inconsistent or structure revision
10297 * does not match one used by the framework.
10298 *
10299 * Returns SATA_SUCCESS if sata_hba_tran has matching revision and contains
10300 * required function pointers.
10301 * Returns SATA_FAILURE otherwise.
10302 */
10303 static int
10304 sata_validate_sata_hba_tran(dev_info_t *dip, sata_hba_tran_t *sata_tran)
10305 {
10306 /*
10307 * SATA_TRAN_HBA_REV is the current (highest) revision number
10308 * of the SATA interface.
10309 */
10310 if (sata_tran->sata_tran_hba_rev > SATA_TRAN_HBA_REV) {
10311 sata_log(NULL, CE_WARN,
10312 "sata: invalid sata_hba_tran version %d for driver %s",
10313 sata_tran->sata_tran_hba_rev, ddi_driver_name(dip));
10314 return (SATA_FAILURE);
10315 }
10316
10317 if (dip != sata_tran->sata_tran_hba_dip) {
10318 SATA_LOG_D((NULL, CE_WARN,
10319 "sata: inconsistent sata_tran_hba_dip "
10320 "%p / %p", sata_tran->sata_tran_hba_dip, dip));
10321 return (SATA_FAILURE);
10322 }
10323
10324 if (sata_tran->sata_tran_probe_port == NULL ||
10325 sata_tran->sata_tran_start == NULL ||
10326 sata_tran->sata_tran_abort == NULL ||
10327 sata_tran->sata_tran_reset_dport == NULL ||
10328 sata_tran->sata_tran_hotplug_ops == NULL ||
10329 sata_tran->sata_tran_hotplug_ops->sata_tran_port_activate == NULL ||
10330 sata_tran->sata_tran_hotplug_ops->sata_tran_port_deactivate ==
10331 NULL) {
10332 SATA_LOG_D((NULL, CE_WARN, "sata: sata_hba_tran missing "
10333 "required functions"));
10334 }
10335 return (SATA_SUCCESS);
10336 }
10337
10338 /*
10339 * Remove HBA instance from sata_hba_list.
10340 */
10341 static void
10342 sata_remove_hba_instance(dev_info_t *dip)
10343 {
10344 sata_hba_inst_t *sata_hba_inst;
10345
10346 mutex_enter(&sata_mutex);
10347 for (sata_hba_inst = sata_hba_list;
10348 sata_hba_inst != (struct sata_hba_inst *)NULL;
10349 sata_hba_inst = sata_hba_inst->satahba_next) {
10350 if (sata_hba_inst->satahba_dip == dip)
10351 break;
10352 }
10353
10354 if (sata_hba_inst == (struct sata_hba_inst *)NULL) {
10355 #ifdef SATA_DEBUG
10356 cmn_err(CE_WARN, "sata_remove_hba_instance: "
10357 "unknown HBA instance\n");
10358 #endif
10359 ASSERT(FALSE);
10360 }
10361 if (sata_hba_inst == sata_hba_list) {
10362 sata_hba_list = sata_hba_inst->satahba_next;
10363 if (sata_hba_list) {
10364 sata_hba_list->satahba_prev =
10365 (struct sata_hba_inst *)NULL;
10366 }
10367 if (sata_hba_inst == sata_hba_list_tail) {
10368 sata_hba_list_tail = NULL;
10369 }
10370 } else if (sata_hba_inst == sata_hba_list_tail) {
10371 sata_hba_list_tail = sata_hba_inst->satahba_prev;
10372 if (sata_hba_list_tail) {
10373 sata_hba_list_tail->satahba_next =
10374 (struct sata_hba_inst *)NULL;
10375 }
10376 } else {
10377 sata_hba_inst->satahba_prev->satahba_next =
10378 sata_hba_inst->satahba_next;
10379 sata_hba_inst->satahba_next->satahba_prev =
10380 sata_hba_inst->satahba_prev;
10381 }
10382 mutex_exit(&sata_mutex);
10383 }
10384
10385 /*
10386 * Probe all SATA ports of the specified HBA instance.
10387 * The assumption is that there are no target and attachment point minor nodes
10388 * created by the boot subsystems, so we do not need to prune device tree.
10389 *
10390 * This function is called only from sata_hba_attach(). It does not have to
10391 * be protected by controller mutex, because the hba_attached flag is not set
10392 * yet and no one would be touching this HBA instance other than this thread.
10393 * Determines if port is active and what type of the device is attached
10394 * (if any). Allocates necessary structures for each port.
10395 *
10396 * An AP (Attachement Point) node is created for each SATA device port even
10397 * when there is no device attached.
10398 */
10399
10400 static void
10401 sata_probe_ports(sata_hba_inst_t *sata_hba_inst)
10402 {
10403 dev_info_t *dip = SATA_DIP(sata_hba_inst);
10404 int ncport;
10405 sata_cport_info_t *cportinfo;
10406 sata_drive_info_t *drive;
10407 sata_device_t sata_device;
10408 int rval;
10409 dev_t minor_number;
10410 char name[16];
10411 clock_t start_time, cur_time;
10412
10413 /*
10414 * Probe controller ports first, to find port status and
10415 * any port multiplier attached.
10416 */
10417 for (ncport = 0; ncport < SATA_NUM_CPORTS(sata_hba_inst); ncport++) {
10418 /* allocate cport structure */
10419 cportinfo = kmem_zalloc(sizeof (sata_cport_info_t), KM_SLEEP);
10420 ASSERT(cportinfo != NULL);
10421 mutex_init(&cportinfo->cport_mutex, NULL, MUTEX_DRIVER, NULL);
10422
10423 mutex_enter(&cportinfo->cport_mutex);
10424
10425 cportinfo->cport_addr.cport = ncport;
10426 cportinfo->cport_addr.pmport = 0;
10427 cportinfo->cport_addr.qual = SATA_ADDR_CPORT;
10428 cportinfo->cport_state &= ~SATA_PORT_STATE_CLEAR_MASK;
10429 cportinfo->cport_state |= SATA_STATE_PROBING;
10430 SATA_CPORT_INFO(sata_hba_inst, ncport) = cportinfo;
10431
10432 /*
10433 * Regardless if a port is usable or not, create
10434 * an attachment point
10435 */
10436 mutex_exit(&cportinfo->cport_mutex);
10437 minor_number = SATA_MAKE_AP_MINOR(ddi_get_instance(dip),
10438 ncport, 0, SATA_ADDR_CPORT);
10439 (void) sprintf(name, "%d", ncport);
10440 if (ddi_create_minor_node(dip, name, S_IFCHR,
10441 minor_number, DDI_NT_SATA_ATTACHMENT_POINT, 0) !=
10442 DDI_SUCCESS) {
10443 sata_log(sata_hba_inst, CE_WARN, "sata_hba_attach: "
10444 "cannot create SATA attachment point for port %d",
10445 ncport);
10446 }
10447
10448 /* Probe port */
10449 start_time = ddi_get_lbolt();
10450 reprobe_cport:
10451 sata_device.satadev_addr.cport = ncport;
10452 sata_device.satadev_addr.pmport = 0;
10453 sata_device.satadev_addr.qual = SATA_ADDR_CPORT;
10454 sata_device.satadev_rev = SATA_DEVICE_REV;
10455
10456 rval = (*SATA_PROBE_PORT_FUNC(sata_hba_inst))
10457 (dip, &sata_device);
10458
10459 mutex_enter(&cportinfo->cport_mutex);
10460 cportinfo->cport_scr = sata_device.satadev_scr;
10461 if (rval != SATA_SUCCESS) {
10462 /* Something went wrong? Fail the port */
10463 cportinfo->cport_state = SATA_PSTATE_FAILED;
10464 mutex_exit(&cportinfo->cport_mutex);
10465 continue;
10466 }
10467 cportinfo->cport_state &= ~SATA_STATE_PROBING;
10468 cportinfo->cport_state |= SATA_STATE_PROBED;
10469 cportinfo->cport_dev_type = sata_device.satadev_type;
10470
10471 cportinfo->cport_state |= SATA_STATE_READY;
10472 if (cportinfo->cport_dev_type == SATA_DTYPE_NONE) {
10473 mutex_exit(&cportinfo->cport_mutex);
10474 continue;
10475 }
10476 if (cportinfo->cport_dev_type != SATA_DTYPE_PMULT) {
10477 /*
10478 * There is some device attached.
10479 * Allocate device info structure
10480 */
10481 if (SATA_CPORTINFO_DRV_INFO(cportinfo) == NULL) {
10482 mutex_exit(&cportinfo->cport_mutex);
10483 SATA_CPORTINFO_DRV_INFO(cportinfo) =
10484 kmem_zalloc(sizeof (sata_drive_info_t),
10485 KM_SLEEP);
10486 mutex_enter(&cportinfo->cport_mutex);
10487 }
10488 drive = SATA_CPORTINFO_DRV_INFO(cportinfo);
10489 drive->satadrv_addr = cportinfo->cport_addr;
10490 drive->satadrv_addr.qual = SATA_ADDR_DCPORT;
10491 drive->satadrv_type = cportinfo->cport_dev_type;
10492 drive->satadrv_state = SATA_STATE_UNKNOWN;
10493
10494 mutex_exit(&cportinfo->cport_mutex);
10495 if (sata_add_device(dip, sata_hba_inst, &sata_device) !=
10496 SATA_SUCCESS) {
10497 /*
10498 * Plugged device was not correctly identified.
10499 * Retry, within a SATA_DEV_IDENTIFY_TIMEOUT
10500 */
10501 cur_time = ddi_get_lbolt();
10502 if ((cur_time - start_time) <
10503 drv_usectohz(SATA_DEV_IDENTIFY_TIMEOUT)) {
10504 /* sleep for a while */
10505 delay(drv_usectohz(
10506 SATA_DEV_RETRY_DLY));
10507 goto reprobe_cport;
10508 }
10509 }
10510 } else { /* SATA_DTYPE_PMULT */
10511 mutex_exit(&cportinfo->cport_mutex);
10512
10513 /* Allocate sata_pmult_info and sata_pmport_info */
10514 if (sata_alloc_pmult(sata_hba_inst, &sata_device) !=
10515 SATA_SUCCESS)
10516 continue;
10517
10518 /* Log the information of the port multiplier */
10519 sata_show_pmult_info(sata_hba_inst, &sata_device);
10520
10521 /* Probe its pmports */
10522 sata_probe_pmports(sata_hba_inst, ncport);
10523 }
10524 }
10525 }
10526
10527 /*
10528 * Probe all device ports behind a port multiplier.
10529 *
10530 * PMult-related structure should be allocated before by sata_alloc_pmult().
10531 *
10532 * NOTE1: Only called from sata_probe_ports()
10533 * NOTE2: No mutex should be hold.
10534 */
10535 static void
10536 sata_probe_pmports(sata_hba_inst_t *sata_hba_inst, uint8_t ncport)
10537 {
10538 dev_info_t *dip = SATA_DIP(sata_hba_inst);
10539 sata_pmult_info_t *pmultinfo = NULL;
10540 sata_pmport_info_t *pmportinfo = NULL;
10541 sata_drive_info_t *drive = NULL;
10542 sata_device_t sata_device;
10543
10544 clock_t start_time, cur_time;
10545 int npmport;
10546 int rval;
10547
10548 pmultinfo = SATA_PMULT_INFO(sata_hba_inst, ncport);
10549
10550 /* Probe Port Multiplier ports */
10551 for (npmport = 0; npmport < pmultinfo->pmult_num_dev_ports; npmport++) {
10552 pmportinfo = pmultinfo->pmult_dev_port[npmport];
10553 start_time = ddi_get_lbolt();
10554 reprobe_pmport:
10555 sata_device.satadev_addr.cport = ncport;
10556 sata_device.satadev_addr.pmport = npmport;
10557 sata_device.satadev_addr.qual = SATA_ADDR_PMPORT;
10558 sata_device.satadev_rev = SATA_DEVICE_REV;
10559
10560 /* Let HBA driver probe it. */
10561 rval = (*SATA_PROBE_PORT_FUNC(sata_hba_inst))
10562 (dip, &sata_device);
10563 mutex_enter(&pmportinfo->pmport_mutex);
10564
10565 pmportinfo->pmport_scr = sata_device.satadev_scr;
10566
10567 if (rval != SATA_SUCCESS) {
10568 pmportinfo->pmport_state =
10569 SATA_PSTATE_FAILED;
10570 mutex_exit(&pmportinfo->pmport_mutex);
10571 continue;
10572 }
10573 pmportinfo->pmport_state &= ~SATA_STATE_PROBING;
10574 pmportinfo->pmport_state |= SATA_STATE_PROBED;
10575 pmportinfo->pmport_dev_type = sata_device.satadev_type;
10576
10577 pmportinfo->pmport_state |= SATA_STATE_READY;
10578 if (pmportinfo->pmport_dev_type ==
10579 SATA_DTYPE_NONE) {
10580 SATADBG2(SATA_DBG_PMULT, sata_hba_inst,
10581 "no device found at port %d:%d", ncport, npmport);
10582 mutex_exit(&pmportinfo->pmport_mutex);
10583 continue;
10584 }
10585 /* Port multipliers cannot be chained */
10586 ASSERT(pmportinfo->pmport_dev_type != SATA_DTYPE_PMULT);
10587 /*
10588 * There is something attached to Port
10589 * Multiplier device port
10590 * Allocate device info structure
10591 */
10592 if (pmportinfo->pmport_sata_drive == NULL) {
10593 mutex_exit(&pmportinfo->pmport_mutex);
10594 pmportinfo->pmport_sata_drive =
10595 kmem_zalloc(sizeof (sata_drive_info_t), KM_SLEEP);
10596 mutex_enter(&pmportinfo->pmport_mutex);
10597 }
10598 drive = pmportinfo->pmport_sata_drive;
10599 drive->satadrv_addr.cport = pmportinfo->pmport_addr.cport;
10600 drive->satadrv_addr.pmport = npmport;
10601 drive->satadrv_addr.qual = SATA_ADDR_DPMPORT;
10602 drive->satadrv_type = pmportinfo-> pmport_dev_type;
10603 drive->satadrv_state = SATA_STATE_UNKNOWN;
10604
10605 mutex_exit(&pmportinfo->pmport_mutex);
10606 rval = sata_add_device(dip, sata_hba_inst, &sata_device);
10607
10608 if (rval != SATA_SUCCESS) {
10609 /*
10610 * Plugged device was not correctly identified.
10611 * Retry, within the SATA_DEV_IDENTIFY_TIMEOUT
10612 */
10613 cur_time = ddi_get_lbolt();
10614 if ((cur_time - start_time) < drv_usectohz(
10615 SATA_DEV_IDENTIFY_TIMEOUT)) {
10616 /* sleep for a while */
10617 delay(drv_usectohz(SATA_DEV_RETRY_DLY));
10618 goto reprobe_pmport;
10619 }
10620 }
10621 }
10622 }
10623
10624 /*
10625 * Add SATA device for specified HBA instance & port (SCSI target
10626 * device nodes).
10627 * This function is called (indirectly) only from sata_hba_attach().
10628 * A target node is created when there is a supported type device attached,
10629 * but may be removed if it cannot be put online.
10630 *
10631 * This function cannot be called from an interrupt context.
10632 *
10633 * Create target nodes for disk, CD/DVD, Tape and ATAPI disk devices
10634 *
10635 * Returns SATA_SUCCESS when port/device was fully processed, SATA_FAILURE when
10636 * device identification failed - adding a device could be retried.
10637 *
10638 */
10639 static int
10640 sata_add_device(dev_info_t *pdip, sata_hba_inst_t *sata_hba_inst,
10641 sata_device_t *sata_device)
10642 {
10643 sata_cport_info_t *cportinfo;
10644 sata_pmult_info_t *pminfo;
10645 sata_pmport_info_t *pmportinfo;
10646 dev_info_t *cdip; /* child dip */
10647 sata_address_t *saddr = &sata_device->satadev_addr;
10648 uint8_t cport, pmport;
10649 int rval;
10650
10651 cport = saddr->cport;
10652 pmport = saddr->pmport;
10653 cportinfo = SATA_CPORT_INFO(sata_hba_inst, cport);
10654 ASSERT(cportinfo->cport_dev_type != SATA_DTYPE_NONE);
10655
10656 /*
10657 * Some device is attached to a controller port.
10658 * We rely on controllers distinquishing between no-device,
10659 * attached port multiplier and other kind of attached device.
10660 * We need to get Identify Device data and determine
10661 * positively the dev type before trying to attach
10662 * the target driver.
10663 */
10664 sata_device->satadev_rev = SATA_DEVICE_REV;
10665 switch (saddr->qual) {
10666 case SATA_ADDR_CPORT:
10667 /*
10668 * Add a non-port-multiplier device at controller port.
10669 */
10670 saddr->qual = SATA_ADDR_DCPORT;
10671
10672 rval = sata_probe_device(sata_hba_inst, sata_device);
10673 if (rval != SATA_SUCCESS ||
10674 sata_device->satadev_type == SATA_DTYPE_UNKNOWN)
10675 return (SATA_FAILURE);
10676
10677 mutex_enter(&cportinfo->cport_mutex);
10678 sata_show_drive_info(sata_hba_inst,
10679 SATA_CPORTINFO_DRV_INFO(cportinfo));
10680
10681 if ((sata_device->satadev_type & SATA_VALID_DEV_TYPE) == 0) {
10682 /*
10683 * Could not determine device type or
10684 * a device is not supported.
10685 * Degrade this device to unknown.
10686 */
10687 cportinfo->cport_dev_type = SATA_DTYPE_UNKNOWN;
10688 mutex_exit(&cportinfo->cport_mutex);
10689 return (SATA_SUCCESS);
10690 }
10691 cportinfo->cport_dev_type = sata_device->satadev_type;
10692 cportinfo->cport_tgtnode_clean = B_TRUE;
10693 mutex_exit(&cportinfo->cport_mutex);
10694
10695 /*
10696 * Initialize device to the desired state. Even if it
10697 * fails, the device will still attach but syslog
10698 * will show the warning.
10699 */
10700 if (sata_initialize_device(sata_hba_inst,
10701 SATA_CPORTINFO_DRV_INFO(cportinfo)) != SATA_SUCCESS) {
10702 /* Retry */
10703 rval = sata_initialize_device(sata_hba_inst,
10704 SATA_CPORTINFO_DRV_INFO(cportinfo));
10705
10706 if (rval == SATA_RETRY)
10707 sata_log(sata_hba_inst, CE_WARN,
10708 "SATA device at port %d - "
10709 "default device features could not be set."
10710 " Device may not operate as expected.",
10711 cport);
10712 }
10713
10714 cdip = sata_create_target_node(pdip, sata_hba_inst, saddr);
10715 if (cdip == NULL) {
10716 /*
10717 * Attaching target node failed.
10718 * We retain sata_drive_info structure...
10719 */
10720 return (SATA_SUCCESS);
10721 }
10722
10723 mutex_enter(&cportinfo->cport_mutex);
10724 (SATA_CPORTINFO_DRV_INFO(cportinfo))->
10725 satadrv_state = SATA_STATE_READY;
10726 mutex_exit(&cportinfo->cport_mutex);
10727
10728 break;
10729
10730 case SATA_ADDR_PMPORT:
10731 saddr->qual = SATA_ADDR_DPMPORT;
10732
10733 mutex_enter(&cportinfo->cport_mutex);
10734 /* It must be a Port Multiplier at the controller port */
10735 ASSERT(cportinfo->cport_dev_type == SATA_DTYPE_PMULT);
10736
10737 pminfo = SATA_CPORTINFO_PMULT_INFO(cportinfo);
10738 pmportinfo = pminfo->pmult_dev_port[saddr->pmport];
10739 mutex_exit(&cportinfo->cport_mutex);
10740
10741 rval = sata_probe_device(sata_hba_inst, sata_device);
10742 if (rval != SATA_SUCCESS ||
10743 sata_device->satadev_type == SATA_DTYPE_UNKNOWN) {
10744 return (SATA_FAILURE);
10745 }
10746
10747 mutex_enter(&pmportinfo->pmport_mutex);
10748 sata_show_drive_info(sata_hba_inst,
10749 SATA_PMPORTINFO_DRV_INFO(pmportinfo));
10750
10751 if ((sata_device->satadev_type & SATA_VALID_DEV_TYPE) == 0) {
10752 /*
10753 * Could not determine device type.
10754 * Degrade this device to unknown.
10755 */
10756 pmportinfo->pmport_dev_type = SATA_DTYPE_UNKNOWN;
10757 mutex_exit(&pmportinfo->pmport_mutex);
10758 return (SATA_SUCCESS);
10759 }
10760 pmportinfo->pmport_dev_type = sata_device->satadev_type;
10761 pmportinfo->pmport_tgtnode_clean = B_TRUE;
10762 mutex_exit(&pmportinfo->pmport_mutex);
10763
10764 /*
10765 * Initialize device to the desired state.
10766 * Even if it fails, the device will still
10767 * attach but syslog will show the warning.
10768 */
10769 if (sata_initialize_device(sata_hba_inst,
10770 pmportinfo->pmport_sata_drive) != SATA_SUCCESS) {
10771 /* Retry */
10772 rval = sata_initialize_device(sata_hba_inst,
10773 pmportinfo->pmport_sata_drive);
10774
10775 if (rval == SATA_RETRY)
10776 sata_log(sata_hba_inst, CE_WARN,
10777 "SATA device at port %d:%d - "
10778 "default device features could not be set."
10779 " Device may not operate as expected.",
10780 cport, pmport);
10781 }
10782
10783 cdip = sata_create_target_node(pdip, sata_hba_inst, saddr);
10784 if (cdip == NULL) {
10785 /*
10786 * Attaching target node failed.
10787 * We retain sata_drive_info structure...
10788 */
10789 return (SATA_SUCCESS);
10790 }
10791 mutex_enter(&pmportinfo->pmport_mutex);
10792 pmportinfo->pmport_sata_drive->satadrv_state |=
10793 SATA_STATE_READY;
10794 mutex_exit(&pmportinfo->pmport_mutex);
10795
10796 break;
10797
10798 default:
10799 return (SATA_FAILURE);
10800 }
10801
10802 return (SATA_SUCCESS);
10803 }
10804
10805 /*
10806 * Clean up target node at specific address.
10807 *
10808 * NOTE: No Mutex should be hold.
10809 */
10810 static int
10811 sata_offline_device(sata_hba_inst_t *sata_hba_inst,
10812 sata_device_t *sata_device, sata_drive_info_t *sdinfo)
10813 {
10814 uint8_t cport, pmport, qual;
10815 dev_info_t *tdip;
10816
10817 cport = sata_device->satadev_addr.cport;
10818 pmport = sata_device->satadev_addr.pmport;
10819 qual = sata_device->satadev_addr.qual;
10820
10821 if (qual == SATA_ADDR_DCPORT) {
10822 SATA_LOG_D((sata_hba_inst, CE_WARN,
10823 "sata_hba_ioctl: disconnect device at port %d", cport));
10824 } else {
10825 SATA_LOG_D((sata_hba_inst, CE_WARN,
10826 "sata_hba_ioctl: disconnect device at port %d:%d",
10827 cport, pmport));
10828 }
10829
10830 /* We are addressing attached device, not a port */
10831 sata_device->satadev_addr.qual =
10832 sdinfo->satadrv_addr.qual;
10833 tdip = sata_get_scsi_target_dip(SATA_DIP(sata_hba_inst),
10834 &sata_device->satadev_addr);
10835 if (tdip != NULL && ndi_devi_offline(tdip,
10836 NDI_DEVI_REMOVE) != NDI_SUCCESS) {
10837 /*
10838 * Problem :
10839 * The target node remained attached.
10840 * This happens when the device file was open
10841 * or a node was waiting for resources.
10842 * Cannot do anything about it.
10843 */
10844 if (qual == SATA_ADDR_DCPORT) {
10845 SATA_LOG_D((sata_hba_inst, CE_WARN,
10846 "sata_hba_ioctl: disconnect: could "
10847 "not unconfigure device before "
10848 "disconnecting the SATA port %d",
10849 cport));
10850 } else {
10851 SATA_LOG_D((sata_hba_inst, CE_WARN,
10852 "sata_hba_ioctl: disconnect: could "
10853 "not unconfigure device before "
10854 "disconnecting the SATA port %d:%d",
10855 cport, pmport));
10856 }
10857 /*
10858 * Set DEVICE REMOVED state in the target
10859 * node. It will prevent access to the device
10860 * even when a new device is attached, until
10861 * the old target node is released, removed and
10862 * recreated for a new device.
10863 */
10864 sata_set_device_removed(tdip);
10865
10866 /*
10867 * Instruct event daemon to try the target
10868 * node cleanup later.
10869 */
10870 sata_set_target_node_cleanup(
10871 sata_hba_inst, &sata_device->satadev_addr);
10872 }
10873
10874
10875 return (SATA_SUCCESS);
10876 }
10877
10878
10879 /*
10880 * Create scsi target node for attached device, create node properties and
10881 * attach the node.
10882 * The node could be removed if the device onlining fails.
10883 *
10884 * A dev_info_t pointer is returned if operation is successful, NULL is
10885 * returned otherwise.
10886 */
10887
10888 static dev_info_t *
10889 sata_create_target_node(dev_info_t *dip, sata_hba_inst_t *sata_hba_inst,
10890 sata_address_t *sata_addr)
10891 {
10892 dev_info_t *cdip = NULL;
10893 int rval;
10894 char *nname = NULL;
10895 char **compatible = NULL;
10896 int ncompatible;
10897 struct scsi_inquiry inq;
10898 sata_device_t sata_device;
10899 sata_drive_info_t *sdinfo;
10900 int target;
10901 int i;
10902
10903 sata_device.satadev_rev = SATA_DEVICE_REV;
10904 sata_device.satadev_addr = *sata_addr;
10905
10906 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, sata_addr->cport)));
10907
10908 sdinfo = sata_get_device_info(sata_hba_inst, &sata_device);
10909
10910 target = SATA_TO_SCSI_TARGET(sata_addr->cport,
10911 sata_addr->pmport, sata_addr->qual);
10912
10913 if (sdinfo == NULL) {
10914 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst,
10915 sata_addr->cport)));
10916 SATA_LOG_D((sata_hba_inst, CE_WARN,
10917 "sata_create_target_node: no sdinfo for target %x",
10918 target));
10919 return (NULL);
10920 }
10921
10922 /*
10923 * create or get scsi inquiry data, expected by
10924 * scsi_hba_nodename_compatible_get()
10925 * SATA hard disks get Identify Data translated into Inguiry Data.
10926 * ATAPI devices respond directly to Inquiry request.
10927 */
10928 if (sdinfo->satadrv_type == SATA_DTYPE_ATADISK) {
10929 sata_identdev_to_inquiry(sata_hba_inst, sdinfo,
10930 (uint8_t *)&inq);
10931 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst,
10932 sata_addr->cport)));
10933 } else { /* Assume supported ATAPI device */
10934 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst,
10935 sata_addr->cport)));
10936 if (sata_get_atapi_inquiry_data(sata_hba_inst, sata_addr,
10937 &inq) == SATA_FAILURE)
10938 return (NULL);
10939 /*
10940 * Save supported ATAPI transport version
10941 */
10942 sdinfo->satadrv_atapi_trans_ver =
10943 SATA_ATAPI_TRANS_VERSION(&inq);
10944 }
10945
10946 /* determine the node name and compatible */
10947 scsi_hba_nodename_compatible_get(&inq, NULL,
10948 inq.inq_dtype, NULL, &nname, &compatible, &ncompatible);
10949
10950 #ifdef SATA_DEBUG
10951 if (sata_debug_flags & SATA_DBG_NODES) {
10952 if (nname == NULL) {
10953 cmn_err(CE_NOTE, "sata_create_target_node: "
10954 "cannot determine nodename for target %d\n",
10955 target);
10956 } else {
10957 cmn_err(CE_WARN, "sata_create_target_node: "
10958 "target %d nodename: %s\n", target, nname);
10959 }
10960 if (compatible == NULL) {
10961 cmn_err(CE_WARN,
10962 "sata_create_target_node: no compatible name\n");
10963 } else {
10964 for (i = 0; i < ncompatible; i++) {
10965 cmn_err(CE_WARN, "sata_create_target_node: "
10966 "compatible name: %s\n", compatible[i]);
10967 }
10968 }
10969 }
10970 #endif
10971
10972 /* if nodename can't be determined, log error and exit */
10973 if (nname == NULL) {
10974 SATA_LOG_D((sata_hba_inst, CE_WARN,
10975 "sata_create_target_node: cannot determine nodename "
10976 "for target %d\n", target));
10977 scsi_hba_nodename_compatible_free(nname, compatible);
10978 return (NULL);
10979 }
10980 /*
10981 * Create scsi target node
10982 */
10983 ndi_devi_alloc_sleep(dip, nname, (pnode_t)DEVI_SID_NODEID, &cdip);
10984 rval = ndi_prop_update_string(DDI_DEV_T_NONE, cdip,
10985 "device-type", "scsi");
10986
10987 if (rval != DDI_PROP_SUCCESS) {
10988 SATA_LOG_D((sata_hba_inst, CE_WARN, "sata_create_target_node: "
10989 "updating device_type prop failed %d", rval));
10990 goto fail;
10991 }
10992
10993 /*
10994 * Create target node properties: target & lun
10995 */
10996 rval = ndi_prop_update_int(DDI_DEV_T_NONE, cdip, "target", target);
10997 if (rval != DDI_PROP_SUCCESS) {
10998 SATA_LOG_D((sata_hba_inst, CE_WARN, "sata_create_target_node: "
10999 "updating target prop failed %d", rval));
11000 goto fail;
11001 }
11002 rval = ndi_prop_update_int(DDI_DEV_T_NONE, cdip, "lun", 0);
11003 if (rval != DDI_PROP_SUCCESS) {
11004 SATA_LOG_D((sata_hba_inst, CE_WARN, "sata_create_target_node: "
11005 "updating target prop failed %d", rval));
11006 goto fail;
11007 }
11008
11009 if (sdinfo->satadrv_type & SATA_DTYPE_ATAPI) {
11010 /*
11011 * Add "variant" property
11012 */
11013 rval = ndi_prop_update_string(DDI_DEV_T_NONE, cdip,
11014 "variant", "atapi");
11015 if (rval != DDI_PROP_SUCCESS) {
11016 SATA_LOG_D((sata_hba_inst, CE_WARN,
11017 "sata_create_target_node: variant atapi "
11018 "property could not be created: %d", rval));
11019 goto fail;
11020 }
11021 }
11022 /* decorate the node with compatible */
11023 if (ndi_prop_update_string_array(DDI_DEV_T_NONE, cdip, "compatible",
11024 compatible, ncompatible) != DDI_PROP_SUCCESS) {
11025 SATA_LOG_D((sata_hba_inst, CE_WARN,
11026 "sata_create_target_node: FAIL compatible props cdip 0x%p",
11027 (void *)cdip));
11028 goto fail;
11029 }
11030
11031 if (sdinfo->satadrv_type == SATA_DTYPE_ATADISK) {
11032 /*
11033 * Add "sata-phy" property
11034 */
11035 if (ndi_prop_update_int(DDI_DEV_T_NONE, cdip, "sata-phy",
11036 (int)sata_addr->cport) != DDI_PROP_SUCCESS) {
11037 SATA_LOG_D((sata_hba_inst, CE_WARN,
11038 "sata_create_target_node: failed to create "
11039 "\"sata-phy\" property: port %d",
11040 sata_addr->cport));
11041 }
11042 }
11043
11044
11045 /*
11046 * Now, try to attach the driver. If probing of the device fails,
11047 * the target node may be removed
11048 */
11049 rval = ndi_devi_online(cdip, NDI_ONLINE_ATTACH);
11050
11051 scsi_hba_nodename_compatible_free(nname, compatible);
11052
11053 if (rval == NDI_SUCCESS)
11054 return (cdip);
11055
11056 /* target node was removed - are we sure? */
11057 return (NULL);
11058
11059 fail:
11060 scsi_hba_nodename_compatible_free(nname, compatible);
11061 ddi_prop_remove_all(cdip);
11062 rval = ndi_devi_free(cdip);
11063 if (rval != NDI_SUCCESS) {
11064 SATA_LOG_D((sata_hba_inst, CE_WARN, "sata_create_target_node: "
11065 "node removal failed %d", rval));
11066 }
11067 sata_log(sata_hba_inst, CE_WARN, "sata_create_target_node: "
11068 "cannot create target node for SATA device at port %d",
11069 sata_addr->cport);
11070 return (NULL);
11071 }
11072
11073 /*
11074 * Remove a target node.
11075 */
11076 static void
11077 sata_remove_target_node(sata_hba_inst_t *sata_hba_inst,
11078 sata_address_t *sata_addr)
11079 {
11080 dev_info_t *tdip;
11081 uint8_t cport = sata_addr->cport;
11082 uint8_t pmport = sata_addr->pmport;
11083 uint8_t qual = sata_addr->qual;
11084
11085 /* Note the sata daemon uses the address of the port/pmport */
11086 ASSERT(qual == SATA_ADDR_CPORT || qual == SATA_ADDR_PMPORT);
11087
11088 /* Remove target node */
11089 tdip = sata_get_target_dip(SATA_DIP(sata_hba_inst), cport, pmport);
11090 if (tdip != NULL) {
11091 /*
11092 * Target node exists. Unconfigure device
11093 * then remove the target node (one ndi
11094 * operation).
11095 */
11096 if (ndi_devi_offline(tdip, NDI_DEVI_REMOVE) != NDI_SUCCESS) {
11097 /*
11098 * PROBLEM - no device, but target node remained. This
11099 * happens when the file was open or node was waiting
11100 * for resources.
11101 */
11102 SATA_LOG_D((sata_hba_inst, CE_WARN,
11103 "sata_remove_target_node: "
11104 "Failed to remove target node for "
11105 "detached SATA device."));
11106 /*
11107 * Set target node state to DEVI_DEVICE_REMOVED. But
11108 * re-check first that the node still exists.
11109 */
11110 tdip = sata_get_target_dip(SATA_DIP(sata_hba_inst),
11111 cport, pmport);
11112 if (tdip != NULL) {
11113 sata_set_device_removed(tdip);
11114 /*
11115 * Instruct event daemon to retry the cleanup
11116 * later.
11117 */
11118 sata_set_target_node_cleanup(sata_hba_inst,
11119 sata_addr);
11120 }
11121 }
11122
11123 if (qual == SATA_ADDR_CPORT)
11124 sata_log(sata_hba_inst, CE_WARN,
11125 "SATA device detached at port %d", cport);
11126 else
11127 sata_log(sata_hba_inst, CE_WARN,
11128 "SATA device detached at port %d:%d",
11129 cport, pmport);
11130 }
11131 #ifdef SATA_DEBUG
11132 else {
11133 if (qual == SATA_ADDR_CPORT)
11134 sata_log(sata_hba_inst, CE_WARN,
11135 "target node not found at port %d", cport);
11136 else
11137 sata_log(sata_hba_inst, CE_WARN,
11138 "target node not found at port %d:%d",
11139 cport, pmport);
11140 }
11141 #endif
11142 }
11143
11144
11145 /*
11146 * Re-probe sata port, check for a device and attach info
11147 * structures when necessary. Identify Device data is fetched, if possible.
11148 * Assumption: sata address is already validated.
11149 * SATA_SUCCESS is returned if port is re-probed sucessfully, regardless of
11150 * the presence of a device and its type.
11151 *
11152 * flag arg specifies that the function should try multiple times to identify
11153 * device type and to initialize it, or it should return immediately on failure.
11154 * SATA_DEV_IDENTIFY_RETRY - retry
11155 * SATA_DEV_IDENTIFY_NORETRY - no retry
11156 *
11157 * SATA_FAILURE is returned if one of the operations failed.
11158 *
11159 * This function cannot be called in interrupt context - it may sleep.
11160 *
11161 * Note: Port multiplier is supported.
11162 */
11163 static int
11164 sata_reprobe_port(sata_hba_inst_t *sata_hba_inst, sata_device_t *sata_device,
11165 int flag)
11166 {
11167 sata_cport_info_t *cportinfo;
11168 sata_pmult_info_t *pmultinfo;
11169 sata_drive_info_t *sdinfo, *osdinfo;
11170 boolean_t init_device = B_FALSE;
11171 int prev_device_type = SATA_DTYPE_NONE;
11172 int prev_device_settings = 0;
11173 int prev_device_state = 0;
11174 clock_t start_time;
11175 int retry = B_FALSE;
11176 uint8_t cport = sata_device->satadev_addr.cport;
11177 int rval_probe, rval_init;
11178
11179 /*
11180 * If target is pmport, sata_reprobe_pmport() will handle it.
11181 */
11182 if (sata_device->satadev_addr.qual == SATA_ADDR_PMPORT ||
11183 sata_device->satadev_addr.qual == SATA_ADDR_DPMPORT)
11184 return (sata_reprobe_pmport(sata_hba_inst, sata_device, flag));
11185
11186 /* We only care about host sata cport for now */
11187 cportinfo = SATA_CPORT_INFO(sata_hba_inst,
11188 sata_device->satadev_addr.cport);
11189
11190 /*
11191 * If a port multiplier was previously attached (we have no idea it
11192 * still there or not), sata_reprobe_pmult() will handle it.
11193 */
11194 if (cportinfo->cport_dev_type == SATA_DTYPE_PMULT)
11195 return (sata_reprobe_pmult(sata_hba_inst, sata_device, flag));
11196
11197 /* Store sata_drive_info when a non-pmult device was attached. */
11198 osdinfo = SATA_CPORTINFO_DRV_INFO(cportinfo);
11199 if (osdinfo != NULL) {
11200 /*
11201 * We are re-probing port with a previously attached device.
11202 * Save previous device type and settings.
11203 */
11204 prev_device_type = cportinfo->cport_dev_type;
11205 prev_device_settings = osdinfo->satadrv_settings;
11206 prev_device_state = osdinfo->satadrv_state;
11207 }
11208 if (flag == SATA_DEV_IDENTIFY_RETRY) {
11209 start_time = ddi_get_lbolt();
11210 retry = B_TRUE;
11211 }
11212 retry_probe:
11213
11214 /* probe port */
11215 mutex_enter(&cportinfo->cport_mutex);
11216 cportinfo->cport_state &= ~SATA_PORT_STATE_CLEAR_MASK;
11217 cportinfo->cport_state |= SATA_STATE_PROBING;
11218 mutex_exit(&cportinfo->cport_mutex);
11219
11220 rval_probe = (*SATA_PROBE_PORT_FUNC(sata_hba_inst))
11221 (SATA_DIP(sata_hba_inst), sata_device);
11222
11223 mutex_enter(&cportinfo->cport_mutex);
11224 if (rval_probe != SATA_SUCCESS) {
11225 cportinfo->cport_state = SATA_PSTATE_FAILED;
11226 mutex_exit(&cportinfo->cport_mutex);
11227 SATA_LOG_D((sata_hba_inst, CE_WARN, "sata_reprobe_port: "
11228 "SATA port %d probing failed",
11229 cportinfo->cport_addr.cport));
11230 return (SATA_FAILURE);
11231 }
11232
11233 /*
11234 * update sata port state and set device type
11235 */
11236 sata_update_port_info(sata_hba_inst, sata_device);
11237 cportinfo->cport_state &= ~SATA_STATE_PROBING;
11238
11239 /*
11240 * Sanity check - Port is active? Is the link active?
11241 * Is there any device attached?
11242 */
11243 if ((cportinfo->cport_state &
11244 (SATA_PSTATE_SHUTDOWN | SATA_PSTATE_FAILED)) ||
11245 (cportinfo->cport_scr.sstatus & SATA_PORT_DEVLINK_UP_MASK) !=
11246 SATA_PORT_DEVLINK_UP) {
11247 /*
11248 * Port in non-usable state or no link active/no device.
11249 * Free info structure if necessary (direct attached drive
11250 * only, for now!
11251 */
11252 sdinfo = SATA_CPORTINFO_DRV_INFO(cportinfo);
11253 SATA_CPORTINFO_DRV_INFO(cportinfo) = NULL;
11254 /* Add here differentiation for device attached or not */
11255 cportinfo->cport_dev_type = SATA_DTYPE_NONE;
11256 mutex_exit(&cportinfo->cport_mutex);
11257 if (sdinfo != NULL)
11258 kmem_free(sdinfo, sizeof (sata_drive_info_t));
11259 return (SATA_SUCCESS);
11260 }
11261
11262 cportinfo->cport_state |= SATA_STATE_READY;
11263 cportinfo->cport_state |= SATA_STATE_PROBED;
11264
11265 cportinfo->cport_dev_type = sata_device->satadev_type;
11266 sdinfo = SATA_CPORTINFO_DRV_INFO(cportinfo);
11267
11268 /*
11269 * If we are re-probing the port, there may be
11270 * sata_drive_info structure attached
11271 */
11272 if (sata_device->satadev_type == SATA_DTYPE_NONE) {
11273
11274 /*
11275 * There is no device, so remove device info structure,
11276 * if necessary.
11277 */
11278 /* Device change: Drive -> None */
11279 SATA_CPORTINFO_DRV_INFO(cportinfo) = NULL;
11280 cportinfo->cport_dev_type = SATA_DTYPE_NONE;
11281 if (sdinfo != NULL) {
11282 kmem_free(sdinfo, sizeof (sata_drive_info_t));
11283 sata_log(sata_hba_inst, CE_WARN,
11284 "SATA device detached "
11285 "from port %d", cportinfo->cport_addr.cport);
11286 }
11287 mutex_exit(&cportinfo->cport_mutex);
11288 return (SATA_SUCCESS);
11289
11290 }
11291
11292 if (sata_device->satadev_type != SATA_DTYPE_PMULT) {
11293
11294 /* Device (may) change: Drive -> Drive */
11295 if (sdinfo == NULL) {
11296 /*
11297 * There is some device attached, but there is
11298 * no sata_drive_info structure - allocate one
11299 */
11300 mutex_exit(&cportinfo->cport_mutex);
11301 sdinfo = kmem_zalloc(
11302 sizeof (sata_drive_info_t), KM_SLEEP);
11303 mutex_enter(&cportinfo->cport_mutex);
11304 /*
11305 * Recheck, that the port state did not change when we
11306 * released mutex.
11307 */
11308 if (cportinfo->cport_state & SATA_STATE_READY) {
11309 SATA_CPORTINFO_DRV_INFO(cportinfo) = sdinfo;
11310 sdinfo->satadrv_addr = cportinfo->cport_addr;
11311 sdinfo->satadrv_addr.qual = SATA_ADDR_DCPORT;
11312 sdinfo->satadrv_type = SATA_DTYPE_UNKNOWN;
11313 sdinfo->satadrv_state = SATA_STATE_UNKNOWN;
11314 } else {
11315 /*
11316 * Port is not in ready state, we
11317 * cannot attach a device.
11318 */
11319 mutex_exit(&cportinfo->cport_mutex);
11320 kmem_free(sdinfo, sizeof (sata_drive_info_t));
11321 return (SATA_SUCCESS);
11322 }
11323 /*
11324 * Since we are adding device, presumably new one,
11325 * indicate that it should be initalized,
11326 * as well as some internal framework states).
11327 */
11328 init_device = B_TRUE;
11329 }
11330 cportinfo->cport_dev_type = SATA_DTYPE_UNKNOWN;
11331 sata_device->satadev_addr.qual = sdinfo->satadrv_addr.qual;
11332 } else {
11333 /* Device change: Drive -> PMult */
11334 SATA_CPORTINFO_DRV_INFO(cportinfo) = NULL;
11335 if (sdinfo != NULL) {
11336 kmem_free(sdinfo, sizeof (sata_drive_info_t));
11337 sata_log(sata_hba_inst, CE_WARN,
11338 "SATA device detached "
11339 "from port %d", cportinfo->cport_addr.cport);
11340 }
11341
11342 sata_log(sata_hba_inst, CE_WARN,
11343 "SATA port multiplier detected at port %d",
11344 cportinfo->cport_addr.cport);
11345
11346 mutex_exit(&cportinfo->cport_mutex);
11347 if (sata_alloc_pmult(sata_hba_inst, sata_device) !=
11348 SATA_SUCCESS)
11349 return (SATA_FAILURE);
11350 sata_show_pmult_info(sata_hba_inst, sata_device);
11351 mutex_enter(&cportinfo->cport_mutex);
11352
11353 /*
11354 * Mark all the port multiplier port behind the port
11355 * multiplier behind with link events, so that the sata daemon
11356 * will update their status.
11357 */
11358 pmultinfo = SATA_PMULT_INFO(sata_hba_inst, cport);
11359 pmultinfo->pmult_event_flags |= SATA_EVNT_DEVICE_RESET;
11360 mutex_exit(&cportinfo->cport_mutex);
11361 return (SATA_SUCCESS);
11362 }
11363 mutex_exit(&cportinfo->cport_mutex);
11364
11365 /*
11366 * Figure out what kind of device we are really
11367 * dealing with. Failure of identifying device does not fail this
11368 * function.
11369 */
11370 rval_probe = sata_probe_device(sata_hba_inst, sata_device);
11371 rval_init = SATA_FAILURE;
11372 mutex_enter(&cportinfo->cport_mutex);
11373 if (rval_probe == SATA_SUCCESS) {
11374 /*
11375 * If we are dealing with the same type of a device as before,
11376 * restore its settings flags.
11377 */
11378 if (osdinfo != NULL &&
11379 sata_device->satadev_type == prev_device_type)
11380 sdinfo->satadrv_settings = prev_device_settings;
11381
11382 mutex_exit(&cportinfo->cport_mutex);
11383 rval_init = SATA_SUCCESS;
11384 /* Set initial device features, if necessary */
11385 if (init_device == B_TRUE) {
11386 rval_init = sata_initialize_device(sata_hba_inst,
11387 sdinfo);
11388 }
11389 if (rval_init == SATA_SUCCESS)
11390 return (rval_init);
11391 /* else we will retry if retry was asked for */
11392
11393 } else {
11394 /*
11395 * If there was some device info before we probe the device,
11396 * restore previous device setting, so we can retry from scratch
11397 * later. Providing, of course, that device has not disapear
11398 * during probing process.
11399 */
11400 if (sata_device->satadev_type != SATA_DTYPE_NONE) {
11401 if (osdinfo != NULL) {
11402 cportinfo->cport_dev_type = prev_device_type;
11403 sdinfo->satadrv_type = prev_device_type;
11404 sdinfo->satadrv_state = prev_device_state;
11405 }
11406 } else {
11407 /* device is gone */
11408 kmem_free(sdinfo, sizeof (sata_drive_info_t));
11409 cportinfo->cport_dev_type = SATA_DTYPE_NONE;
11410 SATA_CPORTINFO_DRV_INFO(cportinfo) = NULL;
11411 mutex_exit(&cportinfo->cport_mutex);
11412 return (SATA_SUCCESS);
11413 }
11414 mutex_exit(&cportinfo->cport_mutex);
11415 }
11416
11417 if (retry) {
11418 clock_t cur_time = ddi_get_lbolt();
11419 /*
11420 * A device was not successfully identified or initialized.
11421 * Track retry time for device identification.
11422 */
11423 if ((cur_time - start_time) <
11424 drv_usectohz(SATA_DEV_REPROBE_TIMEOUT)) {
11425 /* sleep for a while */
11426 delay(drv_usectohz(SATA_DEV_RETRY_DLY));
11427 goto retry_probe;
11428 }
11429 /* else no more retries */
11430 mutex_enter(&cportinfo->cport_mutex);
11431 if (SATA_CPORTINFO_DRV_INFO(cportinfo) != NULL) {
11432 if (rval_init == SATA_RETRY) {
11433 /*
11434 * Setting drive features have failed, but
11435 * because the drive is still accessible,
11436 * keep it and emit a warning message.
11437 */
11438 sata_log(sata_hba_inst, CE_WARN,
11439 "SATA device at port %d - desired "
11440 "drive features could not be set. "
11441 "Device may not operate as expected.",
11442 cportinfo->cport_addr.cport);
11443 } else {
11444 SATA_CPORTINFO_DRV_INFO(cportinfo)->
11445 satadrv_state = SATA_DSTATE_FAILED;
11446 }
11447 }
11448 mutex_exit(&cportinfo->cport_mutex);
11449 }
11450 return (SATA_SUCCESS);
11451 }
11452
11453 /*
11454 * Reprobe a controller port that connected to a port multiplier.
11455 *
11456 * NOTE: No Mutex should be hold.
11457 */
11458 static int
11459 sata_reprobe_pmult(sata_hba_inst_t *sata_hba_inst, sata_device_t *sata_device,
11460 int flag)
11461 {
11462 _NOTE(ARGUNUSED(flag))
11463 sata_cport_info_t *cportinfo;
11464 sata_pmult_info_t *pmultinfo;
11465 uint8_t cport = sata_device->satadev_addr.cport;
11466 int rval_probe;
11467
11468 cportinfo = SATA_CPORT_INFO(sata_hba_inst, cport);
11469 pmultinfo = SATA_PMULT_INFO(sata_hba_inst, cport);
11470
11471 /* probe port */
11472 mutex_enter(&cportinfo->cport_mutex);
11473 cportinfo->cport_state &= ~SATA_PORT_STATE_CLEAR_MASK;
11474 cportinfo->cport_state |= SATA_STATE_PROBING;
11475 mutex_exit(&cportinfo->cport_mutex);
11476
11477 rval_probe = (*SATA_PROBE_PORT_FUNC(sata_hba_inst))
11478 (SATA_DIP(sata_hba_inst), sata_device);
11479
11480 mutex_enter(&cportinfo->cport_mutex);
11481 if (rval_probe != SATA_SUCCESS) {
11482 cportinfo->cport_state = SATA_PSTATE_FAILED;
11483 SATA_LOG_D((sata_hba_inst, CE_WARN, "sata_reprobe_pmult: "
11484 "SATA port %d probing failed", cport));
11485 sata_log(sata_hba_inst, CE_WARN,
11486 "SATA port multiplier detached at port %d", cport);
11487 mutex_exit(&cportinfo->cport_mutex);
11488 sata_free_pmult(sata_hba_inst, sata_device);
11489 return (SATA_FAILURE);
11490 }
11491
11492 /*
11493 * update sata port state and set device type
11494 */
11495 sata_update_port_info(sata_hba_inst, sata_device);
11496 cportinfo->cport_state &= ~SATA_STATE_PROBING;
11497 cportinfo->cport_state |= SATA_STATE_PROBED;
11498
11499 /*
11500 * Sanity check - Port is active? Is the link active?
11501 * Is there any device attached?
11502 */
11503 if ((cportinfo->cport_state &
11504 (SATA_PSTATE_SHUTDOWN | SATA_PSTATE_FAILED)) ||
11505 (cportinfo->cport_scr.sstatus & SATA_PORT_DEVLINK_UP_MASK) !=
11506 SATA_PORT_DEVLINK_UP ||
11507 (sata_device->satadev_type == SATA_DTYPE_NONE)) {
11508 cportinfo->cport_dev_type = SATA_DTYPE_NONE;
11509 mutex_exit(&cportinfo->cport_mutex);
11510 sata_free_pmult(sata_hba_inst, sata_device);
11511 sata_log(sata_hba_inst, CE_WARN,
11512 "SATA port multiplier detached at port %d", cport);
11513 return (SATA_SUCCESS);
11514 }
11515
11516 /*
11517 * Device changed: PMult -> Non-PMult
11518 *
11519 * This situation is uncommon, most possibly being caused by errors
11520 * after which the port multiplier is not correct initialized and
11521 * recognized. In that case the new device will be marked as unknown
11522 * and will not be automatically probed in this routine. Instead
11523 * system administrator could manually restart it via cfgadm(1M).
11524 */
11525 if (sata_device->satadev_type != SATA_DTYPE_PMULT) {
11526 cportinfo->cport_dev_type = SATA_DTYPE_UNKNOWN;
11527 mutex_exit(&cportinfo->cport_mutex);
11528 sata_free_pmult(sata_hba_inst, sata_device);
11529 sata_log(sata_hba_inst, CE_WARN,
11530 "SATA port multiplier detached at port %d", cport);
11531 return (SATA_FAILURE);
11532 }
11533
11534 /*
11535 * Now we know it is a port multiplier. However, if this is not the
11536 * previously attached port multiplier - they may have different
11537 * pmport numbers - we need to re-allocate data structures for every
11538 * pmport and drive.
11539 *
11540 * Port multipliers of the same model have identical values in these
11541 * registers, so it is still necessary to update the information of
11542 * all drives attached to the previous port multiplier afterwards.
11543 */
11544 /* Device changed: PMult -> another PMult */
11545 mutex_exit(&cportinfo->cport_mutex);
11546 sata_free_pmult(sata_hba_inst, sata_device);
11547 if (sata_alloc_pmult(sata_hba_inst, sata_device) != SATA_SUCCESS)
11548 return (SATA_FAILURE);
11549 mutex_enter(&cportinfo->cport_mutex);
11550
11551 SATADBG1(SATA_DBG_PMULT, sata_hba_inst,
11552 "SATA port multiplier [changed] at port %d", cport);
11553 sata_log(sata_hba_inst, CE_WARN,
11554 "SATA port multiplier detected at port %d", cport);
11555
11556 /*
11557 * Mark all the port multiplier port behind the port
11558 * multiplier behind with link events, so that the sata daemon
11559 * will update their status.
11560 */
11561 pmultinfo->pmult_event_flags |= SATA_EVNT_DEVICE_RESET;
11562 mutex_exit(&cportinfo->cport_mutex);
11563
11564 return (SATA_SUCCESS);
11565 }
11566
11567 /*
11568 * Re-probe a port multiplier port, check for a device and attach info
11569 * structures when necessary. Identify Device data is fetched, if possible.
11570 * Assumption: sata address is already validated as port multiplier port.
11571 * SATA_SUCCESS is returned if port is re-probed sucessfully, regardless of
11572 * the presence of a device and its type.
11573 *
11574 * flag arg specifies that the function should try multiple times to identify
11575 * device type and to initialize it, or it should return immediately on failure.
11576 * SATA_DEV_IDENTIFY_RETRY - retry
11577 * SATA_DEV_IDENTIFY_NORETRY - no retry
11578 *
11579 * SATA_FAILURE is returned if one of the operations failed.
11580 *
11581 * This function cannot be called in interrupt context - it may sleep.
11582 *
11583 * NOTE: Should be only called by sata_probe_port() in case target port is a
11584 * port multiplier port.
11585 * NOTE: No Mutex should be hold.
11586 */
11587 static int
11588 sata_reprobe_pmport(sata_hba_inst_t *sata_hba_inst, sata_device_t *sata_device,
11589 int flag)
11590 {
11591 sata_cport_info_t *cportinfo = NULL;
11592 sata_pmport_info_t *pmportinfo = NULL;
11593 sata_drive_info_t *sdinfo, *osdinfo;
11594 sata_device_t sdevice;
11595 boolean_t init_device = B_FALSE;
11596 int prev_device_type = SATA_DTYPE_NONE;
11597 int prev_device_settings = 0;
11598 int prev_device_state = 0;
11599 clock_t start_time;
11600 uint8_t cport = sata_device->satadev_addr.cport;
11601 uint8_t pmport = sata_device->satadev_addr.pmport;
11602 int rval;
11603
11604 cportinfo = SATA_CPORT_INFO(sata_hba_inst, cport);
11605 pmportinfo = SATA_PMPORT_INFO(sata_hba_inst, cport, pmport);
11606 osdinfo = SATA_PMPORTINFO_DRV_INFO(pmportinfo);
11607
11608 if (osdinfo != NULL) {
11609 /*
11610 * We are re-probing port with a previously attached device.
11611 * Save previous device type and settings.
11612 */
11613 prev_device_type = pmportinfo->pmport_dev_type;
11614 prev_device_settings = osdinfo->satadrv_settings;
11615 prev_device_state = osdinfo->satadrv_state;
11616 }
11617
11618 start_time = ddi_get_lbolt();
11619
11620 /* check parent status */
11621 mutex_enter(&cportinfo->cport_mutex);
11622 if ((cportinfo->cport_state &
11623 (SATA_PSTATE_SHUTDOWN | SATA_PSTATE_FAILED)) ||
11624 (cportinfo->cport_scr.sstatus & SATA_PORT_DEVLINK_UP_MASK) !=
11625 SATA_PORT_DEVLINK_UP) {
11626 mutex_exit(&cportinfo->cport_mutex);
11627 return (SATA_FAILURE);
11628 }
11629 mutex_exit(&cportinfo->cport_mutex);
11630
11631 retry_probe_pmport:
11632
11633 /* probe port */
11634 mutex_enter(&pmportinfo->pmport_mutex);
11635 pmportinfo->pmport_state &= ~SATA_PORT_STATE_CLEAR_MASK;
11636 pmportinfo->pmport_state |= SATA_STATE_PROBING;
11637 mutex_exit(&pmportinfo->pmport_mutex);
11638
11639 rval = (*SATA_PROBE_PORT_FUNC(sata_hba_inst))
11640 (SATA_DIP(sata_hba_inst), sata_device);
11641
11642 /* might need retry because we cannot touch registers. */
11643 if (rval == SATA_FAILURE) {
11644 mutex_enter(&pmportinfo->pmport_mutex);
11645 pmportinfo->pmport_state = SATA_PSTATE_FAILED;
11646 mutex_exit(&pmportinfo->pmport_mutex);
11647 SATA_LOG_D((sata_hba_inst, CE_WARN, "sata_reprobe_pmport: "
11648 "SATA port %d:%d probing failed",
11649 cport, pmport));
11650 return (SATA_FAILURE);
11651 } else if (rval == SATA_RETRY) {
11652 SATA_LOG_D((sata_hba_inst, CE_WARN, "sata_reprobe_pmport: "
11653 "SATA port %d:%d probing failed, retrying...",
11654 cport, pmport));
11655 clock_t cur_time = ddi_get_lbolt();
11656 /*
11657 * A device was not successfully identified or initialized.
11658 * Track retry time for device identification.
11659 */
11660 if ((cur_time - start_time) <
11661 drv_usectohz(SATA_DEV_REPROBE_TIMEOUT)) {
11662 /* sleep for a while */
11663 delay(drv_usectohz(SATA_DEV_RETRY_DLY));
11664 goto retry_probe_pmport;
11665 } else {
11666 mutex_enter(&pmportinfo->pmport_mutex);
11667 if (SATA_PMPORTINFO_DRV_INFO(pmportinfo) != NULL)
11668 SATA_PMPORTINFO_DRV_INFO(pmportinfo)->
11669 satadrv_state = SATA_DSTATE_FAILED;
11670 mutex_exit(&pmportinfo->pmport_mutex);
11671 return (SATA_SUCCESS);
11672 }
11673 }
11674
11675 /*
11676 * Sanity check - Controller port is active? Is the link active?
11677 * Is it still a port multiplier?
11678 */
11679 if ((cportinfo->cport_state &
11680 (SATA_PSTATE_SHUTDOWN | SATA_PSTATE_FAILED)) ||
11681 (cportinfo->cport_scr.sstatus & SATA_PORT_DEVLINK_UP_MASK) !=
11682 SATA_PORT_DEVLINK_UP ||
11683 (cportinfo->cport_dev_type != SATA_DTYPE_PMULT)) {
11684 /*
11685 * Port in non-usable state or no link active/no
11686 * device. Free info structure.
11687 */
11688 cportinfo->cport_dev_type = SATA_DTYPE_UNKNOWN;
11689
11690 sdevice.satadev_addr.cport = cport;
11691 sdevice.satadev_addr.pmport = pmport;
11692 sdevice.satadev_addr.qual = SATA_ADDR_PMULT;
11693 mutex_exit(&cportinfo->cport_mutex);
11694
11695 sata_free_pmult(sata_hba_inst, &sdevice);
11696 return (SATA_FAILURE);
11697 }
11698
11699 /* SATA_SUCCESS NOW */
11700 /*
11701 * update sata port state and set device type
11702 */
11703 mutex_enter(&pmportinfo->pmport_mutex);
11704 sata_update_pmport_info(sata_hba_inst, sata_device);
11705 pmportinfo->pmport_state &= ~SATA_STATE_PROBING;
11706
11707 /*
11708 * Sanity check - Port is active? Is the link active?
11709 * Is there any device attached?
11710 */
11711 if ((pmportinfo->pmport_state &
11712 (SATA_PSTATE_SHUTDOWN | SATA_PSTATE_FAILED)) ||
11713 (pmportinfo->pmport_scr.sstatus & SATA_PORT_DEVLINK_UP_MASK) !=
11714 SATA_PORT_DEVLINK_UP) {
11715 /*
11716 * Port in non-usable state or no link active/no device.
11717 * Free info structure if necessary (direct attached drive
11718 * only, for now!
11719 */
11720 sdinfo = SATA_PMPORTINFO_DRV_INFO(pmportinfo);
11721 SATA_PMPORTINFO_DRV_INFO(pmportinfo) = NULL;
11722 /* Add here differentiation for device attached or not */
11723 pmportinfo->pmport_dev_type = SATA_DTYPE_NONE;
11724 mutex_exit(&pmportinfo->pmport_mutex);
11725 if (sdinfo != NULL)
11726 kmem_free(sdinfo, sizeof (sata_drive_info_t));
11727 return (SATA_SUCCESS);
11728 }
11729
11730 pmportinfo->pmport_state |= SATA_STATE_READY;
11731 pmportinfo->pmport_dev_type = sata_device->satadev_type;
11732 sdinfo = SATA_PMPORTINFO_DRV_INFO(pmportinfo);
11733
11734 /*
11735 * If we are re-probing the port, there may be
11736 * sata_drive_info structure attached
11737 * (or sata_pm_info, if PMult is supported).
11738 */
11739 if (sata_device->satadev_type == SATA_DTYPE_NONE) {
11740 /*
11741 * There is no device, so remove device info structure,
11742 * if necessary.
11743 */
11744 SATA_PMPORTINFO_DRV_INFO(pmportinfo) = NULL;
11745 pmportinfo->pmport_dev_type = SATA_DTYPE_NONE;
11746 if (sdinfo != NULL) {
11747 kmem_free(sdinfo, sizeof (sata_drive_info_t));
11748 sata_log(sata_hba_inst, CE_WARN,
11749 "SATA device detached from port %d:%d",
11750 cport, pmport);
11751 }
11752 mutex_exit(&pmportinfo->pmport_mutex);
11753 return (SATA_SUCCESS);
11754 }
11755
11756 /* this should not be a pmult */
11757 ASSERT(sata_device->satadev_type != SATA_DTYPE_PMULT);
11758 if (sdinfo == NULL) {
11759 /*
11760 * There is some device attached, but there is
11761 * no sata_drive_info structure - allocate one
11762 */
11763 mutex_exit(&pmportinfo->pmport_mutex);
11764 sdinfo = kmem_zalloc(sizeof (sata_drive_info_t),
11765 KM_SLEEP);
11766 mutex_enter(&pmportinfo->pmport_mutex);
11767 /*
11768 * Recheck, that the port state did not change when we
11769 * released mutex.
11770 */
11771 if (pmportinfo->pmport_state & SATA_STATE_READY) {
11772 SATA_PMPORTINFO_DRV_INFO(pmportinfo) = sdinfo;
11773 sdinfo->satadrv_addr = pmportinfo->pmport_addr;
11774 sdinfo->satadrv_addr.qual = SATA_ADDR_DPMPORT;
11775 sdinfo->satadrv_type = SATA_DTYPE_UNKNOWN;
11776 sdinfo->satadrv_state = SATA_STATE_UNKNOWN;
11777 } else {
11778 /*
11779 * Port is not in ready state, we
11780 * cannot attach a device.
11781 */
11782 mutex_exit(&pmportinfo->pmport_mutex);
11783 kmem_free(sdinfo, sizeof (sata_drive_info_t));
11784 return (SATA_SUCCESS);
11785 }
11786 /*
11787 * Since we are adding device, presumably new one,
11788 * indicate that it should be initalized,
11789 * as well as some internal framework states).
11790 */
11791 init_device = B_TRUE;
11792 }
11793
11794 pmportinfo->pmport_dev_type = SATA_DTYPE_UNKNOWN;
11795 sata_device->satadev_addr.qual = sdinfo->satadrv_addr.qual;
11796
11797 mutex_exit(&pmportinfo->pmport_mutex);
11798 /*
11799 * Figure out what kind of device we are really
11800 * dealing with.
11801 */
11802 rval = sata_probe_device(sata_hba_inst, sata_device);
11803
11804 mutex_enter(&pmportinfo->pmport_mutex);
11805 if (rval == SATA_SUCCESS) {
11806 /*
11807 * If we are dealing with the same type of a device as before,
11808 * restore its settings flags.
11809 */
11810 if (osdinfo != NULL &&
11811 sata_device->satadev_type == prev_device_type)
11812 sdinfo->satadrv_settings = prev_device_settings;
11813
11814 mutex_exit(&pmportinfo->pmport_mutex);
11815 /* Set initial device features, if necessary */
11816 if (init_device == B_TRUE) {
11817 rval = sata_initialize_device(sata_hba_inst, sdinfo);
11818 }
11819 if (rval == SATA_SUCCESS)
11820 return (rval);
11821 } else {
11822 /*
11823 * If there was some device info before we probe the device,
11824 * restore previous device setting, so we can retry from scratch
11825 * later. Providing, of course, that device has not disappeared
11826 * during probing process.
11827 */
11828 if (sata_device->satadev_type != SATA_DTYPE_NONE) {
11829 if (osdinfo != NULL) {
11830 pmportinfo->pmport_dev_type = prev_device_type;
11831 sdinfo->satadrv_type = prev_device_type;
11832 sdinfo->satadrv_state = prev_device_state;
11833 }
11834 } else {
11835 /* device is gone */
11836 kmem_free(sdinfo, sizeof (sata_drive_info_t));
11837 pmportinfo->pmport_dev_type = SATA_DTYPE_NONE;
11838 SATA_PMPORTINFO_DRV_INFO(pmportinfo) = NULL;
11839 mutex_exit(&pmportinfo->pmport_mutex);
11840 return (SATA_SUCCESS);
11841 }
11842 mutex_exit(&pmportinfo->pmport_mutex);
11843 }
11844
11845 if (flag == SATA_DEV_IDENTIFY_RETRY) {
11846 clock_t cur_time = ddi_get_lbolt();
11847 /*
11848 * A device was not successfully identified or initialized.
11849 * Track retry time for device identification.
11850 */
11851 if ((cur_time - start_time) <
11852 drv_usectohz(SATA_DEV_REPROBE_TIMEOUT)) {
11853 /* sleep for a while */
11854 delay(drv_usectohz(SATA_DEV_RETRY_DLY));
11855 goto retry_probe_pmport;
11856 } else {
11857 mutex_enter(&pmportinfo->pmport_mutex);
11858 if (SATA_PMPORTINFO_DRV_INFO(pmportinfo) != NULL)
11859 SATA_PMPORTINFO_DRV_INFO(pmportinfo)->
11860 satadrv_state = SATA_DSTATE_FAILED;
11861 mutex_exit(&pmportinfo->pmport_mutex);
11862 }
11863 }
11864 return (SATA_SUCCESS);
11865 }
11866
11867 /*
11868 * Allocated related structure for a port multiplier and its device ports
11869 *
11870 * Port multiplier should be ready and probed, and related information like
11871 * the number of the device ports should be store in sata_device_t.
11872 *
11873 * NOTE: No Mutex should be hold.
11874 */
11875 static int
11876 sata_alloc_pmult(sata_hba_inst_t *sata_hba_inst, sata_device_t *sata_device)
11877 {
11878 dev_info_t *dip = SATA_DIP(sata_hba_inst);
11879 sata_cport_info_t *cportinfo = NULL;
11880 sata_pmult_info_t *pmultinfo = NULL;
11881 sata_pmport_info_t *pmportinfo = NULL;
11882 sata_device_t sd;
11883 dev_t minor_number;
11884 char name[16];
11885 uint8_t cport = sata_device->satadev_addr.cport;
11886 int rval;
11887 int npmport;
11888
11889 cportinfo = SATA_CPORT_INFO(sata_hba_inst, cport);
11890
11891 /* This function might be called while a port-mult is hot-plugged. */
11892 mutex_enter(&cportinfo->cport_mutex);
11893
11894 /* dev_type's not updated when get called from sata_reprobe_port() */
11895 if (SATA_CPORTINFO_PMULT_INFO(cportinfo) == NULL) {
11896 /* Create a pmult_info structure */
11897 SATA_CPORTINFO_PMULT_INFO(cportinfo) =
11898 kmem_zalloc(sizeof (sata_pmult_info_t), KM_SLEEP);
11899 }
11900 pmultinfo = SATA_CPORTINFO_PMULT_INFO(cportinfo);
11901
11902 pmultinfo->pmult_addr = sata_device->satadev_addr;
11903 pmultinfo->pmult_addr.qual = SATA_ADDR_PMULT;
11904 pmultinfo->pmult_state = SATA_STATE_PROBING;
11905
11906 /*
11907 * Probe the port multiplier with qualifier SATA_ADDR_PMULT_SPEC,
11908 * The HBA driver should initialize and register the port multiplier,
11909 * sata_register_pmult() will fill following fields,
11910 * + sata_pmult_info.pmult_gscr
11911 * + sata_pmult_info.pmult_num_dev_ports
11912 */
11913 sd.satadev_addr = sata_device->satadev_addr;
11914 sd.satadev_addr.qual = SATA_ADDR_PMULT_SPEC;
11915 mutex_exit(&cportinfo->cport_mutex);
11916 rval = (*SATA_PROBE_PORT_FUNC(sata_hba_inst))
11917 (SATA_DIP(sata_hba_inst), &sd);
11918 mutex_enter(&cportinfo->cport_mutex);
11919
11920 if (rval != SATA_SUCCESS ||
11921 (sd.satadev_type != SATA_DTYPE_PMULT) ||
11922 !(sd.satadev_state & SATA_DSTATE_PMULT_INIT)) {
11923 SATA_CPORTINFO_PMULT_INFO(cportinfo) = NULL;
11924 kmem_free(pmultinfo, sizeof (sata_pmult_info_t));
11925 cportinfo->cport_state = SATA_PSTATE_FAILED;
11926 cportinfo->cport_dev_type = SATA_DTYPE_UNKNOWN;
11927 mutex_exit(&cportinfo->cport_mutex);
11928 SATADBG1(SATA_DBG_PMULT, sata_hba_inst,
11929 "sata_alloc_pmult: failed to initialize pmult "
11930 "at port %d.", cport)
11931 return (SATA_FAILURE);
11932 }
11933
11934 /* Initialize pmport_info structure */
11935 for (npmport = 0; npmport < pmultinfo->pmult_num_dev_ports;
11936 npmport++) {
11937
11938 /* if everything is allocated, skip */
11939 if (SATA_PMPORT_INFO(sata_hba_inst, cport, npmport) != NULL)
11940 continue;
11941
11942 pmportinfo = kmem_zalloc(sizeof (sata_pmport_info_t), KM_SLEEP);
11943 mutex_init(&pmportinfo->pmport_mutex, NULL, MUTEX_DRIVER, NULL);
11944 mutex_exit(&cportinfo->cport_mutex);
11945
11946 mutex_enter(&pmportinfo->pmport_mutex);
11947 pmportinfo->pmport_addr.cport = cport;
11948 pmportinfo->pmport_addr.pmport = (uint8_t)npmport;
11949 pmportinfo->pmport_addr.qual = SATA_ADDR_PMPORT;
11950 pmportinfo->pmport_state &= ~SATA_PORT_STATE_CLEAR_MASK;
11951 mutex_exit(&pmportinfo->pmport_mutex);
11952
11953 mutex_enter(&cportinfo->cport_mutex);
11954 SATA_PMPORT_INFO(sata_hba_inst, cport, npmport) = pmportinfo;
11955
11956 /* Create an attachment point */
11957 minor_number = SATA_MAKE_AP_MINOR(ddi_get_instance(dip),
11958 cport, (uint8_t)npmport, SATA_ADDR_PMPORT);
11959 (void) sprintf(name, "%d.%d", cport, npmport);
11960
11961 if (ddi_create_minor_node(dip, name, S_IFCHR, minor_number,
11962 DDI_NT_SATA_ATTACHMENT_POINT, 0) != DDI_SUCCESS) {
11963 sata_log(sata_hba_inst, CE_WARN, "sata_hba_attach: "
11964 "cannot create SATA attachment point for "
11965 "port %d:%d", cport, npmport);
11966 }
11967 }
11968
11969 pmultinfo->pmult_state &= ~SATA_STATE_PROBING;
11970 pmultinfo->pmult_state |= (SATA_STATE_PROBED|SATA_STATE_READY);
11971 cportinfo->cport_dev_type = SATA_DTYPE_PMULT;
11972
11973 mutex_exit(&cportinfo->cport_mutex);
11974 return (SATA_SUCCESS);
11975 }
11976
11977 /*
11978 * Free data structures when a port multiplier is removed.
11979 *
11980 * NOTE: No Mutex should be hold.
11981 */
11982 static void
11983 sata_free_pmult(sata_hba_inst_t *sata_hba_inst, sata_device_t *sata_device)
11984 {
11985 sata_cport_info_t *cportinfo;
11986 sata_pmult_info_t *pmultinfo;
11987 sata_pmport_info_t *pmportinfo;
11988 sata_device_t pmport_device;
11989 sata_drive_info_t *sdinfo;
11990 dev_info_t *tdip;
11991 char name[16];
11992 uint8_t cport = sata_device->satadev_addr.cport;
11993 int npmport;
11994
11995 cportinfo = SATA_CPORT_INFO(sata_hba_inst, cport);
11996
11997 /* This function might be called while port-mult is hot plugged. */
11998 mutex_enter(&cportinfo->cport_mutex);
11999
12000 cportinfo->cport_dev_type = SATA_DTYPE_NONE;
12001 pmultinfo = SATA_CPORTINFO_PMULT_INFO(cportinfo);
12002 ASSERT(pmultinfo != NULL);
12003
12004 /* Free pmport_info structure */
12005 for (npmport = 0; npmport < pmultinfo->pmult_num_dev_ports;
12006 npmport++) {
12007 pmportinfo = SATA_PMPORT_INFO(sata_hba_inst, cport, npmport);
12008 if (pmportinfo == NULL)
12009 continue;
12010 mutex_exit(&cportinfo->cport_mutex);
12011
12012 mutex_enter(&pmportinfo->pmport_mutex);
12013 sdinfo = pmportinfo->pmport_sata_drive;
12014 SATA_PMPORTINFO_DRV_INFO(pmportinfo) = NULL;
12015 mutex_exit(&pmportinfo->pmport_mutex);
12016
12017 /* Remove attachment point. */
12018 name[0] = '\0';
12019 (void) sprintf(name, "%d.%d", cport, npmport);
12020 ddi_remove_minor_node(SATA_DIP(sata_hba_inst), name);
12021 sata_log(sata_hba_inst, CE_NOTE,
12022 "Remove attachment point of port %d:%d",
12023 cport, npmport);
12024
12025 /*
12026 * Rumove target node
12027 */
12028 bzero(&pmport_device, sizeof (sata_device_t));
12029 pmport_device.satadev_rev = SATA_DEVICE_REV;
12030 pmport_device.satadev_addr.cport = cport;
12031 pmport_device.satadev_addr.pmport = (uint8_t)npmport;
12032 pmport_device.satadev_addr.qual = SATA_ADDR_DPMPORT;
12033
12034 tdip = sata_get_scsi_target_dip(SATA_DIP(sata_hba_inst),
12035 &(pmport_device.satadev_addr));
12036 if (tdip != NULL && ndi_devi_offline(tdip,
12037 NDI_DEVI_REMOVE) != NDI_SUCCESS) {
12038 /*
12039 * Problem :
12040 * The target node remained attached.
12041 * This happens when the device file was open
12042 * or a node was waiting for resources.
12043 * Cannot do anything about it.
12044 */
12045 SATA_LOG_D((sata_hba_inst, CE_WARN,
12046 "sata_free_pmult: could not unconfigure device "
12047 "before disconnecting the SATA port %d:%d",
12048 cport, npmport));
12049
12050 /*
12051 * Set DEVICE REMOVED state in the target
12052 * node. It will prevent access to the device
12053 * even when a new device is attached, until
12054 * the old target node is released, removed and
12055 * recreated for a new device.
12056 */
12057 sata_set_device_removed(tdip);
12058
12059 /*
12060 * Instruct event daemon to try the target
12061 * node cleanup later.
12062 */
12063 sata_set_target_node_cleanup(
12064 sata_hba_inst, &(pmport_device.satadev_addr));
12065
12066 }
12067 mutex_enter(&cportinfo->cport_mutex);
12068
12069 /*
12070 * Add here differentiation for device attached or not
12071 */
12072 if (sdinfo != NULL) {
12073 sata_log(sata_hba_inst, CE_WARN,
12074 "SATA device detached from port %d:%d",
12075 cport, npmport);
12076 kmem_free(sdinfo, sizeof (sata_drive_info_t));
12077 }
12078
12079 mutex_destroy(&pmportinfo->pmport_mutex);
12080 kmem_free(pmportinfo, sizeof (sata_pmport_info_t));
12081 }
12082
12083 kmem_free(pmultinfo, sizeof (sata_pmult_info_t));
12084
12085 cportinfo->cport_devp.cport_sata_pmult = NULL;
12086
12087 sata_log(sata_hba_inst, CE_WARN,
12088 "SATA port multiplier detached at port %d", cport);
12089
12090 mutex_exit(&cportinfo->cport_mutex);
12091 }
12092
12093 /*
12094 * Initialize device
12095 * Specified device is initialized to a default state.
12096 *
12097 * Returns SATA_SUCCESS if all device features are set successfully,
12098 * SATA_RETRY if device is accessible but device features were not set
12099 * successfully, and SATA_FAILURE otherwise.
12100 */
12101 static int
12102 sata_initialize_device(sata_hba_inst_t *sata_hba_inst,
12103 sata_drive_info_t *sdinfo)
12104 {
12105 int rval;
12106
12107 sata_save_drive_settings(sdinfo);
12108
12109 sdinfo->satadrv_settings |= SATA_DEV_READ_AHEAD;
12110
12111 sata_init_write_cache_mode(sdinfo);
12112
12113 rval = sata_set_drive_features(sata_hba_inst, sdinfo, 0);
12114
12115 /* Determine current data transfer mode */
12116 if ((sdinfo->satadrv_id.ai_cap & SATA_DMA_SUPPORT) == 0) {
12117 sdinfo->satadrv_settings &= ~SATA_DEV_DMA;
12118 } else if ((sdinfo->satadrv_id.ai_validinfo &
12119 SATA_VALIDINFO_88) != 0 &&
12120 (sdinfo->satadrv_id.ai_ultradma & SATA_UDMA_SEL_MASK) != 0) {
12121 sdinfo->satadrv_settings |= SATA_DEV_DMA;
12122 } else if ((sdinfo->satadrv_id.ai_dworddma &
12123 SATA_MDMA_SEL_MASK) != 0) {
12124 sdinfo->satadrv_settings |= SATA_DEV_DMA;
12125 } else
12126 /* DMA supported, not no DMA transfer mode is selected !? */
12127 sdinfo->satadrv_settings &= ~SATA_DEV_DMA;
12128
12129 if ((sdinfo->satadrv_id.ai_cmdset83 & 0x20) &&
12130 (sdinfo->satadrv_id.ai_features86 & 0x20))
12131 sdinfo->satadrv_power_level = SATA_POWER_STANDBY;
12132 else
12133 sdinfo->satadrv_power_level = SATA_POWER_ACTIVE;
12134
12135 return (rval);
12136 }
12137
12138
12139 /*
12140 * Initialize write cache mode.
12141 *
12142 * The default write cache setting for SATA HDD is provided by sata_write_cache
12143 * static variable. ATAPI CD/DVDs devices have write cache default is
12144 * determined by sata_atapicdvd_write_cache static variable.
12145 * ATAPI tape devices have write cache default is determined by
12146 * sata_atapitape_write_cache static variable.
12147 * ATAPI disk devices have write cache default is determined by
12148 * sata_atapidisk_write_cache static variable.
12149 * 1 - enable
12150 * 0 - disable
12151 * any other value - current drive setting
12152 *
12153 * Although there is not reason to disable write cache on CD/DVD devices,
12154 * tape devices and ATAPI disk devices, the default setting control is provided
12155 * for the maximun flexibility.
12156 *
12157 * In the future, it may be overridden by the
12158 * disk-write-cache-enable property setting, if it is defined.
12159 * Returns SATA_SUCCESS if all device features are set successfully,
12160 * SATA_FAILURE otherwise.
12161 */
12162 static void
12163 sata_init_write_cache_mode(sata_drive_info_t *sdinfo)
12164 {
12165 switch (sdinfo->satadrv_type) {
12166 case SATA_DTYPE_ATADISK:
12167 if (sata_write_cache == 1)
12168 sdinfo->satadrv_settings |= SATA_DEV_WRITE_CACHE;
12169 else if (sata_write_cache == 0)
12170 sdinfo->satadrv_settings &= ~SATA_DEV_WRITE_CACHE;
12171 /*
12172 * When sata_write_cache value is not 0 or 1,
12173 * a current setting of the drive's write cache is used.
12174 */
12175 break;
12176 case SATA_DTYPE_ATAPICD:
12177 if (sata_atapicdvd_write_cache == 1)
12178 sdinfo->satadrv_settings |= SATA_DEV_WRITE_CACHE;
12179 else if (sata_atapicdvd_write_cache == 0)
12180 sdinfo->satadrv_settings &= ~SATA_DEV_WRITE_CACHE;
12181 /*
12182 * When sata_atapicdvd_write_cache value is not 0 or 1,
12183 * a current setting of the drive's write cache is used.
12184 */
12185 break;
12186 case SATA_DTYPE_ATAPITAPE:
12187 if (sata_atapitape_write_cache == 1)
12188 sdinfo->satadrv_settings |= SATA_DEV_WRITE_CACHE;
12189 else if (sata_atapitape_write_cache == 0)
12190 sdinfo->satadrv_settings &= ~SATA_DEV_WRITE_CACHE;
12191 /*
12192 * When sata_atapitape_write_cache value is not 0 or 1,
12193 * a current setting of the drive's write cache is used.
12194 */
12195 break;
12196 case SATA_DTYPE_ATAPIDISK:
12197 if (sata_atapidisk_write_cache == 1)
12198 sdinfo->satadrv_settings |= SATA_DEV_WRITE_CACHE;
12199 else if (sata_atapidisk_write_cache == 0)
12200 sdinfo->satadrv_settings &= ~SATA_DEV_WRITE_CACHE;
12201 /*
12202 * When sata_atapidisk_write_cache value is not 0 or 1,
12203 * a current setting of the drive's write cache is used.
12204 */
12205 break;
12206 }
12207 }
12208
12209
12210 /*
12211 * Validate sata address.
12212 * Specified cport, pmport and qualifier has to match
12213 * passed sata_scsi configuration info.
12214 * The presence of an attached device is not verified.
12215 *
12216 * Returns 0 when address is valid, -1 otherwise.
12217 */
12218 static int
12219 sata_validate_sata_address(sata_hba_inst_t *sata_hba_inst, int cport,
12220 int pmport, int qual)
12221 {
12222 if (qual == SATA_ADDR_DCPORT && pmport != 0)
12223 goto invalid_address;
12224 if (cport >= SATA_NUM_CPORTS(sata_hba_inst))
12225 goto invalid_address;
12226 if ((qual == SATA_ADDR_DPMPORT || qual == SATA_ADDR_PMPORT) &&
12227 ((SATA_CPORT_DEV_TYPE(sata_hba_inst, cport) != SATA_DTYPE_PMULT) ||
12228 (SATA_PMULT_INFO(sata_hba_inst, cport) == NULL) ||
12229 (pmport >= SATA_NUM_PMPORTS(sata_hba_inst, cport))))
12230 goto invalid_address;
12231
12232 return (0);
12233
12234 invalid_address:
12235 return (-1);
12236
12237 }
12238
12239 /*
12240 * Validate scsi address
12241 * SCSI target address is translated into SATA cport/pmport and compared
12242 * with a controller port/device configuration. LUN has to be 0.
12243 * Returns 0 if a scsi target refers to an attached device,
12244 * returns 1 if address is valid but no valid device is attached,
12245 * returns 2 if address is valid but device type is unknown (not valid device),
12246 * returns -1 if bad address or device is of an unsupported type.
12247 * Upon return sata_device argument is set.
12248 *
12249 * Port multiplier is supported now.
12250 */
12251 static int
12252 sata_validate_scsi_address(sata_hba_inst_t *sata_hba_inst,
12253 struct scsi_address *ap, sata_device_t *sata_device)
12254 {
12255 int cport, pmport, qual, rval;
12256
12257 rval = -1; /* Invalid address */
12258 if (ap->a_lun != 0)
12259 goto out;
12260
12261 qual = SCSI_TO_SATA_ADDR_QUAL(ap->a_target);
12262 cport = SCSI_TO_SATA_CPORT(ap->a_target);
12263 pmport = SCSI_TO_SATA_PMPORT(ap->a_target);
12264
12265 if (qual != SATA_ADDR_DCPORT && qual != SATA_ADDR_DPMPORT)
12266 goto out;
12267
12268 if (sata_validate_sata_address(sata_hba_inst, cport, pmport, qual) ==
12269 0) {
12270
12271 sata_cport_info_t *cportinfo;
12272 sata_pmult_info_t *pmultinfo;
12273 sata_drive_info_t *sdinfo = NULL;
12274
12275 sata_device->satadev_addr.qual = qual;
12276 sata_device->satadev_addr.cport = cport;
12277 sata_device->satadev_addr.pmport = pmport;
12278 sata_device->satadev_rev = SATA_DEVICE_REV_1;
12279
12280 rval = 1; /* Valid sata address */
12281
12282 cportinfo = SATA_CPORT_INFO(sata_hba_inst, cport);
12283 if (qual == SATA_ADDR_DCPORT) {
12284 if (cportinfo == NULL ||
12285 cportinfo->cport_dev_type == SATA_DTYPE_NONE)
12286 goto out;
12287
12288 sdinfo = SATA_CPORTINFO_DRV_INFO(cportinfo);
12289 if (cportinfo->cport_dev_type == SATA_DTYPE_UNKNOWN &&
12290 sdinfo != NULL) {
12291 rval = 2;
12292 goto out;
12293 }
12294
12295 if ((cportinfo->cport_dev_type &
12296 SATA_VALID_DEV_TYPE) == 0) {
12297 rval = -1;
12298 goto out;
12299 }
12300
12301 } else if (qual == SATA_ADDR_DPMPORT) {
12302 pmultinfo = SATA_CPORTINFO_PMULT_INFO(cportinfo);
12303 if (pmultinfo == NULL) {
12304 rval = -1;
12305 goto out;
12306 }
12307 if (SATA_PMPORT_INFO(sata_hba_inst, cport, pmport) ==
12308 NULL ||
12309 SATA_PMPORT_DEV_TYPE(sata_hba_inst, cport,
12310 pmport) == SATA_DTYPE_NONE)
12311 goto out;
12312
12313 sdinfo = SATA_PMPORT_DRV_INFO(sata_hba_inst, cport,
12314 pmport);
12315 if (SATA_PMPORT_DEV_TYPE(sata_hba_inst, cport,
12316 pmport) == SATA_DTYPE_UNKNOWN && sdinfo != NULL) {
12317 rval = 2;
12318 goto out;
12319 }
12320
12321 if ((SATA_PMPORT_DEV_TYPE(sata_hba_inst, cport,
12322 pmport) & SATA_VALID_DEV_TYPE) == 0) {
12323 rval = -1;
12324 goto out;
12325 }
12326
12327 } else {
12328 rval = -1;
12329 goto out;
12330 }
12331 if ((sdinfo == NULL) ||
12332 (sdinfo->satadrv_type & SATA_VALID_DEV_TYPE) == 0)
12333 goto out;
12334
12335 sata_device->satadev_type = sdinfo->satadrv_type;
12336
12337 return (0);
12338 }
12339 out:
12340 if (rval > 0) {
12341 SATADBG2(SATA_DBG_SCSI_IF, sata_hba_inst,
12342 "sata_validate_scsi_address: no valid target %x lun %x",
12343 ap->a_target, ap->a_lun);
12344 }
12345 return (rval);
12346 }
12347
12348 /*
12349 * Find dip corresponding to passed device number
12350 *
12351 * Returns NULL if invalid device number is passed or device cannot be found,
12352 * Returns dip is device is found.
12353 */
12354 static dev_info_t *
12355 sata_devt_to_devinfo(dev_t dev)
12356 {
12357 dev_info_t *dip;
12358 #ifndef __lock_lint
12359 struct devnames *dnp;
12360 major_t major = getmajor(dev);
12361 int instance = SATA_MINOR2INSTANCE(getminor(dev));
12362
12363 if (major >= devcnt)
12364 return (NULL);
12365
12366 dnp = &devnamesp[major];
12367 LOCK_DEV_OPS(&(dnp->dn_lock));
12368 dip = dnp->dn_head;
12369 while (dip && (ddi_get_instance(dip) != instance)) {
12370 dip = ddi_get_next(dip);
12371 }
12372 UNLOCK_DEV_OPS(&(dnp->dn_lock));
12373 #endif
12374
12375 return (dip);
12376 }
12377
12378
12379 /*
12380 * Probe device.
12381 * This function issues Identify Device command and initializes local
12382 * sata_drive_info structure if the device can be identified.
12383 * The device type is determined by examining Identify Device
12384 * command response.
12385 * If the sata_hba_inst has linked drive info structure for this
12386 * device address, the Identify Device data is stored into sata_drive_info
12387 * structure linked to the port info structure.
12388 *
12389 * sata_device has to refer to the valid sata port(s) for HBA described
12390 * by sata_hba_inst structure.
12391 *
12392 * Returns:
12393 * SATA_SUCCESS if device type was successfully probed and port-linked
12394 * drive info structure was updated;
12395 * SATA_FAILURE if there is no device, or device was not probed
12396 * successully;
12397 * SATA_RETRY if device probe can be retried later.
12398 * If a device cannot be identified, sata_device's dev_state and dev_type
12399 * fields are set to unknown.
12400 * There are no retries in this function. Any retries should be managed by
12401 * the caller.
12402 */
12403
12404
12405 static int
12406 sata_probe_device(sata_hba_inst_t *sata_hba_inst, sata_device_t *sata_device)
12407 {
12408 sata_pmport_info_t *pmportinfo;
12409 sata_drive_info_t *sdinfo;
12410 sata_drive_info_t new_sdinfo; /* local drive info struct */
12411 int rval;
12412
12413 ASSERT((SATA_CPORT_STATE(sata_hba_inst,
12414 sata_device->satadev_addr.cport) &
12415 (SATA_STATE_PROBED | SATA_STATE_READY)) != 0);
12416
12417 sata_device->satadev_type = SATA_DTYPE_NONE;
12418
12419 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst,
12420 sata_device->satadev_addr.cport)));
12421
12422 if (sata_device->satadev_addr.qual == SATA_ADDR_DPMPORT) {
12423 pmportinfo = SATA_PMPORT_INFO(sata_hba_inst,
12424 sata_device->satadev_addr.cport,
12425 sata_device->satadev_addr.pmport);
12426 ASSERT(pmportinfo != NULL);
12427 }
12428
12429 /* Get pointer to port-linked sata device info structure */
12430 sdinfo = sata_get_device_info(sata_hba_inst, sata_device);
12431 if (sdinfo != NULL) {
12432 sdinfo->satadrv_state &=
12433 ~(SATA_STATE_PROBED | SATA_STATE_READY);
12434 sdinfo->satadrv_state |= SATA_STATE_PROBING;
12435 } else {
12436 /* No device to probe */
12437 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst,
12438 sata_device->satadev_addr.cport)));
12439 sata_device->satadev_type = SATA_DTYPE_NONE;
12440 sata_device->satadev_state = SATA_STATE_UNKNOWN;
12441 return (SATA_FAILURE);
12442 }
12443 /*
12444 * Need to issue both types of identify device command and
12445 * determine device type by examining retreived data/status.
12446 * First, ATA Identify Device.
12447 */
12448 bzero(&new_sdinfo, sizeof (sata_drive_info_t));
12449 new_sdinfo.satadrv_addr = sata_device->satadev_addr;
12450 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst,
12451 sata_device->satadev_addr.cport)));
12452 new_sdinfo.satadrv_type = SATA_DTYPE_ATADISK;
12453 rval = sata_identify_device(sata_hba_inst, &new_sdinfo);
12454 if (rval == SATA_RETRY) {
12455 /* We may try to check for ATAPI device */
12456 if (SATA_FEATURES(sata_hba_inst) & SATA_CTLF_ATAPI) {
12457 /*
12458 * HBA supports ATAPI - try to issue Identify Packet
12459 * Device command.
12460 */
12461 new_sdinfo.satadrv_type = SATA_DTYPE_ATAPI;
12462 rval = sata_identify_device(sata_hba_inst, &new_sdinfo);
12463 }
12464 }
12465 if (rval == SATA_SUCCESS) {
12466 /*
12467 * Got something responding positively to ATA Identify Device
12468 * or to Identify Packet Device cmd.
12469 * Save last used device type.
12470 */
12471 sata_device->satadev_type = new_sdinfo.satadrv_type;
12472
12473 /* save device info, if possible */
12474 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst,
12475 sata_device->satadev_addr.cport)));
12476 sdinfo = sata_get_device_info(sata_hba_inst, sata_device);
12477 if (sdinfo == NULL) {
12478 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst,
12479 sata_device->satadev_addr.cport)));
12480 return (SATA_FAILURE);
12481 }
12482 /*
12483 * Copy drive info into the port-linked drive info structure.
12484 */
12485 *sdinfo = new_sdinfo;
12486 sdinfo->satadrv_state &= ~SATA_STATE_PROBING;
12487 sdinfo->satadrv_state |= SATA_STATE_PROBED;
12488 if (sata_device->satadev_addr.qual == SATA_ADDR_DCPORT)
12489 SATA_CPORT_DEV_TYPE(sata_hba_inst,
12490 sata_device->satadev_addr.cport) =
12491 sdinfo->satadrv_type;
12492 else { /* SATA_ADDR_DPMPORT */
12493 mutex_enter(&pmportinfo->pmport_mutex);
12494 SATA_PMPORT_DEV_TYPE(sata_hba_inst,
12495 sata_device->satadev_addr.cport,
12496 sata_device->satadev_addr.pmport) =
12497 sdinfo->satadrv_type;
12498 mutex_exit(&pmportinfo->pmport_mutex);
12499 }
12500 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst,
12501 sata_device->satadev_addr.cport)));
12502 return (SATA_SUCCESS);
12503 }
12504
12505 /*
12506 * It may be SATA_RETRY or SATA_FAILURE return.
12507 * Looks like we cannot determine the device type at this time.
12508 */
12509 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst,
12510 sata_device->satadev_addr.cport)));
12511 sdinfo = sata_get_device_info(sata_hba_inst, sata_device);
12512 if (sdinfo != NULL) {
12513 sata_device->satadev_type = SATA_DTYPE_UNKNOWN;
12514 sdinfo->satadrv_type = SATA_DTYPE_UNKNOWN;
12515 sdinfo->satadrv_state &= ~SATA_STATE_PROBING;
12516 sdinfo->satadrv_state |= SATA_STATE_PROBED;
12517 if (sata_device->satadev_addr.qual == SATA_ADDR_DCPORT)
12518 SATA_CPORT_DEV_TYPE(sata_hba_inst,
12519 sata_device->satadev_addr.cport) =
12520 SATA_DTYPE_UNKNOWN;
12521 else {
12522 /* SATA_ADDR_DPMPORT */
12523 mutex_enter(&pmportinfo->pmport_mutex);
12524 if ((SATA_PMULT_INFO(sata_hba_inst,
12525 sata_device->satadev_addr.cport) != NULL) &&
12526 (SATA_PMPORT_INFO(sata_hba_inst,
12527 sata_device->satadev_addr.cport,
12528 sata_device->satadev_addr.pmport) != NULL))
12529 SATA_PMPORT_DEV_TYPE(sata_hba_inst,
12530 sata_device->satadev_addr.cport,
12531 sata_device->satadev_addr.pmport) =
12532 SATA_DTYPE_UNKNOWN;
12533 mutex_exit(&pmportinfo->pmport_mutex);
12534 }
12535 }
12536 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst,
12537 sata_device->satadev_addr.cport)));
12538 return (rval);
12539 }
12540
12541
12542 /*
12543 * Get pointer to sata_drive_info structure.
12544 *
12545 * The sata_device has to contain address (cport, pmport and qualifier) for
12546 * specified sata_scsi structure.
12547 *
12548 * Returns NULL if device address is not valid for this HBA configuration.
12549 * Otherwise, returns a pointer to sata_drive_info structure.
12550 *
12551 * This function should be called with a port mutex held.
12552 */
12553 static sata_drive_info_t *
12554 sata_get_device_info(sata_hba_inst_t *sata_hba_inst,
12555 sata_device_t *sata_device)
12556 {
12557 uint8_t cport = sata_device->satadev_addr.cport;
12558 uint8_t pmport = sata_device->satadev_addr.pmport;
12559 uint8_t qual = sata_device->satadev_addr.qual;
12560
12561 if (cport >= SATA_NUM_CPORTS(sata_hba_inst))
12562 return (NULL);
12563
12564 if (!(SATA_CPORT_STATE(sata_hba_inst, cport) &
12565 (SATA_STATE_PROBED | SATA_STATE_READY)))
12566 /* Port not probed yet */
12567 return (NULL);
12568
12569 if (SATA_CPORT_DEV_TYPE(sata_hba_inst, cport) == SATA_DTYPE_NONE)
12570 return (NULL);
12571
12572 if (qual == SATA_ADDR_DCPORT) {
12573 /* Request for a device on a controller port */
12574 if (SATA_CPORT_DEV_TYPE(sata_hba_inst, cport) ==
12575 SATA_DTYPE_PMULT)
12576 /* Port multiplier attached */
12577 return (NULL);
12578 return (SATA_CPORT_DRV_INFO(sata_hba_inst, cport));
12579 }
12580 if (qual == SATA_ADDR_DPMPORT) {
12581 if (SATA_CPORT_DEV_TYPE(sata_hba_inst, cport) !=
12582 SATA_DTYPE_PMULT)
12583 return (NULL);
12584
12585 if (pmport > SATA_NUM_PMPORTS(sata_hba_inst, cport))
12586 return (NULL);
12587
12588 if (!(SATA_PMPORT_STATE(sata_hba_inst, cport, pmport) &
12589 (SATA_STATE_PROBED | SATA_STATE_READY)))
12590 /* Port multiplier port not probed yet */
12591 return (NULL);
12592
12593 return (SATA_PMPORT_DRV_INFO(sata_hba_inst, cport, pmport));
12594 }
12595
12596 /* we should not get here */
12597 return (NULL);
12598 }
12599
12600
12601 /*
12602 * sata_identify_device.
12603 * Send Identify Device command to SATA HBA driver.
12604 * If command executes successfully, update sata_drive_info structure pointed
12605 * to by sdinfo argument, including Identify Device data.
12606 * If command fails, invalidate data in sata_drive_info.
12607 *
12608 * Cannot be called from interrupt level.
12609 *
12610 * Returns:
12611 * SATA_SUCCESS if the device was identified as a supported device,
12612 * SATA_RETRY if the device was not identified but could be retried,
12613 * SATA_FAILURE if the device was not identified and identify attempt
12614 * should not be retried.
12615 */
12616 static int
12617 sata_identify_device(sata_hba_inst_t *sata_hba_inst,
12618 sata_drive_info_t *sdinfo)
12619 {
12620 uint16_t cfg_word;
12621 int rval;
12622
12623 /* fetch device identify data */
12624 if ((rval = sata_fetch_device_identify_data(sata_hba_inst,
12625 sdinfo)) != SATA_SUCCESS)
12626 goto fail_unknown;
12627
12628 cfg_word = sdinfo->satadrv_id.ai_config;
12629
12630 /* Set the correct device type */
12631 if ((cfg_word & SATA_ATA_TYPE_MASK) == SATA_ATA_TYPE) {
12632 sdinfo->satadrv_type = SATA_DTYPE_ATADISK;
12633 } else if (cfg_word == SATA_CFA_TYPE) {
12634 /* It's a Compact Flash media via CF-to-SATA HDD adapter */
12635 sdinfo->satadrv_type = SATA_DTYPE_ATADISK;
12636 } else if ((cfg_word & SATA_ATAPI_TYPE_MASK) == SATA_ATAPI_TYPE) {
12637 switch (cfg_word & SATA_ATAPI_ID_DEV_TYPE) {
12638 case SATA_ATAPI_CDROM_DEV:
12639 sdinfo->satadrv_type = SATA_DTYPE_ATAPICD;
12640 break;
12641 case SATA_ATAPI_SQACC_DEV:
12642 sdinfo->satadrv_type = SATA_DTYPE_ATAPITAPE;
12643 break;
12644 case SATA_ATAPI_DIRACC_DEV:
12645 sdinfo->satadrv_type = SATA_DTYPE_ATAPIDISK;
12646 break;
12647 case SATA_ATAPI_PROC_DEV:
12648 sdinfo->satadrv_type = SATA_DTYPE_ATAPIPROC;
12649 break;
12650 default:
12651 sdinfo->satadrv_type = SATA_DTYPE_UNKNOWN;
12652 }
12653 } else {
12654 sdinfo->satadrv_type = SATA_DTYPE_UNKNOWN;
12655 }
12656
12657 if (sdinfo->satadrv_type == SATA_DTYPE_ATADISK) {
12658 if (sdinfo->satadrv_capacity == 0) {
12659 /* Non-LBA disk. Too bad... */
12660 sata_log(sata_hba_inst, CE_WARN,
12661 "SATA disk device at port %d does not support LBA",
12662 sdinfo->satadrv_addr.cport);
12663 rval = SATA_FAILURE;
12664 goto fail_unknown;
12665 }
12666 }
12667 #if 0
12668 /* Left for historical reason */
12669 /*
12670 * Some initial version of SATA spec indicated that at least
12671 * UDMA mode 4 has to be supported. It is not metioned in
12672 * SerialATA 2.6, so this restriction is removed.
12673 */
12674 /* Check for Ultra DMA modes 6 through 0 being supported */
12675 for (i = 6; i >= 0; --i) {
12676 if (sdinfo->satadrv_id.ai_ultradma & (1 << i))
12677 break;
12678 }
12679
12680 /*
12681 * At least UDMA 4 mode has to be supported. If mode 4 or
12682 * higher are not supported by the device, fail this
12683 * device.
12684 */
12685 if (i < 4) {
12686 /* No required Ultra DMA mode supported */
12687 sata_log(sata_hba_inst, CE_WARN,
12688 "SATA disk device at port %d does not support UDMA "
12689 "mode 4 or higher", sdinfo->satadrv_addr.cport);
12690 SATA_LOG_D((sata_hba_inst, CE_WARN,
12691 "mode 4 or higher required, %d supported", i));
12692 rval = SATA_FAILURE;
12693 goto fail_unknown;
12694 }
12695 #endif
12696
12697 /*
12698 * For Disk devices, if it doesn't support UDMA mode, we would
12699 * like to return failure directly.
12700 */
12701 if ((sdinfo->satadrv_type == SATA_DTYPE_ATADISK) &&
12702 !((sdinfo->satadrv_id.ai_validinfo & SATA_VALIDINFO_88) != 0 &&
12703 (sdinfo->satadrv_id.ai_ultradma & SATA_UDMA_SUP_MASK) != 0)) {
12704 sata_log(sata_hba_inst, CE_WARN,
12705 "SATA disk device at port %d does not support UDMA",
12706 sdinfo->satadrv_addr.cport);
12707 rval = SATA_FAILURE;
12708 goto fail_unknown;
12709 }
12710
12711 return (SATA_SUCCESS);
12712
12713 fail_unknown:
12714 /* Invalidate sata_drive_info ? */
12715 sdinfo->satadrv_type = SATA_DTYPE_UNKNOWN;
12716 sdinfo->satadrv_state = SATA_STATE_UNKNOWN;
12717 return (rval);
12718 }
12719
12720 /*
12721 * Log/display device information
12722 */
12723 static void
12724 sata_show_drive_info(sata_hba_inst_t *sata_hba_inst,
12725 sata_drive_info_t *sdinfo)
12726 {
12727 int valid_version;
12728 char msg_buf[MAXPATHLEN];
12729 int i;
12730
12731 /* Show HBA path */
12732 (void) ddi_pathname(SATA_DIP(sata_hba_inst), msg_buf);
12733
12734 cmn_err(CE_CONT, "?%s :\n", msg_buf);
12735
12736 switch (sdinfo->satadrv_type) {
12737 case SATA_DTYPE_ATADISK:
12738 (void) sprintf(msg_buf, "SATA disk device at");
12739 break;
12740
12741 case SATA_DTYPE_ATAPICD:
12742 (void) sprintf(msg_buf, "SATA CD/DVD (ATAPI) device at");
12743 break;
12744
12745 case SATA_DTYPE_ATAPITAPE:
12746 (void) sprintf(msg_buf, "SATA tape (ATAPI) device at");
12747 break;
12748
12749 case SATA_DTYPE_ATAPIDISK:
12750 (void) sprintf(msg_buf, "SATA disk (ATAPI) device at");
12751 break;
12752
12753 case SATA_DTYPE_ATAPIPROC:
12754 (void) sprintf(msg_buf, "SATA processor (ATAPI) device at");
12755 break;
12756
12757 case SATA_DTYPE_UNKNOWN:
12758 (void) sprintf(msg_buf,
12759 "Unsupported SATA device type (cfg 0x%x) at ",
12760 sdinfo->satadrv_id.ai_config);
12761 break;
12762 }
12763
12764 if (sdinfo->satadrv_addr.qual == SATA_ADDR_DCPORT)
12765 cmn_err(CE_CONT, "?\t%s port %d\n",
12766 msg_buf, sdinfo->satadrv_addr.cport);
12767 else
12768 cmn_err(CE_CONT, "?\t%s port %d:%d\n",
12769 msg_buf, sdinfo->satadrv_addr.cport,
12770 sdinfo->satadrv_addr.pmport);
12771
12772 bcopy(&sdinfo->satadrv_id.ai_model, msg_buf,
12773 sizeof (sdinfo->satadrv_id.ai_model));
12774 swab(msg_buf, msg_buf, sizeof (sdinfo->satadrv_id.ai_model));
12775 msg_buf[sizeof (sdinfo->satadrv_id.ai_model)] = '\0';
12776 cmn_err(CE_CONT, "?\tmodel %s\n", msg_buf);
12777
12778 bcopy(&sdinfo->satadrv_id.ai_fw, msg_buf,
12779 sizeof (sdinfo->satadrv_id.ai_fw));
12780 swab(msg_buf, msg_buf, sizeof (sdinfo->satadrv_id.ai_fw));
12781 msg_buf[sizeof (sdinfo->satadrv_id.ai_fw)] = '\0';
12782 cmn_err(CE_CONT, "?\tfirmware %s\n", msg_buf);
12783
12784 bcopy(&sdinfo->satadrv_id.ai_drvser, msg_buf,
12785 sizeof (sdinfo->satadrv_id.ai_drvser));
12786 swab(msg_buf, msg_buf, sizeof (sdinfo->satadrv_id.ai_drvser));
12787 msg_buf[sizeof (sdinfo->satadrv_id.ai_drvser)] = '\0';
12788 if (sdinfo->satadrv_type == SATA_DTYPE_ATADISK) {
12789 cmn_err(CE_CONT, "?\tserial number %s\n", msg_buf);
12790 } else {
12791 /*
12792 * Some drives do not implement serial number and may
12793 * violate the spec by providing spaces rather than zeros
12794 * in serial number field. Scan the buffer to detect it.
12795 */
12796 for (i = 0; i < sizeof (sdinfo->satadrv_id.ai_drvser); i++) {
12797 if (msg_buf[i] != '\0' && msg_buf[i] != ' ')
12798 break;
12799 }
12800 if (i == sizeof (sdinfo->satadrv_id.ai_drvser)) {
12801 cmn_err(CE_CONT, "?\tserial number - none\n");
12802 } else {
12803 cmn_err(CE_CONT, "?\tserial number %s\n", msg_buf);
12804 }
12805 }
12806
12807 #ifdef SATA_DEBUG
12808 if (sdinfo->satadrv_id.ai_majorversion != 0 &&
12809 sdinfo->satadrv_id.ai_majorversion != 0xffff) {
12810 int i;
12811 for (i = 14; i >= 2; i--) {
12812 if (sdinfo->satadrv_id.ai_majorversion & (1 << i)) {
12813 valid_version = i;
12814 break;
12815 }
12816 }
12817 cmn_err(CE_CONT,
12818 "?\tATA/ATAPI-%d supported, majver 0x%x minver 0x%x\n",
12819 valid_version,
12820 sdinfo->satadrv_id.ai_majorversion,
12821 sdinfo->satadrv_id.ai_minorversion);
12822 }
12823 #endif
12824 /* Log some info */
12825 cmn_err(CE_CONT, "?\tsupported features:\n");
12826 msg_buf[0] = '\0';
12827 if (sdinfo->satadrv_type == SATA_DTYPE_ATADISK) {
12828 if (sdinfo->satadrv_features_support & SATA_DEV_F_LBA48)
12829 (void) strlcat(msg_buf, "48-bit LBA, ", MAXPATHLEN);
12830 else if (sdinfo->satadrv_features_support & SATA_DEV_F_LBA28)
12831 (void) strlcat(msg_buf, "28-bit LBA, ", MAXPATHLEN);
12832 }
12833 if (sdinfo->satadrv_features_support & SATA_DEV_F_DMA)
12834 (void) strlcat(msg_buf, "DMA", MAXPATHLEN);
12835 if (sdinfo->satadrv_features_support & SATA_DEV_F_NCQ)
12836 (void) strlcat(msg_buf, ", Native Command Queueing",
12837 MAXPATHLEN);
12838 if (sdinfo->satadrv_features_support & SATA_DEV_F_TCQ)
12839 (void) strlcat(msg_buf, ", Legacy Tagged Queuing", MAXPATHLEN);
12840 if ((sdinfo->satadrv_id.ai_cmdset82 & SATA_SMART_SUPPORTED) &&
12841 (sdinfo->satadrv_id.ai_features85 & SATA_SMART_ENABLED))
12842 (void) strlcat(msg_buf, ", SMART", MAXPATHLEN);
12843 if ((sdinfo->satadrv_id.ai_cmdset84 & SATA_SMART_SELF_TEST_SUPPORTED) &&
12844 (sdinfo->satadrv_id.ai_features87 & SATA_SMART_SELF_TEST_SUPPORTED))
12845 (void) strlcat(msg_buf, ", SMART self-test", MAXPATHLEN);
12846 cmn_err(CE_CONT, "?\t %s\n", msg_buf);
12847 if (sdinfo->satadrv_features_support & SATA_DEV_F_SATA3)
12848 cmn_err(CE_CONT, "?\tSATA Gen3 signaling speed (6.0Gbps)\n");
12849 else if (sdinfo->satadrv_features_support & SATA_DEV_F_SATA2)
12850 cmn_err(CE_CONT, "?\tSATA Gen2 signaling speed (3.0Gbps)\n");
12851 else if (sdinfo->satadrv_features_support & SATA_DEV_F_SATA1)
12852 cmn_err(CE_CONT, "?\tSATA Gen1 signaling speed (1.5Gbps)\n");
12853 if (sdinfo->satadrv_features_support &
12854 (SATA_DEV_F_TCQ | SATA_DEV_F_NCQ)) {
12855 msg_buf[0] = '\0';
12856 (void) snprintf(msg_buf, MAXPATHLEN,
12857 "Supported queue depth %d",
12858 sdinfo->satadrv_queue_depth);
12859 if (!(sata_func_enable &
12860 (SATA_ENABLE_QUEUING | SATA_ENABLE_NCQ)))
12861 (void) strlcat(msg_buf,
12862 " - queueing disabled globally", MAXPATHLEN);
12863 else if (sdinfo->satadrv_queue_depth >
12864 sdinfo->satadrv_max_queue_depth) {
12865 (void) snprintf(&msg_buf[strlen(msg_buf)],
12866 MAXPATHLEN - strlen(msg_buf), ", limited to %d",
12867 (int)sdinfo->satadrv_max_queue_depth);
12868 }
12869 cmn_err(CE_CONT, "?\t%s\n", msg_buf);
12870 }
12871
12872 if (sdinfo->satadrv_type == SATA_DTYPE_ATADISK) {
12873 #ifdef __i386
12874 (void) sprintf(msg_buf, "\tcapacity = %llu sectors\n",
12875 sdinfo->satadrv_capacity);
12876 #else
12877 (void) sprintf(msg_buf, "\tcapacity = %lu sectors\n",
12878 sdinfo->satadrv_capacity);
12879 #endif
12880 cmn_err(CE_CONT, "?%s", msg_buf);
12881 }
12882 }
12883
12884 /*
12885 * Log/display port multiplier information
12886 * No Mutex should be hold.
12887 */
12888 static void
12889 sata_show_pmult_info(sata_hba_inst_t *sata_hba_inst,
12890 sata_device_t *sata_device)
12891 {
12892 _NOTE(ARGUNUSED(sata_hba_inst))
12893
12894 int cport = sata_device->satadev_addr.cport;
12895 sata_pmult_info_t *pmultinfo;
12896 char msg_buf[MAXPATHLEN];
12897 uint32_t gscr0, gscr1, gscr2, gscr64;
12898
12899 mutex_enter(&SATA_CPORT_MUTEX(sata_hba_inst, cport));
12900 pmultinfo = SATA_PMULT_INFO(sata_hba_inst, cport);
12901 if (pmultinfo == NULL) {
12902 mutex_exit(&SATA_CPORT_MUTEX(sata_hba_inst, cport));
12903 return;
12904 }
12905
12906 gscr0 = pmultinfo->pmult_gscr.gscr0;
12907 gscr1 = pmultinfo->pmult_gscr.gscr1;
12908 gscr2 = pmultinfo->pmult_gscr.gscr2;
12909 gscr64 = pmultinfo->pmult_gscr.gscr64;
12910 mutex_exit(&SATA_CPORT_MUTEX(sata_hba_inst, cport));
12911
12912 cmn_err(CE_CONT, "?Port Multiplier %d device-ports found at port %d",
12913 sata_device->satadev_add_info, sata_device->satadev_addr.cport);
12914
12915 (void) sprintf(msg_buf, "\tVendor_ID 0x%04x, Module_ID 0x%04x",
12916 gscr0 & 0xffff, (gscr0 >> 16) & 0xffff);
12917 cmn_err(CE_CONT, "?%s", msg_buf);
12918
12919 (void) strcpy(msg_buf, "\tSupport SATA PMP Spec ");
12920 if (gscr1 & (1 << 3))
12921 (void) strlcat(msg_buf, "1.2", MAXPATHLEN);
12922 else if (gscr1 & (1 << 2))
12923 (void) strlcat(msg_buf, "1.1", MAXPATHLEN);
12924 else if (gscr1 & (1 << 1))
12925 (void) strlcat(msg_buf, "1.0", MAXPATHLEN);
12926 else
12927 (void) strlcat(msg_buf, "unknown", MAXPATHLEN);
12928 cmn_err(CE_CONT, "?%s", msg_buf);
12929
12930 (void) strcpy(msg_buf, "\tSupport ");
12931 if (gscr64 & (1 << 3))
12932 (void) strlcat(msg_buf, "Asy-Notif, ",
12933 MAXPATHLEN);
12934 if (gscr64 & (1 << 2))
12935 (void) strlcat(msg_buf, "Dyn-SSC, ", MAXPATHLEN);
12936 if (gscr64 & (1 << 1))
12937 (void) strlcat(msg_buf, "Iss-PMREQ, ", MAXPATHLEN);
12938 if (gscr64 & (1 << 0))
12939 (void) strlcat(msg_buf, "BIST", MAXPATHLEN);
12940 if ((gscr64 & 0xf) == 0)
12941 (void) strlcat(msg_buf, "nothing", MAXPATHLEN);
12942 cmn_err(CE_CONT, "?%s", msg_buf);
12943
12944 (void) sprintf(msg_buf, "\tNumber of exposed device fan-out ports: %d",
12945 gscr2 & SATA_PMULT_PORTNUM_MASK);
12946 cmn_err(CE_CONT, "?%s", msg_buf);
12947 }
12948
12949 /*
12950 * sata_save_drive_settings extracts current setting of the device and stores
12951 * it for future reference, in case the device setup would need to be restored
12952 * after the device reset.
12953 *
12954 * For all devices read ahead and write cache settings are saved, if the
12955 * device supports these features at all.
12956 * For ATAPI devices the Removable Media Status Notification setting is saved.
12957 */
12958 static void
12959 sata_save_drive_settings(sata_drive_info_t *sdinfo)
12960 {
12961 if (SATA_READ_AHEAD_SUPPORTED(sdinfo->satadrv_id) ||
12962 SATA_WRITE_CACHE_SUPPORTED(sdinfo->satadrv_id)) {
12963
12964 /* Current setting of Read Ahead (and Read Cache) */
12965 if (SATA_READ_AHEAD_ENABLED(sdinfo->satadrv_id))
12966 sdinfo->satadrv_settings |= SATA_DEV_READ_AHEAD;
12967 else
12968 sdinfo->satadrv_settings &= ~SATA_DEV_READ_AHEAD;
12969
12970 /* Current setting of Write Cache */
12971 if (SATA_WRITE_CACHE_ENABLED(sdinfo->satadrv_id))
12972 sdinfo->satadrv_settings |= SATA_DEV_WRITE_CACHE;
12973 else
12974 sdinfo->satadrv_settings &= ~SATA_DEV_WRITE_CACHE;
12975 }
12976
12977 if (sdinfo->satadrv_type == SATA_DTYPE_ATAPICD) {
12978 if (SATA_RM_NOTIFIC_SUPPORTED(sdinfo->satadrv_id))
12979 sdinfo->satadrv_settings |= SATA_DEV_RMSN;
12980 else
12981 sdinfo->satadrv_settings &= ~SATA_DEV_RMSN;
12982 }
12983 }
12984
12985
12986 /*
12987 * sata_check_capacity function determines a disk capacity
12988 * and addressing mode (LBA28/LBA48) by examining a disk identify device data.
12989 *
12990 * NOTE: CHS mode is not supported! If a device does not support LBA,
12991 * this function is not called.
12992 *
12993 * Returns device capacity in number of blocks, i.e. largest addressable LBA+1
12994 */
12995 static uint64_t
12996 sata_check_capacity(sata_drive_info_t *sdinfo)
12997 {
12998 uint64_t capacity = 0;
12999 int i;
13000
13001 if (sdinfo->satadrv_type != SATA_DTYPE_ATADISK ||
13002 !sdinfo->satadrv_id.ai_cap & SATA_LBA_SUPPORT)
13003 /* Capacity valid only for LBA-addressable disk devices */
13004 return (0);
13005
13006 if ((sdinfo->satadrv_id.ai_validinfo & SATA_VALIDINFO_88) &&
13007 (sdinfo->satadrv_id.ai_cmdset83 & SATA_EXT48) &&
13008 (sdinfo->satadrv_id.ai_features86 & SATA_EXT48)) {
13009 /* LBA48 mode supported and enabled */
13010 sdinfo->satadrv_features_support |= SATA_DEV_F_LBA48 |
13011 SATA_DEV_F_LBA28;
13012 for (i = 3; i >= 0; --i) {
13013 capacity <<= 16;
13014 capacity += sdinfo->satadrv_id.ai_addrsecxt[i];
13015 }
13016 } else {
13017 capacity = sdinfo->satadrv_id.ai_addrsec[1];
13018 capacity <<= 16;
13019 capacity += sdinfo->satadrv_id.ai_addrsec[0];
13020 if (capacity >= 0x1000000)
13021 /* LBA28 mode */
13022 sdinfo->satadrv_features_support |= SATA_DEV_F_LBA28;
13023 }
13024 return (capacity);
13025 }
13026
13027
13028 /*
13029 * Allocate consistent buffer for DMA transfer
13030 *
13031 * Cannot be called from interrupt level or with mutex held - it may sleep.
13032 *
13033 * Returns pointer to allocated buffer structure, or NULL if allocation failed.
13034 */
13035 static struct buf *
13036 sata_alloc_local_buffer(sata_pkt_txlate_t *spx, int len)
13037 {
13038 struct scsi_address ap;
13039 struct buf *bp;
13040 ddi_dma_attr_t cur_dma_attr;
13041
13042 ASSERT(spx->txlt_sata_pkt != NULL);
13043 ap.a_hba_tran = spx->txlt_sata_hba_inst->satahba_scsi_tran;
13044 ap.a_target = SATA_TO_SCSI_TARGET(
13045 spx->txlt_sata_pkt->satapkt_device.satadev_addr.cport,
13046 spx->txlt_sata_pkt->satapkt_device.satadev_addr.pmport,
13047 spx->txlt_sata_pkt->satapkt_device.satadev_addr.qual);
13048 ap.a_lun = 0;
13049
13050 bp = scsi_alloc_consistent_buf(&ap, NULL, len,
13051 B_READ, SLEEP_FUNC, NULL);
13052
13053 if (bp != NULL) {
13054 /* Allocate DMA resources for this buffer */
13055 spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp = bp;
13056 /*
13057 * We use a local version of the dma_attr, to account
13058 * for a device addressing limitations.
13059 * sata_adjust_dma_attr() will handle sdinfo == NULL which
13060 * will cause dma attributes to be adjusted to a lowest
13061 * acceptable level.
13062 */
13063 sata_adjust_dma_attr(NULL,
13064 SATA_DMA_ATTR(spx->txlt_sata_hba_inst), &cur_dma_attr);
13065
13066 if (sata_dma_buf_setup(spx, PKT_CONSISTENT,
13067 SLEEP_FUNC, NULL, &cur_dma_attr) != DDI_SUCCESS) {
13068 scsi_free_consistent_buf(bp);
13069 spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp = NULL;
13070 bp = NULL;
13071 }
13072 }
13073 return (bp);
13074 }
13075
13076 /*
13077 * Release local buffer (consistent buffer for DMA transfer) allocated
13078 * via sata_alloc_local_buffer().
13079 */
13080 static void
13081 sata_free_local_buffer(sata_pkt_txlate_t *spx)
13082 {
13083 ASSERT(spx->txlt_sata_pkt != NULL);
13084 ASSERT(spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp != NULL);
13085
13086 spx->txlt_sata_pkt->satapkt_cmd.satacmd_num_dma_cookies = 0;
13087 spx->txlt_sata_pkt->satapkt_cmd.satacmd_dma_cookie_list = NULL;
13088
13089 sata_common_free_dma_rsrcs(spx);
13090
13091 /* Free buffer */
13092 scsi_free_consistent_buf(spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp);
13093 spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp = NULL;
13094 }
13095
13096 /*
13097 * Allocate sata_pkt
13098 * Pkt structure version and embedded strcutures version are initialized.
13099 * sata_pkt and sata_pkt_txlate structures are cross-linked.
13100 *
13101 * Since this may be called in interrupt context by sata_scsi_init_pkt,
13102 * callback argument determines if it can sleep or not.
13103 * Hence, it should not be called from interrupt context.
13104 *
13105 * If successful, non-NULL pointer to a sata pkt is returned.
13106 * Upon failure, NULL pointer is returned.
13107 */
13108 static sata_pkt_t *
13109 sata_pkt_alloc(sata_pkt_txlate_t *spx, int (*callback)(caddr_t))
13110 {
13111 sata_pkt_t *spkt;
13112 int kmsflag;
13113
13114 kmsflag = (callback == SLEEP_FUNC) ? KM_SLEEP : KM_NOSLEEP;
13115 spkt = kmem_zalloc(sizeof (sata_pkt_t), kmsflag);
13116 if (spkt == NULL) {
13117 SATA_LOG_D((spx->txlt_sata_hba_inst, CE_WARN,
13118 "sata_pkt_alloc: failed"));
13119 return (NULL);
13120 }
13121 spkt->satapkt_rev = SATA_PKT_REV;
13122 spkt->satapkt_cmd.satacmd_rev = SATA_CMD_REV;
13123 spkt->satapkt_device.satadev_rev = SATA_DEVICE_REV;
13124 spkt->satapkt_framework_private = spx;
13125 spx->txlt_sata_pkt = spkt;
13126 return (spkt);
13127 }
13128
13129 /*
13130 * Free sata pkt allocated via sata_pkt_alloc()
13131 */
13132 static void
13133 sata_pkt_free(sata_pkt_txlate_t *spx)
13134 {
13135 ASSERT(spx->txlt_sata_pkt != NULL);
13136 ASSERT(spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp == NULL);
13137 kmem_free(spx->txlt_sata_pkt, sizeof (sata_pkt_t));
13138 spx->txlt_sata_pkt = NULL;
13139 }
13140
13141
13142 /*
13143 * Adjust DMA attributes.
13144 * SCSI cmds block count is up to 24 bits, SATA cmd block count vary
13145 * from 8 bits to 16 bits, depending on a command being used.
13146 * Limiting max block count arbitrarily to 256 for all read/write
13147 * commands may affects performance, so check both the device and
13148 * controller capability before adjusting dma attributes.
13149 */
13150 void
13151 sata_adjust_dma_attr(sata_drive_info_t *sdinfo, ddi_dma_attr_t *dma_attr,
13152 ddi_dma_attr_t *adj_dma_attr)
13153 {
13154 uint32_t count_max;
13155
13156 /* Copy original attributes */
13157 *adj_dma_attr = *dma_attr;
13158 /*
13159 * Things to consider: device addressing capability,
13160 * "excessive" controller DMA capabilities.
13161 * If a device is being probed/initialized, there are
13162 * no device info - use default limits then.
13163 */
13164 if (sdinfo == NULL) {
13165 count_max = dma_attr->dma_attr_granular * 0x100;
13166 if (dma_attr->dma_attr_count_max > count_max)
13167 adj_dma_attr->dma_attr_count_max = count_max;
13168 if (dma_attr->dma_attr_maxxfer > count_max)
13169 adj_dma_attr->dma_attr_maxxfer = count_max;
13170 return;
13171 }
13172
13173 if (sdinfo->satadrv_type == SATA_DTYPE_ATADISK) {
13174 if (sdinfo->satadrv_features_support & (SATA_DEV_F_LBA48)) {
13175 /*
13176 * 16-bit sector count may be used - we rely on
13177 * the assumption that only read and write cmds
13178 * will request more than 256 sectors worth of data
13179 */
13180 count_max = adj_dma_attr->dma_attr_granular * 0x10000;
13181 } else {
13182 /*
13183 * 8-bit sector count will be used - default limits
13184 * for dma attributes
13185 */
13186 count_max = adj_dma_attr->dma_attr_granular * 0x100;
13187 }
13188 /*
13189 * Adjust controler dma attributes, if necessary
13190 */
13191 if (dma_attr->dma_attr_count_max > count_max)
13192 adj_dma_attr->dma_attr_count_max = count_max;
13193 if (dma_attr->dma_attr_maxxfer > count_max)
13194 adj_dma_attr->dma_attr_maxxfer = count_max;
13195 }
13196 }
13197
13198
13199 /*
13200 * Allocate DMA resources for the buffer
13201 * This function handles initial DMA resource allocation as well as
13202 * DMA window shift and may be called repeatedly for the same DMA window
13203 * until all DMA cookies in the DMA window are processed.
13204 * To guarantee that there is always a coherent set of cookies to process
13205 * by SATA HBA driver (observing alignment, device granularity, etc.),
13206 * the number of slots for DMA cookies is equal to lesser of a number of
13207 * cookies in a DMA window and a max number of scatter/gather entries.
13208 *
13209 * Returns DDI_SUCCESS upon successful operation.
13210 * Return failure code of a failing command or DDI_FAILURE when
13211 * internal cleanup failed.
13212 */
13213 static int
13214 sata_dma_buf_setup(sata_pkt_txlate_t *spx, int flags,
13215 int (*callback)(caddr_t), caddr_t arg,
13216 ddi_dma_attr_t *cur_dma_attr)
13217 {
13218 int rval;
13219 off_t offset;
13220 size_t size;
13221 int max_sg_len, req_len, i;
13222 uint_t dma_flags;
13223 struct buf *bp;
13224 uint64_t cur_txfer_len;
13225
13226
13227 ASSERT(spx->txlt_sata_pkt != NULL);
13228 bp = spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp;
13229 ASSERT(bp != NULL);
13230
13231
13232 if (spx->txlt_buf_dma_handle == NULL) {
13233 /*
13234 * No DMA resources allocated so far - this is a first call
13235 * for this sata pkt.
13236 */
13237 rval = ddi_dma_alloc_handle(SATA_DIP(spx->txlt_sata_hba_inst),
13238 cur_dma_attr, callback, arg, &spx->txlt_buf_dma_handle);
13239
13240 if (rval != DDI_SUCCESS) {
13241 SATA_LOG_D((spx->txlt_sata_hba_inst, CE_WARN,
13242 "sata_dma_buf_setup: no buf DMA resources %x",
13243 rval));
13244 return (rval);
13245 }
13246
13247 if (bp->b_flags & B_READ)
13248 dma_flags = DDI_DMA_READ;
13249 else
13250 dma_flags = DDI_DMA_WRITE;
13251
13252 if (flags & PKT_CONSISTENT)
13253 dma_flags |= DDI_DMA_CONSISTENT;
13254
13255 if (flags & PKT_DMA_PARTIAL)
13256 dma_flags |= DDI_DMA_PARTIAL;
13257
13258 /*
13259 * Check buffer alignment and size against dma attributes
13260 * Consider dma_attr_align only. There may be requests
13261 * with the size lower than device granularity, but they
13262 * will not read/write from/to the device, so no adjustment
13263 * is necessary. The dma_attr_minxfer theoretically should
13264 * be considered, but no HBA driver is checking it.
13265 */
13266 if (IS_P2ALIGNED(bp->b_un.b_addr,
13267 cur_dma_attr->dma_attr_align)) {
13268 rval = ddi_dma_buf_bind_handle(
13269 spx->txlt_buf_dma_handle,
13270 bp, dma_flags, callback, arg,
13271 &spx->txlt_dma_cookie,
13272 &spx->txlt_curwin_num_dma_cookies);
13273 } else { /* Buffer is not aligned */
13274
13275 int (*ddicallback)(caddr_t);
13276 size_t bufsz;
13277
13278 /* Check id sleeping is allowed */
13279 ddicallback = (callback == NULL_FUNC) ?
13280 DDI_DMA_DONTWAIT : DDI_DMA_SLEEP;
13281
13282 SATADBG2(SATA_DBG_DMA_SETUP, spx->txlt_sata_hba_inst,
13283 "mis-aligned buffer: addr=0x%p, cnt=%lu",
13284 (void *)bp->b_un.b_addr, bp->b_bcount);
13285
13286 if (bp->b_flags & (B_PAGEIO|B_PHYS))
13287 /*
13288 * CPU will need to access data in the buffer
13289 * (for copying) so map it.
13290 */
13291 bp_mapin(bp);
13292
13293 ASSERT(spx->txlt_tmp_buf == NULL);
13294
13295 /* Buffer may be padded by ddi_dma_mem_alloc()! */
13296 rval = ddi_dma_mem_alloc(
13297 spx->txlt_buf_dma_handle,
13298 bp->b_bcount,
13299 &sata_acc_attr,
13300 DDI_DMA_STREAMING,
13301 ddicallback, NULL,
13302 &spx->txlt_tmp_buf,
13303 &bufsz,
13304 &spx->txlt_tmp_buf_handle);
13305
13306 if (rval != DDI_SUCCESS) {
13307 /* DMA mapping failed */
13308 (void) ddi_dma_free_handle(
13309 &spx->txlt_buf_dma_handle);
13310 spx->txlt_buf_dma_handle = NULL;
13311 #ifdef SATA_DEBUG
13312 mbuffail_count++;
13313 #endif
13314 SATADBG1(SATA_DBG_DMA_SETUP,
13315 spx->txlt_sata_hba_inst,
13316 "sata_dma_buf_setup: "
13317 "buf dma mem alloc failed %x\n", rval);
13318 return (rval);
13319 }
13320 ASSERT(IS_P2ALIGNED(spx->txlt_tmp_buf,
13321 cur_dma_attr->dma_attr_align));
13322
13323 #ifdef SATA_DEBUG
13324 mbuf_count++;
13325
13326 if (bp->b_bcount != bufsz)
13327 /*
13328 * This will require special handling, because
13329 * DMA cookies will be based on the temporary
13330 * buffer size, not the original buffer
13331 * b_bcount, so the residue may have to
13332 * be counted differently.
13333 */
13334 SATADBG2(SATA_DBG_DMA_SETUP,
13335 spx->txlt_sata_hba_inst,
13336 "sata_dma_buf_setup: bp size %x != "
13337 "bufsz %x\n", bp->b_bcount, bufsz);
13338 #endif
13339 if (dma_flags & DDI_DMA_WRITE) {
13340 /*
13341 * Write operation - copy data into
13342 * an aligned temporary buffer. Buffer will be
13343 * synced for device by ddi_dma_addr_bind_handle
13344 */
13345 bcopy(bp->b_un.b_addr, spx->txlt_tmp_buf,
13346 bp->b_bcount);
13347 }
13348
13349 rval = ddi_dma_addr_bind_handle(
13350 spx->txlt_buf_dma_handle,
13351 NULL,
13352 spx->txlt_tmp_buf,
13353 bufsz, dma_flags, ddicallback, 0,
13354 &spx->txlt_dma_cookie,
13355 &spx->txlt_curwin_num_dma_cookies);
13356 }
13357
13358 switch (rval) {
13359 case DDI_DMA_PARTIAL_MAP:
13360 SATADBG1(SATA_DBG_DMA_SETUP, spx->txlt_sata_hba_inst,
13361 "sata_dma_buf_setup: DMA Partial Map\n", NULL);
13362 /*
13363 * Partial DMA mapping.
13364 * Retrieve number of DMA windows for this request.
13365 */
13366 if (ddi_dma_numwin(spx->txlt_buf_dma_handle,
13367 &spx->txlt_num_dma_win) != DDI_SUCCESS) {
13368 if (spx->txlt_tmp_buf != NULL) {
13369 ddi_dma_mem_free(
13370 &spx->txlt_tmp_buf_handle);
13371 spx->txlt_tmp_buf = NULL;
13372 }
13373 (void) ddi_dma_unbind_handle(
13374 spx->txlt_buf_dma_handle);
13375 (void) ddi_dma_free_handle(
13376 &spx->txlt_buf_dma_handle);
13377 spx->txlt_buf_dma_handle = NULL;
13378 SATA_LOG_D((spx->txlt_sata_hba_inst, CE_WARN,
13379 "sata_dma_buf_setup: numwin failed\n"));
13380 return (DDI_FAILURE);
13381 }
13382 SATADBG2(SATA_DBG_DMA_SETUP,
13383 spx->txlt_sata_hba_inst,
13384 "sata_dma_buf_setup: windows: %d, cookies: %d\n",
13385 spx->txlt_num_dma_win,
13386 spx->txlt_curwin_num_dma_cookies);
13387 spx->txlt_cur_dma_win = 0;
13388 break;
13389
13390 case DDI_DMA_MAPPED:
13391 /* DMA fully mapped */
13392 spx->txlt_num_dma_win = 1;
13393 spx->txlt_cur_dma_win = 0;
13394 SATADBG1(SATA_DBG_DMA_SETUP,
13395 spx->txlt_sata_hba_inst,
13396 "sata_dma_buf_setup: windows: 1 "
13397 "cookies: %d\n", spx->txlt_curwin_num_dma_cookies);
13398 break;
13399
13400 default:
13401 /* DMA mapping failed */
13402 if (spx->txlt_tmp_buf != NULL) {
13403 ddi_dma_mem_free(
13404 &spx->txlt_tmp_buf_handle);
13405 spx->txlt_tmp_buf = NULL;
13406 }
13407 (void) ddi_dma_free_handle(&spx->txlt_buf_dma_handle);
13408 spx->txlt_buf_dma_handle = NULL;
13409 SATA_LOG_D((spx->txlt_sata_hba_inst, CE_WARN,
13410 "sata_dma_buf_setup: buf dma handle binding "
13411 "failed %x\n", rval));
13412 return (rval);
13413 }
13414 spx->txlt_curwin_processed_dma_cookies = 0;
13415 spx->txlt_dma_cookie_list = NULL;
13416 } else {
13417 /*
13418 * DMA setup is reused. Check if we need to process more
13419 * cookies in current window, or to get next window, if any.
13420 */
13421
13422 ASSERT(spx->txlt_curwin_processed_dma_cookies <=
13423 spx->txlt_curwin_num_dma_cookies);
13424
13425 if (spx->txlt_curwin_processed_dma_cookies ==
13426 spx->txlt_curwin_num_dma_cookies) {
13427 /*
13428 * All cookies from current DMA window were processed.
13429 * Get next DMA window.
13430 */
13431 spx->txlt_cur_dma_win++;
13432 if (spx->txlt_cur_dma_win < spx->txlt_num_dma_win) {
13433 (void) ddi_dma_getwin(spx->txlt_buf_dma_handle,
13434 spx->txlt_cur_dma_win, &offset, &size,
13435 &spx->txlt_dma_cookie,
13436 &spx->txlt_curwin_num_dma_cookies);
13437 spx->txlt_curwin_processed_dma_cookies = 0;
13438 } else {
13439 /* No more windows! End of request! */
13440 /* What to do? - panic for now */
13441 ASSERT(spx->txlt_cur_dma_win >=
13442 spx->txlt_num_dma_win);
13443
13444 spx->txlt_curwin_num_dma_cookies = 0;
13445 spx->txlt_curwin_processed_dma_cookies = 0;
13446 spx->txlt_sata_pkt->
13447 satapkt_cmd.satacmd_num_dma_cookies = 0;
13448 return (DDI_SUCCESS);
13449 }
13450 }
13451 }
13452 /* There better be at least one DMA cookie outstanding */
13453 ASSERT((spx->txlt_curwin_num_dma_cookies -
13454 spx->txlt_curwin_processed_dma_cookies) > 0);
13455
13456 if (spx->txlt_dma_cookie_list == &spx->txlt_dma_cookie) {
13457 /* The default cookie slot was used in previous run */
13458 ASSERT(spx->txlt_curwin_processed_dma_cookies == 0);
13459 spx->txlt_dma_cookie_list = NULL;
13460 spx->txlt_dma_cookie_list_len = 0;
13461 }
13462 if (spx->txlt_curwin_processed_dma_cookies == 0) {
13463 /*
13464 * Processing a new DMA window - set-up dma cookies list.
13465 * We may reuse previously allocated cookie array if it is
13466 * possible.
13467 */
13468 if (spx->txlt_dma_cookie_list != NULL &&
13469 spx->txlt_dma_cookie_list_len <
13470 spx->txlt_curwin_num_dma_cookies) {
13471 /*
13472 * New DMA window contains more cookies than
13473 * the previous one. We need larger cookie list - free
13474 * the old one.
13475 */
13476 (void) kmem_free(spx->txlt_dma_cookie_list,
13477 spx->txlt_dma_cookie_list_len *
13478 sizeof (ddi_dma_cookie_t));
13479 spx->txlt_dma_cookie_list = NULL;
13480 spx->txlt_dma_cookie_list_len = 0;
13481 }
13482 if (spx->txlt_dma_cookie_list == NULL) {
13483 /*
13484 * Calculate lesser of number of cookies in this
13485 * DMA window and number of s/g entries.
13486 */
13487 max_sg_len = cur_dma_attr->dma_attr_sgllen;
13488 req_len = MIN(max_sg_len,
13489 spx->txlt_curwin_num_dma_cookies);
13490
13491 /* Allocate new dma cookie array if necessary */
13492 if (req_len == 1) {
13493 /* Only one cookie - no need for a list */
13494 spx->txlt_dma_cookie_list =
13495 &spx->txlt_dma_cookie;
13496 spx->txlt_dma_cookie_list_len = 1;
13497 } else {
13498 /*
13499 * More than one cookie - try to allocate space.
13500 */
13501 spx->txlt_dma_cookie_list = kmem_zalloc(
13502 sizeof (ddi_dma_cookie_t) * req_len,
13503 callback == NULL_FUNC ? KM_NOSLEEP :
13504 KM_SLEEP);
13505 if (spx->txlt_dma_cookie_list == NULL) {
13506 SATADBG1(SATA_DBG_DMA_SETUP,
13507 spx->txlt_sata_hba_inst,
13508 "sata_dma_buf_setup: cookie list "
13509 "allocation failed\n", NULL);
13510 /*
13511 * We could not allocate space for
13512 * neccessary number of dma cookies in
13513 * this window, so we fail this request.
13514 * Next invocation would try again to
13515 * allocate space for cookie list.
13516 * Note:Packet residue was not modified.
13517 */
13518 return (DDI_DMA_NORESOURCES);
13519 } else {
13520 spx->txlt_dma_cookie_list_len = req_len;
13521 }
13522 }
13523 }
13524 /*
13525 * Fetch DMA cookies into cookie list in sata_pkt_txlate.
13526 * First cookie was already fetched.
13527 */
13528 *(&spx->txlt_dma_cookie_list[0]) = spx->txlt_dma_cookie;
13529 cur_txfer_len =
13530 (uint64_t)spx->txlt_dma_cookie_list[0].dmac_size;
13531 spx->txlt_sata_pkt->satapkt_cmd.satacmd_num_dma_cookies = 1;
13532 spx->txlt_curwin_processed_dma_cookies++;
13533 for (i = 1; (i < spx->txlt_dma_cookie_list_len) &&
13534 (i < spx->txlt_curwin_num_dma_cookies); i++) {
13535 ddi_dma_nextcookie(spx->txlt_buf_dma_handle,
13536 &spx->txlt_dma_cookie_list[i]);
13537 cur_txfer_len +=
13538 (uint64_t)spx->txlt_dma_cookie_list[i].dmac_size;
13539 spx->txlt_curwin_processed_dma_cookies++;
13540 spx->txlt_sata_pkt->
13541 satapkt_cmd.satacmd_num_dma_cookies += 1;
13542 }
13543 } else {
13544 SATADBG2(SATA_DBG_DMA_SETUP, spx->txlt_sata_hba_inst,
13545 "sata_dma_buf_setup: sliding within DMA window, "
13546 "cur cookie %d, total cookies %d\n",
13547 spx->txlt_curwin_processed_dma_cookies,
13548 spx->txlt_curwin_num_dma_cookies);
13549
13550 /*
13551 * Not all cookies from the current dma window were used because
13552 * of s/g limitation.
13553 * There is no need to re-size the list - it was set at
13554 * optimal size, or only default entry is used (s/g = 1).
13555 */
13556 if (spx->txlt_dma_cookie_list == NULL) {
13557 spx->txlt_dma_cookie_list = &spx->txlt_dma_cookie;
13558 spx->txlt_dma_cookie_list_len = 1;
13559 }
13560 /*
13561 * Since we are processing remaining cookies in a DMA window,
13562 * there may be less of them than the number of entries in the
13563 * current dma cookie list.
13564 */
13565 req_len = MIN(spx->txlt_dma_cookie_list_len,
13566 (spx->txlt_curwin_num_dma_cookies -
13567 spx->txlt_curwin_processed_dma_cookies));
13568
13569 /* Fetch the next batch of cookies */
13570 for (i = 0, cur_txfer_len = 0; i < req_len; i++) {
13571 ddi_dma_nextcookie(spx->txlt_buf_dma_handle,
13572 &spx->txlt_dma_cookie_list[i]);
13573 cur_txfer_len +=
13574 (uint64_t)spx->txlt_dma_cookie_list[i].dmac_size;
13575 spx->txlt_sata_pkt->
13576 satapkt_cmd.satacmd_num_dma_cookies++;
13577 spx->txlt_curwin_processed_dma_cookies++;
13578 }
13579 }
13580
13581 ASSERT(spx->txlt_sata_pkt->satapkt_cmd.satacmd_num_dma_cookies > 0);
13582
13583 /* Point sata_cmd to the cookie list */
13584 spx->txlt_sata_pkt->satapkt_cmd.satacmd_dma_cookie_list =
13585 &spx->txlt_dma_cookie_list[0];
13586
13587 /* Remember number of DMA cookies passed in sata packet */
13588 spx->txlt_num_dma_cookies =
13589 spx->txlt_sata_pkt->satapkt_cmd.satacmd_num_dma_cookies;
13590
13591 ASSERT(cur_txfer_len != 0);
13592 if (cur_txfer_len <= bp->b_bcount)
13593 spx->txlt_total_residue -= cur_txfer_len;
13594 else {
13595 /*
13596 * Temporary DMA buffer has been padded by
13597 * ddi_dma_mem_alloc()!
13598 * This requires special handling, because DMA cookies are
13599 * based on the temporary buffer size, not the b_bcount,
13600 * and we have extra bytes to transfer - but the packet
13601 * residue has to stay correct because we will copy only
13602 * the requested number of bytes.
13603 */
13604 spx->txlt_total_residue -= bp->b_bcount;
13605 }
13606
13607 return (DDI_SUCCESS);
13608 }
13609
13610 /*
13611 * Common routine for releasing DMA resources
13612 */
13613 static void
13614 sata_common_free_dma_rsrcs(sata_pkt_txlate_t *spx)
13615 {
13616 if (spx->txlt_buf_dma_handle != NULL) {
13617 if (spx->txlt_tmp_buf != NULL) {
13618 /*
13619 * Intermediate DMA buffer was allocated.
13620 * Free allocated buffer and associated access handle.
13621 */
13622 ddi_dma_mem_free(&spx->txlt_tmp_buf_handle);
13623 spx->txlt_tmp_buf = NULL;
13624 }
13625 /*
13626 * Free DMA resources - cookies and handles
13627 */
13628 /* ASSERT(spx->txlt_dma_cookie_list != NULL); */
13629 if (spx->txlt_dma_cookie_list != NULL) {
13630 if (spx->txlt_dma_cookie_list !=
13631 &spx->txlt_dma_cookie) {
13632 (void) kmem_free(spx->txlt_dma_cookie_list,
13633 spx->txlt_dma_cookie_list_len *
13634 sizeof (ddi_dma_cookie_t));
13635 spx->txlt_dma_cookie_list = NULL;
13636 }
13637 }
13638 (void) ddi_dma_unbind_handle(spx->txlt_buf_dma_handle);
13639 (void) ddi_dma_free_handle(&spx->txlt_buf_dma_handle);
13640 spx->txlt_buf_dma_handle = NULL;
13641 }
13642 }
13643
13644 /*
13645 * Free DMA resources
13646 * Used by the HBA driver to release DMA resources that it does not use.
13647 *
13648 * Returns Void
13649 */
13650 void
13651 sata_free_dma_resources(sata_pkt_t *sata_pkt)
13652 {
13653 sata_pkt_txlate_t *spx;
13654
13655 if (sata_pkt == NULL)
13656 return;
13657
13658 spx = (sata_pkt_txlate_t *)sata_pkt->satapkt_framework_private;
13659
13660 sata_common_free_dma_rsrcs(spx);
13661 }
13662
13663 /*
13664 * Fetch Device Identify data.
13665 * Send DEVICE IDENTIFY or IDENTIFY PACKET DEVICE (depending on a device type)
13666 * command to a device and get the device identify data.
13667 * The device_info structure has to be set to device type (for selecting proper
13668 * device identify command).
13669 *
13670 * Returns:
13671 * SATA_SUCCESS if cmd succeeded
13672 * SATA_RETRY if cmd was rejected and could be retried,
13673 * SATA_FAILURE if cmd failed and should not be retried (port error)
13674 *
13675 * Cannot be called in an interrupt context.
13676 */
13677
13678 static int
13679 sata_fetch_device_identify_data(sata_hba_inst_t *sata_hba_inst,
13680 sata_drive_info_t *sdinfo)
13681 {
13682 struct buf *bp;
13683 sata_pkt_t *spkt;
13684 sata_cmd_t *scmd;
13685 sata_pkt_txlate_t *spx;
13686 int rval;
13687 dev_info_t *dip = SATA_DIP(sata_hba_inst);
13688
13689 spx = kmem_zalloc(sizeof (sata_pkt_txlate_t), KM_SLEEP);
13690 spx->txlt_sata_hba_inst = sata_hba_inst;
13691 spx->txlt_scsi_pkt = NULL; /* No scsi pkt involved */
13692 spkt = sata_pkt_alloc(spx, SLEEP_FUNC);
13693 if (spkt == NULL) {
13694 kmem_free(spx, sizeof (sata_pkt_txlate_t));
13695 return (SATA_RETRY); /* may retry later */
13696 }
13697 /* address is needed now */
13698 spkt->satapkt_device.satadev_addr = sdinfo->satadrv_addr;
13699
13700 /*
13701 * Allocate buffer for Identify Data return data
13702 */
13703 bp = sata_alloc_local_buffer(spx, sizeof (sata_id_t));
13704 if (bp == NULL) {
13705 sata_pkt_free(spx);
13706 kmem_free(spx, sizeof (sata_pkt_txlate_t));
13707 SATA_LOG_D((sata_hba_inst, CE_WARN,
13708 "sata_fetch_device_identify_data: "
13709 "cannot allocate buffer for ID"));
13710 return (SATA_RETRY); /* may retry later */
13711 }
13712
13713 /* Fill sata_pkt */
13714 sdinfo->satadrv_state = SATA_STATE_PROBING;
13715 spkt->satapkt_device.satadev_addr = sdinfo->satadrv_addr;
13716 spkt->satapkt_op_mode = SATA_OPMODE_SYNCH | SATA_OPMODE_INTERRUPTS;
13717 /* Synchronous mode, no callback */
13718 spkt->satapkt_comp = NULL;
13719 /* Timeout 30s */
13720 spkt->satapkt_time = sata_default_pkt_time;
13721
13722 scmd = &spkt->satapkt_cmd;
13723 scmd->satacmd_bp = bp;
13724 scmd->satacmd_flags.sata_data_direction = SATA_DIR_READ;
13725 scmd->satacmd_flags.sata_ignore_dev_reset = B_TRUE;
13726
13727 /* Build Identify Device cmd in the sata_pkt */
13728 scmd->satacmd_addr_type = 0; /* N/A */
13729 scmd->satacmd_sec_count_lsb = 0; /* N/A */
13730 scmd->satacmd_lba_low_lsb = 0; /* N/A */
13731 scmd->satacmd_lba_mid_lsb = 0; /* N/A */
13732 scmd->satacmd_lba_high_lsb = 0; /* N/A */
13733 scmd->satacmd_features_reg = 0; /* N/A */
13734 scmd->satacmd_device_reg = 0; /* Always device 0 */
13735 if (sdinfo->satadrv_type & SATA_DTYPE_ATAPI) {
13736 /* Identify Packet Device cmd */
13737 scmd->satacmd_cmd_reg = SATAC_ID_PACKET_DEVICE;
13738 } else {
13739 /* Identify Device cmd - mandatory for all other devices */
13740 scmd->satacmd_cmd_reg = SATAC_ID_DEVICE;
13741 }
13742
13743 /* Send pkt to SATA HBA driver */
13744 rval = (*SATA_START_FUNC(sata_hba_inst))(SATA_DIP(sata_hba_inst), spkt);
13745
13746 #ifdef SATA_INJECT_FAULTS
13747 sata_inject_pkt_fault(spkt, &rval, sata_fault_type);
13748 #endif
13749
13750 if (rval == SATA_TRAN_ACCEPTED &&
13751 spkt->satapkt_reason == SATA_PKT_COMPLETED) {
13752 if (spx->txlt_buf_dma_handle != NULL) {
13753 rval = ddi_dma_sync(spx->txlt_buf_dma_handle, 0, 0,
13754 DDI_DMA_SYNC_FORKERNEL);
13755 ASSERT(rval == DDI_SUCCESS);
13756 if (sata_check_for_dma_error(dip, spx)) {
13757 ddi_fm_service_impact(dip,
13758 DDI_SERVICE_UNAFFECTED);
13759 rval = SATA_RETRY;
13760 goto fail;
13761 }
13762
13763 }
13764 if ((((sata_id_t *)(bp->b_un.b_addr))->ai_config &
13765 SATA_INCOMPLETE_DATA) == SATA_INCOMPLETE_DATA) {
13766 SATA_LOG_D((sata_hba_inst, CE_WARN,
13767 "SATA disk device at port %d - "
13768 "partial Identify Data",
13769 sdinfo->satadrv_addr.cport));
13770 rval = SATA_RETRY; /* may retry later */
13771 goto fail;
13772 }
13773 /* Update sata_drive_info */
13774 bcopy(bp->b_un.b_addr, &sdinfo->satadrv_id,
13775 sizeof (sata_id_t));
13776
13777 sdinfo->satadrv_features_support = 0;
13778 if (sdinfo->satadrv_type == SATA_DTYPE_ATADISK) {
13779 /*
13780 * Retrieve capacity (disks only) and addressing mode
13781 */
13782 sdinfo->satadrv_capacity = sata_check_capacity(sdinfo);
13783 } else {
13784 /*
13785 * For ATAPI devices one would have to issue
13786 * Get Capacity cmd for media capacity. Not here.
13787 */
13788 sdinfo->satadrv_capacity = 0;
13789 /*
13790 * Check what cdb length is supported
13791 */
13792 if ((sdinfo->satadrv_id.ai_config &
13793 SATA_ATAPI_ID_PKT_SZ) == SATA_ATAPI_ID_PKT_16B)
13794 sdinfo->satadrv_atapi_cdb_len = 16;
13795 else
13796 sdinfo->satadrv_atapi_cdb_len = 12;
13797 }
13798 /* Setup supported features flags */
13799 if (sdinfo->satadrv_id.ai_cap & SATA_DMA_SUPPORT)
13800 sdinfo->satadrv_features_support |= SATA_DEV_F_DMA;
13801
13802 /* Check for SATA GEN and NCQ support */
13803 if (sdinfo->satadrv_id.ai_satacap != 0 &&
13804 sdinfo->satadrv_id.ai_satacap != 0xffff) {
13805 /* SATA compliance */
13806 if (sdinfo->satadrv_id.ai_satacap & SATA_NCQ)
13807 sdinfo->satadrv_features_support |=
13808 SATA_DEV_F_NCQ;
13809 if (sdinfo->satadrv_id.ai_satacap &
13810 (SATA_1_SPEED | SATA_2_SPEED | SATA_3_SPEED)) {
13811 if (sdinfo->satadrv_id.ai_satacap &
13812 SATA_3_SPEED)
13813 sdinfo->satadrv_features_support |=
13814 SATA_DEV_F_SATA3;
13815 if (sdinfo->satadrv_id.ai_satacap &
13816 SATA_2_SPEED)
13817 sdinfo->satadrv_features_support |=
13818 SATA_DEV_F_SATA2;
13819 if (sdinfo->satadrv_id.ai_satacap &
13820 SATA_1_SPEED)
13821 sdinfo->satadrv_features_support |=
13822 SATA_DEV_F_SATA1;
13823 } else {
13824 sdinfo->satadrv_features_support |=
13825 SATA_DEV_F_SATA1;
13826 }
13827 }
13828 if ((sdinfo->satadrv_id.ai_cmdset83 & SATA_RW_DMA_QUEUED_CMD) &&
13829 (sdinfo->satadrv_id.ai_features86 & SATA_RW_DMA_QUEUED_CMD))
13830 sdinfo->satadrv_features_support |= SATA_DEV_F_TCQ;
13831
13832 sdinfo->satadrv_queue_depth = sdinfo->satadrv_id.ai_qdepth;
13833 if ((sdinfo->satadrv_features_support & SATA_DEV_F_NCQ) ||
13834 (sdinfo->satadrv_features_support & SATA_DEV_F_TCQ)) {
13835 ++sdinfo->satadrv_queue_depth;
13836 /* Adjust according to controller capabilities */
13837 sdinfo->satadrv_max_queue_depth = MIN(
13838 sdinfo->satadrv_queue_depth,
13839 SATA_QDEPTH(sata_hba_inst));
13840 /* Adjust according to global queue depth limit */
13841 sdinfo->satadrv_max_queue_depth = MIN(
13842 sdinfo->satadrv_max_queue_depth,
13843 sata_current_max_qdepth);
13844 if (sdinfo->satadrv_max_queue_depth == 0)
13845 sdinfo->satadrv_max_queue_depth = 1;
13846 } else
13847 sdinfo->satadrv_max_queue_depth = 1;
13848
13849 rval = SATA_SUCCESS;
13850 } else {
13851 /*
13852 * Woops, no Identify Data.
13853 */
13854 if (rval == SATA_TRAN_BUSY || rval == SATA_TRAN_QUEUE_FULL) {
13855 rval = SATA_RETRY; /* may retry later */
13856 } else if (rval == SATA_TRAN_ACCEPTED) {
13857 if (spkt->satapkt_reason == SATA_PKT_DEV_ERROR ||
13858 spkt->satapkt_reason == SATA_PKT_ABORTED ||
13859 spkt->satapkt_reason == SATA_PKT_TIMEOUT ||
13860 spkt->satapkt_reason == SATA_PKT_RESET)
13861 rval = SATA_RETRY; /* may retry later */
13862 else
13863 rval = SATA_FAILURE;
13864 } else {
13865 rval = SATA_FAILURE;
13866 }
13867 }
13868 fail:
13869 /* Free allocated resources */
13870 sata_free_local_buffer(spx);
13871 sata_pkt_free(spx);
13872 kmem_free(spx, sizeof (sata_pkt_txlate_t));
13873
13874 return (rval);
13875 }
13876
13877
13878 /*
13879 * Some devices may not come-up with default DMA mode (UDMA or MWDMA).
13880 * UDMA mode is checked first, followed by MWDMA mode.
13881 * set correctly, so this function is setting it to the highest supported level.
13882 * Older SATA spec required that the device supports at least DMA 4 mode and
13883 * UDMA mode is selected. It is not mentioned in SerialATA 2.6, so this
13884 * restriction has been removed.
13885 *
13886 * Returns SATA_SUCCESS if proper DMA mode is selected or no DMA is supported.
13887 * Returns SATA_FAILURE if proper DMA mode could not be selected.
13888 *
13889 * NOTE: This function should be called only if DMA mode is supported.
13890 */
13891 static int
13892 sata_set_dma_mode(sata_hba_inst_t *sata_hba_inst, sata_drive_info_t *sdinfo)
13893 {
13894 sata_pkt_t *spkt;
13895 sata_cmd_t *scmd;
13896 sata_pkt_txlate_t *spx;
13897 int i, mode;
13898 uint8_t subcmd;
13899 int rval = SATA_SUCCESS;
13900
13901 ASSERT(sdinfo != NULL);
13902 ASSERT(sata_hba_inst != NULL);
13903
13904 if ((sdinfo->satadrv_id.ai_validinfo & SATA_VALIDINFO_88) != 0 &&
13905 (sdinfo->satadrv_id.ai_ultradma & SATA_UDMA_SUP_MASK) != 0) {
13906 /* Find highest Ultra DMA mode supported */
13907 for (mode = 6; mode >= 0; --mode) {
13908 if (sdinfo->satadrv_id.ai_ultradma & (1 << mode))
13909 break;
13910 }
13911 #if 0
13912 /* Left for historical reasons */
13913 /*
13914 * Some initial version of SATA spec indicated that at least
13915 * UDMA mode 4 has to be supported. It is not mentioned in
13916 * SerialATA 2.6, so this restriction is removed.
13917 */
13918 if (mode < 4)
13919 return (SATA_FAILURE);
13920 #endif
13921
13922 /*
13923 * For disk, we're still going to set DMA mode whatever is
13924 * selected by default
13925 *
13926 * We saw an old maxtor sata drive will select Ultra DMA and
13927 * Multi-Word DMA simultaneouly by default, which is going
13928 * to cause DMA command timed out, so we need to select DMA
13929 * mode even when it's already done by default
13930 */
13931 if (sdinfo->satadrv_type != SATA_DTYPE_ATADISK) {
13932
13933 /* Find UDMA mode currently selected */
13934 for (i = 6; i >= 0; --i) {
13935 if (sdinfo->satadrv_id.ai_ultradma &
13936 (1 << (i + 8)))
13937 break;
13938 }
13939 if (i >= mode)
13940 /* Nothing to do */
13941 return (SATA_SUCCESS);
13942 }
13943
13944 subcmd = SATAC_TRANSFER_MODE_ULTRA_DMA;
13945
13946 } else if ((sdinfo->satadrv_id.ai_dworddma & SATA_MDMA_SUP_MASK) != 0) {
13947 /* Find highest MultiWord DMA mode supported */
13948 for (mode = 2; mode >= 0; --mode) {
13949 if (sdinfo->satadrv_id.ai_dworddma & (1 << mode))
13950 break;
13951 }
13952
13953 /*
13954 * For disk, We're still going to set DMA mode whatever is
13955 * selected by default
13956 *
13957 * We saw an old maxtor sata drive will select Ultra DMA and
13958 * Multi-Word DMA simultaneouly by default, which is going
13959 * to cause DMA command timed out, so we need to select DMA
13960 * mode even when it's already done by default
13961 */
13962 if (sdinfo->satadrv_type != SATA_DTYPE_ATADISK) {
13963
13964 /* Find highest MultiWord DMA mode selected */
13965 for (i = 2; i >= 0; --i) {
13966 if (sdinfo->satadrv_id.ai_dworddma &
13967 (1 << (i + 8)))
13968 break;
13969 }
13970 if (i >= mode)
13971 /* Nothing to do */
13972 return (SATA_SUCCESS);
13973 }
13974
13975 subcmd = SATAC_TRANSFER_MODE_MULTI_WORD_DMA;
13976 } else
13977 return (SATA_SUCCESS);
13978
13979 /*
13980 * Set DMA mode via SET FEATURES COMMAND.
13981 * Prepare packet for SET FEATURES COMMAND.
13982 */
13983 spx = kmem_zalloc(sizeof (sata_pkt_txlate_t), KM_SLEEP);
13984 spx->txlt_sata_hba_inst = sata_hba_inst;
13985 spx->txlt_scsi_pkt = NULL; /* No scsi pkt involved */
13986 spkt = sata_pkt_alloc(spx, SLEEP_FUNC);
13987 if (spkt == NULL) {
13988 SATA_LOG_D((sata_hba_inst, CE_WARN,
13989 "sata_set_dma_mode: could not set DMA mode %d", mode));
13990 rval = SATA_FAILURE;
13991 goto done;
13992 }
13993 /* Fill sata_pkt */
13994 spkt->satapkt_device.satadev_addr = sdinfo->satadrv_addr;
13995 /* Timeout 30s */
13996 spkt->satapkt_time = sata_default_pkt_time;
13997 /* Synchronous mode, no callback, interrupts */
13998 spkt->satapkt_op_mode = SATA_OPMODE_SYNCH | SATA_OPMODE_INTERRUPTS;
13999 spkt->satapkt_comp = NULL;
14000 scmd = &spkt->satapkt_cmd;
14001 scmd->satacmd_flags.sata_data_direction = SATA_DIR_NODATA_XFER;
14002 scmd->satacmd_flags.sata_ignore_dev_reset = B_TRUE;
14003 scmd->satacmd_addr_type = 0;
14004 scmd->satacmd_device_reg = 0;
14005 scmd->satacmd_status_reg = 0;
14006 scmd->satacmd_error_reg = 0;
14007 scmd->satacmd_cmd_reg = SATAC_SET_FEATURES;
14008 scmd->satacmd_features_reg = SATAC_SF_TRANSFER_MODE;
14009 scmd->satacmd_sec_count_lsb = subcmd | mode;
14010
14011 /* Transfer command to HBA */
14012 if ((*SATA_START_FUNC(sata_hba_inst))(SATA_DIP(sata_hba_inst),
14013 spkt) != SATA_TRAN_ACCEPTED ||
14014 spkt->satapkt_reason != SATA_PKT_COMPLETED) {
14015 /* Pkt execution failed */
14016 rval = SATA_FAILURE;
14017 }
14018 done:
14019
14020 /* Free allocated resources */
14021 if (spkt != NULL)
14022 sata_pkt_free(spx);
14023 (void) kmem_free(spx, sizeof (sata_pkt_txlate_t));
14024
14025 return (rval);
14026 }
14027
14028
14029 /*
14030 * Set device caching mode.
14031 * One of the following operations should be specified:
14032 * SATAC_SF_ENABLE_READ_AHEAD
14033 * SATAC_SF_DISABLE_READ_AHEAD
14034 * SATAC_SF_ENABLE_WRITE_CACHE
14035 * SATAC_SF_DISABLE_WRITE_CACHE
14036 *
14037 * If operation fails, system log messgage is emitted.
14038 * Returns SATA_SUCCESS when the operation succeeds, SATA_RETRY if
14039 * command was sent but did not succeed, and SATA_FAILURE otherwise.
14040 */
14041
14042 static int
14043 sata_set_cache_mode(sata_hba_inst_t *sata_hba_inst, sata_drive_info_t *sdinfo,
14044 int cache_op)
14045 {
14046 sata_pkt_t *spkt;
14047 sata_cmd_t *scmd;
14048 sata_pkt_txlate_t *spx;
14049 int rval = SATA_SUCCESS;
14050 int hba_rval;
14051 char *infop;
14052
14053 ASSERT(sdinfo != NULL);
14054 ASSERT(sata_hba_inst != NULL);
14055 ASSERT(cache_op == SATAC_SF_ENABLE_READ_AHEAD ||
14056 cache_op == SATAC_SF_DISABLE_READ_AHEAD ||
14057 cache_op == SATAC_SF_ENABLE_WRITE_CACHE ||
14058 cache_op == SATAC_SF_DISABLE_WRITE_CACHE);
14059
14060
14061 /* Prepare packet for SET FEATURES COMMAND */
14062 spx = kmem_zalloc(sizeof (sata_pkt_txlate_t), KM_SLEEP);
14063 spx->txlt_sata_hba_inst = sata_hba_inst;
14064 spx->txlt_scsi_pkt = NULL; /* No scsi pkt involved */
14065 spkt = sata_pkt_alloc(spx, SLEEP_FUNC);
14066 if (spkt == NULL) {
14067 rval = SATA_FAILURE;
14068 goto failure;
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 =
14076 SATA_OPMODE_SYNCH | SATA_OPMODE_INTERRUPTS;
14077 spkt->satapkt_comp = NULL;
14078 scmd = &spkt->satapkt_cmd;
14079 scmd->satacmd_flags.sata_data_direction = SATA_DIR_NODATA_XFER;
14080 scmd->satacmd_flags.sata_ignore_dev_reset = B_TRUE;
14081 scmd->satacmd_addr_type = 0;
14082 scmd->satacmd_device_reg = 0;
14083 scmd->satacmd_status_reg = 0;
14084 scmd->satacmd_error_reg = 0;
14085 scmd->satacmd_cmd_reg = SATAC_SET_FEATURES;
14086 scmd->satacmd_features_reg = cache_op;
14087
14088 /* Transfer command to HBA */
14089 hba_rval = (*SATA_START_FUNC(sata_hba_inst))(
14090 SATA_DIP(sata_hba_inst), spkt);
14091
14092 #ifdef SATA_INJECT_FAULTS
14093 sata_inject_pkt_fault(spkt, &rval, sata_fault_type);
14094 #endif
14095
14096 if ((hba_rval != SATA_TRAN_ACCEPTED) ||
14097 (spkt->satapkt_reason != SATA_PKT_COMPLETED)) {
14098 /* Pkt execution failed */
14099 switch (cache_op) {
14100 case SATAC_SF_ENABLE_READ_AHEAD:
14101 infop = "enabling read ahead failed";
14102 break;
14103 case SATAC_SF_DISABLE_READ_AHEAD:
14104 infop = "disabling read ahead failed";
14105 break;
14106 case SATAC_SF_ENABLE_WRITE_CACHE:
14107 infop = "enabling write cache failed";
14108 break;
14109 case SATAC_SF_DISABLE_WRITE_CACHE:
14110 infop = "disabling write cache failed";
14111 break;
14112 }
14113 SATA_LOG_D((sata_hba_inst, CE_WARN, "%s", infop));
14114 rval = SATA_RETRY;
14115 }
14116 failure:
14117 /* Free allocated resources */
14118 if (spkt != NULL)
14119 sata_pkt_free(spx);
14120 (void) kmem_free(spx, sizeof (sata_pkt_txlate_t));
14121 return (rval);
14122 }
14123
14124 /*
14125 * Set Removable Media Status Notification (enable/disable)
14126 * state == 0 , disable
14127 * state != 0 , enable
14128 *
14129 * If operation fails, system log messgage is emitted.
14130 * Returns SATA_SUCCESS when the operation succeeds, SATA_FAILURE otherwise.
14131 */
14132
14133 static int
14134 sata_set_rmsn(sata_hba_inst_t *sata_hba_inst, sata_drive_info_t *sdinfo,
14135 int state)
14136 {
14137 sata_pkt_t *spkt;
14138 sata_cmd_t *scmd;
14139 sata_pkt_txlate_t *spx;
14140 int rval = SATA_SUCCESS;
14141 char *infop;
14142
14143 ASSERT(sdinfo != NULL);
14144 ASSERT(sata_hba_inst != NULL);
14145
14146 /* Prepare packet for SET FEATURES COMMAND */
14147 spx = kmem_zalloc(sizeof (sata_pkt_txlate_t), KM_SLEEP);
14148 spx->txlt_sata_hba_inst = sata_hba_inst;
14149 spx->txlt_scsi_pkt = NULL; /* No scsi pkt involved */
14150 spkt = sata_pkt_alloc(spx, SLEEP_FUNC);
14151 if (spkt == NULL) {
14152 rval = SATA_FAILURE;
14153 goto failure;
14154 }
14155 /* Fill sata_pkt */
14156 spkt->satapkt_device.satadev_addr = sdinfo->satadrv_addr;
14157 /* Timeout 30s */
14158 spkt->satapkt_time = sata_default_pkt_time;
14159 /* Synchronous mode, no callback, interrupts */
14160 spkt->satapkt_op_mode =
14161 SATA_OPMODE_SYNCH | SATA_OPMODE_INTERRUPTS;
14162 spkt->satapkt_comp = NULL;
14163 scmd = &spkt->satapkt_cmd;
14164 scmd->satacmd_flags.sata_data_direction = SATA_DIR_NODATA_XFER;
14165 scmd->satacmd_flags.sata_ignore_dev_reset = B_TRUE;
14166 scmd->satacmd_addr_type = 0;
14167 scmd->satacmd_device_reg = 0;
14168 scmd->satacmd_status_reg = 0;
14169 scmd->satacmd_error_reg = 0;
14170 scmd->satacmd_cmd_reg = SATAC_SET_FEATURES;
14171 if (state == 0)
14172 scmd->satacmd_features_reg = SATAC_SF_DISABLE_RMSN;
14173 else
14174 scmd->satacmd_features_reg = SATAC_SF_ENABLE_RMSN;
14175
14176 /* Transfer command to HBA */
14177 if (((*SATA_START_FUNC(sata_hba_inst))(
14178 SATA_DIP(sata_hba_inst), spkt) != SATA_TRAN_ACCEPTED) ||
14179 (spkt->satapkt_reason != SATA_PKT_COMPLETED)) {
14180 /* Pkt execution failed */
14181 if (state == 0)
14182 infop = "disabling Removable Media Status "
14183 "Notification failed";
14184 else
14185 infop = "enabling Removable Media Status "
14186 "Notification failed";
14187
14188 SATA_LOG_D((sata_hba_inst, CE_WARN, "%s", infop));
14189 rval = SATA_FAILURE;
14190 }
14191 failure:
14192 /* Free allocated resources */
14193 if (spkt != NULL)
14194 sata_pkt_free(spx);
14195 (void) kmem_free(spx, sizeof (sata_pkt_txlate_t));
14196 return (rval);
14197 }
14198
14199
14200 /*
14201 * Update state and copy port ss* values from passed sata_device structure.
14202 * sata_address is validated - if not valid, nothing is changed in sata_scsi
14203 * configuration struct.
14204 *
14205 * SATA_PSTATE_SHUTDOWN in port state is not reset to 0 by this function
14206 * regardless of the state in device argument.
14207 *
14208 * Port mutex should be held while calling this function.
14209 */
14210 static void
14211 sata_update_port_info(sata_hba_inst_t *sata_hba_inst,
14212 sata_device_t *sata_device)
14213 {
14214 sata_cport_info_t *cportinfo;
14215
14216 if (sata_device->satadev_addr.qual == SATA_ADDR_CPORT ||
14217 sata_device->satadev_addr.qual == SATA_ADDR_DCPORT) {
14218 if (SATA_NUM_CPORTS(sata_hba_inst) <=
14219 sata_device->satadev_addr.cport)
14220 return;
14221
14222 cportinfo = SATA_CPORT_INFO(sata_hba_inst,
14223 sata_device->satadev_addr.cport);
14224
14225 ASSERT(mutex_owned(&cportinfo->cport_mutex));
14226 cportinfo->cport_scr = sata_device->satadev_scr;
14227
14228 /* Preserve SATA_PSTATE_SHUTDOWN flag */
14229 cportinfo->cport_state &= ~(SATA_PSTATE_PWRON |
14230 SATA_PSTATE_PWROFF | SATA_PSTATE_FAILED);
14231 cportinfo->cport_state |=
14232 sata_device->satadev_state & SATA_PSTATE_VALID;
14233 }
14234 }
14235
14236 void
14237 sata_update_pmport_info(sata_hba_inst_t *sata_hba_inst,
14238 sata_device_t *sata_device)
14239 {
14240 sata_pmport_info_t *pmportinfo;
14241
14242 if ((sata_device->satadev_addr.qual != SATA_ADDR_PMPORT &&
14243 sata_device->satadev_addr.qual != SATA_ADDR_DPMPORT) ||
14244 SATA_NUM_PMPORTS(sata_hba_inst,
14245 sata_device->satadev_addr.cport) <
14246 sata_device->satadev_addr.pmport) {
14247 SATADBG1(SATA_DBG_PMULT, sata_hba_inst,
14248 "sata_update_port_info: error address %p.",
14249 &sata_device->satadev_addr);
14250 return;
14251 }
14252
14253 pmportinfo = SATA_PMPORT_INFO(sata_hba_inst,
14254 sata_device->satadev_addr.cport,
14255 sata_device->satadev_addr.pmport);
14256
14257 ASSERT(mutex_owned(&pmportinfo->pmport_mutex));
14258 pmportinfo->pmport_scr = sata_device->satadev_scr;
14259
14260 /* Preserve SATA_PSTATE_SHUTDOWN flag */
14261 pmportinfo->pmport_state &=
14262 ~(SATA_PSTATE_PWRON | SATA_PSTATE_PWROFF | SATA_PSTATE_FAILED);
14263 pmportinfo->pmport_state |=
14264 sata_device->satadev_state & SATA_PSTATE_VALID;
14265 }
14266
14267 /*
14268 * Extract SATA port specification from an IOCTL argument.
14269 *
14270 * This function return the port the user land send us as is, unless it
14271 * cannot retrieve port spec, then -1 is returned.
14272 *
14273 * Support port multiplier.
14274 */
14275 static int32_t
14276 sata_get_port_num(sata_hba_inst_t *sata_hba_inst, struct devctl_iocdata *dcp)
14277 {
14278 int32_t port;
14279
14280 /* Extract port number from nvpair in dca structure */
14281 if (nvlist_lookup_int32(ndi_dc_get_ap_data(dcp), "port", &port) != 0) {
14282 SATA_LOG_D((sata_hba_inst, CE_NOTE,
14283 "sata_get_port_num: invalid port spec 0x%x in ioctl",
14284 port));
14285 port = -1;
14286 }
14287
14288 return (port);
14289 }
14290
14291 /*
14292 * Get dev_info_t pointer to the device node pointed to by port argument.
14293 * NOTE: target argument is a value used in ioctls to identify
14294 * the AP - it is not a sata_address.
14295 * It is a combination of cport, pmport and address qualifier, encodded same
14296 * way as a scsi target number.
14297 * At this moment it carries only cport number.
14298 *
14299 * PMult hotplug is supported now.
14300 *
14301 * Returns dev_info_t pointer if target device was found, NULL otherwise.
14302 */
14303
14304 static dev_info_t *
14305 sata_get_target_dip(dev_info_t *dip, uint8_t cport, uint8_t pmport)
14306 {
14307 dev_info_t *cdip = NULL;
14308 int target, tgt;
14309 int circ;
14310 uint8_t qual;
14311
14312 sata_hba_inst_t *sata_hba_inst;
14313 scsi_hba_tran_t *scsi_hba_tran;
14314
14315 /* Get target id */
14316 scsi_hba_tran = ddi_get_driver_private(dip);
14317 if (scsi_hba_tran == NULL)
14318 return (NULL);
14319
14320 sata_hba_inst = scsi_hba_tran->tran_hba_private;
14321
14322 if (sata_hba_inst == NULL)
14323 return (NULL);
14324
14325 /* Identify a port-mult by cport_info.cport_dev_type */
14326 if (SATA_CPORT_DEV_TYPE(sata_hba_inst, cport) == SATA_DTYPE_PMULT)
14327 qual = SATA_ADDR_DPMPORT;
14328 else
14329 qual = SATA_ADDR_DCPORT;
14330
14331 target = SATA_TO_SCSI_TARGET(cport, pmport, qual);
14332
14333 /* Retrieve target dip */
14334 ndi_devi_enter(dip, &circ);
14335 for (cdip = ddi_get_child(dip); cdip != NULL; ) {
14336 dev_info_t *next = ddi_get_next_sibling(cdip);
14337
14338 tgt = ddi_prop_get_int(DDI_DEV_T_ANY, cdip,
14339 DDI_PROP_DONTPASS, "target", -1);
14340 if (tgt == -1) {
14341 /*
14342 * This is actually an error condition, but not
14343 * a fatal one. Just continue the search.
14344 */
14345 cdip = next;
14346 continue;
14347 }
14348
14349 if (tgt == target)
14350 break;
14351
14352 cdip = next;
14353 }
14354 ndi_devi_exit(dip, circ);
14355
14356 return (cdip);
14357 }
14358
14359 /*
14360 * Get dev_info_t pointer to the device node pointed to by port argument.
14361 * NOTE: target argument is a value used in ioctls to identify
14362 * the AP - it is not a sata_address.
14363 * It is a combination of cport, pmport and address qualifier, encoded same
14364 * way as a scsi target number.
14365 *
14366 * Returns dev_info_t pointer if target device was found, NULL otherwise.
14367 */
14368
14369 static dev_info_t *
14370 sata_get_scsi_target_dip(dev_info_t *dip, sata_address_t *saddr)
14371 {
14372 dev_info_t *cdip = NULL;
14373 int target, tgt;
14374 int circ;
14375
14376 target = SATA_TO_SCSI_TARGET(saddr->cport, saddr->pmport, saddr->qual);
14377
14378 ndi_devi_enter(dip, &circ);
14379 for (cdip = ddi_get_child(dip); cdip != NULL; ) {
14380 dev_info_t *next = ddi_get_next_sibling(cdip);
14381
14382 tgt = ddi_prop_get_int(DDI_DEV_T_ANY, cdip,
14383 DDI_PROP_DONTPASS, "target", -1);
14384 if (tgt == -1) {
14385 /*
14386 * This is actually an error condition, but not
14387 * a fatal one. Just continue the search.
14388 */
14389 cdip = next;
14390 continue;
14391 }
14392
14393 if (tgt == target)
14394 break;
14395
14396 cdip = next;
14397 }
14398 ndi_devi_exit(dip, circ);
14399
14400 return (cdip);
14401 }
14402
14403 /*
14404 * Process sata port disconnect request.
14405 * Normally, cfgadm sata plugin will try to offline (unconfigure) the device
14406 * before this request. Nevertheless, if a device is still configured,
14407 * we need to attempt to offline and unconfigure device.
14408 * Regardless of the unconfigure operation results the port is marked as
14409 * deactivated and no access to the attached device is possible.
14410 * If the target node remains because unconfigure operation failed, its state
14411 * will be set to DEVICE_REMOVED, preventing it to be used again when a device
14412 * is inserted/re-inserted. The event daemon will repeatedly try to unconfigure
14413 * the device and remove old target node.
14414 *
14415 * This function invokes sata_hba_inst->satahba_tran->
14416 * sata_tran_hotplug_ops->sata_tran_port_deactivate().
14417 * If successful, the device structure (if any) attached to the specified port
14418 * is removed and state of the port marked appropriately.
14419 * Failure of the port_deactivate may keep port in the physically active state,
14420 * or may fail the port.
14421 *
14422 * NOTE: Port multiplier is supported.
14423 */
14424
14425 static int
14426 sata_ioctl_disconnect(sata_hba_inst_t *sata_hba_inst,
14427 sata_device_t *sata_device)
14428 {
14429 sata_drive_info_t *sdinfo = NULL, *subsdinfo = NULL;
14430 sata_cport_info_t *cportinfo = NULL;
14431 sata_pmport_info_t *pmportinfo = NULL;
14432 sata_pmult_info_t *pmultinfo = NULL;
14433 sata_device_t subsdevice;
14434 int cport, pmport, qual;
14435 int rval = SATA_SUCCESS;
14436 int npmport = 0;
14437 int rv = 0;
14438
14439 cport = sata_device->satadev_addr.cport;
14440 pmport = sata_device->satadev_addr.pmport;
14441 qual = sata_device->satadev_addr.qual;
14442
14443 ASSERT(qual == SATA_ADDR_DCPORT || qual == SATA_ADDR_DPMPORT);
14444 if (qual == SATA_ADDR_DCPORT)
14445 qual = SATA_ADDR_CPORT;
14446 else
14447 qual = SATA_ADDR_PMPORT;
14448
14449 /*
14450 * DEVCTL_AP_DISCONNECT invokes sata_hba_inst->satahba_tran->
14451 * sata_tran_hotplug_ops->sata_tran_port_deactivate().
14452 * Do the sanity check.
14453 */
14454 if (SATA_PORT_DEACTIVATE_FUNC(sata_hba_inst) == NULL) {
14455 /* No physical port deactivation supported. */
14456 return (EINVAL);
14457 }
14458
14459 /* Check the current state of the port */
14460 rval = (*SATA_PROBE_PORT_FUNC(sata_hba_inst))
14461 (SATA_DIP(sata_hba_inst), sata_device);
14462
14463 cportinfo = SATA_CPORT_INFO(sata_hba_inst, cport);
14464
14465 /*
14466 * Processing port mulitiplier
14467 */
14468 if (qual == SATA_ADDR_CPORT &&
14469 SATA_CPORT_DEV_TYPE(sata_hba_inst, cport) == SATA_DTYPE_PMULT) {
14470 mutex_enter(&cportinfo->cport_mutex);
14471
14472 /* Check controller port status */
14473 sata_update_port_info(sata_hba_inst, sata_device);
14474 if (rval != SATA_SUCCESS ||
14475 (sata_device->satadev_state & SATA_PSTATE_FAILED) != 0) {
14476 /*
14477 * Device port status is unknown or it is in failed
14478 * state
14479 */
14480 SATA_CPORT_STATE(sata_hba_inst, cport) =
14481 SATA_PSTATE_FAILED;
14482 SATADBG1(SATA_DBG_IOCTL_IF, sata_hba_inst,
14483 "sata_hba_ioctl: connect: failed to deactivate "
14484 "SATA port %d", cport);
14485 mutex_exit(&cportinfo->cport_mutex);
14486 return (EIO);
14487 }
14488
14489 /* Disconnect all sub-devices. */
14490 pmultinfo = SATA_CPORTINFO_PMULT_INFO(cportinfo);
14491 if (pmultinfo != NULL) {
14492
14493 for (npmport = 0; npmport < SATA_NUM_PMPORTS(
14494 sata_hba_inst, cport); npmport ++) {
14495 subsdinfo = SATA_PMPORT_DRV_INFO(
14496 sata_hba_inst, cport, npmport);
14497 if (subsdinfo == NULL)
14498 continue;
14499
14500 subsdevice.satadev_addr = subsdinfo->
14501 satadrv_addr;
14502
14503 mutex_exit(&cportinfo->cport_mutex);
14504 if (sata_ioctl_disconnect(sata_hba_inst,
14505 &subsdevice) == SATA_SUCCESS) {
14506 SATADBG2(SATA_DBG_PMULT, sata_hba_inst,
14507 "[Remove] device at port %d:%d "
14508 "successfully.", cport, npmport);
14509 }
14510 mutex_enter(&cportinfo->cport_mutex);
14511 }
14512 }
14513
14514 /* Disconnect the port multiplier */
14515 cportinfo->cport_state &= ~SATA_STATE_READY;
14516 mutex_exit(&cportinfo->cport_mutex);
14517
14518 sata_device->satadev_addr.qual = qual;
14519 rval = (*SATA_PORT_DEACTIVATE_FUNC(sata_hba_inst))
14520 (SATA_DIP(sata_hba_inst), sata_device);
14521
14522 sata_gen_sysevent(sata_hba_inst, &sata_device->satadev_addr,
14523 SE_NO_HINT);
14524
14525 mutex_enter(&cportinfo->cport_mutex);
14526 sata_update_port_info(sata_hba_inst, sata_device);
14527 if (rval != SATA_SUCCESS &&
14528 sata_device->satadev_state & SATA_PSTATE_FAILED) {
14529 cportinfo->cport_state = SATA_PSTATE_FAILED;
14530 rv = EIO;
14531 } else {
14532 cportinfo->cport_state |= SATA_PSTATE_SHUTDOWN;
14533 }
14534 mutex_exit(&cportinfo->cport_mutex);
14535
14536 return (rv);
14537 }
14538
14539 /*
14540 * Process non-port-multiplier device - it could be a drive connected
14541 * to a port multiplier port or a controller port.
14542 */
14543 if (qual == SATA_ADDR_PMPORT) {
14544 pmportinfo = SATA_PMPORT_INFO(sata_hba_inst, cport, pmport);
14545 mutex_enter(&pmportinfo->pmport_mutex);
14546 sata_update_pmport_info(sata_hba_inst, sata_device);
14547 if (rval != SATA_SUCCESS ||
14548 (sata_device->satadev_state & SATA_PSTATE_FAILED) != 0) {
14549 SATA_PMPORT_STATE(sata_hba_inst, cport, pmport) =
14550 SATA_PSTATE_FAILED;
14551 SATADBG2(SATA_DBG_IOCTL_IF, sata_hba_inst,
14552 "sata_hba_ioctl: connect: failed to deactivate "
14553 "SATA port %d:%d", cport, pmport);
14554 mutex_exit(&pmportinfo->pmport_mutex);
14555 return (EIO);
14556 }
14557
14558 if (pmportinfo->pmport_dev_type != SATA_DTYPE_NONE) {
14559 sdinfo = pmportinfo->pmport_sata_drive;
14560 ASSERT(sdinfo != NULL);
14561 }
14562
14563 /*
14564 * Set port's dev_state to not ready - this will disable
14565 * an access to a potentially attached device.
14566 */
14567 pmportinfo->pmport_state &= ~SATA_STATE_READY;
14568
14569 /* Remove and release sata_drive info structure. */
14570 if (sdinfo != NULL) {
14571 if ((sdinfo->satadrv_type &
14572 SATA_VALID_DEV_TYPE) != 0) {
14573 /*
14574 * If a target node exists, try to offline
14575 * a device and remove target node.
14576 */
14577 mutex_exit(&pmportinfo->pmport_mutex);
14578 (void) sata_offline_device(sata_hba_inst,
14579 sata_device, sdinfo);
14580 mutex_enter(&pmportinfo->pmport_mutex);
14581 }
14582
14583 SATA_PMPORTINFO_DRV_INFO(pmportinfo) = NULL;
14584 pmportinfo->pmport_dev_type = SATA_DTYPE_NONE;
14585 (void) kmem_free((void *)sdinfo,
14586 sizeof (sata_drive_info_t));
14587 }
14588 mutex_exit(&pmportinfo->pmport_mutex);
14589
14590 } else if (qual == SATA_ADDR_CPORT) {
14591 mutex_enter(&cportinfo->cport_mutex);
14592 sata_update_port_info(sata_hba_inst, sata_device);
14593 if (rval != SATA_SUCCESS ||
14594 (sata_device->satadev_state & SATA_PSTATE_FAILED) != 0) {
14595 /*
14596 * Device port status is unknown or it is in failed
14597 * state
14598 */
14599 SATA_CPORT_STATE(sata_hba_inst, cport) =
14600 SATA_PSTATE_FAILED;
14601 SATADBG1(SATA_DBG_IOCTL_IF, sata_hba_inst,
14602 "sata_hba_ioctl: connect: failed to deactivate "
14603 "SATA port %d", cport);
14604 mutex_exit(&cportinfo->cport_mutex);
14605 return (EIO);
14606 }
14607
14608 if (cportinfo->cport_dev_type == SATA_DTYPE_PMULT) {
14609 pmultinfo = SATA_CPORTINFO_PMULT_INFO(cportinfo);
14610 ASSERT(pmultinfo != NULL);
14611 } else if (cportinfo->cport_dev_type != SATA_DTYPE_NONE) {
14612 sdinfo = SATA_CPORTINFO_DRV_INFO(cportinfo);
14613 ASSERT(sdinfo != NULL);
14614 }
14615 cportinfo->cport_state &= ~SATA_STATE_READY;
14616
14617 if (sdinfo != NULL) {
14618 if ((sdinfo->satadrv_type &
14619 SATA_VALID_DEV_TYPE) != 0) {
14620 /*
14621 * If a target node exists, try to offline
14622 * a device and remove target node.
14623 */
14624 mutex_exit(&cportinfo->cport_mutex);
14625 (void) sata_offline_device(sata_hba_inst,
14626 sata_device, sdinfo);
14627 mutex_enter(&cportinfo->cport_mutex);
14628 }
14629
14630 SATA_CPORTINFO_DRV_INFO(cportinfo) = NULL;
14631 cportinfo->cport_dev_type = SATA_DTYPE_NONE;
14632 (void) kmem_free((void *)sdinfo,
14633 sizeof (sata_drive_info_t));
14634 }
14635 mutex_exit(&cportinfo->cport_mutex);
14636 }
14637
14638 /* Just ask HBA driver to deactivate port */
14639 sata_device->satadev_addr.qual = qual;
14640
14641 rval = (*SATA_PORT_DEACTIVATE_FUNC(sata_hba_inst))
14642 (SATA_DIP(sata_hba_inst), sata_device);
14643
14644 /*
14645 * Generate sysevent - EC_DR / ESC_DR_AP_STATE_CHANGE
14646 * without the hint (to force listener to investivate the state).
14647 */
14648 sata_gen_sysevent(sata_hba_inst, &sata_device->satadev_addr,
14649 SE_NO_HINT);
14650
14651 if (qual == SATA_ADDR_PMPORT) {
14652 mutex_enter(&pmportinfo->pmport_mutex);
14653 sata_update_pmport_info(sata_hba_inst, sata_device);
14654
14655 if (rval != SATA_SUCCESS &&
14656 sata_device->satadev_state & SATA_PSTATE_FAILED) {
14657 /*
14658 * Port deactivation failure - do not change port
14659 * state unless the state returned by HBA indicates a
14660 * port failure.
14661 *
14662 * NOTE: device structures were released, so devices
14663 * now are invisible! Port reset is needed to
14664 * re-enumerate devices.
14665 */
14666 pmportinfo->pmport_state = SATA_PSTATE_FAILED;
14667 rv = EIO;
14668 } else {
14669 /*
14670 * Deactivation succeded. From now on the sata framework
14671 * will not care what is happening to the device, until
14672 * the port is activated again.
14673 */
14674 pmportinfo->pmport_state |= SATA_PSTATE_SHUTDOWN;
14675 }
14676 mutex_exit(&pmportinfo->pmport_mutex);
14677 } else if (qual == SATA_ADDR_CPORT) {
14678 mutex_enter(&cportinfo->cport_mutex);
14679 sata_update_port_info(sata_hba_inst, sata_device);
14680
14681 if (rval != SATA_SUCCESS &&
14682 sata_device->satadev_state & SATA_PSTATE_FAILED) {
14683 cportinfo->cport_state = SATA_PSTATE_FAILED;
14684 rv = EIO;
14685 } else {
14686 cportinfo->cport_state |= SATA_PSTATE_SHUTDOWN;
14687 }
14688 mutex_exit(&cportinfo->cport_mutex);
14689 }
14690
14691 return (rv);
14692 }
14693
14694
14695
14696 /*
14697 * Process sata port connect request
14698 * The sata cfgadm pluging will invoke this operation only if port was found
14699 * in the disconnect state (failed state is also treated as the disconnected
14700 * state).
14701 * DEVCTL_AP_CONNECT would invoke sata_hba_inst->satahba_tran->
14702 * sata_tran_hotplug_ops->sata_tran_port_activate().
14703 * If successful and a device is found attached to the port,
14704 * the initialization sequence is executed to attach a device structure to
14705 * a port structure. The state of the port and a device would be set
14706 * appropriately.
14707 * The device is not set in configured state (system-wise) by this operation.
14708 *
14709 * Note, that activating the port may generate link events,
14710 * so it is important that following processing and the
14711 * event processing does not interfere with each other!
14712 *
14713 * This operation may remove port failed state and will
14714 * try to make port active and in good standing.
14715 *
14716 * NOTE: Port multiplier is supported.
14717 */
14718
14719 static int
14720 sata_ioctl_connect(sata_hba_inst_t *sata_hba_inst,
14721 sata_device_t *sata_device)
14722 {
14723 sata_pmport_info_t *pmportinfo = NULL;
14724 uint8_t cport, pmport, qual;
14725 int rv = 0;
14726
14727 cport = sata_device->satadev_addr.cport;
14728 pmport = sata_device->satadev_addr.pmport;
14729 qual = sata_device->satadev_addr.qual;
14730
14731 ASSERT(qual == SATA_ADDR_DCPORT || qual == SATA_ADDR_DPMPORT);
14732 if (qual == SATA_ADDR_DCPORT)
14733 qual = SATA_ADDR_CPORT;
14734 else
14735 qual = SATA_ADDR_PMPORT;
14736
14737 if (qual == SATA_ADDR_PMPORT)
14738 pmportinfo = SATA_PMPORT_INFO(sata_hba_inst, cport, pmport);
14739
14740 /*
14741 * DEVCTL_AP_CONNECT would invoke sata_hba_inst->
14742 * satahba_tran->sata_tran_hotplug_ops->sata_tran_port_activate().
14743 * Perform sanity check now.
14744 */
14745 if (SATA_PORT_ACTIVATE_FUNC(sata_hba_inst) == NULL) {
14746 /* No physical port activation supported. */
14747 return (EINVAL);
14748 }
14749
14750 /* Just ask HBA driver to activate port */
14751 if ((*SATA_PORT_ACTIVATE_FUNC(sata_hba_inst))
14752 (SATA_DIP(sata_hba_inst), sata_device) != SATA_SUCCESS) {
14753 /*
14754 * Port activation failure.
14755 */
14756 if (qual == SATA_ADDR_CPORT) {
14757 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst,
14758 cport)->cport_mutex);
14759 sata_update_port_info(sata_hba_inst, sata_device);
14760 if (sata_device->satadev_state & SATA_PSTATE_FAILED) {
14761 SATA_CPORT_STATE(sata_hba_inst, cport) =
14762 SATA_PSTATE_FAILED;
14763 SATADBG1(SATA_DBG_IOCTL_IF, sata_hba_inst,
14764 "sata_hba_ioctl: connect: failed to "
14765 "activate SATA port %d", cport);
14766 }
14767 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst,
14768 cport)->cport_mutex);
14769 } else { /* port multiplier device port */
14770 mutex_enter(&pmportinfo->pmport_mutex);
14771 sata_update_pmport_info(sata_hba_inst, sata_device);
14772 if (sata_device->satadev_state & SATA_PSTATE_FAILED) {
14773 SATA_PMPORT_STATE(sata_hba_inst, cport,
14774 pmport) = SATA_PSTATE_FAILED;
14775 SATADBG2(SATA_DBG_IOCTL_IF, sata_hba_inst,
14776 "sata_hba_ioctl: connect: failed to "
14777 "activate SATA port %d:%d", cport, pmport);
14778 }
14779 mutex_exit(&pmportinfo->pmport_mutex);
14780 }
14781 return (EIO);
14782 }
14783
14784 /* Virgin port state - will be updated by the port re-probe. */
14785 if (qual == SATA_ADDR_CPORT) {
14786 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst,
14787 cport)->cport_mutex);
14788 SATA_CPORT_STATE(sata_hba_inst, cport) = 0;
14789 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst,
14790 cport)->cport_mutex);
14791 } else { /* port multiplier device port */
14792 mutex_enter(&pmportinfo->pmport_mutex);
14793 SATA_PMPORT_STATE(sata_hba_inst, cport, pmport) = 0;
14794 mutex_exit(&pmportinfo->pmport_mutex);
14795 }
14796
14797 /*
14798 * Probe the port to find its state and attached device.
14799 */
14800 if (sata_reprobe_port(sata_hba_inst, sata_device,
14801 SATA_DEV_IDENTIFY_RETRY) == SATA_FAILURE)
14802 rv = EIO;
14803
14804 /*
14805 * Generate sysevent - EC_DR / ESC_DR_AP_STATE_CHANGE
14806 * without the hint
14807 */
14808 sata_gen_sysevent(sata_hba_inst, &sata_device->satadev_addr,
14809 SE_NO_HINT);
14810
14811 /*
14812 * If there is a device attached to the port, emit
14813 * a message.
14814 */
14815 if (sata_device->satadev_type != SATA_DTYPE_NONE) {
14816
14817 if (qual == SATA_ADDR_CPORT) {
14818 if (sata_device->satadev_type == SATA_DTYPE_PMULT) {
14819 sata_log(sata_hba_inst, CE_WARN,
14820 "SATA port multiplier detected "
14821 "at port %d", cport);
14822 } else {
14823 sata_log(sata_hba_inst, CE_WARN,
14824 "SATA device detected at port %d", cport);
14825 if (sata_device->satadev_type ==
14826 SATA_DTYPE_UNKNOWN) {
14827 /*
14828 * A device was not successfully identified
14829 */
14830 sata_log(sata_hba_inst, CE_WARN,
14831 "Could not identify SATA "
14832 "device at port %d", cport);
14833 }
14834 }
14835 } else { /* port multiplier device port */
14836 sata_log(sata_hba_inst, CE_WARN,
14837 "SATA device detected at port %d:%d",
14838 cport, pmport);
14839 if (sata_device->satadev_type == SATA_DTYPE_UNKNOWN) {
14840 /*
14841 * A device was not successfully identified
14842 */
14843 sata_log(sata_hba_inst, CE_WARN,
14844 "Could not identify SATA "
14845 "device at port %d:%d", cport, pmport);
14846 }
14847 }
14848 }
14849
14850 return (rv);
14851 }
14852
14853
14854 /*
14855 * Process sata device unconfigure request.
14856 * The unconfigure operation uses generic nexus operation to
14857 * offline a device. It leaves a target device node attached.
14858 * and obviously sata_drive_info attached as well, because
14859 * from the hardware point of view nothing has changed.
14860 */
14861 static int
14862 sata_ioctl_unconfigure(sata_hba_inst_t *sata_hba_inst,
14863 sata_device_t *sata_device)
14864 {
14865 int rv = 0;
14866 dev_info_t *tdip;
14867
14868 /* We are addressing attached device, not a port */
14869 if (sata_device->satadev_addr.qual == SATA_ADDR_CPORT)
14870 sata_device->satadev_addr.qual = SATA_ADDR_DCPORT;
14871 else if (sata_device->satadev_addr.qual == SATA_ADDR_PMPORT)
14872 sata_device->satadev_addr.qual = SATA_ADDR_DPMPORT;
14873
14874 if ((tdip = sata_get_scsi_target_dip(SATA_DIP(sata_hba_inst),
14875 &sata_device->satadev_addr)) != NULL) {
14876
14877 if (ndi_devi_offline(tdip, NDI_UNCONFIG) != NDI_SUCCESS) {
14878 SATA_LOG_D((sata_hba_inst, CE_WARN,
14879 "sata_hba_ioctl: unconfigure: "
14880 "failed to unconfigure device at SATA port %d:%d",
14881 sata_device->satadev_addr.cport,
14882 sata_device->satadev_addr.pmport));
14883 rv = EIO;
14884 }
14885 /*
14886 * The target node devi_state should be marked with
14887 * DEVI_DEVICE_OFFLINE by ndi_devi_offline().
14888 * This would be the indication for cfgadm that
14889 * the AP node occupant state is 'unconfigured'.
14890 */
14891
14892 } else {
14893 /*
14894 * This would indicate a failure on the part of cfgadm
14895 * to detect correct state of the node prior to this
14896 * call - one cannot unconfigure non-existing device.
14897 */
14898 SATA_LOG_D((sata_hba_inst, CE_WARN,
14899 "sata_hba_ioctl: unconfigure: "
14900 "attempt to unconfigure non-existing device "
14901 "at SATA port %d:%d",
14902 sata_device->satadev_addr.cport,
14903 sata_device->satadev_addr.pmport));
14904 rv = ENXIO;
14905 }
14906 return (rv);
14907 }
14908
14909 /*
14910 * Process sata device configure request
14911 * If port is in a failed state, operation is aborted - one has to use
14912 * an explicit connect or port activate request to try to get a port into
14913 * non-failed mode. Port reset wil also work in such situation.
14914 * If the port is in disconnected (shutdown) state, the connect operation is
14915 * attempted prior to any other action.
14916 * When port is in the active state, there is a device attached and the target
14917 * node exists, a device was most likely offlined.
14918 * If target node does not exist, a new target node is created. In both cases
14919 * an attempt is made to online (configure) the device.
14920 *
14921 * NOTE: Port multiplier is supported.
14922 */
14923 static int
14924 sata_ioctl_configure(sata_hba_inst_t *sata_hba_inst,
14925 sata_device_t *sata_device)
14926 {
14927 int cport, pmport, qual;
14928 int rval;
14929 boolean_t target = B_TRUE;
14930 sata_cport_info_t *cportinfo;
14931 sata_pmport_info_t *pmportinfo = NULL;
14932 dev_info_t *tdip;
14933 sata_drive_info_t *sdinfo;
14934
14935 cport = sata_device->satadev_addr.cport;
14936 pmport = sata_device->satadev_addr.pmport;
14937 qual = sata_device->satadev_addr.qual;
14938
14939 /* Get current port state */
14940 rval = (*SATA_PROBE_PORT_FUNC(sata_hba_inst))
14941 (SATA_DIP(sata_hba_inst), sata_device);
14942
14943 cportinfo = SATA_CPORT_INFO(sata_hba_inst, cport);
14944 if (qual == SATA_ADDR_DPMPORT) {
14945 pmportinfo = SATA_PMPORT_INFO(sata_hba_inst, cport, pmport);
14946 mutex_enter(&pmportinfo->pmport_mutex);
14947 sata_update_pmport_info(sata_hba_inst, sata_device);
14948 if (rval != SATA_SUCCESS ||
14949 (sata_device->satadev_state & SATA_PSTATE_FAILED) != 0) {
14950 /*
14951 * Obviously, device on a failed port is not visible
14952 */
14953 mutex_exit(&pmportinfo->pmport_mutex);
14954 return (ENXIO);
14955 }
14956 mutex_exit(&pmportinfo->pmport_mutex);
14957 } else {
14958 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst,
14959 cport)->cport_mutex);
14960 sata_update_port_info(sata_hba_inst, sata_device);
14961 if (rval != SATA_SUCCESS ||
14962 (sata_device->satadev_state & SATA_PSTATE_FAILED) != 0) {
14963 /*
14964 * Obviously, device on a failed port is not visible
14965 */
14966 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst,
14967 cport)->cport_mutex);
14968 return (ENXIO);
14969 }
14970 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst,
14971 cport)->cport_mutex);
14972 }
14973
14974 if ((sata_device->satadev_state & SATA_PSTATE_SHUTDOWN) != 0) {
14975 /* need to activate port */
14976 target = B_FALSE;
14977
14978 /* Sanity check */
14979 if (SATA_PORT_ACTIVATE_FUNC(sata_hba_inst) == NULL)
14980 return (ENXIO);
14981
14982 /* Just let HBA driver to activate port */
14983 if ((*SATA_PORT_ACTIVATE_FUNC(sata_hba_inst))
14984 (SATA_DIP(sata_hba_inst), sata_device) != SATA_SUCCESS) {
14985 /*
14986 * Port activation failure - do not change port state
14987 * unless the state returned by HBA indicates a port
14988 * failure.
14989 */
14990 if (qual == SATA_ADDR_DPMPORT) {
14991 mutex_enter(&pmportinfo->pmport_mutex);
14992 sata_update_pmport_info(sata_hba_inst,
14993 sata_device);
14994 if (sata_device->satadev_state &
14995 SATA_PSTATE_FAILED)
14996 pmportinfo->pmport_state =
14997 SATA_PSTATE_FAILED;
14998 mutex_exit(&pmportinfo->pmport_mutex);
14999 } else {
15000 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst,
15001 cport)->cport_mutex);
15002 sata_update_port_info(sata_hba_inst,
15003 sata_device);
15004 if (sata_device->satadev_state &
15005 SATA_PSTATE_FAILED)
15006 cportinfo->cport_state =
15007 SATA_PSTATE_FAILED;
15008 mutex_exit(&SATA_CPORT_INFO(
15009 sata_hba_inst, cport)->cport_mutex);
15010 }
15011 }
15012 SATA_LOG_D((sata_hba_inst, CE_WARN,
15013 "sata_hba_ioctl: configure: "
15014 "failed to activate SATA port %d:%d",
15015 cport, pmport));
15016 return (EIO);
15017 }
15018 /*
15019 * Generate sysevent - EC_DR / ESC_DR_AP_STATE_CHANGE
15020 * without the hint.
15021 */
15022 sata_gen_sysevent(sata_hba_inst,
15023 &sata_device->satadev_addr, SE_NO_HINT);
15024
15025 /* Virgin port state */
15026 if (qual == SATA_ADDR_DPMPORT) {
15027 mutex_enter(&pmportinfo->pmport_mutex);
15028 pmportinfo->pmport_state = 0;
15029 mutex_exit(&pmportinfo->pmport_mutex);
15030 } else {
15031 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst,
15032 cport)-> cport_mutex);
15033 cportinfo->cport_state = 0;
15034 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst,
15035 cport)->cport_mutex);
15036 }
15037 /*
15038 * Always reprobe port, to get current device info.
15039 */
15040 if (sata_reprobe_port(sata_hba_inst, sata_device,
15041 SATA_DEV_IDENTIFY_RETRY) != SATA_SUCCESS)
15042 return (EIO);
15043
15044 if (sata_device->satadev_type != SATA_DTYPE_NONE && target == B_FALSE) {
15045 if (qual == SATA_ADDR_DPMPORT) {
15046 /*
15047 * That's the transition from "inactive" port
15048 * to active one with device attached.
15049 */
15050 sata_log(sata_hba_inst, CE_WARN,
15051 "SATA device detected at port %d:%d",
15052 cport, pmport);
15053 } else {
15054 /*
15055 * When PM is attached to the cport and cport is
15056 * activated, every PM device port needs to be reprobed.
15057 * We need to emit message for all devices detected
15058 * at port multiplier's device ports.
15059 * Add such code here.
15060 * For now, just inform about device attached to
15061 * cport.
15062 */
15063 sata_log(sata_hba_inst, CE_WARN,
15064 "SATA device detected at port %d", cport);
15065 }
15066 }
15067
15068 /*
15069 * This is where real configuration operation starts.
15070 *
15071 * When PM is attached to the cport and cport is activated,
15072 * devices attached PM device ports may have to be configured
15073 * explicitly. This may change when port multiplier is supported.
15074 * For now, configure only disks and other valid target devices.
15075 */
15076 if (!(sata_device->satadev_type & SATA_VALID_DEV_TYPE)) {
15077 if (qual == SATA_ADDR_DCPORT) {
15078 if (sata_device->satadev_type == SATA_DTYPE_UNKNOWN) {
15079 /*
15080 * A device was not successfully identified
15081 */
15082 sata_log(sata_hba_inst, CE_WARN,
15083 "Could not identify SATA "
15084 "device at port %d", cport);
15085 }
15086 } else { /* port multiplier device port */
15087 if (sata_device->satadev_type == SATA_DTYPE_UNKNOWN) {
15088 /*
15089 * A device was not successfully identified
15090 */
15091 sata_log(sata_hba_inst, CE_WARN,
15092 "Could not identify SATA "
15093 "device at port %d:%d", cport, pmport);
15094 }
15095 }
15096 return (ENXIO); /* No device to configure */
15097 }
15098
15099 /*
15100 * Here we may have a device in reset condition,
15101 * but because we are just configuring it, there is
15102 * no need to process the reset other than just
15103 * to clear device reset condition in the HBA driver.
15104 * Setting the flag SATA_EVNT_CLEAR_DEVICE_RESET will
15105 * cause a first command sent the HBA driver with the request
15106 * to clear device reset condition.
15107 */
15108 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex);
15109 if (qual == SATA_ADDR_DPMPORT)
15110 sata_device->satadev_addr.qual = SATA_ADDR_DPMPORT;
15111 else
15112 sata_device->satadev_addr.qual = SATA_ADDR_DCPORT;
15113 sdinfo = sata_get_device_info(sata_hba_inst, sata_device);
15114 if (sdinfo == NULL) {
15115 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex);
15116 return (ENXIO);
15117 }
15118 if (sdinfo->satadrv_event_flags &
15119 (SATA_EVNT_DEVICE_RESET | SATA_EVNT_INPROC_DEVICE_RESET)) {
15120 sdinfo->satadrv_event_flags = 0;
15121 }
15122 sdinfo->satadrv_event_flags |= SATA_EVNT_CLEAR_DEVICE_RESET;
15123 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex);
15124
15125 if ((tdip = sata_get_scsi_target_dip(SATA_DIP(sata_hba_inst),
15126 &sata_device->satadev_addr)) != NULL) {
15127 /*
15128 * Target node exists. Verify, that it belongs
15129 * to existing, attached device and not to
15130 * a removed device.
15131 */
15132 if (sata_check_device_removed(tdip) == B_TRUE) {
15133 if (qual == SATA_ADDR_DPMPORT)
15134 sata_log(sata_hba_inst, CE_WARN,
15135 "SATA device at port %d cannot be "
15136 "configured. "
15137 "Application(s) accessing "
15138 "previously attached device "
15139 "have to release it before newly "
15140 "inserted device can be made accessible.",
15141 cport);
15142 else
15143 sata_log(sata_hba_inst, CE_WARN,
15144 "SATA device at port %d:%d cannot be"
15145 "configured. "
15146 "Application(s) accessing "
15147 "previously attached device "
15148 "have to release it before newly "
15149 "inserted device can be made accessible.",
15150 cport, pmport);
15151 return (EIO);
15152 }
15153 /*
15154 * Device was not removed and re-inserted.
15155 * Try to online it.
15156 */
15157 if (ndi_devi_online(tdip, 0) != NDI_SUCCESS) {
15158 SATA_LOG_D((sata_hba_inst, CE_WARN,
15159 "sata_hba_ioctl: configure: "
15160 "onlining device at SATA port "
15161 "%d:%d failed", cport, pmport));
15162 return (EIO);
15163 }
15164
15165 if (qual == SATA_ADDR_DPMPORT) {
15166 mutex_enter(&pmportinfo->pmport_mutex);
15167 pmportinfo->pmport_tgtnode_clean = B_TRUE;
15168 mutex_exit(&pmportinfo->pmport_mutex);
15169 } else {
15170 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst,
15171 cport)->cport_mutex);
15172 cportinfo-> cport_tgtnode_clean = B_TRUE;
15173 mutex_exit(&SATA_CPORT_INFO(
15174 sata_hba_inst, cport)->cport_mutex);
15175 }
15176 } else {
15177 /*
15178 * No target node - need to create a new target node.
15179 */
15180 if (qual == SATA_ADDR_DPMPORT) {
15181 mutex_enter(&pmportinfo->pmport_mutex);
15182 pmportinfo->pmport_tgtnode_clean = B_TRUE;
15183 mutex_exit(&pmportinfo->pmport_mutex);
15184 } else {
15185 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, cport)->
15186 cport_mutex);
15187 cportinfo-> cport_tgtnode_clean = B_TRUE;
15188 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)->
15189 cport_mutex);
15190 }
15191
15192 tdip = sata_create_target_node(SATA_DIP(sata_hba_inst),
15193 sata_hba_inst, &sata_device->satadev_addr);
15194 if (tdip == NULL) {
15195 /* Configure operation failed */
15196 SATA_LOG_D((sata_hba_inst, CE_WARN,
15197 "sata_hba_ioctl: configure: "
15198 "configuring SATA device at port %d:%d "
15199 "failed", cport, pmport));
15200 return (EIO);
15201 }
15202 }
15203 return (0);
15204 }
15205
15206
15207 /*
15208 * Process ioctl deactivate port request.
15209 * Arbitrarily unconfigure attached device, if any.
15210 * Even if the unconfigure fails, proceed with the
15211 * port deactivation.
15212 *
15213 * NOTE: Port Multiplier is supported now.
15214 */
15215
15216 static int
15217 sata_ioctl_deactivate(sata_hba_inst_t *sata_hba_inst,
15218 sata_device_t *sata_device)
15219 {
15220 int cport, pmport, qual;
15221 int rval, rv = 0;
15222 int npmport;
15223 sata_cport_info_t *cportinfo;
15224 sata_pmport_info_t *pmportinfo;
15225 sata_pmult_info_t *pmultinfo;
15226 dev_info_t *tdip;
15227 sata_drive_info_t *sdinfo = NULL;
15228 sata_device_t subsdevice;
15229
15230 /* Sanity check */
15231 if (SATA_PORT_DEACTIVATE_FUNC(sata_hba_inst) == NULL)
15232 return (ENOTSUP);
15233
15234 cport = sata_device->satadev_addr.cport;
15235 pmport = sata_device->satadev_addr.pmport;
15236 qual = sata_device->satadev_addr.qual;
15237
15238 /* SCSI_TO_SATA_ADDR_QUAL() translate ap_id into a device qualifier */
15239 ASSERT(qual == SATA_ADDR_DCPORT || qual == SATA_ADDR_DPMPORT);
15240 if (qual == SATA_ADDR_DCPORT)
15241 qual = SATA_ADDR_CPORT;
15242 else
15243 qual = SATA_ADDR_PMPORT;
15244
15245 cportinfo = SATA_CPORT_INFO(sata_hba_inst, cport);
15246 if (qual == SATA_ADDR_PMPORT)
15247 pmportinfo = SATA_PMPORT_INFO(sata_hba_inst, cport, pmport);
15248
15249 /*
15250 * Processing port multiplier
15251 */
15252 if (qual == SATA_ADDR_CPORT &&
15253 SATA_CPORT_DEV_TYPE(sata_hba_inst, cport) == SATA_DTYPE_PMULT) {
15254 mutex_enter(&cportinfo->cport_mutex);
15255
15256 /* Deactivate all sub-deices */
15257 pmultinfo = SATA_CPORTINFO_PMULT_INFO(cportinfo);
15258 if (pmultinfo != NULL) {
15259 for (npmport = 0; npmport < SATA_NUM_PMPORTS(
15260 sata_hba_inst, cport); npmport++) {
15261
15262 subsdevice.satadev_addr.cport = cport;
15263 subsdevice.satadev_addr.pmport =
15264 (uint8_t)npmport;
15265 subsdevice.satadev_addr.qual =
15266 SATA_ADDR_DPMPORT;
15267
15268 SATADBG2(SATA_DBG_PMULT, sata_hba_inst,
15269 "sata_hba_ioctl: deactivate: trying to "
15270 "deactivate SATA port %d:%d",
15271 cport, npmport);
15272
15273 mutex_exit(&cportinfo->cport_mutex);
15274 if (sata_ioctl_deactivate(sata_hba_inst,
15275 &subsdevice) == SATA_SUCCESS) {
15276 SATADBG2(SATA_DBG_PMULT, sata_hba_inst,
15277 "[Deactivate] device at port %d:%d "
15278 "successfully.", cport, npmport);
15279 }
15280 mutex_enter(&cportinfo->cport_mutex);
15281 }
15282 }
15283
15284 /* Deactivate the port multiplier now. */
15285 cportinfo->cport_state &= ~SATA_STATE_READY;
15286 mutex_exit(&cportinfo->cport_mutex);
15287
15288 sata_device->satadev_addr.qual = qual;
15289 rval = (*SATA_PORT_DEACTIVATE_FUNC(sata_hba_inst))
15290 (SATA_DIP(sata_hba_inst), sata_device);
15291
15292 sata_gen_sysevent(sata_hba_inst, &sata_device->satadev_addr,
15293 SE_NO_HINT);
15294
15295 mutex_enter(&cportinfo->cport_mutex);
15296 sata_update_port_info(sata_hba_inst, sata_device);
15297 if (rval != SATA_SUCCESS) {
15298 if (sata_device->satadev_state & SATA_PSTATE_FAILED) {
15299 cportinfo->cport_state = SATA_PSTATE_FAILED;
15300 }
15301 rv = EIO;
15302 } else {
15303 cportinfo->cport_state |= SATA_PSTATE_SHUTDOWN;
15304 }
15305 mutex_exit(&cportinfo->cport_mutex);
15306
15307 return (rv);
15308 }
15309
15310 /*
15311 * Process non-port-multiplier device - it could be a drive connected
15312 * to a port multiplier port or a controller port.
15313 */
15314 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex);
15315 if (qual == SATA_ADDR_CPORT) {
15316 sata_device->satadev_addr.qual = SATA_ADDR_DCPORT;
15317 if (cportinfo->cport_dev_type != SATA_DTYPE_NONE) {
15318 /* deal only with valid devices */
15319 if ((cportinfo->cport_dev_type &
15320 SATA_VALID_DEV_TYPE) != 0)
15321 sdinfo = SATA_CPORTINFO_DRV_INFO(cportinfo);
15322 }
15323 cportinfo->cport_state &= ~SATA_STATE_READY;
15324 } else {
15325 /* Port multiplier device port */
15326 mutex_enter(&pmportinfo->pmport_mutex);
15327 sata_device->satadev_addr.qual = SATA_ADDR_DPMPORT;
15328 if (pmportinfo->pmport_dev_type != SATA_DTYPE_NONE &&
15329 (pmportinfo->pmport_dev_type & SATA_VALID_DEV_TYPE) != 0)
15330 sdinfo = SATA_PMPORTINFO_DRV_INFO(pmportinfo);
15331 pmportinfo->pmport_state &= ~SATA_STATE_READY;
15332 mutex_exit(&pmportinfo->pmport_mutex);
15333 }
15334
15335 if (sdinfo != NULL) {
15336 /*
15337 * If a target node exists, try to offline a device and
15338 * to remove a target node.
15339 */
15340 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)->
15341 cport_mutex);
15342 tdip = sata_get_scsi_target_dip(SATA_DIP(sata_hba_inst),
15343 &sata_device->satadev_addr);
15344 if (tdip != NULL) {
15345 /* target node exist */
15346 SATADBG1(SATA_DBG_IOCTL_IF, sata_hba_inst,
15347 "sata_hba_ioctl: port deactivate: "
15348 "target node exists.", NULL);
15349
15350 if (ndi_devi_offline(tdip, NDI_DEVI_REMOVE) !=
15351 NDI_SUCCESS) {
15352 SATA_LOG_D((sata_hba_inst, CE_WARN,
15353 "sata_hba_ioctl: port deactivate: "
15354 "failed to unconfigure device at port "
15355 "%d:%d before deactivating the port",
15356 cport, pmport));
15357 /*
15358 * Set DEVICE REMOVED state in the target
15359 * node. It will prevent an access to
15360 * the device even when a new device is
15361 * attached, until the old target node is
15362 * released, removed and recreated for a new
15363 * device.
15364 */
15365 sata_set_device_removed(tdip);
15366
15367 /*
15368 * Instruct the event daemon to try the
15369 * target node cleanup later.
15370 */
15371 sata_set_target_node_cleanup(sata_hba_inst,
15372 &sata_device->satadev_addr);
15373 }
15374 }
15375 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, cport)->
15376 cport_mutex);
15377 /*
15378 * In any case, remove and release sata_drive_info
15379 * structure.
15380 */
15381 if (qual == SATA_ADDR_CPORT) {
15382 SATA_CPORTINFO_DRV_INFO(cportinfo) = NULL;
15383 cportinfo->cport_dev_type = SATA_DTYPE_NONE;
15384 } else { /* port multiplier device port */
15385 mutex_enter(&pmportinfo->pmport_mutex);
15386 SATA_PMPORTINFO_DRV_INFO(pmportinfo) = NULL;
15387 pmportinfo->pmport_dev_type = SATA_DTYPE_NONE;
15388 mutex_exit(&pmportinfo->pmport_mutex);
15389 }
15390 (void) kmem_free((void *)sdinfo, sizeof (sata_drive_info_t));
15391 }
15392
15393 if (qual == SATA_ADDR_CPORT) {
15394 cportinfo->cport_state &= ~(SATA_STATE_PROBED |
15395 SATA_STATE_PROBING);
15396 } else if (qual == SATA_ADDR_PMPORT) {
15397 mutex_enter(&pmportinfo->pmport_mutex);
15398 pmportinfo->pmport_state &= ~(SATA_STATE_PROBED |
15399 SATA_STATE_PROBING);
15400 mutex_exit(&pmportinfo->pmport_mutex);
15401 }
15402 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex);
15403
15404 /* Just let HBA driver to deactivate port */
15405 sata_device->satadev_addr.qual = qual;
15406 rval = (*SATA_PORT_DEACTIVATE_FUNC(sata_hba_inst))
15407 (SATA_DIP(sata_hba_inst), sata_device);
15408
15409 /*
15410 * Generate sysevent - EC_DR / ESC_DR_AP_STATE_CHANGE
15411 * without the hint
15412 */
15413 sata_gen_sysevent(sata_hba_inst, &sata_device->satadev_addr,
15414 SE_NO_HINT);
15415
15416 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex);
15417 sata_update_port_info(sata_hba_inst, sata_device);
15418 if (qual == SATA_ADDR_CPORT) {
15419 if (rval != SATA_SUCCESS) {
15420 /*
15421 * Port deactivation failure - do not change port state
15422 * unless the state returned by HBA indicates a port
15423 * failure.
15424 */
15425 if (sata_device->satadev_state & SATA_PSTATE_FAILED) {
15426 SATA_CPORT_STATE(sata_hba_inst, cport) =
15427 SATA_PSTATE_FAILED;
15428 }
15429 SATA_LOG_D((sata_hba_inst, CE_WARN,
15430 "sata_hba_ioctl: port deactivate: "
15431 "cannot deactivate SATA port %d", cport));
15432 rv = EIO;
15433 } else {
15434 cportinfo->cport_state |= SATA_PSTATE_SHUTDOWN;
15435 }
15436 } else {
15437 mutex_enter(&pmportinfo->pmport_mutex);
15438 if (rval != SATA_SUCCESS) {
15439 if (sata_device->satadev_state & SATA_PSTATE_FAILED) {
15440 SATA_PMPORT_STATE(sata_hba_inst, cport,
15441 pmport) = SATA_PSTATE_FAILED;
15442 }
15443 SATA_LOG_D((sata_hba_inst, CE_WARN,
15444 "sata_hba_ioctl: port deactivate: "
15445 "cannot deactivate SATA port %d:%d",
15446 cport, pmport));
15447 rv = EIO;
15448 } else {
15449 pmportinfo->pmport_state |= SATA_PSTATE_SHUTDOWN;
15450 }
15451 mutex_exit(&pmportinfo->pmport_mutex);
15452 }
15453
15454 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex);
15455
15456 return (rv);
15457 }
15458
15459 /*
15460 * Process ioctl port activate request.
15461 *
15462 * NOTE: Port multiplier is supported now.
15463 */
15464 static int
15465 sata_ioctl_activate(sata_hba_inst_t *sata_hba_inst,
15466 sata_device_t *sata_device)
15467 {
15468 int cport, pmport, qual;
15469 sata_cport_info_t *cportinfo;
15470 sata_pmport_info_t *pmportinfo = NULL;
15471 boolean_t dev_existed = B_TRUE;
15472
15473 /* Sanity check */
15474 if (SATA_PORT_ACTIVATE_FUNC(sata_hba_inst) == NULL)
15475 return (ENOTSUP);
15476
15477 cport = sata_device->satadev_addr.cport;
15478 pmport = sata_device->satadev_addr.pmport;
15479 qual = sata_device->satadev_addr.qual;
15480
15481 cportinfo = SATA_CPORT_INFO(sata_hba_inst, cport);
15482
15483 /*
15484 * The qual translate from ap_id (by SCSI_TO_SATA_ADDR_QUAL())
15485 * is a device. But what we are dealing with is port/pmport.
15486 */
15487 ASSERT(qual == SATA_ADDR_DCPORT || qual == SATA_ADDR_DPMPORT);
15488 if (qual == SATA_ADDR_DCPORT)
15489 sata_device->satadev_addr.qual = qual = SATA_ADDR_CPORT;
15490 else
15491 sata_device->satadev_addr.qual = qual = SATA_ADDR_PMPORT;
15492
15493 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex);
15494 if (qual == SATA_ADDR_PMPORT) {
15495 pmportinfo = SATA_PMPORT_INFO(sata_hba_inst, cport, pmport);
15496 if (pmportinfo->pmport_state & SATA_PSTATE_SHUTDOWN ||
15497 pmportinfo->pmport_dev_type == SATA_DTYPE_NONE)
15498 dev_existed = B_FALSE;
15499 } else { /* cport */
15500 if (cportinfo->cport_state & SATA_PSTATE_SHUTDOWN ||
15501 cportinfo->cport_dev_type == SATA_DTYPE_NONE)
15502 dev_existed = B_FALSE;
15503 }
15504 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex);
15505
15506 /* Just let HBA driver to activate port, if necessary */
15507 if ((*SATA_PORT_ACTIVATE_FUNC(sata_hba_inst))
15508 (SATA_DIP(sata_hba_inst), sata_device) != SATA_SUCCESS) {
15509 /*
15510 * Port activation failure - do not change port state unless
15511 * the state returned by HBA indicates a port failure.
15512 */
15513 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst,
15514 cport)->cport_mutex);
15515 sata_update_port_info(sata_hba_inst, sata_device);
15516 if (sata_device->satadev_state & SATA_PSTATE_FAILED) {
15517 if (qual == SATA_ADDR_PMPORT) {
15518 mutex_enter(&pmportinfo->pmport_mutex);
15519 pmportinfo->pmport_state = SATA_PSTATE_FAILED;
15520 mutex_exit(&pmportinfo->pmport_mutex);
15521 } else
15522 cportinfo->cport_state = SATA_PSTATE_FAILED;
15523
15524 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst,
15525 cport)->cport_mutex);
15526 SATA_LOG_D((sata_hba_inst, CE_WARN,
15527 "sata_hba_ioctl: port activate: cannot activate "
15528 "SATA port %d:%d", cport, pmport));
15529 return (EIO);
15530 }
15531 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex);
15532 }
15533 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex);
15534 if (qual == SATA_ADDR_PMPORT) {
15535 mutex_enter(&pmportinfo->pmport_mutex);
15536 pmportinfo->pmport_state &= ~SATA_PSTATE_SHUTDOWN;
15537 mutex_exit(&pmportinfo->pmport_mutex);
15538 } else
15539 cportinfo->cport_state &= ~SATA_PSTATE_SHUTDOWN;
15540 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex);
15541
15542 /*
15543 * Re-probe port to find its current state and possibly attached device.
15544 * Port re-probing may change the cportinfo device type if device is
15545 * found attached.
15546 * If port probing failed, the device type would be set to
15547 * SATA_DTYPE_NONE.
15548 */
15549 (void) sata_reprobe_port(sata_hba_inst, sata_device,
15550 SATA_DEV_IDENTIFY_RETRY);
15551
15552 /*
15553 * Generate sysevent - EC_DR / ESC_DR_AP_STATE_CHANGE
15554 * without the hint.
15555 */
15556 sata_gen_sysevent(sata_hba_inst, &sata_device->satadev_addr,
15557 SE_NO_HINT);
15558
15559 if (dev_existed == B_FALSE) {
15560 if (qual == SATA_ADDR_PMPORT &&
15561 pmportinfo->pmport_dev_type != SATA_DTYPE_NONE) {
15562 /*
15563 * That's the transition from the "inactive" port state
15564 * or the active port without a device attached to the
15565 * active port state with a device attached.
15566 */
15567 sata_log(sata_hba_inst, CE_WARN,
15568 "SATA device detected at port %d:%d",
15569 cport, pmport);
15570 } else if (qual == SATA_ADDR_CPORT &&
15571 cportinfo->cport_dev_type != SATA_DTYPE_NONE) {
15572 /*
15573 * That's the transition from the "inactive" port state
15574 * or the active port without a device attached to the
15575 * active port state with a device attached.
15576 */
15577 if (cportinfo->cport_dev_type != SATA_DTYPE_PMULT) {
15578 sata_log(sata_hba_inst, CE_WARN,
15579 "SATA device detected at port %d", cport);
15580 } else {
15581 sata_log(sata_hba_inst, CE_WARN,
15582 "SATA port multiplier detected at port %d",
15583 cport);
15584 }
15585 }
15586 }
15587 return (0);
15588 }
15589
15590
15591
15592 /*
15593 * Process ioctl reset port request.
15594 *
15595 * NOTE: Port-Multiplier is supported.
15596 */
15597 static int
15598 sata_ioctl_reset_port(sata_hba_inst_t *sata_hba_inst,
15599 sata_device_t *sata_device)
15600 {
15601 int cport, pmport, qual;
15602 int rv = 0;
15603
15604 cport = sata_device->satadev_addr.cport;
15605 pmport = sata_device->satadev_addr.pmport;
15606 qual = sata_device->satadev_addr.qual;
15607
15608 /*
15609 * The qual translate from ap_id (by SCSI_TO_SATA_ADDR_QUAL())
15610 * is a device. But what we are dealing with is port/pmport.
15611 */
15612 if (qual == SATA_ADDR_DCPORT)
15613 sata_device->satadev_addr.qual = qual = SATA_ADDR_CPORT;
15614 else
15615 sata_device->satadev_addr.qual = qual = SATA_ADDR_PMPORT;
15616 ASSERT(qual == SATA_ADDR_CPORT || qual == SATA_ADDR_PMPORT);
15617
15618 /* Sanity check */
15619 if (SATA_RESET_DPORT_FUNC(sata_hba_inst) == NULL) {
15620 SATA_LOG_D((sata_hba_inst, CE_WARN,
15621 "sata_hba_ioctl: sata_hba_tran missing required "
15622 "function sata_tran_reset_dport"));
15623 return (ENOTSUP);
15624 }
15625
15626 /* Ask HBA to reset port */
15627 if ((*SATA_RESET_DPORT_FUNC(sata_hba_inst))(SATA_DIP(sata_hba_inst),
15628 sata_device) != SATA_SUCCESS) {
15629 SATA_LOG_D((sata_hba_inst, CE_WARN,
15630 "sata_hba_ioctl: reset port: failed %d:%d",
15631 cport, pmport));
15632 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, cport)->
15633 cport_mutex);
15634 sata_update_port_info(sata_hba_inst, sata_device);
15635 if (qual == SATA_ADDR_CPORT)
15636 SATA_CPORT_STATE(sata_hba_inst, cport) =
15637 SATA_PSTATE_FAILED;
15638 else {
15639 mutex_enter(&SATA_PMPORT_MUTEX(sata_hba_inst, cport,
15640 pmport));
15641 SATA_PMPORT_STATE(sata_hba_inst, cport, pmport) =
15642 SATA_PSTATE_FAILED;
15643 mutex_exit(&SATA_PMPORT_MUTEX(sata_hba_inst, cport,
15644 pmport));
15645 }
15646 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)->
15647 cport_mutex);
15648 rv = EIO;
15649 }
15650
15651 return (rv);
15652 }
15653
15654 /*
15655 * Process ioctl reset device request.
15656 *
15657 * NOTE: Port multiplier is supported.
15658 */
15659 static int
15660 sata_ioctl_reset_device(sata_hba_inst_t *sata_hba_inst,
15661 sata_device_t *sata_device)
15662 {
15663 sata_drive_info_t *sdinfo = NULL;
15664 sata_pmult_info_t *pmultinfo = NULL;
15665 int cport, pmport;
15666 int rv = 0;
15667
15668 /* Sanity check */
15669 if (SATA_RESET_DPORT_FUNC(sata_hba_inst) == NULL) {
15670 SATA_LOG_D((sata_hba_inst, CE_WARN,
15671 "sata_hba_ioctl: sata_hba_tran missing required "
15672 "function sata_tran_reset_dport"));
15673 return (ENOTSUP);
15674 }
15675
15676 cport = sata_device->satadev_addr.cport;
15677 pmport = sata_device->satadev_addr.pmport;
15678
15679 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex);
15680 if (sata_device->satadev_addr.qual == SATA_ADDR_DCPORT) {
15681 if (SATA_CPORT_DEV_TYPE(sata_hba_inst, cport) ==
15682 SATA_DTYPE_PMULT)
15683 pmultinfo = SATA_CPORT_INFO(sata_hba_inst, cport)->
15684 cport_devp.cport_sata_pmult;
15685 else
15686 sdinfo = SATA_CPORT_DRV_INFO(sata_hba_inst,
15687 sata_device->satadev_addr.cport);
15688 } else { /* port multiplier */
15689 sata_device->satadev_addr.qual = SATA_ADDR_DPMPORT;
15690 sdinfo = SATA_PMPORT_DRV_INFO(sata_hba_inst,
15691 sata_device->satadev_addr.cport,
15692 sata_device->satadev_addr.pmport);
15693 }
15694 if (sdinfo == NULL && pmultinfo == NULL) {
15695 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex);
15696 return (EINVAL);
15697 }
15698 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex);
15699
15700 /* Ask HBA to reset device */
15701 if ((*SATA_RESET_DPORT_FUNC(sata_hba_inst))
15702 (SATA_DIP(sata_hba_inst), sata_device) != SATA_SUCCESS) {
15703 SATA_LOG_D((sata_hba_inst, CE_WARN,
15704 "sata_hba_ioctl: reset device: failed at port %d:%d",
15705 cport, pmport));
15706 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, cport)->
15707 cport_mutex);
15708 sata_update_port_info(sata_hba_inst, sata_device);
15709 /*
15710 * Device info structure remains attached. Another device reset
15711 * or port disconnect/connect and re-probing is
15712 * needed to change it's state
15713 */
15714 if (sdinfo != NULL) {
15715 sdinfo->satadrv_state &= ~SATA_STATE_READY;
15716 sdinfo->satadrv_state |= SATA_DSTATE_FAILED;
15717 } else if (pmultinfo != NULL) {
15718 pmultinfo->pmult_state &= ~SATA_STATE_READY;
15719 pmultinfo->pmult_state |= SATA_DSTATE_FAILED;
15720 }
15721
15722 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex);
15723 rv = EIO;
15724 }
15725 /*
15726 * If attached device was a port multiplier, some extra processing
15727 * may be needed to bring it back. SATA specification requies a
15728 * mandatory software reset on host port to reliably enumerate a port
15729 * multiplier, the HBA driver should handle that after reset
15730 * operation.
15731 */
15732 return (rv);
15733 }
15734
15735
15736 /*
15737 * Process ioctl reset all request.
15738 */
15739 static int
15740 sata_ioctl_reset_all(sata_hba_inst_t *sata_hba_inst)
15741 {
15742 sata_device_t sata_device;
15743 int rv = 0;
15744 int tcport;
15745
15746 sata_device.satadev_rev = SATA_DEVICE_REV;
15747
15748 /*
15749 * There is no protection here for configured devices.
15750 */
15751 /* Sanity check */
15752 if (SATA_RESET_DPORT_FUNC(sata_hba_inst) == NULL) {
15753 SATA_LOG_D((sata_hba_inst, CE_WARN,
15754 "sata_hba_ioctl: sata_hba_tran missing required "
15755 "function sata_tran_reset_dport"));
15756 return (ENOTSUP);
15757 }
15758
15759 /*
15760 * Need to lock all ports, not just one.
15761 * If any port is locked by event processing, fail the whole operation.
15762 * One port is already locked, but for simplicity lock it again.
15763 */
15764 for (tcport = 0; tcport < SATA_NUM_CPORTS(sata_hba_inst); tcport++) {
15765 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, tcport)->
15766 cport_mutex);
15767 if (((SATA_CPORT_INFO(sata_hba_inst, tcport)->
15768 cport_event_flags) & SATA_EVNT_LOCK_PORT_BUSY) != 0) {
15769 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, tcport)->
15770 cport_mutex);
15771 rv = EBUSY;
15772 break;
15773 } else {
15774 /*
15775 * It is enough to lock cport in command-based
15776 * switching mode.
15777 */
15778 SATA_CPORT_INFO(sata_hba_inst, tcport)->
15779 cport_event_flags |= SATA_APCTL_LOCK_PORT_BUSY;
15780 }
15781 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, tcport)->
15782 cport_mutex);
15783 }
15784
15785 if (rv == 0) {
15786 /*
15787 * All cports were successfully locked.
15788 * Reset main SATA controller.
15789 * Set the device address to port 0, to have a valid device
15790 * address.
15791 */
15792 sata_device.satadev_addr.qual = SATA_ADDR_CNTRL;
15793 sata_device.satadev_addr.cport = 0;
15794 sata_device.satadev_addr.pmport = 0;
15795
15796 if ((*SATA_RESET_DPORT_FUNC(sata_hba_inst))
15797 (SATA_DIP(sata_hba_inst), &sata_device) != SATA_SUCCESS) {
15798 SATA_LOG_D((sata_hba_inst, CE_WARN,
15799 "sata_hba_ioctl: reset controller failed"));
15800 return (EIO);
15801 }
15802 }
15803 /*
15804 * Unlock all ports
15805 */
15806 for (tcport = 0; tcport < SATA_NUM_CPORTS(sata_hba_inst); tcport++) {
15807 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, tcport)->
15808 cport_mutex);
15809 SATA_CPORT_INFO(sata_hba_inst, tcport)->
15810 cport_event_flags &= ~SATA_APCTL_LOCK_PORT_BUSY;
15811 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, tcport)->
15812 cport_mutex);
15813 }
15814
15815 /*
15816 * This operation returns EFAULT if either reset
15817 * controller failed or a re-probing of any port failed.
15818 */
15819 return (rv);
15820 }
15821
15822
15823 /*
15824 * Process ioctl port self test request.
15825 *
15826 * NOTE: Port multiplier code is not completed nor tested.
15827 */
15828 static int
15829 sata_ioctl_port_self_test(sata_hba_inst_t *sata_hba_inst,
15830 sata_device_t *sata_device)
15831 {
15832 int cport, pmport, qual;
15833 int rv = 0;
15834
15835 /* Sanity check */
15836 if (SATA_SELFTEST_FUNC(sata_hba_inst) == NULL)
15837 return (ENOTSUP);
15838
15839 cport = sata_device->satadev_addr.cport;
15840 pmport = sata_device->satadev_addr.pmport;
15841 qual = sata_device->satadev_addr.qual;
15842
15843 /*
15844 * There is no protection here for a configured
15845 * device attached to this port.
15846 */
15847
15848 if ((*SATA_SELFTEST_FUNC(sata_hba_inst))
15849 (SATA_DIP(sata_hba_inst), sata_device) != SATA_SUCCESS) {
15850 SATA_LOG_D((sata_hba_inst, CE_WARN,
15851 "sata_hba_ioctl: port selftest: "
15852 "failed port %d:%d", cport, pmport));
15853 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, cport)->
15854 cport_mutex);
15855 sata_update_port_info(sata_hba_inst, sata_device);
15856 if (qual == SATA_ADDR_CPORT)
15857 SATA_CPORT_STATE(sata_hba_inst, cport) =
15858 SATA_PSTATE_FAILED;
15859 else { /* port multiplier device port */
15860 mutex_enter(&SATA_PMPORT_MUTEX(sata_hba_inst,
15861 cport, pmport));
15862 SATA_PMPORT_STATE(sata_hba_inst, cport, pmport) =
15863 SATA_PSTATE_FAILED;
15864 mutex_exit(&SATA_PMPORT_MUTEX(sata_hba_inst,
15865 cport, pmport));
15866 }
15867
15868 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)->
15869 cport_mutex);
15870 return (EIO);
15871 }
15872 /*
15873 * Beacuse the port was reset in the course of testing, it should be
15874 * re-probed and attached device state should be restored. At this
15875 * point the port state is unknown - it's state is HBA-specific.
15876 * Force port re-probing to get it into a known state.
15877 */
15878 if (sata_reprobe_port(sata_hba_inst, sata_device,
15879 SATA_DEV_IDENTIFY_RETRY) != SATA_SUCCESS)
15880 rv = EIO;
15881 return (rv);
15882 }
15883
15884
15885 /*
15886 * sata_cfgadm_state:
15887 * Use the sata port state and state of the target node to figure out
15888 * the cfgadm_state.
15889 *
15890 * The port argument is a value with encoded cport,
15891 * pmport and address qualifier, in the same manner as a scsi target number.
15892 * SCSI_TO_SATA_CPORT macro extracts cport number,
15893 * SCSI_TO_SATA_PMPORT extracts pmport number and
15894 * SCSI_TO_SATA_ADDR_QUAL extracts port mulitplier qualifier flag.
15895 *
15896 * Port multiplier is supported.
15897 */
15898
15899 static void
15900 sata_cfgadm_state(sata_hba_inst_t *sata_hba_inst, int32_t port,
15901 devctl_ap_state_t *ap_state)
15902 {
15903 uint8_t cport, pmport, qual;
15904 uint32_t port_state, pmult_state;
15905 uint32_t dev_type;
15906 sata_drive_info_t *sdinfo;
15907
15908 cport = SCSI_TO_SATA_CPORT(port);
15909 pmport = SCSI_TO_SATA_PMPORT(port);
15910 qual = SCSI_TO_SATA_ADDR_QUAL(port);
15911
15912 /* Check cport state */
15913 port_state = SATA_CPORT_STATE(sata_hba_inst, cport);
15914 if (port_state & SATA_PSTATE_SHUTDOWN ||
15915 port_state & SATA_PSTATE_FAILED) {
15916 ap_state->ap_rstate = AP_RSTATE_DISCONNECTED;
15917 ap_state->ap_ostate = AP_OSTATE_UNCONFIGURED;
15918 if (port_state & SATA_PSTATE_FAILED)
15919 ap_state->ap_condition = AP_COND_FAILED;
15920 else
15921 ap_state->ap_condition = AP_COND_UNKNOWN;
15922
15923 return;
15924 }
15925
15926 /* cport state is okay. Now check pmport state */
15927 if (qual == SATA_ADDR_DPMPORT || qual == SATA_ADDR_PMPORT) {
15928 /* Sanity check */
15929 if (SATA_CPORT_DEV_TYPE(sata_hba_inst, cport) !=
15930 SATA_DTYPE_PMULT || SATA_PMPORT_INFO(sata_hba_inst,
15931 cport, pmport) == NULL)
15932 return;
15933 port_state = SATA_PMPORT_STATE(sata_hba_inst, cport, pmport);
15934 if (port_state & SATA_PSTATE_SHUTDOWN ||
15935 port_state & SATA_PSTATE_FAILED) {
15936 ap_state->ap_rstate = AP_RSTATE_DISCONNECTED;
15937 ap_state->ap_ostate = AP_OSTATE_UNCONFIGURED;
15938 if (port_state & SATA_PSTATE_FAILED)
15939 ap_state->ap_condition = AP_COND_FAILED;
15940 else
15941 ap_state->ap_condition = AP_COND_UNKNOWN;
15942
15943 return;
15944 }
15945 }
15946
15947 /* Port is enabled and ready */
15948 if (qual == SATA_ADDR_DCPORT || qual == SATA_ADDR_CPORT)
15949 dev_type = SATA_CPORT_DEV_TYPE(sata_hba_inst, cport);
15950 else
15951 dev_type = SATA_PMPORT_DEV_TYPE(sata_hba_inst, cport, pmport);
15952
15953 switch (dev_type) {
15954 case SATA_DTYPE_NONE:
15955 {
15956 ap_state->ap_ostate = AP_OSTATE_UNCONFIGURED;
15957 ap_state->ap_condition = AP_COND_OK;
15958 /* No device attached */
15959 ap_state->ap_rstate = AP_RSTATE_EMPTY;
15960 break;
15961 }
15962 case SATA_DTYPE_PMULT:
15963 {
15964 /* Need to check port multiplier state */
15965 ASSERT(qual == SATA_ADDR_DCPORT);
15966 pmult_state = SATA_PMULT_INFO(sata_hba_inst, cport)->
15967 pmult_state;
15968 if (pmult_state & (SATA_PSTATE_SHUTDOWN|SATA_PSTATE_FAILED)) {
15969 ap_state->ap_rstate = AP_RSTATE_DISCONNECTED;
15970 ap_state->ap_ostate = AP_OSTATE_UNCONFIGURED;
15971 if (pmult_state & SATA_PSTATE_FAILED)
15972 ap_state->ap_condition = AP_COND_FAILED;
15973 else
15974 ap_state->ap_condition = AP_COND_UNKNOWN;
15975
15976 return;
15977 }
15978
15979 /* Port multiplier is not configurable */
15980 ap_state->ap_ostate = AP_OSTATE_CONFIGURED;
15981 ap_state->ap_rstate = AP_RSTATE_CONNECTED;
15982 ap_state->ap_condition = AP_COND_OK;
15983 break;
15984 }
15985
15986 case SATA_DTYPE_ATADISK:
15987 case SATA_DTYPE_ATAPICD:
15988 case SATA_DTYPE_ATAPITAPE:
15989 case SATA_DTYPE_ATAPIDISK:
15990 {
15991 dev_info_t *tdip = NULL;
15992 dev_info_t *dip = NULL;
15993 int circ;
15994
15995 dip = SATA_DIP(sata_hba_inst);
15996 tdip = sata_get_target_dip(dip, cport, pmport);
15997 ap_state->ap_rstate = AP_RSTATE_CONNECTED;
15998 if (tdip != NULL) {
15999 ndi_devi_enter(dip, &circ);
16000 mutex_enter(&(DEVI(tdip)->devi_lock));
16001 if (DEVI_IS_DEVICE_REMOVED(tdip)) {
16002 /*
16003 * There could be the case where previously
16004 * configured and opened device was removed
16005 * and unknown device was plugged.
16006 * In such case we want to show a device, and
16007 * its configured or unconfigured state but
16008 * indicate unusable condition untill the
16009 * old target node is released and removed.
16010 */
16011 ap_state->ap_condition = AP_COND_UNUSABLE;
16012 } else {
16013 mutex_enter(&SATA_CPORT_MUTEX(sata_hba_inst,
16014 cport));
16015 sdinfo = SATA_CPORT_DRV_INFO(sata_hba_inst,
16016 cport);
16017 if (sdinfo != NULL) {
16018 if ((sdinfo->satadrv_state &
16019 SATA_DSTATE_FAILED) != 0)
16020 ap_state->ap_condition =
16021 AP_COND_FAILED;
16022 else
16023 ap_state->ap_condition =
16024 AP_COND_OK;
16025 } else {
16026 ap_state->ap_condition =
16027 AP_COND_UNKNOWN;
16028 }
16029 mutex_exit(&SATA_CPORT_MUTEX(sata_hba_inst,
16030 cport));
16031 }
16032 if ((DEVI_IS_DEVICE_OFFLINE(tdip)) ||
16033 (DEVI_IS_DEVICE_DOWN(tdip))) {
16034 ap_state->ap_ostate =
16035 AP_OSTATE_UNCONFIGURED;
16036 } else {
16037 ap_state->ap_ostate =
16038 AP_OSTATE_CONFIGURED;
16039 }
16040 mutex_exit(&(DEVI(tdip)->devi_lock));
16041 ndi_devi_exit(dip, circ);
16042 } else {
16043 ap_state->ap_ostate = AP_OSTATE_UNCONFIGURED;
16044 ap_state->ap_condition = AP_COND_UNKNOWN;
16045 }
16046 break;
16047 }
16048 case SATA_DTYPE_ATAPIPROC:
16049 ap_state->ap_rstate = AP_RSTATE_CONNECTED;
16050 ap_state->ap_ostate = AP_OSTATE_UNCONFIGURED;
16051 ap_state->ap_condition = AP_COND_OK;
16052 break;
16053 default:
16054 ap_state->ap_rstate = AP_RSTATE_CONNECTED;
16055 ap_state->ap_ostate = AP_OSTATE_UNCONFIGURED;
16056 ap_state->ap_condition = AP_COND_UNKNOWN;
16057 /*
16058 * This is actually internal error condition (non fatal),
16059 * because we have already checked all defined device types.
16060 */
16061 SATA_LOG_D((sata_hba_inst, CE_WARN,
16062 "sata_cfgadm_state: Internal error: "
16063 "unknown device type"));
16064 break;
16065 }
16066 }
16067
16068
16069 /*
16070 * Process ioctl get device path request.
16071 *
16072 * NOTE: Port multiplier has no target dip. Devices connected to port
16073 * multiplier have target node attached to the HBA node. The only difference
16074 * between them and the directly-attached device node is a target address.
16075 */
16076 static int
16077 sata_ioctl_get_device_path(sata_hba_inst_t *sata_hba_inst,
16078 sata_device_t *sata_device, sata_ioctl_data_t *ioc, int mode)
16079 {
16080 char path[MAXPATHLEN];
16081 uint32_t size;
16082 dev_info_t *tdip;
16083
16084 (void) strcpy(path, "/devices");
16085 if ((tdip = sata_get_scsi_target_dip(SATA_DIP(sata_hba_inst),
16086 &sata_device->satadev_addr)) == NULL) {
16087 /*
16088 * No such device. If this is a request for a size, do not
16089 * return EINVAL for non-existing target, because cfgadm
16090 * will then indicate a meaningless ioctl failure.
16091 * If this is a request for a path, indicate invalid
16092 * argument.
16093 */
16094 if (ioc->get_size == 0)
16095 return (EINVAL);
16096 } else {
16097 (void) ddi_pathname(tdip, path + strlen(path));
16098 }
16099 size = strlen(path) + 1;
16100
16101 if (ioc->get_size != 0) {
16102 if (ddi_copyout((void *)&size, ioc->buf, ioc->bufsiz,
16103 mode) != 0)
16104 return (EFAULT);
16105 } else {
16106 if (ioc->bufsiz != size)
16107 return (EINVAL);
16108
16109 else if (ddi_copyout((void *)&path, ioc->buf, ioc->bufsiz,
16110 mode) != 0)
16111 return (EFAULT);
16112 }
16113 return (0);
16114 }
16115
16116 /*
16117 * Process ioctl get attachment point type request.
16118 *
16119 * NOTE: Port multiplier is supported.
16120 */
16121 static int
16122 sata_ioctl_get_ap_type(sata_hba_inst_t *sata_hba_inst,
16123 sata_device_t *sata_device, sata_ioctl_data_t *ioc, int mode)
16124 {
16125 uint32_t type_len;
16126 const char *ap_type;
16127 int dev_type;
16128
16129 if (sata_device->satadev_addr.qual == SATA_ADDR_DCPORT)
16130 dev_type = SATA_CPORT_DEV_TYPE(sata_hba_inst,
16131 sata_device->satadev_addr.cport);
16132 else /* pmport */
16133 dev_type = SATA_PMPORT_DEV_TYPE(sata_hba_inst,
16134 sata_device->satadev_addr.cport,
16135 sata_device->satadev_addr.pmport);
16136
16137 switch (dev_type) {
16138 case SATA_DTYPE_NONE:
16139 ap_type = "port";
16140 break;
16141
16142 case SATA_DTYPE_ATADISK:
16143 case SATA_DTYPE_ATAPIDISK:
16144 ap_type = "disk";
16145 break;
16146
16147 case SATA_DTYPE_ATAPICD:
16148 ap_type = "cd/dvd";
16149 break;
16150
16151 case SATA_DTYPE_ATAPITAPE:
16152 ap_type = "tape";
16153 break;
16154
16155 case SATA_DTYPE_ATAPIPROC:
16156 ap_type = "processor";
16157 break;
16158
16159 case SATA_DTYPE_PMULT:
16160 ap_type = "sata-pmult";
16161 break;
16162
16163 case SATA_DTYPE_UNKNOWN:
16164 ap_type = "unknown";
16165 break;
16166
16167 default:
16168 ap_type = "unsupported";
16169 break;
16170
16171 } /* end of dev_type switch */
16172
16173 type_len = strlen(ap_type) + 1;
16174
16175 if (ioc->get_size) {
16176 if (ddi_copyout((void *)&type_len, ioc->buf, ioc->bufsiz,
16177 mode) != 0)
16178 return (EFAULT);
16179 } else {
16180 if (ioc->bufsiz != type_len)
16181 return (EINVAL);
16182
16183 if (ddi_copyout((void *)ap_type, ioc->buf,
16184 ioc->bufsiz, mode) != 0)
16185 return (EFAULT);
16186 }
16187 return (0);
16188
16189 }
16190
16191 /*
16192 * Process ioctl get device model info request.
16193 * This operation should return to cfgadm the device model
16194 * information string
16195 *
16196 * NOTE: Port multiplier is supported.
16197 */
16198 static int
16199 sata_ioctl_get_model_info(sata_hba_inst_t *sata_hba_inst,
16200 sata_device_t *sata_device, sata_ioctl_data_t *ioc, int mode)
16201 {
16202 sata_drive_info_t *sdinfo;
16203 uint32_t info_len;
16204 char ap_info[SATA_ID_MODEL_LEN + 1];
16205
16206 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst,
16207 sata_device->satadev_addr.cport)->cport_mutex);
16208 if (sata_device->satadev_addr.qual == SATA_ADDR_DCPORT)
16209 sdinfo = SATA_CPORT_DRV_INFO(sata_hba_inst,
16210 sata_device->satadev_addr.cport);
16211 else /* port multiplier */
16212 sdinfo = SATA_PMPORT_DRV_INFO(sata_hba_inst,
16213 sata_device->satadev_addr.cport,
16214 sata_device->satadev_addr.pmport);
16215 if (sdinfo == NULL) {
16216 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst,
16217 sata_device->satadev_addr.cport)->cport_mutex);
16218 return (EINVAL);
16219 }
16220
16221 #ifdef _LITTLE_ENDIAN
16222 swab(sdinfo->satadrv_id.ai_model, ap_info, SATA_ID_MODEL_LEN);
16223 #else /* _LITTLE_ENDIAN */
16224 bcopy(sdinfo->satadrv_id.ai_model, ap_info, SATA_ID_MODEL_LEN);
16225 #endif /* _LITTLE_ENDIAN */
16226
16227 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst,
16228 sata_device->satadev_addr.cport)->cport_mutex);
16229
16230 ap_info[SATA_ID_MODEL_LEN] = '\0';
16231
16232 info_len = strlen(ap_info) + 1;
16233
16234 if (ioc->get_size) {
16235 if (ddi_copyout((void *)&info_len, ioc->buf, ioc->bufsiz,
16236 mode) != 0)
16237 return (EFAULT);
16238 } else {
16239 if (ioc->bufsiz < info_len)
16240 return (EINVAL);
16241 if (ddi_copyout((void *)ap_info, ioc->buf, ioc->bufsiz,
16242 mode) != 0)
16243 return (EFAULT);
16244 }
16245 return (0);
16246 }
16247
16248
16249 /*
16250 * Process ioctl get device firmware revision info request.
16251 * This operation should return to cfgadm the device firmware revision
16252 * information string
16253 *
16254 * Port multiplier is supported.
16255 */
16256 static int
16257 sata_ioctl_get_revfirmware_info(sata_hba_inst_t *sata_hba_inst,
16258 sata_device_t *sata_device, sata_ioctl_data_t *ioc, int mode)
16259 {
16260 sata_drive_info_t *sdinfo;
16261 uint32_t info_len;
16262 char ap_info[SATA_ID_FW_LEN + 1];
16263
16264 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst,
16265 sata_device->satadev_addr.cport)->cport_mutex);
16266 if (sata_device->satadev_addr.qual == SATA_ADDR_DCPORT)
16267 sdinfo = SATA_CPORT_DRV_INFO(sata_hba_inst,
16268 sata_device->satadev_addr.cport);
16269 else /* port multiplier */
16270 sdinfo = SATA_PMPORT_DRV_INFO(sata_hba_inst,
16271 sata_device->satadev_addr.cport,
16272 sata_device->satadev_addr.pmport);
16273 if (sdinfo == NULL) {
16274 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst,
16275 sata_device->satadev_addr.cport)->cport_mutex);
16276 return (EINVAL);
16277 }
16278
16279 #ifdef _LITTLE_ENDIAN
16280 swab(sdinfo->satadrv_id.ai_fw, ap_info, SATA_ID_FW_LEN);
16281 #else /* _LITTLE_ENDIAN */
16282 bcopy(sdinfo->satadrv_id.ai_fw, ap_info, SATA_ID_FW_LEN);
16283 #endif /* _LITTLE_ENDIAN */
16284
16285 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst,
16286 sata_device->satadev_addr.cport)->cport_mutex);
16287
16288 ap_info[SATA_ID_FW_LEN] = '\0';
16289
16290 info_len = strlen(ap_info) + 1;
16291
16292 if (ioc->get_size) {
16293 if (ddi_copyout((void *)&info_len, ioc->buf, ioc->bufsiz,
16294 mode) != 0)
16295 return (EFAULT);
16296 } else {
16297 if (ioc->bufsiz < info_len)
16298 return (EINVAL);
16299 if (ddi_copyout((void *)ap_info, ioc->buf, ioc->bufsiz,
16300 mode) != 0)
16301 return (EFAULT);
16302 }
16303 return (0);
16304 }
16305
16306
16307 /*
16308 * Process ioctl get device serial number info request.
16309 * This operation should return to cfgadm the device serial number string.
16310 *
16311 * NOTE: Port multiplier is supported.
16312 */
16313 static int
16314 sata_ioctl_get_serialnumber_info(sata_hba_inst_t *sata_hba_inst,
16315 sata_device_t *sata_device, sata_ioctl_data_t *ioc, int mode)
16316 {
16317 sata_drive_info_t *sdinfo;
16318 uint32_t info_len;
16319 char ap_info[SATA_ID_SERIAL_LEN + 1];
16320
16321 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst,
16322 sata_device->satadev_addr.cport)->cport_mutex);
16323 if (sata_device->satadev_addr.qual == SATA_ADDR_DCPORT)
16324 sdinfo = SATA_CPORT_DRV_INFO(sata_hba_inst,
16325 sata_device->satadev_addr.cport);
16326 else /* port multiplier */
16327 sdinfo = SATA_PMPORT_DRV_INFO(sata_hba_inst,
16328 sata_device->satadev_addr.cport,
16329 sata_device->satadev_addr.pmport);
16330 if (sdinfo == NULL) {
16331 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst,
16332 sata_device->satadev_addr.cport)->cport_mutex);
16333 return (EINVAL);
16334 }
16335
16336 #ifdef _LITTLE_ENDIAN
16337 swab(sdinfo->satadrv_id.ai_drvser, ap_info, SATA_ID_SERIAL_LEN);
16338 #else /* _LITTLE_ENDIAN */
16339 bcopy(sdinfo->satadrv_id.ai_drvser, ap_info, SATA_ID_SERIAL_LEN);
16340 #endif /* _LITTLE_ENDIAN */
16341
16342 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst,
16343 sata_device->satadev_addr.cport)->cport_mutex);
16344
16345 ap_info[SATA_ID_SERIAL_LEN] = '\0';
16346
16347 info_len = strlen(ap_info) + 1;
16348
16349 if (ioc->get_size) {
16350 if (ddi_copyout((void *)&info_len, ioc->buf, ioc->bufsiz,
16351 mode) != 0)
16352 return (EFAULT);
16353 } else {
16354 if (ioc->bufsiz < info_len)
16355 return (EINVAL);
16356 if (ddi_copyout((void *)ap_info, ioc->buf, ioc->bufsiz,
16357 mode) != 0)
16358 return (EFAULT);
16359 }
16360 return (0);
16361 }
16362
16363
16364 /*
16365 * Preset scsi extended sense data (to NO SENSE)
16366 * First 18 bytes of the sense data are preset to current valid sense
16367 * with a key NO SENSE data.
16368 *
16369 * Returns void
16370 */
16371 static void
16372 sata_fixed_sense_data_preset(struct scsi_extended_sense *sense)
16373 {
16374 sense->es_valid = 1; /* Valid sense */
16375 sense->es_class = CLASS_EXTENDED_SENSE; /* 0x70 - current err */
16376 sense->es_key = KEY_NO_SENSE;
16377 sense->es_info_1 = 0;
16378 sense->es_info_2 = 0;
16379 sense->es_info_3 = 0;
16380 sense->es_info_4 = 0;
16381 sense->es_add_len = 10; /* Additional length - replace with a def */
16382 sense->es_cmd_info[0] = 0;
16383 sense->es_cmd_info[1] = 0;
16384 sense->es_cmd_info[2] = 0;
16385 sense->es_cmd_info[3] = 0;
16386 sense->es_add_code = 0;
16387 sense->es_qual_code = 0;
16388 }
16389
16390 /*
16391 * Register a legacy cmdk-style devid for the target (disk) device.
16392 *
16393 * Note: This function is called only when the HBA devinfo node has the
16394 * property "use-cmdk-devid-format" set. This property indicates that
16395 * devid compatible with old cmdk (target) driver is to be generated
16396 * for any target device attached to this controller. This will take
16397 * precedence over the devid generated by sd (target) driver.
16398 * This function is derived from cmdk_devid_setup() function in cmdk.c.
16399 */
16400 static void
16401 sata_target_devid_register(dev_info_t *dip, sata_drive_info_t *sdinfo)
16402 {
16403 char *hwid;
16404 int modlen;
16405 int serlen;
16406 int rval;
16407 ddi_devid_t devid;
16408
16409 /*
16410 * device ID is a concatanation of model number, "=", serial number.
16411 */
16412 hwid = kmem_zalloc(LEGACY_HWID_LEN, KM_SLEEP);
16413 bcopy(&sdinfo->satadrv_id.ai_model, hwid,
16414 sizeof (sdinfo->satadrv_id.ai_model));
16415 swab(hwid, hwid, sizeof (sdinfo->satadrv_id.ai_model));
16416 modlen = sata_check_modser(hwid, sizeof (sdinfo->satadrv_id.ai_model));
16417 if (modlen == 0)
16418 goto err;
16419 hwid[modlen++] = '=';
16420 bcopy(&sdinfo->satadrv_id.ai_drvser, &hwid[modlen],
16421 sizeof (sdinfo->satadrv_id.ai_drvser));
16422 swab(&hwid[modlen], &hwid[modlen],
16423 sizeof (sdinfo->satadrv_id.ai_drvser));
16424 serlen = sata_check_modser(&hwid[modlen],
16425 sizeof (sdinfo->satadrv_id.ai_drvser));
16426 if (serlen == 0)
16427 goto err;
16428 hwid[modlen + serlen] = 0; /* terminate the hwid string */
16429
16430 /* initialize/register devid */
16431 if ((rval = ddi_devid_init(dip, DEVID_ATA_SERIAL,
16432 (ushort_t)(modlen + serlen), hwid, &devid)) == DDI_SUCCESS) {
16433 rval = ddi_devid_register(dip, devid);
16434 /*
16435 * Free up the allocated devid buffer.
16436 * NOTE: This doesn't mean unregistering devid.
16437 */
16438 ddi_devid_free(devid);
16439 }
16440
16441 if (rval != DDI_SUCCESS)
16442 cmn_err(CE_WARN, "sata: failed to create devid for the disk"
16443 " on port %d", sdinfo->satadrv_addr.cport);
16444 err:
16445 kmem_free(hwid, LEGACY_HWID_LEN);
16446 }
16447
16448 /*
16449 * valid model/serial string must contain a non-zero non-space characters.
16450 * trim trailing spaces/NULLs.
16451 */
16452 static int
16453 sata_check_modser(char *buf, int buf_len)
16454 {
16455 boolean_t ret;
16456 char *s;
16457 int i;
16458 int tb;
16459 char ch;
16460
16461 ret = B_FALSE;
16462 s = buf;
16463 for (i = 0; i < buf_len; i++) {
16464 ch = *s++;
16465 if (ch != ' ' && ch != '\0')
16466 tb = i + 1;
16467 if (ch != ' ' && ch != '\0' && ch != '0')
16468 ret = B_TRUE;
16469 }
16470
16471 if (ret == B_FALSE)
16472 return (0); /* invalid string */
16473
16474 return (tb); /* return length */
16475 }
16476
16477 /*
16478 * sata_set_drive_features function compares current device features setting
16479 * with the saved device features settings and, if there is a difference,
16480 * it restores device features setting to the previously saved state.
16481 * It also arbitrarily tries to select the highest supported DMA mode.
16482 * Device Identify or Identify Packet Device data has to be current.
16483 * At the moment read ahead and write cache are considered for all devices.
16484 * For atapi devices, Removable Media Status Notification is set in addition
16485 * to common features.
16486 *
16487 * This function cannot be called in the interrupt context (it may sleep).
16488 *
16489 * The input argument sdinfo should point to the drive info structure
16490 * to be updated after features are set. Note, that only
16491 * device (packet) identify data is updated, not the flags indicating the
16492 * supported features.
16493 *
16494 * Returns SATA_SUCCESS if successful or there was nothing to do.
16495 * Device Identify data in the drive info structure pointed to by the sdinfo
16496 * arguments is updated even when no features were set or changed.
16497 *
16498 * Returns SATA_FAILURE if device features could not be set or DMA mode
16499 * for a disk cannot be set and device identify data cannot be fetched.
16500 *
16501 * Returns SATA_RETRY if device features could not be set (other than disk
16502 * DMA mode) but the device identify data was fetched successfully.
16503 *
16504 * Note: This function may fail the port, making it inaccessible.
16505 * In such case the explicit port disconnect/connect or physical device
16506 * detach/attach is required to re-evaluate port state again.
16507 */
16508
16509 static int
16510 sata_set_drive_features(sata_hba_inst_t *sata_hba_inst,
16511 sata_drive_info_t *sdinfo, int restore)
16512 {
16513 int rval = SATA_SUCCESS;
16514 int rval_set;
16515 sata_drive_info_t new_sdinfo;
16516 char *finfo = "sata_set_drive_features: cannot";
16517 char *finfox;
16518 int cache_op;
16519
16520 bzero(&new_sdinfo, sizeof (sata_drive_info_t));
16521 new_sdinfo.satadrv_addr = sdinfo->satadrv_addr;
16522 new_sdinfo.satadrv_type = sdinfo->satadrv_type;
16523 if (sata_fetch_device_identify_data(sata_hba_inst, &new_sdinfo) != 0) {
16524 /*
16525 * Cannot get device identification - caller may retry later
16526 */
16527 SATADBG1(SATA_DBG_DEV_SETTINGS, sata_hba_inst,
16528 "%s fetch device identify data\n", finfo);
16529 return (SATA_FAILURE);
16530 }
16531 finfox = (restore != 0) ? " restore device features" :
16532 " initialize device features\n";
16533
16534 switch (sdinfo->satadrv_type) {
16535 case SATA_DTYPE_ATADISK:
16536 /* Arbitrarily set UDMA mode */
16537 if (sata_set_dma_mode(sata_hba_inst, &new_sdinfo) !=
16538 SATA_SUCCESS) {
16539 SATA_LOG_D((sata_hba_inst, CE_WARN,
16540 "%s set UDMA mode\n", finfo));
16541 return (SATA_FAILURE);
16542 }
16543 break;
16544 case SATA_DTYPE_ATAPICD:
16545 case SATA_DTYPE_ATAPITAPE:
16546 case SATA_DTYPE_ATAPIDISK:
16547 /* Set Removable Media Status Notification, if necessary */
16548 if (SATA_RM_NOTIFIC_SUPPORTED(new_sdinfo.satadrv_id) &&
16549 restore != 0) {
16550 if (((sdinfo->satadrv_settings & SATA_DEV_RMSN) &&
16551 (!SATA_RM_NOTIFIC_ENABLED(new_sdinfo.satadrv_id)))||
16552 ((!(sdinfo->satadrv_settings & SATA_DEV_RMSN)) &&
16553 SATA_RM_NOTIFIC_ENABLED(new_sdinfo.satadrv_id))) {
16554 /* Current setting does not match saved one */
16555 if (sata_set_rmsn(sata_hba_inst, sdinfo,
16556 sdinfo->satadrv_settings &
16557 SATA_DEV_RMSN) != SATA_SUCCESS)
16558 rval = SATA_FAILURE;
16559 }
16560 }
16561 /*
16562 * We have to set Multiword DMA or UDMA, if it is supported, as
16563 * we want to use DMA transfer mode whenever possible.
16564 * Some devices require explicit setting of the DMA mode.
16565 */
16566 if (new_sdinfo.satadrv_id.ai_cap & SATA_DMA_SUPPORT) {
16567 /* Set highest supported DMA mode */
16568 if (sata_set_dma_mode(sata_hba_inst, &new_sdinfo) !=
16569 SATA_SUCCESS) {
16570 SATA_LOG_D((sata_hba_inst, CE_WARN,
16571 "%s set UDMA mode\n", finfo));
16572 rval = SATA_FAILURE;
16573 }
16574 }
16575 break;
16576 }
16577
16578 if (!SATA_READ_AHEAD_SUPPORTED(new_sdinfo.satadrv_id) &&
16579 !SATA_WRITE_CACHE_SUPPORTED(new_sdinfo.satadrv_id)) {
16580 /*
16581 * neither READ AHEAD nor WRITE CACHE is supported
16582 * - do nothing
16583 */
16584 SATADBG1(SATA_DBG_DEV_SETTINGS, sata_hba_inst,
16585 "settable features not supported\n", NULL);
16586 goto update_sdinfo;
16587 }
16588
16589 if ((SATA_READ_AHEAD_ENABLED(new_sdinfo.satadrv_id) &&
16590 (sdinfo->satadrv_settings & SATA_DEV_READ_AHEAD)) &&
16591 (SATA_WRITE_CACHE_ENABLED(new_sdinfo.satadrv_id) &&
16592 (sdinfo->satadrv_settings & SATA_DEV_WRITE_CACHE))) {
16593 /*
16594 * both READ AHEAD and WRITE CACHE are enabled
16595 * - Nothing to do
16596 */
16597 SATADBG1(SATA_DBG_DEV_SETTINGS, sata_hba_inst,
16598 "no device features to set\n", NULL);
16599 goto update_sdinfo;
16600 }
16601
16602 cache_op = 0;
16603
16604 if (SATA_READ_AHEAD_SUPPORTED(new_sdinfo.satadrv_id)) {
16605 if ((sdinfo->satadrv_settings & SATA_DEV_READ_AHEAD) &&
16606 !SATA_READ_AHEAD_ENABLED(new_sdinfo.satadrv_id)) {
16607 /* Enable read ahead / read cache */
16608 cache_op = SATAC_SF_ENABLE_READ_AHEAD;
16609 SATADBG1(SATA_DBG_DEV_SETTINGS, sata_hba_inst,
16610 "enabling read cache\n", NULL);
16611 } else if (!(sdinfo->satadrv_settings & SATA_DEV_READ_AHEAD) &&
16612 SATA_READ_AHEAD_ENABLED(new_sdinfo.satadrv_id)) {
16613 /* Disable read ahead / read cache */
16614 cache_op = SATAC_SF_DISABLE_READ_AHEAD;
16615 SATADBG1(SATA_DBG_DEV_SETTINGS, sata_hba_inst,
16616 "disabling read cache\n", NULL);
16617 }
16618
16619 if (cache_op != 0) {
16620 /* Try to set read cache mode */
16621 rval_set = sata_set_cache_mode(sata_hba_inst,
16622 &new_sdinfo, cache_op);
16623 if (rval != SATA_FAILURE && rval_set != SATA_SUCCESS)
16624 rval = rval_set;
16625 }
16626 }
16627
16628 cache_op = 0;
16629
16630 if (SATA_WRITE_CACHE_SUPPORTED(new_sdinfo.satadrv_id)) {
16631 if ((sdinfo->satadrv_settings & SATA_DEV_WRITE_CACHE) &&
16632 !SATA_WRITE_CACHE_ENABLED(new_sdinfo.satadrv_id)) {
16633 /* Enable write cache */
16634 cache_op = SATAC_SF_ENABLE_WRITE_CACHE;
16635 SATADBG1(SATA_DBG_DEV_SETTINGS, sata_hba_inst,
16636 "enabling write cache\n", NULL);
16637 } else if (!(sdinfo->satadrv_settings & SATA_DEV_WRITE_CACHE) &&
16638 SATA_WRITE_CACHE_ENABLED(new_sdinfo.satadrv_id)) {
16639 /* Disable write cache */
16640 cache_op = SATAC_SF_DISABLE_WRITE_CACHE;
16641 SATADBG1(SATA_DBG_DEV_SETTINGS, sata_hba_inst,
16642 "disabling write cache\n", NULL);
16643 }
16644
16645 if (cache_op != 0) {
16646 /* Try to set write cache mode */
16647 rval_set = sata_set_cache_mode(sata_hba_inst,
16648 &new_sdinfo, cache_op);
16649 if (rval != SATA_FAILURE && rval_set != SATA_SUCCESS)
16650 rval = rval_set;
16651 }
16652 }
16653 if (rval != SATA_SUCCESS)
16654 SATA_LOG_D((sata_hba_inst, CE_WARN,
16655 "%s %s", finfo, finfox));
16656
16657 update_sdinfo:
16658 /*
16659 * We need to fetch Device Identify data again
16660 */
16661 if (sata_fetch_device_identify_data(sata_hba_inst, &new_sdinfo) != 0) {
16662 /*
16663 * Cannot get device identification - retry later
16664 */
16665 SATA_LOG_D((sata_hba_inst, CE_WARN,
16666 "%s re-fetch device identify data\n", finfo));
16667 rval = SATA_FAILURE;
16668 }
16669 /* Copy device sata info. */
16670 sdinfo->satadrv_id = new_sdinfo.satadrv_id;
16671
16672 return (rval);
16673 }
16674
16675
16676 /*
16677 *
16678 * Returns 1 if threshold exceeded, 0 if threshold not exceeded, -1 if
16679 * unable to determine.
16680 *
16681 * Cannot be called in an interrupt context.
16682 *
16683 * Called by sata_build_lsense_page_2f()
16684 */
16685
16686 static int
16687 sata_fetch_smart_return_status(sata_hba_inst_t *sata_hba_inst,
16688 sata_drive_info_t *sdinfo)
16689 {
16690 sata_pkt_t *spkt;
16691 sata_cmd_t *scmd;
16692 sata_pkt_txlate_t *spx;
16693 int rval;
16694
16695 spx = kmem_zalloc(sizeof (sata_pkt_txlate_t), KM_SLEEP);
16696 spx->txlt_sata_hba_inst = sata_hba_inst;
16697 spx->txlt_scsi_pkt = NULL; /* No scsi pkt involved */
16698 spkt = sata_pkt_alloc(spx, SLEEP_FUNC);
16699 if (spkt == NULL) {
16700 kmem_free(spx, sizeof (sata_pkt_txlate_t));
16701 return (-1);
16702 }
16703 /* address is needed now */
16704 spkt->satapkt_device.satadev_addr = sdinfo->satadrv_addr;
16705
16706
16707 /* Fill sata_pkt */
16708 spkt->satapkt_device.satadev_addr = sdinfo->satadrv_addr;
16709 spkt->satapkt_op_mode = SATA_OPMODE_SYNCH | SATA_OPMODE_INTERRUPTS;
16710 /* Synchronous mode, no callback */
16711 spkt->satapkt_comp = NULL;
16712 /* Timeout 30s */
16713 spkt->satapkt_time = sata_default_pkt_time;
16714
16715 scmd = &spkt->satapkt_cmd;
16716 scmd->satacmd_flags.sata_special_regs = B_TRUE;
16717 scmd->satacmd_flags.sata_data_direction = SATA_DIR_NODATA_XFER;
16718
16719 /* Set up which registers need to be returned */
16720 scmd->satacmd_flags.sata_copy_out_lba_mid_lsb = B_TRUE;
16721 scmd->satacmd_flags.sata_copy_out_lba_high_lsb = B_TRUE;
16722
16723 /* Build SMART_RETURN_STATUS cmd in the sata_pkt */
16724 scmd->satacmd_addr_type = 0; /* N/A */
16725 scmd->satacmd_sec_count_lsb = 0; /* N/A */
16726 scmd->satacmd_lba_low_lsb = 0; /* N/A */
16727 scmd->satacmd_lba_mid_lsb = SMART_MAGIC_VAL_1;
16728 scmd->satacmd_lba_high_lsb = SMART_MAGIC_VAL_2;
16729 scmd->satacmd_features_reg = SATA_SMART_RETURN_STATUS;
16730 scmd->satacmd_device_reg = 0; /* Always device 0 */
16731 scmd->satacmd_cmd_reg = SATAC_SMART;
16732 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst,
16733 sdinfo->satadrv_addr.cport)));
16734
16735
16736 /* Send pkt to SATA HBA driver */
16737 if ((*SATA_START_FUNC(sata_hba_inst))(SATA_DIP(sata_hba_inst), spkt) !=
16738 SATA_TRAN_ACCEPTED ||
16739 spkt->satapkt_reason != SATA_PKT_COMPLETED) {
16740 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst,
16741 sdinfo->satadrv_addr.cport)));
16742 /*
16743 * Whoops, no SMART RETURN STATUS
16744 */
16745 rval = -1;
16746 } else {
16747 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst,
16748 sdinfo->satadrv_addr.cport)));
16749 if (scmd->satacmd_error_reg & SATA_ERROR_ABORT) {
16750 rval = -1;
16751 goto fail;
16752 }
16753 if (scmd->satacmd_status_reg & SATA_STATUS_ERR) {
16754 rval = -1;
16755 goto fail;
16756 }
16757 if ((scmd->satacmd_lba_mid_lsb == SMART_MAGIC_VAL_1) &&
16758 (scmd->satacmd_lba_high_lsb == SMART_MAGIC_VAL_2))
16759 rval = 0;
16760 else if ((scmd->satacmd_lba_mid_lsb == SMART_MAGIC_VAL_3) &&
16761 (scmd->satacmd_lba_high_lsb == SMART_MAGIC_VAL_4))
16762 rval = 1;
16763 else {
16764 rval = -1;
16765 goto fail;
16766 }
16767 }
16768 fail:
16769 /* Free allocated resources */
16770 sata_pkt_free(spx);
16771 kmem_free(spx, sizeof (sata_pkt_txlate_t));
16772
16773 return (rval);
16774 }
16775
16776 /*
16777 *
16778 * Returns 0 if succeeded, -1 otherwise
16779 *
16780 * Cannot be called in an interrupt context.
16781 *
16782 */
16783 static int
16784 sata_fetch_smart_data(
16785 sata_hba_inst_t *sata_hba_inst,
16786 sata_drive_info_t *sdinfo,
16787 struct smart_data *smart_data)
16788 {
16789 sata_pkt_t *spkt;
16790 sata_cmd_t *scmd;
16791 sata_pkt_txlate_t *spx;
16792 int rval;
16793 dev_info_t *dip = SATA_DIP(sata_hba_inst);
16794
16795 #if ! defined(lint)
16796 ASSERT(sizeof (struct smart_data) == 512);
16797 #endif
16798
16799 spx = kmem_zalloc(sizeof (sata_pkt_txlate_t), KM_SLEEP);
16800 spx->txlt_sata_hba_inst = sata_hba_inst;
16801 spx->txlt_scsi_pkt = NULL; /* No scsi pkt involved */
16802 spkt = sata_pkt_alloc(spx, SLEEP_FUNC);
16803 if (spkt == NULL) {
16804 kmem_free(spx, sizeof (sata_pkt_txlate_t));
16805 return (-1);
16806 }
16807 /* address is needed now */
16808 spkt->satapkt_device.satadev_addr = sdinfo->satadrv_addr;
16809
16810
16811 /* Fill sata_pkt */
16812 spkt->satapkt_device.satadev_addr = sdinfo->satadrv_addr;
16813 spkt->satapkt_op_mode = SATA_OPMODE_SYNCH | SATA_OPMODE_INTERRUPTS;
16814 /* Synchronous mode, no callback */
16815 spkt->satapkt_comp = NULL;
16816 /* Timeout 30s */
16817 spkt->satapkt_time = sata_default_pkt_time;
16818
16819 scmd = &spkt->satapkt_cmd;
16820 scmd->satacmd_flags.sata_data_direction = SATA_DIR_READ;
16821
16822 /*
16823 * Allocate buffer for SMART data
16824 */
16825 scmd->satacmd_bp = sata_alloc_local_buffer(spx,
16826 sizeof (struct smart_data));
16827 if (scmd->satacmd_bp == NULL) {
16828 sata_pkt_free(spx);
16829 kmem_free(spx, sizeof (sata_pkt_txlate_t));
16830 SATA_LOG_D((sata_hba_inst, CE_WARN,
16831 "sata_fetch_smart_data: "
16832 "cannot allocate buffer"));
16833 return (-1);
16834 }
16835
16836
16837 /* Build SMART_READ_DATA cmd in the sata_pkt */
16838 scmd->satacmd_addr_type = 0; /* N/A */
16839 scmd->satacmd_sec_count_lsb = 0; /* N/A */
16840 scmd->satacmd_lba_low_lsb = 0; /* N/A */
16841 scmd->satacmd_lba_mid_lsb = SMART_MAGIC_VAL_1;
16842 scmd->satacmd_lba_high_lsb = SMART_MAGIC_VAL_2;
16843 scmd->satacmd_features_reg = SATA_SMART_READ_DATA;
16844 scmd->satacmd_device_reg = 0; /* Always device 0 */
16845 scmd->satacmd_cmd_reg = SATAC_SMART;
16846 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst,
16847 sdinfo->satadrv_addr.cport)));
16848
16849 /* Send pkt to SATA HBA driver */
16850 if ((*SATA_START_FUNC(sata_hba_inst))(SATA_DIP(sata_hba_inst), spkt) !=
16851 SATA_TRAN_ACCEPTED ||
16852 spkt->satapkt_reason != SATA_PKT_COMPLETED) {
16853 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst,
16854 sdinfo->satadrv_addr.cport)));
16855 /*
16856 * Whoops, no SMART DATA available
16857 */
16858 rval = -1;
16859 goto fail;
16860 } else {
16861 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst,
16862 sdinfo->satadrv_addr.cport)));
16863 if (spx->txlt_buf_dma_handle != NULL) {
16864 rval = ddi_dma_sync(spx->txlt_buf_dma_handle, 0, 0,
16865 DDI_DMA_SYNC_FORKERNEL);
16866 ASSERT(rval == DDI_SUCCESS);
16867 if (sata_check_for_dma_error(dip, spx)) {
16868 ddi_fm_service_impact(dip,
16869 DDI_SERVICE_UNAFFECTED);
16870 rval = -1;
16871 goto fail;
16872 }
16873 }
16874 bcopy(scmd->satacmd_bp->b_un.b_addr, (uint8_t *)smart_data,
16875 sizeof (struct smart_data));
16876 }
16877
16878 fail:
16879 /* Free allocated resources */
16880 sata_free_local_buffer(spx);
16881 sata_pkt_free(spx);
16882 kmem_free(spx, sizeof (sata_pkt_txlate_t));
16883
16884 return (rval);
16885 }
16886
16887 /*
16888 * Used by LOG SENSE page 0x10
16889 * Reads (in synchronous mode) the self test log data using Read Log Ext cmd.
16890 * Note: cannot be called in the interrupt context.
16891 *
16892 * return 0 for success, -1 otherwise
16893 *
16894 */
16895 static int
16896 sata_ext_smart_selftest_read_log(
16897 sata_hba_inst_t *sata_hba_inst,
16898 sata_drive_info_t *sdinfo,
16899 struct smart_ext_selftest_log *ext_selftest_log,
16900 uint16_t block_num)
16901 {
16902 sata_pkt_txlate_t *spx;
16903 sata_pkt_t *spkt;
16904 sata_cmd_t *scmd;
16905 int rval;
16906 dev_info_t *dip = SATA_DIP(sata_hba_inst);
16907
16908 #if ! defined(lint)
16909 ASSERT(sizeof (struct smart_ext_selftest_log) == 512);
16910 #endif
16911
16912 spx = kmem_zalloc(sizeof (sata_pkt_txlate_t), KM_SLEEP);
16913 spx->txlt_sata_hba_inst = sata_hba_inst;
16914 spx->txlt_scsi_pkt = NULL; /* No scsi pkt involved */
16915 spkt = sata_pkt_alloc(spx, SLEEP_FUNC);
16916 if (spkt == NULL) {
16917 kmem_free(spx, sizeof (sata_pkt_txlate_t));
16918 return (-1);
16919 }
16920 /* address is needed now */
16921 spkt->satapkt_device.satadev_addr = sdinfo->satadrv_addr;
16922
16923
16924 /* Fill sata_pkt */
16925 spkt->satapkt_device.satadev_addr = sdinfo->satadrv_addr;
16926 spkt->satapkt_op_mode = SATA_OPMODE_SYNCH | SATA_OPMODE_INTERRUPTS;
16927 /* Synchronous mode, no callback */
16928 spkt->satapkt_comp = NULL;
16929 /* Timeout 30s */
16930 spkt->satapkt_time = sata_default_pkt_time;
16931
16932 scmd = &spkt->satapkt_cmd;
16933 scmd->satacmd_flags.sata_data_direction = SATA_DIR_READ;
16934
16935 /*
16936 * Allocate buffer for SMART extended self-test log
16937 */
16938 scmd->satacmd_bp = sata_alloc_local_buffer(spx,
16939 sizeof (struct smart_ext_selftest_log));
16940 if (scmd->satacmd_bp == NULL) {
16941 sata_pkt_free(spx);
16942 kmem_free(spx, sizeof (sata_pkt_txlate_t));
16943 SATA_LOG_D((sata_hba_inst, CE_WARN,
16944 "sata_ext_smart_selftest_log: "
16945 "cannot allocate buffer"));
16946 return (-1);
16947 }
16948
16949 /* Build READ LOG EXT w/ extended self-test log cmd in the sata_pkt */
16950 scmd->satacmd_addr_type = ATA_ADDR_LBA48;
16951 scmd->satacmd_sec_count_lsb = 1; /* One sector of selftest log */
16952 scmd->satacmd_sec_count_msb = 0; /* One sector of selftest log */
16953 scmd->satacmd_lba_low_lsb = EXT_SMART_SELFTEST_LOG_PAGE;
16954 scmd->satacmd_lba_low_msb = 0;
16955 scmd->satacmd_lba_mid_lsb = block_num & 0xff;
16956 scmd->satacmd_lba_mid_msb = block_num >> 8;
16957 scmd->satacmd_device_reg = 0; /* Always device 0 */
16958 scmd->satacmd_cmd_reg = SATAC_READ_LOG_EXT;
16959
16960 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst,
16961 sdinfo->satadrv_addr.cport)));
16962
16963 /* Send pkt to SATA HBA driver */
16964 if ((*SATA_START_FUNC(sata_hba_inst))(SATA_DIP(sata_hba_inst), spkt) !=
16965 SATA_TRAN_ACCEPTED ||
16966 spkt->satapkt_reason != SATA_PKT_COMPLETED) {
16967 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst,
16968 sdinfo->satadrv_addr.cport)));
16969
16970 /*
16971 * Whoops, no SMART selftest log info available
16972 */
16973 rval = -1;
16974 goto fail;
16975 } else {
16976 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst,
16977 sdinfo->satadrv_addr.cport)));
16978
16979 if (spx->txlt_buf_dma_handle != NULL) {
16980 rval = ddi_dma_sync(spx->txlt_buf_dma_handle, 0, 0,
16981 DDI_DMA_SYNC_FORKERNEL);
16982 ASSERT(rval == DDI_SUCCESS);
16983 if (sata_check_for_dma_error(dip, spx)) {
16984 ddi_fm_service_impact(dip,
16985 DDI_SERVICE_UNAFFECTED);
16986 rval = -1;
16987 goto fail;
16988 }
16989 }
16990 bcopy(scmd->satacmd_bp->b_un.b_addr,
16991 (uint8_t *)ext_selftest_log,
16992 sizeof (struct smart_ext_selftest_log));
16993 rval = 0;
16994 }
16995
16996 fail:
16997 /* Free allocated resources */
16998 sata_free_local_buffer(spx);
16999 sata_pkt_free(spx);
17000 kmem_free(spx, sizeof (sata_pkt_txlate_t));
17001
17002 return (rval);
17003 }
17004
17005 /*
17006 * Returns 0 for success, -1 otherwise
17007 *
17008 * SMART self-test log data is returned in buffer pointed to by selftest_log
17009 */
17010 static int
17011 sata_smart_selftest_log(
17012 sata_hba_inst_t *sata_hba_inst,
17013 sata_drive_info_t *sdinfo,
17014 struct smart_selftest_log *selftest_log)
17015 {
17016 sata_pkt_t *spkt;
17017 sata_cmd_t *scmd;
17018 sata_pkt_txlate_t *spx;
17019 int rval;
17020 dev_info_t *dip = SATA_DIP(sata_hba_inst);
17021
17022 #if ! defined(lint)
17023 ASSERT(sizeof (struct smart_selftest_log) == 512);
17024 #endif
17025
17026 spx = kmem_zalloc(sizeof (sata_pkt_txlate_t), KM_SLEEP);
17027 spx->txlt_sata_hba_inst = sata_hba_inst;
17028 spx->txlt_scsi_pkt = NULL; /* No scsi pkt involved */
17029 spkt = sata_pkt_alloc(spx, SLEEP_FUNC);
17030 if (spkt == NULL) {
17031 kmem_free(spx, sizeof (sata_pkt_txlate_t));
17032 return (-1);
17033 }
17034 /* address is needed now */
17035 spkt->satapkt_device.satadev_addr = sdinfo->satadrv_addr;
17036
17037
17038 /* Fill sata_pkt */
17039 spkt->satapkt_device.satadev_addr = sdinfo->satadrv_addr;
17040 spkt->satapkt_op_mode = SATA_OPMODE_SYNCH | SATA_OPMODE_INTERRUPTS;
17041 /* Synchronous mode, no callback */
17042 spkt->satapkt_comp = NULL;
17043 /* Timeout 30s */
17044 spkt->satapkt_time = sata_default_pkt_time;
17045
17046 scmd = &spkt->satapkt_cmd;
17047 scmd->satacmd_flags.sata_data_direction = SATA_DIR_READ;
17048
17049 /*
17050 * Allocate buffer for SMART SELFTEST LOG
17051 */
17052 scmd->satacmd_bp = sata_alloc_local_buffer(spx,
17053 sizeof (struct smart_selftest_log));
17054 if (scmd->satacmd_bp == NULL) {
17055 sata_pkt_free(spx);
17056 kmem_free(spx, sizeof (sata_pkt_txlate_t));
17057 SATA_LOG_D((sata_hba_inst, CE_WARN,
17058 "sata_smart_selftest_log: "
17059 "cannot allocate buffer"));
17060 return (-1);
17061 }
17062
17063 /* Build SMART_READ_LOG cmd in the sata_pkt */
17064 scmd->satacmd_addr_type = 0; /* N/A */
17065 scmd->satacmd_sec_count_lsb = 1; /* One sector of SMART log */
17066 scmd->satacmd_lba_low_lsb = SMART_SELFTEST_LOG_PAGE;
17067 scmd->satacmd_lba_mid_lsb = SMART_MAGIC_VAL_1;
17068 scmd->satacmd_lba_high_lsb = SMART_MAGIC_VAL_2;
17069 scmd->satacmd_features_reg = SATA_SMART_READ_LOG;
17070 scmd->satacmd_device_reg = 0; /* Always device 0 */
17071 scmd->satacmd_cmd_reg = SATAC_SMART;
17072 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst,
17073 sdinfo->satadrv_addr.cport)));
17074
17075 /* Send pkt to SATA HBA driver */
17076 if ((*SATA_START_FUNC(sata_hba_inst))(SATA_DIP(sata_hba_inst), spkt) !=
17077 SATA_TRAN_ACCEPTED ||
17078 spkt->satapkt_reason != SATA_PKT_COMPLETED) {
17079 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst,
17080 sdinfo->satadrv_addr.cport)));
17081 /*
17082 * Whoops, no SMART DATA available
17083 */
17084 rval = -1;
17085 goto fail;
17086 } else {
17087 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst,
17088 sdinfo->satadrv_addr.cport)));
17089 if (spx->txlt_buf_dma_handle != NULL) {
17090 rval = ddi_dma_sync(spx->txlt_buf_dma_handle, 0, 0,
17091 DDI_DMA_SYNC_FORKERNEL);
17092 ASSERT(rval == DDI_SUCCESS);
17093 if (sata_check_for_dma_error(dip, spx)) {
17094 ddi_fm_service_impact(dip,
17095 DDI_SERVICE_UNAFFECTED);
17096 rval = -1;
17097 goto fail;
17098 }
17099 }
17100 bcopy(scmd->satacmd_bp->b_un.b_addr, (uint8_t *)selftest_log,
17101 sizeof (struct smart_selftest_log));
17102 rval = 0;
17103 }
17104
17105 fail:
17106 /* Free allocated resources */
17107 sata_free_local_buffer(spx);
17108 sata_pkt_free(spx);
17109 kmem_free(spx, sizeof (sata_pkt_txlate_t));
17110
17111 return (rval);
17112 }
17113
17114
17115 /*
17116 * Returns 0 for success, -1 otherwise
17117 *
17118 * SMART READ LOG data is returned in buffer pointed to by smart_log
17119 */
17120 static int
17121 sata_smart_read_log(
17122 sata_hba_inst_t *sata_hba_inst,
17123 sata_drive_info_t *sdinfo,
17124 uint8_t *smart_log, /* where the data should be returned */
17125 uint8_t which_log, /* which log should be returned */
17126 uint8_t log_size) /* # of 512 bytes in log */
17127 {
17128 sata_pkt_t *spkt;
17129 sata_cmd_t *scmd;
17130 sata_pkt_txlate_t *spx;
17131 int rval;
17132 dev_info_t *dip = SATA_DIP(sata_hba_inst);
17133
17134 spx = kmem_zalloc(sizeof (sata_pkt_txlate_t), KM_SLEEP);
17135 spx->txlt_sata_hba_inst = sata_hba_inst;
17136 spx->txlt_scsi_pkt = NULL; /* No scsi pkt involved */
17137 spkt = sata_pkt_alloc(spx, SLEEP_FUNC);
17138 if (spkt == NULL) {
17139 kmem_free(spx, sizeof (sata_pkt_txlate_t));
17140 return (-1);
17141 }
17142 /* address is needed now */
17143 spkt->satapkt_device.satadev_addr = sdinfo->satadrv_addr;
17144
17145
17146 /* Fill sata_pkt */
17147 spkt->satapkt_device.satadev_addr = sdinfo->satadrv_addr;
17148 spkt->satapkt_op_mode = SATA_OPMODE_SYNCH | SATA_OPMODE_INTERRUPTS;
17149 /* Synchronous mode, no callback */
17150 spkt->satapkt_comp = NULL;
17151 /* Timeout 30s */
17152 spkt->satapkt_time = sata_default_pkt_time;
17153
17154 scmd = &spkt->satapkt_cmd;
17155 scmd->satacmd_flags.sata_data_direction = SATA_DIR_READ;
17156
17157 /*
17158 * Allocate buffer for SMART READ LOG
17159 */
17160 scmd->satacmd_bp = sata_alloc_local_buffer(spx, log_size * 512);
17161 if (scmd->satacmd_bp == NULL) {
17162 sata_pkt_free(spx);
17163 kmem_free(spx, sizeof (sata_pkt_txlate_t));
17164 SATA_LOG_D((sata_hba_inst, CE_WARN,
17165 "sata_smart_read_log: " "cannot allocate buffer"));
17166 return (-1);
17167 }
17168
17169 /* Build SMART_READ_LOG cmd in the sata_pkt */
17170 scmd->satacmd_addr_type = 0; /* N/A */
17171 scmd->satacmd_sec_count_lsb = log_size; /* what the caller asked for */
17172 scmd->satacmd_lba_low_lsb = which_log; /* which log page */
17173 scmd->satacmd_lba_mid_lsb = SMART_MAGIC_VAL_1;
17174 scmd->satacmd_lba_high_lsb = SMART_MAGIC_VAL_2;
17175 scmd->satacmd_features_reg = SATA_SMART_READ_LOG;
17176 scmd->satacmd_device_reg = 0; /* Always device 0 */
17177 scmd->satacmd_cmd_reg = SATAC_SMART;
17178
17179 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst,
17180 sdinfo->satadrv_addr.cport)));
17181
17182 /* Send pkt to SATA HBA driver */
17183 if ((*SATA_START_FUNC(sata_hba_inst))(SATA_DIP(sata_hba_inst), spkt) !=
17184 SATA_TRAN_ACCEPTED ||
17185 spkt->satapkt_reason != SATA_PKT_COMPLETED) {
17186 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst,
17187 sdinfo->satadrv_addr.cport)));
17188
17189 /*
17190 * Whoops, no SMART DATA available
17191 */
17192 rval = -1;
17193 goto fail;
17194 } else {
17195 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst,
17196 sdinfo->satadrv_addr.cport)));
17197
17198 if (spx->txlt_buf_dma_handle != NULL) {
17199 rval = ddi_dma_sync(spx->txlt_buf_dma_handle, 0, 0,
17200 DDI_DMA_SYNC_FORKERNEL);
17201 ASSERT(rval == DDI_SUCCESS);
17202 if (sata_check_for_dma_error(dip, spx)) {
17203 ddi_fm_service_impact(dip,
17204 DDI_SERVICE_UNAFFECTED);
17205 rval = -1;
17206 goto fail;
17207 }
17208 }
17209 bcopy(scmd->satacmd_bp->b_un.b_addr, smart_log, log_size * 512);
17210 rval = 0;
17211 }
17212
17213 fail:
17214 /* Free allocated resources */
17215 sata_free_local_buffer(spx);
17216 sata_pkt_free(spx);
17217 kmem_free(spx, sizeof (sata_pkt_txlate_t));
17218
17219 return (rval);
17220 }
17221
17222 /*
17223 * Used by LOG SENSE page 0x10
17224 *
17225 * return 0 for success, -1 otherwise
17226 *
17227 */
17228 static int
17229 sata_read_log_ext_directory(
17230 sata_hba_inst_t *sata_hba_inst,
17231 sata_drive_info_t *sdinfo,
17232 struct read_log_ext_directory *logdir)
17233 {
17234 sata_pkt_txlate_t *spx;
17235 sata_pkt_t *spkt;
17236 sata_cmd_t *scmd;
17237 int rval;
17238 dev_info_t *dip = SATA_DIP(sata_hba_inst);
17239
17240 #if ! defined(lint)
17241 ASSERT(sizeof (struct read_log_ext_directory) == 512);
17242 #endif
17243
17244 spx = kmem_zalloc(sizeof (sata_pkt_txlate_t), KM_SLEEP);
17245 spx->txlt_sata_hba_inst = sata_hba_inst;
17246 spx->txlt_scsi_pkt = NULL; /* No scsi pkt involved */
17247 spkt = sata_pkt_alloc(spx, SLEEP_FUNC);
17248 if (spkt == NULL) {
17249 kmem_free(spx, sizeof (sata_pkt_txlate_t));
17250 return (-1);
17251 }
17252
17253 /* Fill sata_pkt */
17254 spkt->satapkt_device.satadev_addr = sdinfo->satadrv_addr;
17255 spkt->satapkt_op_mode = SATA_OPMODE_SYNCH | SATA_OPMODE_INTERRUPTS;
17256 /* Synchronous mode, no callback */
17257 spkt->satapkt_comp = NULL;
17258 /* Timeout 30s */
17259 spkt->satapkt_time = sata_default_pkt_time;
17260
17261 scmd = &spkt->satapkt_cmd;
17262 scmd->satacmd_flags.sata_data_direction = SATA_DIR_READ;
17263
17264 /*
17265 * Allocate buffer for SMART READ LOG EXTENDED command
17266 */
17267 scmd->satacmd_bp = sata_alloc_local_buffer(spx,
17268 sizeof (struct read_log_ext_directory));
17269 if (scmd->satacmd_bp == NULL) {
17270 sata_pkt_free(spx);
17271 kmem_free(spx, sizeof (sata_pkt_txlate_t));
17272 SATA_LOG_D((sata_hba_inst, CE_WARN,
17273 "sata_read_log_ext_directory: "
17274 "cannot allocate buffer"));
17275 return (-1);
17276 }
17277
17278 /* Build READ LOG EXT w/ log directory cmd in the sata_pkt */
17279 scmd->satacmd_addr_type = ATA_ADDR_LBA48;
17280 scmd->satacmd_sec_count_lsb = 1; /* One sector of directory */
17281 scmd->satacmd_sec_count_msb = 0; /* One sector of directory */
17282 scmd->satacmd_lba_low_lsb = READ_LOG_EXT_LOG_DIRECTORY;
17283 scmd->satacmd_lba_low_msb = 0;
17284 scmd->satacmd_lba_mid_lsb = 0;
17285 scmd->satacmd_lba_mid_msb = 0;
17286 scmd->satacmd_device_reg = 0; /* Always device 0 */
17287 scmd->satacmd_cmd_reg = SATAC_READ_LOG_EXT;
17288
17289 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst,
17290 sdinfo->satadrv_addr.cport)));
17291
17292 /* Send pkt to SATA HBA driver */
17293 if ((*SATA_START_FUNC(sata_hba_inst))(SATA_DIP(sata_hba_inst), spkt) !=
17294 SATA_TRAN_ACCEPTED ||
17295 spkt->satapkt_reason != SATA_PKT_COMPLETED) {
17296 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst,
17297 sdinfo->satadrv_addr.cport)));
17298 /*
17299 * Whoops, no SMART selftest log info available
17300 */
17301 rval = -1;
17302 goto fail;
17303 } else {
17304 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst,
17305 sdinfo->satadrv_addr.cport)));
17306 if (spx->txlt_buf_dma_handle != NULL) {
17307 rval = ddi_dma_sync(spx->txlt_buf_dma_handle, 0, 0,
17308 DDI_DMA_SYNC_FORKERNEL);
17309 ASSERT(rval == DDI_SUCCESS);
17310 if (sata_check_for_dma_error(dip, spx)) {
17311 ddi_fm_service_impact(dip,
17312 DDI_SERVICE_UNAFFECTED);
17313 rval = -1;
17314 goto fail;
17315 }
17316 }
17317 bcopy(scmd->satacmd_bp->b_un.b_addr, (uint8_t *)logdir,
17318 sizeof (struct read_log_ext_directory));
17319 rval = 0;
17320 }
17321
17322 fail:
17323 /* Free allocated resources */
17324 sata_free_local_buffer(spx);
17325 sata_pkt_free(spx);
17326 kmem_free(spx, sizeof (sata_pkt_txlate_t));
17327
17328 return (rval);
17329 }
17330
17331 /*
17332 * Set up error retrieval sata command for NCQ command error data
17333 * recovery.
17334 *
17335 * Returns SATA_SUCCESS when data buffer is allocated and packet set-up,
17336 * returns SATA_FAILURE otherwise.
17337 */
17338 static int
17339 sata_ncq_err_ret_cmd_setup(sata_pkt_txlate_t *spx, sata_drive_info_t *sdinfo)
17340 {
17341 #ifndef __lock_lint
17342 _NOTE(ARGUNUSED(sdinfo))
17343 #endif
17344
17345 sata_pkt_t *spkt = spx->txlt_sata_pkt;
17346 sata_cmd_t *scmd;
17347 struct buf *bp;
17348
17349 /* Operation modes are up to the caller */
17350 spkt->satapkt_op_mode = SATA_OPMODE_SYNCH | SATA_OPMODE_INTERRUPTS;
17351
17352 /* Synchronous mode, no callback - may be changed by the caller */
17353 spkt->satapkt_comp = NULL;
17354 spkt->satapkt_time = sata_default_pkt_time;
17355
17356 scmd = &spkt->satapkt_cmd;
17357 bcopy(&sata_rle_cmd, scmd, sizeof (sata_cmd_t));
17358 scmd->satacmd_flags.sata_ignore_dev_reset = B_TRUE;
17359
17360 /*
17361 * Allocate dma_able buffer error data.
17362 * Buffer allocation will take care of buffer alignment and other DMA
17363 * attributes.
17364 */
17365 bp = sata_alloc_local_buffer(spx,
17366 sizeof (struct sata_ncq_error_recovery_page));
17367 if (bp == NULL)
17368 return (SATA_FAILURE);
17369
17370 bp_mapin(bp); /* make data buffer accessible */
17371 scmd->satacmd_bp = bp;
17372
17373 /*
17374 * Set-up pointer to the buffer handle, so HBA can sync buffer
17375 * before accessing it. Handle is in usual place in translate struct.
17376 */
17377 scmd->satacmd_err_ret_buf_handle = &spx->txlt_buf_dma_handle;
17378
17379 ASSERT(scmd->satacmd_num_dma_cookies != 0);
17380 ASSERT(scmd->satacmd_dma_cookie_list != NULL);
17381
17382 return (SATA_SUCCESS);
17383 }
17384
17385 /*
17386 * sata_xlate_errors() is used to translate (S)ATA error
17387 * information to SCSI information returned in the SCSI
17388 * packet.
17389 */
17390 static void
17391 sata_xlate_errors(sata_pkt_txlate_t *spx)
17392 {
17393 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt;
17394 struct scsi_extended_sense *sense;
17395
17396 scsipkt->pkt_reason = CMD_INCOMPLETE;
17397 *scsipkt->pkt_scbp = STATUS_CHECK;
17398 sense = sata_arq_sense(spx);
17399
17400 switch (spx->txlt_sata_pkt->satapkt_reason) {
17401 case SATA_PKT_PORT_ERROR:
17402 /*
17403 * We have no device data. Assume no data transfered.
17404 */
17405 sense->es_key = KEY_HARDWARE_ERROR;
17406 break;
17407
17408 case SATA_PKT_DEV_ERROR:
17409 if (spx->txlt_sata_pkt->satapkt_cmd.satacmd_status_reg &
17410 SATA_STATUS_ERR) {
17411 /*
17412 * determine dev error reason from error
17413 * reg content
17414 */
17415 sata_decode_device_error(spx, sense);
17416 break;
17417 }
17418 /* No extended sense key - no info available */
17419 break;
17420
17421 case SATA_PKT_TIMEOUT:
17422 scsipkt->pkt_reason = CMD_TIMEOUT;
17423 scsipkt->pkt_statistics |= STAT_TIMEOUT | STAT_DEV_RESET;
17424 /* No extended sense key */
17425 break;
17426
17427 case SATA_PKT_ABORTED:
17428 scsipkt->pkt_reason = CMD_ABORTED;
17429 scsipkt->pkt_statistics |= STAT_ABORTED;
17430 /* No extended sense key */
17431 break;
17432
17433 case SATA_PKT_RESET:
17434 /*
17435 * pkt aborted either by an explicit reset request from
17436 * a host, or due to error recovery
17437 */
17438 scsipkt->pkt_reason = CMD_RESET;
17439 scsipkt->pkt_statistics |= STAT_DEV_RESET;
17440 break;
17441
17442 default:
17443 scsipkt->pkt_reason = CMD_TRAN_ERR;
17444 break;
17445 }
17446 }
17447
17448
17449
17450
17451 /*
17452 * Log sata message
17453 * dev pathname msg line preceeds the logged message.
17454 */
17455
17456 static void
17457 sata_log(sata_hba_inst_t *sata_hba_inst, uint_t level, char *fmt, ...)
17458 {
17459 char pathname[128];
17460 dev_info_t *dip = NULL;
17461 va_list ap;
17462
17463 mutex_enter(&sata_log_mutex);
17464
17465 va_start(ap, fmt);
17466 (void) vsprintf(sata_log_buf, fmt, ap);
17467 va_end(ap);
17468
17469 if (sata_hba_inst != NULL) {
17470 dip = SATA_DIP(sata_hba_inst);
17471 (void) ddi_pathname(dip, pathname);
17472 } else {
17473 pathname[0] = 0;
17474 }
17475 if (level == CE_CONT) {
17476 if (sata_debug_flags == 0)
17477 cmn_err(level, "?%s:\n %s\n", pathname, sata_log_buf);
17478 else
17479 cmn_err(level, "%s:\n %s\n", pathname, sata_log_buf);
17480 } else {
17481 if (level != CE_NOTE) {
17482 cmn_err(level, "%s:\n %s", pathname, sata_log_buf);
17483 } else if (sata_msg) {
17484 cmn_err(level, "%s:\n %s", pathname,
17485 sata_log_buf);
17486 }
17487 }
17488
17489 /* sata trace debug */
17490 sata_trace_debug(dip, sata_log_buf);
17491
17492 mutex_exit(&sata_log_mutex);
17493 }
17494
17495
17496 /* ******** Asynchronous HBA events handling & hotplugging support ******** */
17497
17498 /*
17499 * Start or terminate the thread, depending on flag arg and current state
17500 */
17501 static void
17502 sata_event_thread_control(int startstop)
17503 {
17504 static int sata_event_thread_terminating = 0;
17505 static int sata_event_thread_starting = 0;
17506 int i;
17507
17508 mutex_enter(&sata_event_mutex);
17509
17510 if (startstop == 0 && (sata_event_thread_starting == 1 ||
17511 sata_event_thread_terminating == 1)) {
17512 mutex_exit(&sata_event_mutex);
17513 return;
17514 }
17515 if (startstop == 1 && sata_event_thread_starting == 1) {
17516 mutex_exit(&sata_event_mutex);
17517 return;
17518 }
17519 if (startstop == 1 && sata_event_thread_terminating == 1) {
17520 sata_event_thread_starting = 1;
17521 /* wait til terminate operation completes */
17522 i = SATA_EVNT_DAEMON_TERM_WAIT/SATA_EVNT_DAEMON_TERM_TIMEOUT;
17523 while (sata_event_thread_terminating == 1) {
17524 if (i-- <= 0) {
17525 sata_event_thread_starting = 0;
17526 mutex_exit(&sata_event_mutex);
17527 #ifdef SATA_DEBUG
17528 cmn_err(CE_WARN, "sata_event_thread_control: "
17529 "timeout waiting for thread to terminate");
17530 #endif
17531 return;
17532 }
17533 mutex_exit(&sata_event_mutex);
17534 delay(drv_usectohz(SATA_EVNT_DAEMON_TERM_TIMEOUT));
17535 mutex_enter(&sata_event_mutex);
17536 }
17537 }
17538 if (startstop == 1) {
17539 if (sata_event_thread == NULL) {
17540 sata_event_thread = thread_create(NULL, 0,
17541 (void (*)())sata_event_daemon,
17542 &sata_hba_list, 0, &p0, TS_RUN, minclsyspri);
17543 }
17544 sata_event_thread_starting = 0;
17545 mutex_exit(&sata_event_mutex);
17546 return;
17547 }
17548
17549 /*
17550 * If we got here, thread may need to be terminated
17551 */
17552 if (sata_event_thread != NULL) {
17553 int i;
17554 /* Signal event thread to go away */
17555 sata_event_thread_terminating = 1;
17556 sata_event_thread_terminate = 1;
17557 cv_signal(&sata_event_cv);
17558 /*
17559 * Wait til daemon terminates.
17560 */
17561 i = SATA_EVNT_DAEMON_TERM_WAIT/SATA_EVNT_DAEMON_TERM_TIMEOUT;
17562 while (sata_event_thread_terminate == 1) {
17563 mutex_exit(&sata_event_mutex);
17564 if (i-- <= 0) {
17565 /* Daemon did not go away !!! */
17566 #ifdef SATA_DEBUG
17567 cmn_err(CE_WARN, "sata_event_thread_control: "
17568 "cannot terminate event daemon thread");
17569 #endif
17570 mutex_enter(&sata_event_mutex);
17571 break;
17572 }
17573 delay(drv_usectohz(SATA_EVNT_DAEMON_TERM_TIMEOUT));
17574 mutex_enter(&sata_event_mutex);
17575 }
17576 sata_event_thread_terminating = 0;
17577 }
17578 ASSERT(sata_event_thread_terminating == 0);
17579 ASSERT(sata_event_thread_starting == 0);
17580 mutex_exit(&sata_event_mutex);
17581 }
17582
17583
17584 /*
17585 * SATA HBA event notification function.
17586 * Events reported by SATA HBA drivers per HBA instance relate to a change in
17587 * a port and/or device state or a controller itself.
17588 * Events for different addresses/addr types cannot be combined.
17589 * A warning message is generated for each event type.
17590 * Events are not processed by this function, so only the
17591 * event flag(s)is set for an affected entity and the event thread is
17592 * waken up. Event daemon thread processes all events.
17593 *
17594 * NOTE: Since more than one event may be reported at the same time, one
17595 * cannot determine a sequence of events when opposite event are reported, eg.
17596 * LINK_LOST and LINK_ESTABLISHED. Actual port status during event processing
17597 * is taking precedence over reported events, i.e. may cause ignoring some
17598 * events.
17599 */
17600 #define SATA_EVENT_MAX_MSG_LENGTH 79
17601
17602 void
17603 sata_hba_event_notify(dev_info_t *dip, sata_device_t *sata_device, int event)
17604 {
17605 sata_hba_inst_t *sata_hba_inst = NULL;
17606 sata_address_t *saddr;
17607 sata_pmult_info_t *pmultinfo;
17608 sata_drive_info_t *sdinfo;
17609 sata_port_stats_t *pstats;
17610 sata_cport_info_t *cportinfo;
17611 sata_pmport_info_t *pmportinfo;
17612 int cport, pmport;
17613 char buf1[SATA_EVENT_MAX_MSG_LENGTH + 1];
17614 char buf2[SATA_EVENT_MAX_MSG_LENGTH + 1];
17615 char *lcp;
17616 static char *err_msg_evnt_1 =
17617 "sata_hba_event_notify: invalid port event 0x%x ";
17618 static char *err_msg_evnt_2 =
17619 "sata_hba_event_notify: invalid device event 0x%x ";
17620 int linkevent;
17621
17622 /*
17623 * There is a possibility that an event will be generated on HBA
17624 * that has not completed attachment or is detaching. We still want
17625 * to process events until HBA is detached.
17626 */
17627 mutex_enter(&sata_mutex);
17628 for (sata_hba_inst = sata_hba_list; sata_hba_inst != NULL;
17629 sata_hba_inst = sata_hba_inst->satahba_next) {
17630 if (SATA_DIP(sata_hba_inst) == dip)
17631 if (sata_hba_inst->satahba_attached == 1)
17632 break;
17633 }
17634 mutex_exit(&sata_mutex);
17635 if (sata_hba_inst == NULL)
17636 /* HBA not attached */
17637 return;
17638
17639 ASSERT(sata_device != NULL);
17640
17641 /*
17642 * Validate address before - do not proceed with invalid address.
17643 */
17644 saddr = &sata_device->satadev_addr;
17645 if (saddr->cport >= SATA_NUM_CPORTS(sata_hba_inst))
17646 return;
17647
17648 cport = saddr->cport;
17649 pmport = saddr->pmport;
17650
17651 buf1[0] = buf2[0] = '\0';
17652
17653 /*
17654 * If event relates to port or device, check port state.
17655 * Port has to be initialized, or we cannot accept an event.
17656 */
17657 if ((saddr->qual & (SATA_ADDR_CPORT | SATA_ADDR_PMPORT |
17658 SATA_ADDR_DCPORT | SATA_ADDR_DPMPORT | SATA_ADDR_PMULT)) != 0) {
17659 mutex_enter(&sata_hba_inst->satahba_mutex);
17660 cportinfo = SATA_CPORT_INFO(sata_hba_inst, cport);
17661 mutex_exit(&sata_hba_inst->satahba_mutex);
17662 if (cportinfo == NULL || cportinfo->cport_state == 0)
17663 return;
17664 }
17665
17666 if ((saddr->qual & (SATA_ADDR_PMULT | SATA_ADDR_PMPORT |
17667 SATA_ADDR_DPMPORT)) != 0) {
17668 if (cportinfo->cport_dev_type != SATA_DTYPE_PMULT) {
17669 SATA_LOG_D((sata_hba_inst, CE_WARN,
17670 "sata_hba_event_notify: Non-pmult device (0x%x)"
17671 "is attached to port %d, ignore pmult/pmport "
17672 "event 0x%x", cportinfo->cport_dev_type,
17673 cport, event));
17674 return;
17675 }
17676
17677 mutex_enter(&cportinfo->cport_mutex);
17678 pmultinfo = SATA_PMULT_INFO(sata_hba_inst, cport);
17679 mutex_exit(&cportinfo->cport_mutex);
17680
17681 /*
17682 * The daemon might be processing attachment of port
17683 * multiplier, in that case we should ignore events on its
17684 * sub-devices.
17685 *
17686 * NOTE: Only pmult_state is checked in sata_hba_event_notify.
17687 * The pmport_state is checked by sata daemon.
17688 */
17689 if (pmultinfo == NULL ||
17690 pmultinfo->pmult_state == SATA_STATE_UNKNOWN) {
17691 SATA_LOG_D((sata_hba_inst, CE_WARN,
17692 "sata_hba_event_notify: pmult is not"
17693 "available at port %d:%d, ignore event 0x%x",
17694 cport, pmport, event));
17695 return;
17696 }
17697 }
17698
17699 if ((saddr->qual &
17700 (SATA_ADDR_PMPORT | SATA_ADDR_DPMPORT)) != 0) {
17701
17702 mutex_enter(&cportinfo->cport_mutex);
17703 if (pmport > SATA_NUM_PMPORTS(sata_hba_inst, cport)) {
17704 SATA_LOG_D((sata_hba_inst, CE_WARN,
17705 "sata_hba_event_notify: invalid/"
17706 "un-implemented port %d:%d (%d ports), "
17707 "ignore event 0x%x", cport, pmport,
17708 SATA_NUM_PMPORTS(sata_hba_inst, cport), event));
17709 mutex_exit(&cportinfo->cport_mutex);
17710 return;
17711 }
17712 mutex_exit(&cportinfo->cport_mutex);
17713
17714 mutex_enter(&sata_hba_inst->satahba_mutex);
17715 pmportinfo = SATA_PMPORT_INFO(sata_hba_inst,
17716 cport, pmport);
17717 mutex_exit(&sata_hba_inst->satahba_mutex);
17718
17719 /* pmport is implemented/valid? */
17720 if (pmportinfo == NULL) {
17721 SATA_LOG_D((sata_hba_inst, CE_WARN,
17722 "sata_hba_event_notify: invalid/"
17723 "un-implemented port %d:%d, ignore "
17724 "event 0x%x", cport, pmport, event));
17725 return;
17726 }
17727 }
17728
17729 /*
17730 * Events refer to devices, ports and controllers - each has
17731 * unique address. Events for different addresses cannot be combined.
17732 */
17733 if (saddr->qual & (SATA_ADDR_CPORT | SATA_ADDR_PMPORT)) {
17734
17735 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, cport)));
17736
17737 /* qualify this event(s) */
17738 if ((event & SATA_EVNT_PORT_EVENTS) == 0) {
17739 /* Invalid event for the device port */
17740 (void) sprintf(buf2, err_msg_evnt_1,
17741 event & SATA_EVNT_PORT_EVENTS);
17742 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, cport)));
17743 goto event_info;
17744 }
17745 if (saddr->qual == SATA_ADDR_CPORT) {
17746 /* Controller's device port event */
17747
17748 (SATA_CPORT_INFO(sata_hba_inst, cport))->
17749 cport_event_flags |=
17750 event & SATA_EVNT_PORT_EVENTS;
17751 pstats =
17752 &(SATA_CPORT_INFO(sata_hba_inst, cport))->
17753 cport_stats;
17754 } else {
17755 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, cport)));
17756 mutex_enter(&pmportinfo->pmport_mutex);
17757 /* Port multiplier's device port event */
17758 (SATA_PMPORT_INFO(sata_hba_inst, cport, pmport))->
17759 pmport_event_flags |=
17760 event & SATA_EVNT_PORT_EVENTS;
17761 pstats =
17762 &(SATA_PMPORT_INFO(sata_hba_inst, cport, pmport))->
17763 pmport_stats;
17764 mutex_exit(&pmportinfo->pmport_mutex);
17765 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, cport)));
17766 }
17767
17768 /*
17769 * Add to statistics and log the message. We have to do it
17770 * here rather than in the event daemon, because there may be
17771 * multiple events occuring before they are processed.
17772 */
17773 linkevent = event &
17774 (SATA_EVNT_LINK_LOST | SATA_EVNT_LINK_ESTABLISHED);
17775 if (linkevent) {
17776 if (linkevent == (SATA_EVNT_LINK_LOST |
17777 SATA_EVNT_LINK_ESTABLISHED)) {
17778 /* This is likely event combination */
17779 (void) strlcat(buf1, "link lost/established, ",
17780 SATA_EVENT_MAX_MSG_LENGTH);
17781
17782 if (pstats->link_lost < 0xffffffffffffffffULL)
17783 pstats->link_lost++;
17784 if (pstats->link_established <
17785 0xffffffffffffffffULL)
17786 pstats->link_established++;
17787 linkevent = 0;
17788 } else if (linkevent & SATA_EVNT_LINK_LOST) {
17789 (void) strlcat(buf1, "link lost, ",
17790 SATA_EVENT_MAX_MSG_LENGTH);
17791
17792 if (pstats->link_lost < 0xffffffffffffffffULL)
17793 pstats->link_lost++;
17794 } else {
17795 (void) strlcat(buf1, "link established, ",
17796 SATA_EVENT_MAX_MSG_LENGTH);
17797 if (pstats->link_established <
17798 0xffffffffffffffffULL)
17799 pstats->link_established++;
17800 }
17801 }
17802 if (event & SATA_EVNT_DEVICE_ATTACHED) {
17803 (void) strlcat(buf1, "device attached, ",
17804 SATA_EVENT_MAX_MSG_LENGTH);
17805 if (pstats->device_attached < 0xffffffffffffffffULL)
17806 pstats->device_attached++;
17807 }
17808 if (event & SATA_EVNT_DEVICE_DETACHED) {
17809 (void) strlcat(buf1, "device detached, ",
17810 SATA_EVENT_MAX_MSG_LENGTH);
17811 if (pstats->device_detached < 0xffffffffffffffffULL)
17812 pstats->device_detached++;
17813 }
17814 if (event & SATA_EVNT_PWR_LEVEL_CHANGED) {
17815 SATADBG1(SATA_DBG_EVENTS, sata_hba_inst,
17816 "port %d power level changed", cport);
17817 if (pstats->port_pwr_changed < 0xffffffffffffffffULL)
17818 pstats->port_pwr_changed++;
17819 }
17820
17821 if ((event & ~SATA_EVNT_PORT_EVENTS) != 0) {
17822 /* There should be no other events for this address */
17823 (void) sprintf(buf2, err_msg_evnt_1,
17824 event & ~SATA_EVNT_PORT_EVENTS);
17825 }
17826 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, cport)));
17827
17828 } else if (saddr->qual & (SATA_ADDR_DCPORT | SATA_ADDR_DPMPORT)) {
17829 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, cport)));
17830
17831 /* qualify this event */
17832 if ((event & SATA_EVNT_DEVICE_RESET) == 0) {
17833 /* Invalid event for a device */
17834 (void) sprintf(buf2, err_msg_evnt_2,
17835 event & SATA_EVNT_DEVICE_RESET);
17836 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, cport)));
17837 goto event_info;
17838 }
17839 /* drive event */
17840 sdinfo = sata_get_device_info(sata_hba_inst, sata_device);
17841 if (sdinfo != NULL) {
17842 if (event & SATA_EVNT_DEVICE_RESET) {
17843 (void) strlcat(buf1, "device reset, ",
17844 SATA_EVENT_MAX_MSG_LENGTH);
17845 if (sdinfo->satadrv_stats.drive_reset <
17846 0xffffffffffffffffULL)
17847 sdinfo->satadrv_stats.drive_reset++;
17848 sdinfo->satadrv_event_flags |=
17849 SATA_EVNT_DEVICE_RESET;
17850 }
17851 }
17852 if ((event & ~SATA_EVNT_DEVICE_RESET) != 0) {
17853 /* Invalid event for a device */
17854 (void) sprintf(buf2, err_msg_evnt_2,
17855 event & ~SATA_EVNT_DRIVE_EVENTS);
17856 }
17857 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, cport)));
17858 } else if (saddr->qual == SATA_ADDR_PMULT) {
17859 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, cport)));
17860
17861 /* qualify this event */
17862 if ((event & (SATA_EVNT_DEVICE_RESET |
17863 SATA_EVNT_PMULT_LINK_CHANGED)) == 0) {
17864 /* Invalid event for a port multiplier */
17865 (void) sprintf(buf2, err_msg_evnt_2,
17866 event & SATA_EVNT_DEVICE_RESET);
17867 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, cport)));
17868 goto event_info;
17869 }
17870
17871 pmultinfo = SATA_PMULT_INFO(sata_hba_inst, cport);
17872
17873 if (event & SATA_EVNT_DEVICE_RESET) {
17874
17875 SATADBG1(SATA_DBG_PMULT, sata_hba_inst,
17876 "[Reset] port-mult on cport %d", cport);
17877 pmultinfo->pmult_event_flags |=
17878 SATA_EVNT_DEVICE_RESET;
17879 (void) strlcat(buf1, "pmult reset, ",
17880 SATA_EVENT_MAX_MSG_LENGTH);
17881 }
17882
17883 if (event & SATA_EVNT_PMULT_LINK_CHANGED) {
17884
17885 SATADBG1(SATA_DBG_PMULT, sata_hba_inst,
17886 "pmult link changed on cport %d", cport);
17887 pmultinfo->pmult_event_flags |=
17888 SATA_EVNT_PMULT_LINK_CHANGED;
17889 (void) strlcat(buf1, "pmult link changed, ",
17890 SATA_EVENT_MAX_MSG_LENGTH);
17891 }
17892 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, cport)));
17893
17894 } else {
17895 if (saddr->qual != SATA_ADDR_NULL) {
17896 /* Wrong address qualifier */
17897 SATA_LOG_D((sata_hba_inst, CE_WARN,
17898 "sata_hba_event_notify: invalid address 0x%x",
17899 *(uint32_t *)saddr));
17900 return;
17901 }
17902 if ((event & SATA_EVNT_CONTROLLER_EVENTS) == 0 ||
17903 (event & ~SATA_EVNT_CONTROLLER_EVENTS) != 0) {
17904 /* Invalid event for the controller */
17905 SATA_LOG_D((sata_hba_inst, CE_WARN,
17906 "sata_hba_event_notify: invalid event 0x%x for "
17907 "controller",
17908 event & SATA_EVNT_CONTROLLER_EVENTS));
17909 return;
17910 }
17911 buf1[0] = '\0';
17912 /* This may be a frequent and not interesting event */
17913 SATADBG1(SATA_DBG_EVENTS, sata_hba_inst,
17914 "controller power level changed\n", NULL);
17915
17916 mutex_enter(&sata_hba_inst->satahba_mutex);
17917 if (sata_hba_inst->satahba_stats.ctrl_pwr_change <
17918 0xffffffffffffffffULL)
17919 sata_hba_inst->satahba_stats.ctrl_pwr_change++;
17920
17921 sata_hba_inst->satahba_event_flags |=
17922 SATA_EVNT_PWR_LEVEL_CHANGED;
17923 mutex_exit(&sata_hba_inst->satahba_mutex);
17924 }
17925 /*
17926 * If we got here, there is something to do with this HBA
17927 * instance.
17928 */
17929 mutex_enter(&sata_hba_inst->satahba_mutex);
17930 sata_hba_inst->satahba_event_flags |= SATA_EVNT_MAIN;
17931 mutex_exit(&sata_hba_inst->satahba_mutex);
17932 mutex_enter(&sata_mutex);
17933 sata_event_pending |= SATA_EVNT_MAIN; /* global event indicator */
17934 mutex_exit(&sata_mutex);
17935
17936 /* Tickle event thread */
17937 mutex_enter(&sata_event_mutex);
17938 if (sata_event_thread_active == 0)
17939 cv_signal(&sata_event_cv);
17940 mutex_exit(&sata_event_mutex);
17941
17942 event_info:
17943 if (buf1[0] != '\0') {
17944 lcp = strrchr(buf1, ',');
17945 if (lcp != NULL)
17946 *lcp = '\0';
17947 }
17948 if (saddr->qual == SATA_ADDR_CPORT ||
17949 saddr->qual == SATA_ADDR_DCPORT) {
17950 if (buf1[0] != '\0') {
17951 sata_log(sata_hba_inst, CE_NOTE, "port %d: %s\n",
17952 cport, buf1);
17953 }
17954 if (buf2[0] != '\0') {
17955 sata_log(sata_hba_inst, CE_NOTE, "port %d: %s\n",
17956 cport, buf2);
17957 }
17958 } else if (saddr->qual == SATA_ADDR_PMPORT ||
17959 saddr->qual == SATA_ADDR_DPMPORT) {
17960 if (buf1[0] != '\0') {
17961 sata_log(sata_hba_inst, CE_NOTE,
17962 "port %d pmport %d: %s\n", cport, pmport, buf1);
17963 }
17964 if (buf2[0] != '\0') {
17965 sata_log(sata_hba_inst, CE_NOTE,
17966 "port %d pmport %d: %s\n", cport, pmport, buf2);
17967 }
17968 }
17969 }
17970
17971
17972 /*
17973 * Event processing thread.
17974 * Arg is a pointer to the sata_hba_list pointer.
17975 * It is not really needed, because sata_hba_list is global and static
17976 */
17977 static void
17978 sata_event_daemon(void *arg)
17979 {
17980 #ifndef __lock_lint
17981 _NOTE(ARGUNUSED(arg))
17982 #endif
17983 sata_hba_inst_t *sata_hba_inst;
17984 clock_t delta;
17985
17986 SATADBG1(SATA_DBG_EVENTS_DAEMON, NULL,
17987 "SATA event daemon started\n", NULL);
17988 loop:
17989 /*
17990 * Process events here. Walk through all registered HBAs
17991 */
17992 mutex_enter(&sata_mutex);
17993 for (sata_hba_inst = sata_hba_list; sata_hba_inst != NULL;
17994 sata_hba_inst = sata_hba_inst->satahba_next) {
17995 ASSERT(sata_hba_inst != NULL);
17996 mutex_enter(&sata_hba_inst->satahba_mutex);
17997 if (sata_hba_inst->satahba_attached == 0 ||
17998 (sata_hba_inst->satahba_event_flags &
17999 SATA_EVNT_SKIP) != 0) {
18000 mutex_exit(&sata_hba_inst->satahba_mutex);
18001 continue;
18002 }
18003 if (sata_hba_inst->satahba_event_flags & SATA_EVNT_MAIN) {
18004 sata_hba_inst->satahba_event_flags |= SATA_EVNT_SKIP;
18005 mutex_exit(&sata_hba_inst->satahba_mutex);
18006 mutex_exit(&sata_mutex);
18007 /* Got the controller with pending event */
18008 sata_process_controller_events(sata_hba_inst);
18009 /*
18010 * Since global mutex was released, there is a
18011 * possibility that HBA list has changed, so start
18012 * over from the top. Just processed controller
18013 * will be passed-over because of the SKIP flag.
18014 */
18015 goto loop;
18016 }
18017 mutex_exit(&sata_hba_inst->satahba_mutex);
18018 }
18019 /* Clear SKIP flag in all controllers */
18020 for (sata_hba_inst = sata_hba_list; sata_hba_inst != NULL;
18021 sata_hba_inst = sata_hba_inst->satahba_next) {
18022 mutex_enter(&sata_hba_inst->satahba_mutex);
18023 sata_hba_inst->satahba_event_flags &= ~SATA_EVNT_SKIP;
18024 mutex_exit(&sata_hba_inst->satahba_mutex);
18025 }
18026 mutex_exit(&sata_mutex);
18027
18028 SATADBG1(SATA_DBG_EVENTS_DAEMON, NULL,
18029 "SATA EVENT DAEMON suspending itself", NULL);
18030
18031 #ifdef SATA_DEBUG
18032 if ((sata_func_enable & SATA_ENABLE_PROCESS_EVENTS) == 0) {
18033 sata_log(sata_hba_inst, CE_WARN,
18034 "SATA EVENTS PROCESSING DISABLED\n");
18035 thread_exit(); /* Daemon will not run again */
18036 }
18037 #endif
18038 mutex_enter(&sata_event_mutex);
18039 sata_event_thread_active = 0;
18040 mutex_exit(&sata_event_mutex);
18041 /*
18042 * Go to sleep/suspend itself and wake up either because new event or
18043 * wait timeout. Exit if there is a termination request (driver
18044 * unload).
18045 */
18046 delta = drv_usectohz(SATA_EVNT_DAEMON_SLEEP_TIME);
18047 do {
18048 mutex_enter(&sata_event_mutex);
18049 (void) cv_reltimedwait(&sata_event_cv, &sata_event_mutex,
18050 delta, TR_CLOCK_TICK);
18051
18052 if (sata_event_thread_active != 0) {
18053 mutex_exit(&sata_event_mutex);
18054 continue;
18055 }
18056
18057 /* Check if it is time to go away */
18058 if (sata_event_thread_terminate == 1) {
18059 /*
18060 * It is up to the thread setting above flag to make
18061 * sure that this thread is not killed prematurely.
18062 */
18063 sata_event_thread_terminate = 0;
18064 sata_event_thread = NULL;
18065 mutex_exit(&sata_event_mutex);
18066 SATADBG1(SATA_DBG_EVENTS_DAEMON, NULL,
18067 "SATA_EVENT_DAEMON_TERMINATING", NULL);
18068 thread_exit(); { _NOTE(NOT_REACHED) }
18069 }
18070 mutex_exit(&sata_event_mutex);
18071 } while (!(sata_event_pending & SATA_EVNT_MAIN));
18072
18073 mutex_enter(&sata_event_mutex);
18074 sata_event_thread_active = 1;
18075 mutex_exit(&sata_event_mutex);
18076
18077 mutex_enter(&sata_mutex);
18078 sata_event_pending &= ~SATA_EVNT_MAIN;
18079 mutex_exit(&sata_mutex);
18080
18081 SATADBG1(SATA_DBG_EVENTS_DAEMON, NULL,
18082 "SATA EVENT DAEMON READY TO PROCESS EVENT", NULL);
18083
18084 goto loop;
18085 }
18086
18087 /*
18088 * Specific HBA instance event processing.
18089 *
18090 * NOTE: At the moment, device event processing is limited to hard disks
18091 * only.
18092 * Port multiplier is supported now.
18093 */
18094 static void
18095 sata_process_controller_events(sata_hba_inst_t *sata_hba_inst)
18096 {
18097 int ncport;
18098 uint32_t event_flags;
18099 sata_address_t *saddr;
18100 sata_cport_info_t *cportinfo;
18101 sata_pmult_info_t *pmultinfo;
18102
18103 SATADBG1(SATA_DBG_EVENTS_CNTRL, sata_hba_inst,
18104 "Processing controller %d event(s)",
18105 ddi_get_instance(SATA_DIP(sata_hba_inst)));
18106
18107 mutex_enter(&sata_hba_inst->satahba_mutex);
18108 sata_hba_inst->satahba_event_flags &= ~SATA_EVNT_MAIN;
18109 event_flags = sata_hba_inst->satahba_event_flags;
18110 mutex_exit(&sata_hba_inst->satahba_mutex);
18111 /*
18112 * Process controller power change first
18113 * HERE
18114 */
18115 if (event_flags & SATA_EVNT_PWR_LEVEL_CHANGED)
18116 sata_process_cntrl_pwr_level_change(sata_hba_inst);
18117
18118 /*
18119 * Search through ports/devices to identify affected port/device.
18120 * We may have to process events for more than one port/device.
18121 */
18122 for (ncport = 0; ncport < SATA_NUM_CPORTS(sata_hba_inst); ncport++) {
18123 /*
18124 * Not all ports may be processed in attach by the time we
18125 * get an event. Check if port info is initialized.
18126 */
18127 mutex_enter(&sata_hba_inst->satahba_mutex);
18128 cportinfo = SATA_CPORT_INFO(sata_hba_inst, ncport);
18129 mutex_exit(&sata_hba_inst->satahba_mutex);
18130 if (cportinfo == NULL || cportinfo->cport_state == NULL)
18131 continue;
18132
18133 /* We have initialized controller port info */
18134 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, ncport)));
18135 event_flags = (SATA_CPORT_INFO(sata_hba_inst, ncport))->
18136 cport_event_flags;
18137 /* Check if port was locked by IOCTL processing */
18138 if (event_flags & SATA_APCTL_LOCK_PORT_BUSY) {
18139 /*
18140 * We ignore port events because port is busy
18141 * with AP control processing. Set again
18142 * controller and main event flag, so that
18143 * events may be processed by the next daemon
18144 * run.
18145 */
18146 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, ncport)));
18147 mutex_enter(&sata_hba_inst->satahba_mutex);
18148 sata_hba_inst->satahba_event_flags |= SATA_EVNT_MAIN;
18149 mutex_exit(&sata_hba_inst->satahba_mutex);
18150 mutex_enter(&sata_mutex);
18151 sata_event_pending |= SATA_EVNT_MAIN;
18152 mutex_exit(&sata_mutex);
18153 SATADBG1(SATA_DBG_EVENTS_PROCPST, sata_hba_inst,
18154 "Event processing postponed until "
18155 "AP control processing completes",
18156 NULL);
18157 /* Check other ports */
18158 continue;
18159 } else {
18160 /*
18161 * Set BSY flag so that AP control would not
18162 * interfere with events processing for
18163 * this port.
18164 */
18165 (SATA_CPORT_INFO(sata_hba_inst, ncport))->
18166 cport_event_flags |= SATA_EVNT_LOCK_PORT_BUSY;
18167 }
18168 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, ncport)));
18169
18170 saddr = &(SATA_CPORT_INFO(sata_hba_inst, ncport))->cport_addr;
18171
18172 if ((event_flags &
18173 (SATA_EVNT_PORT_EVENTS | SATA_EVNT_DRIVE_EVENTS)) != 0) {
18174 /*
18175 * Got port event.
18176 * We need some hierarchy of event processing as they
18177 * are affecting each other:
18178 * 1. port failed
18179 * 2. device detached/attached
18180 * 3. link events - link events may trigger device
18181 * detached or device attached events in some
18182 * circumstances.
18183 * 4. port power level changed
18184 */
18185 if (event_flags & SATA_EVNT_PORT_FAILED) {
18186 sata_process_port_failed_event(sata_hba_inst,
18187 saddr);
18188 }
18189 if (event_flags & SATA_EVNT_DEVICE_DETACHED) {
18190 sata_process_device_detached(sata_hba_inst,
18191 saddr);
18192 }
18193 if (event_flags & SATA_EVNT_DEVICE_ATTACHED) {
18194 sata_process_device_attached(sata_hba_inst,
18195 saddr);
18196 }
18197 if (event_flags &
18198 (SATA_EVNT_LINK_ESTABLISHED |
18199 SATA_EVNT_LINK_LOST)) {
18200 sata_process_port_link_events(sata_hba_inst,
18201 saddr);
18202 }
18203 if (event_flags & SATA_EVNT_PWR_LEVEL_CHANGED) {
18204 sata_process_port_pwr_change(sata_hba_inst,
18205 saddr);
18206 }
18207 if (event_flags & SATA_EVNT_TARGET_NODE_CLEANUP) {
18208 sata_process_target_node_cleanup(
18209 sata_hba_inst, saddr);
18210 }
18211 if (event_flags & SATA_EVNT_AUTOONLINE_DEVICE) {
18212 sata_process_device_autoonline(
18213 sata_hba_inst, saddr);
18214 }
18215 }
18216
18217
18218 /*
18219 * Scan port multiplier and all its sub-ports event flags.
18220 * The events are marked by
18221 * (1) sata_pmult_info.pmult_event_flags
18222 * (2) sata_pmport_info.pmport_event_flags
18223 */
18224 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, ncport)));
18225 if (cportinfo->cport_dev_type == SATA_DTYPE_PMULT) {
18226 /*
18227 * There should be another extra check: this
18228 * port multiplier still exists?
18229 */
18230 pmultinfo = SATA_PMULT_INFO(sata_hba_inst,
18231 ncport);
18232
18233 if (pmultinfo != NULL) {
18234 mutex_exit(&(SATA_CPORT_MUTEX(
18235 sata_hba_inst, ncport)));
18236 sata_process_pmult_events(
18237 sata_hba_inst, ncport);
18238 mutex_enter(&(SATA_CPORT_MUTEX(
18239 sata_hba_inst, ncport)));
18240 } else {
18241 SATADBG1(SATA_DBG_PMULT, sata_hba_inst,
18242 "Port-multiplier is gone. "
18243 "Ignore all sub-device events "
18244 "at port %d.", ncport);
18245 }
18246 }
18247
18248 if ((SATA_CPORT_DEV_TYPE(sata_hba_inst, ncport) !=
18249 SATA_DTYPE_NONE) &&
18250 (SATA_CPORT_DRV_INFO(sata_hba_inst, ncport) != NULL)) {
18251 if (SATA_CPORT_DRV_INFO(sata_hba_inst, ncport)->
18252 satadrv_event_flags &
18253 (SATA_EVNT_DEVICE_RESET |
18254 SATA_EVNT_INPROC_DEVICE_RESET)) {
18255 /* Have device event */
18256 sata_process_device_reset(sata_hba_inst,
18257 saddr);
18258 }
18259 }
18260 /* Release PORT_BUSY flag */
18261 (SATA_CPORT_INFO(sata_hba_inst, ncport))->
18262 cport_event_flags &= ~SATA_EVNT_LOCK_PORT_BUSY;
18263 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, ncport)));
18264
18265 } /* End of loop through the controller SATA ports */
18266 }
18267
18268 /*
18269 * Specific port multiplier instance event processing. At the moment, device
18270 * event processing is limited to link/attach event only.
18271 *
18272 * NOTE: power management event is not supported yet.
18273 */
18274 static void
18275 sata_process_pmult_events(sata_hba_inst_t *sata_hba_inst, uint8_t cport)
18276 {
18277 sata_cport_info_t *cportinfo = SATA_CPORT_INFO(sata_hba_inst, cport);
18278 sata_pmult_info_t *pmultinfo;
18279 sata_pmport_info_t *pmportinfo;
18280 sata_address_t *saddr;
18281 sata_device_t sata_device;
18282 uint32_t event_flags;
18283 int npmport;
18284 int rval;
18285
18286 SATADBG2(SATA_DBG_EVENTS_CNTRL|SATA_DBG_PMULT, sata_hba_inst,
18287 "Processing pmult event(s) on cport %d of controller %d",
18288 cport, ddi_get_instance(SATA_DIP(sata_hba_inst)));
18289
18290 /* First process events on port multiplier */
18291 mutex_enter(&cportinfo->cport_mutex);
18292 pmultinfo = SATA_PMULT_INFO(sata_hba_inst, cport);
18293 event_flags = pmultinfo->pmult_event_flags;
18294
18295 /*
18296 * Reset event (of port multiplier) has higher priority because the
18297 * port multiplier itself might be failed or removed after reset.
18298 */
18299 if (event_flags & SATA_EVNT_DEVICE_RESET) {
18300 /*
18301 * The status of the sub-links are uncertain,
18302 * so mark all sub-ports as RESET
18303 */
18304 for (npmport = 0; npmport < SATA_NUM_PMPORTS(
18305 sata_hba_inst, cport); npmport ++) {
18306 pmportinfo = SATA_PMPORT_INFO(sata_hba_inst,
18307 cport, npmport);
18308 if (pmportinfo == NULL) {
18309 /* That's weird. */
18310 SATA_LOG_D((sata_hba_inst, CE_WARN,
18311 "sata_hba_event_notify: "
18312 "invalid/un-implemented "
18313 "port %d:%d (%d ports), ",
18314 cport, npmport, SATA_NUM_PMPORTS(
18315 sata_hba_inst, cport)));
18316 continue;
18317 }
18318
18319 mutex_enter(&pmportinfo->pmport_mutex);
18320
18321 /* Mark all pmport to unknow state. */
18322 pmportinfo->pmport_state = SATA_STATE_UNKNOWN;
18323 /* Mark all pmports with link events. */
18324 pmportinfo->pmport_event_flags =
18325 (SATA_EVNT_LINK_ESTABLISHED|SATA_EVNT_LINK_LOST);
18326 mutex_exit(&pmportinfo->pmport_mutex);
18327 }
18328
18329 } else if (event_flags & SATA_EVNT_PMULT_LINK_CHANGED) {
18330 /*
18331 * We need probe the port multiplier to know what has
18332 * happened.
18333 */
18334 bzero(&sata_device, sizeof (sata_device_t));
18335 sata_device.satadev_rev = SATA_DEVICE_REV;
18336 sata_device.satadev_addr.cport = cport;
18337 sata_device.satadev_addr.pmport = SATA_PMULT_HOSTPORT;
18338 sata_device.satadev_addr.qual = SATA_ADDR_PMULT;
18339
18340 mutex_exit(&cportinfo->cport_mutex);
18341 rval = (*SATA_PROBE_PORT_FUNC(sata_hba_inst))
18342 (SATA_DIP(sata_hba_inst), &sata_device);
18343 mutex_enter(&cportinfo->cport_mutex);
18344 if (rval != SATA_SUCCESS) {
18345 /* Something went wrong? Fail the port */
18346 cportinfo->cport_state = SATA_PSTATE_FAILED;
18347 mutex_exit(&cportinfo->cport_mutex);
18348 SATA_LOG_D((sata_hba_inst, CE_WARN,
18349 "SATA port %d probing failed", cport));
18350
18351 /* PMult structure must be released. */
18352 sata_free_pmult(sata_hba_inst, &sata_device);
18353 return;
18354 }
18355
18356 sata_update_port_info(sata_hba_inst, &sata_device);
18357
18358 /*
18359 * Sanity check - Port is active? Is the link active?
18360 * The device is still a port multiplier?
18361 */
18362 if ((cportinfo->cport_state &
18363 (SATA_PSTATE_SHUTDOWN | SATA_PSTATE_FAILED)) ||
18364 ((cportinfo->cport_scr.sstatus &
18365 SATA_PORT_DEVLINK_UP_MASK) != SATA_PORT_DEVLINK_UP) ||
18366 (cportinfo->cport_dev_type != SATA_DTYPE_PMULT)) {
18367 mutex_exit(&cportinfo->cport_mutex);
18368
18369 /* PMult structure must be released. */
18370 sata_free_pmult(sata_hba_inst, &sata_device);
18371 return;
18372 }
18373
18374 /* Probed succeed, set port ready. */
18375 cportinfo->cport_state |=
18376 SATA_STATE_PROBED | SATA_STATE_READY;
18377 }
18378
18379 /* Release port multiplier event flags. */
18380 pmultinfo->pmult_event_flags &=
18381 ~(SATA_EVNT_DEVICE_RESET|SATA_EVNT_PMULT_LINK_CHANGED);
18382 mutex_exit(&cportinfo->cport_mutex);
18383
18384 /*
18385 * Check all sub-links.
18386 */
18387 for (npmport = 0; npmport < SATA_NUM_PMPORTS(sata_hba_inst, cport);
18388 npmport ++) {
18389 pmportinfo = SATA_PMPORT_INFO(sata_hba_inst, cport, npmport);
18390 mutex_enter(&pmportinfo->pmport_mutex);
18391 event_flags = pmportinfo->pmport_event_flags;
18392 mutex_exit(&pmportinfo->pmport_mutex);
18393 saddr = &pmportinfo->pmport_addr;
18394
18395 if ((event_flags &
18396 (SATA_EVNT_PORT_EVENTS | SATA_EVNT_DRIVE_EVENTS)) != 0) {
18397 /*
18398 * Got port multiplier port event.
18399 * We need some hierarchy of event processing as they
18400 * are affecting each other:
18401 * 1. device detached/attached
18402 * 2. link events - link events may trigger device
18403 * detached or device attached events in some
18404 * circumstances.
18405 */
18406 if (event_flags & SATA_EVNT_DEVICE_DETACHED) {
18407 sata_process_pmdevice_detached(sata_hba_inst,
18408 saddr);
18409 }
18410 if (event_flags & SATA_EVNT_DEVICE_ATTACHED) {
18411 sata_process_pmdevice_attached(sata_hba_inst,
18412 saddr);
18413 }
18414 if (event_flags & SATA_EVNT_LINK_ESTABLISHED ||
18415 event_flags & SATA_EVNT_LINK_LOST) {
18416 sata_process_pmport_link_events(sata_hba_inst,
18417 saddr);
18418 }
18419 if (event_flags & SATA_EVNT_TARGET_NODE_CLEANUP) {
18420 sata_process_target_node_cleanup(
18421 sata_hba_inst, saddr);
18422 }
18423 }
18424
18425 /* Checking drive event(s). */
18426 mutex_enter(&pmportinfo->pmport_mutex);
18427 if (pmportinfo->pmport_dev_type != SATA_DTYPE_NONE &&
18428 pmportinfo->pmport_sata_drive != NULL) {
18429 event_flags = pmportinfo->pmport_sata_drive->
18430 satadrv_event_flags;
18431 if (event_flags & (SATA_EVNT_DEVICE_RESET |
18432 SATA_EVNT_INPROC_DEVICE_RESET)) {
18433
18434 /* Have device event */
18435 sata_process_pmdevice_reset(sata_hba_inst,
18436 saddr);
18437 }
18438 }
18439 mutex_exit(&pmportinfo->pmport_mutex);
18440
18441 /* Release PORT_BUSY flag */
18442 mutex_enter(&cportinfo->cport_mutex);
18443 cportinfo->cport_event_flags &= ~SATA_EVNT_LOCK_PORT_BUSY;
18444 mutex_exit(&cportinfo->cport_mutex);
18445 }
18446
18447 SATADBG2(SATA_DBG_EVENTS_CNTRL|SATA_DBG_PMULT, sata_hba_inst,
18448 "[DONE] pmult event(s) on cport %d of controller %d",
18449 cport, ddi_get_instance(SATA_DIP(sata_hba_inst)));
18450 }
18451
18452 /*
18453 * Process HBA power level change reported by HBA driver.
18454 * Not implemented at this time - event is ignored.
18455 */
18456 static void
18457 sata_process_cntrl_pwr_level_change(sata_hba_inst_t *sata_hba_inst)
18458 {
18459 SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst,
18460 "Processing controller power level change", NULL);
18461
18462 /* Ignoring it for now */
18463 mutex_enter(&sata_hba_inst->satahba_mutex);
18464 sata_hba_inst->satahba_event_flags &= ~SATA_EVNT_PWR_LEVEL_CHANGED;
18465 mutex_exit(&sata_hba_inst->satahba_mutex);
18466 }
18467
18468 /*
18469 * Process port power level change reported by HBA driver.
18470 * Not implemented at this time - event is ignored.
18471 */
18472 static void
18473 sata_process_port_pwr_change(sata_hba_inst_t *sata_hba_inst,
18474 sata_address_t *saddr)
18475 {
18476 sata_cport_info_t *cportinfo;
18477
18478 SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst,
18479 "Processing port power level change", NULL);
18480
18481 cportinfo = SATA_CPORT_INFO(sata_hba_inst, saddr->cport);
18482 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex);
18483 /* Reset event flag */
18484 cportinfo->cport_event_flags &= ~SATA_EVNT_PWR_LEVEL_CHANGED;
18485 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex);
18486 }
18487
18488 /*
18489 * Process port failure reported by HBA driver.
18490 * cports support only - no pmports.
18491 */
18492 static void
18493 sata_process_port_failed_event(sata_hba_inst_t *sata_hba_inst,
18494 sata_address_t *saddr)
18495 {
18496 sata_cport_info_t *cportinfo;
18497
18498 cportinfo = SATA_CPORT_INFO(sata_hba_inst, saddr->cport);
18499 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex);
18500 /* Reset event flag first */
18501 cportinfo->cport_event_flags &= ~SATA_EVNT_PORT_FAILED;
18502 /* If the port is in SHUTDOWN or FAILED state, ignore this event. */
18503 if ((cportinfo->cport_state &
18504 (SATA_PSTATE_SHUTDOWN | SATA_PSTATE_FAILED)) == 0) {
18505 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->
18506 cport_mutex);
18507 return;
18508 }
18509 /* Fail the port */
18510 cportinfo->cport_state = SATA_PSTATE_FAILED;
18511 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex);
18512 sata_log(sata_hba_inst, CE_WARN, "SATA port %d failed", saddr->cport);
18513 }
18514
18515 /*
18516 * Device Reset Event processing.
18517 * The sequence is managed by 3 stage flags:
18518 * - reset event reported,
18519 * - reset event being processed,
18520 * - request to clear device reset state.
18521 *
18522 * NOTE: This function has to be entered with cport mutex held. It exits with
18523 * mutex held as well, but can release mutex during the processing.
18524 */
18525 static void
18526 sata_process_device_reset(sata_hba_inst_t *sata_hba_inst,
18527 sata_address_t *saddr)
18528 {
18529 sata_drive_info_t old_sdinfo; /* local copy of the drive info */
18530 sata_drive_info_t *sdinfo;
18531 sata_cport_info_t *cportinfo;
18532 sata_device_t sata_device;
18533 int rval_probe, rval_set;
18534
18535 /* We only care about host sata cport for now */
18536 cportinfo = SATA_CPORT_INFO(sata_hba_inst, saddr->cport);
18537 sdinfo = SATA_CPORT_DRV_INFO(sata_hba_inst, saddr->cport);
18538 /*
18539 * If the port is in SHUTDOWN or FAILED state, or device is in FAILED
18540 * state, ignore reset event.
18541 */
18542 if (((cportinfo->cport_state &
18543 (SATA_PSTATE_SHUTDOWN | SATA_PSTATE_FAILED)) != 0) ||
18544 (sdinfo->satadrv_state & SATA_DSTATE_FAILED) != 0) {
18545 sdinfo->satadrv_event_flags &=
18546 ~(SATA_EVNT_DEVICE_RESET | SATA_EVNT_INPROC_DEVICE_RESET);
18547 return;
18548 }
18549
18550 if ((SATA_CPORT_DEV_TYPE(sata_hba_inst, saddr->cport) ==
18551 SATA_DTYPE_PMULT)) {
18552 /*
18553 * Should not happened: this is already handled in
18554 * sata_hba_event_notify()
18555 */
18556 mutex_exit(&cportinfo->cport_mutex);
18557 goto done;
18558 }
18559
18560 if ((SATA_CPORT_DEV_TYPE(sata_hba_inst, saddr->cport) &
18561 SATA_VALID_DEV_TYPE) == 0) {
18562 /*
18563 * This should not happen - coding error.
18564 * But we can recover, so do not panic, just clean up
18565 * and if in debug mode, log the message.
18566 */
18567 #ifdef SATA_DEBUG
18568 sata_log(sata_hba_inst, CE_WARN,
18569 "sata_process_device_reset: "
18570 "Invalid device type with sdinfo!", NULL);
18571 #endif
18572 sdinfo->satadrv_event_flags = 0;
18573 return;
18574 }
18575
18576 #ifdef SATA_DEBUG
18577 if ((sdinfo->satadrv_event_flags &
18578 (SATA_EVNT_DEVICE_RESET | SATA_EVNT_INPROC_DEVICE_RESET)) == 0) {
18579 /* Nothing to do */
18580 /* Something is weird - why we are processing dev reset? */
18581 SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst,
18582 "No device reset event!!!!", NULL);
18583
18584 return;
18585 }
18586 if ((sdinfo->satadrv_event_flags &
18587 (SATA_EVNT_DEVICE_RESET | SATA_EVNT_INPROC_DEVICE_RESET)) ==
18588 (SATA_EVNT_DEVICE_RESET | SATA_EVNT_INPROC_DEVICE_RESET)) {
18589 /* Something is weird - new device reset event */
18590 SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst,
18591 "Overlapping device reset events!", NULL);
18592 }
18593 #endif
18594 SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst,
18595 "Processing port %d device reset", saddr->cport);
18596
18597 /* Clear event flag */
18598 sdinfo->satadrv_event_flags &= ~SATA_EVNT_DEVICE_RESET;
18599
18600 /* It seems that we always need to check the port state first */
18601 sata_device.satadev_rev = SATA_DEVICE_REV;
18602 sata_device.satadev_addr = *saddr;
18603 /*
18604 * We have to exit mutex, because the HBA probe port function may
18605 * block on its own mutex.
18606 */
18607 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex);
18608 rval_probe = (*SATA_PROBE_PORT_FUNC(sata_hba_inst))
18609 (SATA_DIP(sata_hba_inst), &sata_device);
18610 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex);
18611 sata_update_port_info(sata_hba_inst, &sata_device);
18612 if (rval_probe != SATA_SUCCESS) {
18613 /* Something went wrong? Fail the port */
18614 cportinfo->cport_state = SATA_PSTATE_FAILED;
18615 sdinfo = SATA_CPORT_DRV_INFO(sata_hba_inst, saddr->cport);
18616 if (sdinfo != NULL)
18617 sdinfo->satadrv_event_flags = 0;
18618 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->
18619 cport_mutex);
18620 SATA_LOG_D((sata_hba_inst, CE_WARN,
18621 "SATA port %d probing failed",
18622 saddr->cport));
18623 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst,
18624 saddr->cport)->cport_mutex);
18625 return;
18626 }
18627 if ((sata_device.satadev_scr.sstatus &
18628 SATA_PORT_DEVLINK_UP_MASK) !=
18629 SATA_PORT_DEVLINK_UP ||
18630 sata_device.satadev_type == SATA_DTYPE_NONE) {
18631 /*
18632 * No device to process, anymore. Some other event processing
18633 * would or have already performed port info cleanup.
18634 * To be safe (HBA may need it), request clearing device
18635 * reset condition.
18636 */
18637 sdinfo = SATA_CPORT_DRV_INFO(sata_hba_inst, saddr->cport);
18638 if (sdinfo != NULL) {
18639 sdinfo->satadrv_event_flags &=
18640 ~SATA_EVNT_INPROC_DEVICE_RESET;
18641 sdinfo->satadrv_event_flags |=
18642 SATA_EVNT_CLEAR_DEVICE_RESET;
18643 }
18644 return;
18645 }
18646
18647 sdinfo = SATA_CPORT_DRV_INFO(sata_hba_inst, saddr->cport);
18648 if (sdinfo == NULL) {
18649 return;
18650 }
18651 if ((sdinfo->satadrv_event_flags &
18652 SATA_EVNT_INPROC_DEVICE_RESET) == 0) {
18653 /*
18654 * Start tracking time for device feature restoration and
18655 * identification. Save current time (lbolt value).
18656 */
18657 sdinfo->satadrv_reset_time = ddi_get_lbolt();
18658 }
18659 /* Mark device reset processing as active */
18660 sdinfo->satadrv_event_flags |= SATA_EVNT_INPROC_DEVICE_RESET;
18661
18662 old_sdinfo = *sdinfo; /* local copy of the drive info */
18663 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex);
18664
18665 rval_set = sata_set_drive_features(sata_hba_inst, &old_sdinfo, 1);
18666
18667 if (rval_set != SATA_SUCCESS) {
18668 /*
18669 * Restoring drive setting failed.
18670 * Probe the port first, to check if the port state has changed
18671 */
18672 sata_device.satadev_rev = SATA_DEVICE_REV;
18673 sata_device.satadev_addr = *saddr;
18674 sata_device.satadev_addr.qual = SATA_ADDR_CPORT;
18675 /* probe port */
18676 rval_probe = (*SATA_PROBE_PORT_FUNC(sata_hba_inst))
18677 (SATA_DIP(sata_hba_inst), &sata_device);
18678 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->
18679 cport_mutex);
18680 if (rval_probe == SATA_SUCCESS &&
18681 (sata_device.satadev_state &
18682 (SATA_PSTATE_SHUTDOWN | SATA_PSTATE_FAILED)) == 0 &&
18683 (sata_device.satadev_scr.sstatus &
18684 SATA_PORT_DEVLINK_UP_MASK) == SATA_PORT_DEVLINK_UP &&
18685 sata_device.satadev_type != SATA_DTYPE_NONE) {
18686 /*
18687 * We may retry this a bit later - in-process reset
18688 * condition should be already set.
18689 * Track retry time for device identification.
18690 */
18691 if ((cportinfo->cport_dev_type &
18692 SATA_VALID_DEV_TYPE) != 0 &&
18693 SATA_CPORTINFO_DRV_INFO(cportinfo) != NULL &&
18694 sdinfo->satadrv_reset_time != 0) {
18695 clock_t cur_time = ddi_get_lbolt();
18696 /*
18697 * If the retry time limit was not
18698 * exceeded, retry.
18699 */
18700 if ((cur_time - sdinfo->satadrv_reset_time) <
18701 drv_usectohz(SATA_DEV_REPROBE_TIMEOUT)) {
18702 mutex_enter(
18703 &sata_hba_inst->satahba_mutex);
18704 sata_hba_inst->satahba_event_flags |=
18705 SATA_EVNT_MAIN;
18706 mutex_exit(
18707 &sata_hba_inst->satahba_mutex);
18708 mutex_enter(&sata_mutex);
18709 sata_event_pending |= SATA_EVNT_MAIN;
18710 mutex_exit(&sata_mutex);
18711 return;
18712 }
18713 if (rval_set == SATA_RETRY) {
18714 /*
18715 * Setting drive features failed, but
18716 * the drive is still accessible,
18717 * so emit a warning message before
18718 * return.
18719 */
18720 mutex_exit(&SATA_CPORT_INFO(
18721 sata_hba_inst,
18722 saddr->cport)->cport_mutex);
18723 goto done;
18724 }
18725 }
18726 /* Fail the drive */
18727 sdinfo->satadrv_state = SATA_DSTATE_FAILED;
18728
18729 sata_log(sata_hba_inst, CE_WARN,
18730 "SATA device at port %d - device failed",
18731 saddr->cport);
18732
18733 DTRACE_PROBE(port_failed_f);
18734 }
18735 /*
18736 * No point of retrying - device failed or some other event
18737 * processing or already did or will do port info cleanup.
18738 * To be safe (HBA may need it),
18739 * request clearing device reset condition.
18740 */
18741 sdinfo->satadrv_event_flags |= SATA_EVNT_CLEAR_DEVICE_RESET;
18742 sdinfo->satadrv_event_flags &= ~SATA_EVNT_INPROC_DEVICE_RESET;
18743 sdinfo->satadrv_reset_time = 0;
18744 return;
18745 }
18746 done:
18747 /*
18748 * If setting of drive features failed, but the drive is still
18749 * accessible, emit a warning message.
18750 */
18751 if (rval_set == SATA_RETRY) {
18752 sata_log(sata_hba_inst, CE_WARN,
18753 "SATA device at port %d - desired setting could not be "
18754 "restored after reset. Device may not operate as expected.",
18755 saddr->cport);
18756 }
18757 /*
18758 * Raise the flag indicating that the next sata command could
18759 * be sent with SATA_CLEAR_DEV_RESET_STATE flag, if no new device
18760 * reset is reported.
18761 */
18762 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex);
18763 if (SATA_CPORTINFO_DRV_INFO(cportinfo) != NULL) {
18764 sdinfo->satadrv_reset_time = 0;
18765 if ((cportinfo->cport_dev_type & SATA_VALID_DEV_TYPE) != 0) {
18766 sdinfo = SATA_CPORTINFO_DRV_INFO(cportinfo);
18767 sdinfo->satadrv_event_flags &=
18768 ~SATA_EVNT_INPROC_DEVICE_RESET;
18769 sdinfo->satadrv_event_flags |=
18770 SATA_EVNT_CLEAR_DEVICE_RESET;
18771 }
18772 }
18773 }
18774
18775
18776 /*
18777 * Port Multiplier Port Device Reset Event processing.
18778 *
18779 * NOTE: This function has to be entered with pmport mutex held. It exits with
18780 * mutex held as well, but can release mutex during the processing.
18781 */
18782 static void
18783 sata_process_pmdevice_reset(sata_hba_inst_t *sata_hba_inst,
18784 sata_address_t *saddr)
18785 {
18786 sata_drive_info_t old_sdinfo; /* local copy of the drive info */
18787 sata_drive_info_t *sdinfo = NULL;
18788 sata_cport_info_t *cportinfo = NULL;
18789 sata_pmport_info_t *pmportinfo = NULL;
18790 sata_pmult_info_t *pminfo = NULL;
18791 sata_device_t sata_device;
18792 uint8_t cport = saddr->cport;
18793 uint8_t pmport = saddr->pmport;
18794 int rval;
18795
18796 SATADBG2(SATA_DBG_EVENTS_PROC, sata_hba_inst,
18797 "Processing drive reset at port %d:%d", cport, pmport);
18798
18799 cportinfo = SATA_CPORT_INFO(sata_hba_inst, cport);
18800 pmportinfo = SATA_PMPORT_INFO(sata_hba_inst, cport, pmport);
18801 sdinfo = SATA_PMPORT_DRV_INFO(sata_hba_inst, cport, pmport);
18802
18803 /*
18804 * If the port is in SHUTDOWN or FAILED state, or device is in FAILED
18805 * state, ignore reset event.
18806 */
18807 if (((cportinfo->cport_state &
18808 (SATA_PSTATE_SHUTDOWN | SATA_PSTATE_FAILED)) != 0) ||
18809 (sdinfo->satadrv_state & SATA_DSTATE_FAILED) != 0) {
18810 sdinfo->satadrv_event_flags &=
18811 ~(SATA_EVNT_DEVICE_RESET | SATA_EVNT_INPROC_DEVICE_RESET);
18812 return;
18813 }
18814
18815 if ((pmportinfo->pmport_dev_type & SATA_VALID_DEV_TYPE) == 0) {
18816 /*
18817 * This should not happen - coding error.
18818 * But we can recover, so do not panic, just clean up
18819 * and if in debug mode, log the message.
18820 */
18821 #ifdef SATA_DEBUG
18822 sata_log(sata_hba_inst, CE_WARN,
18823 "sata_process_pmdevice_reset: "
18824 "Invalid device type with sdinfo!", NULL);
18825 #endif
18826 sdinfo->satadrv_event_flags = 0;
18827 return;
18828 }
18829
18830 #ifdef SATA_DEBUG
18831 if ((sdinfo->satadrv_event_flags &
18832 (SATA_EVNT_DEVICE_RESET | SATA_EVNT_INPROC_DEVICE_RESET)) == 0) {
18833 /* Nothing to do */
18834 /* Something is weird - why we are processing dev reset? */
18835 SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst,
18836 "No device reset event!!!!", NULL);
18837
18838 return;
18839 }
18840 if ((sdinfo->satadrv_event_flags &
18841 (SATA_EVNT_DEVICE_RESET | SATA_EVNT_INPROC_DEVICE_RESET)) ==
18842 (SATA_EVNT_DEVICE_RESET | SATA_EVNT_INPROC_DEVICE_RESET)) {
18843 /* Something is weird - new device reset event */
18844 SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst,
18845 "Overlapping device reset events!", NULL);
18846 }
18847 #endif
18848 SATADBG2(SATA_DBG_EVENTS_PROC, sata_hba_inst,
18849 "Processing port %d:%d device reset", cport, pmport);
18850
18851 /* Clear event flag */
18852 sdinfo->satadrv_event_flags &= ~SATA_EVNT_DEVICE_RESET;
18853
18854 /* It seems that we always need to check the port state first */
18855 sata_device.satadev_rev = SATA_DEVICE_REV;
18856 sata_device.satadev_addr = *saddr;
18857 /*
18858 * We have to exit mutex, because the HBA probe port function may
18859 * block on its own mutex.
18860 */
18861 mutex_exit(&pmportinfo->pmport_mutex);
18862 rval = (*SATA_PROBE_PORT_FUNC(sata_hba_inst))
18863 (SATA_DIP(sata_hba_inst), &sata_device);
18864 mutex_enter(&pmportinfo->pmport_mutex);
18865
18866 sata_update_pmport_info(sata_hba_inst, &sata_device);
18867 if (rval != SATA_SUCCESS) {
18868 /* Something went wrong? Fail the port */
18869 pmportinfo->pmport_state = SATA_PSTATE_FAILED;
18870 sdinfo = SATA_PMPORT_DRV_INFO(sata_hba_inst, saddr->cport,
18871 saddr->pmport);
18872 if (sdinfo != NULL)
18873 sdinfo->satadrv_event_flags = 0;
18874 mutex_exit(&pmportinfo->pmport_mutex);
18875 SATA_LOG_D((sata_hba_inst, CE_WARN,
18876 "SATA port %d:%d probing failed",
18877 saddr->cport, saddr->pmport));
18878 mutex_enter(&pmportinfo->pmport_mutex);
18879 return;
18880 }
18881 if ((sata_device.satadev_scr.sstatus &
18882 SATA_PORT_DEVLINK_UP_MASK) !=
18883 SATA_PORT_DEVLINK_UP ||
18884 sata_device.satadev_type == SATA_DTYPE_NONE) {
18885 /*
18886 * No device to process, anymore. Some other event processing
18887 * would or have already performed port info cleanup.
18888 * To be safe (HBA may need it), request clearing device
18889 * reset condition.
18890 */
18891 sdinfo = SATA_PMPORT_DRV_INFO(sata_hba_inst, saddr->cport,
18892 saddr->pmport);
18893 if (sdinfo != NULL) {
18894 sdinfo->satadrv_event_flags &=
18895 ~SATA_EVNT_INPROC_DEVICE_RESET;
18896 /* must clear flags on cport */
18897 pminfo = SATA_PMULT_INFO(sata_hba_inst,
18898 saddr->cport);
18899 pminfo->pmult_event_flags |=
18900 SATA_EVNT_CLEAR_DEVICE_RESET;
18901 }
18902 return;
18903 }
18904
18905 sdinfo = SATA_PMPORT_DRV_INFO(sata_hba_inst, saddr->cport,
18906 saddr->pmport);
18907 if (sdinfo == NULL) {
18908 return;
18909 }
18910 if ((sdinfo->satadrv_event_flags &
18911 SATA_EVNT_INPROC_DEVICE_RESET) == 0) {
18912 /*
18913 * Start tracking time for device feature restoration and
18914 * identification. Save current time (lbolt value).
18915 */
18916 sdinfo->satadrv_reset_time = ddi_get_lbolt();
18917 }
18918 /* Mark device reset processing as active */
18919 sdinfo->satadrv_event_flags |= SATA_EVNT_INPROC_DEVICE_RESET;
18920
18921 old_sdinfo = *sdinfo; /* local copy of the drive info */
18922 mutex_exit(&pmportinfo->pmport_mutex);
18923
18924 if (sata_set_drive_features(sata_hba_inst, &old_sdinfo, 1) ==
18925 SATA_FAILURE) {
18926 /*
18927 * Restoring drive setting failed.
18928 * Probe the port first, to check if the port state has changed
18929 */
18930 sata_device.satadev_rev = SATA_DEVICE_REV;
18931 sata_device.satadev_addr = *saddr;
18932 sata_device.satadev_addr.qual = SATA_ADDR_PMPORT;
18933
18934 /* probe port */
18935 rval = (*SATA_PROBE_PORT_FUNC(sata_hba_inst))
18936 (SATA_DIP(sata_hba_inst), &sata_device);
18937 mutex_enter(&pmportinfo->pmport_mutex);
18938 if (rval == SATA_SUCCESS &&
18939 (sata_device.satadev_state &
18940 (SATA_PSTATE_SHUTDOWN | SATA_PSTATE_FAILED)) == 0 &&
18941 (sata_device.satadev_scr.sstatus &
18942 SATA_PORT_DEVLINK_UP_MASK) == SATA_PORT_DEVLINK_UP &&
18943 sata_device.satadev_type != SATA_DTYPE_NONE) {
18944 /*
18945 * We may retry this a bit later - in-process reset
18946 * condition should be already set.
18947 * Track retry time for device identification.
18948 */
18949 if ((pmportinfo->pmport_dev_type &
18950 SATA_VALID_DEV_TYPE) != 0 &&
18951 SATA_PMPORTINFO_DRV_INFO(pmportinfo) != NULL &&
18952 sdinfo->satadrv_reset_time != 0) {
18953 clock_t cur_time = ddi_get_lbolt();
18954 /*
18955 * If the retry time limit was not
18956 * exceeded, retry.
18957 */
18958 if ((cur_time - sdinfo->satadrv_reset_time) <
18959 drv_usectohz(SATA_DEV_REPROBE_TIMEOUT)) {
18960 mutex_enter(
18961 &sata_hba_inst->satahba_mutex);
18962 sata_hba_inst->satahba_event_flags |=
18963 SATA_EVNT_MAIN;
18964 mutex_exit(
18965 &sata_hba_inst->satahba_mutex);
18966 mutex_enter(&sata_mutex);
18967 sata_event_pending |= SATA_EVNT_MAIN;
18968 mutex_exit(&sata_mutex);
18969 return;
18970 }
18971 }
18972 /* Fail the drive */
18973 sdinfo->satadrv_state = SATA_DSTATE_FAILED;
18974
18975 sata_log(sata_hba_inst, CE_WARN,
18976 "SATA device at port %d:%d - device failed",
18977 saddr->cport, saddr->pmport);
18978 } else {
18979 /*
18980 * No point of retrying - some other event processing
18981 * would or already did port info cleanup.
18982 * To be safe (HBA may need it),
18983 * request clearing device reset condition.
18984 */
18985 sdinfo->satadrv_event_flags |=
18986 SATA_EVNT_CLEAR_DEVICE_RESET;
18987 }
18988 sdinfo->satadrv_event_flags &= ~SATA_EVNT_INPROC_DEVICE_RESET;
18989 sdinfo->satadrv_reset_time = 0;
18990 return;
18991 }
18992 /*
18993 * Raise the flag indicating that the next sata command could
18994 * be sent with SATA_CLEAR_DEV_RESET_STATE flag, if no new device
18995 * reset is reported.
18996 */
18997 mutex_enter(&pmportinfo->pmport_mutex);
18998 if (SATA_PMPORTINFO_DRV_INFO(pmportinfo) != NULL) {
18999 sdinfo->satadrv_reset_time = 0;
19000 if (pmportinfo->pmport_dev_type & SATA_VALID_DEV_TYPE) {
19001 sdinfo = SATA_PMPORTINFO_DRV_INFO(pmportinfo);
19002 sdinfo->satadrv_event_flags &=
19003 ~SATA_EVNT_INPROC_DEVICE_RESET;
19004 /* must clear flags on cport */
19005 pminfo = SATA_PMULT_INFO(sata_hba_inst,
19006 saddr->cport);
19007 pminfo->pmult_event_flags |=
19008 SATA_EVNT_CLEAR_DEVICE_RESET;
19009 }
19010 }
19011 }
19012
19013 /*
19014 * Port Link Events processing.
19015 * Every link established event may involve device reset (due to
19016 * COMRESET signal, equivalent of the hard reset) so arbitrarily
19017 * set device reset event for an attached device (if any).
19018 * If the port is in SHUTDOWN or FAILED state, ignore link events.
19019 *
19020 * The link established event processing varies, depending on the state
19021 * of the target node, HBA hotplugging capabilities, state of the port.
19022 * If the link is not active, the link established event is ignored.
19023 * If HBA cannot detect device attachment and there is no target node,
19024 * the link established event triggers device attach event processing.
19025 * Else, link established event triggers device reset event processing.
19026 *
19027 * The link lost event processing varies, depending on a HBA hotplugging
19028 * capability and the state of the port (link active or not active).
19029 * If the link is active, the lost link event is ignored.
19030 * If HBA cannot detect device removal, the lost link event triggers
19031 * device detached event processing after link lost timeout.
19032 * Else, the event is ignored.
19033 *
19034 * NOTE: Port multiplier ports events are handled by
19035 * sata_process_pmport_link_events();
19036 */
19037 static void
19038 sata_process_port_link_events(sata_hba_inst_t *sata_hba_inst,
19039 sata_address_t *saddr)
19040 {
19041 sata_device_t sata_device;
19042 sata_cport_info_t *cportinfo;
19043 sata_drive_info_t *sdinfo;
19044 uint32_t event_flags;
19045 int rval;
19046
19047 SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst,
19048 "Processing port %d link event(s)", saddr->cport);
19049
19050 cportinfo = SATA_CPORT_INFO(sata_hba_inst, saddr->cport);
19051 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex);
19052 event_flags = cportinfo->cport_event_flags;
19053
19054 /* Reset event flags first */
19055 cportinfo->cport_event_flags &=
19056 ~(SATA_EVNT_LINK_ESTABLISHED | SATA_EVNT_LINK_LOST);
19057
19058 /* If the port is in SHUTDOWN or FAILED state, ignore link events. */
19059 if ((cportinfo->cport_state &
19060 (SATA_PSTATE_SHUTDOWN | SATA_PSTATE_FAILED)) != 0) {
19061 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->
19062 cport_mutex);
19063 return;
19064 }
19065
19066 /*
19067 * For the sanity sake get current port state.
19068 * Set device address only. Other sata_device fields should be
19069 * set by HBA driver.
19070 */
19071 sata_device.satadev_rev = SATA_DEVICE_REV;
19072 sata_device.satadev_addr = *saddr;
19073 /*
19074 * We have to exit mutex, because the HBA probe port function may
19075 * block on its own mutex.
19076 */
19077 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex);
19078 rval = (*SATA_PROBE_PORT_FUNC(sata_hba_inst))
19079 (SATA_DIP(sata_hba_inst), &sata_device);
19080 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex);
19081 sata_update_port_info(sata_hba_inst, &sata_device);
19082 if (rval != SATA_SUCCESS) {
19083 /* Something went wrong? Fail the port */
19084 cportinfo->cport_state = SATA_PSTATE_FAILED;
19085 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->
19086 cport_mutex);
19087 SATA_LOG_D((sata_hba_inst, CE_WARN,
19088 "SATA port %d probing failed",
19089 saddr->cport));
19090 /*
19091 * We may want to release device info structure, but
19092 * it is not necessary.
19093 */
19094 return;
19095 } else {
19096 /* port probed successfully */
19097 cportinfo->cport_state |= SATA_STATE_PROBED | SATA_STATE_READY;
19098 }
19099 if (event_flags & SATA_EVNT_LINK_ESTABLISHED) {
19100
19101 if ((sata_device.satadev_scr.sstatus &
19102 SATA_PORT_DEVLINK_UP_MASK) != SATA_PORT_DEVLINK_UP) {
19103 /* Ignore event */
19104 SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst,
19105 "Ignoring port %d link established event - "
19106 "link down",
19107 saddr->cport);
19108 goto linklost;
19109 }
19110
19111 SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst,
19112 "Processing port %d link established event",
19113 saddr->cport);
19114
19115 /*
19116 * For the sanity sake check if a device is attached - check
19117 * return state of a port probing.
19118 */
19119 if (sata_device.satadev_type != SATA_DTYPE_NONE) {
19120 /*
19121 * HBA port probe indicated that there is a device
19122 * attached. Check if the framework had device info
19123 * structure attached for this device.
19124 */
19125 if (cportinfo->cport_dev_type != SATA_DTYPE_NONE) {
19126 ASSERT(SATA_CPORTINFO_DRV_INFO(cportinfo) !=
19127 NULL);
19128
19129 sdinfo = SATA_CPORTINFO_DRV_INFO(cportinfo);
19130 if ((sdinfo->satadrv_type &
19131 SATA_VALID_DEV_TYPE) != 0) {
19132 /*
19133 * Dev info structure is present.
19134 * If dev_type is set to known type in
19135 * the framework's drive info struct
19136 * then the device existed before and
19137 * the link was probably lost
19138 * momentarily - in such case
19139 * we may want to check device
19140 * identity.
19141 * Identity check is not supported now.
19142 *
19143 * Link established event
19144 * triggers device reset event.
19145 */
19146 (SATA_CPORTINFO_DRV_INFO(cportinfo))->
19147 satadrv_event_flags |=
19148 SATA_EVNT_DEVICE_RESET;
19149 }
19150 } else if (cportinfo->cport_dev_type ==
19151 SATA_DTYPE_NONE) {
19152 /*
19153 * We got new device attached! If HBA does not
19154 * generate device attached events, trigger it
19155 * here.
19156 */
19157 if (!(SATA_FEATURES(sata_hba_inst) &
19158 SATA_CTLF_HOTPLUG)) {
19159 cportinfo->cport_event_flags |=
19160 SATA_EVNT_DEVICE_ATTACHED;
19161 }
19162 }
19163 /* Reset link lost timeout */
19164 cportinfo->cport_link_lost_time = 0;
19165 }
19166 }
19167 linklost:
19168 if (event_flags & SATA_EVNT_LINK_LOST) {
19169 if ((sata_device.satadev_scr.sstatus &
19170 SATA_PORT_DEVLINK_UP_MASK) == SATA_PORT_DEVLINK_UP) {
19171 /* Ignore event */
19172 SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst,
19173 "Ignoring port %d link lost event - link is up",
19174 saddr->cport);
19175 goto done;
19176 }
19177 #ifdef SATA_DEBUG
19178 if (cportinfo->cport_link_lost_time == 0) {
19179 SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst,
19180 "Processing port %d link lost event",
19181 saddr->cport);
19182 }
19183 #endif
19184 /*
19185 * When HBA cannot generate device attached/detached events,
19186 * we need to track link lost time and eventually generate
19187 * device detach event.
19188 */
19189 if (!(SATA_FEATURES(sata_hba_inst) & SATA_CTLF_HOTPLUG)) {
19190 /* We are tracking link lost time */
19191 if (cportinfo->cport_link_lost_time == 0) {
19192 /* save current time (lbolt value) */
19193 cportinfo->cport_link_lost_time =
19194 ddi_get_lbolt();
19195 /* just keep link lost event */
19196 cportinfo->cport_event_flags |=
19197 SATA_EVNT_LINK_LOST;
19198 } else {
19199 clock_t cur_time = ddi_get_lbolt();
19200 if ((cur_time -
19201 cportinfo->cport_link_lost_time) >=
19202 drv_usectohz(
19203 SATA_EVNT_LINK_LOST_TIMEOUT)) {
19204 /* trigger device detach event */
19205 cportinfo->cport_event_flags |=
19206 SATA_EVNT_DEVICE_DETACHED;
19207 cportinfo->cport_link_lost_time = 0;
19208 SATADBG1(SATA_DBG_EVENTS,
19209 sata_hba_inst,
19210 "Triggering port %d "
19211 "device detached event",
19212 saddr->cport);
19213 } else {
19214 /* keep link lost event */
19215 cportinfo->cport_event_flags |=
19216 SATA_EVNT_LINK_LOST;
19217 }
19218 }
19219 }
19220 /*
19221 * We could change port state to disable/delay access to
19222 * the attached device until the link is recovered.
19223 */
19224 }
19225 done:
19226 event_flags = cportinfo->cport_event_flags;
19227 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex);
19228 if (event_flags != 0) {
19229 mutex_enter(&sata_hba_inst->satahba_mutex);
19230 sata_hba_inst->satahba_event_flags |= SATA_EVNT_MAIN;
19231 mutex_exit(&sata_hba_inst->satahba_mutex);
19232 mutex_enter(&sata_mutex);
19233 sata_event_pending |= SATA_EVNT_MAIN;
19234 mutex_exit(&sata_mutex);
19235 }
19236 }
19237
19238 /*
19239 * Port Multiplier Port Link Events processing.
19240 */
19241 static void
19242 sata_process_pmport_link_events(sata_hba_inst_t *sata_hba_inst,
19243 sata_address_t *saddr)
19244 {
19245 sata_device_t sata_device;
19246 sata_pmport_info_t *pmportinfo = NULL;
19247 sata_drive_info_t *sdinfo = NULL;
19248 uint32_t event_flags;
19249 uint8_t cport = saddr->cport;
19250 uint8_t pmport = saddr->pmport;
19251 int rval;
19252
19253 SATADBG2(SATA_DBG_EVENTS_PROC, sata_hba_inst,
19254 "Processing port %d:%d link event(s)",
19255 cport, pmport);
19256
19257 pmportinfo = SATA_PMPORT_INFO(sata_hba_inst, cport, pmport);
19258 mutex_enter(&pmportinfo->pmport_mutex);
19259 event_flags = pmportinfo->pmport_event_flags;
19260
19261 /* Reset event flags first */
19262 pmportinfo->pmport_event_flags &=
19263 ~(SATA_EVNT_LINK_ESTABLISHED | SATA_EVNT_LINK_LOST);
19264
19265 /* If the port is in SHUTDOWN or FAILED state, ignore link events. */
19266 if ((pmportinfo->pmport_state &
19267 (SATA_PSTATE_SHUTDOWN | SATA_PSTATE_FAILED)) != 0) {
19268 mutex_exit(&pmportinfo->pmport_mutex);
19269 return;
19270 }
19271
19272 /*
19273 * For the sanity sake get current port state.
19274 * Set device address only. Other sata_device fields should be
19275 * set by HBA driver.
19276 */
19277 sata_device.satadev_rev = SATA_DEVICE_REV;
19278 sata_device.satadev_addr = *saddr;
19279 /*
19280 * We have to exit mutex, because the HBA probe port function may
19281 * block on its own mutex.
19282 */
19283 mutex_exit(&SATA_PMPORT_MUTEX(sata_hba_inst, saddr->cport,
19284 saddr->pmport));
19285 rval = (*SATA_PROBE_PORT_FUNC(sata_hba_inst))
19286 (SATA_DIP(sata_hba_inst), &sata_device);
19287 mutex_enter(&SATA_PMPORT_MUTEX(sata_hba_inst, saddr->cport,
19288 saddr->pmport));
19289 sata_update_pmport_info(sata_hba_inst, &sata_device);
19290 if (rval != SATA_SUCCESS) {
19291 /* Something went wrong? Fail the port */
19292 pmportinfo->pmport_state = SATA_PSTATE_FAILED;
19293 mutex_exit(&SATA_PMPORT_MUTEX(sata_hba_inst, saddr->cport,
19294 saddr->pmport));
19295 SATA_LOG_D((sata_hba_inst, CE_WARN,
19296 "SATA port %d:%d probing failed",
19297 saddr->cport, saddr->pmport));
19298 /*
19299 * We may want to release device info structure, but
19300 * it is not necessary.
19301 */
19302 return;
19303 } else {
19304 /* port probed successfully */
19305 pmportinfo->pmport_state |=
19306 SATA_STATE_PROBED | SATA_STATE_READY;
19307 }
19308 mutex_exit(&SATA_PMPORT_MUTEX(sata_hba_inst,
19309 saddr->cport, saddr->pmport));
19310 mutex_enter(&SATA_PMPORT_MUTEX(sata_hba_inst,
19311 saddr->cport, saddr->pmport));
19312 if (event_flags & SATA_EVNT_LINK_ESTABLISHED) {
19313
19314 if ((sata_device.satadev_scr.sstatus &
19315 SATA_PORT_DEVLINK_UP_MASK) != SATA_PORT_DEVLINK_UP) {
19316 /* Ignore event */
19317 SATADBG2(SATA_DBG_EVENTS_PROC, sata_hba_inst,
19318 "Ignoring port %d:%d link established event - "
19319 "link down",
19320 saddr->cport, saddr->pmport);
19321 goto linklost;
19322 }
19323
19324 SATADBG2(SATA_DBG_EVENTS_PROC, sata_hba_inst,
19325 "Processing port %d:%d link established event",
19326 cport, pmport);
19327
19328 /*
19329 * For the sanity sake check if a device is attached - check
19330 * return state of a port probing.
19331 */
19332 if (sata_device.satadev_type != SATA_DTYPE_NONE &&
19333 sata_device.satadev_type != SATA_DTYPE_PMULT) {
19334 /*
19335 * HBA port probe indicated that there is a device
19336 * attached. Check if the framework had device info
19337 * structure attached for this device.
19338 */
19339 if (pmportinfo->pmport_dev_type != SATA_DTYPE_NONE) {
19340 ASSERT(SATA_PMPORTINFO_DRV_INFO(pmportinfo) !=
19341 NULL);
19342
19343 sdinfo = SATA_PMPORTINFO_DRV_INFO(pmportinfo);
19344 if ((sdinfo->satadrv_type &
19345 SATA_VALID_DEV_TYPE) != 0) {
19346 /*
19347 * Dev info structure is present.
19348 * If dev_type is set to known type in
19349 * the framework's drive info struct
19350 * then the device existed before and
19351 * the link was probably lost
19352 * momentarily - in such case
19353 * we may want to check device
19354 * identity.
19355 * Identity check is not supported now.
19356 *
19357 * Link established event
19358 * triggers device reset event.
19359 */
19360 (SATA_PMPORTINFO_DRV_INFO(pmportinfo))->
19361 satadrv_event_flags |=
19362 SATA_EVNT_DEVICE_RESET;
19363 }
19364 } else if (pmportinfo->pmport_dev_type ==
19365 SATA_DTYPE_NONE) {
19366 /*
19367 * We got new device attached! If HBA does not
19368 * generate device attached events, trigger it
19369 * here.
19370 */
19371 if (!(SATA_FEATURES(sata_hba_inst) &
19372 SATA_CTLF_HOTPLUG)) {
19373 pmportinfo->pmport_event_flags |=
19374 SATA_EVNT_DEVICE_ATTACHED;
19375 }
19376 }
19377 /* Reset link lost timeout */
19378 pmportinfo->pmport_link_lost_time = 0;
19379 }
19380 }
19381 linklost:
19382 if (event_flags & SATA_EVNT_LINK_LOST) {
19383 #ifdef SATA_DEBUG
19384 if (pmportinfo->pmport_link_lost_time == 0) {
19385 SATADBG2(SATA_DBG_EVENTS_PROC, sata_hba_inst,
19386 "Processing port %d:%d link lost event",
19387 saddr->cport, saddr->pmport);
19388 }
19389 #endif
19390 if ((sata_device.satadev_scr.sstatus &
19391 SATA_PORT_DEVLINK_UP_MASK) == SATA_PORT_DEVLINK_UP) {
19392 /* Ignore event */
19393 SATADBG2(SATA_DBG_EVENTS_PROC, sata_hba_inst,
19394 "Ignoring port %d:%d link lost event - link is up",
19395 saddr->cport, saddr->pmport);
19396 goto done;
19397 }
19398 /*
19399 * When HBA cannot generate device attached/detached events,
19400 * we need to track link lost time and eventually generate
19401 * device detach event.
19402 */
19403 if (!(SATA_FEATURES(sata_hba_inst) & SATA_CTLF_HOTPLUG)) {
19404 /* We are tracking link lost time */
19405 if (pmportinfo->pmport_link_lost_time == 0) {
19406 /* save current time (lbolt value) */
19407 pmportinfo->pmport_link_lost_time =
19408 ddi_get_lbolt();
19409 /* just keep link lost event */
19410 pmportinfo->pmport_event_flags |=
19411 SATA_EVNT_LINK_LOST;
19412 } else {
19413 clock_t cur_time = ddi_get_lbolt();
19414 if ((cur_time -
19415 pmportinfo->pmport_link_lost_time) >=
19416 drv_usectohz(
19417 SATA_EVNT_LINK_LOST_TIMEOUT)) {
19418 /* trigger device detach event */
19419 pmportinfo->pmport_event_flags |=
19420 SATA_EVNT_DEVICE_DETACHED;
19421 pmportinfo->pmport_link_lost_time = 0;
19422 SATADBG2(SATA_DBG_EVENTS,
19423 sata_hba_inst,
19424 "Triggering port %d:%d "
19425 "device detached event",
19426 saddr->cport, saddr->pmport);
19427 } else {
19428 /* keep link lost event */
19429 pmportinfo->pmport_event_flags |=
19430 SATA_EVNT_LINK_LOST;
19431 }
19432 }
19433 }
19434 /*
19435 * We could change port state to disable/delay access to
19436 * the attached device until the link is recovered.
19437 */
19438 }
19439 done:
19440 event_flags = pmportinfo->pmport_event_flags;
19441 mutex_exit(&SATA_PMPORT_MUTEX(sata_hba_inst, saddr->cport,
19442 saddr->pmport));
19443 if (event_flags != 0) {
19444 mutex_enter(&sata_hba_inst->satahba_mutex);
19445 sata_hba_inst->satahba_event_flags |= SATA_EVNT_MAIN;
19446 mutex_exit(&sata_hba_inst->satahba_mutex);
19447 mutex_enter(&sata_mutex);
19448 sata_event_pending |= SATA_EVNT_MAIN;
19449 mutex_exit(&sata_mutex);
19450 }
19451 }
19452
19453 /*
19454 * Device Detached Event processing.
19455 * Port is probed to find if a device is really gone. If so,
19456 * the device info structure is detached from the SATA port info structure
19457 * and released.
19458 * Port status is updated.
19459 *
19460 * NOTE: Port multiplier ports events are handled by
19461 * sata_process_pmdevice_detached()
19462 */
19463 static void
19464 sata_process_device_detached(sata_hba_inst_t *sata_hba_inst,
19465 sata_address_t *saddr)
19466 {
19467 sata_cport_info_t *cportinfo;
19468 sata_pmport_info_t *pmportinfo;
19469 sata_drive_info_t *sdevinfo;
19470 sata_device_t sata_device;
19471 sata_address_t pmport_addr;
19472 char name[16];
19473 uint8_t cport = saddr->cport;
19474 int npmport;
19475 int rval;
19476
19477 SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst,
19478 "Processing port %d device detached", saddr->cport);
19479
19480 cportinfo = SATA_CPORT_INFO(sata_hba_inst, saddr->cport);
19481 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex);
19482 /* Clear event flag */
19483 cportinfo->cport_event_flags &= ~SATA_EVNT_DEVICE_DETACHED;
19484
19485 /* If the port is in SHUTDOWN or FAILED state, ignore detach event. */
19486 if ((cportinfo->cport_state &
19487 (SATA_PSTATE_SHUTDOWN | SATA_PSTATE_FAILED)) != 0) {
19488 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->
19489 cport_mutex);
19490 return;
19491 }
19492 /* For sanity, re-probe the port */
19493 sata_device.satadev_rev = SATA_DEVICE_REV;
19494 sata_device.satadev_addr = *saddr;
19495
19496 /*
19497 * We have to exit mutex, because the HBA probe port function may
19498 * block on its own mutex.
19499 */
19500 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex);
19501 rval = (*SATA_PROBE_PORT_FUNC(sata_hba_inst))
19502 (SATA_DIP(sata_hba_inst), &sata_device);
19503 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex);
19504 sata_update_port_info(sata_hba_inst, &sata_device);
19505 if (rval != SATA_SUCCESS) {
19506 /* Something went wrong? Fail the port */
19507 cportinfo->cport_state = SATA_PSTATE_FAILED;
19508 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->
19509 cport_mutex);
19510 SATA_LOG_D((sata_hba_inst, CE_WARN,
19511 "SATA port %d probing failed",
19512 saddr->cport));
19513 /*
19514 * We may want to release device info structure, but
19515 * it is not necessary.
19516 */
19517 return;
19518 } else {
19519 /* port probed successfully */
19520 cportinfo->cport_state |= SATA_STATE_PROBED | SATA_STATE_READY;
19521 }
19522 /*
19523 * Check if a device is still attached. For sanity, check also
19524 * link status - if no link, there is no device.
19525 */
19526 if ((sata_device.satadev_scr.sstatus & SATA_PORT_DEVLINK_UP_MASK) ==
19527 SATA_PORT_DEVLINK_UP && sata_device.satadev_type !=
19528 SATA_DTYPE_NONE) {
19529 /*
19530 * Device is still attached - ignore detach event.
19531 */
19532 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->
19533 cport_mutex);
19534 SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst,
19535 "Ignoring detach - device still attached to port %d",
19536 sata_device.satadev_addr.cport);
19537 return;
19538 }
19539 /*
19540 * We need to detach and release device info structure here
19541 */
19542 if (cportinfo->cport_dev_type == SATA_DTYPE_PMULT) {
19543 /*
19544 * A port-multiplier is removed.
19545 *
19546 * Calling sata_process_pmdevice_detached() does not work
19547 * here. The port multiplier is gone, so we cannot probe
19548 * sub-port any more and all pmult-related data structure must
19549 * be de-allocated immediately. Following structure of every
19550 * implemented sub-port behind the pmult are required to
19551 * released.
19552 *
19553 * - attachment point
19554 * - target node
19555 * - sata_drive_info
19556 * - sata_pmport_info
19557 */
19558 for (npmport = 0; npmport < SATA_NUM_PMPORTS(sata_hba_inst,
19559 cport); npmport ++) {
19560 SATADBG2(SATA_DBG_PMULT|SATA_DBG_EVENTS_PROC,
19561 sata_hba_inst,
19562 "Detaching target node at port %d:%d",
19563 cport, npmport);
19564
19565 mutex_exit(&SATA_CPORT_MUTEX(sata_hba_inst, cport));
19566
19567 /* Remove attachment point. */
19568 name[0] = '\0';
19569 (void) sprintf(name, "%d.%d", cport, npmport);
19570 ddi_remove_minor_node(SATA_DIP(sata_hba_inst), name);
19571 sata_log(sata_hba_inst, CE_NOTE,
19572 "Remove attachment point of port %d:%d",
19573 cport, npmport);
19574
19575 /* Remove target node */
19576 pmport_addr.cport = cport;
19577 pmport_addr.pmport = (uint8_t)npmport;
19578 pmport_addr.qual = SATA_ADDR_PMPORT;
19579 sata_remove_target_node(sata_hba_inst, &pmport_addr);
19580
19581 mutex_enter(&SATA_CPORT_MUTEX(sata_hba_inst, cport));
19582
19583 /* Release sata_pmport_info & sata_drive_info. */
19584 pmportinfo = SATA_PMPORT_INFO(sata_hba_inst,
19585 cport, npmport);
19586 ASSERT(pmportinfo != NULL);
19587
19588 sdevinfo = SATA_PMPORTINFO_DRV_INFO(pmportinfo);
19589 if (sdevinfo != NULL) {
19590 (void) kmem_free((void *) sdevinfo,
19591 sizeof (sata_drive_info_t));
19592 }
19593
19594 /* Release sata_pmport_info at last */
19595 (void) kmem_free((void *) pmportinfo,
19596 sizeof (sata_pmport_info_t));
19597 }
19598
19599 /* Finally, release sata_pmult_info */
19600 (void) kmem_free((void *)
19601 SATA_CPORTINFO_PMULT_INFO(cportinfo),
19602 sizeof (sata_pmult_info_t));
19603 SATA_CPORTINFO_PMULT_INFO(cportinfo) = NULL;
19604
19605 sata_log(sata_hba_inst, CE_WARN,
19606 "SATA port-multiplier detached at port %d", cport);
19607
19608 cportinfo->cport_dev_type = SATA_DTYPE_NONE;
19609 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst,
19610 saddr->cport)->cport_mutex);
19611 } else {
19612 if (SATA_CPORTINFO_DRV_INFO(cportinfo) != NULL) {
19613 sdevinfo = SATA_CPORTINFO_DRV_INFO(cportinfo);
19614 SATA_CPORTINFO_DRV_INFO(cportinfo) = NULL;
19615 (void) kmem_free((void *)sdevinfo,
19616 sizeof (sata_drive_info_t));
19617 }
19618 sata_log(sata_hba_inst, CE_WARN,
19619 "SATA device detached at port %d", cport);
19620
19621 cportinfo->cport_dev_type = SATA_DTYPE_NONE;
19622 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst,
19623 saddr->cport)->cport_mutex);
19624
19625 /*
19626 * Try to offline a device and remove target node
19627 * if it still exists
19628 */
19629 sata_remove_target_node(sata_hba_inst, saddr);
19630 }
19631
19632
19633 /*
19634 * Generate sysevent - EC_DR / ESC_DR_AP_STATE_CHANGE
19635 * with the hint: SE_HINT_REMOVE
19636 */
19637 sata_gen_sysevent(sata_hba_inst, saddr, SE_HINT_REMOVE);
19638 }
19639
19640 /*
19641 * Port Multiplier Port Device Deattached Event processing.
19642 *
19643 * NOTE: No Mutex should be hold.
19644 */
19645 static void
19646 sata_process_pmdevice_detached(sata_hba_inst_t *sata_hba_inst,
19647 sata_address_t *saddr)
19648 {
19649 sata_pmport_info_t *pmportinfo;
19650 sata_drive_info_t *sdevinfo;
19651 sata_device_t sata_device;
19652 int rval;
19653 uint8_t cport, pmport;
19654
19655 cport = saddr->cport;
19656 pmport = saddr->pmport;
19657
19658 SATADBG2(SATA_DBG_EVENTS_PROC, sata_hba_inst,
19659 "Processing port %d:%d device detached",
19660 cport, pmport);
19661
19662 pmportinfo = SATA_PMPORT_INFO(sata_hba_inst, cport, pmport);
19663 mutex_enter(&SATA_PMPORT_MUTEX(sata_hba_inst, cport, pmport));
19664
19665 /* Clear event flag */
19666 pmportinfo->pmport_event_flags &= ~SATA_EVNT_DEVICE_DETACHED;
19667
19668 /* If the port is in SHUTDOWN or FAILED state, ignore detach event. */
19669 if ((pmportinfo->pmport_state &
19670 (SATA_PSTATE_SHUTDOWN | SATA_PSTATE_FAILED)) != 0) {
19671 mutex_exit(&SATA_PMPORT_MUTEX(sata_hba_inst, cport, pmport));
19672 return;
19673 }
19674 /* For sanity, re-probe the port */
19675 sata_device.satadev_rev = SATA_DEVICE_REV;
19676 sata_device.satadev_addr = *saddr;
19677
19678 /*
19679 * We have to exit mutex, because the HBA probe port function may
19680 * block on its own mutex.
19681 */
19682 mutex_exit(&SATA_PMPORT_MUTEX(sata_hba_inst, cport, pmport));
19683 rval = (*SATA_PROBE_PORT_FUNC(sata_hba_inst))
19684 (SATA_DIP(sata_hba_inst), &sata_device);
19685 mutex_enter(&SATA_PMPORT_MUTEX(sata_hba_inst, cport, pmport));
19686 sata_update_pmport_info(sata_hba_inst, &sata_device);
19687 if (rval != SATA_SUCCESS) {
19688 /* Something went wrong? Fail the port */
19689 pmportinfo->pmport_state = SATA_PSTATE_FAILED;
19690 mutex_exit(&SATA_PMPORT_MUTEX(sata_hba_inst, cport, pmport));
19691 SATA_LOG_D((sata_hba_inst, CE_WARN,
19692 "SATA port %d:%d probing failed",
19693 saddr->pmport));
19694 /*
19695 * We may want to release device info structure, but
19696 * it is not necessary.
19697 */
19698 return;
19699 } else {
19700 /* port probed successfully */
19701 pmportinfo->pmport_state |=
19702 SATA_STATE_PROBED | SATA_STATE_READY;
19703 }
19704 /*
19705 * Check if a device is still attached. For sanity, check also
19706 * link status - if no link, there is no device.
19707 */
19708 if ((sata_device.satadev_scr.sstatus & SATA_PORT_DEVLINK_UP_MASK) ==
19709 SATA_PORT_DEVLINK_UP && sata_device.satadev_type !=
19710 SATA_DTYPE_NONE) {
19711 /*
19712 * Device is still attached - ignore detach event.
19713 */
19714 mutex_exit(&SATA_PMPORT_MUTEX(sata_hba_inst, cport, pmport));
19715 SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst,
19716 "Ignoring detach - device still attached to port %d",
19717 sata_device.satadev_addr.pmport);
19718 return;
19719 }
19720 /*
19721 * We need to detach and release device info structure here
19722 */
19723 if (SATA_PMPORTINFO_DRV_INFO(pmportinfo) != NULL) {
19724 sdevinfo = SATA_PMPORTINFO_DRV_INFO(pmportinfo);
19725 SATA_PMPORTINFO_DRV_INFO(pmportinfo) = NULL;
19726 (void) kmem_free((void *)sdevinfo,
19727 sizeof (sata_drive_info_t));
19728 }
19729 pmportinfo->pmport_dev_type = SATA_DTYPE_NONE;
19730 /*
19731 * Device cannot be reached anymore, even if the target node may be
19732 * still present.
19733 */
19734 mutex_exit(&SATA_PMPORT_MUTEX(sata_hba_inst, cport, pmport));
19735
19736 /*
19737 * Try to offline a device and remove target node if it still exists
19738 */
19739 sata_remove_target_node(sata_hba_inst, saddr);
19740
19741 /*
19742 * Generate sysevent - EC_DR / ESC_DR_AP_STATE_CHANGE
19743 * with the hint: SE_HINT_REMOVE
19744 */
19745 sata_gen_sysevent(sata_hba_inst, saddr, SE_HINT_REMOVE);
19746 }
19747
19748
19749 /*
19750 * Device Attached Event processing.
19751 * Port state is checked to verify that a device is really attached. If so,
19752 * the device info structure is created and attached to the SATA port info
19753 * structure.
19754 *
19755 * If attached device cannot be identified or set-up, the retry for the
19756 * attach processing is set-up. Subsequent daemon run would try again to
19757 * identify the device, until the time limit is reached
19758 * (SATA_DEV_IDENTIFY_TIMEOUT).
19759 *
19760 * This function cannot be called in interrupt context (it may sleep).
19761 *
19762 * NOTE: Port multiplier ports events are handled by
19763 * sata_process_pmdevice_attached()
19764 */
19765 static void
19766 sata_process_device_attached(sata_hba_inst_t *sata_hba_inst,
19767 sata_address_t *saddr)
19768 {
19769 sata_cport_info_t *cportinfo = NULL;
19770 sata_drive_info_t *sdevinfo = NULL;
19771 sata_pmult_info_t *pmultinfo = NULL;
19772 sata_pmport_info_t *pmportinfo = NULL;
19773 sata_device_t sata_device;
19774 dev_info_t *tdip;
19775 uint32_t event_flags = 0, pmult_event_flags = 0;
19776 int rval;
19777 int npmport;
19778
19779 SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst,
19780 "Processing port %d device attached", saddr->cport);
19781
19782 cportinfo = SATA_CPORT_INFO(sata_hba_inst, saddr->cport);
19783 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex);
19784
19785 /* Clear attach event flag first */
19786 cportinfo->cport_event_flags &= ~SATA_EVNT_DEVICE_ATTACHED;
19787
19788 /* If the port is in SHUTDOWN or FAILED state, ignore event. */
19789 if ((cportinfo->cport_state &
19790 (SATA_PSTATE_SHUTDOWN | SATA_PSTATE_FAILED)) != 0) {
19791 cportinfo->cport_dev_attach_time = 0;
19792 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->
19793 cport_mutex);
19794 return;
19795 }
19796
19797 /*
19798 * If the sata_drive_info structure is found attached to the port info,
19799 * despite the fact the device was removed and now it is re-attached,
19800 * the old drive info structure was not removed.
19801 * Arbitrarily release device info structure.
19802 */
19803 if (SATA_CPORTINFO_DRV_INFO(cportinfo) != NULL) {
19804 sdevinfo = SATA_CPORTINFO_DRV_INFO(cportinfo);
19805 SATA_CPORTINFO_DRV_INFO(cportinfo) = NULL;
19806 (void) kmem_free((void *)sdevinfo,
19807 sizeof (sata_drive_info_t));
19808 SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst,
19809 "Arbitrarily detaching old device info.", NULL);
19810 }
19811 cportinfo->cport_dev_type = SATA_DTYPE_NONE;
19812
19813 /* For sanity, re-probe the port */
19814 sata_device.satadev_rev = SATA_DEVICE_REV;
19815 sata_device.satadev_addr = *saddr;
19816
19817 /*
19818 * We have to exit mutex, because the HBA probe port function may
19819 * block on its own mutex.
19820 */
19821 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex);
19822 rval = (*SATA_PROBE_PORT_FUNC(sata_hba_inst))
19823 (SATA_DIP(sata_hba_inst), &sata_device);
19824 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex);
19825 sata_update_port_info(sata_hba_inst, &sata_device);
19826 if (rval != SATA_SUCCESS) {
19827 /* Something went wrong? Fail the port */
19828 cportinfo->cport_state = SATA_PSTATE_FAILED;
19829 cportinfo->cport_dev_attach_time = 0;
19830 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->
19831 cport_mutex);
19832 SATA_LOG_D((sata_hba_inst, CE_WARN,
19833 "SATA port %d probing failed",
19834 saddr->cport));
19835 return;
19836 } else {
19837 /* port probed successfully */
19838 cportinfo->cport_state |= SATA_STATE_PROBED | SATA_STATE_READY;
19839 }
19840 /*
19841 * Check if a device is still attached. For sanity, check also
19842 * link status - if no link, there is no device.
19843 */
19844 if ((sata_device.satadev_scr.sstatus & SATA_PORT_DEVLINK_UP_MASK) !=
19845 SATA_PORT_DEVLINK_UP || sata_device.satadev_type ==
19846 SATA_DTYPE_NONE) {
19847 /*
19848 * No device - ignore attach event.
19849 */
19850 cportinfo->cport_dev_attach_time = 0;
19851 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->
19852 cport_mutex);
19853 SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst,
19854 "Ignoring attach - no device connected to port %d",
19855 sata_device.satadev_addr.cport);
19856 return;
19857 }
19858
19859 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex);
19860 /*
19861 * Generate sysevent - EC_DR / ESC_DR_AP_STATE_CHANGE
19862 * with the hint: SE_HINT_INSERT
19863 */
19864 sata_gen_sysevent(sata_hba_inst, saddr, SE_HINT_INSERT);
19865
19866 /*
19867 * Port reprobing will take care of the creation of the device
19868 * info structure and determination of the device type.
19869 */
19870 sata_device.satadev_addr = *saddr;
19871 (void) sata_reprobe_port(sata_hba_inst, &sata_device,
19872 SATA_DEV_IDENTIFY_NORETRY);
19873
19874 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->
19875 cport_mutex);
19876 if ((cportinfo->cport_state & SATA_STATE_READY) &&
19877 (cportinfo->cport_dev_type != SATA_DTYPE_NONE)) {
19878 /* Some device is attached to the port */
19879 if (cportinfo->cport_dev_type == SATA_DTYPE_UNKNOWN) {
19880 /*
19881 * A device was not successfully attached.
19882 * Track retry time for device identification.
19883 */
19884 if (cportinfo->cport_dev_attach_time != 0) {
19885 clock_t cur_time = ddi_get_lbolt();
19886 /*
19887 * If the retry time limit was not exceeded,
19888 * reinstate attach event.
19889 */
19890 if ((cur_time -
19891 cportinfo->cport_dev_attach_time) <
19892 drv_usectohz(
19893 SATA_DEV_IDENTIFY_TIMEOUT)) {
19894 /* OK, restore attach event */
19895 cportinfo->cport_event_flags |=
19896 SATA_EVNT_DEVICE_ATTACHED;
19897 } else {
19898 /* Timeout - cannot identify device */
19899 cportinfo->cport_dev_attach_time = 0;
19900 sata_log(sata_hba_inst,
19901 CE_WARN,
19902 "Could not identify SATA device "
19903 "at port %d",
19904 saddr->cport);
19905 }
19906 } else {
19907 /*
19908 * Start tracking time for device
19909 * identification.
19910 * Save current time (lbolt value).
19911 */
19912 cportinfo->cport_dev_attach_time =
19913 ddi_get_lbolt();
19914 /* Restore attach event */
19915 cportinfo->cport_event_flags |=
19916 SATA_EVNT_DEVICE_ATTACHED;
19917 }
19918 } else if (cportinfo->cport_dev_type == SATA_DTYPE_PMULT) {
19919 cportinfo->cport_dev_attach_time = 0;
19920 sata_log(sata_hba_inst, CE_NOTE,
19921 "SATA port-multiplier detected at port %d",
19922 saddr->cport);
19923
19924 if (SATA_CPORTINFO_PMULT_INFO(cportinfo) != NULL) {
19925 /* Log the info of new port multiplier */
19926 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst,
19927 saddr->cport)->cport_mutex);
19928 sata_show_pmult_info(sata_hba_inst,
19929 &sata_device);
19930 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst,
19931 saddr->cport)->cport_mutex);
19932 }
19933
19934 ASSERT(SATA_CPORTINFO_PMULT_INFO(cportinfo) != NULL);
19935 pmultinfo = SATA_CPORTINFO_PMULT_INFO(cportinfo);
19936 for (npmport = 0; npmport <
19937 pmultinfo->pmult_num_dev_ports; npmport++) {
19938 pmportinfo = SATA_PMPORT_INFO(sata_hba_inst,
19939 saddr->cport, npmport);
19940 ASSERT(pmportinfo != NULL);
19941
19942 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst,
19943 saddr->cport)->cport_mutex);
19944 mutex_enter(&pmportinfo->pmport_mutex);
19945 /* Marked all pmports with link events. */
19946 pmportinfo->pmport_event_flags =
19947 SATA_EVNT_LINK_ESTABLISHED;
19948 pmult_event_flags |=
19949 pmportinfo->pmport_event_flags;
19950 mutex_exit(&pmportinfo->pmport_mutex);
19951 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst,
19952 saddr->cport)->cport_mutex);
19953 }
19954 /* Auto-online is not available for PMult now. */
19955
19956 } else {
19957 /*
19958 * If device was successfully attached, the subsequent
19959 * action depends on a state of the
19960 * sata_auto_online variable. If it is set to zero.
19961 * an explicit 'configure' command will be needed to
19962 * configure it. If its value is non-zero, we will
19963 * attempt to online (configure) the device.
19964 * First, log the message indicating that a device
19965 * was attached.
19966 */
19967 cportinfo->cport_dev_attach_time = 0;
19968 sata_log(sata_hba_inst, CE_WARN,
19969 "SATA device detected at port %d", saddr->cport);
19970
19971 if (SATA_CPORTINFO_DRV_INFO(cportinfo) != NULL) {
19972 sata_drive_info_t new_sdinfo;
19973
19974 /* Log device info data */
19975 new_sdinfo = *(SATA_CPORTINFO_DRV_INFO(
19976 cportinfo));
19977 sata_show_drive_info(sata_hba_inst,
19978 &new_sdinfo);
19979 }
19980
19981 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst,
19982 saddr->cport)->cport_mutex);
19983
19984 /*
19985 * Make sure that there is no target node for that
19986 * device. If so, release it. It should not happen,
19987 * unless we had problem removing the node when
19988 * device was detached.
19989 */
19990 tdip = sata_get_target_dip(SATA_DIP(sata_hba_inst),
19991 saddr->cport, saddr->pmport);
19992 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst,
19993 saddr->cport)->cport_mutex);
19994 if (tdip != NULL) {
19995
19996 #ifdef SATA_DEBUG
19997 if ((cportinfo->cport_event_flags &
19998 SATA_EVNT_TARGET_NODE_CLEANUP) == 0)
19999 sata_log(sata_hba_inst, CE_WARN,
20000 "sata_process_device_attached: "
20001 "old device target node exists!");
20002 #endif
20003 /*
20004 * target node exists - try to unconfigure
20005 * device and remove the node.
20006 */
20007 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst,
20008 saddr->cport)->cport_mutex);
20009 rval = ndi_devi_offline(tdip,
20010 NDI_DEVI_REMOVE);
20011 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst,
20012 saddr->cport)->cport_mutex);
20013
20014 if (rval == NDI_SUCCESS) {
20015 cportinfo->cport_event_flags &=
20016 ~SATA_EVNT_TARGET_NODE_CLEANUP;
20017 cportinfo->cport_tgtnode_clean = B_TRUE;
20018 } else {
20019 /*
20020 * PROBLEM - the target node remained
20021 * and it belongs to a previously
20022 * attached device.
20023 * This happens when the file was open
20024 * or the node was waiting for
20025 * resources at the time the
20026 * associated device was removed.
20027 * Instruct event daemon to retry the
20028 * cleanup later.
20029 */
20030 sata_log(sata_hba_inst,
20031 CE_WARN,
20032 "Application(s) accessing "
20033 "previously attached SATA "
20034 "device have to release "
20035 "it before newly inserted "
20036 "device can be made accessible.",
20037 saddr->cport);
20038 cportinfo->cport_event_flags |=
20039 SATA_EVNT_TARGET_NODE_CLEANUP;
20040 cportinfo->cport_tgtnode_clean =
20041 B_FALSE;
20042 }
20043 }
20044 if (sata_auto_online != 0) {
20045 cportinfo->cport_event_flags |=
20046 SATA_EVNT_AUTOONLINE_DEVICE;
20047 }
20048
20049 }
20050 } else {
20051 cportinfo->cport_dev_attach_time = 0;
20052 }
20053
20054 event_flags = cportinfo->cport_event_flags;
20055 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex);
20056 if (event_flags != 0 || pmult_event_flags != 0) {
20057 mutex_enter(&sata_hba_inst->satahba_mutex);
20058 sata_hba_inst->satahba_event_flags |= SATA_EVNT_MAIN;
20059 mutex_exit(&sata_hba_inst->satahba_mutex);
20060 mutex_enter(&sata_mutex);
20061 sata_event_pending |= SATA_EVNT_MAIN;
20062 mutex_exit(&sata_mutex);
20063 }
20064 }
20065
20066 /*
20067 * Port Multiplier Port Device Attached Event processing.
20068 *
20069 * NOTE: No Mutex should be hold.
20070 */
20071 static void
20072 sata_process_pmdevice_attached(sata_hba_inst_t *sata_hba_inst,
20073 sata_address_t *saddr)
20074 {
20075 sata_pmport_info_t *pmportinfo;
20076 sata_drive_info_t *sdinfo;
20077 sata_device_t sata_device;
20078 dev_info_t *tdip;
20079 uint32_t event_flags;
20080 uint8_t cport = saddr->cport;
20081 uint8_t pmport = saddr->pmport;
20082 int rval;
20083
20084 SATADBG2(SATA_DBG_EVENTS_PROC, sata_hba_inst,
20085 "Processing port %d:%d device attached", cport, pmport);
20086
20087 pmportinfo = SATA_PMPORT_INFO(sata_hba_inst, cport, pmport);
20088
20089 mutex_enter(&pmportinfo->pmport_mutex);
20090
20091 /* Clear attach event flag first */
20092 pmportinfo->pmport_event_flags &= ~SATA_EVNT_DEVICE_ATTACHED;
20093
20094 /* If the port is in SHUTDOWN or FAILED state, ignore event. */
20095 if ((pmportinfo->pmport_state &
20096 (SATA_PSTATE_SHUTDOWN | SATA_PSTATE_FAILED)) != 0) {
20097 pmportinfo->pmport_dev_attach_time = 0;
20098 mutex_exit(&pmportinfo->pmport_mutex);
20099 return;
20100 }
20101
20102 /*
20103 * If the sata_drive_info structure is found attached to the port info,
20104 * despite the fact the device was removed and now it is re-attached,
20105 * the old drive info structure was not removed.
20106 * Arbitrarily release device info structure.
20107 */
20108 if (SATA_PMPORTINFO_DRV_INFO(pmportinfo) != NULL) {
20109 sdinfo = SATA_PMPORTINFO_DRV_INFO(pmportinfo);
20110 SATA_PMPORTINFO_DRV_INFO(pmportinfo) = NULL;
20111 (void) kmem_free((void *)sdinfo,
20112 sizeof (sata_drive_info_t));
20113 SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst,
20114 "Arbitrarily detaching old device info.", NULL);
20115 }
20116 pmportinfo->pmport_dev_type = SATA_DTYPE_NONE;
20117
20118 /* For sanity, re-probe the port */
20119 sata_device.satadev_rev = SATA_DEVICE_REV;
20120 sata_device.satadev_addr = *saddr;
20121
20122 /*
20123 * We have to exit mutex, because the HBA probe port function may
20124 * block on its own mutex.
20125 */
20126 mutex_exit(&pmportinfo->pmport_mutex);
20127 rval = (*SATA_PROBE_PORT_FUNC(sata_hba_inst))
20128 (SATA_DIP(sata_hba_inst), &sata_device);
20129 mutex_enter(&pmportinfo->pmport_mutex);
20130
20131 sata_update_pmport_info(sata_hba_inst, &sata_device);
20132 if (rval != SATA_SUCCESS) {
20133 /* Something went wrong? Fail the port */
20134 pmportinfo->pmport_state = SATA_PSTATE_FAILED;
20135 pmportinfo->pmport_dev_attach_time = 0;
20136 mutex_exit(&pmportinfo->pmport_mutex);
20137 SATA_LOG_D((sata_hba_inst, CE_WARN,
20138 "SATA port %d:%d probing failed", cport, pmport));
20139 return;
20140 } else {
20141 /* pmport probed successfully */
20142 pmportinfo->pmport_state |=
20143 SATA_STATE_PROBED | SATA_STATE_READY;
20144 }
20145 /*
20146 * Check if a device is still attached. For sanity, check also
20147 * link status - if no link, there is no device.
20148 */
20149 if ((sata_device.satadev_scr.sstatus & SATA_PORT_DEVLINK_UP_MASK) !=
20150 SATA_PORT_DEVLINK_UP || sata_device.satadev_type ==
20151 SATA_DTYPE_NONE) {
20152 /*
20153 * No device - ignore attach event.
20154 */
20155 pmportinfo->pmport_dev_attach_time = 0;
20156 mutex_exit(&pmportinfo->pmport_mutex);
20157 SATADBG2(SATA_DBG_EVENTS_PROC, sata_hba_inst,
20158 "Ignoring attach - no device connected to port %d:%d",
20159 cport, pmport);
20160 return;
20161 }
20162
20163 mutex_exit(&pmportinfo->pmport_mutex);
20164 /*
20165 * Generate sysevent - EC_DR / ESC_DR_AP_STATE_CHANGE
20166 * with the hint: SE_HINT_INSERT
20167 */
20168 sata_gen_sysevent(sata_hba_inst, saddr, SE_HINT_INSERT);
20169
20170 /*
20171 * Port reprobing will take care of the creation of the device
20172 * info structure and determination of the device type.
20173 */
20174 sata_device.satadev_addr = *saddr;
20175 (void) sata_reprobe_port(sata_hba_inst, &sata_device,
20176 SATA_DEV_IDENTIFY_NORETRY);
20177
20178 mutex_enter(&pmportinfo->pmport_mutex);
20179 if ((pmportinfo->pmport_state & SATA_STATE_READY) &&
20180 (pmportinfo->pmport_dev_type != SATA_DTYPE_NONE)) {
20181 /* Some device is attached to the port */
20182 if (pmportinfo->pmport_dev_type == SATA_DTYPE_UNKNOWN) {
20183 /*
20184 * A device was not successfully attached.
20185 * Track retry time for device identification.
20186 */
20187 if (pmportinfo->pmport_dev_attach_time != 0) {
20188 clock_t cur_time = ddi_get_lbolt();
20189 /*
20190 * If the retry time limit was not exceeded,
20191 * reinstate attach event.
20192 */
20193 if ((cur_time -
20194 pmportinfo->pmport_dev_attach_time) <
20195 drv_usectohz(
20196 SATA_DEV_IDENTIFY_TIMEOUT)) {
20197 /* OK, restore attach event */
20198 pmportinfo->pmport_event_flags |=
20199 SATA_EVNT_DEVICE_ATTACHED;
20200 } else {
20201 /* Timeout - cannot identify device */
20202 pmportinfo->pmport_dev_attach_time = 0;
20203 sata_log(sata_hba_inst, CE_WARN,
20204 "Could not identify SATA device "
20205 "at port %d:%d",
20206 cport, pmport);
20207 }
20208 } else {
20209 /*
20210 * Start tracking time for device
20211 * identification.
20212 * Save current time (lbolt value).
20213 */
20214 pmportinfo->pmport_dev_attach_time =
20215 ddi_get_lbolt();
20216 /* Restore attach event */
20217 pmportinfo->pmport_event_flags |=
20218 SATA_EVNT_DEVICE_ATTACHED;
20219 }
20220 } else {
20221 /*
20222 * If device was successfully attached, the subsequent
20223 * action depends on a state of the
20224 * sata_auto_online variable. If it is set to zero.
20225 * an explicit 'configure' command will be needed to
20226 * configure it. If its value is non-zero, we will
20227 * attempt to online (configure) the device.
20228 * First, log the message indicating that a device
20229 * was attached.
20230 */
20231 pmportinfo->pmport_dev_attach_time = 0;
20232 sata_log(sata_hba_inst, CE_WARN,
20233 "SATA device detected at port %d:%d",
20234 cport, pmport);
20235
20236 if (SATA_PMPORTINFO_DRV_INFO(pmportinfo) != NULL) {
20237 sata_drive_info_t new_sdinfo;
20238
20239 /* Log device info data */
20240 new_sdinfo = *(SATA_PMPORTINFO_DRV_INFO(
20241 pmportinfo));
20242 sata_show_drive_info(sata_hba_inst,
20243 &new_sdinfo);
20244 }
20245
20246 mutex_exit(&pmportinfo->pmport_mutex);
20247
20248 /*
20249 * Make sure that there is no target node for that
20250 * device. If so, release it. It should not happen,
20251 * unless we had problem removing the node when
20252 * device was detached.
20253 */
20254 tdip = sata_get_target_dip(SATA_DIP(sata_hba_inst),
20255 saddr->cport, saddr->pmport);
20256 mutex_enter(&pmportinfo->pmport_mutex);
20257 if (tdip != NULL) {
20258
20259 #ifdef SATA_DEBUG
20260 if ((pmportinfo->pmport_event_flags &
20261 SATA_EVNT_TARGET_NODE_CLEANUP) == 0)
20262 sata_log(sata_hba_inst, CE_WARN,
20263 "sata_process_device_attached: "
20264 "old device target node exists!");
20265 #endif
20266 /*
20267 * target node exists - try to unconfigure
20268 * device and remove the node.
20269 */
20270 mutex_exit(&pmportinfo->pmport_mutex);
20271 rval = ndi_devi_offline(tdip,
20272 NDI_DEVI_REMOVE);
20273 mutex_enter(&pmportinfo->pmport_mutex);
20274
20275 if (rval == NDI_SUCCESS) {
20276 pmportinfo->pmport_event_flags &=
20277 ~SATA_EVNT_TARGET_NODE_CLEANUP;
20278 pmportinfo->pmport_tgtnode_clean =
20279 B_TRUE;
20280 } else {
20281 /*
20282 * PROBLEM - the target node remained
20283 * and it belongs to a previously
20284 * attached device.
20285 * This happens when the file was open
20286 * or the node was waiting for
20287 * resources at the time the
20288 * associated device was removed.
20289 * Instruct event daemon to retry the
20290 * cleanup later.
20291 */
20292 sata_log(sata_hba_inst,
20293 CE_WARN,
20294 "Application(s) accessing "
20295 "previously attached SATA "
20296 "device have to release "
20297 "it before newly inserted "
20298 "device can be made accessible."
20299 "at port %d:%d",
20300 cport, pmport);
20301 pmportinfo->pmport_event_flags |=
20302 SATA_EVNT_TARGET_NODE_CLEANUP;
20303 pmportinfo->pmport_tgtnode_clean =
20304 B_FALSE;
20305 }
20306 }
20307 if (sata_auto_online != 0) {
20308 pmportinfo->pmport_event_flags |=
20309 SATA_EVNT_AUTOONLINE_DEVICE;
20310 }
20311
20312 }
20313 } else {
20314 pmportinfo->pmport_dev_attach_time = 0;
20315 }
20316
20317 event_flags = pmportinfo->pmport_event_flags;
20318 mutex_exit(&pmportinfo->pmport_mutex);
20319 if (event_flags != 0) {
20320 mutex_enter(&sata_hba_inst->satahba_mutex);
20321 sata_hba_inst->satahba_event_flags |= SATA_EVNT_MAIN;
20322 mutex_exit(&sata_hba_inst->satahba_mutex);
20323 mutex_enter(&sata_mutex);
20324 sata_event_pending |= SATA_EVNT_MAIN;
20325 mutex_exit(&sata_mutex);
20326 }
20327
20328 /* clear the reset_in_progress events */
20329 if (SATA_PMPORTINFO_DRV_INFO(pmportinfo) != NULL) {
20330 if (pmportinfo->pmport_dev_type & SATA_VALID_DEV_TYPE) {
20331 /* must clear flags on cport */
20332 sata_pmult_info_t *pminfo =
20333 SATA_PMULT_INFO(sata_hba_inst,
20334 saddr->cport);
20335 pminfo->pmult_event_flags |=
20336 SATA_EVNT_CLEAR_DEVICE_RESET;
20337 }
20338 }
20339 }
20340
20341 /*
20342 * Device Target Node Cleanup Event processing.
20343 * If the target node associated with a sata port device is in
20344 * DEVI_DEVICE_REMOVED state, an attempt is made to remove it.
20345 * If the target node cannot be removed, the event flag is left intact,
20346 * so that event daemon may re-run this function later.
20347 *
20348 * This function cannot be called in interrupt context (it may sleep).
20349 *
20350 * NOTE: Processes cport events only, not port multiplier ports.
20351 */
20352 static void
20353 sata_process_target_node_cleanup(sata_hba_inst_t *sata_hba_inst,
20354 sata_address_t *saddr)
20355 {
20356 sata_cport_info_t *cportinfo;
20357 dev_info_t *tdip;
20358
20359 SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst,
20360 "Processing port %d device target node cleanup", saddr->cport);
20361
20362 cportinfo = SATA_CPORT_INFO(sata_hba_inst, saddr->cport);
20363
20364 /*
20365 * Check if there is target node for that device and it is in the
20366 * DEVI_DEVICE_REMOVED state. If so, release it.
20367 */
20368 tdip = sata_get_target_dip(SATA_DIP(sata_hba_inst), saddr->cport,
20369 saddr->pmport);
20370 if (tdip != NULL) {
20371 /*
20372 * target node exists - check if it is target node of
20373 * a removed device.
20374 */
20375 if (sata_check_device_removed(tdip) == B_TRUE) {
20376 SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst,
20377 "sata_process_target_node_cleanup: "
20378 "old device target node exists!", NULL);
20379 /*
20380 * Unconfigure and remove the target node
20381 */
20382 if (ndi_devi_offline(tdip, NDI_DEVI_REMOVE) ==
20383 NDI_SUCCESS) {
20384 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst,
20385 saddr->cport)->cport_mutex);
20386 cportinfo->cport_event_flags &=
20387 ~SATA_EVNT_TARGET_NODE_CLEANUP;
20388 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst,
20389 saddr->cport)->cport_mutex);
20390 return;
20391 }
20392 /*
20393 * Event daemon will retry the cleanup later.
20394 */
20395 mutex_enter(&sata_hba_inst->satahba_mutex);
20396 sata_hba_inst->satahba_event_flags |= SATA_EVNT_MAIN;
20397 mutex_exit(&sata_hba_inst->satahba_mutex);
20398 mutex_enter(&sata_mutex);
20399 sata_event_pending |= SATA_EVNT_MAIN;
20400 mutex_exit(&sata_mutex);
20401 }
20402 } else {
20403 if (saddr->qual == SATA_ADDR_CPORT ||
20404 saddr->qual == SATA_ADDR_DCPORT) {
20405 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst,
20406 saddr->cport)->cport_mutex);
20407 cportinfo->cport_event_flags &=
20408 ~SATA_EVNT_TARGET_NODE_CLEANUP;
20409 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst,
20410 saddr->cport)->cport_mutex);
20411 } else {
20412 /* sanity check */
20413 if (SATA_CPORT_DEV_TYPE(sata_hba_inst, saddr->cport) !=
20414 SATA_DTYPE_PMULT || SATA_PMULT_INFO(sata_hba_inst,
20415 saddr->cport) == NULL)
20416 return;
20417 if (SATA_PMPORT_INFO(sata_hba_inst, saddr->cport,
20418 saddr->pmport) == NULL)
20419 return;
20420
20421 mutex_enter(&SATA_PMPORT_INFO(sata_hba_inst,
20422 saddr->cport, saddr->pmport)->pmport_mutex);
20423 SATA_PMPORT_INFO(sata_hba_inst, saddr->cport,
20424 saddr->pmport)->pmport_event_flags &=
20425 ~SATA_EVNT_TARGET_NODE_CLEANUP;
20426 mutex_exit(&SATA_PMPORT_INFO(sata_hba_inst,
20427 saddr->cport, saddr->pmport)->pmport_mutex);
20428 }
20429 }
20430 }
20431
20432 /*
20433 * Device AutoOnline Event processing.
20434 * If attached device is to be onlined, an attempt is made to online this
20435 * device, but only if there is no lingering (old) target node present.
20436 * If the device cannot be onlined, the event flag is left intact,
20437 * so that event daemon may re-run this function later.
20438 *
20439 * This function cannot be called in interrupt context (it may sleep).
20440 *
20441 * NOTE: Processes cport events only, not port multiplier ports.
20442 */
20443 static void
20444 sata_process_device_autoonline(sata_hba_inst_t *sata_hba_inst,
20445 sata_address_t *saddr)
20446 {
20447 sata_cport_info_t *cportinfo;
20448 sata_drive_info_t *sdinfo;
20449 sata_device_t sata_device;
20450 dev_info_t *tdip;
20451
20452 SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst,
20453 "Processing port %d attached device auto-onlining", saddr->cport);
20454
20455 cportinfo = SATA_CPORT_INFO(sata_hba_inst, saddr->cport);
20456
20457 /*
20458 * Check if device is present and recognized. If not, reset event.
20459 */
20460 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex);
20461 if ((cportinfo->cport_dev_type & SATA_VALID_DEV_TYPE) == 0) {
20462 /* Nothing to online */
20463 cportinfo->cport_event_flags &= ~SATA_EVNT_AUTOONLINE_DEVICE;
20464 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst,
20465 saddr->cport)->cport_mutex);
20466 return;
20467 }
20468 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex);
20469
20470 /*
20471 * Check if there is target node for this device and if it is in the
20472 * DEVI_DEVICE_REMOVED state. If so, abort onlining but keep
20473 * the event for later processing.
20474 */
20475 tdip = sata_get_target_dip(SATA_DIP(sata_hba_inst), saddr->cport,
20476 saddr->pmport);
20477 if (tdip != NULL) {
20478 /*
20479 * target node exists - check if it is target node of
20480 * a removed device.
20481 */
20482 if (sata_check_device_removed(tdip) == B_TRUE) {
20483 SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst,
20484 "sata_process_device_autoonline: "
20485 "old device target node exists!", NULL);
20486 /*
20487 * Event daemon will retry device onlining later.
20488 */
20489 mutex_enter(&sata_hba_inst->satahba_mutex);
20490 sata_hba_inst->satahba_event_flags |= SATA_EVNT_MAIN;
20491 mutex_exit(&sata_hba_inst->satahba_mutex);
20492 mutex_enter(&sata_mutex);
20493 sata_event_pending |= SATA_EVNT_MAIN;
20494 mutex_exit(&sata_mutex);
20495 return;
20496 }
20497 /*
20498 * If the target node is not in the 'removed" state, assume
20499 * that it belongs to this device. There is nothing more to do,
20500 * but reset the event.
20501 */
20502 } else {
20503
20504 /*
20505 * Try to online the device
20506 * If there is any reset-related event, remove it. We are
20507 * configuring the device and no state restoring is needed.
20508 */
20509 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst,
20510 saddr->cport)->cport_mutex);
20511 sata_device.satadev_addr = *saddr;
20512 if (saddr->qual == SATA_ADDR_CPORT)
20513 sata_device.satadev_addr.qual = SATA_ADDR_DCPORT;
20514 else
20515 sata_device.satadev_addr.qual = SATA_ADDR_DPMPORT;
20516 sdinfo = sata_get_device_info(sata_hba_inst, &sata_device);
20517 if (sdinfo != NULL) {
20518 if (sdinfo->satadrv_event_flags &
20519 (SATA_EVNT_DEVICE_RESET |
20520 SATA_EVNT_INPROC_DEVICE_RESET))
20521 sdinfo->satadrv_event_flags = 0;
20522 sdinfo->satadrv_event_flags |=
20523 SATA_EVNT_CLEAR_DEVICE_RESET;
20524
20525 /* Need to create a new target node. */
20526 cportinfo->cport_tgtnode_clean = B_TRUE;
20527 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst,
20528 saddr->cport)->cport_mutex);
20529 tdip = sata_create_target_node(SATA_DIP(sata_hba_inst),
20530 sata_hba_inst, &sata_device.satadev_addr);
20531 if (tdip == NULL) {
20532 /*
20533 * Configure (onlining) failed.
20534 * We will NOT retry
20535 */
20536 SATA_LOG_D((sata_hba_inst, CE_WARN,
20537 "sata_process_device_autoonline: "
20538 "configuring SATA device at port %d failed",
20539 saddr->cport));
20540 }
20541 } else {
20542 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst,
20543 saddr->cport)->cport_mutex);
20544 }
20545
20546 }
20547 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex);
20548 cportinfo->cport_event_flags &= ~SATA_EVNT_AUTOONLINE_DEVICE;
20549 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst,
20550 saddr->cport)->cport_mutex);
20551 }
20552
20553
20554 static void
20555 sata_gen_sysevent(sata_hba_inst_t *sata_hba_inst, sata_address_t *saddr,
20556 int hint)
20557 {
20558 char ap[MAXPATHLEN];
20559 nvlist_t *ev_attr_list = NULL;
20560 int err;
20561
20562 /* Allocate and build sysevent attribute list */
20563 err = nvlist_alloc(&ev_attr_list, NV_UNIQUE_NAME_TYPE, DDI_NOSLEEP);
20564 if (err != 0) {
20565 SATA_LOG_D((sata_hba_inst, CE_WARN,
20566 "sata_gen_sysevent: "
20567 "cannot allocate memory for sysevent attributes\n"));
20568 return;
20569 }
20570 /* Add hint attribute */
20571 err = nvlist_add_string(ev_attr_list, DR_HINT, SE_HINT2STR(hint));
20572 if (err != 0) {
20573 SATA_LOG_D((sata_hba_inst, CE_WARN,
20574 "sata_gen_sysevent: "
20575 "failed to add DR_HINT attr for sysevent"));
20576 nvlist_free(ev_attr_list);
20577 return;
20578 }
20579 /*
20580 * Add AP attribute.
20581 * Get controller pathname and convert it into AP pathname by adding
20582 * a target number.
20583 */
20584 (void) snprintf(ap, MAXPATHLEN, "/devices");
20585 (void) ddi_pathname(SATA_DIP(sata_hba_inst), ap + strlen(ap));
20586 (void) snprintf(ap + strlen(ap), MAXPATHLEN - strlen(ap), ":%d",
20587 SATA_MAKE_AP_NUMBER(saddr->cport, saddr->pmport, saddr->qual));
20588
20589 err = nvlist_add_string(ev_attr_list, DR_AP_ID, ap);
20590 if (err != 0) {
20591 SATA_LOG_D((sata_hba_inst, CE_WARN,
20592 "sata_gen_sysevent: "
20593 "failed to add DR_AP_ID attr for sysevent"));
20594 nvlist_free(ev_attr_list);
20595 return;
20596 }
20597
20598 /* Generate/log sysevent */
20599 err = ddi_log_sysevent(SATA_DIP(sata_hba_inst), DDI_VENDOR_SUNW, EC_DR,
20600 ESC_DR_AP_STATE_CHANGE, ev_attr_list, NULL, DDI_NOSLEEP);
20601 if (err != DDI_SUCCESS) {
20602 SATA_LOG_D((sata_hba_inst, CE_WARN,
20603 "sata_gen_sysevent: "
20604 "cannot log sysevent, err code %x\n", err));
20605 }
20606
20607 nvlist_free(ev_attr_list);
20608 }
20609
20610
20611
20612
20613 /*
20614 * Set DEVI_DEVICE_REMOVED state in the SATA device target node.
20615 */
20616 static void
20617 sata_set_device_removed(dev_info_t *tdip)
20618 {
20619 int circ;
20620
20621 ASSERT(tdip != NULL);
20622
20623 ndi_devi_enter(tdip, &circ);
20624 mutex_enter(&DEVI(tdip)->devi_lock);
20625 DEVI_SET_DEVICE_REMOVED(tdip);
20626 mutex_exit(&DEVI(tdip)->devi_lock);
20627 ndi_devi_exit(tdip, circ);
20628 }
20629
20630
20631 /*
20632 * Set internal event instructing event daemon to try
20633 * to perform the target node cleanup.
20634 */
20635 static void
20636 sata_set_target_node_cleanup(sata_hba_inst_t *sata_hba_inst,
20637 sata_address_t *saddr)
20638 {
20639 if (saddr->qual == SATA_ADDR_CPORT ||
20640 saddr->qual == SATA_ADDR_DCPORT) {
20641 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst,
20642 saddr->cport)->cport_mutex);
20643 SATA_CPORT_EVENT_FLAGS(sata_hba_inst, saddr->cport) |=
20644 SATA_EVNT_TARGET_NODE_CLEANUP;
20645 SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->
20646 cport_tgtnode_clean = B_FALSE;
20647 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst,
20648 saddr->cport)->cport_mutex);
20649 } else {
20650 mutex_enter(&SATA_PMPORT_INFO(sata_hba_inst,
20651 saddr->cport, saddr->pmport)->pmport_mutex);
20652 SATA_PMPORT_EVENT_FLAGS(sata_hba_inst, saddr->cport,
20653 saddr->pmport) |= SATA_EVNT_TARGET_NODE_CLEANUP;
20654 SATA_PMPORT_INFO(sata_hba_inst, saddr->cport, saddr->pmport)->
20655 pmport_tgtnode_clean = B_FALSE;
20656 mutex_exit(&SATA_PMPORT_INFO(sata_hba_inst,
20657 saddr->cport, saddr->pmport)->pmport_mutex);
20658 }
20659 mutex_enter(&sata_hba_inst->satahba_mutex);
20660 sata_hba_inst->satahba_event_flags |= SATA_EVNT_MAIN;
20661 mutex_exit(&sata_hba_inst->satahba_mutex);
20662 mutex_enter(&sata_mutex);
20663 sata_event_pending |= SATA_EVNT_MAIN;
20664 mutex_exit(&sata_mutex);
20665 }
20666
20667
20668 /*
20669 * Check if the SATA device target node is in DEVI_DEVICE_REMOVED state,
20670 * i.e. check if the target node state indicates that it belongs to a removed
20671 * device.
20672 *
20673 * Returns B_TRUE if the target node is in DEVI_DEVICE_REMOVED state,
20674 * B_FALSE otherwise.
20675 */
20676 static boolean_t
20677 sata_check_device_removed(dev_info_t *tdip)
20678 {
20679 ASSERT(tdip != NULL);
20680
20681 if (DEVI_IS_DEVICE_REMOVED(tdip))
20682 return (B_TRUE);
20683 else
20684 return (B_FALSE);
20685 }
20686
20687
20688 /*
20689 * Check for DMA error. Return B_TRUE if error, B_FALSE otherwise.
20690 */
20691 static boolean_t
20692 sata_check_for_dma_error(dev_info_t *dip, sata_pkt_txlate_t *spx)
20693 {
20694 int fm_capability = ddi_fm_capable(dip);
20695 ddi_fm_error_t de;
20696
20697 if (fm_capability & DDI_FM_DMACHK_CAPABLE) {
20698 if (spx->txlt_buf_dma_handle != NULL) {
20699 ddi_fm_dma_err_get(spx->txlt_buf_dma_handle, &de,
20700 DDI_FME_VERSION);
20701 if (de.fme_status != DDI_SUCCESS)
20702 return (B_TRUE);
20703 }
20704 }
20705 return (B_FALSE);
20706 }
20707
20708
20709 /* ************************ FAULT INJECTTION **************************** */
20710
20711 #ifdef SATA_INJECT_FAULTS
20712
20713 static uint32_t sata_fault_count = 0;
20714 static uint32_t sata_fault_suspend_count = 0;
20715
20716 /*
20717 * Inject sata pkt fault
20718 * It modifies returned values of the sata packet.
20719 * It returns immediately if:
20720 * pkt fault injection is not enabled (via sata_inject_fault,
20721 * sata_inject_fault_count), or invalid fault is specified (sata_fault_type),
20722 * or pkt does not contain command to be faulted (set in sata_fault_cmd), or
20723 * pkt is not directed to specified fault controller/device
20724 * (sata_fault_ctrl_dev and sata_fault_device).
20725 * If fault controller is not specified, fault injection applies to all
20726 * controllers and devices.
20727 *
20728 * First argument is the pointer to the executed sata packet.
20729 * Second argument is a pointer to a value returned by the HBA tran_start
20730 * function.
20731 * Third argument specifies injected error. Injected sata packet faults
20732 * are the satapkt_reason values.
20733 * SATA_PKT_BUSY -1 Not completed, busy
20734 * SATA_PKT_DEV_ERROR 1 Device reported error
20735 * SATA_PKT_QUEUE_FULL 2 Not accepted, queue full
20736 * SATA_PKT_PORT_ERROR 3 Not completed, port error
20737 * SATA_PKT_CMD_UNSUPPORTED 4 Cmd unsupported
20738 * SATA_PKT_ABORTED 5 Aborted by request
20739 * SATA_PKT_TIMEOUT 6 Operation timeut
20740 * SATA_PKT_RESET 7 Aborted by reset request
20741 *
20742 * Additional global variables affecting the execution:
20743 *
20744 * sata_inject_fault_count variable specifies number of times in row the
20745 * error is injected. Value of -1 specifies permanent fault, ie. every time
20746 * the fault injection point is reached, the fault is injected and a pause
20747 * between fault injection specified by sata_inject_fault_pause_count is
20748 * ignored). Fault injection routine decrements sata_inject_fault_count
20749 * (if greater than zero) until it reaches 0. No fault is injected when
20750 * sata_inject_fault_count is 0 (zero).
20751 *
20752 * sata_inject_fault_pause_count variable specifies number of times a fault
20753 * injection is bypassed (pause between fault injections).
20754 * If set to 0, a fault is injected only a number of times specified by
20755 * sata_inject_fault_count.
20756 *
20757 * The fault counts are static, so for periodic errors they have to be manually
20758 * reset to start repetition sequence from scratch.
20759 * If the original value returned by the HBA tran_start function is not
20760 * SATA_TRAN_ACCEPTED and pkt reason is not SATA_PKT_COMPLETED, no error
20761 * is injected (to avoid masking real problems);
20762 *
20763 * NOTE: In its current incarnation, this function should be invoked only for
20764 * commands executed in SYNCHRONOUS mode.
20765 */
20766
20767
20768 static void
20769 sata_inject_pkt_fault(sata_pkt_t *spkt, int *rval, int fault)
20770 {
20771
20772 if (sata_inject_fault != SATA_INJECT_PKT_FAULT)
20773 return;
20774
20775 if (sata_inject_fault_count == 0)
20776 return;
20777
20778 if (fault == 0)
20779 return;
20780
20781 if (sata_fault_cmd != spkt->satapkt_cmd.satacmd_cmd_reg)
20782 return;
20783
20784 if (sata_fault_ctrl != NULL) {
20785 sata_pkt_txlate_t *spx =
20786 (sata_pkt_txlate_t *)spkt->satapkt_framework_private;
20787
20788 if (sata_fault_ctrl != NULL && sata_fault_ctrl !=
20789 spx->txlt_sata_hba_inst->satahba_dip)
20790 return;
20791
20792 if (sata_fault_device.satadev_addr.cport !=
20793 spkt->satapkt_device.satadev_addr.cport ||
20794 sata_fault_device.satadev_addr.pmport !=
20795 spkt->satapkt_device.satadev_addr.pmport ||
20796 sata_fault_device.satadev_addr.qual !=
20797 spkt->satapkt_device.satadev_addr.qual)
20798 return;
20799 }
20800
20801 /* Modify pkt return parameters */
20802 if (*rval != SATA_TRAN_ACCEPTED ||
20803 spkt->satapkt_reason != SATA_PKT_COMPLETED) {
20804 sata_fault_count = 0;
20805 sata_fault_suspend_count = 0;
20806 return;
20807 }
20808 if (sata_fault_count == 0 && sata_fault_suspend_count != 0) {
20809 /* Pause in the injection */
20810 sata_fault_suspend_count -= 1;
20811 return;
20812 }
20813
20814 if (sata_fault_count == 0 && sata_fault_suspend_count == 0) {
20815 /*
20816 * Init inject fault cycle. If fault count is set to -1,
20817 * it is a permanent fault.
20818 */
20819 if (sata_inject_fault_count != -1) {
20820 sata_fault_count = sata_inject_fault_count;
20821 sata_fault_suspend_count =
20822 sata_inject_fault_pause_count;
20823 if (sata_fault_suspend_count == 0)
20824 sata_inject_fault_count = 0;
20825 }
20826 }
20827
20828 if (sata_fault_count != 0)
20829 sata_fault_count -= 1;
20830
20831 switch (fault) {
20832 case SATA_PKT_BUSY:
20833 *rval = SATA_TRAN_BUSY;
20834 spkt->satapkt_reason = SATA_PKT_BUSY;
20835 break;
20836
20837 case SATA_PKT_QUEUE_FULL:
20838 *rval = SATA_TRAN_QUEUE_FULL;
20839 spkt->satapkt_reason = SATA_PKT_QUEUE_FULL;
20840 break;
20841
20842 case SATA_PKT_CMD_UNSUPPORTED:
20843 *rval = SATA_TRAN_CMD_UNSUPPORTED;
20844 spkt->satapkt_reason = SATA_PKT_CMD_UNSUPPORTED;
20845 break;
20846
20847 case SATA_PKT_PORT_ERROR:
20848 /* This is "rejected" command */
20849 *rval = SATA_TRAN_PORT_ERROR;
20850 spkt->satapkt_reason = SATA_PKT_PORT_ERROR;
20851 /* Additional error setup could be done here - port state */
20852 break;
20853
20854 case SATA_PKT_DEV_ERROR:
20855 spkt->satapkt_reason = SATA_PKT_DEV_ERROR;
20856 /*
20857 * Additional error setup could be done here
20858 */
20859 break;
20860
20861 case SATA_PKT_ABORTED:
20862 spkt->satapkt_reason = SATA_PKT_ABORTED;
20863 break;
20864
20865 case SATA_PKT_TIMEOUT:
20866 spkt->satapkt_reason = SATA_PKT_TIMEOUT;
20867 /* Additional error setup could be done here */
20868 break;
20869
20870 case SATA_PKT_RESET:
20871 spkt->satapkt_reason = SATA_PKT_RESET;
20872 /*
20873 * Additional error setup could be done here - device reset
20874 */
20875 break;
20876
20877 default:
20878 break;
20879 }
20880 }
20881
20882 #endif
20883
20884 /*
20885 * SATA Trace Ring Buffer
20886 * ----------------------
20887 *
20888 * Overview
20889 *
20890 * The SATA trace ring buffer is a ring buffer created and managed by
20891 * the SATA framework module that can be used by any module or driver
20892 * within the SATA framework to store debug messages.
20893 *
20894 * Ring Buffer Interfaces:
20895 *
20896 * sata_vtrace_debug() <-- Adds debug message to ring buffer
20897 * sata_trace_debug() <-- Wraps varargs into sata_vtrace_debug()
20898 *
20899 * Note that the sata_trace_debug() interface was created to give
20900 * consumers the flexibilty of sending debug messages to ring buffer
20901 * as variable arguments. Consumers can send type va_list debug
20902 * messages directly to sata_vtrace_debug(). The sata_trace_debug()
20903 * and sata_vtrace_debug() relationship is similar to that of
20904 * cmn_err(9F) and vcmn_err(9F).
20905 *
20906 * Below is a diagram of the SATA trace ring buffer interfaces and
20907 * sample consumers:
20908 *
20909 * +---------------------------------+
20910 * | o o SATA Framework Module |
20911 * | o SATA o +------------------+ +------------------+
20912 * |o Trace o <--|sata_vtrace_debug/|<-----|SATA HBA Driver #1|
20913 * |o R-Buf o |sata_trace_debug |<--+ +------------------+
20914 * | o o +------------------+ | +------------------+
20915 * | o o ^ | +--|SATA HBA Driver #2|
20916 * | | | +------------------+
20917 * | +------------------+ |
20918 * | |SATA Debug Message| |
20919 * | +------------------+ |
20920 * +---------------------------------+
20921 *
20922 * Supporting Routines:
20923 *
20924 * sata_trace_rbuf_alloc() <-- Initializes ring buffer
20925 * sata_trace_rbuf_free() <-- Destroys ring buffer
20926 * sata_trace_dmsg_alloc() <-- Creates or reuses buffer in ring buffer
20927 * sata_trace_dmsg_free() <-- Destroys content of ring buffer
20928 *
20929 * The default SATA trace ring buffer size is defined by DMSG_RING_SIZE.
20930 * The ring buffer size can be adjusted by setting dmsg_ring_size in
20931 * /etc/system to desired size in unit of bytes.
20932 *
20933 * The individual debug message size in the ring buffer is restricted
20934 * to DMSG_BUF_SIZE.
20935 */
20936 void
20937 sata_vtrace_debug(dev_info_t *dip, const char *fmt, va_list ap)
20938 {
20939 sata_trace_dmsg_t *dmsg;
20940
20941 if (sata_debug_rbuf == NULL) {
20942 return;
20943 }
20944
20945 /*
20946 * If max size of ring buffer is smaller than size
20947 * required for one debug message then just return
20948 * since we have no room for the debug message.
20949 */
20950 if (sata_debug_rbuf->maxsize < (sizeof (sata_trace_dmsg_t))) {
20951 return;
20952 }
20953
20954 mutex_enter(&sata_debug_rbuf->lock);
20955
20956 /* alloc or reuse on ring buffer */
20957 dmsg = sata_trace_dmsg_alloc();
20958
20959 if (dmsg == NULL) {
20960 /* resource allocation failed */
20961 mutex_exit(&sata_debug_rbuf->lock);
20962 return;
20963 }
20964
20965 dmsg->dip = dip;
20966 gethrestime(&dmsg->timestamp);
20967
20968 (void) vsnprintf(dmsg->buf, sizeof (dmsg->buf), fmt, ap);
20969
20970 mutex_exit(&sata_debug_rbuf->lock);
20971 }
20972
20973 void
20974 sata_trace_debug(dev_info_t *dip, const char *fmt, ...)
20975 {
20976 va_list ap;
20977
20978 va_start(ap, fmt);
20979 sata_vtrace_debug(dip, fmt, ap);
20980 va_end(ap);
20981 }
20982
20983 /*
20984 * This routine is used to manage debug messages
20985 * on ring buffer.
20986 */
20987 static sata_trace_dmsg_t *
20988 sata_trace_dmsg_alloc(void)
20989 {
20990 sata_trace_dmsg_t *dmsg_alloc, *dmsg = sata_debug_rbuf->dmsgp;
20991
20992 if (sata_debug_rbuf->looped == TRUE) {
20993 sata_debug_rbuf->dmsgp = dmsg->next;
20994 return (sata_debug_rbuf->dmsgp);
20995 }
20996
20997 /*
20998 * If we're looping for the first time,
20999 * connect the ring.
21000 */
21001 if (((sata_debug_rbuf->size + (sizeof (sata_trace_dmsg_t))) >
21002 sata_debug_rbuf->maxsize) && (sata_debug_rbuf->dmsgh != NULL)) {
21003 dmsg->next = sata_debug_rbuf->dmsgh;
21004 sata_debug_rbuf->dmsgp = sata_debug_rbuf->dmsgh;
21005 sata_debug_rbuf->looped = TRUE;
21006 return (sata_debug_rbuf->dmsgp);
21007 }
21008
21009 /* If we've gotten this far then memory allocation is needed */
21010 dmsg_alloc = kmem_zalloc(sizeof (sata_trace_dmsg_t), KM_NOSLEEP);
21011 if (dmsg_alloc == NULL) {
21012 sata_debug_rbuf->allocfailed++;
21013 return (dmsg_alloc);
21014 } else {
21015 sata_debug_rbuf->size += sizeof (sata_trace_dmsg_t);
21016 }
21017
21018 if (sata_debug_rbuf->dmsgp != NULL) {
21019 dmsg->next = dmsg_alloc;
21020 sata_debug_rbuf->dmsgp = dmsg->next;
21021 return (sata_debug_rbuf->dmsgp);
21022 } else {
21023 /*
21024 * We should only be here if we're initializing
21025 * the ring buffer.
21026 */
21027 if (sata_debug_rbuf->dmsgh == NULL) {
21028 sata_debug_rbuf->dmsgh = dmsg_alloc;
21029 } else {
21030 /* Something is wrong */
21031 kmem_free(dmsg_alloc, sizeof (sata_trace_dmsg_t));
21032 return (NULL);
21033 }
21034
21035 sata_debug_rbuf->dmsgp = dmsg_alloc;
21036 return (sata_debug_rbuf->dmsgp);
21037 }
21038 }
21039
21040
21041 /*
21042 * Free all messages on debug ring buffer.
21043 */
21044 static void
21045 sata_trace_dmsg_free(void)
21046 {
21047 sata_trace_dmsg_t *dmsg_next, *dmsg = sata_debug_rbuf->dmsgh;
21048
21049 while (dmsg != NULL) {
21050 dmsg_next = dmsg->next;
21051 kmem_free(dmsg, sizeof (sata_trace_dmsg_t));
21052
21053 /*
21054 * If we've looped around the ring than we're done.
21055 */
21056 if (dmsg_next == sata_debug_rbuf->dmsgh) {
21057 break;
21058 } else {
21059 dmsg = dmsg_next;
21060 }
21061 }
21062 }
21063
21064
21065 /*
21066 * This function can block
21067 */
21068 static void
21069 sata_trace_rbuf_alloc(void)
21070 {
21071 sata_debug_rbuf = kmem_zalloc(sizeof (sata_trace_rbuf_t), KM_SLEEP);
21072
21073 mutex_init(&sata_debug_rbuf->lock, NULL, MUTEX_DRIVER, NULL);
21074
21075 if (dmsg_ring_size > 0) {
21076 sata_debug_rbuf->maxsize = (size_t)dmsg_ring_size;
21077 }
21078 }
21079
21080
21081 static void
21082 sata_trace_rbuf_free(void)
21083 {
21084 sata_trace_dmsg_free();
21085 mutex_destroy(&sata_debug_rbuf->lock);
21086 kmem_free(sata_debug_rbuf, sizeof (sata_trace_rbuf_t));
21087 }
21088
21089 /*
21090 * If SATA_DEBUG is not defined then this routine is called instead
21091 * of sata_log() via the SATA_LOG_D macro.
21092 */
21093 static void
21094 sata_trace_log(sata_hba_inst_t *sata_hba_inst, uint_t level,
21095 const char *fmt, ...)
21096 {
21097 #ifndef __lock_lint
21098 _NOTE(ARGUNUSED(level))
21099 #endif
21100
21101 dev_info_t *dip = NULL;
21102 va_list ap;
21103
21104 if (sata_hba_inst != NULL) {
21105 dip = SATA_DIP(sata_hba_inst);
21106 }
21107
21108 va_start(ap, fmt);
21109 sata_vtrace_debug(dip, fmt, ap);
21110 va_end(ap);
21111 }